Merge branch 'core/percpu' into perfcounters/core

Conflicts:
	arch/x86/include/asm/pda.h

We merge tip/core/percpu into tip/perfcounters/core because of a
semantic and contextual conflict: the former eliminates the PDA,
while the latter extends it with apic_perf_irqs field.

Resolve the conflict by moving the new field to the irq_cpustat
structure on 64-bit too.

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

128 files changed, 4342 insertions, 913 deletions

diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 0eae9b45355..5a4aad123c4 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -1013,9 +1013,12 @@ next_sg:
                 qc->cursg_ofs = 0;
         }
 
-        /* consumed can be larger than count only for the last transfer */
-        WARN_ON_ONCE(qc->cursg && count != consumed);
-
+        /*
+         * There used to be a  WARN_ON_ONCE(qc->cursg && count != consumed);
+         * Unfortunately __atapi_pio_bytes doesn't know enough to do the WARN
+         * check correctly as it doesn't know if it is the last request being
+         * made. Somebody should implement a proper sanity check.
+         */
         if (bytes)
                 goto next_sg;
         return 0;
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index f828a29d775..f1bb2f9fecb 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -80,7 +80,7 @@
 
 
 #define DRV_NAME "pata_it821x"
-#define DRV_VERSION "0.4.0"
+#define DRV_VERSION "0.4.2"
 
 struct it821x_dev
 {
@@ -494,8 +494,6 @@ static int it821x_smart_set_mode(struct ata_link *link, struct ata_device **unus
  *      special. In our case we need to lock the sector count to avoid
  *      blowing the brains out of the firmware with large LBA48 requests
  *
- *      FIXME: When FUA appears we need to block FUA too. And SMART and
- *      basically we need to filter commands for this chip.
  */
 
 static void it821x_dev_config(struct ata_device *adev)
@@ -890,6 +888,13 @@ static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 .flags = ATA_FLAG_SLAVE_POSS,
                 .pio_mask = 0x1f,
                 .mwdma_mask = 0x07,
+                .udma_mask = ATA_UDMA6,
+                .port_ops = &it821x_rdc_port_ops
+        };
+        static const struct ata_port_info info_rdc_11 = {
+                .flags = ATA_FLAG_SLAVE_POSS,
+                .pio_mask = 0x1f,
+                .mwdma_mask = 0x07,
                 /* No UDMA */
                 .port_ops = &it821x_rdc_port_ops
         };
@@ -903,7 +908,11 @@ static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 return rc;
                 
         if (pdev->vendor == PCI_VENDOR_ID_RDC) {
-                ppi[0] = &info_rdc;
+                /* Deal with Vortex86SX */
+                if (pdev->revision == 0x11)
+                        ppi[0] = &info_rdc_11;
+                else
+                        ppi[0] = &info_rdc;
         } else {
                 /* Force the card into bypass mode if so requested */
                 if (it8212_noraid) {
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 719ee5c1c8d..5b257a57bc5 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -107,7 +107,7 @@ static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
 /*
  * Print cpu online, possible, present, and system maps
  */
-static ssize_t print_cpus_map(char *buf, cpumask_t *map)
+static ssize_t print_cpus_map(char *buf, const struct cpumask *map)
 {
         int n = cpulist_scnprintf(buf, PAGE_SIZE-2, map);
 
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index a778fb52b11..bf6b13206d0 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -31,7 +31,10 @@
 #include <linux/hardirq.h>
 #include <linux/topology.h>
 
-#define define_one_ro(_name)            \
+#define define_one_ro_named(_name, _func)                               \
+static SYSDEV_ATTR(_name, 0444, _func, NULL)
+
+#define define_one_ro(_name)                            \
 static SYSDEV_ATTR(_name, 0444, show_##_name, NULL)
 
 #define define_id_show_func(name)                               \
@@ -42,8 +45,8 @@ static ssize_t show_##name(struct sys_device *dev,		\
         return sprintf(buf, "%d\n", topology_##name(cpu));      \
 }
 
-#if defined(topology_thread_siblings) || defined(topology_core_siblings)
-static ssize_t show_cpumap(int type, cpumask_t *mask, char *buf)
+#if defined(topology_thread_cpumask) || defined(topology_core_cpumask)
+static ssize_t show_cpumap(int type, const struct cpumask *mask, char *buf)
 {
         ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
         int n = 0;
@@ -65,7 +68,7 @@ static ssize_t show_##name(struct sys_device *dev,			\
                            struct sysdev_attribute *attr, char *buf)    \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
-        return show_cpumap(0, &(topology_##name(cpu)), buf);            \
+        return show_cpumap(0, topology_##name(cpu), buf);               \
 }
 
 #define define_siblings_show_list(name)                                 \
@@ -74,7 +77,7 @@ static ssize_t show_##name##_list(struct sys_device *dev,		\
                                   char *buf)                            \
 {                                                                       \
         unsigned int cpu = dev->id;                                     \
-        return show_cpumap(1, &(topology_##name(cpu)), buf);            \
+        return show_cpumap(1, topology_##name(cpu), buf);               \
 }
 
 #else
@@ -82,9 +85,7 @@ static ssize_t show_##name##_list(struct sys_device *dev,		\
 static ssize_t show_##name(struct sys_device *dev,                      \
                            struct sysdev_attribute *attr, char *buf)    \
 {                                                                       \
-        unsigned int cpu = dev->id;                                     \
-        cpumask_t mask = topology_##name(cpu);                          \
-        return show_cpumap(0, &mask, buf);                              \
+        return show_cpumap(0, topology_##name(dev->id), buf);           \
 }
 
 #define define_siblings_show_list(name)                                 \
@@ -92,9 +93,7 @@ static ssize_t show_##name##_list(struct sys_device *dev,		\
                                   struct sysdev_attribute *attr,        \
                                   char *buf)                            \
 {                                                                       \
-        unsigned int cpu = dev->id;                                     \
-        cpumask_t mask = topology_##name(cpu);                          \
-        return show_cpumap(1, &mask, buf);                              \
+        return show_cpumap(1, topology_##name(dev->id), buf);           \
 }
 #endif
 
@@ -107,13 +106,13 @@ define_one_ro(physical_package_id);
 define_id_show_func(core_id);
 define_one_ro(core_id);
 
-define_siblings_show_func(thread_siblings);
-define_one_ro(thread_siblings);
-define_one_ro(thread_siblings_list);
+define_siblings_show_func(thread_cpumask);
+define_one_ro_named(thread_siblings, show_thread_cpumask);
+define_one_ro_named(thread_siblings_list, show_thread_cpumask_list);
 
-define_siblings_show_func(core_siblings);
-define_one_ro(core_siblings);
-define_one_ro(core_siblings_list);
+define_siblings_show_func(core_cpumask);
+define_one_ro_named(core_siblings, show_core_cpumask);
+define_one_ro_named(core_siblings_list, show_core_cpumask_list);
 
 static struct attribute *default_attrs[] = {
         &attr_physical_package_id.attr,
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index 4b1d4ac960f..8df436ff706 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -156,7 +156,7 @@ static volatile int fdc_busy = -1;
 static volatile int fdc_nested;
 static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
  
-static DECLARE_WAIT_QUEUE_HEAD(motor_wait);
+static DECLARE_COMPLETION(motor_on_completion);
 
 static volatile int selected = -1;      /* currently selected drive */
 
@@ -184,8 +184,7 @@ static unsigned char mfmencode[16]={
 static unsigned char mfmdecode[128];
 
 /* floppy internal millisecond timer stuff */
-static volatile int ms_busy = -1;
-static DECLARE_WAIT_QUEUE_HEAD(ms_wait);
+static DECLARE_COMPLETION(ms_wait_completion);
 #define MS_TICKS ((amiga_eclock+50)/1000)
 
 /*
@@ -211,8 +210,7 @@ static int fd_device[4] = { 0, 0, 0, 0 };
 
 static irqreturn_t ms_isr(int irq, void *dummy)
 {
-        ms_busy = -1;
-        wake_up(&ms_wait);
+        complete(&ms_wait_completion);
         return IRQ_HANDLED;
 }
 
@@ -220,19 +218,17 @@ static irqreturn_t ms_isr(int irq, void *dummy)
    A more generic routine would do a schedule a la timer.device */
 static void ms_delay(int ms)
 {
-        unsigned long flags;
         int ticks;
+        static DEFINE_MUTEX(mutex);
+
         if (ms > 0) {
-                local_irq_save(flags);
-                while (ms_busy == 0)
-                        sleep_on(&ms_wait);
-                ms_busy = 0;
-                local_irq_restore(flags);
+                mutex_lock(&mutex);
                 ticks = MS_TICKS*ms-1;
                 ciaa.tblo=ticks%256;
                 ciaa.tbhi=ticks/256;
                 ciaa.crb=0x19; /*count eclock, force load, one-shoot, start */
-                sleep_on(&ms_wait);
+                wait_for_completion(&ms_wait_completion);
+                mutex_unlock(&mutex);
         }
 }
 
@@ -254,8 +250,7 @@ static void get_fdc(int drive)
         printk("get_fdc: drive %d  fdc_busy %d  fdc_nested %d\n",drive,fdc_busy,fdc_nested);
 #endif
         local_irq_save(flags);
-        while (!try_fdc(drive))
-                sleep_on(&fdc_wait);
+        wait_event(fdc_wait, try_fdc(drive));
         fdc_busy = drive;
         fdc_nested++;
         local_irq_restore(flags);
@@ -330,7 +325,7 @@ static void fd_deselect (int drive)
 static void motor_on_callback(unsigned long nr)
 {
         if (!(ciaa.pra & DSKRDY) || --on_attempts == 0) {
-                wake_up (&motor_wait);
+                complete_all(&motor_on_completion);
         } else {
                 motor_on_timer.expires = jiffies + HZ/10;
                 add_timer(&motor_on_timer);
@@ -347,11 +342,12 @@ static int fd_motor_on(int nr)
                 unit[nr].motor = 1;
                 fd_select(nr);
 
+                INIT_COMPLETION(motor_on_completion);
                 motor_on_timer.data = nr;
                 mod_timer(&motor_on_timer, jiffies + HZ/2);
 
                 on_attempts = 10;
-                sleep_on (&motor_wait);
+                wait_for_completion(&motor_on_completion);
                 fd_deselect(nr);
         }
 
@@ -582,8 +578,7 @@ static void raw_read(int drive)
 {
         drive&=3;
         get_fdc(drive);
-        while (block_flag)
-                sleep_on(&wait_fd_block);
+        wait_event(wait_fd_block, !block_flag);
         fd_select(drive);
         /* setup adkcon bits correctly */
         custom.adkcon = ADK_MSBSYNC;
@@ -598,8 +593,7 @@ static void raw_read(int drive)
 
         block_flag = 1;
 
-        while (block_flag)
-                sleep_on (&wait_fd_block);
+        wait_event(wait_fd_block, !block_flag);
 
         custom.dsklen = 0;
         fd_deselect(drive);
@@ -616,8 +610,7 @@ static int raw_write(int drive)
                 rel_fdc();
                 return 0;
         }
-        while (block_flag)
-                sleep_on(&wait_fd_block);
+        wait_event(wait_fd_block, !block_flag);
         fd_select(drive);
         /* clear adkcon bits */
         custom.adkcon = ADK_PRECOMP1|ADK_PRECOMP0|ADK_WORDSYNC|ADK_MSBSYNC;
@@ -1294,8 +1287,7 @@ static int non_int_flush_track (unsigned long nr)
                         writepending = 0;
                         return 0;
                 }
-                while (block_flag == 2)
-                        sleep_on (&wait_fd_block);
+                wait_event(wait_fd_block, block_flag != 2);
         }
         else {
                 local_irq_restore(flags);
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index 4e0cfdeab14..a58869ea851 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -1963,6 +1963,7 @@ static int __init rs_init(void)
 {
         unsigned long flags;
         struct serial_state * state;
+        int error;
 
         if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(AMI_SERIAL))
                 return -ENODEV;
@@ -1975,8 +1976,11 @@ static int __init rs_init(void)
          *  We request SERDAT and SERPER only, because the serial registers are
          *  too spreaded over the custom register space
          */
-        if (!request_mem_region(CUSTOM_PHYSADDR+0x30, 4, "amiserial [Paula]"))
-                return -EBUSY;
+        if (!request_mem_region(CUSTOM_PHYSADDR+0x30, 4,
+                                "amiserial [Paula]")) {
+                error = -EBUSY;
+                goto fail_put_tty_driver;
+        }
 
         IRQ_ports = NULL;
 
@@ -1997,8 +2001,9 @@ static int __init rs_init(void)
         serial_driver->flags = TTY_DRIVER_REAL_RAW;
         tty_set_operations(serial_driver, &serial_ops);
 
-        if (tty_register_driver(serial_driver))
-                panic("Couldn't register serial driver\n");
+        error = tty_register_driver(serial_driver);
+        if (error)
+                goto fail_release_mem_region;
 
         state = rs_table;
         state->magic = SSTATE_MAGIC;
@@ -2024,8 +2029,14 @@ static int __init rs_init(void)
         local_irq_save(flags);
 
         /* set ISRs, and then disable the rx interrupts */
-        request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state);
-        request_irq(IRQ_AMIGA_RBF, ser_rx_int, IRQF_DISABLED, "serial RX", state);
+        error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state);
+        if (error)
+                goto fail_unregister;
+
+        error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, IRQF_DISABLED,
+                            "serial RX", state);
+        if (error)
+                goto fail_free_irq;
 
         /* turn off Rx and Tx interrupts */
         custom.intena = IF_RBF | IF_TBE;
@@ -2045,6 +2056,16 @@ static int __init rs_init(void)
         ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR);  /* inputs */
 
         return 0;
+
+fail_free_irq:
+        free_irq(IRQ_AMIGA_TBE, state);
+fail_unregister:
+        tty_unregister_driver(serial_driver);
+fail_release_mem_region:
+        release_mem_region(CUSTOM_PHYSADDR+0x30, 4);
+fail_put_tty_driver:
+        put_tty_driver(serial_driver);
+        return error;
 }
 
 static __exit void rs_exit(void) 
@@ -2064,6 +2085,9 @@ static __exit void rs_exit(void)
           kfree(info);
         }
 
+        free_irq(IRQ_AMIGA_TBE, rs_table);
+        free_irq(IRQ_AMIGA_RBF, rs_table);
+
         release_mem_region(CUSTOM_PHYSADDR+0x30, 4);
 }
 
diff --git a/drivers/char/pty.c b/drivers/char/pty.c
index 146c97613da..31038a0052a 100644
--- a/drivers/char/pty.c
+++ b/drivers/char/pty.c
@@ -230,9 +230,7 @@ static void pty_set_termios(struct tty_struct *tty,
 /**
  *      pty_do_resize           -       resize event
  *      @tty: tty being resized
- *      @real_tty: real tty (not the same as tty if using a pty/tty pair)
- *      @rows: rows (character)
- *      @cols: cols (character)
+ *      @ws: window size being set.
  *
  *      Update the termios variables and send the neccessary signals to
  *      peform a terminal resize correctly
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 33872a219df..33a2b531802 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -718,6 +718,7 @@ static int __init a2232board_init(void)
         u_char *from;
         volatile u_char *to;
         volatile struct a2232memory *mem;
+        int error, i;
 
 #ifdef CONFIG_SMP
         return -ENODEV; /* This driver is not SMP aware. Is there an SMP ZorroII-bus-machine? */
@@ -797,8 +798,15 @@ static int __init a2232board_init(void)
         */
         if (a2232_init_drivers()) return -ENODEV; // maybe we should use a different -Exxx?
 
-        request_irq(IRQ_AMIGA_VERTB, a2232_vbl_inter, 0, "A2232 serial VBL", a2232_driver_ID);
-        return 0;
+        error = request_irq(IRQ_AMIGA_VERTB, a2232_vbl_inter, 0,
+                            "A2232 serial VBL", a2232_driver_ID);
+        if (error) {
+                for (i = 0; i < nr_a2232; i++)
+                        zorro_release_device(zd_a2232[i]);
+                tty_unregister_driver(a2232_driver);
+                put_tty_driver(a2232_driver);
+        }
+        return error;
 }
 
 static void __exit a2232board_exit(void)
diff --git a/drivers/char/vme_scc.c b/drivers/char/vme_scc.c
index 0e8234bd0e1..994e1a58b98 100644
--- a/drivers/char/vme_scc.c
+++ b/drivers/char/vme_scc.c
@@ -198,6 +198,7 @@ static void scc_init_portstructs(void)
 static int mvme147_scc_init(void)
 {
         struct scc_port *port;
+        int error;
 
         printk(KERN_INFO "SCC: MVME147 Serial Driver\n");
         /* Init channel A */
@@ -207,14 +208,23 @@ static int mvme147_scc_init(void)
         port->datap = port->ctrlp + 1;
         port->port_a = &scc_ports[0];
         port->port_b = &scc_ports[1];
-        request_irq(MVME147_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED,
+        error = request_irq(MVME147_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED,
                             "SCC-A TX", port);
-        request_irq(MVME147_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED,
+        if (error)
+                goto fail;
+        error = request_irq(MVME147_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED,
                             "SCC-A status", port);
-        request_irq(MVME147_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_a_tx;
+        error = request_irq(MVME147_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED,
                             "SCC-A RX", port);
-        request_irq(MVME147_IRQ_SCCA_SPCOND, scc_spcond_int, IRQF_DISABLED,
-                            "SCC-A special cond", port);
+        if (error)
+                goto fail_free_a_stat;
+        error = request_irq(MVME147_IRQ_SCCA_SPCOND, scc_spcond_int,
+                            IRQF_DISABLED, "SCC-A special cond", port);
+        if (error)
+                goto fail_free_a_rx;
+
         {
                 SCC_ACCESS_INIT(port);
 
@@ -234,14 +244,23 @@ static int mvme147_scc_init(void)
         port->datap = port->ctrlp + 1;
         port->port_a = &scc_ports[0];
         port->port_b = &scc_ports[1];
-        request_irq(MVME147_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED,
+        error = request_irq(MVME147_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED,
                             "SCC-B TX", port);
-        request_irq(MVME147_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_a_spcond;
+        error = request_irq(MVME147_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED,
                             "SCC-B status", port);
-        request_irq(MVME147_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_b_tx;
+        error = request_irq(MVME147_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED,
                             "SCC-B RX", port);
-        request_irq(MVME147_IRQ_SCCB_SPCOND, scc_spcond_int, IRQF_DISABLED,
-                            "SCC-B special cond", port);
+        if (error)
+                goto fail_free_b_stat;
+        error = request_irq(MVME147_IRQ_SCCB_SPCOND, scc_spcond_int,
+                            IRQF_DISABLED, "SCC-B special cond", port);
+        if (error)
+                goto fail_free_b_rx;
+
         {
                 SCC_ACCESS_INIT(port);
 
@@ -257,6 +276,23 @@ static int mvme147_scc_init(void)
         scc_init_drivers();
 
         return 0;
+
+fail_free_b_rx:
+        free_irq(MVME147_IRQ_SCCB_RX, port);
+fail_free_b_stat:
+        free_irq(MVME147_IRQ_SCCB_STAT, port);
+fail_free_b_tx:
+        free_irq(MVME147_IRQ_SCCB_TX, port);
+fail_free_a_spcond:
+        free_irq(MVME147_IRQ_SCCA_SPCOND, port);
+fail_free_a_rx:
+        free_irq(MVME147_IRQ_SCCA_RX, port);
+fail_free_a_stat:
+        free_irq(MVME147_IRQ_SCCA_STAT, port);
+fail_free_a_tx:
+        free_irq(MVME147_IRQ_SCCA_TX, port);
+fail:
+        return error;
 }
 #endif
 
@@ -265,6 +301,7 @@ static int mvme147_scc_init(void)
 static int mvme162_scc_init(void)
 {
         struct scc_port *port;
+        int error;
 
         if (!(mvme16x_config & MVME16x_CONFIG_GOT_SCCA))
                 return (-ENODEV);
@@ -277,14 +314,23 @@ static int mvme162_scc_init(void)
         port->datap = port->ctrlp + 2;
         port->port_a = &scc_ports[0];
         port->port_b = &scc_ports[1];
-        request_irq(MVME162_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED,
+        error = request_irq(MVME162_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED,
                             "SCC-A TX", port);
-        request_irq(MVME162_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED,
+        if (error)
+                goto fail;
+        error = request_irq(MVME162_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED,
                             "SCC-A status", port);
-        request_irq(MVME162_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_a_tx;
+        error = request_irq(MVME162_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED,
                             "SCC-A RX", port);
-        request_irq(MVME162_IRQ_SCCA_SPCOND, scc_spcond_int, IRQF_DISABLED,
-                            "SCC-A special cond", port);
+        if (error)
+                goto fail_free_a_stat;
+        error = request_irq(MVME162_IRQ_SCCA_SPCOND, scc_spcond_int,
+                            IRQF_DISABLED, "SCC-A special cond", port);
+        if (error)
+                goto fail_free_a_rx;
+
         {
                 SCC_ACCESS_INIT(port);
 
@@ -304,14 +350,22 @@ static int mvme162_scc_init(void)
         port->datap = port->ctrlp + 2;
         port->port_a = &scc_ports[0];
         port->port_b = &scc_ports[1];
-        request_irq(MVME162_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED,
+        error = request_irq(MVME162_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED,
                             "SCC-B TX", port);
-        request_irq(MVME162_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_a_spcond;
+        error = request_irq(MVME162_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED,
                             "SCC-B status", port);
-        request_irq(MVME162_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_b_tx;
+        error = request_irq(MVME162_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED,
                             "SCC-B RX", port);
-        request_irq(MVME162_IRQ_SCCB_SPCOND, scc_spcond_int, IRQF_DISABLED,
-                            "SCC-B special cond", port);
+        if (error)
+                goto fail_free_b_stat;
+        error = request_irq(MVME162_IRQ_SCCB_SPCOND, scc_spcond_int,
+                            IRQF_DISABLED, "SCC-B special cond", port);
+        if (error)
+                goto fail_free_b_rx;
 
         {
                 SCC_ACCESS_INIT(port);  /* Either channel will do */
@@ -328,6 +382,23 @@ static int mvme162_scc_init(void)
         scc_init_drivers();
 
         return 0;
+
+fail_free_b_rx:
+        free_irq(MVME162_IRQ_SCCB_RX, port);
+fail_free_b_stat:
+        free_irq(MVME162_IRQ_SCCB_STAT, port);
+fail_free_b_tx:
+        free_irq(MVME162_IRQ_SCCB_TX, port);
+fail_free_a_spcond:
+        free_irq(MVME162_IRQ_SCCA_SPCOND, port);
+fail_free_a_rx:
+        free_irq(MVME162_IRQ_SCCA_RX, port);
+fail_free_a_stat:
+        free_irq(MVME162_IRQ_SCCA_STAT, port);
+fail_free_a_tx:
+        free_irq(MVME162_IRQ_SCCA_TX, port);
+fail:
+        return error;
 }
 #endif
 
@@ -336,6 +407,7 @@ static int mvme162_scc_init(void)
 static int bvme6000_scc_init(void)
 {
         struct scc_port *port;
+        int error;
 
         printk(KERN_INFO "SCC: BVME6000 Serial Driver\n");
         /* Init channel A */
@@ -345,14 +417,23 @@ static int bvme6000_scc_init(void)
         port->datap = port->ctrlp + 4;
         port->port_a = &scc_ports[0];
         port->port_b = &scc_ports[1];
-        request_irq(BVME_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED,
+        error = request_irq(BVME_IRQ_SCCA_TX, scc_tx_int, IRQF_DISABLED,
                             "SCC-A TX", port);
-        request_irq(BVME_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED,
+        if (error)
+                goto fail;
+        error = request_irq(BVME_IRQ_SCCA_STAT, scc_stat_int, IRQF_DISABLED,
                             "SCC-A status", port);
-        request_irq(BVME_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_a_tx;
+        error = request_irq(BVME_IRQ_SCCA_RX, scc_rx_int, IRQF_DISABLED,
                             "SCC-A RX", port);
-        request_irq(BVME_IRQ_SCCA_SPCOND, scc_spcond_int, IRQF_DISABLED,
-                            "SCC-A special cond", port);
+        if (error)
+                goto fail_free_a_stat;
+        error = request_irq(BVME_IRQ_SCCA_SPCOND, scc_spcond_int,
+                            IRQF_DISABLED, "SCC-A special cond", port);
+        if (error)
+                goto fail_free_a_rx;
+
         {
                 SCC_ACCESS_INIT(port);
 
@@ -372,14 +453,22 @@ static int bvme6000_scc_init(void)
         port->datap = port->ctrlp + 4;
         port->port_a = &scc_ports[0];
         port->port_b = &scc_ports[1];
-        request_irq(BVME_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED,
+        error = request_irq(BVME_IRQ_SCCB_TX, scc_tx_int, IRQF_DISABLED,
                             "SCC-B TX", port);
-        request_irq(BVME_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_a_spcond;
+        error = request_irq(BVME_IRQ_SCCB_STAT, scc_stat_int, IRQF_DISABLED,
                             "SCC-B status", port);
-        request_irq(BVME_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED,
+        if (error)
+                goto fail_free_b_tx;
+        error = request_irq(BVME_IRQ_SCCB_RX, scc_rx_int, IRQF_DISABLED,
                             "SCC-B RX", port);
-        request_irq(BVME_IRQ_SCCB_SPCOND, scc_spcond_int, IRQF_DISABLED,
-                            "SCC-B special cond", port);
+        if (error)
+                goto fail_free_b_stat;
+        error = request_irq(BVME_IRQ_SCCB_SPCOND, scc_spcond_int,
+                            IRQF_DISABLED, "SCC-B special cond", port);
+        if (error)
+                goto fail_free_b_rx;
 
         {
                 SCC_ACCESS_INIT(port);  /* Either channel will do */
@@ -393,6 +482,23 @@ static int bvme6000_scc_init(void)
         scc_init_drivers();
 
         return 0;
+
+fail:
+        free_irq(BVME_IRQ_SCCA_STAT, port);
+fail_free_a_tx:
+        free_irq(BVME_IRQ_SCCA_RX, port);
+fail_free_a_stat:
+        free_irq(BVME_IRQ_SCCA_SPCOND, port);
+fail_free_a_rx:
+        free_irq(BVME_IRQ_SCCB_TX, port);
+fail_free_a_spcond:
+        free_irq(BVME_IRQ_SCCB_STAT, port);
+fail_free_b_tx:
+        free_irq(BVME_IRQ_SCCB_RX, port);
+fail_free_b_stat:
+        free_irq(BVME_IRQ_SCCB_SPCOND, port);
+fail_free_b_rx:
+        return error;
 }
 #endif
 
diff --git a/drivers/dio/dio-sysfs.c b/drivers/dio/dio-sysfs.c
index f4646303884..ee1a3b59bd4 100644
--- a/drivers/dio/dio-sysfs.c
+++ b/drivers/dio/dio-sysfs.c
@@ -58,20 +58,25 @@ static ssize_t dio_show_resource(struct device *dev, struct device_attribute *at
         struct dio_dev *d = to_dio_dev(dev);
 
         return sprintf(buf, "0x%08lx 0x%08lx 0x%08lx\n",
-                       dio_resource_start(d), dio_resource_end(d),
+                       (unsigned long)dio_resource_start(d),
+                       (unsigned long)dio_resource_end(d),
                        dio_resource_flags(d));
 }
 static DEVICE_ATTR(resource, S_IRUGO, dio_show_resource, NULL);
 
-void dio_create_sysfs_dev_files(struct dio_dev *d)
+int dio_create_sysfs_dev_files(struct dio_dev *d)
 {
         struct device *dev = &d->dev;
+        int error;
 
         /* current configuration's attributes */
-        device_create_file(dev, &dev_attr_id);
-        device_create_file(dev, &dev_attr_ipl);
-        device_create_file(dev, &dev_attr_secid);
-        device_create_file(dev, &dev_attr_name);
-        device_create_file(dev, &dev_attr_resource);
+        if ((error = device_create_file(dev, &dev_attr_id)) ||
+            (error = device_create_file(dev, &dev_attr_ipl)) ||
+            (error = device_create_file(dev, &dev_attr_secid)) ||
+            (error = device_create_file(dev, &dev_attr_name)) ||
+            (error = device_create_file(dev, &dev_attr_resource)))
+                return error;
+
+        return 0;
 }
 
diff --git a/drivers/dio/dio.c b/drivers/dio/dio.c
index 07f274f853d..10c3c498358 100644
--- a/drivers/dio/dio.c
+++ b/drivers/dio/dio.c
@@ -173,6 +173,7 @@ static int __init dio_init(void)
         mm_segment_t fs;
         int i;
         struct dio_dev *dev;
+        int error;
 
         if (!MACH_IS_HP300)
                 return 0;
@@ -182,7 +183,11 @@ static int __init dio_init(void)
         /* Initialize the DIO bus */ 
         INIT_LIST_HEAD(&dio_bus.devices);
         strcpy(dio_bus.dev.bus_id, "dio");
-        device_register(&dio_bus.dev);
+        error = device_register(&dio_bus.dev);
+        if (error) {
+                pr_err("DIO: Error registering dio_bus\n");
+                return error;
+        }
 
         /* Request all resources */
         dio_bus.num_resources = (hp300_model == HP_320 ? 1 : 2);
@@ -252,8 +257,15 @@ static int __init dio_init(void)
 
                 if (scode >= DIOII_SCBASE)
                         iounmap(va);
-                device_register(&dev->dev);
-                dio_create_sysfs_dev_files(dev);
+                error = device_register(&dev->dev);
+                if (error) {
+                        pr_err("DIO: Error registering device %s\n",
+                               dev->name);
+                        continue;
+                }
+                error = dio_create_sysfs_dev_files(dev);
+                if (error)
+                        dev_err(&dev->dev, "Error creating sysfs files\n");
         }
         return 0;
 }
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index 777fba48d2d..3009e0171e5 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -244,7 +244,7 @@ static ssize_t host_control_on_shutdown_store(struct device *dev,
  */
 int dcdbas_smi_request(struct smi_cmd *smi_cmd)
 {
-        cpumask_t old_mask;
+        cpumask_var_t old_mask;
         int ret = 0;
 
         if (smi_cmd->magic != SMI_CMD_MAGIC) {
@@ -254,8 +254,11 @@ int dcdbas_smi_request(struct smi_cmd *smi_cmd)
         }
 
         /* SMI requires CPU 0 */
-        old_mask = current->cpus_allowed;
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(0));
+        if (!alloc_cpumask_var(&old_mask, GFP_KERNEL))
+                return -ENOMEM;
+
+        cpumask_copy(old_mask, &current->cpus_allowed);
+        set_cpus_allowed_ptr(current, cpumask_of(0));
         if (smp_processor_id() != 0) {
                 dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
                         __func__);
@@ -275,7 +278,8 @@ int dcdbas_smi_request(struct smi_cmd *smi_cmd)
         );
 
 out:
-        set_cpus_allowed_ptr(current, &old_mask);
+        set_cpus_allowed_ptr(current, old_mask);
+        free_cpumask_var(old_mask);
         return ret;
 }
 
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index 3b77b674cbf..c7b8a506af6 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -955,7 +955,7 @@ void ehca_poll_eqs(unsigned long data)
                         struct ehca_eq *eq = &shca->eq;
                         int max = 3;
                         volatile u64 q_ofs, q_ofs2;
-                        u64 flags;
+                        unsigned long flags;
                         spin_lock_irqsave(&eq->spinlock, flags);
                         q_ofs = eq->ipz_queue.current_q_offset;
                         spin_unlock_irqrestore(&eq->spinlock, flags);
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index dcefe1fceb5..61588bd273b 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -543,14 +543,21 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
 {
         static int mlx4_ib_version_printed;
         struct mlx4_ib_dev *ibdev;
+        int num_ports = 0;
         int i;
 
-
         if (!mlx4_ib_version_printed) {
                 printk(KERN_INFO "%s", mlx4_ib_version);
                 ++mlx4_ib_version_printed;
         }
 
+        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
+                num_ports++;
+
+        /* No point in registering a device with no ports... */
+        if (num_ports == 0)
+                return NULL;
+
         ibdev = (struct mlx4_ib_dev *) ib_alloc_device(sizeof *ibdev);
         if (!ibdev) {
                 dev_err(&dev->pdev->dev, "Device struct alloc failed\n");
@@ -574,9 +581,7 @@ static void *mlx4_ib_add(struct mlx4_dev *dev)
         ibdev->ib_dev.owner             = THIS_MODULE;
         ibdev->ib_dev.node_type         = RDMA_NODE_IB_CA;
         ibdev->ib_dev.local_dma_lkey    = dev->caps.reserved_lkey;
-        ibdev->num_ports = 0;
-        mlx4_foreach_port(i, dev, MLX4_PORT_TYPE_IB)
-                ibdev->num_ports++;
+        ibdev->num_ports                = num_ports;
         ibdev->ib_dev.phys_port_cnt     = ibdev->num_ports;
         ibdev->ib_dev.num_comp_vectors  = dev->caps.num_comp_vectors;
         ibdev->ib_dev.dma_device        = &dev->pdev->dev;
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index 6ba57e91d7a..a01b4488208 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -778,12 +778,13 @@ static struct nes_cm_node *find_node(struct nes_cm_core *cm_core,
         unsigned long flags;
         struct list_head *hte;
         struct nes_cm_node *cm_node;
+        __be32 tmp_addr = cpu_to_be32(loc_addr);
 
         /* get a handle on the hte */
         hte = &cm_core->connected_nodes;
 
         nes_debug(NES_DBG_CM, "Searching for an owner node: %pI4:%x from core %p->%p\n",
-                  &loc_addr, loc_port, cm_core, hte);
+                  &tmp_addr, loc_port, cm_core, hte);
 
         /* walk list and find cm_node associated with this session ID */
         spin_lock_irqsave(&cm_core->ht_lock, flags);
@@ -816,6 +817,7 @@ static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
 {
         unsigned long flags;
         struct nes_cm_listener *listen_node;
+        __be32 tmp_addr = cpu_to_be32(dst_addr);
 
         /* walk list and find cm_node associated with this session ID */
         spin_lock_irqsave(&cm_core->listen_list_lock, flags);
@@ -833,7 +835,7 @@ static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
         spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
 
         nes_debug(NES_DBG_CM, "Unable to find listener for %pI4:%x\n",
-                  &dst_addr, dst_port);
+                  &tmp_addr, dst_port);
 
         /* no listener */
         return NULL;
@@ -2059,6 +2061,7 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
         struct tcphdr *tcph;
         struct nes_cm_info nfo;
         int skb_handled = 1;
+        __be32 tmp_daddr, tmp_saddr;
 
         if (!skb)
                 return 0;
@@ -2074,8 +2077,11 @@ static int mini_cm_recv_pkt(struct nes_cm_core *cm_core,
         nfo.rem_addr = ntohl(iph->saddr);
         nfo.rem_port = ntohs(tcph->source);
 
+        tmp_daddr = cpu_to_be32(iph->daddr);
+        tmp_saddr = cpu_to_be32(iph->saddr);
+
         nes_debug(NES_DBG_CM, "Received packet: dest=%pI4:0x%04X src=%pI4:0x%04X\n",
-                  &iph->daddr, tcph->dest, &iph->saddr, tcph->source);
+                  &tmp_daddr, tcph->dest, &tmp_saddr, tcph->source);
 
         do {
                 cm_node = find_node(cm_core,
diff --git a/drivers/infiniband/hw/nes/nes_utils.c b/drivers/infiniband/hw/nes/nes_utils.c
index aa9b7348c72..6f3bc1b6bf2 100644
--- a/drivers/infiniband/hw/nes/nes_utils.c
+++ b/drivers/infiniband/hw/nes/nes_utils.c
@@ -655,6 +655,7 @@ int nes_arp_table(struct nes_device *nesdev, u32 ip_addr, u8 *mac_addr, u32 acti
         struct nes_adapter *nesadapter = nesdev->nesadapter;
         int arp_index;
         int err = 0;
+        __be32 tmp_addr;
 
         for (arp_index = 0; (u32) arp_index < nesadapter->arp_table_size; arp_index++) {
                 if (nesadapter->arp_table[arp_index].ip_addr == ip_addr)
@@ -682,8 +683,9 @@ int nes_arp_table(struct nes_device *nesdev, u32 ip_addr, u8 *mac_addr, u32 acti
 
         /* DELETE or RESOLVE */
         if (arp_index == nesadapter->arp_table_size) {
+                tmp_addr = cpu_to_be32(ip_addr);
                 nes_debug(NES_DBG_NETDEV, "MAC for %pI4 not in ARP table - cannot %s\n",
-                          &ip_addr, action == NES_ARP_RESOLVE ? "resolve" : "delete");
+                          &tmp_addr, action == NES_ARP_RESOLVE ? "resolve" : "delete");
                 return -1;
         }
 
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index 19e06bc38b3..dce0443f9d6 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -711,26 +711,26 @@ static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
                 neigh = *to_ipoib_neigh(skb->dst->neighbour);
 
-                if (neigh->ah)
-                        if (unlikely((memcmp(&neigh->dgid.raw,
-                                            skb->dst->neighbour->ha + 4,
-                                            sizeof(union ib_gid))) ||
-                                         (neigh->dev != dev))) {
-                                spin_lock_irqsave(&priv->lock, flags);
-                                /*
-                                 * It's safe to call ipoib_put_ah() inside
-                                 * priv->lock here, because we know that
-                                 * path->ah will always hold one more reference,
-                                 * so ipoib_put_ah() will never do more than
-                                 * decrement the ref count.
-                                 */
+                if (unlikely((memcmp(&neigh->dgid.raw,
+                                     skb->dst->neighbour->ha + 4,
+                                     sizeof(union ib_gid))) ||
+                             (neigh->dev != dev))) {
+                        spin_lock_irqsave(&priv->lock, flags);
+                        /*
+                         * It's safe to call ipoib_put_ah() inside
+                         * priv->lock here, because we know that
+                         * path->ah will always hold one more reference,
+                         * so ipoib_put_ah() will never do more than
+                         * decrement the ref count.
+                         */
+                        if (neigh->ah)
                                 ipoib_put_ah(neigh->ah);
-                                list_del(&neigh->list);
-                                ipoib_neigh_free(dev, neigh);
-                                spin_unlock_irqrestore(&priv->lock, flags);
-                                ipoib_path_lookup(skb, dev);
-                                return NETDEV_TX_OK;
-                        }
+                        list_del(&neigh->list);
+                        ipoib_neigh_free(dev, neigh);
+                        spin_unlock_irqrestore(&priv->lock, flags);
+                        ipoib_path_lookup(skb, dev);
+                        return NETDEV_TX_OK;
+                }
 
                 if (ipoib_cm_get(neigh)) {
                         if (ipoib_cm_up(neigh)) {
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index a2eb3b9789e..59d02e0b8df 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -529,6 +529,9 @@ void ipoib_mcast_join_task(struct work_struct *work)
         if (!priv->broadcast) {
                 struct ipoib_mcast *broadcast;
 
+                if (!test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
+                        return;
+
                 broadcast = ipoib_mcast_alloc(dev, 1);
                 if (!broadcast) {
                         ipoib_warn(priv, "failed to allocate broadcast group\n");
diff --git a/drivers/infiniband/ulp/iser/Kconfig b/drivers/infiniband/ulp/iser/Kconfig
index 77dedba829e..b411c51842d 100644
--- a/drivers/infiniband/ulp/iser/Kconfig
+++ b/drivers/infiniband/ulp/iser/Kconfig
@@ -1,6 +1,6 @@
 config INFINIBAND_ISER
         tristate "iSCSI Extensions for RDMA (iSER)"
-        depends on SCSI && INET
+        depends on SCSI && INET && INFINIBAND_ADDR_TRANS
         select SCSI_ISCSI_ATTRS
         ---help---
           Support for the iSCSI Extensions for RDMA (iSER) Protocol
diff --git a/drivers/input/misc/Kconfig b/drivers/input/misc/Kconfig
index 199055db508..67e5553f699 100644
--- a/drivers/input/misc/Kconfig
+++ b/drivers/input/misc/Kconfig
@@ -220,4 +220,11 @@ config HP_SDC_RTC
           Say Y here if you want to support the built-in real time clock
           of the HP SDC controller.
 
+config INPUT_PCF50633_PMU
+        tristate "PCF50633 PMU events"
+        depends on MFD_PCF50633
+        help
+         Say Y to include support for delivering  PMU events via  input
+         layer on NXP PCF50633.
+
 endif
diff --git a/drivers/input/misc/Makefile b/drivers/input/misc/Makefile
index d7db2aeb8a9..bb62e6efacf 100644
--- a/drivers/input/misc/Makefile
+++ b/drivers/input/misc/Makefile
@@ -21,3 +21,4 @@ obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_UINPUT)              += uinput.o
 obj-$(CONFIG_INPUT_APANEL)              += apanel.o
 obj-$(CONFIG_INPUT_SGI_BTNS)            += sgi_btns.o
+obj-$(CONFIG_INPUT_PCF50633_PMU)        += pcf50633-input.o
diff --git a/drivers/input/misc/pcf50633-input.c b/drivers/input/misc/pcf50633-input.c
new file mode 100644
index 00000000000..039dcb00ebd
--- /dev/null
+++ b/drivers/input/misc/pcf50633-input.c
@@ -0,0 +1,132 @@
+/* NXP PCF50633 Input Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte, Andy Green and Werner Almesberger
+ *
+ *  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/device.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+
+#include <linux/mfd/pcf50633/core.h>
+
+#define PCF50633_OOCSTAT_ONKEY  0x01
+#define PCF50633_REG_OOCSTAT    0x12
+#define PCF50633_REG_OOCMODE    0x10
+
+struct pcf50633_input {
+        struct pcf50633 *pcf;
+        struct input_dev *input_dev;
+};
+
+static void
+pcf50633_input_irq(int irq, void *data)
+{
+        struct pcf50633_input *input;
+        int onkey_released;
+
+        input = data;
+
+        /* We report only one event depending on the key press status */
+        onkey_released = pcf50633_reg_read(input->pcf, PCF50633_REG_OOCSTAT)
+                                                & PCF50633_OOCSTAT_ONKEY;
+
+        if (irq == PCF50633_IRQ_ONKEYF && !onkey_released)
+                input_report_key(input->input_dev, KEY_POWER, 1);
+        else if (irq == PCF50633_IRQ_ONKEYR && onkey_released)
+                input_report_key(input->input_dev, KEY_POWER, 0);
+
+        input_sync(input->input_dev);
+}
+
+static int __devinit pcf50633_input_probe(struct platform_device *pdev)
+{
+        struct pcf50633_input *input;
+        struct pcf50633_subdev_pdata *pdata = pdev->dev.platform_data;
+        struct input_dev *input_dev;
+        int ret;
+
+
+        input = kzalloc(sizeof(*input), GFP_KERNEL);
+        if (!input)
+                return -ENOMEM;
+
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                kfree(input);
+                return -ENOMEM;
+        }
+
+        platform_set_drvdata(pdev, input);
+        input->pcf = pdata->pcf;
+        input->input_dev = input_dev;
+
+        input_dev->name = "PCF50633 PMU events";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_PWR);
+        set_bit(KEY_POWER, input_dev->keybit);
+
+        ret = input_register_device(input_dev);
+        if (ret) {
+                input_free_device(input_dev);
+                kfree(input);
+                return ret;
+        }
+        pcf50633_register_irq(pdata->pcf, PCF50633_IRQ_ONKEYR,
+                                pcf50633_input_irq, input);
+        pcf50633_register_irq(pdata->pcf, PCF50633_IRQ_ONKEYF,
+                                pcf50633_input_irq, input);
+
+        return 0;
+}
+
+static int __devexit pcf50633_input_remove(struct platform_device *pdev)
+{
+        struct pcf50633_input *input  = platform_get_drvdata(pdev);
+
+        pcf50633_free_irq(input->pcf, PCF50633_IRQ_ONKEYR);
+        pcf50633_free_irq(input->pcf, PCF50633_IRQ_ONKEYF);
+
+        input_unregister_device(input->input_dev);
+        kfree(input);
+
+        return 0;
+}
+
+static struct platform_driver pcf50633_input_driver = {
+        .driver = {
+                .name = "pcf50633-input",
+        },
+        .probe = pcf50633_input_probe,
+        .remove = __devexit_p(pcf50633_input_remove),
+};
+
+static int __init pcf50633_input_init(void)
+{
+        return platform_driver_register(&pcf50633_input_driver);
+}
+module_init(pcf50633_input_init);
+
+static void __exit pcf50633_input_exit(void)
+{
+        platform_driver_unregister(&pcf50633_input_driver);
+}
+module_exit(pcf50633_input_exit);
+
+MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
+MODULE_DESCRIPTION("PCF50633 input driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcf50633-input");
diff --git a/drivers/isdn/hardware/mISDN/hfcmulti.c b/drivers/isdn/hardware/mISDN/hfcmulti.c
index 97f4708b387..595ba8eb4a0 100644
--- a/drivers/isdn/hardware/mISDN/hfcmulti.c
+++ b/drivers/isdn/hardware/mISDN/hfcmulti.c
@@ -3615,7 +3615,7 @@ hfcm_bctrl(struct mISDNchannel *ch, u_int cmd, void *arg)
 static void
 ph_state_change(struct dchannel *dch)
 {
-        struct hfc_multi *hc = dch->hw;
+        struct hfc_multi *hc;
         int ch, i;
 
         if (!dch) {
@@ -3623,6 +3623,7 @@ ph_state_change(struct dchannel *dch)
                     __func__);
                 return;
         }
+        hc = dch->hw;
         ch = dch->slot;
 
         if (hc->type == 1) {
diff --git a/drivers/isdn/hardware/mISDN/hfcpci.c b/drivers/isdn/hardware/mISDN/hfcpci.c
index 917bf41a293..f0e14dfcf71 100644
--- a/drivers/isdn/hardware/mISDN/hfcpci.c
+++ b/drivers/isdn/hardware/mISDN/hfcpci.c
@@ -61,7 +61,7 @@ u32	hfc_jiffies;
 
 MODULE_AUTHOR("Karsten Keil");
 MODULE_LICENSE("GPL");
-module_param(debug, uint, 0);
+module_param(debug, uint, S_IRUGO | S_IWUSR);
 module_param(poll, uint, S_IRUGO | S_IWUSR);
 
 enum {
diff --git a/drivers/isdn/mISDN/dsp_cmx.c b/drivers/isdn/mISDN/dsp_cmx.c
index 0ac67bff303..58c43e429f7 100644
--- a/drivers/isdn/mISDN/dsp_cmx.c
+++ b/drivers/isdn/mISDN/dsp_cmx.c
@@ -1579,7 +1579,7 @@ send_packet:
         schedule_work(&dsp->workq);
 }
 
-static u32      jittercount; /* counter for jitter check */;
+static u32      jittercount; /* counter for jitter check */
 struct timer_list dsp_spl_tl;
 u32     dsp_spl_jiffies; /* calculate the next time to fire */
 static u16      dsp_count; /* last sample count */
@@ -1893,7 +1893,7 @@ dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb)
                 /* in case of hardware (echo) */
                 if (dsp->pcm_slot_tx >= 0)
                         return;
-                if (dsp->echo)
+                if (dsp->echo) {
                         nskb = skb_clone(skb, GFP_ATOMIC);
                         if (nskb) {
                                 hh = mISDN_HEAD_P(nskb);
@@ -1902,6 +1902,7 @@ dsp_cmx_hdlc(struct dsp *dsp, struct sk_buff *skb)
                                 skb_queue_tail(&dsp->sendq, nskb);
                                 schedule_work(&dsp->workq);
                         }
+                }
                 return;
         }
         /* in case of hardware conference */
diff --git a/drivers/isdn/mISDN/dsp_pipeline.c b/drivers/isdn/mISDN/dsp_pipeline.c
index bf999bdc41c..18cf87c113e 100644
--- a/drivers/isdn/mISDN/dsp_pipeline.c
+++ b/drivers/isdn/mISDN/dsp_pipeline.c
@@ -110,8 +110,7 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
         }
         list_add_tail(&entry->list, &dsp_elements);
 
-        for (i = 0; i < (sizeof(element_attributes)
-                / sizeof(struct device_attribute)); ++i)
+        for (i = 0; i < ARRAY_SIZE(element_attributes); ++i) {
                 ret = device_create_file(&entry->dev,
                                 &element_attributes[i]);
                 if (ret) {
@@ -119,6 +118,7 @@ int mISDN_dsp_element_register(struct mISDN_dsp_element *elem)
                                 __func__);
                         goto err2;
                 }
+        }
 
 #ifdef PIPELINE_DEBUG
         printk(KERN_DEBUG "%s: %s registered\n", __func__, elem->name);
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 416f9e7286b..06a2b0f7737 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -217,6 +217,29 @@ config MFD_WM8350_I2C
           I2C as the control interface.  Additional options must be
           selected to enable support for the functionality of the chip.
 
+config MFD_PCF50633
+        tristate "Support for NXP PCF50633"
+        depends on I2C
+        help
+          Say yes here if you have NXP PCF50633 chip on your board.
+          This core driver provides register access and IRQ handling
+          facilities, and registers devices for the various functions
+          so that function-specific drivers can bind to them.
+
+config PCF50633_ADC
+        tristate "Support for NXP PCF50633 ADC"
+        depends on MFD_PCF50633
+        help
+         Say yes here if you want to include support for ADC in the
+         NXP PCF50633 chip.
+
+config PCF50633_GPIO
+        tristate "Support for NXP PCF50633 GPIO"
+        depends on MFD_PCF50633
+        help
+         Say yes here if you want to include support GPIO for pins on
+         the PCF50633 chip.
+
 endmenu
 
 menu "Multimedia Capabilities Port drivers"
diff --git a/drivers/mfd/Makefile b/drivers/mfd/Makefile
index 0c9418b36c2..3afb5192e4d 100644
--- a/drivers/mfd/Makefile
+++ b/drivers/mfd/Makefile
@@ -37,3 +37,7 @@ endif
 obj-$(CONFIG_UCB1400_CORE)      += ucb1400_core.o
 
 obj-$(CONFIG_PMIC_DA903X)       += da903x.o
+
+obj-$(CONFIG_MFD_PCF50633)      += pcf50633-core.o
+obj-$(CONFIG_PCF50633_ADC)      += pcf50633-adc.o
+obj-$(CONFIG_PCF50633_GPIO)     += pcf50633-gpio.o
\ No newline at end of file
diff --git a/drivers/mfd/dm355evm_msp.c b/drivers/mfd/dm355evm_msp.c
index 4214b3f7242..7ac12cb0be4 100644
--- a/drivers/mfd/dm355evm_msp.c
+++ b/drivers/mfd/dm355evm_msp.c
@@ -107,6 +107,9 @@ static const u8 msp_gpios[] = {
         MSP_GPIO(0, SWITCH1), MSP_GPIO(1, SWITCH1),
         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 */
 };
 
 #define MSP_GPIO_REG(offset)    (msp_gpios[(offset)] >> 3)
@@ -304,6 +307,13 @@ static int add_children(struct i2c_client *client)
                 gpio_export(gpio, false);
         }
 
+        /* MMC/SD inputs -- right after the last config input */
+        if (client->dev.platform_data) {
+                void (*mmcsd_setup)(unsigned) = client->dev.platform_data;
+
+                mmcsd_setup(dm355evm_msp_gpio.base + 8 + 5);
+        }
+
         /* RTC is a 32 bit counter, no alarm */
         if (msp_has_rtc()) {
                 child = add_child(client, "rtc-dm355evm",
diff --git a/drivers/mfd/pcf50633-adc.c b/drivers/mfd/pcf50633-adc.c
new file mode 100644
index 00000000000..c2d05becfa9
--- /dev/null
+++ b/drivers/mfd/pcf50633-adc.c
@@ -0,0 +1,277 @@
+/* NXP PCF50633 ADC Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte, Andy Green and Werner Almesberger
+ *
+ *  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.
+ *
+ *  NOTE: This driver does not yet support subtractive ADC mode, which means
+ *  you can do only one measurement per read request.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/completion.h>
+
+#include <linux/mfd/pcf50633/core.h>
+#include <linux/mfd/pcf50633/adc.h>
+
+struct pcf50633_adc_request {
+        int mux;
+        int avg;
+        int result;
+        void (*callback)(struct pcf50633 *, void *, int);
+        void *callback_param;
+
+        /* Used in case of sync requests */
+        struct completion completion;
+
+};
+
+#define PCF50633_MAX_ADC_FIFO_DEPTH 8
+
+struct pcf50633_adc {
+        struct pcf50633 *pcf;
+
+        /* Private stuff */
+        struct pcf50633_adc_request *queue[PCF50633_MAX_ADC_FIFO_DEPTH];
+        int queue_head;
+        int queue_tail;
+        struct mutex queue_mutex;
+};
+
+static inline struct pcf50633_adc *__to_adc(struct pcf50633 *pcf)
+{
+        return platform_get_drvdata(pcf->adc_pdev);
+}
+
+static void adc_setup(struct pcf50633 *pcf, int channel, int avg)
+{
+        channel &= PCF50633_ADCC1_ADCMUX_MASK;
+
+        /* kill ratiometric, but enable ACCSW biasing */
+        pcf50633_reg_write(pcf, PCF50633_REG_ADCC2, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_ADCC3, 0x01);
+
+        /* start ADC conversion on selected channel */
+        pcf50633_reg_write(pcf, PCF50633_REG_ADCC1, channel | avg |
+                    PCF50633_ADCC1_ADCSTART | PCF50633_ADCC1_RES_10BIT);
+}
+
+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);
+                return;
+        }
+        mutex_unlock(&adc->queue_mutex);
+
+        adc_setup(pcf, adc->queue[head]->mux, adc->queue[head]->avg);
+}
+
+static int
+adc_enqueue_request(struct pcf50633 *pcf, struct pcf50633_adc_request *req)
+{
+        struct pcf50633_adc *adc = __to_adc(pcf);
+        int head, tail;
+
+        mutex_lock(&adc->queue_mutex);
+
+        head = adc->queue_head;
+        tail = adc->queue_tail;
+
+        if (adc->queue[tail]) {
+                mutex_unlock(&adc->queue_mutex);
+                return -EBUSY;
+        }
+
+        adc->queue[tail] = req;
+        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;
+}
+
+static void
+pcf50633_adc_sync_read_callback(struct pcf50633 *pcf, void *param, int result)
+{
+        struct pcf50633_adc_request *req = param;
+
+        req->result = result;
+        complete(&req->completion);
+}
+
+int pcf50633_adc_sync_read(struct pcf50633 *pcf, int mux, int avg)
+{
+        struct pcf50633_adc_request *req;
+
+        /* req is freed when the result is ready, in interrupt handler */
+        req = kzalloc(sizeof(*req), GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+
+        req->mux = mux;
+        req->avg = avg;
+        req->callback =  pcf50633_adc_sync_read_callback;
+        req->callback_param = req;
+
+        init_completion(&req->completion);
+        adc_enqueue_request(pcf, req);
+        wait_for_completion(&req->completion);
+
+        return req->result;
+}
+EXPORT_SYMBOL_GPL(pcf50633_adc_sync_read);
+
+int pcf50633_adc_async_read(struct pcf50633 *pcf, int mux, int avg,
+                             void (*callback)(struct pcf50633 *, void *, int),
+                             void *callback_param)
+{
+        struct pcf50633_adc_request *req;
+
+        /* req is freed when the result is ready, in interrupt handler */
+        req = kmalloc(sizeof(*req), GFP_KERNEL);
+        if (!req)
+                return -ENOMEM;
+
+        req->mux = mux;
+        req->avg = avg;
+        req->callback = callback;
+        req->callback_param = callback_param;
+
+        adc_enqueue_request(pcf, req);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcf50633_adc_async_read);
+
+static int adc_result(struct pcf50633 *pcf)
+{
+        u8 adcs1, adcs3;
+        u16 result;
+
+        adcs1 = pcf50633_reg_read(pcf, PCF50633_REG_ADCS1);
+        adcs3 = pcf50633_reg_read(pcf, PCF50633_REG_ADCS3);
+        result = (adcs1 << 2) | (adcs3 & PCF50633_ADCS3_ADCDAT1L_MASK);
+
+        dev_dbg(pcf->dev, "adc result = %d\n", result);
+
+        return result;
+}
+
+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;
+
+        mutex_lock(&adc->queue_mutex);
+        head = adc->queue_head;
+
+        req = adc->queue[head];
+        if (WARN_ON(!req)) {
+                dev_err(pcf->dev, "pcf50633-adc irq: ADC queue empty!\n");
+                mutex_unlock(&adc->queue_mutex);
+                return;
+        }
+        adc->queue[head] = NULL;
+        adc->queue_head = (head + 1) &
+                                      (PCF50633_MAX_ADC_FIFO_DEPTH - 1);
+
+        mutex_unlock(&adc->queue_mutex);
+
+        req->callback(pcf, req->callback_param, adc_result(pcf));
+        kfree(req);
+
+        trigger_next_adc_job_if_any(pcf);
+}
+
+static int __devinit pcf50633_adc_probe(struct platform_device *pdev)
+{
+        struct pcf50633_subdev_pdata *pdata = pdev->dev.platform_data;
+        struct pcf50633_adc *adc;
+
+        adc = kzalloc(sizeof(*adc), GFP_KERNEL);
+        if (!adc)
+                return -ENOMEM;
+
+        adc->pcf = pdata->pcf;
+        platform_set_drvdata(pdev, adc);
+
+        pcf50633_register_irq(pdata->pcf, PCF50633_IRQ_ADCRDY,
+                                        pcf50633_adc_irq, adc);
+
+        mutex_init(&adc->queue_mutex);
+
+        return 0;
+}
+
+static int __devexit pcf50633_adc_remove(struct platform_device *pdev)
+{
+        struct pcf50633_adc *adc = platform_get_drvdata(pdev);
+        int i, head;
+
+        pcf50633_free_irq(adc->pcf, PCF50633_IRQ_ADCRDY);
+
+        mutex_lock(&adc->queue_mutex);
+        head = adc->queue_head;
+
+        if (WARN_ON(adc->queue[head]))
+                dev_err(adc->pcf->dev,
+                        "adc driver removed with request pending\n");
+
+        for (i = 0; i < PCF50633_MAX_ADC_FIFO_DEPTH; i++)
+                kfree(adc->queue[i]);
+
+        mutex_unlock(&adc->queue_mutex);
+        kfree(adc);
+
+        return 0;
+}
+
+static struct platform_driver pcf50633_adc_driver = {
+        .driver = {
+                .name = "pcf50633-adc",
+        },
+        .probe = pcf50633_adc_probe,
+        .remove = __devexit_p(pcf50633_adc_remove),
+};
+
+static int __init pcf50633_adc_init(void)
+{
+        return platform_driver_register(&pcf50633_adc_driver);
+}
+module_init(pcf50633_adc_init);
+
+static void __exit pcf50633_adc_exit(void)
+{
+        platform_driver_unregister(&pcf50633_adc_driver);
+}
+module_exit(pcf50633_adc_exit);
+
+MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
+MODULE_DESCRIPTION("PCF50633 adc driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcf50633-adc");
+
diff --git a/drivers/mfd/pcf50633-core.c b/drivers/mfd/pcf50633-core.c
new file mode 100644
index 00000000000..24508e28e3f
--- /dev/null
+++ b/drivers/mfd/pcf50633-core.c
@@ -0,0 +1,710 @@
+/* NXP PCF50633 Power Management Unit (PMU) driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Harald Welte <laforge@openmoko.org>
+ *         Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ *  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/device.h>
+#include <linux/sysfs.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/irq.h>
+
+#include <linux/mfd/pcf50633/core.h>
+
+/* Two MBCS registers used during cold start */
+#define PCF50633_REG_MBCS1              0x4b
+#define PCF50633_REG_MBCS2              0x4c
+#define PCF50633_MBCS1_USBPRES          0x01
+#define PCF50633_MBCS1_ADAPTPRES        0x01
+
+static int __pcf50633_read(struct pcf50633 *pcf, u8 reg, int num, u8 *data)
+{
+        int ret;
+
+        ret = i2c_smbus_read_i2c_block_data(pcf->i2c_client, reg,
+                                num, data);
+        if (ret < 0)
+                dev_err(pcf->dev, "Error reading %d regs at %d\n", num, reg);
+
+        return ret;
+}
+
+static int __pcf50633_write(struct pcf50633 *pcf, u8 reg, int num, u8 *data)
+{
+        int ret;
+
+        ret = i2c_smbus_write_i2c_block_data(pcf->i2c_client, reg,
+                                num, data);
+        if (ret < 0)
+                dev_err(pcf->dev, "Error writing %d regs at %d\n", num, reg);
+
+        return ret;
+
+}
+
+/* Read a block of upto 32 regs  */
+int pcf50633_read_block(struct pcf50633 *pcf, u8 reg,
+                                        int nr_regs, u8 *data)
+{
+        int ret;
+
+        mutex_lock(&pcf->lock);
+        ret = __pcf50633_read(pcf, reg, nr_regs, data);
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pcf50633_read_block);
+
+/* Write a block of upto 32 regs  */
+int pcf50633_write_block(struct pcf50633 *pcf , u8 reg,
+                                        int nr_regs, u8 *data)
+{
+        int ret;
+
+        mutex_lock(&pcf->lock);
+        ret = __pcf50633_write(pcf, reg, nr_regs, data);
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pcf50633_write_block);
+
+u8 pcf50633_reg_read(struct pcf50633 *pcf, u8 reg)
+{
+        u8 val;
+
+        mutex_lock(&pcf->lock);
+        __pcf50633_read(pcf, reg, 1, &val);
+        mutex_unlock(&pcf->lock);
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(pcf50633_reg_read);
+
+int pcf50633_reg_write(struct pcf50633 *pcf, u8 reg, u8 val)
+{
+        int ret;
+
+        mutex_lock(&pcf->lock);
+        ret = __pcf50633_write(pcf, reg, 1, &val);
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pcf50633_reg_write);
+
+int pcf50633_reg_set_bit_mask(struct pcf50633 *pcf, u8 reg, u8 mask, u8 val)
+{
+        int ret;
+        u8 tmp;
+
+        val &= mask;
+
+        mutex_lock(&pcf->lock);
+        ret = __pcf50633_read(pcf, reg, 1, &tmp);
+        if (ret < 0)
+                goto out;
+
+        tmp &= ~mask;
+        tmp |= val;
+        ret = __pcf50633_write(pcf, reg, 1, &tmp);
+
+out:
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pcf50633_reg_set_bit_mask);
+
+int pcf50633_reg_clear_bits(struct pcf50633 *pcf, u8 reg, u8 val)
+{
+        int ret;
+        u8 tmp;
+
+        mutex_lock(&pcf->lock);
+        ret = __pcf50633_read(pcf, reg, 1, &tmp);
+        if (ret < 0)
+                goto out;
+
+        tmp &= ~val;
+        ret = __pcf50633_write(pcf, reg, 1, &tmp);
+
+out:
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pcf50633_reg_clear_bits);
+
+/* sysfs attributes */
+static ssize_t show_dump_regs(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct pcf50633 *pcf = dev_get_drvdata(dev);
+        u8 dump[16];
+        int n, n1, idx = 0;
+        char *buf1 = buf;
+        static u8 address_no_read[] = { /* must be ascending */
+                PCF50633_REG_INT1,
+                PCF50633_REG_INT2,
+                PCF50633_REG_INT3,
+                PCF50633_REG_INT4,
+                PCF50633_REG_INT5,
+                0 /* terminator */
+        };
+
+        for (n = 0; n < 256; n += sizeof(dump)) {
+                for (n1 = 0; n1 < sizeof(dump); n1++)
+                        if (n == address_no_read[idx]) {
+                                idx++;
+                                dump[n1] = 0x00;
+                        } else
+                                dump[n1] = pcf50633_reg_read(pcf, n + n1);
+
+                hex_dump_to_buffer(dump, sizeof(dump), 16, 1, buf1, 128, 0);
+                buf1 += strlen(buf1);
+                *buf1++ = '\n';
+                *buf1 = '\0';
+        }
+
+        return buf1 - buf;
+}
+static DEVICE_ATTR(dump_regs, 0400, show_dump_regs, NULL);
+
+static ssize_t show_resume_reason(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct pcf50633 *pcf = dev_get_drvdata(dev);
+        int n;
+
+        n = sprintf(buf, "%02x%02x%02x%02x%02x\n",
+                                pcf->resume_reason[0],
+                                pcf->resume_reason[1],
+                                pcf->resume_reason[2],
+                                pcf->resume_reason[3],
+                                pcf->resume_reason[4]);
+
+        return n;
+}
+static DEVICE_ATTR(resume_reason, 0400, show_resume_reason, NULL);
+
+static struct attribute *pcf_sysfs_entries[] = {
+        &dev_attr_dump_regs.attr,
+        &dev_attr_resume_reason.attr,
+        NULL,
+};
+
+static struct attribute_group pcf_attr_group = {
+        .name   = NULL,                 /* put in device directory */
+        .attrs  = pcf_sysfs_entries,
+};
+
+int pcf50633_register_irq(struct pcf50633 *pcf, int irq,
+                        void (*handler) (int, void *), void *data)
+{
+        if (irq < 0 || irq > PCF50633_NUM_IRQ || !handler)
+                return -EINVAL;
+
+        if (WARN_ON(pcf->irq_handler[irq].handler))
+                return -EBUSY;
+
+        mutex_lock(&pcf->lock);
+        pcf->irq_handler[irq].handler = handler;
+        pcf->irq_handler[irq].data = data;
+        mutex_unlock(&pcf->lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcf50633_register_irq);
+
+int pcf50633_free_irq(struct pcf50633 *pcf, int irq)
+{
+        if (irq < 0 || irq > PCF50633_NUM_IRQ)
+                return -EINVAL;
+
+        mutex_lock(&pcf->lock);
+        pcf->irq_handler[irq].handler = NULL;
+        mutex_unlock(&pcf->lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(pcf50633_free_irq);
+
+static int __pcf50633_irq_mask_set(struct pcf50633 *pcf, int irq, u8 mask)
+{
+        u8 reg, bits, tmp;
+        int ret = 0, idx;
+
+        idx = irq >> 3;
+        reg =  PCF50633_REG_INT1M + idx;
+        bits = 1 << (irq & 0x07);
+
+        mutex_lock(&pcf->lock);
+
+        if (mask) {
+                ret = __pcf50633_read(pcf, reg, 1, &tmp);
+                if (ret < 0)
+                        goto out;
+
+                tmp |= bits;
+
+                ret = __pcf50633_write(pcf, reg, 1, &tmp);
+                if (ret < 0)
+                        goto out;
+
+                pcf->mask_regs[idx] &= ~bits;
+                pcf->mask_regs[idx] |= bits;
+        } else {
+                ret = __pcf50633_read(pcf, reg, 1, &tmp);
+                if (ret < 0)
+                        goto out;
+
+                tmp &= ~bits;
+
+                ret = __pcf50633_write(pcf, reg, 1, &tmp);
+                if (ret < 0)
+                        goto out;
+
+                pcf->mask_regs[idx] &= ~bits;
+        }
+out:
+        mutex_unlock(&pcf->lock);
+
+        return ret;
+}
+
+int pcf50633_irq_mask(struct pcf50633 *pcf, int irq)
+{
+        dev_info(pcf->dev, "Masking IRQ %d\n", irq);
+
+        return __pcf50633_irq_mask_set(pcf, irq, 1);
+}
+EXPORT_SYMBOL_GPL(pcf50633_irq_mask);
+
+int pcf50633_irq_unmask(struct pcf50633 *pcf, int irq)
+{
+        dev_info(pcf->dev, "Unmasking IRQ %d\n", irq);
+
+        return __pcf50633_irq_mask_set(pcf, irq, 0);
+}
+EXPORT_SYMBOL_GPL(pcf50633_irq_unmask);
+
+int pcf50633_irq_mask_get(struct pcf50633 *pcf, int irq)
+{
+        u8 reg, bits;
+
+        reg =  irq >> 3;
+        bits = 1 << (irq & 0x07);
+
+        return pcf->mask_regs[reg] & bits;
+}
+EXPORT_SYMBOL_GPL(pcf50633_irq_mask_get);
+
+static void pcf50633_irq_call_handler(struct pcf50633 *pcf, int irq)
+{
+        if (pcf->irq_handler[irq].handler)
+                pcf->irq_handler[irq].handler(irq, pcf->irq_handler[irq].data);
+}
+
+/* Maximum amount of time ONKEY is held before emergency action is taken */
+#define PCF50633_ONKEY1S_TIMEOUT 8
+
+static void pcf50633_irq_worker(struct work_struct *work)
+{
+        struct pcf50633 *pcf;
+        int ret, i, j;
+        u8 pcf_int[5], chgstat;
+
+        pcf = container_of(work, struct pcf50633, irq_work);
+
+        /* Read the 5 INT regs in one transaction */
+        ret = pcf50633_read_block(pcf, PCF50633_REG_INT1,
+                                                ARRAY_SIZE(pcf_int), pcf_int);
+        if (ret != ARRAY_SIZE(pcf_int)) {
+                dev_err(pcf->dev, "Error reading INT registers\n");
+
+                /*
+                 * If this doesn't ACK the interrupt to the chip, we'll be
+                 * called once again as we're level triggered.
+                 */
+                goto out;
+        }
+
+        /* We immediately read the usb and adapter status. We thus make sure
+         * only of USBINS/USBREM IRQ handlers are called */
+        if (pcf_int[0] & (PCF50633_INT1_USBINS | PCF50633_INT1_USBREM)) {
+                chgstat = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
+                if (chgstat & (0x3 << 4))
+                        pcf_int[0] &= ~(1 << PCF50633_INT1_USBREM);
+                else
+                        pcf_int[0] &= ~(1 << PCF50633_INT1_USBINS);
+        }
+
+        /* Make sure only one of ADPINS or ADPREM is set */
+        if (pcf_int[0] & (PCF50633_INT1_ADPINS | PCF50633_INT1_ADPREM)) {
+                chgstat = pcf50633_reg_read(pcf, PCF50633_REG_MBCS2);
+                if (chgstat & (0x3 << 4))
+                        pcf_int[0] &= ~(1 << PCF50633_INT1_ADPREM);
+                else
+                        pcf_int[0] &= ~(1 << PCF50633_INT1_ADPINS);
+        }
+
+        dev_dbg(pcf->dev, "INT1=0x%02x INT2=0x%02x INT3=0x%02x "
+                        "INT4=0x%02x INT5=0x%02x\n", pcf_int[0],
+                        pcf_int[1], pcf_int[2], pcf_int[3], pcf_int[4]);
+
+        /* Some revisions of the chip don't have a 8s standby mode on
+         * ONKEY1S press. We try to manually do it in such cases. */
+        if ((pcf_int[0] & PCF50633_INT1_SECOND) && pcf->onkey1s_held) {
+                dev_info(pcf->dev, "ONKEY1S held for %d secs\n",
+                                                        pcf->onkey1s_held);
+                if (pcf->onkey1s_held++ == PCF50633_ONKEY1S_TIMEOUT)
+                        if (pcf->pdata->force_shutdown)
+                                pcf->pdata->force_shutdown(pcf);
+        }
+
+        if (pcf_int[2] & PCF50633_INT3_ONKEY1S) {
+                dev_info(pcf->dev, "ONKEY1S held\n");
+                pcf->onkey1s_held = 1 ;
+
+                /* Unmask IRQ_SECOND */
+                pcf50633_reg_clear_bits(pcf, PCF50633_REG_INT1M,
+                                                PCF50633_INT1_SECOND);
+
+                /* Unmask IRQ_ONKEYR */
+                pcf50633_reg_clear_bits(pcf, PCF50633_REG_INT2M,
+                                                PCF50633_INT2_ONKEYR);
+        }
+
+        if ((pcf_int[1] & PCF50633_INT2_ONKEYR) && pcf->onkey1s_held) {
+                pcf->onkey1s_held = 0;
+
+                /* Mask SECOND and ONKEYR interrupts */
+                if (pcf->mask_regs[0] & PCF50633_INT1_SECOND)
+                        pcf50633_reg_set_bit_mask(pcf,
+                                        PCF50633_REG_INT1M,
+                                        PCF50633_INT1_SECOND,
+                                        PCF50633_INT1_SECOND);
+
+                if (pcf->mask_regs[1] & PCF50633_INT2_ONKEYR)
+                        pcf50633_reg_set_bit_mask(pcf,
+                                        PCF50633_REG_INT2M,
+                                        PCF50633_INT2_ONKEYR,
+                                        PCF50633_INT2_ONKEYR);
+        }
+
+        /* Have we just resumed ? */
+        if (pcf->is_suspended) {
+                pcf->is_suspended = 0;
+
+                /* Set the resume reason filtering out non resumers */
+                for (i = 0; i < ARRAY_SIZE(pcf_int); i++)
+                        pcf->resume_reason[i] = pcf_int[i] &
+                                                pcf->pdata->resumers[i];
+
+                /* Make sure we don't pass on any ONKEY events to
+                 * userspace now */
+                pcf_int[1] &= ~(PCF50633_INT2_ONKEYR | PCF50633_INT2_ONKEYF);
+        }
+
+        for (i = 0; i < ARRAY_SIZE(pcf_int); i++) {
+                /* Unset masked interrupts */
+                pcf_int[i] &= ~pcf->mask_regs[i];
+
+                for (j = 0; j < 8 ; j++)
+                        if (pcf_int[i] & (1 << j))
+                                pcf50633_irq_call_handler(pcf, (i * 8) + j);
+        }
+
+out:
+        put_device(pcf->dev);
+        enable_irq(pcf->irq);
+}
+
+static irqreturn_t pcf50633_irq(int irq, void *data)
+{
+        struct pcf50633 *pcf = data;
+
+        dev_dbg(pcf->dev, "pcf50633_irq\n");
+
+        get_device(pcf->dev);
+        disable_irq(pcf->irq);
+        schedule_work(&pcf->irq_work);
+
+        return IRQ_HANDLED;
+}
+
+static void
+pcf50633_client_dev_register(struct pcf50633 *pcf, const char *name,
+                                                struct platform_device **pdev)
+{
+        struct pcf50633_subdev_pdata *subdev_pdata;
+        int ret;
+
+        *pdev = platform_device_alloc(name, -1);
+        if (!*pdev) {
+                dev_err(pcf->dev, "Falied to allocate %s\n", name);
+                return;
+        }
+
+        subdev_pdata = kmalloc(sizeof(*subdev_pdata), GFP_KERNEL);
+        if (!subdev_pdata) {
+                dev_err(pcf->dev, "Error allocating subdev pdata\n");
+                platform_device_put(*pdev);
+        }
+
+        subdev_pdata->pcf = pcf;
+        platform_device_add_data(*pdev, subdev_pdata, sizeof(*subdev_pdata));
+
+        (*pdev)->dev.parent = pcf->dev;
+
+        ret = platform_device_add(*pdev);
+        if (ret) {
+                dev_err(pcf->dev, "Failed to register %s: %d\n", name, ret);
+                platform_device_put(*pdev);
+                *pdev = NULL;
+        }
+}
+
+#ifdef CONFIG_PM
+static int pcf50633_suspend(struct device *dev, pm_message_t state)
+{
+        struct pcf50633 *pcf;
+        int ret = 0, i;
+        u8 res[5];
+
+        pcf = dev_get_drvdata(dev);
+
+        /* Make sure our interrupt handlers are not called
+         * henceforth */
+        disable_irq(pcf->irq);
+
+        /* Make sure that any running IRQ worker has quit */
+        cancel_work_sync(&pcf->irq_work);
+
+        /* Save the masks */
+        ret = pcf50633_read_block(pcf, PCF50633_REG_INT1M,
+                                ARRAY_SIZE(pcf->suspend_irq_masks),
+                                        pcf->suspend_irq_masks);
+        if (ret < 0) {
+                dev_err(pcf->dev, "error saving irq masks\n");
+                goto out;
+        }
+
+        /* Write wakeup irq masks */
+        for (i = 0; i < ARRAY_SIZE(res); i++)
+                res[i] = ~pcf->pdata->resumers[i];
+
+        ret = pcf50633_write_block(pcf, PCF50633_REG_INT1M,
+                                        ARRAY_SIZE(res), &res[0]);
+        if (ret < 0) {
+                dev_err(pcf->dev, "error writing wakeup irq masks\n");
+                goto out;
+        }
+
+        pcf->is_suspended = 1;
+
+out:
+        return ret;
+}
+
+static int pcf50633_resume(struct device *dev)
+{
+        struct pcf50633 *pcf;
+        int ret;
+
+        pcf = dev_get_drvdata(dev);
+
+        /* Write the saved mask registers */
+        ret = pcf50633_write_block(pcf, PCF50633_REG_INT1M,
+                                ARRAY_SIZE(pcf->suspend_irq_masks),
+                                        pcf->suspend_irq_masks);
+        if (ret < 0)
+                dev_err(pcf->dev, "Error restoring saved suspend masks\n");
+
+        /* Restore regulators' state */
+
+
+        get_device(pcf->dev);
+
+        /*
+         * Clear any pending interrupts and set resume reason if any.
+         * This will leave with enable_irq()
+         */
+        pcf50633_irq_worker(&pcf->irq_work);
+
+        return 0;
+}
+#else
+#define pcf50633_suspend NULL
+#define pcf50633_resume NULL
+#endif
+
+static int __devinit pcf50633_probe(struct i2c_client *client,
+                                const struct i2c_device_id *ids)
+{
+        struct pcf50633 *pcf;
+        struct pcf50633_platform_data *pdata = client->dev.platform_data;
+        int i, ret = 0;
+        int version, variant;
+
+        pcf = kzalloc(sizeof(*pcf), GFP_KERNEL);
+        if (!pcf)
+                return -ENOMEM;
+
+        pcf->pdata = pdata;
+
+        mutex_init(&pcf->lock);
+
+        i2c_set_clientdata(client, pcf);
+        pcf->dev = &client->dev;
+        pcf->i2c_client = client;
+        pcf->irq = client->irq;
+
+        INIT_WORK(&pcf->irq_work, pcf50633_irq_worker);
+
+        version = pcf50633_reg_read(pcf, 0);
+        variant = pcf50633_reg_read(pcf, 1);
+        if (version < 0 || variant < 0) {
+                dev_err(pcf->dev, "Unable to probe pcf50633\n");
+                ret = -ENODEV;
+                goto err;
+        }
+
+        dev_info(pcf->dev, "Probed device version %d variant %d\n",
+                                                        version, variant);
+
+        /* Enable all interrupts except RTC SECOND */
+        pcf->mask_regs[0] = 0x80;
+        pcf50633_reg_write(pcf, PCF50633_REG_INT1M, pcf->mask_regs[0]);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT2M, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT3M, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT4M, 0x00);
+        pcf50633_reg_write(pcf, PCF50633_REG_INT5M, 0x00);
+
+        /* Create sub devices */
+        pcf50633_client_dev_register(pcf, "pcf50633-input",
+                                                &pcf->input_pdev);
+        pcf50633_client_dev_register(pcf, "pcf50633-rtc",
+                                                &pcf->rtc_pdev);
+        pcf50633_client_dev_register(pcf, "pcf50633-mbc",
+                                                &pcf->mbc_pdev);
+        pcf50633_client_dev_register(pcf, "pcf50633-adc",
+                                                &pcf->adc_pdev);
+
+        for (i = 0; i < PCF50633_NUM_REGULATORS; i++) {
+                struct platform_device *pdev;
+
+                pdev = platform_device_alloc("pcf50633-regltr", i);
+                if (!pdev) {
+                        dev_err(pcf->dev, "Cannot create regulator\n");
+                        continue;
+                }
+
+                pdev->dev.parent = pcf->dev;
+                pdev->dev.platform_data = &pdata->reg_init_data[i];
+                pdev->dev.driver_data = pcf;
+                pcf->regulator_pdev[i] = pdev;
+
+                platform_device_add(pdev);
+        }
+
+        if (client->irq) {
+                set_irq_handler(client->irq, handle_level_irq);
+                ret = request_irq(client->irq, pcf50633_irq,
+                                IRQF_TRIGGER_LOW, "pcf50633", pcf);
+
+                if (ret) {
+                        dev_err(pcf->dev, "Failed to request IRQ %d\n", ret);
+                        goto err;
+                }
+        } else {
+                dev_err(pcf->dev, "No IRQ configured\n");
+                goto err;
+        }
+
+        if (enable_irq_wake(client->irq) < 0)
+                dev_err(pcf->dev, "IRQ %u cannot be enabled as wake-up source"
+                        "in this hardware revision", client->irq);
+
+        ret = sysfs_create_group(&client->dev.kobj, &pcf_attr_group);
+        if (ret)
+                dev_err(pcf->dev, "error creating sysfs entries\n");
+
+        if (pdata->probe_done)
+                pdata->probe_done(pcf);
+
+        return 0;
+
+err:
+        kfree(pcf);
+        return ret;
+}
+
+static int __devexit pcf50633_remove(struct i2c_client *client)
+{
+        struct pcf50633 *pcf = i2c_get_clientdata(client);
+        int i;
+
+        free_irq(pcf->irq, pcf);
+
+        platform_device_unregister(pcf->input_pdev);
+        platform_device_unregister(pcf->rtc_pdev);
+        platform_device_unregister(pcf->mbc_pdev);
+        platform_device_unregister(pcf->adc_pdev);
+
+        for (i = 0; i < PCF50633_NUM_REGULATORS; i++)
+                platform_device_unregister(pcf->regulator_pdev[i]);
+
+        kfree(pcf);
+
+        return 0;
+}
+
+static struct i2c_device_id pcf50633_id_table[] = {
+        {"pcf50633", 0x73},
+};
+
+static struct i2c_driver pcf50633_driver = {
+        .driver = {
+                .name   = "pcf50633",
+                .suspend = pcf50633_suspend,
+                .resume = pcf50633_resume,
+        },
+        .id_table = pcf50633_id_table,
+        .probe = pcf50633_probe,
+        .remove = __devexit_p(pcf50633_remove),
+};
+
+static int __init pcf50633_init(void)
+{
+        return i2c_add_driver(&pcf50633_driver);
+}
+
+static void __exit pcf50633_exit(void)
+{
+        i2c_del_driver(&pcf50633_driver);
+}
+
+MODULE_DESCRIPTION("I2C chip driver for NXP PCF50633 PMU");
+MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
+MODULE_LICENSE("GPL");
+
+module_init(pcf50633_init);
+module_exit(pcf50633_exit);
diff --git a/drivers/mfd/pcf50633-gpio.c b/drivers/mfd/pcf50633-gpio.c
new file mode 100644
index 00000000000..2fa2eca5c9c
--- /dev/null
+++ b/drivers/mfd/pcf50633-gpio.c
@@ -0,0 +1,118 @@
+/* NXP PCF50633 GPIO Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte, Andy Green and Werner Almesberger
+ *
+ *  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/mfd/pcf50633/core.h>
+#include <linux/mfd/pcf50633/gpio.h>
+
+enum pcf50633_regulator_id {
+        PCF50633_REGULATOR_AUTO,
+        PCF50633_REGULATOR_DOWN1,
+        PCF50633_REGULATOR_DOWN2,
+        PCF50633_REGULATOR_LDO1,
+        PCF50633_REGULATOR_LDO2,
+        PCF50633_REGULATOR_LDO3,
+        PCF50633_REGULATOR_LDO4,
+        PCF50633_REGULATOR_LDO5,
+        PCF50633_REGULATOR_LDO6,
+        PCF50633_REGULATOR_HCLDO,
+        PCF50633_REGULATOR_MEMLDO,
+};
+
+#define PCF50633_REG_AUTOOUT    0x1a
+#define PCF50633_REG_DOWN1OUT   0x1e
+#define PCF50633_REG_DOWN2OUT   0x22
+#define PCF50633_REG_MEMLDOOUT  0x26
+#define PCF50633_REG_LDO1OUT    0x2d
+#define PCF50633_REG_LDO2OUT    0x2f
+#define PCF50633_REG_LDO3OUT    0x31
+#define PCF50633_REG_LDO4OUT    0x33
+#define PCF50633_REG_LDO5OUT    0x35
+#define PCF50633_REG_LDO6OUT    0x37
+#define PCF50633_REG_HCLDOOUT   0x39
+
+static const u8 pcf50633_regulator_registers[PCF50633_NUM_REGULATORS] = {
+        [PCF50633_REGULATOR_AUTO]       = PCF50633_REG_AUTOOUT,
+        [PCF50633_REGULATOR_DOWN1]      = PCF50633_REG_DOWN1OUT,
+        [PCF50633_REGULATOR_DOWN2]      = PCF50633_REG_DOWN2OUT,
+        [PCF50633_REGULATOR_MEMLDO]     = PCF50633_REG_MEMLDOOUT,
+        [PCF50633_REGULATOR_LDO1]       = PCF50633_REG_LDO1OUT,
+        [PCF50633_REGULATOR_LDO2]       = PCF50633_REG_LDO2OUT,
+        [PCF50633_REGULATOR_LDO3]       = PCF50633_REG_LDO3OUT,
+        [PCF50633_REGULATOR_LDO4]       = PCF50633_REG_LDO4OUT,
+        [PCF50633_REGULATOR_LDO5]       = PCF50633_REG_LDO5OUT,
+        [PCF50633_REGULATOR_LDO6]       = PCF50633_REG_LDO6OUT,
+        [PCF50633_REGULATOR_HCLDO]      = PCF50633_REG_HCLDOOUT,
+};
+
+int pcf50633_gpio_set(struct pcf50633 *pcf, int gpio, u8 val)
+{
+        u8 reg;
+
+        reg = gpio - PCF50633_GPIO1 + PCF50633_REG_GPIO1CFG;
+
+        return pcf50633_reg_set_bit_mask(pcf, reg, 0x07, val);
+}
+EXPORT_SYMBOL_GPL(pcf50633_gpio_set);
+
+u8 pcf50633_gpio_get(struct pcf50633 *pcf, int gpio)
+{
+        u8 reg, val;
+
+        reg = gpio - PCF50633_GPIO1 + PCF50633_REG_GPIO1CFG;
+        val = pcf50633_reg_read(pcf, reg) & 0x07;
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(pcf50633_gpio_get);
+
+int pcf50633_gpio_invert_set(struct pcf50633 *pcf, int gpio, int invert)
+{
+        u8 val, reg;
+
+        reg = gpio - PCF50633_GPIO1 + PCF50633_REG_GPIO1CFG;
+        val = !!invert << 3;
+
+        return pcf50633_reg_set_bit_mask(pcf, reg, 1 << 3, val);
+}
+EXPORT_SYMBOL_GPL(pcf50633_gpio_invert_set);
+
+int pcf50633_gpio_invert_get(struct pcf50633 *pcf, int gpio)
+{
+        u8 reg, val;
+
+        reg = gpio - PCF50633_GPIO1 + PCF50633_REG_GPIO1CFG;
+        val = pcf50633_reg_read(pcf, reg);
+
+        return val & (1 << 3);
+}
+EXPORT_SYMBOL_GPL(pcf50633_gpio_invert_get);
+
+int pcf50633_gpio_power_supply_set(struct pcf50633 *pcf,
+                                        int gpio, int regulator, int on)
+{
+        u8 reg, val, mask;
+
+        /* the *ENA register is always one after the *OUT register */
+        reg = pcf50633_regulator_registers[regulator] + 1;
+
+        val = !!on << (gpio - PCF50633_GPIO1);
+        mask = 1 << (gpio - PCF50633_GPIO1);
+
+        return pcf50633_reg_set_bit_mask(pcf, reg, mask, val);
+}
+EXPORT_SYMBOL_GPL(pcf50633_gpio_power_supply_set);
diff --git a/drivers/mfd/sm501.c b/drivers/mfd/sm501.c
index 170f9d47c2f..0e5761f1263 100644
--- a/drivers/mfd/sm501.c
+++ b/drivers/mfd/sm501.c
@@ -41,6 +41,7 @@ struct sm501_gpio_chip {
         struct gpio_chip        gpio;
         struct sm501_gpio       *ourgpio;       /* to get back to parent. */
         void __iomem            *regbase;
+        void __iomem            *control;       /* address of control reg. */
 };
 
 struct sm501_gpio {
@@ -908,6 +909,25 @@ static int sm501_gpio_get(struct gpio_chip *chip, unsigned offset)
         return result & 1UL;
 }
 
+static void sm501_gpio_ensure_gpio(struct sm501_gpio_chip *smchip,
+                                   unsigned long bit)
+{
+        unsigned long ctrl;
+
+        /* check and modify if this pin is not set as gpio. */
+
+        if (readl(smchip->control) & bit) {
+                dev_info(sm501_gpio_to_dev(smchip->ourgpio)->dev,
+                         "changing mode of gpio, bit %08lx\n", bit);
+
+                ctrl = readl(smchip->control);
+                ctrl &= ~bit;
+                writel(ctrl, smchip->control);
+
+                sm501_sync_regs(sm501_gpio_to_dev(smchip->ourgpio));
+        }
+}
+
 static void sm501_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
 
 {
@@ -929,6 +949,8 @@ static void sm501_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
         writel(val, regs);
 
         sm501_sync_regs(sm501_gpio_to_dev(smgpio));
+        sm501_gpio_ensure_gpio(smchip, bit);
+
         spin_unlock_irqrestore(&smgpio->lock, save);
 }
 
@@ -941,8 +963,8 @@ static int sm501_gpio_input(struct gpio_chip *chip, unsigned offset)
         unsigned long save;
         unsigned long ddr;
 
-        dev_info(sm501_gpio_to_dev(smgpio)->dev, "%s(%p,%d)\n",
-                 __func__, chip, offset);
+        dev_dbg(sm501_gpio_to_dev(smgpio)->dev, "%s(%p,%d)\n",
+                __func__, chip, offset);
 
         spin_lock_irqsave(&smgpio->lock, save);
 
@@ -950,6 +972,8 @@ static int sm501_gpio_input(struct gpio_chip *chip, unsigned offset)
         writel(ddr & ~bit, regs + SM501_GPIO_DDR_LOW);
 
         sm501_sync_regs(sm501_gpio_to_dev(smgpio));
+        sm501_gpio_ensure_gpio(smchip, bit);
+
         spin_unlock_irqrestore(&smgpio->lock, save);
 
         return 0;
@@ -1012,9 +1036,11 @@ static int __devinit sm501_gpio_register_chip(struct sm501_devdata *sm,
                 if (base > 0)
                         base += 32;
                 chip->regbase = gpio->regs + SM501_GPIO_DATA_HIGH;
+                chip->control = sm->regs + SM501_GPIO63_32_CONTROL;
                 gchip->label  = "SM501-HIGH";
         } else {
                 chip->regbase = gpio->regs + SM501_GPIO_DATA_LOW;
+                chip->control = sm->regs + SM501_GPIO31_0_CONTROL;
                 gchip->label  = "SM501-LOW";
         }
 
diff --git a/drivers/mfd/twl4030-core.c b/drivers/mfd/twl4030-core.c
index b59c385cbc1..e7ab0035d30 100644
--- a/drivers/mfd/twl4030-core.c
+++ b/drivers/mfd/twl4030-core.c
@@ -38,6 +38,9 @@
 #include <linux/i2c.h>
 #include <linux/i2c/twl4030.h>
 
+#ifdef CONFIG_ARM
+#include <mach/cpu.h>
+#endif
 
 /*
  * The TWL4030 "Triton 2" is one of a family of a multi-function "Power
@@ -646,7 +649,7 @@ static inline int __init unprotect_pm_master(void)
         return e;
 }
 
-static void __init clocks_init(void)
+static void __init clocks_init(struct device *dev)
 {
         int e = 0;
         struct clk *osc;
@@ -655,9 +658,9 @@ static void __init clocks_init(void)
 
 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
         if (cpu_is_omap2430())
-                osc = clk_get(NULL, "osc_ck");
+                osc = clk_get(dev, "osc_ck");
         else
-                osc = clk_get(NULL, "osc_sys_ck");
+                osc = clk_get(dev, "osc_sys_ck");
 
         if (IS_ERR(osc)) {
                 printk(KERN_WARNING "Skipping twl4030 internal clock init and "
@@ -773,7 +776,7 @@ twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id)
         inuse = true;
 
         /* setup clock framework */
-        clocks_init();
+        clocks_init(&client->dev);
 
         /* Maybe init the T2 Interrupt subsystem */
         if (client->irq
diff --git a/drivers/misc/sgi-xp/xpc_main.c b/drivers/misc/sgi-xp/xpc_main.c
index 89218f7cfaa..6576170de96 100644
--- a/drivers/misc/sgi-xp/xpc_main.c
+++ b/drivers/misc/sgi-xp/xpc_main.c
@@ -318,7 +318,7 @@ xpc_hb_checker(void *ignore)
 
         /* this thread was marked active by xpc_hb_init() */
 
-        set_cpus_allowed_ptr(current, &cpumask_of_cpu(XPC_HB_CHECK_CPU));
+        set_cpus_allowed_ptr(current, cpumask_of(XPC_HB_CHECK_CPU));
 
         /* set our heartbeating to other partitions into motion */
         xpc_hb_check_timeout = jiffies + (xpc_hb_check_interval * HZ);
diff --git a/drivers/net/3c503.c b/drivers/net/3c503.c
index c092c392922..5b91a85fe10 100644
--- a/drivers/net/3c503.c
+++ b/drivers/net/3c503.c
@@ -177,6 +177,7 @@ static const struct net_device_ops el2_netdev_ops = {
         .ndo_get_stats          = eip_get_stats,
         .ndo_set_multicast_list = eip_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = eip_poll,
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 665e7fdf27a..cdbbb6226fc 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -3109,6 +3109,8 @@ static void acpi_set_WOL(struct net_device *dev)
         struct vortex_private *vp = netdev_priv(dev);
         void __iomem *ioaddr = vp->ioaddr;
 
+        device_set_wakeup_enable(vp->gendev, vp->enable_wol);
+
         if (vp->enable_wol) {
                 /* Power up on: 1==Downloaded Filter, 2==Magic Packets, 4==Link Status. */
                 EL3WINDOW(7);
diff --git a/drivers/net/8139cp.c b/drivers/net/8139cp.c
index dd7ac8290ae..4e19ae3ce6b 100644
--- a/drivers/net/8139cp.c
+++ b/drivers/net/8139cp.c
@@ -1821,6 +1821,7 @@ static const struct net_device_ops cp_netdev_ops = {
         .ndo_open               = cp_open,
         .ndo_stop               = cp_close,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_set_multicast_list = cp_set_rx_mode,
         .ndo_get_stats          = cp_get_stats,
         .ndo_do_ioctl           = cp_ioctl,
@@ -1832,6 +1833,7 @@ static const struct net_device_ops cp_netdev_ops = {
 #ifdef BROKEN
         .ndo_change_mtu         = cp_change_mtu,
 #endif
+
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = cp_poll_controller,
 #endif
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index fe370f80579..a5b24202d56 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -917,6 +917,7 @@ static const struct net_device_ops rtl8139_netdev_ops = {
         .ndo_stop               = rtl8139_close,
         .ndo_get_stats          = rtl8139_get_stats,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_start_xmit         = rtl8139_start_xmit,
         .ndo_set_multicast_list = rtl8139_set_rx_mode,
         .ndo_do_ioctl           = netdev_ioctl,
@@ -924,7 +925,6 @@ static const struct net_device_ops rtl8139_netdev_ops = {
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = rtl8139_poll_controller,
 #endif
-
 };
 
 static int __devinit rtl8139_init_one (struct pci_dev *pdev,
diff --git a/drivers/net/8390.c b/drivers/net/8390.c
index fbe609a51e0..ec3e22e6306 100644
--- a/drivers/net/8390.c
+++ b/drivers/net/8390.c
@@ -63,6 +63,7 @@ const struct net_device_ops ei_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/8390p.c b/drivers/net/8390p.c
index ee70b358a81..da863c91d1d 100644
--- a/drivers/net/8390p.c
+++ b/drivers/net/8390p.c
@@ -68,6 +68,7 @@ const struct net_device_ops eip_netdev_ops = {
         .ndo_get_stats          = eip_get_stats,
         .ndo_set_multicast_list = eip_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = eip_poll,
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 65afda4a62d..9fe8cb7d43a 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1600,7 +1600,7 @@ config 8139_OLD_RX_RESET
           old RX-reset behavior.  If unsure, say N.
 
 config R6040
-        tristate "RDC R6040 Fast Ethernet Adapter support (EXPERIMENTAL)"
+        tristate "RDC R6040 Fast Ethernet Adapter support"
         depends on NET_PCI && PCI
         select CRC32
         select MII
diff --git a/drivers/net/acenic.c b/drivers/net/acenic.c
index 5b396ff6c83..9589d620639 100644
--- a/drivers/net/acenic.c
+++ b/drivers/net/acenic.c
@@ -460,6 +460,7 @@ static const struct net_device_ops ace_netdev_ops = {
         .ndo_get_stats          = ace_get_stats,
         .ndo_start_xmit         = ace_start_xmit,
         .ndo_set_multicast_list = ace_set_multicast_list,
+        .ndo_validate_addr      = eth_validate_addr,
         .ndo_set_mac_address    = ace_set_mac_addr,
         .ndo_change_mtu         = ace_change_mtu,
 #if ACENIC_DO_VLAN
diff --git a/drivers/net/arm/etherh.c b/drivers/net/arm/etherh.c
index 6278606d104..745ac188bab 100644
--- a/drivers/net/arm/etherh.c
+++ b/drivers/net/arm/etherh.c
@@ -646,6 +646,7 @@ static const struct net_device_ops etherh_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_addr       = eth_set_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/arm/ks8695net.c b/drivers/net/arm/ks8695net.c
index 9ad22d1b00f..1cf2f949c0b 100644
--- a/drivers/net/arm/ks8695net.c
+++ b/drivers/net/arm/ks8695net.c
@@ -1357,6 +1357,7 @@ static const struct net_device_ops ks8695_netdev_ops = {
         .ndo_start_xmit         = ks8695_start_xmit,
         .ndo_tx_timeout         = ks8695_timeout,
         .ndo_set_mac_address    = ks8695_set_mac,
+        .ndo_validate_addr      = eth_validate_addr,
         .ndo_set_multicast_list = ks8695_set_multicast,
 };
 
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 6926ebedfdc..5ae131c147f 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -73,8 +73,8 @@
           (BP)->tx_cons - (BP)->tx_prod - TX_RING_GAP(BP))
 #define NEXT_TX(N)              (((N) + 1) & (B44_TX_RING_SIZE - 1))
 
-#define RX_PKT_OFFSET           30
-#define RX_PKT_BUF_SZ           (1536 + RX_PKT_OFFSET + 64)
+#define RX_PKT_OFFSET           (RX_HEADER_LEN + 2)
+#define RX_PKT_BUF_SZ           (1536 + RX_PKT_OFFSET)
 
 /* minimum number of free TX descriptors required to wake up TX process */
 #define B44_TX_WAKEUP_THRESH            (B44_TX_RING_SIZE / 4)
@@ -682,7 +682,6 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
         }
 
         rh = (struct rx_header *) skb->data;
-        skb_reserve(skb, RX_PKT_OFFSET);
 
         rh->len = 0;
         rh->flags = 0;
@@ -693,13 +692,13 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
         if (src_map != NULL)
                 src_map->skb = NULL;
 
-        ctrl  = (DESC_CTRL_LEN & (RX_PKT_BUF_SZ - RX_PKT_OFFSET));
+        ctrl = (DESC_CTRL_LEN & RX_PKT_BUF_SZ);
         if (dest_idx == (B44_RX_RING_SIZE - 1))
                 ctrl |= DESC_CTRL_EOT;
 
         dp = &bp->rx_ring[dest_idx];
         dp->ctrl = cpu_to_le32(ctrl);
-        dp->addr = cpu_to_le32((u32) mapping + RX_PKT_OFFSET + bp->dma_offset);
+        dp->addr = cpu_to_le32((u32) mapping + bp->dma_offset);
 
         if (bp->flags & B44_FLAG_RX_RING_HACK)
                 b44_sync_dma_desc_for_device(bp->sdev, bp->rx_ring_dma,
@@ -809,8 +808,8 @@ static int b44_rx(struct b44 *bp, int budget)
                         ssb_dma_unmap_single(bp->sdev, map,
                                              skb_size, DMA_FROM_DEVICE);
                         /* Leave out rx_header */
-                        skb_put(skb, len + RX_PKT_OFFSET);
-                        skb_pull(skb, RX_PKT_OFFSET);
+                        skb_put(skb, len + RX_PKT_OFFSET);
+                        skb_pull(skb, RX_PKT_OFFSET);
                 } else {
                         struct sk_buff *copy_skb;
 
diff --git a/drivers/net/cxgb3/adapter.h b/drivers/net/cxgb3/adapter.h
index 5b346f9eaa8..a89d8cc5120 100644
--- a/drivers/net/cxgb3/adapter.h
+++ b/drivers/net/cxgb3/adapter.h
@@ -50,12 +50,17 @@ struct vlan_group;
 struct adapter;
 struct sge_qset;
 
+enum {                  /* rx_offload flags */
+        T3_RX_CSUM      = 1 << 0,
+        T3_LRO          = 1 << 1,
+};
+
 struct port_info {
         struct adapter *adapter;
         struct vlan_group *vlan_grp;
         struct sge_qset *qs;
         u8 port_id;
-        u8 rx_csum_offload;
+        u8 rx_offload;
         u8 nqsets;
         u8 first_qset;
         struct cphy phy;
diff --git a/drivers/net/cxgb3/cxgb3_main.c b/drivers/net/cxgb3/cxgb3_main.c
index 2847f947499..0089746b8d0 100644
--- a/drivers/net/cxgb3/cxgb3_main.c
+++ b/drivers/net/cxgb3/cxgb3_main.c
@@ -546,7 +546,7 @@ static int setup_sge_qsets(struct adapter *adap)
                 pi->qs = &adap->sge.qs[pi->first_qset];
                 for (j = pi->first_qset; j < pi->first_qset + pi->nqsets;
                      ++j, ++qset_idx) {
-                        set_qset_lro(dev, qset_idx, pi->rx_csum_offload);
+                        set_qset_lro(dev, qset_idx, pi->rx_offload & T3_LRO);
                         err = t3_sge_alloc_qset(adap, qset_idx, 1,
                                 (adap->flags & USING_MSIX) ? qset_idx + 1 :
                                                              irq_idx,
@@ -1657,17 +1657,19 @@ static u32 get_rx_csum(struct net_device *dev)
 {
         struct port_info *p = netdev_priv(dev);
 
-        return p->rx_csum_offload;
+        return p->rx_offload & T3_RX_CSUM;
 }
 
 static int set_rx_csum(struct net_device *dev, u32 data)
 {
         struct port_info *p = netdev_priv(dev);
 
-        p->rx_csum_offload = data;
-        if (!data) {
+        if (data) {
+                p->rx_offload |= T3_RX_CSUM;
+        } else {
                 int i;
 
+                p->rx_offload &= ~(T3_RX_CSUM | T3_LRO);
                 for (i = p->first_qset; i < p->first_qset + p->nqsets; i++)
                         set_qset_lro(dev, i, 0);
         }
@@ -1830,15 +1832,18 @@ static int cxgb3_set_flags(struct net_device *dev, u32 data)
         int i;
 
         if (data & ETH_FLAG_LRO) {
-                if (!pi->rx_csum_offload)
+                if (!(pi->rx_offload & T3_RX_CSUM))
                         return -EINVAL;
 
+                pi->rx_offload |= T3_LRO;
                 for (i = pi->first_qset; i < pi->first_qset + pi->nqsets; i++)
                         set_qset_lro(dev, i, 1);
 
-        } else
+        } else {
+                pi->rx_offload &= ~T3_LRO;
                 for (i = pi->first_qset; i < pi->first_qset + pi->nqsets; i++)
                         set_qset_lro(dev, i, 0);
+        }
 
         return 0;
 }
@@ -1926,7 +1931,7 @@ static int cxgb_extension_ioctl(struct net_device *dev, void __user *useraddr)
                                 pi = adap2pinfo(adapter, i);
                                 if (t.qset_idx >= pi->first_qset &&
                                     t.qset_idx < pi->first_qset + pi->nqsets &&
-                                    !pi->rx_csum_offload)
+                                    !(pi->rx_offload & T3_RX_CSUM))
                                         return -EINVAL;
                         }
 
@@ -2946,7 +2951,7 @@ static int __devinit init_one(struct pci_dev *pdev,
                 adapter->port[i] = netdev;
                 pi = netdev_priv(netdev);
                 pi->adapter = adapter;
-                pi->rx_csum_offload = 1;
+                pi->rx_offload = T3_RX_CSUM | T3_LRO;
                 pi->port_id = i;
                 netif_carrier_off(netdev);
                 netif_tx_stop_all_queues(netdev);
@@ -2955,6 +2960,7 @@ static int __devinit init_one(struct pci_dev *pdev,
                 netdev->mem_end = mmio_start + mmio_len - 1;
                 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO;
                 netdev->features |= NETIF_F_LLTX;
+                netdev->features |= NETIF_F_LRO;
                 if (pci_using_dac)
                         netdev->features |= NETIF_F_HIGHDMA;
 
diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index 6c641a88947..14f9fb3e879 100644
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -1932,7 +1932,7 @@ static void rx_eth(struct adapter *adap, struct sge_rspq *rq,
         skb_pull(skb, sizeof(*p) + pad);
         skb->protocol = eth_type_trans(skb, adap->port[p->iff]);
         pi = netdev_priv(skb->dev);
-        if (pi->rx_csum_offload && p->csum_valid && p->csum == htons(0xffff) &&
+        if ((pi->rx_offload & T3_RX_CSUM) && p->csum_valid && p->csum == htons(0xffff) &&
             !p->fragment) {
                 qs->port_stats[SGE_PSTAT_RX_CSUM_GOOD]++;
                 skb->ip_summed = CHECKSUM_UNNECESSARY;
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index f2a5963b5a9..e415e81ecd3 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -390,7 +390,8 @@ static s32 e1000_get_variants_ich8lan(struct e1000_adapter *adapter)
 }
 
 static DEFINE_MUTEX(nvm_mutex);
-static pid_t nvm_owner = -1;
+static pid_t nvm_owner_pid = -1;
+static char nvm_owner_name[TASK_COMM_LEN] = "";
 
 /**
  *  e1000_acquire_swflag_ich8lan - Acquire software control flag
@@ -408,11 +409,15 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_hw *hw)
         might_sleep();
 
         if (!mutex_trylock(&nvm_mutex)) {
-                WARN(1, KERN_ERR "e1000e mutex contention. Owned by pid %d\n",
-                     nvm_owner);
+                WARN(1, KERN_ERR "e1000e mutex contention. Owned by process "
+                     "%s (pid %d), required by process %s (pid %d)\n",
+                     nvm_owner_name, nvm_owner_pid,
+                     current->comm, current->pid);
+
                 mutex_lock(&nvm_mutex);
         }
-        nvm_owner = current->pid;
+        nvm_owner_pid = current->pid;
+        strncpy(nvm_owner_name, current->comm, TASK_COMM_LEN);
 
         while (timeout) {
                 extcnf_ctrl = er32(EXTCNF_CTRL);
@@ -430,7 +435,8 @@ static s32 e1000_acquire_swflag_ich8lan(struct e1000_hw *hw)
                 hw_dbg(hw, "FW or HW has locked the resource for too long.\n");
                 extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
                 ew32(EXTCNF_CTRL, extcnf_ctrl);
-                nvm_owner = -1;
+                nvm_owner_pid = -1;
+                strcpy(nvm_owner_name, "");
                 mutex_unlock(&nvm_mutex);
                 return -E1000_ERR_CONFIG;
         }
@@ -454,7 +460,8 @@ static void e1000_release_swflag_ich8lan(struct e1000_hw *hw)
         extcnf_ctrl &= ~E1000_EXTCNF_CTRL_SWFLAG;
         ew32(EXTCNF_CTRL, extcnf_ctrl);
 
-        nvm_owner = -1;
+        nvm_owner_pid = -1;
+        strcpy(nvm_owner_name, "");
         mutex_unlock(&nvm_mutex);
 }
 
diff --git a/drivers/net/e2100.c b/drivers/net/e2100.c
index 20eb05cddb8..b07ba1924de 100644
--- a/drivers/net/e2100.c
+++ b/drivers/net/e2100.c
@@ -169,6 +169,7 @@ static const struct net_device_ops e21_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/enic/enic_main.c b/drivers/net/enic/enic_main.c
index d039e16f276..7d60551d538 100644
--- a/drivers/net/enic/enic_main.c
+++ b/drivers/net/enic/enic_main.c
@@ -1599,6 +1599,7 @@ static const struct net_device_ops enic_netdev_ops = {
         .ndo_start_xmit         = enic_hard_start_xmit,
         .ndo_get_stats          = enic_get_stats,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_set_multicast_list = enic_set_multicast_list,
         .ndo_change_mtu         = enic_change_mtu,
         .ndo_vlan_rx_register   = enic_vlan_rx_register,
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 5b68dc20168..5b910cf6374 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -13,7 +13,7 @@
  * Copyright (C) 2004 Andrew de Quincey (wol support)
  * Copyright (C) 2004 Carl-Daniel Hailfinger (invalid MAC handling, insane
  *              IRQ rate fixes, bigendian fixes, cleanups, verification)
- * Copyright (c) 2004,2005,2006,2007,2008 NVIDIA Corporation
+ * Copyright (c) 2004,2005,2006,2007,2008,2009 NVIDIA Corporation
  *
  * 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
@@ -39,7 +39,7 @@
  * DEV_NEED_TIMERIRQ will not harm you on sane hardware, only generating a few
  * superfluous timer interrupts from the nic.
  */
-#define FORCEDETH_VERSION               "0.61"
+#define FORCEDETH_VERSION               "0.62"
 #define DRV_NAME                        "forcedeth"
 
 #include <linux/module.h>
@@ -2096,14 +2096,15 @@ static int nv_start_xmit(struct sk_buff *skb, struct net_device *dev)
                            ((skb_shinfo(skb)->frags[i].size & (NV_TX2_TSO_MAX_SIZE-1)) ? 1 : 0);
         }
 
+        spin_lock_irqsave(&np->lock, flags);
         empty_slots = nv_get_empty_tx_slots(np);
         if (unlikely(empty_slots <= entries)) {
-                spin_lock_irqsave(&np->lock, flags);
                 netif_stop_queue(dev);
                 np->tx_stop = 1;
                 spin_unlock_irqrestore(&np->lock, flags);
                 return NETDEV_TX_BUSY;
         }
+        spin_unlock_irqrestore(&np->lock, flags);
 
         start_tx = put_tx = np->put_tx.orig;
 
@@ -2214,14 +2215,15 @@ static int nv_start_xmit_optimized(struct sk_buff *skb, struct net_device *dev)
                            ((skb_shinfo(skb)->frags[i].size & (NV_TX2_TSO_MAX_SIZE-1)) ? 1 : 0);
         }
 
+        spin_lock_irqsave(&np->lock, flags);
         empty_slots = nv_get_empty_tx_slots(np);
         if (unlikely(empty_slots <= entries)) {
-                spin_lock_irqsave(&np->lock, flags);
                 netif_stop_queue(dev);
                 np->tx_stop = 1;
                 spin_unlock_irqrestore(&np->lock, flags);
                 return NETDEV_TX_BUSY;
         }
+        spin_unlock_irqrestore(&np->lock, flags);
 
         start_tx = put_tx = np->put_tx.ex;
         start_tx_ctx = np->put_tx_ctx;
@@ -3403,10 +3405,10 @@ static irqreturn_t nv_nic_irq(int foo, void *data)
 
 #ifdef CONFIG_FORCEDETH_NAPI
                 if (events & NVREG_IRQ_RX_ALL) {
+                        spin_lock(&np->lock);
                         netif_rx_schedule(&np->napi);
 
                         /* Disable furthur receive irq's */
-                        spin_lock(&np->lock);
                         np->irqmask &= ~NVREG_IRQ_RX_ALL;
 
                         if (np->msi_flags & NV_MSI_X_ENABLED)
@@ -3520,10 +3522,10 @@ static irqreturn_t nv_nic_irq_optimized(int foo, void *data)
 
 #ifdef CONFIG_FORCEDETH_NAPI
                 if (events & NVREG_IRQ_RX_ALL) {
+                        spin_lock(&np->lock);
                         netif_rx_schedule(&np->napi);
 
                         /* Disable furthur receive irq's */
-                        spin_lock(&np->lock);
                         np->irqmask &= ~NVREG_IRQ_RX_ALL;
 
                         if (np->msi_flags & NV_MSI_X_ENABLED)
@@ -6167,19 +6169,19 @@ static struct pci_device_id pci_tbl[] = {
         },
         {       /* MCP79 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_36),
-                .driver_data = DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
+                .driver_data = DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
         },
         {       /* MCP79 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_37),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
         },
         {       /* MCP79 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_38),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
         },
         {       /* MCP79 Ethernet Controller */
                 PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_39),
-                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
+                .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_LARGEDESC|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX_V3|DEV_HAS_STATISTICS_V3|DEV_HAS_TEST_EXTENDED|DEV_HAS_CORRECT_MACADDR|DEV_HAS_COLLISION_FIX|DEV_NEED_TX_LIMIT|DEV_HAS_GEAR_MODE,
         },
         {0,},
 };
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 1b8deca8b9f..efcbeb6c867 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -296,6 +296,20 @@ err_out:
         return err;
 }
 
+/* Ioctl MII Interface */
+static int gfar_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
+{
+        struct gfar_private *priv = netdev_priv(dev);
+
+        if (!netif_running(dev))
+                return -EINVAL;
+
+        if (!priv->phydev)
+                return -ENODEV;
+
+        return phy_mii_ioctl(priv->phydev, if_mii(rq), cmd);
+}
+
 /* Set up the ethernet device structure, private data,
  * and anything else we need before we start */
 static int gfar_probe(struct of_device *ofdev,
@@ -366,6 +380,7 @@ static int gfar_probe(struct of_device *ofdev,
         dev->set_multicast_list = gfar_set_multi;
 
         dev->ethtool_ops = &gfar_ethtool_ops;
+        dev->do_ioctl = gfar_ioctl;
 
         if (priv->device_flags & FSL_GIANFAR_DEV_HAS_CSUM) {
                 priv->rx_csum_enable = 1;
diff --git a/drivers/net/hamachi.c b/drivers/net/hamachi.c
index 32200227c92..7e8b3c59a7d 100644
--- a/drivers/net/hamachi.c
+++ b/drivers/net/hamachi.c
@@ -576,6 +576,7 @@ static const struct net_device_ops hamachi_netdev_ops = {
         .ndo_set_multicast_list = set_rx_mode,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_tx_timeout         = hamachi_tx_timeout,
         .ndo_do_ioctl           = netdev_ioctl,
 };
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 50f1e172ee8..2d4089894ec 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -717,11 +717,12 @@ static int sixpack_ioctl(struct tty_struct *tty, struct file *file,
         unsigned int cmd, unsigned long arg)
 {
         struct sixpack *sp = sp_get(tty);
-        struct net_device *dev = sp->dev;
+        struct net_device *dev;
         unsigned int tmp, err;
 
         if (!sp)
                 return -ENXIO;
+        dev = sp->dev;
 
         switch(cmd) {
         case SIOCGIFNAME:
diff --git a/drivers/net/hp-plus.c b/drivers/net/hp-plus.c
index b507dbc16e6..5e070f44663 100644
--- a/drivers/net/hp-plus.c
+++ b/drivers/net/hp-plus.c
@@ -166,6 +166,7 @@ static const struct net_device_ops hpp_netdev_ops = {
         .ndo_get_stats          = eip_get_stats,
         .ndo_set_multicast_list = eip_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = eip_poll,
diff --git a/drivers/net/hydra.c b/drivers/net/hydra.c
index 9cb38a8d438..8ac0930c183 100644
--- a/drivers/net/hydra.c
+++ b/drivers/net/hydra.c
@@ -103,6 +103,7 @@ static const struct net_device_ops hydra_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/irda/au1k_ir.c b/drivers/net/irda/au1k_ir.c
index 75a1d0a86de..941164076a2 100644
--- a/drivers/net/irda/au1k_ir.c
+++ b/drivers/net/irda/au1k_ir.c
@@ -594,7 +594,7 @@ static int au1k_irda_rx(struct net_device *dev)
                         update_rx_stats(dev, flags, count);
                         skb=alloc_skb(count+1,GFP_ATOMIC);
                         if (skb == NULL) {
-                                aup->stats.rx_dropped++;
+                                aup->netdev->stats.rx_dropped++;
                                 continue;
                         }
                         skb_reserve(skb, 1);
diff --git a/drivers/net/irda/donauboe.c b/drivers/net/irda/donauboe.c
index 687c2d53d4d..6f3e7f71658 100644
--- a/drivers/net/irda/donauboe.c
+++ b/drivers/net/irda/donauboe.c
@@ -1194,13 +1194,13 @@ toshoboe_interrupt (int irq, void *dev_id)
               txp = txpc;
               txpc++;
               txpc %= TX_SLOTS;
-              self->stats.tx_packets++;
+              self->netdev->stats.tx_packets++;
               if (self->ring->tx[txpc].control & OBOE_CTL_TX_HW_OWNS)
                   self->ring->tx[txp].control &= ~OBOE_CTL_TX_RTCENTX;
             }
-          self->stats.tx_packets--;
+          self->netdev->stats.tx_packets--;
 #else
-          self->stats.tx_packets++;
+          self->netdev->stats.tx_packets++;
 #endif
           toshoboe_start_DMA(self, OBOE_CONFIG0H_ENTX);
         }
@@ -1280,7 +1280,7 @@ dumpbufs(self->rx_bufs[self->rxs],len,'<');
                       skb_put (skb, len);
                       skb_copy_to_linear_data(skb, self->rx_bufs[self->rxs],
                                               len);
-                      self->stats.rx_packets++;
+                      self->netdev->stats.rx_packets++;
                       skb->dev = self->netdev;
                       skb_reset_mac_header(skb);
                       skb->protocol = htons (ETH_P_IRDA);
diff --git a/drivers/net/mac8390.c b/drivers/net/mac8390.c
index 57716e22660..8e884869a05 100644
--- a/drivers/net/mac8390.c
+++ b/drivers/net/mac8390.c
@@ -486,6 +486,7 @@ static const struct net_device_ops mac8390_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/mlx4/en_netdev.c b/drivers/net/mlx4/en_netdev.c
index 15bb38d9930..9f6644a4403 100644
--- a/drivers/net/mlx4/en_netdev.c
+++ b/drivers/net/mlx4/en_netdev.c
@@ -952,6 +952,7 @@ static const struct net_device_ops mlx4_netdev_ops = {
         .ndo_get_stats          = mlx4_en_get_stats,
         .ndo_set_multicast_list = mlx4_en_set_multicast,
         .ndo_set_mac_address    = mlx4_en_set_mac,
+        .ndo_validate_addr      = eth_validate_addr,
         .ndo_change_mtu         = mlx4_en_change_mtu,
         .ndo_tx_timeout         = mlx4_en_tx_timeout,
         .ndo_vlan_rx_register   = mlx4_en_vlan_rx_register,
diff --git a/drivers/net/mlx4/main.c b/drivers/net/mlx4/main.c
index 710c79e7a2d..6ef2490d5c3 100644
--- a/drivers/net/mlx4/main.c
+++ b/drivers/net/mlx4/main.c
@@ -912,8 +912,8 @@ static void mlx4_enable_msi_x(struct mlx4_dev *dev)
         int i;
 
         if (msi_x) {
-                nreq = min(dev->caps.num_eqs - dev->caps.reserved_eqs,
-                           num_possible_cpus() + 1);
+                nreq = min_t(int, dev->caps.num_eqs - dev->caps.reserved_eqs,
+                             num_possible_cpus() + 1);
                 entries = kcalloc(nreq, sizeof *entries, GFP_KERNEL);
                 if (!entries)
                         goto no_msi;
diff --git a/drivers/net/ne-h8300.c b/drivers/net/ne-h8300.c
index b5723917104..7bd6662d5b0 100644
--- a/drivers/net/ne-h8300.c
+++ b/drivers/net/ne-h8300.c
@@ -202,6 +202,7 @@ static const struct net_device_ops ne_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/ne2k-pci.c b/drivers/net/ne2k-pci.c
index 62f20ba211c..f090d3b9ec9 100644
--- a/drivers/net/ne2k-pci.c
+++ b/drivers/net/ne2k-pci.c
@@ -208,6 +208,7 @@ static const struct net_device_ops ne2k_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller = ei_poll,
diff --git a/drivers/net/ns83820.c b/drivers/net/ns83820.c
index 42021aca1dd..e80294d8cc1 100644
--- a/drivers/net/ns83820.c
+++ b/drivers/net/ns83820.c
@@ -1956,6 +1956,7 @@ static const struct net_device_ops netdev_ops = {
         .ndo_change_mtu         = ns83820_change_mtu,
         .ndo_set_multicast_list = ns83820_set_multicast,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_tx_timeout         = ns83820_tx_timeout,
 #ifdef NS83820_VLAN_ACCEL_SUPPORT
         .ndo_vlan_rx_register   = ns83820_vlan_rx_register,
diff --git a/drivers/net/qlge/qlge.h b/drivers/net/qlge/qlge.h
index 459663a4023..c1dadadfab1 100644
--- a/drivers/net/qlge/qlge.h
+++ b/drivers/net/qlge/qlge.h
@@ -28,11 +28,11 @@
        } while (0)
 
 #define QLGE_VENDOR_ID    0x1077
-#define QLGE_DEVICE_ID1    0x8012
-#define QLGE_DEVICE_ID   0x8000
+#define QLGE_DEVICE_ID    0x8012
 
-#define MAX_RX_RINGS 128
-#define MAX_TX_RINGS 128
+#define MAX_CPUS 8
+#define MAX_TX_RINGS MAX_CPUS
+#define MAX_RX_RINGS ((MAX_CPUS * 2) + 1)
 
 #define NUM_TX_RING_ENTRIES     256
 #define NUM_RX_RING_ENTRIES     256
@@ -45,6 +45,7 @@
 #define MAX_SPLIT_SIZE 1023
 #define QLGE_SB_PAD 32
 
+#define MAX_CQ 128
 #define DFLT_COALESCE_WAIT 100  /* 100 usec wait for coalescing */
 #define MAX_INTER_FRAME_WAIT 10 /* 10 usec max interframe-wait for coalescing */
 #define DFLT_INTER_FRAME_WAIT (MAX_INTER_FRAME_WAIT/2)
@@ -961,8 +962,7 @@ struct ib_mac_iocb_rsp {
 #define IB_MAC_IOCB_RSP_DS      0x40    /* data is in small buffer */
 #define IB_MAC_IOCB_RSP_DL      0x80    /* data is in large buffer */
         __le32 data_len;        /* */
-        __le32 data_addr_lo;    /* */
-        __le32 data_addr_hi;    /* */
+        __le64 data_addr;       /* */
         __le32 rss;             /* */
         __le16 vlan_id;         /* 12 bits */
 #define IB_MAC_IOCB_RSP_C       0x1000  /* VLAN CFI bit */
@@ -976,8 +976,7 @@ struct ib_mac_iocb_rsp {
 #define IB_MAC_IOCB_RSP_HS      0x40
 #define IB_MAC_IOCB_RSP_HL      0x80
         __le32 hdr_len;         /* */
-        __le32 hdr_addr_lo;     /* */
-        __le32 hdr_addr_hi;     /* */
+        __le64 hdr_addr;        /* */
 } __attribute((packed));
 
 struct ib_ae_iocb_rsp {
@@ -1042,10 +1041,8 @@ struct wqicb {
         __le16 cq_id_rss;
 #define Q_CQ_ID_RSS_RV 0x8000
         __le16 rid;
-        __le32 addr_lo;
-        __le32 addr_hi;
-        __le32 cnsmr_idx_addr_lo;
-        __le32 cnsmr_idx_addr_hi;
+        __le64 addr;
+        __le64 cnsmr_idx_addr;
 } __attribute((packed));
 
 /*
@@ -1070,18 +1067,14 @@ struct cqicb {
 #define LEN_CPP_64      0x0002
 #define LEN_CPP_128     0x0003
         __le16 rid;
-        __le32 addr_lo;
-        __le32 addr_hi;
-        __le32 prod_idx_addr_lo;
-        __le32 prod_idx_addr_hi;
+        __le64 addr;
+        __le64 prod_idx_addr;
         __le16 pkt_delay;
         __le16 irq_delay;
-        __le32 lbq_addr_lo;
-        __le32 lbq_addr_hi;
+        __le64 lbq_addr;
         __le16 lbq_buf_size;
         __le16 lbq_len;         /* entry count */
-        __le32 sbq_addr_lo;
-        __le32 sbq_addr_hi;
+        __le64 sbq_addr;
         __le16 sbq_buf_size;
         __le16 sbq_len;         /* entry count */
 } __attribute((packed));
@@ -1145,7 +1138,7 @@ struct tx_ring {
         struct wqicb wqicb;     /* structure used to inform chip of new queue */
         void *wq_base;          /* pci_alloc:virtual addr for tx */
         dma_addr_t wq_base_dma; /* pci_alloc:dma addr for tx */
-        u32 *cnsmr_idx_sh_reg;  /* shadow copy of consumer idx */
+        __le32 *cnsmr_idx_sh_reg;       /* shadow copy of consumer idx */
         dma_addr_t cnsmr_idx_sh_reg_dma;        /* dma-shadow copy of consumer */
         u32 wq_size;            /* size in bytes of queue area */
         u32 wq_len;             /* number of entries in queue */
@@ -1181,7 +1174,7 @@ struct rx_ring {
         u32 cq_size;
         u32 cq_len;
         u16 cq_id;
-        volatile __le32 *prod_idx_sh_reg;       /* Shadowed producer register. */
+        __le32 *prod_idx_sh_reg;        /* Shadowed producer register. */
         dma_addr_t prod_idx_sh_reg_dma;
         void __iomem *cnsmr_idx_db_reg; /* PCI doorbell mem area + 0 */
         u32 cnsmr_idx;          /* current sw idx */
@@ -1402,9 +1395,11 @@ struct ql_adapter {
         int rx_ring_count;
         int ring_mem_size;
         void *ring_mem;
-        struct rx_ring *rx_ring;
+
+        struct rx_ring rx_ring[MAX_RX_RINGS];
+        struct tx_ring tx_ring[MAX_TX_RINGS];
+
         int rx_csum;
-        struct tx_ring *tx_ring;
         u32 default_rx_queue;
 
         u16 rx_coalesce_usecs;  /* cqicb->int_delay */
@@ -1459,6 +1454,24 @@ static inline void ql_write_db_reg(u32 val, void __iomem *addr)
         mmiowb();
 }
 
+/*
+ * Shadow Registers:
+ * Outbound queues have a consumer index that is maintained by the chip.
+ * Inbound queues have a producer index that is maintained by the chip.
+ * For lower overhead, these registers are "shadowed" to host memory
+ * which allows the device driver to track the queue progress without
+ * PCI reads. When an entry is placed on an inbound queue, the chip will
+ * update the relevant index register and then copy the value to the
+ * shadow register in host memory.
+ */
+static inline u32 ql_read_sh_reg(__le32  *addr)
+{
+        u32 reg;
+        reg =  le32_to_cpu(*addr);
+        rmb();
+        return reg;
+}
+
 extern char qlge_driver_name[];
 extern const char qlge_driver_version[];
 extern const struct ethtool_ops qlge_ethtool_ops;
diff --git a/drivers/net/qlge/qlge_dbg.c b/drivers/net/qlge/qlge_dbg.c
index 3f5e02d2e4a..379b895ed6e 100644
--- a/drivers/net/qlge/qlge_dbg.c
+++ b/drivers/net/qlge/qlge_dbg.c
@@ -435,14 +435,10 @@ void ql_dump_wqicb(struct wqicb *wqicb)
         printk(KERN_ERR PFX "wqicb->cq_id_rss = %d.\n",
                le16_to_cpu(wqicb->cq_id_rss));
         printk(KERN_ERR PFX "wqicb->rid = 0x%x.\n", le16_to_cpu(wqicb->rid));
-        printk(KERN_ERR PFX "wqicb->wq_addr_lo = 0x%.08x.\n",
-               le32_to_cpu(wqicb->addr_lo));
-        printk(KERN_ERR PFX "wqicb->wq_addr_hi = 0x%.08x.\n",
-               le32_to_cpu(wqicb->addr_hi));
-        printk(KERN_ERR PFX "wqicb->wq_cnsmr_idx_addr_lo = 0x%.08x.\n",
-               le32_to_cpu(wqicb->cnsmr_idx_addr_lo));
-        printk(KERN_ERR PFX "wqicb->wq_cnsmr_idx_addr_hi = 0x%.08x.\n",
-               le32_to_cpu(wqicb->cnsmr_idx_addr_hi));
+        printk(KERN_ERR PFX "wqicb->wq_addr = 0x%llx.\n",
+               (unsigned long long) le64_to_cpu(wqicb->addr));
+        printk(KERN_ERR PFX "wqicb->wq_cnsmr_idx_addr = 0x%llx.\n",
+               (unsigned long long) le64_to_cpu(wqicb->cnsmr_idx_addr));
 }
 
 void ql_dump_tx_ring(struct tx_ring *tx_ring)
@@ -455,10 +451,11 @@ void ql_dump_tx_ring(struct tx_ring *tx_ring)
         printk(KERN_ERR PFX "tx_ring->base = %p.\n", tx_ring->wq_base);
         printk(KERN_ERR PFX "tx_ring->base_dma = 0x%llx.\n",
                (unsigned long long) tx_ring->wq_base_dma);
-        printk(KERN_ERR PFX "tx_ring->cnsmr_idx_sh_reg = %p.\n",
-               tx_ring->cnsmr_idx_sh_reg);
-        printk(KERN_ERR PFX "tx_ring->cnsmr_idx_sh_reg_dma = 0x%llx.\n",
-               (unsigned long long) tx_ring->cnsmr_idx_sh_reg_dma);
+        printk(KERN_ERR PFX
+               "tx_ring->cnsmr_idx_sh_reg, addr = 0x%p, value = %d.\n",
+               tx_ring->cnsmr_idx_sh_reg,
+               tx_ring->cnsmr_idx_sh_reg
+                        ? ql_read_sh_reg(tx_ring->cnsmr_idx_sh_reg) : 0);
         printk(KERN_ERR PFX "tx_ring->size = %d.\n", tx_ring->wq_size);
         printk(KERN_ERR PFX "tx_ring->len = %d.\n", tx_ring->wq_len);
         printk(KERN_ERR PFX "tx_ring->prod_idx_db_reg = %p.\n",
@@ -510,30 +507,22 @@ void ql_dump_cqicb(struct cqicb *cqicb)
         printk(KERN_ERR PFX "cqicb->msix_vect = %d.\n", cqicb->msix_vect);
         printk(KERN_ERR PFX "cqicb->flags = %x.\n", cqicb->flags);
         printk(KERN_ERR PFX "cqicb->len = %d.\n", le16_to_cpu(cqicb->len));
-        printk(KERN_ERR PFX "cqicb->addr_lo = %x.\n",
-               le32_to_cpu(cqicb->addr_lo));
-        printk(KERN_ERR PFX "cqicb->addr_hi = %x.\n",
-               le32_to_cpu(cqicb->addr_hi));
-        printk(KERN_ERR PFX "cqicb->prod_idx_addr_lo = %x.\n",
-               le32_to_cpu(cqicb->prod_idx_addr_lo));
-        printk(KERN_ERR PFX "cqicb->prod_idx_addr_hi = %x.\n",
-               le32_to_cpu(cqicb->prod_idx_addr_hi));
+        printk(KERN_ERR PFX "cqicb->addr = 0x%llx.\n",
+               (unsigned long long) le64_to_cpu(cqicb->addr));
+        printk(KERN_ERR PFX "cqicb->prod_idx_addr = 0x%llx.\n",
+               (unsigned long long) le64_to_cpu(cqicb->prod_idx_addr));
         printk(KERN_ERR PFX "cqicb->pkt_delay = 0x%.04x.\n",
                le16_to_cpu(cqicb->pkt_delay));
         printk(KERN_ERR PFX "cqicb->irq_delay = 0x%.04x.\n",
                le16_to_cpu(cqicb->irq_delay));
-        printk(KERN_ERR PFX "cqicb->lbq_addr_lo = %x.\n",
-               le32_to_cpu(cqicb->lbq_addr_lo));
-        printk(KERN_ERR PFX "cqicb->lbq_addr_hi = %x.\n",
-               le32_to_cpu(cqicb->lbq_addr_hi));
+        printk(KERN_ERR PFX "cqicb->lbq_addr = 0x%llx.\n",
+               (unsigned long long) le64_to_cpu(cqicb->lbq_addr));
         printk(KERN_ERR PFX "cqicb->lbq_buf_size = 0x%.04x.\n",
                le16_to_cpu(cqicb->lbq_buf_size));
         printk(KERN_ERR PFX "cqicb->lbq_len = 0x%.04x.\n",
                le16_to_cpu(cqicb->lbq_len));
-        printk(KERN_ERR PFX "cqicb->sbq_addr_lo = %x.\n",
-               le32_to_cpu(cqicb->sbq_addr_lo));
-        printk(KERN_ERR PFX "cqicb->sbq_addr_hi = %x.\n",
-               le32_to_cpu(cqicb->sbq_addr_hi));
+        printk(KERN_ERR PFX "cqicb->sbq_addr = 0x%llx.\n",
+               (unsigned long long) le64_to_cpu(cqicb->sbq_addr));
         printk(KERN_ERR PFX "cqicb->sbq_buf_size = 0x%.04x.\n",
                le16_to_cpu(cqicb->sbq_buf_size));
         printk(KERN_ERR PFX "cqicb->sbq_len = 0x%.04x.\n",
@@ -558,9 +547,10 @@ void ql_dump_rx_ring(struct rx_ring *rx_ring)
         printk(KERN_ERR PFX "rx_ring->cq_size = %d.\n", rx_ring->cq_size);
         printk(KERN_ERR PFX "rx_ring->cq_len = %d.\n", rx_ring->cq_len);
         printk(KERN_ERR PFX
-               "rx_ring->prod_idx_sh_reg, addr = %p, value = %d.\n",
+               "rx_ring->prod_idx_sh_reg, addr = 0x%p, value = %d.\n",
                rx_ring->prod_idx_sh_reg,
-               rx_ring->prod_idx_sh_reg ? *(rx_ring->prod_idx_sh_reg) : 0);
+               rx_ring->prod_idx_sh_reg
+                        ? ql_read_sh_reg(rx_ring->prod_idx_sh_reg) : 0);
         printk(KERN_ERR PFX "rx_ring->prod_idx_sh_reg_dma = %llx.\n",
                (unsigned long long) rx_ring->prod_idx_sh_reg_dma);
         printk(KERN_ERR PFX "rx_ring->cnsmr_idx_db_reg = %p.\n",
@@ -809,10 +799,8 @@ void ql_dump_ib_mac_rsp(struct ib_mac_iocb_rsp *ib_mac_rsp)
 
         printk(KERN_ERR PFX "data_len   = %d\n",
                le32_to_cpu(ib_mac_rsp->data_len));
-        printk(KERN_ERR PFX "data_addr_hi    = 0x%x\n",
-               le32_to_cpu(ib_mac_rsp->data_addr_hi));
-        printk(KERN_ERR PFX "data_addr_lo    = 0x%x\n",
-               le32_to_cpu(ib_mac_rsp->data_addr_lo));
+        printk(KERN_ERR PFX "data_addr    = 0x%llx\n",
+               (unsigned long long) le64_to_cpu(ib_mac_rsp->data_addr));
         if (ib_mac_rsp->flags3 & IB_MAC_IOCB_RSP_RSS_MASK)
                 printk(KERN_ERR PFX "rss    = %x\n",
                        le32_to_cpu(ib_mac_rsp->rss));
@@ -828,10 +816,8 @@ void ql_dump_ib_mac_rsp(struct ib_mac_iocb_rsp *ib_mac_rsp)
         if (ib_mac_rsp->flags4 & IB_MAC_IOCB_RSP_HV) {
                 printk(KERN_ERR PFX "hdr length = %d.\n",
                        le32_to_cpu(ib_mac_rsp->hdr_len));
-                printk(KERN_ERR PFX "hdr addr_hi    = 0x%x.\n",
-                       le32_to_cpu(ib_mac_rsp->hdr_addr_hi));
-                printk(KERN_ERR PFX "hdr addr_lo    = 0x%x.\n",
-                       le32_to_cpu(ib_mac_rsp->hdr_addr_lo));
+                printk(KERN_ERR PFX "hdr addr    = 0x%llx.\n",
+                       (unsigned long long) le64_to_cpu(ib_mac_rsp->hdr_addr));
         }
 }
 #endif
diff --git a/drivers/net/qlge/qlge_main.c b/drivers/net/qlge/qlge_main.c
index f4c016012f1..45421c8b601 100644
--- a/drivers/net/qlge/qlge_main.c
+++ b/drivers/net/qlge/qlge_main.c
@@ -76,7 +76,6 @@ MODULE_PARM_DESC(irq_type, "0 = MSI-X, 1 = MSI, 2 = Legacy.");
 
 static struct pci_device_id qlge_pci_tbl[] __devinitdata = {
         {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QLGE_DEVICE_ID)},
-        {PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, QLGE_DEVICE_ID1)},
         /* required last entry */
         {0,}
 };
@@ -127,12 +126,12 @@ static int ql_sem_trylock(struct ql_adapter *qdev, u32 sem_mask)
 
 int ql_sem_spinlock(struct ql_adapter *qdev, u32 sem_mask)
 {
-        unsigned int seconds = 3;
+        unsigned int wait_count = 30;
         do {
                 if (!ql_sem_trylock(qdev, sem_mask))
                         return 0;
-                ssleep(1);
-        } while (--seconds);
+                udelay(100);
+        } while (--wait_count);
         return -ETIMEDOUT;
 }
 
@@ -1545,7 +1544,7 @@ static void ql_process_chip_ae_intr(struct ql_adapter *qdev,
 static int ql_clean_outbound_rx_ring(struct rx_ring *rx_ring)
 {
         struct ql_adapter *qdev = rx_ring->qdev;
-        u32 prod = le32_to_cpu(*rx_ring->prod_idx_sh_reg);
+        u32 prod = ql_read_sh_reg(rx_ring->prod_idx_sh_reg);
         struct ob_mac_iocb_rsp *net_rsp = NULL;
         int count = 0;
 
@@ -1571,7 +1570,7 @@ static int ql_clean_outbound_rx_ring(struct rx_ring *rx_ring)
                 }
                 count++;
                 ql_update_cq(rx_ring);
-                prod = le32_to_cpu(*rx_ring->prod_idx_sh_reg);
+                prod = ql_read_sh_reg(rx_ring->prod_idx_sh_reg);
         }
         ql_write_cq_idx(rx_ring);
         if (netif_queue_stopped(qdev->ndev) && net_rsp != NULL) {
@@ -1591,7 +1590,7 @@ static int ql_clean_outbound_rx_ring(struct rx_ring *rx_ring)
 static int ql_clean_inbound_rx_ring(struct rx_ring *rx_ring, int budget)
 {
         struct ql_adapter *qdev = rx_ring->qdev;
-        u32 prod = le32_to_cpu(*rx_ring->prod_idx_sh_reg);
+        u32 prod = ql_read_sh_reg(rx_ring->prod_idx_sh_reg);
         struct ql_net_rsp_iocb *net_rsp;
         int count = 0;
 
@@ -1624,7 +1623,7 @@ static int ql_clean_inbound_rx_ring(struct rx_ring *rx_ring, int budget)
                 }
                 count++;
                 ql_update_cq(rx_ring);
-                prod = le32_to_cpu(*rx_ring->prod_idx_sh_reg);
+                prod = ql_read_sh_reg(rx_ring->prod_idx_sh_reg);
                 if (count == budget)
                         break;
         }
@@ -1787,7 +1786,7 @@ static irqreturn_t qlge_isr(int irq, void *dev_id)
          * Check the default queue and wake handler if active.
          */
         rx_ring = &qdev->rx_ring[0];
-        if (le32_to_cpu(*rx_ring->prod_idx_sh_reg) != rx_ring->cnsmr_idx) {
+        if (ql_read_sh_reg(rx_ring->prod_idx_sh_reg) != rx_ring->cnsmr_idx) {
                 QPRINTK(qdev, INTR, INFO, "Waking handler for rx_ring[0].\n");
                 ql_disable_completion_interrupt(qdev, intr_context->intr);
                 queue_delayed_work_on(smp_processor_id(), qdev->q_workqueue,
@@ -1801,7 +1800,7 @@ static irqreturn_t qlge_isr(int irq, void *dev_id)
                  */
                 for (i = 1; i < qdev->rx_ring_count; i++) {
                         rx_ring = &qdev->rx_ring[i];
-                        if (le32_to_cpu(*rx_ring->prod_idx_sh_reg) !=
+                        if (ql_read_sh_reg(rx_ring->prod_idx_sh_reg) !=
                             rx_ring->cnsmr_idx) {
                                 QPRINTK(qdev, INTR, INFO,
                                         "Waking handler for rx_ring[%d].\n", i);
@@ -2356,28 +2355,6 @@ static void ql_tx_ring_clean(struct ql_adapter *qdev)
         }
 }
 
-static void ql_free_ring_cb(struct ql_adapter *qdev)
-{
-        kfree(qdev->ring_mem);
-}
-
-static int ql_alloc_ring_cb(struct ql_adapter *qdev)
-{
-        /* Allocate space for tx/rx ring control blocks. */
-        qdev->ring_mem_size =
-            (qdev->tx_ring_count * sizeof(struct tx_ring)) +
-            (qdev->rx_ring_count * sizeof(struct rx_ring));
-        qdev->ring_mem = kmalloc(qdev->ring_mem_size, GFP_KERNEL);
-        if (qdev->ring_mem == NULL) {
-                return -ENOMEM;
-        } else {
-                qdev->rx_ring = qdev->ring_mem;
-                qdev->tx_ring = qdev->ring_mem +
-                    (qdev->rx_ring_count * sizeof(struct rx_ring));
-        }
-        return 0;
-}
-
 static void ql_free_mem_resources(struct ql_adapter *qdev)
 {
         int i;
@@ -2467,12 +2444,9 @@ static int ql_start_rx_ring(struct ql_adapter *qdev, struct rx_ring *rx_ring)
         bq_len = (rx_ring->cq_len == 65536) ? 0 : (u16) rx_ring->cq_len;
         cqicb->len = cpu_to_le16(bq_len | LEN_V | LEN_CPP_CONT);
 
-        cqicb->addr_lo = cpu_to_le32(rx_ring->cq_base_dma);
-        cqicb->addr_hi = cpu_to_le32((u64) rx_ring->cq_base_dma >> 32);
+        cqicb->addr = cpu_to_le64(rx_ring->cq_base_dma);
 
-        cqicb->prod_idx_addr_lo = cpu_to_le32(rx_ring->prod_idx_sh_reg_dma);
-        cqicb->prod_idx_addr_hi =
-            cpu_to_le32((u64) rx_ring->prod_idx_sh_reg_dma >> 32);
+        cqicb->prod_idx_addr = cpu_to_le64(rx_ring->prod_idx_sh_reg_dma);
 
         /*
          * Set up the control block load flags.
@@ -2483,10 +2457,8 @@ static int ql_start_rx_ring(struct ql_adapter *qdev, struct rx_ring *rx_ring)
         if (rx_ring->lbq_len) {
                 cqicb->flags |= FLAGS_LL;       /* Load lbq values */
                 *((u64 *) rx_ring->lbq_base_indirect) = rx_ring->lbq_base_dma;
-                cqicb->lbq_addr_lo =
-                    cpu_to_le32(rx_ring->lbq_base_indirect_dma);
-                cqicb->lbq_addr_hi =
-                    cpu_to_le32((u64) rx_ring->lbq_base_indirect_dma >> 32);
+                cqicb->lbq_addr =
+                    cpu_to_le64(rx_ring->lbq_base_indirect_dma);
                 bq_len = (rx_ring->lbq_buf_size == 65536) ? 0 :
                         (u16) rx_ring->lbq_buf_size;
                 cqicb->lbq_buf_size = cpu_to_le16(bq_len);
@@ -2501,10 +2473,8 @@ static int ql_start_rx_ring(struct ql_adapter *qdev, struct rx_ring *rx_ring)
         if (rx_ring->sbq_len) {
                 cqicb->flags |= FLAGS_LS;       /* Load sbq values */
                 *((u64 *) rx_ring->sbq_base_indirect) = rx_ring->sbq_base_dma;
-                cqicb->sbq_addr_lo =
-                    cpu_to_le32(rx_ring->sbq_base_indirect_dma);
-                cqicb->sbq_addr_hi =
-                    cpu_to_le32((u64) rx_ring->sbq_base_indirect_dma >> 32);
+                cqicb->sbq_addr =
+                    cpu_to_le64(rx_ring->sbq_base_indirect_dma);
                 cqicb->sbq_buf_size =
                     cpu_to_le16(((rx_ring->sbq_buf_size / 2) + 8) & 0xfffffff8);
                 bq_len = (rx_ring->sbq_len == 65536) ? 0 :
@@ -2611,12 +2581,9 @@ static int ql_start_tx_ring(struct ql_adapter *qdev, struct tx_ring *tx_ring)
                                    Q_FLAGS_LB | Q_FLAGS_LI | Q_FLAGS_LO);
         wqicb->cq_id_rss = cpu_to_le16(tx_ring->cq_id);
         wqicb->rid = 0;
-        wqicb->addr_lo = cpu_to_le32(tx_ring->wq_base_dma);
-        wqicb->addr_hi = cpu_to_le32((u64) tx_ring->wq_base_dma >> 32);
+        wqicb->addr = cpu_to_le64(tx_ring->wq_base_dma);
 
-        wqicb->cnsmr_idx_addr_lo = cpu_to_le32(tx_ring->cnsmr_idx_sh_reg_dma);
-        wqicb->cnsmr_idx_addr_hi =
-            cpu_to_le32((u64) tx_ring->cnsmr_idx_sh_reg_dma >> 32);
+        wqicb->cnsmr_idx_addr = cpu_to_le64(tx_ring->cnsmr_idx_sh_reg_dma);
 
         ql_init_tx_ring(qdev, tx_ring);
 
@@ -2746,14 +2713,14 @@ static void ql_resolve_queues_to_irqs(struct ql_adapter *qdev)
                                  * Outbound queue is for outbound completions only.
                                  */
                                 intr_context->handler = qlge_msix_tx_isr;
-                                sprintf(intr_context->name, "%s-txq-%d",
+                                sprintf(intr_context->name, "%s-tx-%d",
                                         qdev->ndev->name, i);
                         } else {
                                 /*
                                  * Inbound queues handle unicast frames only.
                                  */
                                 intr_context->handler = qlge_msix_rx_isr;
-                                sprintf(intr_context->name, "%s-rxq-%d",
+                                sprintf(intr_context->name, "%s-rx-%d",
                                         qdev->ndev->name, i);
                         }
                 }
@@ -3247,7 +3214,6 @@ static int qlge_close(struct net_device *ndev)
                 msleep(1);
         ql_adapter_down(qdev);
         ql_release_adapter_resources(qdev);
-        ql_free_ring_cb(qdev);
         return 0;
 }
 
@@ -3273,8 +3239,8 @@ static int ql_configure_rings(struct ql_adapter *qdev)
          * This limitation can be removed when requested.
          */
 
-        if (cpu_cnt > 8)
-                cpu_cnt = 8;
+        if (cpu_cnt > MAX_CPUS)
+                cpu_cnt = MAX_CPUS;
 
         /*
          * rx_ring[0] is always the default queue.
@@ -3294,9 +3260,6 @@ static int ql_configure_rings(struct ql_adapter *qdev)
          */
         qdev->rx_ring_count = qdev->tx_ring_count + qdev->rss_ring_count + 1;
 
-        if (ql_alloc_ring_cb(qdev))
-                return -ENOMEM;
-
         for (i = 0; i < qdev->tx_ring_count; i++) {
                 tx_ring = &qdev->tx_ring[i];
                 memset((void *)tx_ring, 0, sizeof(tx_ring));
@@ -3393,7 +3356,6 @@ static int qlge_open(struct net_device *ndev)
 
 error_up:
         ql_release_adapter_resources(qdev);
-        ql_free_ring_cb(qdev);
         return err;
 }
 
diff --git a/drivers/net/r6040.c b/drivers/net/r6040.c
index cf3a082bc89..72fd9e97c19 100644
--- a/drivers/net/r6040.c
+++ b/drivers/net/r6040.c
@@ -49,8 +49,8 @@
 #include <asm/processor.h>
 
 #define DRV_NAME        "r6040"
-#define DRV_VERSION     "0.20"
-#define DRV_RELDATE     "07Jan2009"
+#define DRV_VERSION     "0.21"
+#define DRV_RELDATE     "09Jan2009"
 
 /* PHY CHIP Address */
 #define PHY1_ADDR       1       /* For MAC1 */
@@ -457,22 +457,12 @@ static void r6040_down(struct net_device *dev)
         iowrite16(adrp[0], ioaddr + MID_0L);
         iowrite16(adrp[1], ioaddr + MID_0M);
         iowrite16(adrp[2], ioaddr + MID_0H);
-        free_irq(dev->irq, dev);
-
-        /* Free RX buffer */
-        r6040_free_rxbufs(dev);
-
-        /* Free TX buffer */
-        r6040_free_txbufs(dev);
-
-        /* Free Descriptor memory */
-        pci_free_consistent(pdev, RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma);
-        pci_free_consistent(pdev, TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma);
 }
 
 static int r6040_close(struct net_device *dev)
 {
         struct r6040_private *lp = netdev_priv(dev);
+        struct pci_dev *pdev = lp->pdev;
 
         /* deleted timer */
         del_timer_sync(&lp->timer);
@@ -481,8 +471,28 @@ static int r6040_close(struct net_device *dev)
         napi_disable(&lp->napi);
         netif_stop_queue(dev);
         r6040_down(dev);
+
+        free_irq(dev->irq, dev);
+
+        /* Free RX buffer */
+        r6040_free_rxbufs(dev);
+
+        /* Free TX buffer */
+        r6040_free_txbufs(dev);
+
         spin_unlock_irq(&lp->lock);
 
+        /* Free Descriptor memory */
+        if (lp->rx_ring) {
+                pci_free_consistent(pdev, RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma);
+                lp->rx_ring = 0;
+        }
+
+        if (lp->tx_ring) {
+                pci_free_consistent(pdev, TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma);
+                lp->tx_ring = 0;
+        }
+
         return 0;
 }
 
@@ -1049,6 +1059,7 @@ static const struct net_device_ops r6040_netdev_ops = {
         .ndo_set_multicast_list = r6040_multicast_list,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_do_ioctl           = r6040_ioctl,
         .ndo_tx_timeout         = r6040_tx_timeout,
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -1143,8 +1154,10 @@ static int __devinit r6040_init_one(struct pci_dev *pdev,
 
         /* Some bootloader/BIOSes do not initialize
          * MAC address, warn about that */
-        if (!(adrp[0] || adrp[1] || adrp[2]))
-                printk(KERN_WARNING DRV_NAME ": MAC address not initialized\n");
+        if (!(adrp[0] || adrp[1] || adrp[2])) {
+                printk(KERN_WARNING DRV_NAME ": MAC address not initialized, generating random\n");
+                random_ether_addr(dev->dev_addr);
+        }
 
         /* Link new device into r6040_root_dev */
         lp->pdev = pdev;
diff --git a/drivers/net/sc92031.c b/drivers/net/sc92031.c
index 42fd3127660..8b75bef4a84 100644
--- a/drivers/net/sc92031.c
+++ b/drivers/net/sc92031.c
@@ -1408,6 +1408,7 @@ static const struct net_device_ops sc92031_netdev_ops = {
         .ndo_set_multicast_list = sc92031_set_multicast_list,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_tx_timeout         = sc92031_tx_timeout,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = sc92031_poll_controller,
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index 7673fd92eaf..101c00a7bb7 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -854,20 +854,27 @@ static void efx_fini_io(struct efx_nic *efx)
  * interrupts across them. */
 static int efx_wanted_rx_queues(void)
 {
-        cpumask_t core_mask;
+        cpumask_var_t core_mask;
         int count;
         int cpu;
 
-        cpus_clear(core_mask);
+        if (!alloc_cpumask_var(&core_mask, GFP_KERNEL)) {
+                printk(KERN_WARNING
+                       "efx.c: allocation failure, irq balancing hobbled\n");
+                return 1;
+        }
+
+        cpumask_clear(core_mask);
         count = 0;
         for_each_online_cpu(cpu) {
-                if (!cpu_isset(cpu, core_mask)) {
+                if (!cpumask_test_cpu(cpu, core_mask)) {
                         ++count;
-                        cpus_or(core_mask, core_mask,
-                                topology_core_siblings(cpu));
+                        cpumask_or(core_mask, core_mask,
+                                   topology_core_cpumask(cpu));
                 }
         }
 
+        free_cpumask_var(core_mask);
         return count;
 }
 
diff --git a/drivers/net/sfc/tenxpress.c b/drivers/net/sfc/tenxpress.c
index b9768760fae..9ecb77da954 100644
--- a/drivers/net/sfc/tenxpress.c
+++ b/drivers/net/sfc/tenxpress.c
@@ -636,10 +636,11 @@ static void tenxpress_phy_fini(struct efx_nic *efx)
 {
         int reg;
 
-        if (efx->phy_type == PHY_TYPE_SFT9001B) {
+        if (efx->phy_type == PHY_TYPE_SFT9001B)
                 device_remove_file(&efx->pci_dev->dev,
                                    &dev_attr_phy_short_reach);
-        } else {
+
+        if (efx->phy_type == PHY_TYPE_SFX7101) {
                 /* Power down the LNPGA */
                 reg = (1 << PMA_PMD_LNPGA_POWERDOWN_LBN);
                 mdio_clause45_write(efx, efx->mii.phy_id, MDIO_MMD_PMAPMD,
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 4acd41a093a..6cbefcae9ac 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -389,6 +389,7 @@ static const struct net_device_ops sis900_netdev_ops = {
         .ndo_set_multicast_list = set_rx_mode,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_do_ioctl           = mii_ioctl,
         .ndo_tx_timeout         = sis900_tx_timeout,
 #ifdef CONFIG_NET_POLL_CONTROLLER
diff --git a/drivers/net/smc-mca.c b/drivers/net/smc-mca.c
index 404b80e5ba1..8d36d40649e 100644
--- a/drivers/net/smc-mca.c
+++ b/drivers/net/smc-mca.c
@@ -192,6 +192,7 @@ static const struct net_device_ops ultramca_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/smc-ultra.c b/drivers/net/smc-ultra.c
index b3866089a20..2033fee3143 100644
--- a/drivers/net/smc-ultra.c
+++ b/drivers/net/smc-ultra.c
@@ -196,6 +196,7 @@ static const struct net_device_ops ultra_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/smsc911x.c b/drivers/net/smsc911x.c
index dc3f1108884..f513bdf1c88 100644
--- a/drivers/net/smsc911x.c
+++ b/drivers/net/smsc911x.c
@@ -144,6 +144,7 @@ static inline u32 smsc911x_reg_read(struct smsc911x_data *pdata, u32 reg)
         }
 
         BUG();
+        return 0;
 }
 
 static inline void smsc911x_reg_write(struct smsc911x_data *pdata, u32 reg,
@@ -1740,6 +1741,7 @@ static const struct net_device_ops smsc911x_netdev_ops = {
         .ndo_set_multicast_list = smsc911x_set_multicast_list,
         .ndo_do_ioctl           = smsc911x_do_ioctl,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = smsc911x_poll_controller,
 #endif
@@ -1967,7 +1969,7 @@ static int __devinit smsc911x_drv_probe(struct platform_device *pdev)
         smsc911x_reg_write(pdata, INT_STS, 0xFFFFFFFF);
 
         retval = request_irq(dev->irq, smsc911x_irqhandler, IRQF_DISABLED,
-                             SMSC_CHIPNAME, dev);
+                             dev->name, dev);
         if (retval) {
                 SMSC_WARNING(PROBE,
                         "Unable to claim requested irq: %d", dev->irq);
diff --git a/drivers/net/smsc9420.c b/drivers/net/smsc9420.c
index 27e017d9696..c14a4c6452c 100644
--- a/drivers/net/smsc9420.c
+++ b/drivers/net/smsc9420.c
@@ -1551,6 +1551,7 @@ static const struct net_device_ops smsc9420_netdev_ops = {
         .ndo_set_multicast_list = smsc9420_set_multicast_list,
         .ndo_do_ioctl           = smsc9420_do_ioctl,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = smsc9420_poll_controller,
 #endif /* CONFIG_NET_POLL_CONTROLLER */
diff --git a/drivers/net/ucc_geth.c b/drivers/net/ucc_geth.c
index 7d5a1303e30..11441225bf4 100644
--- a/drivers/net/ucc_geth.c
+++ b/drivers/net/ucc_geth.c
@@ -442,40 +442,30 @@ static void magic_packet_detection_enable(struct ucc_geth_private *ugeth)
 {
         struct ucc_fast_private *uccf;
         struct ucc_geth __iomem *ug_regs;
-        u32 maccfg2, uccm;
 
         uccf = ugeth->uccf;
         ug_regs = ugeth->ug_regs;
 
         /* Enable interrupts for magic packet detection */
-        uccm = in_be32(uccf->p_uccm);
-        uccm |= UCCE_MPD;
-        out_be32(uccf->p_uccm, uccm);
+        setbits32(uccf->p_uccm, UCC_GETH_UCCE_MPD);
 
         /* Enable magic packet detection */
-        maccfg2 = in_be32(&ug_regs->maccfg2);
-        maccfg2 |= MACCFG2_MPE;
-        out_be32(&ug_regs->maccfg2, maccfg2);
+        setbits32(&ug_regs->maccfg2, MACCFG2_MPE);
 }
 
 static void magic_packet_detection_disable(struct ucc_geth_private *ugeth)
 {
         struct ucc_fast_private *uccf;
         struct ucc_geth __iomem *ug_regs;
-        u32 maccfg2, uccm;
 
         uccf = ugeth->uccf;
         ug_regs = ugeth->ug_regs;
 
         /* Disable interrupts for magic packet detection */
-        uccm = in_be32(uccf->p_uccm);
-        uccm &= ~UCCE_MPD;
-        out_be32(uccf->p_uccm, uccm);
+        clrbits32(uccf->p_uccm, UCC_GETH_UCCE_MPD);
 
         /* Disable magic packet detection */
-        maccfg2 = in_be32(&ug_regs->maccfg2);
-        maccfg2 &= ~MACCFG2_MPE;
-        out_be32(&ug_regs->maccfg2, maccfg2);
+        clrbits32(&ug_regs->maccfg2, MACCFG2_MPE);
 }
 #endif /* MAGIC_PACKET */
 
@@ -585,7 +575,8 @@ static void get_statistics(struct ucc_geth_private *ugeth,
 
         /* Hardware only if user handed pointer and driver actually
         gathers hardware statistics */
-        if (hardware_statistics && (in_be32(&uf_regs->upsmr) & UPSMR_HSE)) {
+        if (hardware_statistics &&
+            (in_be32(&uf_regs->upsmr) & UCC_GETH_UPSMR_HSE)) {
                 hardware_statistics->tx64 = in_be32(&ug_regs->tx64);
                 hardware_statistics->tx127 = in_be32(&ug_regs->tx127);
                 hardware_statistics->tx255 = in_be32(&ug_regs->tx255);
@@ -1181,9 +1172,7 @@ int init_flow_control_params(u32 automatic_flow_control_mode,
         out_be32(uempr_register, value);
 
         /* Set UPSMR register */
-        value = in_be32(upsmr_register);
-        value |= automatic_flow_control_mode;
-        out_be32(upsmr_register, value);
+        setbits32(upsmr_register, automatic_flow_control_mode);
 
         value = in_be32(maccfg1_register);
         if (rx_flow_control_enable)
@@ -1200,14 +1189,11 @@ static int init_hw_statistics_gathering_mode(int enable_hardware_statistics,
                                              u32 __iomem *upsmr_register,
                                              u16 __iomem *uescr_register)
 {
-        u32 upsmr_value = 0;
         u16 uescr_value = 0;
+
         /* Enable hardware statistics gathering if requested */
-        if (enable_hardware_statistics) {
-                upsmr_value = in_be32(upsmr_register);
-                upsmr_value |= UPSMR_HSE;
-                out_be32(upsmr_register, upsmr_value);
-        }
+        if (enable_hardware_statistics)
+                setbits32(upsmr_register, UCC_GETH_UPSMR_HSE);
 
         /* Clear hardware statistics counters */
         uescr_value = in_be16(uescr_register);
@@ -1233,23 +1219,17 @@ static int init_firmware_statistics_gathering_mode(int
 {
         /* Note: this function does not check if */
         /* the parameters it receives are NULL   */
-        u16 temoder_value;
-        u32 remoder_value;
 
         if (enable_tx_firmware_statistics) {
                 out_be32(tx_rmon_base_ptr,
                          tx_firmware_statistics_structure_address);
-                temoder_value = in_be16(temoder_register);
-                temoder_value |= TEMODER_TX_RMON_STATISTICS_ENABLE;
-                out_be16(temoder_register, temoder_value);
+                setbits16(temoder_register, TEMODER_TX_RMON_STATISTICS_ENABLE);
         }
 
         if (enable_rx_firmware_statistics) {
                 out_be32(rx_rmon_base_ptr,
                          rx_firmware_statistics_structure_address);
-                remoder_value = in_be32(remoder_register);
-                remoder_value |= REMODER_RX_RMON_STATISTICS_ENABLE;
-                out_be32(remoder_register, remoder_value);
+                setbits32(remoder_register, REMODER_RX_RMON_STATISTICS_ENABLE);
         }
 
         return 0;
@@ -1316,15 +1296,12 @@ static int init_check_frame_length_mode(int length_check,
 static int init_preamble_length(u8 preamble_length,
                                 u32 __iomem *maccfg2_register)
 {
-        u32 value = 0;
-
         if ((preamble_length < 3) || (preamble_length > 7))
                 return -EINVAL;
 
-        value = in_be32(maccfg2_register);
-        value &= ~MACCFG2_PREL_MASK;
-        value |= (preamble_length << MACCFG2_PREL_SHIFT);
-        out_be32(maccfg2_register, value);
+        clrsetbits_be32(maccfg2_register, MACCFG2_PREL_MASK,
+                        preamble_length << MACCFG2_PREL_SHIFT);
+
         return 0;
 }
 
@@ -1337,19 +1314,19 @@ static int init_rx_parameters(int reject_broadcast,
         value = in_be32(upsmr_register);
 
         if (reject_broadcast)
-                value |= UPSMR_BRO;
+                value |= UCC_GETH_UPSMR_BRO;
         else
-                value &= ~UPSMR_BRO;
+                value &= ~UCC_GETH_UPSMR_BRO;
 
         if (receive_short_frames)
-                value |= UPSMR_RSH;
+                value |= UCC_GETH_UPSMR_RSH;
         else
-                value &= ~UPSMR_RSH;
+                value &= ~UCC_GETH_UPSMR_RSH;
 
         if (promiscuous)
-                value |= UPSMR_PRO;
+                value |= UCC_GETH_UPSMR_PRO;
         else
-                value &= ~UPSMR_PRO;
+                value &= ~UCC_GETH_UPSMR_PRO;
 
         out_be32(upsmr_register, value);
 
@@ -1410,26 +1387,27 @@ static int adjust_enet_interface(struct ucc_geth_private *ugeth)
 
         /*                    Set UPSMR                      */
         upsmr = in_be32(&uf_regs->upsmr);
-        upsmr &= ~(UPSMR_RPM | UPSMR_R10M | UPSMR_TBIM | UPSMR_RMM);
+        upsmr &= ~(UCC_GETH_UPSMR_RPM | UCC_GETH_UPSMR_R10M |
+                   UCC_GETH_UPSMR_TBIM | UCC_GETH_UPSMR_RMM);
         if ((ugeth->phy_interface == PHY_INTERFACE_MODE_RMII) ||
             (ugeth->phy_interface == PHY_INTERFACE_MODE_RGMII) ||
             (ugeth->phy_interface == PHY_INTERFACE_MODE_RGMII_ID) ||
             (ugeth->phy_interface == PHY_INTERFACE_MODE_RGMII_RXID) ||
             (ugeth->phy_interface == PHY_INTERFACE_MODE_RGMII_TXID) ||
             (ugeth->phy_interface == PHY_INTERFACE_MODE_RTBI)) {
-                upsmr |= UPSMR_RPM;
+                upsmr |= UCC_GETH_UPSMR_RPM;
                 switch (ugeth->max_speed) {
                 case SPEED_10:
-                        upsmr |= UPSMR_R10M;
+                        upsmr |= UCC_GETH_UPSMR_R10M;
                         /* FALLTHROUGH */
                 case SPEED_100:
                         if (ugeth->phy_interface != PHY_INTERFACE_MODE_RTBI)
-                                upsmr |= UPSMR_RMM;
+                                upsmr |= UCC_GETH_UPSMR_RMM;
                 }
         }
         if ((ugeth->phy_interface == PHY_INTERFACE_MODE_TBI) ||
             (ugeth->phy_interface == PHY_INTERFACE_MODE_RTBI)) {
-                upsmr |= UPSMR_TBIM;
+                upsmr |= UCC_GETH_UPSMR_TBIM;
         }
         out_be32(&uf_regs->upsmr, upsmr);
 
@@ -1517,9 +1495,9 @@ static void adjust_link(struct net_device *dev)
                                     (ugeth->phy_interface == PHY_INTERFACE_MODE_RGMII_TXID) ||
                                     (ugeth->phy_interface == PHY_INTERFACE_MODE_RTBI)) {
                                         if (phydev->speed == SPEED_10)
-                                                upsmr |= UPSMR_R10M;
+                                                upsmr |= UCC_GETH_UPSMR_R10M;
                                         else
-                                                upsmr &= ~(UPSMR_R10M);
+                                                upsmr &= ~UCC_GETH_UPSMR_R10M;
                                 }
                                 break;
                         default:
@@ -1602,10 +1580,8 @@ static int ugeth_graceful_stop_tx(struct ucc_geth_private *ugeth)
         uccf = ugeth->uccf;
 
         /* Mask GRACEFUL STOP TX interrupt bit and clear it */
-        temp = in_be32(uccf->p_uccm);
-        temp &= ~UCCE_GRA;
-        out_be32(uccf->p_uccm, temp);
-        out_be32(uccf->p_ucce, UCCE_GRA);       /* clear by writing 1 */
+        clrbits32(uccf->p_uccm, UCC_GETH_UCCE_GRA);
+        out_be32(uccf->p_ucce, UCC_GETH_UCCE_GRA);  /* clear by writing 1 */
 
         /* Issue host command */
         cecr_subblock =
@@ -1617,7 +1593,7 @@ static int ugeth_graceful_stop_tx(struct ucc_geth_private *ugeth)
         do {
                 msleep(10);
                 temp = in_be32(uccf->p_ucce);
-        } while (!(temp & UCCE_GRA) && --i);
+        } while (!(temp & UCC_GETH_UCCE_GRA) && --i);
 
         uccf->stopped_tx = 1;
 
@@ -1975,12 +1951,9 @@ static void ucc_geth_set_multi(struct net_device *dev)
         uf_regs = ugeth->uccf->uf_regs;
 
         if (dev->flags & IFF_PROMISC) {
-
-                out_be32(&uf_regs->upsmr, in_be32(&uf_regs->upsmr) | UPSMR_PRO);
-
+                setbits32(&uf_regs->upsmr, UCC_GETH_UPSMR_PRO);
         } else {
-
-                out_be32(&uf_regs->upsmr, in_be32(&uf_regs->upsmr)&~UPSMR_PRO);
+                clrbits32(&uf_regs->upsmr, UCC_GETH_UPSMR_PRO);
 
                 p_82xx_addr_filt =
                     (struct ucc_geth_82xx_address_filtering_pram __iomem *) ugeth->
@@ -2020,7 +1993,6 @@ static void ucc_geth_stop(struct ucc_geth_private *ugeth)
 {
         struct ucc_geth __iomem *ug_regs = ugeth->ug_regs;
         struct phy_device *phydev = ugeth->phydev;
-        u32 tempval;
 
         ugeth_vdbg("%s: IN", __func__);
 
@@ -2037,9 +2009,7 @@ static void ucc_geth_stop(struct ucc_geth_private *ugeth)
         out_be32(ugeth->uccf->p_ucce, 0xffffffff);
 
         /* Disable Rx and Tx */
-        tempval = in_be32(&ug_regs->maccfg1);
-        tempval &= ~(MACCFG1_ENABLE_RX | MACCFG1_ENABLE_TX);
-        out_be32(&ug_regs->maccfg1, tempval);
+        clrbits32(&ug_regs->maccfg1, MACCFG1_ENABLE_RX | MACCFG1_ENABLE_TX);
 
         ucc_geth_memclean(ugeth);
 }
@@ -2153,10 +2123,10 @@ static int ucc_struct_init(struct ucc_geth_private *ugeth)
         /* Generate uccm_mask for receive */
         uf_info->uccm_mask = ug_info->eventRegMask & UCCE_OTHER;/* Errors */
         for (i = 0; i < ug_info->numQueuesRx; i++)
-                uf_info->uccm_mask |= (UCCE_RXBF_SINGLE_MASK << i);
+                uf_info->uccm_mask |= (UCC_GETH_UCCE_RXF0 << i);
 
         for (i = 0; i < ug_info->numQueuesTx; i++)
-                uf_info->uccm_mask |= (UCCE_TXBF_SINGLE_MASK << i);
+                uf_info->uccm_mask |= (UCC_GETH_UCCE_TXB0 << i);
         /* Initialize the general fast UCC block. */
         if (ucc_fast_init(uf_info, &ugeth->uccf)) {
                 if (netif_msg_probe(ugeth))
@@ -2185,7 +2155,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
         struct ucc_geth __iomem *ug_regs;
         int ret_val = -EINVAL;
         u32 remoder = UCC_GETH_REMODER_INIT;
-        u32 init_enet_pram_offset, cecr_subblock, command, maccfg1;
+        u32 init_enet_pram_offset, cecr_subblock, command;
         u32 ifstat, i, j, size, l2qt, l3qt, length;
         u16 temoder = UCC_GETH_TEMODER_INIT;
         u16 test;
@@ -2281,10 +2251,7 @@ static int ucc_geth_startup(struct ucc_geth_private *ugeth)
                                  &uf_regs->upsmr,
                                  &ug_regs->uempr, &ug_regs->maccfg1);
 
-        maccfg1 = in_be32(&ug_regs->maccfg1);
-        maccfg1 |= MACCFG1_ENABLE_RX;
-        maccfg1 |= MACCFG1_ENABLE_TX;
-        out_be32(&ug_regs->maccfg1, maccfg1);
+        setbits32(&ug_regs->maccfg1, MACCFG1_ENABLE_RX | MACCFG1_ENABLE_TX);
 
         /*                    Set IPGIFG                     */
         /* For more details see the hardware spec.           */
@@ -3274,7 +3241,6 @@ static int ucc_geth_tx(struct net_device *dev, u8 txQ)
 static int ucc_geth_poll(struct napi_struct *napi, int budget)
 {
         struct ucc_geth_private *ugeth = container_of(napi, struct ucc_geth_private, napi);
-        struct net_device *dev = ugeth->dev;
         struct ucc_geth_info *ug_info;
         int howmany, i;
 
@@ -3285,14 +3251,8 @@ static int ucc_geth_poll(struct napi_struct *napi, int budget)
                 howmany += ucc_geth_rx(ugeth, i, budget - howmany);
 
         if (howmany < budget) {
-                struct ucc_fast_private *uccf;
-                u32 uccm;
-
                 netif_rx_complete(napi);
-                uccf = ugeth->uccf;
-                uccm = in_be32(uccf->p_uccm);
-                uccm |= UCCE_RX_EVENTS;
-                out_be32(uccf->p_uccm, uccm);
+                setbits32(ugeth->uccf->p_uccm, UCCE_RX_EVENTS);
         }
 
         return howmany;
@@ -3332,7 +3292,7 @@ static irqreturn_t ucc_geth_irq_handler(int irq, void *info)
         /* Tx event processing */
         if (ucce & UCCE_TX_EVENTS) {
                 spin_lock(&ugeth->lock);
-                tx_mask = UCCE_TXBF_SINGLE_MASK;
+                tx_mask = UCC_GETH_UCCE_TXB0;
                 for (i = 0; i < ug_info->numQueuesTx; i++) {
                         if (ucce & tx_mask)
                                 ucc_geth_tx(dev, i);
@@ -3344,12 +3304,10 @@ static irqreturn_t ucc_geth_irq_handler(int irq, void *info)
 
         /* Errors and other events */
         if (ucce & UCCE_OTHER) {
-                if (ucce & UCCE_BSY) {
+                if (ucce & UCC_GETH_UCCE_BSY)
                         dev->stats.rx_errors++;
-                }
-                if (ucce & UCCE_TXE) {
+                if (ucce & UCC_GETH_UCCE_TXE)
                         dev->stats.tx_errors++;
-                }
         }
 
         return IRQ_HANDLED;
diff --git a/drivers/net/ucc_geth.h b/drivers/net/ucc_geth.h
index d74d2f7cb73..8f699cb773e 100644
--- a/drivers/net/ucc_geth.h
+++ b/drivers/net/ucc_geth.h
@@ -162,92 +162,27 @@ struct ucc_geth {
                                                                    boundary */
 
 /* UCC GETH Event Register */
-#define UCCE_MPD                                0x80000000      /* Magic packet
-                                                                   detection */
-#define UCCE_SCAR                               0x40000000
-#define UCCE_GRA                                0x20000000      /* Tx graceful
-                                                                   stop
-                                                                   complete */
-#define UCCE_CBPR                               0x10000000
-#define UCCE_BSY                                0x08000000
-#define UCCE_RXC                                0x04000000
-#define UCCE_TXC                                0x02000000
-#define UCCE_TXE                                0x01000000
-#define UCCE_TXB7                               0x00800000
-#define UCCE_TXB6                               0x00400000
-#define UCCE_TXB5                               0x00200000
-#define UCCE_TXB4                               0x00100000
-#define UCCE_TXB3                               0x00080000
-#define UCCE_TXB2                               0x00040000
-#define UCCE_TXB1                               0x00020000
-#define UCCE_TXB0                               0x00010000
-#define UCCE_RXB7                               0x00008000
-#define UCCE_RXB6                               0x00004000
-#define UCCE_RXB5                               0x00002000
-#define UCCE_RXB4                               0x00001000
-#define UCCE_RXB3                               0x00000800
-#define UCCE_RXB2                               0x00000400
-#define UCCE_RXB1                               0x00000200
-#define UCCE_RXB0                               0x00000100
-#define UCCE_RXF7                               0x00000080
-#define UCCE_RXF6                               0x00000040
-#define UCCE_RXF5                               0x00000020
-#define UCCE_RXF4                               0x00000010
-#define UCCE_RXF3                               0x00000008
-#define UCCE_RXF2                               0x00000004
-#define UCCE_RXF1                               0x00000002
-#define UCCE_RXF0                               0x00000001
-
-#define UCCE_RXBF_SINGLE_MASK                   (UCCE_RXF0)
-#define UCCE_TXBF_SINGLE_MASK                   (UCCE_TXB0)
-
-#define UCCE_TXB         (UCCE_TXB7 | UCCE_TXB6 | UCCE_TXB5 | UCCE_TXB4 |\
-                        UCCE_TXB3 | UCCE_TXB2 | UCCE_TXB1 | UCCE_TXB0)
-#define UCCE_RXB         (UCCE_RXB7 | UCCE_RXB6 | UCCE_RXB5 | UCCE_RXB4 |\
-                        UCCE_RXB3 | UCCE_RXB2 | UCCE_RXB1 | UCCE_RXB0)
-#define UCCE_RXF         (UCCE_RXF7 | UCCE_RXF6 | UCCE_RXF5 | UCCE_RXF4 |\
-                        UCCE_RXF3 | UCCE_RXF2 | UCCE_RXF1 | UCCE_RXF0)
-#define UCCE_OTHER       (UCCE_SCAR | UCCE_GRA  | UCCE_CBPR | UCCE_BSY  |\
-                        UCCE_RXC  | UCCE_TXC  | UCCE_TXE)
-
-#define UCCE_RX_EVENTS                                                  (UCCE_RXF | UCCE_BSY)
-#define UCCE_TX_EVENTS                                                  (UCCE_TXB | UCCE_TXE)
-
-/* UCC GETH UPSMR (Protocol Specific Mode Register) */
-#define UPSMR_ECM                               0x04000000      /* Enable CAM
-                                                                   Miss or
-                                                                   Enable
-                                                                   Filtering
-                                                                   Miss */
-#define UPSMR_HSE                               0x02000000      /* Hardware
-                                                                   Statistics
-                                                                   Enable */
-#define UPSMR_PRO                               0x00400000      /* Promiscuous*/
-#define UPSMR_CAP                               0x00200000      /* CAM polarity
-                                                                 */
-#define UPSMR_RSH                               0x00100000      /* Receive
-                                                                   Short Frames
-                                                                 */
-#define UPSMR_RPM                               0x00080000      /* Reduced Pin
-                                                                   Mode
-                                                                   interfaces */
-#define UPSMR_R10M                              0x00040000      /* RGMII/RMII
-                                                                   10 Mode */
-#define UPSMR_RLPB                              0x00020000      /* RMII
-                                                                   Loopback
-                                                                   Mode */
-#define UPSMR_TBIM                              0x00010000      /* Ten-bit
-                                                                   Interface
-                                                                   Mode */
-#define UPSMR_RMM                               0x00001000      /* RMII/RGMII
-                                                                   Mode */
-#define UPSMR_CAM                               0x00000400      /* CAM Address
-                                                                   Matching */
-#define UPSMR_BRO                               0x00000200      /* Broadcast
-                                                                   Address */
-#define UPSMR_RES1                              0x00002000      /* Reserved
-                                                                   feild - must
-                                                                   be 1 */
+#define UCCE_TXB   (UCC_GETH_UCCE_TXB7 | UCC_GETH_UCCE_TXB6 | \
+                    UCC_GETH_UCCE_TXB5 | UCC_GETH_UCCE_TXB4 | \
+                    UCC_GETH_UCCE_TXB3 | UCC_GETH_UCCE_TXB2 | \
+                    UCC_GETH_UCCE_TXB1 | UCC_GETH_UCCE_TXB0)
+
+#define UCCE_RXB   (UCC_GETH_UCCE_RXB7 | UCC_GETH_UCCE_RXB6 | \
+                    UCC_GETH_UCCE_RXB5 | UCC_GETH_UCCE_RXB4 | \
+                    UCC_GETH_UCCE_RXB3 | UCC_GETH_UCCE_RXB2 | \
+                    UCC_GETH_UCCE_RXB1 | UCC_GETH_UCCE_RXB0)
+
+#define UCCE_RXF   (UCC_GETH_UCCE_RXF7 | UCC_GETH_UCCE_RXF6 | \
+                    UCC_GETH_UCCE_RXF5 | UCC_GETH_UCCE_RXF4 | \
+                    UCC_GETH_UCCE_RXF3 | UCC_GETH_UCCE_RXF2 | \
+                    UCC_GETH_UCCE_RXF1 | UCC_GETH_UCCE_RXF0)
+
+#define UCCE_OTHER (UCC_GETH_UCCE_SCAR | UCC_GETH_UCCE_GRA | \
+                    UCC_GETH_UCCE_CBPR | UCC_GETH_UCCE_BSY | \
+                    UCC_GETH_UCCE_RXC  | UCC_GETH_UCCE_TXC | UCC_GETH_UCCE_TXE)
+
+#define UCCE_RX_EVENTS  (UCCE_RXF | UCC_GETH_UCCE_BSY)
+#define UCCE_TX_EVENTS  (UCCE_TXB | UCC_GETH_UCCE_TXE)
 
 /* UCC GETH MACCFG1 (MAC Configuration 1 Register) */
 #define MACCFG1_FLOW_RX                         0x00000020      /* Flow Control
@@ -945,9 +880,10 @@ struct ucc_geth_hardware_statistics {
 #define UCC_GETH_REMODER_INIT                   0       /* bits that must be
                                                            set */
 #define UCC_GETH_TEMODER_INIT                   0xC000  /* bits that must */
-#define UCC_GETH_UPSMR_INIT                     (UPSMR_RES1)    /* Start value
-                                                                   for this
-                                                                   register */
+
+/* Initial value for UPSMR */
+#define UCC_GETH_UPSMR_INIT                     UCC_GETH_UPSMR_RES1
+
 #define UCC_GETH_MACCFG1_INIT                   0
 #define UCC_GETH_MACCFG2_INIT                   (MACCFG2_RESERVED_1)
 
diff --git a/drivers/net/via-rhine.c b/drivers/net/via-rhine.c
index ac07cc6e3cb..3b8e6325427 100644
--- a/drivers/net/via-rhine.c
+++ b/drivers/net/via-rhine.c
@@ -622,6 +622,7 @@ static const struct net_device_ops rhine_netdev_ops = {
         .ndo_get_stats           = rhine_get_stats,
         .ndo_set_multicast_list  = rhine_set_rx_mode,
         .ndo_validate_addr       = eth_validate_addr,
+        .ndo_set_mac_address     = eth_mac_addr,
         .ndo_do_ioctl            = netdev_ioctl,
         .ndo_tx_timeout          = rhine_tx_timeout,
 #ifdef CONFIG_NET_POLL_CONTROLLER
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index 58e25d090ae..a75f91dc315 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -855,6 +855,7 @@ static const struct net_device_ops velocity_netdev_ops = {
         .ndo_start_xmit         = velocity_xmit,
         .ndo_get_stats          = velocity_get_stats,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_set_multicast_list = velocity_set_multi,
         .ndo_change_mtu         = velocity_change_mtu,
         .ndo_do_ioctl           = velocity_ioctl,
diff --git a/drivers/net/wd.c b/drivers/net/wd.c
index 3c1edda08d3..d8322d2d1e2 100644
--- a/drivers/net/wd.c
+++ b/drivers/net/wd.c
@@ -155,6 +155,7 @@ static const struct net_device_ops wd_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/wireless/libertas/main.c b/drivers/net/wireless/libertas/main.c
index 3dba8367944..4e0007d2003 100644
--- a/drivers/net/wireless/libertas/main.c
+++ b/drivers/net/wireless/libertas/main.c
@@ -1369,7 +1369,7 @@ EXPORT_SYMBOL_GPL(lbs_start_card);
 
 void lbs_stop_card(struct lbs_private *priv)
 {
-        struct net_device *dev = priv->dev;
+        struct net_device *dev;
         struct cmd_ctrl_node *cmdnode;
         unsigned long flags;
 
@@ -1377,9 +1377,10 @@ void lbs_stop_card(struct lbs_private *priv)
 
         if (!priv)
                 goto out;
+        dev = priv->dev;
 
-        netif_stop_queue(priv->dev);
-        netif_carrier_off(priv->dev);
+        netif_stop_queue(dev);
+        netif_carrier_off(dev);
 
         lbs_debugfs_remove_one(priv);
         if (priv->mesh_tlv) {
diff --git a/drivers/net/yellowfin.c b/drivers/net/yellowfin.c
index cf971292277..2f1645dcb8c 100644
--- a/drivers/net/yellowfin.c
+++ b/drivers/net/yellowfin.c
@@ -362,6 +362,7 @@ static const struct net_device_ops netdev_ops = {
         .ndo_set_multicast_list = set_rx_mode,
         .ndo_change_mtu         = eth_change_mtu,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_do_ioctl           = netdev_ioctl,
         .ndo_tx_timeout         = yellowfin_tx_timeout,
 };
diff --git a/drivers/net/zorro8390.c b/drivers/net/zorro8390.c
index affd904deaf..37c84e3b8be 100644
--- a/drivers/net/zorro8390.c
+++ b/drivers/net/zorro8390.c
@@ -147,6 +147,7 @@ static const struct net_device_ops zorro8390_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/oprofile/buffer_sync.c b/drivers/oprofile/buffer_sync.c
index 9da5a4b8113..c3ea5fa7d05 100644
--- a/drivers/oprofile/buffer_sync.c
+++ b/drivers/oprofile/buffer_sync.c
@@ -38,7 +38,7 @@
 
 static LIST_HEAD(dying_tasks);
 static LIST_HEAD(dead_tasks);
-static cpumask_t marked_cpus = CPU_MASK_NONE;
+static cpumask_var_t marked_cpus;
 static DEFINE_SPINLOCK(task_mortuary);
 static void process_task_mortuary(void);
 
@@ -456,10 +456,10 @@ static void mark_done(int cpu)
 {
         int i;
 
-        cpu_set(cpu, marked_cpus);
+        cpumask_set_cpu(cpu, marked_cpus);
 
         for_each_online_cpu(i) {
-                if (!cpu_isset(i, marked_cpus))
+                if (!cpumask_test_cpu(i, marked_cpus))
                         return;
         }
 
@@ -468,7 +468,7 @@ static void mark_done(int cpu)
          */
         process_task_mortuary();
 
-        cpus_clear(marked_cpus);
+        cpumask_clear(marked_cpus);
 }
 
 
@@ -565,6 +565,20 @@ void sync_buffer(int cpu)
         mutex_unlock(&buffer_mutex);
 }
 
+int __init buffer_sync_init(void)
+{
+        if (!alloc_cpumask_var(&marked_cpus, GFP_KERNEL))
+                return -ENOMEM;
+
+        cpumask_clear(marked_cpus);
+                return 0;
+}
+
+void __exit buffer_sync_cleanup(void)
+{
+        free_cpumask_var(marked_cpus);
+}
+
 /* The function can be used to add a buffer worth of data directly to
  * the kernel buffer. The buffer is assumed to be a circular buffer.
  * Take the entries from index start and end at index end, wrapping
diff --git a/drivers/oprofile/buffer_sync.h b/drivers/oprofile/buffer_sync.h
index 3110732c183..0ebf5db6267 100644
--- a/drivers/oprofile/buffer_sync.h
+++ b/drivers/oprofile/buffer_sync.h
@@ -19,4 +19,8 @@ void sync_stop(void);
 /* sync the given CPU's buffer */
 void sync_buffer(int cpu);
 
+/* initialize/destroy the buffer system. */
+int buffer_sync_init(void);
+void buffer_sync_cleanup(void);
+
 #endif /* OPROFILE_BUFFER_SYNC_H */
diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
index 3cffce90f82..ced39f60229 100644
--- a/drivers/oprofile/oprof.c
+++ b/drivers/oprofile/oprof.c
@@ -183,6 +183,10 @@ static int __init oprofile_init(void)
 {
         int err;
 
+        err = buffer_sync_init();
+        if (err)
+                return err;
+
         err = oprofile_arch_init(&oprofile_ops);
 
         if (err < 0 || timer) {
@@ -191,8 +195,10 @@ static int __init oprofile_init(void)
         }
 
         err = oprofilefs_register();
-        if (err)
+        if (err) {
                 oprofile_arch_exit();
+                buffer_sync_cleanup();
+        }
 
         return err;
 }
@@ -202,6 +208,7 @@ static void __exit oprofile_exit(void)
 {
         oprofilefs_unregister();
         oprofile_arch_exit();
+        buffer_sync_cleanup();
 }
 
 
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index 1e93c837514..4fa3bb2ddfe 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -405,7 +405,6 @@ static void __init superio_serial_init(void)
         serial_port.type        = PORT_16550A;
         serial_port.uartclk     = 115200*16;
         serial_port.fifosize    = 16;
-        spin_lock_init(&serial_port.lock);
 
         /* serial port #1 */
         serial_port.iobase      = sio_dev.sp1_base;
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index 235fb7a5a8a..3dfecb20d5e 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -438,7 +438,8 @@ static struct intel_iommu *device_to_iommu(u8 bus, u8 devfn)
                         continue;
 
                 for (i = 0; i < drhd->devices_cnt; i++)
-                        if (drhd->devices[i]->bus->number == bus &&
+                        if (drhd->devices[i] &&
+                            drhd->devices[i]->bus->number == bus &&
                             drhd->devices[i]->devfn == devfn)
                                 return drhd->iommu;
 
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index f78371b2252..5a57753ea9f 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -6,6 +6,7 @@
 #include <linux/irq.h>
 #include <asm/io_apic.h>
 #include <asm/smp.h>
+#include <asm/cpu.h>
 #include <linux/intel-iommu.h>
 #include "intr_remapping.h"
 
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 668472405a5..33da1127992 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -82,4 +82,10 @@ config BATTERY_DA9030
           Say Y here to enable support for batteries charger integrated into
           DA9030 PMIC.
 
+config CHARGER_PCF50633
+        tristate "NXP PCF50633 MBC"
+        depends on MFD_PCF50633
+        help
+         Say Y to include support for NXP PCF50633 Main Battery Charger.
+
 endif # POWER_SUPPLY
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index eebb15505a4..2fcf41d13e5 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -25,3 +25,4 @@ obj-$(CONFIG_BATTERY_TOSA)	+= tosa_battery.o
 obj-$(CONFIG_BATTERY_WM97XX)    += wm97xx_battery.o
 obj-$(CONFIG_BATTERY_BQ27x00)   += bq27x00_battery.o
 obj-$(CONFIG_BATTERY_DA9030)    += da9030_battery.o
+obj-$(CONFIG_CHARGER_PCF50633)  += pcf50633-charger.o
\ No newline at end of file
diff --git a/drivers/power/pcf50633-charger.c b/drivers/power/pcf50633-charger.c
new file mode 100644
index 00000000000..e988ec130fc
--- /dev/null
+++ b/drivers/power/pcf50633-charger.c
@@ -0,0 +1,358 @@
+/* NXP PCF50633 Main Battery Charger Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte, Andy Green and Werner Almesberger
+ *
+ *  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/types.h>
+#include <linux/device.h>
+#include <linux/sysfs.h>
+#include <linux/platform_device.h>
+#include <linux/power_supply.h>
+
+#include <linux/mfd/pcf50633/core.h>
+#include <linux/mfd/pcf50633/mbc.h>
+
+struct pcf50633_mbc {
+        struct pcf50633 *pcf;
+
+        int adapter_active;
+        int adapter_online;
+        int usb_active;
+        int usb_online;
+
+        struct power_supply usb;
+        struct power_supply adapter;
+};
+
+int pcf50633_mbc_usb_curlim_set(struct pcf50633 *pcf, int ma)
+{
+        struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
+        int ret = 0;
+        u8 bits;
+
+        if (ma >= 1000)
+                bits = PCF50633_MBCC7_USB_1000mA;
+        else if (ma >= 500)
+                bits = PCF50633_MBCC7_USB_500mA;
+        else if (ma >= 100)
+                bits = PCF50633_MBCC7_USB_100mA;
+        else
+                bits = PCF50633_MBCC7_USB_SUSPEND;
+
+        ret = pcf50633_reg_set_bit_mask(pcf, PCF50633_REG_MBCC7,
+                                        PCF50633_MBCC7_USB_MASK, bits);
+        if (ret)
+                dev_err(pcf->dev, "error setting usb curlim to %d mA\n", ma);
+        else
+                dev_info(pcf->dev, "usb curlim to %d mA\n", ma);
+
+        power_supply_changed(&mbc->usb);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(pcf50633_mbc_usb_curlim_set);
+
+int pcf50633_mbc_get_status(struct pcf50633 *pcf)
+{
+        struct pcf50633_mbc *mbc  = platform_get_drvdata(pcf->mbc_pdev);
+        int status = 0;
+
+        if (mbc->usb_online)
+                status |= PCF50633_MBC_USB_ONLINE;
+        if (mbc->usb_active)
+                status |= PCF50633_MBC_USB_ACTIVE;
+        if (mbc->adapter_online)
+                status |= PCF50633_MBC_ADAPTER_ONLINE;
+        if (mbc->adapter_active)
+                status |= PCF50633_MBC_ADAPTER_ACTIVE;
+
+        return status;
+}
+EXPORT_SYMBOL_GPL(pcf50633_mbc_get_status);
+
+void pcf50633_mbc_set_status(struct pcf50633 *pcf, int what, int status)
+{
+        struct pcf50633_mbc *mbc = platform_get_drvdata(pcf->mbc_pdev);
+
+        if (what & PCF50633_MBC_USB_ONLINE)
+                mbc->usb_online = !!status;
+        if (what & PCF50633_MBC_USB_ACTIVE)
+                mbc->usb_active = !!status;
+        if (what & PCF50633_MBC_ADAPTER_ONLINE)
+                mbc->adapter_online = !!status;
+        if (what & PCF50633_MBC_ADAPTER_ACTIVE)
+                mbc->adapter_active = !!status;
+}
+EXPORT_SYMBOL_GPL(pcf50633_mbc_set_status);
+
+static ssize_t
+show_chgmode(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
+
+        u8 mbcs2 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS2);
+        u8 chgmod = (mbcs2 & PCF50633_MBCS2_MBC_MASK);
+
+        return sprintf(buf, "%d\n", chgmod);
+}
+static DEVICE_ATTR(chgmode, S_IRUGO, show_chgmode, NULL);
+
+static ssize_t
+show_usblim(struct device *dev, struct device_attribute *attr, char *buf)
+{
+        struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
+        u8 usblim = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCC7) &
+                                                PCF50633_MBCC7_USB_MASK;
+        unsigned int ma;
+
+        if (usblim == PCF50633_MBCC7_USB_1000mA)
+                ma = 1000;
+        else if (usblim == PCF50633_MBCC7_USB_500mA)
+                ma = 500;
+        else if (usblim == PCF50633_MBCC7_USB_100mA)
+                ma = 100;
+        else
+                ma = 0;
+
+        return sprintf(buf, "%u\n", ma);
+}
+
+static ssize_t set_usblim(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct pcf50633_mbc *mbc = dev_get_drvdata(dev);
+        unsigned long ma;
+        int ret;
+
+        ret = strict_strtoul(buf, 10, &ma);
+        if (ret)
+                return -EINVAL;
+
+        pcf50633_mbc_usb_curlim_set(mbc->pcf, ma);
+
+        return count;
+}
+
+static DEVICE_ATTR(usb_curlim, S_IRUGO | S_IWUSR, show_usblim, set_usblim);
+
+static struct attribute *pcf50633_mbc_sysfs_entries[] = {
+        &dev_attr_chgmode.attr,
+        &dev_attr_usb_curlim.attr,
+        NULL,
+};
+
+static struct attribute_group mbc_attr_group = {
+        .name   = NULL,                 /* put in device directory */
+        .attrs  = pcf50633_mbc_sysfs_entries,
+};
+
+static void
+pcf50633_mbc_irq_handler(int irq, void *data)
+{
+        struct pcf50633_mbc *mbc = data;
+
+        /* USB */
+        if (irq == PCF50633_IRQ_USBINS) {
+                mbc->usb_online = 1;
+        } else if (irq == PCF50633_IRQ_USBREM) {
+                mbc->usb_online = 0;
+                mbc->usb_active = 0;
+                pcf50633_mbc_usb_curlim_set(mbc->pcf, 0);
+        }
+
+        /* Adapter */
+        if (irq == PCF50633_IRQ_ADPINS) {
+                mbc->adapter_online = 1;
+                mbc->adapter_active = 1;
+        } else if (irq == PCF50633_IRQ_ADPREM) {
+                mbc->adapter_online = 0;
+                mbc->adapter_active = 0;
+        }
+
+        if (irq == PCF50633_IRQ_BATFULL) {
+                mbc->usb_active = 0;
+                mbc->adapter_active = 0;
+        }
+
+        power_supply_changed(&mbc->usb);
+        power_supply_changed(&mbc->adapter);
+
+        if (mbc->pcf->pdata->mbc_event_callback)
+                mbc->pcf->pdata->mbc_event_callback(mbc->pcf, irq);
+}
+
+static int adapter_get_property(struct power_supply *psy,
+                        enum power_supply_property psp,
+                        union power_supply_propval *val)
+{
+        struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, usb);
+        int ret = 0;
+
+        switch (psp) {
+        case POWER_SUPPLY_PROP_ONLINE:
+                val->intval =  mbc->adapter_online;
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+static int usb_get_property(struct power_supply *psy,
+                        enum power_supply_property psp,
+                        union power_supply_propval *val)
+{
+        struct pcf50633_mbc *mbc = container_of(psy, struct pcf50633_mbc, usb);
+        int ret = 0;
+
+        switch (psp) {
+        case POWER_SUPPLY_PROP_ONLINE:
+                val->intval = mbc->usb_online;
+                break;
+        default:
+                ret = -EINVAL;
+                break;
+        }
+        return ret;
+}
+
+static enum power_supply_property power_props[] = {
+        POWER_SUPPLY_PROP_ONLINE,
+};
+
+static const u8 mbc_irq_handlers[] = {
+        PCF50633_IRQ_ADPINS,
+        PCF50633_IRQ_ADPREM,
+        PCF50633_IRQ_USBINS,
+        PCF50633_IRQ_USBREM,
+        PCF50633_IRQ_BATFULL,
+        PCF50633_IRQ_CHGHALT,
+        PCF50633_IRQ_THLIMON,
+        PCF50633_IRQ_THLIMOFF,
+        PCF50633_IRQ_USBLIMON,
+        PCF50633_IRQ_USBLIMOFF,
+        PCF50633_IRQ_LOWSYS,
+        PCF50633_IRQ_LOWBAT,
+};
+
+static int __devinit pcf50633_mbc_probe(struct platform_device *pdev)
+{
+        struct pcf50633_mbc *mbc;
+        struct pcf50633_subdev_pdata *pdata = pdev->dev.platform_data;
+        int ret;
+        int i;
+        u8 mbcs1;
+
+        mbc = kzalloc(sizeof(*mbc), GFP_KERNEL);
+        if (!mbc)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, mbc);
+        mbc->pcf = pdata->pcf;
+
+        /* Set up IRQ handlers */
+        for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
+                pcf50633_register_irq(mbc->pcf, mbc_irq_handlers[i],
+                                        pcf50633_mbc_irq_handler, mbc);
+
+        /* Create power supplies */
+        mbc->adapter.name               = "adapter";
+        mbc->adapter.type               = POWER_SUPPLY_TYPE_MAINS;
+        mbc->adapter.properties         = power_props;
+        mbc->adapter.num_properties     = ARRAY_SIZE(power_props);
+        mbc->adapter.get_property       = &adapter_get_property;
+        mbc->adapter.supplied_to        = mbc->pcf->pdata->batteries;
+        mbc->adapter.num_supplicants    = mbc->pcf->pdata->num_batteries;
+
+        mbc->usb.name                   = "usb";
+        mbc->usb.type                   = POWER_SUPPLY_TYPE_USB;
+        mbc->usb.properties             = power_props;
+        mbc->usb.num_properties         = ARRAY_SIZE(power_props);
+        mbc->usb.get_property           = usb_get_property;
+        mbc->usb.supplied_to            = mbc->pcf->pdata->batteries;
+        mbc->usb.num_supplicants        = mbc->pcf->pdata->num_batteries;
+
+        ret = power_supply_register(&pdev->dev, &mbc->adapter);
+        if (ret) {
+                dev_err(mbc->pcf->dev, "failed to register adapter\n");
+                kfree(mbc);
+                return ret;
+        }
+
+        ret = power_supply_register(&pdev->dev, &mbc->usb);
+        if (ret) {
+                dev_err(mbc->pcf->dev, "failed to register usb\n");
+                power_supply_unregister(&mbc->adapter);
+                kfree(mbc);
+                return ret;
+        }
+
+        ret = sysfs_create_group(&pdev->dev.kobj, &mbc_attr_group);
+        if (ret)
+                dev_err(mbc->pcf->dev, "failed to create sysfs entries\n");
+
+        mbcs1 = pcf50633_reg_read(mbc->pcf, PCF50633_REG_MBCS1);
+        if (mbcs1 & PCF50633_MBCS1_USBPRES)
+                pcf50633_mbc_irq_handler(PCF50633_IRQ_USBINS, mbc);
+        if (mbcs1 & PCF50633_MBCS1_ADAPTPRES)
+                pcf50633_mbc_irq_handler(PCF50633_IRQ_ADPINS, mbc);
+
+        return 0;
+}
+
+static int __devexit pcf50633_mbc_remove(struct platform_device *pdev)
+{
+        struct pcf50633_mbc *mbc = platform_get_drvdata(pdev);
+        int i;
+
+        /* Remove IRQ handlers */
+        for (i = 0; i < ARRAY_SIZE(mbc_irq_handlers); i++)
+                pcf50633_free_irq(mbc->pcf, mbc_irq_handlers[i]);
+
+        power_supply_unregister(&mbc->usb);
+        power_supply_unregister(&mbc->adapter);
+
+        kfree(mbc);
+
+        return 0;
+}
+
+static struct platform_driver pcf50633_mbc_driver = {
+        .driver = {
+                .name = "pcf50633-mbc",
+        },
+        .probe = pcf50633_mbc_probe,
+        .remove = __devexit_p(pcf50633_mbc_remove),
+};
+
+static int __init pcf50633_mbc_init(void)
+{
+        return platform_driver_register(&pcf50633_mbc_driver);
+}
+module_init(pcf50633_mbc_init);
+
+static void __exit pcf50633_mbc_exit(void)
+{
+        platform_driver_unregister(&pcf50633_mbc_driver);
+}
+module_exit(pcf50633_mbc_exit);
+
+MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
+MODULE_DESCRIPTION("PCF50633 mbc driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcf50633-mbc");
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index 39360e2a454..e7e0cf102d6 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -73,4 +73,11 @@ config REGULATOR_DA903X
           Say y here to support the BUCKs and LDOs regulators found on
           Dialog Semiconductor DA9030/DA9034 PMIC.
 
+config REGULATOR_PCF50633
+        tristate "PCF50633 regulator driver"
+        depends on MFD_PCF50633
+        help
+         Say Y here to support the voltage regulators and convertors
+         on PCF50633
+
 endif
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 254d40c02ee..61b30c6ddec 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -11,5 +11,6 @@ obj-$(CONFIG_REGULATOR_BQ24022) += bq24022.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
 
 ccflags-$(CONFIG_REGULATOR_DEBUG) += -DDEBUG
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c
new file mode 100644
index 00000000000..4cc85ec6e12
--- /dev/null
+++ b/drivers/regulator/pcf50633-regulator.c
@@ -0,0 +1,329 @@
+/* NXP PCF50633 PMIC Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte and Andy Green and Werner Almesberger
+ *
+ *  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/device.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+
+#include <linux/mfd/pcf50633/core.h>
+#include <linux/mfd/pcf50633/pmic.h>
+
+#define PCF50633_REGULATOR(_name, _id)          \
+        {                                       \
+                .name = _name,                  \
+                .id = _id,                      \
+                .ops = &pcf50633_regulator_ops, \
+                .type = REGULATOR_VOLTAGE,      \
+                .owner = THIS_MODULE,           \
+        }
+
+static const u8 pcf50633_regulator_registers[PCF50633_NUM_REGULATORS] = {
+        [PCF50633_REGULATOR_AUTO]       = PCF50633_REG_AUTOOUT,
+        [PCF50633_REGULATOR_DOWN1]      = PCF50633_REG_DOWN1OUT,
+        [PCF50633_REGULATOR_DOWN2]      = PCF50633_REG_DOWN2OUT,
+        [PCF50633_REGULATOR_MEMLDO]     = PCF50633_REG_MEMLDOOUT,
+        [PCF50633_REGULATOR_LDO1]       = PCF50633_REG_LDO1OUT,
+        [PCF50633_REGULATOR_LDO2]       = PCF50633_REG_LDO2OUT,
+        [PCF50633_REGULATOR_LDO3]       = PCF50633_REG_LDO3OUT,
+        [PCF50633_REGULATOR_LDO4]       = PCF50633_REG_LDO4OUT,
+        [PCF50633_REGULATOR_LDO5]       = PCF50633_REG_LDO5OUT,
+        [PCF50633_REGULATOR_LDO6]       = PCF50633_REG_LDO6OUT,
+        [PCF50633_REGULATOR_HCLDO]      = PCF50633_REG_HCLDOOUT,
+};
+
+/* Bits from voltage value */
+static u8 auto_voltage_bits(unsigned int millivolts)
+{
+        if (millivolts < 1800)
+                return 0;
+        if (millivolts > 3800)
+                return 0xff;
+
+        millivolts -= 625;
+
+        return millivolts / 25;
+}
+
+static u8 down_voltage_bits(unsigned int millivolts)
+{
+        if (millivolts < 625)
+                return 0;
+        else if (millivolts > 3000)
+                return 0xff;
+
+        millivolts -= 625;
+
+        return millivolts / 25;
+}
+
+static u8 ldo_voltage_bits(unsigned int millivolts)
+{
+        if (millivolts < 900)
+                return 0;
+        else if (millivolts > 3600)
+                return 0x1f;
+
+        millivolts -= 900;
+        return millivolts / 100;
+}
+
+/* Obtain voltage value from bits */
+static unsigned int auto_voltage_value(u8 bits)
+{
+        if (bits < 0x2f)
+                return 0;
+
+        return 625 + (bits * 25);
+}
+
+
+static unsigned int down_voltage_value(u8 bits)
+{
+        return 625 + (bits * 25);
+}
+
+
+static unsigned int ldo_voltage_value(u8 bits)
+{
+        bits &= 0x1f;
+
+        return 900 + (bits * 100);
+}
+
+static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
+                                                int min_uV, int max_uV)
+{
+        struct pcf50633 *pcf;
+        int regulator_id, millivolts;
+        u8 volt_bits, regnr;
+
+        pcf = rdev_get_drvdata(rdev);
+
+        regulator_id = rdev_get_id(rdev);
+        if (regulator_id >= PCF50633_NUM_REGULATORS)
+                return -EINVAL;
+
+        millivolts = min_uV / 1000;
+
+        regnr = pcf50633_regulator_registers[regulator_id];
+
+        switch (regulator_id) {
+        case PCF50633_REGULATOR_AUTO:
+                volt_bits = auto_voltage_bits(millivolts);
+                break;
+        case PCF50633_REGULATOR_DOWN1:
+                volt_bits = down_voltage_bits(millivolts);
+                break;
+        case PCF50633_REGULATOR_DOWN2:
+                volt_bits = down_voltage_bits(millivolts);
+                break;
+        case PCF50633_REGULATOR_LDO1:
+        case PCF50633_REGULATOR_LDO2:
+        case PCF50633_REGULATOR_LDO3:
+        case PCF50633_REGULATOR_LDO4:
+        case PCF50633_REGULATOR_LDO5:
+        case PCF50633_REGULATOR_LDO6:
+        case PCF50633_REGULATOR_HCLDO:
+                volt_bits = ldo_voltage_bits(millivolts);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return pcf50633_reg_write(pcf, regnr, volt_bits);
+}
+
+static int pcf50633_regulator_get_voltage(struct regulator_dev *rdev)
+{
+        struct pcf50633 *pcf;
+        int regulator_id, millivolts, volt_bits;
+        u8 regnr;
+
+        pcf = rdev_get_drvdata(rdev);;
+
+        regulator_id = rdev_get_id(rdev);
+        if (regulator_id >= PCF50633_NUM_REGULATORS)
+                return -EINVAL;
+
+        regnr = pcf50633_regulator_registers[regulator_id];
+
+        volt_bits = pcf50633_reg_read(pcf, regnr);
+        if (volt_bits < 0)
+                return -1;
+
+        switch (regulator_id) {
+        case PCF50633_REGULATOR_AUTO:
+                millivolts = auto_voltage_value(volt_bits);
+                break;
+        case PCF50633_REGULATOR_DOWN1:
+                millivolts = down_voltage_value(volt_bits);
+                break;
+        case PCF50633_REGULATOR_DOWN2:
+                millivolts = down_voltage_value(volt_bits);
+                break;
+        case PCF50633_REGULATOR_LDO1:
+        case PCF50633_REGULATOR_LDO2:
+        case PCF50633_REGULATOR_LDO3:
+        case PCF50633_REGULATOR_LDO4:
+        case PCF50633_REGULATOR_LDO5:
+        case PCF50633_REGULATOR_LDO6:
+        case PCF50633_REGULATOR_HCLDO:
+                millivolts = ldo_voltage_value(volt_bits);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return millivolts * 1000;
+}
+
+static int pcf50633_regulator_enable(struct regulator_dev *rdev)
+{
+        struct pcf50633 *pcf = rdev_get_drvdata(rdev);
+        int regulator_id;
+        u8 regnr;
+
+        regulator_id = rdev_get_id(rdev);
+        if (regulator_id >= PCF50633_NUM_REGULATORS)
+                return -EINVAL;
+
+        /* The *ENA register is always one after the *OUT register */
+        regnr = pcf50633_regulator_registers[regulator_id] + 1;
+
+        return pcf50633_reg_set_bit_mask(pcf, regnr, PCF50633_REGULATOR_ON,
+                                                       PCF50633_REGULATOR_ON);
+}
+
+static int pcf50633_regulator_disable(struct regulator_dev *rdev)
+{
+        struct pcf50633 *pcf = rdev_get_drvdata(rdev);
+        int regulator_id;
+        u8 regnr;
+
+        regulator_id = rdev_get_id(rdev);
+        if (regulator_id >= PCF50633_NUM_REGULATORS)
+                return -EINVAL;
+
+        /* the *ENA register is always one after the *OUT register */
+        regnr = pcf50633_regulator_registers[regulator_id] + 1;
+
+        return pcf50633_reg_set_bit_mask(pcf, regnr,
+                                        PCF50633_REGULATOR_ON, 0);
+}
+
+static int pcf50633_regulator_is_enabled(struct regulator_dev *rdev)
+{
+        struct pcf50633 *pcf = rdev_get_drvdata(rdev);
+        int regulator_id = rdev_get_id(rdev);
+        u8 regnr;
+
+        regulator_id = rdev_get_id(rdev);
+        if (regulator_id >= PCF50633_NUM_REGULATORS)
+                return -EINVAL;
+
+        /* the *ENA register is always one after the *OUT register */
+        regnr = pcf50633_regulator_registers[regulator_id] + 1;
+
+        return pcf50633_reg_read(pcf, regnr) & PCF50633_REGULATOR_ON;
+}
+
+static struct regulator_ops pcf50633_regulator_ops = {
+        .set_voltage = pcf50633_regulator_set_voltage,
+        .get_voltage = pcf50633_regulator_get_voltage,
+        .enable = pcf50633_regulator_enable,
+        .disable = pcf50633_regulator_disable,
+        .is_enabled = pcf50633_regulator_is_enabled,
+};
+
+static struct regulator_desc regulators[] = {
+        [PCF50633_REGULATOR_AUTO] =
+                PCF50633_REGULATOR("auto", PCF50633_REGULATOR_AUTO),
+        [PCF50633_REGULATOR_DOWN1] =
+                PCF50633_REGULATOR("down1", PCF50633_REGULATOR_DOWN1),
+        [PCF50633_REGULATOR_DOWN2] =
+                PCF50633_REGULATOR("down2", PCF50633_REGULATOR_DOWN2),
+        [PCF50633_REGULATOR_LDO1] =
+                PCF50633_REGULATOR("ldo1", PCF50633_REGULATOR_LDO1),
+        [PCF50633_REGULATOR_LDO2] =
+                PCF50633_REGULATOR("ldo2", PCF50633_REGULATOR_LDO2),
+        [PCF50633_REGULATOR_LDO3] =
+                PCF50633_REGULATOR("ldo3", PCF50633_REGULATOR_LDO3),
+        [PCF50633_REGULATOR_LDO4] =
+                PCF50633_REGULATOR("ldo4", PCF50633_REGULATOR_LDO4),
+        [PCF50633_REGULATOR_LDO5] =
+                PCF50633_REGULATOR("ldo5", PCF50633_REGULATOR_LDO5),
+        [PCF50633_REGULATOR_LDO6] =
+                PCF50633_REGULATOR("ldo6", PCF50633_REGULATOR_LDO6),
+        [PCF50633_REGULATOR_HCLDO] =
+                PCF50633_REGULATOR("hcldo", PCF50633_REGULATOR_HCLDO),
+        [PCF50633_REGULATOR_MEMLDO] =
+                PCF50633_REGULATOR("memldo", PCF50633_REGULATOR_MEMLDO),
+};
+
+static int __devinit pcf50633_regulator_probe(struct platform_device *pdev)
+{
+        struct regulator_dev *rdev;
+        struct pcf50633 *pcf;
+
+        /* Already set by core driver */
+        pcf = platform_get_drvdata(pdev);
+
+        rdev = regulator_register(&regulators[pdev->id], &pdev->dev, pcf);
+        if (IS_ERR(rdev))
+                return PTR_ERR(rdev);
+
+        if (pcf->pdata->regulator_registered)
+                pcf->pdata->regulator_registered(pcf, pdev->id);
+
+        return 0;
+}
+
+static int __devexit pcf50633_regulator_remove(struct platform_device *pdev)
+{
+        struct regulator_dev *rdev = platform_get_drvdata(pdev);
+
+        regulator_unregister(rdev);
+
+        return 0;
+}
+
+static struct platform_driver pcf50633_regulator_driver = {
+        .driver = {
+                .name = "pcf50633-regltr",
+        },
+        .probe = pcf50633_regulator_probe,
+        .remove = __devexit_p(pcf50633_regulator_remove),
+};
+
+static int __init pcf50633_regulator_init(void)
+{
+        return platform_driver_register(&pcf50633_regulator_driver);
+}
+module_init(pcf50633_regulator_init);
+
+static void __exit pcf50633_regulator_exit(void)
+{
+        platform_driver_unregister(&pcf50633_regulator_driver);
+}
+module_exit(pcf50633_regulator_exit);
+
+MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
+MODULE_DESCRIPTION("PCF50633 regulator driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:pcf50633-regulator");
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 4ad831de41a..cced4d10831 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -502,6 +502,13 @@ config RTC_DRV_WM8350
           This driver can also be built as a module. If so, the module
           will be called "rtc-wm8350".
 
+config RTC_DRV_PCF50633
+        depends on MFD_PCF50633
+        tristate "NXP PCF50633 RTC"
+        help
+          If you say yes here you get support for the RTC subsystem of the
+          NXP PCF50633 used in embedded systems.
+
 comment "on-CPU RTC drivers"
 
 config RTC_DRV_OMAP
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 9a4340d48f2..6e28021abb9 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -74,3 +74,4 @@ obj-$(CONFIG_RTC_DRV_V3020)	+= rtc-v3020.o
 obj-$(CONFIG_RTC_DRV_VR41XX)    += rtc-vr41xx.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-pcf50633.c b/drivers/rtc/rtc-pcf50633.c
new file mode 100644
index 00000000000..f4dd87e2907
--- /dev/null
+++ b/drivers/rtc/rtc-pcf50633.c
@@ -0,0 +1,344 @@
+/* NXP PCF50633 RTC Driver
+ *
+ * (C) 2006-2008 by Openmoko, Inc.
+ * Author: Balaji Rao <balajirrao@openmoko.org>
+ * All rights reserved.
+ *
+ * Broken down from monstrous PCF50633 driver mainly by
+ * Harald Welte, Andy Green and Werner Almesberger
+ *
+ *  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/device.h>
+#include <linux/platform_device.h>
+#include <linux/rtc.h>
+#include <linux/bcd.h>
+#include <linux/err.h>
+
+#include <linux/mfd/pcf50633/core.h>
+
+#define PCF50633_REG_RTCSC      0x59 /* Second */
+#define PCF50633_REG_RTCMN      0x5a /* Minute */
+#define PCF50633_REG_RTCHR      0x5b /* Hour */
+#define PCF50633_REG_RTCWD      0x5c /* Weekday */
+#define PCF50633_REG_RTCDT      0x5d /* Day */
+#define PCF50633_REG_RTCMT      0x5e /* Month */
+#define PCF50633_REG_RTCYR      0x5f /* Year */
+#define PCF50633_REG_RTCSCA     0x60 /* Alarm Second */
+#define PCF50633_REG_RTCMNA     0x61 /* Alarm Minute */
+#define PCF50633_REG_RTCHRA     0x62 /* Alarm Hour */
+#define PCF50633_REG_RTCWDA     0x63 /* Alarm Weekday */
+#define PCF50633_REG_RTCDTA     0x64 /* Alarm Day */
+#define PCF50633_REG_RTCMTA     0x65 /* Alarm Month */
+#define PCF50633_REG_RTCYRA     0x66 /* Alarm Year */
+
+enum pcf50633_time_indexes {
+        PCF50633_TI_SEC,
+        PCF50633_TI_MIN,
+        PCF50633_TI_HOUR,
+        PCF50633_TI_WKDAY,
+        PCF50633_TI_DAY,
+        PCF50633_TI_MONTH,
+        PCF50633_TI_YEAR,
+        PCF50633_TI_EXTENT /* always last */
+};
+
+struct pcf50633_time {
+        u_int8_t time[PCF50633_TI_EXTENT];
+};
+
+struct pcf50633_rtc {
+        int alarm_enabled;
+        int second_enabled;
+
+        struct pcf50633 *pcf;
+        struct rtc_device *rtc_dev;
+};
+
+static void pcf2rtc_time(struct rtc_time *rtc, struct pcf50633_time *pcf)
+{
+        rtc->tm_sec = bcd2bin(pcf->time[PCF50633_TI_SEC]);
+        rtc->tm_min = bcd2bin(pcf->time[PCF50633_TI_MIN]);
+        rtc->tm_hour = bcd2bin(pcf->time[PCF50633_TI_HOUR]);
+        rtc->tm_wday = bcd2bin(pcf->time[PCF50633_TI_WKDAY]);
+        rtc->tm_mday = bcd2bin(pcf->time[PCF50633_TI_DAY]);
+        rtc->tm_mon = bcd2bin(pcf->time[PCF50633_TI_MONTH]);
+        rtc->tm_year = bcd2bin(pcf->time[PCF50633_TI_YEAR]) + 100;
+}
+
+static void rtc2pcf_time(struct pcf50633_time *pcf, struct rtc_time *rtc)
+{
+        pcf->time[PCF50633_TI_SEC] = bin2bcd(rtc->tm_sec);
+        pcf->time[PCF50633_TI_MIN] = bin2bcd(rtc->tm_min);
+        pcf->time[PCF50633_TI_HOUR] = bin2bcd(rtc->tm_hour);
+        pcf->time[PCF50633_TI_WKDAY] = bin2bcd(rtc->tm_wday);
+        pcf->time[PCF50633_TI_DAY] = bin2bcd(rtc->tm_mday);
+        pcf->time[PCF50633_TI_MONTH] = bin2bcd(rtc->tm_mon);
+        pcf->time[PCF50633_TI_YEAR] = bin2bcd(rtc->tm_year % 100);
+}
+
+static int
+pcf50633_rtc_alarm_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct pcf50633_rtc *rtc = dev_get_drvdata(dev);
+        int err;
+
+        if (enabled)
+                err = pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_ALARM);
+        else
+                err = pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        if (err < 0)
+                return err;
+
+        rtc->alarm_enabled = enabled;
+
+        return 0;
+}
+
+static int
+pcf50633_rtc_update_irq_enable(struct device *dev, unsigned int enabled)
+{
+        struct pcf50633_rtc *rtc = dev_get_drvdata(dev);
+        int err;
+
+        if (enabled)
+                err = pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_SECOND);
+        else
+                err = pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_SECOND);
+
+        if (err < 0)
+                return err;
+
+        rtc->second_enabled = enabled;
+
+        return 0;
+}
+
+static int pcf50633_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pcf50633_rtc *rtc;
+        struct pcf50633_time pcf_tm;
+        int ret;
+
+        rtc = dev_get_drvdata(dev);
+
+        ret = pcf50633_read_block(rtc->pcf, PCF50633_REG_RTCSC,
+                                            PCF50633_TI_EXTENT,
+                                            &pcf_tm.time[0]);
+        if (ret != PCF50633_TI_EXTENT) {
+                dev_err(dev, "Failed to read time\n");
+                return -EIO;
+        }
+
+        dev_dbg(dev, "PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n",
+                pcf_tm.time[PCF50633_TI_DAY],
+                pcf_tm.time[PCF50633_TI_MONTH],
+                pcf_tm.time[PCF50633_TI_YEAR],
+                pcf_tm.time[PCF50633_TI_HOUR],
+                pcf_tm.time[PCF50633_TI_MIN],
+                pcf_tm.time[PCF50633_TI_SEC]);
+
+        pcf2rtc_time(tm, &pcf_tm);
+
+        dev_dbg(dev, "RTC_TIME: %u.%u.%u %u:%u:%u\n",
+                tm->tm_mday, tm->tm_mon, tm->tm_year,
+                tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+        return rtc_valid_tm(tm);
+}
+
+static int pcf50633_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct pcf50633_rtc *rtc;
+        struct pcf50633_time pcf_tm;
+        int second_masked, alarm_masked, ret = 0;
+
+        rtc = dev_get_drvdata(dev);
+
+        dev_dbg(dev, "RTC_TIME: %u.%u.%u %u:%u:%u\n",
+                tm->tm_mday, tm->tm_mon, tm->tm_year,
+                tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+        rtc2pcf_time(&pcf_tm, tm);
+
+        dev_dbg(dev, "PCF_TIME: %02x.%02x.%02x %02x:%02x:%02x\n",
+                pcf_tm.time[PCF50633_TI_DAY],
+                pcf_tm.time[PCF50633_TI_MONTH],
+                pcf_tm.time[PCF50633_TI_YEAR],
+                pcf_tm.time[PCF50633_TI_HOUR],
+                pcf_tm.time[PCF50633_TI_MIN],
+                pcf_tm.time[PCF50633_TI_SEC]);
+
+
+        second_masked = pcf50633_irq_mask_get(rtc->pcf, PCF50633_IRQ_SECOND);
+        alarm_masked = pcf50633_irq_mask_get(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        if (!second_masked)
+                pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_SECOND);
+        if (!alarm_masked)
+                pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        /* Returns 0 on success */
+        ret = pcf50633_write_block(rtc->pcf, PCF50633_REG_RTCSC,
+                                             PCF50633_TI_EXTENT,
+                                             &pcf_tm.time[0]);
+
+        if (!second_masked)
+                pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_SECOND);
+        if (!alarm_masked)
+                pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        return ret;
+}
+
+static int pcf50633_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct pcf50633_rtc *rtc;
+        struct pcf50633_time pcf_tm;
+        int ret = 0;
+
+        rtc = dev_get_drvdata(dev);
+
+        alrm->enabled = rtc->alarm_enabled;
+
+        ret = pcf50633_read_block(rtc->pcf, PCF50633_REG_RTCSCA,
+                                PCF50633_TI_EXTENT, &pcf_tm.time[0]);
+        if (ret != PCF50633_TI_EXTENT) {
+                dev_err(dev, "Failed to read time\n");
+                return -EIO;
+        }
+
+        pcf2rtc_time(&alrm->time, &pcf_tm);
+
+        return rtc_valid_tm(&alrm->time);
+}
+
+static int pcf50633_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct pcf50633_rtc *rtc;
+        struct pcf50633_time pcf_tm;
+        int alarm_masked, ret = 0;
+
+        rtc = dev_get_drvdata(dev);
+
+        rtc2pcf_time(&pcf_tm, &alrm->time);
+
+        /* do like mktime does and ignore tm_wday */
+        pcf_tm.time[PCF50633_TI_WKDAY] = 7;
+
+        alarm_masked = pcf50633_irq_mask_get(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        /* disable alarm interrupt */
+        if (!alarm_masked)
+                pcf50633_irq_mask(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        /* Returns 0 on success */
+        ret = pcf50633_write_block(rtc->pcf, PCF50633_REG_RTCSCA,
+                                PCF50633_TI_EXTENT, &pcf_tm.time[0]);
+
+        if (!alarm_masked)
+                pcf50633_irq_unmask(rtc->pcf, PCF50633_IRQ_ALARM);
+
+        return ret;
+}
+
+static struct rtc_class_ops pcf50633_rtc_ops = {
+        .read_time              = pcf50633_rtc_read_time,
+        .set_time               = pcf50633_rtc_set_time,
+        .read_alarm             = pcf50633_rtc_read_alarm,
+        .set_alarm              = pcf50633_rtc_set_alarm,
+        .alarm_irq_enable       = pcf50633_rtc_alarm_irq_enable,
+        .update_irq_enable      = pcf50633_rtc_update_irq_enable,
+};
+
+static void pcf50633_rtc_irq(int irq, void *data)
+{
+        struct pcf50633_rtc *rtc = data;
+
+        switch (irq) {
+        case PCF50633_IRQ_ALARM:
+                rtc_update_irq(rtc->rtc_dev, 1, RTC_AF | RTC_IRQF);
+                break;
+        case PCF50633_IRQ_SECOND:
+                rtc_update_irq(rtc->rtc_dev, 1, RTC_UF | RTC_IRQF);
+                break;
+        }
+}
+
+static int __devinit pcf50633_rtc_probe(struct platform_device *pdev)
+{
+        struct pcf50633_subdev_pdata *pdata;
+        struct pcf50633_rtc *rtc;
+
+
+        rtc = kzalloc(sizeof(*rtc), GFP_KERNEL);
+        if (!rtc)
+                return -ENOMEM;
+
+        pdata = pdev->dev.platform_data;
+        rtc->pcf = pdata->pcf;
+        platform_set_drvdata(pdev, rtc);
+        rtc->rtc_dev = rtc_device_register("pcf50633-rtc", &pdev->dev,
+                                &pcf50633_rtc_ops, THIS_MODULE);
+
+        if (IS_ERR(rtc->rtc_dev)) {
+                kfree(rtc);
+                return PTR_ERR(rtc->rtc_dev);
+        }
+
+        pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_ALARM,
+                                        pcf50633_rtc_irq, rtc);
+        pcf50633_register_irq(rtc->pcf, PCF50633_IRQ_SECOND,
+                                        pcf50633_rtc_irq, rtc);
+
+        return 0;
+}
+
+static int __devexit pcf50633_rtc_remove(struct platform_device *pdev)
+{
+        struct pcf50633_rtc *rtc;
+
+        rtc = platform_get_drvdata(pdev);
+
+        pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_ALARM);
+        pcf50633_free_irq(rtc->pcf, PCF50633_IRQ_SECOND);
+
+        rtc_device_unregister(rtc->rtc_dev);
+        kfree(rtc);
+
+        return 0;
+}
+
+static struct platform_driver pcf50633_rtc_driver = {
+        .driver = {
+                .name = "pcf50633-rtc",
+        },
+        .probe = pcf50633_rtc_probe,
+        .remove = __devexit_p(pcf50633_rtc_remove),
+};
+
+static int __init pcf50633_rtc_init(void)
+{
+        return platform_driver_register(&pcf50633_rtc_driver);
+}
+module_init(pcf50633_rtc_init);
+
+static void __exit pcf50633_rtc_exit(void)
+{
+        platform_driver_unregister(&pcf50633_rtc_driver);
+}
+module_exit(pcf50633_rtc_exit);
+
+MODULE_DESCRIPTION("PCF50633 RTC driver");
+MODULE_AUTHOR("Balaji Rao <balajirrao@openmoko.org>");
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/s390/net/qeth_l2_main.c b/drivers/s390/net/qeth_l2_main.c
index c4f1b046c3b..07ab8a5c1c4 100644
--- a/drivers/s390/net/qeth_l2_main.c
+++ b/drivers/s390/net/qeth_l2_main.c
@@ -916,7 +916,7 @@ static struct ethtool_ops qeth_l2_osn_ops = {
         .get_drvinfo = qeth_core_get_drvinfo,
 };
 
-static struct net_device_ops qeth_l2_netdev_ops = {
+static const struct net_device_ops qeth_l2_netdev_ops = {
         .ndo_open               = qeth_l2_open,
         .ndo_stop               = qeth_l2_stop,
         .ndo_get_stats          = qeth_get_stats,
diff --git a/drivers/s390/net/qeth_l3_main.c b/drivers/s390/net/qeth_l3_main.c
index 68d623ab7e6..3d04920b9bb 100644
--- a/drivers/s390/net/qeth_l3_main.c
+++ b/drivers/s390/net/qeth_l3_main.c
@@ -2894,7 +2894,7 @@ qeth_l3_neigh_setup(struct net_device *dev, struct neigh_parms *np)
         return 0;
 }
 
-static struct net_device_ops qeth_l3_netdev_ops = {
+static const struct net_device_ops qeth_l3_netdev_ops = {
         .ndo_open               = qeth_l3_open,
         .ndo_stop               = qeth_l3_stop,
         .ndo_get_stats          = qeth_get_stats,
@@ -2909,6 +2909,22 @@ static struct net_device_ops qeth_l3_netdev_ops = {
         .ndo_tx_timeout         = qeth_tx_timeout,
 };
 
+static const struct net_device_ops qeth_l3_osa_netdev_ops = {
+        .ndo_open               = qeth_l3_open,
+        .ndo_stop               = qeth_l3_stop,
+        .ndo_get_stats          = qeth_get_stats,
+        .ndo_start_xmit         = qeth_l3_hard_start_xmit,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_multicast_list = qeth_l3_set_multicast_list,
+        .ndo_do_ioctl           = qeth_l3_do_ioctl,
+        .ndo_change_mtu         = qeth_change_mtu,
+        .ndo_vlan_rx_register   = qeth_l3_vlan_rx_register,
+        .ndo_vlan_rx_add_vid    = qeth_l3_vlan_rx_add_vid,
+        .ndo_vlan_rx_kill_vid   = qeth_l3_vlan_rx_kill_vid,
+        .ndo_tx_timeout         = qeth_tx_timeout,
+        .ndo_neigh_setup        = qeth_l3_neigh_setup,
+};
+
 static int qeth_l3_setup_netdev(struct qeth_card *card)
 {
         if (card->info.type == QETH_CARD_TYPE_OSAE) {
@@ -2919,12 +2935,12 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
 #endif
                         if (!card->dev)
                                 return -ENODEV;
+                        card->dev->netdev_ops = &qeth_l3_netdev_ops;
                 } else {
                         card->dev = alloc_etherdev(0);
                         if (!card->dev)
                                 return -ENODEV;
-                        qeth_l3_netdev_ops.ndo_neigh_setup =
-                                qeth_l3_neigh_setup;
+                        card->dev->netdev_ops = &qeth_l3_osa_netdev_ops;
 
                         /*IPv6 address autoconfiguration stuff*/
                         qeth_l3_get_unique_id(card);
@@ -2937,6 +2953,7 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
                 if (!card->dev)
                         return -ENODEV;
                 card->dev->flags |= IFF_NOARP;
+                card->dev->netdev_ops = &qeth_l3_netdev_ops;
                 qeth_l3_iqd_read_initial_mac(card);
         } else
                 return -ENODEV;
@@ -2944,7 +2961,6 @@ static int qeth_l3_setup_netdev(struct qeth_card *card)
         card->dev->ml_priv = card;
         card->dev->watchdog_timeo = QETH_TX_TIMEOUT;
         card->dev->mtu = card->info.initial_mtu;
-        card->dev->netdev_ops = &qeth_l3_netdev_ops;
         SET_ETHTOOL_OPS(card->dev, &qeth_l3_ethtool_ops);
         card->dev->features |=  NETIF_F_HW_VLAN_TX |
                                 NETIF_F_HW_VLAN_RX |
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 1889a63ebc2..0d934bfbdd9 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2839,6 +2839,8 @@ int __init early_serial_setup(struct uart_port *port)
         p->flags        = port->flags;
         p->mapbase      = port->mapbase;
         p->private_data = port->private_data;
+        p->type         = port->type;
+        p->line         = port->line;
 
         set_io_from_upio(p);
         if (port->serial_in)
diff --git a/drivers/serial/jsm/jsm_neo.c b/drivers/serial/jsm/jsm_neo.c
index b7584ca55ad..e6390d02363 100644
--- a/drivers/serial/jsm/jsm_neo.c
+++ b/drivers/serial/jsm/jsm_neo.c
@@ -577,9 +577,6 @@ static void neo_parse_modem(struct jsm_channel *ch, u8 signals)
         jsm_printk(MSIGS, INFO, &ch->ch_bd->pci_dev,
                         "neo_parse_modem: port: %d msignals: %x\n", ch->ch_portnum, msignals);
 
-        if (!ch)
-                return;
-
         /* Scrub off lower bits. They signify delta's, which I don't care about */
         /* Keep DDCD and DDSR though */
         msignals &= 0xf8;
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index 01d0c70d60e..3cf41df302d 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -145,7 +145,7 @@ static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
 static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
         __u8 mask, __u8 byte);
 
-static int ti_download_firmware(struct ti_device *tdev, int type);
+static int ti_download_firmware(struct ti_device *tdev);
 
 /* circular buffer */
 static struct circ_buf *ti_buf_alloc(void);
@@ -176,9 +176,14 @@ static unsigned int product_5052_count;
 /* the array dimension is the number of default entries plus */
 /* TI_EXTRA_VID_PID_COUNT user defined entries plus 1 terminating */
 /* null entry */
-static struct usb_device_id ti_id_table_3410[1+TI_EXTRA_VID_PID_COUNT+1] = {
+static struct usb_device_id ti_id_table_3410[7+TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_NO_FW_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_EDGE_PRODUCT_ID) },
 };
 
 static struct usb_device_id ti_id_table_5052[4+TI_EXTRA_VID_PID_COUNT+1] = {
@@ -188,9 +193,14 @@ static struct usb_device_id ti_id_table_5052[4+TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
 };
 
-static struct usb_device_id ti_id_table_combined[] = {
+static struct usb_device_id ti_id_table_combined[6+2*TI_EXTRA_VID_PID_COUNT+1] = {
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_NO_FW_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_PRODUCT_ID) },
+        { USB_DEVICE(MTS_VENDOR_ID, MTS_EDGE_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
         { USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
@@ -272,6 +282,9 @@ MODULE_LICENSE("GPL");
 
 MODULE_FIRMWARE("ti_3410.fw");
 MODULE_FIRMWARE("ti_5052.fw");
+MODULE_FIRMWARE("mts_cdma.fw");
+MODULE_FIRMWARE("mts_gsm.fw");
+MODULE_FIRMWARE("mts_edge.fw");
 
 module_param(debug, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Enable debugging, 0=no, 1=yes");
@@ -304,21 +317,28 @@ MODULE_DEVICE_TABLE(usb, ti_id_table_combined);
 
 static int __init ti_init(void)
 {
-        int i, j;
+        int i, j, c;
         int ret;
 
         /* insert extra vendor and product ids */
+        c = ARRAY_SIZE(ti_id_table_combined) - 2 * TI_EXTRA_VID_PID_COUNT - 1;
         j = ARRAY_SIZE(ti_id_table_3410) - TI_EXTRA_VID_PID_COUNT - 1;
-        for (i = 0; i < min(vendor_3410_count, product_3410_count); i++, j++) {
+        for (i = 0; i < min(vendor_3410_count, product_3410_count); i++, j++, c++) {
                 ti_id_table_3410[j].idVendor = vendor_3410[i];
                 ti_id_table_3410[j].idProduct = product_3410[i];
                 ti_id_table_3410[j].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
+                ti_id_table_combined[c].idVendor = vendor_3410[i];
+                ti_id_table_combined[c].idProduct = product_3410[i];
+                ti_id_table_combined[c].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
         }
         j = ARRAY_SIZE(ti_id_table_5052) - TI_EXTRA_VID_PID_COUNT - 1;
-        for (i = 0; i < min(vendor_5052_count, product_5052_count); i++, j++) {
+        for (i = 0; i < min(vendor_5052_count, product_5052_count); i++, j++, c++) {
                 ti_id_table_5052[j].idVendor = vendor_5052[i];
                 ti_id_table_5052[j].idProduct = product_5052[i];
                 ti_id_table_5052[j].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
+                ti_id_table_combined[c].idVendor = vendor_5052[i];
+                ti_id_table_combined[c].idProduct = product_5052[i];
+                ti_id_table_combined[c].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
         }
 
         ret = usb_serial_register(&ti_1port_device);
@@ -390,11 +410,7 @@ static int ti_startup(struct usb_serial *serial)
 
         /* if we have only 1 configuration, download firmware */
         if (dev->descriptor.bNumConfigurations == 1) {
-                if (tdev->td_is_3410)
-                        status = ti_download_firmware(tdev, 3410);
-                else
-                        status = ti_download_firmware(tdev, 5052);
-                if (status)
+                if ((status = ti_download_firmware(tdev)) != 0)
                         goto free_tdev;
 
                 /* 3410 must be reset, 5052 resets itself */
@@ -1671,9 +1687,9 @@ static int ti_do_download(struct usb_device *dev, int pipe,
         return status;
 }
 
-static int ti_download_firmware(struct ti_device *tdev, int type)
+static int ti_download_firmware(struct ti_device *tdev)
 {
-        int status = -ENOMEM;
+        int status;
         int buffer_size;
         __u8 *buffer;
         struct usb_device *dev = tdev->td_serial->dev;
@@ -1681,9 +1697,34 @@ static int ti_download_firmware(struct ti_device *tdev, int type)
                 tdev->td_serial->port[0]->bulk_out_endpointAddress);
         const struct firmware *fw_p;
         char buf[32];
-        sprintf(buf, "ti_usb-%d.bin", type);
 
-        if (request_firmware(&fw_p, buf, &dev->dev)) {
+        /* try ID specific firmware first, then try generic firmware */
+        sprintf(buf, "ti_usb-v%04x-p%04x.fw", dev->descriptor.idVendor,
+            dev->descriptor.idProduct);
+        if ((status = request_firmware(&fw_p, buf, &dev->dev)) != 0) {
+                buf[0] = '\0';
+                if (dev->descriptor.idVendor == MTS_VENDOR_ID) {
+                        switch (dev->descriptor.idProduct) {
+                        case MTS_CDMA_PRODUCT_ID:
+                                strcpy(buf, "mts_cdma.fw");
+                                break;
+                        case MTS_GSM_PRODUCT_ID:
+                                strcpy(buf, "mts_gsm.fw");
+                                break;
+                        case MTS_EDGE_PRODUCT_ID:
+                                strcpy(buf, "mts_edge.fw");
+                                break;
+                        }
+                }
+                if (buf[0] == '\0') {
+                        if (tdev->td_is_3410)
+                                strcpy(buf, "ti_3410.fw");
+                        else
+                                strcpy(buf, "ti_5052.fw");
+                }
+                status = request_firmware(&fw_p, buf, &dev->dev);
+        }
+        if (status) {
                 dev_err(&dev->dev, "%s - firmware not found\n", __func__);
                 return -ENOENT;
         }
@@ -1699,6 +1740,8 @@ static int ti_download_firmware(struct ti_device *tdev, int type)
                 memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
                 status = ti_do_download(dev, pipe, buffer, fw_p->size);
                 kfree(buffer);
+        } else {
+                status = -ENOMEM;
         }
         release_firmware(fw_p);
         if (status) {
diff --git a/drivers/usb/serial/ti_usb_3410_5052.h b/drivers/usb/serial/ti_usb_3410_5052.h
index b5541bf991b..7e4752fbf23 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.h
+++ b/drivers/usb/serial/ti_usb_3410_5052.h
@@ -34,6 +34,14 @@
 #define TI_5052_EEPROM_PRODUCT_ID       0x505A  /* EEPROM, no firmware */
 #define TI_5052_FIRMWARE_PRODUCT_ID     0x505F  /* firmware is running */
 
+/* Multi-Tech vendor and product ids */
+#define MTS_VENDOR_ID                   0x06E0
+#define MTS_GSM_NO_FW_PRODUCT_ID        0xF108
+#define MTS_CDMA_NO_FW_PRODUCT_ID       0xF109
+#define MTS_CDMA_PRODUCT_ID             0xF110
+#define MTS_GSM_PRODUCT_ID              0xF111
+#define MTS_EDGE_PRODUCT_ID             0xF112
+
 /* Commands */
 #define TI_GET_VERSION                  0x01
 #define TI_GET_PORT_STATUS              0x02
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index 080ade223d5..cfcfd5ab06c 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -511,9 +511,6 @@ static void usb_serial_port_work(struct work_struct *work)
 
         dbg("%s - port %d", __func__, port->number);
 
-        if (!port)
-                return;
-
         tty = tty_port_tty_get(&port->port);
         if (!tty)
                 return;
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index e39e33e797d..be2b657546e 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -28,7 +28,7 @@ obj-$(CONFIG_FB_DDC)           += fb_ddc.o
 obj-$(CONFIG_FB_DEFERRED_IO)   += fb_defio.o
 
 # Hardware specific drivers go first
-obj-$(CONFIG_FB_AMIGA)            += amifb.o c2p.o
+obj-$(CONFIG_FB_AMIGA)            += amifb.o c2p_planar.o
 obj-$(CONFIG_FB_ARC)              += arcfb.o
 obj-$(CONFIG_FB_CLPS711X)         += clps711xfb.o
 obj-$(CONFIG_FB_CYBER2000)        += cyber2000fb.o
@@ -72,7 +72,7 @@ obj-$(CONFIG_FB_TCX)              += tcx.o sbuslib.o
 obj-$(CONFIG_FB_LEO)              += leo.o sbuslib.o
 obj-$(CONFIG_FB_SGIVW)            += sgivwfb.o
 obj-$(CONFIG_FB_ACORN)            += acornfb.o
-obj-$(CONFIG_FB_ATARI)            += atafb.o c2p.o atafb_mfb.o \
+obj-$(CONFIG_FB_ATARI)            += atafb.o c2p_iplan2.o atafb_mfb.o \
                                      atafb_iplan2p2.o atafb_iplan2p4.o atafb_iplan2p8.o
 obj-$(CONFIG_FB_MAC)              += macfb.o
 obj-$(CONFIG_FB_HECUBA)           += hecubafb.o
diff --git a/drivers/video/amifb.c b/drivers/video/amifb.c
index b8e9a8682f2..100f2366146 100644
--- a/drivers/video/amifb.c
+++ b/drivers/video/amifb.c
@@ -2159,9 +2159,9 @@ static void amifb_imageblit(struct fb_info *info, const struct fb_image *image)
                         src += pitch;
                 }
         } else {
-                c2p(info->screen_base, image->data, dx, dy, width, height,
-                    par->next_line, par->next_plane, image->width,
-                    info->var.bits_per_pixel);
+                c2p_planar(info->screen_base, image->data, dx, dy, width,
+                           height, par->next_line, par->next_plane,
+                           image->width, info->var.bits_per_pixel);
         }
 }
 
diff --git a/drivers/video/atafb.c b/drivers/video/atafb.c
index 77eb8b34fbf..8058572a742 100644
--- a/drivers/video/atafb.c
+++ b/drivers/video/atafb.c
@@ -122,7 +122,6 @@ static struct atafb_par {
         void *screen_base;
         int yres_virtual;
         u_long next_line;
-        u_long next_plane;
 #if defined ATAFB_TT || defined ATAFB_STE
         union {
                 struct {
@@ -149,6 +148,7 @@ static struct atafb_par {
                         short mono;
                         short ste_mode;
                         short bpp;
+                        u32 pseudo_palette[16];
                 } falcon;
 #endif
                 /* Nothing needed for external mode */
@@ -614,7 +614,7 @@ static int tt_encode_fix(struct fb_fix_screeninfo *fix, struct atafb_par *par)
         fix->xpanstep = 0;
         fix->ypanstep = 1;
         fix->ywrapstep = 0;
-        fix->line_length = 0;
+        fix->line_length = par->next_line;
         fix->accel = FB_ACCEL_ATARIBLITT;
         return 0;
 }
@@ -691,6 +691,7 @@ static int tt_decode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
                 return -EINVAL;
         par->yres_virtual = yres_virtual;
         par->screen_base = screen_base + var->yoffset * linelen;
+        par->next_line = linelen;
         return 0;
 }
 
@@ -884,10 +885,6 @@ static int vdl_prescale[4][3] = {
 /* Default hsync timing [mon_type] in picoseconds */
 static long h_syncs[4] = { 3000000, 4875000, 4000000, 4875000 };
 
-#ifdef FBCON_HAS_CFB16
-static u16 fbcon_cfb16_cmap[16];
-#endif
-
 static inline int hxx_prescale(struct falcon_hw *hw)
 {
         return hw->ste_mode ? 16
@@ -918,7 +915,7 @@ static int falcon_encode_fix(struct fb_fix_screeninfo *fix,
                 fix->visual = FB_VISUAL_TRUECOLOR;
                 fix->xpanstep = 2;
         }
-        fix->line_length = 0;
+        fix->line_length = par->next_line;
         fix->accel = FB_ACCEL_ATARIBLITT;
         return 0;
 }
@@ -1394,14 +1391,7 @@ set_screen_base:
         par->screen_base = screen_base + var->yoffset * linelen;
         par->hw.falcon.xoffset = 0;
 
-        // FIXME!!! sort of works, no crash
-        //par->next_line = linelen;
-        //par->next_plane = yres_virtual * linelen;
         par->next_line = linelen;
-        par->next_plane = 2;
-        // crashes
-        //par->next_plane = linelen;
-        //par->next_line  = yres_virtual * linelen;
 
         return 0;
 }
@@ -1735,10 +1725,10 @@ static int falcon_setcolreg(unsigned int regno, unsigned int red,
                         (((red & 0xe000) >> 13) | ((red & 0x1000) >> 12) << 8) |
                         (((green & 0xe000) >> 13) | ((green & 0x1000) >> 12) << 4) |
                         ((blue & 0xe000) >> 13) | ((blue & 0x1000) >> 12);
-#ifdef FBCON_HAS_CFB16
-                fbcon_cfb16_cmap[regno] = ((red & 0xf800) |
-                                           ((green & 0xfc00) >> 5) |
-                                           ((blue & 0xf800) >> 11));
+#ifdef ATAFB_FALCON
+                ((u32 *)info->pseudo_palette)[regno] = ((red & 0xf800) |
+                                                       ((green & 0xfc00) >> 5) |
+                                                       ((blue & 0xf800) >> 11));
 #endif
         }
         return 0;
@@ -1852,7 +1842,7 @@ static int stste_encode_fix(struct fb_fix_screeninfo *fix,
                 fix->ypanstep = 0;
         }
         fix->ywrapstep = 0;
-        fix->line_length = 0;
+        fix->line_length = par->next_line;
         fix->accel = FB_ACCEL_ATARIBLITT;
         return 0;
 }
@@ -1910,6 +1900,7 @@ static int stste_decode_var(struct fb_var_screeninfo *var,
                 return -EINVAL;
         par->yres_virtual = yres_virtual;
         par->screen_base = screen_base + var->yoffset * linelen;
+        par->next_line = linelen;
         return 0;
 }
 
@@ -2169,7 +2160,7 @@ static int ext_encode_fix(struct fb_fix_screeninfo *fix, struct atafb_par *par)
         fix->xpanstep = 0;
         fix->ypanstep = 0;
         fix->ywrapstep = 0;
-        fix->line_length = 0;
+        fix->line_length = par->next_line;
         return 0;
 }
 
@@ -2184,6 +2175,8 @@ static int ext_decode_var(struct fb_var_screeninfo *var, struct atafb_par *par)
             var->xoffset > 0 ||
             var->yoffset > 0)
                 return -EINVAL;
+
+        par->next_line = external_xres_virtual * external_depth / 8;
         return 0;
 }
 
@@ -2443,42 +2436,6 @@ static void atafb_set_disp(struct fb_info *info)
         atafb_get_fix(&info->fix, info);
 
         info->screen_base = (void *)info->fix.smem_start;
-
-        switch (info->fix.type) {
-        case FB_TYPE_INTERLEAVED_PLANES:
-                switch (info->var.bits_per_pixel) {
-                case 2:
-                        // display->dispsw = &fbcon_iplan2p2;
-                        break;
-                case 4:
-                        // display->dispsw = &fbcon_iplan2p4;
-                        break;
-                case 8:
-                        // display->dispsw = &fbcon_iplan2p8;
-                        break;
-                }
-                break;
-        case FB_TYPE_PACKED_PIXELS:
-                switch (info->var.bits_per_pixel) {
-#ifdef FBCON_HAS_MFB
-                case 1:
-                        // display->dispsw = &fbcon_mfb;
-                        break;
-#endif
-#ifdef FBCON_HAS_CFB8
-                case 8:
-                        // display->dispsw = &fbcon_cfb8;
-                        break;
-#endif
-#ifdef FBCON_HAS_CFB16
-                case 16:
-                        // display->dispsw = &fbcon_cfb16;
-                        // display->dispsw_data = fbcon_cfb16_cmap;
-                        break;
-#endif
-                }
-                break;
-        }
 }
 
 static int atafb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
@@ -2549,6 +2506,13 @@ static void atafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
         if (!rect->width || !rect->height)
                 return;
 
+#ifdef ATAFB_FALCON
+        if (info->var.bits_per_pixel == 16) {
+                cfb_fillrect(info, rect);
+                return;
+        }
+#endif
+
         /*
          * We could use hardware clipping but on many cards you get around
          * hardware clipping by writing to framebuffer directly.
@@ -2583,6 +2547,13 @@ static void atafb_copyarea(struct fb_info *info, const struct fb_copyarea *area)
         u32 dx, dy, sx, sy, width, height;
         int rev_copy = 0;
 
+#ifdef ATAFB_FALCON
+        if (info->var.bits_per_pixel == 16) {
+                cfb_copyarea(info, area);
+                return;
+        }
+#endif
+
         /* clip the destination */
         x2 = area->dx + area->width;
         y2 = area->dy + area->height;
@@ -2632,6 +2603,13 @@ static void atafb_imageblit(struct fb_info *info, const struct fb_image *image)
         const char *src;
         u32 dx, dy, width, height, pitch;
 
+#ifdef ATAFB_FALCON
+        if (info->var.bits_per_pixel == 16) {
+                cfb_imageblit(info, image);
+                return;
+        }
+#endif
+
         /*
          * We could use hardware clipping but on many cards you get around
          * hardware clipping by writing to framebuffer directly like we are
@@ -2676,10 +2654,9 @@ static void atafb_imageblit(struct fb_info *info, const struct fb_image *image)
                         src += pitch;
                 }
         } else {
-                // only used for logo; broken
-                c2p(info->screen_base, image->data, dx, dy, width, height,
-                    par->next_line, par->next_plane, image->width,
-                    info->var.bits_per_pixel);
+                c2p_iplan2(info->screen_base, image->data, dx, dy, width,
+                           height, par->next_line, image->width,
+                           info->var.bits_per_pixel);
         }
 }
 
@@ -3098,8 +3075,7 @@ int __init atafb_setup(char *options)
 
 int __init atafb_init(void)
 {
-        int pad;
-        int detected_mode;
+        int pad, detected_mode, error;
         unsigned int defmode = 0;
         unsigned long mem_req;
 
@@ -3139,8 +3115,12 @@ int __init atafb_init(void)
                         printk("atafb_init: initializing Falcon hw\n");
                         fbhw = &falcon_switch;
                         atafb_ops.fb_setcolreg = &falcon_setcolreg;
-                        request_irq(IRQ_AUTO_4, falcon_vbl_switcher, IRQ_TYPE_PRIO,
-                                    "framebuffer/modeswitch", falcon_vbl_switcher);
+                        error = request_irq(IRQ_AUTO_4, falcon_vbl_switcher,
+                                            IRQ_TYPE_PRIO,
+                                            "framebuffer/modeswitch",
+                                            falcon_vbl_switcher);
+                        if (error)
+                                return error;
                         defmode = DEFMODE_F30;
                         break;
                 }
@@ -3225,6 +3205,10 @@ int __init atafb_init(void)
         // tries to read from HW which may not be initialized yet
         // so set sane var first, then call atafb_set_par
         atafb_get_var(&fb_info.var, &fb_info);
+
+#ifdef ATAFB_FALCON
+        fb_info.pseudo_palette = current_par.hw.falcon.pseudo_palette;
+#endif
         fb_info.flags = FBINFO_FLAG_DEFAULT;
 
         if (!fb_find_mode(&fb_info.var, &fb_info, mode_option, atafb_modedb,
diff --git a/drivers/video/c2p.c b/drivers/video/c2p.c
deleted file mode 100644
index 376bc07ff95..00000000000
--- a/drivers/video/c2p.c
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- *  Fast C2P (Chunky-to-Planar) Conversion
- *
- *  Copyright (C) 2003 Geert Uytterhoeven
- *
- *  NOTES:
- *    - This code was inspired by Scout's C2P tutorial
- *    - It assumes to run on a big endian system
- *
- *  This file is subject to the terms and conditions of the GNU General Public
- *  License. See the file COPYING in the main directory of this archive
- *  for more details.
- */
-
-#include <linux/module.h>
-#include <linux/string.h>
-#include "c2p.h"
-
-
-    /*
-     *  Basic transpose step
-     */
-
-#define _transp(d, i1, i2, shift, mask)                 \
-    do {                                                \
-        u32 t = (d[i1] ^ (d[i2] >> shift)) & mask;      \
-        d[i1] ^= t;                                     \
-        d[i2] ^= t << shift;                            \
-    } while (0)
-
-static inline u32 get_mask(int n)
-{
-    switch (n) {
-        case 1:
-            return 0x55555555;
-            break;
-
-        case 2:
-            return 0x33333333;
-            break;
-
-        case 4:
-            return 0x0f0f0f0f;
-            break;
-
-        case 8:
-            return 0x00ff00ff;
-            break;
-
-        case 16:
-            return 0x0000ffff;
-            break;
-    }
-    return 0;
-}
-
-#define transp_nx1(d, n)                                \
-    do {                                                \
-        u32 mask = get_mask(n);                         \
-        /* First block */                               \
-        _transp(d, 0, 1, n, mask);                      \
-        /* Second block */                              \
-        _transp(d, 2, 3, n, mask);                      \
-        /* Third block */                               \
-        _transp(d, 4, 5, n, mask);                      \
-        /* Fourth block */                              \
-        _transp(d, 6, 7, n, mask);                      \
-    } while (0)
-
-#define transp_nx2(d, n)                                \
-    do {                                                \
-        u32 mask = get_mask(n);                         \
-        /* First block */                               \
-        _transp(d, 0, 2, n, mask);                      \
-        _transp(d, 1, 3, n, mask);                      \
-        /* Second block */                              \
-        _transp(d, 4, 6, n, mask);                      \
-        _transp(d, 5, 7, n, mask);                      \
-    } while (0)
-
-#define transp_nx4(d, n)                                \
-    do {                                                \
-        u32 mask = get_mask(n);                         \
-        _transp(d, 0, 4, n, mask);                      \
-        _transp(d, 1, 5, n, mask);                      \
-        _transp(d, 2, 6, n, mask);                      \
-        _transp(d, 3, 7, n, mask);                      \
-    } while (0)
-
-#define transp(d, n, m) transp_nx ## m(d, n)
-
-
-    /*
-     *  Perform a full C2P step on 32 8-bit pixels, stored in 8 32-bit words
-     *  containing
-     *    - 32 8-bit chunky pixels on input
-     *    - permuted planar data on output
-     */
-
-static void c2p_8bpp(u32 d[8])
-{
-    transp(d, 16, 4);
-    transp(d, 8, 2);
-    transp(d, 4, 1);
-    transp(d, 2, 4);
-    transp(d, 1, 2);
-}
-
-
-    /*
-     *  Array containing the permution indices of the planar data after c2p
-     */
-
-static const int perm_c2p_8bpp[8] = { 7, 5, 3, 1, 6, 4, 2, 0 };
-
-
-    /*
-     *  Compose two values, using a bitmask as decision value
-     *  This is equivalent to (a & mask) | (b & ~mask)
-     */
-
-static inline unsigned long comp(unsigned long a, unsigned long b,
-                                 unsigned long mask)
-{
-        return ((a ^ b) & mask) ^ b;
-}
-
-
-    /*
-     *  Store a full block of planar data after c2p conversion
-     */
-
-static inline void store_planar(char *dst, u32 dst_inc, u32 bpp, u32 d[8])
-{
-    int i;
-
-    for (i = 0; i < bpp; i++, dst += dst_inc)
-        *(u32 *)dst = d[perm_c2p_8bpp[i]];
-}
-
-
-    /*
-     *  Store a partial block of planar data after c2p conversion
-     */
-
-static inline void store_planar_masked(char *dst, u32 dst_inc, u32 bpp,
-                                       u32 d[8], u32 mask)
-{
-    int i;
-
-    for (i = 0; i < bpp; i++, dst += dst_inc)
-        *(u32 *)dst = comp(d[perm_c2p_8bpp[i]], *(u32 *)dst, mask);
-}
-
-
-    /*
-     *  c2p - Copy 8-bit chunky image data to a planar frame buffer
-     *  @dst: Starting address of the planar frame buffer
-     *  @dx: Horizontal destination offset (in pixels)
-     *  @dy: Vertical destination offset (in pixels)
-     *  @width: Image width (in pixels)
-     *  @height: Image height (in pixels)
-     *  @dst_nextline: Frame buffer offset to the next line (in bytes)
-     *  @dst_nextplane: Frame buffer offset to the next plane (in bytes)
-     *  @src_nextline: Image offset to the next line (in bytes)
-     *  @bpp: Bits per pixel of the planar frame buffer (1-8)
-     */
-
-void c2p(u8 *dst, const u8 *src, u32 dx, u32 dy, u32 width, u32 height,
-         u32 dst_nextline, u32 dst_nextplane, u32 src_nextline, u32 bpp)
-{
-    int dst_idx;
-    u32 d[8], first, last, w;
-    const u8 *c;
-    u8 *p;
-
-    dst += dy*dst_nextline+(dx & ~31);
-    dst_idx = dx % 32;
-    first = ~0UL >> dst_idx;
-    last = ~(~0UL >> ((dst_idx+width) % 32));
-    while (height--) {
-        c = src;
-        p = dst;
-        w = width;
-        if (dst_idx+width <= 32) {
-            /* Single destination word */
-            first &= last;
-            memset(d, 0, sizeof(d));
-            memcpy((u8 *)d+dst_idx, c, width);
-            c += width;
-            c2p_8bpp(d);
-            store_planar_masked(p, dst_nextplane, bpp, d, first);
-            p += 4;
-        } else {
-            /* Multiple destination words */
-            w = width;
-            /* Leading bits */
-            if (dst_idx) {
-                w = 32 - dst_idx;
-                memset(d, 0, dst_idx);
-                memcpy((u8 *)d+dst_idx, c, w);
-                c += w;
-                c2p_8bpp(d);
-                store_planar_masked(p, dst_nextplane, bpp, d, first);
-                p += 4;
-                w = width-w;
-            }
-            /* Main chunk */
-            while (w >= 32) {
-                memcpy(d, c, 32);
-                c += 32;
-                c2p_8bpp(d);
-                store_planar(p, dst_nextplane, bpp, d);
-                p += 4;
-                w -= 32;
-            }
-            /* Trailing bits */
-            w %= 32;
-            if (w > 0) {
-                memcpy(d, c, w);
-                memset((u8 *)d+w, 0, 32-w);
-                c2p_8bpp(d);
-                store_planar_masked(p, dst_nextplane, bpp, d, last);
-            }
-        }
-        src += src_nextline;
-        dst += dst_nextline;
-    }
-}
-EXPORT_SYMBOL_GPL(c2p);
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/video/c2p.h b/drivers/video/c2p.h
index c77cbf17e04..6c38d40427d 100644
--- a/drivers/video/c2p.h
+++ b/drivers/video/c2p.h
@@ -1,7 +1,7 @@
 /*
  *  Fast C2P (Chunky-to-Planar) Conversion
  *
- *  Copyright (C) 2003 Geert Uytterhoeven
+ *  Copyright (C) 2003-2008 Geert Uytterhoeven
  *
  *  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
@@ -10,7 +10,10 @@
 
 #include <linux/types.h>
 
-extern void c2p(u8 *dst, const u8 *src, u32 dx, u32 dy, u32 width, u32 height,
-                u32 dst_nextline, u32 dst_nextplane, u32 src_nextline,
-                u32 bpp);
+extern void c2p_planar(void *dst, const void *src, u32 dx, u32 dy, u32 width,
+                       u32 height, u32 dst_nextline, u32 dst_nextplane,
+                       u32 src_nextline, u32 bpp);
 
+extern void c2p_iplan2(void *dst, const void *src, u32 dx, u32 dy, u32 width,
+                       u32 height, u32 dst_nextline, u32 src_nextline,
+                       u32 bpp);
diff --git a/drivers/video/c2p_core.h b/drivers/video/c2p_core.h
new file mode 100644
index 00000000000..e1035a865fb
--- /dev/null
+++ b/drivers/video/c2p_core.h
@@ -0,0 +1,153 @@
+/*
+ *  Fast C2P (Chunky-to-Planar) Conversion
+ *
+ *  Copyright (C) 2003-2008 Geert Uytterhoeven
+ *
+ *  NOTES:
+ *    - This code was inspired by Scout's C2P tutorial
+ *    - It assumes to run on a big endian system
+ *
+ *  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.
+ */
+
+
+    /*
+     *  Basic transpose step
+     */
+
+static inline void _transp(u32 d[], unsigned int i1, unsigned int i2,
+                           unsigned int shift, u32 mask)
+{
+        u32 t = (d[i1] ^ (d[i2] >> shift)) & mask;
+
+        d[i1] ^= t;
+        d[i2] ^= t << shift;
+}
+
+
+extern void c2p_unsupported(void);
+
+static inline u32 get_mask(unsigned int n)
+{
+        switch (n) {
+        case 1:
+                return 0x55555555;
+
+        case 2:
+                return 0x33333333;
+
+        case 4:
+                return 0x0f0f0f0f;
+
+        case 8:
+                return 0x00ff00ff;
+
+        case 16:
+                return 0x0000ffff;
+        }
+
+        c2p_unsupported();
+        return 0;
+}
+
+
+    /*
+     *  Transpose operations on 8 32-bit words
+     */
+
+static inline void transp8(u32 d[], unsigned int n, unsigned int m)
+{
+        u32 mask = get_mask(n);
+
+        switch (m) {
+        case 1:
+                /* First n x 1 block */
+                _transp(d, 0, 1, n, mask);
+                /* Second n x 1 block */
+                _transp(d, 2, 3, n, mask);
+                /* Third n x 1 block */
+                _transp(d, 4, 5, n, mask);
+                /* Fourth n x 1 block */
+                _transp(d, 6, 7, n, mask);
+                return;
+
+        case 2:
+                /* First n x 2 block */
+                _transp(d, 0, 2, n, mask);
+                _transp(d, 1, 3, n, mask);
+                /* Second n x 2 block */
+                _transp(d, 4, 6, n, mask);
+                _transp(d, 5, 7, n, mask);
+                return;
+
+        case 4:
+                /* Single n x 4 block */
+                _transp(d, 0, 4, n, mask);
+                _transp(d, 1, 5, n, mask);
+                _transp(d, 2, 6, n, mask);
+                _transp(d, 3, 7, n, mask);
+                return;
+        }
+
+        c2p_unsupported();
+}
+
+
+    /*
+     *  Transpose operations on 4 32-bit words
+     */
+
+static inline void transp4(u32 d[], unsigned int n, unsigned int m)
+{
+        u32 mask = get_mask(n);
+
+        switch (m) {
+        case 1:
+                /* First n x 1 block */
+                _transp(d, 0, 1, n, mask);
+                /* Second n x 1 block */
+                _transp(d, 2, 3, n, mask);
+                return;
+
+        case 2:
+                /* Single n x 2 block */
+                _transp(d, 0, 2, n, mask);
+                _transp(d, 1, 3, n, mask);
+                return;
+        }
+
+        c2p_unsupported();
+}
+
+
+    /*
+     *  Transpose operations on 4 32-bit words (reverse order)
+     */
+
+static inline void transp4x(u32 d[], unsigned int n, unsigned int m)
+{
+        u32 mask = get_mask(n);
+
+        switch (m) {
+        case 2:
+                /* Single n x 2 block */
+                _transp(d, 2, 0, n, mask);
+                _transp(d, 3, 1, n, mask);
+                return;
+        }
+
+        c2p_unsupported();
+}
+
+
+    /*
+     *  Compose two values, using a bitmask as decision value
+     *  This is equivalent to (a & mask) | (b & ~mask)
+     */
+
+static inline u32 comp(u32 a, u32 b, u32 mask)
+{
+        return ((a ^ b) & mask) ^ b;
+}
diff --git a/drivers/video/c2p_iplan2.c b/drivers/video/c2p_iplan2.c
new file mode 100644
index 00000000000..19156dc6158
--- /dev/null
+++ b/drivers/video/c2p_iplan2.c
@@ -0,0 +1,153 @@
+/*
+ *  Fast C2P (Chunky-to-Planar) Conversion
+ *
+ *  Copyright (C) 2003-2008 Geert Uytterhoeven
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive
+ *  for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+
+#include <asm/unaligned.h>
+
+#include "c2p.h"
+#include "c2p_core.h"
+
+
+    /*
+     *  Perform a full C2P step on 16 8-bit pixels, stored in 4 32-bit words
+     *  containing
+     *    - 16 8-bit chunky pixels on input
+     *    - permutated planar data (2 planes per 32-bit word) on output
+     */
+
+static void c2p_16x8(u32 d[4])
+{
+        transp4(d, 8, 2);
+        transp4(d, 1, 2);
+        transp4x(d, 16, 2);
+        transp4x(d, 2, 2);
+        transp4(d, 4, 1);
+}
+
+
+    /*
+     *  Array containing the permutation indices of the planar data after c2p
+     */
+
+static const int perm_c2p_16x8[4] = { 1, 3, 0, 2 };
+
+
+    /*
+     *  Store a full block of iplan2 data after c2p conversion
+     */
+
+static inline void store_iplan2(void *dst, u32 bpp, u32 d[4])
+{
+        int i;
+
+        for (i = 0; i < bpp/2; i++, dst += 4)
+                put_unaligned_be32(d[perm_c2p_16x8[i]], dst);
+}
+
+
+    /*
+     *  Store a partial block of iplan2 data after c2p conversion
+     */
+
+static inline void store_iplan2_masked(void *dst, u32 bpp, u32 d[4], u32 mask)
+{
+        int i;
+
+        for (i = 0; i < bpp/2; i++, dst += 4)
+                put_unaligned_be32(comp(d[perm_c2p_16x8[i]],
+                                        get_unaligned_be32(dst), mask),
+                                   dst);
+}
+
+
+    /*
+     *  c2p_iplan2 - Copy 8-bit chunky image data to an interleaved planar
+     *  frame buffer with 2 bytes of interleave
+     *  @dst: Starting address of the planar frame buffer
+     *  @dx: Horizontal destination offset (in pixels)
+     *  @dy: Vertical destination offset (in pixels)
+     *  @width: Image width (in pixels)
+     *  @height: Image height (in pixels)
+     *  @dst_nextline: Frame buffer offset to the next line (in bytes)
+     *  @src_nextline: Image offset to the next line (in bytes)
+     *  @bpp: Bits per pixel of the planar frame buffer (2, 4, or 8)
+     */
+
+void c2p_iplan2(void *dst, const void *src, u32 dx, u32 dy, u32 width,
+                u32 height, u32 dst_nextline, u32 src_nextline, u32 bpp)
+{
+        union {
+                u8 pixels[16];
+                u32 words[4];
+        } d;
+        u32 dst_idx, first, last, w;
+        const u8 *c;
+        void *p;
+
+        dst += dy*dst_nextline+(dx & ~15)*bpp;
+        dst_idx = dx % 16;
+        first = 0xffffU >> dst_idx;
+        first |= first << 16;
+        last = 0xffffU ^ (0xffffU >> ((dst_idx+width) % 16));
+        last |= last << 16;
+        while (height--) {
+                c = src;
+                p = dst;
+                w = width;
+                if (dst_idx+width <= 16) {
+                        /* Single destination word */
+                        first &= last;
+                        memset(d.pixels, 0, sizeof(d));
+                        memcpy(d.pixels+dst_idx, c, width);
+                        c += width;
+                        c2p_16x8(d.words);
+                        store_iplan2_masked(p, bpp, d.words, first);
+                        p += bpp*2;
+                } else {
+                        /* Multiple destination words */
+                        w = width;
+                        /* Leading bits */
+                        if (dst_idx) {
+                                w = 16 - dst_idx;
+                                memset(d.pixels, 0, dst_idx);
+                                memcpy(d.pixels+dst_idx, c, w);
+                                c += w;
+                                c2p_16x8(d.words);
+                                store_iplan2_masked(p, bpp, d.words, first);
+                                p += bpp*2;
+                                w = width-w;
+                        }
+                        /* Main chunk */
+                        while (w >= 16) {
+                                memcpy(d.pixels, c, 16);
+                                c += 16;
+                                c2p_16x8(d.words);
+                                store_iplan2(p, bpp, d.words);
+                                p += bpp*2;
+                                w -= 16;
+                        }
+                        /* Trailing bits */
+                        w %= 16;
+                        if (w > 0) {
+                                memcpy(d.pixels, c, w);
+                                memset(d.pixels+w, 0, 16-w);
+                                c2p_16x8(d.words);
+                                store_iplan2_masked(p, bpp, d.words, last);
+                        }
+                }
+                src += src_nextline;
+                dst += dst_nextline;
+        }
+}
+EXPORT_SYMBOL_GPL(c2p_iplan2);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/c2p_planar.c b/drivers/video/c2p_planar.c
new file mode 100644
index 00000000000..ec7ac8526f0
--- /dev/null
+++ b/drivers/video/c2p_planar.c
@@ -0,0 +1,156 @@
+/*
+ *  Fast C2P (Chunky-to-Planar) Conversion
+ *
+ *  Copyright (C) 2003-2008 Geert Uytterhoeven
+ *
+ *  This file is subject to the terms and conditions of the GNU General Public
+ *  License. See the file COPYING in the main directory of this archive
+ *  for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/string.h>
+
+#include <asm/unaligned.h>
+
+#include "c2p.h"
+#include "c2p_core.h"
+
+
+    /*
+     *  Perform a full C2P step on 32 8-bit pixels, stored in 8 32-bit words
+     *  containing
+     *    - 32 8-bit chunky pixels on input
+     *    - permutated planar data (1 plane per 32-bit word) on output
+     */
+
+static void c2p_32x8(u32 d[8])
+{
+        transp8(d, 16, 4);
+        transp8(d, 8, 2);
+        transp8(d, 4, 1);
+        transp8(d, 2, 4);
+        transp8(d, 1, 2);
+}
+
+
+    /*
+     *  Array containing the permutation indices of the planar data after c2p
+     */
+
+static const int perm_c2p_32x8[8] = { 7, 5, 3, 1, 6, 4, 2, 0 };
+
+
+    /*
+     *  Store a full block of planar data after c2p conversion
+     */
+
+static inline void store_planar(void *dst, u32 dst_inc, u32 bpp, u32 d[8])
+{
+        int i;
+
+        for (i = 0; i < bpp; i++, dst += dst_inc)
+                put_unaligned_be32(d[perm_c2p_32x8[i]], dst);
+}
+
+
+    /*
+     *  Store a partial block of planar data after c2p conversion
+     */
+
+static inline void store_planar_masked(void *dst, u32 dst_inc, u32 bpp,
+                                       u32 d[8], u32 mask)
+{
+        int i;
+
+        for (i = 0; i < bpp; i++, dst += dst_inc)
+                put_unaligned_be32(comp(d[perm_c2p_32x8[i]],
+                                        get_unaligned_be32(dst), mask),
+                                   dst);
+}
+
+
+    /*
+     *  c2p_planar - Copy 8-bit chunky image data to a planar frame buffer
+     *  @dst: Starting address of the planar frame buffer
+     *  @dx: Horizontal destination offset (in pixels)
+     *  @dy: Vertical destination offset (in pixels)
+     *  @width: Image width (in pixels)
+     *  @height: Image height (in pixels)
+     *  @dst_nextline: Frame buffer offset to the next line (in bytes)
+     *  @dst_nextplane: Frame buffer offset to the next plane (in bytes)
+     *  @src_nextline: Image offset to the next line (in bytes)
+     *  @bpp: Bits per pixel of the planar frame buffer (1-8)
+     */
+
+void c2p_planar(void *dst, const void *src, u32 dx, u32 dy, u32 width,
+                u32 height, u32 dst_nextline, u32 dst_nextplane,
+                u32 src_nextline, u32 bpp)
+{
+        union {
+                u8 pixels[32];
+                u32 words[8];
+        } d;
+        u32 dst_idx, first, last, w;
+        const u8 *c;
+        void *p;
+
+        dst += dy*dst_nextline+(dx & ~31);
+        dst_idx = dx % 32;
+        first = 0xffffffffU >> dst_idx;
+        last = ~(0xffffffffU >> ((dst_idx+width) % 32));
+        while (height--) {
+                c = src;
+                p = dst;
+                w = width;
+                if (dst_idx+width <= 32) {
+                        /* Single destination word */
+                        first &= last;
+                        memset(d.pixels, 0, sizeof(d));
+                        memcpy(d.pixels+dst_idx, c, width);
+                        c += width;
+                        c2p_32x8(d.words);
+                        store_planar_masked(p, dst_nextplane, bpp, d.words,
+                                            first);
+                        p += 4;
+                } else {
+                        /* Multiple destination words */
+                        w = width;
+                        /* Leading bits */
+                        if (dst_idx) {
+                                w = 32 - dst_idx;
+                                memset(d.pixels, 0, dst_idx);
+                                memcpy(d.pixels+dst_idx, c, w);
+                                c += w;
+                                c2p_32x8(d.words);
+                                store_planar_masked(p, dst_nextplane, bpp,
+                                                    d.words, first);
+                                p += 4;
+                                w = width-w;
+                        }
+                        /* Main chunk */
+                        while (w >= 32) {
+                                memcpy(d.pixels, c, 32);
+                                c += 32;
+                                c2p_32x8(d.words);
+                                store_planar(p, dst_nextplane, bpp, d.words);
+                                p += 4;
+                                w -= 32;
+                        }
+                        /* Trailing bits */
+                        w %= 32;
+                        if (w > 0) {
+                                memcpy(d.pixels, c, w);
+                                memset(d.pixels+w, 0, 32-w);
+                                c2p_32x8(d.words);
+                                store_planar_masked(p, dst_nextplane, bpp,
+                                                    d.words, last);
+                        }
+                }
+                src += src_nextline;
+                dst += dst_nextline;
+        }
+}
+EXPORT_SYMBOL_GPL(c2p_planar);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 4bcff81b50e..1657b9608b0 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -78,13 +78,6 @@
 #include <asm/fb.h>
 #include <asm/irq.h>
 #include <asm/system.h>
-#ifdef CONFIG_ATARI
-#include <asm/atariints.h>
-#endif
-#if defined(__mc68000__)
-#include <asm/machdep.h>
-#include <asm/setup.h>
-#endif
 
 #include "fbcon.h"
 
@@ -155,9 +148,6 @@ static int fbcon_set_origin(struct vc_data *);
 
 #define CURSOR_DRAW_DELAY               (1)
 
-/* # VBL ints between cursor state changes */
-#define ATARI_CURSOR_BLINK_RATE         (42)
-
 static int vbl_cursor_cnt;
 static int fbcon_cursor_noblink;
 
@@ -403,20 +393,6 @@ static void fb_flashcursor(struct work_struct *work)
         release_console_sem();
 }
 
-#ifdef CONFIG_ATARI
-static int cursor_blink_rate;
-static irqreturn_t fb_vbl_handler(int irq, void *dev_id)
-{
-        struct fb_info *info = dev_id;
-
-        if (vbl_cursor_cnt && --vbl_cursor_cnt == 0) {
-                schedule_work(&info->queue);    
-                vbl_cursor_cnt = cursor_blink_rate; 
-        }
-        return IRQ_HANDLED;
-}
-#endif
-        
 static void cursor_timer_handler(unsigned long dev_addr)
 {
         struct fb_info *info = (struct fb_info *) dev_addr;
@@ -1017,15 +993,6 @@ static const char *fbcon_startup(void)
                 info->var.yres,
                 info->var.bits_per_pixel);
 
-#ifdef CONFIG_ATARI
-        if (MACH_IS_ATARI) {
-                cursor_blink_rate = ATARI_CURSOR_BLINK_RATE;
-                (void)request_irq(IRQ_AUTO_4, fb_vbl_handler,
-                                IRQ_TYPE_PRIO, "framebuffer vbl",
-                                info);
-        }
-#endif /* CONFIG_ATARI */
-
         fbcon_add_cursor_timer(info);
         fbcon_has_exited = 0;
         return display_desc;
@@ -3454,11 +3421,6 @@ static void fbcon_exit(void)
         if (fbcon_has_exited)
                 return;
 
-#ifdef CONFIG_ATARI
-        if (MACH_IS_ATARI)
-                free_irq(IRQ_AUTO_4, fb_vbl_handler);
-#endif
-
         kfree((void *)softback_buf);
         softback_buf = 0UL;
 
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index ec68c741b56..3efa12f9ee5 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -770,6 +770,12 @@ config TXX9_WDT
 
 # POWERPC Architecture
 
+config GEF_WDT
+        tristate "GE Fanuc Watchdog Timer"
+        depends on GEF_SBC610
+        ---help---
+          Watchdog timer found in a number of GE Fanuc single board computers.
+
 config MPC5200_WDT
         tristate "MPC5200 Watchdog Timer"
         depends on PPC_MPC52xx
@@ -790,6 +796,14 @@ config MV64X60_WDT
         tristate "MV64X60 (Marvell Discovery) Watchdog Timer"
         depends on MV64X60
 
+config PIKA_WDT
+        tristate "PIKA FPGA Watchdog"
+        depends on WARP
+        default y
+        help
+          This enables the watchdog in the PIKA FPGA. Currently used on
+          the Warp platform.
+
 config BOOKE_WDT
         bool "PowerPC Book-E Watchdog Timer"
         depends on BOOKE || 4xx
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index c19b866f5ed..806b3eb0853 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -111,9 +111,11 @@ obj-$(CONFIG_TXX9_WDT) += txx9wdt.o
 # PARISC Architecture
 
 # POWERPC Architecture
+obj-$(CONFIG_GEF_WDT) += gef_wdt.o
 obj-$(CONFIG_MPC5200_WDT) += mpc5200_wdt.o
 obj-$(CONFIG_8xxx_WDT) += mpc8xxx_wdt.o
 obj-$(CONFIG_MV64X60_WDT) += mv64x60_wdt.o
+obj-$(CONFIG_PIKA_WDT) += pika_wdt.o
 obj-$(CONFIG_BOOKE_WDT) += booke_wdt.o
 
 # PPC64 Architecture
diff --git a/drivers/watchdog/gef_wdt.c b/drivers/watchdog/gef_wdt.c
new file mode 100644
index 00000000000..f0c2b7a1a17
--- /dev/null
+++ b/drivers/watchdog/gef_wdt.c
@@ -0,0 +1,330 @@
+/*
+ * GE Fanuc watchdog userspace interface
+ *
+ * Author:  Martyn Welch <martyn.welch@gefanuc.com>
+ *
+ * Copyright 2008 GE Fanuc Intelligent Platforms Embedded Systems, Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ *
+ * Based on: mv64x60_wdt.c (MV64X60 watchdog userspace interface)
+ *   Author: James Chapman <jchapman@katalix.com>
+ */
+
+/* TODO:
+ * This driver does not provide support for the hardwares capability of sending
+ * an interrupt at a programmable threshold.
+ *
+ * This driver currently can only support 1 watchdog - there are 2 in the
+ * hardware that this driver supports. Thus one could be configured as a
+ * process-based watchdog (via /dev/watchdog), the second (using the interrupt
+ * capabilities) a kernel-based watchdog.
+ */
+
+#include <linux/kernel.h>
+#include <linux/compiler.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
+
+#include <sysdev/fsl_soc.h>
+
+/*
+ * The watchdog configuration register contains a pair of 2-bit fields,
+ *   1.  a reload field, bits 27-26, which triggers a reload of
+ *       the countdown register, and
+ *   2.  an enable field, bits 25-24, which toggles between
+ *       enabling and disabling the watchdog timer.
+ * Bit 31 is a read-only field which indicates whether the
+ * watchdog timer is currently enabled.
+ *
+ * The low 24 bits contain the timer reload value.
+ */
+#define GEF_WDC_ENABLE_SHIFT    24
+#define GEF_WDC_SERVICE_SHIFT   26
+#define GEF_WDC_ENABLED_SHIFT   31
+
+#define GEF_WDC_ENABLED_TRUE    1
+#define GEF_WDC_ENABLED_FALSE   0
+
+/* Flags bits */
+#define GEF_WDOG_FLAG_OPENED    0
+
+static unsigned long wdt_flags;
+static int wdt_status;
+static void __iomem *gef_wdt_regs;
+static int gef_wdt_timeout;
+static int gef_wdt_count;
+static unsigned int bus_clk;
+static char expect_close;
+static DEFINE_SPINLOCK(gef_wdt_spinlock);
+
+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 int gef_wdt_toggle_wdc(int enabled_predicate, int field_shift)
+{
+        u32 data;
+        u32 enabled;
+        int ret = 0;
+
+        spin_lock(&gef_wdt_spinlock);
+        data = ioread32be(gef_wdt_regs);
+        enabled = (data >> GEF_WDC_ENABLED_SHIFT) & 1;
+
+        /* only toggle the requested field if enabled state matches predicate */
+        if ((enabled ^ enabled_predicate) == 0) {
+                /* We write a 1, then a 2 -- to the appropriate field */
+                data = (1 << field_shift) | gef_wdt_count;
+                iowrite32be(data, gef_wdt_regs);
+
+                data = (2 << field_shift) | gef_wdt_count;
+                iowrite32be(data, gef_wdt_regs);
+                ret = 1;
+        }
+        spin_unlock(&gef_wdt_spinlock);
+
+        return ret;
+}
+
+static void gef_wdt_service(void)
+{
+        gef_wdt_toggle_wdc(GEF_WDC_ENABLED_TRUE,
+                GEF_WDC_SERVICE_SHIFT);
+}
+
+static void gef_wdt_handler_enable(void)
+{
+        if (gef_wdt_toggle_wdc(GEF_WDC_ENABLED_FALSE,
+                                   GEF_WDC_ENABLE_SHIFT)) {
+                gef_wdt_service();
+                printk(KERN_NOTICE "gef_wdt: watchdog activated\n");
+        }
+}
+
+static void gef_wdt_handler_disable(void)
+{
+        if (gef_wdt_toggle_wdc(GEF_WDC_ENABLED_TRUE,
+                                   GEF_WDC_ENABLE_SHIFT))
+                printk(KERN_NOTICE "gef_wdt: watchdog deactivated\n");
+}
+
+static void gef_wdt_set_timeout(unsigned int timeout)
+{
+        /* maximum bus cycle count is 0xFFFFFFFF */
+        if (timeout > 0xFFFFFFFF / bus_clk)
+                timeout = 0xFFFFFFFF / bus_clk;
+
+        /* Register only holds upper 24 bits, bit shifted into lower 24 */
+        gef_wdt_count = (timeout * bus_clk) >> 8;
+        gef_wdt_timeout = timeout;
+}
+
+
+static ssize_t gef_wdt_write(struct file *file, const char __user *data,
+                                 size_t len, loff_t *ppos)
+{
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        expect_close = 0;
+
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_close = 42;
+                        }
+                }
+                gef_wdt_service();
+        }
+
+        return len;
+}
+
+static long gef_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int timeout;
+        int options;
+        void __user *argp = (void __user *)arg;
+        static struct watchdog_info info = {
+                .options =      WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE |
+                                WDIOF_KEEPALIVEPING,
+                .firmware_version = 0,
+                .identity = "GE Fanuc watchdog",
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user(argp, &info, sizeof(info)))
+                        return -EFAULT;
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                if (put_user(wdt_status, (int __user *)argp))
+                        return -EFAULT;
+                wdt_status &= ~WDIOF_KEEPALIVEPING;
+                break;
+
+        case WDIOC_SETOPTIONS:
+                if (get_user(options, (int __user *)argp))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD)
+                        gef_wdt_handler_disable();
+
+                if (options & WDIOS_ENABLECARD)
+                        gef_wdt_handler_enable();
+                break;
+
+        case WDIOC_KEEPALIVE:
+                gef_wdt_service();
+                wdt_status |= WDIOF_KEEPALIVEPING;
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(timeout, (int __user *)argp))
+                        return -EFAULT;
+                gef_wdt_set_timeout(timeout);
+                /* Fall through */
+
+        case WDIOC_GETTIMEOUT:
+                if (put_user(gef_wdt_timeout, (int __user *)argp))
+                        return -EFAULT;
+                break;
+
+        default:
+                return -ENOTTY;
+        }
+
+        return 0;
+}
+
+static int gef_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(GEF_WDOG_FLAG_OPENED, &wdt_flags))
+                return -EBUSY;
+
+        if (nowayout)
+                __module_get(THIS_MODULE);
+
+        gef_wdt_handler_enable();
+
+        return nonseekable_open(inode, file);
+}
+
+static int gef_wdt_release(struct inode *inode, struct file *file)
+{
+        if (expect_close == 42)
+                gef_wdt_handler_disable();
+        else {
+                printk(KERN_CRIT
+                       "gef_wdt: unexpected close, not stopping timer!\n");
+                gef_wdt_service();
+        }
+        expect_close = 0;
+
+        clear_bit(GEF_WDOG_FLAG_OPENED, &wdt_flags);
+
+        return 0;
+}
+
+static const struct file_operations gef_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = gef_wdt_write,
+        .unlocked_ioctl = gef_wdt_ioctl,
+        .open = gef_wdt_open,
+        .release = gef_wdt_release,
+};
+
+static struct miscdevice gef_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &gef_wdt_fops,
+};
+
+
+static int __devinit gef_wdt_probe(struct of_device *dev,
+        const struct of_device_id *match)
+{
+        int timeout = 10;
+        u32 freq;
+
+        bus_clk = 133; /* in MHz */
+
+        freq = fsl_get_sys_freq();
+        if (freq > 0)
+                bus_clk = freq;
+
+        /* Map devices registers into memory */
+        gef_wdt_regs = of_iomap(dev->node, 0);
+        if (gef_wdt_regs == NULL)
+                return -ENOMEM;
+
+        gef_wdt_set_timeout(timeout);
+
+        gef_wdt_handler_disable();      /* in case timer was already running */
+
+        return misc_register(&gef_wdt_miscdev);
+}
+
+static int __devexit gef_wdt_remove(struct platform_device *dev)
+{
+        misc_deregister(&gef_wdt_miscdev);
+
+        gef_wdt_handler_disable();
+
+        iounmap(gef_wdt_regs);
+
+        return 0;
+}
+
+static const struct of_device_id gef_wdt_ids[] = {
+        {
+                .compatible = "gef,fpga-wdt",
+        },
+        {},
+};
+
+static struct of_platform_driver gef_wdt_driver = {
+        .owner          = THIS_MODULE,
+        .name           = "gef_wdt",
+        .match_table    = gef_wdt_ids,
+        .probe          = gef_wdt_probe,
+};
+
+static int __init gef_wdt_init(void)
+{
+        printk(KERN_INFO "GE Fanuc watchdog driver\n");
+        return of_register_platform_driver(&gef_wdt_driver);
+}
+
+static void __exit gef_wdt_exit(void)
+{
+        of_unregister_platform_driver(&gef_wdt_driver);
+}
+
+module_init(gef_wdt_init);
+module_exit(gef_wdt_exit);
+
+MODULE_AUTHOR("Martyn Welch <martyn.welch@gefanuc.com>");
+MODULE_DESCRIPTION("GE Fanuc watchdog driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+MODULE_ALIAS("platform: gef_wdt");
diff --git a/drivers/watchdog/pika_wdt.c b/drivers/watchdog/pika_wdt.c
new file mode 100644
index 00000000000..2d22e996e99
--- /dev/null
+++ b/drivers/watchdog/pika_wdt.c
@@ -0,0 +1,301 @@
+/*
+ * PIKA FPGA based Watchdog Timer
+ *
+ * Copyright (c) 2008 PIKA Technologies
+ *   Sean MacLennan <smaclennan@pikatech.com>
+ */
+
+#include <linux/init.h>
+#include <linux/errno.h>
+#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/watchdog.h>
+#include <linux/reboot.h>
+#include <linux/jiffies.h>
+#include <linux/timer.h>
+#include <linux/bitops.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/of_platform.h>
+
+#define DRV_NAME "PIKA-WDT"
+#define PFX DRV_NAME ": "
+
+/* Hardware timeout in seconds */
+#define WDT_HW_TIMEOUT 2
+
+/* Timer heartbeat (500ms) */
+#define WDT_TIMEOUT     (HZ/2)
+
+/* User land timeout */
+#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) ")");
+
+static struct {
+        void __iomem *fpga;
+        unsigned long next_heartbeat;   /* the next_heartbeat for the timer */
+        unsigned long open;
+        char expect_close;
+        int bootstatus;
+        struct timer_list timer;        /* The timer that pings the watchdog */
+} pikawdt_private;
+
+static struct watchdog_info ident = {
+        .identity       = DRV_NAME,
+        .options        = WDIOF_CARDRESET |
+                          WDIOF_SETTIMEOUT |
+                          WDIOF_KEEPALIVEPING |
+                          WDIOF_MAGICCLOSE,
+};
+
+/*
+ * Reload the watchdog timer.  (ie, pat the watchdog)
+ */
+static inline void pikawdt_reset(void)
+{
+        /* -- FPGA: Reset Control Register (32bit R/W) (Offset: 0x14) --
+         * Bit 7,    WTCHDG_EN: When set to 1, the watchdog timer is enabled.
+         *           Once enabled, it cannot be disabled. The watchdog can be
+         *           kicked by performing any write access to the reset
+         *           control register (this register).
+         * Bit 8-11, WTCHDG_TIMEOUT_SEC: Sets the watchdog timeout value in
+         *           seconds. Valid ranges are 1 to 15 seconds. The value can
+         *           be modified dynamically.
+         */
+        unsigned reset = in_be32(pikawdt_private.fpga + 0x14);
+        /* enable with max timeout - 15 seconds */
+        reset |= (1 << 7) + (WDT_HW_TIMEOUT << 8);
+        out_be32(pikawdt_private.fpga + 0x14, reset);
+}
+
+/*
+ * Timer tick
+ */
+static void pikawdt_ping(unsigned long data)
+{
+        if (time_before(jiffies, pikawdt_private.next_heartbeat) ||
+                        (!nowayout && !pikawdt_private.open)) {
+                pikawdt_reset();
+                mod_timer(&pikawdt_private.timer, jiffies + WDT_TIMEOUT);
+        } else
+                printk(KERN_CRIT PFX "I will reset your machine !\n");
+}
+
+
+static void pikawdt_keepalive(void)
+{
+        pikawdt_private.next_heartbeat = jiffies + heartbeat * HZ;
+}
+
+static void pikawdt_start(void)
+{
+        pikawdt_keepalive();
+        mod_timer(&pikawdt_private.timer, jiffies + WDT_TIMEOUT);
+}
+
+/*
+ * Watchdog device is opened, and watchdog starts running.
+ */
+static int pikawdt_open(struct inode *inode, struct file *file)
+{
+        /* /dev/watchdog can only be opened once */
+        if (test_and_set_bit(0, &pikawdt_private.open))
+                return -EBUSY;
+
+        pikawdt_start();
+
+        return nonseekable_open(inode, file);
+}
+
+/*
+ * Close the watchdog device.
+ */
+static int pikawdt_release(struct inode *inode, struct file *file)
+{
+        /* stop internal ping */
+        if (!pikawdt_private.expect_close)
+                del_timer(&pikawdt_private.timer);
+
+        clear_bit(0, &pikawdt_private.open);
+        pikawdt_private.expect_close = 0;
+        return 0;
+}
+
+/*
+ * Pat the watchdog whenever device is written to.
+ */
+static ssize_t pikawdt_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;
+
+                pikawdt_private.expect_close = 0;
+
+                for (i = 0; i < len; i++) {
+                        char c;
+                        if (get_user(c, data + i))
+                                return -EFAULT;
+                        if (c == 'V') {
+                                pikawdt_private.expect_close = 42;
+                                break;
+                        }
+                }
+        }
+
+        pikawdt_keepalive();
+
+        return len;
+}
+
+/*
+ * Handle commands from user-space.
+ */
+static long pikawdt_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, &ident, sizeof(ident)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(pikawdt_private.bootstatus, p);
+
+        case WDIOC_KEEPALIVE:
+                pikawdt_keepalive();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+
+                heartbeat = new_value;
+                pikawdt_keepalive();
+
+                return put_user(new_value, p);  /* return current value */
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(heartbeat, p);
+        }
+        return -ENOTTY;
+}
+
+
+static const struct file_operations pikawdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .open           = pikawdt_open,
+        .release        = pikawdt_release,
+        .write          = pikawdt_write,
+        .unlocked_ioctl = pikawdt_ioctl,
+};
+
+static struct miscdevice pikawdt_miscdev = {
+        .minor  = WATCHDOG_MINOR,
+        .name   = "watchdog",
+        .fops   = &pikawdt_fops,
+};
+
+static int __init pikawdt_init(void)
+{
+        struct device_node *np;
+        void __iomem *fpga;
+        static u32 post1;
+        int ret;
+
+        np = of_find_compatible_node(NULL, NULL, "pika,fpga");
+        if (np == NULL) {
+                printk(KERN_ERR PFX "Unable to find fpga.\n");
+                return -ENOENT;
+        }
+
+        pikawdt_private.fpga = of_iomap(np, 0);
+        of_node_put(np);
+        if (pikawdt_private.fpga == NULL) {
+                printk(KERN_ERR PFX "Unable to map fpga.\n");
+                return -ENOMEM;
+        }
+
+        ident.firmware_version = in_be32(pikawdt_private.fpga + 0x1c) & 0xffff;
+
+        /* POST information is in the sd area. */
+        np = of_find_compatible_node(NULL, NULL, "pika,fpga-sd");
+        if (np == NULL) {
+                printk(KERN_ERR PFX "Unable to find fpga-sd.\n");
+                ret = -ENOENT;
+                goto out;
+        }
+
+        fpga = of_iomap(np, 0);
+        of_node_put(np);
+        if (fpga == NULL) {
+                printk(KERN_ERR PFX "Unable to map fpga-sd.\n");
+                ret = -ENOMEM;
+                goto out;
+        }
+
+        /* -- FPGA: POST Test Results Register 1 (32bit R/W) (Offset: 0x4040) --
+         * Bit 31,   WDOG: Set to 1 when the last reset was caused by a watchdog
+         *           timeout.
+         */
+        post1 = in_be32(fpga + 0x40);
+        if (post1 & 0x80000000)
+                pikawdt_private.bootstatus = WDIOF_CARDRESET;
+
+        iounmap(fpga);
+
+        setup_timer(&pikawdt_private.timer, pikawdt_ping, 0);
+
+        ret = misc_register(&pikawdt_miscdev);
+        if (ret) {
+                printk(KERN_ERR PFX "Unable to register miscdev.\n");
+                goto out;
+        }
+
+        printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
+                                                        heartbeat, nowayout);
+        return 0;
+
+out:
+        iounmap(pikawdt_private.fpga);
+        return ret;
+}
+
+static void __exit pikawdt_exit(void)
+{
+        misc_deregister(&pikawdt_miscdev);
+
+        iounmap(pikawdt_private.fpga);
+}
+
+module_init(pikawdt_init);
+module_exit(pikawdt_exit);
+
+MODULE_AUTHOR("Sean MacLennan <smaclennan@pikatech.com>");
+MODULE_DESCRIPTION("PIKA FPGA based Watchdog Timer");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+
diff --git a/drivers/watchdog/wm8350_wdt.c b/drivers/watchdog/wm8350_wdt.c
index 2bc0d4d4b41..a2d2e8eb228 100644
--- a/drivers/watchdog/wm8350_wdt.c
+++ b/drivers/watchdog/wm8350_wdt.c
@@ -279,7 +279,7 @@ static struct miscdevice wm8350_wdt_miscdev = {
         .fops = &wm8350_wdt_fops,
 };
 
-static int wm8350_wdt_probe(struct platform_device *pdev)
+static int __devinit wm8350_wdt_probe(struct platform_device *pdev)
 {
         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
 
@@ -296,7 +296,7 @@ static int wm8350_wdt_probe(struct platform_device *pdev)
         return misc_register(&wm8350_wdt_miscdev);
 }
 
-static int __exit wm8350_wdt_remove(struct platform_device *pdev)
+static int __devexit wm8350_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&wm8350_wdt_miscdev);
 
@@ -305,7 +305,7 @@ static int __exit wm8350_wdt_remove(struct platform_device *pdev)
 
 static struct platform_driver wm8350_wdt_driver = {
         .probe = wm8350_wdt_probe,
-        .remove = wm8350_wdt_remove,
+        .remove = __devexit_p(wm8350_wdt_remove),
         .driver = {
                 .name = "wm8350-wdt",
         },
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index eb0dfdeaa94..3141e149d59 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -26,6 +26,7 @@
 #include <linux/irq.h>
 #include <linux/module.h>
 #include <linux/string.h>
+#include <linux/bootmem.h>
 
 #include <asm/ptrace.h>
 #include <asm/irq.h>
@@ -75,7 +76,14 @@ enum {
 static int evtchn_to_irq[NR_EVENT_CHANNELS] = {
         [0 ... NR_EVENT_CHANNELS-1] = -1
 };
-static unsigned long cpu_evtchn_mask[NR_CPUS][NR_EVENT_CHANNELS/BITS_PER_LONG];
+struct cpu_evtchn_s {
+        unsigned long bits[NR_EVENT_CHANNELS/BITS_PER_LONG];
+};
+static struct cpu_evtchn_s *cpu_evtchn_mask_p;
+static inline unsigned long *cpu_evtchn_mask(int cpu)
+{
+        return cpu_evtchn_mask_p[cpu].bits;
+}
 static u8 cpu_evtchn[NR_EVENT_CHANNELS];
 
 /* Reference counts for bindings to IRQs. */
@@ -115,7 +123,7 @@ static inline unsigned long active_evtchns(unsigned int cpu,
                                            unsigned int idx)
 {
         return (sh->evtchn_pending[idx] &
-                cpu_evtchn_mask[cpu][idx] &
+                cpu_evtchn_mask(cpu)[idx] &
                 ~sh->evtchn_mask[idx]);
 }
 
@@ -125,11 +133,11 @@ static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
 
         BUG_ON(irq == -1);
 #ifdef CONFIG_SMP
-        irq_to_desc(irq)->affinity = cpumask_of_cpu(cpu);
+        cpumask_copy(irq_to_desc(irq)->affinity, cpumask_of(cpu));
 #endif
 
-        __clear_bit(chn, cpu_evtchn_mask[cpu_evtchn[chn]]);
-        __set_bit(chn, cpu_evtchn_mask[cpu]);
+        __clear_bit(chn, cpu_evtchn_mask(cpu_evtchn[chn]));
+        __set_bit(chn, cpu_evtchn_mask(cpu));
 
         cpu_evtchn[chn] = cpu;
 }
@@ -142,12 +150,12 @@ static void init_evtchn_cpu_bindings(void)
 
         /* By default all event channels notify CPU#0. */
         for_each_irq_desc(i, desc) {
-                desc->affinity = cpumask_of_cpu(0);
+                cpumask_copy(desc->affinity, cpumask_of(0));
         }
 #endif
 
         memset(cpu_evtchn, 0, sizeof(cpu_evtchn));
-        memset(cpu_evtchn_mask[0], ~0, sizeof(cpu_evtchn_mask[0]));
+        memset(cpu_evtchn_mask(0), ~0, sizeof(cpu_evtchn_mask(0)));
 }
 
 static inline unsigned int cpu_from_evtchn(unsigned int evtchn)
@@ -822,6 +830,10 @@ static struct irq_chip xen_dynamic_chip __read_mostly = {
 void __init xen_init_IRQ(void)
 {
         int i;
+        size_t size = nr_cpu_ids * sizeof(struct cpu_evtchn_s);
+
+        cpu_evtchn_mask_p = alloc_bootmem(size);
+        BUG_ON(cpu_evtchn_mask_p == NULL);
 
         init_evtchn_cpu_bindings();
 
diff --git a/drivers/xen/manage.c b/drivers/xen/manage.c
index 9b91617b958..e7e83b65c18 100644
--- a/drivers/xen/manage.c
+++ b/drivers/xen/manage.c
@@ -100,7 +100,7 @@ static void do_suspend(void)
         /* XXX use normal device tree? */
         xenbus_suspend();
 
-        err = stop_machine(xen_suspend, &cancelled, &cpumask_of_cpu(0));
+        err = stop_machine(xen_suspend, &cancelled, cpumask_of(0));
         if (err) {
                 printk(KERN_ERR "failed to start xen_suspend: %d\n", err);
                 goto out;
diff --git a/drivers/zorro/.gitignore b/drivers/zorro/.gitignore
new file mode 100644
index 00000000000..34f980bd8ff
--- /dev/null
+++ b/drivers/zorro/.gitignore
@@ -0,0 +1,2 @@
+devlist.h
+gen-devlist
diff --git a/drivers/zorro/zorro-sysfs.c b/drivers/zorro/zorro-sysfs.c
index 5290552d2ef..1d2a772ea14 100644
--- a/drivers/zorro/zorro-sysfs.c
+++ b/drivers/zorro/zorro-sysfs.c
@@ -77,17 +77,21 @@ static struct bin_attribute zorro_config_attr = {
         .read = zorro_read_config,
 };
 
-void zorro_create_sysfs_dev_files(struct zorro_dev *z)
+int zorro_create_sysfs_dev_files(struct zorro_dev *z)
 {
         struct device *dev = &z->dev;
+        int error;
 
         /* current configuration's attributes */
-        device_create_file(dev, &dev_attr_id);
-        device_create_file(dev, &dev_attr_type);
-        device_create_file(dev, &dev_attr_serial);
-        device_create_file(dev, &dev_attr_slotaddr);
-        device_create_file(dev, &dev_attr_slotsize);
-        device_create_file(dev, &dev_attr_resource);
-        sysfs_create_bin_file(&dev->kobj, &zorro_config_attr);
+        if ((error = device_create_file(dev, &dev_attr_id)) ||
+            (error = device_create_file(dev, &dev_attr_type)) ||
+            (error = device_create_file(dev, &dev_attr_serial)) ||
+            (error = device_create_file(dev, &dev_attr_slotaddr)) ||
+            (error = device_create_file(dev, &dev_attr_slotsize)) ||
+            (error = device_create_file(dev, &dev_attr_resource)) ||
+            (error = sysfs_create_bin_file(&dev->kobj, &zorro_config_attr)))
+                return error;
+
+        return 0;
 }
 
diff --git a/drivers/zorro/zorro.c b/drivers/zorro/zorro.c
index dff16d9767d..a1585d6f648 100644
--- a/drivers/zorro/zorro.c
+++ b/drivers/zorro/zorro.c
@@ -130,6 +130,7 @@ static int __init zorro_init(void)
 {
     struct zorro_dev *z;
     unsigned int i;
+    int error;
 
     if (!MACH_IS_AMIGA || !AMIGAHW_PRESENT(ZORRO))
         return 0;
@@ -140,7 +141,11 @@ static int __init zorro_init(void)
     /* Initialize the Zorro bus */
     INIT_LIST_HEAD(&zorro_bus.devices);
     strcpy(zorro_bus.dev.bus_id, "zorro");
-    device_register(&zorro_bus.dev);
+    error = device_register(&zorro_bus.dev);
+    if (error) {
+        pr_err("Zorro: Error registering zorro_bus\n");
+        return error;
+    }
 
     /* Request the resources */
     zorro_bus.num_resources = AMIGAHW_PRESENT(ZORRO3) ? 4 : 2;
@@ -160,15 +165,19 @@ static int __init zorro_init(void)
         zorro_name_device(z);
         z->resource.name = z->name;
         if (request_resource(zorro_find_parent_resource(z), &z->resource))
-            printk(KERN_ERR "Zorro: Address space collision on device %s "
-                   "[%lx:%lx]\n",
-                   z->name, (unsigned long)zorro_resource_start(z),
-                   (unsigned long)zorro_resource_end(z));
+            pr_err("Zorro: Address space collision on device %s %pR\n",
+                   z->name, &z->resource);
         sprintf(z->dev.bus_id, "%02x", i);
         z->dev.parent = &zorro_bus.dev;
         z->dev.bus = &zorro_bus_type;
-        device_register(&z->dev);
-        zorro_create_sysfs_dev_files(z);
+        error = device_register(&z->dev);
+        if (error) {
+            pr_err("Zorro: Error registering device %s\n", z->name);
+            continue;
+        }
+        error = zorro_create_sysfs_dev_files(z);
+        if (error)
+            dev_err(&z->dev, "Error creating sysfs files\n");
     }
 
     /* Mark all available Zorro II memory */
diff --git a/drivers/zorro/zorro.h b/drivers/zorro/zorro.h
index 5c91adac4df..b682d5ccd63 100644
--- a/drivers/zorro/zorro.h
+++ b/drivers/zorro/zorro.h
@@ -1,4 +1,4 @@
 
 extern void zorro_name_device(struct zorro_dev *z);
-extern void zorro_create_sysfs_dev_files(struct zorro_dev *z);
+extern int zorro_create_sysfs_dev_files(struct zorro_dev *z);