Merge branch 'linus' into perfcounters/rename

Merge reason: pull in all the latest code before doing the rename.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

214 files changed, 16054 insertions, 4776 deletions

diff --git a/drivers/base/core.c b/drivers/base/core.c
index 390e664ec1c7..6bee6af8d8e1 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -166,13 +166,16 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
         if (MAJOR(dev->devt)) {
                 const char *tmp;
                 const char *name;
+                mode_t mode = 0;
 
                 add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt));
                 add_uevent_var(env, "MINOR=%u", MINOR(dev->devt));
-                name = device_get_nodename(dev, &tmp);
+                name = device_get_devnode(dev, &mode, &tmp);
                 if (name) {
                         add_uevent_var(env, "DEVNAME=%s", name);
                         kfree(tmp);
+                        if (mode)
+                                add_uevent_var(env, "DEVMODE=%#o", mode & 0777);
                 }
         }
 
@@ -1148,8 +1151,9 @@ static struct device *next_device(struct klist_iter *i)
 }
 
 /**
- * device_get_nodename - path of device node file
+ * device_get_devnode - path of device node file
  * @dev: device
+ * @mode: returned file access mode
  * @tmp: possibly allocated string
  *
  * Return the relative path of a possible device node.
@@ -1157,21 +1161,22 @@ static struct device *next_device(struct klist_iter *i)
  * a name. This memory is returned in tmp and needs to be
  * freed by the caller.
  */
-const char *device_get_nodename(struct device *dev, const char **tmp)
+const char *device_get_devnode(struct device *dev,
+                               mode_t *mode, const char **tmp)
 {
         char *s;
 
         *tmp = NULL;
 
         /* the device type may provide a specific name */
-        if (dev->type && dev->type->nodename)
-                *tmp = dev->type->nodename(dev);
+        if (dev->type && dev->type->devnode)
+                *tmp = dev->type->devnode(dev, mode);
         if (*tmp)
                 return *tmp;
 
         /* the class may provide a specific name */
-        if (dev->class && dev->class->nodename)
-                *tmp = dev->class->nodename(dev);
+        if (dev->class && dev->class->devnode)
+                *tmp = dev->class->devnode(dev, mode);
         if (*tmp)
                 return *tmp;
 
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index fd488ad4263a..a1cb5afe6801 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -6,9 +6,10 @@
  * During bootup, before any driver core device is registered,
  * devtmpfs, a tmpfs-based filesystem is created. Every driver-core
  * device which requests a device node, will add a node in this
- * filesystem. The node is named after the the name of the device,
- * or the susbsytem can provide a custom name. All devices are
- * owned by root and have a mode of 0600.
+ * filesystem.
+ * By default, all devices are named after the the name of the
+ * device, owned by root and have a default mode of 0600. Subsystems
+ * can overwrite the default setting if needed.
  */
 
 #include <linux/kernel.h>
@@ -20,6 +21,7 @@
 #include <linux/fs.h>
 #include <linux/shmem_fs.h>
 #include <linux/cred.h>
+#include <linux/sched.h>
 #include <linux/init_task.h>
 
 static struct vfsmount *dev_mnt;
@@ -134,7 +136,7 @@ int devtmpfs_create_node(struct device *dev)
         const char *tmp = NULL;
         const char *nodename;
         const struct cred *curr_cred;
-        mode_t mode;
+        mode_t mode = 0;
         struct nameidata nd;
         struct dentry *dentry;
         int err;
@@ -142,14 +144,16 @@ int devtmpfs_create_node(struct device *dev)
         if (!dev_mnt)
                 return 0;
 
-        nodename = device_get_nodename(dev, &tmp);
+        nodename = device_get_devnode(dev, &mode, &tmp);
         if (!nodename)
                 return -ENOMEM;
 
+        if (mode == 0)
+                mode = 0600;
         if (is_blockdev(dev))
-                mode = S_IFBLK|0600;
+                mode |= S_IFBLK;
         else
-                mode = S_IFCHR|0600;
+                mode |= S_IFCHR;
 
         curr_cred = override_creds(&init_cred);
         err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
@@ -165,8 +169,12 @@ int devtmpfs_create_node(struct device *dev)
 
         dentry = lookup_create(&nd, 0);
         if (!IS_ERR(dentry)) {
+                int umask;
+
+                umask = sys_umask(0000);
                 err = vfs_mknod(nd.path.dentry->d_inode,
                                 dentry, mode, dev->devt);
+                sys_umask(umask);
                 /* mark as kernel created inode */
                 if (!err)
                         dentry->d_inode->i_private = &dev_mnt;
@@ -271,7 +279,7 @@ int devtmpfs_delete_node(struct device *dev)
         if (!dev_mnt)
                 return 0;
 
-        nodename = device_get_nodename(dev, &tmp);
+        nodename = device_get_devnode(dev, NULL, &tmp);
         if (!nodename)
                 return -ENOMEM;
 
diff --git a/drivers/block/aoe/aoechr.c b/drivers/block/aoe/aoechr.c
index 19888354188f..62141ec09a22 100644
--- a/drivers/block/aoe/aoechr.c
+++ b/drivers/block/aoe/aoechr.c
@@ -266,7 +266,7 @@ static const struct file_operations aoe_fops = {
         .owner = THIS_MODULE,
 };
 
-static char *aoe_nodename(struct device *dev)
+static char *aoe_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "etherd/%s", dev_name(dev));
 }
@@ -288,7 +288,7 @@ aoechr_init(void)
                 unregister_chrdev(AOE_MAJOR, "aoechr");
                 return PTR_ERR(aoe_class);
         }
-        aoe_class->nodename = aoe_nodename;
+        aoe_class->devnode = aoe_devnode;
 
         for (i = 0; i < ARRAY_SIZE(chardevs); ++i)
                 device_create(aoe_class, NULL,
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 95f11cdef203..fd5bb8ad59a9 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2857,7 +2857,7 @@ static struct block_device_operations pktcdvd_ops = {
         .media_changed =        pkt_media_changed,
 };
 
-static char *pktcdvd_nodename(struct gendisk *gd)
+static char *pktcdvd_devnode(struct gendisk *gd, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "pktcdvd/%s", gd->disk_name);
 }
@@ -2914,7 +2914,7 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
         disk->fops = &pktcdvd_ops;
         disk->flags = GENHD_FL_REMOVABLE;
         strcpy(disk->disk_name, pd->name);
-        disk->nodename = pktcdvd_nodename;
+        disk->devnode = pktcdvd_devnode;
         disk->private_data = pd;
         disk->queue = blk_alloc_queue(GFP_KERNEL);
         if (!disk->queue)
@@ -3070,7 +3070,7 @@ static const struct file_operations pkt_ctl_fops = {
 static struct miscdevice pkt_misc = {
         .minor          = MISC_DYNAMIC_MINOR,
         .name           = DRIVER_NAME,
-        .name           = "pktcdvd/control",
+        .nodename       = "pktcdvd/control",
         .fops           = &pkt_ctl_fops
 };
 
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index 2dafc2da0648..df5038bbcbc2 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -11,7 +11,7 @@
  * Initially written by Randolph Bentson <bentson@grieg.seaslug.org>.
  * Modified and maintained by Marcio Saito <marcio@cyclades.com>.
  *
- * Copyright (C) 2007 Jiri Slaby <jirislaby@gmail.com>
+ * Copyright (C) 2007-2009 Jiri Slaby <jirislaby@gmail.com>
  *
  * Much of the design and some of the code came from serial.c
  * which was copyright (C) 1991, 1992  Linus Torvalds.  It was
@@ -19,577 +19,9 @@
  * and then fixed as suggested by Michael K. Johnson 12/12/92.
  * Converted to pci probing and cleaned up by Jiri Slaby.
  *
- * This version supports shared IRQ's (only for PCI boards).
- *
- * Prevent users from opening non-existing Z ports.
- *
- * Revision 2.3.2.8   2000/07/06 18:14:16 ivan
- * Fixed the PCI detection function to work properly on Alpha systems.
- * Implemented support for TIOCSERGETLSR ioctl.
- * Implemented full support for non-standard baud rates.
- *
- * Revision 2.3.2.7   2000/06/01 18:26:34 ivan
- * Request PLX I/O region, although driver doesn't use it, to avoid
- * problems with other drivers accessing it.
- * Removed count for on-board buffer characters in cy_chars_in_buffer
- * (Cyclades-Z only).
- *
- * Revision 2.3.2.6   2000/05/05 13:56:05 ivan
- * Driver now reports physical instead of virtual memory addresses.
- * Masks were added to some Cyclades-Z read accesses.
- * Implemented workaround for PLX9050 bug that would cause a system lockup
- * in certain systems, depending on the MMIO addresses allocated to the
- * board.
- * Changed the Tx interrupt programming in the CD1400 chips to boost up
- * performance (Cyclom-Y only).
- * Code is now compliant with the new module interface (module_[init|exit]).
- * Make use of the PCI helper functions to access PCI resources.
- * Did some code "housekeeping".
- *
- * Revision 2.3.2.5   2000/01/19 14:35:33 ivan
- * Fixed bug in cy_set_termios on CRTSCTS flag turnoff.
- *
- * Revision 2.3.2.4   2000/01/17 09:19:40 ivan
- * Fixed SMP locking in Cyclom-Y interrupt handler.
- *
- * Revision 2.3.2.3   1999/12/28 12:11:39 ivan
- * Added a new cyclades_card field called nports to allow the driver to
- * know the exact number of ports found by the Z firmware after its load;
- * RX buffer contention prevention logic on interrupt op mode revisited
- * (Cyclades-Z only);
- * Revisited printk's for Z debug;
- * Driver now makes sure that the constant SERIAL_XMIT_SIZE is defined;
- *
- * Revision 2.3.2.2   1999/10/01 11:27:43 ivan
- * Fixed bug in cyz_poll that would make all ports but port 0
- * unable to transmit/receive data (Cyclades-Z only);
- * Implemented logic to prevent the RX buffer from being stuck with data
- * due to a driver / firmware race condition in interrupt op mode
- * (Cyclades-Z only);
- * Fixed bug in block_til_ready logic that would lead to a system crash;
- * Revisited cy_close spinlock usage;
- *
- * Revision 2.3.2.1   1999/09/28 11:01:22 ivan
- * Revisited CONFIG_PCI conditional compilation for PCI board support;
- * Implemented TIOCGICOUNT and TIOCMIWAIT ioctl support;
- * _Major_ cleanup on the Cyclades-Z interrupt support code / logic;
- * Removed CTS handling from the driver -- this is now completely handled
- * by the firmware (Cyclades-Z only);
- * Flush RX on-board buffers on a port open (Cyclades-Z only);
- * Fixed handling of ASYNC_SPD_* TTY flags;
- * Module unload now unmaps all memory area allocated by ioremap;
- *
- * Revision 2.3.1.1   1999/07/15 16:45:53 ivan
- * Removed CY_PROC conditional compilation;
- * Implemented SMP-awareness for the driver;
- * Implemented a new ISA IRQ autoprobe that uses the irq_probe_[on|off]
- * functions;
- * The driver now accepts memory addresses (maddr=0xMMMMM) and IRQs
- * (irq=NN) as parameters (only for ISA boards);
- * Fixed bug in set_line_char that would prevent the Cyclades-Z
- * ports from being configured at speeds above 115.2Kbps;
- * Fixed bug in cy_set_termios that would prevent XON/XOFF flow control
- * switching from working properly;
- * The driver now only prints IRQ info for the Cyclades-Z if it's
- * configured to work in interrupt mode;
- *
- * Revision 2.2.2.3   1999/06/28 11:13:29 ivan
- * Added support for interrupt mode operation for the Z cards;
- * Removed the driver inactivity control for the Z;
- * Added a missing MOD_DEC_USE_COUNT in the cy_open function for when
- * the Z firmware is not loaded yet;
- * Replaced the "manual" Z Tx flush buffer by a call to a FW command of
- * same functionality;
- * Implemented workaround for IRQ setting loss on the PCI configuration
- * registers after a PCI bridge EEPROM reload (affects PLX9060 only);
- *
- * Revision 2.2.2.2  1999/05/14 17:18:15 ivan
- * /proc entry location changed to /proc/tty/driver/cyclades;
- * Added support to shared IRQ's (only for PCI boards);
- * Added support for Cobalt Qube2 systems;
- * IRQ [de]allocation scheme revisited;
- * BREAK implementation changed in order to make use of the 'break_ctl'
- * TTY facility;
- * Fixed typo in TTY structure field 'driver_name';
- * Included a PCI bridge reset and EEPROM reload in the board
- * initialization code (for both Y and Z series).
- *
- * Revision 2.2.2.1  1999/04/08 16:17:43 ivan
- * Fixed a bug in cy_wait_until_sent that was preventing the port to be
- * closed properly after a SIGINT;
- * Module usage counter scheme revisited;
- * Added support to the upcoming Y PCI boards (i.e., support to additional
- * PCI Device ID's).
- *
- * Revision 2.2.1.10 1999/01/20 16:14:29 ivan
- * Removed all unnecessary page-alignement operations in ioremap calls
- * (ioremap is currently safe for these operations).
- *
- * Revision 2.2.1.9  1998/12/30 18:18:30 ivan
- * Changed access to PLX PCI bridge registers from I/O to MMIO, in
- * order to make PLX9050-based boards work with certain motherboards.
- *
- * Revision 2.2.1.8  1998/11/13 12:46:20 ivan
- * cy_close function now resets (correctly) the tty->closing flag;
- * JIFFIES_DIFF macro fixed.
- *
- * Revision 2.2.1.7  1998/09/03 12:07:28 ivan
- * Fixed bug in cy_close function, which was not informing HW of
- * which port should have the reception disabled before doing so;
- * fixed Cyclom-8YoP hardware detection bug.
- *
- * Revision 2.2.1.6  1998/08/20 17:15:39 ivan
- * Fixed bug in cy_close function, which causes malfunction
- * of one of the first 4 ports when a higher port is closed
- * (Cyclom-Y only).
- *
- * Revision 2.2.1.5  1998/08/10 18:10:28 ivan
- * Fixed Cyclom-4Yo hardware detection bug.
- *
- * Revision 2.2.1.4  1998/08/04 11:02:50 ivan
- * /proc/cyclades implementation with great collaboration of
- * Marc Lewis <marc@blarg.net>;
- * cyy_interrupt was changed to avoid occurrence of kernel oopses
- * during PPP operation.
- *
- * Revision 2.2.1.3  1998/06/01 12:09:10 ivan
- * General code review in order to comply with 2.1 kernel standards;
- * data loss prevention for slow devices revisited (cy_wait_until_sent
- * was created);
- * removed conditional compilation for new/old PCI structure support
- * (now the driver only supports the new PCI structure).
- *
- * Revision 2.2.1.1  1998/03/19 16:43:12 ivan
- * added conditional compilation for new/old PCI structure support;
- * removed kernel series (2.0.x / 2.1.x) conditional compilation.
- *
- * Revision 2.1.1.3  1998/03/16 18:01:12 ivan
- * cleaned up the data loss fix;
- * fixed XON/XOFF handling once more (Cyclades-Z);
- * general review of the driver routines;
- * introduction of a mechanism to prevent data loss with slow
- * printers, by forcing a delay before closing the port.
- *
- * Revision 2.1.1.2  1998/02/17 16:50:00 ivan
- * fixed detection/handling of new CD1400 in Ye boards;
- * fixed XON/XOFF handling (Cyclades-Z);
- * fixed data loss caused by a premature port close;
- * introduction of a flag that holds the CD1400 version ID per port
- * (used by the CYGETCD1400VER new ioctl).
- *
- * Revision 2.1.1.1  1997/12/03 17:31:19 ivan
- * Code review for the module cleanup routine;
- * fixed RTS and DTR status report for new CD1400's in get_modem_info;
- * includes anonymous changes regarding signal_pending.
- *
- * Revision 2.1  1997/11/01 17:42:41 ivan
- * Changes in the driver to support Alpha systems (except 8Zo V_1);
- * BREAK fix for the Cyclades-Z boards;
- * driver inactivity control by FW implemented;
- * introduction of flag that allows driver to take advantage of
- * a special CD1400 feature related to HW flow control;
- * added support for the CD1400  rev. J (Cyclom-Y boards);
- * introduction of ioctls to:
- *  - control the rtsdtr_inv flag (Cyclom-Y);
- *  - control the rflow flag (Cyclom-Y);
- *  - adjust the polling interval (Cyclades-Z);
- *
- * Revision 1.36.4.33  1997/06/27 19:00:00  ivan
- * Fixes related to kernel version conditional
- * compilation.
- *
- * Revision 1.36.4.32  1997/06/14 19:30:00  ivan
- * Compatibility issues between kernels 2.0.x and
- * 2.1.x (mainly related to clear_bit function).
- *
- * Revision 1.36.4.31  1997/06/03 15:30:00  ivan
- * Changes to define the memory window according to the
- * board type.
- *
- * Revision 1.36.4.30  1997/05/16 15:30:00  daniel
- * Changes to support new cycladesZ boards.
- *
- * Revision 1.36.4.29  1997/05/12 11:30:00  daniel
- * Merge of Bentson's and Daniel's version 1.36.4.28.
- * Corrects bug in cy_detect_pci: check if there are more
- * ports than the number of static structs allocated.
- * Warning message during initialization if this driver is
- * used with the new generation of cycladesZ boards.  Those
- * will be supported only in next release of the driver.
- * Corrects bug in cy_detect_pci and cy_detect_isa that
- * returned wrong number of VALID boards, when a cyclomY
- * was found with no serial modules connected.
- * Changes to use current (2.1.x) kernel subroutine names
- * and created macros for compilation with 2.0.x kernel,
- * instead of the other way around.
- *
- * Revision 1.36.4.28  1997/05/?? ??:00:00  bentson
- * Change queue_task_irq_off to queue_task_irq.
- * The inline function queue_task_irq_off (tqueue.h)
- * was removed from latest releases of 2.1.x kernel.
- * Use of macro __init to mark the initialization
- * routines, so memory can be reused.
- * Also incorporate implementation of critical region
- * in function cleanup_module() created by anonymous
- * linuxer.
- *
- * Revision 1.36.4.28  1997/04/25 16:00:00  daniel
- * Change to support new firmware that solves DCD problem:
- * application could fail to receive SIGHUP signal when DCD
- * varying too fast.
- *
- * Revision 1.36.4.27  1997/03/26 10:30:00  daniel
- * Changed for support linux versions 2.1.X.
- * Backward compatible with linux versions 2.0.X.
- * Corrected illegal use of filler field in
- * CH_CTRL struct.
- * Deleted some debug messages.
- *
- * Revision 1.36.4.26  1997/02/27 12:00:00  daniel
- * Included check for NULL tty pointer in cyz_poll.
- *
- * Revision 1.36.4.25  1997/02/26 16:28:30  bentson
- * Bill Foster at Blarg! Online services noticed that
- * some of the switch elements of -Z modem control
- * lacked a closing "break;"
- *
- * Revision 1.36.4.24  1997/02/24 11:00:00  daniel
- * Changed low water threshold for buffer xmit_buf
- *
- * Revision 1.36.4.23  1996/12/02 21:50:16  bentson
- * Marcio provided fix to modem status fetch for -Z
- *
- * Revision 1.36.4.22  1996/10/28 22:41:17  bentson
- * improve mapping of -Z control page (thanks to Steve
- * Price <stevep@fa.tdktca.com> for help on this)
- *
- * Revision 1.36.4.21  1996/09/10 17:00:10  bentson
- * shift from CPU-bound to memcopy in cyz_polling operation
- *
- * Revision 1.36.4.20  1996/09/09 18:30:32  Bentson
- * Added support to set and report higher speeds.
- *
- * Revision 1.36.4.19c  1996/08/09 10:00:00  Marcio Saito
- * Some fixes in the HW flow control for the BETA release.
- * Don't try to register the IRQ.
- *
- * Revision 1.36.4.19  1996/08/08 16:23:18  Bentson
- * make sure "cyc" appears in all kernel messages; all soft interrupts
- * handled by same routine; recognize out-of-band reception; comment
- * out some diagnostic messages; leave RTS/CTS flow control to hardware;
- * fix race condition in -Z buffer management; only -Y needs to explicitly
- * flush chars; tidy up some startup messages;
- *
- * Revision 1.36.4.18  1996/07/25 18:57:31  bentson
- * shift MOD_INC_USE_COUNT location to match
- * serial.c; purge some diagnostic messages;
- *
- * Revision 1.36.4.17  1996/07/25 18:01:08  bentson
- * enable modem status messages and fetch & process them; note
- * time of last activity type for each port; set_line_char now
- * supports more than line 0 and treats 0 baud correctly;
- * get_modem_info senses rs_status;
- *
- * Revision 1.36.4.16  1996/07/20 08:43:15  bentson
- * barely works--now's time to turn on
- * more features 'til it breaks
- *
- * Revision 1.36.4.15  1996/07/19 22:30:06  bentson
- * check more -Z board status; shorten boot message
- *
- * Revision 1.36.4.14  1996/07/19 22:20:37  bentson
- * fix reference to ch_ctrl in startup; verify return
- * values from cyz_issue_cmd and cyz_update_channel;
- * more stuff to get modem control correct;
- *
- * Revision 1.36.4.13  1996/07/11 19:53:33  bentson
- * more -Z stuff folded in; re-order changes to put -Z stuff
- * after -Y stuff (to make changes clearer)
- *
- * Revision 1.36.4.12  1996/07/11 15:40:55  bentson
- * Add code to poll Cyclades-Z.  Add code to get & set RS-232 control.
- * Add code to send break.  Clear firmware ID word at startup (so
- * that other code won't talk to inactive board).
- *
- * Revision 1.36.4.11  1996/07/09 05:28:29  bentson
- * add code for -Z in set_line_char
- *
- * Revision 1.36.4.10  1996/07/08 19:28:37  bentson
- * fold more -Z stuff (or in some cases, error messages)
- * into driver; add text to "don't know what to do" messages.
- *
- * Revision 1.36.4.9  1996/07/08 18:38:38  bentson
- * moved compile-time flags near top of file; cosmetic changes
- * to narrow text (to allow 2-up printing); changed many declarations
- * to "static" to limit external symbols; shuffled code order to
- * coalesce -Y and -Z specific code, also to put internal functions
- * in order of tty_driver structure; added code to recognize -Z
- * ports (and for moment, do nothing or report error); add cy_startup
- * to parse boot command line for extra base addresses for ISA probes;
- *
- * Revision 1.36.4.8  1996/06/25 17:40:19  bentson
- * reorder some code, fix types of some vars (int vs. long),
- * add cy_setup to support user declared ISA addresses
- *
- * Revision 1.36.4.7  1996/06/21 23:06:18  bentson
- * dump ioctl based firmware load (it's now a user level
- * program); ensure uninitialzed ports cannot be used
- *
- * Revision 1.36.4.6  1996/06/20 23:17:19  bentson
- * rename vars and restructure some code
- *
- * Revision 1.36.4.5  1996/06/14 15:09:44  bentson
- * get right status back after boot load
- *
- * Revision 1.36.4.4  1996/06/13 19:51:44  bentson
- * successfully loads firmware
- *
- * Revision 1.36.4.3  1996/06/13 06:08:33  bentson
- * add more of the code for the boot/load ioctls
- *
- * Revision 1.36.4.2  1996/06/11 21:00:51  bentson
- * start to add Z functionality--starting with ioctl
- * for loading firmware
- *
- * Revision 1.36.4.1  1996/06/10 18:03:02  bentson
- * added code to recognize Z/PCI card at initialization; report
- * presence, but card is not initialized (because firmware needs
- * to be loaded)
- *
- * Revision 1.36.3.8  1996/06/07 16:29:00  bentson
- * starting minor number at zero; added missing verify_area
- * as noted by Heiko Eißfeldt <heiko@colossus.escape.de>
- *
- * Revision 1.36.3.7  1996/04/19 21:06:18  bentson
- * remove unneeded boot message & fix CLOCAL hardware flow
- * control (Miquel van Smoorenburg <miquels@Q.cistron.nl>);
- * remove unused diagnostic statements; minor 0 is first;
- *
- * Revision 1.36.3.6  1996/03/13 13:21:17  marcio
- * The kernel function vremap (available only in later 1.3.xx kernels)
- * allows the access to memory addresses above the RAM. This revision
- * of the driver supports PCI boards below 1Mb (device id 0x100) and
- * above 1Mb (device id 0x101).
- *
- * Revision 1.36.3.5  1996/03/07 15:20:17  bentson
- * Some global changes to interrupt handling spilled into
- * this driver--mostly unused arguments in system function
- * calls.  Also added change by Marcio Saito which should
- * reduce lost interrupts at startup by fast processors.
- *
- * Revision 1.36.3.4  1995/11/13  20:45:10  bentson
- * Changes by Corey Minyard <minyard@wf-rch.cirr.com> distributed
- * in 1.3.41 kernel to remove a possible race condition, extend
- * some error messages, and let the driver run as a loadable module
- * Change by Alan Wendt <alan@ez0.ezlink.com> to remove a
- * possible race condition.
- * Change by Marcio Saito <marcio@cyclades.com> to fix PCI addressing.
- *
- * Revision 1.36.3.3  1995/11/13  19:44:48  bentson
- * Changes by Linus Torvalds in 1.3.33 kernel distribution
- * required due to reordering of driver initialization.
- * Drivers are now initialized *after* memory management.
- *
- * Revision 1.36.3.2  1995/09/08  22:07:14  bentson
- * remove printk from ISR; fix typo
- *
- * Revision 1.36.3.1  1995/09/01  12:00:42  marcio
- * Minor fixes in the PCI board support. PCI function calls in
- * conditional compilation (CONFIG_PCI). Thanks to Jim Duncan
- * <duncan@okay.com>. "bad serial count" message removed.
- *
- * Revision 1.36.3  1995/08/22  09:19:42  marcio
- * Cyclom-Y/PCI support added. Changes in the cy_init routine and
- * board initialization. Changes in the boot messages. The driver
- * supports up to 4 boards and 64 ports by default.
- *
- * Revision 1.36.1.4  1995/03/29  06:14:14  bentson
- * disambiguate between Cyclom-16Y and Cyclom-32Ye;
- *
- * Revision 1.36.1.3  1995/03/23  22:15:35  bentson
- * add missing break in modem control block in ioctl switch statement
- * (discovered by Michael Edward Chastain <mec@jobe.shell.portal.com>);
- *
- * Revision 1.36.1.2  1995/03/22  19:16:22  bentson
- * make sure CTS flow control is set as soon as possible (thanks
- * to note from David Lambert <lambert@chesapeake.rps.slb.com>);
- *
- * Revision 1.36.1.1  1995/03/13  15:44:43  bentson
- * initialize defaults for receive threshold and stale data timeout;
- * cosmetic changes;
- *
- * Revision 1.36  1995/03/10  23:33:53  bentson
- * added support of chips 4-7 in 32 port Cyclom-Ye;
- * fix cy_interrupt pointer dereference problem
- * (Joe Portman <baron@aa.net>);
- * give better error response if open is attempted on non-existent port
- * (Zachariah Vaum <jchryslr@netcom.com>);
- * correct command timeout (Kenneth Lerman <lerman@@seltd.newnet.com>);
- * conditional compilation for -16Y on systems with fast, noisy bus;
- * comment out diagnostic print function;
- * cleaned up table of base addresses;
- * set receiver time-out period register to correct value,
- * set receive threshold to better default values,
- * set chip timer to more accurate 200 Hz ticking,
- * add code to monitor and modify receive parameters
- * (Rik Faith <faith@cs.unc.edu> Nick Simicich
- * <njs@scifi.emi.net>);
- *
- * Revision 1.35  1994/12/16  13:54:18  steffen
- * additional patch by Marcio Saito for board detection
- * Accidently left out in 1.34
- *
- * Revision 1.34  1994/12/10  12:37:12  steffen
- * This is the corrected version as suggested by Marcio Saito
- *
- * Revision 1.33  1994/12/01  22:41:18  bentson
- * add hooks to support more high speeds directly; add tytso
- * patch regarding CLOCAL wakeups
- *
- * Revision 1.32  1994/11/23  19:50:04  bentson
- * allow direct kernel control of higher signalling rates;
- * look for cards at additional locations
- *
- * Revision 1.31  1994/11/16  04:33:28  bentson
- * ANOTHER fix from Corey Minyard, minyard@wf-rch.cirr.com--
- * a problem in chars_in_buffer has been resolved by some
- * small changes;  this should yield smoother output
- *
- * Revision 1.30  1994/11/16  04:28:05  bentson
- * Fix from Corey Minyard, Internet: minyard@metronet.com,
- * UUCP: minyard@wf-rch.cirr.com, WORK: minyardbnr.ca, to
- * cy_hangup that appears to clear up much (all?) of the
- * DTR glitches; also he's added/cleaned-up diagnostic messages
- *
- * Revision 1.29  1994/11/16  04:16:07  bentson
- * add change proposed by Ralph Sims, ralphs@halcyon.com, to
- * operate higher speeds in same way as other serial ports;
- * add more serial ports (for up to two 16-port muxes).
- *
- * Revision 1.28  1994/11/04  00:13:16  root
- * turn off diagnostic messages
- *
- * Revision 1.27  1994/11/03  23:46:37  root
- * bunch of changes to bring driver into greater conformance
- * with the serial.c driver (looking for missed fixes)
- *
- * Revision 1.26  1994/11/03  22:40:36  root
- * automatic interrupt probing fixed.
- *
- * Revision 1.25  1994/11/03  20:17:02  root
- * start to implement auto-irq
- *
- * Revision 1.24  1994/11/03  18:01:55  root
- * still working on modem signals--trying not to drop DTR
- * during the getty/login processes
- *
- * Revision 1.23  1994/11/03  17:51:36  root
- * extend baud rate support; set receive threshold as function
- * of baud rate; fix some problems with RTS/CTS;
- *
- * Revision 1.22  1994/11/02  18:05:35  root
- * changed arguments to udelay to type long to get
- * delays to be of correct duration
- *
- * Revision 1.21  1994/11/02  17:37:30  root
- * employ udelay (after calibrating loops_per_second earlier
- * in init/main.c) instead of using home-grown delay routines
- *
- * Revision 1.20  1994/11/02  03:11:38  root
- * cy_chars_in_buffer forces a return value of 0 to let
- * login work (don't know why it does); some functions
- * that were returning EFAULT, now executes the code;
- * more work on deciding when to disable xmit interrupts;
- *
- * Revision 1.19  1994/11/01  20:10:14  root
- * define routine to start transmission interrupts (by enabling
- * transmit interrupts); directly enable/disable modem interrupts;
- *
- * Revision 1.18  1994/11/01  18:40:45  bentson
- * Don't always enable transmit interrupts in startup; interrupt on
- * TxMpty instead of TxRdy to help characters get out before shutdown;
- * restructure xmit interrupt to check for chars first and quit if
- * none are ready to go; modem status (MXVRx) is upright, _not_ inverted
- * (to my view);
- *
- * Revision 1.17  1994/10/30  04:39:45  bentson
- * rename serial_driver and callout_driver to cy_serial_driver and
- * cy_callout_driver to avoid linkage interference; initialize
- * info->type to PORT_CIRRUS; ruggedize paranoia test; elide ->port
- * from cyclades_port structure; add paranoia check to cy_close;
- *
- * Revision 1.16  1994/10/30  01:14:33  bentson
- * change major numbers; add some _early_ return statements;
- *
- * Revision 1.15  1994/10/29  06:43:15  bentson
- * final tidying up for clean compile;  enable some error reporting
- *
- * Revision 1.14  1994/10/28  20:30:22  Bentson
- * lots of changes to drag the driver towards the new tty_io
- * structures and operation.  not expected to work, but may
- * compile cleanly.
- *
- * Revision 1.13  1994/07/21  23:08:57  Bentson
- * add some diagnostic cruft; support 24 lines (for testing
- * both -8Y and -16Y cards; be more thorough in servicing all
- * chips during interrupt; add "volatile" a few places to
- * circumvent compiler optimizations; fix base & offset
- * computations in block_til_ready (was causing chip 0 to
- * stop operation)
- *
- * Revision 1.12  1994/07/19  16:42:11  Bentson
- * add some hackery for kernel version 1.1.8; expand
- * error messages; refine timing for delay loops and
- * declare loop params volatile
- *
- * Revision 1.11  1994/06/11  21:53:10  bentson
- * get use of save_car right in transmit interrupt service
- *
- * Revision 1.10.1.1  1994/06/11  21:31:18  bentson
- * add some diagnostic printing; try to fix save_car stuff
- *
- * Revision 1.10  1994/06/11  20:36:08  bentson
- * clean up compiler warnings
- *
- * Revision 1.9  1994/06/11  19:42:46  bentson
- * added a bunch of code to support modem signalling
- *
- * Revision 1.8  1994/06/11  17:57:07  bentson
- * recognize break & parity error
- *
- * Revision 1.7  1994/06/05  05:51:34  bentson
- * Reorder baud table to be monotonic; add cli to CP; discard
- * incoming characters and status if the line isn't open; start to
- * fold code into cy_throttle; start to port get_serial_info,
- * set_serial_info, get_modem_info, set_modem_info, and send_break
- * from serial.c; expand cy_ioctl; relocate and expand config_setup;
- * get flow control characters from tty struct; invalidate ports w/o
- * hardware;
- *
- * Revision 1.6  1994/05/31  18:42:21  bentson
- * add a loop-breaker in the interrupt service routine;
- * note when port is initialized so that it can be shut
- * down under the right conditions; receive works without
- * any obvious errors
- *
- * Revision 1.5  1994/05/30  00:55:02  bentson
- * transmit works without obvious errors
- *
- * Revision 1.4  1994/05/27  18:46:27  bentson
- * incorporated more code from lib_y.c; can now print short
- * strings under interrupt control to port zero; seems to
- * select ports/channels/lines correctly
- *
- * Revision 1.3  1994/05/25  22:12:44  bentson
- * shifting from multi-port on a card to proper multiplexor
- * data structures;  added skeletons of most routines
- *
- * Revision 1.2  1994/05/19  13:21:43  bentson
- * start to crib from other sources
- *
  */
 
-#define CY_VERSION      "2.5"
+#define CY_VERSION      "2.6"
 
 /* If you need to install more boards than NR_CARDS, change the constant
    in the definition below. No other change is necessary to support up to
@@ -648,9 +80,7 @@
 #include <linux/firmware.h>
 #include <linux/device.h>
 
-#include <asm/system.h>
 #include <linux/io.h>
-#include <asm/irq.h>
 #include <linux/uaccess.h>
 
 #include <linux/kernel.h>
@@ -660,13 +90,11 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 
-static void cy_throttle(struct tty_struct *tty);
 static void cy_send_xchar(struct tty_struct *tty, char ch);
 
 #ifndef SERIAL_XMIT_SIZE
 #define SERIAL_XMIT_SIZE        (min(PAGE_SIZE, 4096))
 #endif
-#define WAKEUP_CHARS            256
 
 #define STD_COM_FLAGS (0)
 
@@ -756,25 +184,25 @@ static int cy_next_channel;	/* next minor available */
  *                                               HI            VHI
  *     20
  */
-static int baud_table[] = {
+static const int baud_table[] = {
         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
         1800, 2400, 4800, 9600, 19200, 38400, 57600, 76800, 115200, 150000,
         230400, 0
 };
 
-static char baud_co_25[] = {    /* 25 MHz clock option table */
+static const char baud_co_25[] = {      /* 25 MHz clock option table */
         /* value =>    00    01   02    03    04 */
         /* divide by    8    32   128   512  2048 */
         0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03, 0x03, 0x02,
         0x02, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 
-static char baud_bpr_25[] = {   /* 25 MHz baud rate period table */
+static const char baud_bpr_25[] = {     /* 25 MHz baud rate period table */
         0x00, 0xf5, 0xa3, 0x6f, 0x5c, 0x51, 0xf5, 0xa3, 0x51, 0xa3,
         0x6d, 0x51, 0xa3, 0x51, 0xa3, 0x51, 0x36, 0x29, 0x1b, 0x15
 };
 
-static char baud_co_60[] = {    /* 60 MHz clock option table (CD1400 J) */
+static const char baud_co_60[] = {      /* 60 MHz clock option table (CD1400 J) */
         /* value =>    00    01   02    03    04 */
         /* divide by    8    32   128   512  2048 */
         0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03, 0x03,
@@ -782,13 +210,13 @@ static char baud_co_60[] = {	/* 60 MHz clock option table (CD1400 J) */
         0x00
 };
 
-static char baud_bpr_60[] = {   /* 60 MHz baud rate period table (CD1400 J) */
+static const char baud_bpr_60[] = {     /* 60 MHz baud rate period table (CD1400 J) */
         0x00, 0x82, 0x21, 0xff, 0xdb, 0xc3, 0x92, 0x62, 0xc3, 0x62,
         0x41, 0xc3, 0x62, 0xc3, 0x62, 0xc3, 0x82, 0x62, 0x41, 0x32,
         0x21
 };
 
-static char baud_cor3[] = {     /* receive threshold */
+static const char baud_cor3[] = {       /* receive threshold */
         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
         0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x08, 0x08, 0x08, 0x08, 0x07,
         0x07
@@ -805,7 +233,7 @@ static char baud_cor3[] = {	/* receive threshold */
  * cables.
  */
 
-static char rflow_thr[] = {     /* rflow threshold */
+static const char rflow_thr[] = {       /* rflow threshold */
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
         0x0a
@@ -814,7 +242,7 @@ static char rflow_thr[] = {	/* rflow threshold */
 /*  The Cyclom-Ye has placed the sequential chips in non-sequential
  *  address order.  This look-up table overcomes that problem.
  */
-static int cy_chip_offset[] = { 0x0000,
+static const unsigned int cy_chip_offset[] = { 0x0000,
         0x0400,
         0x0800,
         0x0C00,
@@ -827,7 +255,7 @@ static int cy_chip_offset[] = { 0x0000,
 /* PCI related definitions */
 
 #ifdef CONFIG_PCI
-static struct pci_device_id cy_pci_dev_id[] __devinitdata = {
+static const struct pci_device_id cy_pci_dev_id[] = {
         /* PCI < 1Mb */
         { PCI_DEVICE(PCI_VENDOR_ID_CYCLADES, PCI_DEVICE_ID_CYCLOM_Y_Lo) },
         /* PCI > 1Mb */
@@ -850,7 +278,7 @@ MODULE_DEVICE_TABLE(pci, cy_pci_dev_id);
 #endif
 
 static void cy_start(struct tty_struct *);
-static void set_line_char(struct cyclades_port *);
+static void cy_set_line_char(struct cyclades_port *, struct tty_struct *);
 static int cyz_issue_cmd(struct cyclades_card *, __u32, __u8, __u32);
 #ifdef CONFIG_ISA
 static unsigned detect_isa_irq(void __iomem *);
@@ -869,6 +297,20 @@ static void cyz_rx_restart(unsigned long);
 static struct timer_list cyz_rx_full_timer[NR_PORTS];
 #endif                          /* CONFIG_CYZ_INTR */
 
+static inline void cyy_writeb(struct cyclades_port *port, u32 reg, u8 val)
+{
+        struct cyclades_card *card = port->card;
+
+        cy_writeb(port->u.cyy.base_addr + (reg << card->bus_index), val);
+}
+
+static inline u8 cyy_readb(struct cyclades_port *port, u32 reg)
+{
+        struct cyclades_card *card = port->card;
+
+        return readb(port->u.cyy.base_addr + (reg << card->bus_index));
+}
+
 static inline bool cy_is_Z(struct cyclades_card *card)
 {
         return card->num_chips == (unsigned int)-1;
@@ -893,7 +335,7 @@ static inline bool cyz_is_loaded(struct cyclades_card *card)
 }
 
 static inline int serial_paranoia_check(struct cyclades_port *info,
-                char *name, const char *routine)
+                const char *name, const char *routine)
 {
 #ifdef SERIAL_PARANOIA_CHECK
         if (!info) {
@@ -909,7 +351,7 @@ static inline int serial_paranoia_check(struct cyclades_port *info,
         }
 #endif
         return 0;
-}                               /* serial_paranoia_check */
+}
 
 /***********************************************************/
 /********* Start of block of Cyclom-Y specific code ********/
@@ -921,13 +363,14 @@ static inline int serial_paranoia_check(struct cyclades_port *info,
 
    This function is only called from inside spinlock-protected code.
  */
-static int cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index)
+static int __cyy_issue_cmd(void __iomem *base_addr, u8 cmd, int index)
 {
+        void __iomem *ccr = base_addr + (CyCCR << index);
         unsigned int i;
 
         /* Check to see that the previous command has completed */
         for (i = 0; i < 100; i++) {
-                if (readb(base_addr + (CyCCR << index)) == 0)
+                if (readb(ccr) == 0)
                         break;
                 udelay(10L);
         }
@@ -937,10 +380,16 @@ static int cyy_issue_cmd(void __iomem *base_addr, u_char cmd, int index)
                 return -1;
 
         /* Issue the new command */
-        cy_writeb(base_addr + (CyCCR << index), cmd);
+        cy_writeb(ccr, cmd);
 
         return 0;
-}                               /* cyy_issue_cmd */
+}
+
+static inline int cyy_issue_cmd(struct cyclades_port *port, u8 cmd)
+{
+        return __cyy_issue_cmd(port->u.cyy.base_addr, cmd,
+                        port->card->bus_index);
+}
 
 #ifdef CONFIG_ISA
 /* ISA interrupt detection code */
@@ -960,12 +409,12 @@ static unsigned detect_isa_irq(void __iomem *address)
 
         irqs = probe_irq_on();
         /* Wait ... */
-        udelay(5000L);
+        msleep(5);
 
         /* Enable the Tx interrupts on the CD1400 */
         local_irq_save(flags);
         cy_writeb(address + (CyCAR << index), 0);
-        cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
+        __cyy_issue_cmd(address, CyCHAN_CTL | CyENB_XMTR, index);
 
         cy_writeb(address + (CyCAR << index), 0);
         cy_writeb(address + (CySRER << index),
@@ -973,7 +422,7 @@ static unsigned detect_isa_irq(void __iomem *address)
         local_irq_restore(flags);
 
         /* Wait ... */
-        udelay(5000L);
+        msleep(5);
 
         /* Check which interrupt is in use */
         irq = probe_irq_off(irqs);
@@ -999,7 +448,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
         struct cyclades_port *info;
         struct tty_struct *tty;
         int len, index = cinfo->bus_index;
-        u8 save_xir, channel, save_car, data, char_count;
+        u8 ivr, save_xir, channel, save_car, data, char_count;
 
 #ifdef CY_DEBUG_INTERRUPTS
         printk(KERN_DEBUG "cyy_interrupt: rcvd intr, chip %d\n", chip);
@@ -1008,26 +457,25 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
         save_xir = readb(base_addr + (CyRIR << index));
         channel = save_xir & CyIRChannel;
         info = &cinfo->ports[channel + chip * 4];
-        save_car = readb(base_addr + (CyCAR << index));
-        cy_writeb(base_addr + (CyCAR << index), save_xir);
+        save_car = cyy_readb(info, CyCAR);
+        cyy_writeb(info, CyCAR, save_xir);
+        ivr = cyy_readb(info, CyRIVR) & CyIVRMask;
 
+        tty = tty_port_tty_get(&info->port);
         /* if there is nowhere to put the data, discard it */
-        if (info->port.tty == NULL) {
-                if ((readb(base_addr + (CyRIVR << index)) & CyIVRMask) ==
-                                CyIVRRxEx) {    /* exception */
-                        data = readb(base_addr + (CyRDSR << index));
+        if (tty == NULL) {
+                if (ivr == CyIVRRxEx) { /* exception */
+                        data = cyy_readb(info, CyRDSR);
                 } else {        /* normal character reception */
-                        char_count = readb(base_addr + (CyRDCR << index));
+                        char_count = cyy_readb(info, CyRDCR);
                         while (char_count--)
-                                data = readb(base_addr + (CyRDSR << index));
+                                data = cyy_readb(info, CyRDSR);
                 }
                 goto end;
         }
         /* there is an open port for this data */
-        tty = info->port.tty;
-        if ((readb(base_addr + (CyRIVR << index)) & CyIVRMask) ==
-                        CyIVRRxEx) {    /* exception */
-                data = readb(base_addr + (CyRDSR << index));
+        if (ivr == CyIVRRxEx) { /* exception */
+                data = cyy_readb(info, CyRDSR);
 
                 /* For statistics only */
                 if (data & CyBREAK)
@@ -1041,28 +489,29 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
 
                 if (data & info->ignore_status_mask) {
                         info->icount.rx++;
+                        tty_kref_put(tty);
                         return;
                 }
                 if (tty_buffer_request_room(tty, 1)) {
                         if (data & info->read_status_mask) {
                                 if (data & CyBREAK) {
                                         tty_insert_flip_char(tty,
-                                                readb(base_addr + (CyRDSR <<
-                                                        index)), TTY_BREAK);
+                                                cyy_readb(info, CyRDSR),
+                                                TTY_BREAK);
                                         info->icount.rx++;
                                         if (info->port.flags & ASYNC_SAK)
                                                 do_SAK(tty);
                                 } else if (data & CyFRAME) {
                                         tty_insert_flip_char(tty,
-                                                readb(base_addr + (CyRDSR <<
-                                                        index)), TTY_FRAME);
+                                                cyy_readb(info, CyRDSR),
+                                                TTY_FRAME);
                                         info->icount.rx++;
                                         info->idle_stats.frame_errs++;
                                 } else if (data & CyPARITY) {
                                         /* Pieces of seven... */
                                         tty_insert_flip_char(tty,
-                                                readb(base_addr + (CyRDSR <<
-                                                        index)), TTY_PARITY);
+                                                cyy_readb(info, CyRDSR),
+                                                TTY_PARITY);
                                         info->icount.rx++;
                                         info->idle_stats.parity_errs++;
                                 } else if (data & CyOVERRUN) {
@@ -1074,8 +523,8 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                                            the next incoming character.
                                          */
                                         tty_insert_flip_char(tty,
-                                                readb(base_addr + (CyRDSR <<
-                                                        index)), TTY_FRAME);
+                                                cyy_readb(info, CyRDSR),
+                                                TTY_FRAME);
                                         info->icount.rx++;
                                         info->idle_stats.overruns++;
                                 /* These two conditions may imply */
@@ -1099,7 +548,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                 }
         } else {        /* normal character reception */
                 /* load # chars available from the chip */
-                char_count = readb(base_addr + (CyRDCR << index));
+                char_count = cyy_readb(info, CyRDCR);
 
 #ifdef CY_ENABLE_MONITORING
                 ++info->mon.int_count;
@@ -1110,7 +559,7 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
 #endif
                 len = tty_buffer_request_room(tty, char_count);
                 while (len--) {
-                        data = readb(base_addr + (CyRDSR << index));
+                        data = cyy_readb(info, CyRDSR);
                         tty_insert_flip_char(tty, data, TTY_NORMAL);
                         info->idle_stats.recv_bytes++;
                         info->icount.rx++;
@@ -1121,16 +570,18 @@ static void cyy_chip_rx(struct cyclades_card *cinfo, int chip,
                 info->idle_stats.recv_idle = jiffies;
         }
         tty_schedule_flip(tty);
+        tty_kref_put(tty);
 end:
         /* end of service */
-        cy_writeb(base_addr + (CyRIR << index), save_xir & 0x3f);
-        cy_writeb(base_addr + (CyCAR << index), save_car);
+        cyy_writeb(info, CyRIR, save_xir & 0x3f);
+        cyy_writeb(info, CyCAR, save_car);
 }
 
 static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
                 void __iomem *base_addr)
 {
         struct cyclades_port *info;
+        struct tty_struct *tty;
         int char_count, index = cinfo->bus_index;
         u8 save_xir, channel, save_car, outch;
 
@@ -1154,9 +605,9 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
                 goto end;
         }
         info = &cinfo->ports[channel + chip * 4];
-        if (info->port.tty == NULL) {
-                cy_writeb(base_addr + (CySRER << index),
-                          readb(base_addr + (CySRER << index)) & ~CyTxRdy);
+        tty = tty_port_tty_get(&info->port);
+        if (tty == NULL) {
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
                 goto end;
         }
 
@@ -1165,7 +616,7 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
 
         if (info->x_char) {     /* send special char */
                 outch = info->x_char;
-                cy_writeb(base_addr + (CyTDR << index), outch);
+                cyy_writeb(info, CyTDR, outch);
                 char_count--;
                 info->icount.tx++;
                 info->x_char = 0;
@@ -1173,14 +624,14 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
 
         if (info->breakon || info->breakoff) {
                 if (info->breakon) {
-                        cy_writeb(base_addr + (CyTDR << index), 0);
-                        cy_writeb(base_addr + (CyTDR << index), 0x81);
+                        cyy_writeb(info, CyTDR, 0);
+                        cyy_writeb(info, CyTDR, 0x81);
                         info->breakon = 0;
                         char_count -= 2;
                 }
                 if (info->breakoff) {
-                        cy_writeb(base_addr + (CyTDR << index), 0);
-                        cy_writeb(base_addr + (CyTDR << index), 0x83);
+                        cyy_writeb(info, CyTDR, 0);
+                        cyy_writeb(info, CyTDR, 0x83);
                         info->breakoff = 0;
                         char_count -= 2;
                 }
@@ -1188,27 +639,23 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
 
         while (char_count-- > 0) {
                 if (!info->xmit_cnt) {
-                        if (readb(base_addr + (CySRER << index)) & CyTxMpty) {
-                                cy_writeb(base_addr + (CySRER << index),
-                                        readb(base_addr + (CySRER << index)) &
-                                                ~CyTxMpty);
+                        if (cyy_readb(info, CySRER) & CyTxMpty) {
+                                cyy_writeb(info, CySRER,
+                                        cyy_readb(info, CySRER) & ~CyTxMpty);
                         } else {
-                                cy_writeb(base_addr + (CySRER << index),
-                                        (readb(base_addr + (CySRER << index)) &
-                                                ~CyTxRdy) | CyTxMpty);
+                                cyy_writeb(info, CySRER, CyTxMpty |
+                                        (cyy_readb(info, CySRER) & ~CyTxRdy));
                         }
                         goto done;
                 }
                 if (info->port.xmit_buf == NULL) {
-                        cy_writeb(base_addr + (CySRER << index),
-                                readb(base_addr + (CySRER << index)) &
-                                        ~CyTxRdy);
+                        cyy_writeb(info, CySRER,
+                                cyy_readb(info, CySRER) & ~CyTxRdy);
                         goto done;
                 }
-                if (info->port.tty->stopped || info->port.tty->hw_stopped) {
-                        cy_writeb(base_addr + (CySRER << index),
-                                readb(base_addr + (CySRER << index)) &
-                                        ~CyTxRdy);
+                if (tty->stopped || tty->hw_stopped) {
+                        cyy_writeb(info, CySRER,
+                                cyy_readb(info, CySRER) & ~CyTxRdy);
                         goto done;
                 }
                 /* Because the Embedded Transmit Commands have been enabled,
@@ -1225,15 +672,15 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
                         info->xmit_cnt--;
                         info->xmit_tail = (info->xmit_tail + 1) &
                                         (SERIAL_XMIT_SIZE - 1);
-                        cy_writeb(base_addr + (CyTDR << index), outch);
+                        cyy_writeb(info, CyTDR, outch);
                         info->icount.tx++;
                 } else {
                         if (char_count > 1) {
                                 info->xmit_cnt--;
                                 info->xmit_tail = (info->xmit_tail + 1) &
                                         (SERIAL_XMIT_SIZE - 1);
-                                cy_writeb(base_addr + (CyTDR << index), outch);
-                                cy_writeb(base_addr + (CyTDR << index), 0);
+                                cyy_writeb(info, CyTDR, outch);
+                                cyy_writeb(info, CyTDR, 0);
                                 info->icount.tx++;
                                 char_count--;
                         }
@@ -1241,17 +688,19 @@ static void cyy_chip_tx(struct cyclades_card *cinfo, unsigned int chip,
         }
 
 done:
-        tty_wakeup(info->port.tty);
+        tty_wakeup(tty);
+        tty_kref_put(tty);
 end:
         /* end of service */
-        cy_writeb(base_addr + (CyTIR << index), save_xir & 0x3f);
-        cy_writeb(base_addr + (CyCAR << index), save_car);
+        cyy_writeb(info, CyTIR, save_xir & 0x3f);
+        cyy_writeb(info, CyCAR, save_car);
 }
 
 static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
                 void __iomem *base_addr)
 {
         struct cyclades_port *info;
+        struct tty_struct *tty;
         int index = cinfo->bus_index;
         u8 save_xir, channel, save_car, mdm_change, mdm_status;
 
@@ -1259,13 +708,14 @@ static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
         save_xir = readb(base_addr + (CyMIR << index));
         channel = save_xir & CyIRChannel;
         info = &cinfo->ports[channel + chip * 4];
-        save_car = readb(base_addr + (CyCAR << index));
-        cy_writeb(base_addr + (CyCAR << index), save_xir);
+        save_car = cyy_readb(info, CyCAR);
+        cyy_writeb(info, CyCAR, save_xir);
 
-        mdm_change = readb(base_addr + (CyMISR << index));
-        mdm_status = readb(base_addr + (CyMSVR1 << index));
+        mdm_change = cyy_readb(info, CyMISR);
+        mdm_status = cyy_readb(info, CyMSVR1);
 
-        if (!info->port.tty)
+        tty = tty_port_tty_get(&info->port);
+        if (!tty)
                 goto end;
 
         if (mdm_change & CyANY_DELTA) {
@@ -1279,35 +729,32 @@ static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
                 if (mdm_change & CyRI)
                         info->icount.rng++;
 
-                wake_up_interruptible(&info->delta_msr_wait);
+                wake_up_interruptible(&info->port.delta_msr_wait);
         }
 
         if ((mdm_change & CyDCD) && (info->port.flags & ASYNC_CHECK_CD)) {
-                if (!(mdm_status & CyDCD)) {
-                        tty_hangup(info->port.tty);
-                        info->port.flags &= ~ASYNC_NORMAL_ACTIVE;
-                }
-                wake_up_interruptible(&info->port.open_wait);
+                if (mdm_status & CyDCD)
+                        wake_up_interruptible(&info->port.open_wait);
+                else
+                        tty_hangup(tty);
         }
         if ((mdm_change & CyCTS) && (info->port.flags & ASYNC_CTS_FLOW)) {
-                if (info->port.tty->hw_stopped) {
+                if (tty->hw_stopped) {
                         if (mdm_status & CyCTS) {
                                 /* cy_start isn't used
                                    because... !!! */
-                                info->port.tty->hw_stopped = 0;
-                                cy_writeb(base_addr + (CySRER << index),
-                                        readb(base_addr + (CySRER << index)) |
-                                                CyTxRdy);
-                                tty_wakeup(info->port.tty);
+                                tty->hw_stopped = 0;
+                                cyy_writeb(info, CySRER,
+                                        cyy_readb(info, CySRER) | CyTxRdy);
+                                tty_wakeup(tty);
                         }
                 } else {
                         if (!(mdm_status & CyCTS)) {
                                 /* cy_stop isn't used
                                    because ... !!! */
-                                info->port.tty->hw_stopped = 1;
-                                cy_writeb(base_addr + (CySRER << index),
-                                        readb(base_addr + (CySRER << index)) &
-                                                ~CyTxRdy);
+                                tty->hw_stopped = 1;
+                                cyy_writeb(info, CySRER,
+                                        cyy_readb(info, CySRER) & ~CyTxRdy);
                         }
                 }
         }
@@ -1315,10 +762,11 @@ static void cyy_chip_modem(struct cyclades_card *cinfo, int chip,
         }
         if (mdm_change & CyRI) {
         }*/
+        tty_kref_put(tty);
 end:
         /* end of service */
-        cy_writeb(base_addr + (CyMIR << index), save_xir & 0x3f);
-        cy_writeb(base_addr + (CyCAR << index), save_car);
+        cyy_writeb(info, CyMIR, save_xir & 0x3f);
+        cyy_writeb(info, CyCAR, save_car);
 }
 
 /* The real interrupt service routine is called
@@ -1389,6 +837,56 @@ static irqreturn_t cyy_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }                               /* cyy_interrupt */
 
+static void cyy_change_rts_dtr(struct cyclades_port *info, unsigned int set,
+                unsigned int clear)
+{
+        struct cyclades_card *card = info->card;
+        int channel = info->line - card->first_line;
+        u32 rts, dtr, msvrr, msvrd;
+
+        channel &= 0x03;
+
+        if (info->rtsdtr_inv) {
+                msvrr = CyMSVR2;
+                msvrd = CyMSVR1;
+                rts = CyDTR;
+                dtr = CyRTS;
+        } else {
+                msvrr = CyMSVR1;
+                msvrd = CyMSVR2;
+                rts = CyRTS;
+                dtr = CyDTR;
+        }
+        if (set & TIOCM_RTS) {
+                cyy_writeb(info, CyCAR, channel);
+                cyy_writeb(info, msvrr, rts);
+        }
+        if (clear & TIOCM_RTS) {
+                cyy_writeb(info, CyCAR, channel);
+                cyy_writeb(info, msvrr, ~rts);
+        }
+        if (set & TIOCM_DTR) {
+                cyy_writeb(info, CyCAR, channel);
+                cyy_writeb(info, msvrd, dtr);
+#ifdef CY_DEBUG_DTR
+                printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
+                printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                        cyy_readb(info, CyMSVR1),
+                        cyy_readb(info, CyMSVR2));
+#endif
+        }
+        if (clear & TIOCM_DTR) {
+                cyy_writeb(info, CyCAR, channel);
+                cyy_writeb(info, msvrd, ~dtr);
+#ifdef CY_DEBUG_DTR
+                printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
+                printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
+                        cyy_readb(info, CyMSVR1),
+                        cyy_readb(info, CyMSVR2));
+#endif
+        }
+}
+
 /***********************************************************/
 /********* End of block of Cyclom-Y specific code **********/
 /******** Start of block of Cyclades-Z specific code *******/
@@ -1398,15 +896,9 @@ static int
 cyz_fetch_msg(struct cyclades_card *cinfo,
                 __u32 *channel, __u8 *cmd, __u32 *param)
 {
-        struct FIRM_ID __iomem *firm_id;
-        struct ZFW_CTRL __iomem *zfw_ctrl;
-        struct BOARD_CTRL __iomem *board_ctrl;
+        struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
         unsigned long loc_doorbell;
 
-        firm_id = cinfo->base_addr + ID_ADDRESS;
-        zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &zfw_ctrl->board_ctrl;
-
         loc_doorbell = readl(&cinfo->ctl_addr.p9060->loc_doorbell);
         if (loc_doorbell) {
                 *cmd = (char)(0xff & loc_doorbell);
@@ -1422,19 +914,13 @@ static int
 cyz_issue_cmd(struct cyclades_card *cinfo,
                 __u32 channel, __u8 cmd, __u32 param)
 {
-        struct FIRM_ID __iomem *firm_id;
-        struct ZFW_CTRL __iomem *zfw_ctrl;
-        struct BOARD_CTRL __iomem *board_ctrl;
+        struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
         __u32 __iomem *pci_doorbell;
         unsigned int index;
 
-        firm_id = cinfo->base_addr + ID_ADDRESS;
         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 = &cinfo->ctl_addr.p9060->pci_doorbell;
         while ((readl(pci_doorbell) & 0xff) != 0) {
@@ -1449,11 +935,10 @@ cyz_issue_cmd(struct cyclades_card *cinfo,
         return 0;
 }                               /* cyz_issue_cmd */
 
-static void cyz_handle_rx(struct cyclades_port *info,
-                struct BUF_CTRL __iomem *buf_ctrl)
+static void cyz_handle_rx(struct cyclades_port *info, struct tty_struct *tty)
 {
+        struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
         struct cyclades_card *cinfo = info->card;
-        struct tty_struct *tty = info->port.tty;
         unsigned int char_count;
         int len;
 #ifdef BLOCKMOVE
@@ -1542,11 +1027,10 @@ static void cyz_handle_rx(struct cyclades_port *info,
         }
 }
 
-static void cyz_handle_tx(struct cyclades_port *info,
-                struct BUF_CTRL __iomem *buf_ctrl)
+static void cyz_handle_tx(struct cyclades_port *info, struct tty_struct *tty)
 {
+        struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
         struct cyclades_card *cinfo = info->card;
-        struct tty_struct *tty = info->port.tty;
         u8 data;
         unsigned int char_count;
 #ifdef BLOCKMOVE
@@ -1621,34 +1105,24 @@ ztxdone:
 
 static void cyz_handle_cmd(struct cyclades_card *cinfo)
 {
+        struct BOARD_CTRL __iomem *board_ctrl = cinfo->board_ctrl;
         struct tty_struct *tty;
         struct cyclades_port *info;
-        static struct FIRM_ID __iomem *firm_id;
-        static struct ZFW_CTRL __iomem *zfw_ctrl;
-        static struct BOARD_CTRL __iomem *board_ctrl;
-        static struct CH_CTRL __iomem *ch_ctrl;
-        static struct BUF_CTRL __iomem *buf_ctrl;
         __u32 channel, param, fw_ver;
         __u8 cmd;
         int special_count;
         int delta_count;
 
-        firm_id = cinfo->base_addr + ID_ADDRESS;
-        zfw_ctrl = cinfo->base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-        board_ctrl = &zfw_ctrl->board_ctrl;
         fw_ver = readl(&board_ctrl->fw_version);
 
         while (cyz_fetch_msg(cinfo, &channel, &cmd, &param) == 1) {
                 special_count = 0;
                 delta_count = 0;
                 info = &cinfo->ports[channel];
-                tty = info->port.tty;
+                tty = tty_port_tty_get(&info->port);
                 if (tty == NULL)
                         continue;
 
-                ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-                buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
-
                 switch (cmd) {
                 case C_CM_PR_ERROR:
                         tty_insert_flip_char(tty, 0, TTY_PARITY);
@@ -1669,15 +1143,12 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         info->icount.dcd++;
                         delta_count++;
                         if (info->port.flags & ASYNC_CHECK_CD) {
-                                if ((fw_ver > 241 ? ((u_long) param) :
-                                                readl(&ch_ctrl->rs_status)) &
-                                                C_RS_DCD) {
+                                u32 dcd = fw_ver > 241 ? param :
+                                        readl(&info->u.cyz.ch_ctrl->rs_status);
+                                if (dcd & C_RS_DCD)
                                         wake_up_interruptible(&info->port.open_wait);
-                                } else {
-                                        tty_hangup(info->port.tty);
-                                        wake_up_interruptible(&info->port.open_wait);
-                                        info->port.flags &= ~ASYNC_NORMAL_ACTIVE;
-                                }
+                                else
+                                        tty_hangup(tty);
                         }
                         break;
                 case C_CM_MCTS:
@@ -1706,7 +1177,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         printk(KERN_DEBUG "cyz_interrupt: rcvd intr, card %d, "
                                         "port %ld\n", info->card, channel);
 #endif
-                        cyz_handle_rx(info, buf_ctrl);
+                        cyz_handle_rx(info, tty);
                         break;
                 case C_CM_TXBEMPTY:
                 case C_CM_TXLOWWM:
@@ -1716,7 +1187,7 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         printk(KERN_DEBUG "cyz_interrupt: xmit intr, card %d, "
                                         "port %ld\n", info->card, channel);
 #endif
-                        cyz_handle_tx(info, buf_ctrl);
+                        cyz_handle_tx(info, tty);
                         break;
 #endif                          /* CONFIG_CYZ_INTR */
                 case C_CM_FATAL:
@@ -1726,9 +1197,10 @@ static void cyz_handle_cmd(struct cyclades_card *cinfo)
                         break;
                 }
                 if (delta_count)
-                        wake_up_interruptible(&info->delta_msr_wait);
+                        wake_up_interruptible(&info->port.delta_msr_wait);
                 if (special_count)
                         tty_schedule_flip(tty);
+                tty_kref_put(tty);
         }
 }
 
@@ -1774,10 +1246,6 @@ static void cyz_poll(unsigned long arg)
 {
         struct cyclades_card *cinfo;
         struct cyclades_port *info;
-        struct tty_struct *tty;
-        struct FIRM_ID __iomem *firm_id;
-        struct ZFW_CTRL __iomem *zfw_ctrl;
-        struct BUF_CTRL __iomem *buf_ctrl;
         unsigned long expires = jiffies + HZ;
         unsigned int port, card;
 
@@ -1789,10 +1257,6 @@ static void cyz_poll(unsigned long arg)
                 if (!cyz_is_loaded(cinfo))
                         continue;
 
-                firm_id = cinfo->base_addr + ID_ADDRESS;
-                zfw_ctrl = cinfo->base_addr +
-                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-
         /* Skip first polling cycle to avoid racing conditions with the FW */
                 if (!cinfo->intr_enabled) {
                         cinfo->intr_enabled = 1;
@@ -1802,13 +1266,17 @@ static void cyz_poll(unsigned long arg)
                 cyz_handle_cmd(cinfo);
 
                 for (port = 0; port < cinfo->nports; port++) {
+                        struct tty_struct *tty;
+
                         info = &cinfo->ports[port];
-                        tty = info->port.tty;
-                        buf_ctrl = &(zfw_ctrl->buf_ctrl[port]);
+                        tty = tty_port_tty_get(&info->port);
+                        /* OK to pass NULL to the handle functions below.
+                           They need to drop the data in that case. */
 
                         if (!info->throttle)
-                                cyz_handle_rx(info, buf_ctrl);
-                        cyz_handle_tx(info, buf_ctrl);
+                                cyz_handle_rx(info, tty);
+                        cyz_handle_tx(info, tty);
+                        tty_kref_put(tty);
                 }
                 /* poll every 'cyz_polling_cycle' period */
                 expires = jiffies + cyz_polling_cycle;
@@ -1824,13 +1292,12 @@ static void cyz_poll(unsigned long arg)
 /* This is called whenever a port becomes active;
    interrupts are enabled and DTR & RTS are turned on.
  */
-static int startup(struct cyclades_port *info)
+static int cy_startup(struct cyclades_port *info, struct tty_struct *tty)
 {
         struct cyclades_card *card;
         unsigned long flags;
         int retval = 0;
-        void __iomem *base_addr;
-        int chip, channel, index;
+        int channel;
         unsigned long page;
 
         card = info->card;
@@ -1842,15 +1309,11 @@ static int startup(struct cyclades_port *info)
 
         spin_lock_irqsave(&card->card_lock, flags);
 
-        if (info->port.flags & ASYNC_INITIALIZED) {
-                free_page(page);
+        if (info->port.flags & ASYNC_INITIALIZED)
                 goto errout;
-        }
 
         if (!info->type) {
-                if (info->port.tty)
-                        set_bit(TTY_IO_ERROR, &info->port.tty->flags);
-                free_page(page);
+                set_bit(TTY_IO_ERROR, &tty->flags);
                 goto errout;
         }
 
@@ -1861,96 +1324,53 @@ static int startup(struct cyclades_port *info)
 
         spin_unlock_irqrestore(&card->card_lock, flags);
 
-        set_line_char(info);
+        cy_set_line_char(info, tty);
 
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
                 channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
-#ifdef CY_DEBUG_OPEN
-                printk(KERN_DEBUG "cyc startup card %d, chip %d, channel %d, "
-                                "base_addr %p\n",
-                                card, chip, channel, base_addr);
-#endif
                 spin_lock_irqsave(&card->card_lock, flags);
 
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+                cyy_writeb(info, CyCAR, channel);
 
-                cy_writeb(base_addr + (CyRTPR << index),
+                cyy_writeb(info, CyRTPR,
                         (info->default_timeout ? info->default_timeout : 0x02));
                 /* 10ms rx timeout */
 
-                cyy_issue_cmd(base_addr, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR,
-                                index);
-
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
-                cy_writeb(base_addr + (CyMSVR1 << index), CyRTS);
-                cy_writeb(base_addr + (CyMSVR2 << index), CyDTR);
-
-#ifdef CY_DEBUG_DTR
-                printk(KERN_DEBUG "cyc:startup raising DTR\n");
-                printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                        readb(base_addr + (CyMSVR1 << index)),
-                        readb(base_addr + (CyMSVR2 << index)));
-#endif
-
-                cy_writeb(base_addr + (CySRER << index),
-                        readb(base_addr + (CySRER << index)) | CyRxData);
-                info->port.flags |= ASYNC_INITIALIZED;
-
-                if (info->port.tty)
-                        clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
-                info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-                info->breakon = info->breakoff = 0;
-                memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
-                info->idle_stats.in_use =
-                info->idle_stats.recv_idle =
-                info->idle_stats.xmit_idle = jiffies;
+                cyy_issue_cmd(info, CyCHAN_CTL | CyENB_RCVR | CyENB_XMTR);
 
-                spin_unlock_irqrestore(&card->card_lock, flags);
+                cyy_change_rts_dtr(info, TIOCM_RTS | TIOCM_DTR, 0);
 
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyRxData);
         } 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 CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
 
-                base_addr = card->base_addr;
-
-                firm_id = base_addr + ID_ADDRESS;
                 if (!cyz_is_loaded(card))
                         return -ENODEV;
 
-                zfw_ctrl = card->base_addr +
-                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                board_ctrl = &zfw_ctrl->board_ctrl;
-                ch_ctrl = zfw_ctrl->ch_ctrl;
-
 #ifdef CY_DEBUG_OPEN
                 printk(KERN_DEBUG "cyc startup Z card %d, channel %d, "
-                        "base_addr %p\n", card, channel, base_addr);
+                        "base_addr %p\n", card, channel, card->base_addr);
 #endif
                 spin_lock_irqsave(&card->card_lock, flags);
 
-                cy_writel(&ch_ctrl[channel].op_mode, C_CH_ENABLE);
+                cy_writel(&ch_ctrl->op_mode, C_CH_ENABLE);
 #ifdef Z_WAKE
 #ifdef CONFIG_CYZ_INTR
-                cy_writel(&ch_ctrl[channel].intr_enable,
+                cy_writel(&ch_ctrl->intr_enable,
                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
                           C_IN_RXNNDT | C_IN_IOCTLW | C_IN_MDCD);
 #else
-                cy_writel(&ch_ctrl[channel].intr_enable,
+                cy_writel(&ch_ctrl->intr_enable,
                           C_IN_IOCTLW | C_IN_MDCD);
 #endif                          /* CONFIG_CYZ_INTR */
 #else
 #ifdef CONFIG_CYZ_INTR
-                cy_writel(&ch_ctrl[channel].intr_enable,
+                cy_writel(&ch_ctrl->intr_enable,
                           C_IN_TXBEMPTY | C_IN_TXLOWWM | C_IN_RXHIWM |
                           C_IN_RXNNDT | C_IN_MDCD);
 #else
-                cy_writel(&ch_ctrl[channel].intr_enable, C_IN_MDCD);
+                cy_writel(&ch_ctrl->intr_enable, C_IN_MDCD);
 #endif                          /* CONFIG_CYZ_INTR */
 #endif                          /* Z_WAKE */
 
@@ -1969,32 +1389,22 @@ static int startup(struct cyclades_port *info)
 
                 /* set timeout !!! */
                 /* set RTS and DTR !!! */
-                cy_writel(&ch_ctrl[channel].rs_control,
-                        readl(&ch_ctrl[channel].rs_control) | C_RS_RTS |
-                        C_RS_DTR);
-                retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
-                if (retval != 0) {
-                        printk(KERN_ERR "cyc:startup(3) retval on ttyC%d was "
-                                "%x\n", info->line, retval);
-                }
-#ifdef CY_DEBUG_DTR
-                printk(KERN_DEBUG "cyc:startup raising Z DTR\n");
-#endif
+                tty_port_raise_dtr_rts(&info->port);
 
                 /* enable send, recv, modem !!! */
+        }
 
-                info->port.flags |= ASYNC_INITIALIZED;
-                if (info->port.tty)
-                        clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
-                info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
-                info->breakon = info->breakoff = 0;
-                memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
-                info->idle_stats.in_use =
-                info->idle_stats.recv_idle =
-                info->idle_stats.xmit_idle = jiffies;
+        info->port.flags |= ASYNC_INITIALIZED;
 
-                spin_unlock_irqrestore(&card->card_lock, flags);
-        }
+        clear_bit(TTY_IO_ERROR, &tty->flags);
+        info->xmit_cnt = info->xmit_head = info->xmit_tail = 0;
+        info->breakon = info->breakoff = 0;
+        memset((char *)&info->idle_stats, 0, sizeof(info->idle_stats));
+        info->idle_stats.in_use =
+        info->idle_stats.recv_idle =
+        info->idle_stats.xmit_idle = jiffies;
+
+        spin_unlock_irqrestore(&card->card_lock, flags);
 
 #ifdef CY_DEBUG_OPEN
         printk(KERN_DEBUG "cyc startup done\n");
@@ -2003,28 +1413,20 @@ static int startup(struct cyclades_port *info)
 
 errout:
         spin_unlock_irqrestore(&card->card_lock, flags);
+        free_page(page);
         return retval;
 }                               /* startup */
 
 static void start_xmit(struct cyclades_port *info)
 {
-        struct cyclades_card *card;
+        struct cyclades_card *card = info->card;
         unsigned long flags;
-        void __iomem *base_addr;
-        int chip, channel, index;
+        int channel = info->line - card->first_line;
 
-        card = info->card;
-        channel = info->line - card->first_line;
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-
                 spin_lock_irqsave(&card->card_lock, flags);
-                cy_writeb(base_addr + (CyCAR << index), channel);
-                cy_writeb(base_addr + (CySRER << index),
-                        readb(base_addr + (CySRER << index)) | CyTxRdy);
+                cyy_writeb(info, CyCAR, channel & 0x03);
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
                 spin_unlock_irqrestore(&card->card_lock, flags);
         } else {
 #ifdef CONFIG_CYZ_INTR
@@ -2047,12 +1449,11 @@ static void start_xmit(struct cyclades_port *info)
  * This routine shuts down a serial port; interrupts are disabled,
  * and DTR is dropped if the hangup on close termio flag is on.
  */
-static void shutdown(struct cyclades_port *info)
+static void cy_shutdown(struct cyclades_port *info, struct tty_struct *tty)
 {
         struct cyclades_card *card;
         unsigned long flags;
-        void __iomem *base_addr;
-        int chip, channel, index;
+        int channel;
 
         if (!(info->port.flags & ASYNC_INITIALIZED))
                 return;
@@ -2060,21 +1461,10 @@ static void shutdown(struct cyclades_port *info)
         card = info->card;
         channel = info->line - card->first_line;
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-
-#ifdef CY_DEBUG_OPEN
-                printk(KERN_DEBUG "cyc shutdown Y card %d, chip %d, "
-                                "channel %d, base_addr %p\n",
-                                card, chip, channel, base_addr);
-#endif
-
                 spin_lock_irqsave(&card->card_lock, flags);
 
                 /* Clear delta_msr_wait queue to avoid mem leaks. */
-                wake_up_interruptible(&info->delta_msr_wait);
+                wake_up_interruptible(&info->port.delta_msr_wait);
 
                 if (info->port.xmit_buf) {
                         unsigned char *temp;
@@ -2082,47 +1472,25 @@ static void shutdown(struct cyclades_port *info)
                         info->port.xmit_buf = NULL;
                         free_page((unsigned long)temp);
                 }
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
-                if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) {
-                        cy_writeb(base_addr + (CyMSVR1 << index), ~CyRTS);
-                        cy_writeb(base_addr + (CyMSVR2 << index), ~CyDTR);
-#ifdef CY_DEBUG_DTR
-                        printk(KERN_DEBUG "cyc shutdown dropping DTR\n");
-                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                                readb(base_addr + (CyMSVR1 << index)),
-                                readb(base_addr + (CyMSVR2 << index)));
-#endif
-                }
-                cyy_issue_cmd(base_addr, CyCHAN_CTL | CyDIS_RCVR, index);
+                if (tty->termios->c_cflag & HUPCL)
+                        cyy_change_rts_dtr(info, 0, TIOCM_RTS | TIOCM_DTR);
+
+                cyy_issue_cmd(info, CyCHAN_CTL | CyDIS_RCVR);
                 /* it may be appropriate to clear _XMIT at
                    some later date (after testing)!!! */
 
-                if (info->port.tty)
-                        set_bit(TTY_IO_ERROR, &info->port.tty->flags);
+                set_bit(TTY_IO_ERROR, &tty->flags);
                 info->port.flags &= ~ASYNC_INITIALIZED;
                 spin_unlock_irqrestore(&card->card_lock, flags);
         } 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;
-                int retval;
-
-                base_addr = card->base_addr;
 #ifdef CY_DEBUG_OPEN
                 printk(KERN_DEBUG "cyc shutdown Z card %d, channel %d, "
-                        "base_addr %p\n", card, channel, base_addr);
+                        "base_addr %p\n", card, channel, card->base_addr);
 #endif
 
-                firm_id = base_addr + ID_ADDRESS;
                 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;
-
                 spin_lock_irqsave(&card->card_lock, flags);
 
                 if (info->port.xmit_buf) {
@@ -2132,23 +1500,10 @@ static void shutdown(struct cyclades_port *info)
                         free_page((unsigned long)temp);
                 }
 
-                if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) {
-                        cy_writel(&ch_ctrl[channel].rs_control,
-                                (__u32)(readl(&ch_ctrl[channel].rs_control) &
-                                        ~(C_RS_RTS | C_RS_DTR)));
-                        retval = cyz_issue_cmd(info->card, channel,
-                                        C_CM_IOCTLM, 0L);
-                        if (retval != 0) {
-                                printk(KERN_ERR"cyc:shutdown retval on ttyC%d "
-                                        "was %x\n", info->line, retval);
-                        }
-#ifdef CY_DEBUG_DTR
-                        printk(KERN_DEBUG "cyc:shutdown dropping Z DTR\n");
-#endif
-                }
+                if (tty->termios->c_cflag & HUPCL)
+                        tty_port_lower_dtr_rts(&info->port);
 
-                if (info->port.tty)
-                        set_bit(TTY_IO_ERROR, &info->port.tty->flags);
+                set_bit(TTY_IO_ERROR, &tty->flags);
                 info->port.flags &= ~ASYNC_INITIALIZED;
 
                 spin_unlock_irqrestore(&card->card_lock, flags);
@@ -2165,199 +1520,6 @@ static void shutdown(struct cyclades_port *info)
  * ------------------------------------------------------------
  */
 
-static int
-block_til_ready(struct tty_struct *tty, struct file *filp,
-                struct cyclades_port *info)
-{
-        DECLARE_WAITQUEUE(wait, current);
-        struct cyclades_card *cinfo;
-        unsigned long flags;
-        int chip, channel, index;
-        int retval;
-        void __iomem *base_addr;
-
-        cinfo = info->card;
-        channel = info->line - cinfo->first_line;
-
-        /*
-         * If the device is in the middle of being closed, then block
-         * until it's done, and then try again.
-         */
-        if (tty_hung_up_p(filp) || (info->port.flags & ASYNC_CLOSING)) {
-                wait_event_interruptible(info->port.close_wait,
-                                !(info->port.flags & ASYNC_CLOSING));
-                return (info->port.flags & ASYNC_HUP_NOTIFY) ? -EAGAIN: -ERESTARTSYS;
-        }
-
-        /*
-         * If non-blocking mode is set, then make the check up front
-         * and then exit.
-         */
-        if ((filp->f_flags & O_NONBLOCK) ||
-                                        (tty->flags & (1 << TTY_IO_ERROR))) {
-                info->port.flags |= ASYNC_NORMAL_ACTIVE;
-                return 0;
-        }
-
-        /*
-         * Block waiting for the carrier detect and the line to become
-         * free (i.e., not in use by the callout).  While we are in
-         * this loop, info->port.count is dropped by one, so that
-         * cy_close() knows when to free things.  We restore it upon
-         * exit, either normal or abnormal.
-         */
-        retval = 0;
-        add_wait_queue(&info->port.open_wait, &wait);
-#ifdef CY_DEBUG_OPEN
-        printk(KERN_DEBUG "cyc block_til_ready before block: ttyC%d, "
-                "count = %d\n", info->line, info->port.count);
-#endif
-        spin_lock_irqsave(&cinfo->card_lock, flags);
-        if (!tty_hung_up_p(filp))
-                info->port.count--;
-        spin_unlock_irqrestore(&cinfo->card_lock, flags);
-#ifdef CY_DEBUG_COUNT
-        printk(KERN_DEBUG "cyc block_til_ready: (%d): decrementing count to "
-                "%d\n", current->pid, info->port.count);
-#endif
-        info->port.blocked_open++;
-
-        if (!cy_is_Z(cinfo)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = cinfo->bus_index;
-                base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
-
-                while (1) {
-                        spin_lock_irqsave(&cinfo->card_lock, flags);
-                        if ((tty->termios->c_cflag & CBAUD)) {
-                                cy_writeb(base_addr + (CyCAR << index),
-                                          (u_char) channel);
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          CyRTS);
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          CyDTR);
-#ifdef CY_DEBUG_DTR
-                                printk(KERN_DEBUG "cyc:block_til_ready raising "
-                                        "DTR\n");
-                                printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                                        readb(base_addr + (CyMSVR1 << index)),
-                                        readb(base_addr + (CyMSVR2 << index)));
-#endif
-                        }
-                        spin_unlock_irqrestore(&cinfo->card_lock, flags);
-
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        if (tty_hung_up_p(filp) ||
-                                        !(info->port.flags & ASYNC_INITIALIZED)) {
-                                retval = ((info->port.flags & ASYNC_HUP_NOTIFY) ?
-                                          -EAGAIN : -ERESTARTSYS);
-                                break;
-                        }
-
-                        spin_lock_irqsave(&cinfo->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (!(info->port.flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
-                                        (readb(base_addr +
-                                                (CyMSVR1 << index)) & CyDCD))) {
-                                spin_unlock_irqrestore(&cinfo->card_lock, flags);
-                                break;
-                        }
-                        spin_unlock_irqrestore(&cinfo->card_lock, flags);
-
-                        if (signal_pending(current)) {
-                                retval = -ERESTARTSYS;
-                                break;
-                        }
-#ifdef CY_DEBUG_OPEN
-                        printk(KERN_DEBUG "cyc block_til_ready blocking: "
-                                "ttyC%d, count = %d\n",
-                                info->line, info->port.count);
-#endif
-                        schedule();
-                }
-        } 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;
-
-                base_addr = cinfo->base_addr;
-                firm_id = base_addr + ID_ADDRESS;
-                if (!cyz_is_loaded(cinfo)) {
-                        __set_current_state(TASK_RUNNING);
-                        remove_wait_queue(&info->port.open_wait, &wait);
-                        return -EINVAL;
-                }
-
-                zfw_ctrl = base_addr + (readl(&firm_id->zfwctrl_addr)
-                                                                & 0xfffff);
-                board_ctrl = &zfw_ctrl->board_ctrl;
-                ch_ctrl = zfw_ctrl->ch_ctrl;
-
-                while (1) {
-                        if ((tty->termios->c_cflag & CBAUD)) {
-                                cy_writel(&ch_ctrl[channel].rs_control,
-                                        readl(&ch_ctrl[channel].rs_control) |
-                                        C_RS_RTS | C_RS_DTR);
-                                retval = cyz_issue_cmd(cinfo,
-                                        channel, C_CM_IOCTLM, 0L);
-                                if (retval != 0) {
-                                        printk(KERN_ERR "cyc:block_til_ready "
-                                                "retval on ttyC%d was %x\n",
-                                                info->line, retval);
-                                }
-#ifdef CY_DEBUG_DTR
-                                printk(KERN_DEBUG "cyc:block_til_ready raising "
-                                        "Z DTR\n");
-#endif
-                        }
-
-                        set_current_state(TASK_INTERRUPTIBLE);
-                        if (tty_hung_up_p(filp) ||
-                                        !(info->port.flags & ASYNC_INITIALIZED)) {
-                                retval = ((info->port.flags & ASYNC_HUP_NOTIFY) ?
-                                          -EAGAIN : -ERESTARTSYS);
-                                break;
-                        }
-                        if (!(info->port.flags & ASYNC_CLOSING) && (C_CLOCAL(tty) ||
-                                        (readl(&ch_ctrl[channel].rs_status) &
-                                                C_RS_DCD))) {
-                                break;
-                        }
-                        if (signal_pending(current)) {
-                                retval = -ERESTARTSYS;
-                                break;
-                        }
-#ifdef CY_DEBUG_OPEN
-                        printk(KERN_DEBUG "cyc block_til_ready blocking: "
-                                "ttyC%d, count = %d\n",
-                                info->line, info->port.count);
-#endif
-                        schedule();
-                }
-        }
-        __set_current_state(TASK_RUNNING);
-        remove_wait_queue(&info->port.open_wait, &wait);
-        if (!tty_hung_up_p(filp)) {
-                info->port.count++;
-#ifdef CY_DEBUG_COUNT
-                printk(KERN_DEBUG "cyc:block_til_ready (%d): incrementing "
-                        "count to %d\n", current->pid, info->port.count);
-#endif
-        }
-        info->port.blocked_open--;
-#ifdef CY_DEBUG_OPEN
-        printk(KERN_DEBUG "cyc:block_til_ready after blocking: ttyC%d, "
-                "count = %d\n", info->line, info->port.count);
-#endif
-        if (retval)
-                return retval;
-        info->port.flags |= ASYNC_NORMAL_ACTIVE;
-        return 0;
-}                               /* block_til_ready */
-
 /*
  * This routine is called whenever a serial port is opened.  It
  * performs the serial-specific initialization for the tty structure.
@@ -2436,7 +1598,6 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
         printk(KERN_DEBUG "cyc:cy_open ttyC%d\n", info->line);
 #endif
         tty->driver_data = info;
-        info->port.tty = tty;
         if (serial_paranoia_check(info, tty->name, "cy_open"))
                 return -ENODEV;
 
@@ -2462,11 +1623,11 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
         /*
          * Start up serial port
          */
-        retval = startup(info);
+        retval = cy_startup(info, tty);
         if (retval)
                 return retval;
 
-        retval = block_til_ready(tty, filp, info);
+        retval = tty_port_block_til_ready(&info->port, tty, filp);
         if (retval) {
 #ifdef CY_DEBUG_OPEN
                 printk(KERN_DEBUG "cyc:cy_open returning after block_til_ready "
@@ -2476,6 +1637,7 @@ static int cy_open(struct tty_struct *tty, struct file *filp)
         }
 
         info->throttle = 0;
+        tty_port_tty_set(&info->port, tty);
 
 #ifdef CY_DEBUG_OPEN
         printk(KERN_DEBUG "cyc:cy_open done\n");
@@ -2490,8 +1652,6 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
 {
         struct cyclades_card *card;
         struct cyclades_port *info = tty->driver_data;
-        void __iomem *base_addr;
-        int chip, channel, index;
         unsigned long orig_jiffies;
         int char_time;
 
@@ -2535,13 +1695,8 @@ static void cy_wait_until_sent(struct tty_struct *tty, int timeout)
                 timeout, char_time, jiffies);
 #endif
         card = info->card;
-        channel = (info->line) - (card->first_line);
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-                while (readb(base_addr + (CySRER << index)) & CyTxRdy) {
+                while (cyy_readb(info, CySRER) & CyTxRdy) {
 #ifdef CY_DEBUG_WAIT_UNTIL_SENT
                         printk(KERN_DEBUG "Not clean (jiff=%lu)...", jiffies);
 #endif
@@ -2595,103 +1750,37 @@ static void cy_flush_buffer(struct tty_struct *tty)
 }                               /* cy_flush_buffer */
 
 
-/*
- * This routine is called when a particular tty device is closed.
- */
-static void cy_close(struct tty_struct *tty, struct file *filp)
+static void cy_do_close(struct tty_port *port)
 {
-        struct cyclades_port *info = tty->driver_data;
+        struct cyclades_port *info = container_of(port, struct cyclades_port,
+                                                                port);
         struct cyclades_card *card;
         unsigned long flags;
-
-#ifdef CY_DEBUG_OTHER
-        printk(KERN_DEBUG "cyc:cy_close ttyC%d\n", info->line);
-#endif
-
-        if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
-                return;
+        int channel;
 
         card = info->card;
-
-        spin_lock_irqsave(&card->card_lock, flags);
-        /* If the TTY is being hung up, nothing to do */
-        if (tty_hung_up_p(filp)) {
-                spin_unlock_irqrestore(&card->card_lock, flags);
-                return;
-        }
-#ifdef CY_DEBUG_OPEN
-        printk(KERN_DEBUG "cyc:cy_close ttyC%d, count = %d\n", info->line,
-                info->port.count);
-#endif
-        if ((tty->count == 1) && (info->port.count != 1)) {
-                /*
-                 * Uh, oh.  tty->count is 1, which means that the tty
-                 * structure will be freed.  Info->count should always
-                 * be one in these conditions.  If it's greater than
-                 * one, we've got real problems, since it means the
-                 * serial port won't be shutdown.
-                 */
-                printk(KERN_ERR "cyc:cy_close: bad serial port count; "
-                        "tty->count is 1, info->port.count is %d\n", info->port.count);
-                info->port.count = 1;
-        }
-#ifdef CY_DEBUG_COUNT
-        printk(KERN_DEBUG  "cyc:cy_close at (%d): decrementing count to %d\n",
-                current->pid, info->port.count - 1);
-#endif
-        if (--info->port.count < 0) {
-#ifdef CY_DEBUG_COUNT
-                printk(KERN_DEBUG "cyc:cyc_close setting count to 0\n");
-#endif
-                info->port.count = 0;
-        }
-        if (info->port.count) {
-                spin_unlock_irqrestore(&card->card_lock, flags);
-                return;
-        }
-        info->port.flags |= ASYNC_CLOSING;
-
-        /*
-         * Now we wait for the transmit buffer to clear; and we notify
-         * the line discipline to only process XON/XOFF characters.
-         */
-        tty->closing = 1;
-        spin_unlock_irqrestore(&card->card_lock, flags);
-        if (info->port.closing_wait != CY_CLOSING_WAIT_NONE)
-                tty_wait_until_sent(tty, info->port.closing_wait);
-
+        channel = info->line - card->first_line;
         spin_lock_irqsave(&card->card_lock, flags);
 
         if (!cy_is_Z(card)) {
-                int channel = info->line - card->first_line;
-                int index = card->bus_index;
-                void __iomem *base_addr = card->base_addr +
-                        (cy_chip_offset[channel >> 2] << index);
                 /* Stop accepting input */
-                channel &= 0x03;
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
-                cy_writeb(base_addr + (CySRER << index),
-                          readb(base_addr + (CySRER << index)) & ~CyRxData);
+                cyy_writeb(info, CyCAR, channel & 0x03);
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyRxData);
                 if (info->port.flags & ASYNC_INITIALIZED) {
                         /* Waiting for on-board buffers to be empty before
                            closing the port */
                         spin_unlock_irqrestore(&card->card_lock, flags);
-                        cy_wait_until_sent(tty, info->timeout);
+                        cy_wait_until_sent(port->tty, info->timeout);
                         spin_lock_irqsave(&card->card_lock, flags);
                 }
         } else {
 #ifdef Z_WAKE
                 /* Waiting for on-board buffers to be empty before closing
                    the port */
-                void __iomem *base_addr = card->base_addr;
-                struct FIRM_ID __iomem *firm_id = base_addr + ID_ADDRESS;
-                struct ZFW_CTRL __iomem *zfw_ctrl =
-                    base_addr + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                struct CH_CTRL __iomem *ch_ctrl = zfw_ctrl->ch_ctrl;
-                int channel = info->line - card->first_line;
+                struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
                 int retval;
 
-                if (readl(&ch_ctrl[channel].flow_status) != C_FS_TXIDLE) {
+                if (readl(&ch_ctrl->flow_status) != C_FS_TXIDLE) {
                         retval = cyz_issue_cmd(card, channel, C_CM_IOCTLW, 0L);
                         if (retval != 0) {
                                 printk(KERN_DEBUG "cyc:cy_close retval on "
@@ -2703,32 +1792,19 @@ static void cy_close(struct tty_struct *tty, struct file *filp)
                 }
 #endif
         }
-
         spin_unlock_irqrestore(&card->card_lock, flags);
-        shutdown(info);
-        cy_flush_buffer(tty);
-        tty_ldisc_flush(tty);
-        spin_lock_irqsave(&card->card_lock, flags);
-
-        tty->closing = 0;
-        info->port.tty = NULL;
-        if (info->port.blocked_open) {
-                spin_unlock_irqrestore(&card->card_lock, flags);
-                if (info->port.close_delay) {
-                        msleep_interruptible(jiffies_to_msecs
-                                                (info->port.close_delay));
-                }
-                wake_up_interruptible(&info->port.open_wait);
-                spin_lock_irqsave(&card->card_lock, flags);
-        }
-        info->port.flags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
-        wake_up_interruptible(&info->port.close_wait);
-
-#ifdef CY_DEBUG_OTHER
-        printk(KERN_DEBUG "cyc:cy_close done\n");
-#endif
+        cy_shutdown(info, port->tty);
+}
 
-        spin_unlock_irqrestore(&card->card_lock, flags);
+/*
+ * This routine is called when a particular tty device is closed.
+ */
+static void cy_close(struct tty_struct *tty, struct file *filp)
+{
+        struct cyclades_port *info = tty->driver_data;
+        if (!info || serial_paranoia_check(info, tty->name, "cy_close"))
+                return;
+        tty_port_close(&info->port, tty, filp);
 }                               /* cy_close */
 
 /* This routine gets called when tty_write has put something into
@@ -2871,18 +1947,13 @@ static int cy_write_room(struct tty_struct *tty)
 
 static int cy_chars_in_buffer(struct tty_struct *tty)
 {
-        struct cyclades_card *card;
         struct cyclades_port *info = tty->driver_data;
-        int channel;
 
         if (serial_paranoia_check(info, tty->name, "cy_chars_in_buffer"))
                 return 0;
 
-        card = info->card;
-        channel = (info->line) - (card->first_line);
-
 #ifdef Z_EXT_CHARS_IN_BUFFER
-        if (!cy_is_Z(card)) {
+        if (!cy_is_Z(info->card)) {
 #endif                          /* Z_EXT_CHARS_IN_BUFFER */
 #ifdef CY_DEBUG_IO
                 printk(KERN_DEBUG "cyc:cy_chars_in_buffer ttyC%d %d\n",
@@ -2891,20 +1962,11 @@ static int cy_chars_in_buffer(struct tty_struct *tty)
                 return info->xmit_cnt;
 #ifdef Z_EXT_CHARS_IN_BUFFER
         } else {
-                static struct FIRM_ID *firm_id;
-                static struct ZFW_CTRL *zfw_ctrl;
-                static struct CH_CTRL *ch_ctrl;
-                static struct BUF_CTRL *buf_ctrl;
+                struct BUF_CTRL __iomem *buf_ctrl = info->u.cyz.buf_ctrl;
                 int char_count;
                 __u32 tx_put, tx_get, tx_bufsize;
 
                 lock_kernel();
-                firm_id = card->base_addr + ID_ADDRESS;
-                zfw_ctrl = card->base_addr +
-                        (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-                buf_ctrl = &(zfw_ctrl->buf_ctrl[channel]);
-
                 tx_get = readl(&buf_ctrl->tx_get);
                 tx_put = readl(&buf_ctrl->tx_put);
                 tx_bufsize = readl(&buf_ctrl->tx_bufsize);
@@ -2957,48 +2019,44 @@ static void cyy_baud_calc(struct cyclades_port *info, __u32 baud)
  * This routine finds or computes the various line characteristics.
  * It used to be called config_setup
  */
-static void set_line_char(struct cyclades_port *info)
+static void cy_set_line_char(struct cyclades_port *info, struct tty_struct *tty)
 {
         struct cyclades_card *card;
         unsigned long flags;
-        void __iomem *base_addr;
-        int chip, channel, index;
+        int channel;
         unsigned cflag, iflag;
         int baud, baud_rate = 0;
         int i;
 
-        if (!info->port.tty || !info->port.tty->termios)
+        if (!tty->termios) /* XXX can this happen at all? */
                 return;
 
         if (info->line == -1)
                 return;
 
-        cflag = info->port.tty->termios->c_cflag;
-        iflag = info->port.tty->termios->c_iflag;
+        cflag = tty->termios->c_cflag;
+        iflag = tty->termios->c_iflag;
 
         /*
          * Set up the tty->alt_speed kludge
          */
-        if (info->port.tty) {
-                if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
-                        info->port.tty->alt_speed = 57600;
-                if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
-                        info->port.tty->alt_speed = 115200;
-                if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
-                        info->port.tty->alt_speed = 230400;
-                if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
-                        info->port.tty->alt_speed = 460800;
-        }
+        if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
+                tty->alt_speed = 57600;
+        if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
+                tty->alt_speed = 115200;
+        if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
+                tty->alt_speed = 230400;
+        if ((info->port.flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
+                tty->alt_speed = 460800;
 
         card = info->card;
         channel = info->line - card->first_line;
 
         if (!cy_is_Z(card)) {
-
-                index = card->bus_index;
+                u32 cflags;
 
                 /* baud rate */
-                baud = tty_get_baud_rate(info->port.tty);
+                baud = tty_get_baud_rate(tty);
                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
                                 ASYNC_SPD_CUST) {
                         if (info->custom_divisor)
@@ -3107,124 +2165,68 @@ static void set_line_char(struct cyclades_port *info)
             cable.  Contact Marcio Saito for details.
          ***********************************************/
 
-                chip = channel >> 2;
                 channel &= 0x03;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
 
                 spin_lock_irqsave(&card->card_lock, flags);
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
+                cyy_writeb(info, CyCAR, channel);
 
                 /* tx and rx baud rate */
 
-                cy_writeb(base_addr + (CyTCOR << index), info->tco);
-                cy_writeb(base_addr + (CyTBPR << index), info->tbpr);
-                cy_writeb(base_addr + (CyRCOR << index), info->rco);
-                cy_writeb(base_addr + (CyRBPR << index), info->rbpr);
+                cyy_writeb(info, CyTCOR, info->tco);
+                cyy_writeb(info, CyTBPR, info->tbpr);
+                cyy_writeb(info, CyRCOR, info->rco);
+                cyy_writeb(info, CyRBPR, info->rbpr);
 
                 /* set line characteristics  according configuration */
 
-                cy_writeb(base_addr + (CySCHR1 << index),
-                          START_CHAR(info->port.tty));
-                cy_writeb(base_addr + (CySCHR2 << index), STOP_CHAR(info->port.tty));
-                cy_writeb(base_addr + (CyCOR1 << index), info->cor1);
-                cy_writeb(base_addr + (CyCOR2 << index), info->cor2);
-                cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
-                cy_writeb(base_addr + (CyCOR4 << index), info->cor4);
-                cy_writeb(base_addr + (CyCOR5 << index), info->cor5);
+                cyy_writeb(info, CySCHR1, START_CHAR(tty));
+                cyy_writeb(info, CySCHR2, STOP_CHAR(tty));
+                cyy_writeb(info, CyCOR1, info->cor1);
+                cyy_writeb(info, CyCOR2, info->cor2);
+                cyy_writeb(info, CyCOR3, info->cor3);
+                cyy_writeb(info, CyCOR4, info->cor4);
+                cyy_writeb(info, CyCOR5, info->cor5);
 
-                cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
-                                CyCOR3ch, index);
+                cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR1ch | CyCOR2ch |
+                                CyCOR3ch);
 
                 /* !!! Is this needed? */
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
-                cy_writeb(base_addr + (CyRTPR << index),
+                cyy_writeb(info, CyCAR, channel);
+                cyy_writeb(info, CyRTPR,
                         (info->default_timeout ? info->default_timeout : 0x02));
                 /* 10ms rx timeout */
 
-                if (C_CLOCAL(info->port.tty)) {
-                        /* without modem intr */
-                        cy_writeb(base_addr + (CySRER << index),
-                                readb(base_addr + (CySRER << index)) | CyMdmCh);
-                        /* act on 1->0 modem transitions */
-                        if ((cflag & CRTSCTS) && info->rflow) {
-                                cy_writeb(base_addr + (CyMCOR1 << index),
-                                          (CyCTS | rflow_thr[i]));
-                        } else {
-                                cy_writeb(base_addr + (CyMCOR1 << index),
-                                          CyCTS);
-                        }
-                        /* act on 0->1 modem transitions */
-                        cy_writeb(base_addr + (CyMCOR2 << index), CyCTS);
-                } else {
-                        /* without modem intr */
-                        cy_writeb(base_addr + (CySRER << index),
-                                  readb(base_addr +
-                                           (CySRER << index)) | CyMdmCh);
-                        /* act on 1->0 modem transitions */
-                        if ((cflag & CRTSCTS) && info->rflow) {
-                                cy_writeb(base_addr + (CyMCOR1 << index),
-                                          (CyDSR | CyCTS | CyRI | CyDCD |
-                                           rflow_thr[i]));
-                        } else {
-                                cy_writeb(base_addr + (CyMCOR1 << index),
-                                          CyDSR | CyCTS | CyRI | CyDCD);
-                        }
-                        /* act on 0->1 modem transitions */
-                        cy_writeb(base_addr + (CyMCOR2 << index),
-                                  CyDSR | CyCTS | CyRI | CyDCD);
-                }
+                cflags = CyCTS;
+                if (!C_CLOCAL(tty))
+                        cflags |= CyDSR | CyRI | CyDCD;
+                /* without modem intr */
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyMdmCh);
+                /* act on 1->0 modem transitions */
+                if ((cflag & CRTSCTS) && info->rflow)
+                        cyy_writeb(info, CyMCOR1, cflags | rflow_thr[i]);
+                else
+                        cyy_writeb(info, CyMCOR1, cflags);
+                /* act on 0->1 modem transitions */
+                cyy_writeb(info, CyMCOR2, cflags);
 
-                if (i == 0) {   /* baud rate is zero, turn off line */
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          ~CyRTS);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          ~CyDTR);
-                        }
-#ifdef CY_DEBUG_DTR
-                        printk(KERN_DEBUG "cyc:set_line_char dropping DTR\n");
-                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                                readb(base_addr + (CyMSVR1 << index)),
-                                readb(base_addr + (CyMSVR2 << index)));
-#endif
-                } else {
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          CyRTS);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          CyDTR);
-                        }
-#ifdef CY_DEBUG_DTR
-                        printk(KERN_DEBUG "cyc:set_line_char raising DTR\n");
-                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                                readb(base_addr + (CyMSVR1 << index)),
-                                readb(base_addr + (CyMSVR2 << index)));
-#endif
-                }
+                if (i == 0)     /* baud rate is zero, turn off line */
+                        cyy_change_rts_dtr(info, 0, TIOCM_DTR);
+                else
+                        cyy_change_rts_dtr(info, TIOCM_DTR, 0);
 
-                if (info->port.tty)
-                        clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
+                clear_bit(TTY_IO_ERROR, &tty->flags);
                 spin_unlock_irqrestore(&card->card_lock, flags);
 
         } else {
-                struct FIRM_ID __iomem *firm_id;
-                struct ZFW_CTRL __iomem *zfw_ctrl;
-                struct CH_CTRL __iomem *ch_ctrl;
+                struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
                 __u32 sw_flow;
                 int retval;
 
-                firm_id = card->base_addr + ID_ADDRESS;
                 if (!cyz_is_loaded(card))
                         return;
 
-                zfw_ctrl = card->base_addr +
-                        (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                ch_ctrl = &(zfw_ctrl->ch_ctrl[channel]);
-
                 /* baud rate */
-                baud = tty_get_baud_rate(info->port.tty);
+                baud = tty_get_baud_rate(tty);
                 if (baud == 38400 && (info->port.flags & ASYNC_SPD_MASK) ==
                                 ASYNC_SPD_CUST) {
                         if (info->custom_divisor)
@@ -3335,45 +2337,38 @@ static void set_line_char(struct cyclades_port *info)
                                 "was %x\n", info->line, retval);
                 }
 
-                if (info->port.tty)
-                        clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
+                clear_bit(TTY_IO_ERROR, &tty->flags);
         }
 }                               /* set_line_char */
 
-static int
-get_serial_info(struct cyclades_port *info,
+static int cy_get_serial_info(struct cyclades_port *info,
                 struct serial_struct __user *retinfo)
 {
-        struct serial_struct tmp;
         struct cyclades_card *cinfo = info->card;
-
-        if (!retinfo)
-                return -EFAULT;
-        memset(&tmp, 0, sizeof(tmp));
-        tmp.type = info->type;
-        tmp.line = info->line;
-        tmp.port = (info->card - cy_card) * 0x100 + info->line -
-                cinfo->first_line;
-        tmp.irq = cinfo->irq;
-        tmp.flags = info->port.flags;
-        tmp.close_delay = info->port.close_delay;
-        tmp.closing_wait = info->port.closing_wait;
-        tmp.baud_base = info->baud;
-        tmp.custom_divisor = info->custom_divisor;
-        tmp.hub6 = 0;           /*!!! */
+        struct serial_struct tmp = {
+                .type = info->type,
+                .line = info->line,
+                .port = (info->card - cy_card) * 0x100 + info->line -
+                        cinfo->first_line,
+                .irq = cinfo->irq,
+                .flags = info->port.flags,
+                .close_delay = info->port.close_delay,
+                .closing_wait = info->port.closing_wait,
+                .baud_base = info->baud,
+                .custom_divisor = info->custom_divisor,
+                .hub6 = 0,              /*!!! */
+        };
         return copy_to_user(retinfo, &tmp, sizeof(*retinfo)) ? -EFAULT : 0;
-}                               /* get_serial_info */
+}
 
 static int
-set_serial_info(struct cyclades_port *info,
+cy_set_serial_info(struct cyclades_port *info, struct tty_struct *tty,
                 struct serial_struct __user *new_info)
 {
         struct serial_struct new_serial;
-        struct cyclades_port old_info;
 
         if (copy_from_user(&new_serial, new_info, sizeof(new_serial)))
                 return -EFAULT;
-        old_info = *info;
 
         if (!capable(CAP_SYS_ADMIN)) {
                 if (new_serial.close_delay != info->port.close_delay ||
@@ -3403,10 +2398,10 @@ set_serial_info(struct cyclades_port *info,
 
 check_and_exit:
         if (info->port.flags & ASYNC_INITIALIZED) {
-                set_line_char(info);
+                cy_set_line_char(info, tty);
                 return 0;
         } else {
-                return startup(info);
+                return cy_startup(info, tty);
         }
 }                               /* set_serial_info */
 
@@ -3422,24 +2417,14 @@ check_and_exit:
  */
 static int get_lsr_info(struct cyclades_port *info, unsigned int __user *value)
 {
-        struct cyclades_card *card;
-        int chip, channel, index;
-        unsigned char status;
+        struct cyclades_card *card = info->card;
         unsigned int result;
         unsigned long flags;
-        void __iomem *base_addr;
+        u8 status;
 
-        card = info->card;
-        channel = (info->line) - (card->first_line);
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-
                 spin_lock_irqsave(&card->card_lock, flags);
-                status = readb(base_addr + (CySRER << index)) &
-                                (CyTxRdy | CyTxMpty);
+                status = cyy_readb(info, CySRER) & (CyTxRdy | CyTxMpty);
                 spin_unlock_irqrestore(&card->card_lock, flags);
                 result = (status ? 0 : TIOCSER_TEMT);
         } else {
@@ -3453,34 +2438,23 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct cyclades_port *info = tty->driver_data;
         struct cyclades_card *card;
-        int chip, channel, index;
-        void __iomem *base_addr;
-        unsigned long flags;
-        unsigned char status;
-        unsigned long lstatus;
-        unsigned int result;
-        struct FIRM_ID __iomem *firm_id;
-        struct ZFW_CTRL __iomem *zfw_ctrl;
-        struct BOARD_CTRL __iomem *board_ctrl;
-        struct CH_CTRL __iomem *ch_ctrl;
+        int result;
 
         if (serial_paranoia_check(info, tty->name, __func__))
                 return -ENODEV;
 
-        lock_kernel();
-
         card = info->card;
-        channel = info->line - card->first_line;
+
+        lock_kernel();
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
+                unsigned long flags;
+                int channel = info->line - card->first_line;
+                u8 status;
 
                 spin_lock_irqsave(&card->card_lock, flags);
-                cy_writeb(base_addr + (CyCAR << index), (u_char) channel);
-                status = readb(base_addr + (CyMSVR1 << index));
-                status |= readb(base_addr + (CyMSVR2 << index));
+                cyy_writeb(info, CyCAR, channel & 0x03);
+                status = cyy_readb(info, CyMSVR1);
+                status |= cyy_readb(info, CyMSVR2);
                 spin_unlock_irqrestore(&card->card_lock, flags);
 
                 if (info->rtsdtr_inv) {
@@ -3495,27 +2469,22 @@ static int cy_tiocmget(struct tty_struct *tty, struct file *file)
                         ((status & CyDSR) ? TIOCM_DSR : 0) |
                         ((status & CyCTS) ? TIOCM_CTS : 0);
         } else {
-                base_addr = card->base_addr;
-                firm_id = card->base_addr + ID_ADDRESS;
-                if (cyz_is_loaded(card)) {
-                        zfw_ctrl = card->base_addr +
-                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                        board_ctrl = &zfw_ctrl->board_ctrl;
-                        ch_ctrl = zfw_ctrl->ch_ctrl;
-                        lstatus = readl(&ch_ctrl[channel].rs_status);
-                        result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
-                                ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
-                                ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
-                                ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
-                                ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
-                                ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
-                } else {
-                        result = 0;
-                        unlock_kernel();
-                        return -ENODEV;
+                u32 lstatus;
+
+                if (!cyz_is_loaded(card)) {
+                        result = -ENODEV;
+                        goto end;
                 }
 
+                lstatus = readl(&info->u.cyz.ch_ctrl->rs_status);
+                result = ((lstatus & C_RS_RTS) ? TIOCM_RTS : 0) |
+                        ((lstatus & C_RS_DTR) ? TIOCM_DTR : 0) |
+                        ((lstatus & C_RS_DCD) ? TIOCM_CAR : 0) |
+                        ((lstatus & C_RS_RI) ? TIOCM_RNG : 0) |
+                        ((lstatus & C_RS_DSR) ? TIOCM_DSR : 0) |
+                        ((lstatus & C_RS_CTS) ? TIOCM_CTS : 0);
         }
+end:
         unlock_kernel();
         return result;
 }                               /* cy_tiomget */
@@ -3526,150 +2495,53 @@ cy_tiocmset(struct tty_struct *tty, struct file *file,
 {
         struct cyclades_port *info = tty->driver_data;
         struct cyclades_card *card;
-        int chip, channel, index;
-        void __iomem *base_addr;
         unsigned long flags;
-        struct FIRM_ID __iomem *firm_id;
-        struct ZFW_CTRL __iomem *zfw_ctrl;
-        struct BOARD_CTRL __iomem *board_ctrl;
-        struct CH_CTRL __iomem *ch_ctrl;
-        int retval;
 
         if (serial_paranoia_check(info, tty->name, __func__))
                 return -ENODEV;
 
         card = info->card;
-        channel = (info->line) - (card->first_line);
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
+                spin_lock_irqsave(&card->card_lock, flags);
+                cyy_change_rts_dtr(info, set, clear);
+                spin_unlock_irqrestore(&card->card_lock, flags);
+        } else {
+                struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
+                int retval, channel = info->line - card->first_line;
+                u32 rs;
 
-                if (set & TIOCM_RTS) {
-                        spin_lock_irqsave(&card->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          CyDTR);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          CyRTS);
-                        }
-                        spin_unlock_irqrestore(&card->card_lock, flags);
-                }
-                if (clear & TIOCM_RTS) {
-                        spin_lock_irqsave(&card->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          ~CyDTR);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          ~CyRTS);
-                        }
-                        spin_unlock_irqrestore(&card->card_lock, flags);
-                }
+                if (!cyz_is_loaded(card))
+                        return -ENODEV;
+
+                spin_lock_irqsave(&card->card_lock, flags);
+                rs = readl(&ch_ctrl->rs_control);
+                if (set & TIOCM_RTS)
+                        rs |= C_RS_RTS;
+                if (clear & TIOCM_RTS)
+                        rs &= ~C_RS_RTS;
                 if (set & TIOCM_DTR) {
-                        spin_lock_irqsave(&card->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          CyRTS);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          CyDTR);
-                        }
+                        rs |= C_RS_DTR;
 #ifdef CY_DEBUG_DTR
-                        printk(KERN_DEBUG "cyc:set_modem_info raising DTR\n");
-                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                                readb(base_addr + (CyMSVR1 << index)),
-                                readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc:set_modem_info raising Z DTR\n");
 #endif
-                        spin_unlock_irqrestore(&card->card_lock, flags);
                 }
                 if (clear & TIOCM_DTR) {
-                        spin_lock_irqsave(&card->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          ~CyRTS);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          ~CyDTR);
-                        }
-
+                        rs &= ~C_RS_DTR;
 #ifdef CY_DEBUG_DTR
-                        printk(KERN_DEBUG "cyc:set_modem_info dropping DTR\n");
-                        printk(KERN_DEBUG "     status: 0x%x, 0x%x\n",
-                                readb(base_addr + (CyMSVR1 << index)),
-                                readb(base_addr + (CyMSVR2 << index)));
+                        printk(KERN_DEBUG "cyc:set_modem_info clearing "
+                                "Z DTR\n");
 #endif
-                        spin_unlock_irqrestore(&card->card_lock, flags);
                 }
-        } else {
-                base_addr = card->base_addr;
-
-                firm_id = card->base_addr + ID_ADDRESS;
-                if (cyz_is_loaded(card)) {
-                        zfw_ctrl = card->base_addr +
-                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
-                        board_ctrl = &zfw_ctrl->board_ctrl;
-                        ch_ctrl = zfw_ctrl->ch_ctrl;
-
-                        if (set & TIOCM_RTS) {
-                                spin_lock_irqsave(&card->card_lock, flags);
-                                cy_writel(&ch_ctrl[channel].rs_control,
-                                        readl(&ch_ctrl[channel].rs_control) |
-                                        C_RS_RTS);
-                                spin_unlock_irqrestore(&card->card_lock, flags);
-                        }
-                        if (clear & TIOCM_RTS) {
-                                spin_lock_irqsave(&card->card_lock, flags);
-                                cy_writel(&ch_ctrl[channel].rs_control,
-                                        readl(&ch_ctrl[channel].rs_control) &
-                                        ~C_RS_RTS);
-                                spin_unlock_irqrestore(&card->card_lock, flags);
-                        }
-                        if (set & TIOCM_DTR) {
-                                spin_lock_irqsave(&card->card_lock, flags);
-                                cy_writel(&ch_ctrl[channel].rs_control,
-                                        readl(&ch_ctrl[channel].rs_control) |
-                                        C_RS_DTR);
-#ifdef CY_DEBUG_DTR
-                                printk(KERN_DEBUG "cyc:set_modem_info raising "
-                                        "Z DTR\n");
-#endif
-                                spin_unlock_irqrestore(&card->card_lock, flags);
-                        }
-                        if (clear & TIOCM_DTR) {
-                                spin_lock_irqsave(&card->card_lock, flags);
-                                cy_writel(&ch_ctrl[channel].rs_control,
-                                        readl(&ch_ctrl[channel].rs_control) &
-                                        ~C_RS_DTR);
-#ifdef CY_DEBUG_DTR
-                                printk(KERN_DEBUG "cyc:set_modem_info clearing "
-                                        "Z DTR\n");
-#endif
-                                spin_unlock_irqrestore(&card->card_lock, flags);
-                        }
-                } else {
-                        return -ENODEV;
-                }
-                spin_lock_irqsave(&card->card_lock, flags);
+                cy_writel(&ch_ctrl->rs_control, rs);
                 retval = cyz_issue_cmd(card, channel, C_CM_IOCTLM, 0L);
+                spin_unlock_irqrestore(&card->card_lock, flags);
                 if (retval != 0) {
                         printk(KERN_ERR "cyc:set_modem_info retval on ttyC%d "
                                 "was %x\n", info->line, retval);
                 }
-                spin_unlock_irqrestore(&card->card_lock, flags);
         }
         return 0;
-}                               /* cy_tiocmset */
+}
 
 /*
  * cy_break() --- routine which turns the break handling on or off
@@ -3734,41 +2606,18 @@ static int cy_break(struct tty_struct *tty, int break_state)
         return retval;
 }                               /* cy_break */
 
-static int get_mon_info(struct cyclades_port *info,
-                                struct cyclades_monitor __user *mon)
-{
-
-        if (copy_to_user(mon, &info->mon, sizeof(struct cyclades_monitor)))
-                return -EFAULT;
-        info->mon.int_count = 0;
-        info->mon.char_count = 0;
-        info->mon.char_max = 0;
-        info->mon.char_last = 0;
-        return 0;
-}                               /* get_mon_info */
-
 static int set_threshold(struct cyclades_port *info, unsigned long value)
 {
-        struct cyclades_card *card;
-        void __iomem *base_addr;
-        int channel, chip, index;
+        struct cyclades_card *card = info->card;
         unsigned long flags;
 
-        card = info->card;
-        channel = info->line - card->first_line;
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr =
-                    card->base_addr + (cy_chip_offset[chip] << index);
-
                 info->cor3 &= ~CyREC_FIFO;
                 info->cor3 |= value & CyREC_FIFO;
 
                 spin_lock_irqsave(&card->card_lock, flags);
-                cy_writeb(base_addr + (CyCOR3 << index), info->cor3);
-                cyy_issue_cmd(base_addr, CyCOR_CHANGE | CyCOR3ch, index);
+                cyy_writeb(info, CyCOR3, info->cor3);
+                cyy_issue_cmd(info, CyCOR_CHANGE | CyCOR3ch);
                 spin_unlock_irqrestore(&card->card_lock, flags);
         }
         return 0;
@@ -3777,55 +2626,23 @@ static int set_threshold(struct cyclades_port *info, unsigned long value)
 static int get_threshold(struct cyclades_port *info,
                                                 unsigned long __user *value)
 {
-        struct cyclades_card *card;
-        void __iomem *base_addr;
-        int channel, chip, index;
-        unsigned long tmp;
+        struct cyclades_card *card = info->card;
 
-        card = info->card;
-        channel = info->line - card->first_line;
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-
-                tmp = readb(base_addr + (CyCOR3 << index)) & CyREC_FIFO;
+                u8 tmp = cyy_readb(info, CyCOR3) & CyREC_FIFO;
                 return put_user(tmp, value);
         }
         return 0;
 }                               /* get_threshold */
 
-static int set_default_threshold(struct cyclades_port *info,
-                                                        unsigned long value)
-{
-        info->default_threshold = value & 0x0f;
-        return 0;
-}                               /* set_default_threshold */
-
-static int get_default_threshold(struct cyclades_port *info,
-                                                unsigned long __user *value)
-{
-        return put_user(info->default_threshold, value);
-}                               /* get_default_threshold */
-
 static int set_timeout(struct cyclades_port *info, unsigned long value)
 {
-        struct cyclades_card *card;
-        void __iomem *base_addr;
-        int channel, chip, index;
+        struct cyclades_card *card = info->card;
         unsigned long flags;
 
-        card = info->card;
-        channel = info->line - card->first_line;
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-
                 spin_lock_irqsave(&card->card_lock, flags);
-                cy_writeb(base_addr + (CyRTPR << index), value & 0xff);
+                cyy_writeb(info, CyRTPR, value & 0xff);
                 spin_unlock_irqrestore(&card->card_lock, flags);
         }
         return 0;
@@ -3834,36 +2651,35 @@ static int set_timeout(struct cyclades_port *info, unsigned long value)
 static int get_timeout(struct cyclades_port *info,
                                                 unsigned long __user *value)
 {
-        struct cyclades_card *card;
-        void __iomem *base_addr;
-        int channel, chip, index;
-        unsigned long tmp;
+        struct cyclades_card *card = info->card;
 
-        card = info->card;
-        channel = info->line - card->first_line;
         if (!cy_is_Z(card)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                index = card->bus_index;
-                base_addr = card->base_addr + (cy_chip_offset[chip] << index);
-
-                tmp = readb(base_addr + (CyRTPR << index));
+                u8 tmp = cyy_readb(info, CyRTPR);
                 return put_user(tmp, value);
         }
         return 0;
 }                               /* get_timeout */
 
-static int set_default_timeout(struct cyclades_port *info, unsigned long value)
+static int cy_cflags_changed(struct cyclades_port *info, unsigned long arg,
+                struct cyclades_icount *cprev)
 {
-        info->default_timeout = value & 0xff;
-        return 0;
-}                               /* set_default_timeout */
+        struct cyclades_icount cnow;
+        unsigned long flags;
+        int ret;
 
-static int get_default_timeout(struct cyclades_port *info,
-                                        unsigned long __user *value)
-{
-        return put_user(info->default_timeout, value);
-}                               /* get_default_timeout */
+        spin_lock_irqsave(&info->card->card_lock, flags);
+        cnow = info->icount;    /* atomic copy */
+        spin_unlock_irqrestore(&info->card->card_lock, flags);
+
+        ret =   ((arg & TIOCM_RNG) && (cnow.rng != cprev->rng)) ||
+                ((arg & TIOCM_DSR) && (cnow.dsr != cprev->dsr)) ||
+                ((arg & TIOCM_CD)  && (cnow.dcd != cprev->dcd)) ||
+                ((arg & TIOCM_CTS) && (cnow.cts != cprev->cts));
+
+        *cprev = cnow;
+
+        return ret;
+}
 
 /*
  * This routine allows the tty driver to implement device-
@@ -3875,8 +2691,7 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
          unsigned int cmd, unsigned long arg)
 {
         struct cyclades_port *info = tty->driver_data;
-        struct cyclades_icount cprev, cnow;     /* kernel counter temps */
-        struct serial_icounter_struct __user *p_cuser;  /* user space */
+        struct cyclades_icount cnow;    /* kernel counter temps */
         int ret_val = 0;
         unsigned long flags;
         void __user *argp = (void __user *)arg;
@@ -3892,7 +2707,11 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
 
         switch (cmd) {
         case CYGETMON:
-                ret_val = get_mon_info(info, argp);
+                if (copy_to_user(argp, &info->mon, sizeof(info->mon))) {
+                        ret_val = -EFAULT;
+                        break;
+                }
+                memset(&info->mon, 0, sizeof(info->mon));
                 break;
         case CYGETTHRESH:
                 ret_val = get_threshold(info, argp);
@@ -3901,10 +2720,11 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                 ret_val = set_threshold(info, arg);
                 break;
         case CYGETDEFTHRESH:
-                ret_val = get_default_threshold(info, argp);
+                ret_val = put_user(info->default_threshold,
+                                (unsigned long __user *)argp);
                 break;
         case CYSETDEFTHRESH:
-                ret_val = set_default_threshold(info, arg);
+                info->default_threshold = arg & 0x0f;
                 break;
         case CYGETTIMEOUT:
                 ret_val = get_timeout(info, argp);
@@ -3913,21 +2733,20 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                 ret_val = set_timeout(info, arg);
                 break;
         case CYGETDEFTIMEOUT:
-                ret_val = get_default_timeout(info, argp);
+                ret_val = put_user(info->default_timeout,
+                                (unsigned long __user *)argp);
                 break;
         case CYSETDEFTIMEOUT:
-                ret_val = set_default_timeout(info, arg);
+                info->default_timeout = arg & 0xff;
                 break;
         case CYSETRFLOW:
                 info->rflow = (int)arg;
-                ret_val = 0;
                 break;
         case CYGETRFLOW:
                 ret_val = info->rflow;
                 break;
         case CYSETRTSDTR_INV:
                 info->rtsdtr_inv = (int)arg;
-                ret_val = 0;
                 break;
         case CYGETRTSDTR_INV:
                 ret_val = info->rtsdtr_inv;
@@ -3938,7 +2757,6 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
 #ifndef CONFIG_CYZ_INTR
         case CYZSETPOLLCYCLE:
                 cyz_polling_cycle = (arg * HZ) / 1000;
-                ret_val = 0;
                 break;
         case CYZGETPOLLCYCLE:
                 ret_val = (cyz_polling_cycle * 1000) / HZ;
@@ -3946,16 +2764,15 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
 #endif                          /* CONFIG_CYZ_INTR */
         case CYSETWAIT:
                 info->port.closing_wait = (unsigned short)arg * HZ / 100;
-                ret_val = 0;
                 break;
         case CYGETWAIT:
                 ret_val = info->port.closing_wait / (HZ / 100);
                 break;
         case TIOCGSERIAL:
-                ret_val = get_serial_info(info, argp);
+                ret_val = cy_get_serial_info(info, argp);
                 break;
         case TIOCSSERIAL:
-                ret_val = set_serial_info(info, argp);
+                ret_val = cy_set_serial_info(info, tty, argp);
                 break;
         case TIOCSERGETLSR:     /* Get line status register */
                 ret_val = get_lsr_info(info, argp);
@@ -3971,17 +2788,8 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                 /* note the counters on entry */
                 cnow = info->icount;
                 spin_unlock_irqrestore(&info->card->card_lock, flags);
-                ret_val = wait_event_interruptible(info->delta_msr_wait, ({
-                        cprev = cnow;
-                        spin_lock_irqsave(&info->card->card_lock, flags);
-                        cnow = info->icount;    /* atomic copy */
-                        spin_unlock_irqrestore(&info->card->card_lock, flags);
-
-                        ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
-                        ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
-                        ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
-                        ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts));
-                }));
+                ret_val = wait_event_interruptible(info->port.delta_msr_wait,
+                                cy_cflags_changed(info, arg, &cnow));
                 break;
 
                 /*
@@ -3990,46 +2798,29 @@ cy_ioctl(struct tty_struct *tty, struct file *file,
                  * NB: both 1->0 and 0->1 transitions are counted except for
                  *     RI where only 0->1 is counted.
                  */
-        case TIOCGICOUNT:
+        case TIOCGICOUNT: {
+                struct serial_icounter_struct sic = { };
+
                 spin_lock_irqsave(&info->card->card_lock, flags);
                 cnow = info->icount;
                 spin_unlock_irqrestore(&info->card->card_lock, flags);
-                p_cuser = argp;
-                ret_val = put_user(cnow.cts, &p_cuser->cts);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.dsr, &p_cuser->dsr);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.rng, &p_cuser->rng);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.dcd, &p_cuser->dcd);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.rx, &p_cuser->rx);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.tx, &p_cuser->tx);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.frame, &p_cuser->frame);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.overrun, &p_cuser->overrun);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.parity, &p_cuser->parity);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.brk, &p_cuser->brk);
-                if (ret_val)
-                        break;
-                ret_val = put_user(cnow.buf_overrun, &p_cuser->buf_overrun);
-                if (ret_val)
-                        break;
-                ret_val = 0;
+
+                sic.cts = cnow.cts;
+                sic.dsr = cnow.dsr;
+                sic.rng = cnow.rng;
+                sic.dcd = cnow.dcd;
+                sic.rx = cnow.rx;
+                sic.tx = cnow.tx;
+                sic.frame = cnow.frame;
+                sic.overrun = cnow.overrun;
+                sic.parity = cnow.parity;
+                sic.brk = cnow.brk;
+                sic.buf_overrun = cnow.buf_overrun;
+
+                if (copy_to_user(argp, &sic, sizeof(sic)))
+                        ret_val = -EFAULT;
                 break;
+        }
         default:
                 ret_val = -ENOIOCTLCMD;
         }
@@ -4055,7 +2846,7 @@ static void cy_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
         printk(KERN_DEBUG "cyc:cy_set_termios ttyC%d\n", info->line);
 #endif
 
-        set_line_char(info);
+        cy_set_line_char(info, tty);
 
         if ((old_termios->c_cflag & CRTSCTS) &&
                         !(tty->termios->c_cflag & CRTSCTS)) {
@@ -4112,8 +2903,6 @@ static void cy_throttle(struct tty_struct *tty)
         struct cyclades_port *info = tty->driver_data;
         struct cyclades_card *card;
         unsigned long flags;
-        void __iomem *base_addr;
-        int chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
         char buf[64];
@@ -4135,24 +2924,9 @@ static void cy_throttle(struct tty_struct *tty)
         }
 
         if (tty->termios->c_cflag & CRTSCTS) {
-                channel = info->line - card->first_line;
                 if (!cy_is_Z(card)) {
-                        chip = channel >> 2;
-                        channel &= 0x03;
-                        index = card->bus_index;
-                        base_addr = card->base_addr +
-                                (cy_chip_offset[chip] << index);
-
                         spin_lock_irqsave(&card->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          ~CyDTR);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          ~CyRTS);
-                        }
+                        cyy_change_rts_dtr(info, 0, TIOCM_RTS);
                         spin_unlock_irqrestore(&card->card_lock, flags);
                 } else {
                         info->throttle = 1;
@@ -4170,8 +2944,6 @@ static void cy_unthrottle(struct tty_struct *tty)
         struct cyclades_port *info = tty->driver_data;
         struct cyclades_card *card;
         unsigned long flags;
-        void __iomem *base_addr;
-        int chip, channel, index;
 
 #ifdef CY_DEBUG_THROTTLE
         char buf[64];
@@ -4192,24 +2964,9 @@ static void cy_unthrottle(struct tty_struct *tty)
 
         if (tty->termios->c_cflag & CRTSCTS) {
                 card = info->card;
-                channel = info->line - card->first_line;
                 if (!cy_is_Z(card)) {
-                        chip = channel >> 2;
-                        channel &= 0x03;
-                        index = card->bus_index;
-                        base_addr = card->base_addr +
-                                (cy_chip_offset[chip] << index);
-
                         spin_lock_irqsave(&card->card_lock, flags);
-                        cy_writeb(base_addr + (CyCAR << index),
-                                  (u_char) channel);
-                        if (info->rtsdtr_inv) {
-                                cy_writeb(base_addr + (CyMSVR2 << index),
-                                          CyDTR);
-                        } else {
-                                cy_writeb(base_addr + (CyMSVR1 << index),
-                                          CyRTS);
-                        }
+                        cyy_change_rts_dtr(info, TIOCM_RTS, 0);
                         spin_unlock_irqrestore(&card->card_lock, flags);
                 } else {
                         info->throttle = 0;
@@ -4224,8 +2981,7 @@ static void cy_stop(struct tty_struct *tty)
 {
         struct cyclades_card *cinfo;
         struct cyclades_port *info = tty->driver_data;
-        void __iomem *base_addr;
-        int chip, channel, index;
+        int channel;
         unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
@@ -4238,16 +2994,9 @@ static void cy_stop(struct tty_struct *tty)
         cinfo = info->card;
         channel = info->line - cinfo->first_line;
         if (!cy_is_Z(cinfo)) {
-                index = cinfo->bus_index;
-                chip = channel >> 2;
-                channel &= 0x03;
-                base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
-
                 spin_lock_irqsave(&cinfo->card_lock, flags);
-                cy_writeb(base_addr + (CyCAR << index),
-                        (u_char)(channel & 0x0003)); /* index channel */
-                cy_writeb(base_addr + (CySRER << index),
-                          readb(base_addr + (CySRER << index)) & ~CyTxRdy);
+                cyy_writeb(info, CyCAR, channel & 0x03);
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) & ~CyTxRdy);
                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
         }
 }                               /* cy_stop */
@@ -4256,8 +3005,7 @@ static void cy_start(struct tty_struct *tty)
 {
         struct cyclades_card *cinfo;
         struct cyclades_port *info = tty->driver_data;
-        void __iomem *base_addr;
-        int chip, channel, index;
+        int channel;
         unsigned long flags;
 
 #ifdef CY_DEBUG_OTHER
@@ -4269,17 +3017,10 @@ static void cy_start(struct tty_struct *tty)
 
         cinfo = info->card;
         channel = info->line - cinfo->first_line;
-        index = cinfo->bus_index;
         if (!cy_is_Z(cinfo)) {
-                chip = channel >> 2;
-                channel &= 0x03;
-                base_addr = cinfo->base_addr + (cy_chip_offset[chip] << index);
-
                 spin_lock_irqsave(&cinfo->card_lock, flags);
-                cy_writeb(base_addr + (CyCAR << index),
-                        (u_char) (channel & 0x0003));   /* index channel */
-                cy_writeb(base_addr + (CySRER << index),
-                          readb(base_addr + (CySRER << index)) | CyTxRdy);
+                cyy_writeb(info, CyCAR, channel & 0x03);
+                cyy_writeb(info, CySRER, cyy_readb(info, CySRER) | CyTxRdy);
                 spin_unlock_irqrestore(&cinfo->card_lock, flags);
         }
 }                               /* cy_start */
@@ -4299,17 +3040,84 @@ static void cy_hangup(struct tty_struct *tty)
                 return;
 
         cy_flush_buffer(tty);
-        shutdown(info);
-        info->port.count = 0;
-#ifdef CY_DEBUG_COUNT
-        printk(KERN_DEBUG "cyc:cy_hangup (%d): setting count to 0\n",
-                current->pid);
-#endif
-        info->port.tty = NULL;
-        info->port.flags &= ~ASYNC_NORMAL_ACTIVE;
-        wake_up_interruptible(&info->port.open_wait);
+        cy_shutdown(info, tty);
+        tty_port_hangup(&info->port);
 }                               /* cy_hangup */
 
+static int cyy_carrier_raised(struct tty_port *port)
+{
+        struct cyclades_port *info = container_of(port, struct cyclades_port,
+                        port);
+        struct cyclades_card *cinfo = info->card;
+        unsigned long flags;
+        int channel = info->line - cinfo->first_line;
+        u32 cd;
+
+        spin_lock_irqsave(&cinfo->card_lock, flags);
+        cyy_writeb(info, CyCAR, channel & 0x03);
+        cd = cyy_readb(info, CyMSVR1) & CyDCD;
+        spin_unlock_irqrestore(&cinfo->card_lock, flags);
+
+        return cd;
+}
+
+static void cyy_dtr_rts(struct tty_port *port, int raise)
+{
+        struct cyclades_port *info = container_of(port, struct cyclades_port,
+                        port);
+        struct cyclades_card *cinfo = info->card;
+        unsigned long flags;
+
+        spin_lock_irqsave(&cinfo->card_lock, flags);
+        cyy_change_rts_dtr(info, raise ? TIOCM_RTS | TIOCM_DTR : 0,
+                        raise ? 0 : TIOCM_RTS | TIOCM_DTR);
+        spin_unlock_irqrestore(&cinfo->card_lock, flags);
+}
+
+static int cyz_carrier_raised(struct tty_port *port)
+{
+        struct cyclades_port *info = container_of(port, struct cyclades_port,
+                        port);
+
+        return readl(&info->u.cyz.ch_ctrl->rs_status) & C_RS_DCD;
+}
+
+static void cyz_dtr_rts(struct tty_port *port, int raise)
+{
+        struct cyclades_port *info = container_of(port, struct cyclades_port,
+                        port);
+        struct cyclades_card *cinfo = info->card;
+        struct CH_CTRL __iomem *ch_ctrl = info->u.cyz.ch_ctrl;
+        int ret, channel = info->line - cinfo->first_line;
+        u32 rs;
+
+        rs = readl(&ch_ctrl->rs_control);
+        if (raise)
+                rs |= C_RS_RTS | C_RS_DTR;
+        else
+                rs &= ~(C_RS_RTS | C_RS_DTR);
+        cy_writel(&ch_ctrl->rs_control, rs);
+        ret = cyz_issue_cmd(cinfo, channel, C_CM_IOCTLM, 0L);
+        if (ret != 0)
+                printk(KERN_ERR "%s: retval on ttyC%d was %x\n",
+                                __func__, info->line, ret);
+#ifdef CY_DEBUG_DTR
+        printk(KERN_DEBUG "%s: raising Z DTR\n", __func__);
+#endif
+}
+
+static const struct tty_port_operations cyy_port_ops = {
+        .carrier_raised = cyy_carrier_raised,
+        .dtr_rts = cyy_dtr_rts,
+        .shutdown = cy_do_close,
+};
+
+static const struct tty_port_operations cyz_port_ops = {
+        .carrier_raised = cyz_carrier_raised,
+        .dtr_rts = cyz_dtr_rts,
+        .shutdown = cy_do_close,
+};
+
 /*
  * ---------------------------------------------------------------------
  * cy_init() and friends
@@ -4321,8 +3129,7 @@ static void cy_hangup(struct tty_struct *tty)
 static int __devinit cy_init_card(struct cyclades_card *cinfo)
 {
         struct cyclades_port *info;
-        unsigned int port;
-        unsigned short chip_number;
+        unsigned int channel, port;
 
         spin_lock_init(&cinfo->card_lock);
         cinfo->intr_enabled = 0;
@@ -4334,9 +3141,9 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
                 return -ENOMEM;
         }
 
-        for (port = cinfo->first_line; port < cinfo->first_line + cinfo->nports;
-                        port++) {
-                info = &cinfo->ports[port - cinfo->first_line];
+        for (channel = 0, port = cinfo->first_line; channel < cinfo->nports;
+                        channel++, port++) {
+                info = &cinfo->ports[channel];
                 tty_port_init(&info->port);
                 info->magic = CYCLADES_MAGIC;
                 info->card = cinfo;
@@ -4346,10 +3153,19 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
                 info->port.close_delay = 5 * HZ / 10;
                 info->port.flags = STD_COM_FLAGS;
                 init_completion(&info->shutdown_wait);
-                init_waitqueue_head(&info->delta_msr_wait);
 
                 if (cy_is_Z(cinfo)) {
+                        struct FIRM_ID *firm_id = cinfo->base_addr + ID_ADDRESS;
+                        struct ZFW_CTRL *zfw_ctrl;
+
+                        info->port.ops = &cyz_port_ops;
                         info->type = PORT_STARTECH;
+
+                        zfw_ctrl = cinfo->base_addr +
+                                (readl(&firm_id->zfwctrl_addr) & 0xfffff);
+                        info->u.cyz.ch_ctrl = &zfw_ctrl->ch_ctrl[channel];
+                        info->u.cyz.buf_ctrl = &zfw_ctrl->buf_ctrl[channel];
+
                         if (cinfo->hw_ver == ZO_V1)
                                 info->xmit_fifo_size = CYZ_FIFO_SIZE;
                         else
@@ -4359,17 +3175,20 @@ static int __devinit cy_init_card(struct cyclades_card *cinfo)
                                 cyz_rx_restart, (unsigned long)info);
 #endif
                 } else {
+                        unsigned short chip_number;
                         int index = cinfo->bus_index;
+
+                        info->port.ops = &cyy_port_ops;
                         info->type = PORT_CIRRUS;
                         info->xmit_fifo_size = CyMAX_CHAR_FIFO;
                         info->cor1 = CyPARITY_NONE | Cy_1_STOP | Cy_8_BITS;
                         info->cor2 = CyETC;
                         info->cor3 = 0x08;      /* _very_ small rcv threshold */
 
-                        chip_number = (port - cinfo->first_line) / 4;
-                        info->chip_rev = readb(cinfo->base_addr +
-                                      (cy_chip_offset[chip_number] << index) +
-                                      (CyGFRCR << index));
+                        chip_number = channel / CyPORTS_PER_CHIP;
+                        info->u.cyy.base_addr = cinfo->base_addr +
+                                (cy_chip_offset[chip_number] << index);
+                        info->chip_rev = cyy_readb(info, CyGFRCR);
 
                         if (info->chip_rev >= CD1400_REV_J) {
                                 /* It is a CD1400 rev. J or later */
@@ -5060,8 +3879,14 @@ static int __devinit cy_pci_probe(struct pci_dev *pdev,
                 }
                 cy_card[card_no].num_chips = nchan / CyPORTS_PER_CHIP;
         } else {
+                struct FIRM_ID __iomem *firm_id = addr2 + ID_ADDRESS;
+                struct ZFW_CTRL __iomem *zfw_ctrl;
+
+                zfw_ctrl = addr2 + (readl(&firm_id->zfwctrl_addr) & 0xfffff);
+
                 cy_card[card_no].hw_ver = mailbox;
                 cy_card[card_no].num_chips = (unsigned int)-1;
+                cy_card[card_no].board_ctrl = &zfw_ctrl->board_ctrl;
 #ifdef CONFIG_CYZ_INTR
                 /* allocate IRQ only if board has an IRQ */
                 if (irq != 0 && irq != 255) {
@@ -5191,18 +4016,30 @@ static int cyclades_proc_show(struct seq_file *m, void *v)
                 for (j = 0; j < cy_card[i].nports; j++) {
                         info = &cy_card[i].ports[j];
 
-                        if (info->port.count)
+                        if (info->port.count) {
+                                /* XXX is the ldisc num worth this? */
+                                struct tty_struct *tty;
+                                struct tty_ldisc *ld;
+                                int num = 0;
+                                tty = tty_port_tty_get(&info->port);
+                                if (tty) {
+                                        ld = tty_ldisc_ref(tty);
+                                        if (ld) {
+                                                num = ld->ops->num;
+                                                tty_ldisc_deref(ld);
+                                        }
+                                        tty_kref_put(tty);
+                                }
                                 seq_printf(m, "%3d %8lu %10lu %8lu "
-                                        "%10lu %8lu %9lu %6ld\n", info->line,
+                                        "%10lu %8lu %9lu %6d\n", info->line,
                                         (cur_jifs - info->idle_stats.in_use) /
                                         HZ, info->idle_stats.xmit_bytes,
                                         (cur_jifs - info->idle_stats.xmit_idle)/
                                         HZ, info->idle_stats.recv_bytes,
                                         (cur_jifs - info->idle_stats.recv_idle)/
                                         HZ, info->idle_stats.overruns,
-                                        /* FIXME: double check locking */
-                                        (long)info->port.tty->ldisc->ops->num);
-                        else
+                                        num);
+                        } else
                                 seq_printf(m, "%3d %8lu %10lu %8lu "
                                         "%10lu %8lu %9lu %6ld\n",
                                         info->line, 0L, 0L, 0L, 0L, 0L, 0L, 0L);
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index a5c59fc2b0ff..b19d43cd9542 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -572,7 +572,7 @@ static void check_modem_status(struct esp_struct *info)
                         info->icount.dcd++;
                 if (status & UART_MSR_DCTS)
                         info->icount.cts++;
-                wake_up_interruptible(&info->delta_msr_wait);
+                wake_up_interruptible(&info->port.delta_msr_wait);
         }
 
         if ((info->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
@@ -927,7 +927,7 @@ static void shutdown(struct esp_struct *info)
          * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
          * here so the queue might never be waken up
          */
-        wake_up_interruptible(&info->delta_msr_wait);
+        wake_up_interruptible(&info->port.delta_msr_wait);
         wake_up_interruptible(&info->break_wait);
 
         /* stop a DMA transfer on the port being closed */
@@ -1800,7 +1800,7 @@ static int rs_ioctl(struct tty_struct *tty, struct file *file,
                 spin_unlock_irqrestore(&info->lock, flags);
                 while (1) {
                         /* FIXME: convert to new style wakeup */
-                        interruptible_sleep_on(&info->delta_msr_wait);
+                        interruptible_sleep_on(&info->port.delta_msr_wait);
                         /* see if a signal did it */
                         if (signal_pending(current))
                                 return -ERESTARTSYS;
@@ -2452,7 +2452,6 @@ static int __init espserial_init(void)
                 info->config.flow_off = flow_off;
                 info->config.pio_threshold = pio_threshold;
                 info->next_port = ports;
-                init_waitqueue_head(&info->delta_msr_wait);
                 init_waitqueue_head(&info->break_wait);
                 ports = info;
                 printk(KERN_INFO "ttyP%d at 0x%04x (irq = %d) is an ESP ",
diff --git a/drivers/char/hw_random/core.c b/drivers/char/hw_random/core.c
index fc93e2fc7c71..1573aebd54b5 100644
--- a/drivers/char/hw_random/core.c
+++ b/drivers/char/hw_random/core.c
@@ -153,7 +153,7 @@ static const struct file_operations rng_chrdev_ops = {
 static struct miscdevice rng_miscdev = {
         .minor          = RNG_MISCDEV_MINOR,
         .name           = RNG_MODULE_NAME,
-        .devnode        = "hwrng",
+        .nodename       = "hwrng",
         .fops           = &rng_chrdev_ops,
 };
 
diff --git a/drivers/char/isicom.c b/drivers/char/isicom.c
index 4f1f4cd670da..426bfdd7f3e0 100644
--- a/drivers/char/isicom.c
+++ b/drivers/char/isicom.c
@@ -846,37 +846,53 @@ static int isicom_carrier_raised(struct tty_port *port)
         return (ip->status & ISI_DCD)?1 : 0;
 }
 
-static int isicom_open(struct tty_struct *tty, struct file *filp)
+static struct tty_port *isicom_find_port(struct tty_struct *tty)
 {
         struct isi_port *port;
         struct isi_board *card;
         unsigned int board;
-        int error, line;
+        int line = tty->index;
 
-        line = tty->index;
         if (line < 0 || line > PORT_COUNT-1)
-                return -ENODEV;
+                return NULL;
         board = BOARD(line);
         card = &isi_card[board];
 
         if (!(card->status & FIRMWARE_LOADED))
-                return -ENODEV;
+                return NULL;
 
         /*  open on a port greater than the port count for the card !!! */
         if (line > ((board * 16) + card->port_count - 1))
-                return -ENODEV;
+                return NULL;
 
         port = &isi_ports[line];
         if (isicom_paranoia_check(port, tty->name, "isicom_open"))
-                return -ENODEV;
+                return NULL;
 
+        return &port->port;
+}
+        
+static int isicom_open(struct tty_struct *tty, struct file *filp)
+{
+        struct isi_port *port;
+        struct isi_board *card;
+        struct tty_port *tport;
+        int error = 0;
+
+        tport = isicom_find_port(tty);
+        if (tport == NULL)
+                return -ENODEV;
+        port = container_of(tport, struct isi_port, port);
+        card = &isi_card[BOARD(tty->index)];
         isicom_setup_board(card);
 
         /* FIXME: locking on port.count etc */
         port->port.count++;
         tty->driver_data = port;
         tty_port_tty_set(&port->port, tty);
-        error = isicom_setup_port(tty);
+        /* FIXME: Locking on Initialized flag */
+        if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
+                error = isicom_setup_port(tty);
         if (error == 0)
                 error = tty_port_block_til_ready(&port->port, tty, filp);
         return error;
@@ -952,19 +968,12 @@ static void isicom_flush_buffer(struct tty_struct *tty)
         tty_wakeup(tty);
 }
 
-static void isicom_close(struct tty_struct *tty, struct file *filp)
+static void isicom_close_port(struct tty_port *port)
 {
-        struct isi_port *ip = tty->driver_data;
-        struct tty_port *port = &ip->port;
-        struct isi_board *card;
+        struct isi_port *ip = container_of(port, struct isi_port, port);
+        struct isi_board *card = ip->card;
         unsigned long flags;
 
-        BUG_ON(!ip);
-
-        card = ip->card;
-        if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
-                return;
-
         /* indicate to the card that no more data can be received
            on this port */
         spin_lock_irqsave(&card->card_lock, flags);
@@ -974,9 +983,19 @@ static void isicom_close(struct tty_struct *tty, struct file *filp)
         }
         isicom_shutdown_port(ip);
         spin_unlock_irqrestore(&card->card_lock, flags);
+}
+
+static void isicom_close(struct tty_struct *tty, struct file *filp)
+{
+        struct isi_port *ip = tty->driver_data;
+        struct tty_port *port = &ip->port;
+        if (isicom_paranoia_check(ip, tty->name, "isicom_close"))
+                return;
 
+        if (tty_port_close_start(port, tty, filp) == 0)
+                return;
+        isicom_close_port(port);
         isicom_flush_buffer(tty);
-        
         tty_port_close_end(port, tty);
 }
 
diff --git a/drivers/char/mbcs.c b/drivers/char/mbcs.c
index acd8e9ed474a..87c67b42bc08 100644
--- a/drivers/char/mbcs.c
+++ b/drivers/char/mbcs.c
@@ -15,6 +15,7 @@
 #include <linux/moduleparam.h>
 #include <linux/types.h>
 #include <linux/ioport.h>
+#include <linux/kernel.h>
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
@@ -715,8 +716,8 @@ static ssize_t show_algo(struct device *dev, struct device_attribute *attr, char
          */
         debug0 = *(uint64_t *) soft->debug_addr;
 
-        return sprintf(buf, "0x%lx 0x%lx\n",
-                       (debug0 >> 32), (debug0 & 0xffffffff));
+        return sprintf(buf, "0x%x 0x%x\n",
+                       upper_32_bits(debug0), lower_32_bits(debug0));
 }
 
 static ssize_t store_algo(struct device *dev, struct device_attribute *attr, const char *buf, size_t count)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 0491cdf63f2a..0aede1d6a9ea 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -866,24 +866,25 @@ static const struct file_operations kmsg_fops = {
 
 static const struct memdev {
         const char *name;
+        mode_t mode;
         const struct file_operations *fops;
         struct backing_dev_info *dev_info;
 } devlist[] = {
-        [ 1] = { "mem", &mem_fops, &directly_mappable_cdev_bdi },
+         [1] = { "mem", 0, &mem_fops, &directly_mappable_cdev_bdi },
 #ifdef CONFIG_DEVKMEM
-        [ 2] = { "kmem", &kmem_fops, &directly_mappable_cdev_bdi },
+         [2] = { "kmem", 0, &kmem_fops, &directly_mappable_cdev_bdi },
 #endif
-        [ 3] = {"null", &null_fops, NULL },
+         [3] = { "null", 0666, &null_fops, NULL },
 #ifdef CONFIG_DEVPORT
-        [ 4] = { "port", &port_fops, NULL },
+         [4] = { "port", 0, &port_fops, NULL },
 #endif
-        [ 5] = { "zero", &zero_fops, &zero_bdi },
-        [ 7] = { "full", &full_fops, NULL },
-        [ 8] = { "random", &random_fops, NULL },
-        [ 9] = { "urandom", &urandom_fops, NULL },
-        [11] = { "kmsg", &kmsg_fops, NULL },
+         [5] = { "zero", 0666, &zero_fops, &zero_bdi },
+         [7] = { "full", 0666, &full_fops, NULL },
+         [8] = { "random", 0666, &random_fops, NULL },
+         [9] = { "urandom", 0666, &urandom_fops, NULL },
+        [11] = { "kmsg", 0, &kmsg_fops, NULL },
 #ifdef CONFIG_CRASH_DUMP
-        [12] = { "oldmem", &oldmem_fops, NULL },
+        [12] = { "oldmem", 0, &oldmem_fops, NULL },
 #endif
 };
 
@@ -920,6 +921,13 @@ static const struct file_operations memory_fops = {
         .open           = memory_open,
 };
 
+static char *mem_devnode(struct device *dev, mode_t *mode)
+{
+        if (mode && devlist[MINOR(dev->devt)].mode)
+                *mode = devlist[MINOR(dev->devt)].mode;
+        return NULL;
+}
+
 static struct class *mem_class;
 
 static int __init chr_dev_init(void)
@@ -935,6 +943,7 @@ static int __init chr_dev_init(void)
                 printk("unable to get major %d for memory devs\n", MEM_MAJOR);
 
         mem_class = class_create(THIS_MODULE, "mem");
+        mem_class->devnode = mem_devnode;
         for (minor = 1; minor < ARRAY_SIZE(devlist); minor++) {
                 if (!devlist[minor].name)
                         continue;
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 62c99fa59e2b..1ee27cc23426 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -263,12 +263,14 @@ int misc_deregister(struct miscdevice *misc)
 EXPORT_SYMBOL(misc_register);
 EXPORT_SYMBOL(misc_deregister);
 
-static char *misc_nodename(struct device *dev)
+static char *misc_devnode(struct device *dev, mode_t *mode)
 {
         struct miscdevice *c = dev_get_drvdata(dev);
 
-        if (c->devnode)
-                return kstrdup(c->devnode, GFP_KERNEL);
+        if (mode && c->mode)
+                *mode = c->mode;
+        if (c->nodename)
+                return kstrdup(c->nodename, GFP_KERNEL);
         return NULL;
 }
 
@@ -287,7 +289,7 @@ static int __init misc_init(void)
         err = -EIO;
         if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))
                 goto fail_printk;
-        misc_class->nodename = misc_nodename;
+        misc_class->devnode = misc_devnode;
         return 0;
 
 fail_printk:
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index dbf8d52f31d0..5e28d39b9e81 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -48,7 +48,7 @@
 
 #include "mxser.h"
 
-#define MXSER_VERSION   "2.0.4"         /* 1.12 */
+#define MXSER_VERSION   "2.0.5"         /* 1.14 */
 #define MXSERMAJOR       174
 
 #define MXSER_BOARDS            4       /* Max. boards */
@@ -69,6 +69,7 @@
 #define PCI_DEVICE_ID_POS104UL  0x1044
 #define PCI_DEVICE_ID_CB108     0x1080
 #define PCI_DEVICE_ID_CP102UF   0x1023
+#define PCI_DEVICE_ID_CP112UL   0x1120
 #define PCI_DEVICE_ID_CB114     0x1142
 #define PCI_DEVICE_ID_CP114UL   0x1143
 #define PCI_DEVICE_ID_CB134I    0x1341
@@ -139,7 +140,8 @@ static const struct mxser_cardinfo mxser_cards[] = {
         { "CP-138U series",     8, },
         { "POS-104UL series",   4, },
         { "CP-114UL series",    4, },
-/*30*/  { "CP-102UF series",    2, }
+/*30*/  { "CP-102UF series",    2, },
+        { "CP-112UL series",    2, },
 };
 
 /* driver_data correspond to the lines in the structure above
@@ -170,6 +172,7 @@ static struct pci_device_id mxser_pcibrds[] = {
         { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_POS104UL),    .driver_data = 28 },
         { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP114UL),     .driver_data = 29 },
         { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP102UF),     .driver_data = 30 },
+        { PCI_VDEVICE(MOXA, PCI_DEVICE_ID_CP112UL),     .driver_data = 31 },
         { }
 };
 MODULE_DEVICE_TABLE(pci, mxser_pcibrds);
@@ -258,7 +261,6 @@ struct mxser_port {
         struct mxser_mon mon_data;
 
         spinlock_t slock;
-        wait_queue_head_t delta_msr_wait;
 };
 
 struct mxser_board {
@@ -818,7 +820,7 @@ static void mxser_check_modem_status(struct tty_struct *tty,
         if (status & UART_MSR_DCTS)
                 port->icount.cts++;
         port->mon_data.modem_status = status;
-        wake_up_interruptible(&port->delta_msr_wait);
+        wake_up_interruptible(&port->port.delta_msr_wait);
 
         if ((port->port.flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) {
                 if (status & UART_MSR_DCD)
@@ -973,7 +975,7 @@ static void mxser_shutdown(struct tty_struct *tty)
          * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
          * here so the queue might never be waken up
          */
-        wake_up_interruptible(&info->delta_msr_wait);
+        wake_up_interruptible(&info->port.delta_msr_wait);
 
         /*
          * Free the IRQ, if necessary
@@ -1073,34 +1075,17 @@ static void mxser_flush_buffer(struct tty_struct *tty)
 }
 
 
-/*
- * This routine is called when the serial port gets closed.  First, we
- * wait for the last remaining data to be sent.  Then, we unlink its
- * async structure from the interrupt chain if necessary, and we free
- * that IRQ if nothing is left in the chain.
- */
-static void mxser_close(struct tty_struct *tty, struct file *filp)
+static void mxser_close_port(struct tty_struct *tty, struct tty_port *port)
 {
-        struct mxser_port *info = tty->driver_data;
-        struct tty_port *port = &info->port;
-
+        struct mxser_port *info = container_of(port, struct mxser_port, port);
         unsigned long timeout;
-
-        if (tty->index == MXSER_PORTS)
-                return;
-        if (!info)
-                return;
-
-        if (tty_port_close_start(port, tty, filp) == 0)
-                return;
-
         /*
          * Save the termios structure, since this port may have
          * separate termios for callout and dialin.
          *
          * FIXME: Can this go ?
          */
-        if (info->port.flags & ASYNC_NORMAL_ACTIVE)
+        if (port->flags & ASYNC_NORMAL_ACTIVE)
                 info->normal_termios = *tty->termios;
         /*
          * At this point we stop accepting input.  To do this, we
@@ -1112,7 +1097,7 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
         if (info->board->chip_flag)
                 info->IER &= ~MOXA_MUST_RECV_ISR;
 
-        if (info->port.flags & ASYNC_INITIALIZED) {
+        if (port->flags & ASYNC_INITIALIZED) {
                 outb(info->IER, info->ioaddr + UART_IER);
                 /*
                  * Before we drop DTR, make sure the UART transmitter
@@ -1127,8 +1112,26 @@ static void mxser_close(struct tty_struct *tty, struct file *filp)
                 }
         }
         mxser_shutdown(tty);
-        mxser_flush_buffer(tty);
 
+}
+
+/*
+ * This routine is called when the serial port gets closed.  First, we
+ * wait for the last remaining data to be sent.  Then, we unlink its
+ * async structure from the interrupt chain if necessary, and we free
+ * that IRQ if nothing is left in the chain.
+ */
+static void mxser_close(struct tty_struct *tty, struct file *filp)
+{
+        struct mxser_port *info = tty->driver_data;
+        struct tty_port *port = &info->port;
+
+        if (tty->index == MXSER_PORTS)
+                return;
+        if (tty_port_close_start(port, tty, filp) == 0)
+                return;
+        mxser_close_port(tty, port);
+        mxser_flush_buffer(tty);
         /* Right now the tty_port set is done outside of the close_end helper
            as we don't yet have everyone using refcounts */     
         tty_port_close_end(port, tty);
@@ -1761,7 +1764,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file,
                 cnow = info->icount;    /* note the counters on entry */
                 spin_unlock_irqrestore(&info->slock, flags);
 
-                return wait_event_interruptible(info->delta_msr_wait,
+                return wait_event_interruptible(info->port.delta_msr_wait,
                                 mxser_cflags_changed(info, arg, &cnow));
         /*
          * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
@@ -1803,7 +1806,7 @@ static int mxser_ioctl(struct tty_struct *tty, struct file *file,
 
                 lock_kernel();
                 len = mxser_chars_in_buffer(tty);
-                lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_TEMT;
+                lsr = inb(info->ioaddr + UART_LSR) & UART_LSR_THRE;
                 len += (lsr ? 0 : 1);
                 unlock_kernel();
 
@@ -2413,7 +2416,6 @@ static int __devinit mxser_initbrd(struct mxser_board *brd,
                 info->port.close_delay = 5 * HZ / 10;
                 info->port.closing_wait = 30 * HZ;
                 info->normal_termios = mxvar_sdriver->init_termios;
-                init_waitqueue_head(&info->delta_msr_wait);
                 memset(&info->mon_data, 0, sizeof(struct mxser_mon));
                 info->err_shadow = 0;
                 spin_lock_init(&info->slock);
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index 4e28b35024ec..2e50f4dfc79c 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -272,7 +272,8 @@ static inline int is_continuation(unsigned char c, struct tty_struct *tty)
  *
  *      This is a helper function that handles one output character
  *      (including special characters like TAB, CR, LF, etc.),
- *      putting the results in the tty driver's write buffer.
+ *      doing OPOST processing and putting the results in the
+ *      tty driver's write buffer.
  *
  *      Note that Linux currently ignores TABDLY, CRDLY, VTDLY, FFDLY
  *      and NLDLY.  They simply aren't relevant in the world today.
@@ -350,8 +351,9 @@ static int do_output_char(unsigned char c, struct tty_struct *tty, int space)
  *      @c: character (or partial unicode symbol)
  *      @tty: terminal device
  *
- *      Perform OPOST processing.  Returns -1 when the output device is
- *      full and the character must be retried.
+ *      Output one character with OPOST processing.
+ *      Returns -1 when the output device is full and the character
+ *      must be retried.
  *
  *      Locking: output_lock to protect column state and space left
  *               (also, this is called from n_tty_write under the
@@ -377,8 +379,11 @@ static int process_output(unsigned char c, struct tty_struct *tty)
 /**
  *      process_output_block            -       block post processor
  *      @tty: terminal device
- *      @inbuf: user buffer
- *      @nr: number of bytes
+ *      @buf: character buffer
+ *      @nr: number of bytes to output
+ *
+ *      Output a block of characters with OPOST processing.
+ *      Returns the number of characters output.
  *
  *      This path is used to speed up block console writes, among other
  *      things when processing blocks of output data. It handles only
@@ -571,33 +576,23 @@ static void process_echoes(struct tty_struct *tty)
                                 break;
 
                         default:
-                                if (iscntrl(op)) {
-                                        if (L_ECHOCTL(tty)) {
-                                                /*
-                                                 * Ensure there is enough space
-                                                 * for the whole ctrl pair.
-                                                 */
-                                                if (space < 2) {
-                                                        no_space_left = 1;
-                                                        break;
-                                                }
-                                                tty_put_char(tty, '^');
-                                                tty_put_char(tty, op ^ 0100);
-                                                tty->column += 2;
-                                                space -= 2;
-                                        } else {
-                                                if (!space) {
-                                                        no_space_left = 1;
-                                                        break;
-                                                }
-                                                tty_put_char(tty, op);
-                                                space--;
-                                        }
-                                }
                                 /*
-                                 * If above falls through, this was an
-                                 * undefined op.
+                                 * If the op is not a special byte code,
+                                 * it is a ctrl char tagged to be echoed
+                                 * as "^X" (where X is the letter
+                                 * representing the control char).
+                                 * Note that we must ensure there is
+                                 * enough space for the whole ctrl pair.
+                                 *
                                  */
+                                if (space < 2) {
+                                        no_space_left = 1;
+                                        break;
+                                }
+                                tty_put_char(tty, '^');
+                                tty_put_char(tty, op ^ 0100);
+                                tty->column += 2;
+                                space -= 2;
                                 cp += 2;
                                 nr -= 2;
                         }
@@ -605,12 +600,18 @@ static void process_echoes(struct tty_struct *tty)
                         if (no_space_left)
                                 break;
                 } else {
-                        int retval;
-
-                        retval = do_output_char(c, tty, space);
-                        if (retval < 0)
-                                break;
-                        space -= retval;
+                        if (O_OPOST(tty) &&
+                            !(test_bit(TTY_HW_COOK_OUT, &tty->flags))) {
+                                int retval = do_output_char(c, tty, space);
+                                if (retval < 0)
+                                        break;
+                                space -= retval;
+                        } else {
+                                if (!space)
+                                        break;
+                                tty_put_char(tty, c);
+                                space -= 1;
+                        }
                         cp += 1;
                         nr -= 1;
                 }
@@ -798,8 +799,8 @@ static void echo_char_raw(unsigned char c, struct tty_struct *tty)
  *      Echo user input back onto the screen. This must be called only when
  *      L_ECHO(tty) is true. Called from the driver receive_buf path.
  *
- *      This variant tags control characters to be possibly echoed as
- *      as "^X" (where X is the letter representing the control char).
+ *      This variant tags control characters to be echoed as "^X"
+ *      (where X is the letter representing the control char).
  *
  *      Locking: echo_lock to protect the echo buffer
  */
@@ -812,7 +813,7 @@ static void echo_char(unsigned char c, struct tty_struct *tty)
                 add_echo_byte(ECHO_OP_START, tty);
                 add_echo_byte(ECHO_OP_START, tty);
         } else {
-                if (iscntrl(c) && c != '\t')
+                if (L_ECHOCTL(tty) && iscntrl(c) && c != '\t')
                         add_echo_byte(ECHO_OP_START, tty);
                 add_echo_byte(c, tty);
         }
diff --git a/drivers/char/raw.c b/drivers/char/raw.c
index 40268db02e22..64acd05f71c8 100644
--- a/drivers/char/raw.c
+++ b/drivers/char/raw.c
@@ -261,7 +261,7 @@ static const struct file_operations raw_ctl_fops = {
 
 static struct cdev raw_cdev;
 
-static char *raw_nodename(struct device *dev)
+static char *raw_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "raw/%s", dev_name(dev));
 }
@@ -289,7 +289,7 @@ static int __init raw_init(void)
                 ret = PTR_ERR(raw_class);
                 goto error_region;
         }
-        raw_class->nodename = raw_nodename;
+        raw_class->devnode = raw_devnode;
         device_create(raw_class, NULL, MKDEV(RAW_MAJOR, 0), NULL, "rawctl");
 
         return 0;
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index 171711acf5cd..3cfa22d469e0 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -343,7 +343,7 @@ static void rc_receive_exc(struct riscom_board const *bp)
         if (port == NULL)
                 return;
 
-        tty = port->port.tty;
+        tty = tty_port_tty_get(&port->port);
 
 #ifdef RC_REPORT_OVERRUN
         status = rc_in(bp, CD180_RCSR);
@@ -355,18 +355,18 @@ static void rc_receive_exc(struct riscom_board const *bp)
 #endif
         ch = rc_in(bp, CD180_RDR);
         if (!status)
-                return;
+                goto out;
         if (status & RCSR_TOUT)  {
                 printk(KERN_WARNING "rc%d: port %d: Receiver timeout. "
                                     "Hardware problems ?\n",
                        board_No(bp), port_No(port));
-                return;
+                goto out;
 
         } else if (status & RCSR_BREAK)  {
                 printk(KERN_INFO "rc%d: port %d: Handling break...\n",
                        board_No(bp), port_No(port));
                 flag = TTY_BREAK;
-                if (port->port.flags & ASYNC_SAK)
+                if (tty && (port->port.flags & ASYNC_SAK))
                         do_SAK(tty);
 
         } else if (status & RCSR_PE)
@@ -380,8 +380,12 @@ static void rc_receive_exc(struct riscom_board const *bp)
         else
                 flag = TTY_NORMAL;
 
-        tty_insert_flip_char(tty, ch, flag);
-        tty_flip_buffer_push(tty);
+        if (tty) {
+                tty_insert_flip_char(tty, ch, flag);
+                tty_flip_buffer_push(tty);
+        }
+out:
+        tty_kref_put(tty);
 }
 
 static void rc_receive(struct riscom_board const *bp)
@@ -394,7 +398,7 @@ static void rc_receive(struct riscom_board const *bp)
         if (port == NULL)
                 return;
 
-        tty = port->port.tty;
+        tty = tty_port_tty_get(&port->port);
 
         count = rc_in(bp, CD180_RDCR);
 
@@ -403,15 +407,14 @@ static void rc_receive(struct riscom_board const *bp)
 #endif
 
         while (count--)  {
-                if (tty_buffer_request_room(tty, 1) == 0)  {
-                        printk(KERN_WARNING "rc%d: port %d: Working around "
-                                            "flip buffer overflow.\n",
-                               board_No(bp), port_No(port));
-                        break;
-                }
-                tty_insert_flip_char(tty, rc_in(bp, CD180_RDR), TTY_NORMAL);
+                u8 ch = rc_in(bp, CD180_RDR);
+                if (tty)
+                        tty_insert_flip_char(tty, ch, TTY_NORMAL);
+        }
+        if (tty) {
+                tty_flip_buffer_push(tty);
+                tty_kref_put(tty);
         }
-        tty_flip_buffer_push(tty);
 }
 
 static void rc_transmit(struct riscom_board const *bp)
@@ -424,22 +427,22 @@ static void rc_transmit(struct riscom_board const *bp)
         if (port == NULL)
                 return;
 
-        tty = port->port.tty;
+        tty = tty_port_tty_get(&port->port);
 
         if (port->IER & IER_TXEMPTY) {
                 /* FIFO drained */
                 rc_out(bp, CD180_CAR, port_No(port));
                 port->IER &= ~IER_TXEMPTY;
                 rc_out(bp, CD180_IER, port->IER);
-                return;
+                goto out;
         }
 
         if ((port->xmit_cnt <= 0 && !port->break_length)
-            || tty->stopped || tty->hw_stopped)  {
+            || (tty && (tty->stopped || tty->hw_stopped)))  {
                 rc_out(bp, CD180_CAR, port_No(port));
                 port->IER &= ~IER_TXRDY;
                 rc_out(bp, CD180_IER, port->IER);
-                return;
+                goto out;
         }
 
         if (port->break_length)  {
@@ -464,7 +467,7 @@ static void rc_transmit(struct riscom_board const *bp)
                         rc_out(bp, CD180_CCR, CCR_CORCHG2);
                         port->break_length = 0;
                 }
-                return;
+                goto out;
         }
 
         count = CD180_NFIFO;
@@ -480,8 +483,10 @@ static void rc_transmit(struct riscom_board const *bp)
                 port->IER &= ~IER_TXRDY;
                 rc_out(bp, CD180_IER, port->IER);
         }
-        if (port->xmit_cnt <= port->wakeup_chars)
+        if (tty && port->xmit_cnt <= port->wakeup_chars)
                 tty_wakeup(tty);
+out:
+        tty_kref_put(tty);
 }
 
 static void rc_check_modem(struct riscom_board const *bp)
@@ -494,37 +499,43 @@ static void rc_check_modem(struct riscom_board const *bp)
         if (port == NULL)
                 return;
 
-        tty = port->port.tty;
+        tty = tty_port_tty_get(&port->port);
 
         mcr = rc_in(bp, CD180_MCR);
         if (mcr & MCR_CDCHG) {
                 if (rc_in(bp, CD180_MSVR) & MSVR_CD)
                         wake_up_interruptible(&port->port.open_wait);
-                else
+                else if (tty)
                         tty_hangup(tty);
         }
 
 #ifdef RISCOM_BRAIN_DAMAGED_CTS
         if (mcr & MCR_CTSCHG)  {
                 if (rc_in(bp, CD180_MSVR) & MSVR_CTS)  {
-                        tty->hw_stopped = 0;
                         port->IER |= IER_TXRDY;
-                        if (port->xmit_cnt <= port->wakeup_chars)
-                                tty_wakeup(tty);
+                        if (tty) {
+                                tty->hw_stopped = 0;
+                                if (port->xmit_cnt <= port->wakeup_chars)
+                                        tty_wakeup(tty);
+                        }
                 } else  {
-                        tty->hw_stopped = 1;
+                        if (tty)
+                                tty->hw_stopped = 1;
                         port->IER &= ~IER_TXRDY;
                 }
                 rc_out(bp, CD180_IER, port->IER);
         }
         if (mcr & MCR_DSRCHG)  {
                 if (rc_in(bp, CD180_MSVR) & MSVR_DSR)  {
-                        tty->hw_stopped = 0;
                         port->IER |= IER_TXRDY;
-                        if (port->xmit_cnt <= port->wakeup_chars)
-                                tty_wakeup(tty);
+                        if (tty) {
+                                tty->hw_stopped = 0;
+                                if (port->xmit_cnt <= port->wakeup_chars)
+                                        tty_wakeup(tty);
+                        }
                 } else  {
-                        tty->hw_stopped = 1;
+                        if (tty)
+                                tty->hw_stopped = 1;
                         port->IER &= ~IER_TXRDY;
                 }
                 rc_out(bp, CD180_IER, port->IER);
@@ -533,6 +544,7 @@ static void rc_check_modem(struct riscom_board const *bp)
 
         /* Clear change bits */
         rc_out(bp, CD180_MCR, 0);
+        tty_kref_put(tty);
 }
 
 /* The main interrupt processing routine */
@@ -632,9 +644,9 @@ static void rc_shutdown_board(struct riscom_board *bp)
  * Setting up port characteristics.
  * Must be called with disabled interrupts
  */
-static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
+static void rc_change_speed(struct tty_struct *tty, struct riscom_board *bp,
+                                                struct riscom_port *port)
 {
-        struct tty_struct *tty = port->port.tty;
         unsigned long baud;
         long tmp;
         unsigned char cor1 = 0, cor3 = 0;
@@ -781,7 +793,8 @@ static void rc_change_speed(struct riscom_board *bp, struct riscom_port *port)
 }
 
 /* Must be called with interrupts enabled */
-static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
+static int rc_setup_port(struct tty_struct *tty, struct riscom_board *bp,
+                                                struct riscom_port *port)
 {
         unsigned long flags;
 
@@ -793,11 +806,11 @@ static int rc_setup_port(struct riscom_board *bp, struct riscom_port *port)
 
         spin_lock_irqsave(&riscom_lock, flags);
 
-        clear_bit(TTY_IO_ERROR, &port->port.tty->flags);
+        clear_bit(TTY_IO_ERROR, &tty->flags);
         if (port->port.count == 1)
                 bp->count++;
         port->xmit_cnt = port->xmit_head = port->xmit_tail = 0;
-        rc_change_speed(bp, port);
+        rc_change_speed(tty, bp, port);
         port->port.flags |= ASYNC_INITIALIZED;
 
         spin_unlock_irqrestore(&riscom_lock, flags);
@@ -898,9 +911,9 @@ static int rc_open(struct tty_struct *tty, struct file *filp)
 
         port->port.count++;
         tty->driver_data = port;
-        port->port.tty = tty;
+        tty_port_tty_set(&port->port, tty);
 
-        error = rc_setup_port(bp, port);
+        error = rc_setup_port(tty, bp, port);
         if (error == 0)
                 error = tty_port_block_til_ready(&port->port, tty, filp);
         return error;
@@ -921,20 +934,12 @@ static void rc_flush_buffer(struct tty_struct *tty)
         tty_wakeup(tty);
 }
 
-static void rc_close(struct tty_struct *tty, struct file *filp)
+static void rc_close_port(struct tty_port *port)
 {
-        struct riscom_port *port = tty->driver_data;
-        struct riscom_board *bp;
         unsigned long flags;
+        struct riscom_port *rp = container_of(port, struct riscom_port, port);
+        struct riscom_board *bp = port_Board(rp);
         unsigned long timeout;
-
-        if (!port || rc_paranoia_check(port, tty->name, "close"))
-                return;
-
-        bp = port_Board(port);
-        
-        if (tty_port_close_start(&port->port, tty, filp) == 0)
-                return;
         
         /*
          * At this point we stop accepting input.  To do this, we
@@ -944,31 +949,37 @@ static void rc_close(struct tty_struct *tty, struct file *filp)
          */
 
         spin_lock_irqsave(&riscom_lock, flags);
-        port->IER &= ~IER_RXD;
-        if (port->port.flags & ASYNC_INITIALIZED) {
-                port->IER &= ~IER_TXRDY;
-                port->IER |= IER_TXEMPTY;
-                rc_out(bp, CD180_CAR, port_No(port));
-                rc_out(bp, CD180_IER, port->IER);
+        rp->IER &= ~IER_RXD;
+        if (port->flags & ASYNC_INITIALIZED) {
+                rp->IER &= ~IER_TXRDY;
+                rp->IER |= IER_TXEMPTY;
+                rc_out(bp, CD180_CAR, port_No(rp));
+                rc_out(bp, CD180_IER, rp->IER);
                 /*
                  * Before we drop DTR, make sure the UART transmitter
                  * has completely drained; this is especially
                  * important if there is a transmit FIFO!
                  */
                 timeout = jiffies + HZ;
-                while (port->IER & IER_TXEMPTY) {
+                while (rp->IER & IER_TXEMPTY) {
                         spin_unlock_irqrestore(&riscom_lock, flags);
-                        msleep_interruptible(jiffies_to_msecs(port->timeout));
+                        msleep_interruptible(jiffies_to_msecs(rp->timeout));
                         spin_lock_irqsave(&riscom_lock, flags);
                         if (time_after(jiffies, timeout))
                                 break;
                 }
         }
-        rc_shutdown_port(tty, bp, port);
-        rc_flush_buffer(tty);
+        rc_shutdown_port(port->tty, bp, rp);
         spin_unlock_irqrestore(&riscom_lock, flags);
+}
+
+static void rc_close(struct tty_struct *tty, struct file *filp)
+{
+        struct riscom_port *port = tty->driver_data;
 
-        tty_port_close_end(&port->port, tty);
+        if (!port || rc_paranoia_check(port, tty->name, "close"))
+                return;
+        tty_port_close(&port->port, tty, filp);
 }
 
 static int rc_write(struct tty_struct *tty,
@@ -1170,7 +1181,7 @@ static int rc_send_break(struct tty_struct *tty, int length)
         return 0;
 }
 
-static int rc_set_serial_info(struct riscom_port *port,
+static int rc_set_serial_info(struct tty_struct *tty, struct riscom_port *port,
                                      struct serial_struct __user *newinfo)
 {
         struct serial_struct tmp;
@@ -1180,17 +1191,6 @@ static int rc_set_serial_info(struct riscom_port *port,
         if (copy_from_user(&tmp, newinfo, sizeof(tmp)))
                 return -EFAULT;
 
-#if 0
-        if ((tmp.irq != bp->irq) ||
-            (tmp.port != bp->base) ||
-            (tmp.type != PORT_CIRRUS) ||
-            (tmp.baud_base != (RC_OSCFREQ + CD180_TPC/2) / CD180_TPC) ||
-            (tmp.custom_divisor != 0) ||
-            (tmp.xmit_fifo_size != CD180_NFIFO) ||
-            (tmp.flags & ~RISCOM_LEGAL_FLAGS))
-                return -EINVAL;
-#endif
-
         change_speed = ((port->port.flags & ASYNC_SPD_MASK) !=
                         (tmp.flags & ASYNC_SPD_MASK));
 
@@ -1212,7 +1212,7 @@ static int rc_set_serial_info(struct riscom_port *port,
                 unsigned long flags;
 
                 spin_lock_irqsave(&riscom_lock, flags);
-                rc_change_speed(bp, port);
+                rc_change_speed(tty, bp, port);
                 spin_unlock_irqrestore(&riscom_lock, flags);
         }
         return 0;
@@ -1255,7 +1255,7 @@ static int rc_ioctl(struct tty_struct *tty, struct file *filp,
                 break;
         case TIOCSSERIAL:
                 lock_kernel();
-                retval = rc_set_serial_info(port, argp);
+                retval = rc_set_serial_info(tty, port, argp);
                 unlock_kernel();
                 break;
         default:
@@ -1350,21 +1350,12 @@ static void rc_start(struct tty_struct *tty)
 static void rc_hangup(struct tty_struct *tty)
 {
         struct riscom_port *port = tty->driver_data;
-        struct riscom_board *bp;
-        unsigned long flags;
 
         if (rc_paranoia_check(port, tty->name, "rc_hangup"))
                 return;
 
-        bp = port_Board(port);
-
-        rc_shutdown_port(tty, bp, port);
-        spin_lock_irqsave(&port->port.lock, flags);
-        port->port.count = 0;
-        port->port.flags &= ~ASYNC_NORMAL_ACTIVE;
-        port->port.tty = NULL;
-        wake_up_interruptible(&port->port.open_wait);
-        spin_unlock_irqrestore(&port->port.lock, flags);
+        rc_shutdown_port(tty, port_Board(port), port);
+        tty_port_hangup(&port->port);
 }
 
 static void rc_set_termios(struct tty_struct *tty,
@@ -1377,7 +1368,7 @@ static void rc_set_termios(struct tty_struct *tty,
                 return;
 
         spin_lock_irqsave(&riscom_lock, flags);
-        rc_change_speed(port_Board(port), port);
+        rc_change_speed(tty, port_Board(port), port);
         spin_unlock_irqrestore(&riscom_lock, flags);
 
         if ((old_termios->c_cflag & CRTSCTS) &&
@@ -1410,6 +1401,7 @@ static const struct tty_operations riscom_ops = {
 
 static const struct tty_port_operations riscom_port_ops = {
         .carrier_raised = carrier_raised,
+        .shutdown = rc_close_port,
 };
 
 
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index a3afa0c387cd..ea18a129b0b5 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -1184,6 +1184,7 @@ int tty_init_termios(struct tty_struct *tty)
         tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
         return 0;
 }
+EXPORT_SYMBOL_GPL(tty_init_termios);
 
 /**
  *      tty_driver_install_tty() - install a tty entry in the driver
@@ -1386,10 +1387,14 @@ EXPORT_SYMBOL(tty_shutdown);
  *              tty_mutex - sometimes only
  *              takes the file list lock internally when working on the list
  *      of ttys that the driver keeps.
+ *
+ *      This method gets called from a work queue so that the driver private
+ *      shutdown ops can sleep (needed for USB at least)
  */
-static void release_one_tty(struct kref *kref)
+static void release_one_tty(struct work_struct *work)
 {
-        struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
+        struct tty_struct *tty =
+                container_of(work, struct tty_struct, hangup_work);
         struct tty_driver *driver = tty->driver;
 
         if (tty->ops->shutdown)
@@ -1407,6 +1412,15 @@ static void release_one_tty(struct kref *kref)
         free_tty_struct(tty);
 }
 
+static void queue_release_one_tty(struct kref *kref)
+{
+        struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
+        /* The hangup queue is now free so we can reuse it rather than
+           waste a chunk of memory for each port */
+        INIT_WORK(&tty->hangup_work, release_one_tty);
+        schedule_work(&tty->hangup_work);
+}
+
 /**
  *      tty_kref_put            -       release a tty kref
  *      @tty: tty device
@@ -1418,7 +1432,7 @@ static void release_one_tty(struct kref *kref)
 void tty_kref_put(struct tty_struct *tty)
 {
         if (tty)
-                kref_put(&tty->kref, release_one_tty);
+                kref_put(&tty->kref, queue_release_one_tty);
 }
 EXPORT_SYMBOL(tty_kref_put);
 
@@ -2085,7 +2099,7 @@ static int tioccons(struct file *file)
  *      the generic functionality existed. This piece of history is preserved
  *      in the expected tty API of posix OS's.
  *
- *      Locking: none, the open fle handle ensures it won't go away.
+ *      Locking: none, the open file handle ensures it won't go away.
  */
 
 static int fionbio(struct file *file, int __user *p)
@@ -3056,11 +3070,22 @@ void __init console_init(void)
         }
 }
 
+static char *tty_devnode(struct device *dev, mode_t *mode)
+{
+        if (!mode)
+                return NULL;
+        if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
+            dev->devt == MKDEV(TTYAUX_MAJOR, 2))
+                *mode = 0666;
+        return NULL;
+}
+
 static int __init tty_class_init(void)
 {
         tty_class = class_create(THIS_MODULE, "tty");
         if (IS_ERR(tty_class))
                 return PTR_ERR(tty_class);
+        tty_class->devnode = tty_devnode;
         return 0;
 }
 
diff --git a/drivers/char/tty_ioctl.c b/drivers/char/tty_ioctl.c
index ad6ba4ed2808..8e67d5c642a4 100644
--- a/drivers/char/tty_ioctl.c
+++ b/drivers/char/tty_ioctl.c
@@ -393,9 +393,7 @@ void tty_termios_encode_baud_rate(struct ktermios *termios,
                 termios->c_cflag |= (BOTHER << IBSHIFT);
 #else
         if (ifound == -1 || ofound == -1) {
-                static int warned;
-                if (!warned++)
-                        printk(KERN_WARNING "tty: Unable to return correct "
+                printk_once(KERN_WARNING "tty: Unable to return correct "
                           "speed data as your architecture needs updating.\n");
         }
 #endif
diff --git a/drivers/char/tty_ldisc.c b/drivers/char/tty_ldisc.c
index e48af9f79219..aafdbaebc16a 100644
--- a/drivers/char/tty_ldisc.c
+++ b/drivers/char/tty_ldisc.c
@@ -145,48 +145,33 @@ int tty_unregister_ldisc(int disc)
 }
 EXPORT_SYMBOL(tty_unregister_ldisc);
 
-
-/**
- *      tty_ldisc_try_get       -       try and reference an ldisc
- *      @disc: ldisc number
- *
- *      Attempt to open and lock a line discipline into place. Return
- *      the line discipline refcounted or an error.
- */
-
-static struct tty_ldisc *tty_ldisc_try_get(int disc)
+static struct tty_ldisc_ops *get_ldops(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);
+        struct tty_ldisc_ops *ldops, *ret;
 
         spin_lock_irqsave(&tty_ldisc_lock, flags);
-        ld->ops = NULL;
+        ret = ERR_PTR(-EINVAL);
         ldops = tty_ldiscs[disc];
-        /* Check the entry is defined */
         if (ldops) {
-                /* If the module is being unloaded we can't use it */
-                if (!try_module_get(ldops->owner))
-                        err = -EAGAIN;
-                else {
-                        /* lock it */
+                ret = ERR_PTR(-EAGAIN);
+                if (try_module_get(ldops->owner)) {
                         ldops->refcount++;
-                        ld->ops = ldops;
-                        atomic_set(&ld->users, 1);
-                        err = 0;
+                        ret = ldops;
                 }
         }
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-        if (err) {
-                kfree(ld);
-                return ERR_PTR(err);
-        }
-        return ld;
+        return ret;
+}
+
+static void put_ldops(struct tty_ldisc_ops *ldops)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&tty_ldisc_lock, flags);
+        ldops->refcount--;
+        module_put(ldops->owner);
+        spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 }
 
 /**
@@ -205,14 +190,31 @@ static struct tty_ldisc *tty_ldisc_try_get(int disc)
 static struct tty_ldisc *tty_ldisc_get(int disc)
 {
         struct tty_ldisc *ld;
+        struct tty_ldisc_ops *ldops;
 
         if (disc < N_TTY || disc >= NR_LDISCS)
                 return ERR_PTR(-EINVAL);
-        ld = tty_ldisc_try_get(disc);
-        if (IS_ERR(ld)) {
+
+        /*
+         * Get the ldisc ops - we may need to request them to be loaded
+         * dynamically and try again.
+         */
+        ldops = get_ldops(disc);
+        if (IS_ERR(ldops)) {
                 request_module("tty-ldisc-%d", disc);
-                ld = tty_ldisc_try_get(disc);
+                ldops = get_ldops(disc);
+                if (IS_ERR(ldops))
+                        return ERR_CAST(ldops);
         }
+
+        ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
+        if (ld == NULL) {
+                put_ldops(ldops);
+                return ERR_PTR(-ENOMEM);
+        }
+
+        ld->ops = ldops;
+        atomic_set(&ld->users, 1);
         return ld;
 }
 
@@ -234,13 +236,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;
+        struct tty_ldisc_ops *ldops;
 
-        ld = tty_ldisc_try_get(i);
-        if (IS_ERR(ld))
+        ldops = get_ldops(i);
+        if (IS_ERR(ldops))
                 return 0;
-        seq_printf(m, "%-10s %2d\n", ld->ops->name ? ld->ops->name : "???", i);
-        put_ldisc(ld);
+        seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
+        put_ldops(ldops);
         return 0;
 }
 
diff --git a/drivers/char/tty_port.c b/drivers/char/tty_port.c
index 9769b1149f76..a4bbb28f10be 100644
--- a/drivers/char/tty_port.c
+++ b/drivers/char/tty_port.c
@@ -23,6 +23,7 @@ void tty_port_init(struct tty_port *port)
         memset(port, 0, sizeof(*port));
         init_waitqueue_head(&port->open_wait);
         init_waitqueue_head(&port->close_wait);
+        init_waitqueue_head(&port->delta_msr_wait);
         mutex_init(&port->mutex);
         spin_lock_init(&port->lock);
         port->close_delay = (50 * HZ) / 100;
@@ -96,6 +97,14 @@ void tty_port_tty_set(struct tty_port *port, struct tty_struct *tty)
 }
 EXPORT_SYMBOL(tty_port_tty_set);
 
+static void tty_port_shutdown(struct tty_port *port)
+{
+        if (port->ops->shutdown &&
+                test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags))
+                        port->ops->shutdown(port);
+
+}
+
 /**
  *      tty_port_hangup         -       hangup helper
  *      @port: tty port
@@ -116,6 +125,8 @@ void tty_port_hangup(struct tty_port *port)
         port->tty = NULL;
         spin_unlock_irqrestore(&port->lock, flags);
         wake_up_interruptible(&port->open_wait);
+        wake_up_interruptible(&port->delta_msr_wait);
+        tty_port_shutdown(port);
 }
 EXPORT_SYMBOL(tty_port_hangup);
 
@@ -296,15 +307,17 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
 
         if (port->count) {
                 spin_unlock_irqrestore(&port->lock, flags);
+                if (port->ops->drop)
+                        port->ops->drop(port);
                 return 0;
         }
-        port->flags |= ASYNC_CLOSING;
+        set_bit(ASYNCB_CLOSING, &port->flags);
         tty->closing = 1;
         spin_unlock_irqrestore(&port->lock, flags);
         /* Don't block on a stalled port, just pull the chain */
         if (tty->flow_stopped)
                 tty_driver_flush_buffer(tty);
-        if (port->flags & ASYNC_INITIALIZED &&
+        if (test_bit(ASYNCB_INITIALIZED, &port->flags) &&
                         port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
                 tty_wait_until_sent(tty, port->closing_wait);
         if (port->drain_delay) {
@@ -318,6 +331,9 @@ int tty_port_close_start(struct tty_port *port, struct tty_struct *tty, struct f
                         timeout = 2 * HZ;
                 schedule_timeout_interruptible(timeout);
         }
+        /* Don't call port->drop for the last reference. Callers will want
+           to drop the last active reference in ->shutdown() or the tty
+           shutdown path */
         return 1;
 }
 EXPORT_SYMBOL(tty_port_close_start);
@@ -348,3 +364,14 @@ void tty_port_close_end(struct tty_port *port, struct tty_struct *tty)
         spin_unlock_irqrestore(&port->lock, flags);
 }
 EXPORT_SYMBOL(tty_port_close_end);
+
+void tty_port_close(struct tty_port *port, struct tty_struct *tty,
+                                                        struct file *filp)
+{
+        if (tty_port_close_start(port, tty, filp) == 0)
+                return;
+        tty_port_shutdown(port);
+        tty_port_close_end(port, tty);
+        tty_port_tty_set(port, NULL);
+}
+EXPORT_SYMBOL(tty_port_close);
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index 6aa88f50b039..0c80c68cd047 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -252,7 +252,6 @@ static void notify_update(struct vc_data *vc)
         struct vt_notifier_param param = { .vc = vc };
         atomic_notifier_call_chain(&vt_notifier_list, VT_UPDATE, &param);
 }
-
 /*
  *      Low-Level Functions
  */
@@ -935,6 +934,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc,
 
         if (CON_IS_VISIBLE(vc))
                 update_screen(vc);
+        vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num);
         return err;
 }
 
@@ -2129,11 +2129,7 @@ static int do_con_write(struct tty_struct *tty, const unsigned char *buf, int co
         currcons = vc->vc_num;
         if (!vc_cons_allocated(currcons)) {
             /* could this happen? */
-            static int error = 0;
-            if (!error) {
-                error = 1;
-                printk("con_write: tty %d not allocated\n", currcons+1);
-            }
+                printk_once("con_write: tty %d not allocated\n", currcons+1);
             release_console_sem();
             return 0;
         }
@@ -2910,6 +2906,9 @@ static const struct tty_operations con_ops = {
         .flush_chars = con_flush_chars,
         .chars_in_buffer = con_chars_in_buffer,
         .ioctl = vt_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl = vt_compat_ioctl,
+#endif
         .stop = con_stop,
         .start = con_start,
         .throttle = con_throttle,
@@ -2955,7 +2954,6 @@ int __init vty_init(const struct file_operations *console_fops)
 }
 
 #ifndef VT_SINGLE_DRIVER
-#include <linux/device.h>
 
 static struct class *vtconsole_class;
 
@@ -3638,6 +3636,7 @@ void do_blank_screen(int entering_gfx)
                 blank_state = blank_vesa_wait;
                 mod_timer(&console_timer, jiffies + vesa_off_interval);
         }
+        vt_event_post(VT_EVENT_BLANK, vc->vc_num, vc->vc_num);
 }
 EXPORT_SYMBOL(do_blank_screen);
 
@@ -3682,6 +3681,7 @@ void do_unblank_screen(int leaving_gfx)
                 console_blank_hook(0);
         set_palette(vc);
         set_cursor(vc);
+        vt_event_post(VT_EVENT_UNBLANK, vc->vc_num, vc->vc_num);
 }
 EXPORT_SYMBOL(do_unblank_screen);
 
diff --git a/drivers/char/vt_ioctl.c b/drivers/char/vt_ioctl.c
index 95189f288f8c..29c651ab0d78 100644
--- a/drivers/char/vt_ioctl.c
+++ b/drivers/char/vt_ioctl.c
@@ -16,6 +16,8 @@
 #include <linux/tty.h>
 #include <linux/timer.h>
 #include <linux/kernel.h>
+#include <linux/compat.h>
+#include <linux/module.h>
 #include <linux/kd.h>
 #include <linux/vt.h>
 #include <linux/string.h>
@@ -62,6 +64,133 @@ extern struct tty_driver *console_driver;
 static void complete_change_console(struct vc_data *vc);
 
 /*
+ *      User space VT_EVENT handlers
+ */
+
+struct vt_event_wait {
+        struct list_head list;
+        struct vt_event event;
+        int done;
+};
+
+static LIST_HEAD(vt_events);
+static DEFINE_SPINLOCK(vt_event_lock);
+static DECLARE_WAIT_QUEUE_HEAD(vt_event_waitqueue);
+
+/**
+ *      vt_event_post
+ *      @event: the event that occurred
+ *      @old: old console
+ *      @new: new console
+ *
+ *      Post an VT event to interested VT handlers
+ */
+
+void vt_event_post(unsigned int event, unsigned int old, unsigned int new)
+{
+        struct list_head *pos, *head;
+        unsigned long flags;
+        int wake = 0;
+
+        spin_lock_irqsave(&vt_event_lock, flags);
+        head = &vt_events;
+
+        list_for_each(pos, head) {
+                struct vt_event_wait *ve = list_entry(pos,
+                                                struct vt_event_wait, list);
+                if (!(ve->event.event & event))
+                        continue;
+                ve->event.event = event;
+                /* kernel view is consoles 0..n-1, user space view is
+                   console 1..n with 0 meaning current, so we must bias */
+                ve->event.old = old + 1;
+                ve->event.new = new + 1;
+                wake = 1;
+                ve->done = 1;
+        }
+        spin_unlock_irqrestore(&vt_event_lock, flags);
+        if (wake)
+                wake_up_interruptible(&vt_event_waitqueue);
+}
+
+/**
+ *      vt_event_wait           -       wait for an event
+ *      @vw: our event
+ *
+ *      Waits for an event to occur which completes our vt_event_wait
+ *      structure. On return the structure has wv->done set to 1 for success
+ *      or 0 if some event such as a signal ended the wait.
+ */
+
+static void vt_event_wait(struct vt_event_wait *vw)
+{
+        unsigned long flags;
+        /* Prepare the event */
+        INIT_LIST_HEAD(&vw->list);
+        vw->done = 0;
+        /* Queue our event */
+        spin_lock_irqsave(&vt_event_lock, flags);
+        list_add(&vw->list, &vt_events);
+        spin_unlock_irqrestore(&vt_event_lock, flags);
+        /* Wait for it to pass */
+        wait_event_interruptible(vt_event_waitqueue, vw->done);
+        /* Dequeue it */
+        spin_lock_irqsave(&vt_event_lock, flags);
+        list_del(&vw->list);
+        spin_unlock_irqrestore(&vt_event_lock, flags);
+}
+
+/**
+ *      vt_event_wait_ioctl     -       event ioctl handler
+ *      @arg: argument to ioctl
+ *
+ *      Implement the VT_WAITEVENT ioctl using the VT event interface
+ */
+
+static int vt_event_wait_ioctl(struct vt_event __user *event)
+{
+        struct vt_event_wait vw;
+
+        if (copy_from_user(&vw.event, event, sizeof(struct vt_event)))
+                return -EFAULT;
+        /* Highest supported event for now */
+        if (vw.event.event & ~VT_MAX_EVENT)
+                return -EINVAL;
+
+        vt_event_wait(&vw);
+        /* If it occurred report it */
+        if (vw.done) {
+                if (copy_to_user(event, &vw.event, sizeof(struct vt_event)))
+                        return -EFAULT;
+                return 0;
+        }
+        return -EINTR;
+}
+
+/**
+ *      vt_waitactive   -       active console wait
+ *      @event: event code
+ *      @n: new console
+ *
+ *      Helper for event waits. Used to implement the legacy
+ *      event waiting ioctls in terms of events
+ */
+
+int vt_waitactive(int n)
+{
+        struct vt_event_wait vw;
+        do {
+                if (n == fg_console + 1)
+                        break;
+                vw.event.event = VT_EVENT_SWITCH;
+                vt_event_wait(&vw);
+                if (vw.done == 0)
+                        return -EINTR;
+        } while (vw.event.new != n);
+        return 0;
+}
+
+/*
  * these are the valid i/o ports we're allowed to change. they map all the
  * video ports
  */
@@ -360,6 +489,8 @@ do_unimap_ioctl(int cmd, struct unimapdesc __user *user_ud, int perm, struct vc_
         return 0;
 }
 
+
+
 /*
  * We handle the console-specific ioctl's here.  We allow the
  * capability to modify any console, not just the fg_console. 
@@ -842,6 +973,41 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 }
                 break;
 
+        case VT_SETACTIVATE:
+        {
+                struct vt_setactivate vsa;
+
+                if (!perm)
+                        goto eperm;
+
+                if (copy_from_user(&vsa, (struct vt_setactivate __user *)arg,
+                                                sizeof(struct vt_setactivate)))
+                        return -EFAULT;
+                if (vsa.console == 0 || vsa.console > MAX_NR_CONSOLES)
+                        ret = -ENXIO;
+                else {
+                        vsa.console--;
+                        acquire_console_sem();
+                        ret = vc_allocate(vsa.console);
+                        if (ret == 0) {
+                                struct vc_data *nvc;
+                                /* This is safe providing we don't drop the
+                                   console sem between vc_allocate and
+                                   finishing referencing nvc */
+                                nvc = vc_cons[vsa.console].d;
+                                nvc->vt_mode = vsa.mode;
+                                nvc->vt_mode.frsig = 0;
+                                put_pid(nvc->vt_pid);
+                                nvc->vt_pid = get_pid(task_pid(current));
+                        }
+                        release_console_sem();
+                        if (ret)
+                                break;
+                        /* Commence switch and lock */
+                        set_console(arg);
+                }
+        }
+
         /*
          * wait until the specified VT has been activated
          */
@@ -851,7 +1017,7 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 if (arg == 0 || arg > MAX_NR_CONSOLES)
                         ret = -ENXIO;
                 else
-                        ret = vt_waitactive(arg - 1);
+                        ret = vt_waitactive(arg);
                 break;
 
         /*
@@ -1159,6 +1325,9 @@ int vt_ioctl(struct tty_struct *tty, struct file * file,
                 ret = put_user(vc->vc_hi_font_mask,
                                         (unsigned short __user *)arg);
                 break;
+        case VT_WAITEVENT:
+                ret = vt_event_wait_ioctl((struct vt_event __user *)arg);
+                break;
         default:
                 ret = -ENOIOCTLCMD;
         }
@@ -1170,54 +1339,6 @@ eperm:
         goto out;
 }
 
-/*
- * Sometimes we want to wait until a particular VT has been activated. We
- * do it in a very simple manner. Everybody waits on a single queue and
- * get woken up at once. Those that are satisfied go on with their business,
- * while those not ready go back to sleep. Seems overkill to add a wait
- * to each vt just for this - usually this does nothing!
- */
-static DECLARE_WAIT_QUEUE_HEAD(vt_activate_queue);
-
-/*
- * Sleeps until a vt is activated, or the task is interrupted. Returns
- * 0 if activation, -EINTR if interrupted by a signal handler.
- */
-int vt_waitactive(int vt)
-{
-        int retval;
-        DECLARE_WAITQUEUE(wait, current);
-
-        add_wait_queue(&vt_activate_queue, &wait);
-        for (;;) {
-                retval = 0;
-
-                /*
-                 * Synchronize with redraw_screen(). By acquiring the console
-                 * semaphore we make sure that the console switch is completed
-                 * before we return. If we didn't wait for the semaphore, we
-                 * could return at a point where fg_console has already been
-                 * updated, but the console switch hasn't been completed.
-                 */
-                acquire_console_sem();
-                set_current_state(TASK_INTERRUPTIBLE);
-                if (vt == fg_console) {
-                        release_console_sem();
-                        break;
-                }
-                release_console_sem();
-                retval = -ERESTARTNOHAND;
-                if (signal_pending(current))
-                        break;
-                schedule();
-        }
-        remove_wait_queue(&vt_activate_queue, &wait);
-        __set_current_state(TASK_RUNNING);
-        return retval;
-}
-
-#define vt_wake_waitactive() wake_up(&vt_activate_queue)
-
 void reset_vc(struct vc_data *vc)
 {
         vc->vc_mode = KD_TEXT;
@@ -1256,12 +1377,216 @@ void vc_SAK(struct work_struct *work)
         release_console_sem();
 }
 
+#ifdef CONFIG_COMPAT
+
+struct compat_consolefontdesc {
+        unsigned short charcount;       /* characters in font (256 or 512) */
+        unsigned short charheight;      /* scan lines per character (1-32) */
+        compat_caddr_t chardata;        /* font data in expanded form */
+};
+
+static inline int
+compat_fontx_ioctl(int cmd, struct compat_consolefontdesc __user *user_cfd,
+                         int perm, struct console_font_op *op)
+{
+        struct compat_consolefontdesc cfdarg;
+        int i;
+
+        if (copy_from_user(&cfdarg, user_cfd, sizeof(struct compat_consolefontdesc)))
+                return -EFAULT;
+
+        switch (cmd) {
+        case PIO_FONTX:
+                if (!perm)
+                        return -EPERM;
+                op->op = KD_FONT_OP_SET;
+                op->flags = KD_FONT_FLAG_OLD;
+                op->width = 8;
+                op->height = cfdarg.charheight;
+                op->charcount = cfdarg.charcount;
+                op->data = compat_ptr(cfdarg.chardata);
+                return con_font_op(vc_cons[fg_console].d, op);
+        case GIO_FONTX:
+                op->op = KD_FONT_OP_GET;
+                op->flags = KD_FONT_FLAG_OLD;
+                op->width = 8;
+                op->height = cfdarg.charheight;
+                op->charcount = cfdarg.charcount;
+                op->data = compat_ptr(cfdarg.chardata);
+                i = con_font_op(vc_cons[fg_console].d, op);
+                if (i)
+                        return i;
+                cfdarg.charheight = op->height;
+                cfdarg.charcount = op->charcount;
+                if (copy_to_user(user_cfd, &cfdarg, sizeof(struct compat_consolefontdesc)))
+                        return -EFAULT;
+                return 0;
+        }
+        return -EINVAL;
+}
+
+struct compat_console_font_op {
+        compat_uint_t op;        /* operation code KD_FONT_OP_* */
+        compat_uint_t flags;     /* KD_FONT_FLAG_* */
+        compat_uint_t width, height;     /* font size */
+        compat_uint_t charcount;
+        compat_caddr_t data;    /* font data with height fixed to 32 */
+};
+
+static inline int
+compat_kdfontop_ioctl(struct compat_console_font_op __user *fontop,
+                         int perm, struct console_font_op *op, struct vc_data *vc)
+{
+        int i;
+
+        if (copy_from_user(op, fontop, sizeof(struct compat_console_font_op)))
+                return -EFAULT;
+        if (!perm && op->op != KD_FONT_OP_GET)
+                return -EPERM;
+        op->data = compat_ptr(((struct compat_console_font_op *)op)->data);
+        op->flags |= KD_FONT_FLAG_OLD;
+        i = con_font_op(vc, op);
+        if (i)
+                return i;
+        ((struct compat_console_font_op *)op)->data = (unsigned long)op->data;
+        if (copy_to_user(fontop, op, sizeof(struct compat_console_font_op)))
+                return -EFAULT;
+        return 0;
+}
+
+struct compat_unimapdesc {
+        unsigned short entry_ct;
+        compat_caddr_t entries;
+};
+
+static inline int
+compat_unimap_ioctl(unsigned int cmd, struct compat_unimapdesc __user *user_ud,
+                         int perm, struct vc_data *vc)
+{
+        struct compat_unimapdesc tmp;
+        struct unipair __user *tmp_entries;
+
+        if (copy_from_user(&tmp, user_ud, sizeof tmp))
+                return -EFAULT;
+        tmp_entries = compat_ptr(tmp.entries);
+        if (tmp_entries)
+                if (!access_ok(VERIFY_WRITE, tmp_entries,
+                                tmp.entry_ct*sizeof(struct unipair)))
+                        return -EFAULT;
+        switch (cmd) {
+        case PIO_UNIMAP:
+                if (!perm)
+                        return -EPERM;
+                return con_set_unimap(vc, tmp.entry_ct, tmp_entries);
+        case GIO_UNIMAP:
+                if (!perm && fg_console != vc->vc_num)
+                        return -EPERM;
+                return con_get_unimap(vc, tmp.entry_ct, &(user_ud->entry_ct), tmp_entries);
+        }
+        return 0;
+}
+
+long vt_compat_ioctl(struct tty_struct *tty, struct file * file,
+             unsigned int cmd, unsigned long arg)
+{
+        struct vc_data *vc = tty->driver_data;
+        struct console_font_op op;      /* used in multiple places here */
+        struct kbd_struct *kbd;
+        unsigned int console;
+        void __user *up = (void __user *)arg;
+        int perm;
+        int ret = 0;
+
+        console = vc->vc_num;
+
+        lock_kernel();
+
+        if (!vc_cons_allocated(console)) {      /* impossible? */
+                ret = -ENOIOCTLCMD;
+                goto out;
+        }
+
+        /*
+         * To have permissions to do most of the vt ioctls, we either have
+         * to be the owner of the tty, or have CAP_SYS_TTY_CONFIG.
+         */
+        perm = 0;
+        if (current->signal->tty == tty || capable(CAP_SYS_TTY_CONFIG))
+                perm = 1;
+
+        kbd = kbd_table + console;
+        switch (cmd) {
+        /*
+         * these need special handlers for incompatible data structures
+         */
+        case PIO_FONTX:
+        case GIO_FONTX:
+                ret = compat_fontx_ioctl(cmd, up, perm, &op);
+                break;
+
+        case KDFONTOP:
+                ret = compat_kdfontop_ioctl(up, perm, &op, vc);
+                break;
+
+        case PIO_UNIMAP:
+        case GIO_UNIMAP:
+                ret = do_unimap_ioctl(cmd, up, perm, vc);
+                break;
+
+        /*
+         * all these treat 'arg' as an integer
+         */
+        case KIOCSOUND:
+        case KDMKTONE:
+#ifdef CONFIG_X86
+        case KDADDIO:
+        case KDDELIO:
+#endif
+        case KDSETMODE:
+        case KDMAPDISP:
+        case KDUNMAPDISP:
+        case KDSKBMODE:
+        case KDSKBMETA:
+        case KDSKBLED:
+        case KDSETLED:
+        case KDSIGACCEPT:
+        case VT_ACTIVATE:
+        case VT_WAITACTIVE:
+        case VT_RELDISP:
+        case VT_DISALLOCATE:
+        case VT_RESIZE:
+        case VT_RESIZEX:
+                goto fallback;
+
+        /*
+         * the rest has a compatible data structure behind arg,
+         * but we have to convert it to a proper 64 bit pointer.
+         */
+        default:
+                arg = (unsigned long)compat_ptr(arg);
+                goto fallback;
+        }
+out:
+        unlock_kernel();
+        return ret;
+
+fallback:
+        unlock_kernel();
+        return vt_ioctl(tty, file, cmd, arg);
+}
+
+
+#endif /* CONFIG_COMPAT */
+
+
 /*
- * Performs the back end of a vt switch
+ * Performs the back end of a vt switch. Called under the console
+ * semaphore.
  */
 static void complete_change_console(struct vc_data *vc)
 {
         unsigned char old_vc_mode;
+        int old = fg_console;
 
         last_console = fg_console;
 
@@ -1325,7 +1650,7 @@ static void complete_change_console(struct vc_data *vc)
         /*
          * Wake anyone waiting for their VT to activate
          */
-        vt_wake_waitactive();
+        vt_event_post(VT_EVENT_SWITCH, old, vc->vc_num);
         return;
 }
 
@@ -1398,3 +1723,58 @@ void change_console(struct vc_data *new_vc)
 
         complete_change_console(new_vc);
 }
+
+/* Perform a kernel triggered VT switch for suspend/resume */
+
+static int disable_vt_switch;
+
+int vt_move_to_console(unsigned int vt, int alloc)
+{
+        int prev;
+
+        acquire_console_sem();
+        /* Graphics mode - up to X */
+        if (disable_vt_switch) {
+                release_console_sem();
+                return 0;
+        }
+        prev = fg_console;
+
+        if (alloc && vc_allocate(vt)) {
+                /* we can't have a free VC for now. Too bad,
+                 * we don't want to mess the screen for now. */
+                release_console_sem();
+                return -ENOSPC;
+        }
+
+        if (set_console(vt)) {
+                /*
+                 * We're unable to switch to the SUSPEND_CONSOLE.
+                 * Let the calling function know so it can decide
+                 * what to do.
+                 */
+                release_console_sem();
+                return -EIO;
+        }
+        release_console_sem();
+        if (vt_waitactive(vt + 1)) {
+                pr_debug("Suspend: Can't switch VCs.");
+                return -EINTR;
+        }
+        return prev;
+}
+
+/*
+ * Normally during a suspend, we allocate a new console and switch to it.
+ * When we resume, we switch back to the original console.  This switch
+ * can be slow, so on systems where the framebuffer can handle restoration
+ * of video registers anyways, there's little point in doing the console
+ * switch.  This function allows you to disable it by passing it '0'.
+ */
+void pm_set_vt_switch(int do_switch)
+{
+        acquire_console_sem();
+        disable_vt_switch = !do_switch;
+        release_console_sem();
+}
+EXPORT_SYMBOL(pm_set_vt_switch);
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 2968ed6a9c49..3938c7817095 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -61,6 +61,8 @@ static DEFINE_SPINLOCK(cpufreq_driver_lock);
  *   are concerned with are online after they get the lock.
  * - Governor routines that can be called in cpufreq hotplug path should not
  *   take this sem as top level hotplug notifier handler takes this.
+ * - Lock should not be held across
+ *     __cpufreq_governor(data, CPUFREQ_GOV_STOP);
  */
 static DEFINE_PER_CPU(int, policy_cpu);
 static DEFINE_PER_CPU(struct rw_semaphore, cpu_policy_rwsem);
@@ -686,6 +688,9 @@ static struct attribute *default_attrs[] = {
         NULL
 };
 
+struct kobject *cpufreq_global_kobject;
+EXPORT_SYMBOL(cpufreq_global_kobject);
+
 #define to_policy(k) container_of(k, struct cpufreq_policy, kobj)
 #define to_attr(a) container_of(a, struct freq_attr, attr)
 
@@ -756,92 +761,20 @@ static struct kobj_type ktype_cpufreq = {
         .release        = cpufreq_sysfs_release,
 };
 
-
-/**
- * cpufreq_add_dev - add a CPU device
- *
- * Adds the cpufreq interface for a CPU device.
- *
- * The Oracle says: try running cpufreq registration/unregistration concurrently
- * with with cpu hotplugging and all hell will break loose. Tried to clean this
- * mess up, but more thorough testing is needed. - Mathieu
+/*
+ * Returns:
+ *   Negative: Failure
+ *   0:        Success
+ *   Positive: When we have a managed CPU and the sysfs got symlinked
  */
-static int cpufreq_add_dev(struct sys_device *sys_dev)
+int cpufreq_add_dev_policy(unsigned int cpu, struct cpufreq_policy *policy,
+                struct sys_device *sys_dev)
 {
-        unsigned int cpu = sys_dev->id;
         int ret = 0;
-        struct cpufreq_policy new_policy;
-        struct cpufreq_policy *policy;
-        struct freq_attr **drv_attr;
-        struct sys_device *cpu_sys_dev;
+#ifdef CONFIG_SMP
         unsigned long flags;
         unsigned int j;
 
-        if (cpu_is_offline(cpu))
-                return 0;
-
-        cpufreq_debug_disable_ratelimit();
-        dprintk("adding CPU %u\n", cpu);
-
-#ifdef CONFIG_SMP
-        /* check whether a different CPU already registered this
-         * CPU because it is in the same boat. */
-        policy = cpufreq_cpu_get(cpu);
-        if (unlikely(policy)) {
-                cpufreq_cpu_put(policy);
-                cpufreq_debug_enable_ratelimit();
-                return 0;
-        }
-#endif
-
-        if (!try_module_get(cpufreq_driver->owner)) {
-                ret = -EINVAL;
-                goto module_out;
-        }
-
-        policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
-        if (!policy) {
-                ret = -ENOMEM;
-                goto nomem_out;
-        }
-        if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL)) {
-                ret = -ENOMEM;
-                goto err_free_policy;
-        }
-        if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL)) {
-                ret = -ENOMEM;
-                goto err_free_cpumask;
-        }
-
-        policy->cpu = cpu;
-        cpumask_copy(policy->cpus, cpumask_of(cpu));
-
-        /* Initially set CPU itself as the policy_cpu */
-        per_cpu(policy_cpu, cpu) = cpu;
-        ret = (lock_policy_rwsem_write(cpu) < 0);
-        WARN_ON(ret);
-
-        init_completion(&policy->kobj_unregister);
-        INIT_WORK(&policy->update, handle_update);
-
-        /* Set governor before ->init, so that driver could check it */
-        policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
-        /* call driver. From then on the cpufreq must be able
-         * to accept all calls to ->verify and ->setpolicy for this CPU
-         */
-        ret = cpufreq_driver->init(policy);
-        if (ret) {
-                dprintk("initialization failed\n");
-                goto err_unlock_policy;
-        }
-        policy->user_policy.min = policy->min;
-        policy->user_policy.max = policy->max;
-
-        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
-                                     CPUFREQ_START, policy);
-
-#ifdef CONFIG_SMP
-
 #ifdef CONFIG_HOTPLUG_CPU
         if (per_cpu(cpufreq_cpu_governor, cpu)) {
                 policy->governor = per_cpu(cpufreq_cpu_governor, cpu);
@@ -872,9 +805,8 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                                 /* Should not go through policy unlock path */
                                 if (cpufreq_driver->exit)
                                         cpufreq_driver->exit(policy);
-                                ret = -EBUSY;
                                 cpufreq_cpu_put(managed_policy);
-                                goto err_free_cpumask;
+                                return -EBUSY;
                         }
 
                         spin_lock_irqsave(&cpufreq_driver_lock, flags);
@@ -893,17 +825,62 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
                          * Call driver->exit() because only the cpu parent of
                          * the kobj needed to call init().
                          */
-                        goto out_driver_exit; /* call driver->exit() */
+                        if (cpufreq_driver->exit)
+                                cpufreq_driver->exit(policy);
+
+                        if (!ret)
+                                return 1;
+                        else
+                                return ret;
                 }
         }
 #endif
-        memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
+        return ret;
+}
+
+
+/* symlink affected CPUs */
+int cpufreq_add_dev_symlink(unsigned int cpu, struct cpufreq_policy *policy)
+{
+        unsigned int j;
+        int ret = 0;
+
+        for_each_cpu(j, policy->cpus) {
+                struct cpufreq_policy *managed_policy;
+                struct sys_device *cpu_sys_dev;
+
+                if (j == cpu)
+                        continue;
+                if (!cpu_online(j))
+                        continue;
+
+                dprintk("CPU %u already managed, adding link\n", j);
+                managed_policy = cpufreq_cpu_get(cpu);
+                cpu_sys_dev = get_cpu_sysdev(j);
+                ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
+                                        "cpufreq");
+                if (ret) {
+                        cpufreq_cpu_put(managed_policy);
+                        return ret;
+                }
+        }
+        return ret;
+}
+
+int cpufreq_add_dev_interface(unsigned int cpu, struct cpufreq_policy *policy,
+                struct sys_device *sys_dev)
+{
+        struct cpufreq_policy new_policy;
+        struct freq_attr **drv_attr;
+        unsigned long flags;
+        int ret = 0;
+        unsigned int j;
 
         /* prepare interface data */
-        ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq, &sys_dev->kobj,
-                                   "cpufreq");
+        ret = kobject_init_and_add(&policy->kobj, &ktype_cpufreq,
+                                   &sys_dev->kobj, "cpufreq");
         if (ret)
-                goto out_driver_exit;
+                return ret;
 
         /* set up files for this cpu device */
         drv_attr = cpufreq_driver->attr;
@@ -926,35 +903,20 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 
         spin_lock_irqsave(&cpufreq_driver_lock, flags);
         for_each_cpu(j, policy->cpus) {
-                if (!cpu_online(j))
-                        continue;
+        if (!cpu_online(j))
+                continue;
                 per_cpu(cpufreq_cpu_data, j) = policy;
                 per_cpu(policy_cpu, j) = policy->cpu;
         }
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-        /* symlink affected CPUs */
-        for_each_cpu(j, policy->cpus) {
-                struct cpufreq_policy *managed_policy;
-
-                if (j == cpu)
-                        continue;
-                if (!cpu_online(j))
-                        continue;
-
-                dprintk("CPU %u already managed, adding link\n", j);
-                managed_policy = cpufreq_cpu_get(cpu);
-                cpu_sys_dev = get_cpu_sysdev(j);
-                ret = sysfs_create_link(&cpu_sys_dev->kobj, &policy->kobj,
-                                        "cpufreq");
-                if (ret) {
-                        cpufreq_cpu_put(managed_policy);
-                        goto err_out_unregister;
-                }
-        }
+        ret = cpufreq_add_dev_symlink(cpu, policy);
+        if (ret)
+                goto err_out_kobj_put;
 
-        policy->governor = NULL; /* to assure that the starting sequence is
-                                  * run in cpufreq_set_policy */
+        memcpy(&new_policy, policy, sizeof(struct cpufreq_policy));
+        /* assure that the starting sequence is run in __cpufreq_set_policy */
+        policy->governor = NULL;
 
         /* set default policy */
         ret = __cpufreq_set_policy(policy, &new_policy);
@@ -963,8 +925,107 @@ static int cpufreq_add_dev(struct sys_device *sys_dev)
 
         if (ret) {
                 dprintk("setting policy failed\n");
-                goto err_out_unregister;
+                if (cpufreq_driver->exit)
+                        cpufreq_driver->exit(policy);
+        }
+        return ret;
+
+err_out_kobj_put:
+        kobject_put(&policy->kobj);
+        wait_for_completion(&policy->kobj_unregister);
+        return ret;
+}
+
+
+/**
+ * cpufreq_add_dev - add a CPU device
+ *
+ * Adds the cpufreq interface for a CPU device.
+ *
+ * The Oracle says: try running cpufreq registration/unregistration concurrently
+ * with with cpu hotplugging and all hell will break loose. Tried to clean this
+ * mess up, but more thorough testing is needed. - Mathieu
+ */
+static int cpufreq_add_dev(struct sys_device *sys_dev)
+{
+        unsigned int cpu = sys_dev->id;
+        int ret = 0;
+        struct cpufreq_policy *policy;
+        unsigned long flags;
+        unsigned int j;
+
+        if (cpu_is_offline(cpu))
+                return 0;
+
+        cpufreq_debug_disable_ratelimit();
+        dprintk("adding CPU %u\n", cpu);
+
+#ifdef CONFIG_SMP
+        /* check whether a different CPU already registered this
+         * CPU because it is in the same boat. */
+        policy = cpufreq_cpu_get(cpu);
+        if (unlikely(policy)) {
+                cpufreq_cpu_put(policy);
+                cpufreq_debug_enable_ratelimit();
+                return 0;
+        }
+#endif
+
+        if (!try_module_get(cpufreq_driver->owner)) {
+                ret = -EINVAL;
+                goto module_out;
+        }
+
+        ret = -ENOMEM;
+        policy = kzalloc(sizeof(struct cpufreq_policy), GFP_KERNEL);
+        if (!policy)
+                goto nomem_out;
+
+        if (!alloc_cpumask_var(&policy->cpus, GFP_KERNEL))
+                goto err_free_policy;
+
+        if (!zalloc_cpumask_var(&policy->related_cpus, GFP_KERNEL))
+                goto err_free_cpumask;
+
+        policy->cpu = cpu;
+        cpumask_copy(policy->cpus, cpumask_of(cpu));
+
+        /* Initially set CPU itself as the policy_cpu */
+        per_cpu(policy_cpu, cpu) = cpu;
+        ret = (lock_policy_rwsem_write(cpu) < 0);
+        WARN_ON(ret);
+
+        init_completion(&policy->kobj_unregister);
+        INIT_WORK(&policy->update, handle_update);
+
+        /* Set governor before ->init, so that driver could check it */
+        policy->governor = CPUFREQ_DEFAULT_GOVERNOR;
+        /* call driver. From then on the cpufreq must be able
+         * to accept all calls to ->verify and ->setpolicy for this CPU
+         */
+        ret = cpufreq_driver->init(policy);
+        if (ret) {
+                dprintk("initialization failed\n");
+                goto err_unlock_policy;
         }
+        policy->user_policy.min = policy->min;
+        policy->user_policy.max = policy->max;
+
+        blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
+                                     CPUFREQ_START, policy);
+
+        ret = cpufreq_add_dev_policy(cpu, policy, sys_dev);
+        if (ret) {
+                if (ret > 0)
+                        /* This is a managed cpu, symlink created,
+                           exit with 0 */
+                        ret = 0;
+                goto err_unlock_policy;
+        }
+
+        ret = cpufreq_add_dev_interface(cpu, policy, sys_dev);
+        if (ret)
+                goto err_out_unregister;
 
         unlock_policy_rwsem_write(cpu);
 
@@ -982,14 +1043,9 @@ err_out_unregister:
                 per_cpu(cpufreq_cpu_data, j) = NULL;
         spin_unlock_irqrestore(&cpufreq_driver_lock, flags);
 
-err_out_kobj_put:
         kobject_put(&policy->kobj);
         wait_for_completion(&policy->kobj_unregister);
 
-out_driver_exit:
-        if (cpufreq_driver->exit)
-                cpufreq_driver->exit(policy);
-
 err_unlock_policy:
         unlock_policy_rwsem_write(cpu);
 err_free_cpumask:
@@ -1653,8 +1709,17 @@ static int __cpufreq_set_policy(struct cpufreq_policy *data,
                         dprintk("governor switch\n");
 
                         /* end old governor */
-                        if (data->governor)
+                        if (data->governor) {
+                                /*
+                                 * Need to release the rwsem around governor
+                                 * stop due to lock dependency between
+                                 * cancel_delayed_work_sync and the read lock
+                                 * taken in the delayed work handler.
+                                 */
+                                unlock_policy_rwsem_write(data->cpu);
                                 __cpufreq_governor(data, CPUFREQ_GOV_STOP);
+                                lock_policy_rwsem_write(data->cpu);
+                        }
 
                         /* start new governor */
                         data->governor = policy->governor;
@@ -1884,7 +1949,11 @@ static int __init cpufreq_core_init(void)
                 per_cpu(policy_cpu, cpu) = -1;
                 init_rwsem(&per_cpu(cpu_policy_rwsem, cpu));
         }
+
+        cpufreq_global_kobject = kobject_create_and_add("cpufreq",
+                                                &cpu_sysdev_class.kset.kobj);
+        BUG_ON(!cpufreq_global_kobject);
+
         return 0;
 }
-
 core_initcall(cpufreq_core_init);
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index d7a528c80de8..071699de50ee 100644
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -55,6 +55,18 @@ static unsigned int min_sampling_rate;
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000 * 1000)
 
 static void do_dbs_timer(struct work_struct *work);
+static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
+                                unsigned int event);
+
+#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
+static
+#endif
+struct cpufreq_governor cpufreq_gov_ondemand = {
+       .name                   = "ondemand",
+       .governor               = cpufreq_governor_dbs,
+       .max_transition_latency = TRANSITION_LATENCY_LIMIT,
+       .owner                  = THIS_MODULE,
+};
 
 /* Sampling types */
 enum {DBS_NORMAL_SAMPLE, DBS_SUB_SAMPLE};
@@ -207,20 +219,23 @@ static void ondemand_powersave_bias_init(void)
 }
 
 /************************** sysfs interface ************************/
-static ssize_t show_sampling_rate_max(struct cpufreq_policy *policy, char *buf)
+
+static ssize_t show_sampling_rate_max(struct kobject *kobj,
+                                      struct attribute *attr, char *buf)
 {
         printk_once(KERN_INFO "CPUFREQ: ondemand sampling_rate_max "
                "sysfs file is deprecated - used by: %s\n", current->comm);
         return sprintf(buf, "%u\n", -1U);
 }
 
-static ssize_t show_sampling_rate_min(struct cpufreq_policy *policy, char *buf)
+static ssize_t show_sampling_rate_min(struct kobject *kobj,
+                                      struct attribute *attr, char *buf)
 {
         return sprintf(buf, "%u\n", min_sampling_rate);
 }
 
 #define define_one_ro(_name)            \
-static struct freq_attr _name =         \
+static struct global_attr _name =       \
 __ATTR(_name, 0444, show_##_name, NULL)
 
 define_one_ro(sampling_rate_max);
@@ -229,7 +244,7 @@ define_one_ro(sampling_rate_min);
 /* cpufreq_ondemand Governor Tunables */
 #define show_one(file_name, object)                                     \
 static ssize_t show_##file_name                                         \
-(struct cpufreq_policy *unused, char *buf)                              \
+(struct kobject *kobj, struct attribute *attr, char *buf)              \
 {                                                                       \
         return sprintf(buf, "%u\n", dbs_tuners_ins.object);             \
 }
@@ -238,8 +253,38 @@ show_one(up_threshold, up_threshold);
 show_one(ignore_nice_load, ignore_nice);
 show_one(powersave_bias, powersave_bias);
 
-static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+/*** delete after deprecation time ***/
+
+#define DEPRECATION_MSG(file_name)                                      \
+        printk_once(KERN_INFO "CPUFREQ: Per core ondemand sysfs "       \
+                    "interface is deprecated - " #file_name "\n");
+
+#define show_one_old(file_name)                                         \
+static ssize_t show_##file_name##_old                                   \
+(struct cpufreq_policy *unused, char *buf)                              \
+{                                                                       \
+        printk_once(KERN_INFO "CPUFREQ: Per core ondemand sysfs "       \
+                    "interface is deprecated - " #file_name "\n");      \
+        return show_##file_name(NULL, NULL, buf);                       \
+}
+show_one_old(sampling_rate);
+show_one_old(up_threshold);
+show_one_old(ignore_nice_load);
+show_one_old(powersave_bias);
+show_one_old(sampling_rate_min);
+show_one_old(sampling_rate_max);
+
+#define define_one_ro_old(object, _name)       \
+static struct freq_attr object =               \
+__ATTR(_name, 0444, show_##_name##_old, NULL)
+
+define_one_ro_old(sampling_rate_min_old, sampling_rate_min);
+define_one_ro_old(sampling_rate_max_old, sampling_rate_max);
+
+/*** delete after deprecation time ***/
+
+static ssize_t store_sampling_rate(struct kobject *a, struct attribute *b,
+                                   const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -254,8 +299,8 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused,
         return count;
 }
 
-static ssize_t store_up_threshold(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+static ssize_t store_up_threshold(struct kobject *a, struct attribute *b,
+                                  const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -273,8 +318,8 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused,
         return count;
 }
 
-static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
-                const char *buf, size_t count)
+static ssize_t store_ignore_nice_load(struct kobject *a, struct attribute *b,
+                                      const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -310,8 +355,8 @@ static ssize_t store_ignore_nice_load(struct cpufreq_policy *policy,
         return count;
 }
 
-static ssize_t store_powersave_bias(struct cpufreq_policy *unused,
-                const char *buf, size_t count)
+static ssize_t store_powersave_bias(struct kobject *a, struct attribute *b,
+                                    const char *buf, size_t count)
 {
         unsigned int input;
         int ret;
@@ -332,7 +377,7 @@ static ssize_t store_powersave_bias(struct cpufreq_policy *unused,
 }
 
 #define define_one_rw(_name) \
-static struct freq_attr _name = \
+static struct global_attr _name = \
 __ATTR(_name, 0644, show_##_name, store_##_name)
 
 define_one_rw(sampling_rate);
@@ -355,6 +400,47 @@ static struct attribute_group dbs_attr_group = {
         .name = "ondemand",
 };
 
+/*** delete after deprecation time ***/
+
+#define write_one_old(file_name)                                        \
+static ssize_t store_##file_name##_old                                  \
+(struct cpufreq_policy *unused, const char *buf, size_t count)          \
+{                                                                       \
+       printk_once(KERN_INFO "CPUFREQ: Per core ondemand sysfs "        \
+                   "interface is deprecated - " #file_name "\n");       \
+       return store_##file_name(NULL, NULL, buf, count);                \
+}
+write_one_old(sampling_rate);
+write_one_old(up_threshold);
+write_one_old(ignore_nice_load);
+write_one_old(powersave_bias);
+
+#define define_one_rw_old(object, _name)       \
+static struct freq_attr object =               \
+__ATTR(_name, 0644, show_##_name##_old, store_##_name##_old)
+
+define_one_rw_old(sampling_rate_old, sampling_rate);
+define_one_rw_old(up_threshold_old, up_threshold);
+define_one_rw_old(ignore_nice_load_old, ignore_nice_load);
+define_one_rw_old(powersave_bias_old, powersave_bias);
+
+static struct attribute *dbs_attributes_old[] = {
+       &sampling_rate_max_old.attr,
+       &sampling_rate_min_old.attr,
+       &sampling_rate_old.attr,
+       &up_threshold_old.attr,
+       &ignore_nice_load_old.attr,
+       &powersave_bias_old.attr,
+       NULL
+};
+
+static struct attribute_group dbs_attr_group_old = {
+       .attrs = dbs_attributes_old,
+       .name = "ondemand",
+};
+
+/*** delete after deprecation time ***/
+
 /************************** sysfs end ************************/
 
 static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info)
@@ -545,7 +631,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
 
                 mutex_lock(&dbs_mutex);
 
-                rc = sysfs_create_group(&policy->kobj, &dbs_attr_group);
+                rc = sysfs_create_group(&policy->kobj, &dbs_attr_group_old);
                 if (rc) {
                         mutex_unlock(&dbs_mutex);
                         return rc;
@@ -566,13 +652,20 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 }
                 this_dbs_info->cpu = cpu;
                 ondemand_powersave_bias_init_cpu(cpu);
-                mutex_init(&this_dbs_info->timer_mutex);
                 /*
                  * Start the timerschedule work, when this governor
                  * is used for first time
                  */
                 if (dbs_enable == 1) {
                         unsigned int latency;
+
+                        rc = sysfs_create_group(cpufreq_global_kobject,
+                                                &dbs_attr_group);
+                        if (rc) {
+                                mutex_unlock(&dbs_mutex);
+                                return rc;
+                        }
+
                         /* policy latency is in nS. Convert it to uS first */
                         latency = policy->cpuinfo.transition_latency / 1000;
                         if (latency == 0)
@@ -586,6 +679,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 }
                 mutex_unlock(&dbs_mutex);
 
+                mutex_init(&this_dbs_info->timer_mutex);
                 dbs_timer_init(this_dbs_info);
                 break;
 
@@ -593,10 +687,13 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
                 dbs_timer_exit(this_dbs_info);
 
                 mutex_lock(&dbs_mutex);
-                sysfs_remove_group(&policy->kobj, &dbs_attr_group);
+                sysfs_remove_group(&policy->kobj, &dbs_attr_group_old);
                 mutex_destroy(&this_dbs_info->timer_mutex);
                 dbs_enable--;
                 mutex_unlock(&dbs_mutex);
+                if (!dbs_enable)
+                        sysfs_remove_group(cpufreq_global_kobject,
+                                           &dbs_attr_group);
 
                 break;
 
@@ -614,16 +711,6 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
         return 0;
 }
 
-#ifndef CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND
-static
-#endif
-struct cpufreq_governor cpufreq_gov_ondemand = {
-        .name                   = "ondemand",
-        .governor               = cpufreq_governor_dbs,
-        .max_transition_latency = TRANSITION_LATENCY_LIMIT,
-        .owner                  = THIS_MODULE,
-};
-
 static int __init cpufreq_gov_dbs_init(void)
 {
         int err;
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 96dda81c9228..6b4c484a699a 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -155,6 +155,13 @@ config GPIO_TWL4030
           Say yes here to access the GPIO signals of various multi-function
           power management chips from Texas Instruments.
 
+config GPIO_WM831X
+        tristate "WM831x GPIOs"
+        depends on MFD_WM831X
+        help
+          Say yes here to access the GPIO signals of WM831x power management
+          chips from Wolfson Microelectronics.
+
 comment "PCI GPIO expanders:"
 
 config GPIO_BT8XX
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 9244c6fcd8be..ea7c745f26a8 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -14,3 +14,4 @@ obj-$(CONFIG_GPIO_TWL4030)	+= twl4030-gpio.o
 obj-$(CONFIG_GPIO_XILINX)       += xilinx_gpio.o
 obj-$(CONFIG_GPIO_BT8XX)        += bt8xxgpio.o
 obj-$(CONFIG_GPIO_VR41XX)       += vr41xx_giu.o
+obj-$(CONFIG_GPIO_WM831X)       += wm831x-gpio.o
diff --git a/drivers/gpio/wm831x-gpio.c b/drivers/gpio/wm831x-gpio.c
new file mode 100644
index 000000000000..f9c09a54ec7f
--- /dev/null
+++ b/drivers/gpio/wm831x-gpio.c
@@ -0,0 +1,252 @@
+/*
+ * wm831x-gpio.c  --  gpiolib support for Wolfson WM831x PMICs
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/mfd/core.h>
+#include <linux/platform_device.h>
+#include <linux/seq_file.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/pdata.h>
+#include <linux/mfd/wm831x/gpio.h>
+
+#define WM831X_GPIO_MAX 16
+
+struct wm831x_gpio {
+        struct wm831x *wm831x;
+        struct gpio_chip gpio_chip;
+};
+
+static inline struct wm831x_gpio *to_wm831x_gpio(struct gpio_chip *chip)
+{
+        return container_of(chip, struct wm831x_gpio, gpio_chip);
+}
+
+static int wm831x_gpio_direction_in(struct gpio_chip *chip, unsigned offset)
+{
+        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x *wm831x = wm831x_gpio->wm831x;
+
+        return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,
+                               WM831X_GPN_DIR | WM831X_GPN_TRI,
+                               WM831X_GPN_DIR);
+}
+
+static int wm831x_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x *wm831x = wm831x_gpio->wm831x;
+        int ret;
+
+        ret = wm831x_reg_read(wm831x, WM831X_GPIO_LEVEL);
+        if (ret < 0)
+                return ret;
+
+        if (ret & 1 << offset)
+                return 1;
+        else
+                return 0;
+}
+
+static int wm831x_gpio_direction_out(struct gpio_chip *chip,
+                                     unsigned offset, int value)
+{
+        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x *wm831x = wm831x_gpio->wm831x;
+
+        return wm831x_set_bits(wm831x, WM831X_GPIO1_CONTROL + offset,
+                               WM831X_GPN_DIR | WM831X_GPN_TRI, 0);
+}
+
+static void wm831x_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x *wm831x = wm831x_gpio->wm831x;
+
+        wm831x_set_bits(wm831x, WM831X_GPIO_LEVEL, 1 << offset,
+                        value << offset);
+}
+
+#ifdef CONFIG_DEBUG_FS
+static void wm831x_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
+{
+        struct wm831x_gpio *wm831x_gpio = to_wm831x_gpio(chip);
+        struct wm831x *wm831x = wm831x_gpio->wm831x;
+        int i;
+
+        for (i = 0; i < chip->ngpio; i++) {
+                int gpio = i + chip->base;
+                int reg;
+                const char *label, *pull, *powerdomain;
+
+                /* We report the GPIO even if it's not requested since
+                 * we're also reporting things like alternate
+                 * functions which apply even when the GPIO is not in
+                 * use as a GPIO.
+                 */
+                label = gpiochip_is_requested(chip, i);
+                if (!label)
+                        label = "Unrequested";
+
+                seq_printf(s, " gpio-%-3d (%-20.20s) ", gpio, label);
+
+                reg = wm831x_reg_read(wm831x, WM831X_GPIO1_CONTROL + i);
+                if (reg < 0) {
+                        dev_err(wm831x->dev,
+                                "GPIO control %d read failed: %d\n",
+                                gpio, reg);
+                        seq_printf(s, "\n");
+                        continue;
+                }
+
+                switch (reg & WM831X_GPN_PULL_MASK) {
+                case WM831X_GPIO_PULL_NONE:
+                        pull = "nopull";
+                        break;
+                case WM831X_GPIO_PULL_DOWN:
+                        pull = "pulldown";
+                        break;
+                case WM831X_GPIO_PULL_UP:
+                        pull = "pullup";
+                default:
+                        pull = "INVALID PULL";
+                        break;
+                }
+
+                switch (i + 1) {
+                case 1 ... 3:
+                case 7 ... 9:
+                        if (reg & WM831X_GPN_PWR_DOM)
+                                powerdomain = "VPMIC";
+                        else
+                                powerdomain = "DBVDD";
+                        break;
+
+                case 4 ... 6:
+                case 10 ... 12:
+                        if (reg & WM831X_GPN_PWR_DOM)
+                                powerdomain = "SYSVDD";
+                        else
+                                powerdomain = "DBVDD";
+                        break;
+
+                case 13 ... 16:
+                        powerdomain = "TPVDD";
+                        break;
+
+                default:
+                        BUG();
+                        break;
+                }
+
+                seq_printf(s, " %s %s %s %s%s\n"
+                           "                                  %s%s (0x%4x)\n",
+                           reg & WM831X_GPN_DIR ? "in" : "out",
+                           wm831x_gpio_get(chip, i) ? "high" : "low",
+                           pull,
+                           powerdomain,
+                           reg & WM831X_GPN_POL ? " inverted" : "",
+                           reg & WM831X_GPN_OD ? "open-drain" : "CMOS",
+                           reg & WM831X_GPN_TRI ? " tristated" : "",
+                           reg);
+        }
+}
+#else
+#define wm831x_gpio_dbg_show NULL
+#endif
+
+static struct gpio_chip template_chip = {
+        .label                  = "wm831x",
+        .owner                  = THIS_MODULE,
+        .direction_input        = wm831x_gpio_direction_in,
+        .get                    = wm831x_gpio_get,
+        .direction_output       = wm831x_gpio_direction_out,
+        .set                    = wm831x_gpio_set,
+        .dbg_show               = wm831x_gpio_dbg_show,
+        .can_sleep              = 1,
+};
+
+static int __devinit wm831x_gpio_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct wm831x_gpio *wm831x_gpio;
+        int ret;
+
+        wm831x_gpio = kzalloc(sizeof(*wm831x_gpio), GFP_KERNEL);
+        if (wm831x_gpio == NULL)
+                return -ENOMEM;
+
+        wm831x_gpio->wm831x = wm831x;
+        wm831x_gpio->gpio_chip = template_chip;
+        wm831x_gpio->gpio_chip.ngpio = WM831X_GPIO_MAX;
+        wm831x_gpio->gpio_chip.dev = &pdev->dev;
+        if (pdata && pdata->gpio_base)
+                wm831x_gpio->gpio_chip.base = pdata->gpio_base;
+        else
+                wm831x_gpio->gpio_chip.base = -1;
+
+        ret = gpiochip_add(&wm831x_gpio->gpio_chip);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Could not register gpiochip, %d\n",
+                        ret);
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, wm831x_gpio);
+
+        return ret;
+
+err:
+        kfree(wm831x_gpio);
+        return ret;
+}
+
+static int __devexit wm831x_gpio_remove(struct platform_device *pdev)
+{
+        struct wm831x_gpio *wm831x_gpio = platform_get_drvdata(pdev);
+        int ret;
+
+        ret = gpiochip_remove(&wm831x_gpio->gpio_chip);
+        if (ret == 0)
+                kfree(wm831x_gpio);
+
+        return ret;
+}
+
+static struct platform_driver wm831x_gpio_driver = {
+        .driver.name    = "wm831x-gpio",
+        .driver.owner   = THIS_MODULE,
+        .probe          = wm831x_gpio_probe,
+        .remove         = __devexit_p(wm831x_gpio_remove),
+};
+
+static int __init wm831x_gpio_init(void)
+{
+        return platform_driver_register(&wm831x_gpio_driver);
+}
+subsys_initcall(wm831x_gpio_init);
+
+static void __exit wm831x_gpio_exit(void)
+{
+        platform_driver_unregister(&wm831x_gpio_driver);
+}
+module_exit(wm831x_gpio_exit);
+
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("GPIO interface for WM831x PMICs");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-gpio");
diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index f7a615b80c70..5301f226cb1c 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -76,7 +76,7 @@ static ssize_t version_show(struct class *dev, char *buf)
                        CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
 }
 
-static char *drm_nodename(struct device *dev)
+static char *drm_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
 }
@@ -112,7 +112,7 @@ struct class *drm_sysfs_create(struct module *owner, char *name)
         if (err)
                 goto err_out_class;
 
-        class->nodename = drm_nodename;
+        class->devnode = drm_devnode;
 
         return class;
 
diff --git a/drivers/hid/usbhid/hiddev.c b/drivers/hid/usbhid/hiddev.c
index 4d1dc0cf1401..8b6ee247bfe4 100644
--- a/drivers/hid/usbhid/hiddev.c
+++ b/drivers/hid/usbhid/hiddev.c
@@ -852,14 +852,14 @@ static const struct file_operations hiddev_fops = {
 #endif
 };
 
-static char *hiddev_nodename(struct device *dev)
+static char *hiddev_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
 }
 
 static struct usb_class_driver hiddev_class = {
         .name =         "hiddev%d",
-        .nodename =     hiddev_nodename,
+        .devnode =      hiddev_devnode,
         .fops =         &hiddev_fops,
         .minor_base =   HIDDEV_MINOR_BASE,
 };
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 461abb1e273a..ed7711d11ae8 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -946,6 +946,27 @@ config SENSORS_W83627EHF
           This driver can also be built as a module.  If so, the module
           will be called w83627ehf.
 
+config SENSORS_WM831X
+        tristate "WM831x PMICs"
+        depends on MFD_WM831X
+        help
+          If you say yes here you get support for the hardware
+          monitoring functionality of the Wolfson Microelectronics
+          WM831x series of PMICs.
+
+          This driver can also be built as a module.  If so, the module
+          will be called wm831x-hwmon.
+
+config SENSORS_WM8350
+        tristate "Wolfson Microelectronics WM835x"
+        depends on MFD_WM8350
+        help
+          If you say yes here you get support for the hardware
+          monitoring features of the WM835x series of PMICs.
+
+          This driver can also be built as a module.  If so, the module
+          will be called wm8350-hwmon.
+
 config SENSORS_ULTRA45
         tristate "Sun Ultra45 PIC16F747"
         depends on SPARC64
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 2e547881bc0a..bcf73a9bb619 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -93,6 +93,8 @@ obj-$(CONFIG_SENSORS_VT8231)	+= vt8231.o
 obj-$(CONFIG_SENSORS_W83627EHF) += w83627ehf.o
 obj-$(CONFIG_SENSORS_W83L785TS) += w83l785ts.o
 obj-$(CONFIG_SENSORS_W83L786NG) += w83l786ng.o
+obj-$(CONFIG_SENSORS_WM831X)    += wm831x-hwmon.o
+obj-$(CONFIG_SENSORS_WM8350)    += wm8350-hwmon.o
 
 ifeq ($(CONFIG_HWMON_DEBUG_CHIP),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/hwmon/wm831x-hwmon.c b/drivers/hwmon/wm831x-hwmon.c
new file mode 100644
index 000000000000..c16e9e74c356
--- /dev/null
+++ b/drivers/hwmon/wm831x-hwmon.c
@@ -0,0 +1,226 @@
+/*
+ * drivers/hwmon/wm831x-hwmon.c - Wolfson Microelectronics WM831x PMIC
+ *                                hardware monitoring features.
+ *
+ * Copyright (C) 2009 Wolfson Microelectronics plc
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License v2 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/auxadc.h>
+
+struct wm831x_hwmon {
+        struct wm831x *wm831x;
+        struct device *classdev;
+};
+
+static ssize_t show_name(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "wm831x\n");
+}
+
+static const char *input_names[] = {
+        [WM831X_AUX_SYSVDD]    = "SYSVDD",
+        [WM831X_AUX_USB]       = "USB",
+        [WM831X_AUX_BKUP_BATT] = "Backup battery",
+        [WM831X_AUX_BATT]      = "Battery",
+        [WM831X_AUX_WALL]      = "WALL",
+        [WM831X_AUX_CHIP_TEMP] = "PMIC",
+        [WM831X_AUX_BATT_TEMP] = "Battery",
+};
+
+
+static ssize_t show_voltage(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+        struct wm831x_hwmon *hwmon = dev_get_drvdata(dev);
+        int channel = to_sensor_dev_attr(attr)->index;
+        int ret;
+
+        ret = wm831x_auxadc_read_uv(hwmon->wm831x, channel);
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%d\n", DIV_ROUND_CLOSEST(ret, 1000));
+}
+
+static ssize_t show_chip_temp(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct wm831x_hwmon *hwmon = dev_get_drvdata(dev);
+        int channel = to_sensor_dev_attr(attr)->index;
+        int ret;
+
+        ret = wm831x_auxadc_read(hwmon->wm831x, channel);
+        if (ret < 0)
+                return ret;
+
+        /* Degrees celsius = (512.18-ret) / 1.0983 */
+        ret = 512180 - (ret * 1000);
+        ret = DIV_ROUND_CLOSEST(ret * 10000, 10983);
+
+        return sprintf(buf, "%d\n", ret);
+}
+
+static ssize_t show_label(struct device *dev,
+                          struct device_attribute *attr, char *buf)
+{
+        int channel = to_sensor_dev_attr(attr)->index;
+
+        return sprintf(buf, "%s\n", input_names[channel]);
+}
+
+#define WM831X_VOLTAGE(id, name) \
+        static SENSOR_DEVICE_ATTR(in##id##_input, S_IRUGO, show_voltage, \
+                                  NULL, name)
+
+#define WM831X_NAMED_VOLTAGE(id, name) \
+        WM831X_VOLTAGE(id, name); \
+        static SENSOR_DEVICE_ATTR(in##id##_label, S_IRUGO, show_label,  \
+                                  NULL, name)
+
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
+WM831X_VOLTAGE(0, WM831X_AUX_AUX1);
+WM831X_VOLTAGE(1, WM831X_AUX_AUX2);
+WM831X_VOLTAGE(2, WM831X_AUX_AUX3);
+WM831X_VOLTAGE(3, WM831X_AUX_AUX4);
+
+WM831X_NAMED_VOLTAGE(4, WM831X_AUX_SYSVDD);
+WM831X_NAMED_VOLTAGE(5, WM831X_AUX_USB);
+WM831X_NAMED_VOLTAGE(6, WM831X_AUX_BATT);
+WM831X_NAMED_VOLTAGE(7, WM831X_AUX_WALL);
+WM831X_NAMED_VOLTAGE(8, WM831X_AUX_BKUP_BATT);
+
+static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, show_chip_temp, NULL,
+                          WM831X_AUX_CHIP_TEMP);
+static SENSOR_DEVICE_ATTR(temp1_label, S_IRUGO, show_label, NULL,
+                          WM831X_AUX_CHIP_TEMP);
+/* Report as a voltage since conversion depends on external components
+ * and that's what the ABI wants. */
+static SENSOR_DEVICE_ATTR(temp2_input, S_IRUGO, show_voltage, NULL,
+                          WM831X_AUX_BATT_TEMP);
+static SENSOR_DEVICE_ATTR(temp2_label, S_IRUGO, show_label, NULL,
+                          WM831X_AUX_BATT_TEMP);
+
+static struct attribute *wm831x_attributes[] = {
+        &dev_attr_name.attr,
+
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in3_input.dev_attr.attr,
+
+        &sensor_dev_attr_in4_input.dev_attr.attr,
+        &sensor_dev_attr_in4_label.dev_attr.attr,
+        &sensor_dev_attr_in5_input.dev_attr.attr,
+        &sensor_dev_attr_in5_label.dev_attr.attr,
+        &sensor_dev_attr_in6_input.dev_attr.attr,
+        &sensor_dev_attr_in6_label.dev_attr.attr,
+        &sensor_dev_attr_in7_input.dev_attr.attr,
+        &sensor_dev_attr_in7_label.dev_attr.attr,
+        &sensor_dev_attr_in8_input.dev_attr.attr,
+        &sensor_dev_attr_in8_label.dev_attr.attr,
+
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_label.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_label.dev_attr.attr,
+
+        NULL
+};
+
+static const struct attribute_group wm831x_attr_group = {
+        .attrs  = wm831x_attributes,
+};
+
+static int __devinit wm831x_hwmon_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_hwmon *hwmon;
+        int ret;
+
+        hwmon = kzalloc(sizeof(struct wm831x_hwmon), GFP_KERNEL);
+        if (!hwmon)
+                return -ENOMEM;
+
+        hwmon->wm831x = wm831x;
+
+        ret = sysfs_create_group(&pdev->dev.kobj, &wm831x_attr_group);
+        if (ret)
+                goto err;
+
+        hwmon->classdev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(hwmon->classdev)) {
+                ret = PTR_ERR(hwmon->classdev);
+                goto err_sysfs;
+        }
+
+        platform_set_drvdata(pdev, hwmon);
+
+        return 0;
+
+err_sysfs:
+        sysfs_remove_group(&pdev->dev.kobj, &wm831x_attr_group);
+err:
+        kfree(hwmon);
+        return ret;
+}
+
+static int __devexit wm831x_hwmon_remove(struct platform_device *pdev)
+{
+        struct wm831x_hwmon *hwmon = platform_get_drvdata(pdev);
+
+        hwmon_device_unregister(hwmon->classdev);
+        sysfs_remove_group(&pdev->dev.kobj, &wm831x_attr_group);
+        platform_set_drvdata(pdev, NULL);
+        kfree(hwmon);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_hwmon_driver = {
+        .probe = wm831x_hwmon_probe,
+        .remove = __devexit_p(wm831x_hwmon_remove),
+        .driver = {
+                .name = "wm831x-hwmon",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init wm831x_hwmon_init(void)
+{
+        return platform_driver_register(&wm831x_hwmon_driver);
+}
+module_init(wm831x_hwmon_init);
+
+static void __exit wm831x_hwmon_exit(void)
+{
+        platform_driver_unregister(&wm831x_hwmon_driver);
+}
+module_exit(wm831x_hwmon_exit);
+
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("WM831x Hardware Monitoring");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-hwmon");
diff --git a/drivers/hwmon/wm8350-hwmon.c b/drivers/hwmon/wm8350-hwmon.c
new file mode 100644
index 000000000000..13290595ca86
--- /dev/null
+++ b/drivers/hwmon/wm8350-hwmon.c
@@ -0,0 +1,151 @@
+/*
+ * drivers/hwmon/wm8350-hwmon.c - Wolfson Microelectronics WM8350 PMIC
+ *                                  hardware monitoring features.
+ *
+ * Copyright (C) 2009 Wolfson Microelectronics plc
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License v2 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+
+#include <linux/mfd/wm8350/core.h>
+#include <linux/mfd/wm8350/comparator.h>
+
+static ssize_t show_name(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "wm8350\n");
+}
+
+static const char *input_names[] = {
+        [WM8350_AUXADC_USB]  = "USB",
+        [WM8350_AUXADC_LINE] = "Line",
+        [WM8350_AUXADC_BATT] = "Battery",
+};
+
+
+static ssize_t show_voltage(struct device *dev,
+                            struct device_attribute *attr, char *buf)
+{
+        struct wm8350 *wm8350 = dev_get_drvdata(dev);
+        int channel = to_sensor_dev_attr(attr)->index;
+        int val;
+
+        val = wm8350_read_auxadc(wm8350, channel, 0, 0) * WM8350_AUX_COEFF;
+        val = DIV_ROUND_CLOSEST(val, 1000);
+
+        return sprintf(buf, "%d\n", val);
+}
+
+static ssize_t show_label(struct device *dev,
+                          struct device_attribute *attr, char *buf)
+{
+        int channel = to_sensor_dev_attr(attr)->index;
+
+        return sprintf(buf, "%s\n", input_names[channel]);
+}
+
+#define WM8350_NAMED_VOLTAGE(id, name) \
+        static SENSOR_DEVICE_ATTR(in##id##_input, S_IRUGO, show_voltage,\
+                                  NULL, name);          \
+        static SENSOR_DEVICE_ATTR(in##id##_label, S_IRUGO, show_label,  \
+                                  NULL, name)
+
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
+WM8350_NAMED_VOLTAGE(0, WM8350_AUXADC_USB);
+WM8350_NAMED_VOLTAGE(1, WM8350_AUXADC_BATT);
+WM8350_NAMED_VOLTAGE(2, WM8350_AUXADC_LINE);
+
+static struct attribute *wm8350_attributes[] = {
+        &dev_attr_name.attr,
+
+        &sensor_dev_attr_in0_input.dev_attr.attr,
+        &sensor_dev_attr_in0_label.dev_attr.attr,
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_label.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_label.dev_attr.attr,
+
+        NULL,
+};
+
+static const struct attribute_group wm8350_attr_group = {
+        .attrs  = wm8350_attributes,
+};
+
+static int __devinit wm8350_hwmon_probe(struct platform_device *pdev)
+{
+        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
+        int ret;
+
+        ret = sysfs_create_group(&pdev->dev.kobj, &wm8350_attr_group);
+        if (ret)
+                goto err;
+
+        wm8350->hwmon.classdev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(wm8350->hwmon.classdev)) {
+                ret = PTR_ERR(wm8350->hwmon.classdev);
+                goto err_group;
+        }
+
+        return 0;
+
+err_group:
+        sysfs_remove_group(&pdev->dev.kobj, &wm8350_attr_group);
+err:
+        return ret;
+}
+
+static int __devexit wm8350_hwmon_remove(struct platform_device *pdev)
+{
+        struct wm8350 *wm8350 = platform_get_drvdata(pdev);
+
+        hwmon_device_unregister(wm8350->hwmon.classdev);
+        sysfs_remove_group(&pdev->dev.kobj, &wm8350_attr_group);
+
+        return 0;
+}
+
+static struct platform_driver wm8350_hwmon_driver = {
+        .probe = wm8350_hwmon_probe,
+        .remove = __devexit_p(wm8350_hwmon_remove),
+        .driver = {
+                .name = "wm8350-hwmon",
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init wm8350_hwmon_init(void)
+{
+        return platform_driver_register(&wm8350_hwmon_driver);
+}
+module_init(wm8350_hwmon_init);
+
+static void __exit wm8350_hwmon_exit(void)
+{
+        platform_driver_unregister(&wm8350_hwmon_driver);
+}
+module_exit(wm8350_hwmon_exit);
+
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("WM8350 Hardware Monitoring");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm8350-hwmon");
diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index 0b486a63460d..4afba3ec2a61 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -609,13 +609,12 @@ static int __init i2c_adap_imx_init(void)
 {
         return platform_driver_probe(&i2c_imx_driver, i2c_imx_probe);
 }
+subsys_initcall(i2c_adap_imx_init);
 
 static void __exit i2c_adap_imx_exit(void)
 {
         platform_driver_unregister(&i2c_imx_driver);
 }
-
-module_init(i2c_adap_imx_init);
 module_exit(i2c_adap_imx_exit);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index c3869d94ad42..bbab0e166630 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -293,13 +293,13 @@ mv64xxx_i2c_do_action(struct mv64xxx_i2c_data *drv_data)
         }
 }
 
-static int
+static irqreturn_t
 mv64xxx_i2c_intr(int irq, void *dev_id)
 {
         struct mv64xxx_i2c_data *drv_data = dev_id;
         unsigned long   flags;
         u32             status;
-        int             rc = IRQ_NONE;
+        irqreturn_t     rc = IRQ_NONE;
 
         spin_lock_irqsave(&drv_data->lock, flags);
         while (readl(drv_data->reg_base + MV64XXX_I2C_REG_CONTROL) &
diff --git a/drivers/i2c/busses/i2c-sh_mobile.c b/drivers/i2c/busses/i2c-sh_mobile.c
index 820487d0d5c7..86a9d4e81472 100644
--- a/drivers/i2c/busses/i2c-sh_mobile.c
+++ b/drivers/i2c/busses/i2c-sh_mobile.c
@@ -28,6 +28,7 @@
 #include <linux/interrupt.h>
 #include <linux/i2c.h>
 #include <linux/err.h>
+#include <linux/pm_runtime.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 
@@ -165,7 +166,8 @@ static void activate_ch(struct sh_mobile_i2c_data *pd)
         u_int32_t denom;
         u_int32_t tmp;
 
-        /* Make sure the clock is enabled */
+        /* Wake up device and enable clock */
+        pm_runtime_get_sync(pd->dev);
         clk_enable(pd->clk);
 
         /* Get clock rate after clock is enabled */
@@ -213,8 +215,9 @@ static void deactivate_ch(struct sh_mobile_i2c_data *pd)
         /* Disable channel */
         iowrite8(ioread8(ICCR(pd)) & ~ICCR_ICE, ICCR(pd));
 
-        /* Disable clock */
+        /* Disable clock and mark device as idle */
         clk_disable(pd->clk);
+        pm_runtime_put_sync(pd->dev);
 }
 
 static unsigned char i2c_op(struct sh_mobile_i2c_data *pd,
@@ -572,6 +575,19 @@ static int sh_mobile_i2c_probe(struct platform_device *dev)
                 goto err_irq;
         }
 
+        /* Enable Runtime PM for this device.
+         *
+         * Also tell the Runtime PM core to ignore children
+         * for this device since it is valid for us to suspend
+         * this I2C master driver even though the slave devices
+         * on the I2C bus may not be suspended.
+         *
+         * The state of the I2C hardware bus is unaffected by
+         * the Runtime PM state.
+         */
+        pm_suspend_ignore_children(&dev->dev, true);
+        pm_runtime_enable(&dev->dev);
+
         /* setup the private data */
         adap = &pd->adap;
         i2c_set_adapdata(adap, pd);
@@ -614,14 +630,33 @@ static int sh_mobile_i2c_remove(struct platform_device *dev)
         iounmap(pd->reg);
         sh_mobile_i2c_hook_irqs(dev, 0);
         clk_put(pd->clk);
+        pm_runtime_disable(&dev->dev);
         kfree(pd);
         return 0;
 }
 
+static int sh_mobile_i2c_runtime_nop(struct device *dev)
+{
+        /* Runtime PM callback shared between ->runtime_suspend()
+         * and ->runtime_resume(). Simply returns success.
+         *
+         * This driver re-initializes all registers after
+         * pm_runtime_get_sync() anyway so there is no need
+         * to save and restore registers here.
+         */
+        return 0;
+}
+
+static struct dev_pm_ops sh_mobile_i2c_dev_pm_ops = {
+        .runtime_suspend = sh_mobile_i2c_runtime_nop,
+        .runtime_resume = sh_mobile_i2c_runtime_nop,
+};
+
 static struct platform_driver sh_mobile_i2c_driver = {
         .driver         = {
                 .name           = "i2c-sh_mobile",
                 .owner          = THIS_MODULE,
+                .pm             = &sh_mobile_i2c_dev_pm_ops,
         },
         .probe          = sh_mobile_i2c_probe,
         .remove         = sh_mobile_i2c_remove,
diff --git a/drivers/input/input.c b/drivers/input/input.c
index 851791d955f3..556539d617a4 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -1265,14 +1265,14 @@ static struct device_type input_dev_type = {
         .uevent         = input_dev_uevent,
 };
 
-static char *input_nodename(struct device *dev)
+static char *input_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
 }
 
 struct class input_class = {
         .name           = "input",
-        .nodename       = input_nodename,
+        .devnode        = input_devnode,
 };
 EXPORT_SYMBOL_GPL(input_class);
 
diff --git a/drivers/input/keyboard/omap-keypad.c b/drivers/input/keyboard/omap-keypad.c
index 87ec7b18ac69..bba85add35a3 100644
--- a/drivers/input/keyboard/omap-keypad.c
+++ b/drivers/input/keyboard/omap-keypad.c
@@ -116,7 +116,7 @@ static irqreturn_t omap_kp_interrupt(int irq, void *dev_id)
                 }
         } else
                 /* disable keyboard interrupt and schedule for handling */
-                omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
         tasklet_schedule(&kp_tasklet);
 
@@ -143,20 +143,20 @@ static void omap_kp_scan_keypad(struct omap_kp *omap_kp, unsigned char *state)
 
         } else {
                 /* disable keyboard interrupt and schedule for handling */
-                omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
                 /* read the keypad status */
-                omap_writew(0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC);
+                omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
                 for (col = 0; col < omap_kp->cols; col++) {
                         omap_writew(~(1 << col) & 0xff,
-                                    OMAP_MPUIO_BASE + OMAP_MPUIO_KBC);
+                                    OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
 
                         udelay(omap_kp->delay);
 
-                        state[col] = ~omap_readw(OMAP_MPUIO_BASE +
+                        state[col] = ~omap_readw(OMAP1_MPUIO_BASE +
                                                  OMAP_MPUIO_KBR_LATCH) & 0xff;
                 }
-                omap_writew(0x00, OMAP_MPUIO_BASE + OMAP_MPUIO_KBC);
+                omap_writew(0x00, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBC);
                 udelay(2);
         }
 }
@@ -234,7 +234,7 @@ static void omap_kp_tasklet(unsigned long data)
                         for (i = 0; i < omap_kp_data->rows; i++)
                                 enable_irq(gpio_to_irq(row_gpios[i]));
                 } else {
-                        omap_writew(0, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                        omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
                         kp_cur_group = -1;
                 }
         }
@@ -317,7 +317,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
 
         /* Disable the interrupt for the MPUIO keyboard */
         if (!cpu_is_omap24xx())
-                omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
 
         keymap = pdata->keymap;
 
@@ -391,7 +391,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
         }
 
         if (pdata->dbounce)
-                omap_writew(0xff, OMAP_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING);
+                omap_writew(0xff, OMAP1_MPUIO_BASE + OMAP_MPUIO_GPIO_DEBOUNCING);
 
         /* scan current status and enable interrupt */
         omap_kp_scan_keypad(omap_kp, keypad_state);
@@ -402,7 +402,7 @@ static int __devinit omap_kp_probe(struct platform_device *pdev)
                                         "omap-keypad", omap_kp) < 0)
                                 goto err4;
                 }
-                omap_writew(0, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                omap_writew(0, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
         } else {
                 for (irq_idx = 0; irq_idx < omap_kp->rows; irq_idx++) {
                         if (request_irq(gpio_to_irq(row_gpios[irq_idx]),
@@ -449,7 +449,7 @@ static int __devexit omap_kp_remove(struct platform_device *pdev)
                         free_irq(gpio_to_irq(row_gpios[i]), 0);
                 }
         } else {
-                omap_writew(1, OMAP_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
+                omap_writew(1, OMAP1_MPUIO_BASE + OMAP_MPUIO_KBD_MASKIT);
                 free_irq(omap_kp->irq, 0);
         }
 
diff --git a/drivers/input/keyboard/sh_keysc.c b/drivers/input/keyboard/sh_keysc.c
index 0714bf2c28fc..887af79b7bff 100644
--- a/drivers/input/keyboard/sh_keysc.c
+++ b/drivers/input/keyboard/sh_keysc.c
@@ -80,6 +80,9 @@ static irqreturn_t sh_keysc_isr(int irq, void *dev_id)
                 iowrite16(KYCR2_IRQ_LEVEL | (keyin_set << 8),
                           priv->iomem_base + KYCR2_OFFS);
 
+                if (pdata->kycr2_delay)
+                        udelay(pdata->kycr2_delay);
+
                 keys ^= ~0;
                 keys &= (1 << (sh_keysc_mode[pdata->mode].keyin *
                                sh_keysc_mode[pdata->mode].keyout)) - 1;
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index cbe21bc96b52..1a50be379cbc 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -279,4 +279,24 @@ config INPUT_BFIN_ROTARY
           To compile this driver as a module, choose M here: the
           module will be called bfin-rotary.
 
+config INPUT_WM831X_ON
+        tristate "WM831X ON pin"
+        depends on MFD_WM831X
+        help
+          Support the ON pin of WM831X PMICs as an input device
+          reporting power button status.
+
+          To compile this driver as a module, choose M here: the module
+          will be called wm831x_on.
+
+config INPUT_PCAP
+        tristate "Motorola EZX PCAP misc input events"
+        depends on EZX_PCAP
+        help
+          Say Y here if you want to use Power key and Headphone button
+          on Motorola EZX phones.
+
+          To compile this driver as a module, choose M here: the
+          module will be called pcap_keys.
+
 endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index 79c1e9a5ea31..bf4db626c313 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_IXP4XX_BEEPER)       += ixp4xx-beeper.o
 obj-$(CONFIG_INPUT_KEYSPAN_REMOTE)      += keyspan_remote.o
 obj-$(CONFIG_INPUT_M68K_BEEP)           += m68kspkr.o
+obj-$(CONFIG_INPUT_PCAP)                += pcap_keys.o
 obj-$(CONFIG_INPUT_PCF50633_PMU)        += pcf50633-input.o
 obj-$(CONFIG_INPUT_PCSPKR)              += pcspkr.o
 obj-$(CONFIG_INPUT_POWERMATE)           += powermate.o
@@ -26,4 +27,6 @@ obj-$(CONFIG_INPUT_SPARCSPKR)		+= sparcspkr.o
 obj-$(CONFIG_INPUT_TWL4030_PWRBUTTON)   += twl4030-pwrbutton.o
 obj-$(CONFIG_INPUT_UINPUT)              += uinput.o
 obj-$(CONFIG_INPUT_WISTRON_BTNS)        += wistron_btns.o
+obj-$(CONFIG_INPUT_WM831X_ON)           += wm831x-on.o
 obj-$(CONFIG_INPUT_YEALINK)             += yealink.o
+
diff --git a/drivers/input/misc/pcap_keys.c b/drivers/input/misc/pcap_keys.c
new file mode 100644
index 000000000000..7ea969347ca9
--- /dev/null
+++ b/drivers/input/misc/pcap_keys.c
@@ -0,0 +1,144 @@
+/*
+ *  Input driver for PCAP events:
+ *   * Power key
+ *   * Headphone button
+ *
+ *  Copyright (c) 2008,2009 Ilya Petrov <ilya.muromec@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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/mfd/ezx-pcap.h>
+
+struct pcap_keys {
+        struct pcap_chip *pcap;
+        struct input_dev *input;
+};
+
+/* PCAP2 interrupts us on keypress */
+static irqreturn_t pcap_keys_handler(int irq, void *_pcap_keys)
+{
+        struct pcap_keys *pcap_keys = _pcap_keys;
+        int pirq = irq_to_pcap(pcap_keys->pcap, irq);
+        u32 pstat;
+
+        ezx_pcap_read(pcap_keys->pcap, PCAP_REG_PSTAT, &pstat);
+        pstat &= 1 << pirq;
+
+        switch (pirq) {
+        case PCAP_IRQ_ONOFF:
+                input_report_key(pcap_keys->input, KEY_POWER, !pstat);
+                break;
+        case PCAP_IRQ_MIC:
+                input_report_key(pcap_keys->input, KEY_HP, !pstat);
+                break;
+        }
+
+        input_sync(pcap_keys->input);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit pcap_keys_probe(struct platform_device *pdev)
+{
+        int err = -ENOMEM;
+        struct pcap_keys *pcap_keys;
+        struct input_dev *input_dev;
+
+        pcap_keys = kmalloc(sizeof(struct pcap_keys), GFP_KERNEL);
+        if (!pcap_keys)
+                return err;
+
+        pcap_keys->pcap = dev_get_drvdata(pdev->dev.parent);
+
+        input_dev = input_allocate_device();
+        if (!input_dev)
+                goto fail;
+
+        pcap_keys->input = input_dev;
+
+        platform_set_drvdata(pdev, pcap_keys);
+        input_dev->name = pdev->name;
+        input_dev->phys = "pcap-keys/input0";
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->dev.parent = &pdev->dev;
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(KEY_POWER, input_dev->keybit);
+        __set_bit(KEY_HP, input_dev->keybit);
+
+        err = input_register_device(input_dev);
+        if (err)
+                goto fail_allocate;
+
+        err = request_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_ONOFF),
+                        pcap_keys_handler, 0, "Power key", pcap_keys);
+        if (err)
+                goto fail_register;
+
+        err = request_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_MIC),
+                        pcap_keys_handler, 0, "Headphone button", pcap_keys);
+        if (err)
+                goto fail_pwrkey;
+
+        return 0;
+
+fail_pwrkey:
+        free_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_ONOFF), pcap_keys);
+fail_register:
+        input_unregister_device(input_dev);
+        goto fail;
+fail_allocate:
+        input_free_device(input_dev);
+fail:
+        kfree(pcap_keys);
+        return err;
+}
+
+static int __devexit pcap_keys_remove(struct platform_device *pdev)
+{
+        struct pcap_keys *pcap_keys = platform_get_drvdata(pdev);
+
+        free_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_ONOFF), pcap_keys);
+        free_irq(pcap_to_irq(pcap_keys->pcap, PCAP_IRQ_MIC), pcap_keys);
+
+        input_unregister_device(pcap_keys->input);
+        kfree(pcap_keys);
+
+        return 0;
+}
+
+static struct platform_driver pcap_keys_device_driver = {
+        .probe          = pcap_keys_probe,
+        .remove         = __devexit_p(pcap_keys_remove),
+        .driver         = {
+                .name   = "pcap-keys",
+                .owner  = THIS_MODULE,
+        }
+};
+
+static int __init pcap_keys_init(void)
+{
+        return platform_driver_register(&pcap_keys_device_driver);
+};
+
+static void __exit pcap_keys_exit(void)
+{
+        platform_driver_unregister(&pcap_keys_device_driver);
+};
+
+module_init(pcap_keys_init);
+module_exit(pcap_keys_exit);
+
+MODULE_DESCRIPTION("Motorola PCAP2 input events driver");
+MODULE_AUTHOR("Ilya Petrov <ilya.muromec@gmail.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcap_keys");
diff --git a/drivers/input/misc/wm831x-on.c b/drivers/input/misc/wm831x-on.c
new file mode 100644
index 000000000000..ba4f5dd7c60e
--- /dev/null
+++ b/drivers/input/misc/wm831x-on.c
@@ -0,0 +1,163 @@
+/**
+ * wm831x-on.c - WM831X ON pin driver
+ *
+ * Copyright (C) 2009 Wolfson Microelectronics plc
+ *
+ * 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 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/module.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/mfd/wm831x/core.h>
+
+struct wm831x_on {
+        struct input_dev *dev;
+        struct delayed_work work;
+        struct wm831x *wm831x;
+};
+
+/*
+ * The chip gives us an interrupt when the ON pin is asserted but we
+ * then need to poll to see when the pin is deasserted.
+ */
+static void wm831x_poll_on(struct work_struct *work)
+{
+        struct wm831x_on *wm831x_on = container_of(work, struct wm831x_on,
+                                                   work.work);
+        struct wm831x *wm831x = wm831x_on->wm831x;
+        int poll, ret;
+
+        ret = wm831x_reg_read(wm831x, WM831X_ON_PIN_CONTROL);
+        if (ret >= 0) {
+                poll = !(ret & WM831X_ON_PIN_STS);
+
+                input_report_key(wm831x_on->dev, KEY_POWER, poll);
+                input_sync(wm831x_on->dev);
+        } else {
+                dev_err(wm831x->dev, "Failed to read ON status: %d\n", ret);
+                poll = 1;
+        }
+
+        if (poll)
+                schedule_delayed_work(&wm831x_on->work, 100);
+}
+
+static irqreturn_t wm831x_on_irq(int irq, void *data)
+{
+        struct wm831x_on *wm831x_on = data;
+
+        schedule_delayed_work(&wm831x_on->work, 0);
+
+        return IRQ_HANDLED;
+}
+
+static int __devinit wm831x_on_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_on *wm831x_on;
+        int irq = platform_get_irq(pdev, 0);
+        int ret;
+
+        wm831x_on = kzalloc(sizeof(struct wm831x_on), GFP_KERNEL);
+        if (!wm831x_on) {
+                dev_err(&pdev->dev, "Can't allocate data\n");
+                return -ENOMEM;
+        }
+
+        wm831x_on->wm831x = wm831x;
+        INIT_DELAYED_WORK(&wm831x_on->work, wm831x_poll_on);
+
+        wm831x_on->dev = input_allocate_device();
+        if (!wm831x_on->dev) {
+                dev_err(&pdev->dev, "Can't allocate input dev\n");
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        wm831x_on->dev->evbit[0] = BIT_MASK(EV_KEY);
+        wm831x_on->dev->keybit[BIT_WORD(KEY_POWER)] = BIT_MASK(KEY_POWER);
+        wm831x_on->dev->name = "wm831x_on";
+        wm831x_on->dev->phys = "wm831x_on/input0";
+        wm831x_on->dev->dev.parent = &pdev->dev;
+
+        ret = wm831x_request_irq(wm831x, irq, wm831x_on_irq,
+                                 IRQF_TRIGGER_RISING, "wm831x_on", wm831x_on);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Unable to request IRQ: %d\n", ret);
+                goto err_input_dev;
+        }
+        ret = input_register_device(wm831x_on->dev);
+        if (ret) {
+                dev_dbg(&pdev->dev, "Can't register input device: %d\n", ret);
+                goto err_irq;
+        }
+
+        platform_set_drvdata(pdev, wm831x_on);
+
+        return 0;
+
+err_irq:
+        wm831x_free_irq(wm831x, irq, NULL);
+err_input_dev:
+        input_free_device(wm831x_on->dev);
+err:
+        kfree(wm831x_on);
+        return ret;
+}
+
+static int __devexit wm831x_on_remove(struct platform_device *pdev)
+{
+        struct wm831x_on *wm831x_on = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
+
+        wm831x_free_irq(wm831x_on->wm831x, irq, wm831x_on);
+        cancel_delayed_work_sync(&wm831x_on->work);
+        input_unregister_device(wm831x_on->dev);
+        kfree(wm831x_on);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_on_driver = {
+        .probe          = wm831x_on_probe,
+        .remove         = __devexit_p(wm831x_on_remove),
+        .driver         = {
+                .name   = "wm831x-on",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init wm831x_on_init(void)
+{
+        return platform_driver_register(&wm831x_on_driver);
+}
+module_init(wm831x_on_init);
+
+static void __exit wm831x_on_exit(void)
+{
+        platform_driver_unregister(&wm831x_on_driver);
+}
+module_exit(wm831x_on_exit);
+
+MODULE_ALIAS("platform:wm831x-on");
+MODULE_DESCRIPTION("WM831x ON pin");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 87a1ae63bcc4..ab02d72afbf3 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -510,4 +510,13 @@ config TOUCHSCREEN_W90X900
           To compile this driver as a module, choose M here: the
           module will be called w90p910_ts.
 
+config TOUCHSCREEN_PCAP
+        tristate "Motorola PCAP touchscreen"
+        depends on EZX_PCAP
+        help
+          Say Y here if you have a Motorola EZX telephone and
+          want to enable support for the built-in touchscreen.
+
+          To compile this driver as a module, choose M here: the
+          module will be called pcap_ts.
 endif
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 3e1c5e0b952f..4599bf7ad819 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -40,3 +40,4 @@ obj-$(CONFIG_TOUCHSCREEN_WM97XX_ATMEL)	+= atmel-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_MAINSTONE)      += mainstone-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_WM97XX_ZYLONITE)       += zylonite-wm97xx.o
 obj-$(CONFIG_TOUCHSCREEN_W90X900)       += w90p910_ts.o
+obj-$(CONFIG_TOUCHSCREEN_PCAP)          += pcap_ts.o
diff --git a/drivers/input/touchscreen/pcap_ts.c b/drivers/input/touchscreen/pcap_ts.c
new file mode 100644
index 000000000000..67fcd33595de
--- /dev/null
+++ b/drivers/input/touchscreen/pcap_ts.c
@@ -0,0 +1,271 @@
+/*
+ * Driver for Motorola PCAP2 touchscreen as found in the EZX phone platform.
+ *
+ *  Copyright (C) 2006 Harald Welte <laforge@openezx.org>
+ *  Copyright (C) 2009 Daniel Ribeiro <drwyrm@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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/string.h>
+#include <linux/pm.h>
+#include <linux/timer.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <linux/mfd/ezx-pcap.h>
+
+struct pcap_ts {
+        struct pcap_chip *pcap;
+        struct input_dev *input;
+        struct delayed_work work;
+        u16 x, y;
+        u16 pressure;
+        u8 read_state;
+};
+
+#define SAMPLE_DELAY    20 /* msecs */
+
+#define X_AXIS_MIN      0
+#define X_AXIS_MAX      1023
+#define Y_AXIS_MAX      X_AXIS_MAX
+#define Y_AXIS_MIN      X_AXIS_MIN
+#define PRESSURE_MAX    X_AXIS_MAX
+#define PRESSURE_MIN    X_AXIS_MIN
+
+static void pcap_ts_read_xy(void *data, u16 res[2])
+{
+        struct pcap_ts *pcap_ts = data;
+
+        switch (pcap_ts->read_state) {
+        case PCAP_ADC_TS_M_PRESSURE:
+                /* pressure reading is unreliable */
+                if (res[0] > PRESSURE_MIN && res[0] < PRESSURE_MAX)
+                        pcap_ts->pressure = res[0];
+                pcap_ts->read_state = PCAP_ADC_TS_M_XY;
+                schedule_delayed_work(&pcap_ts->work, 0);
+                break;
+        case PCAP_ADC_TS_M_XY:
+                pcap_ts->y = res[0];
+                pcap_ts->x = res[1];
+                if (pcap_ts->x <= X_AXIS_MIN || pcap_ts->x >= X_AXIS_MAX ||
+                    pcap_ts->y <= Y_AXIS_MIN || pcap_ts->y >= Y_AXIS_MAX) {
+                        /* pen has been released */
+                        input_report_abs(pcap_ts->input, ABS_PRESSURE, 0);
+                        input_report_key(pcap_ts->input, BTN_TOUCH, 0);
+
+                        pcap_ts->read_state = PCAP_ADC_TS_M_STANDBY;
+                        schedule_delayed_work(&pcap_ts->work, 0);
+                } else {
+                        /* pen is touching the screen */
+                        input_report_abs(pcap_ts->input, ABS_X, pcap_ts->x);
+                        input_report_abs(pcap_ts->input, ABS_Y, pcap_ts->y);
+                        input_report_key(pcap_ts->input, BTN_TOUCH, 1);
+                        input_report_abs(pcap_ts->input, ABS_PRESSURE,
+                                                pcap_ts->pressure);
+
+                        /* switch back to pressure read mode */
+                        pcap_ts->read_state = PCAP_ADC_TS_M_PRESSURE;
+                        schedule_delayed_work(&pcap_ts->work,
+                                        msecs_to_jiffies(SAMPLE_DELAY));
+                }
+                input_sync(pcap_ts->input);
+                break;
+        default:
+                dev_warn(&pcap_ts->input->dev,
+                                "pcap_ts: Warning, unhandled read_state %d\n",
+                                pcap_ts->read_state);
+                break;
+        }
+}
+
+static void pcap_ts_work(struct work_struct *work)
+{
+        struct delayed_work *dw = container_of(work, struct delayed_work, work);
+        struct pcap_ts *pcap_ts = container_of(dw, struct pcap_ts, work);
+        u8 ch[2];
+
+        pcap_set_ts_bits(pcap_ts->pcap,
+                        pcap_ts->read_state << PCAP_ADC_TS_M_SHIFT);
+
+        if (pcap_ts->read_state == PCAP_ADC_TS_M_STANDBY)
+                return;
+
+        /* start adc conversion */
+        ch[0] = PCAP_ADC_CH_TS_X1;
+        ch[1] = PCAP_ADC_CH_TS_Y1;
+        pcap_adc_async(pcap_ts->pcap, PCAP_ADC_BANK_1, 0, ch,
+                                                pcap_ts_read_xy, pcap_ts);
+}
+
+static irqreturn_t pcap_ts_event_touch(int pirq, void *data)
+{
+        struct pcap_ts *pcap_ts = data;
+
+        if (pcap_ts->read_state == PCAP_ADC_TS_M_STANDBY) {
+                pcap_ts->read_state = PCAP_ADC_TS_M_PRESSURE;
+                schedule_delayed_work(&pcap_ts->work, 0);
+        }
+        return IRQ_HANDLED;
+}
+
+static int pcap_ts_open(struct input_dev *dev)
+{
+        struct pcap_ts *pcap_ts = input_get_drvdata(dev);
+
+        pcap_ts->read_state = PCAP_ADC_TS_M_STANDBY;
+        schedule_delayed_work(&pcap_ts->work, 0);
+
+        return 0;
+}
+
+static void pcap_ts_close(struct input_dev *dev)
+{
+        struct pcap_ts *pcap_ts = input_get_drvdata(dev);
+
+        cancel_delayed_work_sync(&pcap_ts->work);
+
+        pcap_ts->read_state = PCAP_ADC_TS_M_NONTS;
+        pcap_set_ts_bits(pcap_ts->pcap,
+                                pcap_ts->read_state << PCAP_ADC_TS_M_SHIFT);
+}
+
+static int __devinit pcap_ts_probe(struct platform_device *pdev)
+{
+        struct input_dev *input_dev;
+        struct pcap_ts *pcap_ts;
+        int err = -ENOMEM;
+
+        pcap_ts = kzalloc(sizeof(*pcap_ts), GFP_KERNEL);
+        if (!pcap_ts)
+                return err;
+
+        pcap_ts->pcap = dev_get_drvdata(pdev->dev.parent);
+        platform_set_drvdata(pdev, pcap_ts);
+
+        input_dev = input_allocate_device();
+        if (!input_dev)
+                goto fail;
+
+        INIT_DELAYED_WORK(&pcap_ts->work, pcap_ts_work);
+
+        pcap_ts->read_state = PCAP_ADC_TS_M_NONTS;
+        pcap_set_ts_bits(pcap_ts->pcap,
+                                pcap_ts->read_state << PCAP_ADC_TS_M_SHIFT);
+
+        pcap_ts->input = input_dev;
+        input_set_drvdata(input_dev, pcap_ts);
+
+        input_dev->name = "pcap-touchscreen";
+        input_dev->phys = "pcap_ts/input0";
+        input_dev->id.bustype = BUS_HOST;
+        input_dev->id.vendor = 0x0001;
+        input_dev->id.product = 0x0002;
+        input_dev->id.version = 0x0100;
+        input_dev->dev.parent = &pdev->dev;
+        input_dev->open = pcap_ts_open;
+        input_dev->close = pcap_ts_close;
+
+        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+        input_set_abs_params(input_dev, ABS_X, X_AXIS_MIN, X_AXIS_MAX, 0, 0);
+        input_set_abs_params(input_dev, ABS_Y, Y_AXIS_MIN, Y_AXIS_MAX, 0, 0);
+        input_set_abs_params(input_dev, ABS_PRESSURE, PRESSURE_MIN,
+                             PRESSURE_MAX, 0, 0);
+
+        err = input_register_device(pcap_ts->input);
+        if (err)
+                goto fail_allocate;
+
+        err = request_irq(pcap_to_irq(pcap_ts->pcap, PCAP_IRQ_TS),
+                        pcap_ts_event_touch, 0, "Touch Screen", pcap_ts);
+        if (err)
+                goto fail_register;
+
+        return 0;
+
+fail_register:
+        input_unregister_device(input_dev);
+        goto fail;
+fail_allocate:
+        input_free_device(input_dev);
+fail:
+        kfree(pcap_ts);
+
+        return err;
+}
+
+static int __devexit pcap_ts_remove(struct platform_device *pdev)
+{
+        struct pcap_ts *pcap_ts = platform_get_drvdata(pdev);
+
+        free_irq(pcap_to_irq(pcap_ts->pcap, PCAP_IRQ_TS), pcap_ts);
+        cancel_delayed_work_sync(&pcap_ts->work);
+
+        input_unregister_device(pcap_ts->input);
+
+        kfree(pcap_ts);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int pcap_ts_suspend(struct device *dev)
+{
+        struct pcap_ts *pcap_ts = dev_get_drvdata(dev);
+
+        pcap_set_ts_bits(pcap_ts->pcap, PCAP_ADC_TS_REF_LOWPWR);
+        return 0;
+}
+
+static int pcap_ts_resume(struct device *dev)
+{
+        struct pcap_ts *pcap_ts = dev_get_drvdata(dev);
+
+        pcap_set_ts_bits(pcap_ts->pcap,
+                                pcap_ts->read_state << PCAP_ADC_TS_M_SHIFT);
+        return 0;
+}
+
+static struct dev_pm_ops pcap_ts_pm_ops = {
+        .suspend        = pcap_ts_suspend,
+        .resume         = pcap_ts_resume,
+};
+#define PCAP_TS_PM_OPS (&pcap_ts_pm_ops)
+#else
+#define PCAP_TS_PM_OPS NULL
+#endif
+
+static struct platform_driver pcap_ts_driver = {
+        .probe          = pcap_ts_probe,
+        .remove         = __devexit_p(pcap_ts_remove),
+        .driver         = {
+                .name   = "pcap-ts",
+                .owner  = THIS_MODULE,
+                .pm     = PCAP_TS_PM_OPS,
+        },
+};
+
+static int __init pcap_ts_init(void)
+{
+        return platform_driver_register(&pcap_ts_driver);
+}
+
+static void __exit pcap_ts_exit(void)
+{
+        platform_driver_unregister(&pcap_ts_driver);
+}
+
+module_init(pcap_ts_init);
+module_exit(pcap_ts_exit);
+
+MODULE_DESCRIPTION("Motorola PCAP2 touchscreen driver");
+MODULE_AUTHOR("Daniel Ribeiro / Harald Welte");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcap_ts");
diff --git a/drivers/isdn/gigaset/interface.c b/drivers/isdn/gigaset/interface.c
index 8ff7e35c7069..f33ac27de643 100644
--- a/drivers/isdn/gigaset/interface.c
+++ b/drivers/isdn/gigaset/interface.c
@@ -408,33 +408,28 @@ static int if_write_room(struct tty_struct *tty)
         return retval;
 }
 
-/* FIXME: This function does not have error returns */
-
 static int if_chars_in_buffer(struct tty_struct *tty)
 {
         struct cardstate *cs;
-        int retval = -ENODEV;
+        int retval = 0;
 
         cs = (struct cardstate *) tty->driver_data;
         if (!cs) {
                 pr_err("%s: no cardstate\n", __func__);
-                return -ENODEV;
+                return 0;
         }
 
         gig_dbg(DEBUG_IF, "%u: %s()", cs->minor_index, __func__);
 
-        if (mutex_lock_interruptible(&cs->mutex))
-                return -ERESTARTSYS; // FIXME -EINTR?
+        mutex_lock(&cs->mutex);
 
-        if (!cs->connected) {
+        if (!cs->connected)
                 gig_dbg(DEBUG_IF, "not connected");
-                retval = -ENODEV;
-        } else if (!cs->open_count)
+        else if (!cs->open_count)
                 dev_warn(cs->dev, "%s: device not opened\n", __func__);
-        else if (cs->mstate != MS_LOCKED) {
+        else if (cs->mstate != MS_LOCKED)
                 dev_warn(cs->dev, "can't write to unlocked device\n");
-                retval = -EBUSY;
-        } else
+        else
                 retval = cs->ops->chars_in_buffer(cs);
 
         mutex_unlock(&cs->mutex);
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 7f77f18fcafa..a67942931582 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -1532,7 +1532,7 @@ static const struct file_operations _ctl_fops = {
 static struct miscdevice _dm_misc = {
         .minor          = MISC_DYNAMIC_MINOR,
         .name           = DM_NAME,
-        .devnode        = "mapper/control",
+        .nodename       = "mapper/control",
         .fops           = &_ctl_fops
 };
 
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 479dd05762a5..94159b90f733 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -447,7 +447,7 @@ static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env)
         return 0;
 }
 
-static char *dvb_nodename(struct device *dev)
+static char *dvb_devnode(struct device *dev, mode_t *mode)
 {
         struct dvb_device *dvbdev = dev_get_drvdata(dev);
 
@@ -478,7 +478,7 @@ static int __init init_dvbdev(void)
                 goto error;
         }
         dvb_class->dev_uevent = dvb_uevent;
-        dvb_class->nodename = dvb_nodename;
+        dvb_class->devnode = dvb_devnode;
         return 0;
 
 error:
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index e86878deea71..61c47b824083 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -30,7 +30,7 @@
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/videodev2.h>
-#include <linux/clk.h>
+#include <linux/pm_runtime.h>
 
 #include <media/v4l2-common.h>
 #include <media/v4l2-dev.h>
@@ -86,7 +86,6 @@ struct sh_mobile_ceu_dev {
 
         unsigned int irq;
         void __iomem *base;
-        struct clk *clk;
         unsigned long video_limit;
 
         /* lock used to protect videobuf */
@@ -361,7 +360,7 @@ static int sh_mobile_ceu_add_device(struct soc_camera_device *icd)
         if (ret)
                 goto err;
 
-        clk_enable(pcdev->clk);
+        pm_runtime_get_sync(ici->dev);
 
         ceu_write(pcdev, CAPSR, 1 << 16); /* reset */
         while (ceu_read(pcdev, CSTSR) & 1)
@@ -395,7 +394,7 @@ static void sh_mobile_ceu_remove_device(struct soc_camera_device *icd)
         }
         spin_unlock_irqrestore(&pcdev->lock, flags);
 
-        clk_disable(pcdev->clk);
+        pm_runtime_put_sync(ici->dev);
 
         icd->ops->release(icd);
 
@@ -798,7 +797,6 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
         struct sh_mobile_ceu_dev *pcdev;
         struct resource *res;
         void __iomem *base;
-        char clk_name[8];
         unsigned int irq;
         int err = 0;
 
@@ -862,13 +860,9 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
                 goto exit_release_mem;
         }
 
-        snprintf(clk_name, sizeof(clk_name), "ceu%d", pdev->id);
-        pcdev->clk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(pcdev->clk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                err = PTR_ERR(pcdev->clk);
-                goto exit_free_irq;
-        }
+        pm_suspend_ignore_children(&pdev->dev, true);
+        pm_runtime_enable(&pdev->dev);
+        pm_runtime_resume(&pdev->dev);
 
         pcdev->ici.priv = pcdev;
         pcdev->ici.dev = &pdev->dev;
@@ -878,12 +872,10 @@ static int sh_mobile_ceu_probe(struct platform_device *pdev)
 
         err = soc_camera_host_register(&pcdev->ici);
         if (err)
-                goto exit_free_clk;
+                goto exit_free_irq;
 
         return 0;
 
-exit_free_clk:
-        clk_put(pcdev->clk);
 exit_free_irq:
         free_irq(pcdev->irq, pcdev);
 exit_release_mem:
@@ -904,7 +896,6 @@ static int sh_mobile_ceu_remove(struct platform_device *pdev)
                                         struct sh_mobile_ceu_dev, ici);
 
         soc_camera_host_unregister(soc_host);
-        clk_put(pcdev->clk);
         free_irq(pcdev->irq, pcdev);
         if (platform_get_resource(pdev, IORESOURCE_MEM, 1))
                 dma_release_declared_memory(&pdev->dev);
@@ -913,9 +904,27 @@ static int sh_mobile_ceu_remove(struct platform_device *pdev)
         return 0;
 }
 
+static int sh_mobile_ceu_runtime_nop(struct device *dev)
+{
+        /* Runtime PM callback shared between ->runtime_suspend()
+         * and ->runtime_resume(). Simply returns success.
+         *
+         * This driver re-initializes all registers after
+         * pm_runtime_get_sync() anyway so there is no need
+         * to save and restore registers here.
+         */
+        return 0;
+}
+
+static struct dev_pm_ops sh_mobile_ceu_dev_pm_ops = {
+        .runtime_suspend = sh_mobile_ceu_runtime_nop,
+        .runtime_resume = sh_mobile_ceu_runtime_nop,
+};
+
 static struct platform_driver sh_mobile_ceu_driver = {
         .driver         = {
                 .name   = "sh_mobile_ceu",
+                .pm     = &sh_mobile_ceu_dev_pm_ops,
         },
         .probe          = sh_mobile_ceu_probe,
         .remove         = sh_mobile_ceu_remove,
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 491ac0f800d2..570be139f9df 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -108,6 +108,19 @@ config TWL4030_CORE
           high speed USB OTG transceiver, an audio codec (on most
           versions) and many other features.
 
+config TWL4030_POWER
+        bool "Support power resources on TWL4030 family chips"
+        depends on TWL4030_CORE && ARM
+        help
+          Say yes here if you want to use the power resources on the
+          TWL4030 family chips.  Most of these resources are regulators,
+          which have a separate driver; some are control signals, such
+          as clock request handshaking.
+
+          This driver uses board-specific data to initialize the resources
+          and load scripts controling which resources are switched off/on
+          or reset when a sleep, wakeup or warm reset event occurs.
+
 config MFD_TMIO
         bool
         default n
@@ -157,6 +170,16 @@ config MFD_WM8400
           the device, additional drivers must be enabled in order to use
           the functionality of the device.
 
+config MFD_WM831X
+        tristate "Support Wolfson Microelectronics WM831x PMICs"
+        select MFD_CORE
+        depends on I2C
+        help
+          Support for the Wolfson Microelecronics WM831x PMICs.  This
+          driver provides common support for accessing the device,
+          additional drivers must be enabled in order to use the
+          functionality of the device.
+
 config MFD_WM8350
         tristate
 
@@ -228,6 +251,16 @@ config MFD_PCF50633
           facilities, and registers devices for the various functions
           so that function-specific drivers can bind to them.
 
+config MFD_MC13783
+        tristate "Support Freescale MC13783"
+        depends on SPI_MASTER
+        select MFD_CORE
+        help
+          Support for the Freescale (Atlas) MC13783 PMIC and audio CODEC.
+          This driver provides common support for accessing  the device,
+          additional drivers must be enabled in order to use the
+          functionality of the device.
+
 config PCF50633_ADC
         tristate "Support for NXP PCF50633 ADC"
         depends on MFD_PCF50633
@@ -256,6 +289,15 @@ config AB3100_CORE
           LEDs, vibrator, system power and temperature, power management
           and ALSA sound.
 
+config AB3100_OTP
+        tristate "ST-Ericsson AB3100 OTP functions"
+        depends on AB3100_CORE
+        default y if AB3100_CORE
+        help
+          Select this to enable the AB3100 Mixed Signal IC OTP (one-time
+          programmable memory) support. This exposes a sysfs file to read
+          out OTP values.
+
 config EZX_PCAP
         bool "PCAP Support"
         depends on GENERIC_HARDIRQS && SPI_MASTER
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 6f8a9a1af20b..f3b277b90d40 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -15,6 +15,8 @@ obj-$(CONFIG_MFD_TC6387XB)	+= tc6387xb.o
 obj-$(CONFIG_MFD_TC6393XB)      += tc6393xb.o
 
 obj-$(CONFIG_MFD_WM8400)        += wm8400-core.o
+wm831x-objs                     := wm831x-core.o wm831x-irq.o wm831x-otp.o
+obj-$(CONFIG_MFD_WM831X)        += wm831x.o
 wm8350-objs                     := wm8350-core.o wm8350-regmap.o wm8350-gpio.o
 obj-$(CONFIG_MFD_WM8350)        += wm8350.o
 obj-$(CONFIG_MFD_WM8350_I2C)    += wm8350-i2c.o
@@ -23,6 +25,9 @@ obj-$(CONFIG_TPS65010)		+= tps65010.o
 obj-$(CONFIG_MENELAUS)          += menelaus.o
 
 obj-$(CONFIG_TWL4030_CORE)      += twl4030-core.o twl4030-irq.o
+obj-$(CONFIG_TWL4030_POWER)    += twl4030-power.o
+
+obj-$(CONFIG_MFD_MC13783)       += mc13783-core.o
 
 obj-$(CONFIG_MFD_CORE)          += mfd-core.o
 
@@ -44,3 +49,4 @@ obj-$(CONFIG_MFD_PCF50633)	+= pcf50633-core.o
 obj-$(CONFIG_PCF50633_ADC)      += pcf50633-adc.o
 obj-$(CONFIG_PCF50633_GPIO)     += pcf50633-gpio.o
 obj-$(CONFIG_AB3100_CORE)       += ab3100-core.o
+obj-$(CONFIG_AB3100_OTP)        += ab3100-otp.o
diff --git a/drivers/mfd/ab3100-core.c b/drivers/mfd/ab3100-core.c
index 13e7d7bfe85f..c533f86ff5ea 100644
--- a/drivers/mfd/ab3100-core.c
+++ b/drivers/mfd/ab3100-core.c
@@ -14,7 +14,6 @@
 #include <linux/platform_device.h>
 #include <linux/device.h>
 #include <linux/interrupt.h>
-#include <linux/workqueue.h>
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 #include <linux/uaccess.h>
@@ -77,7 +76,7 @@ u8 ab3100_get_chip_type(struct ab3100 *ab3100)
 }
 EXPORT_SYMBOL(ab3100_get_chip_type);
 
-int ab3100_set_register(struct ab3100 *ab3100, u8 reg, u8 regval)
+int ab3100_set_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 regval)
 {
         u8 regandval[2] = {reg, regval};
         int err;
@@ -107,9 +106,10 @@ int ab3100_set_register(struct ab3100 *ab3100, u8 reg, u8 regval)
                 err = 0;
         }
         mutex_unlock(&ab3100->access_mutex);
-        return 0;
+        return err;
 }
-EXPORT_SYMBOL(ab3100_set_register);
+EXPORT_SYMBOL(ab3100_set_register_interruptible);
+
 
 /*
  * The test registers exist at an I2C bus address up one
@@ -118,7 +118,7 @@ EXPORT_SYMBOL(ab3100_set_register);
  * anyway. It's currently only used from this file so declare
  * it static and do not export.
  */
-static int ab3100_set_test_register(struct ab3100 *ab3100,
+static int ab3100_set_test_register_interruptible(struct ab3100 *ab3100,
                                     u8 reg, u8 regval)
 {
         u8 regandval[2] = {reg, regval};
@@ -148,7 +148,8 @@ static int ab3100_set_test_register(struct ab3100 *ab3100,
         return err;
 }
 
-int ab3100_get_register(struct ab3100 *ab3100, u8 reg, u8 *regval)
+
+int ab3100_get_register_interruptible(struct ab3100 *ab3100, u8 reg, u8 *regval)
 {
         int err;
 
@@ -202,9 +203,10 @@ int ab3100_get_register(struct ab3100 *ab3100, u8 reg, u8 *regval)
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_get_register);
+EXPORT_SYMBOL(ab3100_get_register_interruptible);
 
-int ab3100_get_register_page(struct ab3100 *ab3100,
+
+int ab3100_get_register_page_interruptible(struct ab3100 *ab3100,
                              u8 first_reg, u8 *regvals, u8 numregs)
 {
         int err;
@@ -258,9 +260,10 @@ int ab3100_get_register_page(struct ab3100 *ab3100,
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_get_register_page);
+EXPORT_SYMBOL(ab3100_get_register_page_interruptible);
+
 
-int ab3100_mask_and_set_register(struct ab3100 *ab3100,
+int ab3100_mask_and_set_register_interruptible(struct ab3100 *ab3100,
                                  u8 reg, u8 andmask, u8 ormask)
 {
         u8 regandval[2] = {reg, 0};
@@ -328,7 +331,8 @@ int ab3100_mask_and_set_register(struct ab3100 *ab3100,
         mutex_unlock(&ab3100->access_mutex);
         return err;
 }
-EXPORT_SYMBOL(ab3100_mask_and_set_register);
+EXPORT_SYMBOL(ab3100_mask_and_set_register_interruptible);
+
 
 /*
  * Register a simple callback for handling any AB3100 events.
@@ -371,7 +375,7 @@ static void ab3100_work(struct work_struct *work)
         u32 fatevent;
         int err;
 
-        err = ab3100_get_register_page(ab3100, AB3100_EVENTA1,
+        err = ab3100_get_register_page_interruptible(ab3100, AB3100_EVENTA1,
                                        event_regs, 3);
         if (err)
                 goto err_event_wq;
@@ -417,7 +421,7 @@ static irqreturn_t ab3100_irq_handler(int irq, void *data)
          * stuff and we will re-enable the interrupts once th
          * worker has finished.
          */
-        disable_irq(ab3100->i2c_client->irq);
+        disable_irq_nosync(irq);
         schedule_work(&ab3100->work);
         return IRQ_HANDLED;
 }
@@ -435,7 +439,7 @@ static int ab3100_registers_print(struct seq_file *s, void *p)
         seq_printf(s, "AB3100 registers:\n");
 
         for (reg = 0; reg < 0xff; reg++) {
-                ab3100_get_register(ab3100, reg, &value);
+                ab3100_get_register_interruptible(ab3100, reg, &value);
                 seq_printf(s, "[0x%x]:  0x%x\n", reg, value);
         }
         return 0;
@@ -465,14 +469,14 @@ static int ab3100_get_set_reg_open_file(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int ab3100_get_set_reg(struct file *file,
-                              const char __user *user_buf,
-                              size_t count, loff_t *ppos)
+static ssize_t ab3100_get_set_reg(struct file *file,
+                                  const char __user *user_buf,
+                                  size_t count, loff_t *ppos)
 {
         struct ab3100_get_set_reg_priv *priv = file->private_data;
         struct ab3100 *ab3100 = priv->ab3100;
         char buf[32];
-        int buf_size;
+        ssize_t buf_size;
         int regp;
         unsigned long user_reg;
         int err;
@@ -515,7 +519,7 @@ static int ab3100_get_set_reg(struct file *file,
                 u8 reg = (u8) user_reg;
                 u8 regvalue;
 
-                ab3100_get_register(ab3100, reg, &regvalue);
+                ab3100_get_register_interruptible(ab3100, reg, &regvalue);
 
                 dev_info(ab3100->dev,
                          "debug read AB3100 reg[0x%02x]: 0x%02x\n",
@@ -547,8 +551,8 @@ static int ab3100_get_set_reg(struct file *file,
                         return -EINVAL;
 
                 value = (u8) user_value;
-                ab3100_set_register(ab3100, reg, value);
-                ab3100_get_register(ab3100, reg, &regvalue);
+                ab3100_set_register_interruptible(ab3100, reg, value);
+                ab3100_get_register_interruptible(ab3100, reg, &regvalue);
 
                 dev_info(ab3100->dev,
                          "debug write reg[0x%02x] with 0x%02x, "
@@ -662,7 +666,7 @@ ab3100_init_settings[] = {
                 .setting = 0x01
         }, {
                 .abreg = AB3100_IMRB1,
-                .setting = 0xFF
+                .setting = 0xBF
         }, {
                 .abreg = AB3100_IMRB2,
                 .setting = 0xFF
@@ -696,7 +700,7 @@ static int __init ab3100_setup(struct ab3100 *ab3100)
         int i;
 
         for (i = 0; i < ARRAY_SIZE(ab3100_init_settings); i++) {
-                err = ab3100_set_register(ab3100,
+                err = ab3100_set_register_interruptible(ab3100,
                                           ab3100_init_settings[i].abreg,
                                           ab3100_init_settings[i].setting);
                 if (err)
@@ -705,14 +709,14 @@ static int __init ab3100_setup(struct ab3100 *ab3100)
 
         /*
          * Special trick to make the AB3100 use the 32kHz clock (RTC)
-         * bit 3 in test registe 0x02 is a special, undocumented test
+         * bit 3 in test register 0x02 is a special, undocumented test
          * register bit that only exist in AB3100 P1E
          */
         if (ab3100->chip_id == 0xc4) {
                 dev_warn(ab3100->dev,
                          "AB3100 P1E variant detected, "
                          "forcing chip to 32KHz\n");
-                err = ab3100_set_test_register(ab3100, 0x02, 0x08);
+                err = ab3100_set_test_register_interruptible(ab3100, 0x02, 0x08);
         }
 
  exit_no_setup:
@@ -833,6 +837,8 @@ static int __init ab3100_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
         struct ab3100 *ab3100;
+        struct ab3100_platform_data *ab3100_plf_data =
+                client->dev.platform_data;
         int err;
         int i;
 
@@ -852,8 +858,8 @@ static int __init ab3100_probe(struct i2c_client *client,
         i2c_set_clientdata(client, ab3100);
 
         /* Read chip ID register */
-        err = ab3100_get_register(ab3100, AB3100_CID,
-                                  &ab3100->chip_id);
+        err = ab3100_get_register_interruptible(ab3100, AB3100_CID,
+                                                &ab3100->chip_id);
         if (err) {
                 dev_err(&client->dev,
                         "could not communicate with the AB3100 analog "
@@ -916,6 +922,8 @@ static int __init ab3100_probe(struct i2c_client *client,
         for (i = 0; i < ARRAY_SIZE(ab3100_platform_devs); i++) {
                 ab3100_platform_devs[i]->dev.parent =
                         &client->dev;
+                ab3100_platform_devs[i]->dev.platform_data =
+                        ab3100_plf_data;
                 platform_set_drvdata(ab3100_platform_devs[i], ab3100);
         }
 
diff --git a/drivers/mfd/ab3100-otp.c b/drivers/mfd/ab3100-otp.c
new file mode 100644
index 000000000000..0499b2031a2c
--- /dev/null
+++ b/drivers/mfd/ab3100-otp.c
@@ -0,0 +1,268 @@
+/*
+ * drivers/mfd/ab3100_otp.c
+ *
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * Driver to read out OTP from the AB3100 Mixed-signal circuit
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/ab3100.h>
+#include <linux/debugfs.h>
+
+/* The OTP registers */
+#define AB3100_OTP0             0xb0
+#define AB3100_OTP1             0xb1
+#define AB3100_OTP2             0xb2
+#define AB3100_OTP3             0xb3
+#define AB3100_OTP4             0xb4
+#define AB3100_OTP5             0xb5
+#define AB3100_OTP6             0xb6
+#define AB3100_OTP7             0xb7
+#define AB3100_OTPP             0xbf
+
+/**
+ * struct ab3100_otp
+ * @dev containing device
+ * @ab3100 a pointer to the parent ab3100 device struct
+ * @locked whether the OTP is locked, after locking, no more bits
+ *       can be changed but before locking it is still possible
+ *       to change bits from 1->0.
+ * @freq clocking frequency for the OTP, this frequency is either
+ *       32768Hz or 1MHz/30
+ * @paf product activation flag, indicates whether this is a real
+ *       product (paf true) or a lab board etc (paf false)
+ * @imeich if this is set it is possible to override the
+ *       IMEI number found in the tac, fac and svn fields with
+ *       (secured) software
+ * @cid customer ID
+ * @tac type allocation code of the IMEI
+ * @fac final assembly code of the IMEI
+ * @svn software version number of the IMEI
+ * @debugfs a debugfs file used when dumping to file
+ */
+struct ab3100_otp {
+        struct device *dev;
+        struct ab3100 *ab3100;
+        bool locked;
+        u32 freq;
+        bool paf;
+        bool imeich;
+        u16 cid:14;
+        u32 tac:20;
+        u8 fac;
+        u32 svn:20;
+        struct dentry *debugfs;
+};
+
+static int __init ab3100_otp_read(struct ab3100_otp *otp)
+{
+        struct ab3100 *ab = otp->ab3100;
+        u8 otpval[8];
+        u8 otpp;
+        int err;
+
+        err = ab3100_get_register_interruptible(ab, AB3100_OTPP, &otpp);
+        if (err) {
+                dev_err(otp->dev, "unable to read OTPP register\n");
+                return err;
+        }
+
+        err = ab3100_get_register_page_interruptible(ab, AB3100_OTP0,
+                                                     otpval, 8);
+        if (err) {
+                dev_err(otp->dev, "unable to read OTP register page\n");
+                return err;
+        }
+
+        /* Cache OTP properties, they never change by nature */
+        otp->locked = (otpp & 0x80);
+        otp->freq = (otpp & 0x40) ? 32768 : 34100;
+        otp->paf = (otpval[1] & 0x80);
+        otp->imeich = (otpval[1] & 0x40);
+        otp->cid = ((otpval[1] << 8) | otpval[0]) & 0x3fff;
+        otp->tac = ((otpval[4] & 0x0f) << 16) | (otpval[3] << 8) | otpval[2];
+        otp->fac = ((otpval[5] & 0x0f) << 4) | (otpval[4] >> 4);
+        otp->svn = (otpval[7] << 12) | (otpval[6] << 4) | (otpval[5] >> 4);
+        return 0;
+}
+
+/*
+ * This is a simple debugfs human-readable file that dumps out
+ * the contents of the OTP.
+ */
+#ifdef CONFIG_DEBUGFS
+static int show_otp(struct seq_file *s, void *v)
+{
+        struct ab3100_otp *otp = s->private;
+        int err;
+
+        seq_printf(s, "OTP is %s\n", otp->locked ? "LOCKED" : "UNLOCKED");
+        seq_printf(s, "OTP clock switch startup is %uHz\n", otp->freq);
+        seq_printf(s, "PAF is %s\n", otp->paf ? "SET" : "NOT SET");
+        seq_printf(s, "IMEI is %s\n", otp->imeich ?
+                   "CHANGEABLE" : "NOT CHANGEABLE");
+        seq_printf(s, "CID: 0x%04x (decimal: %d)\n", otp->cid, otp->cid);
+        seq_printf(s, "IMEI: %u-%u-%u\n", otp->tac, otp->fac, otp->svn);
+        return 0;
+}
+
+static int ab3100_otp_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, ab3100_otp_show, inode->i_private);
+}
+
+static const struct file_operations ab3100_otp_operations = {
+        .open           = ab3100_otp_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int __init ab3100_otp_init_debugfs(struct device *dev,
+                                          struct ab3100_otp *otp)
+{
+        otp->debugfs = debugfs_create_file("ab3100_otp", S_IFREG | S_IRUGO,
+                                           NULL, otp,
+                                           &ab3100_otp_operations);
+        if (!otp->debugfs) {
+                dev_err(dev, "AB3100 debugfs OTP file registration failed!\n");
+                return err;
+        }
+}
+
+static void __exit ab3100_otp_exit_debugfs(struct ab3100_otp *otp)
+{
+        debugfs_remove_file(otp->debugfs);
+}
+#else
+/* Compile this out if debugfs not selected */
+static inline int __init ab3100_otp_init_debugfs(struct device *dev,
+                                                 struct ab3100_otp *otp)
+{
+        return 0;
+}
+
+static inline void __exit ab3100_otp_exit_debugfs(struct ab3100_otp *otp)
+{
+}
+#endif
+
+#define SHOW_AB3100_ATTR(name) \
+static ssize_t ab3100_otp_##name##_show(struct device *dev, \
+                               struct device_attribute *attr, \
+                               char *buf) \
+{\
+        struct ab3100_otp *otp = dev_get_drvdata(dev); \
+        return sprintf(buf, "%u\n", otp->name); \
+}
+
+SHOW_AB3100_ATTR(locked)
+SHOW_AB3100_ATTR(freq)
+SHOW_AB3100_ATTR(paf)
+SHOW_AB3100_ATTR(imeich)
+SHOW_AB3100_ATTR(cid)
+SHOW_AB3100_ATTR(fac)
+SHOW_AB3100_ATTR(tac)
+SHOW_AB3100_ATTR(svn)
+
+static struct device_attribute ab3100_otp_attrs[] = {
+        __ATTR(locked, S_IRUGO, ab3100_otp_locked_show, NULL),
+        __ATTR(freq, S_IRUGO, ab3100_otp_freq_show, NULL),
+        __ATTR(paf, S_IRUGO, ab3100_otp_paf_show, NULL),
+        __ATTR(imeich, S_IRUGO, ab3100_otp_imeich_show, NULL),
+        __ATTR(cid, S_IRUGO, ab3100_otp_cid_show, NULL),
+        __ATTR(fac, S_IRUGO, ab3100_otp_fac_show, NULL),
+        __ATTR(tac, S_IRUGO, ab3100_otp_tac_show, NULL),
+        __ATTR(svn, S_IRUGO, ab3100_otp_svn_show, NULL),
+};
+
+static int __init ab3100_otp_probe(struct platform_device *pdev)
+{
+        struct ab3100_otp *otp;
+        int err = 0;
+        int i;
+
+        otp = kzalloc(sizeof(struct ab3100_otp), GFP_KERNEL);
+        if (!otp) {
+                dev_err(&pdev->dev, "could not allocate AB3100 OTP device\n");
+                return -ENOMEM;
+        }
+        otp->dev = &pdev->dev;
+
+        /* Replace platform data coming in with a local struct */
+        otp->ab3100 = platform_get_drvdata(pdev);
+        platform_set_drvdata(pdev, otp);
+
+        err = ab3100_otp_read(otp);
+        if (err)
+                return err;
+
+        dev_info(&pdev->dev, "AB3100 OTP readout registered\n");
+
+        /* sysfs entries */
+        for (i = 0; i < ARRAY_SIZE(ab3100_otp_attrs); i++) {
+                err = device_create_file(&pdev->dev,
+                                         &ab3100_otp_attrs[i]);
+                if (err)
+                        goto out_no_sysfs;
+        }
+
+        /* debugfs entries */
+        err = ab3100_otp_init_debugfs(&pdev->dev, otp);
+        if (err)
+                goto out_no_debugfs;
+
+        return 0;
+
+out_no_sysfs:
+        for (i = 0; i < ARRAY_SIZE(ab3100_otp_attrs); i++)
+                device_remove_file(&pdev->dev,
+                                   &ab3100_otp_attrs[i]);
+out_no_debugfs:
+        kfree(otp);
+        return err;
+}
+
+static int __exit ab3100_otp_remove(struct platform_device *pdev)
+{
+        struct ab3100_otp *otp = platform_get_drvdata(pdev);
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ab3100_otp_attrs); i++)
+                device_remove_file(&pdev->dev,
+                                   &ab3100_otp_attrs[i]);
+        ab3100_otp_exit_debugfs(otp);
+        kfree(otp);
+        return 0;
+}
+
+static struct platform_driver ab3100_otp_driver = {
+        .driver = {
+                .name = "ab3100-otp",
+                .owner = THIS_MODULE,
+        },
+        .remove  = __exit_p(ab3100_otp_remove),
+};
+
+static int __init ab3100_otp_init(void)
+{
+        return platform_driver_probe(&ab3100_otp_driver,
+                                     ab3100_otp_probe);
+}
+
+static void __exit ab3100_otp_exit(void)
+{
+        platform_driver_unregister(&ab3100_otp_driver);
+}
+
+module_init(ab3100_otp_init);
+module_exit(ab3100_otp_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("AB3100 OTP Readout Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/dm355evm_msp.c b/drivers/mfd/dm355evm_msp.c
index 5b6e58a3ba46..3d4a861976ca 100644
--- a/drivers/mfd/dm355evm_msp.c
+++ b/drivers/mfd/dm355evm_msp.c
@@ -107,8 +107,16 @@ static const u8 msp_gpios[] = {
         MSP_GPIO(2, SWITCH1), MSP_GPIO(3, SWITCH1),
         MSP_GPIO(4, SWITCH1),
         /* switches on MMC/SD sockets */
-        MSP_GPIO(1, SDMMC), MSP_GPIO(2, SDMMC), /* mmc0 WP, nCD */
-        MSP_GPIO(3, SDMMC), MSP_GPIO(4, SDMMC), /* mmc1 WP, nCD */
+        /*
+         * Note: EVMDM355_ECP_VA4.pdf suggests that Bit 2 and 4 should be
+         * checked for card detection. However on the EVM bit 1 and 3 gives
+         * this status, for 0 and 1 instance respectively. The pdf also
+         * suggests that Bit 1 and 3 should be checked for write protection.
+         * However on the EVM bit 2 and 4 gives this status,for 0 and 1
+         * instance respectively.
+         */
+        MSP_GPIO(2, SDMMC), MSP_GPIO(1, SDMMC), /* mmc0 WP, nCD */
+        MSP_GPIO(4, SDMMC), MSP_GPIO(3, SDMMC), /* mmc1 WP, nCD */
 };
 
 #define MSP_GPIO_REG(offset)    (msp_gpios[(offset)] >> 3)
diff --git a/drivers/mfd/ezx-pcap.c b/drivers/mfd/ezx-pcap.c
index c1de4afa89a6..016be4938e4c 100644
--- a/drivers/mfd/ezx-pcap.c
+++ b/drivers/mfd/ezx-pcap.c
@@ -17,6 +17,7 @@
 #include <linux/irq.h>
 #include <linux/mfd/ezx-pcap.h>
 #include <linux/spi/spi.h>
+#include <linux/gpio.h>
 
 #define PCAP_ADC_MAXQ           8
 struct pcap_adc_request {
@@ -106,11 +107,35 @@ int ezx_pcap_read(struct pcap_chip *pcap, u8 reg_num, u32 *value)
 }
 EXPORT_SYMBOL_GPL(ezx_pcap_read);
 
+int ezx_pcap_set_bits(struct pcap_chip *pcap, u8 reg_num, u32 mask, u32 val)
+{
+        int ret;
+        u32 tmp = PCAP_REGISTER_READ_OP_BIT |
+                (reg_num << PCAP_REGISTER_ADDRESS_SHIFT);
+
+        mutex_lock(&pcap->io_mutex);
+        ret = ezx_pcap_putget(pcap, &tmp);
+        if (ret)
+                goto out_unlock;
+
+        tmp &= (PCAP_REGISTER_VALUE_MASK & ~mask);
+        tmp |= (val & mask) | PCAP_REGISTER_WRITE_OP_BIT |
+                (reg_num << PCAP_REGISTER_ADDRESS_SHIFT);
+
+        ret = ezx_pcap_putget(pcap, &tmp);
+out_unlock:
+        mutex_unlock(&pcap->io_mutex);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ezx_pcap_set_bits);
+
 /* IRQ */
-static inline unsigned int irq2pcap(struct pcap_chip *pcap, int irq)
+int irq_to_pcap(struct pcap_chip *pcap, int irq)
 {
-        return 1 << (irq - pcap->irq_base);
+        return irq - pcap->irq_base;
 }
+EXPORT_SYMBOL_GPL(irq_to_pcap);
 
 int pcap_to_irq(struct pcap_chip *pcap, int irq)
 {
@@ -122,7 +147,7 @@ static void pcap_mask_irq(unsigned int irq)
 {
         struct pcap_chip *pcap = get_irq_chip_data(irq);
 
-        pcap->msr |= irq2pcap(pcap, irq);
+        pcap->msr |= 1 << irq_to_pcap(pcap, irq);
         queue_work(pcap->workqueue, &pcap->msr_work);
 }
 
@@ -130,7 +155,7 @@ static void pcap_unmask_irq(unsigned int irq)
 {
         struct pcap_chip *pcap = get_irq_chip_data(irq);
 
-        pcap->msr &= ~irq2pcap(pcap, irq);
+        pcap->msr &= ~(1 << irq_to_pcap(pcap, irq));
         queue_work(pcap->workqueue, &pcap->msr_work);
 }
 
@@ -154,34 +179,38 @@ static void pcap_isr_work(struct work_struct *work)
         u32 msr, isr, int_sel, service;
         int irq;
 
-        ezx_pcap_read(pcap, PCAP_REG_MSR, &msr);
-        ezx_pcap_read(pcap, PCAP_REG_ISR, &isr);
+        do {
+                ezx_pcap_read(pcap, PCAP_REG_MSR, &msr);
+                ezx_pcap_read(pcap, PCAP_REG_ISR, &isr);
 
-        /* We cant service/ack irqs that are assigned to port 2 */
-        if (!(pdata->config & PCAP_SECOND_PORT)) {
-                ezx_pcap_read(pcap, PCAP_REG_INT_SEL, &int_sel);
-                isr &= ~int_sel;
-        }
-        ezx_pcap_write(pcap, PCAP_REG_ISR, isr);
+                /* We cant service/ack irqs that are assigned to port 2 */
+                if (!(pdata->config & PCAP_SECOND_PORT)) {
+                        ezx_pcap_read(pcap, PCAP_REG_INT_SEL, &int_sel);
+                        isr &= ~int_sel;
+                }
 
-        local_irq_disable();
-        service = isr & ~msr;
+                ezx_pcap_write(pcap, PCAP_REG_MSR, isr | msr);
+                ezx_pcap_write(pcap, PCAP_REG_ISR, isr);
 
-        for (irq = pcap->irq_base; service; service >>= 1, irq++) {
-                if (service & 1) {
-                        struct irq_desc *desc = irq_to_desc(irq);
+                local_irq_disable();
+                service = isr & ~msr;
+                for (irq = pcap->irq_base; service; service >>= 1, irq++) {
+                        if (service & 1) {
+                                struct irq_desc *desc = irq_to_desc(irq);
 
-                        if (WARN(!desc, KERN_WARNING
-                                        "Invalid PCAP IRQ %d\n", irq))
-                                break;
+                                if (WARN(!desc, KERN_WARNING
+                                                "Invalid PCAP IRQ %d\n", irq))
+                                        break;
 
-                        if (desc->status & IRQ_DISABLED)
-                                note_interrupt(irq, desc, IRQ_NONE);
-                        else
-                                desc->handle_irq(irq, desc);
+                                if (desc->status & IRQ_DISABLED)
+                                        note_interrupt(irq, desc, IRQ_NONE);
+                                else
+                                        desc->handle_irq(irq, desc);
+                        }
                 }
-        }
-        local_irq_enable();
+                local_irq_enable();
+                ezx_pcap_write(pcap, PCAP_REG_MSR, pcap->msr);
+        } while (gpio_get_value(irq_to_gpio(pcap->spi->irq)));
 }
 
 static void pcap_irq_handler(unsigned int irq, struct irq_desc *desc)
@@ -194,6 +223,19 @@ static void pcap_irq_handler(unsigned int irq, struct irq_desc *desc)
 }
 
 /* ADC */
+void pcap_set_ts_bits(struct pcap_chip *pcap, u32 bits)
+{
+        u32 tmp;
+
+        mutex_lock(&pcap->adc_mutex);
+        ezx_pcap_read(pcap, PCAP_REG_ADC, &tmp);
+        tmp &= ~(PCAP_ADC_TS_M_MASK | PCAP_ADC_TS_REF_LOWPWR);
+        tmp |= bits & (PCAP_ADC_TS_M_MASK | PCAP_ADC_TS_REF_LOWPWR);
+        ezx_pcap_write(pcap, PCAP_REG_ADC, tmp);
+        mutex_unlock(&pcap->adc_mutex);
+}
+EXPORT_SYMBOL_GPL(pcap_set_ts_bits);
+
 static void pcap_disable_adc(struct pcap_chip *pcap)
 {
         u32 tmp;
@@ -216,15 +258,16 @@ static void pcap_adc_trigger(struct pcap_chip *pcap)
                 mutex_unlock(&pcap->adc_mutex);
                 return;
         }
-        mutex_unlock(&pcap->adc_mutex);
-
-        /* start conversion on requested bank */
-        tmp = pcap->adc_queue[head]->flags | PCAP_ADC_ADEN;
+        /* start conversion on requested bank, save TS_M bits */
+        ezx_pcap_read(pcap, PCAP_REG_ADC, &tmp);
+        tmp &= (PCAP_ADC_TS_M_MASK | PCAP_ADC_TS_REF_LOWPWR);
+        tmp |= pcap->adc_queue[head]->flags | PCAP_ADC_ADEN;
 
         if (pcap->adc_queue[head]->bank == PCAP_ADC_BANK_1)
                 tmp |= PCAP_ADC_AD_SEL1;
 
         ezx_pcap_write(pcap, PCAP_REG_ADC, tmp);
+        mutex_unlock(&pcap->adc_mutex);
         ezx_pcap_write(pcap, PCAP_REG_ADR, PCAP_ADR_ASC);
 }
 
@@ -499,7 +542,7 @@ static void __exit ezx_pcap_exit(void)
         spi_unregister_driver(&ezxpcap_driver);
 }
 
-module_init(ezx_pcap_init);
+subsys_initcall(ezx_pcap_init);
 module_exit(ezx_pcap_exit);
 
 MODULE_LICENSE("GPL");
diff --git a/drivers/mfd/mc13783-core.c b/drivers/mfd/mc13783-core.c
new file mode 100644
index 000000000000..e354d2912ef1
--- /dev/null
+++ b/drivers/mfd/mc13783-core.c
@@ -0,0 +1,427 @@
+/*
+ * Copyright 2009 Pengutronix, Sascha Hauer <s.hauer@pengutronix.de>
+ *
+ * This code is in parts based on wm8350-core.c and pcf50633-core.c
+ *
+ * Initial development of this code was funded by
+ * Phytec Messtechnik GmbH, http://www.phytec.de
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/mfd/mc13783-private.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/mc13783.h>
+#include <linux/completion.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/core.h>
+#include <linux/spi/spi.h>
+#include <linux/uaccess.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+
+#define MC13783_MAX_REG_NUM     0x3f
+#define MC13783_FRAME_MASK      0x00ffffff
+#define MC13783_MAX_REG_NUM     0x3f
+#define MC13783_REG_NUM_SHIFT   0x19
+#define MC13783_WRITE_BIT_SHIFT 31
+
+static inline int spi_rw(struct spi_device *spi, u8 * buf, size_t len)
+{
+        struct spi_transfer t = {
+                .tx_buf = (const void *)buf,
+                .rx_buf = buf,
+                .len = len,
+                .cs_change = 0,
+                .delay_usecs = 0,
+        };
+        struct spi_message m;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        if (spi_sync(spi, &m) != 0 || m.status != 0)
+                return -EINVAL;
+        return len - m.actual_length;
+}
+
+static int mc13783_read(struct mc13783 *mc13783, int reg_num, u32 *reg_val)
+{
+        unsigned int frame = 0;
+        int ret = 0;
+
+        if (reg_num > MC13783_MAX_REG_NUM)
+                return -EINVAL;
+
+        frame |= reg_num << MC13783_REG_NUM_SHIFT;
+
+        ret = spi_rw(mc13783->spi_device, (u8 *)&frame, 4);
+
+        *reg_val = frame & MC13783_FRAME_MASK;
+
+        return ret;
+}
+
+static int mc13783_write(struct mc13783 *mc13783, int reg_num, u32 reg_val)
+{
+        unsigned int frame = 0;
+
+        if (reg_num > MC13783_MAX_REG_NUM)
+                return -EINVAL;
+
+        frame |= (1 << MC13783_WRITE_BIT_SHIFT);
+        frame |= reg_num << MC13783_REG_NUM_SHIFT;
+        frame |= reg_val & MC13783_FRAME_MASK;
+
+        return spi_rw(mc13783->spi_device, (u8 *)&frame, 4);
+}
+
+int mc13783_reg_read(struct mc13783 *mc13783, int reg_num, u32 *reg_val)
+{
+        int ret;
+
+        mutex_lock(&mc13783->io_lock);
+        ret = mc13783_read(mc13783, reg_num, reg_val);
+        mutex_unlock(&mc13783->io_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(mc13783_reg_read);
+
+int mc13783_reg_write(struct mc13783 *mc13783, int reg_num, u32 reg_val)
+{
+        int ret;
+
+        mutex_lock(&mc13783->io_lock);
+        ret = mc13783_write(mc13783, reg_num, reg_val);
+        mutex_unlock(&mc13783->io_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(mc13783_reg_write);
+
+/**
+ * mc13783_set_bits - Bitmask write
+ *
+ * @mc13783: Pointer to mc13783 control structure
+ * @reg:    Register to access
+ * @mask:   Mask of bits to change
+ * @val:    Value to set for masked bits
+ */
+int mc13783_set_bits(struct mc13783 *mc13783, int reg, u32 mask, u32 val)
+{
+        u32 tmp;
+        int ret;
+
+        mutex_lock(&mc13783->io_lock);
+
+        ret = mc13783_read(mc13783, reg, &tmp);
+        tmp = (tmp & ~mask) | val;
+        if (ret == 0)
+                ret = mc13783_write(mc13783, reg, tmp);
+
+        mutex_unlock(&mc13783->io_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(mc13783_set_bits);
+
+int mc13783_register_irq(struct mc13783 *mc13783, int irq,
+                void (*handler) (int, void *), void *data)
+{
+        if (irq < 0 || irq > MC13783_NUM_IRQ || !handler)
+                return -EINVAL;
+
+        if (WARN_ON(mc13783->irq_handler[irq].handler))
+                return -EBUSY;
+
+        mutex_lock(&mc13783->io_lock);
+        mc13783->irq_handler[irq].handler = handler;
+        mc13783->irq_handler[irq].data = data;
+        mutex_unlock(&mc13783->io_lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mc13783_register_irq);
+
+int mc13783_free_irq(struct mc13783 *mc13783, int irq)
+{
+        if (irq < 0 || irq > MC13783_NUM_IRQ)
+                return -EINVAL;
+
+        mutex_lock(&mc13783->io_lock);
+        mc13783->irq_handler[irq].handler = NULL;
+        mutex_unlock(&mc13783->io_lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mc13783_free_irq);
+
+static void mc13783_irq_work(struct work_struct *work)
+{
+        struct mc13783 *mc13783 = container_of(work, struct mc13783, work);
+        int i;
+        unsigned int adc_sts;
+
+        /* check if the adc has finished any completion */
+        mc13783_reg_read(mc13783, MC13783_REG_INTERRUPT_STATUS_0, &adc_sts);
+        mc13783_reg_write(mc13783, MC13783_REG_INTERRUPT_STATUS_0,
+                        adc_sts & MC13783_INT_STAT_ADCDONEI);
+
+        if (adc_sts & MC13783_INT_STAT_ADCDONEI)
+                complete_all(&mc13783->adc_done);
+
+        for (i = 0; i < MC13783_NUM_IRQ; i++)
+                if (mc13783->irq_handler[i].handler)
+                        mc13783->irq_handler[i].handler(i,
+                                        mc13783->irq_handler[i].data);
+        enable_irq(mc13783->irq);
+}
+
+static irqreturn_t mc13783_interrupt(int irq, void *dev_id)
+{
+        struct mc13783 *mc13783 = dev_id;
+
+        disable_irq_nosync(irq);
+
+        schedule_work(&mc13783->work);
+        return IRQ_HANDLED;
+}
+
+/* set adc to ts interrupt mode, which generates touchscreen wakeup interrupt */
+static inline void mc13783_adc_set_ts_irq_mode(struct mc13783 *mc13783)
+{
+        unsigned int reg_adc0, reg_adc1;
+
+        reg_adc0 = MC13783_ADC0_ADREFEN | MC13783_ADC0_ADREFMODE
+                        | MC13783_ADC0_TSMOD0;
+        reg_adc1 = MC13783_ADC1_ADEN | MC13783_ADC1_ADTRIGIGN;
+
+        mc13783_reg_write(mc13783, MC13783_REG_ADC_0, reg_adc0);
+        mc13783_reg_write(mc13783, MC13783_REG_ADC_1, reg_adc1);
+}
+
+int mc13783_adc_do_conversion(struct mc13783 *mc13783, unsigned int mode,
+                unsigned int channel, unsigned int *sample)
+{
+        unsigned int reg_adc0, reg_adc1;
+        int i;
+
+        mutex_lock(&mc13783->adc_conv_lock);
+
+        /* set up auto incrementing anyway to make quick read */
+        reg_adc0 =  MC13783_ADC0_ADINC1 | MC13783_ADC0_ADINC2;
+        /* enable the adc, ignore external triggering and set ASC to trigger
+         * conversion */
+        reg_adc1 =  MC13783_ADC1_ADEN | MC13783_ADC1_ADTRIGIGN
+                | MC13783_ADC1_ASC;
+
+        /* setup channel number */
+        if (channel > 7)
+                reg_adc1 |= MC13783_ADC1_ADSEL;
+
+        switch (mode) {
+        case MC13783_ADC_MODE_TS:
+                /* enables touch screen reference mode and set touchscreen mode
+                 * to position mode */
+                reg_adc0 |= MC13783_ADC0_ADREFEN | MC13783_ADC0_ADREFMODE
+                        | MC13783_ADC0_TSMOD0 | MC13783_ADC0_TSMOD1;
+                reg_adc1 |= 4 << MC13783_ADC1_CHAN1_SHIFT;
+                break;
+        case MC13783_ADC_MODE_SINGLE_CHAN:
+                reg_adc1 |= (channel & 0x7) << MC13783_ADC1_CHAN0_SHIFT;
+                reg_adc1 |= MC13783_ADC1_RAND;
+                break;
+        case MC13783_ADC_MODE_MULT_CHAN:
+                reg_adc1 |= 4 << MC13783_ADC1_CHAN1_SHIFT;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        mc13783_reg_write(mc13783, MC13783_REG_ADC_0, reg_adc0);
+        mc13783_reg_write(mc13783, MC13783_REG_ADC_1, reg_adc1);
+
+        wait_for_completion_interruptible(&mc13783->adc_done);
+
+        for (i = 0; i < 4; i++)
+                mc13783_reg_read(mc13783, MC13783_REG_ADC_2, &sample[i]);
+
+        if (mc13783->ts_active)
+                mc13783_adc_set_ts_irq_mode(mc13783);
+
+        mutex_unlock(&mc13783->adc_conv_lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mc13783_adc_do_conversion);
+
+void mc13783_adc_set_ts_status(struct mc13783 *mc13783, unsigned int status)
+{
+        mc13783->ts_active = status;
+}
+EXPORT_SYMBOL_GPL(mc13783_adc_set_ts_status);
+
+static int mc13783_check_revision(struct mc13783 *mc13783)
+{
+        u32 rev_id, rev1, rev2, finid, icid;
+
+        mc13783_read(mc13783, MC13783_REG_REVISION, &rev_id);
+
+        rev1 = (rev_id & 0x018) >> 3;
+        rev2 = (rev_id & 0x007);
+        icid = (rev_id & 0x01C0) >> 6;
+        finid = (rev_id & 0x01E00) >> 9;
+
+        /* Ver 0.2 is actually 3.2a.  Report as 3.2 */
+        if ((rev1 == 0) && (rev2 == 2))
+                rev1 = 3;
+
+        if (rev1 == 0 || icid != 2) {
+                dev_err(mc13783->dev, "No MC13783 detected.\n");
+                return -ENODEV;
+        }
+
+        mc13783->revision = ((rev1 * 10) + rev2);
+        dev_info(mc13783->dev, "MC13783 Rev %d.%d FinVer %x detected\n", rev1,
+               rev2, finid);
+
+        return 0;
+}
+
+/*
+ * Register a client device.  This is non-fatal since there is no need to
+ * fail the entire device init due to a single platform device failing.
+ */
+static void mc13783_client_dev_register(struct mc13783 *mc13783,
+                                       const char *name)
+{
+        struct mfd_cell cell = {};
+
+        cell.name = name;
+
+        mfd_add_devices(mc13783->dev, -1, &cell, 1, NULL, 0);
+}
+
+static int __devinit mc13783_probe(struct spi_device *spi)
+{
+        struct mc13783 *mc13783;
+        struct mc13783_platform_data *pdata = spi->dev.platform_data;
+        int ret;
+
+        mc13783 = kzalloc(sizeof(struct mc13783), GFP_KERNEL);
+        if (!mc13783)
+                return -ENOMEM;
+
+        dev_set_drvdata(&spi->dev, mc13783);
+        spi->mode = SPI_MODE_0 | SPI_CS_HIGH;
+        spi->bits_per_word = 32;
+        spi_setup(spi);
+
+        mc13783->spi_device = spi;
+        mc13783->dev = &spi->dev;
+        mc13783->irq = spi->irq;
+
+        INIT_WORK(&mc13783->work, mc13783_irq_work);
+        mutex_init(&mc13783->io_lock);
+        mutex_init(&mc13783->adc_conv_lock);
+        init_completion(&mc13783->adc_done);
+
+        if (pdata) {
+                mc13783->flags = pdata->flags;
+                mc13783->regulators = pdata->regulators;
+                mc13783->num_regulators = pdata->num_regulators;
+        }
+
+        if (mc13783_check_revision(mc13783)) {
+                ret = -ENODEV;
+                goto err_out;
+        }
+
+        /* clear and mask all interrupts */
+        mc13783_reg_write(mc13783, MC13783_REG_INTERRUPT_STATUS_0, 0x00ffffff);
+        mc13783_reg_write(mc13783, MC13783_REG_INTERRUPT_MASK_0, 0x00ffffff);
+        mc13783_reg_write(mc13783, MC13783_REG_INTERRUPT_STATUS_1, 0x00ffffff);
+        mc13783_reg_write(mc13783, MC13783_REG_INTERRUPT_MASK_1, 0x00ffffff);
+
+        /* unmask adcdone interrupts */
+        mc13783_set_bits(mc13783, MC13783_REG_INTERRUPT_MASK_0,
+                        MC13783_INT_MASK_ADCDONEM, 0);
+
+        ret = request_irq(mc13783->irq, mc13783_interrupt,
+                        IRQF_DISABLED | IRQF_TRIGGER_HIGH, "mc13783",
+                        mc13783);
+        if (ret)
+                goto err_out;
+
+        if (mc13783->flags & MC13783_USE_CODEC)
+                mc13783_client_dev_register(mc13783, "mc13783-codec");
+        if (mc13783->flags & MC13783_USE_ADC)
+                mc13783_client_dev_register(mc13783, "mc13783-adc");
+        if (mc13783->flags & MC13783_USE_RTC)
+                mc13783_client_dev_register(mc13783, "mc13783-rtc");
+        if (mc13783->flags & MC13783_USE_REGULATOR)
+                mc13783_client_dev_register(mc13783, "mc13783-regulator");
+        if (mc13783->flags & MC13783_USE_TOUCHSCREEN)
+                mc13783_client_dev_register(mc13783, "mc13783-ts");
+
+        return 0;
+
+err_out:
+        kfree(mc13783);
+        return ret;
+}
+
+static int __devexit mc13783_remove(struct spi_device *spi)
+{
+        struct mc13783 *mc13783;
+
+        mc13783 = dev_get_drvdata(&spi->dev);
+
+        free_irq(mc13783->irq, mc13783);
+
+        mfd_remove_devices(&spi->dev);
+
+        return 0;
+}
+
+static struct spi_driver pmic_driver = {
+        .driver = {
+                   .name = "mc13783",
+                   .bus = &spi_bus_type,
+                   .owner = THIS_MODULE,
+        },
+        .probe = mc13783_probe,
+        .remove = __devexit_p(mc13783_remove),
+};
+
+static int __init pmic_init(void)
+{
+        return spi_register_driver(&pmic_driver);
+}
+subsys_initcall(pmic_init);
+
+static void __exit pmic_exit(void)
+{
+        spi_unregister_driver(&pmic_driver);
+}
+module_exit(pmic_exit);
+
+MODULE_DESCRIPTION("Core/Protocol driver for Freescale MC13783 PMIC");
+MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/mfd/mfd-core.c b/drivers/mfd/mfd-core.c
index 54ddf3772e0c..ae15e495e20e 100644
--- a/drivers/mfd/mfd-core.c
+++ b/drivers/mfd/mfd-core.c
@@ -25,7 +25,7 @@ static int mfd_add_device(struct device *parent, int id,
         int ret = -ENOMEM;
         int r;
 
-        pdev = platform_device_alloc(cell->name, id);
+        pdev = platform_device_alloc(cell->name, id + cell->id);
         if (!pdev)
                 goto fail_alloc;
 
diff --git a/drivers/mfd/pcf50633-adc.c b/drivers/mfd/pcf50633-adc.c
index c2d05becfa97..3d31e97d6a45 100644
--- a/drivers/mfd/pcf50633-adc.c
+++ b/drivers/mfd/pcf50633-adc.c
@@ -73,15 +73,10 @@ static void trigger_next_adc_job_if_any(struct pcf50633 *pcf)
         struct pcf50633_adc *adc = __to_adc(pcf);
         int head;
 
-        mutex_lock(&adc->queue_mutex);
-
         head = adc->queue_head;
 
-        if (!adc->queue[head]) {
-                mutex_unlock(&adc->queue_mutex);
+        if (!adc->queue[head])
                 return;
-        }
-        mutex_unlock(&adc->queue_mutex);
 
         adc_setup(pcf, adc->queue[head]->mux, adc->queue[head]->avg);
 }
@@ -99,16 +94,17 @@ adc_enqueue_request(struct pcf50633 *pcf, struct pcf50633_adc_request *req)
 
         if (adc->queue[tail]) {
                 mutex_unlock(&adc->queue_mutex);
+                dev_err(pcf->dev, "ADC queue is full, dropping request\n");
                 return -EBUSY;
         }
 
         adc->queue[tail] = req;
+        if (head == tail)
+                trigger_next_adc_job_if_any(pcf);
         adc->queue_tail = (tail + 1) & (PCF50633_MAX_ADC_FIFO_DEPTH - 1);
 
         mutex_unlock(&adc->queue_mutex);
 
-        trigger_next_adc_job_if_any(pcf);
-
         return 0;
 }
 
@@ -124,6 +120,7 @@ pcf50633_adc_sync_read_callback(struct pcf50633 *pcf, void *param, int result)
 int pcf50633_adc_sync_read(struct pcf50633 *pcf, int mux, int avg)
 {
         struct pcf50633_adc_request *req;
+        int err;
 
         /* req is freed when the result is ready, in interrupt handler */
         req = kzalloc(sizeof(*req), GFP_KERNEL);
@@ -136,9 +133,13 @@ int pcf50633_adc_sync_read(struct pcf50633 *pcf, int mux, int avg)
         req->callback_param = req;
 
         init_completion(&req->completion);
-        adc_enqueue_request(pcf, req);
+        err = adc_enqueue_request(pcf, req);
+        if (err)
+                return err;
+
         wait_for_completion(&req->completion);
 
+        /* FIXME by this time req might be already freed */
         return req->result;
 }
 EXPORT_SYMBOL_GPL(pcf50633_adc_sync_read);
@@ -159,9 +160,7 @@ int pcf50633_adc_async_read(struct pcf50633 *pcf, int mux, int avg,
         req->callback = callback;
         req->callback_param = callback_param;
 
-        adc_enqueue_request(pcf, req);
-
-        return 0;
+        return adc_enqueue_request(pcf, req);
 }
 EXPORT_SYMBOL_GPL(pcf50633_adc_async_read);
 
@@ -184,7 +183,7 @@ static void pcf50633_adc_irq(int irq, void *data)
         struct pcf50633_adc *adc = data;
         struct pcf50633 *pcf = adc->pcf;
         struct pcf50633_adc_request *req;
-        int head;
+        int head, res;
 
         mutex_lock(&adc->queue_mutex);
         head = adc->queue_head;
@@ -199,12 +198,13 @@ static void pcf50633_adc_irq(int irq, void *data)
         adc->queue_head = (head + 1) &
                                       (PCF50633_MAX_ADC_FIFO_DEPTH - 1);
 
+        res = adc_result(pcf);
+        trigger_next_adc_job_if_any(pcf);
+
         mutex_unlock(&adc->queue_mutex);
 
-        req->callback(pcf, req->callback_param, adc_result(pcf));
+        req->callback(pcf, req->callback_param, res);
         kfree(req);
-
-        trigger_next_adc_job_if_any(pcf);
 }
 
 static int __devinit pcf50633_adc_probe(struct platform_device *pdev)
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c
index 8d3c38bf9714..d26d7747175e 100644
--- a/drivers/mfd/pcf50633-core.c
+++ b/drivers/mfd/pcf50633-core.c
@@ -444,7 +444,7 @@ static irqreturn_t pcf50633_irq(int irq, void *data)
 
         get_device(pcf->dev);
         disable_irq_nosync(pcf->irq);
-        schedule_work(&pcf->irq_work);
+        queue_work(pcf->work_queue, &pcf->irq_work);
 
         return IRQ_HANDLED;
 }
@@ -575,6 +575,7 @@ static int __devinit pcf50633_probe(struct i2c_client *client,
         pcf->dev = &client->dev;
         pcf->i2c_client = client;
         pcf->irq = client->irq;
+        pcf->work_queue = create_singlethread_workqueue("pcf50633");
 
         INIT_WORK(&pcf->irq_work, pcf50633_irq_worker);
 
@@ -651,6 +652,7 @@ static int __devinit pcf50633_probe(struct i2c_client *client,
         return 0;
 
 err:
+        destroy_workqueue(pcf->work_queue);
         kfree(pcf);
         return ret;
 }
@@ -661,6 +663,7 @@ static int __devexit pcf50633_remove(struct i2c_client *client)
         int i;
 
         free_irq(pcf->irq, pcf);
+        destroy_workqueue(pcf->work_queue);
 
         platform_device_unregister(pcf->input_pdev);
         platform_device_unregister(pcf->rtc_pdev);
diff --git a/drivers/mfd/twl4030-core.c b/drivers/mfd/twl4030-core.c
index ca54996ffd0e..e424cf6d8e9e 100644
--- a/drivers/mfd/twl4030-core.c
+++ b/drivers/mfd/twl4030-core.c
@@ -89,6 +89,12 @@
 #define twl_has_madc()  false
 #endif
 
+#ifdef CONFIG_TWL4030_POWER
+#define twl_has_power()        true
+#else
+#define twl_has_power()        false
+#endif
+
 #if defined(CONFIG_RTC_DRV_TWL4030) || defined(CONFIG_RTC_DRV_TWL4030_MODULE)
 #define twl_has_rtc()   true
 #else
@@ -115,6 +121,12 @@
 
 #define TWL4030_NUM_SLAVES              4
 
+#if defined(CONFIG_INPUT_TWL4030_PWRBUTTON) \
+        || defined(CONFIG_INPUT_TWL4030_PWBUTTON_MODULE)
+#define twl_has_pwrbutton()     true
+#else
+#define twl_has_pwrbutton()     false
+#endif
 
 /* Base Address defns for twl4030_map[] */
 
@@ -538,6 +550,13 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
                         return PTR_ERR(child);
         }
 
+        if (twl_has_pwrbutton()) {
+                child = add_child(1, "twl4030_pwrbutton",
+                                NULL, 0, true, pdata->irq_base + 8 + 0, 0);
+                if (IS_ERR(child))
+                        return PTR_ERR(child);
+        }
+
         if (twl_has_regulator()) {
                 /*
                 child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1);
@@ -788,6 +807,10 @@ twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id)
         /* setup clock framework */
         clocks_init(&client->dev);
 
+        /* load power event scripts */
+        if (twl_has_power() && pdata->power)
+                twl4030_power_init(pdata->power);
+
         /* Maybe init the T2 Interrupt subsystem */
         if (client->irq
                         && pdata->irq_base
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index 7d430835655f..fb194fe244c1 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -424,7 +424,7 @@ static void twl4030_sih_do_edge(struct work_struct *work)
         /* see what work we have */
         spin_lock_irq(&sih_agent_lock);
         edge_change = agent->edge_change;
-        agent->edge_change = 0;;
+        agent->edge_change = 0;
         sih = edge_change ? agent->sih : NULL;
         spin_unlock_irq(&sih_agent_lock);
         if (!sih)
diff --git a/drivers/mfd/twl4030-power.c b/drivers/mfd/twl4030-power.c
new file mode 100644
index 000000000000..d423e0c4176b
--- /dev/null
+++ b/drivers/mfd/twl4030-power.c
@@ -0,0 +1,472 @@
+/*
+ * linux/drivers/i2c/chips/twl4030-power.c
+ *
+ * Handle TWL4030 Power initialization
+ *
+ * Copyright (C) 2008 Nokia Corporation
+ * Copyright (C) 2006 Texas Instruments, Inc
+ *
+ * Written by   Kalle Jokiniemi
+ *              Peter De Schrijver <peter.de-schrijver@nokia.com>
+ * Several fixes by Amit Kucheria <amit.kucheria@verdurent.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.
+ *
+ * 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/module.h>
+#include <linux/pm.h>
+#include <linux/i2c/twl4030.h>
+#include <linux/platform_device.h>
+
+#include <asm/mach-types.h>
+
+static u8 twl4030_start_script_address = 0x2b;
+
+#define PWR_P1_SW_EVENTS        0x10
+#define PWR_DEVOFF      (1<<0)
+
+#define PHY_TO_OFF_PM_MASTER(p)         (p - 0x36)
+#define PHY_TO_OFF_PM_RECEIVER(p)       (p - 0x5b)
+
+/* resource - hfclk */
+#define R_HFCLKOUT_DEV_GRP      PHY_TO_OFF_PM_RECEIVER(0xe6)
+
+/* PM events */
+#define R_P1_SW_EVENTS          PHY_TO_OFF_PM_MASTER(0x46)
+#define R_P2_SW_EVENTS          PHY_TO_OFF_PM_MASTER(0x47)
+#define R_P3_SW_EVENTS          PHY_TO_OFF_PM_MASTER(0x48)
+#define R_CFG_P1_TRANSITION     PHY_TO_OFF_PM_MASTER(0x36)
+#define R_CFG_P2_TRANSITION     PHY_TO_OFF_PM_MASTER(0x37)
+#define R_CFG_P3_TRANSITION     PHY_TO_OFF_PM_MASTER(0x38)
+
+#define LVL_WAKEUP      0x08
+
+#define ENABLE_WARMRESET (1<<4)
+
+#define END_OF_SCRIPT           0x3f
+
+#define R_SEQ_ADD_A2S           PHY_TO_OFF_PM_MASTER(0x55)
+#define R_SEQ_ADD_S2A12         PHY_TO_OFF_PM_MASTER(0x56)
+#define R_SEQ_ADD_S2A3          PHY_TO_OFF_PM_MASTER(0x57)
+#define R_SEQ_ADD_WARM          PHY_TO_OFF_PM_MASTER(0x58)
+#define R_MEMORY_ADDRESS        PHY_TO_OFF_PM_MASTER(0x59)
+#define R_MEMORY_DATA           PHY_TO_OFF_PM_MASTER(0x5a)
+
+#define R_PROTECT_KEY           0x0E
+#define R_KEY_1                 0xC0
+#define R_KEY_2                 0x0C
+
+/* resource configuration registers */
+
+#define DEVGROUP_OFFSET         0
+#define TYPE_OFFSET             1
+
+/* Bit positions */
+#define DEVGROUP_SHIFT          5
+#define DEVGROUP_MASK           (7 << DEVGROUP_SHIFT)
+#define TYPE_SHIFT              0
+#define TYPE_MASK               (7 << TYPE_SHIFT)
+#define TYPE2_SHIFT             3
+#define TYPE2_MASK              (3 << TYPE2_SHIFT)
+
+static u8 res_config_addrs[] = {
+        [RES_VAUX1]     = 0x17,
+        [RES_VAUX2]     = 0x1b,
+        [RES_VAUX3]     = 0x1f,
+        [RES_VAUX4]     = 0x23,
+        [RES_VMMC1]     = 0x27,
+        [RES_VMMC2]     = 0x2b,
+        [RES_VPLL1]     = 0x2f,
+        [RES_VPLL2]     = 0x33,
+        [RES_VSIM]      = 0x37,
+        [RES_VDAC]      = 0x3b,
+        [RES_VINTANA1]  = 0x3f,
+        [RES_VINTANA2]  = 0x43,
+        [RES_VINTDIG]   = 0x47,
+        [RES_VIO]       = 0x4b,
+        [RES_VDD1]      = 0x55,
+        [RES_VDD2]      = 0x63,
+        [RES_VUSB_1V5]  = 0x71,
+        [RES_VUSB_1V8]  = 0x74,
+        [RES_VUSB_3V1]  = 0x77,
+        [RES_VUSBCP]    = 0x7a,
+        [RES_REGEN]     = 0x7f,
+        [RES_NRES_PWRON] = 0x82,
+        [RES_CLKEN]     = 0x85,
+        [RES_SYSEN]     = 0x88,
+        [RES_HFCLKOUT]  = 0x8b,
+        [RES_32KCLKOUT] = 0x8e,
+        [RES_RESET]     = 0x91,
+        [RES_Main_Ref]  = 0x94,
+};
+
+static int __init twl4030_write_script_byte(u8 address, u8 byte)
+{
+        int err;
+
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
+                                R_MEMORY_ADDRESS);
+        if (err)
+                goto out;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, byte,
+                                R_MEMORY_DATA);
+out:
+        return err;
+}
+
+static int __init twl4030_write_script_ins(u8 address, u16 pmb_message,
+                                           u8 delay, u8 next)
+{
+        int err;
+
+        address *= 4;
+        err = twl4030_write_script_byte(address++, pmb_message >> 8);
+        if (err)
+                goto out;
+        err = twl4030_write_script_byte(address++, pmb_message & 0xff);
+        if (err)
+                goto out;
+        err = twl4030_write_script_byte(address++, delay);
+        if (err)
+                goto out;
+        err = twl4030_write_script_byte(address++, next);
+out:
+        return err;
+}
+
+static int __init twl4030_write_script(u8 address, struct twl4030_ins *script,
+                                       int len)
+{
+        int err;
+
+        for (; len; len--, address++, script++) {
+                if (len == 1) {
+                        err = twl4030_write_script_ins(address,
+                                                script->pmb_message,
+                                                script->delay,
+                                                END_OF_SCRIPT);
+                        if (err)
+                                break;
+                } else {
+                        err = twl4030_write_script_ins(address,
+                                                script->pmb_message,
+                                                script->delay,
+                                                address + 1);
+                        if (err)
+                                break;
+                }
+        }
+        return err;
+}
+
+static int __init twl4030_config_wakeup3_sequence(u8 address)
+{
+        int err;
+        u8 data;
+
+        /* Set SLEEP to ACTIVE SEQ address for P3 */
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
+                                R_SEQ_ADD_S2A3);
+        if (err)
+                goto out;
+
+        /* P3 LVL_WAKEUP should be on LEVEL */
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
+                                R_P3_SW_EVENTS);
+        if (err)
+                goto out;
+        data |= LVL_WAKEUP;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
+                                R_P3_SW_EVENTS);
+out:
+        if (err)
+                pr_err("TWL4030 wakeup sequence for P3 config error\n");
+        return err;
+}
+
+static int __init twl4030_config_wakeup12_sequence(u8 address)
+{
+        int err = 0;
+        u8 data;
+
+        /* Set SLEEP to ACTIVE SEQ address for P1 and P2 */
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
+                                R_SEQ_ADD_S2A12);
+        if (err)
+                goto out;
+
+        /* P1/P2 LVL_WAKEUP should be on LEVEL */
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
+                                R_P1_SW_EVENTS);
+        if (err)
+                goto out;
+
+        data |= LVL_WAKEUP;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
+                                R_P1_SW_EVENTS);
+        if (err)
+                goto out;
+
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
+                                R_P2_SW_EVENTS);
+        if (err)
+                goto out;
+
+        data |= LVL_WAKEUP;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
+                                R_P2_SW_EVENTS);
+        if (err)
+                goto out;
+
+        if (machine_is_omap_3430sdp() || machine_is_omap_ldp()) {
+                /* Disabling AC charger effect on sleep-active transitions */
+                err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
+                                        R_CFG_P1_TRANSITION);
+                if (err)
+                        goto out;
+                data &= ~(1<<1);
+                err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data ,
+                                        R_CFG_P1_TRANSITION);
+                if (err)
+                        goto out;
+        }
+
+out:
+        if (err)
+                pr_err("TWL4030 wakeup sequence for P1 and P2" \
+                        "config error\n");
+        return err;
+}
+
+static int __init twl4030_config_sleep_sequence(u8 address)
+{
+        int err;
+
+        /* Set ACTIVE to SLEEP SEQ address in T2 memory*/
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
+                                R_SEQ_ADD_A2S);
+
+        if (err)
+                pr_err("TWL4030 sleep sequence config error\n");
+
+        return err;
+}
+
+static int __init twl4030_config_warmreset_sequence(u8 address)
+{
+        int err;
+        u8 rd_data;
+
+        /* Set WARM RESET SEQ address for P1 */
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
+                                R_SEQ_ADD_WARM);
+        if (err)
+                goto out;
+
+        /* P1/P2/P3 enable WARMRESET */
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
+                                R_P1_SW_EVENTS);
+        if (err)
+                goto out;
+
+        rd_data |= ENABLE_WARMRESET;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
+                                R_P1_SW_EVENTS);
+        if (err)
+                goto out;
+
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
+                                R_P2_SW_EVENTS);
+        if (err)
+                goto out;
+
+        rd_data |= ENABLE_WARMRESET;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
+                                R_P2_SW_EVENTS);
+        if (err)
+                goto out;
+
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
+                                R_P3_SW_EVENTS);
+        if (err)
+                goto out;
+
+        rd_data |= ENABLE_WARMRESET;
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
+                                R_P3_SW_EVENTS);
+out:
+        if (err)
+                pr_err("TWL4030 warmreset seq config error\n");
+        return err;
+}
+
+static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
+{
+        int rconfig_addr;
+        int err;
+        u8 type;
+        u8 grp;
+
+        if (rconfig->resource > TOTAL_RESOURCES) {
+                pr_err("TWL4030 Resource %d does not exist\n",
+                        rconfig->resource);
+                return -EINVAL;
+        }
+
+        rconfig_addr = res_config_addrs[rconfig->resource];
+
+        /* Set resource group */
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &grp,
+                                rconfig_addr + DEVGROUP_OFFSET);
+        if (err) {
+                pr_err("TWL4030 Resource %d group could not be read\n",
+                        rconfig->resource);
+                return err;
+        }
+
+        if (rconfig->devgroup >= 0) {
+                grp &= ~DEVGROUP_MASK;
+                grp |= rconfig->devgroup << DEVGROUP_SHIFT;
+                err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
+                                        grp, rconfig_addr + DEVGROUP_OFFSET);
+                if (err < 0) {
+                        pr_err("TWL4030 failed to program devgroup\n");
+                        return err;
+                }
+        }
+
+        /* Set resource types */
+        err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &type,
+                                rconfig_addr + TYPE_OFFSET);
+        if (err < 0) {
+                pr_err("TWL4030 Resource %d type could not be read\n",
+                        rconfig->resource);
+                return err;
+        }
+
+        if (rconfig->type >= 0) {
+                type &= ~TYPE_MASK;
+                type |= rconfig->type << TYPE_SHIFT;
+        }
+
+        if (rconfig->type2 >= 0) {
+                type &= ~TYPE2_MASK;
+                type |= rconfig->type2 << TYPE2_SHIFT;
+        }
+
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
+                                type, rconfig_addr + TYPE_OFFSET);
+        if (err < 0) {
+                pr_err("TWL4030 failed to program resource type\n");
+                return err;
+        }
+
+        return 0;
+}
+
+static int __init load_twl4030_script(struct twl4030_script *tscript,
+               u8 address)
+{
+        int err;
+        static int order;
+
+        /* Make sure the script isn't going beyond last valid address (0x3f) */
+        if ((address + tscript->size) > END_OF_SCRIPT) {
+                pr_err("TWL4030 scripts too big error\n");
+                return -EINVAL;
+        }
+
+        err = twl4030_write_script(address, tscript->script, tscript->size);
+        if (err)
+                goto out;
+
+        if (tscript->flags & TWL4030_WRST_SCRIPT) {
+                err = twl4030_config_warmreset_sequence(address);
+                if (err)
+                        goto out;
+        }
+        if (tscript->flags & TWL4030_WAKEUP12_SCRIPT) {
+                err = twl4030_config_wakeup12_sequence(address);
+                if (err)
+                        goto out;
+                order = 1;
+        }
+        if (tscript->flags & TWL4030_WAKEUP3_SCRIPT) {
+                err = twl4030_config_wakeup3_sequence(address);
+                if (err)
+                        goto out;
+        }
+        if (tscript->flags & TWL4030_SLEEP_SCRIPT)
+                if (order)
+                        pr_warning("TWL4030: Bad order of scripts (sleep "\
+                                        "script before wakeup) Leads to boot"\
+                                        "failure on some boards\n");
+                err = twl4030_config_sleep_sequence(address);
+out:
+        return err;
+}
+
+void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts)
+{
+        int err = 0;
+        int i;
+        struct twl4030_resconfig *resconfig;
+        u8 address = twl4030_start_script_address;
+
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_1,
+                                R_PROTECT_KEY);
+        if (err)
+                goto unlock;
+
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_2,
+                                R_PROTECT_KEY);
+        if (err)
+                goto unlock;
+
+        for (i = 0; i < twl4030_scripts->num; i++) {
+                err = load_twl4030_script(twl4030_scripts->scripts[i], address);
+                if (err)
+                        goto load;
+                address += twl4030_scripts->scripts[i]->size;
+        }
+
+        resconfig = twl4030_scripts->resource_config;
+        if (resconfig) {
+                while (resconfig->resource) {
+                        err = twl4030_configure_resource(resconfig);
+                        if (err)
+                                goto resource;
+                        resconfig++;
+
+                }
+        }
+
+        err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);
+        if (err)
+                pr_err("TWL4030 Unable to relock registers\n");
+        return;
+
+unlock:
+        if (err)
+                pr_err("TWL4030 Unable to unlock registers\n");
+        return;
+load:
+        if (err)
+                pr_err("TWL4030 failed to load scripts\n");
+        return;
+resource:
+        if (err)
+                pr_err("TWL4030 failed to configure resource\n");
+        return;
+}
diff --git a/drivers/mfd/wm831x-core.c b/drivers/mfd/wm831x-core.c
new file mode 100644
index 000000000000..49b7885c2702
--- /dev/null
+++ b/drivers/mfd/wm831x-core.c
@@ -0,0 +1,1549 @@
+/*
+ * wm831x-core.c  --  Device access for Wolfson WM831x PMICs
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/delay.h>
+#include <linux/mfd/core.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/pdata.h>
+#include <linux/mfd/wm831x/irq.h>
+#include <linux/mfd/wm831x/auxadc.h>
+#include <linux/mfd/wm831x/otp.h>
+#include <linux/mfd/wm831x/regulator.h>
+
+/* Current settings - values are 2*2^(reg_val/4) microamps.  These are
+ * exported since they are used by multiple drivers.
+ */
+int wm831x_isinkv_values[WM831X_ISINK_MAX_ISEL] = {
+        2,
+        2,
+        3,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        10,
+        11,
+        13,
+        16,
+        19,
+        23,
+        27,
+        32,
+        38,
+        45,
+        54,
+        64,
+        76,
+        91,
+        108,
+        128,
+        152,
+        181,
+        215,
+        256,
+        304,
+        362,
+        431,
+        512,
+        609,
+        724,
+        861,
+        1024,
+        1218,
+        1448,
+        1722,
+        2048,
+        2435,
+        2896,
+        3444,
+        4096,
+        4871,
+        5793,
+        6889,
+        8192,
+        9742,
+        11585,
+        13777,
+        16384,
+        19484,
+        23170,
+        27554,
+};
+EXPORT_SYMBOL_GPL(wm831x_isinkv_values);
+
+enum wm831x_parent {
+        WM8310 = 0,
+        WM8311 = 1,
+        WM8312 = 2,
+};
+
+static int wm831x_reg_locked(struct wm831x *wm831x, unsigned short reg)
+{
+        if (!wm831x->locked)
+                return 0;
+
+        switch (reg) {
+        case WM831X_WATCHDOG:
+        case WM831X_DC4_CONTROL:
+        case WM831X_ON_PIN_CONTROL:
+        case WM831X_BACKUP_CHARGER_CONTROL:
+        case WM831X_CHARGER_CONTROL_1:
+        case WM831X_CHARGER_CONTROL_2:
+                return 1;
+
+        default:
+                return 0;
+        }
+}
+
+/**
+ * wm831x_reg_unlock: Unlock user keyed registers
+ *
+ * The WM831x has a user key preventing writes to particularly
+ * critical registers.  This function locks those registers,
+ * allowing writes to them.
+ */
+void wm831x_reg_lock(struct wm831x *wm831x)
+{
+        int ret;
+
+        ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
+        if (ret == 0) {
+                dev_vdbg(wm831x->dev, "Registers locked\n");
+
+                mutex_lock(&wm831x->io_lock);
+                WARN_ON(wm831x->locked);
+                wm831x->locked = 1;
+                mutex_unlock(&wm831x->io_lock);
+        } else {
+                dev_err(wm831x->dev, "Failed to lock registers: %d\n", ret);
+        }
+
+}
+EXPORT_SYMBOL_GPL(wm831x_reg_lock);
+
+/**
+ * wm831x_reg_unlock: Unlock user keyed registers
+ *
+ * The WM831x has a user key preventing writes to particularly
+ * critical registers.  This function locks those registers,
+ * preventing spurious writes.
+ */
+int wm831x_reg_unlock(struct wm831x *wm831x)
+{
+        int ret;
+
+        /* 0x9716 is the value required to unlock the registers */
+        ret = wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0x9716);
+        if (ret == 0) {
+                dev_vdbg(wm831x->dev, "Registers unlocked\n");
+
+                mutex_lock(&wm831x->io_lock);
+                WARN_ON(!wm831x->locked);
+                wm831x->locked = 0;
+                mutex_unlock(&wm831x->io_lock);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_reg_unlock);
+
+static int wm831x_read(struct wm831x *wm831x, unsigned short reg,
+                       int bytes, void *dest)
+{
+        int ret, i;
+        u16 *buf = dest;
+
+        BUG_ON(bytes % 2);
+        BUG_ON(bytes <= 0);
+
+        ret = wm831x->read_dev(wm831x, reg, bytes, dest);
+        if (ret < 0)
+                return ret;
+
+        for (i = 0; i < bytes / 2; i++) {
+                buf[i] = be16_to_cpu(buf[i]);
+
+                dev_vdbg(wm831x->dev, "Read %04x from R%d(0x%x)\n",
+                         buf[i], reg + i, reg + i);
+        }
+
+        return 0;
+}
+
+/**
+ * wm831x_reg_read: Read a single WM831x register.
+ *
+ * @wm831x: Device to read from.
+ * @reg: Register to read.
+ */
+int wm831x_reg_read(struct wm831x *wm831x, unsigned short reg)
+{
+        unsigned short val;
+        int ret;
+
+        mutex_lock(&wm831x->io_lock);
+
+        ret = wm831x_read(wm831x, reg, 2, &val);
+
+        mutex_unlock(&wm831x->io_lock);
+
+        if (ret < 0)
+                return ret;
+        else
+                return val;
+}
+EXPORT_SYMBOL_GPL(wm831x_reg_read);
+
+/**
+ * wm831x_bulk_read: Read multiple WM831x registers
+ *
+ * @wm831x: Device to read from
+ * @reg: First register
+ * @count: Number of registers
+ * @buf: Buffer to fill.
+ */
+int wm831x_bulk_read(struct wm831x *wm831x, unsigned short reg,
+                     int count, u16 *buf)
+{
+        int ret;
+
+        mutex_lock(&wm831x->io_lock);
+
+        ret = wm831x_read(wm831x, reg, count * 2, buf);
+
+        mutex_unlock(&wm831x->io_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_bulk_read);
+
+static int wm831x_write(struct wm831x *wm831x, unsigned short reg,
+                        int bytes, void *src)
+{
+        u16 *buf = src;
+        int i;
+
+        BUG_ON(bytes % 2);
+        BUG_ON(bytes <= 0);
+
+        for (i = 0; i < bytes / 2; i++) {
+                if (wm831x_reg_locked(wm831x, reg))
+                        return -EPERM;
+
+                dev_vdbg(wm831x->dev, "Write %04x to R%d(0x%x)\n",
+                         buf[i], reg + i, reg + i);
+
+                buf[i] = cpu_to_be16(buf[i]);
+        }
+
+        return wm831x->write_dev(wm831x, reg, bytes, src);
+}
+
+/**
+ * wm831x_reg_write: Write a single WM831x register.
+ *
+ * @wm831x: Device to write to.
+ * @reg: Register to write to.
+ * @val: Value to write.
+ */
+int wm831x_reg_write(struct wm831x *wm831x, unsigned short reg,
+                     unsigned short val)
+{
+        int ret;
+
+        mutex_lock(&wm831x->io_lock);
+
+        ret = wm831x_write(wm831x, reg, 2, &val);
+
+        mutex_unlock(&wm831x->io_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_reg_write);
+
+/**
+ * wm831x_set_bits: Set the value of a bitfield in a WM831x register
+ *
+ * @wm831x: Device to write to.
+ * @reg: Register to write to.
+ * @mask: Mask of bits to set.
+ * @val: Value to set (unshifted)
+ */
+int wm831x_set_bits(struct wm831x *wm831x, unsigned short reg,
+                    unsigned short mask, unsigned short val)
+{
+        int ret;
+        u16 r;
+
+        mutex_lock(&wm831x->io_lock);
+
+        ret = wm831x_read(wm831x, reg, 2, &r);
+        if (ret < 0)
+                goto out;
+
+        r &= ~mask;
+        r |= val;
+
+        ret = wm831x_write(wm831x, reg, 2, &r);
+
+out:
+        mutex_unlock(&wm831x->io_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_set_bits);
+
+/**
+ * wm831x_auxadc_read: Read a value from the WM831x AUXADC
+ *
+ * @wm831x: Device to read from.
+ * @input: AUXADC input to read.
+ */
+int wm831x_auxadc_read(struct wm831x *wm831x, enum wm831x_auxadc input)
+{
+        int tries = 10;
+        int ret, src;
+
+        mutex_lock(&wm831x->auxadc_lock);
+
+        ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                              WM831X_AUX_ENA, WM831X_AUX_ENA);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to enable AUXADC: %d\n", ret);
+                goto out;
+        }
+
+        /* We force a single source at present */
+        src = input;
+        ret = wm831x_reg_write(wm831x, WM831X_AUXADC_SOURCE,
+                               1 << src);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to set AUXADC source: %d\n", ret);
+                goto out;
+        }
+
+        ret = wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL,
+                              WM831X_AUX_CVT_ENA, WM831X_AUX_CVT_ENA);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to start AUXADC: %d\n", ret);
+                goto disable;
+        }
+
+        do {
+                msleep(1);
+
+                ret = wm831x_reg_read(wm831x, WM831X_AUXADC_CONTROL);
+                if (ret < 0)
+                        ret = WM831X_AUX_CVT_ENA;
+        } while ((ret & WM831X_AUX_CVT_ENA) && --tries);
+
+        if (ret & WM831X_AUX_CVT_ENA) {
+                dev_err(wm831x->dev, "Timed out reading AUXADC\n");
+                ret = -EBUSY;
+                goto disable;
+        }
+
+        ret = wm831x_reg_read(wm831x, WM831X_AUXADC_DATA);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read AUXADC data: %d\n", ret);
+        } else {
+                src = ((ret & WM831X_AUX_DATA_SRC_MASK)
+                       >> WM831X_AUX_DATA_SRC_SHIFT) - 1;
+
+                if (src == 14)
+                        src = WM831X_AUX_CAL;
+
+                if (src != input) {
+                        dev_err(wm831x->dev, "Data from source %d not %d\n",
+                                src, input);
+                        ret = -EINVAL;
+                } else {
+                        ret &= WM831X_AUX_DATA_MASK;
+                }
+        }
+
+disable:
+        wm831x_set_bits(wm831x, WM831X_AUXADC_CONTROL, WM831X_AUX_ENA, 0);
+out:
+        mutex_unlock(&wm831x->auxadc_lock);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_auxadc_read);
+
+/**
+ * wm831x_auxadc_read_uv: Read a voltage from the WM831x AUXADC
+ *
+ * @wm831x: Device to read from.
+ * @input: AUXADC input to read.
+ */
+int wm831x_auxadc_read_uv(struct wm831x *wm831x, enum wm831x_auxadc input)
+{
+        int ret;
+
+        ret = wm831x_auxadc_read(wm831x, input);
+        if (ret < 0)
+                return ret;
+
+        ret *= 1465;
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_auxadc_read_uv);
+
+static struct resource wm831x_dcdc1_resources[] = {
+        {
+                .start = WM831X_DC1_CONTROL_1,
+                .end   = WM831X_DC1_DVS_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_DC1,
+                .end   = WM831X_IRQ_UV_DC1,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name  = "HC",
+                .start = WM831X_IRQ_HC_DC1,
+                .end   = WM831X_IRQ_HC_DC1,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+
+static struct resource wm831x_dcdc2_resources[] = {
+        {
+                .start = WM831X_DC2_CONTROL_1,
+                .end   = WM831X_DC2_DVS_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_DC2,
+                .end   = WM831X_IRQ_UV_DC2,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name  = "HC",
+                .start = WM831X_IRQ_HC_DC2,
+                .end   = WM831X_IRQ_HC_DC2,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_dcdc3_resources[] = {
+        {
+                .start = WM831X_DC3_CONTROL_1,
+                .end   = WM831X_DC3_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_DC3,
+                .end   = WM831X_IRQ_UV_DC3,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_dcdc4_resources[] = {
+        {
+                .start = WM831X_DC4_CONTROL,
+                .end   = WM831X_DC4_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_DC4,
+                .end   = WM831X_IRQ_UV_DC4,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_gpio_resources[] = {
+        {
+                .start = WM831X_IRQ_GPIO_1,
+                .end   = WM831X_IRQ_GPIO_16,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_isink1_resources[] = {
+        {
+                .start = WM831X_CURRENT_SINK_1,
+                .end   = WM831X_CURRENT_SINK_1,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .start = WM831X_IRQ_CS1,
+                .end   = WM831X_IRQ_CS1,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_isink2_resources[] = {
+        {
+                .start = WM831X_CURRENT_SINK_2,
+                .end   = WM831X_CURRENT_SINK_2,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .start = WM831X_IRQ_CS2,
+                .end   = WM831X_IRQ_CS2,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo1_resources[] = {
+        {
+                .start = WM831X_LDO1_CONTROL,
+                .end   = WM831X_LDO1_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO1,
+                .end   = WM831X_IRQ_UV_LDO1,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo2_resources[] = {
+        {
+                .start = WM831X_LDO2_CONTROL,
+                .end   = WM831X_LDO2_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO2,
+                .end   = WM831X_IRQ_UV_LDO2,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo3_resources[] = {
+        {
+                .start = WM831X_LDO3_CONTROL,
+                .end   = WM831X_LDO3_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO3,
+                .end   = WM831X_IRQ_UV_LDO3,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo4_resources[] = {
+        {
+                .start = WM831X_LDO4_CONTROL,
+                .end   = WM831X_LDO4_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO4,
+                .end   = WM831X_IRQ_UV_LDO4,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo5_resources[] = {
+        {
+                .start = WM831X_LDO5_CONTROL,
+                .end   = WM831X_LDO5_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO5,
+                .end   = WM831X_IRQ_UV_LDO5,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo6_resources[] = {
+        {
+                .start = WM831X_LDO6_CONTROL,
+                .end   = WM831X_LDO6_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO6,
+                .end   = WM831X_IRQ_UV_LDO6,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo7_resources[] = {
+        {
+                .start = WM831X_LDO7_CONTROL,
+                .end   = WM831X_LDO7_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO7,
+                .end   = WM831X_IRQ_UV_LDO7,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo8_resources[] = {
+        {
+                .start = WM831X_LDO8_CONTROL,
+                .end   = WM831X_LDO8_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO8,
+                .end   = WM831X_IRQ_UV_LDO8,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo9_resources[] = {
+        {
+                .start = WM831X_LDO9_CONTROL,
+                .end   = WM831X_LDO9_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO9,
+                .end   = WM831X_IRQ_UV_LDO9,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo10_resources[] = {
+        {
+                .start = WM831X_LDO10_CONTROL,
+                .end   = WM831X_LDO10_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+        {
+                .name  = "UV",
+                .start = WM831X_IRQ_UV_LDO10,
+                .end   = WM831X_IRQ_UV_LDO10,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_ldo11_resources[] = {
+        {
+                .start = WM831X_LDO11_ON_CONTROL,
+                .end   = WM831X_LDO11_SLEEP_CONTROL,
+                .flags = IORESOURCE_IO,
+        },
+};
+
+static struct resource wm831x_on_resources[] = {
+        {
+                .start = WM831X_IRQ_ON,
+                .end   = WM831X_IRQ_ON,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+
+static struct resource wm831x_power_resources[] = {
+        {
+                .name = "SYSLO",
+                .start = WM831X_IRQ_PPM_SYSLO,
+                .end   = WM831X_IRQ_PPM_SYSLO,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "PWR SRC",
+                .start = WM831X_IRQ_PPM_PWR_SRC,
+                .end   = WM831X_IRQ_PPM_PWR_SRC,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "USB CURR",
+                .start = WM831X_IRQ_PPM_USB_CURR,
+                .end   = WM831X_IRQ_PPM_USB_CURR,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "BATT HOT",
+                .start = WM831X_IRQ_CHG_BATT_HOT,
+                .end   = WM831X_IRQ_CHG_BATT_HOT,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "BATT COLD",
+                .start = WM831X_IRQ_CHG_BATT_COLD,
+                .end   = WM831X_IRQ_CHG_BATT_COLD,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "BATT FAIL",
+                .start = WM831X_IRQ_CHG_BATT_FAIL,
+                .end   = WM831X_IRQ_CHG_BATT_FAIL,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "OV",
+                .start = WM831X_IRQ_CHG_OV,
+                .end   = WM831X_IRQ_CHG_OV,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "END",
+                .start = WM831X_IRQ_CHG_END,
+                .end   = WM831X_IRQ_CHG_END,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "TO",
+                .start = WM831X_IRQ_CHG_TO,
+                .end   = WM831X_IRQ_CHG_TO,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "MODE",
+                .start = WM831X_IRQ_CHG_MODE,
+                .end   = WM831X_IRQ_CHG_MODE,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "START",
+                .start = WM831X_IRQ_CHG_START,
+                .end   = WM831X_IRQ_CHG_START,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_rtc_resources[] = {
+        {
+                .name = "PER",
+                .start = WM831X_IRQ_RTC_PER,
+                .end   = WM831X_IRQ_RTC_PER,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "ALM",
+                .start = WM831X_IRQ_RTC_ALM,
+                .end   = WM831X_IRQ_RTC_ALM,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_status1_resources[] = {
+        {
+                .start = WM831X_STATUS_LED_1,
+                .end   = WM831X_STATUS_LED_1,
+                .flags = IORESOURCE_IO,
+        },
+};
+
+static struct resource wm831x_status2_resources[] = {
+        {
+                .start = WM831X_STATUS_LED_2,
+                .end   = WM831X_STATUS_LED_2,
+                .flags = IORESOURCE_IO,
+        },
+};
+
+static struct resource wm831x_touch_resources[] = {
+        {
+                .name = "TCHPD",
+                .start = WM831X_IRQ_TCHPD,
+                .end   = WM831X_IRQ_TCHPD,
+                .flags = IORESOURCE_IRQ,
+        },
+        {
+                .name = "TCHDATA",
+                .start = WM831X_IRQ_TCHDATA,
+                .end   = WM831X_IRQ_TCHDATA,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct resource wm831x_wdt_resources[] = {
+        {
+                .start = WM831X_IRQ_WDOG_TO,
+                .end   = WM831X_IRQ_WDOG_TO,
+                .flags = IORESOURCE_IRQ,
+        },
+};
+
+static struct mfd_cell wm8310_devs[] = {
+        {
+                .name = "wm831x-buckv",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
+                .resources = wm831x_dcdc1_resources,
+        },
+        {
+                .name = "wm831x-buckv",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
+                .resources = wm831x_dcdc2_resources,
+        },
+        {
+                .name = "wm831x-buckp",
+                .id = 3,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
+                .resources = wm831x_dcdc3_resources,
+        },
+        {
+                .name = "wm831x-boostp",
+                .id = 4,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
+                .resources = wm831x_dcdc4_resources,
+        },
+        {
+                .name = "wm831x-epe",
+                .id = 1,
+        },
+        {
+                .name = "wm831x-epe",
+                .id = 2,
+        },
+        {
+                .name = "wm831x-gpio",
+                .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
+                .resources = wm831x_gpio_resources,
+        },
+        {
+                .name = "wm831x-hwmon",
+        },
+        {
+                .name = "wm831x-isink",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
+                .resources = wm831x_isink1_resources,
+        },
+        {
+                .name = "wm831x-isink",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
+                .resources = wm831x_isink2_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
+                .resources = wm831x_ldo1_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
+                .resources = wm831x_ldo2_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 3,
+                .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
+                .resources = wm831x_ldo3_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 4,
+                .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
+                .resources = wm831x_ldo4_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 5,
+                .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
+                .resources = wm831x_ldo5_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 6,
+                .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
+                .resources = wm831x_ldo6_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 7,
+                .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
+                .resources = wm831x_ldo7_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 8,
+                .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
+                .resources = wm831x_ldo8_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 9,
+                .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
+                .resources = wm831x_ldo9_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 10,
+                .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
+                .resources = wm831x_ldo10_resources,
+        },
+        {
+                .name = "wm831x-alive-ldo",
+                .id = 11,
+                .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
+                .resources = wm831x_ldo11_resources,
+        },
+        {
+                .name = "wm831x-on",
+                .num_resources = ARRAY_SIZE(wm831x_on_resources),
+                .resources = wm831x_on_resources,
+        },
+        {
+                .name = "wm831x-power",
+                .num_resources = ARRAY_SIZE(wm831x_power_resources),
+                .resources = wm831x_power_resources,
+        },
+        {
+                .name = "wm831x-rtc",
+                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
+                .resources = wm831x_rtc_resources,
+        },
+        {
+                .name = "wm831x-status",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_status1_resources),
+                .resources = wm831x_status1_resources,
+        },
+        {
+                .name = "wm831x-status",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_status2_resources),
+                .resources = wm831x_status2_resources,
+        },
+        {
+                .name = "wm831x-watchdog",
+                .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
+                .resources = wm831x_wdt_resources,
+        },
+};
+
+static struct mfd_cell wm8311_devs[] = {
+        {
+                .name = "wm831x-buckv",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
+                .resources = wm831x_dcdc1_resources,
+        },
+        {
+                .name = "wm831x-buckv",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
+                .resources = wm831x_dcdc2_resources,
+        },
+        {
+                .name = "wm831x-buckp",
+                .id = 3,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
+                .resources = wm831x_dcdc3_resources,
+        },
+        {
+                .name = "wm831x-boostp",
+                .id = 4,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
+                .resources = wm831x_dcdc4_resources,
+        },
+        {
+                .name = "wm831x-epe",
+                .id = 1,
+        },
+        {
+                .name = "wm831x-epe",
+                .id = 2,
+        },
+        {
+                .name = "wm831x-gpio",
+                .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
+                .resources = wm831x_gpio_resources,
+        },
+        {
+                .name = "wm831x-hwmon",
+        },
+        {
+                .name = "wm831x-isink",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
+                .resources = wm831x_isink1_resources,
+        },
+        {
+                .name = "wm831x-isink",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
+                .resources = wm831x_isink2_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
+                .resources = wm831x_ldo1_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
+                .resources = wm831x_ldo2_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 3,
+                .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
+                .resources = wm831x_ldo3_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 4,
+                .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
+                .resources = wm831x_ldo4_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 5,
+                .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
+                .resources = wm831x_ldo5_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 7,
+                .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
+                .resources = wm831x_ldo7_resources,
+        },
+        {
+                .name = "wm831x-alive-ldo",
+                .id = 11,
+                .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
+                .resources = wm831x_ldo11_resources,
+        },
+        {
+                .name = "wm831x-on",
+                .num_resources = ARRAY_SIZE(wm831x_on_resources),
+                .resources = wm831x_on_resources,
+        },
+        {
+                .name = "wm831x-power",
+                .num_resources = ARRAY_SIZE(wm831x_power_resources),
+                .resources = wm831x_power_resources,
+        },
+        {
+                .name = "wm831x-rtc",
+                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
+                .resources = wm831x_rtc_resources,
+        },
+        {
+                .name = "wm831x-status",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_status1_resources),
+                .resources = wm831x_status1_resources,
+        },
+        {
+                .name = "wm831x-status",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_status2_resources),
+                .resources = wm831x_status2_resources,
+        },
+        {
+                .name = "wm831x-touch",
+                .num_resources = ARRAY_SIZE(wm831x_touch_resources),
+                .resources = wm831x_touch_resources,
+        },
+        {
+                .name = "wm831x-watchdog",
+                .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
+                .resources = wm831x_wdt_resources,
+        },
+};
+
+static struct mfd_cell wm8312_devs[] = {
+        {
+                .name = "wm831x-buckv",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc1_resources),
+                .resources = wm831x_dcdc1_resources,
+        },
+        {
+                .name = "wm831x-buckv",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc2_resources),
+                .resources = wm831x_dcdc2_resources,
+        },
+        {
+                .name = "wm831x-buckp",
+                .id = 3,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc3_resources),
+                .resources = wm831x_dcdc3_resources,
+        },
+        {
+                .name = "wm831x-boostp",
+                .id = 4,
+                .num_resources = ARRAY_SIZE(wm831x_dcdc4_resources),
+                .resources = wm831x_dcdc4_resources,
+        },
+        {
+                .name = "wm831x-epe",
+                .id = 1,
+        },
+        {
+                .name = "wm831x-epe",
+                .id = 2,
+        },
+        {
+                .name = "wm831x-gpio",
+                .num_resources = ARRAY_SIZE(wm831x_gpio_resources),
+                .resources = wm831x_gpio_resources,
+        },
+        {
+                .name = "wm831x-hwmon",
+        },
+        {
+                .name = "wm831x-isink",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_isink1_resources),
+                .resources = wm831x_isink1_resources,
+        },
+        {
+                .name = "wm831x-isink",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_isink2_resources),
+                .resources = wm831x_isink2_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_ldo1_resources),
+                .resources = wm831x_ldo1_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_ldo2_resources),
+                .resources = wm831x_ldo2_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 3,
+                .num_resources = ARRAY_SIZE(wm831x_ldo3_resources),
+                .resources = wm831x_ldo3_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 4,
+                .num_resources = ARRAY_SIZE(wm831x_ldo4_resources),
+                .resources = wm831x_ldo4_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 5,
+                .num_resources = ARRAY_SIZE(wm831x_ldo5_resources),
+                .resources = wm831x_ldo5_resources,
+        },
+        {
+                .name = "wm831x-ldo",
+                .id = 6,
+                .num_resources = ARRAY_SIZE(wm831x_ldo6_resources),
+                .resources = wm831x_ldo6_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 7,
+                .num_resources = ARRAY_SIZE(wm831x_ldo7_resources),
+                .resources = wm831x_ldo7_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 8,
+                .num_resources = ARRAY_SIZE(wm831x_ldo8_resources),
+                .resources = wm831x_ldo8_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 9,
+                .num_resources = ARRAY_SIZE(wm831x_ldo9_resources),
+                .resources = wm831x_ldo9_resources,
+        },
+        {
+                .name = "wm831x-aldo",
+                .id = 10,
+                .num_resources = ARRAY_SIZE(wm831x_ldo10_resources),
+                .resources = wm831x_ldo10_resources,
+        },
+        {
+                .name = "wm831x-alive-ldo",
+                .id = 11,
+                .num_resources = ARRAY_SIZE(wm831x_ldo11_resources),
+                .resources = wm831x_ldo11_resources,
+        },
+        {
+                .name = "wm831x-on",
+                .num_resources = ARRAY_SIZE(wm831x_on_resources),
+                .resources = wm831x_on_resources,
+        },
+        {
+                .name = "wm831x-power",
+                .num_resources = ARRAY_SIZE(wm831x_power_resources),
+                .resources = wm831x_power_resources,
+        },
+        {
+                .name = "wm831x-rtc",
+                .num_resources = ARRAY_SIZE(wm831x_rtc_resources),
+                .resources = wm831x_rtc_resources,
+        },
+        {
+                .name = "wm831x-status",
+                .id = 1,
+                .num_resources = ARRAY_SIZE(wm831x_status1_resources),
+                .resources = wm831x_status1_resources,
+        },
+        {
+                .name = "wm831x-status",
+                .id = 2,
+                .num_resources = ARRAY_SIZE(wm831x_status2_resources),
+                .resources = wm831x_status2_resources,
+        },
+        {
+                .name = "wm831x-touch",
+                .num_resources = ARRAY_SIZE(wm831x_touch_resources),
+                .resources = wm831x_touch_resources,
+        },
+        {
+                .name = "wm831x-watchdog",
+                .num_resources = ARRAY_SIZE(wm831x_wdt_resources),
+                .resources = wm831x_wdt_resources,
+        },
+};
+
+static struct mfd_cell backlight_devs[] = {
+        {
+                .name = "wm831x-backlight",
+        },
+};
+
+/*
+ * Instantiate the generic non-control parts of the device.
+ */
+static int wm831x_device_init(struct wm831x *wm831x, unsigned long id, int irq)
+{
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int rev;
+        enum wm831x_parent parent;
+        int ret;
+
+        mutex_init(&wm831x->io_lock);
+        mutex_init(&wm831x->key_lock);
+        mutex_init(&wm831x->auxadc_lock);
+        dev_set_drvdata(wm831x->dev, wm831x);
+
+        ret = wm831x_reg_read(wm831x, WM831X_PARENT_ID);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read parent ID: %d\n", ret);
+                goto err;
+        }
+        if (ret != 0x6204) {
+                dev_err(wm831x->dev, "Device is not a WM831x: ID %x\n", ret);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        ret = wm831x_reg_read(wm831x, WM831X_REVISION);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read revision: %d\n", ret);
+                goto err;
+        }
+        rev = (ret & WM831X_PARENT_REV_MASK) >> WM831X_PARENT_REV_SHIFT;
+
+        ret = wm831x_reg_read(wm831x, WM831X_RESET_ID);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read device ID: %d\n", ret);
+                goto err;
+        }
+
+        switch (ret) {
+        case 0x8310:
+                parent = WM8310;
+                switch (rev) {
+                case 0:
+                        dev_info(wm831x->dev, "WM8310 revision %c\n",
+                                 'A' + rev);
+                        break;
+                }
+                break;
+
+        case 0x8311:
+                parent = WM8311;
+                switch (rev) {
+                case 0:
+                        dev_info(wm831x->dev, "WM8311 revision %c\n",
+                                 'A' + rev);
+                        break;
+                }
+                break;
+
+        case 0x8312:
+                parent = WM8312;
+                switch (rev) {
+                case 0:
+                        dev_info(wm831x->dev, "WM8312 revision %c\n",
+                                 'A' + rev);
+                        break;
+                }
+                break;
+
+        case 0:
+                /* Some engineering samples do not have the ID set,
+                 * rely on the device being registered correctly.
+                 * This will need revisiting for future devices with
+                 * multiple dies.
+                 */
+                parent = id;
+                switch (rev) {
+                case 0:
+                        dev_info(wm831x->dev, "WM831%d ES revision %c\n",
+                                 parent, 'A' + rev);
+                        break;
+                }
+                break;
+
+        default:
+                dev_err(wm831x->dev, "Unknown WM831x device %04x\n", ret);
+                ret = -EINVAL;
+                goto err;
+        }
+
+        /* This will need revisiting in future but is OK for all
+         * current parts.
+         */
+        if (parent != id)
+                dev_warn(wm831x->dev, "Device was registered as a WM831%lu\n",
+                         id);
+
+        /* Bootstrap the user key */
+        ret = wm831x_reg_read(wm831x, WM831X_SECURITY_KEY);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read security key: %d\n", ret);
+                goto err;
+        }
+        if (ret != 0) {
+                dev_warn(wm831x->dev, "Security key had non-zero value %x\n",
+                         ret);
+                wm831x_reg_write(wm831x, WM831X_SECURITY_KEY, 0);
+        }
+        wm831x->locked = 1;
+
+        if (pdata && pdata->pre_init) {
+                ret = pdata->pre_init(wm831x);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "pre_init() failed: %d\n", ret);
+                        goto err;
+                }
+        }
+
+        ret = wm831x_irq_init(wm831x, irq);
+        if (ret != 0)
+                goto err;
+
+        /* The core device is up, instantiate the subdevices. */
+        switch (parent) {
+        case WM8310:
+                ret = mfd_add_devices(wm831x->dev, -1,
+                                      wm8310_devs, ARRAY_SIZE(wm8310_devs),
+                                      NULL, 0);
+                break;
+
+        case WM8311:
+                ret = mfd_add_devices(wm831x->dev, -1,
+                                      wm8311_devs, ARRAY_SIZE(wm8311_devs),
+                                      NULL, 0);
+                break;
+
+        case WM8312:
+                ret = mfd_add_devices(wm831x->dev, -1,
+                                      wm8312_devs, ARRAY_SIZE(wm8312_devs),
+                                      NULL, 0);
+                break;
+
+        default:
+                /* If this happens the bus probe function is buggy */
+                BUG();
+        }
+
+        if (ret != 0) {
+                dev_err(wm831x->dev, "Failed to add children\n");
+                goto err_irq;
+        }
+
+        if (pdata && pdata->backlight) {
+                /* Treat errors as non-critical */
+                ret = mfd_add_devices(wm831x->dev, -1, backlight_devs,
+                                      ARRAY_SIZE(backlight_devs), NULL, 0);
+                if (ret < 0)
+                        dev_err(wm831x->dev, "Failed to add backlight: %d\n",
+                                ret);
+        }
+
+        wm831x_otp_init(wm831x);
+
+        if (pdata && pdata->post_init) {
+                ret = pdata->post_init(wm831x);
+                if (ret != 0) {
+                        dev_err(wm831x->dev, "post_init() failed: %d\n", ret);
+                        goto err_irq;
+                }
+        }
+
+        return 0;
+
+err_irq:
+        wm831x_irq_exit(wm831x);
+err:
+        mfd_remove_devices(wm831x->dev);
+        kfree(wm831x);
+        return ret;
+}
+
+static void wm831x_device_exit(struct wm831x *wm831x)
+{
+        wm831x_otp_exit(wm831x);
+        mfd_remove_devices(wm831x->dev);
+        wm831x_irq_exit(wm831x);
+        kfree(wm831x);
+}
+
+static int wm831x_i2c_read_device(struct wm831x *wm831x, unsigned short reg,
+                                  int bytes, void *dest)
+{
+        struct i2c_client *i2c = wm831x->control_data;
+        int ret;
+        u16 r = cpu_to_be16(reg);
+
+        ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
+        if (ret < 0)
+                return ret;
+        if (ret != 2)
+                return -EIO;
+
+        ret = i2c_master_recv(i2c, dest, bytes);
+        if (ret < 0)
+                return ret;
+        if (ret != bytes)
+                return -EIO;
+        return 0;
+}
+
+/* Currently we allocate the write buffer on the stack; this is OK for
+ * small writes - if we need to do large writes this will need to be
+ * revised.
+ */
+static int wm831x_i2c_write_device(struct wm831x *wm831x, unsigned short reg,
+                                   int bytes, void *src)
+{
+        struct i2c_client *i2c = wm831x->control_data;
+        unsigned char msg[bytes + 2];
+        int ret;
+
+        reg = cpu_to_be16(reg);
+        memcpy(&msg[0], &reg, 2);
+        memcpy(&msg[2], src, bytes);
+
+        ret = i2c_master_send(i2c, msg, bytes + 2);
+        if (ret < 0)
+                return ret;
+        if (ret < bytes + 2)
+                return -EIO;
+
+        return 0;
+}
+
+static int wm831x_i2c_probe(struct i2c_client *i2c,
+                            const struct i2c_device_id *id)
+{
+        struct wm831x *wm831x;
+
+        wm831x = kzalloc(sizeof(struct wm831x), GFP_KERNEL);
+        if (wm831x == NULL) {
+                kfree(i2c);
+                return -ENOMEM;
+        }
+
+        i2c_set_clientdata(i2c, wm831x);
+        wm831x->dev = &i2c->dev;
+        wm831x->control_data = i2c;
+        wm831x->read_dev = wm831x_i2c_read_device;
+        wm831x->write_dev = wm831x_i2c_write_device;
+
+        return wm831x_device_init(wm831x, id->driver_data, i2c->irq);
+}
+
+static int wm831x_i2c_remove(struct i2c_client *i2c)
+{
+        struct wm831x *wm831x = i2c_get_clientdata(i2c);
+
+        wm831x_device_exit(wm831x);
+
+        return 0;
+}
+
+static const struct i2c_device_id wm831x_i2c_id[] = {
+        { "wm8310", WM8310 },
+        { "wm8311", WM8311 },
+        { "wm8312", WM8312 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, wm831x_i2c_id);
+
+
+static struct i2c_driver wm831x_i2c_driver = {
+        .driver = {
+                   .name = "wm831x",
+                   .owner = THIS_MODULE,
+        },
+        .probe = wm831x_i2c_probe,
+        .remove = wm831x_i2c_remove,
+        .id_table = wm831x_i2c_id,
+};
+
+static int __init wm831x_i2c_init(void)
+{
+        int ret;
+
+        ret = i2c_add_driver(&wm831x_i2c_driver);
+        if (ret != 0)
+                pr_err("Failed to register wm831x I2C driver: %d\n", ret);
+
+        return ret;
+}
+subsys_initcall(wm831x_i2c_init);
+
+static void __exit wm831x_i2c_exit(void)
+{
+        i2c_del_driver(&wm831x_i2c_driver);
+}
+module_exit(wm831x_i2c_exit);
+
+MODULE_DESCRIPTION("I2C support for the WM831X AudioPlus PMIC");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mark Brown");
diff --git a/drivers/mfd/wm831x-irq.c b/drivers/mfd/wm831x-irq.c
new file mode 100644
index 000000000000..d3015dfb9134
--- /dev/null
+++ b/drivers/mfd/wm831x-irq.c
@@ -0,0 +1,559 @@
+/*
+ * wm831x-irq.c  --  Interrupt controller support for Wolfson WM831x PMICs
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/mfd/core.h>
+#include <linux/interrupt.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/pdata.h>
+#include <linux/mfd/wm831x/irq.h>
+
+#include <linux/delay.h>
+
+/*
+ * Since generic IRQs don't currently support interrupt controllers on
+ * interrupt driven buses we don't use genirq but instead provide an
+ * interface that looks very much like the standard ones.  This leads
+ * to some bodges, including storing interrupt handler information in
+ * the static irq_data table we use to look up the data for individual
+ * interrupts, but hopefully won't last too long.
+ */
+
+struct wm831x_irq_data {
+        int primary;
+        int reg;
+        int mask;
+        irq_handler_t handler;
+        void *handler_data;
+};
+
+static struct wm831x_irq_data wm831x_irqs[] = {
+        [WM831X_IRQ_TEMP_THW] = {
+                .primary = WM831X_TEMP_INT,
+                .reg = 1,
+                .mask = WM831X_TEMP_THW_EINT,
+        },
+        [WM831X_IRQ_GPIO_1] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP1_EINT,
+        },
+        [WM831X_IRQ_GPIO_2] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP2_EINT,
+        },
+        [WM831X_IRQ_GPIO_3] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP3_EINT,
+        },
+        [WM831X_IRQ_GPIO_4] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP4_EINT,
+        },
+        [WM831X_IRQ_GPIO_5] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP5_EINT,
+        },
+        [WM831X_IRQ_GPIO_6] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP6_EINT,
+        },
+        [WM831X_IRQ_GPIO_7] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP7_EINT,
+        },
+        [WM831X_IRQ_GPIO_8] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP8_EINT,
+        },
+        [WM831X_IRQ_GPIO_9] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP9_EINT,
+        },
+        [WM831X_IRQ_GPIO_10] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP10_EINT,
+        },
+        [WM831X_IRQ_GPIO_11] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP11_EINT,
+        },
+        [WM831X_IRQ_GPIO_12] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP12_EINT,
+        },
+        [WM831X_IRQ_GPIO_13] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP13_EINT,
+        },
+        [WM831X_IRQ_GPIO_14] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP14_EINT,
+        },
+        [WM831X_IRQ_GPIO_15] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP15_EINT,
+        },
+        [WM831X_IRQ_GPIO_16] = {
+                .primary = WM831X_GP_INT,
+                .reg = 5,
+                .mask = WM831X_GP16_EINT,
+        },
+        [WM831X_IRQ_ON] = {
+                .primary = WM831X_ON_PIN_INT,
+                .reg = 1,
+                .mask = WM831X_ON_PIN_EINT,
+        },
+        [WM831X_IRQ_PPM_SYSLO] = {
+                .primary = WM831X_PPM_INT,
+                .reg = 1,
+                .mask = WM831X_PPM_SYSLO_EINT,
+        },
+        [WM831X_IRQ_PPM_PWR_SRC] = {
+                .primary = WM831X_PPM_INT,
+                .reg = 1,
+                .mask = WM831X_PPM_PWR_SRC_EINT,
+        },
+        [WM831X_IRQ_PPM_USB_CURR] = {
+                .primary = WM831X_PPM_INT,
+                .reg = 1,
+                .mask = WM831X_PPM_USB_CURR_EINT,
+        },
+        [WM831X_IRQ_WDOG_TO] = {
+                .primary = WM831X_WDOG_INT,
+                .reg = 1,
+                .mask = WM831X_WDOG_TO_EINT,
+        },
+        [WM831X_IRQ_RTC_PER] = {
+                .primary = WM831X_RTC_INT,
+                .reg = 1,
+                .mask = WM831X_RTC_PER_EINT,
+        },
+        [WM831X_IRQ_RTC_ALM] = {
+                .primary = WM831X_RTC_INT,
+                .reg = 1,
+                .mask = WM831X_RTC_ALM_EINT,
+        },
+        [WM831X_IRQ_CHG_BATT_HOT] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_BATT_HOT_EINT,
+        },
+        [WM831X_IRQ_CHG_BATT_COLD] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_BATT_COLD_EINT,
+        },
+        [WM831X_IRQ_CHG_BATT_FAIL] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_BATT_FAIL_EINT,
+        },
+        [WM831X_IRQ_CHG_OV] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_OV_EINT,
+        },
+        [WM831X_IRQ_CHG_END] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_END_EINT,
+        },
+        [WM831X_IRQ_CHG_TO] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_TO_EINT,
+        },
+        [WM831X_IRQ_CHG_MODE] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_MODE_EINT,
+        },
+        [WM831X_IRQ_CHG_START] = {
+                .primary = WM831X_CHG_INT,
+                .reg = 2,
+                .mask = WM831X_CHG_START_EINT,
+        },
+        [WM831X_IRQ_TCHDATA] = {
+                .primary = WM831X_TCHDATA_INT,
+                .reg = 1,
+                .mask = WM831X_TCHDATA_EINT,
+        },
+        [WM831X_IRQ_TCHPD] = {
+                .primary = WM831X_TCHPD_INT,
+                .reg = 1,
+                .mask = WM831X_TCHPD_EINT,
+        },
+        [WM831X_IRQ_AUXADC_DATA] = {
+                .primary = WM831X_AUXADC_INT,
+                .reg = 1,
+                .mask = WM831X_AUXADC_DATA_EINT,
+        },
+        [WM831X_IRQ_AUXADC_DCOMP1] = {
+                .primary = WM831X_AUXADC_INT,
+                .reg = 1,
+                .mask = WM831X_AUXADC_DCOMP1_EINT,
+        },
+        [WM831X_IRQ_AUXADC_DCOMP2] = {
+                .primary = WM831X_AUXADC_INT,
+                .reg = 1,
+                .mask = WM831X_AUXADC_DCOMP2_EINT,
+        },
+        [WM831X_IRQ_AUXADC_DCOMP3] = {
+                .primary = WM831X_AUXADC_INT,
+                .reg = 1,
+                .mask = WM831X_AUXADC_DCOMP3_EINT,
+        },
+        [WM831X_IRQ_AUXADC_DCOMP4] = {
+                .primary = WM831X_AUXADC_INT,
+                .reg = 1,
+                .mask = WM831X_AUXADC_DCOMP4_EINT,
+        },
+        [WM831X_IRQ_CS1] = {
+                .primary = WM831X_CS_INT,
+                .reg = 2,
+                .mask = WM831X_CS1_EINT,
+        },
+        [WM831X_IRQ_CS2] = {
+                .primary = WM831X_CS_INT,
+                .reg = 2,
+                .mask = WM831X_CS2_EINT,
+        },
+        [WM831X_IRQ_HC_DC1] = {
+                .primary = WM831X_HC_INT,
+                .reg = 4,
+                .mask = WM831X_HC_DC1_EINT,
+        },
+        [WM831X_IRQ_HC_DC2] = {
+                .primary = WM831X_HC_INT,
+                .reg = 4,
+                .mask = WM831X_HC_DC2_EINT,
+        },
+        [WM831X_IRQ_UV_LDO1] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO1_EINT,
+        },
+        [WM831X_IRQ_UV_LDO2] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO2_EINT,
+        },
+        [WM831X_IRQ_UV_LDO3] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO3_EINT,
+        },
+        [WM831X_IRQ_UV_LDO4] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO4_EINT,
+        },
+        [WM831X_IRQ_UV_LDO5] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO5_EINT,
+        },
+        [WM831X_IRQ_UV_LDO6] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO6_EINT,
+        },
+        [WM831X_IRQ_UV_LDO7] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO7_EINT,
+        },
+        [WM831X_IRQ_UV_LDO8] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO8_EINT,
+        },
+        [WM831X_IRQ_UV_LDO9] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO9_EINT,
+        },
+        [WM831X_IRQ_UV_LDO10] = {
+                .primary = WM831X_UV_INT,
+                .reg = 3,
+                .mask = WM831X_UV_LDO10_EINT,
+        },
+        [WM831X_IRQ_UV_DC1] = {
+                .primary = WM831X_UV_INT,
+                .reg = 4,
+                .mask = WM831X_UV_DC1_EINT,
+        },
+        [WM831X_IRQ_UV_DC2] = {
+                .primary = WM831X_UV_INT,
+                .reg = 4,
+                .mask = WM831X_UV_DC2_EINT,
+        },
+        [WM831X_IRQ_UV_DC3] = {
+                .primary = WM831X_UV_INT,
+                .reg = 4,
+                .mask = WM831X_UV_DC3_EINT,
+        },
+        [WM831X_IRQ_UV_DC4] = {
+                .primary = WM831X_UV_INT,
+                .reg = 4,
+                .mask = WM831X_UV_DC4_EINT,
+        },
+};
+
+static inline int irq_data_to_status_reg(struct wm831x_irq_data *irq_data)
+{
+        return WM831X_INTERRUPT_STATUS_1 - 1 + irq_data->reg;
+}
+
+static inline int irq_data_to_mask_reg(struct wm831x_irq_data *irq_data)
+{
+        return WM831X_INTERRUPT_STATUS_1_MASK - 1 + irq_data->reg;
+}
+
+static void __wm831x_enable_irq(struct wm831x *wm831x, int irq)
+{
+        struct wm831x_irq_data *irq_data = &wm831x_irqs[irq];
+
+        wm831x->irq_masks[irq_data->reg - 1] &= ~irq_data->mask;
+        wm831x_reg_write(wm831x, irq_data_to_mask_reg(irq_data),
+                         wm831x->irq_masks[irq_data->reg - 1]);
+}
+
+void wm831x_enable_irq(struct wm831x *wm831x, int irq)
+{
+        mutex_lock(&wm831x->irq_lock);
+        __wm831x_enable_irq(wm831x, irq);
+        mutex_unlock(&wm831x->irq_lock);
+}
+EXPORT_SYMBOL_GPL(wm831x_enable_irq);
+
+static void __wm831x_disable_irq(struct wm831x *wm831x, int irq)
+{
+        struct wm831x_irq_data *irq_data = &wm831x_irqs[irq];
+
+        wm831x->irq_masks[irq_data->reg - 1] |= irq_data->mask;
+        wm831x_reg_write(wm831x, irq_data_to_mask_reg(irq_data),
+                         wm831x->irq_masks[irq_data->reg - 1]);
+}
+
+void wm831x_disable_irq(struct wm831x *wm831x, int irq)
+{
+        mutex_lock(&wm831x->irq_lock);
+        __wm831x_disable_irq(wm831x, irq);
+        mutex_unlock(&wm831x->irq_lock);
+}
+EXPORT_SYMBOL_GPL(wm831x_disable_irq);
+
+int wm831x_request_irq(struct wm831x *wm831x,
+                       unsigned int irq, irq_handler_t handler,
+                       unsigned long flags, const char *name,
+                       void *dev)
+{
+        int ret = 0;
+
+        if (irq < 0 || irq >= WM831X_NUM_IRQS)
+                return -EINVAL;
+
+        mutex_lock(&wm831x->irq_lock);
+
+        if (wm831x_irqs[irq].handler) {
+                dev_err(wm831x->dev, "Already have handler for IRQ %d\n", irq);
+                ret = -EINVAL;
+                goto out;
+        }
+
+        wm831x_irqs[irq].handler = handler;
+        wm831x_irqs[irq].handler_data = dev;
+
+        __wm831x_enable_irq(wm831x, irq);
+
+out:
+        mutex_unlock(&wm831x->irq_lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(wm831x_request_irq);
+
+void wm831x_free_irq(struct wm831x *wm831x, unsigned int irq, void *data)
+{
+        if (irq < 0 || irq >= WM831X_NUM_IRQS)
+                return;
+
+        mutex_lock(&wm831x->irq_lock);
+
+        wm831x_irqs[irq].handler = NULL;
+        wm831x_irqs[irq].handler_data = NULL;
+
+        __wm831x_disable_irq(wm831x, irq);
+
+        mutex_unlock(&wm831x->irq_lock);
+}
+EXPORT_SYMBOL_GPL(wm831x_free_irq);
+
+
+static void wm831x_handle_irq(struct wm831x *wm831x, int irq, int status)
+{
+        struct wm831x_irq_data *irq_data = &wm831x_irqs[irq];
+
+        if (irq_data->handler) {
+                irq_data->handler(irq, irq_data->handler_data);
+                wm831x_reg_write(wm831x, irq_data_to_status_reg(irq_data),
+                                 irq_data->mask);
+        } else {
+                dev_err(wm831x->dev, "Unhandled IRQ %d, masking\n", irq);
+                __wm831x_disable_irq(wm831x, irq);
+        }
+}
+
+/* Main interrupt handling occurs in a workqueue since we need
+ * interrupts enabled to interact with the chip. */
+static void wm831x_irq_worker(struct work_struct *work)
+{
+        struct wm831x *wm831x = container_of(work, struct wm831x, irq_work);
+        unsigned int i;
+        int primary;
+        int status_regs[5];
+        int read[5] = { 0 };
+        int *status;
+
+        primary = wm831x_reg_read(wm831x, WM831X_SYSTEM_INTERRUPTS);
+        if (primary < 0) {
+                dev_err(wm831x->dev, "Failed to read system interrupt: %d\n",
+                        primary);
+                goto out;
+        }
+
+        mutex_lock(&wm831x->irq_lock);
+
+        for (i = 0; i < ARRAY_SIZE(wm831x_irqs); i++) {
+                int offset = wm831x_irqs[i].reg - 1;
+
+                if (!(primary & wm831x_irqs[i].primary))
+                        continue;
+
+                status = &status_regs[offset];
+
+                /* Hopefully there should only be one register to read
+                 * each time otherwise we ought to do a block read. */
+                if (!read[offset]) {
+                        *status = wm831x_reg_read(wm831x,
+                                     irq_data_to_status_reg(&wm831x_irqs[i]));
+                        if (*status < 0) {
+                                dev_err(wm831x->dev,
+                                        "Failed to read IRQ status: %d\n",
+                                        *status);
+                                goto out_lock;
+                        }
+
+                        /* Mask out the disabled IRQs */
+                        *status &= ~wm831x->irq_masks[offset];
+                        read[offset] = 1;
+                }
+
+                if (*status & wm831x_irqs[i].mask)
+                        wm831x_handle_irq(wm831x, i, *status);
+        }
+
+out_lock:
+        mutex_unlock(&wm831x->irq_lock);
+out:
+        enable_irq(wm831x->irq);
+}
+
+
+static irqreturn_t wm831x_cpu_irq(int irq, void *data)
+{
+        struct wm831x *wm831x = data;
+
+        /* Shut the interrupt to the CPU up and schedule the actual
+         * handler; we can't check that the IRQ is asserted. */
+        disable_irq_nosync(irq);
+
+        queue_work(wm831x->irq_wq, &wm831x->irq_work);
+
+        return IRQ_HANDLED;
+}
+
+int wm831x_irq_init(struct wm831x *wm831x, int irq)
+{
+        int i, ret;
+
+        if (!irq) {
+                dev_warn(wm831x->dev,
+                         "No interrupt specified - functionality limited\n");
+                return 0;
+        }
+
+
+        wm831x->irq_wq = create_singlethread_workqueue("wm831x-irq");
+        if (!wm831x->irq_wq) {
+                dev_err(wm831x->dev, "Failed to allocate IRQ worker\n");
+                return -ESRCH;
+        }
+
+        wm831x->irq = irq;
+        mutex_init(&wm831x->irq_lock);
+        INIT_WORK(&wm831x->irq_work, wm831x_irq_worker);
+
+        /* Mask the individual interrupt sources */
+        for (i = 0; i < ARRAY_SIZE(wm831x->irq_masks); i++) {
+                wm831x->irq_masks[i] = 0xffff;
+                wm831x_reg_write(wm831x, WM831X_INTERRUPT_STATUS_1_MASK + i,
+                                 0xffff);
+        }
+
+        /* Enable top level interrupts, we mask at secondary level */
+        wm831x_reg_write(wm831x, WM831X_SYSTEM_INTERRUPTS_MASK, 0);
+
+        /* We're good to go.  We set IRQF_SHARED since there's a
+         * chance the driver will interoperate with another driver but
+         * the need to disable the IRQ while handing via I2C/SPI means
+         * that this may break and performance will be impacted.  If
+         * this does happen it's a hardware design issue and the only
+         * other alternative would be polling.
+         */
+        ret = request_irq(irq, wm831x_cpu_irq, IRQF_TRIGGER_LOW | IRQF_SHARED,
+                          "wm831x", wm831x);
+        if (ret != 0) {
+                dev_err(wm831x->dev, "Failed to request IRQ %d: %d\n",
+                        irq, ret);
+                return ret;
+        }
+
+        return 0;
+}
+
+void wm831x_irq_exit(struct wm831x *wm831x)
+{
+        if (wm831x->irq)
+                free_irq(wm831x->irq, wm831x);
+}
diff --git a/drivers/mfd/wm831x-otp.c b/drivers/mfd/wm831x-otp.c
new file mode 100644
index 000000000000..f742745ff354
--- /dev/null
+++ b/drivers/mfd/wm831x-otp.c
@@ -0,0 +1,83 @@
+/*
+ * wm831x-otp.c  --  OTP for Wolfson WM831x PMICs
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/bcd.h>
+#include <linux/delay.h>
+#include <linux/mfd/core.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/otp.h>
+
+/* In bytes */
+#define WM831X_UNIQUE_ID_LEN 16
+
+/* Read the unique ID from the chip into id */
+static int wm831x_unique_id_read(struct wm831x *wm831x, char *id)
+{
+        int i, val;
+
+        for (i = 0; i < WM831X_UNIQUE_ID_LEN / 2; i++) {
+                val = wm831x_reg_read(wm831x, WM831X_UNIQUE_ID_1 + i);
+                if (val < 0)
+                        return val;
+
+                id[i * 2]       = (val >> 8) & 0xff;
+                id[(i * 2) + 1] = val & 0xff;
+        }
+
+        return 0;
+}
+
+static ssize_t wm831x_unique_id_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct wm831x *wm831x = dev_get_drvdata(dev);
+        int i, rval;
+        char id[WM831X_UNIQUE_ID_LEN];
+        ssize_t ret = 0;
+
+        rval = wm831x_unique_id_read(wm831x, id);
+        if (rval < 0)
+                return 0;
+
+        for (i = 0; i < WM831X_UNIQUE_ID_LEN; i++)
+                ret += sprintf(&buf[ret], "%02x", buf[i]);
+
+        ret += sprintf(&buf[ret], "\n");
+
+        return ret;
+}
+
+static DEVICE_ATTR(unique_id, 0444, wm831x_unique_id_show, NULL);
+
+int wm831x_otp_init(struct wm831x *wm831x)
+{
+        int ret;
+
+        ret = device_create_file(wm831x->dev, &dev_attr_unique_id);
+        if (ret != 0)
+                dev_err(wm831x->dev, "Unique ID attribute not created: %d\n",
+                        ret);
+
+        return ret;
+}
+
+void wm831x_otp_exit(struct wm831x *wm831x)
+{
+        device_remove_file(wm831x->dev, &dev_attr_unique_id);
+}
+
diff --git a/drivers/mfd/wm8350-core.c b/drivers/mfd/wm8350-core.c
index fe24079387c5..ba27c9dc1ad3 100644
--- a/drivers/mfd/wm8350-core.c
+++ b/drivers/mfd/wm8350-core.c
@@ -353,15 +353,15 @@ static void wm8350_irq_call_handler(struct wm8350 *wm8350, int irq)
 }
 
 /*
- * wm8350_irq_worker actually handles the interrupts.  Since all
+ * This is a threaded IRQ handler so can access I2C/SPI.  Since all
  * interrupts are clear on read the IRQ line will be reasserted and
  * the physical IRQ will be handled again if another interrupt is
  * asserted while we run - in the normal course of events this is a
  * rare occurrence so we save I2C/SPI reads.
  */
-static void wm8350_irq_worker(struct work_struct *work)
+static irqreturn_t wm8350_irq(int irq, void *data)
 {
-        struct wm8350 *wm8350 = container_of(work, struct wm8350, irq_work);
+        struct wm8350 *wm8350 = data;
         u16 level_one, status1, status2, comp;
 
         /* TODO: Use block reads to improve performance? */
@@ -552,16 +552,6 @@ static void wm8350_irq_worker(struct work_struct *work)
                 }
         }
 
-        enable_irq(wm8350->chip_irq);
-}
-
-static irqreturn_t wm8350_irq(int irq, void *data)
-{
-        struct wm8350 *wm8350 = data;
-
-        disable_irq_nosync(irq);
-        schedule_work(&wm8350->irq_work);
-
         return IRQ_HANDLED;
 }
 
@@ -1428,9 +1418,8 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
 
         mutex_init(&wm8350->auxadc_mutex);
         mutex_init(&wm8350->irq_mutex);
-        INIT_WORK(&wm8350->irq_work, wm8350_irq_worker);
         if (irq) {
-                int flags = 0;
+                int flags = IRQF_ONESHOT;
 
                 if (pdata && pdata->irq_high) {
                         flags |= IRQF_TRIGGER_HIGH;
@@ -1444,8 +1433,8 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
                                           WM8350_IRQ_POL);
                 }
 
-                ret = request_irq(irq, wm8350_irq, flags,
-                                  "wm8350", wm8350);
+                ret = request_threaded_irq(irq, NULL, wm8350_irq, flags,
+                                           "wm8350", wm8350);
                 if (ret != 0) {
                         dev_err(wm8350->dev, "Failed to request IRQ: %d\n",
                                 ret);
@@ -1472,6 +1461,8 @@ int wm8350_device_init(struct wm8350 *wm8350, int irq,
                                    &(wm8350->codec.pdev));
         wm8350_client_dev_register(wm8350, "wm8350-gpio",
                                    &(wm8350->gpio.pdev));
+        wm8350_client_dev_register(wm8350, "wm8350-hwmon",
+                                   &(wm8350->hwmon.pdev));
         wm8350_client_dev_register(wm8350, "wm8350-power",
                                    &(wm8350->power.pdev));
         wm8350_client_dev_register(wm8350, "wm8350-rtc", &(wm8350->rtc.pdev));
@@ -1498,11 +1489,11 @@ void wm8350_device_exit(struct wm8350 *wm8350)
         platform_device_unregister(wm8350->wdt.pdev);
         platform_device_unregister(wm8350->rtc.pdev);
         platform_device_unregister(wm8350->power.pdev);
+        platform_device_unregister(wm8350->hwmon.pdev);
         platform_device_unregister(wm8350->gpio.pdev);
         platform_device_unregister(wm8350->codec.pdev);
 
         free_irq(wm8350->chip_irq, wm8350);
-        flush_work(&wm8350->irq_work);
         kfree(wm8350->reg_cache);
 }
 EXPORT_SYMBOL_GPL(wm8350_device_exit);
diff --git a/drivers/misc/sgi-xp/xpc_sn2.c b/drivers/misc/sgi-xp/xpc_sn2.c
index 915a3b495da5..8b70e03f939f 100644
--- a/drivers/misc/sgi-xp/xpc_sn2.c
+++ b/drivers/misc/sgi-xp/xpc_sn2.c
@@ -279,7 +279,7 @@ xpc_check_for_sent_chctl_flags_sn2(struct xpc_partition *part)
         spin_unlock_irqrestore(&part->chctl_lock, irq_flags);
 
         dev_dbg(xpc_chan, "received notify IRQ from partid=%d, chctl.all_flags="
-                "0x%lx\n", XPC_PARTID(part), chctl.all_flags);
+                "0x%llx\n", XPC_PARTID(part), chctl.all_flags);
 
         xpc_wakeup_channel_mgr(part);
 }
@@ -615,7 +615,8 @@ xpc_get_partition_rsvd_page_pa_sn2(void *buf, u64 *cookie, unsigned long *rp_pa,
         s64 status;
         enum xp_retval ret;
 
-        status = sn_partition_reserved_page_pa((u64)buf, cookie, rp_pa, len);
+        status = sn_partition_reserved_page_pa((u64)buf, cookie,
+                        (u64 *)rp_pa, (u64 *)len);
         if (status == SALRET_OK)
                 ret = xpSuccess;
         else if (status == SALRET_MORE_PASSES)
@@ -777,8 +778,8 @@ xpc_get_remote_heartbeat_sn2(struct xpc_partition *part)
         if (ret != xpSuccess)
                 return ret;
 
-        dev_dbg(xpc_part, "partid=%d, heartbeat=%ld, last_heartbeat=%ld, "
-                "heartbeat_offline=%ld, HB_mask[0]=0x%lx\n", XPC_PARTID(part),
+        dev_dbg(xpc_part, "partid=%d, heartbeat=%lld, last_heartbeat=%lld, "
+                "heartbeat_offline=%lld, HB_mask[0]=0x%lx\n", XPC_PARTID(part),
                 remote_vars->heartbeat, part->last_heartbeat,
                 remote_vars->heartbeat_offline,
                 remote_vars->heartbeating_to_mask[0]);
@@ -940,7 +941,7 @@ xpc_update_partition_info_sn2(struct xpc_partition *part, u8 remote_rp_version,
                 part_sn2->remote_vars_pa);
 
         part->last_heartbeat = remote_vars->heartbeat - 1;
-        dev_dbg(xpc_part, "  last_heartbeat = 0x%016lx\n",
+        dev_dbg(xpc_part, "  last_heartbeat = 0x%016llx\n",
                 part->last_heartbeat);
 
         part_sn2->remote_vars_part_pa = remote_vars->vars_part_pa;
@@ -1029,7 +1030,8 @@ xpc_identify_activate_IRQ_req_sn2(int nasid)
         part->activate_IRQ_rcvd++;
 
         dev_dbg(xpc_part, "partid for nasid %d is %d; IRQs = %d; HB = "
-                "%ld:0x%lx\n", (int)nasid, (int)partid, part->activate_IRQ_rcvd,
+                "%lld:0x%lx\n", (int)nasid, (int)partid,
+                part->activate_IRQ_rcvd,
                 remote_vars->heartbeat, remote_vars->heartbeating_to_mask[0]);
 
         if (xpc_partition_disengaged(part) &&
@@ -1129,7 +1131,7 @@ xpc_identify_activate_IRQ_sender_sn2(void)
                 do {
                         n_IRQs_detected++;
                         nasid = (l * BITS_PER_LONG + b) * 2;
-                        dev_dbg(xpc_part, "interrupt from nasid %ld\n", nasid);
+                        dev_dbg(xpc_part, "interrupt from nasid %lld\n", nasid);
                         xpc_identify_activate_IRQ_req_sn2(nasid);
 
                         b = find_next_bit(&nasid_mask_long, BITS_PER_LONG,
@@ -1386,7 +1388,7 @@ xpc_pull_remote_vars_part_sn2(struct xpc_partition *part)
 
                 if (pulled_entry->magic != 0) {
                         dev_dbg(xpc_chan, "partition %d's XPC vars_part for "
-                                "partition %d has bad magic value (=0x%lx)\n",
+                                "partition %d has bad magic value (=0x%llx)\n",
                                 partid, sn_partition_id, pulled_entry->magic);
                         return xpBadMagic;
                 }
@@ -1730,14 +1732,14 @@ xpc_notify_senders_sn2(struct xpc_channel *ch, enum xp_retval reason, s64 put)
 
                 if (notify->func != NULL) {
                         dev_dbg(xpc_chan, "notify->func() called, notify=0x%p "
-                                "msg_number=%ld partid=%d channel=%d\n",
+                                "msg_number=%lld partid=%d channel=%d\n",
                                 (void *)notify, get, ch->partid, ch->number);
 
                         notify->func(reason, ch->partid, ch->number,
                                      notify->key);
 
                         dev_dbg(xpc_chan, "notify->func() returned, notify=0x%p"
-                                " msg_number=%ld partid=%d channel=%d\n",
+                                " msg_number=%lld partid=%d channel=%d\n",
                                 (void *)notify, get, ch->partid, ch->number);
                 }
         }
@@ -1858,7 +1860,7 @@ xpc_process_msg_chctl_flags_sn2(struct xpc_partition *part, int ch_number)
 
                 ch_sn2->w_remote_GP.get = ch_sn2->remote_GP.get;
 
-                dev_dbg(xpc_chan, "w_remote_GP.get changed to %ld, partid=%d, "
+                dev_dbg(xpc_chan, "w_remote_GP.get changed to %lld, partid=%d, "
                         "channel=%d\n", ch_sn2->w_remote_GP.get, ch->partid,
                         ch->number);
 
@@ -1885,7 +1887,7 @@ xpc_process_msg_chctl_flags_sn2(struct xpc_partition *part, int ch_number)
                 smp_wmb(); /* ensure flags have been cleared before bte_copy */
                 ch_sn2->w_remote_GP.put = ch_sn2->remote_GP.put;
 
-                dev_dbg(xpc_chan, "w_remote_GP.put changed to %ld, partid=%d, "
+                dev_dbg(xpc_chan, "w_remote_GP.put changed to %lld, partid=%d, "
                         "channel=%d\n", ch_sn2->w_remote_GP.put, ch->partid,
                         ch->number);
 
@@ -1943,7 +1945,7 @@ xpc_pull_remote_msg_sn2(struct xpc_channel *ch, s64 get)
                 if (ret != xpSuccess) {
 
                         dev_dbg(xpc_chan, "failed to pull %d msgs starting with"
-                                " msg %ld from partition %d, channel=%d, "
+                                " msg %lld from partition %d, channel=%d, "
                                 "ret=%d\n", nmsgs, ch_sn2->next_msg_to_pull,
                                 ch->partid, ch->number, ret);
 
@@ -1995,7 +1997,7 @@ xpc_get_deliverable_payload_sn2(struct xpc_channel *ch)
                 if (cmpxchg(&ch_sn2->w_local_GP.get, get, get + 1) == get) {
                         /* we got the entry referenced by get */
 
-                        dev_dbg(xpc_chan, "w_local_GP.get changed to %ld, "
+                        dev_dbg(xpc_chan, "w_local_GP.get changed to %lld, "
                                 "partid=%d, channel=%d\n", get + 1,
                                 ch->partid, ch->number);
 
@@ -2062,7 +2064,7 @@ xpc_send_msgs_sn2(struct xpc_channel *ch, s64 initial_put)
 
                 /* we just set the new value of local_GP->put */
 
-                dev_dbg(xpc_chan, "local_GP->put changed to %ld, partid=%d, "
+                dev_dbg(xpc_chan, "local_GP->put changed to %lld, partid=%d, "
                         "channel=%d\n", put, ch->partid, ch->number);
 
                 send_msgrequest = 1;
@@ -2147,8 +2149,8 @@ xpc_allocate_msg_sn2(struct xpc_channel *ch, u32 flags,
         DBUG_ON(msg->flags != 0);
         msg->number = put;
 
-        dev_dbg(xpc_chan, "w_local_GP.put changed to %ld; msg=0x%p, "
-                "msg_number=%ld, partid=%d, channel=%d\n", put + 1,
+        dev_dbg(xpc_chan, "w_local_GP.put changed to %lld; msg=0x%p, "
+                "msg_number=%lld, partid=%d, channel=%d\n", put + 1,
                 (void *)msg, msg->number, ch->partid, ch->number);
 
         *address_of_msg = msg;
@@ -2296,7 +2298,7 @@ xpc_acknowledge_msgs_sn2(struct xpc_channel *ch, s64 initial_get, u8 msg_flags)
 
                 /* we just set the new value of local_GP->get */
 
-                dev_dbg(xpc_chan, "local_GP->get changed to %ld, partid=%d, "
+                dev_dbg(xpc_chan, "local_GP->get changed to %lld, partid=%d, "
                         "channel=%d\n", get, ch->partid, ch->number);
 
                 send_msgrequest = (msg_flags & XPC_M_SN2_INTERRUPT);
@@ -2323,7 +2325,7 @@ xpc_received_payload_sn2(struct xpc_channel *ch, void *payload)
         msg = container_of(payload, struct xpc_msg_sn2, payload);
         msg_number = msg->number;
 
-        dev_dbg(xpc_chan, "msg=0x%p, msg_number=%ld, partid=%d, channel=%d\n",
+        dev_dbg(xpc_chan, "msg=0x%p, msg_number=%lld, partid=%d, channel=%d\n",
                 (void *)msg, msg_number, ch->partid, ch->number);
 
         DBUG_ON((((u64)msg - (u64)ch->sn.sn2.remote_msgqueue) / ch->entry_size) !=
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index 782994ead0e8..005b91f096f2 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -63,7 +63,7 @@ static void ams_delta_write_byte(struct mtd_info *mtd, u_char byte)
 {
         struct nand_chip *this = mtd->priv;
 
-        omap_writew(0, (OMAP_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
+        omap_writew(0, (OMAP1_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
         omap_writew(byte, this->IO_ADDR_W);
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NWE, 0);
         ndelay(40);
@@ -78,7 +78,7 @@ static u_char ams_delta_read_byte(struct mtd_info *mtd)
 
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE, 0);
         ndelay(40);
-        omap_writew(~0, (OMAP_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
+        omap_writew(~0, (OMAP1_MPUIO_BASE + OMAP_MPUIO_IO_CNTL));
         res = omap_readw(this->IO_ADDR_R);
         ams_delta_latch2_write(AMS_DELTA_LATCH2_NAND_NRE,
                                AMS_DELTA_LATCH2_NAND_NRE);
@@ -178,8 +178,8 @@ static int __init ams_delta_init(void)
         ams_delta_mtd->priv = this;
 
         /* Set address of NAND IO lines */
-        this->IO_ADDR_R = (OMAP_MPUIO_BASE + OMAP_MPUIO_INPUT_LATCH);
-        this->IO_ADDR_W = (OMAP_MPUIO_BASE + OMAP_MPUIO_OUTPUT);
+        this->IO_ADDR_R = (OMAP1_MPUIO_BASE + OMAP_MPUIO_INPUT_LATCH);
+        this->IO_ADDR_W = (OMAP1_MPUIO_BASE + OMAP_MPUIO_OUTPUT);
         this->read_byte = ams_delta_read_byte;
         this->write_buf = ams_delta_write_buf;
         this->read_buf = ams_delta_read_buf;
diff --git a/drivers/net/slip.c b/drivers/net/slip.c
index 26f6ee93a064..e17c535a577e 100644
--- a/drivers/net/slip.c
+++ b/drivers/net/slip.c
@@ -616,6 +616,14 @@ static void sl_uninit(struct net_device *dev)
         sl_free_bufs(sl);
 }
 
+/* Hook the destructor so we can free slip devices at the right point in time */
+static void sl_free_netdev(struct net_device *dev)
+{
+        int i = dev->base_addr;
+        free_netdev(dev);
+        slip_devs[i] = NULL;
+}
+
 static const struct net_device_ops sl_netdev_ops = {
         .ndo_init               = sl_init,
         .ndo_uninit             = sl_uninit,
@@ -634,7 +642,7 @@ static const struct net_device_ops sl_netdev_ops = {
 static void sl_setup(struct net_device *dev)
 {
         dev->netdev_ops         = &sl_netdev_ops;
-        dev->destructor         = free_netdev;
+        dev->destructor         = sl_free_netdev;
 
         dev->hard_header_len    = 0;
         dev->addr_len           = 0;
@@ -712,8 +720,6 @@ static void sl_sync(void)
 static struct slip *sl_alloc(dev_t line)
 {
         int i;
-        int sel = -1;
-        int score = -1;
         struct net_device *dev = NULL;
         struct slip       *sl;
 
@@ -724,55 +730,7 @@ static struct slip *sl_alloc(dev_t line)
                 dev = slip_devs[i];
                 if (dev == NULL)
                         break;
-
-                sl = netdev_priv(dev);
-                if (sl->leased) {
-                        if (sl->line != line)
-                                continue;
-                        if (sl->tty)
-                                return NULL;
-
-                        /* Clear ESCAPE & ERROR flags */
-                        sl->flags &= (1 << SLF_INUSE);
-                        return sl;
-                }
-
-                if (sl->tty)
-                        continue;
-
-                if (current->pid == sl->pid) {
-                        if (sl->line == line && score < 3) {
-                                sel = i;
-                                score = 3;
-                                continue;
-                        }
-                        if (score < 2) {
-                                sel = i;
-                                score = 2;
-                        }
-                        continue;
-                }
-                if (sl->line == line && score < 1) {
-                        sel = i;
-                        score = 1;
-                        continue;
-                }
-                if (score < 0) {
-                        sel = i;
-                        score = 0;
-                }
-        }
-
-        if (sel >= 0) {
-                i = sel;
-                dev = slip_devs[i];
-                if (score > 1) {
-                        sl = netdev_priv(dev);
-                        sl->flags &= (1 << SLF_INUSE);
-                        return sl;
-                }
         }
-
         /* Sorry, too many, all slots in use */
         if (i >= slip_maxdev)
                 return NULL;
@@ -909,30 +867,13 @@ err_exit:
 }
 
 /*
-
-  FIXME: 1,2 are fixed 3 was never true anyway.
-
-   Let me to blame a bit.
-   1. TTY module calls this funstion on soft interrupt.
-   2. TTY module calls this function WITH MASKED INTERRUPTS!
-   3. TTY module does not notify us about line discipline
-      shutdown,
-
-   Seems, now it is clean. The solution is to consider netdevice and
-   line discipline sides as two independent threads.
-
-   By-product (not desired): sl? does not feel hangups and remains open.
-   It is supposed, that user level program (dip, diald, slattach...)
-   will catch SIGHUP and make the rest of work.
-
-   I see no way to make more with current tty code. --ANK
- */
-
-/*
  * Close down a SLIP channel.
  * This means flushing out any pending queues, and then returning. This
  * call is serialized against other ldisc functions.
+ *
+ * We also use this method fo a hangup event
  */
+
 static void slip_close(struct tty_struct *tty)
 {
         struct slip *sl = tty->disc_data;
@@ -951,10 +892,16 @@ static void slip_close(struct tty_struct *tty)
         del_timer_sync(&sl->keepalive_timer);
         del_timer_sync(&sl->outfill_timer);
 #endif
-
-        /* Count references from TTY module */
+        /* Flush network side */
+        unregister_netdev(sl->dev);
+        /* This will complete via sl_free_netdev */
 }
 
+static int slip_hangup(struct tty_struct *tty)
+{
+        slip_close(tty);
+        return 0;
+}
  /************************************************************************
   *                     STANDARD SLIP ENCAPSULATION                      *
   ************************************************************************/
@@ -1311,6 +1258,7 @@ static struct tty_ldisc_ops sl_ldisc = {
         .name           = "slip",
         .open           = slip_open,
         .close          = slip_close,
+        .hangup         = slip_hangup,
         .ioctl          = slip_ioctl,
         .receive_buf    = slip_receive_buf,
         .write_wakeup   = slip_write_wakeup,
@@ -1384,6 +1332,8 @@ static void __exit slip_exit(void)
                 }
         } while (busy && time_before(jiffies, timeout));
 
+        /* FIXME: hangup is async so we should wait when doing this second
+           phase */
 
         for (i = 0; i < slip_maxdev; i++) {
                 dev = slip_devs[i];
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 3f5d28851aa2..d3ee1994b02f 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -1370,7 +1370,7 @@ static const struct file_operations tun_fops = {
 static struct miscdevice tun_miscdev = {
         .minor = TUN_MINOR,
         .name = "tun",
-        .devnode = "net/tun",
+        .nodename = "net/tun",
         .fops = &tun_fops,
 };
 
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index f4317798e47c..2dc42bbf6fe9 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -82,6 +82,13 @@ config REGULATOR_TWL4030
           This driver supports the voltage regulators provided by
           this family of companion chips.
 
+config REGULATOR_WM831X
+        tristate "Wolfson Microelcronics WM831x PMIC regulators"
+        depends on MFD_WM831X
+        help
+          Support the voltage and current regulators of the WM831x series
+          of PMIC devices.
+
 config REGULATOR_WM8350
         tristate "Wolfson Microelectroncis WM8350 AudioPlus PMIC"
         depends on MFD_WM8350
@@ -117,4 +124,28 @@ config REGULATOR_LP3971
          Say Y here to support the voltage regulators and convertors
          on National Semiconductors LP3971 PMIC
 
+config REGULATOR_PCAP
+        tristate "PCAP2 regulator driver"
+        depends on EZX_PCAP
+        help
+         This driver provides support for the voltage regulators of the
+         PCAP2 PMIC.
+
+config REGULATOR_MC13783
+        tristate "Support regulators on Freescale MC13783 PMIC"
+        depends on MFD_MC13783
+        help
+          Say y here to support the regulators found on the Freescale MC13783
+          PMIC.
+
+config REGULATOR_AB3100
+        tristate "ST-Ericsson AB3100 Regulator functions"
+        depends on AB3100_CORE
+        default y if AB3100_CORE
+        help
+         These regulators correspond to functionality in the
+         AB3100 analog baseband dealing with power regulators
+         for the system.
+
 endif
+
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 4d762c4cccfd..768b3316d6eb 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -12,9 +12,15 @@ obj-$(CONFIG_REGULATOR_BQ24022) += bq24022.o
 obj-$(CONFIG_REGULATOR_LP3971) += lp3971.o
 obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o
 obj-$(CONFIG_REGULATOR_TWL4030) += twl4030-regulator.o
+obj-$(CONFIG_REGULATOR_WM831X) += wm831x-dcdc.o
+obj-$(CONFIG_REGULATOR_WM831X) += wm831x-isink.o
+obj-$(CONFIG_REGULATOR_WM831X) += wm831x-ldo.o
 obj-$(CONFIG_REGULATOR_WM8350) += wm8350-regulator.o
 obj-$(CONFIG_REGULATOR_WM8400) += wm8400-regulator.o
 obj-$(CONFIG_REGULATOR_DA903X)  += da903x.o
 obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
+obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o
+obj-$(CONFIG_REGULATOR_MC13783) += mc13783.o
+obj-$(CONFIG_REGULATOR_AB3100) += ab3100.o
 
 ccflags-$(CONFIG_REGULATOR_DEBUG) += -DDEBUG
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
new file mode 100644
index 000000000000..49aeee823a25
--- /dev/null
+++ b/drivers/regulator/ab3100.c
@@ -0,0 +1,700 @@
+/*
+ * drivers/regulator/ab3100.c
+ *
+ * Copyright (C) 2008-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * Low-level control of the AB3100 IC Low Dropout (LDO)
+ * regulators, external regulator and buck converter
+ * Author: Mattias Wallin <mattias.wallin@stericsson.com>
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/mfd/ab3100.h>
+
+/* LDO registers and some handy masking definitions for AB3100 */
+#define AB3100_LDO_A            0x40
+#define AB3100_LDO_C            0x41
+#define AB3100_LDO_D            0x42
+#define AB3100_LDO_E            0x43
+#define AB3100_LDO_E_SLEEP      0x44
+#define AB3100_LDO_F            0x45
+#define AB3100_LDO_G            0x46
+#define AB3100_LDO_H            0x47
+#define AB3100_LDO_H_SLEEP_MODE 0
+#define AB3100_LDO_H_SLEEP_EN   2
+#define AB3100_LDO_ON           4
+#define AB3100_LDO_H_VSEL_AC    5
+#define AB3100_LDO_K            0x48
+#define AB3100_LDO_EXT          0x49
+#define AB3100_BUCK             0x4A
+#define AB3100_BUCK_SLEEP       0x4B
+#define AB3100_REG_ON_MASK      0x10
+
+/**
+ * struct ab3100_regulator
+ * A struct passed around the individual regulator functions
+ * @platform_device: platform device holding this regulator
+ * @ab3100: handle to the AB3100 parent chip
+ * @plfdata: AB3100 platform data passed in at probe time
+ * @regreg: regulator register number in the AB3100
+ * @fixed_voltage: a fixed voltage for this regulator, if this
+ *          0 the voltages array is used instead.
+ * @typ_voltages: an array of available typical voltages for
+ *          this regulator
+ * @voltages_len: length of the array of available voltages
+ */
+struct ab3100_regulator {
+        struct regulator_dev *rdev;
+        struct ab3100 *ab3100;
+        struct ab3100_platform_data *plfdata;
+        u8 regreg;
+        int fixed_voltage;
+        int const *typ_voltages;
+        u8 voltages_len;
+};
+
+/* The order in which registers are initialized */
+static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
+        AB3100_LDO_A,
+        AB3100_LDO_C,
+        AB3100_LDO_E,
+        AB3100_LDO_E_SLEEP,
+        AB3100_LDO_F,
+        AB3100_LDO_G,
+        AB3100_LDO_H,
+        AB3100_LDO_K,
+        AB3100_LDO_EXT,
+        AB3100_BUCK,
+        AB3100_BUCK_SLEEP,
+        AB3100_LDO_D,
+};
+
+/* Preset (hardware defined) voltages for these regulators */
+#define LDO_A_VOLTAGE 2750000
+#define LDO_C_VOLTAGE 2650000
+#define LDO_D_VOLTAGE 2650000
+
+static const int const ldo_e_buck_typ_voltages[] = {
+        1800000,
+        1400000,
+        1300000,
+        1200000,
+        1100000,
+        1050000,
+        900000,
+};
+
+static const int const ldo_f_typ_voltages[] = {
+        1800000,
+        1400000,
+        1300000,
+        1200000,
+        1100000,
+        1050000,
+        2500000,
+        2650000,
+};
+
+static const int const ldo_g_typ_voltages[] = {
+        2850000,
+        2750000,
+        1800000,
+        1500000,
+};
+
+static const int const ldo_h_typ_voltages[] = {
+        2750000,
+        1800000,
+        1500000,
+        1200000,
+};
+
+static const int const ldo_k_typ_voltages[] = {
+        2750000,
+        1800000,
+};
+
+
+/* The regulator devices */
+static struct ab3100_regulator
+ab3100_regulators[AB3100_NUM_REGULATORS] = {
+        {
+                .regreg = AB3100_LDO_A,
+                .fixed_voltage = LDO_A_VOLTAGE,
+        },
+        {
+                .regreg = AB3100_LDO_C,
+                .fixed_voltage = LDO_C_VOLTAGE,
+        },
+        {
+                .regreg = AB3100_LDO_D,
+                .fixed_voltage = LDO_D_VOLTAGE,
+        },
+        {
+                .regreg = AB3100_LDO_E,
+                .typ_voltages = ldo_e_buck_typ_voltages,
+                .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
+        },
+        {
+                .regreg = AB3100_LDO_F,
+                .typ_voltages = ldo_f_typ_voltages,
+                .voltages_len = ARRAY_SIZE(ldo_f_typ_voltages),
+        },
+        {
+                .regreg = AB3100_LDO_G,
+                .typ_voltages = ldo_g_typ_voltages,
+                .voltages_len = ARRAY_SIZE(ldo_g_typ_voltages),
+        },
+        {
+                .regreg = AB3100_LDO_H,
+                .typ_voltages = ldo_h_typ_voltages,
+                .voltages_len = ARRAY_SIZE(ldo_h_typ_voltages),
+        },
+        {
+                .regreg = AB3100_LDO_K,
+                .typ_voltages = ldo_k_typ_voltages,
+                .voltages_len = ARRAY_SIZE(ldo_k_typ_voltages),
+        },
+        {
+                .regreg = AB3100_LDO_EXT,
+                /* No voltages for the external regulator */
+        },
+        {
+                .regreg = AB3100_BUCK,
+                .typ_voltages = ldo_e_buck_typ_voltages,
+                .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
+        },
+};
+
+/*
+ * General functions for enable, disable and is_enabled used for
+ * LDO: A,C,E,F,G,H,K,EXT and BUCK
+ */
+static int ab3100_enable_regulator(struct regulator_dev *reg)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        int err;
+        u8 regval;
+
+        err = ab3100_get_register_interruptible(abreg->ab3100, abreg->regreg,
+                                                &regval);
+        if (err) {
+                dev_warn(&reg->dev, "failed to get regid %d value\n",
+                         abreg->regreg);
+                return err;
+        }
+
+        /* The regulator is already on, no reason to go further */
+        if (regval & AB3100_REG_ON_MASK)
+                return 0;
+
+        regval |= AB3100_REG_ON_MASK;
+
+        err = ab3100_set_register_interruptible(abreg->ab3100, abreg->regreg,
+                                                regval);
+        if (err) {
+                dev_warn(&reg->dev, "failed to set regid %d value\n",
+                         abreg->regreg);
+                return err;
+        }
+
+        /* Per-regulator power on delay from spec */
+        switch (abreg->regreg) {
+        case AB3100_LDO_A: /* Fallthrough */
+        case AB3100_LDO_C: /* Fallthrough */
+        case AB3100_LDO_D: /* Fallthrough */
+        case AB3100_LDO_E: /* Fallthrough */
+        case AB3100_LDO_H: /* Fallthrough */
+        case AB3100_LDO_K:
+                udelay(200);
+                break;
+        case AB3100_LDO_F:
+                udelay(600);
+                break;
+        case AB3100_LDO_G:
+                udelay(400);
+                break;
+        case AB3100_BUCK:
+                mdelay(1);
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static int ab3100_disable_regulator(struct regulator_dev *reg)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        int err;
+        u8 regval;
+
+        /*
+         * LDO D is a special regulator. When it is disabled, the entire
+         * system is shut down. So this is handled specially.
+         */
+        if (abreg->regreg == AB3100_LDO_D) {
+                int i;
+
+                dev_info(&reg->dev, "disabling LDO D - shut down system\n");
+                /*
+                 * Set regulators to default values, ignore any errors,
+                 * we're going DOWN
+                 */
+                for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
+                        (void) ab3100_set_register_interruptible(abreg->ab3100,
+                                        ab3100_reg_init_order[i],
+                                        abreg->plfdata->reg_initvals[i]);
+                }
+
+                /* Setting LDO D to 0x00 cuts the power to the SoC */
+                return ab3100_set_register_interruptible(abreg->ab3100,
+                                                         AB3100_LDO_D, 0x00U);
+
+        }
+
+        /*
+         * All other regulators are handled here
+         */
+        err = ab3100_get_register_interruptible(abreg->ab3100, abreg->regreg,
+                                                &regval);
+        if (err) {
+                dev_err(&reg->dev, "unable to get register 0x%x\n",
+                        abreg->regreg);
+                return err;
+        }
+        regval &= ~AB3100_REG_ON_MASK;
+        return ab3100_set_register_interruptible(abreg->ab3100, abreg->regreg,
+                                                 regval);
+}
+
+static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        u8 regval;
+        int err;
+
+        err = ab3100_get_register_interruptible(abreg->ab3100, abreg->regreg,
+                                                &regval);
+        if (err) {
+                dev_err(&reg->dev, "unable to get register 0x%x\n",
+                        abreg->regreg);
+                return err;
+        }
+
+        return regval & AB3100_REG_ON_MASK;
+}
+
+static int ab3100_list_voltage_regulator(struct regulator_dev *reg,
+                                         unsigned selector)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+
+        if (selector > abreg->voltages_len)
+                return -EINVAL;
+        return abreg->typ_voltages[selector];
+}
+
+static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        u8 regval;
+        int err;
+
+        /* Return the voltage for fixed regulators immediately */
+        if (abreg->fixed_voltage)
+                return abreg->fixed_voltage;
+
+        /*
+         * For variable types, read out setting and index into
+         * supplied voltage list.
+         */
+        err = ab3100_get_register_interruptible(abreg->ab3100,
+                                                abreg->regreg, &regval);
+        if (err) {
+                dev_warn(&reg->dev,
+                         "failed to get regulator value in register %02x\n",
+                         abreg->regreg);
+                return err;
+        }
+
+        /* The 3 highest bits index voltages */
+        regval &= 0xE0;
+        regval >>= 5;
+
+        if (regval > abreg->voltages_len) {
+                dev_err(&reg->dev,
+                        "regulator register %02x contains an illegal voltage setting\n",
+                        abreg->regreg);
+                return -EINVAL;
+        }
+
+        return abreg->typ_voltages[regval];
+}
+
+static int ab3100_get_best_voltage_index(struct regulator_dev *reg,
+                                   int min_uV, int max_uV)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        int i;
+        int bestmatch;
+        int bestindex;
+
+        /*
+         * Locate the minimum voltage fitting the criteria on
+         * this regulator. The switchable voltages are not
+         * in strict falling order so we need to check them
+         * all for the best match.
+         */
+        bestmatch = INT_MAX;
+        bestindex = -1;
+        for (i = 0; i < abreg->voltages_len; i++) {
+                if (abreg->typ_voltages[i] <= max_uV &&
+                    abreg->typ_voltages[i] >= min_uV &&
+                    abreg->typ_voltages[i] < bestmatch) {
+                        bestmatch = abreg->typ_voltages[i];
+                        bestindex = i;
+                }
+        }
+
+        if (bestindex < 0) {
+                dev_warn(&reg->dev, "requested %d<=x<=%d uV, out of range!\n",
+                         min_uV, max_uV);
+                return -EINVAL;
+        }
+        return bestindex;
+}
+
+static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
+                                        int min_uV, int max_uV)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        u8 regval;
+        int err;
+        int bestindex;
+
+        bestindex = ab3100_get_best_voltage_index(reg, min_uV, max_uV);
+        if (bestindex < 0)
+                return bestindex;
+
+        err = ab3100_get_register_interruptible(abreg->ab3100,
+                                                abreg->regreg, &regval);
+        if (err) {
+                dev_warn(&reg->dev,
+                         "failed to get regulator register %02x\n",
+                         abreg->regreg);
+                return err;
+        }
+
+        /* The highest three bits control the variable regulators */
+        regval &= ~0xE0;
+        regval |= (bestindex << 5);
+
+        err = ab3100_set_register_interruptible(abreg->ab3100,
+                                                abreg->regreg, regval);
+        if (err)
+                dev_warn(&reg->dev, "failed to set regulator register %02x\n",
+                        abreg->regreg);
+
+        return err;
+}
+
+static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
+                                                int uV)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+        u8 regval;
+        int err;
+        int bestindex;
+        u8 targetreg;
+
+        if (abreg->regreg == AB3100_LDO_E)
+                targetreg = AB3100_LDO_E_SLEEP;
+        else if (abreg->regreg == AB3100_BUCK)
+                targetreg = AB3100_BUCK_SLEEP;
+        else
+                return -EINVAL;
+
+        /* LDO E and BUCK have special suspend voltages you can set */
+        bestindex = ab3100_get_best_voltage_index(reg, uV, uV);
+
+        err = ab3100_get_register_interruptible(abreg->ab3100,
+                                                targetreg, &regval);
+        if (err) {
+                dev_warn(&reg->dev,
+                         "failed to get regulator register %02x\n",
+                         targetreg);
+                return err;
+        }
+
+        /* The highest three bits control the variable regulators */
+        regval &= ~0xE0;
+        regval |= (bestindex << 5);
+
+        err = ab3100_set_register_interruptible(abreg->ab3100,
+                                                targetreg, regval);
+        if (err)
+                dev_warn(&reg->dev, "failed to set regulator register %02x\n",
+                        abreg->regreg);
+
+        return err;
+}
+
+/*
+ * The external regulator can just define a fixed voltage.
+ */
+static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
+{
+        struct ab3100_regulator *abreg = reg->reg_data;
+
+        return abreg->plfdata->external_voltage;
+}
+
+static struct regulator_ops regulator_ops_fixed = {
+        .enable      = ab3100_enable_regulator,
+        .disable     = ab3100_disable_regulator,
+        .is_enabled  = ab3100_is_enabled_regulator,
+        .get_voltage = ab3100_get_voltage_regulator,
+};
+
+static struct regulator_ops regulator_ops_variable = {
+        .enable      = ab3100_enable_regulator,
+        .disable     = ab3100_disable_regulator,
+        .is_enabled  = ab3100_is_enabled_regulator,
+        .get_voltage = ab3100_get_voltage_regulator,
+        .set_voltage = ab3100_set_voltage_regulator,
+        .list_voltage = ab3100_list_voltage_regulator,
+};
+
+static struct regulator_ops regulator_ops_variable_sleepable = {
+        .enable      = ab3100_enable_regulator,
+        .disable     = ab3100_disable_regulator,
+        .is_enabled  = ab3100_is_enabled_regulator,
+        .get_voltage = ab3100_get_voltage_regulator,
+        .set_voltage = ab3100_set_voltage_regulator,
+        .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
+        .list_voltage = ab3100_list_voltage_regulator,
+};
+
+/*
+ * LDO EXT is an external regulator so it is really
+ * not possible to set any voltage locally here, AB3100
+ * is an on/off switch plain an simple. The external
+ * voltage is defined in the board set-up if any.
+ */
+static struct regulator_ops regulator_ops_external = {
+        .enable      = ab3100_enable_regulator,
+        .disable     = ab3100_disable_regulator,
+        .is_enabled  = ab3100_is_enabled_regulator,
+        .get_voltage = ab3100_get_voltage_regulator_external,
+};
+
+static struct regulator_desc
+ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
+        {
+                .name = "LDO_A",
+                .id   = AB3100_LDO_A,
+                .ops  = &regulator_ops_fixed,
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_C",
+                .id   = AB3100_LDO_C,
+                .ops  = &regulator_ops_fixed,
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_D",
+                .id   = AB3100_LDO_D,
+                .ops  = &regulator_ops_fixed,
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_E",
+                .id   = AB3100_LDO_E,
+                .ops  = &regulator_ops_variable_sleepable,
+                .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_F",
+                .id   = AB3100_LDO_F,
+                .ops  = &regulator_ops_variable,
+                .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_G",
+                .id   = AB3100_LDO_G,
+                .ops  = &regulator_ops_variable,
+                .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_H",
+                .id   = AB3100_LDO_H,
+                .ops  = &regulator_ops_variable,
+                .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_K",
+                .id   = AB3100_LDO_K,
+                .ops  = &regulator_ops_variable,
+                .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "LDO_EXT",
+                .id   = AB3100_LDO_EXT,
+                .ops  = &regulator_ops_external,
+                .type = REGULATOR_VOLTAGE,
+        },
+        {
+                .name = "BUCK",
+                .id   = AB3100_BUCK,
+                .ops  = &regulator_ops_variable_sleepable,
+                .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
+                .type = REGULATOR_VOLTAGE,
+        },
+};
+
+/*
+ * NOTE: the following functions are regulators pluralis - it is the
+ * binding to the AB3100 core driver and the parent platform device
+ * for all the different regulators.
+ */
+
+static int __init ab3100_regulators_probe(struct platform_device *pdev)
+{
+        struct ab3100_platform_data *plfdata = pdev->dev.platform_data;
+        struct ab3100 *ab3100 = platform_get_drvdata(pdev);
+        int err = 0;
+        u8 data;
+        int i;
+
+        /* Check chip state */
+        err = ab3100_get_register_interruptible(ab3100,
+                                                AB3100_LDO_D, &data);
+        if (err) {
+                dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
+                return err;
+        }
+        if (data & 0x10)
+                dev_notice(&pdev->dev,
+                           "chip is already in active mode (Warm start)\n");
+        else
+                dev_notice(&pdev->dev,
+                           "chip is in inactive mode (Cold start)\n");
+
+        /* Set up regulators */
+        for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
+                err = ab3100_set_register_interruptible(ab3100,
+                                        ab3100_reg_init_order[i],
+                                        plfdata->reg_initvals[i]);
+                if (err) {
+                        dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
+                                err);
+                        return err;
+                }
+        }
+
+        if (err) {
+                dev_err(&pdev->dev,
+                        "LDO D regulator initialization failed with error %d\n",
+                        err);
+                return err;
+        }
+
+        /* Register the regulators */
+        for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
+                struct ab3100_regulator *reg = &ab3100_regulators[i];
+                struct regulator_dev *rdev;
+
+                /*
+                 * Initialize per-regulator struct.
+                 * Inherit platform data, this comes down from the
+                 * i2c boarddata, from the machine. So if you want to
+                 * see what it looks like for a certain machine, go
+                 * into the machine I2C setup.
+                 */
+                reg->ab3100 = ab3100;
+                reg->plfdata = plfdata;
+
+                /*
+                 * Register the regulator, pass around
+                 * the ab3100_regulator struct
+                 */
+                rdev = regulator_register(&ab3100_regulator_desc[i],
+                                          &pdev->dev,
+                                          &plfdata->reg_constraints[i],
+                                          reg);
+
+                if (IS_ERR(rdev)) {
+                        err = PTR_ERR(rdev);
+                        dev_err(&pdev->dev,
+                                "%s: failed to register regulator %s err %d\n",
+                                __func__, ab3100_regulator_desc[i].name,
+                                err);
+                        i--;
+                        /* remove the already registered regulators */
+                        while (i > 0) {
+                                regulator_unregister(ab3100_regulators[i].rdev);
+                                i--;
+                        }
+                        return err;
+                }
+
+                /* Then set a pointer back to the registered regulator */
+                reg->rdev = rdev;
+        }
+
+        return 0;
+}
+
+static int __exit ab3100_regulators_remove(struct platform_device *pdev)
+{
+        int i;
+
+        for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
+                struct ab3100_regulator *reg = &ab3100_regulators[i];
+
+                regulator_unregister(reg->rdev);
+        }
+        return 0;
+}
+
+static struct platform_driver ab3100_regulators_driver = {
+        .driver = {
+                .name  = "ab3100-regulators",
+                .owner = THIS_MODULE,
+        },
+        .probe = ab3100_regulators_probe,
+        .remove = __exit_p(ab3100_regulators_remove),
+};
+
+static __init int ab3100_regulators_init(void)
+{
+        return platform_driver_register(&ab3100_regulators_driver);
+}
+
+static __exit void ab3100_regulators_exit(void)
+{
+        platform_driver_register(&ab3100_regulators_driver);
+}
+
+subsys_initcall(ab3100_regulators_init);
+module_exit(ab3100_regulators_exit);
+
+MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
+MODULE_DESCRIPTION("AB3100 Regulator driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ab3100-regulators");
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index 98c3a74e9949..91ba9bfaa706 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -1864,6 +1864,30 @@ int regulator_notifier_call_chain(struct regulator_dev *rdev,
 }
 EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
 
+/**
+ * regulator_mode_to_status - convert a regulator mode into a status
+ *
+ * @mode: Mode to convert
+ *
+ * Convert a regulator mode into a status.
+ */
+int regulator_mode_to_status(unsigned int mode)
+{
+        switch (mode) {
+        case REGULATOR_MODE_FAST:
+                return REGULATOR_STATUS_FAST;
+        case REGULATOR_MODE_NORMAL:
+                return REGULATOR_STATUS_NORMAL;
+        case REGULATOR_MODE_IDLE:
+                return REGULATOR_STATUS_IDLE;
+        case REGULATOR_STATUS_STANDBY:
+                return REGULATOR_STATUS_STANDBY;
+        default:
+                return 0;
+        }
+}
+EXPORT_SYMBOL_GPL(regulator_mode_to_status);
+
 /*
  * To avoid cluttering sysfs (and memory) with useless state, only
  * create attributes that can be meaningfully displayed.
diff --git a/drivers/regulator/mc13783.c b/drivers/regulator/mc13783.c
new file mode 100644
index 000000000000..710211f67449
--- /dev/null
+++ b/drivers/regulator/mc13783.c
@@ -0,0 +1,410 @@
+/*
+ * Regulator Driver for Freescale MC13783 PMIC
+ *
+ * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
+ *
+ * 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/mfd/mc13783-private.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/driver.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/mc13783.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/err.h>
+
+struct mc13783_regulator {
+        struct regulator_desc desc;
+        int reg;
+        int enable_bit;
+};
+
+static struct regulator_ops mc13783_regulator_ops;
+
+static struct mc13783_regulator mc13783_regulators[] = {
+        [MC13783_SW_SW3] = {
+                .desc = {
+                        .name   = "SW_SW3",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_SW_SW3,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_SWITCHERS_5,
+                .enable_bit = MC13783_SWCTRL_SW3_EN,
+        },
+        [MC13783_SW_PLL] = {
+                .desc = {
+                        .name   = "SW_PLL",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_SW_PLL,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_SWITCHERS_4,
+                .enable_bit = MC13783_SWCTRL_PLL_EN,
+        },
+        [MC13783_REGU_VAUDIO] = {
+                .desc = {
+                        .name   = "REGU_VAUDIO",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VAUDIO,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VAUDIO_EN,
+        },
+        [MC13783_REGU_VIOHI] = {
+                .desc = {
+                        .name   = "REGU_VIOHI",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VIOHI,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VIOHI_EN,
+        },
+        [MC13783_REGU_VIOLO] = {
+                .desc = {
+                        .name   = "REGU_VIOLO",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VIOLO,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VIOLO_EN,
+        },
+        [MC13783_REGU_VDIG] = {
+                .desc = {
+                        .name   = "REGU_VDIG",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VDIG,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VDIG_EN,
+        },
+        [MC13783_REGU_VGEN] = {
+                .desc = {
+                        .name   = "REGU_VGEN",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VGEN,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VGEN_EN,
+        },
+        [MC13783_REGU_VRFDIG] = {
+                .desc = {
+                        .name   = "REGU_VRFDIG",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VRFDIG,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VRFDIG_EN,
+        },
+        [MC13783_REGU_VRFREF] = {
+                .desc = {
+                        .name   = "REGU_VRFREF",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VRFREF,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VRFREF_EN,
+        },
+        [MC13783_REGU_VRFCP] = {
+                .desc = {
+                        .name   = "REGU_VRFCP",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VRFCP,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_0,
+                .enable_bit = MC13783_REGCTRL_VRFCP_EN,
+        },
+        [MC13783_REGU_VSIM] = {
+                .desc = {
+                        .name   = "REGU_VSIM",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VSIM,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VSIM_EN,
+        },
+        [MC13783_REGU_VESIM] = {
+                .desc = {
+                        .name   = "REGU_VESIM",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VESIM,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VESIM_EN,
+        },
+        [MC13783_REGU_VCAM] = {
+                .desc = {
+                        .name   = "REGU_VCAM",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VCAM,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VCAM_EN,
+        },
+        [MC13783_REGU_VRFBG] = {
+                .desc = {
+                        .name   = "REGU_VRFBG",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VRFBG,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VRFBG_EN,
+        },
+        [MC13783_REGU_VVIB] = {
+                .desc = {
+                        .name   = "REGU_VVIB",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VVIB,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VVIB_EN,
+        },
+        [MC13783_REGU_VRF1] = {
+                .desc = {
+                        .name   = "REGU_VRF1",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VRF1,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VRF1_EN,
+        },
+        [MC13783_REGU_VRF2] = {
+                .desc = {
+                        .name   = "REGU_VRF2",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VRF2,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VRF2_EN,
+        },
+        [MC13783_REGU_VMMC1] = {
+                .desc = {
+                        .name   = "REGU_VMMC1",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VMMC1,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VMMC1_EN,
+        },
+        [MC13783_REGU_VMMC2] = {
+                .desc = {
+                        .name   = "REGU_VMMC2",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_VMMC2,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_REGULATOR_MODE_1,
+                .enable_bit = MC13783_REGCTRL_VMMC2_EN,
+        },
+        [MC13783_REGU_GPO1] = {
+                .desc = {
+                        .name   = "REGU_GPO1",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_GPO1,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_POWER_MISCELLANEOUS,
+                .enable_bit = MC13783_REGCTRL_GPO1_EN,
+        },
+        [MC13783_REGU_GPO2] = {
+                .desc = {
+                        .name   = "REGU_GPO2",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_GPO2,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_POWER_MISCELLANEOUS,
+                .enable_bit = MC13783_REGCTRL_GPO2_EN,
+        },
+        [MC13783_REGU_GPO3] = {
+                .desc = {
+                        .name   = "REGU_GPO3",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_GPO3,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_POWER_MISCELLANEOUS,
+                .enable_bit = MC13783_REGCTRL_GPO3_EN,
+        },
+        [MC13783_REGU_GPO4] = {
+                .desc = {
+                        .name   = "REGU_GPO4",
+                        .ops    = &mc13783_regulator_ops,
+                        .type   = REGULATOR_VOLTAGE,
+                        .id     = MC13783_REGU_GPO4,
+                        .owner  = THIS_MODULE,
+                },
+                .reg = MC13783_REG_POWER_MISCELLANEOUS,
+                .enable_bit = MC13783_REGCTRL_GPO4_EN,
+        },
+};
+
+struct mc13783_priv {
+        struct regulator_desc desc[ARRAY_SIZE(mc13783_regulators)];
+        struct mc13783 *mc13783;
+        struct regulator_dev *regulators[0];
+};
+
+static int mc13783_enable(struct regulator_dev *rdev)
+{
+        struct mc13783_priv *priv = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        return mc13783_set_bits(priv->mc13783, mc13783_regulators[id].reg,
+                        mc13783_regulators[id].enable_bit,
+                        mc13783_regulators[id].enable_bit);
+}
+
+static int mc13783_disable(struct regulator_dev *rdev)
+{
+        struct mc13783_priv *priv = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        return mc13783_set_bits(priv->mc13783, mc13783_regulators[id].reg,
+                        mc13783_regulators[id].enable_bit, 0);
+}
+
+static int mc13783_is_enabled(struct regulator_dev *rdev)
+{
+        struct mc13783_priv *priv = rdev_get_drvdata(rdev);
+        int ret, id = rdev_get_id(rdev);
+        unsigned int val;
+
+        ret = mc13783_reg_read(priv->mc13783, mc13783_regulators[id].reg, &val);
+        if (ret)
+                return ret;
+
+        return (val & mc13783_regulators[id].enable_bit) != 0;
+}
+
+static struct regulator_ops mc13783_regulator_ops = {
+        .enable         = mc13783_enable,
+        .disable        = mc13783_disable,
+        .is_enabled     = mc13783_is_enabled,
+};
+
+static int __devinit mc13783_regulator_probe(struct platform_device *pdev)
+{
+        struct mc13783_priv *priv;
+        struct mc13783 *mc13783 = dev_get_drvdata(pdev->dev.parent);
+        struct mc13783_regulator_init_data *init_data;
+        int i, ret;
+
+        dev_dbg(&pdev->dev, "mc13783_regulator_probe id %d\n", pdev->id);
+
+        priv = kzalloc(sizeof(*priv) + mc13783->num_regulators * sizeof(void *),
+                        GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->mc13783 = mc13783;
+
+        for (i = 0; i < mc13783->num_regulators; i++) {
+                init_data = &mc13783->regulators[i];
+                priv->regulators[i] = regulator_register(
+                                &mc13783_regulators[init_data->id].desc,
+                                &pdev->dev, init_data->init_data, priv);
+
+                if (IS_ERR(priv->regulators[i])) {
+                        dev_err(&pdev->dev, "failed to register regulator %s\n",
+                                mc13783_regulators[i].desc.name);
+                        ret = PTR_ERR(priv->regulators[i]);
+                        goto err;
+                }
+        }
+
+        platform_set_drvdata(pdev, priv);
+
+        return 0;
+err:
+        while (--i >= 0)
+                regulator_unregister(priv->regulators[i]);
+
+        kfree(priv);
+
+        return ret;
+}
+
+static int __devexit mc13783_regulator_remove(struct platform_device *pdev)
+{
+        struct mc13783_priv *priv = platform_get_drvdata(pdev);
+        struct mc13783 *mc13783 = priv->mc13783;
+        int i;
+
+        for (i = 0; i < mc13783->num_regulators; i++)
+                regulator_unregister(priv->regulators[i]);
+
+        return 0;
+}
+
+static struct platform_driver mc13783_regulator_driver = {
+        .driver = {
+                .name   = "mc13783-regulator",
+                .owner  = THIS_MODULE,
+        },
+        .remove         = __devexit_p(mc13783_regulator_remove),
+};
+
+static int __init mc13783_regulator_init(void)
+{
+        return platform_driver_probe(&mc13783_regulator_driver,
+                        mc13783_regulator_probe);
+}
+subsys_initcall(mc13783_regulator_init);
+
+static void __exit mc13783_regulator_exit(void)
+{
+        platform_driver_unregister(&mc13783_regulator_driver);
+}
+module_exit(mc13783_regulator_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de");
+MODULE_DESCRIPTION("Regulator Driver for Freescale MC13783 PMIC");
+MODULE_ALIAS("platform:mc13783-regulator");
diff --git a/drivers/regulator/pcap-regulator.c b/drivers/regulator/pcap-regulator.c
new file mode 100644
index 000000000000..33d7d899e030
--- /dev/null
+++ b/drivers/regulator/pcap-regulator.c
@@ -0,0 +1,318 @@
+/*
+ * PCAP2 Regulator Driver
+ *
+ * Copyright (c) 2009 Daniel Ribeiro <drwyrm@gmail.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/mfd/ezx-pcap.h>
+
+static const u16 V1_table[] = {
+        2775, 1275, 1600, 1725, 1825, 1925, 2075, 2275,
+};
+
+static const u16 V2_table[] = {
+        2500, 2775,
+};
+
+static const u16 V3_table[] = {
+        1075, 1275, 1550, 1725, 1876, 1950, 2075, 2275,
+};
+
+static const u16 V4_table[] = {
+        1275, 1550, 1725, 1875, 1950, 2075, 2275, 2775,
+};
+
+static const u16 V5_table[] = {
+        1875, 2275, 2475, 2775,
+};
+
+static const u16 V6_table[] = {
+        2475, 2775,
+};
+
+static const u16 V7_table[] = {
+        1875, 2775,
+};
+
+#define V8_table V4_table
+
+static const u16 V9_table[] = {
+        1575, 1875, 2475, 2775,
+};
+
+static const u16 V10_table[] = {
+        5000,
+};
+
+static const u16 VAUX1_table[] = {
+        1875, 2475, 2775, 3000,
+};
+
+#define VAUX2_table VAUX1_table
+
+static const u16 VAUX3_table[] = {
+        1200, 1200, 1200, 1200, 1400, 1600, 1800, 2000,
+        2200, 2400, 2600, 2800, 3000, 3200, 3400, 3600,
+};
+
+static const u16 VAUX4_table[] = {
+        1800, 1800, 3000, 5000,
+};
+
+static const u16 VSIM_table[] = {
+        1875, 3000,
+};
+
+static const u16 VSIM2_table[] = {
+        1875,
+};
+
+static const u16 VVIB_table[] = {
+        1300, 1800, 2000, 3000,
+};
+
+static const u16 SW1_table[] = {
+        900, 950, 1000, 1050, 1100, 1150, 1200, 1250,
+        1300, 1350, 1400, 1450, 1500, 1600, 1875, 2250,
+};
+
+#define SW2_table SW1_table
+
+static const u16 SW3_table[] = {
+        4000, 4500, 5000, 5500,
+};
+
+struct pcap_regulator {
+        const u8 reg;
+        const u8 en;
+        const u8 index;
+        const u8 stby;
+        const u8 lowpwr;
+        const u8 n_voltages;
+        const u16 *voltage_table;
+};
+
+#define NA 0xff
+
+#define VREG_INFO(_vreg, _reg, _en, _index, _stby, _lowpwr)             \
+        [_vreg] = {                                                     \
+                .reg            = _reg,                                 \
+                .en             = _en,                                  \
+                .index          = _index,                               \
+                .stby           = _stby,                                \
+                .lowpwr         = _lowpwr,                              \
+                .n_voltages     = ARRAY_SIZE(_vreg##_table),            \
+                .voltage_table  = _vreg##_table,                        \
+        }
+
+static struct pcap_regulator vreg_table[] = {
+        VREG_INFO(V1,    PCAP_REG_VREG1,   1,  2,  18, 0),
+        VREG_INFO(V2,    PCAP_REG_VREG1,   5,  6,  19, 22),
+        VREG_INFO(V3,    PCAP_REG_VREG1,   7,  8,  20, 23),
+        VREG_INFO(V4,    PCAP_REG_VREG1,   11, 12, 21, 24),
+        /* V5 STBY and LOWPWR are on PCAP_REG_VREG2 */
+        VREG_INFO(V5,    PCAP_REG_VREG1,   15, 16, 12, 19),
+
+        VREG_INFO(V6,    PCAP_REG_VREG2,   1,  2,  14, 20),
+        VREG_INFO(V7,    PCAP_REG_VREG2,   3,  4,  15, 21),
+        VREG_INFO(V8,    PCAP_REG_VREG2,   5,  6,  16, 22),
+        VREG_INFO(V9,    PCAP_REG_VREG2,   9,  10, 17, 23),
+        VREG_INFO(V10,   PCAP_REG_VREG2,   10, NA, 18, 24),
+
+        VREG_INFO(VAUX1, PCAP_REG_AUXVREG, 1,  2,  22, 23),
+        /* VAUX2 ... VSIM2 STBY and LOWPWR are on PCAP_REG_LOWPWR */
+        VREG_INFO(VAUX2, PCAP_REG_AUXVREG, 4,  5,  0,  1),
+        VREG_INFO(VAUX3, PCAP_REG_AUXVREG, 7,  8,  2,  3),
+        VREG_INFO(VAUX4, PCAP_REG_AUXVREG, 12, 13, 4,  5),
+        VREG_INFO(VSIM,  PCAP_REG_AUXVREG, 17, 18, NA, 6),
+        VREG_INFO(VSIM2, PCAP_REG_AUXVREG, 16, NA, NA, 7),
+        VREG_INFO(VVIB,  PCAP_REG_AUXVREG, 19, 20, NA, NA),
+
+        VREG_INFO(SW1,   PCAP_REG_SWCTRL,  1,  2,  NA, NA),
+        VREG_INFO(SW2,   PCAP_REG_SWCTRL,  6,  7,  NA, NA),
+        /* SW3 STBY is on PCAP_REG_AUXVREG */
+        VREG_INFO(SW3,   PCAP_REG_SWCTRL,  11, 12, 24, NA),
+
+        /* SWxS used to control SWx voltage on standby */
+/*      VREG_INFO(SW1S,  PCAP_REG_LOWPWR,  NA, 12, NA, NA),
+        VREG_INFO(SW2S,  PCAP_REG_LOWPWR,  NA, 20, NA, NA), */
+};
+
+static int pcap_regulator_set_voltage(struct regulator_dev *rdev,
+                                                int min_uV, int max_uV)
+{
+        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
+        void *pcap = rdev_get_drvdata(rdev);
+        int uV;
+        u8 i;
+
+        /* the regulator doesn't support voltage switching */
+        if (vreg->n_voltages == 1)
+                return -EINVAL;
+
+        for (i = 0; i < vreg->n_voltages; i++) {
+                /* For V1 the first is not the best match */
+                if (i == 0 && rdev_get_id(rdev) == V1)
+                        i = 1;
+                else if (i + 1 == vreg->n_voltages && rdev_get_id(rdev) == V1)
+                        i = 0;
+
+                uV = vreg->voltage_table[i] * 1000;
+                if (min_uV <= uV && uV <= max_uV)
+                        return ezx_pcap_set_bits(pcap, vreg->reg,
+                                        (vreg->n_voltages - 1) << vreg->index,
+                                        i << vreg->index);
+
+                if (i == 0 && rdev_get_id(rdev) == V1)
+                        i = vreg->n_voltages - 1;
+        }
+
+        /* the requested voltage range is not supported by this regulator */
+        return -EINVAL;
+}
+
+static int pcap_regulator_get_voltage(struct regulator_dev *rdev)
+{
+        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
+        void *pcap = rdev_get_drvdata(rdev);
+        u32 tmp;
+        int mV;
+
+        if (vreg->n_voltages == 1)
+                return vreg->voltage_table[0] * 1000;
+
+        ezx_pcap_read(pcap, vreg->reg, &tmp);
+        tmp = ((tmp >> vreg->index) & (vreg->n_voltages - 1));
+        mV = vreg->voltage_table[tmp];
+
+        return mV * 1000;
+}
+
+static int pcap_regulator_enable(struct regulator_dev *rdev)
+{
+        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
+        void *pcap = rdev_get_drvdata(rdev);
+
+        if (vreg->en == NA)
+                return -EINVAL;
+
+        return ezx_pcap_set_bits(pcap, vreg->reg, 1 << vreg->en, 1 << vreg->en);
+}
+
+static int pcap_regulator_disable(struct regulator_dev *rdev)
+{
+        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
+        void *pcap = rdev_get_drvdata(rdev);
+
+        if (vreg->en == NA)
+                return -EINVAL;
+
+        return ezx_pcap_set_bits(pcap, vreg->reg, 1 << vreg->en, 0);
+}
+
+static int pcap_regulator_is_enabled(struct regulator_dev *rdev)
+{
+        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
+        void *pcap = rdev_get_drvdata(rdev);
+        u32 tmp;
+
+        if (vreg->en == NA)
+                return -EINVAL;
+
+        ezx_pcap_read(pcap, vreg->reg, &tmp);
+        return (tmp >> vreg->en) & 1;
+}
+
+static int pcap_regulator_list_voltage(struct regulator_dev *rdev,
+                                                        unsigned int index)
+{
+        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
+
+        return vreg->voltage_table[index] * 1000;
+}
+
+static struct regulator_ops pcap_regulator_ops = {
+        .list_voltage   = pcap_regulator_list_voltage,
+        .set_voltage    = pcap_regulator_set_voltage,
+        .get_voltage    = pcap_regulator_get_voltage,
+        .enable         = pcap_regulator_enable,
+        .disable        = pcap_regulator_disable,
+        .is_enabled     = pcap_regulator_is_enabled,
+};
+
+#define VREG(_vreg)                                             \
+        [_vreg] = {                                             \
+                .name           = #_vreg,                       \
+                .id             = _vreg,                        \
+                .n_voltages     = ARRAY_SIZE(_vreg##_table),    \
+                .ops            = &pcap_regulator_ops,          \
+                .type           = REGULATOR_VOLTAGE,            \
+                .owner          = THIS_MODULE,                  \
+        }
+
+static struct regulator_desc pcap_regulators[] = {
+        VREG(V1), VREG(V2), VREG(V3), VREG(V4), VREG(V5), VREG(V6), VREG(V7),
+        VREG(V8), VREG(V9), VREG(V10), VREG(VAUX1), VREG(VAUX2), VREG(VAUX3),
+        VREG(VAUX4), VREG(VSIM), VREG(VSIM2), VREG(VVIB), VREG(SW1), VREG(SW2),
+};
+
+static int __devinit pcap_regulator_probe(struct platform_device *pdev)
+{
+        struct regulator_dev *rdev;
+        void *pcap = dev_get_drvdata(pdev->dev.parent);
+
+        rdev = regulator_register(&pcap_regulators[pdev->id], &pdev->dev,
+                                pdev->dev.platform_data, pcap);
+        if (IS_ERR(rdev))
+                return PTR_ERR(rdev);
+
+        platform_set_drvdata(pdev, rdev);
+
+        return 0;
+}
+
+static int __devexit pcap_regulator_remove(struct platform_device *pdev)
+{
+        struct regulator_dev *rdev = platform_get_drvdata(pdev);
+
+        regulator_unregister(rdev);
+
+        return 0;
+}
+
+static struct platform_driver pcap_regulator_driver = {
+        .driver = {
+                .name = "pcap-regulator",
+        },
+        .probe = pcap_regulator_probe,
+        .remove = __devexit_p(pcap_regulator_remove),
+};
+
+static int __init pcap_regulator_init(void)
+{
+        return platform_driver_register(&pcap_regulator_driver);
+}
+
+static void __exit pcap_regulator_exit(void)
+{
+        platform_driver_unregister(&pcap_regulator_driver);
+}
+
+subsys_initcall(pcap_regulator_init);
+module_exit(pcap_regulator_exit);
+
+MODULE_AUTHOR("Daniel Ribeiro <drwyrm@gmail.com>");
+MODULE_DESCRIPTION("PCAP2 Regulator Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
new file mode 100644
index 000000000000..2eefc1a0cf08
--- /dev/null
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -0,0 +1,862 @@
+/*
+ * wm831x-dcdc.c  --  DC-DC buck convertor driver for the WM831x series
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/regulator.h>
+#include <linux/mfd/wm831x/pdata.h>
+
+#define WM831X_BUCKV_MAX_SELECTOR 0x68
+#define WM831X_BUCKP_MAX_SELECTOR 0x66
+
+#define WM831X_DCDC_MODE_FAST    0
+#define WM831X_DCDC_MODE_NORMAL  1
+#define WM831X_DCDC_MODE_IDLE    2
+#define WM831X_DCDC_MODE_STANDBY 3
+
+#define WM831X_DCDC_MAX_NAME 6
+
+/* Register offsets in control block */
+#define WM831X_DCDC_CONTROL_1     0
+#define WM831X_DCDC_CONTROL_2     1
+#define WM831X_DCDC_ON_CONFIG     2
+#define WM831X_DCDC_SLEEP_CONTROL 3
+
+/*
+ * Shared
+ */
+
+struct wm831x_dcdc {
+        char name[WM831X_DCDC_MAX_NAME];
+        struct regulator_desc desc;
+        int base;
+        struct wm831x *wm831x;
+        struct regulator_dev *regulator;
+};
+
+static int wm831x_dcdc_is_enabled(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+        int reg;
+
+        reg = wm831x_reg_read(wm831x, WM831X_DCDC_ENABLE);
+        if (reg < 0)
+                return reg;
+
+        if (reg & mask)
+                return 1;
+        else
+                return 0;
+}
+
+static int wm831x_dcdc_enable(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+
+        return wm831x_set_bits(wm831x, WM831X_DCDC_ENABLE, mask, mask);
+}
+
+static int wm831x_dcdc_disable(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+
+        return wm831x_set_bits(wm831x, WM831X_DCDC_ENABLE, mask, 0);
+}
+
+static unsigned int wm831x_dcdc_get_mode(struct regulator_dev *rdev)
+
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
+        int val;
+
+        val = wm831x_reg_read(wm831x, reg);
+        if (val < 0)
+                return val;
+
+        val = (val & WM831X_DC1_ON_MODE_MASK) >> WM831X_DC1_ON_MODE_SHIFT;
+
+        switch (val) {
+        case WM831X_DCDC_MODE_FAST:
+                return REGULATOR_MODE_FAST;
+        case WM831X_DCDC_MODE_NORMAL:
+                return REGULATOR_MODE_NORMAL;
+        case WM831X_DCDC_MODE_STANDBY:
+                return REGULATOR_MODE_STANDBY;
+        case WM831X_DCDC_MODE_IDLE:
+                return REGULATOR_MODE_IDLE;
+        default:
+                BUG();
+        }
+}
+
+static int wm831x_dcdc_set_mode_int(struct wm831x *wm831x, int reg,
+                                    unsigned int mode)
+{
+        int val;
+
+        switch (mode) {
+        case REGULATOR_MODE_FAST:
+                val = WM831X_DCDC_MODE_FAST;
+                break;
+        case REGULATOR_MODE_NORMAL:
+                val = WM831X_DCDC_MODE_NORMAL;
+                break;
+        case REGULATOR_MODE_STANDBY:
+                val = WM831X_DCDC_MODE_STANDBY;
+                break;
+        case REGULATOR_MODE_IDLE:
+                val = WM831X_DCDC_MODE_IDLE;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return wm831x_set_bits(wm831x, reg, WM831X_DC1_ON_MODE_MASK,
+                               val << WM831X_DC1_ON_MODE_SHIFT);
+}
+
+static int wm831x_dcdc_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
+
+        return wm831x_dcdc_set_mode_int(wm831x, reg, mode);
+}
+
+static int wm831x_dcdc_set_suspend_mode(struct regulator_dev *rdev,
+                                        unsigned int mode)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
+
+        return wm831x_dcdc_set_mode_int(wm831x, reg, mode);
+}
+
+static int wm831x_dcdc_get_status(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        int ret;
+
+        /* First, check for errors */
+        ret = wm831x_reg_read(wm831x, WM831X_DCDC_UV_STATUS);
+        if (ret < 0)
+                return ret;
+
+        if (ret & (1 << rdev_get_id(rdev))) {
+                dev_dbg(wm831x->dev, "DCDC%d under voltage\n",
+                        rdev_get_id(rdev) + 1);
+                return REGULATOR_STATUS_ERROR;
+        }
+
+        /* DCDC1 and DCDC2 can additionally detect high voltage/current */
+        if (rdev_get_id(rdev) < 2) {
+                if (ret & (WM831X_DC1_OV_STS << rdev_get_id(rdev))) {
+                        dev_dbg(wm831x->dev, "DCDC%d over voltage\n",
+                                rdev_get_id(rdev) + 1);
+                        return REGULATOR_STATUS_ERROR;
+                }
+
+                if (ret & (WM831X_DC1_HC_STS << rdev_get_id(rdev))) {
+                        dev_dbg(wm831x->dev, "DCDC%d over current\n",
+                                rdev_get_id(rdev) + 1);
+                        return REGULATOR_STATUS_ERROR;
+                }
+        }
+
+        /* Is the regulator on? */
+        ret = wm831x_reg_read(wm831x, WM831X_DCDC_STATUS);
+        if (ret < 0)
+                return ret;
+        if (!(ret & (1 << rdev_get_id(rdev))))
+                return REGULATOR_STATUS_OFF;
+
+        /* TODO: When we handle hardware control modes so we can report the
+         * current mode. */
+        return REGULATOR_STATUS_ON;
+}
+
+static irqreturn_t wm831x_dcdc_uv_irq(int irq, void *data)
+{
+        struct wm831x_dcdc *dcdc = data;
+
+        regulator_notifier_call_chain(dcdc->regulator,
+                                      REGULATOR_EVENT_UNDER_VOLTAGE,
+                                      NULL);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t wm831x_dcdc_oc_irq(int irq, void *data)
+{
+        struct wm831x_dcdc *dcdc = data;
+
+        regulator_notifier_call_chain(dcdc->regulator,
+                                      REGULATOR_EVENT_OVER_CURRENT,
+                                      NULL);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * BUCKV specifics
+ */
+
+static int wm831x_buckv_list_voltage(struct regulator_dev *rdev,
+                                      unsigned selector)
+{
+        if (selector <= 0x8)
+                return 600000;
+        if (selector <= WM831X_BUCKV_MAX_SELECTOR)
+                return 600000 + ((selector - 0x8) * 12500);
+        return -EINVAL;
+}
+
+static int wm831x_buckv_set_voltage_int(struct regulator_dev *rdev, int reg,
+                                         int min_uV, int max_uV)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 vsel;
+
+        if (min_uV < 600000)
+                vsel = 0;
+        else if (min_uV <= 1800000)
+                vsel = ((min_uV - 600000) / 12500) + 8;
+        else
+                return -EINVAL;
+
+        if (wm831x_buckv_list_voltage(rdev, vsel) > max_uV)
+                return -EINVAL;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_DC1_ON_VSEL_MASK, vsel);
+}
+
+static int wm831x_buckv_set_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
+
+        return wm831x_buckv_set_voltage_int(rdev, reg, min_uV, max_uV);
+}
+
+static int wm831x_buckv_set_suspend_voltage(struct regulator_dev *rdev,
+                                             int uV)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
+
+        return wm831x_buckv_set_voltage_int(rdev, reg, uV, uV);
+}
+
+static int wm831x_buckv_get_voltage(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
+        int val;
+
+        val = wm831x_reg_read(wm831x, reg);
+        if (val < 0)
+                return val;
+
+        return wm831x_buckv_list_voltage(rdev, val & WM831X_DC1_ON_VSEL_MASK);
+}
+
+/* Current limit options */
+static u16 wm831x_dcdc_ilim[] = {
+        125, 250, 375, 500, 625, 750, 875, 1000
+};
+
+static int wm831x_buckv_set_current_limit(struct regulator_dev *rdev,
+                                           int min_uA, int max_uA)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_CONTROL_2;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(wm831x_dcdc_ilim); i++) {
+                if (max_uA <= wm831x_dcdc_ilim[i])
+                        break;
+        }
+        if (i == ARRAY_SIZE(wm831x_dcdc_ilim))
+                return -EINVAL;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_DC1_HC_THR_MASK, i);
+}
+
+static int wm831x_buckv_get_current_limit(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_CONTROL_2;
+        int val;
+
+        val = wm831x_reg_read(wm831x, reg);
+        if (val < 0)
+                return val;
+
+        return wm831x_dcdc_ilim[val & WM831X_DC1_HC_THR_MASK];
+}
+
+static struct regulator_ops wm831x_buckv_ops = {
+        .set_voltage = wm831x_buckv_set_voltage,
+        .get_voltage = wm831x_buckv_get_voltage,
+        .list_voltage = wm831x_buckv_list_voltage,
+        .set_suspend_voltage = wm831x_buckv_set_suspend_voltage,
+        .set_current_limit = wm831x_buckv_set_current_limit,
+        .get_current_limit = wm831x_buckv_get_current_limit,
+
+        .is_enabled = wm831x_dcdc_is_enabled,
+        .enable = wm831x_dcdc_enable,
+        .disable = wm831x_dcdc_disable,
+        .get_status = wm831x_dcdc_get_status,
+        .get_mode = wm831x_dcdc_get_mode,
+        .set_mode = wm831x_dcdc_set_mode,
+        .set_suspend_mode = wm831x_dcdc_set_suspend_mode,
+};
+
+static __devinit int wm831x_buckv_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
+        struct wm831x_dcdc *dcdc;
+        struct resource *res;
+        int ret, irq;
+
+        dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
+
+        if (pdata == NULL || pdata->dcdc[id] == NULL)
+                return -ENODEV;
+
+        dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL);
+        if (dcdc == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        dcdc->wm831x = wm831x;
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        dcdc->base = res->start;
+
+        snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
+        dcdc->desc.name = dcdc->name;
+        dcdc->desc.id = id;
+        dcdc->desc.type = REGULATOR_VOLTAGE;
+        dcdc->desc.n_voltages = WM831X_BUCKV_MAX_SELECTOR + 1;
+        dcdc->desc.ops = &wm831x_buckv_ops;
+        dcdc->desc.owner = THIS_MODULE;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
+                                             pdata->dcdc[id], dcdc);
+        if (IS_ERR(dcdc->regulator)) {
+                ret = PTR_ERR(dcdc->regulator);
+                dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        irq = platform_get_irq_byname(pdev, "UV");
+        ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_uv_irq,
+                                 IRQF_TRIGGER_RISING, dcdc->name,
+                                 dcdc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
+                        irq, ret);
+                goto err_regulator;
+        }
+
+        irq = platform_get_irq_byname(pdev, "HC");
+        ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_oc_irq,
+                                 IRQF_TRIGGER_RISING, dcdc->name,
+                                 dcdc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request HC IRQ %d: %d\n",
+                        irq, ret);
+                goto err_uv;
+        }
+
+        platform_set_drvdata(pdev, dcdc);
+
+        return 0;
+
+err_uv:
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), dcdc);
+err_regulator:
+        regulator_unregister(dcdc->regulator);
+err:
+        kfree(dcdc);
+        return ret;
+}
+
+static __devexit int wm831x_buckv_remove(struct platform_device *pdev)
+{
+        struct wm831x_dcdc *dcdc = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "HC"), dcdc);
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), dcdc);
+        regulator_unregister(dcdc->regulator);
+        kfree(dcdc);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_buckv_driver = {
+        .probe = wm831x_buckv_probe,
+        .remove = __devexit_p(wm831x_buckv_remove),
+        .driver         = {
+                .name   = "wm831x-buckv",
+        },
+};
+
+/*
+ * BUCKP specifics
+ */
+
+static int wm831x_buckp_list_voltage(struct regulator_dev *rdev,
+                                      unsigned selector)
+{
+        if (selector <= WM831X_BUCKP_MAX_SELECTOR)
+                return 850000 + (selector * 25000);
+        else
+                return -EINVAL;
+}
+
+static int wm831x_buckp_set_voltage_int(struct regulator_dev *rdev, int reg,
+                                        int min_uV, int max_uV)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 vsel;
+
+        if (min_uV <= 34000000)
+                vsel = (min_uV - 850000) / 25000;
+        else
+                return -EINVAL;
+
+        if (wm831x_buckp_list_voltage(rdev, vsel) > max_uV)
+                return -EINVAL;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, vsel);
+}
+
+static int wm831x_buckp_set_voltage(struct regulator_dev *rdev,
+                                    int min_uV, int max_uV)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
+
+        return wm831x_buckp_set_voltage_int(rdev, reg, min_uV, max_uV);
+}
+
+static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev,
+                                            int uV)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
+
+        return wm831x_buckp_set_voltage_int(rdev, reg, uV, uV);
+}
+
+static int wm831x_buckp_get_voltage(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
+        int val;
+
+        val = wm831x_reg_read(wm831x, reg);
+        if (val < 0)
+                return val;
+
+        return wm831x_buckp_list_voltage(rdev, val & WM831X_DC3_ON_VSEL_MASK);
+}
+
+static struct regulator_ops wm831x_buckp_ops = {
+        .set_voltage = wm831x_buckp_set_voltage,
+        .get_voltage = wm831x_buckp_get_voltage,
+        .list_voltage = wm831x_buckp_list_voltage,
+        .set_suspend_voltage = wm831x_buckp_set_suspend_voltage,
+
+        .is_enabled = wm831x_dcdc_is_enabled,
+        .enable = wm831x_dcdc_enable,
+        .disable = wm831x_dcdc_disable,
+        .get_status = wm831x_dcdc_get_status,
+        .get_mode = wm831x_dcdc_get_mode,
+        .set_mode = wm831x_dcdc_set_mode,
+        .set_suspend_mode = wm831x_dcdc_set_suspend_mode,
+};
+
+static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
+        struct wm831x_dcdc *dcdc;
+        struct resource *res;
+        int ret, irq;
+
+        dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
+
+        if (pdata == NULL || pdata->dcdc[id] == NULL)
+                return -ENODEV;
+
+        dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL);
+        if (dcdc == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        dcdc->wm831x = wm831x;
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        dcdc->base = res->start;
+
+        snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
+        dcdc->desc.name = dcdc->name;
+        dcdc->desc.id = id;
+        dcdc->desc.type = REGULATOR_VOLTAGE;
+        dcdc->desc.n_voltages = WM831X_BUCKP_MAX_SELECTOR + 1;
+        dcdc->desc.ops = &wm831x_buckp_ops;
+        dcdc->desc.owner = THIS_MODULE;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
+                                             pdata->dcdc[id], dcdc);
+        if (IS_ERR(dcdc->regulator)) {
+                ret = PTR_ERR(dcdc->regulator);
+                dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        irq = platform_get_irq_byname(pdev, "UV");
+        ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_uv_irq,
+                                 IRQF_TRIGGER_RISING, dcdc->name,
+                                 dcdc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
+                        irq, ret);
+                goto err_regulator;
+        }
+
+        platform_set_drvdata(pdev, dcdc);
+
+        return 0;
+
+err_regulator:
+        regulator_unregister(dcdc->regulator);
+err:
+        kfree(dcdc);
+        return ret;
+}
+
+static __devexit int wm831x_buckp_remove(struct platform_device *pdev)
+{
+        struct wm831x_dcdc *dcdc = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), dcdc);
+        regulator_unregister(dcdc->regulator);
+        kfree(dcdc);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_buckp_driver = {
+        .probe = wm831x_buckp_probe,
+        .remove = __devexit_p(wm831x_buckp_remove),
+        .driver         = {
+                .name   = "wm831x-buckp",
+        },
+};
+
+/*
+ * DCDC boost convertors
+ */
+
+static int wm831x_boostp_get_status(struct regulator_dev *rdev)
+{
+        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+        int ret;
+
+        /* First, check for errors */
+        ret = wm831x_reg_read(wm831x, WM831X_DCDC_UV_STATUS);
+        if (ret < 0)
+                return ret;
+
+        if (ret & (1 << rdev_get_id(rdev))) {
+                dev_dbg(wm831x->dev, "DCDC%d under voltage\n",
+                        rdev_get_id(rdev) + 1);
+                return REGULATOR_STATUS_ERROR;
+        }
+
+        /* Is the regulator on? */
+        ret = wm831x_reg_read(wm831x, WM831X_DCDC_STATUS);
+        if (ret < 0)
+                return ret;
+        if (ret & (1 << rdev_get_id(rdev)))
+                return REGULATOR_STATUS_ON;
+        else
+                return REGULATOR_STATUS_OFF;
+}
+
+static struct regulator_ops wm831x_boostp_ops = {
+        .get_status = wm831x_boostp_get_status,
+
+        .is_enabled = wm831x_dcdc_is_enabled,
+        .enable = wm831x_dcdc_enable,
+        .disable = wm831x_dcdc_disable,
+};
+
+static __devinit int wm831x_boostp_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->dcdc);
+        struct wm831x_dcdc *dcdc;
+        struct resource *res;
+        int ret, irq;
+
+        dev_dbg(&pdev->dev, "Probing DCDC%d\n", id + 1);
+
+        if (pdata == NULL || pdata->dcdc[id] == NULL)
+                return -ENODEV;
+
+        dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL);
+        if (dcdc == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        dcdc->wm831x = wm831x;
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        dcdc->base = res->start;
+
+        snprintf(dcdc->name, sizeof(dcdc->name), "DCDC%d", id + 1);
+        dcdc->desc.name = dcdc->name;
+        dcdc->desc.id = id;
+        dcdc->desc.type = REGULATOR_VOLTAGE;
+        dcdc->desc.ops = &wm831x_boostp_ops;
+        dcdc->desc.owner = THIS_MODULE;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
+                                             pdata->dcdc[id], dcdc);
+        if (IS_ERR(dcdc->regulator)) {
+                ret = PTR_ERR(dcdc->regulator);
+                dev_err(wm831x->dev, "Failed to register DCDC%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        irq = platform_get_irq_byname(pdev, "UV");
+        ret = wm831x_request_irq(wm831x, irq, wm831x_dcdc_uv_irq,
+                                 IRQF_TRIGGER_RISING, dcdc->name,
+                                 dcdc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
+                        irq, ret);
+                goto err_regulator;
+        }
+
+        platform_set_drvdata(pdev, dcdc);
+
+        return 0;
+
+err_regulator:
+        regulator_unregister(dcdc->regulator);
+err:
+        kfree(dcdc);
+        return ret;
+}
+
+static __devexit int wm831x_boostp_remove(struct platform_device *pdev)
+{
+        struct wm831x_dcdc *dcdc = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = dcdc->wm831x;
+
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), dcdc);
+        regulator_unregister(dcdc->regulator);
+        kfree(dcdc);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_boostp_driver = {
+        .probe = wm831x_boostp_probe,
+        .remove = __devexit_p(wm831x_boostp_remove),
+        .driver         = {
+                .name   = "wm831x-boostp",
+        },
+};
+
+/*
+ * External Power Enable
+ *
+ * These aren't actually DCDCs but look like them in hardware so share
+ * code.
+ */
+
+#define WM831X_EPE_BASE 6
+
+static struct regulator_ops wm831x_epe_ops = {
+        .is_enabled = wm831x_dcdc_is_enabled,
+        .enable = wm831x_dcdc_enable,
+        .disable = wm831x_dcdc_disable,
+        .get_status = wm831x_dcdc_get_status,
+};
+
+static __devinit int wm831x_epe_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->epe);
+        struct wm831x_dcdc *dcdc;
+        int ret;
+
+        dev_dbg(&pdev->dev, "Probing EPE%d\n", id + 1);
+
+        if (pdata == NULL || pdata->epe[id] == NULL)
+                return -ENODEV;
+
+        dcdc = kzalloc(sizeof(struct wm831x_dcdc), GFP_KERNEL);
+        if (dcdc == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        dcdc->wm831x = wm831x;
+
+        /* For current parts this is correct; probably need to revisit
+         * in future.
+         */
+        snprintf(dcdc->name, sizeof(dcdc->name), "EPE%d", id + 1);
+        dcdc->desc.name = dcdc->name;
+        dcdc->desc.id = id + WM831X_EPE_BASE; /* Offset in DCDC registers */
+        dcdc->desc.ops = &wm831x_epe_ops;
+        dcdc->desc.type = REGULATOR_VOLTAGE;
+        dcdc->desc.owner = THIS_MODULE;
+
+        dcdc->regulator = regulator_register(&dcdc->desc, &pdev->dev,
+                                             pdata->epe[id], dcdc);
+        if (IS_ERR(dcdc->regulator)) {
+                ret = PTR_ERR(dcdc->regulator);
+                dev_err(wm831x->dev, "Failed to register EPE%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, dcdc);
+
+        return 0;
+
+err:
+        kfree(dcdc);
+        return ret;
+}
+
+static __devexit int wm831x_epe_remove(struct platform_device *pdev)
+{
+        struct wm831x_dcdc *dcdc = platform_get_drvdata(pdev);
+
+        regulator_unregister(dcdc->regulator);
+        kfree(dcdc);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_epe_driver = {
+        .probe = wm831x_epe_probe,
+        .remove = __devexit_p(wm831x_epe_remove),
+        .driver         = {
+                .name   = "wm831x-epe",
+        },
+};
+
+static int __init wm831x_dcdc_init(void)
+{
+        int ret;
+        ret = platform_driver_register(&wm831x_buckv_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x BUCKV driver: %d\n", ret);
+
+        ret = platform_driver_register(&wm831x_buckp_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x BUCKP driver: %d\n", ret);
+
+        ret = platform_driver_register(&wm831x_boostp_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x BOOST driver: %d\n", ret);
+
+        ret = platform_driver_register(&wm831x_epe_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x EPE driver: %d\n", ret);
+
+        return 0;
+}
+subsys_initcall(wm831x_dcdc_init);
+
+static void __exit wm831x_dcdc_exit(void)
+{
+        platform_driver_unregister(&wm831x_epe_driver);
+        platform_driver_unregister(&wm831x_boostp_driver);
+        platform_driver_unregister(&wm831x_buckp_driver);
+        platform_driver_unregister(&wm831x_buckv_driver);
+}
+module_exit(wm831x_dcdc_exit);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown");
+MODULE_DESCRIPTION("WM831x DC-DC convertor driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-buckv");
+MODULE_ALIAS("platform:wm831x-buckp");
diff --git a/drivers/regulator/wm831x-isink.c b/drivers/regulator/wm831x-isink.c
new file mode 100644
index 000000000000..1d8d9879d3a1
--- /dev/null
+++ b/drivers/regulator/wm831x-isink.c
@@ -0,0 +1,260 @@
+/*
+ * wm831x-isink.c  --  Current sink driver for the WM831x series
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/regulator.h>
+#include <linux/mfd/wm831x/pdata.h>
+
+#define WM831X_ISINK_MAX_NAME 7
+
+struct wm831x_isink {
+        char name[WM831X_ISINK_MAX_NAME];
+        struct regulator_desc desc;
+        int reg;
+        struct wm831x *wm831x;
+        struct regulator_dev *regulator;
+};
+
+static int wm831x_isink_enable(struct regulator_dev *rdev)
+{
+        struct wm831x_isink *isink = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = isink->wm831x;
+        int ret;
+
+        /* We have a two stage enable: first start the ISINK... */
+        ret = wm831x_set_bits(wm831x, isink->reg, WM831X_CS1_ENA,
+                              WM831X_CS1_ENA);
+        if (ret != 0)
+                return ret;
+
+        /* ...then enable drive */
+        ret = wm831x_set_bits(wm831x, isink->reg, WM831X_CS1_DRIVE,
+                              WM831X_CS1_DRIVE);
+        if (ret != 0)
+                wm831x_set_bits(wm831x, isink->reg, WM831X_CS1_ENA, 0);
+
+        return ret;
+
+}
+
+static int wm831x_isink_disable(struct regulator_dev *rdev)
+{
+        struct wm831x_isink *isink = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = isink->wm831x;
+        int ret;
+
+        ret = wm831x_set_bits(wm831x, isink->reg, WM831X_CS1_DRIVE, 0);
+        if (ret < 0)
+                return ret;
+
+        ret = wm831x_set_bits(wm831x, isink->reg, WM831X_CS1_ENA, 0);
+        if (ret < 0)
+                return ret;
+
+        return ret;
+
+}
+
+static int wm831x_isink_is_enabled(struct regulator_dev *rdev)
+{
+        struct wm831x_isink *isink = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = isink->wm831x;
+        int ret;
+
+        ret = wm831x_reg_read(wm831x, isink->reg);
+        if (ret < 0)
+                return ret;
+
+        if ((ret & (WM831X_CS1_ENA | WM831X_CS1_DRIVE)) ==
+            (WM831X_CS1_ENA | WM831X_CS1_DRIVE))
+                return 1;
+        else
+                return 0;
+}
+
+static int wm831x_isink_set_current(struct regulator_dev *rdev,
+                                    int min_uA, int max_uA)
+{
+        struct wm831x_isink *isink = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = isink->wm831x;
+        int ret, i;
+
+        for (i = 0; i < ARRAY_SIZE(wm831x_isinkv_values); i++) {
+                int val = wm831x_isinkv_values[i];
+                if (min_uA >= val && val <= max_uA) {
+                        ret = wm831x_set_bits(wm831x, isink->reg,
+                                              WM831X_CS1_ISEL_MASK, i);
+                        return ret;
+                }
+        }
+
+        return -EINVAL;
+}
+
+static int wm831x_isink_get_current(struct regulator_dev *rdev)
+{
+        struct wm831x_isink *isink = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = isink->wm831x;
+        int ret;
+
+        ret = wm831x_reg_read(wm831x, isink->reg);
+        if (ret < 0)
+                return ret;
+
+        ret &= WM831X_CS1_ISEL_MASK;
+        if (ret > WM831X_ISINK_MAX_ISEL)
+                ret = WM831X_ISINK_MAX_ISEL;
+
+        return wm831x_isinkv_values[ret];
+}
+
+static struct regulator_ops wm831x_isink_ops = {
+        .is_enabled = wm831x_isink_is_enabled,
+        .enable = wm831x_isink_enable,
+        .disable = wm831x_isink_disable,
+        .set_current_limit = wm831x_isink_set_current,
+        .get_current_limit = wm831x_isink_get_current,
+};
+
+static irqreturn_t wm831x_isink_irq(int irq, void *data)
+{
+        struct wm831x_isink *isink = data;
+
+        regulator_notifier_call_chain(isink->regulator,
+                                      REGULATOR_EVENT_OVER_CURRENT,
+                                      NULL);
+
+        return IRQ_HANDLED;
+}
+
+
+static __devinit int wm831x_isink_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        struct wm831x_isink *isink;
+        int id = pdev->id % ARRAY_SIZE(pdata->isink);
+        struct resource *res;
+        int ret, irq;
+
+        dev_dbg(&pdev->dev, "Probing ISINK%d\n", id + 1);
+
+        if (pdata == NULL || pdata->isink[id] == NULL)
+                return -ENODEV;
+
+        isink = kzalloc(sizeof(struct wm831x_isink), GFP_KERNEL);
+        if (isink == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        isink->reg = res->start;
+
+        /* For current parts this is correct; probably need to revisit
+         * in future.
+         */
+        snprintf(isink->name, sizeof(isink->name), "ISINK%d", id + 1);
+        isink->desc.name = isink->name;
+        isink->desc.id = id;
+        isink->desc.ops = &wm831x_isink_ops;
+        isink->desc.type = REGULATOR_CURRENT;
+        isink->desc.owner = THIS_MODULE;
+
+        isink->regulator = regulator_register(&isink->desc, &pdev->dev,
+                                             pdata->isink[id], isink);
+        if (IS_ERR(isink->regulator)) {
+                ret = PTR_ERR(isink->regulator);
+                dev_err(wm831x->dev, "Failed to register ISINK%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        irq = platform_get_irq(pdev, 0);
+        ret = wm831x_request_irq(wm831x, irq, wm831x_isink_irq,
+                                 IRQF_TRIGGER_RISING, isink->name,
+                                 isink);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request ISINK IRQ %d: %d\n",
+                        irq, ret);
+                goto err_regulator;
+        }
+
+        platform_set_drvdata(pdev, isink);
+
+        return 0;
+
+err_regulator:
+        regulator_unregister(isink->regulator);
+err:
+        kfree(isink);
+        return ret;
+}
+
+static __devexit int wm831x_isink_remove(struct platform_device *pdev)
+{
+        struct wm831x_isink *isink = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = isink->wm831x;
+
+        wm831x_free_irq(wm831x, platform_get_irq(pdev, 0), isink);
+
+        regulator_unregister(isink->regulator);
+        kfree(isink);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_isink_driver = {
+        .probe = wm831x_isink_probe,
+        .remove = __devexit_p(wm831x_isink_remove),
+        .driver         = {
+                .name   = "wm831x-isink",
+        },
+};
+
+static int __init wm831x_isink_init(void)
+{
+        int ret;
+        ret = platform_driver_register(&wm831x_isink_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x ISINK driver: %d\n", ret);
+
+        return ret;
+}
+subsys_initcall(wm831x_isink_init);
+
+static void __exit wm831x_isink_exit(void)
+{
+        platform_driver_unregister(&wm831x_isink_driver);
+}
+module_exit(wm831x_isink_exit);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown");
+MODULE_DESCRIPTION("WM831x current sink driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-isink");
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
new file mode 100644
index 000000000000..bb61aede4801
--- /dev/null
+++ b/drivers/regulator/wm831x-ldo.c
@@ -0,0 +1,852 @@
+/*
+ * wm831x-ldo.c  --  LDO driver for the WM831x series
+ *
+ * Copyright 2009 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/regulator.h>
+#include <linux/mfd/wm831x/pdata.h>
+
+#define WM831X_LDO_MAX_NAME 6
+
+#define WM831X_LDO_CONTROL       0
+#define WM831X_LDO_ON_CONTROL    1
+#define WM831X_LDO_SLEEP_CONTROL 2
+
+#define WM831X_ALIVE_LDO_ON_CONTROL    0
+#define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
+
+struct wm831x_ldo {
+        char name[WM831X_LDO_MAX_NAME];
+        struct regulator_desc desc;
+        int base;
+        struct wm831x *wm831x;
+        struct regulator_dev *regulator;
+};
+
+/*
+ * Shared
+ */
+
+static int wm831x_ldo_is_enabled(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+        int reg;
+
+        reg = wm831x_reg_read(wm831x, WM831X_LDO_ENABLE);
+        if (reg < 0)
+                return reg;
+
+        if (reg & mask)
+                return 1;
+        else
+                return 0;
+}
+
+static int wm831x_ldo_enable(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+
+        return wm831x_set_bits(wm831x, WM831X_LDO_ENABLE, mask, mask);
+}
+
+static int wm831x_ldo_disable(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+
+        return wm831x_set_bits(wm831x, WM831X_LDO_ENABLE, mask, 0);
+}
+
+static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
+{
+        struct wm831x_ldo *ldo = data;
+
+        regulator_notifier_call_chain(ldo->regulator,
+                                      REGULATOR_EVENT_UNDER_VOLTAGE,
+                                      NULL);
+
+        return IRQ_HANDLED;
+}
+
+/*
+ * General purpose LDOs
+ */
+
+#define WM831X_GP_LDO_SELECTOR_LOW 0xe
+#define WM831X_GP_LDO_MAX_SELECTOR 0x1f
+
+static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
+                                      unsigned int selector)
+{
+        /* 0.9-1.6V in 50mV steps */
+        if (selector <= WM831X_GP_LDO_SELECTOR_LOW)
+                return 900000 + (selector * 50000);
+        /* 1.7-3.3V in 50mV steps */
+        if (selector <= WM831X_GP_LDO_MAX_SELECTOR)
+                return 1600000 + ((selector - WM831X_GP_LDO_SELECTOR_LOW)
+                                  * 100000);
+        return -EINVAL;
+}
+
+static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
+                                         int min_uV, int max_uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int vsel, ret;
+
+        if (min_uV < 900000)
+                vsel = 0;
+        else if (min_uV < 1700000)
+                vsel = ((min_uV - 900000) / 50000);
+        else
+                vsel = ((min_uV - 1700000) / 100000)
+                        + WM831X_GP_LDO_SELECTOR_LOW + 1;
+
+        ret = wm831x_gp_ldo_list_voltage(rdev, vsel);
+        if (ret < 0)
+                return ret;
+        if (ret < min_uV || ret > max_uV)
+                return -EINVAL;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, vsel);
+}
+
+static int wm831x_gp_ldo_set_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
+
+        return wm831x_gp_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
+}
+
+static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
+                                             int uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
+
+        return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV);
+}
+
+static int wm831x_gp_ldo_get_voltage(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        int ret;
+
+        ret = wm831x_reg_read(wm831x, reg);
+        if (ret < 0)
+                return ret;
+
+        ret &= WM831X_LDO1_ON_VSEL_MASK;
+
+        return wm831x_gp_ldo_list_voltage(rdev, ret);
+}
+
+static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
+        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        unsigned int ret;
+
+        ret = wm831x_reg_read(wm831x, on_reg);
+        if (ret < 0)
+                return 0;
+
+        if (!(ret & WM831X_LDO1_ON_MODE))
+                return REGULATOR_MODE_NORMAL;
+
+        ret = wm831x_reg_read(wm831x, ctrl_reg);
+        if (ret < 0)
+                return 0;
+
+        if (ret & WM831X_LDO1_LP_MODE)
+                return REGULATOR_MODE_STANDBY;
+        else
+                return REGULATOR_MODE_IDLE;
+}
+
+static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
+                                  unsigned int mode)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
+        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        int ret;
+
+
+        switch (mode) {
+        case REGULATOR_MODE_NORMAL:
+                ret = wm831x_set_bits(wm831x, on_reg,
+                                      WM831X_LDO1_ON_MODE, 0);
+                if (ret < 0)
+                        return ret;
+                break;
+
+        case REGULATOR_MODE_IDLE:
+                ret = wm831x_set_bits(wm831x, ctrl_reg,
+                                      WM831X_LDO1_LP_MODE,
+                                      WM831X_LDO1_LP_MODE);
+                if (ret < 0)
+                        return ret;
+
+                ret = wm831x_set_bits(wm831x, on_reg,
+                                      WM831X_LDO1_ON_MODE,
+                                      WM831X_LDO1_ON_MODE);
+                if (ret < 0)
+                        return ret;
+
+        case REGULATOR_MODE_STANDBY:
+                ret = wm831x_set_bits(wm831x, ctrl_reg,
+                                      WM831X_LDO1_LP_MODE, 0);
+                if (ret < 0)
+                        return ret;
+
+                ret = wm831x_set_bits(wm831x, on_reg,
+                                      WM831X_LDO1_ON_MODE,
+                                      WM831X_LDO1_ON_MODE);
+                if (ret < 0)
+                        return ret;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+        int ret;
+
+        /* Is the regulator on? */
+        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
+        if (ret < 0)
+                return ret;
+        if (!(ret & mask))
+                return REGULATOR_STATUS_OFF;
+
+        /* Is it reporting under voltage? */
+        ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
+        if (ret & mask)
+                return REGULATOR_STATUS_ERROR;
+
+        ret = wm831x_gp_ldo_get_mode(rdev);
+        if (ret < 0)
+                return ret;
+        else
+                return regulator_mode_to_status(ret);
+}
+
+static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
+                                                   int input_uV,
+                                                   int output_uV, int load_uA)
+{
+        if (load_uA < 20000)
+                return REGULATOR_MODE_STANDBY;
+        if (load_uA < 50000)
+                return REGULATOR_MODE_IDLE;
+        return REGULATOR_MODE_NORMAL;
+}
+
+
+static struct regulator_ops wm831x_gp_ldo_ops = {
+        .list_voltage = wm831x_gp_ldo_list_voltage,
+        .get_voltage = wm831x_gp_ldo_get_voltage,
+        .set_voltage = wm831x_gp_ldo_set_voltage,
+        .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
+        .get_mode = wm831x_gp_ldo_get_mode,
+        .set_mode = wm831x_gp_ldo_set_mode,
+        .get_status = wm831x_gp_ldo_get_status,
+        .get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
+
+        .is_enabled = wm831x_ldo_is_enabled,
+        .enable = wm831x_ldo_enable,
+        .disable = wm831x_ldo_disable,
+};
+
+static __devinit int wm831x_gp_ldo_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        struct wm831x_ldo *ldo;
+        struct resource *res;
+        int ret, irq;
+
+        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
+
+        if (pdata == NULL || pdata->ldo[id] == NULL)
+                return -ENODEV;
+
+        ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
+        if (ldo == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        ldo->wm831x = wm831x;
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        ldo->base = res->start;
+
+        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
+        ldo->desc.name = ldo->name;
+        ldo->desc.id = id;
+        ldo->desc.type = REGULATOR_VOLTAGE;
+        ldo->desc.n_voltages = WM831X_GP_LDO_MAX_SELECTOR + 1;
+        ldo->desc.ops = &wm831x_gp_ldo_ops;
+        ldo->desc.owner = THIS_MODULE;
+
+        ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
+                                             pdata->ldo[id], ldo);
+        if (IS_ERR(ldo->regulator)) {
+                ret = PTR_ERR(ldo->regulator);
+                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        irq = platform_get_irq_byname(pdev, "UV");
+        ret = wm831x_request_irq(wm831x, irq, wm831x_ldo_uv_irq,
+                                 IRQF_TRIGGER_RISING, ldo->name,
+                                 ldo);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
+                        irq, ret);
+                goto err_regulator;
+        }
+
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+
+err_regulator:
+        regulator_unregister(ldo->regulator);
+err:
+        kfree(ldo);
+        return ret;
+}
+
+static __devexit int wm831x_gp_ldo_remove(struct platform_device *pdev)
+{
+        struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = ldo->wm831x;
+
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), ldo);
+        regulator_unregister(ldo->regulator);
+        kfree(ldo);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_gp_ldo_driver = {
+        .probe = wm831x_gp_ldo_probe,
+        .remove = __devexit_p(wm831x_gp_ldo_remove),
+        .driver         = {
+                .name   = "wm831x-ldo",
+        },
+};
+
+/*
+ * Analogue LDOs
+ */
+
+
+#define WM831X_ALDO_SELECTOR_LOW 0xc
+#define WM831X_ALDO_MAX_SELECTOR 0x1f
+
+static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
+                                      unsigned int selector)
+{
+        /* 1-1.6V in 50mV steps */
+        if (selector <= WM831X_ALDO_SELECTOR_LOW)
+                return 1000000 + (selector * 50000);
+        /* 1.7-3.5V in 50mV steps */
+        if (selector <= WM831X_ALDO_MAX_SELECTOR)
+                return 1600000 + ((selector - WM831X_ALDO_SELECTOR_LOW)
+                                  * 100000);
+        return -EINVAL;
+}
+
+static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
+                                         int min_uV, int max_uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int vsel, ret;
+
+        if (min_uV < 1000000)
+                vsel = 0;
+        else if (min_uV < 1700000)
+                vsel = ((min_uV - 1000000) / 50000);
+        else
+                vsel = ((min_uV - 1700000) / 100000)
+                        + WM831X_ALDO_SELECTOR_LOW + 1;
+
+        ret = wm831x_aldo_list_voltage(rdev, vsel);
+        if (ret < 0)
+                return ret;
+        if (ret < min_uV || ret > max_uV)
+                return -EINVAL;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel);
+}
+
+static int wm831x_aldo_set_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
+
+        return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV);
+}
+
+static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
+                                             int uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
+
+        return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV);
+}
+
+static int wm831x_aldo_get_voltage(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        int ret;
+
+        ret = wm831x_reg_read(wm831x, reg);
+        if (ret < 0)
+                return ret;
+
+        ret &= WM831X_LDO7_ON_VSEL_MASK;
+
+        return wm831x_aldo_list_voltage(rdev, ret);
+}
+
+static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        unsigned int ret;
+
+        ret = wm831x_reg_read(wm831x, on_reg);
+        if (ret < 0)
+                return 0;
+
+        if (ret & WM831X_LDO7_ON_MODE)
+                return REGULATOR_MODE_IDLE;
+        else
+                return REGULATOR_MODE_NORMAL;
+}
+
+static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
+                                  unsigned int mode)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
+        int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        int ret;
+
+
+        switch (mode) {
+        case REGULATOR_MODE_NORMAL:
+                ret = wm831x_set_bits(wm831x, on_reg,
+                                      WM831X_LDO7_ON_MODE, 0);
+                if (ret < 0)
+                        return ret;
+                break;
+
+        case REGULATOR_MODE_IDLE:
+                ret = wm831x_set_bits(wm831x, ctrl_reg,
+                                      WM831X_LDO7_ON_MODE,
+                                      WM831X_LDO7_ON_MODE);
+                if (ret < 0)
+                        return ret;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static int wm831x_aldo_get_status(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+        int ret;
+
+        /* Is the regulator on? */
+        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
+        if (ret < 0)
+                return ret;
+        if (!(ret & mask))
+                return REGULATOR_STATUS_OFF;
+
+        /* Is it reporting under voltage? */
+        ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
+        if (ret & mask)
+                return REGULATOR_STATUS_ERROR;
+
+        ret = wm831x_aldo_get_mode(rdev);
+        if (ret < 0)
+                return ret;
+        else
+                return regulator_mode_to_status(ret);
+}
+
+static struct regulator_ops wm831x_aldo_ops = {
+        .list_voltage = wm831x_aldo_list_voltage,
+        .get_voltage = wm831x_aldo_get_voltage,
+        .set_voltage = wm831x_aldo_set_voltage,
+        .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
+        .get_mode = wm831x_aldo_get_mode,
+        .set_mode = wm831x_aldo_set_mode,
+        .get_status = wm831x_aldo_get_status,
+
+        .is_enabled = wm831x_ldo_is_enabled,
+        .enable = wm831x_ldo_enable,
+        .disable = wm831x_ldo_disable,
+};
+
+static __devinit int wm831x_aldo_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        struct wm831x_ldo *ldo;
+        struct resource *res;
+        int ret, irq;
+
+        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
+
+        if (pdata == NULL || pdata->ldo[id] == NULL)
+                return -ENODEV;
+
+        ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
+        if (ldo == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        ldo->wm831x = wm831x;
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        ldo->base = res->start;
+
+        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
+        ldo->desc.name = ldo->name;
+        ldo->desc.id = id;
+        ldo->desc.type = REGULATOR_VOLTAGE;
+        ldo->desc.n_voltages = WM831X_ALDO_MAX_SELECTOR + 1;
+        ldo->desc.ops = &wm831x_aldo_ops;
+        ldo->desc.owner = THIS_MODULE;
+
+        ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
+                                             pdata->ldo[id], ldo);
+        if (IS_ERR(ldo->regulator)) {
+                ret = PTR_ERR(ldo->regulator);
+                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        irq = platform_get_irq_byname(pdev, "UV");
+        ret = wm831x_request_irq(wm831x, irq, wm831x_ldo_uv_irq,
+                                 IRQF_TRIGGER_RISING, ldo->name,
+                                 ldo);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
+                        irq, ret);
+                goto err_regulator;
+        }
+
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+
+err_regulator:
+        regulator_unregister(ldo->regulator);
+err:
+        kfree(ldo);
+        return ret;
+}
+
+static __devexit int wm831x_aldo_remove(struct platform_device *pdev)
+{
+        struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
+        struct wm831x *wm831x = ldo->wm831x;
+
+        wm831x_free_irq(wm831x, platform_get_irq_byname(pdev, "UV"), ldo);
+        regulator_unregister(ldo->regulator);
+        kfree(ldo);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_aldo_driver = {
+        .probe = wm831x_aldo_probe,
+        .remove = __devexit_p(wm831x_aldo_remove),
+        .driver         = {
+                .name   = "wm831x-aldo",
+        },
+};
+
+/*
+ * Alive LDO
+ */
+
+#define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
+
+static int wm831x_alive_ldo_list_voltage(struct regulator_dev *rdev,
+                                      unsigned int selector)
+{
+        /* 0.8-1.55V in 50mV steps */
+        if (selector <= WM831X_ALIVE_LDO_MAX_SELECTOR)
+                return 800000 + (selector * 50000);
+        return -EINVAL;
+}
+
+static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
+                                            int reg,
+                                            int min_uV, int max_uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int vsel, ret;
+
+        vsel = (min_uV - 800000) / 50000;
+
+        ret = wm831x_alive_ldo_list_voltage(rdev, vsel);
+        if (ret < 0)
+                return ret;
+        if (ret < min_uV || ret > max_uV)
+                return -EINVAL;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel);
+}
+
+static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
+
+        return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
+}
+
+static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
+                                             int uV)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
+
+        return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV);
+}
+
+static int wm831x_alive_ldo_get_voltage(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
+        int ret;
+
+        ret = wm831x_reg_read(wm831x, reg);
+        if (ret < 0)
+                return ret;
+
+        ret &= WM831X_LDO11_ON_VSEL_MASK;
+
+        return wm831x_alive_ldo_list_voltage(rdev, ret);
+}
+
+static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
+{
+        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
+        struct wm831x *wm831x = ldo->wm831x;
+        int mask = 1 << rdev_get_id(rdev);
+        int ret;
+
+        /* Is the regulator on? */
+        ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
+        if (ret < 0)
+                return ret;
+        if (ret & mask)
+                return REGULATOR_STATUS_ON;
+        else
+                return REGULATOR_STATUS_OFF;
+}
+
+static struct regulator_ops wm831x_alive_ldo_ops = {
+        .list_voltage = wm831x_alive_ldo_list_voltage,
+        .get_voltage = wm831x_alive_ldo_get_voltage,
+        .set_voltage = wm831x_alive_ldo_set_voltage,
+        .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
+        .get_status = wm831x_alive_ldo_get_status,
+
+        .is_enabled = wm831x_ldo_is_enabled,
+        .enable = wm831x_ldo_enable,
+        .disable = wm831x_ldo_disable,
+};
+
+static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_pdata *pdata = wm831x->dev->platform_data;
+        int id = pdev->id % ARRAY_SIZE(pdata->ldo);
+        struct wm831x_ldo *ldo;
+        struct resource *res;
+        int ret;
+
+        dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
+
+        if (pdata == NULL || pdata->ldo[id] == NULL)
+                return -ENODEV;
+
+        ldo = kzalloc(sizeof(struct wm831x_ldo), GFP_KERNEL);
+        if (ldo == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        ldo->wm831x = wm831x;
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        if (res == NULL) {
+                dev_err(&pdev->dev, "No I/O resource\n");
+                ret = -EINVAL;
+                goto err;
+        }
+        ldo->base = res->start;
+
+        snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
+        ldo->desc.name = ldo->name;
+        ldo->desc.id = id;
+        ldo->desc.type = REGULATOR_VOLTAGE;
+        ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
+        ldo->desc.ops = &wm831x_alive_ldo_ops;
+        ldo->desc.owner = THIS_MODULE;
+
+        ldo->regulator = regulator_register(&ldo->desc, &pdev->dev,
+                                             pdata->ldo[id], ldo);
+        if (IS_ERR(ldo->regulator)) {
+                ret = PTR_ERR(ldo->regulator);
+                dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
+                        id + 1, ret);
+                goto err;
+        }
+
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+
+err:
+        kfree(ldo);
+        return ret;
+}
+
+static __devexit int wm831x_alive_ldo_remove(struct platform_device *pdev)
+{
+        struct wm831x_ldo *ldo = platform_get_drvdata(pdev);
+
+        regulator_unregister(ldo->regulator);
+        kfree(ldo);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_alive_ldo_driver = {
+        .probe = wm831x_alive_ldo_probe,
+        .remove = __devexit_p(wm831x_alive_ldo_remove),
+        .driver         = {
+                .name   = "wm831x-alive-ldo",
+        },
+};
+
+static int __init wm831x_ldo_init(void)
+{
+        int ret;
+
+        ret = platform_driver_register(&wm831x_gp_ldo_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x GP LDO driver: %d\n", ret);
+
+        ret = platform_driver_register(&wm831x_aldo_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x ALDO driver: %d\n", ret);
+
+        ret = platform_driver_register(&wm831x_alive_ldo_driver);
+        if (ret != 0)
+                pr_err("Failed to register WM831x alive LDO driver: %d\n",
+                       ret);
+
+        return 0;
+}
+subsys_initcall(wm831x_ldo_init);
+
+static void __exit wm831x_ldo_exit(void)
+{
+        platform_driver_unregister(&wm831x_alive_ldo_driver);
+        platform_driver_unregister(&wm831x_aldo_driver);
+        platform_driver_unregister(&wm831x_gp_ldo_driver);
+}
+module_exit(wm831x_ldo_exit);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("WM831x LDO driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-ldo");
+MODULE_ALIAS("platform:wm831x-aldo");
+MODULE_ALIAS("platform:wm831x-aliveldo");
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 81adbdbd5042..73771b09fbd3 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -518,6 +518,16 @@ config RTC_DRV_V3020
           This driver can also be built as a module. If so, the module
           will be called rtc-v3020.
 
+config RTC_DRV_WM831X
+        tristate "Wolfson Microelectronics WM831x RTC"
+        depends on MFD_WM831X
+        help
+          If you say yes here you will get support for the RTC subsystem
+          of the Wolfson Microelectronics WM831X series PMICs.
+
+          This driver can also be built as a module. If so, the module
+          will be called "rtc-wm831x".
+
 config RTC_DRV_WM8350
         tristate "Wolfson Microelectronics WM8350 RTC"
         depends on MFD_WM8350
@@ -535,6 +545,15 @@ config RTC_DRV_PCF50633
           If you say yes here you get support for the RTC subsystem of the
           NXP PCF50633 used in embedded systems.
 
+config RTC_DRV_AB3100
+        tristate "ST-Ericsson AB3100 RTC"
+        depends on AB3100_CORE
+        default y if AB3100_CORE
+        help
+          Select this to enable the ST-Ericsson AB3100 Mixed Signal IC RTC
+          support. This chip contains a battery- and capacitor-backed RTC.
+
+
 comment "on-CPU RTC drivers"
 
 config RTC_DRV_OMAP
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 3c0f2b2ac927..5e152ffe5058 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -17,6 +17,7 @@ rtc-core-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o
 
 # Keep the list ordered.
 
+obj-$(CONFIG_RTC_DRV_AB3100)    += rtc-ab3100.o
 obj-$(CONFIG_RTC_DRV_AT32AP700X)+= rtc-at32ap700x.o
 obj-$(CONFIG_RTC_DRV_AT91RM9200)+= rtc-at91rm9200.o
 obj-$(CONFIG_RTC_DRV_AT91SAM9)  += rtc-at91sam9.o
@@ -74,6 +75,7 @@ obj-$(CONFIG_RTC_DRV_TWL4030)	+= rtc-twl4030.o
 obj-$(CONFIG_RTC_DRV_TX4939)    += rtc-tx4939.o
 obj-$(CONFIG_RTC_DRV_V3020)     += rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.o
+obj-$(CONFIG_RTC_DRV_WM831X)    += rtc-wm831x.o
 obj-$(CONFIG_RTC_DRV_WM8350)    += rtc-wm8350.o
 obj-$(CONFIG_RTC_DRV_X1205)     += rtc-x1205.o
 obj-$(CONFIG_RTC_DRV_PCF50633)  += rtc-pcf50633.o
diff --git a/drivers/rtc/rtc-ab3100.c b/drivers/rtc/rtc-ab3100.c
new file mode 100644
index 000000000000..4704aac2b5af
--- /dev/null
+++ b/drivers/rtc/rtc-ab3100.c
@@ -0,0 +1,281 @@
+/*
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * RTC clock driver for the AB3100 Analog Baseband Chip
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/mfd/ab3100.h>
+
+/* Clock rate in Hz */
+#define AB3100_RTC_CLOCK_RATE   32768
+
+/*
+ * The AB3100 RTC registers. These are the same for
+ * AB3000 and AB3100.
+ * Control register:
+ * Bit 0: RTC Monitor cleared=0, active=1, if you set it
+ *        to 1 it remains active until RTC power is lost.
+ * Bit 1: 32 kHz Oscillator, 0 = on, 1 = bypass
+ * Bit 2: Alarm on, 0 = off, 1 = on
+ * Bit 3: 32 kHz buffer disabling, 0 = enabled, 1 = disabled
+ */
+#define AB3100_RTC              0x53
+/* default setting, buffer disabled, alarm on */
+#define RTC_SETTING             0x30
+/* Alarm when AL0-AL3 == TI0-TI3  */
+#define AB3100_AL0              0x56
+#define AB3100_AL1              0x57
+#define AB3100_AL2              0x58
+#define AB3100_AL3              0x59
+/* This 48-bit register that counts up at 32768 Hz */
+#define AB3100_TI0              0x5a
+#define AB3100_TI1              0x5b
+#define AB3100_TI2              0x5c
+#define AB3100_TI3              0x5d
+#define AB3100_TI4              0x5e
+#define AB3100_TI5              0x5f
+
+/*
+ * RTC clock functions and device struct declaration
+ */
+static int ab3100_rtc_set_mmss(struct device *dev, unsigned long secs)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        u8 regs[] = {AB3100_TI0, AB3100_TI1, AB3100_TI2,
+                     AB3100_TI3, AB3100_TI4, AB3100_TI5};
+        unsigned char buf[6];
+        u64 fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        int err = 0;
+        int i;
+
+        buf[0] = (fat_time) & 0xFF;
+        buf[1] = (fat_time >> 8) & 0xFF;
+        buf[2] = (fat_time >> 16) & 0xFF;
+        buf[3] = (fat_time >> 24) & 0xFF;
+        buf[4] = (fat_time >> 32) & 0xFF;
+        buf[5] = (fat_time >> 40) & 0xFF;
+
+        for (i = 0; i < 6; i++) {
+                err = ab3100_set_register_interruptible(ab3100_data,
+                                                        regs[i], buf[i]);
+                if (err)
+                        return err;
+        }
+
+        /* Set the flag to mark that the clock is now set */
+        return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                          AB3100_RTC,
+                                                          0xFE, 0x01);
+
+}
+
+static int ab3100_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        unsigned long time;
+        u8 rtcval;
+        int err;
+
+        err = ab3100_get_register_interruptible(ab3100_data,
+                                                AB3100_RTC, &rtcval);
+        if (err)
+                return err;
+
+        if (!(rtcval & 0x01)) {
+                dev_info(dev, "clock not set (lost power)");
+                return -EINVAL;
+        } else {
+                u64 fat_time;
+                u8 buf[6];
+
+                /* Read out time registers */
+                err = ab3100_get_register_page_interruptible(ab3100_data,
+                                                             AB3100_TI0,
+                                                             buf, 6);
+                if (err != 0)
+                        return err;
+
+                fat_time = ((u64) buf[5] << 40) | ((u64) buf[4] << 32) |
+                        ((u64) buf[3] << 24) | ((u64) buf[2] << 16) |
+                        ((u64) buf[1] << 8) | (u64) buf[0];
+                time = (unsigned long) (fat_time /
+                                        (u64) (AB3100_RTC_CLOCK_RATE * 2));
+        }
+
+        rtc_time_to_tm(time, tm);
+
+        return rtc_valid_tm(tm);
+}
+
+static int ab3100_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        unsigned long time;
+        u64 fat_time;
+        u8 buf[6];
+        u8 rtcval;
+        int err;
+
+        /* Figure out if alarm is enabled or not */
+        err = ab3100_get_register_interruptible(ab3100_data,
+                                                AB3100_RTC, &rtcval);
+        if (err)
+                return err;
+        if (rtcval & 0x04)
+                alarm->enabled = 1;
+        else
+                alarm->enabled = 0;
+        /* No idea how this could be represented */
+        alarm->pending = 0;
+        /* Read out alarm registers, only 4 bytes */
+        err = ab3100_get_register_page_interruptible(ab3100_data,
+                                                     AB3100_AL0, buf, 4);
+        if (err)
+                return err;
+        fat_time = ((u64) buf[3] << 40) | ((u64) buf[2] << 32) |
+                ((u64) buf[1] << 24) | ((u64) buf[0] << 16);
+        time = (unsigned long) (fat_time / (u64) (AB3100_RTC_CLOCK_RATE * 2));
+
+        rtc_time_to_tm(time, &alarm->time);
+
+        return rtc_valid_tm(&alarm->time);
+}
+
+static int ab3100_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alarm)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+        u8 regs[] = {AB3100_AL0, AB3100_AL1, AB3100_AL2, AB3100_AL3};
+        unsigned char buf[4];
+        unsigned long secs;
+        u64 fat_time;
+        int err;
+        int i;
+
+        rtc_tm_to_time(&alarm->time, &secs);
+        fat_time = (u64) secs * AB3100_RTC_CLOCK_RATE * 2;
+        buf[0] = (fat_time >> 16) & 0xFF;
+        buf[1] = (fat_time >> 24) & 0xFF;
+        buf[2] = (fat_time >> 32) & 0xFF;
+        buf[3] = (fat_time >> 40) & 0xFF;
+
+        /* Set the alarm */
+        for (i = 0; i < 4; i++) {
+                err = ab3100_set_register_interruptible(ab3100_data,
+                                                        regs[i], buf[i]);
+                if (err)
+                        return err;
+        }
+        /* Then enable the alarm */
+        return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                          AB3100_RTC, ~(1 << 2),
+                                                          alarm->enabled << 2);
+}
+
+static int ab3100_rtc_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct ab3100 *ab3100_data = dev_get_drvdata(dev);
+
+        /*
+         * It's not possible to enable/disable the alarm IRQ for this RTC.
+         * It does not actually trigger any IRQ: instead its only function is
+         * to power up the system, if it wasn't on. This will manifest as
+         * a "power up cause" in the AB3100 power driver (battery charging etc)
+         * and need to be handled there instead.
+         */
+        if (enabled)
+                return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                    AB3100_RTC, ~(1 << 2),
+                                                    1 << 2);
+        else
+                return ab3100_mask_and_set_register_interruptible(ab3100_data,
+                                                    AB3100_RTC, ~(1 << 2),
+                                                    0);
+}
+
+static const struct rtc_class_ops ab3100_rtc_ops = {
+        .read_time      = ab3100_rtc_read_time,
+        .set_mmss       = ab3100_rtc_set_mmss,
+        .read_alarm     = ab3100_rtc_read_alarm,
+        .set_alarm      = ab3100_rtc_set_alarm,
+        .alarm_irq_enable = ab3100_rtc_irq_enable,
+};
+
+static int __init ab3100_rtc_probe(struct platform_device *pdev)
+{
+        int err;
+        u8 regval;
+        struct rtc_device *rtc;
+        struct ab3100 *ab3100_data = platform_get_drvdata(pdev);
+
+        /* The first RTC register needs special treatment */
+        err = ab3100_get_register_interruptible(ab3100_data,
+                                                AB3100_RTC, &regval);
+        if (err) {
+                dev_err(&pdev->dev, "unable to read RTC register\n");
+                return -ENODEV;
+        }
+
+        if ((regval & 0xFE) != RTC_SETTING) {
+                dev_warn(&pdev->dev, "not default value in RTC reg 0x%x\n",
+                         regval);
+        }
+
+        if ((regval & 1) == 0) {
+                /*
+                 * Set bit to detect power loss.
+                 * This bit remains until RTC power is lost.
+                 */
+                regval = 1 | RTC_SETTING;
+                err = ab3100_set_register_interruptible(ab3100_data,
+                                                        AB3100_RTC, regval);
+                /* Ignore any error on this write */
+        }
+
+        rtc = rtc_device_register("ab3100-rtc", &pdev->dev, &ab3100_rtc_ops,
+                                  THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                err = PTR_ERR(rtc);
+                return err;
+        }
+
+        return 0;
+}
+
+static int __exit ab3100_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
+
+        rtc_device_unregister(rtc);
+        return 0;
+}
+
+static struct platform_driver ab3100_rtc_driver = {
+        .driver = {
+                .name = "ab3100-rtc",
+                .owner = THIS_MODULE,
+        },
+        .remove  = __exit_p(ab3100_rtc_remove),
+};
+
+static int __init ab3100_rtc_init(void)
+{
+        return platform_driver_probe(&ab3100_rtc_driver,
+                                     ab3100_rtc_probe);
+}
+
+static void __exit ab3100_rtc_exit(void)
+{
+        platform_driver_unregister(&ab3100_rtc_driver);
+}
+
+module_init(ab3100_rtc_init);
+module_exit(ab3100_rtc_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("AB3100 RTC Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/rtc-ds1302.c b/drivers/rtc/rtc-ds1302.c
index 184556620778..d490628b64da 100644
--- a/drivers/rtc/rtc-ds1302.c
+++ b/drivers/rtc/rtc-ds1302.c
@@ -1,26 +1,25 @@
 /*
  * Dallas DS1302 RTC Support
  *
- *  Copyright (C) 2002  David McCullough
- *  Copyright (C) 2003 - 2007  Paul Mundt
+ *  Copyright (C) 2002 David McCullough
+ *  Copyright (C) 2003 - 2007 Paul Mundt
  *
  * This file is subject to the terms and conditions of the GNU General Public
- * License version 2.  See the file "COPYING" in the main directory of
+ * License version 2. See the file "COPYING" in the main directory of
  * this archive for more details.
  */
+
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
-#include <linux/time.h>
 #include <linux/rtc.h>
-#include <linux/spinlock.h>
 #include <linux/io.h>
 #include <linux/bcd.h>
 #include <asm/rtc.h>
 
 #define DRV_NAME        "rtc-ds1302"
-#define DRV_VERSION     "0.1.0"
+#define DRV_VERSION     "0.1.1"
 
 #define RTC_CMD_READ    0x81            /* Read command */
 #define RTC_CMD_WRITE   0x80            /* Write command */
@@ -47,11 +46,6 @@
 #error "Add support for your platform"
 #endif
 
-struct ds1302_rtc {
-        struct rtc_device *rtc_dev;
-        spinlock_t lock;
-};
-
 static void ds1302_sendbits(unsigned int val)
 {
         int i;
@@ -103,10 +97,6 @@ static void ds1302_writebyte(unsigned int addr, unsigned int val)
 
 static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ds1302_rtc *rtc = dev_get_drvdata(dev);
-
-        spin_lock_irq(&rtc->lock);
-
         tm->tm_sec      = bcd2bin(ds1302_readbyte(RTC_ADDR_SEC));
         tm->tm_min      = bcd2bin(ds1302_readbyte(RTC_ADDR_MIN));
         tm->tm_hour     = bcd2bin(ds1302_readbyte(RTC_ADDR_HOUR));
@@ -118,26 +108,17 @@ static int ds1302_rtc_read_time(struct device *dev, struct rtc_time *tm)
         if (tm->tm_year < 70)
                 tm->tm_year += 100;
 
-        spin_unlock_irq(&rtc->lock);
-
         dev_dbg(dev, "%s: tm is secs=%d, mins=%d, hours=%d, "
                 "mday=%d, mon=%d, year=%d, wday=%d\n",
                 __func__,
                 tm->tm_sec, tm->tm_min, tm->tm_hour,
                 tm->tm_mday, tm->tm_mon + 1, tm->tm_year, tm->tm_wday);
 
-        if (rtc_valid_tm(tm) < 0)
-                dev_err(dev, "invalid date\n");
-
-        return 0;
+        return rtc_valid_tm(tm);
 }
 
 static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
 {
-        struct ds1302_rtc *rtc = dev_get_drvdata(dev);
-
-        spin_lock_irq(&rtc->lock);
-
         /* Stop RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) | 0x80);
 
@@ -152,8 +133,6 @@ static int ds1302_rtc_set_time(struct device *dev, struct rtc_time *tm)
         /* Start RTC */
         ds1302_writebyte(RTC_ADDR_SEC, ds1302_readbyte(RTC_ADDR_SEC) & ~0x80);
 
-        spin_unlock_irq(&rtc->lock);
-
         return 0;
 }
 
@@ -170,9 +149,7 @@ static int ds1302_rtc_ioctl(struct device *dev, unsigned int cmd,
                 if (copy_from_user(&tcs_val, (int __user *)arg, sizeof(int)))
                         return -EFAULT;
 
-                spin_lock_irq(&rtc->lock);
                 ds1302_writebyte(RTC_ADDR_TCR, (0xa0 | tcs_val * 0xf));
-                spin_unlock_irq(&rtc->lock);
                 return 0;
         }
 #endif
@@ -187,10 +164,9 @@ static struct rtc_class_ops ds1302_rtc_ops = {
         .ioctl          = ds1302_rtc_ioctl,
 };
 
-static int __devinit ds1302_rtc_probe(struct platform_device *pdev)
+static int __init ds1302_rtc_probe(struct platform_device *pdev)
 {
-        struct ds1302_rtc *rtc;
-        int ret;
+        struct rtc_device *rtc;
 
         /* Reset */
         set_dp(get_dp() & ~(RTC_RESET | RTC_IODATA | RTC_SCLK));
@@ -200,37 +176,23 @@ static int __devinit ds1302_rtc_probe(struct platform_device *pdev)
         if (ds1302_readbyte(RTC_ADDR_RAM0) != 0x42)
                 return -ENODEV;
 
-        rtc = kzalloc(sizeof(struct ds1302_rtc), GFP_KERNEL);
-        if (unlikely(!rtc))
-                return -ENOMEM;
-
-        spin_lock_init(&rtc->lock);
-        rtc->rtc_dev = rtc_device_register("ds1302", &pdev->dev,
+        rtc = rtc_device_register("ds1302", &pdev->dev,
                                            &ds1302_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto out;
-        }
+        if (IS_ERR(rtc))
+                return PTR_ERR(rtc);
 
         platform_set_drvdata(pdev, rtc);
 
         return 0;
-out:
-        kfree(rtc);
-        return ret;
 }
 
 static int __devexit ds1302_rtc_remove(struct platform_device *pdev)
 {
-        struct ds1302_rtc *rtc = platform_get_drvdata(pdev);
-
-        if (likely(rtc->rtc_dev))
-                rtc_device_unregister(rtc->rtc_dev);
+        struct rtc_device *rtc = platform_get_drvdata(pdev);
 
+        rtc_device_unregister(rtc);
         platform_set_drvdata(pdev, NULL);
 
-        kfree(rtc);
-
         return 0;
 }
 
@@ -239,13 +201,12 @@ static struct platform_driver ds1302_platform_driver = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
         },
-        .probe          = ds1302_rtc_probe,
-        .remove         = __devexit_p(ds1302_rtc_remove),
+        .remove         = __exit_p(ds1302_rtc_remove),
 };
 
 static int __init ds1302_rtc_init(void)
 {
-        return platform_driver_register(&ds1302_platform_driver);
+        return platform_driver_probe(&ds1302_platform_driver, ds1302_rtc_probe);
 }
 
 static void __exit ds1302_rtc_exit(void)
diff --git a/drivers/rtc/rtc-sh.c b/drivers/rtc/rtc-sh.c
index d7310adb7152..e6ed5404bca0 100644
--- a/drivers/rtc/rtc-sh.c
+++ b/drivers/rtc/rtc-sh.c
@@ -29,7 +29,7 @@
 #include <asm/rtc.h>
 
 #define DRV_NAME        "sh-rtc"
-#define DRV_VERSION     "0.2.2"
+#define DRV_VERSION     "0.2.3"
 
 #define RTC_REG(r)      ((r) * rtc_reg_size)
 
@@ -215,7 +215,7 @@ static irqreturn_t sh_rtc_shared(int irq, void *dev_id)
         return IRQ_RETVAL(ret);
 }
 
-static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
+static int sh_rtc_irq_set_state(struct device *dev, int enable)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         unsigned int tmp;
@@ -225,17 +225,22 @@ static inline void sh_rtc_setpie(struct device *dev, unsigned int enable)
         tmp = readb(rtc->regbase + RCR2);
 
         if (enable) {
+                rtc->periodic_freq |= PF_KOU;
                 tmp &= ~RCR2_PEF;       /* Clear PES bit */
                 tmp |= (rtc->periodic_freq & ~PF_HP);   /* Set PES2-0 */
-        } else
+        } else {
+                rtc->periodic_freq &= ~PF_KOU;
                 tmp &= ~(RCR2_PESMASK | RCR2_PEF);
+        }
 
         writeb(tmp, rtc->regbase + RCR2);
 
         spin_unlock_irq(&rtc->lock);
+
+        return 0;
 }
 
-static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
+static int sh_rtc_irq_set_freq(struct device *dev, int freq)
 {
         struct sh_rtc *rtc = dev_get_drvdata(dev);
         int tmp, ret = 0;
@@ -278,10 +283,8 @@ static inline int sh_rtc_setfreq(struct device *dev, unsigned int freq)
                 ret = -ENOTSUPP;
         }
 
-        if (ret == 0) {
+        if (ret == 0)
                 rtc->periodic_freq |= tmp;
-                rtc->rtc_dev->irq_freq = freq;
-        }
 
         spin_unlock_irq(&rtc->lock);
         return ret;
@@ -346,10 +349,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
         unsigned int ret = 0;
 
         switch (cmd) {
-        case RTC_PIE_OFF:
-        case RTC_PIE_ON:
-                sh_rtc_setpie(dev, cmd == RTC_PIE_ON);
-                break;
         case RTC_AIE_OFF:
         case RTC_AIE_ON:
                 sh_rtc_setaie(dev, cmd == RTC_AIE_ON);
@@ -362,13 +361,6 @@ static int sh_rtc_ioctl(struct device *dev, unsigned int cmd, unsigned long arg)
                 rtc->periodic_freq |= PF_OXS;
                 sh_rtc_setcie(dev, 1);
                 break;
-        case RTC_IRQP_READ:
-                ret = put_user(rtc->rtc_dev->irq_freq,
-                               (unsigned long __user *)arg);
-                break;
-        case RTC_IRQP_SET:
-                ret = sh_rtc_setfreq(dev, arg);
-                break;
         default:
                 ret = -ENOIOCTLCMD;
         }
@@ -602,28 +594,6 @@ static int sh_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *wkalrm)
         return 0;
 }
 
-static int sh_rtc_irq_set_state(struct device *dev, int enabled)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct sh_rtc *rtc = platform_get_drvdata(pdev);
-
-        if (enabled) {
-                rtc->periodic_freq |= PF_KOU;
-                return sh_rtc_ioctl(dev, RTC_PIE_ON, 0);
-        } else {
-                rtc->periodic_freq &= ~PF_KOU;
-                return sh_rtc_ioctl(dev, RTC_PIE_OFF, 0);
-        }
-}
-
-static int sh_rtc_irq_set_freq(struct device *dev, int freq)
-{
-        if (!is_power_of_2(freq))
-                return -EINVAL;
-
-        return sh_rtc_ioctl(dev, RTC_IRQP_SET, freq);
-}
-
 static struct rtc_class_ops sh_rtc_ops = {
         .ioctl          = sh_rtc_ioctl,
         .read_time      = sh_rtc_read_time,
@@ -635,7 +605,7 @@ static struct rtc_class_ops sh_rtc_ops = {
         .proc           = sh_rtc_proc,
 };
 
-static int __devinit sh_rtc_probe(struct platform_device *pdev)
+static int __init sh_rtc_probe(struct platform_device *pdev)
 {
         struct sh_rtc *rtc;
         struct resource *res;
@@ -702,13 +672,6 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
 
         clk_enable(rtc->clk);
 
-        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
-                                           &sh_rtc_ops, THIS_MODULE);
-        if (IS_ERR(rtc->rtc_dev)) {
-                ret = PTR_ERR(rtc->rtc_dev);
-                goto err_unmap;
-        }
-
         rtc->capabilities = RTC_DEF_CAPABILITIES;
         if (pdev->dev.platform_data) {
                 struct sh_rtc_platform_info *pinfo = pdev->dev.platform_data;
@@ -720,10 +683,6 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 rtc->capabilities |= pinfo->capabilities;
         }
 
-        rtc->rtc_dev->max_user_freq = 256;
-
-        platform_set_drvdata(pdev, rtc);
-
         if (rtc->carry_irq <= 0) {
                 /* register shared periodic/carry/alarm irq */
                 ret = request_irq(rtc->periodic_irq, sh_rtc_shared,
@@ -767,13 +726,26 @@ static int __devinit sh_rtc_probe(struct platform_device *pdev)
                 }
         }
 
+        platform_set_drvdata(pdev, rtc);
+
         /* everything disabled by default */
-        rtc->periodic_freq = 0;
-        rtc->rtc_dev->irq_freq = 0;
-        sh_rtc_setpie(&pdev->dev, 0);
+        sh_rtc_irq_set_freq(&pdev->dev, 0);
+        sh_rtc_irq_set_state(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
         sh_rtc_setcie(&pdev->dev, 0);
 
+        rtc->rtc_dev = rtc_device_register("sh", &pdev->dev,
+                                           &sh_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc->rtc_dev)) {
+                ret = PTR_ERR(rtc->rtc_dev);
+                free_irq(rtc->periodic_irq, rtc);
+                free_irq(rtc->carry_irq, rtc);
+                free_irq(rtc->alarm_irq, rtc);
+                goto err_unmap;
+        }
+
+        rtc->rtc_dev->max_user_freq = 256;
+
         /* reset rtc to epoch 0 if time is invalid */
         if (rtc_read_time(rtc->rtc_dev, &r) < 0) {
                 rtc_time_to_tm(0, &r);
@@ -795,14 +767,13 @@ err_badres:
         return ret;
 }
 
-static int __devexit sh_rtc_remove(struct platform_device *pdev)
+static int __exit sh_rtc_remove(struct platform_device *pdev)
 {
         struct sh_rtc *rtc = platform_get_drvdata(pdev);
 
-        if (likely(rtc->rtc_dev))
-                rtc_device_unregister(rtc->rtc_dev);
+        rtc_device_unregister(rtc->rtc_dev);
+        sh_rtc_irq_set_state(&pdev->dev, 0);
 
-        sh_rtc_setpie(&pdev->dev, 0);
         sh_rtc_setaie(&pdev->dev, 0);
         sh_rtc_setcie(&pdev->dev, 0);
 
@@ -813,9 +784,8 @@ static int __devexit sh_rtc_remove(struct platform_device *pdev)
                 free_irq(rtc->alarm_irq, rtc);
         }
 
-        release_resource(rtc->res);
-
         iounmap(rtc->regbase);
+        release_resource(rtc->res);
 
         clk_disable(rtc->clk);
         clk_put(rtc->clk);
@@ -867,13 +837,12 @@ static struct platform_driver sh_rtc_platform_driver = {
                 .owner  = THIS_MODULE,
                 .pm     = &sh_rtc_dev_pm_ops,
         },
-        .probe          = sh_rtc_probe,
-        .remove         = __devexit_p(sh_rtc_remove),
+        .remove         = __exit_p(sh_rtc_remove),
 };
 
 static int __init sh_rtc_init(void)
 {
-        return platform_driver_register(&sh_rtc_platform_driver);
+        return platform_driver_probe(&sh_rtc_platform_driver, sh_rtc_probe);
 }
 
 static void __exit sh_rtc_exit(void)
diff --git a/drivers/rtc/rtc-wm831x.c b/drivers/rtc/rtc-wm831x.c
new file mode 100644
index 000000000000..79795cdf6ed8
--- /dev/null
+++ b/drivers/rtc/rtc-wm831x.c
@@ -0,0 +1,523 @@
+/*
+ *      Real Time Clock driver for Wolfson Microelectronics WM831x
+ *
+ *      Copyright (C) 2009 Wolfson Microelectronics PLC.
+ *
+ *  Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/interrupt.h>
+#include <linux/ioctl.h>
+#include <linux/completion.h>
+#include <linux/mfd/wm831x/core.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+
+
+/*
+ * R16416 (0x4020) - RTC Write Counter
+ */
+#define WM831X_RTC_WR_CNT_MASK                  0xFFFF  /* RTC_WR_CNT - [15:0] */
+#define WM831X_RTC_WR_CNT_SHIFT                      0  /* RTC_WR_CNT - [15:0] */
+#define WM831X_RTC_WR_CNT_WIDTH                     16  /* RTC_WR_CNT - [15:0] */
+
+/*
+ * R16417 (0x4021) - RTC Time 1
+ */
+#define WM831X_RTC_TIME_MASK                    0xFFFF  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_SHIFT                        0  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_WIDTH                       16  /* RTC_TIME - [15:0] */
+
+/*
+ * R16418 (0x4022) - RTC Time 2
+ */
+#define WM831X_RTC_TIME_MASK                    0xFFFF  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_SHIFT                        0  /* RTC_TIME - [15:0] */
+#define WM831X_RTC_TIME_WIDTH                       16  /* RTC_TIME - [15:0] */
+
+/*
+ * R16419 (0x4023) - RTC Alarm 1
+ */
+#define WM831X_RTC_ALM_MASK                     0xFFFF  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_SHIFT                         0  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_WIDTH                        16  /* RTC_ALM - [15:0] */
+
+/*
+ * R16420 (0x4024) - RTC Alarm 2
+ */
+#define WM831X_RTC_ALM_MASK                     0xFFFF  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_SHIFT                         0  /* RTC_ALM - [15:0] */
+#define WM831X_RTC_ALM_WIDTH                        16  /* RTC_ALM - [15:0] */
+
+/*
+ * R16421 (0x4025) - RTC Control
+ */
+#define WM831X_RTC_VALID                        0x8000  /* RTC_VALID */
+#define WM831X_RTC_VALID_MASK                   0x8000  /* RTC_VALID */
+#define WM831X_RTC_VALID_SHIFT                      15  /* RTC_VALID */
+#define WM831X_RTC_VALID_WIDTH                       1  /* RTC_VALID */
+#define WM831X_RTC_SYNC_BUSY                    0x4000  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_MASK               0x4000  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_SHIFT                  14  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_SYNC_BUSY_WIDTH                   1  /* RTC_SYNC_BUSY */
+#define WM831X_RTC_ALM_ENA                      0x0400  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_MASK                 0x0400  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_SHIFT                    10  /* RTC_ALM_ENA */
+#define WM831X_RTC_ALM_ENA_WIDTH                     1  /* RTC_ALM_ENA */
+#define WM831X_RTC_PINT_FREQ_MASK               0x0070  /* RTC_PINT_FREQ - [6:4] */
+#define WM831X_RTC_PINT_FREQ_SHIFT                   4  /* RTC_PINT_FREQ - [6:4] */
+#define WM831X_RTC_PINT_FREQ_WIDTH                   3  /* RTC_PINT_FREQ - [6:4] */
+
+/*
+ * R16422 (0x4026) - RTC Trim
+ */
+#define WM831X_RTC_TRIM_MASK                    0x03FF  /* RTC_TRIM - [9:0] */
+#define WM831X_RTC_TRIM_SHIFT                        0  /* RTC_TRIM - [9:0] */
+#define WM831X_RTC_TRIM_WIDTH                       10  /* RTC_TRIM - [9:0] */
+
+#define WM831X_SET_TIME_RETRIES 5
+#define WM831X_GET_TIME_RETRIES 5
+
+struct wm831x_rtc {
+        struct wm831x *wm831x;
+        struct rtc_device *rtc;
+        unsigned int alarm_enabled:1;
+};
+
+/*
+ * Read current time and date in RTC
+ */
+static int wm831x_rtc_readtime(struct device *dev, struct rtc_time *tm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        u16 time1[2], time2[2];
+        int ret;
+        int count = 0;
+
+        /* Has the RTC been programmed? */
+        ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC control: %d\n", ret);
+                return ret;
+        }
+        if (!(ret & WM831X_RTC_VALID)) {
+                dev_dbg(dev, "RTC not yet configured\n");
+                return -EINVAL;
+        }
+
+        /* Read twice to make sure we don't read a corrupt, partially
+         * incremented, value.
+         */
+        do {
+                ret = wm831x_bulk_read(wm831x, WM831X_RTC_TIME_1,
+                                       2, time1);
+                if (ret != 0)
+                        continue;
+
+                ret = wm831x_bulk_read(wm831x, WM831X_RTC_TIME_1,
+                                       2, time2);
+                if (ret != 0)
+                        continue;
+
+                if (memcmp(time1, time2, sizeof(time1)) == 0) {
+                        u32 time = (time1[0] << 16) | time1[1];
+
+                        rtc_time_to_tm(time, tm);
+                        return rtc_valid_tm(tm);
+                }
+
+        } while (++count < WM831X_GET_TIME_RETRIES);
+
+        dev_err(dev, "Timed out reading current time\n");
+
+        return -EIO;
+}
+
+/*
+ * Set current time and date in RTC
+ */
+static int wm831x_rtc_set_mmss(struct device *dev, unsigned long time)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        struct rtc_time new_tm;
+        unsigned long new_time;
+        int ret;
+        int count = 0;
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_TIME_1,
+                               (time >> 16) & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write TIME_1: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_TIME_2, time & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write TIME_2: %d\n", ret);
+                return ret;
+        }
+
+        /* Wait for the update to complete - should happen first time
+         * round but be conservative.
+         */
+        do {
+                msleep(1);
+
+                ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+                if (ret < 0)
+                        ret = WM831X_RTC_SYNC_BUSY;
+        } while (!(ret & WM831X_RTC_SYNC_BUSY) &&
+                 ++count < WM831X_SET_TIME_RETRIES);
+
+        if (ret & WM831X_RTC_SYNC_BUSY) {
+                dev_err(dev, "Timed out writing RTC update\n");
+                return -EIO;
+        }
+
+        /* Check that the update was accepted; security features may
+         * have caused the update to be ignored.
+         */
+        ret = wm831x_rtc_readtime(dev, &new_tm);
+        if (ret < 0)
+                return ret;
+
+        ret = rtc_tm_to_time(&new_tm, &new_time);
+        if (ret < 0) {
+                dev_err(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+
+        /* Allow a second of change in case of tick */
+        if (new_time - time > 1) {
+                dev_err(dev, "RTC update not permitted by hardware\n");
+                return -EPERM;
+        }
+
+        return 0;
+}
+
+/*
+ * Read alarm time and date in RTC
+ */
+static int wm831x_rtc_readalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        int ret;
+        u16 data[2];
+        u32 time;
+
+        ret = wm831x_bulk_read(wm831x_rtc->wm831x, WM831X_RTC_ALARM_1,
+                               2, data);
+        if (ret != 0) {
+                dev_err(dev, "Failed to read alarm time: %d\n", ret);
+                return ret;
+        }
+
+        time = (data[0] << 16) | data[1];
+
+        rtc_time_to_tm(time, &alrm->time);
+
+        ret = wm831x_reg_read(wm831x_rtc->wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read RTC control: %d\n", ret);
+                return ret;
+        }
+
+        if (ret & WM831X_RTC_ALM_ENA)
+                alrm->enabled = 1;
+        else
+                alrm->enabled = 0;
+
+        return 0;
+}
+
+static int wm831x_rtc_stop_alarm(struct wm831x_rtc *wm831x_rtc)
+{
+        wm831x_rtc->alarm_enabled = 0;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_ALM_ENA, 0);
+}
+
+static int wm831x_rtc_start_alarm(struct wm831x_rtc *wm831x_rtc)
+{
+        wm831x_rtc->alarm_enabled = 1;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_ALM_ENA, WM831X_RTC_ALM_ENA);
+}
+
+static int wm831x_rtc_setalarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        struct wm831x *wm831x = wm831x_rtc->wm831x;
+        int ret;
+        unsigned long time;
+
+        ret = rtc_tm_to_time(&alrm->time, &time);
+        if (ret < 0) {
+                dev_err(dev, "Failed to convert time: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_rtc_stop_alarm(wm831x_rtc);
+        if (ret < 0) {
+                dev_err(dev, "Failed to stop alarm: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_ALARM_1,
+                               (time >> 16) & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write ALARM_1: %d\n", ret);
+                return ret;
+        }
+
+        ret = wm831x_reg_write(wm831x, WM831X_RTC_ALARM_2, time & 0xffff);
+        if (ret < 0) {
+                dev_err(dev, "Failed to write ALARM_2: %d\n", ret);
+                return ret;
+        }
+
+        if (alrm->enabled) {
+                ret = wm831x_rtc_start_alarm(wm831x_rtc);
+                if (ret < 0) {
+                        dev_err(dev, "Failed to start alarm: %d\n", ret);
+                        return ret;
+                }
+        }
+
+        return 0;
+}
+
+static int wm831x_rtc_alarm_irq_enable(struct device *dev,
+                                       unsigned int enabled)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+
+        if (enabled)
+                return wm831x_rtc_start_alarm(wm831x_rtc);
+        else
+                return wm831x_rtc_stop_alarm(wm831x_rtc);
+}
+
+static int wm831x_rtc_update_irq_enable(struct device *dev,
+                                        unsigned int enabled)
+{
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(dev);
+        int val;
+
+        if (enabled)
+                val = 1 << WM831X_RTC_PINT_FREQ_SHIFT;
+        else
+                val = 0;
+
+        return wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                               WM831X_RTC_PINT_FREQ_MASK, val);
+}
+
+static irqreturn_t wm831x_alm_irq(int irq, void *data)
+{
+        struct wm831x_rtc *wm831x_rtc = data;
+
+        rtc_update_irq(wm831x_rtc->rtc, 1, RTC_IRQF | RTC_AF);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t wm831x_per_irq(int irq, void *data)
+{
+        struct wm831x_rtc *wm831x_rtc = data;
+
+        rtc_update_irq(wm831x_rtc->rtc, 1, RTC_IRQF | RTC_UF);
+
+        return IRQ_HANDLED;
+}
+
+static const struct rtc_class_ops wm831x_rtc_ops = {
+        .read_time = wm831x_rtc_readtime,
+        .set_mmss = wm831x_rtc_set_mmss,
+        .read_alarm = wm831x_rtc_readalarm,
+        .set_alarm = wm831x_rtc_setalarm,
+        .alarm_irq_enable = wm831x_rtc_alarm_irq_enable,
+        .update_irq_enable = wm831x_rtc_update_irq_enable,
+};
+
+#ifdef CONFIG_PM
+/* Turn off the alarm if it should not be a wake source. */
+static int wm831x_rtc_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret, enable;
+
+        if (wm831x_rtc->alarm_enabled && device_may_wakeup(&pdev->dev))
+                enable = WM831X_RTC_ALM_ENA;
+        else
+                enable = 0;
+
+        ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                              WM831X_RTC_ALM_ENA, enable);
+        if (ret != 0)
+                dev_err(&pdev->dev, "Failed to update RTC alarm: %d\n", ret);
+
+        return 0;
+}
+
+/* Enable the alarm if it should be enabled (in case it was disabled to
+ * prevent use as a wake source).
+ */
+static int wm831x_rtc_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret;
+
+        if (wm831x_rtc->alarm_enabled) {
+                ret = wm831x_rtc_start_alarm(wm831x_rtc);
+                if (ret != 0)
+                        dev_err(&pdev->dev,
+                                "Failed to restart RTC alarm: %d\n", ret);
+        }
+
+        return 0;
+}
+
+/* Unconditionally disable the alarm */
+static int wm831x_rtc_freeze(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct wm831x_rtc *wm831x_rtc = dev_get_drvdata(&pdev->dev);
+        int ret;
+
+        ret = wm831x_set_bits(wm831x_rtc->wm831x, WM831X_RTC_CONTROL,
+                              WM831X_RTC_ALM_ENA, 0);
+        if (ret != 0)
+                dev_err(&pdev->dev, "Failed to stop RTC alarm: %d\n", ret);
+
+        return 0;
+}
+#else
+#define wm831x_rtc_suspend NULL
+#define wm831x_rtc_resume NULL
+#define wm831x_rtc_freeze NULL
+#endif
+
+static int wm831x_rtc_probe(struct platform_device *pdev)
+{
+        struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
+        struct wm831x_rtc *wm831x_rtc;
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+        int ret = 0;
+
+        wm831x_rtc = kzalloc(sizeof(*wm831x_rtc), GFP_KERNEL);
+        if (wm831x_rtc == NULL)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, wm831x_rtc);
+        wm831x_rtc->wm831x = wm831x;
+
+        ret = wm831x_reg_read(wm831x, WM831X_RTC_CONTROL);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read RTC control: %d\n", ret);
+                goto err;
+        }
+        if (ret & WM831X_RTC_ALM_ENA)
+                wm831x_rtc->alarm_enabled = 1;
+
+        device_init_wakeup(&pdev->dev, 1);
+
+        wm831x_rtc->rtc = rtc_device_register("wm831x", &pdev->dev,
+                                              &wm831x_rtc_ops, THIS_MODULE);
+        if (IS_ERR(wm831x_rtc->rtc)) {
+                ret = PTR_ERR(wm831x_rtc->rtc);
+                goto err;
+        }
+
+        ret = wm831x_request_irq(wm831x, per_irq, wm831x_per_irq,
+                                 IRQF_TRIGGER_RISING, "wm831x_rtc_per",
+                                 wm831x_rtc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request periodic IRQ %d: %d\n",
+                        per_irq, ret);
+        }
+
+        ret = wm831x_request_irq(wm831x, alm_irq, wm831x_alm_irq,
+                                 IRQF_TRIGGER_RISING, "wm831x_rtc_alm",
+                                 wm831x_rtc);
+        if (ret != 0) {
+                dev_err(&pdev->dev, "Failed to request alarm IRQ %d: %d\n",
+                        alm_irq, ret);
+        }
+
+        return 0;
+
+err:
+        kfree(wm831x_rtc);
+        return ret;
+}
+
+static int __devexit wm831x_rtc_remove(struct platform_device *pdev)
+{
+        struct wm831x_rtc *wm831x_rtc = platform_get_drvdata(pdev);
+        int per_irq = platform_get_irq_byname(pdev, "PER");
+        int alm_irq = platform_get_irq_byname(pdev, "ALM");
+
+        wm831x_free_irq(wm831x_rtc->wm831x, alm_irq, wm831x_rtc);
+        wm831x_free_irq(wm831x_rtc->wm831x, per_irq, wm831x_rtc);
+        rtc_device_unregister(wm831x_rtc->rtc);
+        kfree(wm831x_rtc);
+
+        return 0;
+}
+
+static struct dev_pm_ops wm831x_rtc_pm_ops = {
+        .suspend = wm831x_rtc_suspend,
+        .resume = wm831x_rtc_resume,
+
+        .freeze = wm831x_rtc_freeze,
+        .thaw = wm831x_rtc_resume,
+        .restore = wm831x_rtc_resume,
+
+        .poweroff = wm831x_rtc_suspend,
+};
+
+static struct platform_driver wm831x_rtc_driver = {
+        .probe = wm831x_rtc_probe,
+        .remove = __devexit_p(wm831x_rtc_remove),
+        .driver = {
+                .name = "wm831x-rtc",
+                .pm = &wm831x_rtc_pm_ops,
+        },
+};
+
+static int __init wm831x_rtc_init(void)
+{
+        return platform_driver_register(&wm831x_rtc_driver);
+}
+module_init(wm831x_rtc_init);
+
+static void __exit wm831x_rtc_exit(void)
+{
+        platform_driver_unregister(&wm831x_rtc_driver);
+}
+module_exit(wm831x_rtc_exit);
+
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("RTC driver for the WM831x series PMICs");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-rtc");
diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index 62a4c2026072..11ae5c94608b 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -29,7 +29,6 @@
 #include <linux/ethtool.h>
 #include <linux/if_ether.h>
 #include <linux/if_vlan.h>
-#include <linux/netdevice.h>
 #include <linux/errno.h>
 #include <linux/bitops.h>
 #include <net/rtnetlink.h>
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index 9928704e235f..d9b0e9d31983 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -73,7 +73,6 @@
 #include <linux/of.h>
 #include <asm/firmware.h>
 #include <asm/vio.h>
-#include <asm/firmware.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_host.h>
diff --git a/drivers/serial/21285.c b/drivers/serial/21285.c
index cb6d85d7ff43..1e3d19397a59 100644
--- a/drivers/serial/21285.c
+++ b/drivers/serial/21285.c
@@ -86,7 +86,7 @@ static void serial21285_enable_ms(struct uart_port *port)
 static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned int status, ch, flag, rxs, max_count = 256;
 
         status = *CSR_UARTFLG;
@@ -124,7 +124,7 @@ static irqreturn_t serial21285_rx_chars(int irq, void *dev_id)
 static irqreturn_t serial21285_tx_chars(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         int count = 256;
 
         if (port->x_char) {
@@ -235,8 +235,8 @@ serial21285_set_termios(struct uart_port *port, struct ktermios *termios,
         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 
         quot = uart_get_divisor(port, baud);
 
-        if (port->info && port->info->port.tty) {
-                struct tty_struct *tty = port->info->port.tty;
+        if (port->state && port->state->port.tty) {
+                struct tty_struct *tty = port->state->port.tty;
                 unsigned int b = port->uartclk / (16 * quot);
                 tty_encode_baud_rate(tty, b, b);
         }
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index fb867a9f55e9..2209620d2349 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -1382,7 +1382,7 @@ static void serial8250_enable_ms(struct uart_port *port)
 static void
 receive_chars(struct uart_8250_port *up, unsigned int *status)
 {
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned char ch, lsr = *status;
         int max_count = 256;
         char flag;
@@ -1457,7 +1457,7 @@ ignore_char:
 
 static void transmit_chars(struct uart_8250_port *up)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int count;
 
         if (up->port.x_char) {
@@ -1500,7 +1500,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
         status |= up->msr_saved_flags;
         up->msr_saved_flags = 0;
         if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
-            up->port.info != NULL) {
+            up->port.state != NULL) {
                 if (status & UART_MSR_TERI)
                         up->port.icount.rng++;
                 if (status & UART_MSR_DDSR)
@@ -1510,7 +1510,7 @@ static unsigned int check_modem_status(struct uart_8250_port *up)
                 if (status & UART_MSR_DCTS)
                         uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
 
-                wake_up_interruptible(&up->port.info->delta_msr_wait);
+                wake_up_interruptible(&up->port.state->port.delta_msr_wait);
         }
 
         return status;
@@ -1677,7 +1677,7 @@ static int serial_link_irq_chain(struct uart_8250_port *up)
                 INIT_LIST_HEAD(&up->list);
                 i->head = &up->list;
                 spin_unlock_irq(&i->lock);
-
+                irq_flags |= up->port.irqflags;
                 ret = request_irq(up->port.irq, serial8250_interrupt,
                                   irq_flags, "serial", i);
                 if (ret < 0)
@@ -1764,7 +1764,7 @@ static void serial8250_backup_timeout(unsigned long data)
         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
         spin_unlock_irqrestore(&up->port.lock, flags);
         if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
-            (!uart_circ_empty(&up->port.info->xmit) || up->port.x_char) &&
+            (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
             (lsr & UART_LSR_THRE)) {
                 iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
                 iir |= UART_IIR_THRI;
@@ -2026,7 +2026,7 @@ static int serial8250_startup(struct uart_port *port)
                  * allow register changes to become visible.
                  */
                 spin_lock_irqsave(&up->port.lock, flags);
-                if (up->port.flags & UPF_SHARE_IRQ)
+                if (up->port.irqflags & IRQF_SHARED)
                         disable_irq_nosync(up->port.irq);
 
                 wait_for_xmitr(up, UART_LSR_THRE);
@@ -2039,7 +2039,7 @@ static int serial8250_startup(struct uart_port *port)
                 iir = serial_in(up, UART_IIR);
                 serial_out(up, UART_IER, 0);
 
-                if (up->port.flags & UPF_SHARE_IRQ)
+                if (up->port.irqflags & IRQF_SHARED)
                         enable_irq(up->port.irq);
                 spin_unlock_irqrestore(&up->port.lock, flags);
 
@@ -2272,7 +2272,9 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
         /*
          * Ask the core to calculate the divisor for us.
          */
-        baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
+        baud = uart_get_baud_rate(port, termios, old,
+                                  port->uartclk / 16 / 0xffff,
+                                  port->uartclk / 16);
         quot = serial8250_get_divisor(port, baud);
 
         /*
@@ -2671,6 +2673,7 @@ static void __init serial8250_isa_init_ports(void)
              i++, up++) {
                 up->port.iobase   = old_serial_port[i].port;
                 up->port.irq      = irq_canonicalize(old_serial_port[i].irq);
+                up->port.irqflags = old_serial_port[i].irqflags;
                 up->port.uartclk  = old_serial_port[i].baud_base * 16;
                 up->port.flags    = old_serial_port[i].flags;
                 up->port.hub6     = old_serial_port[i].hub6;
@@ -2679,7 +2682,7 @@ static void __init serial8250_isa_init_ports(void)
                 up->port.regshift = old_serial_port[i].iomem_reg_shift;
                 set_io_from_upio(&up->port);
                 if (share_irqs)
-                        up->port.flags |= UPF_SHARE_IRQ;
+                        up->port.irqflags |= IRQF_SHARED;
         }
 }
 
@@ -2869,6 +2872,7 @@ int __init early_serial_setup(struct uart_port *port)
         p->iobase       = port->iobase;
         p->membase      = port->membase;
         p->irq          = port->irq;
+        p->irqflags     = port->irqflags;
         p->uartclk      = port->uartclk;
         p->fifosize     = port->fifosize;
         p->regshift     = port->regshift;
@@ -2942,6 +2946,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
                 port.iobase             = p->iobase;
                 port.membase            = p->membase;
                 port.irq                = p->irq;
+                port.irqflags           = p->irqflags;
                 port.uartclk            = p->uartclk;
                 port.regshift           = p->regshift;
                 port.iotype             = p->iotype;
@@ -2954,7 +2959,7 @@ static int __devinit serial8250_probe(struct platform_device *dev)
                 port.serial_out         = p->serial_out;
                 port.dev                = &dev->dev;
                 if (share_irqs)
-                        port.flags |= UPF_SHARE_IRQ;
+                        port.irqflags |= IRQF_SHARED;
                 ret = serial8250_register_port(&port);
                 if (ret < 0) {
                         dev_err(&dev->dev, "unable to register port at index %d "
@@ -3096,6 +3101,7 @@ int serial8250_register_port(struct uart_port *port)
                 uart->port.iobase       = port->iobase;
                 uart->port.membase      = port->membase;
                 uart->port.irq          = port->irq;
+                uart->port.irqflags     = port->irqflags;
                 uart->port.uartclk      = port->uartclk;
                 uart->port.fifosize     = port->fifosize;
                 uart->port.regshift     = port->regshift;
diff --git a/drivers/serial/8250.h b/drivers/serial/8250.h
index 520260326f3d..6e19ea3e48d5 100644
--- a/drivers/serial/8250.h
+++ b/drivers/serial/8250.h
@@ -25,6 +25,7 @@ struct old_serial_port {
         unsigned char io_type;
         unsigned char *iomem_base;
         unsigned short iomem_reg_shift;
+        unsigned long irqflags;
 };
 
 /*
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 58a4879c7e48..429a8ae86933 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -117,7 +117,7 @@ static void pl010_enable_ms(struct uart_port *port)
 
 static void pl010_rx_chars(struct uart_amba_port *uap)
 {
-        struct tty_struct *tty = uap->port.info->port.tty;
+        struct tty_struct *tty = uap->port.state->port.tty;
         unsigned int status, ch, flag, rsr, max_count = 256;
 
         status = readb(uap->port.membase + UART01x_FR);
@@ -172,7 +172,7 @@ static void pl010_rx_chars(struct uart_amba_port *uap)
 
 static void pl010_tx_chars(struct uart_amba_port *uap)
 {
-        struct circ_buf *xmit = &uap->port.info->xmit;
+        struct circ_buf *xmit = &uap->port.state->xmit;
         int count;
 
         if (uap->port.x_char) {
@@ -225,7 +225,7 @@ static void pl010_modem_status(struct uart_amba_port *uap)
         if (delta & UART01x_FR_CTS)
                 uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS);
 
-        wake_up_interruptible(&uap->port.info->delta_msr_wait);
+        wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
 }
 
 static irqreturn_t pl010_int(int irq, void *dev_id)
diff --git a/drivers/serial/amba-pl011.c b/drivers/serial/amba-pl011.c
index 72ba0c6d3551..ef7adc8135dd 100644
--- a/drivers/serial/amba-pl011.c
+++ b/drivers/serial/amba-pl011.c
@@ -124,7 +124,7 @@ static void pl011_enable_ms(struct uart_port *port)
 
 static void pl011_rx_chars(struct uart_amba_port *uap)
 {
-        struct tty_struct *tty = uap->port.info->port.tty;
+        struct tty_struct *tty = uap->port.state->port.tty;
         unsigned int status, ch, flag, max_count = 256;
 
         status = readw(uap->port.membase + UART01x_FR);
@@ -175,7 +175,7 @@ static void pl011_rx_chars(struct uart_amba_port *uap)
 
 static void pl011_tx_chars(struct uart_amba_port *uap)
 {
-        struct circ_buf *xmit = &uap->port.info->xmit;
+        struct circ_buf *xmit = &uap->port.state->xmit;
         int count;
 
         if (uap->port.x_char) {
@@ -226,7 +226,7 @@ static void pl011_modem_status(struct uart_amba_port *uap)
         if (delta & UART01x_FR_CTS)
                 uart_handle_cts_change(&uap->port, status & UART01x_FR_CTS);
 
-        wake_up_interruptible(&uap->port.info->delta_msr_wait);
+        wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
 }
 
 static irqreturn_t pl011_int(int irq, void *dev_id)
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index 607d43a31048..3551c5cb7094 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -427,7 +427,7 @@ static void atmel_rx_chars(struct uart_port *port)
  */
 static void atmel_tx_chars(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         if (port->x_char && UART_GET_CSR(port) & ATMEL_US_TXRDY) {
                 UART_PUT_CHAR(port, port->x_char);
@@ -560,7 +560,7 @@ static irqreturn_t atmel_interrupt(int irq, void *dev_id)
 static void atmel_tx_dma(struct uart_port *port)
 {
         struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx;
         int count;
 
@@ -663,14 +663,14 @@ static void atmel_rx_from_ring(struct uart_port *port)
          * uart_start(), which takes the lock.
          */
         spin_unlock(&port->lock);
-        tty_flip_buffer_push(port->info->port.tty);
+        tty_flip_buffer_push(port->state->port.tty);
         spin_lock(&port->lock);
 }
 
 static void atmel_rx_from_dma(struct uart_port *port)
 {
         struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         struct atmel_dma_buffer *pdc;
         int rx_idx = atmel_port->pdc_rx_idx;
         unsigned int head;
@@ -776,7 +776,7 @@ static void atmel_tasklet_func(unsigned long data)
                 if (status_change & ATMEL_US_CTS)
                         uart_handle_cts_change(port, !(status & ATMEL_US_CTS));
 
-                wake_up_interruptible(&port->info->delta_msr_wait);
+                wake_up_interruptible(&port->state->port.delta_msr_wait);
 
                 atmel_port->irq_status_prev = status;
         }
@@ -795,7 +795,7 @@ static void atmel_tasklet_func(unsigned long data)
 static int atmel_startup(struct uart_port *port)
 {
         struct atmel_uart_port *atmel_port = to_atmel_uart_port(port);
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         int retval;
 
         /*
@@ -854,7 +854,7 @@ static int atmel_startup(struct uart_port *port)
         }
         if (atmel_use_dma_tx(port)) {
                 struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx;
-                struct circ_buf *xmit = &port->info->xmit;
+                struct circ_buf *xmit = &port->state->xmit;
 
                 pdc->buf = xmit->buf;
                 pdc->dma_addr = dma_map_single(port->dev,
diff --git a/drivers/serial/bfin_5xx.c b/drivers/serial/bfin_5xx.c
index b4a7650af696..50abb7e557f4 100644
--- a/drivers/serial/bfin_5xx.c
+++ b/drivers/serial/bfin_5xx.c
@@ -42,6 +42,10 @@
 # undef CONFIG_EARLY_PRINTK
 #endif
 
+#ifdef CONFIG_SERIAL_BFIN_MODULE
+# undef CONFIG_EARLY_PRINTK
+#endif
+
 /* UART name and device definitions */
 #define BFIN_SERIAL_NAME        "ttyBF"
 #define BFIN_SERIAL_MAJOR       204
@@ -140,7 +144,7 @@ static void bfin_serial_stop_tx(struct uart_port *port)
 {
         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
 #ifdef CONFIG_SERIAL_BFIN_DMA
-        struct circ_buf *xmit = &uart->port.info->xmit;
+        struct circ_buf *xmit = &uart->port.state->xmit;
 #endif
 
         while (!(UART_GET_LSR(uart) & TEMT))
@@ -167,7 +171,7 @@ static void bfin_serial_stop_tx(struct uart_port *port)
 static void bfin_serial_start_tx(struct uart_port *port)
 {
         struct bfin_serial_port *uart = (struct bfin_serial_port *)port;
-        struct tty_struct *tty = uart->port.info->port.tty;
+        struct tty_struct *tty = uart->port.state->port.tty;
 
 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
         if (uart->scts && !(bfin_serial_get_mctrl(&uart->port) & TIOCM_CTS)) {
@@ -239,10 +243,10 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
                         return;
                 }
 
-        if (!uart->port.info || !uart->port.info->port.tty)
+        if (!uart->port.state || !uart->port.state->port.tty)
                 return;
 #endif
-        tty = uart->port.info->port.tty;
+        tty = uart->port.state->port.tty;
 
         if (ANOMALY_05000363) {
                 /* The BF533 (and BF561) family of processors have a nice anomaly
@@ -327,7 +331,7 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 
 static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
 {
-        struct circ_buf *xmit = &uart->port.info->xmit;
+        struct circ_buf *xmit = &uart->port.state->xmit;
 
         if (uart_circ_empty(xmit) || uart_tx_stopped(&uart->port)) {
 #ifdef CONFIG_BF54x
@@ -394,7 +398,7 @@ static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
 #ifdef CONFIG_SERIAL_BFIN_DMA
 static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
 {
-        struct circ_buf *xmit = &uart->port.info->xmit;
+        struct circ_buf *xmit = &uart->port.state->xmit;
 
         uart->tx_done = 0;
 
@@ -432,7 +436,7 @@ static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
 
 static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
 {
-        struct tty_struct *tty = uart->port.info->port.tty;
+        struct tty_struct *tty = uart->port.state->port.tty;
         int i, flg, status;
 
         status = UART_GET_LSR(uart);
@@ -525,7 +529,7 @@ void bfin_serial_rx_dma_timeout(struct bfin_serial_port *uart)
 static irqreturn_t bfin_serial_dma_tx_int(int irq, void *dev_id)
 {
         struct bfin_serial_port *uart = dev_id;
-        struct circ_buf *xmit = &uart->port.info->xmit;
+        struct circ_buf *xmit = &uart->port.state->xmit;
 
 #ifdef CONFIG_SERIAL_BFIN_HARD_CTSRTS
         if (uart->scts && !(bfin_serial_get_mctrl(&uart->port)&TIOCM_CTS)) {
@@ -961,10 +965,10 @@ static void bfin_serial_set_ldisc(struct uart_port *port)
         int line = port->line;
         unsigned short val;
 
-        if (line >= port->info->port.tty->driver->num)
+        if (line >= port->state->port.tty->driver->num)
                 return;
 
-        switch (port->info->port.tty->termios->c_line) {
+        switch (port->state->port.tty->termios->c_line) {
         case N_IRDA:
                 val = UART_GET_GCTL(&bfin_serial_ports[line]);
                 val |= (IREN | RPOLC);
diff --git a/drivers/serial/bfin_sport_uart.c b/drivers/serial/bfin_sport_uart.c
index c108b1a0ce98..088bb35475f1 100644
--- a/drivers/serial/bfin_sport_uart.c
+++ b/drivers/serial/bfin_sport_uart.c
@@ -178,7 +178,7 @@ static int sport_uart_setup(struct sport_uart_port *up, int sclk, int baud_rate)
 static irqreturn_t sport_uart_rx_irq(int irq, void *dev_id)
 {
         struct sport_uart_port *up = dev_id;
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned int ch;
 
         do {
@@ -205,7 +205,7 @@ static irqreturn_t sport_uart_tx_irq(int irq, void *dev_id)
 static irqreturn_t sport_uart_err_irq(int irq, void *dev_id)
 {
         struct sport_uart_port *up = dev_id;
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned int stat = SPORT_GET_STAT(up);
 
         /* Overflow in RX FIFO */
@@ -290,7 +290,7 @@ fail1:
 
 static void sport_uart_tx_chars(struct sport_uart_port *up)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
 
         if (SPORT_GET_STAT(up) & TXF)
                 return;
diff --git a/drivers/serial/clps711x.c b/drivers/serial/clps711x.c
index 80e76426131d..b6acd19b458e 100644
--- a/drivers/serial/clps711x.c
+++ b/drivers/serial/clps711x.c
@@ -93,7 +93,7 @@ static void clps711xuart_enable_ms(struct uart_port *port)
 static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned int status, ch, flg;
 
         status = clps_readl(SYSFLG(port));
@@ -147,7 +147,7 @@ static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
 static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         int count;
 
         if (port->x_char) {
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index f8df0681e160..8d349b23249a 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -244,7 +244,7 @@ static void cpm_uart_int_rx(struct uart_port *port)
         int i;
         unsigned char ch;
         u8 *cp;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         struct uart_cpm_port *pinfo = (struct uart_cpm_port *)port;
         cbd_t __iomem *bdp;
         u16 status;
diff --git a/drivers/serial/dz.c b/drivers/serial/dz.c
index 6042b87797a1..57421d776329 100644
--- a/drivers/serial/dz.c
+++ b/drivers/serial/dz.c
@@ -197,7 +197,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
         while ((status = dz_in(dport, DZ_RBUF)) & DZ_DVAL) {
                 dport = &mux->dport[LINE(status)];
                 uport = &dport->port;
-                tty = uport->info->port.tty;    /* point to the proper dev */
+                tty = uport->state->port.tty;   /* point to the proper dev */
 
                 ch = UCHAR(status);             /* grab the char */
                 flag = TTY_NORMAL;
@@ -249,7 +249,7 @@ static inline void dz_receive_chars(struct dz_mux *mux)
         }
         for (i = 0; i < DZ_NB_PORT; i++)
                 if (lines_rx[i])
-                        tty_flip_buffer_push(mux->dport[i].port.info->port.tty);
+                        tty_flip_buffer_push(mux->dport[i].port.state->port.tty);
 }
 
 /*
@@ -268,7 +268,7 @@ static inline void dz_transmit_chars(struct dz_mux *mux)
 
         status = dz_in(dport, DZ_CSR);
         dport = &mux->dport[LINE(status)];
-        xmit = &dport->port.info->xmit;
+        xmit = &dport->port.state->xmit;
 
         if (dport->port.x_char) {               /* XON/XOFF chars */
                 dz_out(dport, DZ_TDR, dport->port.x_char);
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index cd1b6a45bb82..2d7feecaf492 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -617,7 +617,7 @@ static void shutdown(struct icom_port *icom_port)
          * disable break condition
          */
         cmdReg = readb(&icom_port->dram->CmdReg);
-        if ((cmdReg | CMD_SND_BREAK) == CMD_SND_BREAK) {
+        if (cmdReg & CMD_SND_BREAK) {
                 writeb(cmdReg & ~CMD_SND_BREAK, &icom_port->dram->CmdReg);
         }
 }
@@ -627,7 +627,7 @@ static int icom_write(struct uart_port *port)
         unsigned long data_count;
         unsigned char cmdReg;
         unsigned long offset;
-        int temp_tail = port->info->xmit.tail;
+        int temp_tail = port->state->xmit.tail;
 
         trace(ICOM_PORT, "WRITE", 0);
 
@@ -638,11 +638,11 @@ static int icom_write(struct uart_port *port)
         }
 
         data_count = 0;
-        while ((port->info->xmit.head != temp_tail) &&
+        while ((port->state->xmit.head != temp_tail) &&
                (data_count <= XMIT_BUFF_SZ)) {
 
                 ICOM_PORT->xmit_buf[data_count++] =
-                    port->info->xmit.buf[temp_tail];
+                    port->state->xmit.buf[temp_tail];
 
                 temp_tail++;
                 temp_tail &= (UART_XMIT_SIZE - 1);
@@ -694,8 +694,8 @@ static inline void check_modem_status(struct icom_port *icom_port)
                         uart_handle_cts_change(&icom_port->uart_port,
                                                delta_status & ICOM_CTS);
 
-                wake_up_interruptible(&icom_port->uart_port.info->
-                                      delta_msr_wait);
+                wake_up_interruptible(&icom_port->uart_port.state->
+                                      port.delta_msr_wait);
                 old_status = status;
         }
         spin_unlock(&icom_port->uart_port.lock);
@@ -718,10 +718,10 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
                 icom_port->uart_port.icount.tx += count;
 
                 for (i=0; i<count &&
-                        !uart_circ_empty(&icom_port->uart_port.info->xmit); i++) {
+                        !uart_circ_empty(&icom_port->uart_port.state->xmit); i++) {
 
-                        icom_port->uart_port.info->xmit.tail++;
-                        icom_port->uart_port.info->xmit.tail &=
+                        icom_port->uart_port.state->xmit.tail++;
+                        icom_port->uart_port.state->xmit.tail &=
                                 (UART_XMIT_SIZE - 1);
                 }
 
@@ -735,7 +735,7 @@ static void xmit_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 static void recv_interrupt(u16 port_int_reg, struct icom_port *icom_port)
 {
         short int count, rcv_buff;
-        struct tty_struct *tty = icom_port->uart_port.info->port.tty;
+        struct tty_struct *tty = icom_port->uart_port.state->port.tty;
         unsigned short int status;
         struct uart_icount *icount;
         unsigned long offset;
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 7485afd0df4c..18130f11238e 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -224,7 +224,7 @@ static void imx_mctrl_check(struct imx_port *sport)
         if (changed & TIOCM_CTS)
                 uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
 
-        wake_up_interruptible(&sport->port.info->delta_msr_wait);
+        wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
 }
 
 /*
@@ -236,7 +236,7 @@ static void imx_timeout(unsigned long data)
         struct imx_port *sport = (struct imx_port *)data;
         unsigned long flags;
 
-        if (sport->port.info) {
+        if (sport->port.state) {
                 spin_lock_irqsave(&sport->port.lock, flags);
                 imx_mctrl_check(sport);
                 spin_unlock_irqrestore(&sport->port.lock, flags);
@@ -323,7 +323,7 @@ static void imx_enable_ms(struct uart_port *port)
 
 static inline void imx_transmit_buffer(struct imx_port *sport)
 {
-        struct circ_buf *xmit = &sport->port.info->xmit;
+        struct circ_buf *xmit = &sport->port.state->xmit;
 
         while (!(readl(sport->port.membase + UTS) & UTS_TXFULL)) {
                 /* send xmit->buf[xmit->tail]
@@ -388,7 +388,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
 
         writel(USR1_RTSD, sport->port.membase + USR1);
         uart_handle_cts_change(&sport->port, !!val);
-        wake_up_interruptible(&sport->port.info->delta_msr_wait);
+        wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
 
         spin_unlock_irqrestore(&sport->port.lock, flags);
         return IRQ_HANDLED;
@@ -397,7 +397,7 @@ static irqreturn_t imx_rtsint(int irq, void *dev_id)
 static irqreturn_t imx_txint(int irq, void *dev_id)
 {
         struct imx_port *sport = dev_id;
-        struct circ_buf *xmit = &sport->port.info->xmit;
+        struct circ_buf *xmit = &sport->port.state->xmit;
         unsigned long flags;
 
         spin_lock_irqsave(&sport->port.lock,flags);
@@ -427,7 +427,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
 {
         struct imx_port *sport = dev_id;
         unsigned int rx,flg,ignored = 0;
-        struct tty_struct *tty = sport->port.info->port.tty;
+        struct tty_struct *tty = sport->port.state->port.tty;
         unsigned long flags, temp;
 
         spin_lock_irqsave(&sport->port.lock,flags);
@@ -900,11 +900,11 @@ imx_set_termios(struct uart_port *port, struct ktermios *termios,
         rational_best_approximation(16 * div * baud, sport->port.uartclk,
                 1 << 16, 1 << 16, &num, &denom);
 
-        if (port->info && port->info->port.tty) {
+        if (port->state && port->state->port.tty) {
                 tdiv64 = sport->port.uartclk;
                 tdiv64 *= num;
                 do_div(tdiv64, denom * 16 * div);
-                tty_encode_baud_rate(sport->port.info->port.tty,
+                tty_encode_baud_rate(sport->port.state->port.tty,
                                 (speed_t)tdiv64, (speed_t)tdiv64);
         }
 
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
index ae3699d77dd0..d8983dd5c4b2 100644
--- a/drivers/serial/ioc3_serial.c
+++ b/drivers/serial/ioc3_serial.c
@@ -897,25 +897,25 @@ static void transmit_chars(struct uart_port *the_port)
         char *start;
         struct tty_struct *tty;
         struct ioc3_port *port = get_ioc3_port(the_port);
-        struct uart_info *info;
+        struct uart_state *state;
 
         if (!the_port)
                 return;
         if (!port)
                 return;
 
-        info = the_port->info;
-        tty = info->port.tty;
+        state = the_port->state;
+        tty = state->port.tty;
 
-        if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
+        if (uart_circ_empty(&state->xmit) || uart_tx_stopped(the_port)) {
                 /* Nothing to do or hw stopped */
                 set_notification(port, N_ALL_OUTPUT, 0);
                 return;
         }
 
-        head = info->xmit.head;
-        tail = info->xmit.tail;
-        start = (char *)&info->xmit.buf[tail];
+        head = state->xmit.head;
+        tail = state->xmit.tail;
+        start = (char *)&state->xmit.buf[tail];
 
         /* write out all the data or until the end of the buffer */
         xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
@@ -928,14 +928,14 @@ static void transmit_chars(struct uart_port *the_port)
                         /* advance the pointers */
                         tail += result;
                         tail &= UART_XMIT_SIZE - 1;
-                        info->xmit.tail = tail;
-                        start = (char *)&info->xmit.buf[tail];
+                        state->xmit.tail = tail;
+                        start = (char *)&state->xmit.buf[tail];
                 }
         }
-        if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS)
+        if (uart_circ_chars_pending(&state->xmit) < WAKEUP_CHARS)
                 uart_write_wakeup(the_port);
 
-        if (uart_circ_empty(&info->xmit)) {
+        if (uart_circ_empty(&state->xmit)) {
                 set_notification(port, N_OUTPUT_LOWAT, 0);
         } else {
                 set_notification(port, N_OUTPUT_LOWAT, 1);
@@ -956,7 +956,7 @@ ioc3_change_speed(struct uart_port *the_port,
         unsigned int cflag;
         int baud;
         int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
-        struct uart_info *info = the_port->info;
+        struct uart_state *state = the_port->state;
 
         cflag = new_termios->c_cflag;
 
@@ -997,14 +997,14 @@ ioc3_change_speed(struct uart_port *the_port,
 
         the_port->ignore_status_mask = N_ALL_INPUT;
 
-        info->port.tty->low_latency = 1;
+        state->port.tty->low_latency = 1;
 
-        if (I_IGNPAR(info->port.tty))
+        if (I_IGNPAR(state->port.tty))
                 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
                                                   | N_FRAMING_ERROR);
-        if (I_IGNBRK(info->port.tty)) {
+        if (I_IGNBRK(state->port.tty)) {
                 the_port->ignore_status_mask &= ~N_BREAK;
-                if (I_IGNPAR(info->port.tty))
+                if (I_IGNPAR(state->port.tty))
                         the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
         }
         if (!(cflag & CREAD)) {
@@ -1286,8 +1286,8 @@ static inline int do_read(struct uart_port *the_port, char *buf, int len)
                                                 uart_handle_dcd_change
                                                         (port->ip_port, 0);
                                                 wake_up_interruptible
-                                                    (&the_port->info->
-                                                     delta_msr_wait);
+                                                    (&the_port->state->
+                                                     port.delta_msr_wait);
                                         }
 
                                         /* If we had any data to return, we
@@ -1392,21 +1392,21 @@ static int receive_chars(struct uart_port *the_port)
         struct tty_struct *tty;
         unsigned char ch[MAX_CHARS];
         int read_count = 0, read_room, flip = 0;
-        struct uart_info *info = the_port->info;
+        struct uart_state *state = the_port->state;
         struct ioc3_port *port = get_ioc3_port(the_port);
         unsigned long pflags;
 
         /* Make sure all the pointers are "good" ones */
-        if (!info)
+        if (!state)
                 return 0;
-        if (!info->port.tty)
+        if (!state->port.tty)
                 return 0;
 
         if (!(port->ip_flags & INPUT_ENABLE))
                 return 0;
 
         spin_lock_irqsave(&the_port->lock, pflags);
-        tty = info->port.tty;
+        tty = state->port.tty;
 
         read_count = do_read(the_port, ch, MAX_CHARS);
         if (read_count > 0) {
@@ -1491,7 +1491,7 @@ ioc3uart_intr_one(struct ioc3_submodule *is,
                                 uart_handle_dcd_change(the_port,
                                                 shadow & SHADOW_DCD);
                                 wake_up_interruptible
-                                    (&the_port->info->delta_msr_wait);
+                                    (&the_port->state->port.delta_msr_wait);
                         } else if ((port->ip_notify & N_DDCD)
                                    && !(shadow & SHADOW_DCD)) {
                                 /* Flag delta DCD/no DCD */
@@ -1511,7 +1511,7 @@ ioc3uart_intr_one(struct ioc3_submodule *is,
                                 uart_handle_cts_change(the_port, shadow
                                                 & SHADOW_CTS);
                                 wake_up_interruptible
-                                    (&the_port->info->delta_msr_wait);
+                                    (&the_port->state->port.delta_msr_wait);
                         }
                 }
 
@@ -1721,14 +1721,14 @@ static void ic3_shutdown(struct uart_port *the_port)
 {
         unsigned long port_flags;
         struct ioc3_port *port;
-        struct uart_info *info;
+        struct uart_state *state;
 
         port = get_ioc3_port(the_port);
         if (!port)
                 return;
 
-        info = the_port->info;
-        wake_up_interruptible(&info->delta_msr_wait);
+        state = the_port->state;
+        wake_up_interruptible(&state->port.delta_msr_wait);
 
         spin_lock_irqsave(&the_port->lock, port_flags);
         set_notification(port, N_ALL, 0);
diff --git a/drivers/serial/ioc4_serial.c b/drivers/serial/ioc4_serial.c
index 6bab63cd5b29..2e02c3026d24 100644
--- a/drivers/serial/ioc4_serial.c
+++ b/drivers/serial/ioc4_serial.c
@@ -930,7 +930,7 @@ static void handle_dma_error_intr(void *arg, uint32_t other_ir)
 
         if (readl(&port->ip_mem->pci_err_addr_l.raw) & IOC4_PCI_ERR_ADDR_VLD) {
                 printk(KERN_ERR
-                        "PCI error address is 0x%lx, "
+                        "PCI error address is 0x%llx, "
                                 "master is serial port %c %s\n",
                      (((uint64_t)readl(&port->ip_mem->pci_err_addr_h)
                                                          << 32)
@@ -1627,25 +1627,25 @@ static void transmit_chars(struct uart_port *the_port)
         char *start;
         struct tty_struct *tty;
         struct ioc4_port *port = get_ioc4_port(the_port, 0);
-        struct uart_info *info;
+        struct uart_state *state;
 
         if (!the_port)
                 return;
         if (!port)
                 return;
 
-        info = the_port->info;
-        tty = info->port.tty;
+        state = the_port->state;
+        tty = state->port.tty;
 
-        if (uart_circ_empty(&info->xmit) || uart_tx_stopped(the_port)) {
+        if (uart_circ_empty(&state->xmit) || uart_tx_stopped(the_port)) {
                 /* Nothing to do or hw stopped */
                 set_notification(port, N_ALL_OUTPUT, 0);
                 return;
         }
 
-        head = info->xmit.head;
-        tail = info->xmit.tail;
-        start = (char *)&info->xmit.buf[tail];
+        head = state->xmit.head;
+        tail = state->xmit.tail;
+        start = (char *)&state->xmit.buf[tail];
 
         /* write out all the data or until the end of the buffer */
         xmit_count = (head < tail) ? (UART_XMIT_SIZE - tail) : (head - tail);
@@ -1658,14 +1658,14 @@ static void transmit_chars(struct uart_port *the_port)
                         /* advance the pointers */
                         tail += result;
                         tail &= UART_XMIT_SIZE - 1;
-                        info->xmit.tail = tail;
-                        start = (char *)&info->xmit.buf[tail];
+                        state->xmit.tail = tail;
+                        start = (char *)&state->xmit.buf[tail];
                 }
         }
-        if (uart_circ_chars_pending(&info->xmit) < WAKEUP_CHARS)
+        if (uart_circ_chars_pending(&state->xmit) < WAKEUP_CHARS)
                 uart_write_wakeup(the_port);
 
-        if (uart_circ_empty(&info->xmit)) {
+        if (uart_circ_empty(&state->xmit)) {
                 set_notification(port, N_OUTPUT_LOWAT, 0);
         } else {
                 set_notification(port, N_OUTPUT_LOWAT, 1);
@@ -1686,7 +1686,7 @@ ioc4_change_speed(struct uart_port *the_port,
         int baud, bits;
         unsigned cflag;
         int new_parity = 0, new_parity_enable = 0, new_stop = 0, new_data = 8;
-        struct uart_info *info = the_port->info;
+        struct uart_state *state = the_port->state;
 
         cflag = new_termios->c_cflag;
 
@@ -1738,14 +1738,14 @@ ioc4_change_speed(struct uart_port *the_port,
 
         the_port->ignore_status_mask = N_ALL_INPUT;
 
-        info->port.tty->low_latency = 1;
+        state->port.tty->low_latency = 1;
 
-        if (I_IGNPAR(info->port.tty))
+        if (I_IGNPAR(state->port.tty))
                 the_port->ignore_status_mask &= ~(N_PARITY_ERROR
                                                 | N_FRAMING_ERROR);
-        if (I_IGNBRK(info->port.tty)) {
+        if (I_IGNBRK(state->port.tty)) {
                 the_port->ignore_status_mask &= ~N_BREAK;
-                if (I_IGNPAR(info->port.tty))
+                if (I_IGNPAR(state->port.tty))
                         the_port->ignore_status_mask &= ~N_OVERRUN_ERROR;
         }
         if (!(cflag & CREAD)) {
@@ -1784,7 +1784,7 @@ ioc4_change_speed(struct uart_port *the_port,
 static inline int ic4_startup_local(struct uart_port *the_port)
 {
         struct ioc4_port *port;
-        struct uart_info *info;
+        struct uart_state *state;
 
         if (!the_port)
                 return -1;
@@ -1793,7 +1793,7 @@ static inline int ic4_startup_local(struct uart_port *the_port)
         if (!port)
                 return -1;
 
-        info = the_port->info;
+        state = the_port->state;
 
         local_open(port);
 
@@ -1801,7 +1801,7 @@ static inline int ic4_startup_local(struct uart_port *the_port)
         ioc4_set_proto(port, the_port->mapbase);
 
         /* set the speed of the serial port */
-        ioc4_change_speed(the_port, info->port.tty->termios,
+        ioc4_change_speed(the_port, state->port.tty->termios,
                           (struct ktermios *)0);
 
         return 0;
@@ -1882,7 +1882,7 @@ static void handle_intr(void *arg, uint32_t sio_ir)
                                 the_port = port->ip_port;
                                 the_port->icount.dcd = 1;
                                 wake_up_interruptible
-                                            (&the_port-> info->delta_msr_wait);
+                                            (&the_port->state->port.delta_msr_wait);
                         } else if ((port->ip_notify & N_DDCD)
                                         && !(shadow & IOC4_SHADOW_DCD)) {
                                 /* Flag delta DCD/no DCD */
@@ -1904,7 +1904,7 @@ static void handle_intr(void *arg, uint32_t sio_ir)
                                 the_port->icount.cts =
                                         (shadow & IOC4_SHADOW_CTS) ? 1 : 0;
                                 wake_up_interruptible
-                                        (&the_port->info->delta_msr_wait);
+                                        (&the_port->state->port.delta_msr_wait);
                         }
                 }
 
@@ -2236,8 +2236,8 @@ static inline int do_read(struct uart_port *the_port, unsigned char *buf,
                                                    && port->ip_port) {
                                                 the_port->icount.dcd = 0;
                                                 wake_up_interruptible
-                                                    (&the_port->info->
-                                                        delta_msr_wait);
+                                                    (&the_port->state->
+                                                        port.delta_msr_wait);
                                         }
 
                                         /* If we had any data to return, we
@@ -2341,17 +2341,17 @@ static void receive_chars(struct uart_port *the_port)
         unsigned char ch[IOC4_MAX_CHARS];
         int read_count, request_count = IOC4_MAX_CHARS;
         struct uart_icount *icount;
-        struct uart_info *info = the_port->info;
+        struct uart_state *state = the_port->state;
         unsigned long pflags;
 
         /* Make sure all the pointers are "good" ones */
-        if (!info)
+        if (!state)
                 return;
-        if (!info->port.tty)
+        if (!state->port.tty)
                 return;
 
         spin_lock_irqsave(&the_port->lock, pflags);
-        tty = info->port.tty;
+        tty = state->port.tty;
 
         request_count = tty_buffer_request_room(tty, IOC4_MAX_CHARS);
 
@@ -2430,19 +2430,19 @@ static void ic4_shutdown(struct uart_port *the_port)
 {
         unsigned long port_flags;
         struct ioc4_port *port;
-        struct uart_info *info;
+        struct uart_state *state;
 
         port = get_ioc4_port(the_port, 0);
         if (!port)
                 return;
 
-        info = the_port->info;
+        state = the_port->state;
         port->ip_port = NULL;
 
-        wake_up_interruptible(&info->delta_msr_wait);
+        wake_up_interruptible(&state->port.delta_msr_wait);
 
-        if (info->port.tty)
-                set_bit(TTY_IO_ERROR, &info->port.tty->flags);
+        if (state->port.tty)
+                set_bit(TTY_IO_ERROR, &state->port.tty->flags);
 
         spin_lock_irqsave(&the_port->lock, port_flags);
         set_notification(port, N_ALL, 0);
@@ -2538,7 +2538,7 @@ static int ic4_startup(struct uart_port *the_port)
         int retval;
         struct ioc4_port *port;
         struct ioc4_control *control;
-        struct uart_info *info;
+        struct uart_state *state;
         unsigned long port_flags;
 
         if (!the_port)
@@ -2546,7 +2546,7 @@ static int ic4_startup(struct uart_port *the_port)
         port = get_ioc4_port(the_port, 1);
         if (!port)
                 return -ENODEV;
-        info = the_port->info;
+        state = the_port->state;
 
         control = port->ip_control;
         if (!control) {
diff --git a/drivers/serial/ip22zilog.c b/drivers/serial/ip22zilog.c
index 0d9acbd0bb70..ebff4a1d4bcc 100644
--- a/drivers/serial/ip22zilog.c
+++ b/drivers/serial/ip22zilog.c
@@ -256,9 +256,9 @@ static struct tty_struct *ip22zilog_receive_chars(struct uart_ip22zilog_port *up
         unsigned int r1;
 
         tty = NULL;
-        if (up->port.info != NULL &&
-            up->port.info->port.tty != NULL)
-                tty = up->port.info->port.tty;
+        if (up->port.state != NULL &&
+            up->port.state->port.tty != NULL)
+                tty = up->port.state->port.tty;
 
         for (;;) {
                 ch = readb(&channel->control);
@@ -354,7 +354,7 @@ static void ip22zilog_status_handle(struct uart_ip22zilog_port *up,
                         uart_handle_cts_change(&up->port,
                                                (status & CTS));
 
-                wake_up_interruptible(&up->port.info->delta_msr_wait);
+                wake_up_interruptible(&up->port.state->port.delta_msr_wait);
         }
 
         up->prev_status = status;
@@ -404,9 +404,9 @@ static void ip22zilog_transmit_chars(struct uart_ip22zilog_port *up,
                 return;
         }
 
-        if (up->port.info == NULL)
+        if (up->port.state == NULL)
                 goto ack_tx_int;
-        xmit = &up->port.info->xmit;
+        xmit = &up->port.state->xmit;
         if (uart_circ_empty(xmit))
                 goto ack_tx_int;
         if (uart_tx_stopped(&up->port))
@@ -607,7 +607,7 @@ static void ip22zilog_start_tx(struct uart_port *port)
                 port->icount.tx++;
                 port->x_char = 0;
         } else {
-                struct circ_buf *xmit = &port->info->xmit;
+                struct circ_buf *xmit = &port->state->xmit;
 
                 writeb(xmit->buf[xmit->tail], &channel->data);
                 ZSDELAY();
diff --git a/drivers/serial/jsm/jsm_neo.c b/drivers/serial/jsm/jsm_neo.c
index 9dadaa11d266..b4b124e4828f 100644
--- a/drivers/serial/jsm/jsm_neo.c
+++ b/drivers/serial/jsm/jsm_neo.c
@@ -989,7 +989,7 @@ static void neo_param(struct jsm_channel *ch)
                         {     50, B50     },
                 };
 
-                cflag = C_BAUD(ch->uart_port.info->port.tty);
+                cflag = C_BAUD(ch->uart_port.state->port.tty);
                 baud = 9600;
                 for (i = 0; i < ARRAY_SIZE(baud_rates); i++) {
                         if (baud_rates[i].cflag == cflag) {
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 00f4577d2f7f..7439c0373620 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -147,7 +147,7 @@ static void jsm_tty_send_xchar(struct uart_port *port, char ch)
         struct ktermios *termios;
 
         spin_lock_irqsave(&port->lock, lock_flags);
-        termios = port->info->port.tty->termios;
+        termios = port->state->port.tty->termios;
         if (ch == termios->c_cc[VSTART])
                 channel->ch_bd->bd_ops->send_start_character(channel);
 
@@ -245,7 +245,7 @@ static int jsm_tty_open(struct uart_port *port)
         channel->ch_cached_lsr = 0;
         channel->ch_stops_sent = 0;
 
-        termios = port->info->port.tty->termios;
+        termios = port->state->port.tty->termios;
         channel->ch_c_cflag     = termios->c_cflag;
         channel->ch_c_iflag     = termios->c_iflag;
         channel->ch_c_oflag     = termios->c_oflag;
@@ -278,7 +278,7 @@ static void jsm_tty_close(struct uart_port *port)
         jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
 
         bd = channel->ch_bd;
-        ts = port->info->port.tty->termios;
+        ts = port->state->port.tty->termios;
 
         channel->ch_flags &= ~(CH_STOPI);
 
@@ -530,7 +530,7 @@ void jsm_input(struct jsm_channel *ch)
         if (!ch)
                 return;
 
-        tp = ch->uart_port.info->port.tty;
+        tp = ch->uart_port.state->port.tty;
 
         bd = ch->ch_bd;
         if(!bd)
@@ -849,7 +849,7 @@ int jsm_tty_write(struct uart_port *port)
         u16 tail;
         u16 tmask;
         u32 remain;
-        int temp_tail = port->info->xmit.tail;
+        int temp_tail = port->state->xmit.tail;
         struct jsm_channel *channel = (struct jsm_channel *)port;
 
         tmask = WQUEUEMASK;
@@ -865,10 +865,10 @@ int jsm_tty_write(struct uart_port *port)
         data_count = 0;
         if (bufcount >= remain) {
                 bufcount -= remain;
-                while ((port->info->xmit.head != temp_tail) &&
+                while ((port->state->xmit.head != temp_tail) &&
                 (data_count < remain)) {
                         channel->ch_wqueue[head++] =
-                        port->info->xmit.buf[temp_tail];
+                        port->state->xmit.buf[temp_tail];
 
                         temp_tail++;
                         temp_tail &= (UART_XMIT_SIZE - 1);
@@ -880,10 +880,10 @@ int jsm_tty_write(struct uart_port *port)
         data_count1 = 0;
         if (bufcount > 0) {
                 remain = bufcount;
-                while ((port->info->xmit.head != temp_tail) &&
+                while ((port->state->xmit.head != temp_tail) &&
                         (data_count1 < remain)) {
                         channel->ch_wqueue[head++] =
-                                port->info->xmit.buf[temp_tail];
+                                port->state->xmit.buf[temp_tail];
 
                         temp_tail++;
                         temp_tail &= (UART_XMIT_SIZE - 1);
@@ -892,7 +892,7 @@ int jsm_tty_write(struct uart_port *port)
                 }
         }
 
-        port->info->xmit.tail = temp_tail;
+        port->state->xmit.tail = temp_tail;
 
         data_count += data_count1;
         if (data_count) {
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index 611c97a15654..bea5c215460c 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -286,7 +286,7 @@ static void m32r_sio_start_tx(struct uart_port *port)
 {
 #ifdef CONFIG_SERIAL_M32R_PLDSIO
         struct uart_sio_port *up = (struct uart_sio_port *)port;
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
 
         if (!(up->ier & UART_IER_THRI)) {
                 up->ier |= UART_IER_THRI;
@@ -325,7 +325,7 @@ static void m32r_sio_enable_ms(struct uart_port *port)
 
 static void receive_chars(struct uart_sio_port *up, int *status)
 {
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned char ch;
         unsigned char flag;
         int max_count = 256;
@@ -398,7 +398,7 @@ static void receive_chars(struct uart_sio_port *up, int *status)
 
 static void transmit_chars(struct uart_sio_port *up)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int count;
 
         if (up->port.x_char) {
diff --git a/drivers/serial/max3100.c b/drivers/serial/max3100.c
index 9fd33e5622bd..75ab00631c41 100644
--- a/drivers/serial/max3100.c
+++ b/drivers/serial/max3100.c
@@ -184,7 +184,7 @@ static void max3100_timeout(unsigned long data)
 {
         struct max3100_port *s = (struct max3100_port *)data;
 
-        if (s->port.info) {
+        if (s->port.state) {
                 max3100_dowork(s);
                 mod_timer(&s->timer, jiffies + s->poll_time);
         }
@@ -261,7 +261,7 @@ static void max3100_work(struct work_struct *w)
         int rxchars;
         u16 tx, rx;
         int conf, cconf, rts, crts;
-        struct circ_buf *xmit = &s->port.info->xmit;
+        struct circ_buf *xmit = &s->port.state->xmit;
 
         dev_dbg(&s->spi->dev, "%s\n", __func__);
 
@@ -307,8 +307,8 @@ static void max3100_work(struct work_struct *w)
                         }
                 }
 
-                if (rxchars > 16 && s->port.info->port.tty != NULL) {
-                        tty_flip_buffer_push(s->port.info->port.tty);
+                if (rxchars > 16 && s->port.state->port.tty != NULL) {
+                        tty_flip_buffer_push(s->port.state->port.tty);
                         rxchars = 0;
                 }
                 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
@@ -320,8 +320,8 @@ static void max3100_work(struct work_struct *w)
                   (!uart_circ_empty(xmit) &&
                    !uart_tx_stopped(&s->port))));
 
-        if (rxchars > 0 && s->port.info->port.tty != NULL)
-                tty_flip_buffer_push(s->port.info->port.tty);
+        if (rxchars > 0 && s->port.state->port.tty != NULL)
+                tty_flip_buffer_push(s->port.state->port.tty);
 }
 
 static irqreturn_t max3100_irq(int irqno, void *dev_id)
@@ -429,7 +429,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
         int baud = 0;
         unsigned cflag;
         u32 param_new, param_mask, parity = 0;
-        struct tty_struct *tty = s->port.info->port.tty;
+        struct tty_struct *tty = s->port.state->port.tty;
 
         dev_dbg(&s->spi->dev, "%s\n", __func__);
         if (!tty)
@@ -529,7 +529,7 @@ max3100_set_termios(struct uart_port *port, struct ktermios *termios,
                         MAX3100_STATUS_OE;
 
         /* we are sending char from a workqueue so enable */
-        s->port.info->port.tty->low_latency = 1;
+        s->port.state->port.tty->low_latency = 1;
 
         if (s->poll_time > 0)
                 del_timer_sync(&s->timer);
diff --git a/drivers/serial/mcf.c b/drivers/serial/mcf.c
index 0eefb07bebaf..b44382442bf1 100644
--- a/drivers/serial/mcf.c
+++ b/drivers/serial/mcf.c
@@ -323,7 +323,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
                 uart_insert_char(port, status, MCFUART_USR_RXOVERRUN, ch, flag);
         }
 
-        tty_flip_buffer_push(port->info->port.tty);
+        tty_flip_buffer_push(port->state->port.tty);
 }
 
 /****************************************************************************/
@@ -331,7 +331,7 @@ static void mcf_rx_chars(struct mcf_uart *pp)
 static void mcf_tx_chars(struct mcf_uart *pp)
 {
         struct uart_port *port = &pp->port;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         if (port->x_char) {
                 /* Send special char - probably flow control */
diff --git a/drivers/serial/mpc52xx_uart.c b/drivers/serial/mpc52xx_uart.c
index abbd146c50d9..d7bcd074d383 100644
--- a/drivers/serial/mpc52xx_uart.c
+++ b/drivers/serial/mpc52xx_uart.c
@@ -745,7 +745,7 @@ static struct uart_ops mpc52xx_uart_ops = {
 static inline int
 mpc52xx_uart_int_rx_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned char ch, flag;
         unsigned short status;
 
@@ -812,7 +812,7 @@ mpc52xx_uart_int_rx_chars(struct uart_port *port)
 static inline int
 mpc52xx_uart_int_tx_chars(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         /* Process out of band chars */
         if (port->x_char) {
diff --git a/drivers/serial/mpsc.c b/drivers/serial/mpsc.c
index 61d3ade5286c..b5496c28e60b 100644
--- a/drivers/serial/mpsc.c
+++ b/drivers/serial/mpsc.c
@@ -936,7 +936,7 @@ static int serial_polled;
 static int mpsc_rx_intr(struct mpsc_port_info *pi)
 {
         struct mpsc_rx_desc *rxre;
-        struct tty_struct *tty = pi->port.info->port.tty;
+        struct tty_struct *tty = pi->port.state->port.tty;
         u32     cmdstat, bytes_in, i;
         int     rc = 0;
         u8      *bp;
@@ -1109,7 +1109,7 @@ static void mpsc_setup_tx_desc(struct mpsc_port_info *pi, u32 count, u32 intr)
 
 static void mpsc_copy_tx_data(struct mpsc_port_info *pi)
 {
-        struct circ_buf *xmit = &pi->port.info->xmit;
+        struct circ_buf *xmit = &pi->port.state->xmit;
         u8 *bp;
         u32 i;
 
diff --git a/drivers/serial/msm_serial.c b/drivers/serial/msm_serial.c
index f7c24baa1416..b05c5aa02cb4 100644
--- a/drivers/serial/msm_serial.c
+++ b/drivers/serial/msm_serial.c
@@ -88,7 +88,7 @@ static void msm_enable_ms(struct uart_port *port)
 
 static void handle_rx(struct uart_port *port)
 {
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned int sr;
 
         /*
@@ -136,7 +136,7 @@ static void handle_rx(struct uart_port *port)
 
 static void handle_tx(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         struct msm_port *msm_port = UART_TO_MSM(port);
         int sent_tx;
 
@@ -169,7 +169,7 @@ static void handle_delta_cts(struct uart_port *port)
 {
         msm_write(port, UART_CR_CMD_RESET_CTS, UART_CR);
         port->icount.cts++;
-        wake_up_interruptible(&port->info->delta_msr_wait);
+        wake_up_interruptible(&port->state->port.delta_msr_wait);
 }
 
 static irqreturn_t msm_irq(int irq, void *dev_id)
diff --git a/drivers/serial/mux.c b/drivers/serial/mux.c
index 953a5ffa9b44..7571aaa138b0 100644
--- a/drivers/serial/mux.c
+++ b/drivers/serial/mux.c
@@ -199,7 +199,7 @@ static void mux_break_ctl(struct uart_port *port, int break_state)
 static void mux_write(struct uart_port *port)
 {
         int count;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         if(port->x_char) {
                 UART_PUT_CHAR(port, port->x_char);
@@ -243,7 +243,7 @@ static void mux_write(struct uart_port *port)
 static void mux_read(struct uart_port *port)
 {
         int data;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         __u32 start_count = port->icount.rx;
 
         while(1) {
diff --git a/drivers/serial/netx-serial.c b/drivers/serial/netx-serial.c
index 3e5dda8518b7..7735c9f35fa0 100644
--- a/drivers/serial/netx-serial.c
+++ b/drivers/serial/netx-serial.c
@@ -140,7 +140,7 @@ static void netx_enable_ms(struct uart_port *port)
 
 static inline void netx_transmit_buffer(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         if (port->x_char) {
                 writel(port->x_char, port->membase + UART_DR);
@@ -185,7 +185,7 @@ static unsigned int netx_tx_empty(struct uart_port *port)
 
 static void netx_txint(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
                 netx_stop_tx(port);
@@ -201,7 +201,7 @@ static void netx_txint(struct uart_port *port)
 static void netx_rxint(struct uart_port *port)
 {
         unsigned char rx, flg, status;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
 
         while (!(readl(port->membase + UART_FR) & FR_RXFE)) {
                 rx = readl(port->membase + UART_DR);
diff --git a/drivers/serial/nwpserial.c b/drivers/serial/nwpserial.c
index 9e150b19d726..e1ab8ec0a4a6 100644
--- a/drivers/serial/nwpserial.c
+++ b/drivers/serial/nwpserial.c
@@ -126,7 +126,7 @@ static void nwpserial_config_port(struct uart_port *port, int flags)
 static irqreturn_t nwpserial_interrupt(int irq, void *dev_id)
 {
         struct nwpserial_port *up = dev_id;
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         irqreturn_t ret;
         unsigned int iir;
         unsigned char ch;
@@ -261,7 +261,7 @@ static void nwpserial_start_tx(struct uart_port *port)
         struct nwpserial_port *up;
         struct circ_buf *xmit;
         up = container_of(port, struct nwpserial_port, port);
-        xmit  = &up->port.info->xmit;
+        xmit  = &up->port.state->xmit;
 
         if (port->x_char) {
                 nwpserial_putchar(up, up->port.x_char);
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 9c1243fbd512..0700cd10b97c 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -242,12 +242,12 @@ static struct tty_struct *pmz_receive_chars(struct uart_pmac_port *uap)
         }
 
         /* Sanity check, make sure the old bug is no longer happening */
-        if (uap->port.info == NULL || uap->port.info->port.tty == NULL) {
+        if (uap->port.state == NULL || uap->port.state->port.tty == NULL) {
                 WARN_ON(1);
                 (void)read_zsdata(uap);
                 return NULL;
         }
-        tty = uap->port.info->port.tty;
+        tty = uap->port.state->port.tty;
 
         while (1) {
                 error = 0;
@@ -369,7 +369,7 @@ static void pmz_status_handle(struct uart_pmac_port *uap)
                         uart_handle_cts_change(&uap->port,
                                                !(status & CTS));
 
-                wake_up_interruptible(&uap->port.info->delta_msr_wait);
+                wake_up_interruptible(&uap->port.state->port.delta_msr_wait);
         }
 
         if (status & BRK_ABRT)
@@ -420,9 +420,9 @@ static void pmz_transmit_chars(struct uart_pmac_port *uap)
                 return;
         }
 
-        if (uap->port.info == NULL)
+        if (uap->port.state == NULL)
                 goto ack_tx_int;
-        xmit = &uap->port.info->xmit;
+        xmit = &uap->port.state->xmit;
         if (uart_circ_empty(xmit)) {
                 uart_write_wakeup(&uap->port);
                 goto ack_tx_int;
@@ -655,7 +655,7 @@ static void pmz_start_tx(struct uart_port *port)
                 port->icount.tx++;
                 port->x_char = 0;
         } else {
-                struct circ_buf *xmit = &port->info->xmit;
+                struct circ_buf *xmit = &port->state->xmit;
 
                 write_zsdata(uap, xmit->buf[xmit->tail]);
                 zssync(uap);
@@ -1645,7 +1645,7 @@ static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
         state = pmz_uart_reg.state + uap->port.line;
 
         mutex_lock(&pmz_irq_mutex);
-        mutex_lock(&state->mutex);
+        mutex_lock(&state->port.mutex);
 
         spin_lock_irqsave(&uap->port.lock, flags);
 
@@ -1676,7 +1676,7 @@ static int pmz_suspend(struct macio_dev *mdev, pm_message_t pm_state)
         /* Shut the chip down */
         pmz_set_scc_power(uap, 0);
 
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&state->port.mutex);
         mutex_unlock(&pmz_irq_mutex);
 
         pmz_debug("suspend, switching complete\n");
@@ -1705,7 +1705,7 @@ static int pmz_resume(struct macio_dev *mdev)
         state = pmz_uart_reg.state + uap->port.line;
 
         mutex_lock(&pmz_irq_mutex);
-        mutex_lock(&state->mutex);
+        mutex_lock(&state->port.mutex);
 
         spin_lock_irqsave(&uap->port.lock, flags);
         if (!ZS_IS_OPEN(uap) && !ZS_IS_CONS(uap)) {
@@ -1737,7 +1737,7 @@ static int pmz_resume(struct macio_dev *mdev)
         }
 
  bail:
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&state->port.mutex);
         mutex_unlock(&pmz_irq_mutex);
 
         /* Right now, we deal with delay by blocking here, I'll be
diff --git a/drivers/serial/pnx8xxx_uart.c b/drivers/serial/pnx8xxx_uart.c
index 1bb8f1b45767..0aa75a97531c 100644
--- a/drivers/serial/pnx8xxx_uart.c
+++ b/drivers/serial/pnx8xxx_uart.c
@@ -100,7 +100,7 @@ static void pnx8xxx_mctrl_check(struct pnx8xxx_port *sport)
         if (changed & TIOCM_CTS)
                 uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
 
-        wake_up_interruptible(&sport->port.info->delta_msr_wait);
+        wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
 }
 
 /*
@@ -112,7 +112,7 @@ static void pnx8xxx_timeout(unsigned long data)
         struct pnx8xxx_port *sport = (struct pnx8xxx_port *)data;
         unsigned long flags;
 
-        if (sport->port.info) {
+        if (sport->port.state) {
                 spin_lock_irqsave(&sport->port.lock, flags);
                 pnx8xxx_mctrl_check(sport);
                 spin_unlock_irqrestore(&sport->port.lock, flags);
@@ -181,7 +181,7 @@ static void pnx8xxx_enable_ms(struct uart_port *port)
 
 static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
 {
-        struct tty_struct *tty = sport->port.info->port.tty;
+        struct tty_struct *tty = sport->port.state->port.tty;
         unsigned int status, ch, flg;
 
         status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
@@ -243,7 +243,7 @@ static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
 
 static void pnx8xxx_tx_chars(struct pnx8xxx_port *sport)
 {
-        struct circ_buf *xmit = &sport->port.info->xmit;
+        struct circ_buf *xmit = &sport->port.state->xmit;
 
         if (sport->port.x_char) {
                 serial_out(sport, PNX8XXX_FIFO, sport->port.x_char);
diff --git a/drivers/serial/pxa.c b/drivers/serial/pxa.c
index a48a8a13d87b..6443b7ff274a 100644
--- a/drivers/serial/pxa.c
+++ b/drivers/serial/pxa.c
@@ -96,7 +96,7 @@ static void serial_pxa_stop_rx(struct uart_port *port)
 
 static inline void receive_chars(struct uart_pxa_port *up, int *status)
 {
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned int ch, flag;
         int max_count = 256;
 
@@ -161,7 +161,7 @@ static inline void receive_chars(struct uart_pxa_port *up, int *status)
 
 static void transmit_chars(struct uart_pxa_port *up)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int count;
 
         if (up->port.x_char) {
@@ -220,7 +220,7 @@ static inline void check_modem_status(struct uart_pxa_port *up)
         if (status & UART_MSR_DCTS)
                 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
 
-        wake_up_interruptible(&up->port.info->delta_msr_wait);
+        wake_up_interruptible(&up->port.state->port.delta_msr_wait);
 }
 
 /*
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c
index 94530f01521e..7f5e26873220 100644
--- a/drivers/serial/sa1100.c
+++ b/drivers/serial/sa1100.c
@@ -117,7 +117,7 @@ static void sa1100_mctrl_check(struct sa1100_port *sport)
         if (changed & TIOCM_CTS)
                 uart_handle_cts_change(&sport->port, status & TIOCM_CTS);
 
-        wake_up_interruptible(&sport->port.info->delta_msr_wait);
+        wake_up_interruptible(&sport->port.state->port.delta_msr_wait);
 }
 
 /*
@@ -129,7 +129,7 @@ static void sa1100_timeout(unsigned long data)
         struct sa1100_port *sport = (struct sa1100_port *)data;
         unsigned long flags;
 
-        if (sport->port.info) {
+        if (sport->port.state) {
                 spin_lock_irqsave(&sport->port.lock, flags);
                 sa1100_mctrl_check(sport);
                 spin_unlock_irqrestore(&sport->port.lock, flags);
@@ -189,7 +189,7 @@ static void sa1100_enable_ms(struct uart_port *port)
 static void
 sa1100_rx_chars(struct sa1100_port *sport)
 {
-        struct tty_struct *tty = sport->port.info->port.tty;
+        struct tty_struct *tty = sport->port.state->port.tty;
         unsigned int status, ch, flg;
 
         status = UTSR1_TO_SM(UART_GET_UTSR1(sport)) |
@@ -239,7 +239,7 @@ sa1100_rx_chars(struct sa1100_port *sport)
 
 static void sa1100_tx_chars(struct sa1100_port *sport)
 {
-        struct circ_buf *xmit = &sport->port.info->xmit;
+        struct circ_buf *xmit = &sport->port.state->xmit;
 
         if (sport->port.x_char) {
                 UART_PUT_CHAR(sport, sport->port.x_char);
diff --git a/drivers/serial/samsung.c b/drivers/serial/samsung.c
index c8851a0db63a..1523e8d9ae77 100644
--- a/drivers/serial/samsung.c
+++ b/drivers/serial/samsung.c
@@ -196,7 +196,7 @@ s3c24xx_serial_rx_chars(int irq, void *dev_id)
 {
         struct s3c24xx_uart_port *ourport = dev_id;
         struct uart_port *port = &ourport->port;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned int ufcon, ch, flag, ufstat, uerstat;
         int max_count = 64;
 
@@ -281,7 +281,7 @@ static irqreturn_t s3c24xx_serial_tx_chars(int irq, void *id)
 {
         struct s3c24xx_uart_port *ourport = id;
         struct uart_port *port = &ourport->port;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         int count = 256;
 
         if (port->x_char) {
@@ -992,10 +992,10 @@ static int s3c24xx_serial_cpufreq_transition(struct notifier_block *nb,
                 struct ktermios *termios;
                 struct tty_struct *tty;
 
-                if (uport->info == NULL)
+                if (uport->state == NULL)
                         goto exit;
 
-                tty = uport->info->port.tty;
+                tty = uport->state->port.tty;
 
                 if (tty == NULL)
                         goto exit;
diff --git a/drivers/serial/sb1250-duart.c b/drivers/serial/sb1250-duart.c
index 319e8b83f6be..a2f2b3254499 100644
--- a/drivers/serial/sb1250-duart.c
+++ b/drivers/serial/sb1250-duart.c
@@ -384,13 +384,13 @@ static void sbd_receive_chars(struct sbd_port *sport)
                 uart_insert_char(uport, status, M_DUART_OVRUN_ERR, ch, flag);
         }
 
-        tty_flip_buffer_push(uport->info->port.tty);
+        tty_flip_buffer_push(uport->state->port.tty);
 }
 
 static void sbd_transmit_chars(struct sbd_port *sport)
 {
         struct uart_port *uport = &sport->port;
-        struct circ_buf *xmit = &sport->port.info->xmit;
+        struct circ_buf *xmit = &sport->port.state->xmit;
         unsigned int mask;
         int stop_tx;
 
@@ -440,7 +440,7 @@ static void sbd_status_handle(struct sbd_port *sport)
 
         if (delta & ((M_DUART_IN_PIN2_VAL | M_DUART_IN_PIN0_VAL) <<
                      S_DUART_IN_PIN_CHNG))
-                wake_up_interruptible(&uport->info->delta_msr_wait);
+                wake_up_interruptible(&uport->state->port.delta_msr_wait);
 }
 
 static irqreturn_t sbd_interrupt(int irq, void *dev_id)
diff --git a/drivers/serial/sc26xx.c b/drivers/serial/sc26xx.c
index e0be11ceaa25..75038ad2b242 100644
--- a/drivers/serial/sc26xx.c
+++ b/drivers/serial/sc26xx.c
@@ -140,8 +140,8 @@ static struct tty_struct *receive_chars(struct uart_port *port)
         char flag;
         u8 status;
 
-        if (port->info != NULL)         /* Unopened serial console */
-                tty = port->info->port.tty;
+        if (port->state != NULL)                /* Unopened serial console */
+                tty = port->state->port.tty;
 
         while (limit-- > 0) {
                 status = READ_SC_PORT(port, SR);
@@ -190,10 +190,10 @@ static void transmit_chars(struct uart_port *port)
 {
         struct circ_buf *xmit;
 
-        if (!port->info)
+        if (!port->state)
                 return;
 
-        xmit = &port->info->xmit;
+        xmit = &port->state->xmit;
         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
                 sc26xx_disable_irq(port, IMR_TXRDY);
                 return;
@@ -316,7 +316,7 @@ static void sc26xx_stop_tx(struct uart_port *port)
 /* port->lock held by caller.  */
 static void sc26xx_start_tx(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         while (!uart_circ_empty(xmit)) {
                 if (!(READ_SC_PORT(port, SR) & SR_TXRDY)) {
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index b0bb29d804ae..2514d00c0f6f 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -29,10 +29,10 @@
 #include <linux/console.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
-#include <linux/serial_core.h>
 #include <linux/smp_lock.h>
 #include <linux/device.h>
 #include <linux/serial.h> /* for serial_state and serial_icounter_struct */
+#include <linux/serial_core.h>
 #include <linux/delay.h>
 #include <linux/mutex.h>
 
@@ -52,8 +52,6 @@ static struct lock_class_key port_lock_key;
 
 #define HIGH_BITS_OFFSET        ((sizeof(long)-sizeof(int))*8)
 
-#define uart_users(state)       ((state)->count + (state)->info.port.blocked_open)
-
 #ifdef CONFIG_SERIAL_CORE_CONSOLE
 #define uart_console(port)      ((port)->cons && (port)->cons->index == (port)->line)
 #else
@@ -71,19 +69,19 @@ static void uart_change_pm(struct uart_state *state, int pm_state);
  */
 void uart_write_wakeup(struct uart_port *port)
 {
-        struct uart_info *info = port->info;
+        struct uart_state *state = port->state;
         /*
          * This means you called this function _after_ the port was
          * closed.  No cookie for you.
          */
-        BUG_ON(!info);
-        tasklet_schedule(&info->tlet);
+        BUG_ON(!state);
+        tasklet_schedule(&state->tlet);
 }
 
 static void uart_stop(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
         unsigned long flags;
 
         spin_lock_irqsave(&port->lock, flags);
@@ -94,9 +92,9 @@ static void uart_stop(struct tty_struct *tty)
 static void __uart_start(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
 
-        if (!uart_circ_empty(&state->info.xmit) && state->info.xmit.buf &&
+        if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
             !tty->stopped && !tty->hw_stopped)
                 port->ops->start_tx(port);
 }
@@ -104,7 +102,7 @@ static void __uart_start(struct tty_struct *tty)
 static void uart_start(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
         unsigned long flags;
 
         spin_lock_irqsave(&port->lock, flags);
@@ -115,7 +113,7 @@ static void uart_start(struct tty_struct *tty)
 static void uart_tasklet_action(unsigned long data)
 {
         struct uart_state *state = (struct uart_state *)data;
-        tty_wakeup(state->info.port.tty);
+        tty_wakeup(state->port.tty);
 }
 
 static inline void
@@ -141,12 +139,12 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
  */
 static int uart_startup(struct uart_state *state, int init_hw)
 {
-        struct uart_info *info = &state->info;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         unsigned long page;
         int retval = 0;
 
-        if (info->flags & UIF_INITIALIZED)
+        if (port->flags & ASYNC_INITIALIZED)
                 return 0;
 
         /*
@@ -154,26 +152,26 @@ static int uart_startup(struct uart_state *state, int init_hw)
          * once we have successfully opened the port.  Also set
          * up the tty->alt_speed kludge
          */
-        set_bit(TTY_IO_ERROR, &info->port.tty->flags);
+        set_bit(TTY_IO_ERROR, &port->tty->flags);
 
-        if (port->type == PORT_UNKNOWN)
+        if (uport->type == PORT_UNKNOWN)
                 return 0;
 
         /*
          * Initialise and allocate the transmit and temporary
          * buffer.
          */
-        if (!info->xmit.buf) {
+        if (!state->xmit.buf) {
                 /* This is protected by the per port mutex */
                 page = get_zeroed_page(GFP_KERNEL);
                 if (!page)
                         return -ENOMEM;
 
-                info->xmit.buf = (unsigned char *) page;
-                uart_circ_clear(&info->xmit);
+                state->xmit.buf = (unsigned char *) page;
+                uart_circ_clear(&state->xmit);
         }
 
-        retval = port->ops->startup(port);
+        retval = uport->ops->startup(uport);
         if (retval == 0) {
                 if (init_hw) {
                         /*
@@ -185,20 +183,20 @@ static int uart_startup(struct uart_state *state, int init_hw)
                          * Setup the RTS and DTR signals once the
                          * port is open and ready to respond.
                          */
-                        if (info->port.tty->termios->c_cflag & CBAUD)
-                                uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
+                        if (port->tty->termios->c_cflag & CBAUD)
+                                uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
                 }
 
-                if (info->flags & UIF_CTS_FLOW) {
-                        spin_lock_irq(&port->lock);
-                        if (!(port->ops->get_mctrl(port) & TIOCM_CTS))
-                                info->port.tty->hw_stopped = 1;
-                        spin_unlock_irq(&port->lock);
+                if (port->flags & ASYNC_CTS_FLOW) {
+                        spin_lock_irq(&uport->lock);
+                        if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS))
+                                port->tty->hw_stopped = 1;
+                        spin_unlock_irq(&uport->lock);
                 }
 
-                info->flags |= UIF_INITIALIZED;
+                set_bit(ASYNCB_INITIALIZED, &port->flags);
 
-                clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
+                clear_bit(TTY_IO_ERROR, &port->tty->flags);
         }
 
         if (retval && capable(CAP_SYS_ADMIN))
@@ -214,9 +212,9 @@ static int uart_startup(struct uart_state *state, int init_hw)
  */
 static void uart_shutdown(struct uart_state *state)
 {
-        struct uart_info *info = &state->info;
-        struct uart_port *port = state->port;
-        struct tty_struct *tty = info->port.tty;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
+        struct tty_struct *tty = port->tty;
 
         /*
          * Set the TTY IO error marker
@@ -224,14 +222,12 @@ static void uart_shutdown(struct uart_state *state)
         if (tty)
                 set_bit(TTY_IO_ERROR, &tty->flags);
 
-        if (info->flags & UIF_INITIALIZED) {
-                info->flags &= ~UIF_INITIALIZED;
-
+        if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
                 /*
                  * Turn off DTR and RTS early.
                  */
                 if (!tty || (tty->termios->c_cflag & HUPCL))
-                        uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
+                        uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
 
                 /*
                  * clear delta_msr_wait queue to avoid mem leaks: we may free
@@ -240,30 +236,30 @@ static void uart_shutdown(struct uart_state *state)
                  * any outstanding file descriptors should be pointing at
                  * hung_up_tty_fops now.
                  */
-                wake_up_interruptible(&info->delta_msr_wait);
+                wake_up_interruptible(&port->delta_msr_wait);
 
                 /*
                  * Free the IRQ and disable the port.
                  */
-                port->ops->shutdown(port);
+                uport->ops->shutdown(uport);
 
                 /*
                  * Ensure that the IRQ handler isn't running on another CPU.
                  */
-                synchronize_irq(port->irq);
+                synchronize_irq(uport->irq);
         }
 
         /*
          * kill off our tasklet
          */
-        tasklet_kill(&info->tlet);
+        tasklet_kill(&state->tlet);
 
         /*
          * Free the transmit buffer page.
          */
-        if (info->xmit.buf) {
-                free_page((unsigned long)info->xmit.buf);
-                info->xmit.buf = NULL;
+        if (state->xmit.buf) {
+                free_page((unsigned long)state->xmit.buf);
+                state->xmit.buf = NULL;
         }
 }
 
@@ -430,15 +426,16 @@ EXPORT_SYMBOL(uart_get_divisor);
 static void
 uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
 {
-        struct tty_struct *tty = state->info.port.tty;
-        struct uart_port *port = state->port;
+        struct tty_port *port = &state->port;
+        struct tty_struct *tty = port->tty;
+        struct uart_port *uport = state->uart_port;
         struct ktermios *termios;
 
         /*
          * If we have no tty, termios, or the port does not exist,
          * then we can't set the parameters for this port.
          */
-        if (!tty || !tty->termios || port->type == PORT_UNKNOWN)
+        if (!tty || !tty->termios || uport->type == PORT_UNKNOWN)
                 return;
 
         termios = tty->termios;
@@ -447,16 +444,16 @@ uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
          * Set flags based on termios cflag
          */
         if (termios->c_cflag & CRTSCTS)
-                state->info.flags |= UIF_CTS_FLOW;
+                set_bit(ASYNCB_CTS_FLOW, &port->flags);
         else
-                state->info.flags &= ~UIF_CTS_FLOW;
+                clear_bit(ASYNCB_CTS_FLOW, &port->flags);
 
         if (termios->c_cflag & CLOCAL)
-                state->info.flags &= ~UIF_CHECK_CD;
+                clear_bit(ASYNCB_CHECK_CD, &port->flags);
         else
-                state->info.flags |= UIF_CHECK_CD;
+                set_bit(ASYNCB_CHECK_CD, &port->flags);
 
-        port->ops->set_termios(port, termios, old_termios);
+        uport->ops->set_termios(uport, termios, old_termios);
 }
 
 static inline int
@@ -482,7 +479,7 @@ static int uart_put_char(struct tty_struct *tty, unsigned char ch)
 {
         struct uart_state *state = tty->driver_data;
 
-        return __uart_put_char(state->port, &state->info.xmit, ch);
+        return __uart_put_char(state->uart_port, &state->xmit, ch);
 }
 
 static void uart_flush_chars(struct tty_struct *tty)
@@ -508,8 +505,8 @@ uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
                 return -EL3HLT;
         }
 
-        port = state->port;
-        circ = &state->info.xmit;
+        port = state->uart_port;
+        circ = &state->xmit;
 
         if (!circ->buf)
                 return 0;
@@ -539,9 +536,9 @@ static int uart_write_room(struct tty_struct *tty)
         unsigned long flags;
         int ret;
 
-        spin_lock_irqsave(&state->port->lock, flags);
-        ret = uart_circ_chars_free(&state->info.xmit);
-        spin_unlock_irqrestore(&state->port->lock, flags);
+        spin_lock_irqsave(&state->uart_port->lock, flags);
+        ret = uart_circ_chars_free(&state->xmit);
+        spin_unlock_irqrestore(&state->uart_port->lock, flags);
         return ret;
 }
 
@@ -551,9 +548,9 @@ static int uart_chars_in_buffer(struct tty_struct *tty)
         unsigned long flags;
         int ret;
 
-        spin_lock_irqsave(&state->port->lock, flags);
-        ret = uart_circ_chars_pending(&state->info.xmit);
-        spin_unlock_irqrestore(&state->port->lock, flags);
+        spin_lock_irqsave(&state->uart_port->lock, flags);
+        ret = uart_circ_chars_pending(&state->xmit);
+        spin_unlock_irqrestore(&state->uart_port->lock, flags);
         return ret;
 }
 
@@ -572,11 +569,11 @@ static void uart_flush_buffer(struct tty_struct *tty)
                 return;
         }
 
-        port = state->port;
+        port = state->uart_port;
         pr_debug("uart_flush_buffer(%d) called\n", tty->index);
 
         spin_lock_irqsave(&port->lock, flags);
-        uart_circ_clear(&state->info.xmit);
+        uart_circ_clear(&state->xmit);
         if (port->ops->flush_buffer)
                 port->ops->flush_buffer(port);
         spin_unlock_irqrestore(&port->lock, flags);
@@ -590,7 +587,7 @@ static void uart_flush_buffer(struct tty_struct *tty)
 static void uart_send_xchar(struct tty_struct *tty, char ch)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
         unsigned long flags;
 
         if (port->ops->send_xchar)
@@ -613,13 +610,13 @@ static void uart_throttle(struct tty_struct *tty)
                 uart_send_xchar(tty, STOP_CHAR(tty));
 
         if (tty->termios->c_cflag & CRTSCTS)
-                uart_clear_mctrl(state->port, TIOCM_RTS);
+                uart_clear_mctrl(state->uart_port, TIOCM_RTS);
 }
 
 static void uart_unthrottle(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
 
         if (I_IXOFF(tty)) {
                 if (port->x_char)
@@ -635,35 +632,36 @@ static void uart_unthrottle(struct tty_struct *tty)
 static int uart_get_info(struct uart_state *state,
                          struct serial_struct __user *retinfo)
 {
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         struct serial_struct tmp;
 
         memset(&tmp, 0, sizeof(tmp));
 
         /* Ensure the state we copy is consistent and no hardware changes
            occur as we go */
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
-        tmp.type            = port->type;
-        tmp.line            = port->line;
-        tmp.port            = port->iobase;
+        tmp.type            = uport->type;
+        tmp.line            = uport->line;
+        tmp.port            = uport->iobase;
         if (HIGH_BITS_OFFSET)
-                tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET;
-        tmp.irq             = port->irq;
-        tmp.flags           = port->flags;
-        tmp.xmit_fifo_size  = port->fifosize;
-        tmp.baud_base       = port->uartclk / 16;
-        tmp.close_delay     = state->close_delay / 10;
-        tmp.closing_wait    = state->closing_wait == USF_CLOSING_WAIT_NONE ?
+                tmp.port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
+        tmp.irq             = uport->irq;
+        tmp.flags           = uport->flags;
+        tmp.xmit_fifo_size  = uport->fifosize;
+        tmp.baud_base       = uport->uartclk / 16;
+        tmp.close_delay     = port->close_delay / 10;
+        tmp.closing_wait    = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
                                 ASYNC_CLOSING_WAIT_NONE :
-                                state->closing_wait / 10;
-        tmp.custom_divisor  = port->custom_divisor;
-        tmp.hub6            = port->hub6;
-        tmp.io_type         = port->iotype;
-        tmp.iomem_reg_shift = port->regshift;
-        tmp.iomem_base      = (void *)(unsigned long)port->mapbase;
+                                port->closing_wait / 10;
+        tmp.custom_divisor  = uport->custom_divisor;
+        tmp.hub6            = uport->hub6;
+        tmp.io_type         = uport->iotype;
+        tmp.iomem_reg_shift = uport->regshift;
+        tmp.iomem_base      = (void *)(unsigned long)uport->mapbase;
 
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 
         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
                 return -EFAULT;
@@ -674,7 +672,8 @@ static int uart_set_info(struct uart_state *state,
                          struct serial_struct __user *newinfo)
 {
         struct serial_struct new_serial;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         unsigned long new_port;
         unsigned int change_irq, change_port, closing_wait;
         unsigned int old_custom_divisor, close_delay;
@@ -691,58 +690,58 @@ static int uart_set_info(struct uart_state *state,
         new_serial.irq = irq_canonicalize(new_serial.irq);
         close_delay = new_serial.close_delay * 10;
         closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
-                        USF_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
+                        ASYNC_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
 
         /*
-         * This semaphore protects state->count.  It is also
+         * This semaphore protects port->count.  It is also
          * very useful to prevent opens.  Also, take the
          * port configuration semaphore to make sure that a
          * module insertion/removal doesn't change anything
          * under us.
          */
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
-        change_irq  = !(port->flags & UPF_FIXED_PORT)
-                && new_serial.irq != port->irq;
+        change_irq  = !(uport->flags & UPF_FIXED_PORT)
+                && new_serial.irq != uport->irq;
 
         /*
          * Since changing the 'type' of the port changes its resource
          * allocations, we should treat type changes the same as
          * IO port changes.
          */
-        change_port = !(port->flags & UPF_FIXED_PORT)
-                && (new_port != port->iobase ||
-                    (unsigned long)new_serial.iomem_base != port->mapbase ||
-                    new_serial.hub6 != port->hub6 ||
-                    new_serial.io_type != port->iotype ||
-                    new_serial.iomem_reg_shift != port->regshift ||
-                    new_serial.type != port->type);
-
-        old_flags = port->flags;
+        change_port = !(uport->flags & UPF_FIXED_PORT)
+                && (new_port != uport->iobase ||
+                    (unsigned long)new_serial.iomem_base != uport->mapbase ||
+                    new_serial.hub6 != uport->hub6 ||
+                    new_serial.io_type != uport->iotype ||
+                    new_serial.iomem_reg_shift != uport->regshift ||
+                    new_serial.type != uport->type);
+
+        old_flags = uport->flags;
         new_flags = new_serial.flags;
-        old_custom_divisor = port->custom_divisor;
+        old_custom_divisor = uport->custom_divisor;
 
         if (!capable(CAP_SYS_ADMIN)) {
                 retval = -EPERM;
                 if (change_irq || change_port ||
-                    (new_serial.baud_base != port->uartclk / 16) ||
-                    (close_delay != state->close_delay) ||
-                    (closing_wait != state->closing_wait) ||
+                    (new_serial.baud_base != uport->uartclk / 16) ||
+                    (close_delay != port->close_delay) ||
+                    (closing_wait != port->closing_wait) ||
                     (new_serial.xmit_fifo_size &&
-                     new_serial.xmit_fifo_size != port->fifosize) ||
+                     new_serial.xmit_fifo_size != uport->fifosize) ||
                     (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
                         goto exit;
-                port->flags = ((port->flags & ~UPF_USR_MASK) |
+                uport->flags = ((uport->flags & ~UPF_USR_MASK) |
                                (new_flags & UPF_USR_MASK));
-                port->custom_divisor = new_serial.custom_divisor;
+                uport->custom_divisor = new_serial.custom_divisor;
                 goto check_and_exit;
         }
 
         /*
          * Ask the low level driver to verify the settings.
          */
-        if (port->ops->verify_port)
-                retval = port->ops->verify_port(port, &new_serial);
+        if (uport->ops->verify_port)
+                retval = uport->ops->verify_port(uport, &new_serial);
 
         if ((new_serial.irq >= nr_irqs) || (new_serial.irq < 0) ||
             (new_serial.baud_base < 9600))
@@ -757,7 +756,7 @@ static int uart_set_info(struct uart_state *state,
                 /*
                  * Make sure that we are the sole user of this port.
                  */
-                if (uart_users(state) > 1)
+                if (tty_port_users(port) > 1)
                         goto exit;
 
                 /*
@@ -771,31 +770,31 @@ static int uart_set_info(struct uart_state *state,
                 unsigned long old_iobase, old_mapbase;
                 unsigned int old_type, old_iotype, old_hub6, old_shift;
 
-                old_iobase = port->iobase;
-                old_mapbase = port->mapbase;
-                old_type = port->type;
-                old_hub6 = port->hub6;
-                old_iotype = port->iotype;
-                old_shift = port->regshift;
+                old_iobase = uport->iobase;
+                old_mapbase = uport->mapbase;
+                old_type = uport->type;
+                old_hub6 = uport->hub6;
+                old_iotype = uport->iotype;
+                old_shift = uport->regshift;
 
                 /*
                  * Free and release old regions
                  */
                 if (old_type != PORT_UNKNOWN)
-                        port->ops->release_port(port);
+                        uport->ops->release_port(uport);
 
-                port->iobase = new_port;
-                port->type = new_serial.type;
-                port->hub6 = new_serial.hub6;
-                port->iotype = new_serial.io_type;
-                port->regshift = new_serial.iomem_reg_shift;
-                port->mapbase = (unsigned long)new_serial.iomem_base;
+                uport->iobase = new_port;
+                uport->type = new_serial.type;
+                uport->hub6 = new_serial.hub6;
+                uport->iotype = new_serial.io_type;
+                uport->regshift = new_serial.iomem_reg_shift;
+                uport->mapbase = (unsigned long)new_serial.iomem_base;
 
                 /*
                  * Claim and map the new regions
                  */
-                if (port->type != PORT_UNKNOWN) {
-                        retval = port->ops->request_port(port);
+                if (uport->type != PORT_UNKNOWN) {
+                        retval = uport->ops->request_port(uport);
                 } else {
                         /* Always success - Jean II */
                         retval = 0;
@@ -806,19 +805,19 @@ static int uart_set_info(struct uart_state *state,
                  * new port, try to restore the old settings.
                  */
                 if (retval && old_type != PORT_UNKNOWN) {
-                        port->iobase = old_iobase;
-                        port->type = old_type;
-                        port->hub6 = old_hub6;
-                        port->iotype = old_iotype;
-                        port->regshift = old_shift;
-                        port->mapbase = old_mapbase;
-                        retval = port->ops->request_port(port);
+                        uport->iobase = old_iobase;
+                        uport->type = old_type;
+                        uport->hub6 = old_hub6;
+                        uport->iotype = old_iotype;
+                        uport->regshift = old_shift;
+                        uport->mapbase = old_mapbase;
+                        retval = uport->ops->request_port(uport);
                         /*
                          * If we failed to restore the old settings,
                          * we fail like this.
                          */
                         if (retval)
-                                port->type = PORT_UNKNOWN;
+                                uport->type = PORT_UNKNOWN;
 
                         /*
                          * We failed anyway.
@@ -830,45 +829,45 @@ static int uart_set_info(struct uart_state *state,
         }
 
         if (change_irq)
-                port->irq      = new_serial.irq;
-        if (!(port->flags & UPF_FIXED_PORT))
-                port->uartclk  = new_serial.baud_base * 16;
-        port->flags            = (port->flags & ~UPF_CHANGE_MASK) |
+                uport->irq      = new_serial.irq;
+        if (!(uport->flags & UPF_FIXED_PORT))
+                uport->uartclk  = new_serial.baud_base * 16;
+        uport->flags            = (uport->flags & ~UPF_CHANGE_MASK) |
                                  (new_flags & UPF_CHANGE_MASK);
-        port->custom_divisor   = new_serial.custom_divisor;
-        state->close_delay     = close_delay;
-        state->closing_wait    = closing_wait;
+        uport->custom_divisor   = new_serial.custom_divisor;
+        port->close_delay     = close_delay;
+        port->closing_wait    = closing_wait;
         if (new_serial.xmit_fifo_size)
-                port->fifosize = new_serial.xmit_fifo_size;
-        if (state->info.port.tty)
-                state->info.port.tty->low_latency =
-                        (port->flags & UPF_LOW_LATENCY) ? 1 : 0;
+                uport->fifosize = new_serial.xmit_fifo_size;
+        if (port->tty)
+                port->tty->low_latency =
+                        (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
 
  check_and_exit:
         retval = 0;
-        if (port->type == PORT_UNKNOWN)
+        if (uport->type == PORT_UNKNOWN)
                 goto exit;
-        if (state->info.flags & UIF_INITIALIZED) {
-                if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
-                    old_custom_divisor != port->custom_divisor) {
+        if (port->flags & ASYNC_INITIALIZED) {
+                if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
+                    old_custom_divisor != uport->custom_divisor) {
                         /*
                          * If they're setting up a custom divisor or speed,
                          * instead of clearing it, then bitch about it. No
                          * need to rate-limit; it's CAP_SYS_ADMIN only.
                          */
-                        if (port->flags & UPF_SPD_MASK) {
+                        if (uport->flags & UPF_SPD_MASK) {
                                 char buf[64];
                                 printk(KERN_NOTICE
                                        "%s sets custom speed on %s. This "
                                        "is deprecated.\n", current->comm,
-                                       tty_name(state->info.port.tty, buf));
+                                       tty_name(port->tty, buf));
                         }
                         uart_change_speed(state, NULL);
                 }
         } else
                 retval = uart_startup(state, 1);
  exit:
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
         return retval;
 }
 
@@ -880,10 +879,11 @@ static int uart_set_info(struct uart_state *state,
 static int uart_get_lsr_info(struct uart_state *state,
                              unsigned int __user *value)
 {
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         unsigned int result;
 
-        result = port->ops->tx_empty(port);
+        result = uport->ops->tx_empty(uport);
 
         /*
          * If we're about to load something into the transmit
@@ -891,9 +891,9 @@ static int uart_get_lsr_info(struct uart_state *state,
          * avoid a race condition (depending on when the transmit
          * interrupt happens).
          */
-        if (port->x_char ||
-            ((uart_circ_chars_pending(&state->info.xmit) > 0) &&
-             !state->info.port.tty->stopped && !state->info.port.tty->hw_stopped))
+        if (uport->x_char ||
+            ((uart_circ_chars_pending(&state->xmit) > 0) &&
+             !port->tty->stopped && !port->tty->hw_stopped))
                 result &= ~TIOCSER_TEMT;
 
         return put_user(result, value);
@@ -902,19 +902,20 @@ static int uart_get_lsr_info(struct uart_state *state,
 static int uart_tiocmget(struct tty_struct *tty, struct file *file)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct tty_port *port = &state->port;
+        struct uart_port *uport = state->uart_port;
         int result = -EIO;
 
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
         if ((!file || !tty_hung_up_p(file)) &&
             !(tty->flags & (1 << TTY_IO_ERROR))) {
-                result = port->mctrl;
+                result = uport->mctrl;
 
-                spin_lock_irq(&port->lock);
-                result |= port->ops->get_mctrl(port);
-                spin_unlock_irq(&port->lock);
+                spin_lock_irq(&uport->lock);
+                result |= uport->ops->get_mctrl(uport);
+                spin_unlock_irq(&uport->lock);
         }
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 
         return result;
 }
@@ -924,36 +925,39 @@ uart_tiocmset(struct tty_struct *tty, struct file *file,
               unsigned int set, unsigned int clear)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         int ret = -EIO;
 
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
         if ((!file || !tty_hung_up_p(file)) &&
             !(tty->flags & (1 << TTY_IO_ERROR))) {
-                uart_update_mctrl(port, set, clear);
+                uart_update_mctrl(uport, set, clear);
                 ret = 0;
         }
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
         return ret;
 }
 
 static int uart_break_ctl(struct tty_struct *tty, int break_state)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct tty_port *port = &state->port;
+        struct uart_port *uport = state->uart_port;
 
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
-        if (port->type != PORT_UNKNOWN)
-                port->ops->break_ctl(port, break_state);
+        if (uport->type != PORT_UNKNOWN)
+                uport->ops->break_ctl(uport, break_state);
 
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
         return 0;
 }
 
 static int uart_do_autoconfig(struct uart_state *state)
 {
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         int flags, ret;
 
         if (!capable(CAP_SYS_ADMIN))
@@ -964,33 +968,33 @@ static int uart_do_autoconfig(struct uart_state *state)
          * changing, and hence any extra opens of the port while
          * we're auto-configuring.
          */
-        if (mutex_lock_interruptible(&state->mutex))
+        if (mutex_lock_interruptible(&port->mutex))
                 return -ERESTARTSYS;
 
         ret = -EBUSY;
-        if (uart_users(state) == 1) {
+        if (tty_port_users(port) == 1) {
                 uart_shutdown(state);
 
                 /*
                  * If we already have a port type configured,
                  * we must release its resources.
                  */
-                if (port->type != PORT_UNKNOWN)
-                        port->ops->release_port(port);
+                if (uport->type != PORT_UNKNOWN)
+                        uport->ops->release_port(uport);
 
                 flags = UART_CONFIG_TYPE;
-                if (port->flags & UPF_AUTO_IRQ)
+                if (uport->flags & UPF_AUTO_IRQ)
                         flags |= UART_CONFIG_IRQ;
 
                 /*
                  * This will claim the ports resources if
                  * a port is found.
                  */
-                port->ops->config_port(port, flags);
+                uport->ops->config_port(uport, flags);
 
                 ret = uart_startup(state, 1);
         }
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
         return ret;
 }
 
@@ -999,11 +1003,15 @@ static int uart_do_autoconfig(struct uart_state *state)
  * - mask passed in arg for lines of interest
  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
  * Caller should use TIOCGICOUNT to see which one it was
+ *
+ * FIXME: This wants extracting into a common all driver implementation
+ * of TIOCMWAIT using tty_port.
  */
 static int
 uart_wait_modem_status(struct uart_state *state, unsigned long arg)
 {
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         DECLARE_WAITQUEUE(wait, current);
         struct uart_icount cprev, cnow;
         int ret;
@@ -1011,20 +1019,20 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
         /*
          * note the counters on entry
          */
-        spin_lock_irq(&port->lock);
-        memcpy(&cprev, &port->icount, sizeof(struct uart_icount));
+        spin_lock_irq(&uport->lock);
+        memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
 
         /*
          * Force modem status interrupts on
          */
-        port->ops->enable_ms(port);
-        spin_unlock_irq(&port->lock);
+        uport->ops->enable_ms(uport);
+        spin_unlock_irq(&uport->lock);
 
-        add_wait_queue(&state->info.delta_msr_wait, &wait);
+        add_wait_queue(&port->delta_msr_wait, &wait);
         for (;;) {
-                spin_lock_irq(&port->lock);
-                memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
-                spin_unlock_irq(&port->lock);
+                spin_lock_irq(&uport->lock);
+                memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
+                spin_unlock_irq(&uport->lock);
 
                 set_current_state(TASK_INTERRUPTIBLE);
 
@@ -1048,7 +1056,7 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
         }
 
         current->state = TASK_RUNNING;
-        remove_wait_queue(&state->info.delta_msr_wait, &wait);
+        remove_wait_queue(&port->delta_msr_wait, &wait);
 
         return ret;
 }
@@ -1064,11 +1072,11 @@ static int uart_get_count(struct uart_state *state,
 {
         struct serial_icounter_struct icount;
         struct uart_icount cnow;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
 
-        spin_lock_irq(&port->lock);
-        memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
-        spin_unlock_irq(&port->lock);
+        spin_lock_irq(&uport->lock);
+        memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
+        spin_unlock_irq(&uport->lock);
 
         icount.cts         = cnow.cts;
         icount.dsr         = cnow.dsr;
@@ -1093,6 +1101,7 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
            unsigned long arg)
 {
         struct uart_state *state = tty->driver_data;
+        struct tty_port *port = &state->port;
         void __user *uarg = (void __user *)arg;
         int ret = -ENOIOCTLCMD;
 
@@ -1143,7 +1152,7 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
         if (ret != -ENOIOCTLCMD)
                 goto out;
 
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
         if (tty_hung_up_p(filp)) {
                 ret = -EIO;
@@ -1160,14 +1169,14 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
                 break;
 
         default: {
-                struct uart_port *port = state->port;
-                if (port->ops->ioctl)
-                        ret = port->ops->ioctl(port, cmd, arg);
+                struct uart_port *uport = state->uart_port;
+                if (uport->ops->ioctl)
+                        ret = uport->ops->ioctl(uport, cmd, arg);
                 break;
         }
         }
 out_up:
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 out:
         return ret;
 }
@@ -1175,10 +1184,10 @@ out:
 static void uart_set_ldisc(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
 
-        if (port->ops->set_ldisc)
-                port->ops->set_ldisc(port);
+        if (uport->ops->set_ldisc)
+                uport->ops->set_ldisc(uport);
 }
 
 static void uart_set_termios(struct tty_struct *tty,
@@ -1207,7 +1216,7 @@ static void uart_set_termios(struct tty_struct *tty,
 
         /* Handle transition to B0 status */
         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
-                uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR);
+                uart_clear_mctrl(state->uart_port, TIOCM_RTS | TIOCM_DTR);
 
         /* Handle transition away from B0 status */
         if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
@@ -1215,25 +1224,25 @@ static void uart_set_termios(struct tty_struct *tty,
                 if (!(cflag & CRTSCTS) ||
                     !test_bit(TTY_THROTTLED, &tty->flags))
                         mask |= TIOCM_RTS;
-                uart_set_mctrl(state->port, mask);
+                uart_set_mctrl(state->uart_port, mask);
         }
 
         /* Handle turning off CRTSCTS */
         if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
-                spin_lock_irqsave(&state->port->lock, flags);
+                spin_lock_irqsave(&state->uart_port->lock, flags);
                 tty->hw_stopped = 0;
                 __uart_start(tty);
-                spin_unlock_irqrestore(&state->port->lock, flags);
+                spin_unlock_irqrestore(&state->uart_port->lock, flags);
         }
 
         /* Handle turning on CRTSCTS */
         if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
-                spin_lock_irqsave(&state->port->lock, flags);
-                if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {
+                spin_lock_irqsave(&state->uart_port->lock, flags);
+                if (!(state->uart_port->ops->get_mctrl(state->uart_port) & TIOCM_CTS)) {
                         tty->hw_stopped = 1;
-                        state->port->ops->stop_tx(state->port);
+                        state->uart_port->ops->stop_tx(state->uart_port);
                 }
-                spin_unlock_irqrestore(&state->port->lock, flags);
+                spin_unlock_irqrestore(&state->uart_port->lock, flags);
         }
 #if 0
         /*
@@ -1244,7 +1253,7 @@ static void uart_set_termios(struct tty_struct *tty,
          */
         if (!(old_termios->c_cflag & CLOCAL) &&
             (tty->termios->c_cflag & CLOCAL))
-                wake_up_interruptible(&info->port.open_wait);
+                wake_up_interruptible(&state->uart_port.open_wait);
 #endif
 }
 
@@ -1256,40 +1265,39 @@ static void uart_set_termios(struct tty_struct *tty,
 static void uart_close(struct tty_struct *tty, struct file *filp)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port;
+        struct tty_port *port;
+        struct uart_port *uport;
 
         BUG_ON(!kernel_locked());
 
-        if (!state || !state->port)
-                return;
+        uport = state->uart_port;
+        port = &state->port;
 
-        port = state->port;
+        pr_debug("uart_close(%d) called\n", uport->line);
 
-        pr_debug("uart_close(%d) called\n", port->line);
-
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
         if (tty_hung_up_p(filp))
                 goto done;
 
-        if ((tty->count == 1) && (state->count != 1)) {
+        if ((tty->count == 1) && (port->count != 1)) {
                 /*
                  * Uh, oh.  tty->count is 1, which means that the tty
-                 * structure will be freed.  state->count should always
+                 * structure will be freed.  port->count should always
                  * be one in these conditions.  If it's greater than
                  * one, we've got real problems, since it means the
                  * serial port won't be shutdown.
                  */
                 printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, "
-                       "state->count is %d\n", state->count);
-                state->count = 1;
+                       "port->count is %d\n", port->count);
+                port->count = 1;
         }
-        if (--state->count < 0) {
+        if (--port->count < 0) {
                 printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n",
-                       tty->name, state->count);
-                state->count = 0;
+                       tty->name, port->count);
+                port->count = 0;
         }
-        if (state->count)
+        if (port->count)
                 goto done;
 
         /*
@@ -1299,24 +1307,24 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
          */
         tty->closing = 1;
 
-        if (state->closing_wait != USF_CLOSING_WAIT_NONE)
-                tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait));
+        if (port->closing_wait != ASYNC_CLOSING_WAIT_NONE)
+                tty_wait_until_sent(tty, msecs_to_jiffies(port->closing_wait));
 
         /*
          * At this point, we stop accepting input.  To do this, we
          * disable the receive line status interrupts.
          */
-        if (state->info.flags & UIF_INITIALIZED) {
+        if (port->flags & ASYNC_INITIALIZED) {
                 unsigned long flags;
                 spin_lock_irqsave(&port->lock, flags);
-                port->ops->stop_rx(port);
+                uport->ops->stop_rx(uport);
                 spin_unlock_irqrestore(&port->lock, flags);
                 /*
                  * Before we drop DTR, make sure the UART transmitter
                  * has completely drained; this is especially
                  * important if there is a transmit FIFO!
                  */
-                uart_wait_until_sent(tty, port->timeout);
+                uart_wait_until_sent(tty, uport->timeout);
         }
 
         uart_shutdown(state);
@@ -1325,29 +1333,29 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
         tty_ldisc_flush(tty);
 
         tty->closing = 0;
-        state->info.port.tty = NULL;
+        tty_port_tty_set(port, NULL);
 
-        if (state->info.port.blocked_open) {
-                if (state->close_delay)
-                        msleep_interruptible(state->close_delay);
-        } else if (!uart_console(port)) {
+        if (port->blocked_open) {
+                if (port->close_delay)
+                        msleep_interruptible(port->close_delay);
+        } else if (!uart_console(uport)) {
                 uart_change_pm(state, 3);
         }
 
         /*
          * Wake up anyone trying to open this port.
          */
-        state->info.flags &= ~UIF_NORMAL_ACTIVE;
-        wake_up_interruptible(&state->info.port.open_wait);
+        clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
+        wake_up_interruptible(&port->open_wait);
 
- done:
-        mutex_unlock(&state->mutex);
+done:
+        mutex_unlock(&port->mutex);
 }
 
 static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
         unsigned long char_time, expire;
 
         if (port->type == PORT_UNKNOWN || port->fifosize == 0)
@@ -1412,22 +1420,22 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
 static void uart_hangup(struct tty_struct *tty)
 {
         struct uart_state *state = tty->driver_data;
-        struct uart_info *info = &state->info;
+        struct tty_port *port = &state->port;
 
         BUG_ON(!kernel_locked());
-        pr_debug("uart_hangup(%d)\n", state->port->line);
+        pr_debug("uart_hangup(%d)\n", state->uart_port->line);
 
-        mutex_lock(&state->mutex);
-        if (info->flags & UIF_NORMAL_ACTIVE) {
+        mutex_lock(&port->mutex);
+        if (port->flags & ASYNC_NORMAL_ACTIVE) {
                 uart_flush_buffer(tty);
                 uart_shutdown(state);
-                state->count = 0;
-                info->flags &= ~UIF_NORMAL_ACTIVE;
-                info->port.tty = NULL;
-                wake_up_interruptible(&info->port.open_wait);
-                wake_up_interruptible(&info->delta_msr_wait);
+                port->count = 0;
+                clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
+                tty_port_tty_set(port, NULL);
+                wake_up_interruptible(&port->open_wait);
+                wake_up_interruptible(&port->delta_msr_wait);
         }
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 }
 
 /*
@@ -1438,8 +1446,8 @@ static void uart_hangup(struct tty_struct *tty)
  */
 static void uart_update_termios(struct uart_state *state)
 {
-        struct tty_struct *tty = state->info.port.tty;
-        struct uart_port *port = state->port;
+        struct tty_struct *tty = state->port.tty;
+        struct uart_port *port = state->uart_port;
 
         if (uart_console(port) && port->cons->cflag) {
                 tty->termios->c_cflag = port->cons->cflag;
@@ -1473,27 +1481,27 @@ static int
 uart_block_til_ready(struct file *filp, struct uart_state *state)
 {
         DECLARE_WAITQUEUE(wait, current);
-        struct uart_info *info = &state->info;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
+        struct tty_port *port = &state->port;
         unsigned int mctrl;
 
-        info->port.blocked_open++;
-        state->count--;
+        port->blocked_open++;
+        port->count--;
 
-        add_wait_queue(&info->port.open_wait, &wait);
+        add_wait_queue(&port->open_wait, &wait);
         while (1) {
                 set_current_state(TASK_INTERRUPTIBLE);
 
                 /*
                  * If we have been hung up, tell userspace/restart open.
                  */
-                if (tty_hung_up_p(filp) || info->port.tty == NULL)
+                if (tty_hung_up_p(filp) || port->tty == NULL)
                         break;
 
                 /*
                  * If the port has been closed, tell userspace/restart open.
                  */
-                if (!(info->flags & UIF_INITIALIZED))
+                if (!(port->flags & ASYNC_INITIALIZED))
                         break;
 
                 /*
@@ -1506,8 +1514,8 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
                  * have set TTY_IO_ERROR for a non-existant port.
                  */
                 if ((filp->f_flags & O_NONBLOCK) ||
-                    (info->port.tty->termios->c_cflag & CLOCAL) ||
-                    (info->port.tty->flags & (1 << TTY_IO_ERROR)))
+                    (port->tty->termios->c_cflag & CLOCAL) ||
+                    (port->tty->flags & (1 << TTY_IO_ERROR)))
                         break;
 
                 /*
@@ -1515,37 +1523,37 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
                  * not set RTS here - we want to make sure we catch
                  * the data from the modem.
                  */
-                if (info->port.tty->termios->c_cflag & CBAUD)
-                        uart_set_mctrl(port, TIOCM_DTR);
+                if (port->tty->termios->c_cflag & CBAUD)
+                        uart_set_mctrl(uport, TIOCM_DTR);
 
                 /*
                  * and wait for the carrier to indicate that the
                  * modem is ready for us.
                  */
-                spin_lock_irq(&port->lock);
-                port->ops->enable_ms(port);
-                mctrl = port->ops->get_mctrl(port);
-                spin_unlock_irq(&port->lock);
+                spin_lock_irq(&uport->lock);
+                uport->ops->enable_ms(uport);
+                mctrl = uport->ops->get_mctrl(uport);
+                spin_unlock_irq(&uport->lock);
                 if (mctrl & TIOCM_CAR)
                         break;
 
-                mutex_unlock(&state->mutex);
+                mutex_unlock(&port->mutex);
                 schedule();
-                mutex_lock(&state->mutex);
+                mutex_lock(&port->mutex);
 
                 if (signal_pending(current))
                         break;
         }
         set_current_state(TASK_RUNNING);
-        remove_wait_queue(&info->port.open_wait, &wait);
+        remove_wait_queue(&port->open_wait, &wait);
 
-        state->count++;
-        info->port.blocked_open--;
+        port->count++;
+        port->blocked_open--;
 
         if (signal_pending(current))
                 return -ERESTARTSYS;
 
-        if (!info->port.tty || tty_hung_up_p(filp))
+        if (!port->tty || tty_hung_up_p(filp))
                 return -EAGAIN;
 
         return 0;
@@ -1554,24 +1562,26 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
 static struct uart_state *uart_get(struct uart_driver *drv, int line)
 {
         struct uart_state *state;
+        struct tty_port *port;
         int ret = 0;
 
         state = drv->state + line;
-        if (mutex_lock_interruptible(&state->mutex)) {
+        port = &state->port;
+        if (mutex_lock_interruptible(&port->mutex)) {
                 ret = -ERESTARTSYS;
                 goto err;
         }
 
-        state->count++;
-        if (!state->port || state->port->flags & UPF_DEAD) {
+        port->count++;
+        if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
                 ret = -ENXIO;
                 goto err_unlock;
         }
         return state;
 
  err_unlock:
-        state->count--;
-        mutex_unlock(&state->mutex);
+        port->count--;
+        mutex_unlock(&port->mutex);
  err:
         return ERR_PTR(ret);
 }
@@ -1590,6 +1600,7 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
 {
         struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
         struct uart_state *state;
+        struct tty_port *port;
         int retval, line = tty->index;
 
         BUG_ON(!kernel_locked());
@@ -1606,16 +1617,18 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
 
         /*
          * We take the semaphore inside uart_get to guarantee that we won't
-         * be re-entered while allocating the info structure, or while we
+         * be re-entered while allocating the state structure, or while we
          * request any IRQs that the driver may need.  This also has the nice
          * side-effect that it delays the action of uart_hangup, so we can
-         * guarantee that info->port.tty will always contain something reasonable.
+         * guarantee that state->port.tty will always contain something
+         * reasonable.
          */
         state = uart_get(drv, line);
         if (IS_ERR(state)) {
                 retval = PTR_ERR(state);
                 goto fail;
         }
+        port = &state->port;
 
         /*
          * Once we set tty->driver_data here, we are guaranteed that
@@ -1623,25 +1636,25 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
          * Any failures from here onwards should not touch the count.
          */
         tty->driver_data = state;
-        state->port->info = &state->info;
-        tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
+        state->uart_port->state = state;
+        tty->low_latency = (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
         tty->alt_speed = 0;
-        state->info.port.tty = tty;
+        tty_port_tty_set(port, tty);
 
         /*
          * If the port is in the middle of closing, bail out now.
          */
         if (tty_hung_up_p(filp)) {
                 retval = -EAGAIN;
-                state->count--;
-                mutex_unlock(&state->mutex);
+                port->count--;
+                mutex_unlock(&port->mutex);
                 goto fail;
         }
 
         /*
          * Make sure the device is in D0 state.
          */
-        if (state->count == 1)
+        if (port->count == 1)
                 uart_change_pm(state, 0);
 
         /*
@@ -1654,18 +1667,18 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
          */
         if (retval == 0)
                 retval = uart_block_til_ready(filp, state);
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 
         /*
          * If this is the first open to succeed, adjust things to suit.
          */
-        if (retval == 0 && !(state->info.flags & UIF_NORMAL_ACTIVE)) {
-                state->info.flags |= UIF_NORMAL_ACTIVE;
+        if (retval == 0 && !(port->flags & ASYNC_NORMAL_ACTIVE)) {
+                set_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
 
                 uart_update_termios(state);
         }
 
- fail:
+fail:
         return retval;
 }
 
@@ -1687,57 +1700,58 @@ static const char *uart_type(struct uart_port *port)
 static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
 {
         struct uart_state *state = drv->state + i;
+        struct tty_port *port = &state->port;
         int pm_state;
-        struct uart_port *port = state->port;
+        struct uart_port *uport = state->uart_port;
         char stat_buf[32];
         unsigned int status;
         int mmio;
 
-        if (!port)
+        if (!uport)
                 return;
 
-        mmio = port->iotype >= UPIO_MEM;
+        mmio = uport->iotype >= UPIO_MEM;
         seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
-                        port->line, uart_type(port),
+                        uport->line, uart_type(uport),
                         mmio ? "mmio:0x" : "port:",
-                        mmio ? (unsigned long long)port->mapbase
-                             : (unsigned long long) port->iobase,
-                        port->irq);
+                        mmio ? (unsigned long long)uport->mapbase
+                             : (unsigned long long)uport->iobase,
+                        uport->irq);
 
-        if (port->type == PORT_UNKNOWN) {
+        if (uport->type == PORT_UNKNOWN) {
                 seq_putc(m, '\n');
                 return;
         }
 
         if (capable(CAP_SYS_ADMIN)) {
-                mutex_lock(&state->mutex);
+                mutex_lock(&port->mutex);
                 pm_state = state->pm_state;
                 if (pm_state)
                         uart_change_pm(state, 0);
-                spin_lock_irq(&port->lock);
-                status = port->ops->get_mctrl(port);
-                spin_unlock_irq(&port->lock);
+                spin_lock_irq(&uport->lock);
+                status = uport->ops->get_mctrl(uport);
+                spin_unlock_irq(&uport->lock);
                 if (pm_state)
                         uart_change_pm(state, pm_state);
-                mutex_unlock(&state->mutex);
+                mutex_unlock(&port->mutex);
 
                 seq_printf(m, " tx:%d rx:%d",
-                                port->icount.tx, port->icount.rx);
-                if (port->icount.frame)
+                                uport->icount.tx, uport->icount.rx);
+                if (uport->icount.frame)
                         seq_printf(m, " fe:%d",
-                                port->icount.frame);
-                if (port->icount.parity)
+                                uport->icount.frame);
+                if (uport->icount.parity)
                         seq_printf(m, " pe:%d",
-                                port->icount.parity);
-                if (port->icount.brk)
+                                uport->icount.parity);
+                if (uport->icount.brk)
                         seq_printf(m, " brk:%d",
-                                port->icount.brk);
-                if (port->icount.overrun)
+                                uport->icount.brk);
+                if (uport->icount.overrun)
                         seq_printf(m, " oe:%d",
-                                port->icount.overrun);
+                                uport->icount.overrun);
 
 #define INFOBIT(bit, str) \
-        if (port->mctrl & (bit)) \
+        if (uport->mctrl & (bit)) \
                 strncat(stat_buf, (str), sizeof(stat_buf) - \
                         strlen(stat_buf) - 2)
 #define STATBIT(bit, str) \
@@ -1958,7 +1972,7 @@ EXPORT_SYMBOL_GPL(uart_set_options);
 
 static void uart_change_pm(struct uart_state *state, int pm_state)
 {
-        struct uart_port *port = state->port;
+        struct uart_port *port = state->uart_port;
 
         if (state->pm_state != pm_state) {
                 if (port->ops->pm)
@@ -1982,132 +1996,138 @@ static int serial_match_port(struct device *dev, void *data)
         return dev->devt == devt; /* Actually, only one tty per port */
 }
 
-int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
+int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
 {
-        struct uart_state *state = drv->state + port->line;
+        struct uart_state *state = drv->state + uport->line;
+        struct tty_port *port = &state->port;
         struct device *tty_dev;
-        struct uart_match match = {port, drv};
+        struct uart_match match = {uport, drv};
 
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
-        if (!console_suspend_enabled && uart_console(port)) {
+        if (!console_suspend_enabled && uart_console(uport)) {
                 /* we're going to avoid suspending serial console */
-                mutex_unlock(&state->mutex);
+                mutex_unlock(&port->mutex);
                 return 0;
         }
 
-        tty_dev = device_find_child(port->dev, &match, serial_match_port);
+        tty_dev = device_find_child(uport->dev, &match, serial_match_port);
         if (device_may_wakeup(tty_dev)) {
-                enable_irq_wake(port->irq);
+                enable_irq_wake(uport->irq);
                 put_device(tty_dev);
-                mutex_unlock(&state->mutex);
+                mutex_unlock(&port->mutex);
                 return 0;
         }
-        port->suspended = 1;
+        uport->suspended = 1;
 
-        if (state->info.flags & UIF_INITIALIZED) {
-                const struct uart_ops *ops = port->ops;
+        if (port->flags & ASYNC_INITIALIZED) {
+                const struct uart_ops *ops = uport->ops;
                 int tries;
 
-                state->info.flags = (state->info.flags & ~UIF_INITIALIZED)
-                                     | UIF_SUSPENDED;
+                set_bit(ASYNCB_SUSPENDED, &port->flags);
+                clear_bit(ASYNCB_INITIALIZED, &port->flags);
 
-                spin_lock_irq(&port->lock);
-                ops->stop_tx(port);
-                ops->set_mctrl(port, 0);
-                ops->stop_rx(port);
-                spin_unlock_irq(&port->lock);
+                spin_lock_irq(&uport->lock);
+                ops->stop_tx(uport);
+                ops->set_mctrl(uport, 0);
+                ops->stop_rx(uport);
+                spin_unlock_irq(&uport->lock);
 
                 /*
                  * Wait for the transmitter to empty.
                  */
-                for (tries = 3; !ops->tx_empty(port) && tries; tries--)
+                for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
                         msleep(10);
                 if (!tries)
                         printk(KERN_ERR "%s%s%s%d: Unable to drain "
                                         "transmitter\n",
-                               port->dev ? dev_name(port->dev) : "",
-                               port->dev ? ": " : "",
+                               uport->dev ? dev_name(uport->dev) : "",
+                               uport->dev ? ": " : "",
                                drv->dev_name,
-                               drv->tty_driver->name_base + port->line);
+                               drv->tty_driver->name_base + uport->line);
 
-                ops->shutdown(port);
+                ops->shutdown(uport);
         }
 
         /*
          * Disable the console device before suspending.
          */
-        if (uart_console(port))
-                console_stop(port->cons);
+        if (uart_console(uport))
+                console_stop(uport->cons);
 
         uart_change_pm(state, 3);
 
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 
         return 0;
 }
 
-int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
+int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
 {
-        struct uart_state *state = drv->state + port->line;
+        struct uart_state *state = drv->state + uport->line;
+        struct tty_port *port = &state->port;
         struct device *tty_dev;
-        struct uart_match match = {port, drv};
+        struct uart_match match = {uport, drv};
+        struct ktermios termios;
 
-        mutex_lock(&state->mutex);
+        mutex_lock(&port->mutex);
 
-        if (!console_suspend_enabled && uart_console(port)) {
+        if (!console_suspend_enabled && uart_console(uport)) {
                 /* no need to resume serial console, it wasn't suspended */
-                mutex_unlock(&state->mutex);
+                /*
+                 * First try to use the console cflag setting.
+                 */
+                memset(&termios, 0, sizeof(struct ktermios));
+                termios.c_cflag = uport->cons->cflag;
+                /*
+                 * If that's unset, use the tty termios setting.
+                 */
+                if (termios.c_cflag == 0)
+                        termios = *state->port.tty->termios;
+                else {
+                        termios.c_ispeed = termios.c_ospeed =
+                                tty_termios_input_baud_rate(&termios);
+                        termios.c_ispeed = termios.c_ospeed =
+                                tty_termios_baud_rate(&termios);
+                }
+                uport->ops->set_termios(uport, &termios, NULL);
+                mutex_unlock(&port->mutex);
                 return 0;
         }
 
-        tty_dev = device_find_child(port->dev, &match, serial_match_port);
-        if (!port->suspended && device_may_wakeup(tty_dev)) {
-                disable_irq_wake(port->irq);
-                mutex_unlock(&state->mutex);
+        tty_dev = device_find_child(uport->dev, &match, serial_match_port);
+        if (!uport->suspended && device_may_wakeup(tty_dev)) {
+                disable_irq_wake(uport->irq);
+                mutex_unlock(&port->mutex);
                 return 0;
         }
-        port->suspended = 0;
+        uport->suspended = 0;
 
         /*
          * Re-enable the console device after suspending.
          */
-        if (uart_console(port)) {
-                struct ktermios termios;
-
-                /*
-                 * First try to use the console cflag setting.
-                 */
-                memset(&termios, 0, sizeof(struct ktermios));
-                termios.c_cflag = port->cons->cflag;
-
-                /*
-                 * If that's unset, use the tty termios setting.
-                 */
-                if (state->info.port.tty && termios.c_cflag == 0)
-                        termios = *state->info.port.tty->termios;
-
+        if (uart_console(uport)) {
                 uart_change_pm(state, 0);
-                port->ops->set_termios(port, &termios, NULL);
-                console_start(port->cons);
+                uport->ops->set_termios(uport, &termios, NULL);
+                console_start(uport->cons);
         }
 
-        if (state->info.flags & UIF_SUSPENDED) {
-                const struct uart_ops *ops = port->ops;
+        if (port->flags & ASYNC_SUSPENDED) {
+                const struct uart_ops *ops = uport->ops;
                 int ret;
 
                 uart_change_pm(state, 0);
-                spin_lock_irq(&port->lock);
-                ops->set_mctrl(port, 0);
-                spin_unlock_irq(&port->lock);
-                ret = ops->startup(port);
+                spin_lock_irq(&uport->lock);
+                ops->set_mctrl(uport, 0);
+                spin_unlock_irq(&uport->lock);
+                ret = ops->startup(uport);
                 if (ret == 0) {
                         uart_change_speed(state, NULL);
-                        spin_lock_irq(&port->lock);
-                        ops->set_mctrl(port, port->mctrl);
-                        ops->start_tx(port);
-                        spin_unlock_irq(&port->lock);
-                        state->info.flags |= UIF_INITIALIZED;
+                        spin_lock_irq(&uport->lock);
+                        ops->set_mctrl(uport, uport->mctrl);
+                        ops->start_tx(uport);
+                        spin_unlock_irq(&uport->lock);
+                        set_bit(ASYNCB_INITIALIZED, &port->flags);
                 } else {
                         /*
                          * Failed to resume - maybe hardware went away?
@@ -2117,10 +2137,10 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
                         uart_shutdown(state);
                 }
 
-                state->info.flags &= ~UIF_SUSPENDED;
+                clear_bit(ASYNCB_SUSPENDED, &port->flags);
         }
 
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
 
         return 0;
 }
@@ -2232,10 +2252,10 @@ static int uart_poll_init(struct tty_driver *driver, int line, char *options)
         int parity = 'n';
         int flow = 'n';
 
-        if (!state || !state->port)
+        if (!state || !state->uart_port)
                 return -1;
 
-        port = state->port;
+        port = state->uart_port;
         if (!(port->ops->poll_get_char && port->ops->poll_put_char))
                 return -1;
 
@@ -2253,10 +2273,10 @@ static int uart_poll_get_char(struct tty_driver *driver, int line)
         struct uart_state *state = drv->state + line;
         struct uart_port *port;
 
-        if (!state || !state->port)
+        if (!state || !state->uart_port)
                 return -1;
 
-        port = state->port;
+        port = state->uart_port;
         return port->ops->poll_get_char(port);
 }
 
@@ -2266,10 +2286,10 @@ static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
         struct uart_state *state = drv->state + line;
         struct uart_port *port;
 
-        if (!state || !state->port)
+        if (!state || !state->uart_port)
                 return;
 
-        port = state->port;
+        port = state->uart_port;
         port->ops->poll_put_char(port, ch);
 }
 #endif
@@ -2360,14 +2380,12 @@ int uart_register_driver(struct uart_driver *drv)
          */
         for (i = 0; i < drv->nr; i++) {
                 struct uart_state *state = drv->state + i;
+                struct tty_port *port = &state->port;
 
-                state->close_delay     = 500;   /* .5 seconds */
-                state->closing_wait    = 30000; /* 30 seconds */
-                mutex_init(&state->mutex);
-
-                tty_port_init(&state->info.port);
-                init_waitqueue_head(&state->info.delta_msr_wait);
-                tasklet_init(&state->info.tlet, uart_tasklet_action,
+                tty_port_init(port);
+                port->close_delay     = 500;    /* .5 seconds */
+                port->closing_wait    = 30000;  /* 30 seconds */
+                tasklet_init(&state->tlet, uart_tasklet_action,
                              (unsigned long)state);
         }
 
@@ -2415,62 +2433,64 @@ struct tty_driver *uart_console_device(struct console *co, int *index)
  *      level uart drivers to expand uart_port, rather than having yet
  *      more levels of structures.
  */
-int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
+int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
 {
         struct uart_state *state;
+        struct tty_port *port;
         int ret = 0;
         struct device *tty_dev;
 
         BUG_ON(in_interrupt());
 
-        if (port->line >= drv->nr)
+        if (uport->line >= drv->nr)
                 return -EINVAL;
 
-        state = drv->state + port->line;
+        state = drv->state + uport->line;
+        port = &state->port;
 
         mutex_lock(&port_mutex);
-        mutex_lock(&state->mutex);
-        if (state->port) {
+        mutex_lock(&port->mutex);
+        if (state->uart_port) {
                 ret = -EINVAL;
                 goto out;
         }
 
-        state->port = port;
+        state->uart_port = uport;
         state->pm_state = -1;
 
-        port->cons = drv->cons;
-        port->info = &state->info;
+        uport->cons = drv->cons;
+        uport->state = state;
 
         /*
          * If this port is a console, then the spinlock is already
          * initialised.
          */
-        if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
-                spin_lock_init(&port->lock);
-                lockdep_set_class(&port->lock, &port_lock_key);
+        if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
+                spin_lock_init(&uport->lock);
+                lockdep_set_class(&uport->lock, &port_lock_key);
         }
 
-        uart_configure_port(drv, state, port);
+        uart_configure_port(drv, state, uport);
 
         /*
          * Register the port whether it's detected or not.  This allows
          * setserial to be used to alter this ports parameters.
          */
-        tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev);
+        tty_dev = tty_register_device(drv->tty_driver, uport->line, uport->dev);
         if (likely(!IS_ERR(tty_dev))) {
                 device_init_wakeup(tty_dev, 1);
                 device_set_wakeup_enable(tty_dev, 0);
         } else
                 printk(KERN_ERR "Cannot register tty device on line %d\n",
-                       port->line);
+                       uport->line);
 
         /*
          * Ensure UPF_DEAD is not set.
          */
-        port->flags &= ~UPF_DEAD;
+        uport->flags &= ~UPF_DEAD;
 
  out:
-        mutex_unlock(&state->mutex);
+        mutex_unlock(&port->mutex);
         mutex_unlock(&port_mutex);
 
         return ret;
@@ -2485,16 +2505,16 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
  *      core driver.  No further calls will be made to the low-level code
  *      for this port.
  */
-int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
+int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
 {
-        struct uart_state *state = drv->state + port->line;
-        struct uart_info *info;
+        struct uart_state *state = drv->state + uport->line;
+        struct tty_port *port = &state->port;
 
         BUG_ON(in_interrupt());
 
-        if (state->port != port)
+        if (state->uart_port != uport)
                 printk(KERN_ALERT "Removing wrong port: %p != %p\n",
-                        state->port, port);
+                        state->uart_port, uport);
 
         mutex_lock(&port_mutex);
 
@@ -2502,37 +2522,35 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
          * Mark the port "dead" - this prevents any opens from
          * succeeding while we shut down the port.
          */
-        mutex_lock(&state->mutex);
-        port->flags |= UPF_DEAD;
-        mutex_unlock(&state->mutex);
+        mutex_lock(&port->mutex);
+        uport->flags |= UPF_DEAD;
+        mutex_unlock(&port->mutex);
 
         /*
          * Remove the devices from the tty layer
          */
-        tty_unregister_device(drv->tty_driver, port->line);
+        tty_unregister_device(drv->tty_driver, uport->line);
 
-        info = &state->info;
-        if (info && info->port.tty)
-                tty_vhangup(info->port.tty);
+        if (port->tty)
+                tty_vhangup(port->tty);
 
         /*
          * Free the port IO and memory resources, if any.
          */
-        if (port->type != PORT_UNKNOWN)
-                port->ops->release_port(port);
+        if (uport->type != PORT_UNKNOWN)
+                uport->ops->release_port(uport);
 
         /*
          * Indicate that there isn't a port here anymore.
          */
-        port->type = PORT_UNKNOWN;
+        uport->type = PORT_UNKNOWN;
 
         /*
          * Kill the tasklet, and free resources.
          */
-        if (info)
-                tasklet_kill(&info->tlet);
+        tasklet_kill(&state->tlet);
 
-        state->port = NULL;
+        state->uart_port = NULL;
         mutex_unlock(&port_mutex);
 
         return 0;
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index ed4648b556c7..a3bb49031a7f 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -884,6 +884,7 @@ static struct pcmcia_device_id serial_ids[] = {
         PCMCIA_DEVICE_CIS_MANF_CARD(0x0192, 0xa555, "SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- pre update */
         PCMCIA_DEVICE_CIS_MANF_CARD(0x013f, 0xa555, "SW_555_SER.cis"),  /* Sierra Aircard 555 CDMA 1xrtt Modem -- post update */
         PCMCIA_DEVICE_CIS_PROD_ID12("MultiTech", "PCMCIA 56K DataFax", 0x842047ee, 0xc2efcf03, "cis/MT5634ZLX.cis"),
+        PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-2", 0x96913a85, 0x27ab5437, "COMpad2.cis"),
         PCMCIA_DEVICE_CIS_PROD_ID12("ADVANTECH", "COMpad-32/85B-4", 0x96913a85, 0xcec8f102, "COMpad4.cis"),
         PCMCIA_DEVICE_CIS_PROD_ID123("ADVANTECH", "COMpad-32/85", "1.0", 0x96913a85, 0x8fbe92ae, 0x0877b627, "COMpad2.cis"),
         PCMCIA_DEVICE_CIS_PROD_ID2("RS-COM 2P", 0xad20b156, "cis/RS-COM-2P.cis"),
diff --git a/drivers/serial/serial_ks8695.c b/drivers/serial/serial_ks8695.c
index 52db5cc3f900..2e71bbc04dac 100644
--- a/drivers/serial/serial_ks8695.c
+++ b/drivers/serial/serial_ks8695.c
@@ -154,7 +154,7 @@ static void ks8695uart_disable_ms(struct uart_port *port)
 static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned int status, ch, lsr, flg, max_count = 256;
 
         status = UART_GET_LSR(port);            /* clears pending LSR interrupts */
@@ -210,7 +210,7 @@ ignore_char:
 static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         unsigned int count;
 
         if (port->x_char) {
@@ -266,7 +266,7 @@ static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id)
         if (status & URMS_URTERI)
                 port->icount.rng++;
 
-        wake_up_interruptible(&port->info->delta_msr_wait);
+        wake_up_interruptible(&port->state->port.delta_msr_wait);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index a7bf024a8286..ea744707c4d6 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -138,7 +138,7 @@ static void lh7a40xuart_enable_ms (struct uart_port* port)
 
 static void lh7a40xuart_rx_chars (struct uart_port* port)
 {
-        struct tty_struct* tty = port->info->port.tty;
+        struct tty_struct* tty = port->state->port.tty;
         int cbRxMax = 256;      /* (Gross) limit on receive */
         unsigned int data;      /* Received data and status */
         unsigned int flag;
@@ -184,7 +184,7 @@ static void lh7a40xuart_rx_chars (struct uart_port* port)
 
 static void lh7a40xuart_tx_chars (struct uart_port* port)
 {
-        struct circ_buf* xmit = &port->info->xmit;
+        struct circ_buf* xmit = &port->state->xmit;
         int cbTxMax = port->fifosize;
 
         if (port->x_char) {
@@ -241,7 +241,7 @@ static void lh7a40xuart_modem_status (struct uart_port* port)
         if (delta & CTS)
                 uart_handle_cts_change (port, status & CTS);
 
-        wake_up_interruptible (&port->info->delta_msr_wait);
+        wake_up_interruptible (&port->state->port.delta_msr_wait);
 }
 
 static irqreturn_t lh7a40xuart_int (int irq, void* dev_id)
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 54dd16d66a4b..0f7cf4c453e6 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -272,7 +272,7 @@ static void serial_txx9_initialize(struct uart_port *port)
 static inline void
 receive_chars(struct uart_txx9_port *up, unsigned int *status)
 {
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned char ch;
         unsigned int disr = *status;
         int max_count = 256;
@@ -348,7 +348,7 @@ receive_chars(struct uart_txx9_port *up, unsigned int *status)
 
 static inline void transmit_chars(struct uart_txx9_port *up)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int count;
 
         if (up->port.x_char) {
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 8e2feb563347..85119fb7cb50 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -272,7 +272,8 @@ static inline void sci_init_pins(struct uart_port *port, unsigned int cflag)
                 __raw_writew(data, PSCR);
         }
 }
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763) || \
+#elif defined(CONFIG_CPU_SUBTYPE_SH7757) || \
+      defined(CONFIG_CPU_SUBTYPE_SH7763) || \
       defined(CONFIG_CPU_SUBTYPE_SH7780) || \
       defined(CONFIG_CPU_SUBTYPE_SH7785) || \
       defined(CONFIG_CPU_SUBTYPE_SH7786) || \
@@ -360,7 +361,7 @@ static inline int sci_rxroom(struct uart_port *port)
 
 static void sci_transmit_chars(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
         unsigned int stopped = uart_tx_stopped(port);
         unsigned short status;
         unsigned short ctrl;
@@ -425,7 +426,7 @@ static void sci_transmit_chars(struct uart_port *port)
 static inline void sci_receive_chars(struct uart_port *port)
 {
         struct sci_port *sci_port = to_sci_port(port);
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         int i, count, copied = 0;
         unsigned short status;
         unsigned char flag;
@@ -545,7 +546,7 @@ static inline int sci_handle_errors(struct uart_port *port)
 {
         int copied = 0;
         unsigned short status = sci_in(port, SCxSR);
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
 
         if (status & SCxSR_ORER(port)) {
                 /* overrun error */
@@ -599,7 +600,7 @@ static inline int sci_handle_errors(struct uart_port *port)
 
 static inline int sci_handle_fifo_overrun(struct uart_port *port)
 {
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         int copied = 0;
 
         if (port->type != PORT_SCIF)
@@ -622,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 tty_struct *tty = port->state->port.tty;
         struct sci_port *s = to_sci_port(port);
 
         if (uart_handle_break(port))
@@ -662,10 +663,11 @@ static irqreturn_t sci_rx_interrupt(int irq, void *port)
 static irqreturn_t sci_tx_interrupt(int irq, void *ptr)
 {
         struct uart_port *port = ptr;
+        unsigned long flags;
 
-        spin_lock_irq(&port->lock);
+        spin_lock_irqsave(&port->lock, flags);
         sci_transmit_chars(port);
-        spin_unlock_irq(&port->lock);
+        spin_unlock_irqrestore(&port->lock, flags);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 38072c15b845..3e2fcf93b42e 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -112,6 +112,13 @@
 #elif defined(CONFIG_H8S2678)
 # define SCSCR_INIT(port)          0x30 /* TIE=0,RIE=0,TE=1,RE=1 */
 # define H8300_SCI_DR(ch) *(volatile char *)(P1DR + h8300_sci_pins[ch].port)
+#elif defined(CONFIG_CPU_SUBTYPE_SH7757)
+# define SCSPTR0 0xfe4b0020
+# define SCSPTR1 0xfe4b0020
+# define SCSPTR2 0xfe4b0020
+# define SCIF_ORER 0x0001
+# define SCSCR_INIT(port)       0x38
+# define SCIF_ONLY
 #elif defined(CONFIG_CPU_SUBTYPE_SH7763)
 # define SCSPTR0 0xffe00024 /* 16 bit SCIF */
 # define SCSPTR1 0xffe08024 /* 16 bit SCIF */
@@ -562,6 +569,16 @@ static inline int sci_rxd_in(struct uart_port *port)
                 return ctrl_inw(SCSPTR2)&0x0001 ? 1 : 0; /* SCIF */
         return 1;
 }
+#elif defined(CONFIG_CPU_SUBTYPE_SH7757)
+static inline int sci_rxd_in(struct uart_port *port)
+{
+        if (port->mapbase == 0xfe4b0000)
+                return ctrl_inw(SCSPTR0) & 0x0001 ? 1 : 0;
+        if (port->mapbase == 0xfe4c0000)
+                return ctrl_inw(SCSPTR1) & 0x0001 ? 1 : 0;
+        if (port->mapbase == 0xfe4d0000)
+                return ctrl_inw(SCSPTR2) & 0x0001 ? 1 : 0;
+}
 #elif defined(CONFIG_CPU_SUBTYPE_SH7760)
 static inline int sci_rxd_in(struct uart_port *port)
 {
diff --git a/drivers/serial/sn_console.c b/drivers/serial/sn_console.c
index d5276c012f78..9794e0cd3dcc 100644
--- a/drivers/serial/sn_console.c
+++ b/drivers/serial/sn_console.c
@@ -469,9 +469,9 @@ sn_receive_chars(struct sn_cons_port *port, unsigned long flags)
                 return;
         }
 
-        if (port->sc_port.info) {
+        if (port->sc_port.state) {
                 /* The serial_core stuffs are initilized, use them */
-                tty = port->sc_port.info->port.tty;
+                tty = port->sc_port.state->port.tty;
         }
         else {
                 /* Not registered yet - can't pass to tty layer.  */
@@ -550,9 +550,9 @@ static void sn_transmit_chars(struct sn_cons_port *port, int raw)
 
         BUG_ON(!port->sc_is_asynch);
 
-        if (port->sc_port.info) {
+        if (port->sc_port.state) {
                 /* We're initilized, using serial core infrastructure */
-                xmit = &port->sc_port.info->xmit;
+                xmit = &port->sc_port.state->xmit;
         } else {
                 /* Probably sn_sal_switch_to_asynch has been run but serial core isn't
                  * initilized yet.  Just return.  Writes are going through
@@ -927,7 +927,7 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
         /* We can't look at the xmit buffer if we're not registered with serial core
          *  yet.  So only do the fancy recovery after registering
          */
-        if (!port->sc_port.info) {
+        if (!port->sc_port.state) {
                 /* Not yet registered with serial core - simple case */
                 puts_raw_fixed(port->sc_ops->sal_puts_raw, s, count);
                 return;
@@ -936,8 +936,8 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
         /* somebody really wants this output, might be an
          * oops, kdb, panic, etc.  make sure they get it. */
         if (spin_is_locked(&port->sc_port.lock)) {
-                int lhead = port->sc_port.info->xmit.head;
-                int ltail = port->sc_port.info->xmit.tail;
+                int lhead = port->sc_port.state->xmit.head;
+                int ltail = port->sc_port.state->xmit.tail;
                 int counter, got_lock = 0;
 
                 /*
@@ -962,13 +962,13 @@ sn_sal_console_write(struct console *co, const char *s, unsigned count)
                                 break;
                         } else {
                                 /* still locked */
-                                if ((lhead != port->sc_port.info->xmit.head)
+                                if ((lhead != port->sc_port.state->xmit.head)
                                     || (ltail !=
-                                        port->sc_port.info->xmit.tail)) {
+                                        port->sc_port.state->xmit.tail)) {
                                         lhead =
-                                                port->sc_port.info->xmit.head;
+                                                port->sc_port.state->xmit.head;
                                         ltail =
-                                                port->sc_port.info->xmit.tail;
+                                                port->sc_port.state->xmit.tail;
                                         counter = 0;
                                 }
                         }
diff --git a/drivers/serial/sunhv.c b/drivers/serial/sunhv.c
index 1df5325faab2..d548652dee50 100644
--- a/drivers/serial/sunhv.c
+++ b/drivers/serial/sunhv.c
@@ -184,8 +184,8 @@ static struct tty_struct *receive_chars(struct uart_port *port)
 {
         struct tty_struct *tty = NULL;
 
-        if (port->info != NULL)         /* Unopened serial console */
-                tty = port->info->port.tty;
+        if (port->state != NULL)                /* Unopened serial console */
+                tty = port->state->port.tty;
 
         if (sunhv_ops->receive_chars(port, tty))
                 sun_do_break();
@@ -197,10 +197,10 @@ static void transmit_chars(struct uart_port *port)
 {
         struct circ_buf *xmit;
 
-        if (!port->info)
+        if (!port->state)
                 return;
 
-        xmit = &port->info->xmit;
+        xmit = &port->state->xmit;
         if (uart_circ_empty(xmit) || uart_tx_stopped(port))
                 return;
 
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index 0355efe115d9..d1ad34128635 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -117,8 +117,8 @@ receive_chars(struct uart_sunsab_port *up,
         int count = 0;
         int i;
 
-        if (up->port.info != NULL)              /* Unopened serial console */
-                tty = up->port.info->port.tty;
+        if (up->port.state != NULL)             /* Unopened serial console */
+                tty = up->port.state->port.tty;
 
         /* Read number of BYTES (Character + Status) available. */
         if (stat->sreg.isr0 & SAB82532_ISR0_RPF) {
@@ -229,7 +229,7 @@ static void sunsab_tx_idle(struct uart_sunsab_port *);
 static void transmit_chars(struct uart_sunsab_port *up,
                            union sab82532_irq_status *stat)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int i;
 
         if (stat->sreg.isr1 & SAB82532_ISR1_ALLS) {
@@ -297,7 +297,7 @@ static void check_status(struct uart_sunsab_port *up,
                 up->port.icount.dsr++;
         }
 
-        wake_up_interruptible(&up->port.info->delta_msr_wait);
+        wake_up_interruptible(&up->port.state->port.delta_msr_wait);
 }
 
 static irqreturn_t sunsab_interrupt(int irq, void *dev_id)
@@ -429,7 +429,7 @@ static void sunsab_tx_idle(struct uart_sunsab_port *up)
 static void sunsab_start_tx(struct uart_port *port)
 {
         struct uart_sunsab_port *up = (struct uart_sunsab_port *) port;
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int i;
 
         up->interrupt_mask1 &= ~(SAB82532_IMR1_ALLS|SAB82532_IMR1_XPR);
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index 47c6837850b1..68d262b15749 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -311,7 +311,7 @@ static void sunsu_enable_ms(struct uart_port *port)
 static struct tty_struct *
 receive_chars(struct uart_sunsu_port *up, unsigned char *status)
 {
-        struct tty_struct *tty = up->port.info->port.tty;
+        struct tty_struct *tty = up->port.state->port.tty;
         unsigned char ch, flag;
         int max_count = 256;
         int saw_console_brk = 0;
@@ -389,7 +389,7 @@ receive_chars(struct uart_sunsu_port *up, unsigned char *status)
 
 static void transmit_chars(struct uart_sunsu_port *up)
 {
-        struct circ_buf *xmit = &up->port.info->xmit;
+        struct circ_buf *xmit = &up->port.state->xmit;
         int count;
 
         if (up->port.x_char) {
@@ -441,7 +441,7 @@ static void check_modem_status(struct uart_sunsu_port *up)
         if (status & UART_MSR_DCTS)
                 uart_handle_cts_change(&up->port, status & UART_MSR_CTS);
 
-        wake_up_interruptible(&up->port.info->delta_msr_wait);
+        wake_up_interruptible(&up->port.state->port.delta_msr_wait);
 }
 
 static irqreturn_t sunsu_serial_interrupt(int irq, void *dev_id)
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index e09d3cebb4fb..ef693ae22e7f 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -328,9 +328,9 @@ sunzilog_receive_chars(struct uart_sunzilog_port *up,
         unsigned char ch, r1, flag;
 
         tty = NULL;
-        if (up->port.info != NULL &&            /* Unopened serial console */
-            up->port.info->port.tty != NULL)    /* Keyboard || mouse */
-                tty = up->port.info->port.tty;
+        if (up->port.state != NULL &&           /* Unopened serial console */
+            up->port.state->port.tty != NULL)   /* Keyboard || mouse */
+                tty = up->port.state->port.tty;
 
         for (;;) {
 
@@ -451,7 +451,7 @@ static void sunzilog_status_handle(struct uart_sunzilog_port *up,
                         uart_handle_cts_change(&up->port,
                                                (status & CTS));
 
-                wake_up_interruptible(&up->port.info->delta_msr_wait);
+                wake_up_interruptible(&up->port.state->port.delta_msr_wait);
         }
 
         up->prev_status = status;
@@ -501,9 +501,9 @@ static void sunzilog_transmit_chars(struct uart_sunzilog_port *up,
                 return;
         }
 
-        if (up->port.info == NULL)
+        if (up->port.state == NULL)
                 goto ack_tx_int;
-        xmit = &up->port.info->xmit;
+        xmit = &up->port.state->xmit;
         if (uart_circ_empty(xmit))
                 goto ack_tx_int;
 
@@ -705,7 +705,7 @@ static void sunzilog_start_tx(struct uart_port *port)
                 port->icount.tx++;
                 port->x_char = 0;
         } else {
-                struct circ_buf *xmit = &port->info->xmit;
+                struct circ_buf *xmit = &port->state->xmit;
 
                 writeb(xmit->buf[xmit->tail], &channel->data);
                 ZSDELAY();
diff --git a/drivers/serial/timbuart.c b/drivers/serial/timbuart.c
index 063a313b755c..34b31da01d09 100644
--- a/drivers/serial/timbuart.c
+++ b/drivers/serial/timbuart.c
@@ -77,7 +77,7 @@ static void timbuart_flush_buffer(struct uart_port *port)
 
 static void timbuart_rx_chars(struct uart_port *port)
 {
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
 
         while (ioread32(port->membase + TIMBUART_ISR) & RXDP) {
                 u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
@@ -86,7 +86,7 @@ static void timbuart_rx_chars(struct uart_port *port)
         }
 
         spin_unlock(&port->lock);
-        tty_flip_buffer_push(port->info->port.tty);
+        tty_flip_buffer_push(port->state->port.tty);
         spin_lock(&port->lock);
 
         dev_dbg(port->dev, "%s - total read %d bytes\n",
@@ -95,7 +95,7 @@ static void timbuart_rx_chars(struct uart_port *port)
 
 static void timbuart_tx_chars(struct uart_port *port)
 {
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) &&
                 !uart_circ_empty(xmit)) {
@@ -118,7 +118,7 @@ static void timbuart_handle_tx_port(struct uart_port *port, u32 isr, u32 *ier)
 {
         struct timbuart_port *uart =
                 container_of(port, struct timbuart_port, port);
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         if (uart_circ_empty(xmit) || uart_tx_stopped(port))
                 return;
@@ -231,7 +231,7 @@ static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier)
                 iowrite32(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);
+                wake_up_interruptible(&port->state->port.delta_msr_wait);
         }
 
         *ier |= CTS_DELTA;
diff --git a/drivers/serial/uartlite.c b/drivers/serial/uartlite.c
index 3317148a4b93..377f2712289e 100644
--- a/drivers/serial/uartlite.c
+++ b/drivers/serial/uartlite.c
@@ -75,7 +75,7 @@ static struct uart_port ulite_ports[ULITE_NR_UARTS];
 
 static int ulite_receive(struct uart_port *port, int stat)
 {
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         unsigned char ch = 0;
         char flag = TTY_NORMAL;
 
@@ -125,7 +125,7 @@ static int ulite_receive(struct uart_port *port, int stat)
 
 static int ulite_transmit(struct uart_port *port, int stat)
 {
-        struct circ_buf *xmit  = &port->info->xmit;
+        struct circ_buf *xmit  = &port->state->xmit;
 
         if (stat & ULITE_STATUS_TXFULL)
                 return 0;
@@ -154,17 +154,22 @@ static int ulite_transmit(struct uart_port *port, int stat)
 static irqreturn_t ulite_isr(int irq, void *dev_id)
 {
         struct uart_port *port = dev_id;
-        int busy;
+        int busy, n = 0;
 
         do {
                 int stat = readb(port->membase + ULITE_STATUS);
                 busy  = ulite_receive(port, stat);
                 busy |= ulite_transmit(port, stat);
+                n++;
         } while (busy);
 
-        tty_flip_buffer_push(port->info->port.tty);
-
-        return IRQ_HANDLED;
+        /* work done? */
+        if (n > 1) {
+                tty_flip_buffer_push(port->state->port.tty);
+                return IRQ_HANDLED;
+        } else {
+                return IRQ_NONE;
+        }
 }
 
 static unsigned int ulite_tx_empty(struct uart_port *port)
@@ -221,7 +226,7 @@ static int ulite_startup(struct uart_port *port)
         int ret;
 
         ret = request_irq(port->irq, ulite_isr,
-                          IRQF_DISABLED | IRQF_SAMPLE_RANDOM, "uartlite", port);
+                          IRQF_SHARED | IRQF_SAMPLE_RANDOM, "uartlite", port);
         if (ret)
                 return ret;
 
diff --git a/drivers/serial/ucc_uart.c b/drivers/serial/ucc_uart.c
index e945e780b5c9..0c08f286a2ef 100644
--- a/drivers/serial/ucc_uart.c
+++ b/drivers/serial/ucc_uart.c
@@ -327,7 +327,7 @@ static int qe_uart_tx_pump(struct uart_qe_port *qe_port)
         unsigned char *p;
         unsigned int count;
         struct uart_port *port = &qe_port->port;
-        struct circ_buf *xmit = &port->info->xmit;
+        struct circ_buf *xmit = &port->state->xmit;
 
         bdp = qe_port->rx_cur;
 
@@ -466,7 +466,7 @@ static void qe_uart_int_rx(struct uart_qe_port *qe_port)
         int i;
         unsigned char ch, *cp;
         struct uart_port *port = &qe_port->port;
-        struct tty_struct *tty = port->info->port.tty;
+        struct tty_struct *tty = port->state->port.tty;
         struct qe_bd *bdp;
         u16 status;
         unsigned int flg;
diff --git a/drivers/serial/vr41xx_siu.c b/drivers/serial/vr41xx_siu.c
index dac550e57c29..3beb6ab4fa68 100644
--- a/drivers/serial/vr41xx_siu.c
+++ b/drivers/serial/vr41xx_siu.c
@@ -318,7 +318,7 @@ static inline void receive_chars(struct uart_port *port, uint8_t *status)
         char flag;
         int max_count = RX_MAX_COUNT;
 
-        tty = port->info->port.tty;
+        tty = port->state->port.tty;
         lsr = *status;
 
         do {
@@ -386,7 +386,7 @@ static inline void check_modem_status(struct uart_port *port)
         if (msr & UART_MSR_DCTS)
                 uart_handle_cts_change(port, msr & UART_MSR_CTS);
 
-        wake_up_interruptible(&port->info->delta_msr_wait);
+        wake_up_interruptible(&port->state->port.delta_msr_wait);
 }
 
 static inline void transmit_chars(struct uart_port *port)
@@ -394,7 +394,7 @@ static inline void transmit_chars(struct uart_port *port)
         struct circ_buf *xmit;
         int max_count = TX_MAX_COUNT;
 
-        xmit = &port->info->xmit;
+        xmit = &port->state->xmit;
 
         if (port->x_char) {
                 siu_write(port, UART_TX, port->x_char);
diff --git a/drivers/serial/zs.c b/drivers/serial/zs.c
index d8c2809b1ab6..1a7fd3e70315 100644
--- a/drivers/serial/zs.c
+++ b/drivers/serial/zs.c
@@ -602,12 +602,12 @@ static void zs_receive_chars(struct zs_port *zport)
                 uart_insert_char(uport, status, Rx_OVR, ch, flag);
         }
 
-        tty_flip_buffer_push(uport->info->port.tty);
+        tty_flip_buffer_push(uport->state->port.tty);
 }
 
 static void zs_raw_transmit_chars(struct zs_port *zport)
 {
-        struct circ_buf *xmit = &zport->port.info->xmit;
+        struct circ_buf *xmit = &zport->port.state->xmit;
 
         /* XON/XOFF chars.  */
         if (zport->port.x_char) {
@@ -686,7 +686,7 @@ static void zs_status_handle(struct zs_port *zport, struct zs_port *zport_a)
                         uport->icount.rng++;
 
                 if (delta)
-                        wake_up_interruptible(&uport->info->delta_msr_wait);
+                        wake_up_interruptible(&uport->state->port.delta_msr_wait);
 
                 spin_lock(&scc->zlock);
         }
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index 3dd231a643b5..559b5fe9dc0f 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -77,7 +77,7 @@ static unsigned long ack_handle[NR_IRQS];
 static inline struct intc_desc_int *get_intc_desc(unsigned int irq)
 {
         struct irq_chip *chip = get_irq_chip(irq);
-        return (void *)((char *)chip - offsetof(struct intc_desc_int, chip));
+        return container_of(chip, struct intc_desc_int, chip);
 }
 
 static inline unsigned int set_field(unsigned int value,
@@ -95,16 +95,19 @@ static inline unsigned int set_field(unsigned int value,
 static void write_8(unsigned long addr, unsigned long h, unsigned long data)
 {
         __raw_writeb(set_field(0, data, h), addr);
+        (void)__raw_readb(addr);        /* Defeat write posting */
 }
 
 static void write_16(unsigned long addr, unsigned long h, unsigned long data)
 {
         __raw_writew(set_field(0, data, h), addr);
+        (void)__raw_readw(addr);        /* Defeat write posting */
 }
 
 static void write_32(unsigned long addr, unsigned long h, unsigned long data)
 {
         __raw_writel(set_field(0, data, h), addr);
+        (void)__raw_readl(addr);        /* Defeat write posting */
 }
 
 static void modify_8(unsigned long addr, unsigned long h, unsigned long data)
@@ -112,6 +115,7 @@ static void modify_8(unsigned long addr, unsigned long h, unsigned long data)
         unsigned long flags;
         local_irq_save(flags);
         __raw_writeb(set_field(__raw_readb(addr), data, h), addr);
+        (void)__raw_readb(addr);        /* Defeat write posting */
         local_irq_restore(flags);
 }
 
@@ -120,6 +124,7 @@ static void modify_16(unsigned long addr, unsigned long h, unsigned long data)
         unsigned long flags;
         local_irq_save(flags);
         __raw_writew(set_field(__raw_readw(addr), data, h), addr);
+        (void)__raw_readw(addr);        /* Defeat write posting */
         local_irq_restore(flags);
 }
 
@@ -128,6 +133,7 @@ static void modify_32(unsigned long addr, unsigned long h, unsigned long data)
         unsigned long flags;
         local_irq_save(flags);
         __raw_writel(set_field(__raw_readl(addr), data, h), addr);
+        (void)__raw_readl(addr);        /* Defeat write posting */
         local_irq_restore(flags);
 }
 
@@ -657,16 +663,9 @@ static unsigned int __init save_reg(struct intc_desc_int *d,
         return 0;
 }
 
-static unsigned char *intc_evt2irq_table;
-
-unsigned int intc_evt2irq(unsigned int vector)
+static void intc_redirect_irq(unsigned int irq, struct irq_desc *desc)
 {
-        unsigned int irq = evt2irq(vector);
-
-        if (intc_evt2irq_table && intc_evt2irq_table[irq])
-                irq = intc_evt2irq_table[irq];
-
-        return irq;
+        generic_handle_irq((unsigned int)get_irq_data(irq));
 }
 
 void __init register_intc_controller(struct intc_desc *desc)
@@ -739,50 +738,48 @@ void __init register_intc_controller(struct intc_desc *desc)
 
         BUG_ON(k > 256); /* _INTC_ADDR_E() and _INTC_ADDR_D() are 8 bits */
 
-        /* keep the first vector only if same enum is used multiple times */
+        /* register the vectors one by one */
         for (i = 0; i < desc->nr_vectors; i++) {
                 struct intc_vect *vect = desc->vectors + i;
-                int first_irq = evt2irq(vect->vect);
+                unsigned int irq = evt2irq(vect->vect);
+                struct irq_desc *irq_desc;
 
                 if (!vect->enum_id)
                         continue;
 
+                irq_desc = irq_to_desc_alloc_node(irq, numa_node_id());
+                if (unlikely(!irq_desc)) {
+                        pr_info("can't get irq_desc for %d\n", irq);
+                        continue;
+                }
+
+                intc_register_irq(desc, d, vect->enum_id, irq);
+
                 for (k = i + 1; k < desc->nr_vectors; k++) {
                         struct intc_vect *vect2 = desc->vectors + k;
+                        unsigned int irq2 = evt2irq(vect2->vect);
 
                         if (vect->enum_id != vect2->enum_id)
                                 continue;
 
-                        vect2->enum_id = 0;
-
-                        if (!intc_evt2irq_table)
-                                intc_evt2irq_table = kzalloc(NR_IRQS, GFP_NOWAIT);
-
-                        if (!intc_evt2irq_table) {
-                                pr_warning("intc: cannot allocate evt2irq!\n");
+                        /*
+                         * In the case of multi-evt handling and sparse
+                         * IRQ support, each vector still needs to have
+                         * its own backing irq_desc.
+                         */
+                        irq_desc = irq_to_desc_alloc_node(irq2, numa_node_id());
+                        if (unlikely(!irq_desc)) {
+                                pr_info("can't get irq_desc for %d\n", irq2);
                                 continue;
                         }
 
-                        intc_evt2irq_table[evt2irq(vect2->vect)] = first_irq;
-                }
-        }
-
-        /* 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;
+                        vect2->enum_id = 0;
 
-                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;
+                        /* redirect this interrupts to the first one */
+                        set_irq_chip_and_handler_name(irq2, &d->chip,
+                                        intc_redirect_irq, "redirect");
+                        set_irq_data(irq2, (void *)irq);
                 }
-
-                intc_register_irq(desc, d, vect->enum_id, irq);
         }
 }
 
diff --git a/drivers/uio/uio_pdrv_genirq.c b/drivers/uio/uio_pdrv_genirq.c
index 3f06818cf9fa..02347c57357d 100644
--- a/drivers/uio/uio_pdrv_genirq.c
+++ b/drivers/uio/uio_pdrv_genirq.c
@@ -20,6 +20,7 @@
 #include <linux/bitops.h>
 #include <linux/interrupt.h>
 #include <linux/stringify.h>
+#include <linux/pm_runtime.h>
 
 #define DRIVER_NAME "uio_pdrv_genirq"
 
@@ -27,8 +28,27 @@ struct uio_pdrv_genirq_platdata {
         struct uio_info *uioinfo;
         spinlock_t lock;
         unsigned long flags;
+        struct platform_device *pdev;
 };
 
+static int uio_pdrv_genirq_open(struct uio_info *info, struct inode *inode)
+{
+        struct uio_pdrv_genirq_platdata *priv = info->priv;
+
+        /* Wait until the Runtime PM code has woken up the device */
+        pm_runtime_get_sync(&priv->pdev->dev);
+        return 0;
+}
+
+static int uio_pdrv_genirq_release(struct uio_info *info, struct inode *inode)
+{
+        struct uio_pdrv_genirq_platdata *priv = info->priv;
+
+        /* Tell the Runtime PM code that the device has become idle */
+        pm_runtime_put_sync(&priv->pdev->dev);
+        return 0;
+}
+
 static irqreturn_t uio_pdrv_genirq_handler(int irq, struct uio_info *dev_info)
 {
         struct uio_pdrv_genirq_platdata *priv = dev_info->priv;
@@ -97,6 +117,7 @@ static int uio_pdrv_genirq_probe(struct platform_device *pdev)
         priv->uioinfo = uioinfo;
         spin_lock_init(&priv->lock);
         priv->flags = 0; /* interrupt is enabled to begin with */
+        priv->pdev = pdev;
 
         uiomem = &uioinfo->mem[0];
 
@@ -136,8 +157,17 @@ static int uio_pdrv_genirq_probe(struct platform_device *pdev)
         uioinfo->irq_flags |= IRQF_DISABLED;
         uioinfo->handler = uio_pdrv_genirq_handler;
         uioinfo->irqcontrol = uio_pdrv_genirq_irqcontrol;
+        uioinfo->open = uio_pdrv_genirq_open;
+        uioinfo->release = uio_pdrv_genirq_release;
         uioinfo->priv = priv;
 
+        /* Enable Runtime PM for this device:
+         * The device starts in suspended state to allow the hardware to be
+         * turned off by default. The Runtime PM bus code should power on the
+         * hardware and enable clocks at open().
+         */
+        pm_runtime_enable(&pdev->dev);
+
         ret = uio_register_device(&pdev->dev, priv->uioinfo);
         if (ret) {
                 dev_err(&pdev->dev, "unable to register uio device\n");
@@ -157,16 +187,40 @@ static int uio_pdrv_genirq_remove(struct platform_device *pdev)
         struct uio_pdrv_genirq_platdata *priv = platform_get_drvdata(pdev);
 
         uio_unregister_device(priv->uioinfo);
+        pm_runtime_disable(&pdev->dev);
         kfree(priv);
         return 0;
 }
 
+static int uio_pdrv_genirq_runtime_nop(struct device *dev)
+{
+        /* Runtime PM callback shared between ->runtime_suspend()
+         * and ->runtime_resume(). Simply returns success.
+         *
+         * In this driver pm_runtime_get_sync() and pm_runtime_put_sync()
+         * are used at open() and release() time. This allows the
+         * Runtime PM code to turn off power to the device while the
+         * device is unused, ie before open() and after release().
+         *
+         * This Runtime PM callback does not need to save or restore
+         * any registers since user space is responsbile for hardware
+         * register reinitialization after open().
+         */
+        return 0;
+}
+
+static struct dev_pm_ops uio_pdrv_genirq_dev_pm_ops = {
+        .runtime_suspend = uio_pdrv_genirq_runtime_nop,
+        .runtime_resume = uio_pdrv_genirq_runtime_nop,
+};
+
 static struct platform_driver uio_pdrv_genirq = {
         .probe = uio_pdrv_genirq_probe,
         .remove = uio_pdrv_genirq_remove,
         .driver = {
                 .name = DRIVER_NAME,
                 .owner = THIS_MODULE,
+                .pm = &uio_pdrv_genirq_dev_pm_ops,
         },
 };
 
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 2bfc41ece0e1..85a1a55815cf 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -858,10 +858,7 @@ static void acm_tty_set_termios(struct tty_struct *tty,
         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.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
         newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
         newline.bParityType = termios->c_cflag & PARENB ?
                                 (termios->c_cflag & PARODD ? 1 : 2) +
diff --git a/drivers/usb/class/usblp.c b/drivers/usb/class/usblp.c
index 26c09f0257db..9bc112ee7803 100644
--- a/drivers/usb/class/usblp.c
+++ b/drivers/usb/class/usblp.c
@@ -1057,14 +1057,14 @@ static const struct file_operations usblp_fops = {
         .release =      usblp_release,
 };
 
-static char *usblp_nodename(struct device *dev)
+static char *usblp_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
 }
 
 static struct usb_class_driver usblp_class = {
         .name =         "lp%d",
-        .nodename =     usblp_nodename,
+        .devnode =      usblp_devnode,
         .fops =         &usblp_fops,
         .minor_base =   USBLP_MINOR_BASE,
 };
diff --git a/drivers/usb/core/file.c b/drivers/usb/core/file.c
index 5cef88929b3e..222ee07ea680 100644
--- a/drivers/usb/core/file.c
+++ b/drivers/usb/core/file.c
@@ -67,14 +67,14 @@ static struct usb_class {
         struct class *class;
 } *usb_class;
 
-static char *usb_nodename(struct device *dev)
+static char *usb_devnode(struct device *dev, mode_t *mode)
 {
         struct usb_class_driver *drv;
 
         drv = dev_get_drvdata(dev);
-        if (!drv || !drv->nodename)
+        if (!drv || !drv->devnode)
                 return NULL;
-        return drv->nodename(dev);
+        return drv->devnode(dev, mode);
 }
 
 static int init_usb_class(void)
@@ -100,7 +100,7 @@ static int init_usb_class(void)
                 kfree(usb_class);
                 usb_class = NULL;
         }
-        usb_class->class->nodename = usb_nodename;
+        usb_class->class->devnode = usb_devnode;
 
 exit:
         return result;
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index a26f73880c32..43ee943d757a 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -311,7 +311,7 @@ static struct dev_pm_ops usb_device_pm_ops = {
 #endif  /* CONFIG_PM */
 
 
-static char *usb_nodename(struct device *dev)
+static char *usb_devnode(struct device *dev, mode_t *mode)
 {
         struct usb_device *usb_dev;
 
@@ -324,7 +324,7 @@ struct device_type usb_device_type = {
         .name =         "usb_device",
         .release =      usb_release_dev,
         .uevent =       usb_dev_uevent,
-        .nodename =     usb_nodename,
+        .devnode =      usb_devnode,
         .pm =           &usb_device_pm_ops,
 };
 
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 7f8e83a954ac..9f986b417c5b 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -251,6 +251,24 @@ config USB_PXA25X_SMALL
         default y if USB_ETH
         default y if USB_G_SERIAL
 
+config USB_GADGET_R8A66597
+        boolean "Renesas R8A66597 USB Peripheral Controller"
+        select USB_GADGET_DUALSPEED
+        help
+           R8A66597 is a discrete USB host and peripheral controller chip that
+           supports both full and high speed USB 2.0 data transfers.
+           It has nine configurable endpoints, and endpoint zero.
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "r8a66597_udc" and force all
+           gadget drivers to also be dynamically linked.
+
+config USB_R8A66597
+        tristate
+        depends on USB_GADGET_R8A66597
+        default USB_GADGET
+        select USB_GADGET_SELECTED
+
 config USB_GADGET_PXA27X
         boolean "PXA 27x"
         depends on ARCH_PXA && (PXA27x || PXA3xx)
@@ -360,16 +378,6 @@ config USB_M66592
         default USB_GADGET
         select USB_GADGET_SELECTED
 
-config SUPERH_BUILT_IN_M66592
-        boolean "Enable SuperH built-in USB like the M66592"
-        depends on USB_GADGET_M66592 && CPU_SUBTYPE_SH7722
-        help
-           SH7722 has USB like the M66592.
-
-           The transfer rate is very slow when use "Ethernet Gadget".
-           However, this problem is improved if change a value of
-           NET_IP_ALIGN to 4.
-
 #
 # Controllers available only in discrete form (and all PCI controllers)
 #
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index e6017e6bf6da..9d7b87c52e9f 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -23,6 +23,7 @@ ifeq ($(CONFIG_ARCH_MXC),y)
 fsl_usb2_udc-objs               += fsl_mx3_udc.o
 endif
 obj-$(CONFIG_USB_M66592)        += m66592-udc.o
+obj-$(CONFIG_USB_R8A66597)      += r8a66597-udc.o
 obj-$(CONFIG_USB_FSL_QE)        += fsl_qe_udc.o
 obj-$(CONFIG_USB_CI13XXX)       += ci13xxx_udc.o
 obj-$(CONFIG_USB_S3C_HSOTG)     += s3c-hsotg.o
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index 8e0e9a0b7364..f2d270b202f2 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -173,6 +173,12 @@
 // CONFIG_USB_GADGET_AU1X00
 // ...
 
+#ifdef CONFIG_USB_GADGET_R8A66597
+#define gadget_is_r8a66597(g)   !strcmp("r8a66597_udc", (g)->name)
+#else
+#define gadget_is_r8a66597(g)   0
+#endif
+
 
 /**
  * usb_gadget_controller_number - support bcdDevice id convention
@@ -239,6 +245,8 @@ static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
                 return 0x23;
         else if (gadget_is_langwell(gadget))
                 return 0x24;
+        else if (gadget_is_r8a66597(gadget))
+                return 0x25;
         return -ENOENT;
 }
 
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index 43dcf9e1af6b..a8c8543d1b08 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -25,44 +25,18 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
-
+#include <linux/err.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
 #include "m66592-udc.h"
 
-
 MODULE_DESCRIPTION("M66592 USB gadget driver");
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Yoshihiro Shimoda");
 MODULE_ALIAS("platform:m66592_udc");
 
-#define DRIVER_VERSION  "18 Oct 2007"
-
-/* module parameters */
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
-static unsigned short endian = M66592_LITTLE;
-module_param(endian, ushort, 0644);
-MODULE_PARM_DESC(endian, "data endian: big=0, little=0 (default=0)");
-#else
-static unsigned short clock = M66592_XTAL24;
-module_param(clock, ushort, 0644);
-MODULE_PARM_DESC(clock, "input clock: 48MHz=32768, 24MHz=16384, 12MHz=0 "
-                "(default=16384)");
-
-static unsigned short vif = M66592_LDRV;
-module_param(vif, ushort, 0644);
-MODULE_PARM_DESC(vif, "input VIF: 3.3V=32768, 1.5V=0 (default=32768)");
-
-static unsigned short endian;
-module_param(endian, ushort, 0644);
-MODULE_PARM_DESC(endian, "data endian: big=256, little=0 (default=0)");
-
-static unsigned short irq_sense = M66592_INTL;
-module_param(irq_sense, ushort, 0644);
-MODULE_PARM_DESC(irq_sense, "IRQ sense: low level=2, falling edge=0 "
-                "(default=2)");
-#endif
+#define DRIVER_VERSION  "21 July 2009"
 
 static const char udc_name[] = "m66592_udc";
 static const char *m66592_ep_name[] = {
@@ -244,6 +218,7 @@ static inline int get_buffer_size(struct m66592 *m66592, u16 pipenum)
 static inline void pipe_change(struct m66592 *m66592, u16 pipenum)
 {
         struct m66592_ep *ep = m66592->pipenum2ep[pipenum];
+        unsigned short mbw;
 
         if (ep->use_dma)
                 return;
@@ -252,7 +227,12 @@ static inline void pipe_change(struct m66592 *m66592, u16 pipenum)
 
         ndelay(450);
 
-        m66592_bset(m66592, M66592_MBW, ep->fifosel);
+        if (m66592->pdata->on_chip)
+                mbw = M66592_MBW_32;
+        else
+                mbw = M66592_MBW_16;
+
+        m66592_bset(m66592, mbw, ep->fifosel);
 }
 
 static int pipe_buffer_setting(struct m66592 *m66592,
@@ -276,24 +256,27 @@ static int pipe_buffer_setting(struct m66592 *m66592,
                 buf_bsize = 0;
                 break;
         case M66592_BULK:
-                bufnum = m66592->bi_bufnum +
-                         (info->pipe - M66592_BASE_PIPENUM_BULK) * 16;
-                m66592->bi_bufnum += 16;
+                /* isochronous pipes may be used as bulk pipes */
+                if (info->pipe > M66592_BASE_PIPENUM_BULK)
+                        bufnum = info->pipe - M66592_BASE_PIPENUM_BULK;
+                else
+                        bufnum = info->pipe - M66592_BASE_PIPENUM_ISOC;
+
+                bufnum = M66592_BASE_BUFNUM + (bufnum * 16);
                 buf_bsize = 7;
                 pipecfg |= M66592_DBLB;
                 if (!info->dir_in)
                         pipecfg |= M66592_SHTNAK;
                 break;
         case M66592_ISO:
-                bufnum = m66592->bi_bufnum +
+                bufnum = M66592_BASE_BUFNUM +
                          (info->pipe - M66592_BASE_PIPENUM_ISOC) * 16;
-                m66592->bi_bufnum += 16;
                 buf_bsize = 7;
                 break;
         }
-        if (m66592->bi_bufnum > M66592_MAX_BUFNUM) {
-                pr_err("m66592 pipe memory is insufficient(%d)\n",
-                                m66592->bi_bufnum);
+
+        if (buf_bsize && ((bufnum + 16) >= M66592_MAX_BUFNUM)) {
+                pr_err("m66592 pipe memory is insufficient\n");
                 return -ENOMEM;
         }
 
@@ -313,17 +296,6 @@ static void pipe_buffer_release(struct m66592 *m66592,
         if (info->pipe == 0)
                 return;
 
-        switch (info->type) {
-        case M66592_BULK:
-                if (is_bulk_pipe(info->pipe))
-                        m66592->bi_bufnum -= 16;
-                break;
-        case M66592_ISO:
-                if (is_isoc_pipe(info->pipe))
-                        m66592->bi_bufnum -= 16;
-                break;
-        }
-
         if (is_bulk_pipe(info->pipe)) {
                 m66592->bulk--;
         } else if (is_interrupt_pipe(info->pipe))
@@ -340,6 +312,7 @@ static void pipe_buffer_release(struct m66592 *m66592,
 static void pipe_initialize(struct m66592_ep *ep)
 {
         struct m66592 *m66592 = ep->m66592;
+        unsigned short mbw;
 
         m66592_mdfy(m66592, 0, M66592_CURPIPE, ep->fifosel);
 
@@ -351,7 +324,12 @@ static void pipe_initialize(struct m66592_ep *ep)
 
                 ndelay(450);
 
-                m66592_bset(m66592, M66592_MBW, ep->fifosel);
+                if (m66592->pdata->on_chip)
+                        mbw = M66592_MBW_32;
+                else
+                        mbw = M66592_MBW_16;
+
+                m66592_bset(m66592, mbw, ep->fifosel);
         }
 }
 
@@ -367,15 +345,13 @@ static void m66592_ep_setting(struct m66592 *m66592, struct m66592_ep *ep,
                         ep->fifosel = M66592_D0FIFOSEL;
                         ep->fifoctr = M66592_D0FIFOCTR;
                         ep->fifotrn = M66592_D0FIFOTRN;
-#if !defined(CONFIG_SUPERH_BUILT_IN_M66592)
-                } else if (m66592->num_dma == 1) {
+                } else if (!m66592->pdata->on_chip && m66592->num_dma == 1) {
                         m66592->num_dma++;
                         ep->use_dma = 1;
                         ep->fifoaddr = M66592_D1FIFO;
                         ep->fifosel = M66592_D1FIFOSEL;
                         ep->fifoctr = M66592_D1FIFOCTR;
                         ep->fifotrn = M66592_D1FIFOTRN;
-#endif
                 } else {
                         ep->use_dma = 0;
                         ep->fifoaddr = M66592_CFIFO;
@@ -620,76 +596,120 @@ static void start_ep0(struct m66592_ep *ep, struct m66592_request *req)
         }
 }
 
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
 static void init_controller(struct m66592 *m66592)
 {
-        m66592_bset(m66592, M66592_HSE, M66592_SYSCFG);         /* High spd */
-        m66592_bclr(m66592, M66592_USBE, M66592_SYSCFG);
-        m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
-        m66592_bset(m66592, M66592_USBE, M66592_SYSCFG);
+        unsigned int endian;
 
-        /* This is a workaound for SH7722 2nd cut */
-        m66592_bset(m66592, 0x8000, M66592_DVSTCTR);
-        m66592_bset(m66592, 0x1000, M66592_TESTMODE);
-        m66592_bclr(m66592, 0x8000, M66592_DVSTCTR);
+        if (m66592->pdata->on_chip) {
+                if (m66592->pdata->endian)
+                        endian = 0; /* big endian */
+                else
+                        endian = M66592_LITTLE; /* little endian */
 
-        m66592_bset(m66592, M66592_INTL, M66592_INTENB1);
+                m66592_bset(m66592, M66592_HSE, M66592_SYSCFG); /* High spd */
+                m66592_bclr(m66592, M66592_USBE, M66592_SYSCFG);
+                m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
+                m66592_bset(m66592, M66592_USBE, M66592_SYSCFG);
 
-        m66592_write(m66592, 0, M66592_CFBCFG);
-        m66592_write(m66592, 0, M66592_D0FBCFG);
-        m66592_bset(m66592, endian, M66592_CFBCFG);
-        m66592_bset(m66592, endian, M66592_D0FBCFG);
-}
-#else   /* #if defined(CONFIG_SUPERH_BUILT_IN_M66592) */
-static void init_controller(struct m66592 *m66592)
-{
-        m66592_bset(m66592, (vif & M66592_LDRV) | (endian & M66592_BIGEND),
-                        M66592_PINCFG);
-        m66592_bset(m66592, M66592_HSE, M66592_SYSCFG);         /* High spd */
-        m66592_mdfy(m66592, clock & M66592_XTAL, M66592_XTAL, M66592_SYSCFG);
+                /* This is a workaound for SH7722 2nd cut */
+                m66592_bset(m66592, 0x8000, M66592_DVSTCTR);
+                m66592_bset(m66592, 0x1000, M66592_TESTMODE);
+                m66592_bclr(m66592, 0x8000, M66592_DVSTCTR);
 
-        m66592_bclr(m66592, M66592_USBE, M66592_SYSCFG);
-        m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
-        m66592_bset(m66592, M66592_USBE, M66592_SYSCFG);
+                m66592_bset(m66592, M66592_INTL, M66592_INTENB1);
+
+                m66592_write(m66592, 0, M66592_CFBCFG);
+                m66592_write(m66592, 0, M66592_D0FBCFG);
+                m66592_bset(m66592, endian, M66592_CFBCFG);
+                m66592_bset(m66592, endian, M66592_D0FBCFG);
+        } else {
+                unsigned int clock, vif, irq_sense;
+
+                if (m66592->pdata->endian)
+                        endian = M66592_BIGEND; /* big endian */
+                else
+                        endian = 0; /* little endian */
+
+                if (m66592->pdata->vif)
+                        vif = M66592_LDRV; /* 3.3v */
+                else
+                        vif = 0; /* 1.5v */
+
+                switch (m66592->pdata->xtal) {
+                case M66592_PLATDATA_XTAL_12MHZ:
+                        clock = M66592_XTAL12;
+                        break;
+                case M66592_PLATDATA_XTAL_24MHZ:
+                        clock = M66592_XTAL24;
+                        break;
+                case M66592_PLATDATA_XTAL_48MHZ:
+                        clock = M66592_XTAL48;
+                        break;
+                default:
+                        pr_warning("m66592-udc: xtal configuration error\n");
+                        clock = 0;
+                }
+
+                switch (m66592->irq_trigger) {
+                case IRQF_TRIGGER_LOW:
+                        irq_sense = M66592_INTL;
+                        break;
+                case IRQF_TRIGGER_FALLING:
+                        irq_sense = 0;
+                        break;
+                default:
+                        pr_warning("m66592-udc: irq trigger config error\n");
+                        irq_sense = 0;
+                }
 
-        m66592_bset(m66592, M66592_XCKE, M66592_SYSCFG);
+                m66592_bset(m66592,
+                            (vif & M66592_LDRV) | (endian & M66592_BIGEND),
+                            M66592_PINCFG);
+                m66592_bset(m66592, M66592_HSE, M66592_SYSCFG); /* High spd */
+                m66592_mdfy(m66592, clock & M66592_XTAL, M66592_XTAL,
+                            M66592_SYSCFG);
+                m66592_bclr(m66592, M66592_USBE, M66592_SYSCFG);
+                m66592_bclr(m66592, M66592_DPRPU, M66592_SYSCFG);
+                m66592_bset(m66592, M66592_USBE, M66592_SYSCFG);
+
+                m66592_bset(m66592, M66592_XCKE, M66592_SYSCFG);
 
-        msleep(3);
+                msleep(3);
 
-        m66592_bset(m66592, M66592_RCKE | M66592_PLLC, M66592_SYSCFG);
+                m66592_bset(m66592, M66592_RCKE | M66592_PLLC, M66592_SYSCFG);
 
-        msleep(1);
+                msleep(1);
 
-        m66592_bset(m66592, M66592_SCKE, M66592_SYSCFG);
+                m66592_bset(m66592, M66592_SCKE, M66592_SYSCFG);
 
-        m66592_bset(m66592, irq_sense & M66592_INTL, M66592_INTENB1);
-        m66592_write(m66592, M66592_BURST | M66592_CPU_ADR_RD_WR,
-                        M66592_DMA0CFG);
+                m66592_bset(m66592, irq_sense & M66592_INTL, M66592_INTENB1);
+                m66592_write(m66592, M66592_BURST | M66592_CPU_ADR_RD_WR,
+                             M66592_DMA0CFG);
+        }
 }
-#endif  /* #if defined(CONFIG_SUPERH_BUILT_IN_M66592) */
 
 static void disable_controller(struct m66592 *m66592)
 {
-#if !defined(CONFIG_SUPERH_BUILT_IN_M66592)
-        m66592_bclr(m66592, M66592_SCKE, M66592_SYSCFG);
-        udelay(1);
-        m66592_bclr(m66592, M66592_PLLC, M66592_SYSCFG);
-        udelay(1);
-        m66592_bclr(m66592, M66592_RCKE, M66592_SYSCFG);
-        udelay(1);
-        m66592_bclr(m66592, M66592_XCKE, M66592_SYSCFG);
-#endif
+        if (!m66592->pdata->on_chip) {
+                m66592_bclr(m66592, M66592_SCKE, M66592_SYSCFG);
+                udelay(1);
+                m66592_bclr(m66592, M66592_PLLC, M66592_SYSCFG);
+                udelay(1);
+                m66592_bclr(m66592, M66592_RCKE, M66592_SYSCFG);
+                udelay(1);
+                m66592_bclr(m66592, M66592_XCKE, M66592_SYSCFG);
+        }
 }
 
 static void m66592_start_xclock(struct m66592 *m66592)
 {
-#if !defined(CONFIG_SUPERH_BUILT_IN_M66592)
         u16 tmp;
 
-        tmp = m66592_read(m66592, M66592_SYSCFG);
-        if (!(tmp & M66592_XCKE))
-                m66592_bset(m66592, M66592_XCKE, M66592_SYSCFG);
-#endif
+        if (!m66592->pdata->on_chip) {
+                tmp = m66592_read(m66592, M66592_SYSCFG);
+                if (!(tmp & M66592_XCKE))
+                        m66592_bset(m66592, M66592_XCKE, M66592_SYSCFG);
+        }
 }
 
 /*-------------------------------------------------------------------------*/
@@ -1177,8 +1197,7 @@ static irqreturn_t m66592_irq(int irq, void *_m66592)
         intsts0 = m66592_read(m66592, M66592_INTSTS0);
         intenb0 = m66592_read(m66592, M66592_INTENB0);
 
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
-        if (!intsts0 && !intenb0) {
+        if (m66592->pdata->on_chip && !intsts0 && !intenb0) {
                 /*
                  * When USB clock stops, it cannot read register. Even if a
                  * clock stops, the interrupt occurs. So this driver turn on
@@ -1188,7 +1207,6 @@ static irqreturn_t m66592_irq(int irq, void *_m66592)
                 intsts0 = m66592_read(m66592, M66592_INTSTS0);
                 intenb0 = m66592_read(m66592, M66592_INTENB0);
         }
-#endif
 
         savepipe = m66592_read(m66592, M66592_CFIFOSEL);
 
@@ -1534,9 +1552,11 @@ static int __exit m66592_remove(struct platform_device *pdev)
         iounmap(m66592->reg);
         free_irq(platform_get_irq(pdev, 0), m66592);
         m66592_free_request(&m66592->ep[0].ep, m66592->ep0_req);
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592) && defined(CONFIG_HAVE_CLK)
-        clk_disable(m66592->clk);
-        clk_put(m66592->clk);
+#ifdef CONFIG_HAVE_CLK
+        if (m66592->pdata->on_chip) {
+                clk_disable(m66592->clk);
+                clk_put(m66592->clk);
+        }
 #endif
         kfree(m66592);
         return 0;
@@ -1548,11 +1568,10 @@ static void nop_completion(struct usb_ep *ep, struct usb_request *r)
 
 static int __init m66592_probe(struct platform_device *pdev)
 {
-        struct resource *res;
-        int irq;
+        struct resource *res, *ires;
         void __iomem *reg = NULL;
         struct m66592 *m66592 = NULL;
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592) && defined(CONFIG_HAVE_CLK)
+#ifdef CONFIG_HAVE_CLK
         char clk_name[8];
 #endif
         int ret = 0;
@@ -1565,10 +1584,11 @@ static int __init m66592_probe(struct platform_device *pdev)
                 goto clean_up;
         }
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!ires) {
                 ret = -ENODEV;
-                pr_err("platform_get_irq error.\n");
+                dev_err(&pdev->dev,
+                        "platform_get_resource IORESOURCE_IRQ error.\n");
                 goto clean_up;
         }
 
@@ -1579,6 +1599,12 @@ static int __init m66592_probe(struct platform_device *pdev)
                 goto clean_up;
         }
 
+        if (pdev->dev.platform_data == NULL) {
+                dev_err(&pdev->dev, "no platform data\n");
+                ret = -ENODEV;
+                goto clean_up;
+        }
+
         /* initialize ucd */
         m66592 = kzalloc(sizeof(struct m66592), GFP_KERNEL);
         if (m66592 == NULL) {
@@ -1586,6 +1612,9 @@ static int __init m66592_probe(struct platform_device *pdev)
                 goto clean_up;
         }
 
+        m66592->pdata = pdev->dev.platform_data;
+        m66592->irq_trigger = ires->flags & IRQF_TRIGGER_MASK;
+
         spin_lock_init(&m66592->lock);
         dev_set_drvdata(&pdev->dev, m66592);
 
@@ -1603,24 +1632,25 @@ static int __init m66592_probe(struct platform_device *pdev)
         m66592->timer.data = (unsigned long)m66592;
         m66592->reg = reg;
 
-        m66592->bi_bufnum = M66592_BASE_BUFNUM;
-
-        ret = request_irq(irq, m66592_irq, IRQF_DISABLED | IRQF_SHARED,
+        ret = request_irq(ires->start, m66592_irq, IRQF_DISABLED | IRQF_SHARED,
                         udc_name, m66592);
         if (ret < 0) {
                 pr_err("request_irq error (%d)\n", ret);
                 goto clean_up;
         }
 
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592) && defined(CONFIG_HAVE_CLK)
-        snprintf(clk_name, sizeof(clk_name), "usbf%d", pdev->id);
-        m66592->clk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(m66592->clk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                ret = PTR_ERR(m66592->clk);
-                goto clean_up2;
+#ifdef CONFIG_HAVE_CLK
+        if (m66592->pdata->on_chip) {
+                snprintf(clk_name, sizeof(clk_name), "usbf%d", pdev->id);
+                m66592->clk = clk_get(&pdev->dev, clk_name);
+                if (IS_ERR(m66592->clk)) {
+                        dev_err(&pdev->dev, "cannot get clock \"%s\"\n",
+                                clk_name);
+                        ret = PTR_ERR(m66592->clk);
+                        goto clean_up2;
+                }
+                clk_enable(m66592->clk);
         }
-        clk_enable(m66592->clk);
 #endif
         INIT_LIST_HEAD(&m66592->gadget.ep_list);
         m66592->gadget.ep0 = &m66592->ep[0].ep;
@@ -1662,12 +1692,14 @@ static int __init m66592_probe(struct platform_device *pdev)
         return 0;
 
 clean_up3:
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592) && defined(CONFIG_HAVE_CLK)
-        clk_disable(m66592->clk);
-        clk_put(m66592->clk);
+#ifdef CONFIG_HAVE_CLK
+        if (m66592->pdata->on_chip) {
+                clk_disable(m66592->clk);
+                clk_put(m66592->clk);
+        }
 clean_up2:
 #endif
-        free_irq(irq, m66592);
+        free_irq(ires->start, m66592);
 clean_up:
         if (m66592) {
                 if (m66592->ep0_req)
diff --git a/drivers/usb/gadget/m66592-udc.h b/drivers/usb/gadget/m66592-udc.h
index 286ce07e7960..8b960deed680 100644
--- a/drivers/usb/gadget/m66592-udc.h
+++ b/drivers/usb/gadget/m66592-udc.h
@@ -23,10 +23,12 @@
 #ifndef __M66592_UDC_H__
 #define __M66592_UDC_H__
 
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592) && defined(CONFIG_HAVE_CLK)
+#ifdef CONFIG_HAVE_CLK
 #include <linux/clk.h>
 #endif
 
+#include <linux/usb/m66592.h>
+
 #define M66592_SYSCFG           0x00
 #define M66592_XTAL             0xC000  /* b15-14: Crystal selection */
 #define   M66592_XTAL48          0x8000         /* 48MHz */
@@ -76,11 +78,11 @@
 #define   M66592_P_TST_J         0x0001         /* PERI TEST J */
 #define   M66592_P_TST_NORMAL    0x0000         /* PERI Normal Mode */
 
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
+/* built-in registers */
 #define M66592_CFBCFG           0x0A
 #define M66592_D0FBCFG          0x0C
 #define M66592_LITTLE           0x0100  /* b8: Little endian mode */
-#else
+/* external chip case */
 #define M66592_PINCFG           0x0A
 #define M66592_LDRV             0x8000  /* b15: Drive Current Adjust */
 #define M66592_BIGEND           0x0100  /* b8: Big endian mode */
@@ -100,8 +102,8 @@
 #define M66592_PKTM             0x0020  /* b5: Packet mode */
 #define M66592_DENDE            0x0010  /* b4: Dend enable */
 #define M66592_OBUS             0x0004  /* b2: OUTbus mode */
-#endif  /* #if defined(CONFIG_SUPERH_BUILT_IN_M66592) */
 
+/* common case */
 #define M66592_CFIFO            0x10
 #define M66592_D0FIFO           0x14
 #define M66592_D1FIFO           0x18
@@ -113,13 +115,9 @@
 #define M66592_REW              0x4000  /* b14: Buffer rewind */
 #define M66592_DCLRM            0x2000  /* b13: DMA buffer clear mode */
 #define M66592_DREQE            0x1000  /* b12: DREQ output enable */
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
-#define M66592_MBW              0x0800  /* b11: Maximum bit width for FIFO */
-#else
-#define M66592_MBW              0x0400  /* b10: Maximum bit width for FIFO */
-#define   M66592_MBW_8           0x0000   /*  8bit */
-#define   M66592_MBW_16          0x0400   /* 16bit */
-#endif  /* #if defined(CONFIG_SUPERH_BUILT_IN_M66592) */
+#define M66592_MBW_8            0x0000   /*  8bit */
+#define M66592_MBW_16           0x0400   /* 16bit */
+#define M66592_MBW_32           0x0800   /* 32bit */
 #define M66592_TRENB            0x0200  /* b9: Transaction counter enable */
 #define M66592_TRCLR            0x0100  /* b8: Transaction counter clear */
 #define M66592_DEZPM            0x0080  /* b7: Zero-length packet mode */
@@ -480,9 +478,11 @@ struct m66592_ep {
 struct m66592 {
         spinlock_t              lock;
         void __iomem            *reg;
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592) && defined(CONFIG_HAVE_CLK)
+#ifdef CONFIG_HAVE_CLK
         struct clk *clk;
 #endif
+        struct m66592_platdata  *pdata;
+        unsigned long           irq_trigger;
 
         struct usb_gadget               gadget;
         struct usb_gadget_driver        *driver;
@@ -506,7 +506,6 @@ struct m66592 {
         int interrupt;
         int isochronous;
         int num_dma;
-        int bi_bufnum;  /* bulk and isochronous's bufnum */
 };
 
 #define gadget_to_m66592(_gadget) container_of(_gadget, struct m66592, gadget)
@@ -547,13 +546,13 @@ static inline void m66592_read_fifo(struct m66592 *m66592,
 {
         unsigned long fifoaddr = (unsigned long)m66592->reg + offset;
 
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
-        len = (len + 3) / 4;
-        insl(fifoaddr, buf, len);
-#else
-        len = (len + 1) / 2;
-        insw(fifoaddr, buf, len);
-#endif
+        if (m66592->pdata->on_chip) {
+                len = (len + 3) / 4;
+                insl(fifoaddr, buf, len);
+        } else {
+                len = (len + 1) / 2;
+                insw(fifoaddr, buf, len);
+        }
 }
 
 static inline void m66592_write(struct m66592 *m66592, u16 val,
@@ -567,33 +566,34 @@ static inline void m66592_write_fifo(struct m66592 *m66592,
                 void *buf, unsigned long len)
 {
         unsigned long fifoaddr = (unsigned long)m66592->reg + offset;
-#if defined(CONFIG_SUPERH_BUILT_IN_M66592)
-        unsigned long count;
-        unsigned char *pb;
-        int i;
-
-        count = len / 4;
-        outsl(fifoaddr, buf, count);
-
-        if (len & 0x00000003) {
-                pb = buf + count * 4;
-                for (i = 0; i < (len & 0x00000003); i++) {
-                        if (m66592_read(m66592, M66592_CFBCFG)) /* little */
-                                outb(pb[i], fifoaddr + (3 - i));
-                        else
-                                outb(pb[i], fifoaddr + i);
+
+        if (m66592->pdata->on_chip) {
+                unsigned long count;
+                unsigned char *pb;
+                int i;
+
+                count = len / 4;
+                outsl(fifoaddr, buf, count);
+
+                if (len & 0x00000003) {
+                        pb = buf + count * 4;
+                        for (i = 0; i < (len & 0x00000003); i++) {
+                                if (m66592_read(m66592, M66592_CFBCFG)) /* le */
+                                        outb(pb[i], fifoaddr + (3 - i));
+                                else
+                                        outb(pb[i], fifoaddr + i);
+                        }
+                }
+        } else {
+                unsigned long odd = len & 0x0001;
+
+                len = len / 2;
+                outsw(fifoaddr, buf, len);
+                if (odd) {
+                        unsigned char *p = buf + len*2;
+                        outb(*p, fifoaddr);
                 }
         }
-#else
-        unsigned long odd = len & 0x0001;
-
-        len = len / 2;
-        outsw(fifoaddr, buf, len);
-        if (odd) {
-                unsigned char *p = buf + len*2;
-                outb(*p, fifoaddr);
-        }
-#endif  /* #if defined(CONFIG_SUPERH_BUILT_IN_M66592) */
 }
 
 static inline void m66592_mdfy(struct m66592 *m66592, u16 val, u16 pat,
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
new file mode 100644
index 000000000000..e220fb8091a3
--- /dev/null
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -0,0 +1,1689 @@
+/*
+ * R8A66597 UDC (USB gadget)
+ *
+ * Copyright (C) 2006-2009 Renesas Solutions Corp.
+ *
+ * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+
+#include "r8a66597-udc.h"
+
+#define DRIVER_VERSION  "2009-08-18"
+
+static const char udc_name[] = "r8a66597_udc";
+static const char *r8a66597_ep_name[] = {
+        "ep0", "ep1", "ep2", "ep3", "ep4", "ep5", "ep6", "ep7",
+        "ep8", "ep9",
+};
+
+static void disable_controller(struct r8a66597 *r8a66597);
+static void irq_ep0_write(struct r8a66597_ep *ep, struct r8a66597_request *req);
+static void irq_packet_write(struct r8a66597_ep *ep,
+                                struct r8a66597_request *req);
+static int r8a66597_queue(struct usb_ep *_ep, struct usb_request *_req,
+                        gfp_t gfp_flags);
+
+static void transfer_complete(struct r8a66597_ep *ep,
+                struct r8a66597_request *req, int status);
+
+/*-------------------------------------------------------------------------*/
+static inline u16 get_usb_speed(struct r8a66597 *r8a66597)
+{
+        return r8a66597_read(r8a66597, DVSTCTR0) & RHST;
+}
+
+static void enable_pipe_irq(struct r8a66597 *r8a66597, u16 pipenum,
+                unsigned long reg)
+{
+        u16 tmp;
+
+        tmp = r8a66597_read(r8a66597, INTENB0);
+        r8a66597_bclr(r8a66597, BEMPE | NRDYE | BRDYE,
+                        INTENB0);
+        r8a66597_bset(r8a66597, (1 << pipenum), reg);
+        r8a66597_write(r8a66597, tmp, INTENB0);
+}
+
+static void disable_pipe_irq(struct r8a66597 *r8a66597, u16 pipenum,
+                unsigned long reg)
+{
+        u16 tmp;
+
+        tmp = r8a66597_read(r8a66597, INTENB0);
+        r8a66597_bclr(r8a66597, BEMPE | NRDYE | BRDYE,
+                        INTENB0);
+        r8a66597_bclr(r8a66597, (1 << pipenum), reg);
+        r8a66597_write(r8a66597, tmp, INTENB0);
+}
+
+static void r8a66597_usb_connect(struct r8a66597 *r8a66597)
+{
+        r8a66597_bset(r8a66597, CTRE, INTENB0);
+        r8a66597_bset(r8a66597, BEMPE | BRDYE, INTENB0);
+
+        r8a66597_bset(r8a66597, DPRPU, SYSCFG0);
+}
+
+static void r8a66597_usb_disconnect(struct r8a66597 *r8a66597)
+__releases(r8a66597->lock)
+__acquires(r8a66597->lock)
+{
+        r8a66597_bclr(r8a66597, CTRE, INTENB0);
+        r8a66597_bclr(r8a66597, BEMPE | BRDYE, INTENB0);
+        r8a66597_bclr(r8a66597, DPRPU, SYSCFG0);
+
+        r8a66597->gadget.speed = USB_SPEED_UNKNOWN;
+        spin_unlock(&r8a66597->lock);
+        r8a66597->driver->disconnect(&r8a66597->gadget);
+        spin_lock(&r8a66597->lock);
+
+        disable_controller(r8a66597);
+        INIT_LIST_HEAD(&r8a66597->ep[0].queue);
+}
+
+static inline u16 control_reg_get_pid(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        u16 pid = 0;
+        unsigned long offset;
+
+        if (pipenum == 0)
+                pid = r8a66597_read(r8a66597, DCPCTR) & PID;
+        else if (pipenum < R8A66597_MAX_NUM_PIPE) {
+                offset = get_pipectr_addr(pipenum);
+                pid = r8a66597_read(r8a66597, offset) & PID;
+        } else
+                printk(KERN_ERR "unexpect pipe num (%d)\n", pipenum);
+
+        return pid;
+}
+
+static inline void control_reg_set_pid(struct r8a66597 *r8a66597, u16 pipenum,
+                u16 pid)
+{
+        unsigned long offset;
+
+        if (pipenum == 0)
+                r8a66597_mdfy(r8a66597, pid, PID, DCPCTR);
+        else if (pipenum < R8A66597_MAX_NUM_PIPE) {
+                offset = get_pipectr_addr(pipenum);
+                r8a66597_mdfy(r8a66597, pid, PID, offset);
+        } else
+                printk(KERN_ERR "unexpect pipe num (%d)\n", pipenum);
+}
+
+static inline void pipe_start(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        control_reg_set_pid(r8a66597, pipenum, PID_BUF);
+}
+
+static inline void pipe_stop(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        control_reg_set_pid(r8a66597, pipenum, PID_NAK);
+}
+
+static inline void pipe_stall(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        control_reg_set_pid(r8a66597, pipenum, PID_STALL);
+}
+
+static inline u16 control_reg_get(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        u16 ret = 0;
+        unsigned long offset;
+
+        if (pipenum == 0)
+                ret = r8a66597_read(r8a66597, DCPCTR);
+        else if (pipenum < R8A66597_MAX_NUM_PIPE) {
+                offset = get_pipectr_addr(pipenum);
+                ret = r8a66597_read(r8a66597, offset);
+        } else
+                printk(KERN_ERR "unexpect pipe num (%d)\n", pipenum);
+
+        return ret;
+}
+
+static inline void control_reg_sqclr(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        unsigned long offset;
+
+        pipe_stop(r8a66597, pipenum);
+
+        if (pipenum == 0)
+                r8a66597_bset(r8a66597, SQCLR, DCPCTR);
+        else if (pipenum < R8A66597_MAX_NUM_PIPE) {
+                offset = get_pipectr_addr(pipenum);
+                r8a66597_bset(r8a66597, SQCLR, offset);
+        } else
+                printk(KERN_ERR "unexpect pipe num(%d)\n", pipenum);
+}
+
+static inline int get_buffer_size(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        u16 tmp;
+        int size;
+
+        if (pipenum == 0) {
+                tmp = r8a66597_read(r8a66597, DCPCFG);
+                if ((tmp & R8A66597_CNTMD) != 0)
+                        size = 256;
+                else {
+                        tmp = r8a66597_read(r8a66597, DCPMAXP);
+                        size = tmp & MAXP;
+                }
+        } else {
+                r8a66597_write(r8a66597, pipenum, PIPESEL);
+                tmp = r8a66597_read(r8a66597, PIPECFG);
+                if ((tmp & R8A66597_CNTMD) != 0) {
+                        tmp = r8a66597_read(r8a66597, PIPEBUF);
+                        size = ((tmp >> 10) + 1) * 64;
+                } else {
+                        tmp = r8a66597_read(r8a66597, PIPEMAXP);
+                        size = tmp & MXPS;
+                }
+        }
+
+        return size;
+}
+
+static inline unsigned short mbw_value(struct r8a66597 *r8a66597)
+{
+        if (r8a66597->pdata->on_chip)
+                return MBW_32;
+        else
+                return MBW_16;
+}
+
+static inline void pipe_change(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        struct r8a66597_ep *ep = r8a66597->pipenum2ep[pipenum];
+
+        if (ep->use_dma)
+                return;
+
+        r8a66597_mdfy(r8a66597, pipenum, CURPIPE, ep->fifosel);
+
+        ndelay(450);
+
+        r8a66597_bset(r8a66597, mbw_value(r8a66597), ep->fifosel);
+}
+
+static int pipe_buffer_setting(struct r8a66597 *r8a66597,
+                struct r8a66597_pipe_info *info)
+{
+        u16 bufnum = 0, buf_bsize = 0;
+        u16 pipecfg = 0;
+
+        if (info->pipe == 0)
+                return -EINVAL;
+
+        r8a66597_write(r8a66597, info->pipe, PIPESEL);
+
+        if (info->dir_in)
+                pipecfg |= R8A66597_DIR;
+        pipecfg |= info->type;
+        pipecfg |= info->epnum;
+        switch (info->type) {
+        case R8A66597_INT:
+                bufnum = 4 + (info->pipe - R8A66597_BASE_PIPENUM_INT);
+                buf_bsize = 0;
+                break;
+        case R8A66597_BULK:
+                /* isochronous pipes may be used as bulk pipes */
+                if (info->pipe > R8A66597_BASE_PIPENUM_BULK)
+                        bufnum = info->pipe - R8A66597_BASE_PIPENUM_BULK;
+                else
+                        bufnum = info->pipe - R8A66597_BASE_PIPENUM_ISOC;
+
+                bufnum = R8A66597_BASE_BUFNUM + (bufnum * 16);
+                buf_bsize = 7;
+                pipecfg |= R8A66597_DBLB;
+                if (!info->dir_in)
+                        pipecfg |= R8A66597_SHTNAK;
+                break;
+        case R8A66597_ISO:
+                bufnum = R8A66597_BASE_BUFNUM +
+                         (info->pipe - R8A66597_BASE_PIPENUM_ISOC) * 16;
+                buf_bsize = 7;
+                break;
+        }
+
+        if (buf_bsize && ((bufnum + 16) >= R8A66597_MAX_BUFNUM)) {
+                pr_err(KERN_ERR "r8a66597 pipe memory is insufficient\n");
+                return -ENOMEM;
+        }
+
+        r8a66597_write(r8a66597, pipecfg, PIPECFG);
+        r8a66597_write(r8a66597, (buf_bsize << 10) | (bufnum), PIPEBUF);
+        r8a66597_write(r8a66597, info->maxpacket, PIPEMAXP);
+        if (info->interval)
+                info->interval--;
+        r8a66597_write(r8a66597, info->interval, PIPEPERI);
+
+        return 0;
+}
+
+static void pipe_buffer_release(struct r8a66597 *r8a66597,
+                                struct r8a66597_pipe_info *info)
+{
+        if (info->pipe == 0)
+                return;
+
+        if (is_bulk_pipe(info->pipe))
+                r8a66597->bulk--;
+        else if (is_interrupt_pipe(info->pipe))
+                r8a66597->interrupt--;
+        else if (is_isoc_pipe(info->pipe)) {
+                r8a66597->isochronous--;
+                if (info->type == R8A66597_BULK)
+                        r8a66597->bulk--;
+        } else
+                printk(KERN_ERR "ep_release: unexpect pipenum (%d)\n",
+                                info->pipe);
+}
+
+static void pipe_initialize(struct r8a66597_ep *ep)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+
+        r8a66597_mdfy(r8a66597, 0, CURPIPE, ep->fifosel);
+
+        r8a66597_write(r8a66597, ACLRM, ep->pipectr);
+        r8a66597_write(r8a66597, 0, ep->pipectr);
+        r8a66597_write(r8a66597, SQCLR, ep->pipectr);
+        if (ep->use_dma) {
+                r8a66597_mdfy(r8a66597, ep->pipenum, CURPIPE, ep->fifosel);
+
+                ndelay(450);
+
+                r8a66597_bset(r8a66597, mbw_value(r8a66597), ep->fifosel);
+        }
+}
+
+static void r8a66597_ep_setting(struct r8a66597 *r8a66597,
+                                struct r8a66597_ep *ep,
+                                const struct usb_endpoint_descriptor *desc,
+                                u16 pipenum, int dma)
+{
+        ep->use_dma = 0;
+        ep->fifoaddr = CFIFO;
+        ep->fifosel = CFIFOSEL;
+        ep->fifoctr = CFIFOCTR;
+        ep->fifotrn = 0;
+
+        ep->pipectr = get_pipectr_addr(pipenum);
+        ep->pipenum = pipenum;
+        ep->ep.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+        r8a66597->pipenum2ep[pipenum] = ep;
+        r8a66597->epaddr2ep[desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK]
+                = ep;
+        INIT_LIST_HEAD(&ep->queue);
+}
+
+static void r8a66597_ep_release(struct r8a66597_ep *ep)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+        u16 pipenum = ep->pipenum;
+
+        if (pipenum == 0)
+                return;
+
+        if (ep->use_dma)
+                r8a66597->num_dma--;
+        ep->pipenum = 0;
+        ep->busy = 0;
+        ep->use_dma = 0;
+}
+
+static int alloc_pipe_config(struct r8a66597_ep *ep,
+                const struct usb_endpoint_descriptor *desc)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+        struct r8a66597_pipe_info info;
+        int dma = 0;
+        unsigned char *counter;
+        int ret;
+
+        ep->desc = desc;
+
+        if (ep->pipenum)        /* already allocated pipe  */
+                return 0;
+
+        switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
+        case USB_ENDPOINT_XFER_BULK:
+                if (r8a66597->bulk >= R8A66597_MAX_NUM_BULK) {
+                        if (r8a66597->isochronous >= R8A66597_MAX_NUM_ISOC) {
+                                printk(KERN_ERR "bulk pipe is insufficient\n");
+                                return -ENODEV;
+                        } else {
+                                info.pipe = R8A66597_BASE_PIPENUM_ISOC
+                                                + r8a66597->isochronous;
+                                counter = &r8a66597->isochronous;
+                        }
+                } else {
+                        info.pipe = R8A66597_BASE_PIPENUM_BULK + r8a66597->bulk;
+                        counter = &r8a66597->bulk;
+                }
+                info.type = R8A66597_BULK;
+                dma = 1;
+                break;
+        case USB_ENDPOINT_XFER_INT:
+                if (r8a66597->interrupt >= R8A66597_MAX_NUM_INT) {
+                        printk(KERN_ERR "interrupt pipe is insufficient\n");
+                        return -ENODEV;
+                }
+                info.pipe = R8A66597_BASE_PIPENUM_INT + r8a66597->interrupt;
+                info.type = R8A66597_INT;
+                counter = &r8a66597->interrupt;
+                break;
+        case USB_ENDPOINT_XFER_ISOC:
+                if (r8a66597->isochronous >= R8A66597_MAX_NUM_ISOC) {
+                        printk(KERN_ERR "isochronous pipe is insufficient\n");
+                        return -ENODEV;
+                }
+                info.pipe = R8A66597_BASE_PIPENUM_ISOC + r8a66597->isochronous;
+                info.type = R8A66597_ISO;
+                counter = &r8a66597->isochronous;
+                break;
+        default:
+                printk(KERN_ERR "unexpect xfer type\n");
+                return -EINVAL;
+        }
+        ep->type = info.type;
+
+        info.epnum = desc->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
+        info.maxpacket = le16_to_cpu(desc->wMaxPacketSize);
+        info.interval = desc->bInterval;
+        if (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
+                info.dir_in = 1;
+        else
+                info.dir_in = 0;
+
+        ret = pipe_buffer_setting(r8a66597, &info);
+        if (ret < 0) {
+                printk(KERN_ERR "pipe_buffer_setting fail\n");
+                return ret;
+        }
+
+        (*counter)++;
+        if ((counter == &r8a66597->isochronous) && info.type == R8A66597_BULK)
+                r8a66597->bulk++;
+
+        r8a66597_ep_setting(r8a66597, ep, desc, info.pipe, dma);
+        pipe_initialize(ep);
+
+        return 0;
+}
+
+static int free_pipe_config(struct r8a66597_ep *ep)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+        struct r8a66597_pipe_info info;
+
+        info.pipe = ep->pipenum;
+        info.type = ep->type;
+        pipe_buffer_release(r8a66597, &info);
+        r8a66597_ep_release(ep);
+
+        return 0;
+}
+
+/*-------------------------------------------------------------------------*/
+static void pipe_irq_enable(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        enable_irq_ready(r8a66597, pipenum);
+        enable_irq_nrdy(r8a66597, pipenum);
+}
+
+static void pipe_irq_disable(struct r8a66597 *r8a66597, u16 pipenum)
+{
+        disable_irq_ready(r8a66597, pipenum);
+        disable_irq_nrdy(r8a66597, pipenum);
+}
+
+/* if complete is true, gadget driver complete function is not call */
+static void control_end(struct r8a66597 *r8a66597, unsigned ccpl)
+{
+        r8a66597->ep[0].internal_ccpl = ccpl;
+        pipe_start(r8a66597, 0);
+        r8a66597_bset(r8a66597, CCPL, DCPCTR);
+}
+
+static void start_ep0_write(struct r8a66597_ep *ep,
+                                struct r8a66597_request *req)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+
+        pipe_change(r8a66597, ep->pipenum);
+        r8a66597_mdfy(r8a66597, ISEL, (ISEL | CURPIPE), CFIFOSEL);
+        r8a66597_write(r8a66597, BCLR, ep->fifoctr);
+        if (req->req.length == 0) {
+                r8a66597_bset(r8a66597, BVAL, ep->fifoctr);
+                pipe_start(r8a66597, 0);
+                transfer_complete(ep, req, 0);
+        } else {
+                r8a66597_write(r8a66597, ~BEMP0, BEMPSTS);
+                irq_ep0_write(ep, req);
+        }
+}
+
+static void start_packet_write(struct r8a66597_ep *ep,
+                                struct r8a66597_request *req)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+        u16 tmp;
+
+        pipe_change(r8a66597, ep->pipenum);
+        disable_irq_empty(r8a66597, ep->pipenum);
+        pipe_start(r8a66597, ep->pipenum);
+
+        tmp = r8a66597_read(r8a66597, ep->fifoctr);
+        if (unlikely((tmp & FRDY) == 0))
+                pipe_irq_enable(r8a66597, ep->pipenum);
+        else
+                irq_packet_write(ep, req);
+}
+
+static void start_packet_read(struct r8a66597_ep *ep,
+                                struct r8a66597_request *req)
+{
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+        u16 pipenum = ep->pipenum;
+
+        if (ep->pipenum == 0) {
+                r8a66597_mdfy(r8a66597, 0, (ISEL | CURPIPE), CFIFOSEL);
+                r8a66597_write(r8a66597, BCLR, ep->fifoctr);
+                pipe_start(r8a66597, pipenum);
+                pipe_irq_enable(r8a66597, pipenum);
+        } else {
+                if (ep->use_dma) {
+                        r8a66597_bset(r8a66597, TRCLR, ep->fifosel);
+                        pipe_change(r8a66597, pipenum);
+                        r8a66597_bset(r8a66597, TRENB, ep->fifosel);
+                        r8a66597_write(r8a66597,
+                                (req->req.length + ep->ep.maxpacket - 1)
+                                        / ep->ep.maxpacket,
+                                ep->fifotrn);
+                }
+                pipe_start(r8a66597, pipenum);  /* trigger once */
+                pipe_irq_enable(r8a66597, pipenum);
+        }
+}
+
+static void start_packet(struct r8a66597_ep *ep, struct r8a66597_request *req)
+{
+        if (ep->desc->bEndpointAddress & USB_DIR_IN)
+                start_packet_write(ep, req);
+        else
+                start_packet_read(ep, req);
+}
+
+static void start_ep0(struct r8a66597_ep *ep, struct r8a66597_request *req)
+{
+        u16 ctsq;
+
+        ctsq = r8a66597_read(ep->r8a66597, INTSTS0) & CTSQ;
+
+        switch (ctsq) {
+        case CS_RDDS:
+                start_ep0_write(ep, req);
+                break;
+        case CS_WRDS:
+                start_packet_read(ep, req);
+                break;
+
+        case CS_WRND:
+                control_end(ep->r8a66597, 0);
+                break;
+        default:
+                printk(KERN_ERR "start_ep0: unexpect ctsq(%x)\n", ctsq);
+                break;
+        }
+}
+
+static void init_controller(struct r8a66597 *r8a66597)
+{
+        u16 vif = r8a66597->pdata->vif ? LDRV : 0;
+        u16 irq_sense = r8a66597->irq_sense_low ? INTL : 0;
+        u16 endian = r8a66597->pdata->endian ? BIGEND : 0;
+
+        if (r8a66597->pdata->on_chip) {
+                r8a66597_bset(r8a66597, 0x04, SYSCFG1);
+                r8a66597_bset(r8a66597, HSE, SYSCFG0);
+
+                r8a66597_bclr(r8a66597, USBE, SYSCFG0);
+                r8a66597_bclr(r8a66597, DPRPU, SYSCFG0);
+                r8a66597_bset(r8a66597, USBE, SYSCFG0);
+
+                r8a66597_bset(r8a66597, SCKE, SYSCFG0);
+
+                r8a66597_bset(r8a66597, irq_sense, INTENB1);
+                r8a66597_write(r8a66597, BURST | CPU_ADR_RD_WR,
+                                DMA0CFG);
+        } else {
+                r8a66597_bset(r8a66597, vif | endian, PINCFG);
+                r8a66597_bset(r8a66597, HSE, SYSCFG0);          /* High spd */
+                r8a66597_mdfy(r8a66597, get_xtal_from_pdata(r8a66597->pdata),
+                                XTAL, SYSCFG0);
+
+                r8a66597_bclr(r8a66597, USBE, SYSCFG0);
+                r8a66597_bclr(r8a66597, DPRPU, SYSCFG0);
+                r8a66597_bset(r8a66597, USBE, SYSCFG0);
+
+                r8a66597_bset(r8a66597, XCKE, SYSCFG0);
+
+                msleep(3);
+
+                r8a66597_bset(r8a66597, PLLC, SYSCFG0);
+
+                msleep(1);
+
+                r8a66597_bset(r8a66597, SCKE, SYSCFG0);
+
+                r8a66597_bset(r8a66597, irq_sense, INTENB1);
+                r8a66597_write(r8a66597, BURST | CPU_ADR_RD_WR,
+                               DMA0CFG);
+        }
+}
+
+static void disable_controller(struct r8a66597 *r8a66597)
+{
+        if (r8a66597->pdata->on_chip) {
+                r8a66597_bset(r8a66597, SCKE, SYSCFG0);
+
+                /* disable interrupts */
+                r8a66597_write(r8a66597, 0, INTENB0);
+                r8a66597_write(r8a66597, 0, INTENB1);
+                r8a66597_write(r8a66597, 0, BRDYENB);
+                r8a66597_write(r8a66597, 0, BEMPENB);
+                r8a66597_write(r8a66597, 0, NRDYENB);
+
+                /* clear status */
+                r8a66597_write(r8a66597, 0, BRDYSTS);
+                r8a66597_write(r8a66597, 0, NRDYSTS);
+                r8a66597_write(r8a66597, 0, BEMPSTS);
+
+                r8a66597_bclr(r8a66597, USBE, SYSCFG0);
+                r8a66597_bclr(r8a66597, SCKE, SYSCFG0);
+
+        } else {
+                r8a66597_bclr(r8a66597, SCKE, SYSCFG0);
+                udelay(1);
+                r8a66597_bclr(r8a66597, PLLC, SYSCFG0);
+                udelay(1);
+                udelay(1);
+                r8a66597_bclr(r8a66597, XCKE, SYSCFG0);
+        }
+}
+
+static void r8a66597_start_xclock(struct r8a66597 *r8a66597)
+{
+        u16 tmp;
+
+        if (!r8a66597->pdata->on_chip) {
+                tmp = r8a66597_read(r8a66597, SYSCFG0);
+                if (!(tmp & XCKE))
+                        r8a66597_bset(r8a66597, XCKE, SYSCFG0);
+        }
+}
+
+static struct r8a66597_request *get_request_from_ep(struct r8a66597_ep *ep)
+{
+        return list_entry(ep->queue.next, struct r8a66597_request, queue);
+}
+
+/*-------------------------------------------------------------------------*/
+static void transfer_complete(struct r8a66597_ep *ep,
+                struct r8a66597_request *req, int status)
+__releases(r8a66597->lock)
+__acquires(r8a66597->lock)
+{
+        int restart = 0;
+
+        if (unlikely(ep->pipenum == 0)) {
+                if (ep->internal_ccpl) {
+                        ep->internal_ccpl = 0;
+                        return;
+                }
+        }
+
+        list_del_init(&req->queue);
+        if (ep->r8a66597->gadget.speed == USB_SPEED_UNKNOWN)
+                req->req.status = -ESHUTDOWN;
+        else
+                req->req.status = status;
+
+        if (!list_empty(&ep->queue))
+                restart = 1;
+
+        spin_unlock(&ep->r8a66597->lock);
+        req->req.complete(&ep->ep, &req->req);
+        spin_lock(&ep->r8a66597->lock);
+
+        if (restart) {
+                req = get_request_from_ep(ep);
+                if (ep->desc)
+                        start_packet(ep, req);
+        }
+}
+
+static void irq_ep0_write(struct r8a66597_ep *ep, struct r8a66597_request *req)
+{
+        int i;
+        u16 tmp;
+        unsigned bufsize;
+        size_t size;
+        void *buf;
+        u16 pipenum = ep->pipenum;
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+
+        pipe_change(r8a66597, pipenum);
+        r8a66597_bset(r8a66597, ISEL, ep->fifosel);
+
+        i = 0;
+        do {
+                tmp = r8a66597_read(r8a66597, ep->fifoctr);
+                if (i++ > 100000) {
+                        printk(KERN_ERR "pipe0 is busy. maybe cpu i/o bus"
+                                "conflict. please power off this controller.");
+                        return;
+                }
+                ndelay(1);
+        } while ((tmp & FRDY) == 0);
+
+        /* prepare parameters */
+        bufsize = get_buffer_size(r8a66597, pipenum);
+        buf = req->req.buf + req->req.actual;
+        size = min(bufsize, req->req.length - req->req.actual);
+
+        /* write fifo */
+        if (req->req.buf) {
+                if (size > 0)
+                        r8a66597_write_fifo(r8a66597, ep->fifoaddr, buf, size);
+                if ((size == 0) || ((size % ep->ep.maxpacket) != 0))
+                        r8a66597_bset(r8a66597, BVAL, ep->fifoctr);
+        }
+
+        /* update parameters */
+        req->req.actual += size;
+
+        /* check transfer finish */
+        if ((!req->req.zero && (req->req.actual == req->req.length))
+                        || (size % ep->ep.maxpacket)
+                        || (size == 0)) {
+                disable_irq_ready(r8a66597, pipenum);
+                disable_irq_empty(r8a66597, pipenum);
+        } else {
+                disable_irq_ready(r8a66597, pipenum);
+                enable_irq_empty(r8a66597, pipenum);
+        }
+        pipe_start(r8a66597, pipenum);
+}
+
+static void irq_packet_write(struct r8a66597_ep *ep,
+                                struct r8a66597_request *req)
+{
+        u16 tmp;
+        unsigned bufsize;
+        size_t size;
+        void *buf;
+        u16 pipenum = ep->pipenum;
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+
+        pipe_change(r8a66597, pipenum);
+        tmp = r8a66597_read(r8a66597, ep->fifoctr);
+        if (unlikely((tmp & FRDY) == 0)) {
+                pipe_stop(r8a66597, pipenum);
+                pipe_irq_disable(r8a66597, pipenum);
+                printk(KERN_ERR "write fifo not ready. pipnum=%d\n", pipenum);
+                return;
+        }
+
+        /* prepare parameters */
+        bufsize = get_buffer_size(r8a66597, pipenum);
+        buf = req->req.buf + req->req.actual;
+        size = min(bufsize, req->req.length - req->req.actual);
+
+        /* write fifo */
+        if (req->req.buf) {
+                r8a66597_write_fifo(r8a66597, ep->fifoaddr, buf, size);
+                if ((size == 0)
+                                || ((size % ep->ep.maxpacket) != 0)
+                                || ((bufsize != ep->ep.maxpacket)
+                                        && (bufsize > size)))
+                        r8a66597_bset(r8a66597, BVAL, ep->fifoctr);
+        }
+
+        /* update parameters */
+        req->req.actual += size;
+        /* check transfer finish */
+        if ((!req->req.zero && (req->req.actual == req->req.length))
+                        || (size % ep->ep.maxpacket)
+                        || (size == 0)) {
+                disable_irq_ready(r8a66597, pipenum);
+                enable_irq_empty(r8a66597, pipenum);
+        } else {
+                disable_irq_empty(r8a66597, pipenum);
+                pipe_irq_enable(r8a66597, pipenum);
+        }
+}
+
+static void irq_packet_read(struct r8a66597_ep *ep,
+                                struct r8a66597_request *req)
+{
+        u16 tmp;
+        int rcv_len, bufsize, req_len;
+        int size;
+        void *buf;
+        u16 pipenum = ep->pipenum;
+        struct r8a66597 *r8a66597 = ep->r8a66597;
+        int finish = 0;
+
+        pipe_change(r8a66597, pipenum);
+        tmp = r8a66597_read(r8a66597, ep->fifoctr);
+        if (unlikely((tmp & FRDY) == 0)) {
+                req->req.status = -EPIPE;
+                pipe_stop(r8a66597, pipenum);
+                pipe_irq_disable(r8a66597, pipenum);
+                printk(KERN_ERR "read fifo not ready");
+                return;
+        }
+
+        /* prepare parameters */
+        rcv_len = tmp & DTLN;
+        bufsize = get_buffer_size(r8a66597, pipenum);
+
+        buf = req->req.buf + req->req.actual;
+        req_len = req->req.length - req->req.actual;
+        if (rcv_len < bufsize)
+                size = min(rcv_len, req_len);
+        else
+                size = min(bufsize, req_len);
+
+        /* update parameters */
+        req->req.actual += size;
+
+        /* check transfer finish */
+        if ((!req->req.zero && (req->req.actual == req->req.length))
+                        || (size % ep->ep.maxpacket)
+                        || (size == 0)) {
+                pipe_stop(r8a66597, pipenum);
+                pipe_irq_disable(r8a66597, pipenum);
+                finish = 1;
+        }
+
+        /* read fifo */
+        if (req->req.buf) {
+                if (size == 0)
+                        r8a66597_write(r8a66597, BCLR, ep->fifoctr);
+                else
+                        r8a66597_read_fifo(r8a66597, ep->fifoaddr, buf, size);
+
+        }
+
+        if ((ep->pipenum != 0) && finish)
+                transfer_complete(ep, req, 0);
+}
+
+static void irq_pipe_ready(struct r8a66597 *r8a66597, u16 status, u16 enb)
+{
+        u16 check;
+        u16 pipenum;
+        struct r8a66597_ep *ep;
+        struct r8a66597_request *req;
+
+        if ((status & BRDY0) && (enb & BRDY0)) {
+                r8a66597_write(r8a66597, ~BRDY0, BRDYSTS);
+                r8a66597_mdfy(r8a66597, 0, CURPIPE, CFIFOSEL);
+
+                ep = &r8a66597->ep[0];
+                req = get_request_from_ep(ep);
+                irq_packet_read(ep, req);
+        } else {
+                for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
+                        check = 1 << pipenum;
+                        if ((status & check) && (enb & check)) {
+                                r8a66597_write(r8a66597, ~check, BRDYSTS);
+                                ep = r8a66597->pipenum2ep[pipenum];
+                                req = get_request_from_ep(ep);
+                                if (ep->desc->bEndpointAddress & USB_DIR_IN)
+                                        irq_packet_write(ep, req);
+                                else
+                                        irq_packet_read(ep, req);
+                        }
+                }
+        }
+}
+
+static void irq_pipe_empty(struct r8a66597 *r8a66597, u16 status, u16 enb)
+{
+        u16 tmp;
+        u16 check;
+        u16 pipenum;
+        struct r8a66597_ep *ep;
+        struct r8a66597_request *req;
+
+        if ((status & BEMP0) && (enb & BEMP0)) {
+                r8a66597_write(r8a66597, ~BEMP0, BEMPSTS);
+
+                ep = &r8a66597->ep[0];
+                req = get_request_from_ep(ep);
+                irq_ep0_write(ep, req);
+        } else {
+                for (pipenum = 1; pipenum < R8A66597_MAX_NUM_PIPE; pipenum++) {
+                        check = 1 << pipenum;
+                        if ((status & check) && (enb & check)) {
+                                r8a66597_write(r8a66597, ~check, BEMPSTS);
+                                tmp = control_reg_get(r8a66597, pipenum);
+                                if ((tmp & INBUFM) == 0) {
+                                        disable_irq_empty(r8a66597, pipenum);
+                                        pipe_irq_disable(r8a66597, pipenum);
+                                        pipe_stop(r8a66597, pipenum);
+                                        ep = r8a66597->pipenum2ep[pipenum];
+                                        req = get_request_from_ep(ep);
+                                        if (!list_empty(&ep->queue))
+                                                transfer_complete(ep, req, 0);
+                                }
+                        }
+                }
+        }
+}
+
+static void get_status(struct r8a66597 *r8a66597, struct usb_ctrlrequest *ctrl)
+__releases(r8a66597->lock)
+__acquires(r8a66597->lock)
+{
+        struct r8a66597_ep *ep;
+        u16 pid;
+        u16 status = 0;
+        u16 w_index = le16_to_cpu(ctrl->wIndex);
+
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                status = 1 << USB_DEVICE_SELF_POWERED;
+                break;
+        case USB_RECIP_INTERFACE:
+                status = 0;
+                break;
+        case USB_RECIP_ENDPOINT:
+                ep = r8a66597->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
+                pid = control_reg_get_pid(r8a66597, ep->pipenum);
+                if (pid == PID_STALL)
+                        status = 1 << USB_ENDPOINT_HALT;
+                else
+                        status = 0;
+                break;
+        default:
+                pipe_stall(r8a66597, 0);
+                return;         /* exit */
+        }
+
+        r8a66597->ep0_data = cpu_to_le16(status);
+        r8a66597->ep0_req->buf = &r8a66597->ep0_data;
+        r8a66597->ep0_req->length = 2;
+        /* AV: what happens if we get called again before that gets through? */
+        spin_unlock(&r8a66597->lock);
+        r8a66597_queue(r8a66597->gadget.ep0, r8a66597->ep0_req, GFP_KERNEL);
+        spin_lock(&r8a66597->lock);
+}
+
+static void clear_feature(struct r8a66597 *r8a66597,
+                                struct usb_ctrlrequest *ctrl)
+{
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                control_end(r8a66597, 1);
+                break;
+        case USB_RECIP_INTERFACE:
+                control_end(r8a66597, 1);
+                break;
+        case USB_RECIP_ENDPOINT: {
+                struct r8a66597_ep *ep;
+                struct r8a66597_request *req;
+                u16 w_index = le16_to_cpu(ctrl->wIndex);
+
+                ep = r8a66597->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
+                if (!ep->wedge) {
+                        pipe_stop(r8a66597, ep->pipenum);
+                        control_reg_sqclr(r8a66597, ep->pipenum);
+                        spin_unlock(&r8a66597->lock);
+                        usb_ep_clear_halt(&ep->ep);
+                        spin_lock(&r8a66597->lock);
+                }
+
+                control_end(r8a66597, 1);
+
+                req = get_request_from_ep(ep);
+                if (ep->busy) {
+                        ep->busy = 0;
+                        if (list_empty(&ep->queue))
+                                break;
+                        start_packet(ep, req);
+                } else if (!list_empty(&ep->queue))
+                        pipe_start(r8a66597, ep->pipenum);
+                }
+                break;
+        default:
+                pipe_stall(r8a66597, 0);
+                break;
+        }
+}
+
+static void set_feature(struct r8a66597 *r8a66597, struct usb_ctrlrequest *ctrl)
+{
+
+        switch (ctrl->bRequestType & USB_RECIP_MASK) {
+        case USB_RECIP_DEVICE:
+                control_end(r8a66597, 1);
+                break;
+        case USB_RECIP_INTERFACE:
+                control_end(r8a66597, 1);
+                break;
+        case USB_RECIP_ENDPOINT: {
+                struct r8a66597_ep *ep;
+                u16 w_index = le16_to_cpu(ctrl->wIndex);
+
+                ep = r8a66597->epaddr2ep[w_index & USB_ENDPOINT_NUMBER_MASK];
+                pipe_stall(r8a66597, ep->pipenum);
+
+                control_end(r8a66597, 1);
+                }
+                break;
+        default:
+                pipe_stall(r8a66597, 0);
+                break;
+        }
+}
+
+/* if return value is true, call class driver's setup() */
+static int setup_packet(struct r8a66597 *r8a66597, struct usb_ctrlrequest *ctrl)
+{
+        u16 *p = (u16 *)ctrl;
+        unsigned long offset = USBREQ;
+        int i, ret = 0;
+
+        /* read fifo */
+        r8a66597_write(r8a66597, ~VALID, INTSTS0);
+
+        for (i = 0; i < 4; i++)
+                p[i] = r8a66597_read(r8a66597, offset + i*2);
+
+        /* check request */
+        if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
+                switch (ctrl->bRequest) {
+                case USB_REQ_GET_STATUS:
+                        get_status(r8a66597, ctrl);
+                        break;
+                case USB_REQ_CLEAR_FEATURE:
+                        clear_feature(r8a66597, ctrl);
+                        break;
+                case USB_REQ_SET_FEATURE:
+                        set_feature(r8a66597, ctrl);
+                        break;
+                default:
+                        ret = 1;
+                        break;
+                }
+        } else
+                ret = 1;
+        return ret;
+}
+
+static void r8a66597_update_usb_speed(struct r8a66597 *r8a66597)
+{
+        u16 speed = get_usb_speed(r8a66597);
+
+        switch (speed) {
+        case HSMODE:
+                r8a66597->gadget.speed = USB_SPEED_HIGH;
+                break;
+        case FSMODE:
+                r8a66597->gadget.speed = USB_SPEED_FULL;
+                break;
+        default:
+                r8a66597->gadget.speed = USB_SPEED_UNKNOWN;
+                printk(KERN_ERR "USB speed unknown\n");
+        }
+}
+
+static void irq_device_state(struct r8a66597 *r8a66597)
+{
+        u16 dvsq;
+
+        dvsq = r8a66597_read(r8a66597, INTSTS0) & DVSQ;
+        r8a66597_write(r8a66597, ~DVST, INTSTS0);
+
+        if (dvsq == DS_DFLT) {
+                /* bus reset */
+                r8a66597->driver->disconnect(&r8a66597->gadget);
+                r8a66597_update_usb_speed(r8a66597);
+        }
+        if (r8a66597->old_dvsq == DS_CNFG && dvsq != DS_CNFG)
+                r8a66597_update_usb_speed(r8a66597);
+        if ((dvsq == DS_CNFG || dvsq == DS_ADDS)
+                        && r8a66597->gadget.speed == USB_SPEED_UNKNOWN)
+                r8a66597_update_usb_speed(r8a66597);
+
+        r8a66597->old_dvsq = dvsq;
+}
+
+static void irq_control_stage(struct r8a66597 *r8a66597)
+__releases(r8a66597->lock)
+__acquires(r8a66597->lock)
+{
+        struct usb_ctrlrequest ctrl;
+        u16 ctsq;
+
+        ctsq = r8a66597_read(r8a66597, INTSTS0) & CTSQ;
+        r8a66597_write(r8a66597, ~CTRT, INTSTS0);
+
+        switch (ctsq) {
+        case CS_IDST: {
+                struct r8a66597_ep *ep;
+                struct r8a66597_request *req;
+                ep = &r8a66597->ep[0];
+                req = get_request_from_ep(ep);
+                transfer_complete(ep, req, 0);
+                }
+                break;
+
+        case CS_RDDS:
+        case CS_WRDS:
+        case CS_WRND:
+                if (setup_packet(r8a66597, &ctrl)) {
+                        spin_unlock(&r8a66597->lock);
+                        if (r8a66597->driver->setup(&r8a66597->gadget, &ctrl)
+                                < 0)
+                                pipe_stall(r8a66597, 0);
+                        spin_lock(&r8a66597->lock);
+                }
+                break;
+        case CS_RDSS:
+        case CS_WRSS:
+                control_end(r8a66597, 0);
+                break;
+        default:
+                printk(KERN_ERR "ctrl_stage: unexpect ctsq(%x)\n", ctsq);
+                break;
+        }
+}
+
+static irqreturn_t r8a66597_irq(int irq, void *_r8a66597)
+{
+        struct r8a66597 *r8a66597 = _r8a66597;
+        u16 intsts0;
+        u16 intenb0;
+        u16 brdysts, nrdysts, bempsts;
+        u16 brdyenb, nrdyenb, bempenb;
+        u16 savepipe;
+        u16 mask0;
+
+        spin_lock(&r8a66597->lock);
+
+        intsts0 = r8a66597_read(r8a66597, INTSTS0);
+        intenb0 = r8a66597_read(r8a66597, INTENB0);
+
+        savepipe = r8a66597_read(r8a66597, CFIFOSEL);
+
+        mask0 = intsts0 & intenb0;
+        if (mask0) {
+                brdysts = r8a66597_read(r8a66597, BRDYSTS);
+                nrdysts = r8a66597_read(r8a66597, NRDYSTS);
+                bempsts = r8a66597_read(r8a66597, BEMPSTS);
+                brdyenb = r8a66597_read(r8a66597, BRDYENB);
+                nrdyenb = r8a66597_read(r8a66597, NRDYENB);
+                bempenb = r8a66597_read(r8a66597, BEMPENB);
+
+                if (mask0 & VBINT) {
+                        r8a66597_write(r8a66597,  0xffff & ~VBINT,
+                                        INTSTS0);
+                        r8a66597_start_xclock(r8a66597);
+
+                        /* start vbus sampling */
+                        r8a66597->old_vbus = r8a66597_read(r8a66597, INTSTS0)
+                                        & VBSTS;
+                        r8a66597->scount = R8A66597_MAX_SAMPLING;
+
+                        mod_timer(&r8a66597->timer,
+                                        jiffies + msecs_to_jiffies(50));
+                }
+                if (intsts0 & DVSQ)
+                        irq_device_state(r8a66597);
+
+                if ((intsts0 & BRDY) && (intenb0 & BRDYE)
+                                && (brdysts & brdyenb))
+                        irq_pipe_ready(r8a66597, brdysts, brdyenb);
+                if ((intsts0 & BEMP) && (intenb0 & BEMPE)
+                                && (bempsts & bempenb))
+                        irq_pipe_empty(r8a66597, bempsts, bempenb);
+
+                if (intsts0 & CTRT)
+                        irq_control_stage(r8a66597);
+        }
+
+        r8a66597_write(r8a66597, savepipe, CFIFOSEL);
+
+        spin_unlock(&r8a66597->lock);
+        return IRQ_HANDLED;
+}
+
+static void r8a66597_timer(unsigned long _r8a66597)
+{
+        struct r8a66597 *r8a66597 = (struct r8a66597 *)_r8a66597;
+        unsigned long flags;
+        u16 tmp;
+
+        spin_lock_irqsave(&r8a66597->lock, flags);
+        tmp = r8a66597_read(r8a66597, SYSCFG0);
+        if (r8a66597->scount > 0) {
+                tmp = r8a66597_read(r8a66597, INTSTS0) & VBSTS;
+                if (tmp == r8a66597->old_vbus) {
+                        r8a66597->scount--;
+                        if (r8a66597->scount == 0) {
+                                if (tmp == VBSTS)
+                                        r8a66597_usb_connect(r8a66597);
+                                else
+                                        r8a66597_usb_disconnect(r8a66597);
+                        } else {
+                                mod_timer(&r8a66597->timer,
+                                        jiffies + msecs_to_jiffies(50));
+                        }
+                } else {
+                        r8a66597->scount = R8A66597_MAX_SAMPLING;
+                        r8a66597->old_vbus = tmp;
+                        mod_timer(&r8a66597->timer,
+                                        jiffies + msecs_to_jiffies(50));
+                }
+        }
+        spin_unlock_irqrestore(&r8a66597->lock, flags);
+}
+
+/*-------------------------------------------------------------------------*/
+static int r8a66597_enable(struct usb_ep *_ep,
+                         const struct usb_endpoint_descriptor *desc)
+{
+        struct r8a66597_ep *ep;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+        return alloc_pipe_config(ep, desc);
+}
+
+static int r8a66597_disable(struct usb_ep *_ep)
+{
+        struct r8a66597_ep *ep;
+        struct r8a66597_request *req;
+        unsigned long flags;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+        BUG_ON(!ep);
+
+        while (!list_empty(&ep->queue)) {
+                req = get_request_from_ep(ep);
+                spin_lock_irqsave(&ep->r8a66597->lock, flags);
+                transfer_complete(ep, req, -ECONNRESET);
+                spin_unlock_irqrestore(&ep->r8a66597->lock, flags);
+        }
+
+        pipe_irq_disable(ep->r8a66597, ep->pipenum);
+        return free_pipe_config(ep);
+}
+
+static struct usb_request *r8a66597_alloc_request(struct usb_ep *_ep,
+                                                gfp_t gfp_flags)
+{
+        struct r8a66597_request *req;
+
+        req = kzalloc(sizeof(struct r8a66597_request), gfp_flags);
+        if (!req)
+                return NULL;
+
+        INIT_LIST_HEAD(&req->queue);
+
+        return &req->req;
+}
+
+static void r8a66597_free_request(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct r8a66597_request *req;
+
+        req = container_of(_req, struct r8a66597_request, req);
+        kfree(req);
+}
+
+static int r8a66597_queue(struct usb_ep *_ep, struct usb_request *_req,
+                        gfp_t gfp_flags)
+{
+        struct r8a66597_ep *ep;
+        struct r8a66597_request *req;
+        unsigned long flags;
+        int request = 0;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+        req = container_of(_req, struct r8a66597_request, req);
+
+        if (ep->r8a66597->gadget.speed == USB_SPEED_UNKNOWN)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&ep->r8a66597->lock, flags);
+
+        if (list_empty(&ep->queue))
+                request = 1;
+
+        list_add_tail(&req->queue, &ep->queue);
+        req->req.actual = 0;
+        req->req.status = -EINPROGRESS;
+
+        if (ep->desc == NULL)   /* control */
+                start_ep0(ep, req);
+        else {
+                if (request && !ep->busy)
+                        start_packet(ep, req);
+        }
+
+        spin_unlock_irqrestore(&ep->r8a66597->lock, flags);
+
+        return 0;
+}
+
+static int r8a66597_dequeue(struct usb_ep *_ep, struct usb_request *_req)
+{
+        struct r8a66597_ep *ep;
+        struct r8a66597_request *req;
+        unsigned long flags;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+        req = container_of(_req, struct r8a66597_request, req);
+
+        spin_lock_irqsave(&ep->r8a66597->lock, flags);
+        if (!list_empty(&ep->queue))
+                transfer_complete(ep, req, -ECONNRESET);
+        spin_unlock_irqrestore(&ep->r8a66597->lock, flags);
+
+        return 0;
+}
+
+static int r8a66597_set_halt(struct usb_ep *_ep, int value)
+{
+        struct r8a66597_ep *ep;
+        struct r8a66597_request *req;
+        unsigned long flags;
+        int ret = 0;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+        req = get_request_from_ep(ep);
+
+        spin_lock_irqsave(&ep->r8a66597->lock, flags);
+        if (!list_empty(&ep->queue)) {
+                ret = -EAGAIN;
+                goto out;
+        }
+        if (value) {
+                ep->busy = 1;
+                pipe_stall(ep->r8a66597, ep->pipenum);
+        } else {
+                ep->busy = 0;
+                ep->wedge = 0;
+                pipe_stop(ep->r8a66597, ep->pipenum);
+        }
+
+out:
+        spin_unlock_irqrestore(&ep->r8a66597->lock, flags);
+        return ret;
+}
+
+static int r8a66597_set_wedge(struct usb_ep *_ep)
+{
+        struct r8a66597_ep *ep;
+        unsigned long flags;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+
+        if (!ep || !ep->desc)
+                return -EINVAL;
+
+        spin_lock_irqsave(&ep->r8a66597->lock, flags);
+        ep->wedge = 1;
+        spin_unlock_irqrestore(&ep->r8a66597->lock, flags);
+
+        return usb_ep_set_halt(_ep);
+}
+
+static void r8a66597_fifo_flush(struct usb_ep *_ep)
+{
+        struct r8a66597_ep *ep;
+        unsigned long flags;
+
+        ep = container_of(_ep, struct r8a66597_ep, ep);
+        spin_lock_irqsave(&ep->r8a66597->lock, flags);
+        if (list_empty(&ep->queue) && !ep->busy) {
+                pipe_stop(ep->r8a66597, ep->pipenum);
+                r8a66597_bclr(ep->r8a66597, BCLR, ep->fifoctr);
+        }
+        spin_unlock_irqrestore(&ep->r8a66597->lock, flags);
+}
+
+static struct usb_ep_ops r8a66597_ep_ops = {
+        .enable         = r8a66597_enable,
+        .disable        = r8a66597_disable,
+
+        .alloc_request  = r8a66597_alloc_request,
+        .free_request   = r8a66597_free_request,
+
+        .queue          = r8a66597_queue,
+        .dequeue        = r8a66597_dequeue,
+
+        .set_halt       = r8a66597_set_halt,
+        .set_wedge      = r8a66597_set_wedge,
+        .fifo_flush     = r8a66597_fifo_flush,
+};
+
+/*-------------------------------------------------------------------------*/
+static struct r8a66597 *the_controller;
+
+int usb_gadget_register_driver(struct usb_gadget_driver *driver)
+{
+        struct r8a66597 *r8a66597 = the_controller;
+        int retval;
+
+        if (!driver
+                        || driver->speed != USB_SPEED_HIGH
+                        || !driver->bind
+                        || !driver->setup)
+                return -EINVAL;
+        if (!r8a66597)
+                return -ENODEV;
+        if (r8a66597->driver)
+                return -EBUSY;
+
+        /* hook up the driver */
+        driver->driver.bus = NULL;
+        r8a66597->driver = driver;
+        r8a66597->gadget.dev.driver = &driver->driver;
+
+        retval = device_add(&r8a66597->gadget.dev);
+        if (retval) {
+                printk(KERN_ERR "device_add error (%d)\n", retval);
+                goto error;
+        }
+
+        retval = driver->bind(&r8a66597->gadget);
+        if (retval) {
+                printk(KERN_ERR "bind to driver error (%d)\n", retval);
+                device_del(&r8a66597->gadget.dev);
+                goto error;
+        }
+
+        r8a66597_bset(r8a66597, VBSE, INTENB0);
+        if (r8a66597_read(r8a66597, INTSTS0) & VBSTS) {
+                r8a66597_start_xclock(r8a66597);
+                /* start vbus sampling */
+                r8a66597->old_vbus = r8a66597_read(r8a66597,
+                                         INTSTS0) & VBSTS;
+                r8a66597->scount = R8A66597_MAX_SAMPLING;
+                mod_timer(&r8a66597->timer, jiffies + msecs_to_jiffies(50));
+        }
+
+        return 0;
+
+error:
+        r8a66597->driver = NULL;
+        r8a66597->gadget.dev.driver = NULL;
+
+        return retval;
+}
+EXPORT_SYMBOL(usb_gadget_register_driver);
+
+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
+{
+        struct r8a66597 *r8a66597 = the_controller;
+        unsigned long flags;
+
+        if (driver != r8a66597->driver || !driver->unbind)
+                return -EINVAL;
+
+        spin_lock_irqsave(&r8a66597->lock, flags);
+        if (r8a66597->gadget.speed != USB_SPEED_UNKNOWN)
+                r8a66597_usb_disconnect(r8a66597);
+        spin_unlock_irqrestore(&r8a66597->lock, flags);
+
+        r8a66597_bclr(r8a66597, VBSE, INTENB0);
+
+        driver->unbind(&r8a66597->gadget);
+
+        init_controller(r8a66597);
+        disable_controller(r8a66597);
+
+        device_del(&r8a66597->gadget.dev);
+        r8a66597->driver = NULL;
+        return 0;
+}
+EXPORT_SYMBOL(usb_gadget_unregister_driver);
+
+/*-------------------------------------------------------------------------*/
+static int r8a66597_get_frame(struct usb_gadget *_gadget)
+{
+        struct r8a66597 *r8a66597 = gadget_to_r8a66597(_gadget);
+        return r8a66597_read(r8a66597, FRMNUM) & 0x03FF;
+}
+
+static struct usb_gadget_ops r8a66597_gadget_ops = {
+        .get_frame              = r8a66597_get_frame,
+};
+
+static int __exit r8a66597_remove(struct platform_device *pdev)
+{
+        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+
+        del_timer_sync(&r8a66597->timer);
+        iounmap((void *)r8a66597->reg);
+        free_irq(platform_get_irq(pdev, 0), r8a66597);
+        r8a66597_free_request(&r8a66597->ep[0].ep, r8a66597->ep0_req);
+#ifdef CONFIG_HAVE_CLK
+        if (r8a66597->pdata->on_chip) {
+                clk_disable(r8a66597->clk);
+                clk_put(r8a66597->clk);
+        }
+#endif
+        kfree(r8a66597);
+        return 0;
+}
+
+static void nop_completion(struct usb_ep *ep, struct usb_request *r)
+{
+}
+
+static int __init r8a66597_probe(struct platform_device *pdev)
+{
+#ifdef CONFIG_HAVE_CLK
+        char clk_name[8];
+#endif
+        struct resource *res, *ires;
+        int irq;
+        void __iomem *reg = NULL;
+        struct r8a66597 *r8a66597 = NULL;
+        int ret = 0;
+        int i;
+        unsigned long irq_trigger;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENODEV;
+                printk(KERN_ERR "platform_get_resource error.\n");
+                goto clean_up;
+        }
+
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        irq = ires->start;
+        irq_trigger = ires->flags & IRQF_TRIGGER_MASK;
+
+        if (irq < 0) {
+                ret = -ENODEV;
+                printk(KERN_ERR "platform_get_irq error.\n");
+                goto clean_up;
+        }
+
+        reg = ioremap(res->start, resource_size(res));
+        if (reg == NULL) {
+                ret = -ENOMEM;
+                printk(KERN_ERR "ioremap error.\n");
+                goto clean_up;
+        }
+
+        /* initialize ucd */
+        r8a66597 = kzalloc(sizeof(struct r8a66597), GFP_KERNEL);
+        if (r8a66597 == NULL) {
+                printk(KERN_ERR "kzalloc error\n");
+                goto clean_up;
+        }
+
+        spin_lock_init(&r8a66597->lock);
+        dev_set_drvdata(&pdev->dev, r8a66597);
+        r8a66597->pdata = pdev->dev.platform_data;
+        r8a66597->irq_sense_low = irq_trigger == IRQF_TRIGGER_LOW;
+
+        r8a66597->gadget.ops = &r8a66597_gadget_ops;
+        device_initialize(&r8a66597->gadget.dev);
+        dev_set_name(&r8a66597->gadget.dev, "gadget");
+        r8a66597->gadget.is_dualspeed = 1;
+        r8a66597->gadget.dev.parent = &pdev->dev;
+        r8a66597->gadget.dev.dma_mask = pdev->dev.dma_mask;
+        r8a66597->gadget.dev.release = pdev->dev.release;
+        r8a66597->gadget.name = udc_name;
+
+        init_timer(&r8a66597->timer);
+        r8a66597->timer.function = r8a66597_timer;
+        r8a66597->timer.data = (unsigned long)r8a66597;
+        r8a66597->reg = (unsigned long)reg;
+
+#ifdef CONFIG_HAVE_CLK
+        if (r8a66597->pdata->on_chip) {
+                snprintf(clk_name, sizeof(clk_name), "usb%d", pdev->id);
+                r8a66597->clk = clk_get(&pdev->dev, clk_name);
+                if (IS_ERR(r8a66597->clk)) {
+                        dev_err(&pdev->dev, "cannot get clock \"%s\"\n",
+                                clk_name);
+                        ret = PTR_ERR(r8a66597->clk);
+                        goto clean_up;
+                }
+                clk_enable(r8a66597->clk);
+        }
+#endif
+
+        disable_controller(r8a66597); /* make sure controller is disabled */
+
+        ret = request_irq(irq, r8a66597_irq, IRQF_DISABLED | IRQF_SHARED,
+                        udc_name, r8a66597);
+        if (ret < 0) {
+                printk(KERN_ERR "request_irq error (%d)\n", ret);
+                goto clean_up2;
+        }
+
+        INIT_LIST_HEAD(&r8a66597->gadget.ep_list);
+        r8a66597->gadget.ep0 = &r8a66597->ep[0].ep;
+        INIT_LIST_HEAD(&r8a66597->gadget.ep0->ep_list);
+        for (i = 0; i < R8A66597_MAX_NUM_PIPE; i++) {
+                struct r8a66597_ep *ep = &r8a66597->ep[i];
+
+                if (i != 0) {
+                        INIT_LIST_HEAD(&r8a66597->ep[i].ep.ep_list);
+                        list_add_tail(&r8a66597->ep[i].ep.ep_list,
+                                        &r8a66597->gadget.ep_list);
+                }
+                ep->r8a66597 = r8a66597;
+                INIT_LIST_HEAD(&ep->queue);
+                ep->ep.name = r8a66597_ep_name[i];
+                ep->ep.ops = &r8a66597_ep_ops;
+                ep->ep.maxpacket = 512;
+        }
+        r8a66597->ep[0].ep.maxpacket = 64;
+        r8a66597->ep[0].pipenum = 0;
+        r8a66597->ep[0].fifoaddr = CFIFO;
+        r8a66597->ep[0].fifosel = CFIFOSEL;
+        r8a66597->ep[0].fifoctr = CFIFOCTR;
+        r8a66597->ep[0].fifotrn = 0;
+        r8a66597->ep[0].pipectr = get_pipectr_addr(0);
+        r8a66597->pipenum2ep[0] = &r8a66597->ep[0];
+        r8a66597->epaddr2ep[0] = &r8a66597->ep[0];
+
+        the_controller = r8a66597;
+
+        r8a66597->ep0_req = r8a66597_alloc_request(&r8a66597->ep[0].ep,
+                                                        GFP_KERNEL);
+        if (r8a66597->ep0_req == NULL)
+                goto clean_up3;
+        r8a66597->ep0_req->complete = nop_completion;
+
+        init_controller(r8a66597);
+
+        dev_info(&pdev->dev, "version %s\n", DRIVER_VERSION);
+        return 0;
+
+clean_up3:
+        free_irq(irq, r8a66597);
+clean_up2:
+#ifdef CONFIG_HAVE_CLK
+        if (r8a66597->pdata->on_chip) {
+                clk_disable(r8a66597->clk);
+                clk_put(r8a66597->clk);
+        }
+#endif
+clean_up:
+        if (r8a66597) {
+                if (r8a66597->ep0_req)
+                        r8a66597_free_request(&r8a66597->ep[0].ep,
+                                                r8a66597->ep0_req);
+                kfree(r8a66597);
+        }
+        if (reg)
+                iounmap(reg);
+
+        return ret;
+}
+
+/*-------------------------------------------------------------------------*/
+static struct platform_driver r8a66597_driver = {
+        .remove =       __exit_p(r8a66597_remove),
+        .driver         = {
+                .name = (char *) udc_name,
+        },
+};
+
+static int __init r8a66597_udc_init(void)
+{
+        return platform_driver_probe(&r8a66597_driver, r8a66597_probe);
+}
+module_init(r8a66597_udc_init);
+
+static void __exit r8a66597_udc_cleanup(void)
+{
+        platform_driver_unregister(&r8a66597_driver);
+}
+module_exit(r8a66597_udc_cleanup);
+
+MODULE_DESCRIPTION("R8A66597 USB gadget driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Yoshihiro Shimoda");
+
diff --git a/drivers/usb/gadget/r8a66597-udc.h b/drivers/usb/gadget/r8a66597-udc.h
new file mode 100644
index 000000000000..03087e7b9190
--- /dev/null
+++ b/drivers/usb/gadget/r8a66597-udc.h
@@ -0,0 +1,256 @@
+/*
+ * R8A66597 UDC
+ *
+ * Copyright (C) 2007-2009 Renesas Solutions Corp.
+ *
+ * Author : Yoshihiro Shimoda <shimoda.yoshihiro@renesas.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef __R8A66597_H__
+#define __R8A66597_H__
+
+#ifdef CONFIG_HAVE_CLK
+#include <linux/clk.h>
+#endif
+
+#include <linux/usb/r8a66597.h>
+
+#define R8A66597_MAX_SAMPLING   10
+
+#define R8A66597_MAX_NUM_PIPE   8
+#define R8A66597_MAX_NUM_BULK   3
+#define R8A66597_MAX_NUM_ISOC   2
+#define R8A66597_MAX_NUM_INT    2
+
+#define R8A66597_BASE_PIPENUM_BULK      3
+#define R8A66597_BASE_PIPENUM_ISOC      1
+#define R8A66597_BASE_PIPENUM_INT       6
+
+#define R8A66597_BASE_BUFNUM    6
+#define R8A66597_MAX_BUFNUM     0x4F
+
+#define is_bulk_pipe(pipenum)   \
+        ((pipenum >= R8A66597_BASE_PIPENUM_BULK) && \
+         (pipenum < (R8A66597_BASE_PIPENUM_BULK + R8A66597_MAX_NUM_BULK)))
+#define is_interrupt_pipe(pipenum)      \
+        ((pipenum >= R8A66597_BASE_PIPENUM_INT) && \
+         (pipenum < (R8A66597_BASE_PIPENUM_INT + R8A66597_MAX_NUM_INT)))
+#define is_isoc_pipe(pipenum)   \
+        ((pipenum >= R8A66597_BASE_PIPENUM_ISOC) && \
+         (pipenum < (R8A66597_BASE_PIPENUM_ISOC + R8A66597_MAX_NUM_ISOC)))
+
+struct r8a66597_pipe_info {
+        u16     pipe;
+        u16     epnum;
+        u16     maxpacket;
+        u16     type;
+        u16     interval;
+        u16     dir_in;
+};
+
+struct r8a66597_request {
+        struct usb_request      req;
+        struct list_head        queue;
+};
+
+struct r8a66597_ep {
+        struct usb_ep           ep;
+        struct r8a66597         *r8a66597;
+
+        struct list_head        queue;
+        unsigned                busy:1;
+        unsigned                wedge:1;
+        unsigned                internal_ccpl:1;        /* use only control */
+
+        /* this member can able to after r8a66597_enable */
+        unsigned                use_dma:1;
+        u16                     pipenum;
+        u16                     type;
+        const struct usb_endpoint_descriptor    *desc;
+        /* register address */
+        unsigned char           fifoaddr;
+        unsigned char           fifosel;
+        unsigned char           fifoctr;
+        unsigned char           fifotrn;
+        unsigned char           pipectr;
+};
+
+struct r8a66597 {
+        spinlock_t              lock;
+        unsigned long           reg;
+
+#ifdef CONFIG_HAVE_CLK
+        struct clk *clk;
+#endif
+        struct r8a66597_platdata        *pdata;
+
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+
+        struct r8a66597_ep      ep[R8A66597_MAX_NUM_PIPE];
+        struct r8a66597_ep      *pipenum2ep[R8A66597_MAX_NUM_PIPE];
+        struct r8a66597_ep      *epaddr2ep[16];
+
+        struct timer_list       timer;
+        struct usb_request      *ep0_req;       /* for internal request */
+        u16                     ep0_data;       /* for internal request */
+        u16                     old_vbus;
+        u16                     scount;
+        u16                     old_dvsq;
+
+        /* pipe config */
+        unsigned char bulk;
+        unsigned char interrupt;
+        unsigned char isochronous;
+        unsigned char num_dma;
+
+        unsigned irq_sense_low:1;
+};
+
+#define gadget_to_r8a66597(_gadget)     \
+                container_of(_gadget, struct r8a66597, gadget)
+#define r8a66597_to_gadget(r8a66597) (&r8a66597->gadget)
+
+static inline u16 r8a66597_read(struct r8a66597 *r8a66597, unsigned long offset)
+{
+        return inw(r8a66597->reg + offset);
+}
+
+static inline void r8a66597_read_fifo(struct r8a66597 *r8a66597,
+                                      unsigned long offset, u16 *buf,
+                                      int len)
+{
+        if (r8a66597->pdata->on_chip) {
+                unsigned long fifoaddr = r8a66597->reg + offset;
+                unsigned long count;
+                union {
+                        unsigned long dword;
+                        unsigned char byte[4];
+                } data;
+                unsigned char *pb;
+                int i;
+
+                count = len / 4;
+                insl(fifoaddr, buf, count);
+
+                if (len & 0x00000003) {
+                        data.dword = inl(fifoaddr);
+                        pb = (unsigned char *)buf + count * 4;
+                        for (i = 0; i < (len & 0x00000003); i++)
+                                pb[i] = data.byte[i];
+                }
+        } else {
+                len = (len + 1) / 2;
+                insw(r8a66597->reg + offset, buf, len);
+        }
+}
+
+static inline void r8a66597_write(struct r8a66597 *r8a66597, u16 val,
+                                  unsigned long offset)
+{
+        outw(val, r8a66597->reg + offset);
+}
+
+static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
+                                       unsigned long offset, u16 *buf,
+                                       int len)
+{
+        unsigned long fifoaddr = r8a66597->reg + offset;
+
+        if (r8a66597->pdata->on_chip) {
+                unsigned long count;
+                unsigned char *pb;
+                int i;
+
+                count = len / 4;
+                outsl(fifoaddr, buf, count);
+
+                if (len & 0x00000003) {
+                        pb = (unsigned char *)buf + count * 4;
+                        for (i = 0; i < (len & 0x00000003); i++) {
+                                if (r8a66597_read(r8a66597, CFIFOSEL) & BIGEND)
+                                        outb(pb[i], fifoaddr + i);
+                                else
+                                        outb(pb[i], fifoaddr + 3 - i);
+                        }
+                }
+        } else {
+                int odd = len & 0x0001;
+
+                len = len / 2;
+                outsw(fifoaddr, buf, len);
+                if (unlikely(odd)) {
+                        buf = &buf[len];
+                        outb((unsigned char)*buf, fifoaddr);
+                }
+        }
+}
+
+static inline void r8a66597_mdfy(struct r8a66597 *r8a66597,
+                                 u16 val, u16 pat, unsigned long offset)
+{
+        u16 tmp;
+        tmp = r8a66597_read(r8a66597, offset);
+        tmp = tmp & (~pat);
+        tmp = tmp | val;
+        r8a66597_write(r8a66597, tmp, offset);
+}
+
+static inline u16 get_xtal_from_pdata(struct r8a66597_platdata *pdata)
+{
+        u16 clock = 0;
+
+        switch (pdata->xtal) {
+        case R8A66597_PLATDATA_XTAL_12MHZ:
+                clock = XTAL12;
+                break;
+        case R8A66597_PLATDATA_XTAL_24MHZ:
+                clock = XTAL24;
+                break;
+        case R8A66597_PLATDATA_XTAL_48MHZ:
+                clock = XTAL48;
+                break;
+        default:
+                printk(KERN_ERR "r8a66597: platdata clock is wrong.\n");
+                break;
+        }
+
+        return clock;
+}
+
+#define r8a66597_bclr(r8a66597, val, offset)    \
+                        r8a66597_mdfy(r8a66597, 0, val, offset)
+#define r8a66597_bset(r8a66597, val, offset)    \
+                        r8a66597_mdfy(r8a66597, val, 0, offset)
+
+#define get_pipectr_addr(pipenum)       (PIPE1CTR + (pipenum - 1) * 2)
+
+#define enable_irq_ready(r8a66597, pipenum)     \
+        enable_pipe_irq(r8a66597, pipenum, BRDYENB)
+#define disable_irq_ready(r8a66597, pipenum)    \
+        disable_pipe_irq(r8a66597, pipenum, BRDYENB)
+#define enable_irq_empty(r8a66597, pipenum)     \
+        enable_pipe_irq(r8a66597, pipenum, BEMPENB)
+#define disable_irq_empty(r8a66597, pipenum)    \
+        disable_pipe_irq(r8a66597, pipenum, BEMPENB)
+#define enable_irq_nrdy(r8a66597, pipenum)      \
+        enable_pipe_irq(r8a66597, pipenum, NRDYENB)
+#define disable_irq_nrdy(r8a66597, pipenum)     \
+        disable_pipe_irq(r8a66597, pipenum, NRDYENB)
+
+#endif  /* __R8A66597_H__ */
+
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 1a920c70b5a1..f21ca7d27a43 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -336,13 +336,6 @@ config USB_R8A66597_HCD
           To compile this driver as a module, choose M here: the
           module will be called r8a66597-hcd.
 
-config SUPERH_ON_CHIP_R8A66597
-        boolean "Enable SuperH on-chip R8A66597 USB"
-        depends on USB_R8A66597_HCD && (CPU_SUBTYPE_SH7366 || CPU_SUBTYPE_SH7723 || CPU_SUBTYPE_SH7724)
-        help
-           This driver enables support for the on-chip R8A66597 in the
-           SH7366, SH7723 and SH7724 processors.
-
 config USB_WHCI_HCD
         tristate "Wireless USB Host Controller Interface (WHCI) driver (EXPERIMENTAL)"
         depends on EXPERIMENTAL
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index e18f74946e68..749b53742828 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -91,43 +91,43 @@ static int r8a66597_clock_enable(struct r8a66597 *r8a66597)
         u16 tmp;
         int i = 0;
 
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
-#if defined(CONFIG_HAVE_CLK)
-        clk_enable(r8a66597->clk);
+        if (r8a66597->pdata->on_chip) {
+#ifdef CONFIG_HAVE_CLK
+                clk_enable(r8a66597->clk);
 #endif
-        do {
-                r8a66597_write(r8a66597, SCKE, SYSCFG0);
-                tmp = r8a66597_read(r8a66597, SYSCFG0);
-                if (i++ > 1000) {
-                        printk(KERN_ERR "r8a66597: register access fail.\n");
-                        return -ENXIO;
-                }
-        } while ((tmp & SCKE) != SCKE);
-        r8a66597_write(r8a66597, 0x04, 0x02);
-#else
-        do {
-                r8a66597_write(r8a66597, USBE, SYSCFG0);
-                tmp = r8a66597_read(r8a66597, SYSCFG0);
-                if (i++ > 1000) {
-                        printk(KERN_ERR "r8a66597: register access fail.\n");
-                        return -ENXIO;
-                }
-        } while ((tmp & USBE) != USBE);
-        r8a66597_bclr(r8a66597, USBE, SYSCFG0);
-        r8a66597_mdfy(r8a66597, get_xtal_from_pdata(r8a66597->pdata), XTAL,
-                        SYSCFG0);
+                do {
+                        r8a66597_write(r8a66597, SCKE, SYSCFG0);
+                        tmp = r8a66597_read(r8a66597, SYSCFG0);
+                        if (i++ > 1000) {
+                                printk(KERN_ERR "r8a66597: reg access fail.\n");
+                                return -ENXIO;
+                        }
+                } while ((tmp & SCKE) != SCKE);
+                r8a66597_write(r8a66597, 0x04, 0x02);
+        } else {
+                do {
+                        r8a66597_write(r8a66597, USBE, SYSCFG0);
+                        tmp = r8a66597_read(r8a66597, SYSCFG0);
+                        if (i++ > 1000) {
+                                printk(KERN_ERR "r8a66597: reg access fail.\n");
+                                return -ENXIO;
+                        }
+                } while ((tmp & USBE) != USBE);
+                r8a66597_bclr(r8a66597, USBE, SYSCFG0);
+                r8a66597_mdfy(r8a66597, get_xtal_from_pdata(r8a66597->pdata),
+                              XTAL, SYSCFG0);
 
-        i = 0;
-        r8a66597_bset(r8a66597, XCKE, SYSCFG0);
-        do {
-                msleep(1);
-                tmp = r8a66597_read(r8a66597, SYSCFG0);
-                if (i++ > 500) {
-                        printk(KERN_ERR "r8a66597: register access fail.\n");
-                        return -ENXIO;
-                }
-        } while ((tmp & SCKE) != SCKE);
-#endif  /* #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) */
+                i = 0;
+                r8a66597_bset(r8a66597, XCKE, SYSCFG0);
+                do {
+                        msleep(1);
+                        tmp = r8a66597_read(r8a66597, SYSCFG0);
+                        if (i++ > 500) {
+                                printk(KERN_ERR "r8a66597: reg access fail.\n");
+                                return -ENXIO;
+                        }
+                } while ((tmp & SCKE) != SCKE);
+        }
 
         return 0;
 }
@@ -136,15 +136,16 @@ static void r8a66597_clock_disable(struct r8a66597 *r8a66597)
 {
         r8a66597_bclr(r8a66597, SCKE, SYSCFG0);
         udelay(1);
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
-#if defined(CONFIG_HAVE_CLK)
-        clk_disable(r8a66597->clk);
-#endif
-#else
-        r8a66597_bclr(r8a66597, PLLC, SYSCFG0);
-        r8a66597_bclr(r8a66597, XCKE, SYSCFG0);
-        r8a66597_bclr(r8a66597, USBE, SYSCFG0);
+
+        if (r8a66597->pdata->on_chip) {
+#ifdef CONFIG_HAVE_CLK
+                clk_disable(r8a66597->clk);
 #endif
+        } else {
+                r8a66597_bclr(r8a66597, PLLC, SYSCFG0);
+                r8a66597_bclr(r8a66597, XCKE, SYSCFG0);
+                r8a66597_bclr(r8a66597, USBE, SYSCFG0);
+        }
 }
 
 static void r8a66597_enable_port(struct r8a66597 *r8a66597, int port)
@@ -205,7 +206,7 @@ static int enable_controller(struct r8a66597 *r8a66597)
 
         r8a66597_bset(r8a66597, SIGNE | SACKE, INTENB1);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++)
+        for (port = 0; port < r8a66597->max_root_hub; port++)
                 r8a66597_enable_port(r8a66597, port);
 
         return 0;
@@ -218,7 +219,7 @@ static void disable_controller(struct r8a66597 *r8a66597)
         r8a66597_write(r8a66597, 0, INTENB0);
         r8a66597_write(r8a66597, 0, INTSTS0);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++)
+        for (port = 0; port < r8a66597->max_root_hub; port++)
                 r8a66597_disable_port(r8a66597, port);
 
         r8a66597_clock_disable(r8a66597);
@@ -249,11 +250,12 @@ static int is_hub_limit(char *devpath)
         return ((strlen(devpath) >= 4) ? 1 : 0);
 }
 
-static void get_port_number(char *devpath, u16 *root_port, u16 *hub_port)
+static void get_port_number(struct r8a66597 *r8a66597,
+                            char *devpath, u16 *root_port, u16 *hub_port)
 {
         if (root_port) {
                 *root_port = (devpath[0] & 0x0F) - 1;
-                if (*root_port >= R8A66597_MAX_ROOT_HUB)
+                if (*root_port >= r8a66597->max_root_hub)
                         printk(KERN_ERR "r8a66597: Illegal root port number.\n");
         }
         if (hub_port)
@@ -355,7 +357,8 @@ static int make_r8a66597_device(struct r8a66597 *r8a66597,
         INIT_LIST_HEAD(&dev->device_list);
         list_add_tail(&dev->device_list, &r8a66597->child_device);
 
-        get_port_number(urb->dev->devpath, &dev->root_port, &dev->hub_port);
+        get_port_number(r8a66597, urb->dev->devpath,
+                        &dev->root_port, &dev->hub_port);
         if (!is_child_device(urb->dev->devpath))
                 r8a66597->root_hub[dev->root_port].dev = dev;
 
@@ -420,7 +423,7 @@ static void free_usb_address(struct r8a66597 *r8a66597,
         list_del(&dev->device_list);
         kfree(dev);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+        for (port = 0; port < r8a66597->max_root_hub; port++) {
                 if (r8a66597->root_hub[port].dev == dev) {
                         r8a66597->root_hub[port].dev = NULL;
                         break;
@@ -495,10 +498,20 @@ static void r8a66597_pipe_toggle(struct r8a66597 *r8a66597,
                 r8a66597_bset(r8a66597, SQCLR, pipe->pipectr);
 }
 
+static inline unsigned short mbw_value(struct r8a66597 *r8a66597)
+{
+        if (r8a66597->pdata->on_chip)
+                return MBW_32;
+        else
+                return MBW_16;
+}
+
 /* this function must be called with interrupt disabled */
 static inline void cfifo_change(struct r8a66597 *r8a66597, u16 pipenum)
 {
-        r8a66597_mdfy(r8a66597, MBW | pipenum, MBW | CURPIPE, CFIFOSEL);
+        unsigned short mbw = mbw_value(r8a66597);
+
+        r8a66597_mdfy(r8a66597, mbw | pipenum, mbw | CURPIPE, CFIFOSEL);
         r8a66597_reg_wait(r8a66597, CFIFOSEL, CURPIPE, pipenum);
 }
 
@@ -506,11 +519,13 @@ static inline void cfifo_change(struct r8a66597 *r8a66597, u16 pipenum)
 static inline void fifo_change_from_pipe(struct r8a66597 *r8a66597,
                                          struct r8a66597_pipe *pipe)
 {
+        unsigned short mbw = mbw_value(r8a66597);
+
         cfifo_change(r8a66597, 0);
-        r8a66597_mdfy(r8a66597, MBW | 0, MBW | CURPIPE, D0FIFOSEL);
-        r8a66597_mdfy(r8a66597, MBW | 0, MBW | CURPIPE, D1FIFOSEL);
+        r8a66597_mdfy(r8a66597, mbw | 0, mbw | CURPIPE, D0FIFOSEL);
+        r8a66597_mdfy(r8a66597, mbw | 0, mbw | CURPIPE, D1FIFOSEL);
 
-        r8a66597_mdfy(r8a66597, MBW | pipe->info.pipenum, MBW | CURPIPE,
+        r8a66597_mdfy(r8a66597, mbw | pipe->info.pipenum, mbw | CURPIPE,
                       pipe->fifosel);
         r8a66597_reg_wait(r8a66597, pipe->fifosel, CURPIPE, pipe->info.pipenum);
 }
@@ -742,9 +757,13 @@ static void enable_r8a66597_pipe_dma(struct r8a66597 *r8a66597,
                                      struct r8a66597_pipe *pipe,
                                      struct urb *urb)
 {
-#if !defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
         int i;
         struct r8a66597_pipe_info *info = &pipe->info;
+        unsigned short mbw = mbw_value(r8a66597);
+
+        /* pipe dma is only for external controlles */
+        if (r8a66597->pdata->on_chip)
+                return;
 
         if ((pipe->info.pipenum != 0) && (info->type != R8A66597_INT)) {
                 for (i = 0; i < R8A66597_MAX_DMA_CHANNEL; i++) {
@@ -763,8 +782,8 @@ static void enable_r8a66597_pipe_dma(struct r8a66597 *r8a66597,
                         set_pipe_reg_addr(pipe, i);
 
                         cfifo_change(r8a66597, 0);
-                        r8a66597_mdfy(r8a66597, MBW | pipe->info.pipenum,
-                                      MBW | CURPIPE, pipe->fifosel);
+                        r8a66597_mdfy(r8a66597, mbw | pipe->info.pipenum,
+                                      mbw | CURPIPE, pipe->fifosel);
 
                         r8a66597_reg_wait(r8a66597, pipe->fifosel, CURPIPE,
                                           pipe->info.pipenum);
@@ -772,7 +791,6 @@ static void enable_r8a66597_pipe_dma(struct r8a66597 *r8a66597,
                         break;
                 }
         }
-#endif  /* #if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) */
 }
 
 /* this function must be called with interrupt disabled */
@@ -1769,7 +1787,7 @@ static void r8a66597_timer(unsigned long _r8a66597)
 
         spin_lock_irqsave(&r8a66597->lock, flags);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++)
+        for (port = 0; port < r8a66597->max_root_hub; port++)
                 r8a66597_root_hub_control(r8a66597, port);
 
         spin_unlock_irqrestore(&r8a66597->lock, flags);
@@ -1807,7 +1825,7 @@ static void set_address_zero(struct r8a66597 *r8a66597, struct urb *urb)
         u16 root_port, hub_port;
 
         if (usb_address == 0) {
-                get_port_number(urb->dev->devpath,
+                get_port_number(r8a66597, urb->dev->devpath,
                                 &root_port, &hub_port);
                 set_devadd_reg(r8a66597, 0,
                                get_r8a66597_usb_speed(urb->dev->speed),
@@ -2082,7 +2100,7 @@ static int r8a66597_hub_status_data(struct usb_hcd *hcd, char *buf)
 
         *buf = 0;       /* initialize (no change) */
 
-        for (i = 0; i < R8A66597_MAX_ROOT_HUB; i++) {
+        for (i = 0; i < r8a66597->max_root_hub; i++) {
                 if (r8a66597->root_hub[i].port & 0xffff0000)
                         *buf |= 1 << (i + 1);
         }
@@ -2097,11 +2115,11 @@ static void r8a66597_hub_descriptor(struct r8a66597 *r8a66597,
 {
         desc->bDescriptorType = 0x29;
         desc->bHubContrCurrent = 0;
-        desc->bNbrPorts = R8A66597_MAX_ROOT_HUB;
+        desc->bNbrPorts = r8a66597->max_root_hub;
         desc->bDescLength = 9;
         desc->bPwrOn2PwrGood = 0;
         desc->wHubCharacteristics = cpu_to_le16(0x0011);
-        desc->bitmap[0] = ((1 << R8A66597_MAX_ROOT_HUB) - 1) << 1;
+        desc->bitmap[0] = ((1 << r8a66597->max_root_hub) - 1) << 1;
         desc->bitmap[1] = ~0;
 }
 
@@ -2129,7 +2147,7 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 }
                 break;
         case ClearPortFeature:
-                if (wIndex > R8A66597_MAX_ROOT_HUB)
+                if (wIndex > r8a66597->max_root_hub)
                         goto error;
                 if (wLength != 0)
                         goto error;
@@ -2162,12 +2180,12 @@ static int r8a66597_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 *buf = 0x00;
                 break;
         case GetPortStatus:
-                if (wIndex > R8A66597_MAX_ROOT_HUB)
+                if (wIndex > r8a66597->max_root_hub)
                         goto error;
                 *(__le32 *)buf = cpu_to_le32(rh->port);
                 break;
         case SetPortFeature:
-                if (wIndex > R8A66597_MAX_ROOT_HUB)
+                if (wIndex > r8a66597->max_root_hub)
                         goto error;
                 if (wLength != 0)
                         goto error;
@@ -2216,7 +2234,7 @@ static int r8a66597_bus_suspend(struct usb_hcd *hcd)
 
         dbg("%s", __func__);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+        for (port = 0; port < r8a66597->max_root_hub; port++) {
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
 
@@ -2247,7 +2265,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
 
         dbg("%s", __func__);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+        for (port = 0; port < r8a66597->max_root_hub; port++) {
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
                 unsigned long dvstctr_reg = get_dvstctr_reg(port);
 
@@ -2305,16 +2323,16 @@ static struct hc_driver r8a66597_hc_driver = {
 };
 
 #if defined(CONFIG_PM)
-static int r8a66597_suspend(struct platform_device *pdev, pm_message_t state)
+static int r8a66597_suspend(struct device *dev)
 {
-        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+        struct r8a66597         *r8a66597 = dev_get_drvdata(dev);
         int port;
 
         dbg("%s", __func__);
 
         disable_controller(r8a66597);
 
-        for (port = 0; port < R8A66597_MAX_ROOT_HUB; port++) {
+        for (port = 0; port < r8a66597->max_root_hub; port++) {
                 struct r8a66597_root_hub *rh = &r8a66597->root_hub[port];
 
                 rh->port = 0x00000000;
@@ -2323,9 +2341,9 @@ static int r8a66597_suspend(struct platform_device *pdev, pm_message_t state)
         return 0;
 }
 
-static int r8a66597_resume(struct platform_device *pdev)
+static int r8a66597_resume(struct device *dev)
 {
-        struct r8a66597         *r8a66597 = dev_get_drvdata(&pdev->dev);
+        struct r8a66597         *r8a66597 = dev_get_drvdata(dev);
         struct usb_hcd          *hcd = r8a66597_to_hcd(r8a66597);
 
         dbg("%s", __func__);
@@ -2335,9 +2353,17 @@ static int r8a66597_resume(struct platform_device *pdev)
 
         return 0;
 }
+
+static struct dev_pm_ops r8a66597_dev_pm_ops = {
+        .suspend = r8a66597_suspend,
+        .resume = r8a66597_resume,
+        .poweroff = r8a66597_suspend,
+        .restore = r8a66597_resume,
+};
+
+#define R8A66597_DEV_PM_OPS     (&r8a66597_dev_pm_ops)
 #else   /* if defined(CONFIG_PM) */
-#define r8a66597_suspend        NULL
-#define r8a66597_resume         NULL
+#define R8A66597_DEV_PM_OPS     NULL
 #endif
 
 static int __init_or_module r8a66597_remove(struct platform_device *pdev)
@@ -2348,8 +2374,9 @@ static int __init_or_module r8a66597_remove(struct platform_device *pdev)
         del_timer_sync(&r8a66597->rh_timer);
         usb_remove_hcd(hcd);
         iounmap((void *)r8a66597->reg);
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
-        clk_put(r8a66597->clk);
+#ifdef CONFIG_HAVE_CLK
+        if (r8a66597->pdata->on_chip)
+                clk_put(r8a66597->clk);
 #endif
         usb_put_hcd(hcd);
         return 0;
@@ -2357,7 +2384,7 @@ static int __init_or_module r8a66597_remove(struct platform_device *pdev)
 
 static int __devinit r8a66597_probe(struct platform_device *pdev)
 {
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
+#ifdef CONFIG_HAVE_CLK
         char clk_name[8];
 #endif
         struct resource *res = NULL, *ires;
@@ -2419,15 +2446,20 @@ static int __devinit r8a66597_probe(struct platform_device *pdev)
         r8a66597->pdata = pdev->dev.platform_data;
         r8a66597->irq_sense_low = irq_trigger == IRQF_TRIGGER_LOW;
 
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
-        snprintf(clk_name, sizeof(clk_name), "usb%d", pdev->id);
-        r8a66597->clk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(r8a66597->clk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                ret = PTR_ERR(r8a66597->clk);
-                goto clean_up2;
-        }
+        if (r8a66597->pdata->on_chip) {
+#ifdef CONFIG_HAVE_CLK
+                snprintf(clk_name, sizeof(clk_name), "usb%d", pdev->id);
+                r8a66597->clk = clk_get(&pdev->dev, clk_name);
+                if (IS_ERR(r8a66597->clk)) {
+                        dev_err(&pdev->dev, "cannot get clock \"%s\"\n",
+                                clk_name);
+                        ret = PTR_ERR(r8a66597->clk);
+                        goto clean_up2;
+                }
 #endif
+                r8a66597->max_root_hub = 1;
+        } else
+                r8a66597->max_root_hub = 2;
 
         spin_lock_init(&r8a66597->lock);
         init_timer(&r8a66597->rh_timer);
@@ -2457,8 +2489,9 @@ static int __devinit r8a66597_probe(struct platform_device *pdev)
         return 0;
 
 clean_up3:
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
-        clk_put(r8a66597->clk);
+#ifdef CONFIG_HAVE_CLK
+        if (r8a66597->pdata->on_chip)
+                clk_put(r8a66597->clk);
 clean_up2:
 #endif
         usb_put_hcd(hcd);
@@ -2473,11 +2506,10 @@ clean_up:
 static struct platform_driver r8a66597_driver = {
         .probe =        r8a66597_probe,
         .remove =       r8a66597_remove,
-        .suspend =      r8a66597_suspend,
-        .resume =       r8a66597_resume,
         .driver         = {
                 .name = (char *) hcd_name,
                 .owner  = THIS_MODULE,
+                .pm     = R8A66597_DEV_PM_OPS,
         },
 };
 
diff --git a/drivers/usb/host/r8a66597.h b/drivers/usb/host/r8a66597.h
index d72680b433f9..228e3fb23854 100644
--- a/drivers/usb/host/r8a66597.h
+++ b/drivers/usb/host/r8a66597.h
@@ -26,390 +26,16 @@
 #ifndef __R8A66597_H__
 #define __R8A66597_H__
 
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
+#ifdef CONFIG_HAVE_CLK
 #include <linux/clk.h>
 #endif
 
 #include <linux/usb/r8a66597.h>
 
-#define SYSCFG0         0x00
-#define SYSCFG1         0x02
-#define SYSSTS0         0x04
-#define SYSSTS1         0x06
-#define DVSTCTR0        0x08
-#define DVSTCTR1        0x0A
-#define TESTMODE        0x0C
-#define PINCFG          0x0E
-#define DMA0CFG         0x10
-#define DMA1CFG         0x12
-#define CFIFO           0x14
-#define D0FIFO          0x18
-#define D1FIFO          0x1C
-#define CFIFOSEL        0x20
-#define CFIFOCTR        0x22
-#define CFIFOSIE        0x24
-#define D0FIFOSEL       0x28
-#define D0FIFOCTR       0x2A
-#define D1FIFOSEL       0x2C
-#define D1FIFOCTR       0x2E
-#define INTENB0         0x30
-#define INTENB1         0x32
-#define INTENB2         0x34
-#define BRDYENB         0x36
-#define NRDYENB         0x38
-#define BEMPENB         0x3A
-#define SOFCFG          0x3C
-#define INTSTS0         0x40
-#define INTSTS1         0x42
-#define INTSTS2         0x44
-#define BRDYSTS         0x46
-#define NRDYSTS         0x48
-#define BEMPSTS         0x4A
-#define FRMNUM          0x4C
-#define UFRMNUM         0x4E
-#define USBADDR         0x50
-#define USBREQ          0x54
-#define USBVAL          0x56
-#define USBINDX         0x58
-#define USBLENG         0x5A
-#define DCPCFG          0x5C
-#define DCPMAXP         0x5E
-#define DCPCTR          0x60
-#define PIPESEL         0x64
-#define PIPECFG         0x68
-#define PIPEBUF         0x6A
-#define PIPEMAXP        0x6C
-#define PIPEPERI        0x6E
-#define PIPE1CTR        0x70
-#define PIPE2CTR        0x72
-#define PIPE3CTR        0x74
-#define PIPE4CTR        0x76
-#define PIPE5CTR        0x78
-#define PIPE6CTR        0x7A
-#define PIPE7CTR        0x7C
-#define PIPE8CTR        0x7E
-#define PIPE9CTR        0x80
-#define PIPE1TRE        0x90
-#define PIPE1TRN        0x92
-#define PIPE2TRE        0x94
-#define PIPE2TRN        0x96
-#define PIPE3TRE        0x98
-#define PIPE3TRN        0x9A
-#define PIPE4TRE        0x9C
-#define PIPE4TRN        0x9E
-#define PIPE5TRE        0xA0
-#define PIPE5TRN        0xA2
-#define DEVADD0         0xD0
-#define DEVADD1         0xD2
-#define DEVADD2         0xD4
-#define DEVADD3         0xD6
-#define DEVADD4         0xD8
-#define DEVADD5         0xDA
-#define DEVADD6         0xDC
-#define DEVADD7         0xDE
-#define DEVADD8         0xE0
-#define DEVADD9         0xE2
-#define DEVADDA         0xE4
-
-/* System Configuration Control Register */
-#define XTAL            0xC000  /* b15-14: Crystal selection */
-#define   XTAL48         0x8000   /* 48MHz */
-#define   XTAL24         0x4000   /* 24MHz */
-#define   XTAL12         0x0000   /* 12MHz */
-#define XCKE            0x2000  /* b13: External clock enable */
-#define PLLC            0x0800  /* b11: PLL control */
-#define SCKE            0x0400  /* b10: USB clock enable */
-#define PCSDIS          0x0200  /* b9: not CS wakeup */
-#define LPSME           0x0100  /* b8: Low power sleep mode */
-#define HSE             0x0080  /* b7: Hi-speed enable */
-#define DCFM            0x0040  /* b6: Controller function select  */
-#define DRPD            0x0020  /* b5: D+/- pull down control */
-#define DPRPU           0x0010  /* b4: D+ pull up control */
-#define USBE            0x0001  /* b0: USB module operation enable */
-
-/* System Configuration Status Register */
-#define OVCBIT          0x8000  /* b15-14: Over-current bit */
-#define OVCMON          0xC000  /* b15-14: Over-current monitor */
-#define SOFEA           0x0020  /* b5: SOF monitor */
-#define IDMON           0x0004  /* b3: ID-pin monitor */
-#define LNST            0x0003  /* b1-0: D+, D- line status */
-#define   SE1            0x0003   /* SE1 */
-#define   FS_KSTS        0x0002   /* Full-Speed K State */
-#define   FS_JSTS        0x0001   /* Full-Speed J State */
-#define   LS_JSTS        0x0002   /* Low-Speed J State */
-#define   LS_KSTS        0x0001   /* Low-Speed K State */
-#define   SE0            0x0000   /* SE0 */
-
-/* Device State Control Register */
-#define EXTLP0          0x0400  /* b10: External port */
-#define VBOUT           0x0200  /* b9: VBUS output */
-#define WKUP            0x0100  /* b8: Remote wakeup */
-#define RWUPE           0x0080  /* b7: Remote wakeup sense */
-#define USBRST          0x0040  /* b6: USB reset enable */
-#define RESUME          0x0020  /* b5: Resume enable */
-#define UACT            0x0010  /* b4: USB bus enable */
-#define RHST            0x0007  /* b1-0: Reset handshake status */
-#define   HSPROC         0x0004   /* HS handshake is processing */
-#define   HSMODE         0x0003   /* Hi-Speed mode */
-#define   FSMODE         0x0002   /* Full-Speed mode */
-#define   LSMODE         0x0001   /* Low-Speed mode */
-#define   UNDECID        0x0000   /* Undecided */
-
-/* Test Mode Register */
-#define UTST                    0x000F  /* b3-0: Test select */
-#define   H_TST_PACKET           0x000C   /* HOST TEST Packet */
-#define   H_TST_SE0_NAK          0x000B   /* HOST TEST SE0 NAK */
-#define   H_TST_K                0x000A   /* HOST TEST K */
-#define   H_TST_J                0x0009   /* HOST TEST J */
-#define   H_TST_NORMAL           0x0000   /* HOST Normal Mode */
-#define   P_TST_PACKET           0x0004   /* PERI TEST Packet */
-#define   P_TST_SE0_NAK          0x0003   /* PERI TEST SE0 NAK */
-#define   P_TST_K                0x0002   /* PERI TEST K */
-#define   P_TST_J                0x0001   /* PERI TEST J */
-#define   P_TST_NORMAL           0x0000   /* PERI Normal Mode */
-
-/* Data Pin Configuration Register */
-#define LDRV                    0x8000  /* b15: Drive Current Adjust */
-#define   VIF1                    0x0000                /* VIF = 1.8V */
-#define   VIF3                    0x8000                /* VIF = 3.3V */
-#define INTA                    0x0001  /* b1: USB INT-pin active */
-
-/* DMAx Pin Configuration Register */
-#define DREQA                   0x4000  /* b14: Dreq active select */
-#define BURST                   0x2000  /* b13: Burst mode */
-#define DACKA                   0x0400  /* b10: Dack active select */
-#define DFORM                   0x0380  /* b9-7: DMA mode select */
-#define   CPU_ADR_RD_WR          0x0000   /* Address + RD/WR mode (CPU bus) */
-#define   CPU_DACK_RD_WR         0x0100   /* DACK + RD/WR mode (CPU bus) */
-#define   CPU_DACK_ONLY          0x0180   /* DACK only mode (CPU bus) */
-#define   SPLIT_DACK_ONLY        0x0200   /* DACK only mode (SPLIT bus) */
-#define DENDA                   0x0040  /* b6: Dend active select */
-#define PKTM                    0x0020  /* b5: Packet mode */
-#define DENDE                   0x0010  /* b4: Dend enable */
-#define OBUS                    0x0004  /* b2: OUTbus mode */
-
-/* CFIFO/DxFIFO Port Select Register */
-#define RCNT            0x8000  /* b15: Read count mode */
-#define REW             0x4000  /* b14: Buffer rewind */
-#define DCLRM           0x2000  /* b13: DMA buffer clear mode */
-#define DREQE           0x1000  /* b12: DREQ output enable */
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
-#define MBW             0x0800
-#else
-#define MBW             0x0400  /* b10: Maximum bit width for FIFO access */
-#endif
-#define   MBW_8          0x0000   /*  8bit */
-#define   MBW_16         0x0400   /* 16bit */
-#define BIGEND          0x0100  /* b8: Big endian mode */
-#define   BYTE_LITTLE    0x0000         /* little dendian */
-#define   BYTE_BIG       0x0100         /* big endifan */
-#define ISEL            0x0020  /* b5: DCP FIFO port direction select */
-#define CURPIPE         0x000F  /* b2-0: PIPE select */
-
-/* CFIFO/DxFIFO Port Control Register */
-#define BVAL            0x8000  /* b15: Buffer valid flag */
-#define BCLR            0x4000  /* b14: Buffer clear */
-#define FRDY            0x2000  /* b13: FIFO ready */
-#define DTLN            0x0FFF  /* b11-0: FIFO received data length */
-
-/* Interrupt Enable Register 0 */
-#define VBSE    0x8000  /* b15: VBUS interrupt */
-#define RSME    0x4000  /* b14: Resume interrupt */
-#define SOFE    0x2000  /* b13: Frame update interrupt */
-#define DVSE    0x1000  /* b12: Device state transition interrupt */
-#define CTRE    0x0800  /* b11: Control transfer stage transition interrupt */
-#define BEMPE   0x0400  /* b10: Buffer empty interrupt */
-#define NRDYE   0x0200  /* b9: Buffer not ready interrupt */
-#define BRDYE   0x0100  /* b8: Buffer ready interrupt */
-
-/* Interrupt Enable Register 1 */
-#define OVRCRE          0x8000  /* b15: Over-current interrupt */
-#define BCHGE           0x4000  /* b14: USB us chenge interrupt */
-#define DTCHE           0x1000  /* b12: Detach sense interrupt */
-#define ATTCHE          0x0800  /* b11: Attach sense interrupt */
-#define EOFERRE         0x0040  /* b6: EOF error interrupt */
-#define SIGNE           0x0020  /* b5: SETUP IGNORE interrupt */
-#define SACKE           0x0010  /* b4: SETUP ACK interrupt */
-
-/* BRDY Interrupt Enable/Status Register */
-#define BRDY9           0x0200  /* b9: PIPE9 */
-#define BRDY8           0x0100  /* b8: PIPE8 */
-#define BRDY7           0x0080  /* b7: PIPE7 */
-#define BRDY6           0x0040  /* b6: PIPE6 */
-#define BRDY5           0x0020  /* b5: PIPE5 */
-#define BRDY4           0x0010  /* b4: PIPE4 */
-#define BRDY3           0x0008  /* b3: PIPE3 */
-#define BRDY2           0x0004  /* b2: PIPE2 */
-#define BRDY1           0x0002  /* b1: PIPE1 */
-#define BRDY0           0x0001  /* b1: PIPE0 */
-
-/* NRDY Interrupt Enable/Status Register */
-#define NRDY9           0x0200  /* b9: PIPE9 */
-#define NRDY8           0x0100  /* b8: PIPE8 */
-#define NRDY7           0x0080  /* b7: PIPE7 */
-#define NRDY6           0x0040  /* b6: PIPE6 */
-#define NRDY5           0x0020  /* b5: PIPE5 */
-#define NRDY4           0x0010  /* b4: PIPE4 */
-#define NRDY3           0x0008  /* b3: PIPE3 */
-#define NRDY2           0x0004  /* b2: PIPE2 */
-#define NRDY1           0x0002  /* b1: PIPE1 */
-#define NRDY0           0x0001  /* b1: PIPE0 */
-
-/* BEMP Interrupt Enable/Status Register */
-#define BEMP9           0x0200  /* b9: PIPE9 */
-#define BEMP8           0x0100  /* b8: PIPE8 */
-#define BEMP7           0x0080  /* b7: PIPE7 */
-#define BEMP6           0x0040  /* b6: PIPE6 */
-#define BEMP5           0x0020  /* b5: PIPE5 */
-#define BEMP4           0x0010  /* b4: PIPE4 */
-#define BEMP3           0x0008  /* b3: PIPE3 */
-#define BEMP2           0x0004  /* b2: PIPE2 */
-#define BEMP1           0x0002  /* b1: PIPE1 */
-#define BEMP0           0x0001  /* b0: PIPE0 */
-
-/* SOF Pin Configuration Register */
-#define TRNENSEL        0x0100  /* b8: Select transaction enable period */
-#define BRDYM           0x0040  /* b6: BRDY clear timing */
-#define INTL            0x0020  /* b5: Interrupt sense select */
-#define EDGESTS         0x0010  /* b4:  */
-#define SOFMODE         0x000C  /* b3-2: SOF pin select */
-#define   SOF_125US      0x0008   /* SOF OUT 125us Frame Signal */
-#define   SOF_1MS        0x0004   /* SOF OUT 1ms Frame Signal */
-#define   SOF_DISABLE    0x0000   /* SOF OUT Disable */
-
-/* Interrupt Status Register 0 */
-#define VBINT   0x8000  /* b15: VBUS interrupt */
-#define RESM    0x4000  /* b14: Resume interrupt */
-#define SOFR    0x2000  /* b13: SOF frame update interrupt */
-#define DVST    0x1000  /* b12: Device state transition interrupt */
-#define CTRT    0x0800  /* b11: Control transfer stage transition interrupt */
-#define BEMP    0x0400  /* b10: Buffer empty interrupt */
-#define NRDY    0x0200  /* b9: Buffer not ready interrupt */
-#define BRDY    0x0100  /* b8: Buffer ready interrupt */
-#define VBSTS   0x0080  /* b7: VBUS input port */
-#define DVSQ    0x0070  /* b6-4: Device state */
-#define   DS_SPD_CNFG    0x0070   /* Suspend Configured */
-#define   DS_SPD_ADDR    0x0060   /* Suspend Address */
-#define   DS_SPD_DFLT    0x0050   /* Suspend Default */
-#define   DS_SPD_POWR    0x0040   /* Suspend Powered */
-#define   DS_SUSP        0x0040   /* Suspend */
-#define   DS_CNFG        0x0030   /* Configured */
-#define   DS_ADDS        0x0020   /* Address */
-#define   DS_DFLT        0x0010   /* Default */
-#define   DS_POWR        0x0000   /* Powered */
-#define DVSQS           0x0030  /* b5-4: Device state */
-#define VALID           0x0008  /* b3: Setup packet detected flag */
-#define CTSQ            0x0007  /* b2-0: Control transfer stage */
-#define   CS_SQER        0x0006   /* Sequence error */
-#define   CS_WRND        0x0005   /* Control write nodata status stage */
-#define   CS_WRSS        0x0004   /* Control write status stage */
-#define   CS_WRDS        0x0003   /* Control write data stage */
-#define   CS_RDSS        0x0002   /* Control read status stage */
-#define   CS_RDDS        0x0001   /* Control read data stage */
-#define   CS_IDST        0x0000   /* Idle or setup stage */
-
-/* Interrupt Status Register 1 */
-#define OVRCR           0x8000  /* b15: Over-current interrupt */
-#define BCHG            0x4000  /* b14: USB bus chenge interrupt */
-#define DTCH            0x1000  /* b12: Detach sense interrupt */
-#define ATTCH           0x0800  /* b11: Attach sense interrupt */
-#define EOFERR          0x0040  /* b6: EOF-error interrupt */
-#define SIGN            0x0020  /* b5: Setup ignore interrupt */
-#define SACK            0x0010  /* b4: Setup acknowledge interrupt */
-
-/* Frame Number Register */
-#define OVRN            0x8000  /* b15: Overrun error */
-#define CRCE            0x4000  /* b14: Received data error */
-#define FRNM            0x07FF  /* b10-0: Frame number */
-
-/* Micro Frame Number Register */
-#define UFRNM           0x0007  /* b2-0: Micro frame number */
-
-/* Default Control Pipe Maxpacket Size Register */
-/* Pipe Maxpacket Size Register */
-#define DEVSEL  0xF000  /* b15-14: Device address select */
-#define MAXP    0x007F  /* b6-0: Maxpacket size of default control pipe */
-
-/* Default Control Pipe Control Register */
-#define BSTS            0x8000  /* b15: Buffer status */
-#define SUREQ           0x4000  /* b14: Send USB request  */
-#define CSCLR           0x2000  /* b13: complete-split status clear */
-#define CSSTS           0x1000  /* b12: complete-split status */
-#define SUREQCLR        0x0800  /* b11: stop setup request */
-#define SQCLR           0x0100  /* b8: Sequence toggle bit clear */
-#define SQSET           0x0080  /* b7: Sequence toggle bit set */
-#define SQMON           0x0040  /* b6: Sequence toggle bit monitor */
-#define PBUSY           0x0020  /* b5: pipe busy */
-#define PINGE           0x0010  /* b4: ping enable */
-#define CCPL            0x0004  /* b2: Enable control transfer complete */
-#define PID             0x0003  /* b1-0: Response PID */
-#define   PID_STALL11    0x0003   /* STALL */
-#define   PID_STALL      0x0002   /* STALL */
-#define   PID_BUF        0x0001   /* BUF */
-#define   PID_NAK        0x0000   /* NAK */
-
-/* Pipe Window Select Register */
-#define PIPENM          0x0007  /* b2-0: Pipe select */
-
-/* Pipe Configuration Register */
-#define R8A66597_TYP    0xC000  /* b15-14: Transfer type */
-#define   R8A66597_ISO   0xC000           /* Isochronous */
-#define   R8A66597_INT   0x8000           /* Interrupt */
-#define   R8A66597_BULK  0x4000           /* Bulk */
-#define R8A66597_BFRE   0x0400  /* b10: Buffer ready interrupt mode select */
-#define R8A66597_DBLB   0x0200  /* b9: Double buffer mode select */
-#define R8A66597_CNTMD  0x0100  /* b8: Continuous transfer mode select */
-#define R8A66597_SHTNAK 0x0080  /* b7: Transfer end NAK */
-#define R8A66597_DIR    0x0010  /* b4: Transfer direction select */
-#define R8A66597_EPNUM  0x000F  /* b3-0: Eendpoint number select */
-
-/* Pipe Buffer Configuration Register */
-#define BUFSIZE         0x7C00  /* b14-10: Pipe buffer size */
-#define BUFNMB          0x007F  /* b6-0: Pipe buffer number */
-#define PIPE0BUF        256
-#define PIPExBUF        64
-
-/* Pipe Maxpacket Size Register */
-#define MXPS            0x07FF  /* b10-0: Maxpacket size */
-
-/* Pipe Cycle Configuration Register */
-#define IFIS    0x1000  /* b12: Isochronous in-buffer flush mode select */
-#define IITV    0x0007  /* b2-0: Isochronous interval */
-
-/* Pipex Control Register */
-#define BSTS    0x8000  /* b15: Buffer status */
-#define INBUFM  0x4000  /* b14: IN buffer monitor (Only for PIPE1 to 5) */
-#define CSCLR   0x2000  /* b13: complete-split status clear */
-#define CSSTS   0x1000  /* b12: complete-split status */
-#define ATREPM  0x0400  /* b10: Auto repeat mode */
-#define ACLRM   0x0200  /* b9: Out buffer auto clear mode */
-#define SQCLR   0x0100  /* b8: Sequence toggle bit clear */
-#define SQSET   0x0080  /* b7: Sequence toggle bit set */
-#define SQMON   0x0040  /* b6: Sequence toggle bit monitor */
-#define PBUSY   0x0020  /* b5: pipe busy */
-#define PID     0x0003  /* b1-0: Response PID */
-
-/* PIPExTRE */
-#define TRENB           0x0200  /* b9: Transaction counter enable */
-#define TRCLR           0x0100  /* b8: Transaction counter clear */
-
-/* PIPExTRN */
-#define TRNCNT          0xFFFF  /* b15-0: Transaction counter */
-
-/* DEVADDx */
-#define UPPHUB          0x7800
-#define HUBPORT         0x0700
-#define USBSPD          0x00C0
-#define RTPORT          0x0001
-
 #define R8A66597_MAX_NUM_PIPE           10
 #define R8A66597_BUF_BSIZE              8
 #define R8A66597_MAX_DEVICE             10
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
-#define R8A66597_MAX_ROOT_HUB           1
-#else
 #define R8A66597_MAX_ROOT_HUB           2
-#endif
 #define R8A66597_MAX_SAMPLING           5
 #define R8A66597_RH_POLL_TIME           10
 #define R8A66597_MAX_DMA_CHANNEL        2
@@ -487,7 +113,7 @@ struct r8a66597_root_hub {
 struct r8a66597 {
         spinlock_t lock;
         unsigned long reg;
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597) && defined(CONFIG_HAVE_CLK)
+#ifdef CONFIG_HAVE_CLK
         struct clk *clk;
 #endif
         struct r8a66597_platdata        *pdata;
@@ -504,6 +130,7 @@ struct r8a66597 {
         unsigned short interval_map;
         unsigned char pipe_cnt[R8A66597_MAX_NUM_PIPE];
         unsigned char dma_map;
+        unsigned int max_root_hub;
 
         struct list_head child_device;
         unsigned long child_connect_map[4];
@@ -550,21 +177,22 @@ static inline void r8a66597_read_fifo(struct r8a66597 *r8a66597,
                                       unsigned long offset, u16 *buf,
                                       int len)
 {
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
         unsigned long fifoaddr = r8a66597->reg + offset;
         unsigned long count;
 
-        count = len / 4;
-        insl(fifoaddr, buf, count);
+        if (r8a66597->pdata->on_chip) {
+                count = len / 4;
+                insl(fifoaddr, buf, count);
 
-        if (len & 0x00000003) {
-                unsigned long tmp = inl(fifoaddr);
-                memcpy((unsigned char *)buf + count * 4, &tmp, len & 0x03);
+                if (len & 0x00000003) {
+                        unsigned long tmp = inl(fifoaddr);
+                        memcpy((unsigned char *)buf + count * 4, &tmp,
+                               len & 0x03);
+                }
+        } else {
+                len = (len + 1) / 2;
+                insw(fifoaddr, buf, len);
         }
-#else
-        len = (len + 1) / 2;
-        insw(r8a66597->reg + offset, buf, len);
-#endif
 }
 
 static inline void r8a66597_write(struct r8a66597 *r8a66597, u16 val,
@@ -578,33 +206,33 @@ static inline void r8a66597_write_fifo(struct r8a66597 *r8a66597,
                                        int len)
 {
         unsigned long fifoaddr = r8a66597->reg + offset;
-#if defined(CONFIG_SUPERH_ON_CHIP_R8A66597)
         unsigned long count;
         unsigned char *pb;
         int i;
 
-        count = len / 4;
-        outsl(fifoaddr, buf, count);
+        if (r8a66597->pdata->on_chip) {
+                count = len / 4;
+                outsl(fifoaddr, buf, count);
+
+                if (len & 0x00000003) {
+                        pb = (unsigned char *)buf + count * 4;
+                        for (i = 0; i < (len & 0x00000003); i++) {
+                                if (r8a66597_read(r8a66597, CFIFOSEL) & BIGEND)
+                                        outb(pb[i], fifoaddr + i);
+                                else
+                                        outb(pb[i], fifoaddr + 3 - i);
+                        }
+                }
+        } else {
+                int odd = len & 0x0001;
 
-        if (len & 0x00000003) {
-                pb = (unsigned char *)buf + count * 4;
-                for (i = 0; i < (len & 0x00000003); i++) {
-                        if (r8a66597_read(r8a66597, CFIFOSEL) & BIGEND)
-                                outb(pb[i], fifoaddr + i);
-                        else
-                                outb(pb[i], fifoaddr + 3 - i);
+                len = len / 2;
+                outsw(fifoaddr, buf, len);
+                if (unlikely(odd)) {
+                        buf = &buf[len];
+                        outb((unsigned char)*buf, fifoaddr);
                 }
         }
-#else
-        int odd = len & 0x0001;
-
-        len = len / 2;
-        outsw(fifoaddr, buf, len);
-        if (unlikely(odd)) {
-                buf = &buf[len];
-                outb((unsigned char)*buf, fifoaddr);
-        }
-#endif
 }
 
 static inline void r8a66597_mdfy(struct r8a66597 *r8a66597,
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 90e1a8dedfa9..e75bb87ee92b 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -727,7 +727,7 @@ static const struct file_operations iowarrior_fops = {
         .poll = iowarrior_poll,
 };
 
-static char *iowarrior_nodename(struct device *dev)
+static char *iowarrior_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
 }
@@ -738,7 +738,7 @@ static char *iowarrior_nodename(struct device *dev)
  */
 static struct usb_class_driver iowarrior_class = {
         .name = "iowarrior%d",
-        .nodename = iowarrior_nodename,
+        .devnode = iowarrior_devnode,
         .fops = &iowarrior_fops,
         .minor_base = IOWARRIOR_MINOR_BASE,
 };
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index c1e2433f640d..97efeaec4d52 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -266,7 +266,7 @@ static const struct file_operations tower_fops = {
         .llseek =       tower_llseek,
 };
 
-static char *legousbtower_nodename(struct device *dev)
+static char *legousbtower_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
 }
@@ -277,7 +277,7 @@ static char *legousbtower_nodename(struct device *dev)
  */
 static struct usb_class_driver tower_class = {
         .name =         "legousbtower%d",
-        .nodename =     legousbtower_nodename,
+        .devnode =      legousbtower_devnode,
         .fops =         &tower_fops,
         .minor_base =   LEGO_USB_TOWER_MINOR_BASE,
 };
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index aec61880f36c..5d25d3e52bf6 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -35,11 +35,6 @@ static struct usb_device_id id_table [] = {
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-struct ark3116_private {
-        spinlock_t lock;
-        u8 termios_initialized;
-};
-
 static inline void ARK3116_SND(struct usb_serial *serial, int seq,
                                __u8 request, __u8 requesttype,
                                __u16 value, __u16 index)
@@ -82,22 +77,11 @@ static inline void ARK3116_RCV_QUIET(struct usb_serial *serial,
 static int ark3116_attach(struct usb_serial *serial)
 {
         char *buf;
-        struct ark3116_private *priv;
-        int i;
-
-        for (i = 0; i < serial->num_ports; ++i) {
-                priv = kzalloc(sizeof(struct ark3116_private), GFP_KERNEL);
-                if (!priv)
-                        goto cleanup;
-                spin_lock_init(&priv->lock);
-
-                usb_set_serial_port_data(serial->port[i], priv);
-        }
 
         buf = kmalloc(1, GFP_KERNEL);
         if (!buf) {
                 dbg("error kmalloc -> out of mem?");
-                goto cleanup;
+                return -ENOMEM;
         }
 
         /* 3 */
@@ -149,13 +133,16 @@ static int ark3116_attach(struct usb_serial *serial)
 
         kfree(buf);
         return 0;
+}
 
-cleanup:
-        for (--i; i >= 0; --i) {
-                kfree(usb_get_serial_port_data(serial->port[i]));
-                usb_set_serial_port_data(serial->port[i], NULL);
-        }
-        return -ENOMEM;
+static void ark3116_init_termios(struct tty_struct *tty)
+{
+        struct ktermios *termios = tty->termios;
+        *termios = tty_std_termios;
+        termios->c_cflag = B9600 | CS8
+                                      | CREAD | HUPCL | CLOCAL;
+        termios->c_ispeed = 9600;
+        termios->c_ospeed = 9600;
 }
 
 static void ark3116_set_termios(struct tty_struct *tty,
@@ -163,10 +150,8 @@ static void ark3116_set_termios(struct tty_struct *tty,
                                 struct ktermios *old_termios)
 {
         struct usb_serial *serial = port->serial;
-        struct ark3116_private *priv = usb_get_serial_port_data(port);
         struct ktermios *termios = tty->termios;
         unsigned int cflag = termios->c_cflag;
-        unsigned long flags;
         int baud;
         int ark3116_baud;
         char *buf;
@@ -176,16 +161,6 @@ static void ark3116_set_termios(struct tty_struct *tty,
 
         dbg("%s - port %d", __func__, port->number);
 
-        spin_lock_irqsave(&priv->lock, flags);
-        if (!priv->termios_initialized) {
-                *termios = tty_std_termios;
-                termios->c_cflag = B9600 | CS8
-                                              | CREAD | HUPCL | CLOCAL;
-                termios->c_ispeed = 9600;
-                termios->c_ospeed = 9600;
-                priv->termios_initialized = 1;
-        }
-        spin_unlock_irqrestore(&priv->lock, flags);
 
         cflag = termios->c_cflag;
         termios->c_cflag &= ~(CMSPAR|CRTSCTS);
@@ -318,8 +293,7 @@ static void ark3116_set_termios(struct tty_struct *tty,
         return;
 }
 
-static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                        struct file *filp)
+static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct ktermios tmp_termios;
         struct usb_serial *serial = port->serial;
@@ -334,7 +308,7 @@ static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
                 return -ENOMEM;
         }
 
-        result = usb_serial_generic_open(tty, port, filp);
+        result = usb_serial_generic_open(tty, port);
         if (result)
                 goto err_out;
 
@@ -455,6 +429,7 @@ static struct usb_serial_driver ark3116_device = {
         .num_ports =            1,
         .attach =               ark3116_attach,
         .set_termios =          ark3116_set_termios,
+        .init_termios =         ark3116_init_termios,
         .ioctl =                ark3116_ioctl,
         .tiocmget =             ark3116_tiocmget,
         .open =                 ark3116_open,
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index 7033b031b443..a0467bc61627 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -92,7 +92,7 @@ static int debug;
 static int  belkin_sa_startup(struct usb_serial *serial);
 static void belkin_sa_release(struct usb_serial *serial);
 static int  belkin_sa_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+                        struct usb_serial_port *port);
 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,
@@ -213,7 +213,7 @@ static void belkin_sa_release(struct usb_serial *serial)
 
 
 static int  belkin_sa_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+                                        struct usb_serial_port *port)
 {
         int retval = 0;
 
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index 2830766f5b39..8c894a7d5dcf 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -300,8 +300,7 @@ static void ch341_close(struct usb_serial_port *port)
 
 
 /* open this device, set default parameters */
-static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
@@ -333,7 +332,7 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
                 return -EPROTO;
         }
 
-        r = usb_serial_generic_open(tty, port, filp);
+        r = usb_serial_generic_open(tty, port);
 
 out:    return r;
 }
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index 0e4f2e41ace5..b22ac3258523 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/console.h>
+#include <linux/serial.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
@@ -63,7 +64,7 @@ static int usb_console_setup(struct console *co, char *options)
         char *s;
         struct usb_serial *serial;
         struct usb_serial_port *port;
-        int retval = 0;
+        int retval;
         struct tty_struct *tty = NULL;
         struct ktermios *termios = NULL, dummy;
 
@@ -116,13 +117,17 @@ static int usb_console_setup(struct console *co, char *options)
                 return -ENODEV;
         }
 
-        port = serial->port[0];
+        retval = usb_autopm_get_interface(serial->interface);
+        if (retval)
+                goto error_get_interface;
+
+        port = serial->port[co->index - serial->minor];
         tty_port_tty_set(&port->port, NULL);
 
         info->port = port;
 
         ++port->port.count;
-        if (port->port.count == 1) {
+        if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
                 if (serial->type->set_termios) {
                         /*
                          * allocate a fake tty so the driver can initialize
@@ -150,9 +155,9 @@ static int usb_console_setup(struct console *co, char *options)
                 /* only call the device specific open if this
                  * is the first time the port is opened */
                 if (serial->type->open)
-                        retval = serial->type->open(NULL, port, NULL);
+                        retval = serial->type->open(NULL, port);
                 else
-                        retval = usb_serial_generic_open(NULL, port, NULL);
+                        retval = usb_serial_generic_open(NULL, port);
 
                 if (retval) {
                         err("could not open USB console port");
@@ -168,6 +173,7 @@ static int usb_console_setup(struct console *co, char *options)
                         kfree(termios);
                         kfree(tty);
                 }
+                set_bit(ASYNCB_INITIALIZED, &port->port.flags);
         }
         /* Now that any required fake tty operations are completed restore
          * the tty port count */
@@ -175,18 +181,22 @@ static int usb_console_setup(struct console *co, char *options)
         /* The console is special in terms of closing the device so
          * indicate this port is now acting as a system console. */
         port->console = 1;
-        retval = 0;
 
-out:
+        mutex_unlock(&serial->disc_mutex);
         return retval;
-free_termios:
+
+ free_termios:
         kfree(termios);
         tty_port_tty_set(&port->port, NULL);
-free_tty:
+ free_tty:
         kfree(tty);
-reset_open_count:
+ reset_open_count:
         port->port.count = 0;
-        goto out;
+        usb_autopm_put_interface(serial->interface);
+ error_get_interface:
+        usb_serial_put(serial);
+        mutex_unlock(&serial->disc_mutex);
+        return retval;
 }
 
 static void usb_console_write(struct console *co,
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index 985cbcf48bda..4a208fe85bc9 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -33,8 +33,7 @@
 /*
  * Function Prototypes
  */
-static int cp210x_open(struct tty_struct *, struct usb_serial_port *,
-                                                        struct file *);
+static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
 static void cp210x_cleanup(struct usb_serial_port *);
 static void cp210x_close(struct usb_serial_port *);
 static void cp210x_get_termios(struct tty_struct *,
@@ -368,8 +367,7 @@ static unsigned int cp210x_quantise_baudrate(unsigned int baud) {
         return baud;
 }
 
-static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         int result;
@@ -399,12 +397,6 @@ static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port,
 
         /* Configure the termios structure */
         cp210x_get_termios(tty, port);
-
-        /* Set the DTR and RTS pins low */
-        cp210x_tiocmset_port(tty ? (struct usb_serial_port *) tty->driver_data
-                        : port,
-                NULL, TIOCM_DTR | TIOCM_RTS, 0);
-
         return 0;
 }
 
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 336523fd7366..b0f6402a91ca 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -61,7 +61,7 @@ static int cyberjack_startup(struct usb_serial *serial);
 static void cyberjack_disconnect(struct usb_serial *serial);
 static void cyberjack_release(struct usb_serial *serial);
 static int  cyberjack_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+        struct usb_serial_port *port);
 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);
@@ -173,7 +173,7 @@ static void cyberjack_release(struct usb_serial *serial)
 }
 
 static int  cyberjack_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+                                        struct usb_serial_port *port)
 {
         struct cyberjack_private *priv;
         unsigned long flags;
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index 59adfe123110..e0a8b715f2f2 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -172,8 +172,7 @@ static int  cypress_earthmate_startup(struct usb_serial *serial);
 static int  cypress_hidcom_startup(struct usb_serial *serial);
 static int  cypress_ca42v2_startup(struct usb_serial *serial);
 static void cypress_release(struct usb_serial *serial);
-static int  cypress_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static int  cypress_open(struct tty_struct *tty, struct usb_serial_port *port);
 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,
@@ -633,8 +632,7 @@ static void cypress_release(struct usb_serial *serial)
 }
 
 
-static int cypress_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
         struct usb_serial *serial = port->serial;
@@ -659,15 +657,7 @@ static int cypress_open(struct tty_struct *tty,
         spin_unlock_irqrestore(&priv->lock, flags);
 
         /* Set termios */
-        result = cypress_write(tty, port, NULL, 0);
-
-        if (result) {
-                dev_err(&port->dev,
-                        "%s - failed setting the control lines - error %d\n",
-                                                        __func__, result);
-                return result;
-        } else
-                dbg("%s - success setting the control lines", __func__);
+        cypress_send(port);
 
         if (tty)
                 cypress_set_termios(tty, port, &priv->tmp_termios);
@@ -1005,6 +995,8 @@ static void cypress_set_termios(struct tty_struct *tty,
         dbg("%s - port %d", __func__, port->number);
 
         spin_lock_irqsave(&priv->lock, flags);
+        /* We can't clean this one up as we don't know the device type
+           early enough */
         if (!priv->termios_initialized) {
                 if (priv->chiptype == CT_EARTHMATE) {
                         *(tty->termios) = tty_std_termios;
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index f4808091c47c..ab3dd991586b 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -453,8 +453,7 @@ static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
 static void digi_write_bulk_callback(struct urb *urb);
 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 int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -1347,8 +1346,7 @@ static int digi_carrier_raised(struct usb_serial_port *port)
         return 0;
 }
 
-static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int ret;
         unsigned char buf[32];
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index 80cb3471adbe..33c9e9cf9eb2 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -79,8 +79,7 @@ static int debug;
 #define EMPEG_PRODUCT_ID                0x0001
 
 /* function prototypes for an empeg-car player */
-static int  empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                                struct file *filp);
+static int  empeg_open(struct tty_struct *tty, struct usb_serial_port *port);
 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,
@@ -90,8 +89,7 @@ static int  empeg_chars_in_buffer(struct tty_struct *tty);
 static void empeg_throttle(struct tty_struct *tty);
 static void empeg_unthrottle(struct tty_struct *tty);
 static int  empeg_startup(struct usb_serial *serial);
-static void empeg_set_termios(struct tty_struct *tty,
-                struct usb_serial_port *port, struct ktermios *old_termios);
+static void empeg_init_termios(struct tty_struct *tty);
 static void empeg_write_bulk_callback(struct urb *urb);
 static void empeg_read_bulk_callback(struct urb *urb);
 
@@ -123,7 +121,7 @@ static struct usb_serial_driver empeg_device = {
         .throttle =             empeg_throttle,
         .unthrottle =           empeg_unthrottle,
         .attach =               empeg_startup,
-        .set_termios =          empeg_set_termios,
+        .init_termios =         empeg_init_termios,
         .write =                empeg_write,
         .write_room =           empeg_write_room,
         .chars_in_buffer =      empeg_chars_in_buffer,
@@ -142,17 +140,13 @@ static int		bytes_out;
 /******************************************************************************
  * Empeg specific driver functions
  ******************************************************************************/
-static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                struct file *filp)
+static int empeg_open(struct tty_struct *tty,struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         int result = 0;
 
         dbg("%s - port %d", __func__, port->number);
 
-        /* Force default termio settings */
-        empeg_set_termios(tty, port, NULL) ;
-
         bytes_in = 0;
         bytes_out = 0;
 
@@ -425,11 +419,9 @@ static int  empeg_startup(struct usb_serial *serial)
 }
 
 
-static void empeg_set_termios(struct tty_struct *tty,
-                struct usb_serial_port *port, struct ktermios *old_termios)
+static void empeg_init_termios(struct tty_struct *tty)
 {
         struct ktermios *termios = tty->termios;
-        dbg("%s - port %d", __func__, port->number);
 
         /*
          * The empeg-car player wants these particular tty settings.
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 8fec5d4455c9..76a17f915eef 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -747,8 +747,7 @@ static int  ftdi_sio_probe(struct usb_serial *serial,
                                         const struct usb_device_id *id);
 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 int  ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
 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,
@@ -1680,8 +1679,7 @@ static int ftdi_sio_port_remove(struct usb_serial_port *port)
         return 0;
 }
 
-static int ftdi_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
 { /* ftdi_open */
         struct usb_device *dev = port->serial->dev;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 8839f1c70b7f..20432d345529 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -933,8 +933,7 @@ static int garmin_init_session(struct usb_serial_port *port)
 
 
 
-static int garmin_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int garmin_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         unsigned long flags;
         int status = 0;
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index ce57f6a32bdf..d9398e9f30ce 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -114,8 +114,7 @@ void usb_serial_generic_deregister(void)
 #endif
 }
 
-int usb_serial_generic_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         int result = 0;
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index 0191693625d6..dc0f832657e6 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -205,8 +205,7 @@ static void edge_bulk_out_data_callback(struct urb *urb);
 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 int edge_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -852,8 +851,7 @@ static void edge_bulk_out_cmd_callback(struct urb *urb)
  *      If successful, we return 0
  *      Otherwise we return a negative error number.
  *****************************************************************************/
-static int edge_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct usb_serial *serial;
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index e8bc42f92e79..d4cc0f7af400 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -1831,8 +1831,7 @@ static void edge_bulk_out_callback(struct urb *urb)
         tty_kref_put(tty);
 }
 
-static int edge_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         struct edgeport_serial *edge_serial;
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index 2545d45ce16f..24fcc64b837d 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -75,7 +75,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);
+                        struct usb_serial_port *port);
 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);
@@ -587,7 +587,7 @@ static int		bytes_in;
 static int              bytes_out;
 
 static int ipaq_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+                        struct usb_serial_port *port)
 {
         struct usb_serial       *serial = port->serial;
         struct ipaq_private     *priv;
@@ -628,11 +628,6 @@ static int ipaq_open(struct tty_struct *tty,
                 priv->free_len += PACKET_SIZE;
         }
 
-        if (tty) {
-                /* FIXME: These two are bogus */
-                tty->raw = 1;
-                tty->real_raw = 1;
-        }
         /*
          * Lose the small buffers usbserial provides. Make larger ones.
          */
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 29ad038b9c8d..727d323f092a 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -193,8 +193,7 @@ static void ipw_read_bulk_callback(struct urb *urb)
         return;
 }
 
-static int ipw_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_device *dev = port->serial->dev;
         u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 66009b6b763a..95d8d26b9a44 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -86,8 +86,7 @@ static int buffer_size;
 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 int  ir_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -296,8 +295,7 @@ static int ir_startup(struct usb_serial *serial)
         return 0;
 }
 
-static int ir_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int ir_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         char *buffer;
         int result = 0;
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index 96873a7a32b0..6138c1cda35f 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -71,7 +71,6 @@ struct iuu_private {
         spinlock_t lock;        /* store irq state */
         wait_queue_head_t delta_msr_wait;
         u8 line_status;
-        u8 termios_initialized;
         int tiostatus;          /* store IUART SIGNAL for tiocmget call */
         u8 reset;               /* if 1 reset is needed */
         int poll;               /* number of poll */
@@ -1018,14 +1017,24 @@ static void iuu_close(struct usb_serial_port *port)
         }
 }
 
-static int iuu_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static void iuu_init_termios(struct tty_struct *tty)
+{
+        *(tty->termios) = tty_std_termios;
+        tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
+                                | TIOCM_CTS | CSTOPB | PARENB;
+        tty->termios->c_ispeed = 9600;
+        tty->termios->c_ospeed = 9600;
+        tty->termios->c_lflag = 0;
+        tty->termios->c_oflag = 0;
+        tty->termios->c_iflag = 0;
+}
+
+static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         u8 *buf;
         int result;
         u32 actual;
-        unsigned long flags;
         struct iuu_private *priv = usb_get_serial_port_data(port);
 
         dbg("%s -  port %d", __func__, port->number);
@@ -1064,21 +1073,7 @@ static int iuu_open(struct tty_struct *tty,
                           port->bulk_in_buffer, 512,
                           NULL, NULL);
 
-        /* set the termios structure */
-        spin_lock_irqsave(&priv->lock, flags);
-        if (tty && !priv->termios_initialized) {
-                *(tty->termios) = tty_std_termios;
-                tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
-                                        | TIOCM_CTS | CSTOPB | PARENB;
-                tty->termios->c_ispeed = 9600;
-                tty->termios->c_ospeed = 9600;
-                tty->termios->c_lflag = 0;
-                tty->termios->c_oflag = 0;
-                tty->termios->c_iflag = 0;
-                priv->termios_initialized = 1;
-                priv->poll = 0;
-         }
-        spin_unlock_irqrestore(&priv->lock, flags);
+        priv->poll = 0;
 
         /* initialize writebuf */
 #define FISH(a, b, c, d) do { \
@@ -1201,6 +1196,7 @@ static struct usb_serial_driver iuu_device = {
         .tiocmget = iuu_tiocmget,
         .tiocmset = iuu_tiocmset,
         .set_termios = iuu_set_termios,
+        .init_termios = iuu_init_termios,
         .attach = iuu_startup,
         .release = iuu_release,
 };
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 2594b8743d3f..f8c4b07033ff 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -1209,8 +1209,7 @@ static int keyspan_write_room(struct tty_struct *tty)
 }
 
 
-static int keyspan_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct keyspan_port_private     *p_priv;
         struct keyspan_serial_private   *s_priv;
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index 3107ed15af64..30771e5b3973 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -36,8 +36,7 @@
 
 /* Function prototypes for Keyspan serial converter */
 static int  keyspan_open                (struct tty_struct *tty,
-                                         struct usb_serial_port *port,
-                                         struct file *filp);
+                                         struct usb_serial_port *port);
 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);
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index d0b12e40c2b1..257c16cc6b2a 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -681,7 +681,7 @@ static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
 
 
 static int keyspan_pda_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+                                        struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         unsigned char room;
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index 0f44bb8e8d4f..a61673133d7d 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -75,8 +75,7 @@ static int debug;
 static int  klsi_105_startup(struct usb_serial *serial);
 static void klsi_105_disconnect(struct usb_serial *serial);
 static void klsi_105_release(struct usb_serial *serial);
-static int  klsi_105_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -358,8 +357,7 @@ static void klsi_105_release(struct usb_serial *serial)
         }
 } /* klsi_105_release */
 
-static int  klsi_105_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
         int retval = 0;
@@ -371,10 +369,6 @@ static int  klsi_105_open(struct tty_struct *tty,
 
         dbg("%s port %d", __func__, port->number);
 
-        /* force low_latency on so that our tty_push actually forces
-         * the data through
-         * tty->low_latency = 1; */
-
         /* Do a defined restart:
          * Set up sane default baud rate and send the 'READ_ON'
          * vendor command.
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index 6db0e561f680..45ea694b3ae6 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -70,8 +70,7 @@ static int debug;
 /* Function prototypes */
 static int  kobil_startup(struct usb_serial *serial);
 static void kobil_release(struct usb_serial *serial);
-static int  kobil_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static int  kobil_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -85,7 +84,7 @@ static void kobil_read_int_callback(struct urb *urb);
 static void kobil_write_callback(struct urb *purb);
 static void kobil_set_termios(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
-
+static void kobil_init_termios(struct tty_struct *tty);
 
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(KOBIL_VENDOR_ID, KOBIL_ADAPTER_B_PRODUCT_ID) },
@@ -120,6 +119,7 @@ static struct usb_serial_driver kobil_device = {
         .release =              kobil_release,
         .ioctl =                kobil_ioctl,
         .set_termios =          kobil_set_termios,
+        .init_termios =         kobil_init_termios,
         .tiocmget =             kobil_tiocmget,
         .tiocmset =             kobil_tiocmset,
         .open =                 kobil_open,
@@ -210,9 +210,17 @@ static void kobil_release(struct usb_serial *serial)
                 kfree(usb_get_serial_port_data(serial->port[i]));
 }
 
+static void kobil_init_termios(struct tty_struct *tty)
+{
+        /* Default to echo off and other sane device settings */
+        tty->termios->c_lflag = 0;
+        tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
+        tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
+        /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
+        tty->termios->c_oflag &= ~ONLCR;
+}
 
-static int kobil_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int result = 0;
         struct kobil_private *priv;
@@ -226,16 +234,6 @@ static int kobil_open(struct tty_struct *tty,
         /* someone sets the dev to 0 if the close method has been called */
         port->interrupt_in_urb->dev = port->serial->dev;
 
-        if (tty) {
-
-                /* Default to echo off and other sane device settings */
-                tty->termios->c_lflag = 0;
-                tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN |
-                                                                 XCASE);
-                tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
-                /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
-                tty->termios->c_oflag &= ~ONLCR;
-        }
         /* allocate memory for transfer buffer */
         transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
         if (!transfer_buffer)
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index d8825e159aa5..ad4998bbf16f 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -93,8 +93,7 @@ static int debug;
  */
 static int  mct_u232_startup(struct usb_serial *serial);
 static void mct_u232_release(struct usb_serial *serial);
-static int  mct_u232_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -421,8 +420,7 @@ static void mct_u232_release(struct usb_serial *serial)
         }
 } /* mct_u232_release */
 
-static int  mct_u232_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
@@ -568,10 +566,13 @@ static void mct_u232_read_int_callback(struct urb *urb)
          * Work-a-round: handle the 'usual' bulk-in pipe here
          */
         if (urb->transfer_buffer_length > 2) {
-                tty = tty_port_tty_get(&port->port);
                 if (urb->actual_length) {
-                        tty_insert_flip_string(tty, data, urb->actual_length);
-                        tty_flip_buffer_push(tty);
+                        tty = tty_port_tty_get(&port->port);
+                        if (tty) {
+                                tty_insert_flip_string(tty, data,
+                                                urb->actual_length);
+                                tty_flip_buffer_push(tty);
+                        }
                         tty_kref_put(tty);
                 }
                 goto exit;
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index ccd4dd340d2c..763e32a44be0 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -85,7 +85,7 @@ static int debug;
 #define MOSCHIP_DEVICE_ID_7720          0x7720
 #define MOSCHIP_DEVICE_ID_7715          0x7715
 
-static struct usb_device_id moschip_port_id_table [] = {
+static struct usb_device_id moschip_port_id_table[] = {
         { USB_DEVICE(USB_VENDOR_ID_MOSCHIP, MOSCHIP_DEVICE_ID_7720) },
         { } /* terminating entry */
 };
@@ -319,8 +319,7 @@ static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
         return status;
 }
 
-static int mos7720_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial;
         struct usb_serial_port *port0;
@@ -378,10 +377,14 @@ static int mos7720_open(struct tty_struct *tty,
          /* Initialize MCS7720 -- Write Init values to corresponding Registers
           *
           * Register Index
+          * 0 : THR/RHR
           * 1 : IER
           * 2 : FCR
           * 3 : LCR
           * 4 : MCR
+          * 5 : LSR
+          * 6 : MSR
+          * 7 : SPR
           *
           * 0x08 : SP1/2 Control Reg
           */
@@ -1250,20 +1253,88 @@ static void mos7720_set_termios(struct tty_struct *tty,
 static int get_lsr_info(struct tty_struct *tty,
                 struct moschip_port *mos7720_port, unsigned int __user *value)
 {
-        int count;
+        struct usb_serial_port *port = tty->driver_data;
         unsigned int result = 0;
+        unsigned char data = 0;
+        int port_number = port->number - port->serial->minor;
+        int count;
 
         count = mos7720_chars_in_buffer(tty);
         if (count == 0) {
-                dbg("%s -- Empty", __func__);
-                result = TIOCSER_TEMT;
+                send_mos_cmd(port->serial, MOS_READ, port_number,
+                                                        UART_LSR, &data);
+                if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
+                                        == (UART_LSR_TEMT | UART_LSR_THRE)) {
+                        dbg("%s -- Empty", __func__);
+                        result = TIOCSER_TEMT;
+                }
         }
-
         if (copy_to_user(value, &result, sizeof(int)))
                 return -EFAULT;
         return 0;
 }
 
+static int mos7720_tiocmget(struct tty_struct *tty, struct file *file)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
+        unsigned int result = 0;
+        unsigned int mcr ;
+        unsigned int msr ;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        mcr = mos7720_port->shadowMCR;
+        msr = mos7720_port->shadowMSR;
+
+        result = ((mcr & UART_MCR_DTR)  ? TIOCM_DTR : 0)   /* 0x002 */
+          | ((mcr & UART_MCR_RTS)   ? TIOCM_RTS : 0)   /* 0x004 */
+          | ((msr & UART_MSR_CTS)   ? TIOCM_CTS : 0)   /* 0x020 */
+          | ((msr & UART_MSR_DCD)   ? TIOCM_CAR : 0)   /* 0x040 */
+          | ((msr & UART_MSR_RI)    ? TIOCM_RI :  0)   /* 0x080 */
+          | ((msr & UART_MSR_DSR)   ? TIOCM_DSR : 0);  /* 0x100 */
+
+        dbg("%s -- %x", __func__, result);
+
+        return result;
+}
+
+static int mos7720_tiocmset(struct tty_struct *tty, struct file *file,
+                                        unsigned int set, unsigned int clear)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
+        unsigned int mcr ;
+        unsigned char lmcr;
+
+        dbg("%s - port %d", __func__, port->number);
+        dbg("he was at tiocmget");
+
+        mcr = mos7720_port->shadowMCR;
+
+        if (set & TIOCM_RTS)
+                mcr |= UART_MCR_RTS;
+        if (set & TIOCM_DTR)
+                mcr |= UART_MCR_DTR;
+        if (set & TIOCM_LOOP)
+                mcr |= UART_MCR_LOOP;
+
+        if (clear & TIOCM_RTS)
+                mcr &= ~UART_MCR_RTS;
+        if (clear & TIOCM_DTR)
+                mcr &= ~UART_MCR_DTR;
+        if (clear & TIOCM_LOOP)
+                mcr &= ~UART_MCR_LOOP;
+
+        mos7720_port->shadowMCR = mcr;
+        lmcr = mos7720_port->shadowMCR;
+
+        send_mos_cmd(port->serial, MOS_WRITE,
+                port->number - port->serial->minor, UART_MCR, &lmcr);
+
+        return 0;
+}
+
 static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
                           unsigned int __user *value)
 {
@@ -1301,14 +1372,6 @@ static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
                         mcr &= ~UART_MCR_LOOP;
                 break;
 
-        case TIOCMSET:
-                /* turn off the RTS and DTR and LOOPBACK
-                 * and then only turn on what was asked to */
-                mcr &=  ~(UART_MCR_RTS | UART_MCR_DTR | UART_MCR_LOOP);
-                mcr |= ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0);
-                mcr |= ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0);
-                mcr |= ((arg & TIOCM_LOOP) ? UART_MCR_LOOP : 0);
-                break;
         }
 
         mos7720_port->shadowMCR = mcr;
@@ -1320,28 +1383,6 @@ static int set_modem_info(struct moschip_port *mos7720_port, unsigned int cmd,
         return 0;
 }
 
-static int get_modem_info(struct moschip_port *mos7720_port,
-                          unsigned int __user *value)
-{
-        unsigned int result = 0;
-        unsigned int msr = mos7720_port->shadowMSR;
-        unsigned int mcr = mos7720_port->shadowMCR;
-
-        result = ((mcr & UART_MCR_DTR)  ? TIOCM_DTR: 0)   /* 0x002 */
-                  | ((mcr & UART_MCR_RTS)       ? TIOCM_RTS: 0)   /* 0x004 */
-                  | ((msr & UART_MSR_CTS)       ? TIOCM_CTS: 0)   /* 0x020 */
-                  | ((msr & UART_MSR_DCD)       ? TIOCM_CAR: 0)   /* 0x040 */
-                  | ((msr & UART_MSR_RI)        ? TIOCM_RI:  0)   /* 0x080 */
-                  | ((msr & UART_MSR_DSR)       ? TIOCM_DSR: 0);  /* 0x100 */
-
-
-        dbg("%s -- %x", __func__, result);
-
-        if (copy_to_user(value, &result, sizeof(int)))
-                return -EFAULT;
-        return 0;
-}
-
 static int get_serial_info(struct moschip_port *mos7720_port,
                            struct serial_struct __user *retinfo)
 {
@@ -1392,17 +1433,11 @@ static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
         /* FIXME: These should be using the mode methods */
         case TIOCMBIS:
         case TIOCMBIC:
-        case TIOCMSET:
                 dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET",
                                         __func__, port->number);
                 return set_modem_info(mos7720_port, cmd,
                                       (unsigned int __user *)arg);
 
-        case TIOCMGET:
-                dbg("%s (%d) TIOCMGET", __func__,  port->number);
-                return get_modem_info(mos7720_port,
-                                      (unsigned int __user *)arg);
-
         case TIOCGSERIAL:
                 dbg("%s (%d) TIOCGSERIAL", __func__,  port->number);
                 return get_serial_info(mos7720_port,
@@ -1557,6 +1592,8 @@ static struct usb_serial_driver moschip7720_2port_driver = {
         .attach                 = mos7720_startup,
         .release                = mos7720_release,
         .ioctl                  = mos7720_ioctl,
+        .tiocmget               = mos7720_tiocmget,
+        .tiocmset               = mos7720_tiocmset,
         .set_termios            = mos7720_set_termios,
         .write                  = mos7720_write,
         .write_room             = mos7720_write_room,
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 270009afdf77..f11abf52be7d 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -824,8 +824,7 @@ static int mos7840_serial_probe(struct usb_serial *serial,
  *      Otherwise we return a negative error number.
  *****************************************************************************/
 
-static int mos7840_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int response;
         int j;
@@ -2134,106 +2133,6 @@ static int mos7840_get_lsr_info(struct tty_struct *tty,
 }
 
 /*****************************************************************************
- * mos7840_set_modem_info
- *      function to set modem info
- *****************************************************************************/
-
-/* FIXME: Should be using the model control hooks */
-
-static int mos7840_set_modem_info(struct moschip_port *mos7840_port,
-                                  unsigned int cmd, unsigned int __user *value)
-{
-        unsigned int mcr;
-        unsigned int arg;
-        __u16 Data;
-        int status;
-        struct usb_serial_port *port;
-
-        if (mos7840_port == NULL)
-                return -1;
-
-        port = (struct usb_serial_port *)mos7840_port->port;
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
-                return -1;
-        }
-
-        mcr = mos7840_port->shadowMCR;
-
-        if (copy_from_user(&arg, value, sizeof(int)))
-                return -EFAULT;
-
-        switch (cmd) {
-        case TIOCMBIS:
-                if (arg & TIOCM_RTS)
-                        mcr |= MCR_RTS;
-                if (arg & TIOCM_DTR)
-                        mcr |= MCR_RTS;
-                if (arg & TIOCM_LOOP)
-                        mcr |= MCR_LOOPBACK;
-                break;
-
-        case TIOCMBIC:
-                if (arg & TIOCM_RTS)
-                        mcr &= ~MCR_RTS;
-                if (arg & TIOCM_DTR)
-                        mcr &= ~MCR_RTS;
-                if (arg & TIOCM_LOOP)
-                        mcr &= ~MCR_LOOPBACK;
-                break;
-
-        case TIOCMSET:
-                /* turn off the RTS and DTR and LOOPBACK
-                 * and then only turn on what was asked to */
-                mcr &= ~(MCR_RTS | MCR_DTR | MCR_LOOPBACK);
-                mcr |= ((arg & TIOCM_RTS) ? MCR_RTS : 0);
-                mcr |= ((arg & TIOCM_DTR) ? MCR_DTR : 0);
-                mcr |= ((arg & TIOCM_LOOP) ? MCR_LOOPBACK : 0);
-                break;
-        }
-
-        lock_kernel();
-        mos7840_port->shadowMCR = mcr;
-
-        Data = mos7840_port->shadowMCR;
-        status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, Data);
-        unlock_kernel();
-        if (status < 0) {
-                dbg("setting MODEM_CONTROL_REGISTER Failed");
-                return -1;
-        }
-
-        return 0;
-}
-
-/*****************************************************************************
- * mos7840_get_modem_info
- *      function to get modem info
- *****************************************************************************/
-
-static int mos7840_get_modem_info(struct moschip_port *mos7840_port,
-                                  unsigned int __user *value)
-{
-        unsigned int result = 0;
-        __u16 msr;
-        unsigned int mcr = mos7840_port->shadowMCR;
-        mos7840_get_uart_reg(mos7840_port->port,
-                                                MODEM_STATUS_REGISTER, &msr);
-        result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0)      /* 0x002 */
-            |((mcr & MCR_RTS) ? TIOCM_RTS : 0)  /* 0x004 */
-            |((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0)  /* 0x020 */
-            |((msr & MOS7840_MSR_CD) ? TIOCM_CAR : 0)   /* 0x040 */
-            |((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)    /* 0x080 */
-            |((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0); /* 0x100 */
-
-        dbg("%s -- %x", __func__, result);
-
-        if (copy_to_user(value, &result, sizeof(int)))
-                return -EFAULT;
-        return 0;
-}
-
-/*****************************************************************************
  * mos7840_get_serial_info
  *      function to get information about serial port
  *****************************************************************************/
@@ -2281,7 +2180,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
         struct async_icount cnow;
         struct async_icount cprev;
         struct serial_icounter_struct icount;
-        int mosret = 0;
 
         if (mos7840_port_paranoia_check(port, __func__)) {
                 dbg("%s", "Invalid port");
@@ -2303,20 +2201,6 @@ static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
                 return mos7840_get_lsr_info(tty, argp);
                 return 0;
 
-        /* FIXME: use the modem hooks and remove this */
-        case TIOCMBIS:
-        case TIOCMBIC:
-        case TIOCMSET:
-                dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET", __func__,
-                    port->number);
-                mosret =
-                    mos7840_set_modem_info(mos7840_port, cmd, argp);
-                return mosret;
-
-        case TIOCMGET:
-                dbg("%s (%d) TIOCMGET", __func__, port->number);
-                return mos7840_get_modem_info(mos7840_port, argp);
-
         case TIOCGSERIAL:
                 dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
                 return mos7840_get_serial_info(mos7840_port, argp);
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index f5f3751a888c..5ceaa4c6be09 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -80,8 +80,7 @@ exit:
                         __func__, result);
 }
 
-static int navman_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int navman_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int result = 0;
 
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 56857ddbd70b..062265038bf0 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -64,8 +64,7 @@ static int debug;
 #define BT_IGNITIONPRO_ID       0x2000
 
 /* function prototypes */
-static int  omninet_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *filp);
+static int  omninet_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -163,8 +162,7 @@ static int omninet_attach(struct usb_serial *serial)
         return 0;
 }
 
-static int omninet_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int omninet_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial       *serial = port->serial;
         struct usb_serial_port  *wport;
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index 336bba79ad32..1085a577c5c1 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -144,8 +144,7 @@ exit:
         spin_unlock(&priv->lock);
 }
 
-static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port,
-                        struct file *filp)
+static int opticon_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct opticon_private *priv = usb_get_serial_data(port->serial);
         unsigned long flags;
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index c784ddbe7b61..fe47051dbef2 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -45,8 +45,7 @@
 /* Function prototypes */
 static int  option_probe(struct usb_serial *serial,
                         const struct usb_device_id *id);
-static int  option_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *filp);
+static int  option_open(struct tty_struct *tty, struct usb_serial_port *port);
 static void option_close(struct usb_serial_port *port);
 static void option_dtr_rts(struct usb_serial_port *port, int on);
 
@@ -961,8 +960,7 @@ static int option_chars_in_buffer(struct tty_struct *tty)
         return data_len;
 }
 
-static int option_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int option_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct option_port_private *portdata;
         int i, err;
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index 3cece27325e7..0f4a70ce3823 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -141,11 +141,11 @@ struct oti6858_control_pkt {
           && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
 
 /* function prototypes */
-static int oti6858_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port);
 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 void oti6858_init_termios(struct tty_struct *tty);
 static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg);
 static void oti6858_read_int_callback(struct urb *urb);
@@ -186,6 +186,7 @@ static struct usb_serial_driver oti6858_device = {
         .write =                oti6858_write,
         .ioctl =                oti6858_ioctl,
         .set_termios =          oti6858_set_termios,
+        .init_termios =         oti6858_init_termios,
         .tiocmget =             oti6858_tiocmget,
         .tiocmset =             oti6858_tiocmset,
         .read_bulk_callback =   oti6858_read_bulk_callback,
@@ -206,7 +207,6 @@ struct oti6858_private {
         struct {
                 u8 read_urb_in_use;
                 u8 write_urb_in_use;
-                u8 termios_initialized;
         } flags;
         struct delayed_work delayed_write_work;
 
@@ -447,6 +447,14 @@ static int oti6858_chars_in_buffer(struct tty_struct *tty)
         return chars;
 }
 
+static void oti6858_init_termios(struct tty_struct *tty)
+{
+        *(tty->termios) = tty_std_termios;
+        tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
+        tty->termios->c_ispeed = 38400;
+        tty->termios->c_ospeed = 38400;
+}
+
 static void oti6858_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
@@ -464,16 +472,6 @@ static void oti6858_set_termios(struct tty_struct *tty,
                 return;
         }
 
-        spin_lock_irqsave(&priv->lock, flags);
-        if (!priv->flags.termios_initialized) {
-                *(tty->termios) = tty_std_termios;
-                tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
-                tty->termios->c_ispeed = 38400;
-                tty->termios->c_ospeed = 38400;
-                priv->flags.termios_initialized = 1;
-        }
-        spin_unlock_irqrestore(&priv->lock, flags);
-
         cflag = tty->termios->c_cflag;
 
         spin_lock_irqsave(&priv->lock, flags);
@@ -566,8 +564,7 @@ static void oti6858_set_termios(struct tty_struct *tty,
         spin_unlock_irqrestore(&priv->lock, flags);
 }
 
-static int oti6858_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct oti6858_private *priv = usb_get_serial_port_data(port);
         struct ktermios tmp_termios;
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 3e86815b2705..a63ea99936f7 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -691,8 +691,7 @@ static void pl2303_close(struct usb_serial_port *port)
 
 }
 
-static int pl2303_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct ktermios tmp_termios;
         struct usb_serial *serial = port->serial;
@@ -714,8 +713,6 @@ static int pl2303_open(struct tty_struct *tty,
         if (tty)
                 pl2303_set_termios(tty, port, &tmp_termios);
 
-        /* FIXME: need to assert RTS and DTR if CRTSCTS off */
-
         dbg("%s - submitting read urb", __func__);
         port->read_urb->dev = serial->dev;
         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index f48d05e0acc1..55391bbe1230 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -734,8 +734,7 @@ static void sierra_close(struct usb_serial_port *port)
         }
 }
 
-static int sierra_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int sierra_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct sierra_port_private *portdata;
         struct usb_serial *serial = port->serial;
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index 3c249d8e8b8e..61e7c40b94fb 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -299,7 +299,6 @@ struct spcp8x5_private {
         wait_queue_head_t       delta_msr_wait;
         u8                      line_control;
         u8                      line_status;
-        u8                      termios_initialized;
 };
 
 /* desc : when device plug in,this function would be called.
@@ -498,6 +497,15 @@ static void spcp8x5_close(struct usb_serial_port *port)
                 dev_dbg(&port->dev, "usb_unlink_urb(read_urb) = %d\n", result);
 }
 
+static void spcp8x5_init_termios(struct tty_struct *tty)
+{
+        /* for the 1st time call this function */
+        *(tty->termios) = tty_std_termios;
+        tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
+        tty->termios->c_ispeed = 115200;
+        tty->termios->c_ospeed = 115200;
+}
+
 /* set the serial param for transfer. we should check if we really need to
  * transfer. if we set flow control we should do this too. */
 static void spcp8x5_set_termios(struct tty_struct *tty,
@@ -514,16 +522,6 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
         int i;
         u8 control;
 
-        /* for the 1st time call this function */
-        spin_lock_irqsave(&priv->lock, flags);
-        if (!priv->termios_initialized) {
-                *(tty->termios) = tty_std_termios;
-                tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
-                tty->termios->c_ispeed = 115200;
-                tty->termios->c_ospeed = 115200;
-                priv->termios_initialized = 1;
-        }
-        spin_unlock_irqrestore(&priv->lock, flags);
 
         /* check that they really want us to change something */
         if (!tty_termios_hw_change(tty->termios, old_termios))
@@ -623,8 +621,7 @@ static void spcp8x5_set_termios(struct tty_struct *tty,
 
 /* open the serial port. do some usb system call. set termios and get the line
  * status of the device. then submit the read urb */
-static int spcp8x5_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int spcp8x5_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct ktermios tmp_termios;
         struct usb_serial *serial = port->serial;
@@ -658,8 +655,6 @@ static int spcp8x5_open(struct tty_struct *tty,
         priv->line_status = status & 0xf0 ;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* FIXME: need to assert RTS and DTR if CRTSCTS off */
-
         dbg("%s - submitting read urb", __func__);
         port->read_urb->dev = serial->dev;
         ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
@@ -1011,6 +1006,7 @@ static struct usb_serial_driver spcp8x5_device = {
         .carrier_raised         = spcp8x5_carrier_raised,
         .write                  = spcp8x5_write,
         .set_termios            = spcp8x5_set_termios,
+        .init_termios           = spcp8x5_init_termios,
         .ioctl                  = spcp8x5_ioctl,
         .tiocmget               = spcp8x5_tiocmget,
         .tiocmset               = spcp8x5_tiocmset,
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
index 6157fac9366b..cb7e95f9fcbf 100644
--- a/drivers/usb/serial/symbolserial.c
+++ b/drivers/usb/serial/symbolserial.c
@@ -124,8 +124,7 @@ exit:
         spin_unlock(&priv->lock);
 }
 
-static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port,
-                        struct file *filp)
+static int symbol_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct symbol_private *priv = usb_get_serial_data(port->serial);
         unsigned long flags;
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 3bc609fe2242..1e9dc8821698 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -98,8 +98,7 @@ struct ti_device {
 
 static int ti_startup(struct usb_serial *serial);
 static void ti_release(struct usb_serial *serial);
-static int ti_open(struct tty_struct *tty, struct usb_serial_port *port,
-                struct file *file);
+static int ti_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -492,8 +491,7 @@ static void ti_release(struct usb_serial *serial)
 }
 
 
-static int ti_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *file)
+static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct ti_port *tport = usb_get_serial_port_data(port);
         struct ti_device *tdev;
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 99188c92068b..9d7ca4868d37 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -43,8 +43,6 @@
 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
 #define DRIVER_DESC "USB Serial Driver core"
 
-static void port_free(struct usb_serial_port *port);
-
 /* Driver structure we register with the USB core */
 static struct usb_driver usb_serial_driver = {
         .name =         "usbserial",
@@ -68,6 +66,11 @@ static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
 static DEFINE_MUTEX(table_lock);
 static LIST_HEAD(usb_serial_driver_list);
 
+/*
+ * Look up the serial structure.  If it is found and it hasn't been
+ * disconnected, return with its disc_mutex held and its refcount
+ * incremented.  Otherwise return NULL.
+ */
 struct usb_serial *usb_serial_get_by_index(unsigned index)
 {
         struct usb_serial *serial;
@@ -75,8 +78,15 @@ struct usb_serial *usb_serial_get_by_index(unsigned index)
         mutex_lock(&table_lock);
         serial = serial_table[index];
 
-        if (serial)
-                kref_get(&serial->kref);
+        if (serial) {
+                mutex_lock(&serial->disc_mutex);
+                if (serial->disconnected) {
+                        mutex_unlock(&serial->disc_mutex);
+                        serial = NULL;
+                } else {
+                        kref_get(&serial->kref);
+                }
+        }
         mutex_unlock(&table_lock);
         return serial;
 }
@@ -125,8 +135,10 @@ static void return_serial(struct usb_serial *serial)
 
         dbg("%s", __func__);
 
+        mutex_lock(&table_lock);
         for (i = 0; i < serial->num_ports; ++i)
                 serial_table[serial->minor + i] = NULL;
+        mutex_unlock(&table_lock);
 }
 
 static void destroy_serial(struct kref *kref)
@@ -145,161 +157,157 @@ static void destroy_serial(struct kref *kref)
 
         serial->type->release(serial);
 
-        for (i = 0; i < serial->num_ports; ++i) {
+        /* Now that nothing is using the ports, they can be freed */
+        for (i = 0; i < serial->num_port_pointers; ++i) {
                 port = serial->port[i];
-                if (port)
+                if (port) {
+                        port->serial = NULL;
                         put_device(&port->dev);
-        }
-
-        /* If this is a "fake" port, we have to clean it up here, as it will
-         * not get cleaned up in port_release() as it was never registered with
-         * the driver core */
-        if (serial->num_ports < serial->num_port_pointers) {
-                for (i = serial->num_ports;
-                                        i < serial->num_port_pointers; ++i) {
-                        port = serial->port[i];
-                        if (port)
-                                port_free(port);
                 }
         }
 
         usb_put_dev(serial->dev);
-
-        /* free up any memory that we allocated */
         kfree(serial);
 }
 
 void usb_serial_put(struct usb_serial *serial)
 {
-        mutex_lock(&table_lock);
         kref_put(&serial->kref, destroy_serial);
-        mutex_unlock(&table_lock);
 }
 
 /*****************************************************************************
  * Driver tty interface functions
  *****************************************************************************/
-static int serial_open (struct tty_struct *tty, struct file *filp)
+
+/**
+ * serial_install - install tty
+ * @driver: the driver (USB in our case)
+ * @tty: the tty being created
+ *
+ * Create the termios objects for this tty.  We use the default
+ * USB serial settings but permit them to be overridden by
+ * serial->type->init_termios.
+ *
+ * This is the first place a new tty gets used.  Hence this is where we
+ * acquire references to the usb_serial structure and the driver module,
+ * where we store a pointer to the port, and where we do an autoresume.
+ * All these actions are reversed in serial_release().
+ */
+static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 {
+        int idx = tty->index;
         struct usb_serial *serial;
         struct usb_serial_port *port;
-        unsigned int portNumber;
-        int retval = 0;
-        int first = 0;
+        int retval = -ENODEV;
 
         dbg("%s", __func__);
 
-        /* get the serial object associated with this tty pointer */
-        serial = usb_serial_get_by_index(tty->index);
-        if (!serial) {
-                tty->driver_data = NULL;
-                return -ENODEV;
-        }
+        serial = usb_serial_get_by_index(idx);
+        if (!serial)
+                return retval;
 
-        mutex_lock(&serial->disc_mutex);
-        portNumber = tty->index - serial->minor;
-        port = serial->port[portNumber];
-        if (!port || serial->disconnected)
-                retval = -ENODEV;
-        else
-                get_device(&port->dev);
-        /*
-         * Note: Our locking order requirement does not allow port->mutex
-         * to be acquired while serial->disc_mutex is held.
-         */
-        mutex_unlock(&serial->disc_mutex);
+        port = serial->port[idx - serial->minor];
+        if (!port)
+                goto error_no_port;
+        if (!try_module_get(serial->type->driver.owner))
+                goto error_module_get;
+
+        /* perform the standard setup */
+        retval = tty_init_termios(tty);
         if (retval)
-                goto bailout_serial_put;
+                goto error_init_termios;
 
-        if (mutex_lock_interruptible(&port->mutex)) {
-                retval = -ERESTARTSYS;
-                goto bailout_port_put;
-        }
+        retval = usb_autopm_get_interface(serial->interface);
+        if (retval)
+                goto error_get_interface;
+
+        mutex_unlock(&serial->disc_mutex);
 
-        ++port->port.count;
+        /* allow the driver to update the settings */
+        if (serial->type->init_termios)
+                serial->type->init_termios(tty);
 
-        /* set up our port structure making the tty driver
-         * remember our port object, and us it */
         tty->driver_data = port;
-        tty_port_tty_set(&port->port, tty);
 
-        /* If the console is attached, the device is already open */
-        if (port->port.count == 1 && !port->console) {
-                first = 1;
-                /* lock this module before we call it
-                 * this may fail, which means we must bail out,
-                 * safe because we are called with BKL held */
-                if (!try_module_get(serial->type->driver.owner)) {
-                        retval = -ENODEV;
-                        goto bailout_mutex_unlock;
-                }
+        /* Final install (we use the default method) */
+        tty_driver_kref_get(driver);
+        tty->count++;
+        driver->ttys[idx] = tty;
+        return retval;
 
+ error_get_interface:
+ error_init_termios:
+        module_put(serial->type->driver.owner);
+ error_module_get:
+ error_no_port:
+        usb_serial_put(serial);
+        mutex_unlock(&serial->disc_mutex);
+        return retval;
+}
+
+static int serial_open(struct tty_struct *tty, struct file *filp)
+{
+        struct usb_serial_port *port = tty->driver_data;
+        struct usb_serial *serial = port->serial;
+        int retval;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        spin_lock_irq(&port->port.lock);
+        if (!tty_hung_up_p(filp))
+                ++port->port.count;
+        spin_unlock_irq(&port->port.lock);
+        tty_port_tty_set(&port->port, tty);
+
+        /* Do the device-specific open only if the hardware isn't
+         * already initialized.
+         */
+        if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
+                if (mutex_lock_interruptible(&port->mutex))
+                        return -ERESTARTSYS;
                 mutex_lock(&serial->disc_mutex);
                 if (serial->disconnected)
                         retval = -ENODEV;
                 else
-                        retval = usb_autopm_get_interface(serial->interface);
-                if (retval)
-                        goto bailout_module_put;
-
-                /* only call the device specific open if this
-                 * is the first time the port is opened */
-                retval = serial->type->open(tty, port, filp);
-                if (retval)
-                        goto bailout_interface_put;
+                        retval = port->serial->type->open(tty, port);
                 mutex_unlock(&serial->disc_mutex);
+                mutex_unlock(&port->mutex);
+                if (retval)
+                        return retval;
                 set_bit(ASYNCB_INITIALIZED, &port->port.flags);
         }
-        mutex_unlock(&port->mutex);
+
         /* Now do the correct tty layer semantics */
         retval = tty_port_block_til_ready(&port->port, tty, filp);
-        if (retval == 0) {
-                if (!first)
-                        usb_serial_put(serial);
-                return 0;
-        }
-        mutex_lock(&port->mutex);
-        if (first == 0)
-                goto bailout_mutex_unlock;
-        /* Undo the initial port actions */
-        mutex_lock(&serial->disc_mutex);
-bailout_interface_put:
-        usb_autopm_put_interface(serial->interface);
-bailout_module_put:
-        mutex_unlock(&serial->disc_mutex);
-        module_put(serial->type->driver.owner);
-bailout_mutex_unlock:
-        port->port.count = 0;
-        tty->driver_data = NULL;
-        tty_port_tty_set(&port->port, NULL);
-        mutex_unlock(&port->mutex);
-bailout_port_put:
-        put_device(&port->dev);
-bailout_serial_put:
-        usb_serial_put(serial);
         return retval;
 }
 
 /**
- *      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.
+ * serial_down - shut down hardware
+ * @port: port to shut down
  *
- *      Don't free any resources at this point
+ * Shut down a USB serial port unless it is the console.  We never
+ * shut down the console hardware as it will always be in use.
  */
-static void serial_do_down(struct usb_serial_port *port)
+static void serial_down(struct usb_serial_port *port)
 {
         struct usb_serial_driver *drv = port->serial->type;
         struct usb_serial *serial;
         struct module *owner;
 
-        /* The console is magical, do not hang up the console hardware
-           or there will be tears */
+        /*
+         * The console is magical.  Do not hang up the console hardware
+         * or there will be tears.
+         */
         if (port->console)
                 return;
 
+        /* Don't call the close method if the hardware hasn't been
+         * initialized.
+         */
+        if (!test_and_clear_bit(ASYNCB_INITIALIZED, &port->port.flags))
+                return;
+
         mutex_lock(&port->mutex);
         serial = port->serial;
         owner = serial->type->driver.owner;
@@ -310,79 +318,69 @@ static void serial_do_down(struct usb_serial_port *port)
         mutex_unlock(&port->mutex);
 }
 
-/**
- *      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)
+static void serial_hangup(struct tty_struct *tty)
 {
-        struct usb_serial *serial;
-        struct module *owner;
+        struct usb_serial_port *port = tty->driver_data;
 
-        /* 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);
 
-        serial = port->serial;
-        owner = serial->type->driver.owner;
-        put_device(&port->dev);
-        /* Mustn't dereference port any more */
-        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 */
-        module_put(owner);
+        serial_down(port);
+        tty_port_hangup(&port->port);
 }
 
 static void serial_close(struct tty_struct *tty, struct file *filp)
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        if (!port)
-                return;
-
         dbg("%s - port %d", __func__, port->number);
 
-        /* FIXME:
-           This leaves a very narrow race. Really we should do the
-           serial_do_free() on tty->shutdown(), but tty->shutdown can
-           be called from IRQ context and serial_do_free can sleep.
-
-           The right fix is probably to make the tty free (which is rare)
-           and thus tty->shutdown() occur via a work queue and simplify all
-           the drivers that use it.
-        */
-        if (tty_hung_up_p(filp)) {
-                /* serial_hangup already called serial_down at this point.
-                   Another user may have already reopened the port but
-                   serial_do_free is refcounted */
-                serial_do_free(port);
+        if (tty_hung_up_p(filp))
                 return;
-        }
-
         if (tty_port_close_start(&port->port, tty, filp) == 0)
                 return;
-
-        serial_do_down(port);           
+        serial_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)
+/**
+ * serial_release - free resources post close/hangup
+ * @port: port to free up
+ *
+ * Do the resource freeing and refcount dropping for the port.
+ * Avoid freeing the console.
+ *
+ * Called when the last tty kref is dropped.
+ */
+static void serial_release(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        serial_do_down(port);
-        tty_port_hangup(&port->port);
-        /* We must not free port yet - the USB serial layer depends on it's
-           continued existence */
+        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;
+
+        dbg("%s - port %d", __func__, port->number);
+
+        /* Standard shutdown processing */
+        tty_shutdown(tty);
+
+        tty->driver_data = NULL;
+
+        serial = port->serial;
+        owner = serial->type->driver.owner;
+
+        mutex_lock(&serial->disc_mutex);
+        if (!serial->disconnected)
+                usb_autopm_put_interface(serial->interface);
+        mutex_unlock(&serial->disc_mutex);
+
+        usb_serial_put(serial);
+        module_put(owner);
 }
 
 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
@@ -527,6 +525,7 @@ static int serial_proc_show(struct seq_file *m, void *v)
 
                 seq_putc(m, '\n');
                 usb_serial_put(serial);
+                mutex_unlock(&serial->disc_mutex);
         }
         return 0;
 }
@@ -596,14 +595,6 @@ static void usb_serial_port_work(struct work_struct *work)
         tty_kref_put(tty);
 }
 
-static void port_release(struct device *dev)
-{
-        struct usb_serial_port *port = to_usb_serial_port(dev);
-
-        dbg ("%s - %s", __func__, dev_name(dev));
-        port_free(port);
-}
-
 static void kill_traffic(struct usb_serial_port *port)
 {
         usb_kill_urb(port->read_urb);
@@ -623,8 +614,12 @@ static void kill_traffic(struct usb_serial_port *port)
         usb_kill_urb(port->interrupt_out_urb);
 }
 
-static void port_free(struct usb_serial_port *port)
+static void port_release(struct device *dev)
 {
+        struct usb_serial_port *port = to_usb_serial_port(dev);
+
+        dbg ("%s - %s", __func__, dev_name(dev));
+
         /*
          * Stop all the traffic before cancelling the work, so that
          * nobody will restart it by calling usb_serial_port_softint.
@@ -935,6 +930,11 @@ int usb_serial_probe(struct usb_interface *interface,
                 mutex_init(&port->mutex);
                 INIT_WORK(&port->work, usb_serial_port_work);
                 serial->port[i] = port;
+                port->dev.parent = &interface->dev;
+                port->dev.driver = NULL;
+                port->dev.bus = &usb_serial_bus_type;
+                port->dev.release = &port_release;
+                device_initialize(&port->dev);
         }
 
         /* set up the endpoint information */
@@ -1077,15 +1077,10 @@ int usb_serial_probe(struct usb_interface *interface,
         /* register all of the individual ports with the driver core */
         for (i = 0; i < num_ports; ++i) {
                 port = serial->port[i];
-                port->dev.parent = &interface->dev;
-                port->dev.driver = NULL;
-                port->dev.bus = &usb_serial_bus_type;
-                port->dev.release = &port_release;
-
                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
                 port->dev_state = PORT_REGISTERING;
-                retval = device_register(&port->dev);
+                retval = device_add(&port->dev);
                 if (retval) {
                         dev_err(&port->dev, "Error registering port device, "
                                 "continuing\n");
@@ -1103,39 +1098,7 @@ exit:
         return 0;
 
 probe_error:
-        for (i = 0; i < num_bulk_in; ++i) {
-                port = serial->port[i];
-                if (!port)
-                        continue;
-                usb_free_urb(port->read_urb);
-                kfree(port->bulk_in_buffer);
-        }
-        for (i = 0; i < num_bulk_out; ++i) {
-                port = serial->port[i];
-                if (!port)
-                        continue;
-                usb_free_urb(port->write_urb);
-                kfree(port->bulk_out_buffer);
-        }
-        for (i = 0; i < num_interrupt_in; ++i) {
-                port = serial->port[i];
-                if (!port)
-                        continue;
-                usb_free_urb(port->interrupt_in_urb);
-                kfree(port->interrupt_in_buffer);
-        }
-        for (i = 0; i < num_interrupt_out; ++i) {
-                port = serial->port[i];
-                if (!port)
-                        continue;
-                usb_free_urb(port->interrupt_out_urb);
-                kfree(port->interrupt_out_buffer);
-        }
-
-        /* free up any memory that we allocated */
-        for (i = 0; i < serial->num_port_pointers; ++i)
-                kfree(serial->port[i]);
-        kfree(serial);
+        usb_serial_put(serial);
         return -EIO;
 }
 EXPORT_SYMBOL_GPL(usb_serial_probe);
@@ -1161,10 +1124,7 @@ 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_vhangup(tty);
                                 tty_kref_put(tty);
                         }
                         kill_traffic(port);
@@ -1189,8 +1149,7 @@ void usb_serial_disconnect(struct usb_interface *interface)
         }
         serial->type->disconnect(serial);
 
-        /* let the last holder of this object
-         * cause it to be cleaned up */
+        /* let the last holder of this object cause it to be cleaned up */
         usb_serial_put(serial);
         dev_info(dev, "device disconnected\n");
 }
@@ -1246,6 +1205,8 @@ static const struct tty_operations serial_ops = {
         .chars_in_buffer =      serial_chars_in_buffer,
         .tiocmget =             serial_tiocmget,
         .tiocmset =             serial_tiocmset,
+        .shutdown =             serial_release,
+        .install =              serial_install,
         .proc_fops =            &serial_proc_fops,
 };
 
diff --git a/drivers/usb/serial/usb_debug.c b/drivers/usb/serial/usb_debug.c
index 614800972dc3..7b5bfc4edd3d 100644
--- a/drivers/usb/serial/usb_debug.c
+++ b/drivers/usb/serial/usb_debug.c
@@ -43,11 +43,10 @@ static struct usb_driver debug_driver = {
         .no_dynamic_id =        1,
 };
 
-static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *filp)
+static int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE;
-        return usb_serial_generic_open(tty, port, filp);
+        return usb_serial_generic_open(tty, port);
 }
 
 /* This HW really does not support a serial break, so one will be
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index f5d0f64dcc52..1aa5d20a5d99 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -36,8 +36,7 @@
 #define DRIVER_DESC "USB HandSpring Visor / Palm OS driver"
 
 /* function prototypes for a handspring visor */
-static int  visor_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                        struct file *filp);
+static int  visor_open(struct tty_struct *tty, struct usb_serial_port *port);
 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);
@@ -273,8 +272,7 @@ static int stats;
 /******************************************************************************
  * Handspring Visor specific driver functions
  ******************************************************************************/
-static int visor_open(struct tty_struct *tty, struct usb_serial_port *port,
-                                                        struct file *filp)
+static int visor_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
         struct visor_private *priv = usb_get_serial_port_data(port);
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index 8d126dd7a02e..62424eec33ec 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -146,7 +146,7 @@ static int  whiteheat_firmware_attach(struct usb_serial *serial);
 static int  whiteheat_attach(struct usb_serial *serial);
 static void whiteheat_release(struct usb_serial *serial);
 static int  whiteheat_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp);
+                        struct usb_serial_port *port);
 static void whiteheat_close(struct usb_serial_port *port);
 static int  whiteheat_write(struct tty_struct *tty,
                         struct usb_serial_port *port,
@@ -259,7 +259,7 @@ static int firm_send_command(struct usb_serial_port *port, __u8 command,
                                                 __u8 *data, __u8 datasize);
 static int firm_open(struct usb_serial_port *port);
 static int firm_close(struct usb_serial_port *port);
-static int firm_setup_port(struct tty_struct *tty);
+static void firm_setup_port(struct tty_struct *tty);
 static int firm_set_rts(struct usb_serial_port *port, __u8 onoff);
 static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff);
 static int firm_set_break(struct usb_serial_port *port, __u8 onoff);
@@ -659,8 +659,7 @@ static void whiteheat_release(struct usb_serial *serial)
         return;
 }
 
-static int whiteheat_open(struct tty_struct *tty,
-                        struct usb_serial_port *port, struct file *filp)
+static int whiteheat_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         int             retval = 0;
 
@@ -1211,7 +1210,7 @@ static int firm_close(struct usb_serial_port *port)
 }
 
 
-static int firm_setup_port(struct tty_struct *tty)
+static void firm_setup_port(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
         struct whiteheat_port_settings port_settings;
@@ -1286,7 +1285,7 @@ static int firm_setup_port(struct tty_struct *tty)
         port_settings.lloop = 0;
 
         /* now send the message to the device */
-        return firm_send_command(port, WHITEHEAT_SETUP_PORT,
+        firm_send_command(port, WHITEHEAT_SETUP_PORT,
                         (__u8 *)&port_settings, sizeof(port_settings));
 }
 
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index cef3e1d9b92e..11af4cb8924e 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -1869,7 +1869,7 @@ config FB_W100
 
 config FB_SH_MOBILE_LCDC
         tristate "SuperH Mobile LCDC framebuffer support"
-        depends on FB && SUPERH
+        depends on FB && SUPERH && HAVE_CLK
         select FB_SYS_FILLRECT
         select FB_SYS_COPYAREA
         select FB_SYS_IMAGEBLIT
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 59d7d5ec17a4..74e96cf83b7e 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -180,7 +180,6 @@ static inline void vga_set_mem_top(struct vc_data *c)
 }
 
 #ifdef CONFIG_VGACON_SOFT_SCROLLBACK
-#include <linux/slab.h>
 /* software scrollback */
 static void *vgacon_scrollback;
 static int vgacon_scrollback_tail;
diff --git a/drivers/video/omap/dispc.c b/drivers/video/omap/dispc.c
index 148cbcc39602..915439dc05a0 100644
--- a/drivers/video/omap/dispc.c
+++ b/drivers/video/omap/dispc.c
@@ -212,9 +212,9 @@ static void enable_rfbi_mode(int enable)
         dispc_write_reg(DISPC_CONTROL, l);
 
         /* Set bypass mode in RFBI module */
-        l = __raw_readl(IO_ADDRESS(RFBI_CONTROL));
+        l = __raw_readl(OMAP2_IO_ADDRESS(RFBI_CONTROL));
         l |= enable ? 0 : (1 << 1);
-        __raw_writel(l, IO_ADDRESS(RFBI_CONTROL));
+        __raw_writel(l, OMAP2_IO_ADDRESS(RFBI_CONTROL));
 }
 
 static void set_lcd_data_lines(int data_lines)
@@ -1421,7 +1421,7 @@ static int omap_dispc_init(struct omapfb_device *fbdev, int ext_mode,
         }
 
         /* L3 firewall setting: enable access to OCM RAM */
-        __raw_writel(0x402000b0, IO_ADDRESS(0x680050a0));
+        __raw_writel(0x402000b0, OMAP2_IO_ADDRESS(0x680050a0));
 
         if ((r = alloc_palette_ram()) < 0)
                 goto fail2;
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index 07f22b625632..3ad5157f9899 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -14,6 +14,7 @@
 #include <linux/mm.h>
 #include <linux/fb.h>
 #include <linux/clk.h>
+#include <linux/pm_runtime.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
@@ -22,35 +23,8 @@
 #include <asm/atomic.h>
 
 #define PALETTE_NR 16
-
-struct sh_mobile_lcdc_priv;
-struct sh_mobile_lcdc_chan {
-        struct sh_mobile_lcdc_priv *lcdc;
-        unsigned long *reg_offs;
-        unsigned long ldmt1r_value;
-        unsigned long enabled; /* ME and SE in LDCNT2R */
-        struct sh_mobile_lcdc_chan_cfg cfg;
-        u32 pseudo_palette[PALETTE_NR];
-        struct fb_info *info;
-        dma_addr_t dma_handle;
-        struct fb_deferred_io defio;
-        struct scatterlist *sglist;
-        unsigned long frame_end;
-        wait_queue_head_t frame_end_wait;
-};
-
-struct sh_mobile_lcdc_priv {
-        void __iomem *base;
-        int irq;
-#ifdef CONFIG_HAVE_CLK
-        atomic_t clk_usecnt;
-        struct clk *dot_clk;
-        struct clk *clk;
-#endif
-        unsigned long lddckr;
-        struct sh_mobile_lcdc_chan ch[2];
-        int started;
-};
+#define SIDE_B_OFFSET 0x1000
+#define MIRROR_OFFSET 0x2000
 
 /* shared registers */
 #define _LDDCKR 0x410
@@ -59,17 +33,30 @@ struct sh_mobile_lcdc_priv {
 #define _LDSR 0x46c
 #define _LDCNT1R 0x470
 #define _LDCNT2R 0x474
+#define _LDRCNTR 0x478
 #define _LDDDSR 0x47c
 #define _LDDWD0R 0x800
 #define _LDDRDR 0x840
 #define _LDDWAR 0x900
 #define _LDDRAR 0x904
 
+/* shared registers and their order for context save/restore */
+static int lcdc_shared_regs[] = {
+        _LDDCKR,
+        _LDDCKSTPR,
+        _LDINTR,
+        _LDDDSR,
+        _LDCNT1R,
+        _LDCNT2R,
+};
+#define NR_SHARED_REGS ARRAY_SIZE(lcdc_shared_regs)
+
 /* per-channel registers */
 enum { LDDCKPAT1R, LDDCKPAT2R, LDMT1R, LDMT2R, LDMT3R, LDDFR, LDSM1R,
-       LDSM2R, LDSA1R, LDMLSR, LDHCNR, LDHSYNR, LDVLNR, LDVSYNR, LDPMR };
+       LDSM2R, LDSA1R, LDMLSR, LDHCNR, LDHSYNR, LDVLNR, LDVSYNR, LDPMR,
+       NR_CH_REGS };
 
-static unsigned long lcdc_offs_mainlcd[] = {
+static unsigned long lcdc_offs_mainlcd[NR_CH_REGS] = {
         [LDDCKPAT1R] = 0x400,
         [LDDCKPAT2R] = 0x404,
         [LDMT1R] = 0x418,
@@ -87,7 +74,7 @@ static unsigned long lcdc_offs_mainlcd[] = {
         [LDPMR] = 0x460,
 };
 
-static unsigned long lcdc_offs_sublcd[] = {
+static unsigned long lcdc_offs_sublcd[NR_CH_REGS] = {
         [LDDCKPAT1R] = 0x408,
         [LDDCKPAT2R] = 0x40c,
         [LDMT1R] = 0x600,
@@ -110,12 +97,80 @@ static unsigned long lcdc_offs_sublcd[] = {
 #define DISPLAY_BEU     0x00000008
 #define LCDC_ENABLE     0x00000001
 #define LDINTR_FE       0x00000400
+#define LDINTR_VSE      0x00000200
+#define LDINTR_VEE      0x00000100
 #define LDINTR_FS       0x00000004
+#define LDINTR_VSS      0x00000002
+#define LDINTR_VES      0x00000001
+#define LDRCNTR_SRS     0x00020000
+#define LDRCNTR_SRC     0x00010000
+#define LDRCNTR_MRS     0x00000002
+#define LDRCNTR_MRC     0x00000001
+
+struct sh_mobile_lcdc_priv;
+struct sh_mobile_lcdc_chan {
+        struct sh_mobile_lcdc_priv *lcdc;
+        unsigned long *reg_offs;
+        unsigned long ldmt1r_value;
+        unsigned long enabled; /* ME and SE in LDCNT2R */
+        struct sh_mobile_lcdc_chan_cfg cfg;
+        u32 pseudo_palette[PALETTE_NR];
+        unsigned long saved_ch_regs[NR_CH_REGS];
+        struct fb_info *info;
+        dma_addr_t dma_handle;
+        struct fb_deferred_io defio;
+        struct scatterlist *sglist;
+        unsigned long frame_end;
+        unsigned long pan_offset;
+        unsigned long new_pan_offset;
+        wait_queue_head_t frame_end_wait;
+};
+
+struct sh_mobile_lcdc_priv {
+        void __iomem *base;
+        int irq;
+        atomic_t hw_usecnt;
+        struct device *dev;
+        struct clk *dot_clk;
+        unsigned long lddckr;
+        struct sh_mobile_lcdc_chan ch[2];
+        unsigned long saved_shared_regs[NR_SHARED_REGS];
+        int started;
+};
+
+static bool banked(int reg_nr)
+{
+        switch (reg_nr) {
+        case LDMT1R:
+        case LDMT2R:
+        case LDMT3R:
+        case LDDFR:
+        case LDSM1R:
+        case LDSA1R:
+        case LDMLSR:
+        case LDHCNR:
+        case LDHSYNR:
+        case LDVLNR:
+        case LDVSYNR:
+                return true;
+        }
+        return false;
+}
 
 static void lcdc_write_chan(struct sh_mobile_lcdc_chan *chan,
                             int reg_nr, unsigned long data)
 {
         iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr]);
+        if (banked(reg_nr))
+                iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr] +
+                          SIDE_B_OFFSET);
+}
+
+static void lcdc_write_chan_mirror(struct sh_mobile_lcdc_chan *chan,
+                            int reg_nr, unsigned long data)
+{
+        iowrite32(data, chan->lcdc->base + chan->reg_offs[reg_nr] +
+                  MIRROR_OFFSET);
 }
 
 static unsigned long lcdc_read_chan(struct sh_mobile_lcdc_chan *chan,
@@ -156,6 +211,7 @@ static void lcdc_sys_write_index(void *handle, unsigned long data)
         lcdc_write(ch->lcdc, _LDDWD0R, data | 0x10000000);
         lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
         lcdc_write(ch->lcdc, _LDDWAR, 1 | (lcdc_chan_is_sublcd(ch) ? 2 : 0));
+        lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
 }
 
 static void lcdc_sys_write_data(void *handle, unsigned long data)
@@ -165,6 +221,7 @@ static void lcdc_sys_write_data(void *handle, unsigned long data)
         lcdc_write(ch->lcdc, _LDDWD0R, data | 0x11000000);
         lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
         lcdc_write(ch->lcdc, _LDDWAR, 1 | (lcdc_chan_is_sublcd(ch) ? 2 : 0));
+        lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
 }
 
 static unsigned long lcdc_sys_read_data(void *handle)
@@ -175,8 +232,9 @@ static unsigned long lcdc_sys_read_data(void *handle)
         lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
         lcdc_write(ch->lcdc, _LDDRAR, 1 | (lcdc_chan_is_sublcd(ch) ? 2 : 0));
         udelay(1);
+        lcdc_wait_bit(ch->lcdc, _LDSR, 2, 0);
 
-        return lcdc_read(ch->lcdc, _LDDRDR) & 0xffff;
+        return lcdc_read(ch->lcdc, _LDDRDR) & 0x3ffff;
 }
 
 struct sh_mobile_lcdc_sys_bus_ops sh_mobile_lcdc_sys_bus_ops = {
@@ -185,11 +243,10 @@ struct sh_mobile_lcdc_sys_bus_ops sh_mobile_lcdc_sys_bus_ops = {
         lcdc_sys_read_data,
 };
 
-#ifdef CONFIG_HAVE_CLK
 static void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv *priv)
 {
-        if (atomic_inc_and_test(&priv->clk_usecnt)) {
-                clk_enable(priv->clk);
+        if (atomic_inc_and_test(&priv->hw_usecnt)) {
+                pm_runtime_get_sync(priv->dev);
                 if (priv->dot_clk)
                         clk_enable(priv->dot_clk);
         }
@@ -197,16 +254,12 @@ static void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv *priv)
 
 static void sh_mobile_lcdc_clk_off(struct sh_mobile_lcdc_priv *priv)
 {
-        if (atomic_sub_return(1, &priv->clk_usecnt) == -1) {
+        if (atomic_sub_return(1, &priv->hw_usecnt) == -1) {
                 if (priv->dot_clk)
                         clk_disable(priv->dot_clk);
-                clk_disable(priv->clk);
+                pm_runtime_put(priv->dev);
         }
 }
-#else
-static void sh_mobile_lcdc_clk_on(struct sh_mobile_lcdc_priv *priv) {}
-static void sh_mobile_lcdc_clk_off(struct sh_mobile_lcdc_priv *priv) {}
-#endif
 
 static int sh_mobile_lcdc_sginit(struct fb_info *info,
                                   struct list_head *pagelist)
@@ -255,30 +308,52 @@ static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data)
         struct sh_mobile_lcdc_priv *priv = data;
         struct sh_mobile_lcdc_chan *ch;
         unsigned long tmp;
+        unsigned long ldintr;
         int is_sub;
         int k;
 
         /* acknowledge interrupt */
-        tmp = lcdc_read(priv, _LDINTR);
-        tmp &= 0xffffff00; /* mask in high 24 bits */
-        tmp |= 0x000000ff ^ LDINTR_FS; /* status in low 8 */
+        ldintr = tmp = lcdc_read(priv, _LDINTR);
+        /*
+         * disable further VSYNC End IRQs, preserve all other enabled IRQs,
+         * write 0 to bits 0-6 to ack all triggered IRQs.
+         */
+        tmp &= 0xffffff00 & ~LDINTR_VEE;
         lcdc_write(priv, _LDINTR, tmp);
 
         /* figure out if this interrupt is for main or sub lcd */
         is_sub = (lcdc_read(priv, _LDSR) & (1 << 10)) ? 1 : 0;
 
-        /* wake up channel and disable clocks*/
+        /* wake up channel and disable clocks */
         for (k = 0; k < ARRAY_SIZE(priv->ch); k++) {
                 ch = &priv->ch[k];
 
                 if (!ch->enabled)
                         continue;
 
-                if (is_sub == lcdc_chan_is_sublcd(ch)) {
-                        ch->frame_end = 1;
-                        wake_up(&ch->frame_end_wait);
+                /* Frame Start */
+                if (ldintr & LDINTR_FS) {
+                        if (is_sub == lcdc_chan_is_sublcd(ch)) {
+                                ch->frame_end = 1;
+                                wake_up(&ch->frame_end_wait);
 
-                        sh_mobile_lcdc_clk_off(priv);
+                                sh_mobile_lcdc_clk_off(priv);
+                        }
+                }
+
+                /* VSYNC End */
+                if (ldintr & LDINTR_VES) {
+                        unsigned long ldrcntr = lcdc_read(priv, _LDRCNTR);
+                        /* Set the source address for the next refresh */
+                        lcdc_write_chan_mirror(ch, LDSA1R, ch->dma_handle +
+                                               ch->new_pan_offset);
+                        if (lcdc_chan_is_sublcd(ch))
+                                lcdc_write(ch->lcdc, _LDRCNTR,
+                                           ldrcntr ^ LDRCNTR_SRS);
+                        else
+                                lcdc_write(ch->lcdc, _LDRCNTR,
+                                           ldrcntr ^ LDRCNTR_MRS);
+                        ch->pan_offset = ch->new_pan_offset;
                 }
         }
 
@@ -520,7 +595,6 @@ static void sh_mobile_lcdc_stop(struct sh_mobile_lcdc_priv *priv)
                 board_cfg = &ch->cfg.board_cfg;
                 if (board_cfg->display_off)
                         board_cfg->display_off(board_cfg->board_data);
-
         }
 
         /* stop the lcdc */
@@ -579,9 +653,6 @@ static int sh_mobile_lcdc_setup_clocks(struct platform_device *pdev,
                                        int clock_source,
                                        struct sh_mobile_lcdc_priv *priv)
 {
-#ifdef CONFIG_HAVE_CLK
-        char clk_name[8];
-#endif
         char *str;
         int icksel;
 
@@ -595,25 +666,21 @@ static int sh_mobile_lcdc_setup_clocks(struct platform_device *pdev,
 
         priv->lddckr = icksel << 16;
 
-#ifdef CONFIG_HAVE_CLK
-        atomic_set(&priv->clk_usecnt, -1);
-        snprintf(clk_name, sizeof(clk_name), "lcdc%d", pdev->id);
-        priv->clk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(priv->clk)) {
-                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
-                return PTR_ERR(priv->clk);
-        }
-        
         if (str) {
                 priv->dot_clk = clk_get(&pdev->dev, str);
                 if (IS_ERR(priv->dot_clk)) {
                         dev_err(&pdev->dev, "cannot get dot clock %s\n", str);
-                        clk_put(priv->clk);
                         return PTR_ERR(priv->dot_clk);
                 }
         }
-#endif
-
+        atomic_set(&priv->hw_usecnt, -1);
+
+        /* Runtime PM support involves two step for this driver:
+         * 1) Enable Runtime PM
+         * 2) Force Runtime PM Resume since hardware is accessed from probe()
+         */
+        pm_runtime_enable(priv->dev);
+        pm_runtime_resume(priv->dev);
         return 0;
 }
 
@@ -646,6 +713,9 @@ static struct fb_fix_screeninfo sh_mobile_lcdc_fix  = {
         .type =         FB_TYPE_PACKED_PIXELS,
         .visual =       FB_VISUAL_TRUECOLOR,
         .accel =        FB_ACCEL_NONE,
+        .xpanstep =     0,
+        .ypanstep =     1,
+        .ywrapstep =    0,
 };
 
 static void sh_mobile_lcdc_fillrect(struct fb_info *info,
@@ -669,13 +739,38 @@ static void sh_mobile_lcdc_imageblit(struct fb_info *info,
         sh_mobile_lcdc_deferred_io_touch(info);
 }
 
+static int sh_mobile_fb_pan_display(struct fb_var_screeninfo *var,
+                                     struct fb_info *info)
+{
+        struct sh_mobile_lcdc_chan *ch = info->par;
+
+        if (info->var.xoffset == var->xoffset &&
+            info->var.yoffset == var->yoffset)
+                return 0;       /* No change, do nothing */
+
+        ch->new_pan_offset = (var->yoffset * info->fix.line_length) +
+                (var->xoffset * (info->var.bits_per_pixel / 8));
+
+        if (ch->new_pan_offset != ch->pan_offset) {
+                unsigned long ldintr;
+                ldintr = lcdc_read(ch->lcdc, _LDINTR);
+                ldintr |= LDINTR_VEE;
+                lcdc_write(ch->lcdc, _LDINTR, ldintr);
+                sh_mobile_lcdc_deferred_io_touch(info);
+        }
+
+        return 0;
+}
+
 static struct fb_ops sh_mobile_lcdc_ops = {
+        .owner          = THIS_MODULE,
         .fb_setcolreg   = sh_mobile_lcdc_setcolreg,
         .fb_read        = fb_sys_read,
         .fb_write       = fb_sys_write,
         .fb_fillrect    = sh_mobile_lcdc_fillrect,
         .fb_copyarea    = sh_mobile_lcdc_copyarea,
         .fb_imageblit   = sh_mobile_lcdc_imageblit,
+        .fb_pan_display = sh_mobile_fb_pan_display,
 };
 
 static int sh_mobile_lcdc_set_bpp(struct fb_var_screeninfo *var, int bpp)
@@ -731,9 +826,59 @@ static int sh_mobile_lcdc_resume(struct device *dev)
         return sh_mobile_lcdc_start(platform_get_drvdata(pdev));
 }
 
+static int sh_mobile_lcdc_runtime_suspend(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_mobile_lcdc_priv *p = platform_get_drvdata(pdev);
+        struct sh_mobile_lcdc_chan *ch;
+        int k, n;
+
+        /* save per-channel registers */
+        for (k = 0; k < ARRAY_SIZE(p->ch); k++) {
+                ch = &p->ch[k];
+                if (!ch->enabled)
+                        continue;
+                for (n = 0; n < NR_CH_REGS; n++)
+                        ch->saved_ch_regs[n] = lcdc_read_chan(ch, n);
+        }
+
+        /* save shared registers */
+        for (n = 0; n < NR_SHARED_REGS; n++)
+                p->saved_shared_regs[n] = lcdc_read(p, lcdc_shared_regs[n]);
+
+        /* turn off LCDC hardware */
+        lcdc_write(p, _LDCNT1R, 0);
+        return 0;
+}
+
+static int sh_mobile_lcdc_runtime_resume(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct sh_mobile_lcdc_priv *p = platform_get_drvdata(pdev);
+        struct sh_mobile_lcdc_chan *ch;
+        int k, n;
+
+        /* restore per-channel registers */
+        for (k = 0; k < ARRAY_SIZE(p->ch); k++) {
+                ch = &p->ch[k];
+                if (!ch->enabled)
+                        continue;
+                for (n = 0; n < NR_CH_REGS; n++)
+                        lcdc_write_chan(ch, n, ch->saved_ch_regs[n]);
+        }
+
+        /* restore shared registers */
+        for (n = 0; n < NR_SHARED_REGS; n++)
+                lcdc_write(p, lcdc_shared_regs[n], p->saved_shared_regs[n]);
+
+        return 0;
+}
+
 static struct dev_pm_ops sh_mobile_lcdc_dev_pm_ops = {
         .suspend = sh_mobile_lcdc_suspend,
         .resume = sh_mobile_lcdc_resume,
+        .runtime_suspend = sh_mobile_lcdc_runtime_suspend,
+        .runtime_resume = sh_mobile_lcdc_runtime_resume,
 };
 
 static int sh_mobile_lcdc_remove(struct platform_device *pdev);
@@ -778,6 +923,7 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
         }
 
         priv->irq = i;
+        priv->dev = &pdev->dev;
         platform_set_drvdata(pdev, priv);
         pdata = pdev->dev.platform_data;
 
@@ -792,6 +938,8 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
                         goto err1;
                 }
                 init_waitqueue_head(&priv->ch[i].frame_end_wait);
+                priv->ch[j].pan_offset = 0;
+                priv->ch[j].new_pan_offset = 0;
 
                 switch (pdata->ch[i].chan) {
                 case LCDC_CHAN_MAINLCD:
@@ -834,7 +982,9 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
                 info = priv->ch[i].info;
                 info->fbops = &sh_mobile_lcdc_ops;
                 info->var.xres = info->var.xres_virtual = cfg->lcd_cfg.xres;
-                info->var.yres = info->var.yres_virtual = cfg->lcd_cfg.yres;
+                info->var.yres = cfg->lcd_cfg.yres;
+                /* Default Y virtual resolution is 2x panel size */
+                info->var.yres_virtual = info->var.yres * 2;
                 info->var.width = cfg->lcd_size_cfg.width;
                 info->var.height = cfg->lcd_size_cfg.height;
                 info->var.activate = FB_ACTIVATE_NOW;
@@ -844,7 +994,8 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
 
                 info->fix = sh_mobile_lcdc_fix;
                 info->fix.line_length = cfg->lcd_cfg.xres * (cfg->bpp / 8);
-                info->fix.smem_len = info->fix.line_length * cfg->lcd_cfg.yres;
+                info->fix.smem_len = info->fix.line_length *
+                        info->var.yres_virtual;
 
                 buf = dma_alloc_coherent(&pdev->dev, info->fix.smem_len,
                                          &priv->ch[i].dma_handle, GFP_KERNEL);
@@ -947,11 +1098,10 @@ static int sh_mobile_lcdc_remove(struct platform_device *pdev)
                 framebuffer_release(info);
         }
 
-#ifdef CONFIG_HAVE_CLK
         if (priv->dot_clk)
                 clk_put(priv->dot_clk);
-        clk_put(priv->clk);
-#endif
+
+        pm_runtime_disable(priv->dev);
 
         if (priv->base)
                 iounmap(priv->base);
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index b1ccc04f3c9a..ff3eb8ff6bd7 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -55,6 +55,13 @@ config SOFT_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called softdog.
 
+config WM831X_WATCHDOG
+        tristate "WM831x watchdog"
+        depends on MFD_WM831X
+        help
+          Support for the watchdog in the WM831x AudioPlus PMICs.  When
+          the watchdog triggers the system will be reset.
+
 config WM8350_WATCHDOG
         tristate "WM8350 watchdog"
         depends on MFD_WM8350
@@ -266,6 +273,15 @@ config STMP3XXX_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called stmp3xxx_wdt.
 
+config NUC900_WATCHDOG
+        tristate "Nuvoton NUC900 watchdog"
+        depends on ARCH_W90X900
+        help
+          Say Y here if to include support for the watchdog timer
+          for the Nuvoton NUC900 series SoCs.
+          To compile this driver as a module, choose M here: the
+          module will be called nuc900_wdt.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
@@ -369,6 +385,28 @@ config SC520_WDT
           You can compile this driver directly into the kernel, or use
           it as a module.  The module will be called sc520_wdt.
 
+config SBC_FITPC2_WATCHDOG
+        tristate "Compulab SBC-FITPC2 watchdog"
+        depends on X86
+        ---help---
+          This is the driver for the built-in watchdog timer on the fit-PC2
+          Single-board computer made by Compulab.
+
+          It`s possible to enable watchdog timer either from BIOS (F2) or from booted Linux.
+          When "Watchdog Timer Value" enabled one can set 31-255 s operational range.
+
+          Entering BIOS setup temporary disables watchdog operation regardless to current state,
+          so system will not be restarted while user in BIOS setup.
+
+          Once watchdog was enabled the system will be restarted every
+          "Watchdog Timer Value" period, so to prevent it user can restart or
+          disable the watchdog.
+
+          To compile this driver as a module, choose M here: the
+          module will be called sbc_fitpc2_wdt.
+
+          Most people will say N.
+
 config EUROTECH_WDT
         tristate "Eurotech CPU-1220/1410 Watchdog Timer"
         depends on X86
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 3d774294a2b7..348b3b862c99 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -44,6 +44,7 @@ obj-$(CONFIG_DAVINCI_WATCHDOG) += davinci_wdt.o
 obj-$(CONFIG_ORION_WATCHDOG) += orion_wdt.o
 obj-$(CONFIG_COH901327_WATCHDOG) += coh901327_wdt.o
 obj-$(CONFIG_STMP3XXX_WATCHDOG) += stmp3xxx_wdt.o
+obj-$(CONFIG_NUC900_WATCHDOG) += nuc900_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
@@ -64,6 +65,7 @@ obj-$(CONFIG_ALIM1535_WDT) += alim1535_wdt.o
 obj-$(CONFIG_ALIM7101_WDT) += alim7101_wdt.o
 obj-$(CONFIG_GEODE_WDT) += geodewdt.o
 obj-$(CONFIG_SC520_WDT) += sc520_wdt.o
+obj-$(CONFIG_SBC_FITPC2_WATCHDOG) += sbc_fitpc2_wdt.o
 obj-$(CONFIG_EUROTECH_WDT) += eurotechwdt.o
 obj-$(CONFIG_IB700_WDT) += ib700wdt.o
 obj-$(CONFIG_IBMASR) += ibmasr.o
@@ -139,5 +141,6 @@ obj-$(CONFIG_WATCHDOG_CP1XXX)		+= cpwd.o
 # XTENSA Architecture
 
 # Architecture Independant
+obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o
 obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o
 obj-$(CONFIG_SOFT_WATCHDOG) += softdog.o
diff --git a/drivers/watchdog/ar7_wdt.c b/drivers/watchdog/ar7_wdt.c
index 2f8643efe92c..2e94b71b20d9 100644
--- a/drivers/watchdog/ar7_wdt.c
+++ b/drivers/watchdog/ar7_wdt.c
@@ -28,9 +28,8 @@
 #include <linux/errno.h>
 #include <linux/init.h>
 #include <linux/miscdevice.h>
+#include <linux/platform_device.h>
 #include <linux/watchdog.h>
-#include <linux/notifier.h>
-#include <linux/reboot.h>
 #include <linux/fs.h>
 #include <linux/ioport.h>
 #include <linux/io.h>
@@ -76,24 +75,10 @@ static unsigned expect_close;
 /* XXX currently fixed, allows max margin ~68.72 secs */
 #define prescale_value 0xffff
 
-/* Offset of the WDT registers */
-static unsigned long ar7_regs_wdt;
+/* Resource of the WDT registers */
+static struct resource *ar7_regs_wdt;
 /* Pointer to the remapped WDT IO space */
 static struct ar7_wdt *ar7_wdt;
-static void ar7_wdt_get_regs(void)
-{
-        u16 chip_id = ar7_chip_id();
-        switch (chip_id) {
-        case AR7_CHIP_7100:
-        case AR7_CHIP_7200:
-                ar7_regs_wdt = AR7_REGS_WDT;
-                break;
-        default:
-                ar7_regs_wdt = UR8_REGS_WDT;
-                break;
-        }
-}
-
 
 static void ar7_wdt_kick(u32 value)
 {
@@ -202,20 +187,6 @@ static int ar7_wdt_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static int ar7_wdt_notify_sys(struct notifier_block *this,
-                              unsigned long code, void *unused)
-{
-        if (code == SYS_HALT || code == SYS_POWER_OFF)
-                if (!nowayout)
-                        ar7_wdt_disable_wdt();
-
-        return NOTIFY_DONE;
-}
-
-static struct notifier_block ar7_wdt_notifier = {
-        .notifier_call = ar7_wdt_notify_sys,
-};
-
 static ssize_t ar7_wdt_write(struct file *file, const char *data,
                              size_t len, loff_t *ppos)
 {
@@ -299,56 +270,86 @@ static struct miscdevice ar7_wdt_miscdev = {
         .fops           = &ar7_wdt_fops,
 };
 
-static int __init ar7_wdt_init(void)
+static int __devinit ar7_wdt_probe(struct platform_device *pdev)
 {
         int rc;
 
         spin_lock_init(&wdt_lock);
 
-        ar7_wdt_get_regs();
+        ar7_regs_wdt =
+                platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
+        if (!ar7_regs_wdt) {
+                printk(KERN_ERR DRVNAME ": could not get registers resource\n");
+                rc = -ENODEV;
+                goto out;
+        }
 
-        if (!request_mem_region(ar7_regs_wdt, sizeof(struct ar7_wdt),
-                                                        LONGNAME)) {
+        if (!request_mem_region(ar7_regs_wdt->start,
+                                resource_size(ar7_regs_wdt), LONGNAME)) {
                 printk(KERN_WARNING DRVNAME ": watchdog I/O region busy\n");
-                return -EBUSY;
+                rc = -EBUSY;
+                goto out;
         }
 
-        ar7_wdt = (struct ar7_wdt *)
-                        ioremap(ar7_regs_wdt, sizeof(struct ar7_wdt));
+        ar7_wdt = ioremap(ar7_regs_wdt->start, resource_size(ar7_regs_wdt));
+        if (!ar7_wdt) {
+                printk(KERN_ERR DRVNAME ": could not ioremap registers\n");
+                rc = -ENXIO;
+                goto out_mem_region;
+        }
 
         ar7_wdt_disable_wdt();
         ar7_wdt_prescale(prescale_value);
         ar7_wdt_update_margin(margin);
 
-        rc = register_reboot_notifier(&ar7_wdt_notifier);
-        if (rc) {
-                printk(KERN_ERR DRVNAME
-                        ": unable to register reboot notifier\n");
-                goto out_alloc;
-        }
-
         rc = misc_register(&ar7_wdt_miscdev);
         if (rc) {
                 printk(KERN_ERR DRVNAME ": unable to register misc device\n");
-                goto out_register;
+                goto out_alloc;
         }
         goto out;
 
-out_register:
-        unregister_reboot_notifier(&ar7_wdt_notifier);
 out_alloc:
         iounmap(ar7_wdt);
-        release_mem_region(ar7_regs_wdt, sizeof(struct ar7_wdt));
+out_mem_region:
+        release_mem_region(ar7_regs_wdt->start, resource_size(ar7_regs_wdt));
 out:
         return rc;
 }
 
-static void __exit ar7_wdt_cleanup(void)
+static int __devexit ar7_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&ar7_wdt_miscdev);
-        unregister_reboot_notifier(&ar7_wdt_notifier);
         iounmap(ar7_wdt);
-        release_mem_region(ar7_regs_wdt, sizeof(struct ar7_wdt));
+        release_mem_region(ar7_regs_wdt->start, resource_size(ar7_regs_wdt));
+
+        return 0;
+}
+
+static void ar7_wdt_shutdown(struct platform_device *pdev)
+{
+        if (!nowayout)
+                ar7_wdt_disable_wdt();
+}
+
+static struct platform_driver ar7_wdt_driver = {
+        .probe = ar7_wdt_probe,
+        .remove = __devexit_p(ar7_wdt_remove),
+        .shutdown = ar7_wdt_shutdown,
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "ar7_wdt",
+        },
+};
+
+static int __init ar7_wdt_init(void)
+{
+        return platform_driver_register(&ar7_wdt_driver);
+}
+
+static void __exit ar7_wdt_cleanup(void)
+{
+        platform_driver_unregister(&ar7_wdt_driver);
 }
 
 module_init(ar7_wdt_init);
diff --git a/drivers/watchdog/booke_wdt.c b/drivers/watchdog/booke_wdt.c
index 225398fd5049..e8380ef65c1c 100644
--- a/drivers/watchdog/booke_wdt.c
+++ b/drivers/watchdog/booke_wdt.c
@@ -22,6 +22,8 @@
 
 #include <asm/reg_booke.h>
 #include <asm/system.h>
+#include <asm/time.h>
+#include <asm/div64.h>
 
 /* If the kernel parameter wdt=1, the watchdog will be enabled at boot.
  * Also, the wdt_period sets the watchdog timer period timeout.
@@ -32,7 +34,7 @@
  */
 
 #ifdef  CONFIG_FSL_BOOKE
-#define WDT_PERIOD_DEFAULT 63   /* Ex. wdt_period=28 bus=333Mhz,reset=~40sec */
+#define WDT_PERIOD_DEFAULT 38   /* Ex. wdt_period=28 bus=333Mhz,reset=~40sec */
 #else
 #define WDT_PERIOD_DEFAULT 3    /* Refer to the PPC40x and PPC4xx manuals */
 #endif                          /* for timing information */
@@ -41,7 +43,7 @@ u32 booke_wdt_enabled;
 u32 booke_wdt_period = WDT_PERIOD_DEFAULT;
 
 #ifdef  CONFIG_FSL_BOOKE
-#define WDTP(x)         ((((63-x)&0x3)<<30)|(((63-x)&0x3c)<<15))
+#define WDTP(x)         ((((x)&0x3)<<30)|(((x)&0x3c)<<15))
 #define WDTP_MASK       (WDTP(0))
 #else
 #define WDTP(x)         (TCR_WP(x))
@@ -50,6 +52,45 @@ u32 booke_wdt_period = WDT_PERIOD_DEFAULT;
 
 static DEFINE_SPINLOCK(booke_wdt_lock);
 
+/* For the specified period, determine the number of seconds
+ * corresponding to the reset time.  There will be a watchdog
+ * exception at approximately 3/5 of this time.
+ *
+ * The formula to calculate this is given by:
+ * 2.5 * (2^(63-period+1)) / timebase_freq
+ *
+ * In order to simplify things, we assume that period is
+ * at least 1.  This will still result in a very long timeout.
+ */
+static unsigned long long period_to_sec(unsigned int period)
+{
+        unsigned long long tmp = 1ULL << (64 - period);
+        unsigned long tmp2 = ppc_tb_freq;
+
+        /* tmp may be a very large number and we don't want to overflow,
+         * so divide the timebase freq instead of multiplying tmp
+         */
+        tmp2 = tmp2 / 5 * 2;
+
+        do_div(tmp, tmp2);
+        return tmp;
+}
+
+/*
+ * This procedure will find the highest period which will give a timeout
+ * greater than the one required. e.g. for a bus speed of 66666666 and
+ * and a parameter of 2 secs, then this procedure will return a value of 38.
+ */
+static unsigned int sec_to_period(unsigned int secs)
+{
+        unsigned int period;
+        for (period = 63; period > 0; period--) {
+                if (period_to_sec(period) >= secs)
+                        return period;
+        }
+        return 0;
+}
+
 static void __booke_wdt_ping(void *data)
 {
         mtspr(SPRN_TSR, TSR_ENW|TSR_WIS);
@@ -93,7 +134,7 @@ static long booke_wdt_ioctl(struct file *file,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user(arg, &ident, sizeof(struct watchdog_info)))
+                if (copy_to_user((void *)arg, &ident, sizeof(ident)))
                         return -EFAULT;
         case WDIOC_GETSTATUS:
                 return put_user(ident.options, p);
@@ -115,8 +156,16 @@ static long booke_wdt_ioctl(struct file *file,
                 booke_wdt_ping();
                 return 0;
         case WDIOC_SETTIMEOUT:
-                if (get_user(booke_wdt_period, p))
+                if (get_user(tmp, p))
                         return -EFAULT;
+#ifdef  CONFIG_FSL_BOOKE
+                /* period of 1 gives the largest possible timeout */
+                if (tmp > period_to_sec(1))
+                        return -EINVAL;
+                booke_wdt_period = sec_to_period(tmp);
+#else
+                booke_wdt_period = tmp;
+#endif
                 mtspr(SPRN_TCR, (mfspr(SPRN_TCR) & ~WDTP_MASK) |
                                                 WDTP(booke_wdt_period));
                 return 0;
diff --git a/drivers/watchdog/coh901327_wdt.c b/drivers/watchdog/coh901327_wdt.c
index aec7cefdef21..381026c0bd7b 100644
--- a/drivers/watchdog/coh901327_wdt.c
+++ b/drivers/watchdog/coh901327_wdt.c
@@ -110,7 +110,7 @@ static void coh901327_enable(u16 timeout)
          * Wait 3 32 kHz cycles for it to take effect
          */
         freq = clk_get_rate(clk);
-        delay_ns = (1000000000 + freq - 1) / freq; /* Freq to ns and round up */
+        delay_ns = DIV_ROUND_UP(1000000000, freq); /* Freq to ns and round up */
         delay_ns = 3 * delay_ns; /* Wait 3 cycles */
         ndelay(delay_ns);
         /* Enable the watchdog interrupt */
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index 83e22e7ea4a2..9d7520fa9e9c 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -25,6 +25,7 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
 #include <linux/device.h>
+#include <linux/clk.h>
 
 #define MODULE_NAME "DAVINCI-WDT: "
 
@@ -69,6 +70,7 @@ static unsigned long wdt_status;
 
 static struct resource  *wdt_mem;
 static void __iomem     *wdt_base;
+struct clk              *wdt_clk;
 
 static void wdt_service(void)
 {
@@ -86,6 +88,9 @@ static void wdt_enable(void)
 {
         u32 tgcr;
         u32 timer_margin;
+        unsigned long wdt_freq;
+
+        wdt_freq = clk_get_rate(wdt_clk);
 
         spin_lock(&io_lock);
 
@@ -99,9 +104,9 @@ static void wdt_enable(void)
         iowrite32(0, wdt_base + TIM12);
         iowrite32(0, wdt_base + TIM34);
         /* set timeout period */
-        timer_margin = (((u64)heartbeat * CLOCK_TICK_RATE) & 0xffffffff);
+        timer_margin = (((u64)heartbeat * wdt_freq) & 0xffffffff);
         iowrite32(timer_margin, wdt_base + PRD12);
-        timer_margin = (((u64)heartbeat * CLOCK_TICK_RATE) >> 32);
+        timer_margin = (((u64)heartbeat * wdt_freq) >> 32);
         iowrite32(timer_margin, wdt_base + PRD34);
         /* enable run continuously */
         iowrite32(ENAMODE12_PERIODIC, wdt_base + TCR);
@@ -199,6 +204,12 @@ static int __devinit davinci_wdt_probe(struct platform_device *pdev)
         struct resource *res;
         struct device *dev = &pdev->dev;
 
+        wdt_clk = clk_get(dev, NULL);
+        if (WARN_ON(IS_ERR(wdt_clk)))
+                return PTR_ERR(wdt_clk);
+
+        clk_enable(wdt_clk);
+
         if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
                 heartbeat = DEFAULT_HEARTBEAT;
 
@@ -245,6 +256,10 @@ static int __devexit davinci_wdt_remove(struct platform_device *pdev)
                 kfree(wdt_mem);
                 wdt_mem = NULL;
         }
+
+        clk_disable(wdt_clk);
+        clk_put(wdt_clk);
+
         return 0;
 }
 
diff --git a/drivers/watchdog/iop_wdt.c b/drivers/watchdog/iop_wdt.c
index 0c9059676690..aef94789019f 100644
--- a/drivers/watchdog/iop_wdt.c
+++ b/drivers/watchdog/iop_wdt.c
@@ -139,7 +139,7 @@ static long iop_wdt_ioctl(struct file *file,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user(argp, &ident, sizeof ident))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         ret = -EFAULT;
                 else
                         ret = 0;
diff --git a/drivers/watchdog/nuc900_wdt.c b/drivers/watchdog/nuc900_wdt.c
new file mode 100644
index 000000000000..adefe3a9d510
--- /dev/null
+++ b/drivers/watchdog/nuc900_wdt.c
@@ -0,0 +1,353 @@
+/*
+ * Copyright (c) 2009 Nuvoton technology corporation.
+ *
+ * Wan ZongShun <mcuos.com@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation;version 2 of the License.
+ *
+ */
+
+#include <linux/bitops.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/types.h>
+#include <linux/watchdog.h>
+#include <linux/uaccess.h>
+
+#define REG_WTCR                0x1c
+#define WTCLK                   (0x01 << 10)
+#define WTE                     (0x01 << 7)     /*wdt enable*/
+#define WTIS                    (0x03 << 4)
+#define WTIF                    (0x01 << 3)
+#define WTRF                    (0x01 << 2)
+#define WTRE                    (0x01 << 1)
+#define WTR                     (0x01 << 0)
+/*
+ * The watchdog time interval can be calculated via following formula:
+ * WTIS         real time interval (formula)
+ * 0x00         ((2^ 14 ) * ((external crystal freq) / 256))seconds
+ * 0x01         ((2^ 16 ) * ((external crystal freq) / 256))seconds
+ * 0x02         ((2^ 18 ) * ((external crystal freq) / 256))seconds
+ * 0x03         ((2^ 20 ) * ((external crystal freq) / 256))seconds
+ *
+ * The external crystal freq is 15Mhz in the nuc900 evaluation board.
+ * So 0x00 = +-0.28 seconds, 0x01 = +-1.12 seconds, 0x02 = +-4.48 seconds,
+ * 0x03 = +- 16.92 seconds..
+ */
+#define WDT_HW_TIMEOUT          0x02
+#define WDT_TIMEOUT             (HZ/2)
+#define WDT_HEARTBEAT           15
+
+static int heartbeat = WDT_HEARTBEAT;
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat, "Watchdog heartbeats in seconds. "
+        "(default = " __MODULE_STRING(WDT_HEARTBEAT) ")");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
+        "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+struct nuc900_wdt {
+        struct resource  *res;
+        struct clk       *wdt_clock;
+        struct platform_device *pdev;
+        void __iomem     *wdt_base;
+        char             expect_close;
+        struct timer_list timer;
+        spinlock_t       wdt_lock;
+        unsigned long next_heartbeat;
+};
+
+static unsigned long nuc900wdt_busy;
+struct nuc900_wdt *nuc900_wdt;
+
+static inline void nuc900_wdt_keepalive(void)
+{
+        unsigned int val;
+
+        spin_lock(&nuc900_wdt->wdt_lock);
+
+        val = __raw_readl(nuc900_wdt->wdt_base + REG_WTCR);
+        val |= (WTR | WTIF);
+        __raw_writel(val, nuc900_wdt->wdt_base + REG_WTCR);
+
+        spin_unlock(&nuc900_wdt->wdt_lock);
+}
+
+static inline void nuc900_wdt_start(void)
+{
+        unsigned int val;
+
+        spin_lock(&nuc900_wdt->wdt_lock);
+
+        val = __raw_readl(nuc900_wdt->wdt_base + REG_WTCR);
+        val |= (WTRE | WTE | WTR | WTCLK | WTIF);
+        val &= ~WTIS;
+        val |= (WDT_HW_TIMEOUT << 0x04);
+        __raw_writel(val, nuc900_wdt->wdt_base + REG_WTCR);
+
+        spin_unlock(&nuc900_wdt->wdt_lock);
+
+        nuc900_wdt->next_heartbeat = jiffies + heartbeat * HZ;
+        mod_timer(&nuc900_wdt->timer, jiffies + WDT_TIMEOUT);
+}
+
+static inline void nuc900_wdt_stop(void)
+{
+        unsigned int val;
+
+        del_timer(&nuc900_wdt->timer);
+
+        spin_lock(&nuc900_wdt->wdt_lock);
+
+        val = __raw_readl(nuc900_wdt->wdt_base + REG_WTCR);
+        val &= ~WTE;
+        __raw_writel(val, nuc900_wdt->wdt_base + REG_WTCR);
+
+        spin_unlock(&nuc900_wdt->wdt_lock);
+}
+
+static inline void nuc900_wdt_ping(void)
+{
+        nuc900_wdt->next_heartbeat = jiffies + heartbeat * HZ;
+}
+
+static int nuc900_wdt_open(struct inode *inode, struct file *file)
+{
+
+        if (test_and_set_bit(0, &nuc900wdt_busy))
+                return -EBUSY;
+
+        nuc900_wdt_start();
+
+        return nonseekable_open(inode, file);
+}
+
+static int nuc900_wdt_close(struct inode *inode, struct file *file)
+{
+        if (nuc900_wdt->expect_close == 42)
+                nuc900_wdt_stop();
+        else {
+                dev_crit(&nuc900_wdt->pdev->dev,
+                        "Unexpected close, not stopping watchdog!\n");
+                nuc900_wdt_ping();
+        }
+
+        nuc900_wdt->expect_close = 0;
+        clear_bit(0, &nuc900wdt_busy);
+        return 0;
+}
+
+static const struct watchdog_info nuc900_wdt_info = {
+        .identity       = "nuc900 watchdog",
+        .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
+                                                WDIOF_MAGICCLOSE,
+};
+
+static long nuc900_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        int new_value;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &nuc900_wdt_info,
+                                sizeof(nuc900_wdt_info)) ? -EFAULT : 0;
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_KEEPALIVE:
+                nuc900_wdt_ping();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+
+                heartbeat = new_value;
+                nuc900_wdt_ping();
+
+                return put_user(new_value, p);
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, p);
+        default:
+                return -ENOTTY;
+        }
+}
+
+static ssize_t nuc900_wdt_write(struct file *file, const char __user *data,
+                                                size_t len, loff_t *ppos)
+{
+        if (!len)
+                return 0;
+
+        /* Scan for magic character */
+        if (!nowayout) {
+                size_t i;
+
+                nuc900_wdt->expect_close = 0;
+
+                for (i = 0; i < len; i++) {
+                        char c;
+                        if (get_user(c, data + i))
+                                return -EFAULT;
+                        if (c == 'V') {
+                                nuc900_wdt->expect_close = 42;
+                                break;
+                        }
+                }
+        }
+
+        nuc900_wdt_ping();
+        return len;
+}
+
+static void nuc900_wdt_timer_ping(unsigned long data)
+{
+        if (time_before(jiffies, nuc900_wdt->next_heartbeat)) {
+                nuc900_wdt_keepalive();
+                mod_timer(&nuc900_wdt->timer, jiffies + WDT_TIMEOUT);
+        } else
+                dev_warn(&nuc900_wdt->pdev->dev, "Will reset the machine !\n");
+}
+
+static const struct file_operations nuc900wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .unlocked_ioctl = nuc900_wdt_ioctl,
+        .open           = nuc900_wdt_open,
+        .release        = nuc900_wdt_close,
+        .write          = nuc900_wdt_write,
+};
+
+static struct miscdevice nuc900wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &nuc900wdt_fops,
+};
+
+static int __devinit nuc900wdt_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+
+        nuc900_wdt = kzalloc(sizeof(struct nuc900_wdt), GFP_KERNEL);
+        if (!nuc900_wdt)
+                return -ENOMEM;
+
+        nuc900_wdt->pdev = pdev;
+
+        spin_lock_init(&nuc900_wdt->wdt_lock);
+
+        nuc900_wdt->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (nuc900_wdt->res == NULL) {
+                dev_err(&pdev->dev, "no memory resource specified\n");
+                ret = -ENOENT;
+                goto err_get;
+        }
+
+        if (!request_mem_region(nuc900_wdt->res->start,
+                                resource_size(nuc900_wdt->res), pdev->name)) {
+                dev_err(&pdev->dev, "failed to get memory region\n");
+                ret = -ENOENT;
+                goto err_get;
+        }
+
+        nuc900_wdt->wdt_base = ioremap(nuc900_wdt->res->start,
+                                        resource_size(nuc900_wdt->res));
+        if (nuc900_wdt->wdt_base == NULL) {
+                dev_err(&pdev->dev, "failed to ioremap() region\n");
+                ret = -EINVAL;
+                goto err_req;
+        }
+
+        nuc900_wdt->wdt_clock = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(nuc900_wdt->wdt_clock)) {
+                dev_err(&pdev->dev, "failed to find watchdog clock source\n");
+                ret = PTR_ERR(nuc900_wdt->wdt_clock);
+                goto err_map;
+        }
+
+        clk_enable(nuc900_wdt->wdt_clock);
+
+        setup_timer(&nuc900_wdt->timer, nuc900_wdt_timer_ping, 0);
+
+        if (misc_register(&nuc900wdt_miscdev)) {
+                dev_err(&pdev->dev, "err register miscdev on minor=%d (%d)\n",
+                        WATCHDOG_MINOR, ret);
+                goto err_clk;
+        }
+
+        return 0;
+
+err_clk:
+        clk_disable(nuc900_wdt->wdt_clock);
+        clk_put(nuc900_wdt->wdt_clock);
+err_map:
+        iounmap(nuc900_wdt->wdt_base);
+err_req:
+        release_mem_region(nuc900_wdt->res->start,
+                                        resource_size(nuc900_wdt->res));
+err_get:
+        kfree(nuc900_wdt);
+        return ret;
+}
+
+static int __devexit nuc900wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&nuc900wdt_miscdev);
+
+        clk_disable(nuc900_wdt->wdt_clock);
+        clk_put(nuc900_wdt->wdt_clock);
+
+        iounmap(nuc900_wdt->wdt_base);
+
+        release_mem_region(nuc900_wdt->res->start,
+                                        resource_size(nuc900_wdt->res));
+
+        kfree(nuc900_wdt);
+
+        return 0;
+}
+
+static struct platform_driver nuc900wdt_driver = {
+        .probe          = nuc900wdt_probe,
+        .remove         = __devexit_p(nuc900wdt_remove),
+        .driver         = {
+                .name   = "nuc900-wdt",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init nuc900_wdt_init(void)
+{
+        return platform_driver_register(&nuc900wdt_driver);
+}
+
+static void __exit nuc900_wdt_exit(void)
+{
+        platform_driver_unregister(&nuc900wdt_driver);
+}
+
+module_init(nuc900_wdt_init);
+module_exit(nuc900_wdt_exit);
+
+MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
+MODULE_DESCRIPTION("Watchdog driver for NUC900");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+MODULE_ALIAS("platform:nuc900-wdt");
diff --git a/drivers/watchdog/rm9k_wdt.c b/drivers/watchdog/rm9k_wdt.c
index 2e4442642262..bb66958b9433 100644
--- a/drivers/watchdog/rm9k_wdt.c
+++ b/drivers/watchdog/rm9k_wdt.c
@@ -340,7 +340,7 @@ static const struct resource *wdt_gpi_get_resource(struct platform_device *pdv,
                                         const char *name, unsigned int type)
 {
         char buf[80];
-        if (snprintf(buf, sizeof buf, "%s_0", name) >= sizeof buf)
+        if (snprintf(buf, sizeof(buf), "%s_0", name) >= sizeof(buf))
                 return NULL;
         return platform_get_resource_byname(pdv, type, buf);
 }
diff --git a/drivers/watchdog/sbc_fitpc2_wdt.c b/drivers/watchdog/sbc_fitpc2_wdt.c
new file mode 100644
index 000000000000..852ca1977917
--- /dev/null
+++ b/drivers/watchdog/sbc_fitpc2_wdt.c
@@ -0,0 +1,267 @@
+/*
+ * Watchdog driver for SBC-FITPC2 board
+ *
+ * Author: Denis Turischev <denis@compulab.co.il>
+ *
+ * Adapted from the IXP2000 watchdog driver by Deepak Saxena.
+ *
+ * This file is licensed under  the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME " WATCHDOG: " fmt
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/ioport.h>
+#include <linux/delay.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/moduleparam.h>
+#include <linux/dmi.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+
+#include <asm/system.h>
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+static unsigned int margin = 60;        /* (secs) Default is 1 minute */
+static unsigned long wdt_status;
+static DEFINE_SPINLOCK(wdt_lock);
+
+#define WDT_IN_USE              0
+#define WDT_OK_TO_CLOSE         1
+
+#define COMMAND_PORT            0x4c
+#define DATA_PORT               0x48
+
+#define IFACE_ON_COMMAND        1
+#define REBOOT_COMMAND          2
+
+#define WATCHDOG_NAME           "SBC-FITPC2 Watchdog"
+
+static void wdt_send_data(unsigned char command, unsigned char data)
+{
+        outb(command, COMMAND_PORT);
+        mdelay(100);
+        outb(data, DATA_PORT);
+        mdelay(200);
+}
+
+static void wdt_enable(void)
+{
+        spin_lock(&wdt_lock);
+        wdt_send_data(IFACE_ON_COMMAND, 1);
+        wdt_send_data(REBOOT_COMMAND, margin);
+        spin_unlock(&wdt_lock);
+}
+
+static void wdt_disable(void)
+{
+        spin_lock(&wdt_lock);
+        wdt_send_data(IFACE_ON_COMMAND, 0);
+        wdt_send_data(REBOOT_COMMAND, 0);
+        spin_unlock(&wdt_lock);
+}
+
+static int fitpc2_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(WDT_IN_USE, &wdt_status))
+                return -EBUSY;
+
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        wdt_enable();
+
+        return nonseekable_open(inode, file);
+}
+
+static ssize_t fitpc2_wdt_write(struct file *file, const char *data,
+                                                size_t len, loff_t *ppos)
+{
+        size_t i;
+
+        if (!len)
+                return 0;
+
+        if (nowayout) {
+                len = 0;
+                goto out;
+        }
+
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        for (i = 0; i != len; i++) {
+                char c;
+
+                if (get_user(c, data + i))
+                        return -EFAULT;
+
+                if (c == 'V')
+                        set_bit(WDT_OK_TO_CLOSE, &wdt_status);
+        }
+
+out:
+        wdt_enable();
+
+        return len;
+}
+
+
+static struct watchdog_info ident = {
+        .options        = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
+                                WDIOF_KEEPALIVEPING,
+        .identity       = WATCHDOG_NAME,
+};
+
+
+static long fitpc2_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int ret = -ENOTTY;
+        int time;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user((struct watchdog_info *)arg, &ident,
+                                   sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+
+        case WDIOC_KEEPALIVE:
+                wdt_enable();
+                ret = 0;
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, (int *)arg);
+                if (ret)
+                        break;
+
+                if (time < 31 || time > 255) {
+                        ret = -EINVAL;
+                        break;
+                }
+
+                margin = time;
+                wdt_enable();
+                /* Fall through */
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(margin, (int *)arg);
+                break;
+        }
+
+        return ret;
+}
+
+static int fitpc2_wdt_release(struct inode *inode, struct file *file)
+{
+        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status)) {
+                wdt_disable();
+                pr_info("Device disabled\n");
+        } else {
+                pr_warning("Device closed unexpectedly -"
+                        " timer will not stop\n");
+                wdt_enable();
+        }
+
+        clear_bit(WDT_IN_USE, &wdt_status);
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        return 0;
+}
+
+
+static const struct file_operations fitpc2_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = fitpc2_wdt_write,
+        .unlocked_ioctl = fitpc2_wdt_ioctl,
+        .open           = fitpc2_wdt_open,
+        .release        = fitpc2_wdt_release,
+};
+
+static struct miscdevice fitpc2_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &fitpc2_wdt_fops,
+};
+
+static int __init fitpc2_wdt_init(void)
+{
+        int err;
+
+        if (strcmp("SBC-FITPC2", dmi_get_system_info(DMI_BOARD_NAME))) {
+                pr_info("board name is: %s. Should be SBC-FITPC2\n",
+                        dmi_get_system_info(DMI_BOARD_NAME));
+                return -ENODEV;
+        }
+
+        if (!request_region(COMMAND_PORT, 1, WATCHDOG_NAME)) {
+                pr_err("I/O address 0x%04x already in use\n", COMMAND_PORT);
+                return -EIO;
+        }
+
+        if (!request_region(DATA_PORT, 1, WATCHDOG_NAME)) {
+                pr_err("I/O address 0x%04x already in use\n", DATA_PORT);
+                err = -EIO;
+                goto err_data_port;
+        }
+
+        if (margin < 31 || margin > 255) {
+                pr_err("margin must be in range 31 - 255"
+                       " seconds, you tried to set %d\n", margin);
+                err = -EINVAL;
+                goto err_margin;
+        }
+
+        err = misc_register(&fitpc2_wdt_miscdev);
+        if (!err) {
+                pr_err("cannot register miscdev on minor=%d (err=%d)\n",
+                                                        WATCHDOG_MINOR, err);
+                goto err_margin;
+        }
+
+        return 0;
+
+err_margin:
+        release_region(DATA_PORT, 1);
+err_data_port:
+        release_region(COMMAND_PORT, 1);
+
+        return err;
+}
+
+static void __exit fitpc2_wdt_exit(void)
+{
+        misc_deregister(&fitpc2_wdt_miscdev);
+        release_region(DATA_PORT, 1);
+        release_region(COMMAND_PORT, 1);
+}
+
+module_init(fitpc2_wdt_init);
+module_exit(fitpc2_wdt_exit);
+
+MODULE_AUTHOR("Denis Turischev <denis@compulab.co.il>");
+MODULE_DESCRIPTION("SBC-FITPC2 Watchdog");
+
+module_param(margin, int, 0);
+MODULE_PARM_DESC(margin, "Watchdog margin in seconds (default 60s)");
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started");
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
diff --git a/drivers/watchdog/sc1200wdt.c b/drivers/watchdog/sc1200wdt.c
index b5e19c1820a2..c01daca8405a 100644
--- a/drivers/watchdog/sc1200wdt.c
+++ b/drivers/watchdog/sc1200wdt.c
@@ -197,7 +197,7 @@ static long sc1200wdt_ioctl(struct file *file, unsigned int cmd,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user(argp, &ident, sizeof ident))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
                 return 0;
 
diff --git a/drivers/watchdog/wdt_pci.c b/drivers/watchdog/wdt_pci.c
index 7a1bdc7c95a9..f368dd87083a 100644
--- a/drivers/watchdog/wdt_pci.c
+++ b/drivers/watchdog/wdt_pci.c
@@ -80,7 +80,7 @@ static unsigned long open_lock;
 static DEFINE_SPINLOCK(wdtpci_lock);
 static char expect_close;
 
-static int io;
+static resource_size_t io;
 static int irq;
 
 /* Default timeout */
@@ -647,14 +647,15 @@ static int __devinit wdtpci_init_one(struct pci_dev *dev,
                 goto out_pci;
         }
 
-        irq = dev->irq;
-        io = pci_resource_start(dev, 2);
-
-        if (request_region(io, 16, "wdt_pci") == NULL) {
-                printk(KERN_ERR PFX "I/O address 0x%04x already in use\n", io);
+        if (pci_request_region(dev, 2, "wdt_pci")) {
+                printk(KERN_ERR PFX "I/O address 0x%llx already in use\n",
+                        (unsigned long long)pci_resource_start(dev, 2));
                 goto out_pci;
         }
 
+        irq = dev->irq;
+        io = pci_resource_start(dev, 2);
+
         if (request_irq(irq, wdtpci_interrupt, IRQF_DISABLED | IRQF_SHARED,
                          "wdt_pci", &wdtpci_miscdev)) {
                 printk(KERN_ERR PFX "IRQ %d is not free\n", irq);
@@ -662,8 +663,8 @@ static int __devinit wdtpci_init_one(struct pci_dev *dev,
         }
 
         printk(KERN_INFO
-         "PCI-WDT500/501 (PCI-WDG-CSM) driver 0.10 at 0x%04x (Interrupt %d)\n",
-                                                                io, irq);
+         "PCI-WDT500/501 (PCI-WDG-CSM) driver 0.10 at 0x%llx (Interrupt %d)\n",
+                                        (unsigned long long)io, irq);
 
         /* Check that the heartbeat value is within its range;
            if not reset to the default */
@@ -717,7 +718,7 @@ out_rbt:
 out_irq:
         free_irq(irq, &wdtpci_miscdev);
 out_reg:
-        release_region(io, 16);
+        pci_release_region(dev, 2);
 out_pci:
         pci_disable_device(dev);
         goto out;
@@ -733,7 +734,7 @@ static void __devexit wdtpci_remove_one(struct pci_dev *pdev)
                 misc_deregister(&temp_miscdev);
         unregister_reboot_notifier(&wdtpci_notifier);
         free_irq(irq, &wdtpci_miscdev);
-        release_region(io, 16);
+        pci_release_region(pdev, 2);
         pci_disable_device(pdev);
         dev_count--;
 }
diff --git a/drivers/watchdog/wm831x_wdt.c b/drivers/watchdog/wm831x_wdt.c
new file mode 100644
index 000000000000..775bcd807f31
--- /dev/null
+++ b/drivers/watchdog/wm831x_wdt.c
@@ -0,0 +1,441 @@
+/*
+ * Watchdog driver for the wm831x PMICs
+ *
+ * Copyright (C) 2009 Wolfson Microelectronics
+ *
+ * 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
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/platform_device.h>
+#include <linux/watchdog.h>
+#include <linux/uaccess.h>
+#include <linux/gpio.h>
+
+#include <linux/mfd/wm831x/core.h>
+#include <linux/mfd/wm831x/pdata.h>
+#include <linux/mfd/wm831x/watchdog.h>
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+                 "Watchdog cannot be stopped once started (default="
+                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static unsigned long wm831x_wdt_users;
+static struct miscdevice wm831x_wdt_miscdev;
+static int wm831x_wdt_expect_close;
+static DEFINE_MUTEX(wdt_mutex);
+static struct wm831x *wm831x;
+static unsigned int update_gpio;
+static unsigned int update_state;
+
+/* We can't use the sub-second values here but they're included
+ * for completeness.  */
+static struct {
+        int time;  /* Seconds */
+        u16 val;   /* WDOG_TO value */
+} wm831x_wdt_cfgs[] = {
+        {  1, 2 },
+        {  2, 3 },
+        {  4, 4 },
+        {  8, 5 },
+        { 16, 6 },
+        { 32, 7 },
+        { 33, 7 },  /* Actually 32.768s so include both, others round down */
+};
+
+static int wm831x_wdt_set_timeout(struct wm831x *wm831x, u16 value)
+{
+        int ret;
+
+        mutex_lock(&wdt_mutex);
+
+        ret = wm831x_reg_unlock(wm831x);
+        if (ret == 0) {
+                ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
+                                      WM831X_WDOG_TO_MASK, value);
+                wm831x_reg_lock(wm831x);
+        } else {
+                dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
+                        ret);
+        }
+
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm831x_wdt_start(struct wm831x *wm831x)
+{
+        int ret;
+
+        mutex_lock(&wdt_mutex);
+
+        ret = wm831x_reg_unlock(wm831x);
+        if (ret == 0) {
+                ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
+                                      WM831X_WDOG_ENA, WM831X_WDOG_ENA);
+                wm831x_reg_lock(wm831x);
+        } else {
+                dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
+                        ret);
+        }
+
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm831x_wdt_stop(struct wm831x *wm831x)
+{
+        int ret;
+
+        mutex_lock(&wdt_mutex);
+
+        ret = wm831x_reg_unlock(wm831x);
+        if (ret == 0) {
+                ret = wm831x_set_bits(wm831x, WM831X_WATCHDOG,
+                                      WM831X_WDOG_ENA, 0);
+                wm831x_reg_lock(wm831x);
+        } else {
+                dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
+                        ret);
+        }
+
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm831x_wdt_kick(struct wm831x *wm831x)
+{
+        int ret;
+        u16 reg;
+
+        mutex_lock(&wdt_mutex);
+
+        if (update_gpio) {
+                gpio_set_value_cansleep(update_gpio, update_state);
+                update_state = !update_state;
+                ret = 0;
+                goto out;
+        }
+
+
+        reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
+
+        if (!(reg & WM831X_WDOG_RST_SRC)) {
+                dev_err(wm831x->dev, "Hardware watchdog update unsupported\n");
+                ret = -EINVAL;
+                goto out;
+        }
+
+        reg |= WM831X_WDOG_RESET;
+
+        ret = wm831x_reg_unlock(wm831x);
+        if (ret == 0) {
+                ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
+                wm831x_reg_lock(wm831x);
+        } else {
+                dev_err(wm831x->dev, "Failed to unlock security key: %d\n",
+                        ret);
+        }
+
+out:
+        mutex_unlock(&wdt_mutex);
+
+        return ret;
+}
+
+static int wm831x_wdt_open(struct inode *inode, struct file *file)
+{
+        int ret;
+
+        if (!wm831x)
+                return -ENODEV;
+
+        if (test_and_set_bit(0, &wm831x_wdt_users))
+                return -EBUSY;
+
+        ret = wm831x_wdt_start(wm831x);
+        if (ret != 0)
+                return ret;
+
+        return nonseekable_open(inode, file);
+}
+
+static int wm831x_wdt_release(struct inode *inode, struct file *file)
+{
+        if (wm831x_wdt_expect_close)
+                wm831x_wdt_stop(wm831x);
+        else {
+                dev_warn(wm831x->dev, "Watchdog device closed uncleanly\n");
+                wm831x_wdt_kick(wm831x);
+        }
+
+        clear_bit(0, &wm831x_wdt_users);
+
+        return 0;
+}
+
+static ssize_t wm831x_wdt_write(struct file *file,
+                                const char __user *data, size_t count,
+                                loff_t *ppos)
+{
+        size_t i;
+
+        if (count) {
+                wm831x_wdt_kick(wm831x);
+
+                if (!nowayout) {
+                        /* In case it was set long ago */
+                        wm831x_wdt_expect_close = 0;
+
+                        /* scan to see whether or not we got the magic
+                           character */
+                        for (i = 0; i != count; i++) {
+                                char c;
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        wm831x_wdt_expect_close = 42;
+                        }
+                }
+        }
+        return count;
+}
+
+static struct watchdog_info ident = {
+        .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
+        .identity = "WM831x Watchdog",
+};
+
+static long wm831x_wdt_ioctl(struct file *file, unsigned int cmd,
+                             unsigned long arg)
+{
+        int ret = -ENOTTY, time, i;
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        u16 reg;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(0, p);
+                break;
+
+        case WDIOC_SETOPTIONS:
+        {
+                int options;
+
+                if (get_user(options, p))
+                        return -EFAULT;
+
+                ret = -EINVAL;
+
+                /* Setting both simultaneously means at least one must fail */
+                if (options == WDIOS_DISABLECARD)
+                        ret = wm831x_wdt_start(wm831x);
+
+                if (options == WDIOS_ENABLECARD)
+                        ret = wm831x_wdt_stop(wm831x);
+                break;
+        }
+
+        case WDIOC_KEEPALIVE:
+                ret = wm831x_wdt_kick(wm831x);
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, p);
+                if (ret)
+                        break;
+
+                if (time == 0) {
+                        if (nowayout)
+                                ret = -EINVAL;
+                        else
+                                wm831x_wdt_stop(wm831x);
+                        break;
+                }
+
+                for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
+                        if (wm831x_wdt_cfgs[i].time == time)
+                                break;
+                if (i == ARRAY_SIZE(wm831x_wdt_cfgs))
+                        ret = -EINVAL;
+                else
+                        ret = wm831x_wdt_set_timeout(wm831x,
+                                                     wm831x_wdt_cfgs[i].val);
+                break;
+
+        case WDIOC_GETTIMEOUT:
+                reg = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
+                reg &= WM831X_WDOG_TO_MASK;
+                for (i = 0; i < ARRAY_SIZE(wm831x_wdt_cfgs); i++)
+                        if (wm831x_wdt_cfgs[i].val == reg)
+                                break;
+                if (i == ARRAY_SIZE(wm831x_wdt_cfgs)) {
+                        dev_warn(wm831x->dev,
+                                 "Unknown watchdog configuration: %x\n", reg);
+                        ret = -EINVAL;
+                } else
+                        ret = put_user(wm831x_wdt_cfgs[i].time, p);
+
+        }
+
+        return ret;
+}
+
+static const struct file_operations wm831x_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = wm831x_wdt_write,
+        .unlocked_ioctl = wm831x_wdt_ioctl,
+        .open = wm831x_wdt_open,
+        .release = wm831x_wdt_release,
+};
+
+static struct miscdevice wm831x_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &wm831x_wdt_fops,
+};
+
+static int __devinit wm831x_wdt_probe(struct platform_device *pdev)
+{
+        struct wm831x_pdata *chip_pdata;
+        struct wm831x_watchdog_pdata *pdata;
+        int reg, ret;
+
+        wm831x = dev_get_drvdata(pdev->dev.parent);
+
+        ret = wm831x_reg_read(wm831x, WM831X_WATCHDOG);
+        if (ret < 0) {
+                dev_err(wm831x->dev, "Failed to read watchdog status: %d\n",
+                        ret);
+                goto err;
+        }
+        reg = ret;
+
+        if (reg & WM831X_WDOG_DEBUG)
+                dev_warn(wm831x->dev, "Watchdog is paused\n");
+
+        /* Apply any configuration */
+        if (pdev->dev.parent->platform_data) {
+                chip_pdata = pdev->dev.parent->platform_data;
+                pdata = chip_pdata->watchdog;
+        } else {
+                pdata = NULL;
+        }
+
+        if (pdata) {
+                reg &= ~(WM831X_WDOG_SECACT_MASK | WM831X_WDOG_PRIMACT_MASK |
+                         WM831X_WDOG_RST_SRC);
+
+                reg |= pdata->primary << WM831X_WDOG_PRIMACT_SHIFT;
+                reg |= pdata->secondary << WM831X_WDOG_SECACT_SHIFT;
+                reg |= pdata->software << WM831X_WDOG_RST_SRC_SHIFT;
+
+                if (pdata->update_gpio) {
+                        ret = gpio_request(pdata->update_gpio,
+                                           "Watchdog update");
+                        if (ret < 0) {
+                                dev_err(wm831x->dev,
+                                        "Failed to request update GPIO: %d\n",
+                                        ret);
+                                goto err;
+                        }
+
+                        ret = gpio_direction_output(pdata->update_gpio, 0);
+                        if (ret != 0) {
+                                dev_err(wm831x->dev,
+                                        "gpio_direction_output returned: %d\n",
+                                        ret);
+                                goto err_gpio;
+                        }
+
+                        update_gpio = pdata->update_gpio;
+
+                        /* Make sure the watchdog takes hardware updates */
+                        reg |= WM831X_WDOG_RST_SRC;
+                }
+
+                ret = wm831x_reg_unlock(wm831x);
+                if (ret == 0) {
+                        ret = wm831x_reg_write(wm831x, WM831X_WATCHDOG, reg);
+                        wm831x_reg_lock(wm831x);
+                } else {
+                        dev_err(wm831x->dev,
+                                "Failed to unlock security key: %d\n", ret);
+                        goto err_gpio;
+                }
+        }
+
+        wm831x_wdt_miscdev.parent = &pdev->dev;
+
+        ret = misc_register(&wm831x_wdt_miscdev);
+        if (ret != 0) {
+                dev_err(wm831x->dev, "Failed to register miscdev: %d\n", ret);
+                goto err_gpio;
+        }
+
+        return 0;
+
+err_gpio:
+        if (update_gpio) {
+                gpio_free(update_gpio);
+                update_gpio = 0;
+        }
+err:
+        return ret;
+}
+
+static int __devexit wm831x_wdt_remove(struct platform_device *pdev)
+{
+        if (update_gpio) {
+                gpio_free(update_gpio);
+                update_gpio = 0;
+        }
+
+        misc_deregister(&wm831x_wdt_miscdev);
+
+        return 0;
+}
+
+static struct platform_driver wm831x_wdt_driver = {
+        .probe = wm831x_wdt_probe,
+        .remove = __devexit_p(wm831x_wdt_remove),
+        .driver = {
+                .name = "wm831x-watchdog",
+        },
+};
+
+static int __init wm831x_wdt_init(void)
+{
+        return platform_driver_register(&wm831x_wdt_driver);
+}
+module_init(wm831x_wdt_init);
+
+static void __exit wm831x_wdt_exit(void)
+{
+        platform_driver_unregister(&wm831x_wdt_driver);
+}
+module_exit(wm831x_wdt_exit);
+
+MODULE_AUTHOR("Mark Brown");
+MODULE_DESCRIPTION("WM831x Watchdog");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:wm831x-watchdog");
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index af031950f9b1..79bedba44fee 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -38,7 +38,6 @@
 #include <linux/string.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
-#include <linux/errno.h>
 #include <linux/miscdevice.h>
 #include <linux/major.h>
 #include <linux/proc_fs.h>