Merge branch 'master'

282 files changed, 8086 insertions, 4451 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index 619dd964c51c..5c69b86db624 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -69,7 +69,7 @@ obj-$(CONFIG_EISA)		+= eisa/
 obj-$(CONFIG_CPU_FREQ)          += cpufreq/
 obj-$(CONFIG_MMC)               += mmc/
 obj-$(CONFIG_INFINIBAND)        += infiniband/
-obj-$(CONFIG_SGI_IOC4)          += sn/
+obj-$(CONFIG_SGI_SN)            += sn/
 obj-y                           += firmware/
 obj-$(CONFIG_CRYPTO)            += crypto/
 obj-$(CONFIG_SUPERH)            += sh/
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index be2dae52f6fa..eb730a80952c 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -94,7 +94,9 @@ static int set_max_cstate(struct dmi_system_id *id)
         return 0;
 }
 
-static struct dmi_system_id __initdata processor_power_dmi_table[] = {
+/* Actually this shouldn't be __cpuinitdata, would be better to fix the
+   callers to only run once -AK */
+static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
         { set_max_cstate, "IBM ThinkPad R40e", {
           DMI_MATCH(DMI_BIOS_VENDOR,"IBM"),
           DMI_MATCH(DMI_BIOS_VERSION,"1SET60WW")}, (void *)1},
@@ -899,7 +901,7 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
                 case ACPI_STATE_C3:
                         acpi_processor_power_verify_c3(pr, cx);
 #ifdef ARCH_APICTIMER_STOPS_ON_C3
-                        if (c->x86_vendor == X86_VENDOR_INTEL) {
+                        if (cx->valid && c->x86_vendor == X86_VENDOR_INTEL) {
                                 on_each_cpu(switch_APIC_timer_to_ipi,
                                                 &mask, 1, 1);
                         }
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index f12898d53078..e99471d3232b 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -8,6 +8,7 @@ obj-y			+= power/
 obj-$(CONFIG_FW_LOADER) += firmware_class.o
 obj-$(CONFIG_NUMA)      += node.o
 obj-$(CONFIG_MEMORY_HOTPLUG) += memory.o
+obj-$(CONFIG_SMP)       += topology.o
 
 ifeq ($(CONFIG_DEBUG_DRIVER),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/base/base.h b/drivers/base/base.h
index e3b548d46cff..5735b38582d0 100644
--- a/drivers/base/base.h
+++ b/drivers/base/base.h
@@ -19,6 +19,10 @@ extern void bus_remove_driver(struct device_driver *);
 extern void driver_detach(struct device_driver * drv);
 extern int driver_probe_device(struct device_driver *, struct device *);
 
+extern void sysdev_shutdown(void);
+extern int sysdev_suspend(pm_message_t state);
+extern int sysdev_resume(void);
+
 static inline struct class_device *to_class_dev(struct kobject *obj)
 {
         return container_of(obj, struct class_device, kobj);
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index 29f6af554e71..c3141565d59d 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -133,6 +133,8 @@ static struct kobj_type ktype_bus = {
 decl_subsys(bus, &ktype_bus, NULL);
 
 
+#ifdef CONFIG_HOTPLUG
+
 /* Manually detach a device from its associated driver. */
 static int driver_helper(struct device *dev, void *data)
 {
@@ -193,6 +195,7 @@ static ssize_t driver_bind(struct device_driver *drv,
 }
 static DRIVER_ATTR(bind, S_IWUSR, NULL, driver_bind);
 
+#endif
 
 static struct device * next_device(struct klist_iter * i)
 {
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index d1a05224627e..105a0d61eb1f 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -303,7 +303,7 @@ static int block_size_init(void)
  */
 #ifdef CONFIG_ARCH_MEMORY_PROBE
 static ssize_t
-memory_probe_store(struct class *class, const char __user *buf, size_t count)
+memory_probe_store(struct class *class, const char *buf, size_t count)
 {
         u64 phys_addr;
         int ret;
diff --git a/drivers/base/power/resume.c b/drivers/base/power/resume.c
index 0a7aa07b9a2a..317edbf0feca 100644
--- a/drivers/base/power/resume.c
+++ b/drivers/base/power/resume.c
@@ -9,10 +9,9 @@
  */
 
 #include <linux/device.h>
+#include "../base.h"
 #include "power.h"
 
-extern int sysdev_resume(void);
-
 
 /**
  *      resume_device - Restore state for one device.
diff --git a/drivers/base/power/shutdown.c b/drivers/base/power/shutdown.c
index c2475f3134ea..8826a5b6673e 100644
--- a/drivers/base/power/shutdown.c
+++ b/drivers/base/power/shutdown.c
@@ -12,6 +12,7 @@
 #include <linux/device.h>
 #include <asm/semaphore.h>
 
+#include "../base.h"
 #include "power.h"
 
 #define to_dev(node) container_of(node, struct device, kobj.entry)
@@ -28,7 +29,6 @@ extern struct subsystem devices_subsys;
  * they only get one called once when interrupts are disabled.
  */
 
-extern int sysdev_shutdown(void);
 
 /**
  * device_shutdown - call ->shutdown() on each device to shutdown.
diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
index 50501764d050..8660779fb288 100644
--- a/drivers/base/power/suspend.c
+++ b/drivers/base/power/suspend.c
@@ -9,10 +9,9 @@
  */
 
 #include <linux/device.h>
+#include "../base.h"
 #include "power.h"
 
-extern int sysdev_suspend(pm_message_t state);
-
 /*
  * The entries in the dpm_active list are in a depth first order, simply
  * because children are guaranteed to be discovered after parents, and
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index f3a0c562bcb5..40d7242a07c1 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -27,22 +27,30 @@
 
 static ssize_t state_show(struct device * dev, struct device_attribute *attr, char * buf)
 {
-        return sprintf(buf, "%u\n", dev->power.power_state.event);
+        if (dev->power.power_state.event)
+                return sprintf(buf, "2\n");
+        else
+                return sprintf(buf, "0\n");
 }
 
 static ssize_t state_store(struct device * dev, struct device_attribute *attr, const char * buf, size_t n)
 {
         pm_message_t state;
-        char * rest;
-        int error = 0;
+        int error = -EINVAL;
 
-        state.event = simple_strtoul(buf, &rest, 10);
-        if (*rest)
-                return -EINVAL;
-        if (state.event)
+        state.event = PM_EVENT_SUSPEND;
+        /* Older apps expected to write "3" here - confused with PCI D3 */
+        if ((n == 1) && !strcmp(buf, "3"))
                 error = dpm_runtime_suspend(dev, state);
-        else
+
+        if ((n == 1) && !strcmp(buf, "2"))
+                error = dpm_runtime_suspend(dev, state);
+
+        if ((n == 1) && !strcmp(buf, "0")) {
                 dpm_runtime_resume(dev);
+                error = 0;
+        }
+
         return error ? error : n;
 }
 
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 66ed8f2fece5..6fc23ab127bd 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -21,8 +21,11 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/pm.h>
+#include <linux/device.h>
 #include <asm/semaphore.h>
 
+#include "base.h"
+
 extern struct subsystem devices_subsys;
 
 #define to_sysdev(k) container_of(k, struct sys_device, kobj)
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
new file mode 100644
index 000000000000..915810f6237e
--- /dev/null
+++ b/drivers/base/topology.c
@@ -0,0 +1,148 @@
+/*
+ * driver/base/topology.c - Populate sysfs with cpu topology information
+ *
+ * Written by: Zhang Yanmin, Intel Corporation
+ *
+ * Copyright (C) 2006, Intel Corp.
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ * NON INFRINGEMENT.  See the GNU General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+#include <linux/sysdev.h>
+#include <linux/init.h>
+#include <linux/mm.h>
+#include <linux/cpu.h>
+#include <linux/module.h>
+#include <linux/topology.h>
+
+#define define_one_ro(_name)            \
+static SYSDEV_ATTR(_name, 0444, show_##_name, NULL)
+
+#define define_id_show_func(name)                               \
+static ssize_t show_##name(struct sys_device *dev, char *buf)   \
+{                                                               \
+        unsigned int cpu = dev->id;                             \
+        return sprintf(buf, "%d\n", topology_##name(cpu));      \
+}
+
+#define define_siblings_show_func(name)                                 \
+static ssize_t show_##name(struct sys_device *dev, char *buf)           \
+{                                                                       \
+        ssize_t len = -1;                                               \
+        unsigned int cpu = dev->id;                                     \
+        len = cpumask_scnprintf(buf, NR_CPUS+1, topology_##name(cpu));  \
+        return (len + sprintf(buf + len, "\n"));                        \
+}
+
+#ifdef  topology_physical_package_id
+define_id_show_func(physical_package_id);
+define_one_ro(physical_package_id);
+#define ref_physical_package_id_attr    &attr_physical_package_id.attr,
+#else
+#define ref_physical_package_id_attr
+#endif
+
+#ifdef topology_core_id
+define_id_show_func(core_id);
+define_one_ro(core_id);
+#define ref_core_id_attr                &attr_core_id.attr,
+#else
+#define ref_core_id_attr
+#endif
+
+#ifdef topology_thread_siblings
+define_siblings_show_func(thread_siblings);
+define_one_ro(thread_siblings);
+#define ref_thread_siblings_attr        &attr_thread_siblings.attr,
+#else
+#define ref_thread_siblings_attr
+#endif
+
+#ifdef topology_core_siblings
+define_siblings_show_func(core_siblings);
+define_one_ro(core_siblings);
+#define ref_core_siblings_attr          &attr_core_siblings.attr,
+#else
+#define ref_core_siblings_attr
+#endif
+
+static struct attribute *default_attrs[] = {
+        ref_physical_package_id_attr
+        ref_core_id_attr
+        ref_thread_siblings_attr
+        ref_core_siblings_attr
+        NULL
+};
+
+static struct attribute_group topology_attr_group = {
+        .attrs = default_attrs,
+        .name = "topology"
+};
+
+/* Add/Remove cpu_topology interface for CPU device */
+static int __cpuinit topology_add_dev(struct sys_device * sys_dev)
+{
+        sysfs_create_group(&sys_dev->kobj, &topology_attr_group);
+        return 0;
+}
+
+static int __cpuinit topology_remove_dev(struct sys_device * sys_dev)
+{
+        sysfs_remove_group(&sys_dev->kobj, &topology_attr_group);
+        return 0;
+}
+
+static int __cpuinit topology_cpu_callback(struct notifier_block *nfb,
+                unsigned long action, void *hcpu)
+{
+        unsigned int cpu = (unsigned long)hcpu;
+        struct sys_device *sys_dev;
+
+        sys_dev = get_cpu_sysdev(cpu);
+        switch (action) {
+        case CPU_ONLINE:
+                topology_add_dev(sys_dev);
+                break;
+        case CPU_DEAD:
+                topology_remove_dev(sys_dev);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+static struct notifier_block topology_cpu_notifier =
+{
+        .notifier_call = topology_cpu_callback,
+};
+
+static int __cpuinit topology_sysfs_init(void)
+{
+        int i;
+
+        for_each_online_cpu(i) {
+                topology_cpu_callback(&topology_cpu_notifier, CPU_ONLINE,
+                                (void *)(long)i);
+        }
+
+        register_cpu_notifier(&topology_cpu_notifier);
+
+        return 0;
+}
+
+device_initcall(topology_sysfs_init);
+
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 139cbba76180..8b1331677407 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -433,12 +433,12 @@ config CDROM_PKTCDVD_BUFFERS
           This controls the maximum number of active concurrent packets. More
           concurrent packets can increase write performance, but also require
           more memory. Each concurrent packet will require approximately 64Kb
-          of non-swappable kernel memory, memory which will be allocated at
-          pktsetup time.
+          of non-swappable kernel memory, memory which will be allocated when
+          a disc is opened for writing.
 
 config CDROM_PKTCDVD_WCACHE
-        bool "Enable write caching"
-        depends on CDROM_PKTCDVD
+        bool "Enable write caching (EXPERIMENTAL)"
+        depends on CDROM_PKTCDVD && EXPERIMENTAL
         help
           If enabled, write caching will be set for the CD-R/W device. For now
           this option is dangerous unless the CD-RW media is known good, as we
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index 12d7b9bdfa93..0d65394707db 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -2183,6 +2183,7 @@ static void cciss_softirq_done(struct request *rq)
 {
         CommandList_struct *cmd = rq->completion_data;
         ctlr_info_t *h = hba[cmd->ctlr];
+        unsigned long flags;
         u64bit temp64;
         int i, ddir;
 
@@ -2205,10 +2206,10 @@ static void cciss_softirq_done(struct request *rq)
         printk("Done with %p\n", rq);
 #endif /* CCISS_DEBUG */ 
 
-        spin_lock_irq(&h->lock);
+        spin_lock_irqsave(&h->lock, flags);
         end_that_request_last(rq, rq->errors);
         cmd_free(h, cmd,1);
-        spin_unlock_irq(&h->lock);
+        spin_unlock_irqrestore(&h->lock, flags);
 }
 
 /* checks the status of the job and calls complete buffers to mark all 
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 93affeeef7bd..4e7dbcc425ff 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -43,8 +43,6 @@
  *
  *************************************************************************/
 
-#define VERSION_CODE    "v0.2.0a 2004-07-14 Jens Axboe (axboe@suse.de) and petero2@telia.com"
-
 #include <linux/pktcdvd.h>
 #include <linux/config.h>
 #include <linux/module.h>
@@ -131,7 +129,7 @@ static struct bio *pkt_bio_alloc(int nr_iovecs)
 /*
  * Allocate a packet_data struct
  */
-static struct packet_data *pkt_alloc_packet_data(void)
+static struct packet_data *pkt_alloc_packet_data(int frames)
 {
         int i;
         struct packet_data *pkt;
@@ -140,11 +138,12 @@ static struct packet_data *pkt_alloc_packet_data(void)
         if (!pkt)
                 goto no_pkt;
 
-        pkt->w_bio = pkt_bio_alloc(PACKET_MAX_SIZE);
+        pkt->frames = frames;
+        pkt->w_bio = pkt_bio_alloc(frames);
         if (!pkt->w_bio)
                 goto no_bio;
 
-        for (i = 0; i < PAGES_PER_PACKET; i++) {
+        for (i = 0; i < frames / FRAMES_PER_PAGE; i++) {
                 pkt->pages[i] = alloc_page(GFP_KERNEL|__GFP_ZERO);
                 if (!pkt->pages[i])
                         goto no_page;
@@ -152,7 +151,7 @@ static struct packet_data *pkt_alloc_packet_data(void)
 
         spin_lock_init(&pkt->lock);
 
-        for (i = 0; i < PACKET_MAX_SIZE; i++) {
+        for (i = 0; i < frames; i++) {
                 struct bio *bio = pkt_bio_alloc(1);
                 if (!bio)
                         goto no_rd_bio;
@@ -162,14 +161,14 @@ static struct packet_data *pkt_alloc_packet_data(void)
         return pkt;
 
 no_rd_bio:
-        for (i = 0; i < PACKET_MAX_SIZE; i++) {
+        for (i = 0; i < frames; i++) {
                 struct bio *bio = pkt->r_bios[i];
                 if (bio)
                         bio_put(bio);
         }
 
 no_page:
-        for (i = 0; i < PAGES_PER_PACKET; i++)
+        for (i = 0; i < frames / FRAMES_PER_PAGE; i++)
                 if (pkt->pages[i])
                         __free_page(pkt->pages[i]);
         bio_put(pkt->w_bio);
@@ -186,12 +185,12 @@ static void pkt_free_packet_data(struct packet_data *pkt)
 {
         int i;
 
-        for (i = 0; i < PACKET_MAX_SIZE; i++) {
+        for (i = 0; i < pkt->frames; i++) {
                 struct bio *bio = pkt->r_bios[i];
                 if (bio)
                         bio_put(bio);
         }
-        for (i = 0; i < PAGES_PER_PACKET; i++)
+        for (i = 0; i < pkt->frames / FRAMES_PER_PAGE; i++)
                 __free_page(pkt->pages[i]);
         bio_put(pkt->w_bio);
         kfree(pkt);
@@ -206,17 +205,17 @@ static void pkt_shrink_pktlist(struct pktcdvd_device *pd)
         list_for_each_entry_safe(pkt, next, &pd->cdrw.pkt_free_list, list) {
                 pkt_free_packet_data(pkt);
         }
+        INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
 }
 
 static int pkt_grow_pktlist(struct pktcdvd_device *pd, int nr_packets)
 {
         struct packet_data *pkt;
 
-        INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
-        INIT_LIST_HEAD(&pd->cdrw.pkt_active_list);
-        spin_lock_init(&pd->cdrw.active_list_lock);
+        BUG_ON(!list_empty(&pd->cdrw.pkt_free_list));
+
         while (nr_packets > 0) {
-                pkt = pkt_alloc_packet_data();
+                pkt = pkt_alloc_packet_data(pd->settings.size >> 2);
                 if (!pkt) {
                         pkt_shrink_pktlist(pd);
                         return 0;
@@ -951,7 +950,7 @@ try_next_bio:
 
         pd->current_sector = zone + pd->settings.size;
         pkt->sector = zone;
-        pkt->frames = pd->settings.size >> 2;
+        BUG_ON(pkt->frames != pd->settings.size >> 2);
         pkt->write_size = 0;
 
         /*
@@ -1639,7 +1638,7 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
         pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2;
         if (pd->settings.size == 0) {
                 printk("pktcdvd: detected zero packet size!\n");
-                pd->settings.size = 128;
+                return -ENXIO;
         }
         if (pd->settings.size > PACKET_MAX_SECTORS) {
                 printk("pktcdvd: packet size is too big\n");
@@ -1987,8 +1986,14 @@ static int pkt_open_dev(struct pktcdvd_device *pd, int write)
         if ((ret = pkt_set_segment_merging(pd, q)))
                 goto out_unclaim;
 
-        if (write)
+        if (write) {
+                if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) {
+                        printk("pktcdvd: not enough memory for buffers\n");
+                        ret = -ENOMEM;
+                        goto out_unclaim;
+                }
                 printk("pktcdvd: %lukB available on disc\n", lba << 1);
+        }
 
         return 0;
 
@@ -2014,6 +2019,8 @@ static void pkt_release_dev(struct pktcdvd_device *pd, int flush)
         pkt_set_speed(pd, MAX_SPEED, MAX_SPEED);
         bd_release(pd->bdev);
         blkdev_put(pd->bdev);
+
+        pkt_shrink_pktlist(pd);
 }
 
 static struct pktcdvd_device *pkt_find_dev_from_minor(int dev_minor)
@@ -2379,12 +2386,6 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
         /* This is safe, since we have a reference from open(). */
         __module_get(THIS_MODULE);
 
-        if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) {
-                printk("pktcdvd: not enough memory for buffers\n");
-                ret = -ENOMEM;
-                goto out_mem;
-        }
-
         pd->bdev = bdev;
         set_blocksize(bdev, CD_FRAMESIZE);
 
@@ -2395,7 +2396,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
         if (IS_ERR(pd->cdrw.thread)) {
                 printk("pktcdvd: can't start kernel thread\n");
                 ret = -ENOMEM;
-                goto out_thread;
+                goto out_mem;
         }
 
         proc = create_proc_entry(pd->name, 0, pkt_proc);
@@ -2406,8 +2407,6 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
         DPRINTK("pktcdvd: writer %s mapped to %s\n", pd->name, bdevname(bdev, b));
         return 0;
 
-out_thread:
-        pkt_shrink_pktlist(pd);
 out_mem:
         blkdev_put(bdev);
         /* This is safe: open() is still holding a reference. */
@@ -2503,6 +2502,10 @@ static int pkt_setup_dev(struct pkt_ctrl_command *ctrl_cmd)
                 goto out_mem;
         pd->disk = disk;
 
+        INIT_LIST_HEAD(&pd->cdrw.pkt_free_list);
+        INIT_LIST_HEAD(&pd->cdrw.pkt_active_list);
+        spin_lock_init(&pd->cdrw.active_list_lock);
+
         spin_lock_init(&pd->lock);
         spin_lock_init(&pd->iosched.lock);
         sprintf(pd->name, "pktcdvd%d", idx);
@@ -2567,8 +2570,6 @@ static int pkt_remove_dev(struct pkt_ctrl_command *ctrl_cmd)
 
         blkdev_put(pd->bdev);
 
-        pkt_shrink_pktlist(pd);
-
         remove_proc_entry(pd->name, pkt_proc);
         DPRINTK("pktcdvd: writer %s unmapped\n", pd->name);
 
@@ -2678,7 +2679,6 @@ static int __init pkt_init(void)
 
         pkt_proc = proc_mkdir("pktcdvd", proc_root_driver);
 
-        DPRINTK("pktcdvd: %s\n", VERSION_CODE);
         return 0;
 
 out:
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index a3614e6a68d0..4ada1268b40d 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -882,7 +882,7 @@ static int __devinit mm_pci_probe(struct pci_dev *dev, const struct pci_device_i
                card->card_number, dev->bus->number, dev->devfn);
 
         if (pci_set_dma_mask(dev, 0xffffffffffffffffLL) &&
-            !pci_set_dma_mask(dev, 0xffffffffLL)) {
+            pci_set_dma_mask(dev, 0xffffffffLL)) {
                 printk(KERN_WARNING "MM%d: NO suitable DMA found\n",num_cards);
                 return  -ENOMEM;
         }
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index 193446e6a08a..e27617259552 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -42,8 +42,6 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 
-#include <asm/bug.h>
-
 #include <asm/vio.h>
 #include <asm/scatterlist.h>
 #include <asm/iseries/hv_types.h>
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 4c67727d75b1..05ba410682a3 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -222,7 +222,7 @@ config SYNCLINKMP
 
 config SYNCLINK_GT
         tristate "SyncLink GT/AC support"
-        depends on SERIAL_NONSTANDARD
+        depends on SERIAL_NONSTANDARD && PCI
         help
           Support for SyncLink GT and SyncLink AC families of
           synchronous and asynchronous serial adapters
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index 39c61a71176e..cc7acf877dc0 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -1233,7 +1233,7 @@ cyy_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                             }
                              info->idle_stats.recv_idle = jiffies;
                         }
-                        schedule_delayed_work(&tty->buf.work, 1);
+                        tty_schedule_flip(tty);
                     }
                     /* end of service */
                     cy_writeb(base_addr+(CyRIR<<index), (save_xir & 0x3f));
@@ -1606,7 +1606,7 @@ cyz_handle_rx(struct cyclades_port *info,
             }
 #endif
             info->idle_stats.recv_idle = jiffies;
-            schedule_delayed_work(&tty->buf.work, 1);
+            tty_schedule_flip(tty);
         }
         /* Update rx_get */
         cy_writel(&buf_ctrl->rx_get, new_rx_get);
@@ -1809,7 +1809,7 @@ cyz_handle_cmd(struct cyclades_card *cinfo)
         if(delta_count)
             cy_sched_event(info, Cy_EVENT_DELTA_WAKEUP);
         if(special_count)
-            schedule_delayed_work(&tty->buf.work, 1);
+            tty_schedule_flip(tty);
     }
 }
 
diff --git a/drivers/char/drm/ati_pcigart.c b/drivers/char/drm/ati_pcigart.c
index 5485382cadec..bd7be09ea53d 100644
--- a/drivers/char/drm/ati_pcigart.c
+++ b/drivers/char/drm/ati_pcigart.c
@@ -59,17 +59,16 @@ static void *drm_ati_alloc_pcigart_table(void)
         int i;
         DRM_DEBUG("%s\n", __FUNCTION__);
 
-        address = __get_free_pages(GFP_KERNEL, ATI_PCIGART_TABLE_ORDER);
+        address = __get_free_pages(GFP_KERNEL | __GFP_COMP,
+                                   ATI_PCIGART_TABLE_ORDER);
         if (address == 0UL) {
-                return 0;
+                return NULL;
         }
 
         page = virt_to_page(address);
 
-        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++) {
-                get_page(page);
+        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++)
                 SetPageReserved(page);
-        }
 
         DRM_DEBUG("%s: returning 0x%08lx\n", __FUNCTION__, address);
         return (void *)address;
@@ -83,10 +82,8 @@ static void drm_ati_free_pcigart_table(void *address)
 
         page = virt_to_page((unsigned long)address);
 
-        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++) {
-                __put_page(page);
+        for (i = 0; i < ATI_PCIGART_TABLE_PAGES; i++, page++)
                 ClearPageReserved(page);
-        }
 
         free_pages((unsigned long)address, ATI_PCIGART_TABLE_ORDER);
 }
@@ -127,7 +124,7 @@ int drm_ati_pcigart_cleanup(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
         if (gart_info->gart_table_location == DRM_ATI_GART_MAIN
             && gart_info->addr) {
                 drm_ati_free_pcigart_table(gart_info->addr);
-                gart_info->addr = 0;
+                gart_info->addr = NULL;
         }
 
         return 1;
@@ -168,7 +165,7 @@ int drm_ati_pcigart_init(drm_device_t *dev, drm_ati_pcigart_info *gart_info)
                 if (bus_address == 0) {
                         DRM_ERROR("unable to map PCIGART pages!\n");
                         drm_ati_free_pcigart_table(address);
-                        address = 0;
+                        address = NULL;
                         goto done;
                 }
         } else {
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index 54b561e69486..107df9fdba4e 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -57,6 +57,7 @@
 #include <linux/smp_lock.h>     /* For (un)lock_kernel */
 #include <linux/mm.h>
 #include <linux/cdev.h>
+#include <linux/mutex.h>
 #if defined(__alpha__) || defined(__powerpc__)
 #include <asm/pgtable.h>        /* For pte_wrprotect */
 #endif
@@ -623,7 +624,7 @@ typedef struct drm_device {
         /** \name Locks */
         /*@{ */
         spinlock_t count_lock;          /**< For inuse, drm_device::open_count, drm_device::buf_use */
-        struct semaphore struct_sem;    /**< For others */
+        struct mutex struct_mutex;      /**< For others */
         /*@} */
 
         /** \name Usage Counters */
@@ -658,7 +659,7 @@ typedef struct drm_device {
         /*@{ */
         drm_ctx_list_t *ctxlist;        /**< Linked list of context handles */
         int ctx_count;                  /**< Number of context handles */
-        struct semaphore ctxlist_sem;   /**< For ctxlist */
+        struct mutex ctxlist_mutex;     /**< For ctxlist */
 
         drm_map_t **context_sareas;         /**< per-context SAREA's */
         int max_context;
@@ -979,7 +980,7 @@ extern int drm_put_head(drm_head_t * head);
 extern unsigned int drm_debug;
 extern unsigned int drm_cards_limit;
 extern drm_head_t **drm_heads;
-extern struct drm_sysfs_class *drm_class;
+extern struct class *drm_class;
 extern struct proc_dir_entry *drm_proc_root;
 
                                 /* Proc support (drm_proc.h) */
@@ -1010,11 +1011,9 @@ extern void __drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah);
 extern void drm_pci_free(drm_device_t * dev, drm_dma_handle_t * dmah);
 
                                /* sysfs support (drm_sysfs.c) */
-struct drm_sysfs_class;
-extern struct drm_sysfs_class *drm_sysfs_create(struct module *owner,
-                                                char *name);
-extern void drm_sysfs_destroy(struct drm_sysfs_class *cs);
-extern struct class_device *drm_sysfs_device_add(struct drm_sysfs_class *cs,
+extern struct class *drm_sysfs_create(struct module *owner, char *name);
+extern void drm_sysfs_destroy(struct class *cs);
+extern struct class_device *drm_sysfs_device_add(struct class *cs,
                                                  drm_head_t *head);
 extern void drm_sysfs_device_remove(struct class_device *class_dev);
 
diff --git a/drivers/char/drm/drm_auth.c b/drivers/char/drm/drm_auth.c
index a47b502bc7cc..2a37586a7ee8 100644
--- a/drivers/char/drm/drm_auth.c
+++ b/drivers/char/drm/drm_auth.c
@@ -56,7 +56,7 @@ static int drm_hash_magic(drm_magic_t magic)
  * \param magic magic number.
  *
  * Searches in drm_device::magiclist within all files with the same hash key
- * the one with matching magic number, while holding the drm_device::struct_sem
+ * the one with matching magic number, while holding the drm_device::struct_mutex
  * lock.
  */
 static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
@@ -65,14 +65,14 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
         drm_magic_entry_t *pt;
         int hash = drm_hash_magic(magic);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->magiclist[hash].head; pt; pt = pt->next) {
                 if (pt->magic == magic) {
                         retval = pt->priv;
                         break;
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return retval;
 }
 
@@ -85,7 +85,7 @@ static drm_file_t *drm_find_file(drm_device_t * dev, drm_magic_t magic)
  *
  * Creates a drm_magic_entry structure and appends to the linked list
  * associated the magic number hash key in drm_device::magiclist, while holding
- * the drm_device::struct_sem lock.
+ * the drm_device::struct_mutex lock.
  */
 static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
                          drm_magic_t magic)
@@ -104,7 +104,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
         entry->priv = priv;
         entry->next = NULL;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (dev->magiclist[hash].tail) {
                 dev->magiclist[hash].tail->next = entry;
                 dev->magiclist[hash].tail = entry;
@@ -112,7 +112,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
                 dev->magiclist[hash].head = entry;
                 dev->magiclist[hash].tail = entry;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         return 0;
 }
@@ -124,7 +124,7 @@ static int drm_add_magic(drm_device_t * dev, drm_file_t * priv,
  * \param magic magic number.
  *
  * Searches and unlinks the entry in drm_device::magiclist with the magic
- * number hash key, while holding the drm_device::struct_sem lock.
+ * number hash key, while holding the drm_device::struct_mutex lock.
  */
 static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
 {
@@ -135,7 +135,7 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
         DRM_DEBUG("%d\n", magic);
         hash = drm_hash_magic(magic);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->magiclist[hash].head; pt; prev = pt, pt = pt->next) {
                 if (pt->magic == magic) {
                         if (dev->magiclist[hash].head == pt) {
@@ -147,11 +147,11 @@ static int drm_remove_magic(drm_device_t * dev, drm_magic_t magic)
                         if (prev) {
                                 prev->next = pt->next;
                         }
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         return 0;
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
 
diff --git a/drivers/char/drm/drm_bufs.c b/drivers/char/drm/drm_bufs.c
index 1db12dcb6802..e2637b4d51de 100644
--- a/drivers/char/drm/drm_bufs.c
+++ b/drivers/char/drm/drm_bufs.c
@@ -255,14 +255,14 @@ static int drm_addmap_core(drm_device_t * dev, unsigned int offset,
         memset(list, 0, sizeof(*list));
         list->map = map;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         list_add(&list->head, &dev->maplist->head);
         /* Assign a 32-bit handle */
-        /* We do it here so that dev->struct_sem protects the increment */
+        /* We do it here so that dev->struct_mutex protects the increment */
         list->user_token = HandleID(map->type == _DRM_SHM
                                     ? (unsigned long)map->handle
                                     : map->offset, dev);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         *maplist = list;
         return 0;
@@ -392,9 +392,9 @@ int drm_rmmap(drm_device_t *dev, drm_local_map_t *map)
 {
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm_rmmap_locked(dev, map);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         return ret;
 }
@@ -423,7 +423,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
                 return -EFAULT;
         }
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         list_for_each(list, &dev->maplist->head) {
                 drm_map_list_t *r_list = list_entry(list, drm_map_list_t, head);
 
@@ -439,7 +439,7 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
          * find anything.
          */
         if (list == (&dev->maplist->head)) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
@@ -448,13 +448,13 @@ int drm_rmmap_ioctl(struct inode *inode, struct file *filp,
 
         /* Register and framebuffer maps are permanent */
         if ((map->type == _DRM_REGISTERS) || (map->type == _DRM_FRAME_BUFFER)) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return 0;
         }
 
         ret = drm_rmmap_locked(dev, map);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         return ret;
 }
@@ -566,16 +566,16 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -583,7 +583,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -616,7 +616,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
                         drm_cleanup_buf_error(dev, entry);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -638,7 +638,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         if (!temp_buflist) {
                 /* Free the entry because it isn't valid */
                 drm_cleanup_buf_error(dev, entry);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -656,7 +656,7 @@ int drm_addbufs_agp(drm_device_t * dev, drm_buf_desc_t * request)
         DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
         DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
@@ -722,16 +722,16 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -739,7 +739,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -750,7 +750,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         if (!entry->seglist) {
                 drm_free(entry->buflist,
                          count * sizeof(*entry->buflist), DRM_MEM_BUFS);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -766,7 +766,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                          count * sizeof(*entry->buflist), DRM_MEM_BUFS);
                 drm_free(entry->seglist,
                          count * sizeof(*entry->seglist), DRM_MEM_SEGS);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -790,7 +790,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                         drm_free(temp_pagelist,
                                  (dma->page_count + (count << page_order))
                                  * sizeof(*dma->pagelist), DRM_MEM_PAGES);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -831,7 +831,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                                           (count << page_order))
                                          * sizeof(*dma->pagelist),
                                          DRM_MEM_PAGES);
-                                up(&dev->struct_sem);
+                                mutex_unlock(&dev->struct_mutex);
                                 atomic_dec(&dev->buf_alloc);
                                 return -ENOMEM;
                         }
@@ -853,7 +853,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
                 drm_free(temp_pagelist,
                          (dma->page_count + (count << page_order))
                          * sizeof(*dma->pagelist), DRM_MEM_PAGES);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -878,7 +878,7 @@ int drm_addbufs_pci(drm_device_t * dev, drm_buf_desc_t * request)
         dma->page_count += entry->seg_count << page_order;
         dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
@@ -948,16 +948,16 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -965,7 +965,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -999,7 +999,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
                         drm_cleanup_buf_error(dev, entry);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -1022,7 +1022,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         if (!temp_buflist) {
                 /* Free the entry because it isn't valid */
                 drm_cleanup_buf_error(dev, entry);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -1040,7 +1040,7 @@ static int drm_addbufs_sg(drm_device_t * dev, drm_buf_desc_t * request)
         DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
         DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
@@ -1110,16 +1110,16 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         atomic_inc(&dev->buf_alloc);
         spin_unlock(&dev->count_lock);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         entry = &dma->bufs[order];
         if (entry->buf_count) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM; /* May only call once for each order */
         }
 
         if (count < 0 || count > 4096) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -EINVAL;
         }
@@ -1127,7 +1127,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         entry->buflist = drm_alloc(count * sizeof(*entry->buflist),
                                    DRM_MEM_BUFS);
         if (!entry->buflist) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -1160,7 +1160,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
                         /* Set count correctly so we free the proper amount. */
                         entry->buf_count = count;
                         drm_cleanup_buf_error(dev, entry);
-                        up(&dev->struct_sem);
+                        mutex_unlock(&dev->struct_mutex);
                         atomic_dec(&dev->buf_alloc);
                         return -ENOMEM;
                 }
@@ -1182,7 +1182,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         if (!temp_buflist) {
                 /* Free the entry because it isn't valid */
                 drm_cleanup_buf_error(dev, entry);
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 atomic_dec(&dev->buf_alloc);
                 return -ENOMEM;
         }
@@ -1200,7 +1200,7 @@ int drm_addbufs_fb(drm_device_t * dev, drm_buf_desc_t * request)
         DRM_DEBUG("dma->buf_count : %d\n", dma->buf_count);
         DRM_DEBUG("entry->buf_count : %d\n", entry->buf_count);
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request->count = entry->buf_count;
         request->size = size;
diff --git a/drivers/char/drm/drm_context.c b/drivers/char/drm/drm_context.c
index f84254526949..83094c73da67 100644
--- a/drivers/char/drm/drm_context.c
+++ b/drivers/char/drm/drm_context.c
@@ -53,7 +53,7 @@
  * \param ctx_handle context handle.
  *
  * Clears the bit specified by \p ctx_handle in drm_device::ctx_bitmap and the entry
- * in drm_device::context_sareas, while holding the drm_device::struct_sem
+ * in drm_device::context_sareas, while holding the drm_device::struct_mutex
  * lock.
  */
 void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
@@ -64,10 +64,10 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
                 goto failed;
 
         if (ctx_handle < DRM_MAX_CTXBITMAP) {
-                down(&dev->struct_sem);
+                mutex_lock(&dev->struct_mutex);
                 clear_bit(ctx_handle, dev->ctx_bitmap);
                 dev->context_sareas[ctx_handle] = NULL;
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return;
         }
       failed:
@@ -83,7 +83,7 @@ void drm_ctxbitmap_free(drm_device_t * dev, int ctx_handle)
  *
  * Find the first zero bit in drm_device::ctx_bitmap and (re)allocates
  * drm_device::context_sareas to accommodate the new entry while holding the
- * drm_device::struct_sem lock.
+ * drm_device::struct_mutex lock.
  */
 static int drm_ctxbitmap_next(drm_device_t * dev)
 {
@@ -92,7 +92,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
         if (!dev->ctx_bitmap)
                 return -1;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         bit = find_first_zero_bit(dev->ctx_bitmap, DRM_MAX_CTXBITMAP);
         if (bit < DRM_MAX_CTXBITMAP) {
                 set_bit(bit, dev->ctx_bitmap);
@@ -113,7 +113,7 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
                                                          DRM_MEM_MAPS);
                                 if (!ctx_sareas) {
                                         clear_bit(bit, dev->ctx_bitmap);
-                                        up(&dev->struct_sem);
+                                        mutex_unlock(&dev->struct_mutex);
                                         return -1;
                                 }
                                 dev->context_sareas = ctx_sareas;
@@ -126,16 +126,16 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
                                               DRM_MEM_MAPS);
                                 if (!dev->context_sareas) {
                                         clear_bit(bit, dev->ctx_bitmap);
-                                        up(&dev->struct_sem);
+                                        mutex_unlock(&dev->struct_mutex);
                                         return -1;
                                 }
                                 dev->context_sareas[bit] = NULL;
                         }
                 }
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return bit;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return -1;
 }
 
@@ -145,24 +145,24 @@ static int drm_ctxbitmap_next(drm_device_t * dev)
  * \param dev DRM device.
  *
  * Allocates and initialize drm_device::ctx_bitmap and drm_device::context_sareas, while holding
- * the drm_device::struct_sem lock.
+ * the drm_device::struct_mutex lock.
  */
 int drm_ctxbitmap_init(drm_device_t * dev)
 {
         int i;
         int temp;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         dev->ctx_bitmap = (unsigned long *)drm_alloc(PAGE_SIZE,
                                                      DRM_MEM_CTXBITMAP);
         if (dev->ctx_bitmap == NULL) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -ENOMEM;
         }
         memset((void *)dev->ctx_bitmap, 0, PAGE_SIZE);
         dev->context_sareas = NULL;
         dev->max_context = -1;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         for (i = 0; i < DRM_RESERVED_CONTEXTS; i++) {
                 temp = drm_ctxbitmap_next(dev);
@@ -178,17 +178,17 @@ int drm_ctxbitmap_init(drm_device_t * dev)
  * \param dev DRM device.
  *
  * Frees drm_device::ctx_bitmap and drm_device::context_sareas, while holding
- * the drm_device::struct_sem lock.
+ * the drm_device::struct_mutex lock.
  */
 void drm_ctxbitmap_cleanup(drm_device_t * dev)
 {
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (dev->context_sareas)
                 drm_free(dev->context_sareas,
                          sizeof(*dev->context_sareas) *
                          dev->max_context, DRM_MEM_MAPS);
         drm_free((void *)dev->ctx_bitmap, PAGE_SIZE, DRM_MEM_CTXBITMAP);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 /*@}*/
@@ -222,15 +222,15 @@ int drm_getsareactx(struct inode *inode, struct file *filp,
         if (copy_from_user(&request, argp, sizeof(request)))
                 return -EFAULT;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (dev->max_context < 0
             || request.ctx_id >= (unsigned)dev->max_context) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
         map = dev->context_sareas[request.ctx_id];
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         request.handle = NULL;
         list_for_each_entry(_entry, &dev->maplist->head, head) {
@@ -274,7 +274,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
                            (drm_ctx_priv_map_t __user *) arg, sizeof(request)))
                 return -EFAULT;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         list_for_each(list, &dev->maplist->head) {
                 r_list = list_entry(list, drm_map_list_t, head);
                 if (r_list->map
@@ -282,7 +282,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
                         goto found;
         }
       bad:
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return -EINVAL;
 
       found:
@@ -294,7 +294,7 @@ int drm_setsareactx(struct inode *inode, struct file *filp,
         if (request.ctx_id >= (unsigned)dev->max_context)
                 goto bad;
         dev->context_sareas[request.ctx_id] = map;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return 0;
 }
 
@@ -448,10 +448,10 @@ int drm_addctx(struct inode *inode, struct file *filp,
         ctx_entry->handle = ctx.handle;
         ctx_entry->tag = priv;
 
-        down(&dev->ctxlist_sem);
+        mutex_lock(&dev->ctxlist_mutex);
         list_add(&ctx_entry->head, &dev->ctxlist->head);
         ++dev->ctx_count;
-        up(&dev->ctxlist_sem);
+        mutex_unlock(&dev->ctxlist_mutex);
 
         if (copy_to_user(argp, &ctx, sizeof(ctx)))
                 return -EFAULT;
@@ -574,7 +574,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
                 drm_ctxbitmap_free(dev, ctx.handle);
         }
 
-        down(&dev->ctxlist_sem);
+        mutex_lock(&dev->ctxlist_mutex);
         if (!list_empty(&dev->ctxlist->head)) {
                 drm_ctx_list_t *pos, *n;
 
@@ -586,7 +586,7 @@ int drm_rmctx(struct inode *inode, struct file *filp,
                         }
                 }
         }
-        up(&dev->ctxlist_sem);
+        mutex_unlock(&dev->ctxlist_mutex);
 
         return 0;
 }
diff --git a/drivers/char/drm/drm_drv.c b/drivers/char/drm/drm_drv.c
index c4fa5a29582b..dc6bbe8a18dc 100644
--- a/drivers/char/drm/drm_drv.c
+++ b/drivers/char/drm/drm_drv.c
@@ -151,7 +151,7 @@ int drm_lastclose(drm_device_t * dev)
         if (dev->irq_enabled)
                 drm_irq_uninstall(dev);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         del_timer(&dev->timer);
 
         /* Clear pid list */
@@ -231,7 +231,7 @@ int drm_lastclose(drm_device_t * dev)
                 dev->lock.filp = NULL;
                 wake_up_interruptible(&dev->lock.lock_queue);
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         DRM_DEBUG("lastclose completed\n");
         return 0;
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 403f44a1bf01..641f7633878c 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -262,7 +262,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
                         goto out_free;
         }
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (!dev->file_last) {
                 priv->next = NULL;
                 priv->prev = NULL;
@@ -276,7 +276,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
                 dev->file_last->next = priv;
                 dev->file_last = priv;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
 #ifdef __alpha__
         /*
@@ -413,7 +413,7 @@ int drm_release(struct inode *inode, struct file *filp)
 
         drm_fasync(-1, filp, 0);
 
-        down(&dev->ctxlist_sem);
+        mutex_lock(&dev->ctxlist_mutex);
         if (dev->ctxlist && (!list_empty(&dev->ctxlist->head))) {
                 drm_ctx_list_t *pos, *n;
 
@@ -432,9 +432,9 @@ int drm_release(struct inode *inode, struct file *filp)
                         }
                 }
         }
-        up(&dev->ctxlist_sem);
+        mutex_unlock(&dev->ctxlist_mutex);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (priv->remove_auth_on_close == 1) {
                 drm_file_t *temp = dev->file_first;
                 while (temp) {
@@ -452,7 +452,7 @@ int drm_release(struct inode *inode, struct file *filp)
         } else {
                 dev->file_last = priv->prev;
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (dev->driver->postclose)
                 dev->driver->postclose(dev, priv);
diff --git a/drivers/char/drm/drm_ioctl.c b/drivers/char/drm/drm_ioctl.c
index bcd4e604d3ec..555f323b8a32 100644
--- a/drivers/char/drm/drm_ioctl.c
+++ b/drivers/char/drm/drm_ioctl.c
@@ -194,9 +194,9 @@ int drm_getmap(struct inode *inode, struct file *filp,
                 return -EFAULT;
         idx = map.offset;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         if (idx < 0) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
@@ -209,7 +209,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
                 i++;
         }
         if (!r_list || !r_list->map) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
@@ -219,7 +219,7 @@ int drm_getmap(struct inode *inode, struct file *filp,
         map.flags = r_list->map->flags;
         map.handle = (void *)(unsigned long)r_list->user_token;
         map.mtrr = r_list->map->mtrr;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (copy_to_user(argp, &map, sizeof(map)))
                 return -EFAULT;
@@ -253,11 +253,11 @@ int drm_getclient(struct inode *inode, struct file *filp,
         if (copy_from_user(&client, argp, sizeof(client)))
                 return -EFAULT;
         idx = client.idx;
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (i = 0, pt = dev->file_first; i < idx && pt; i++, pt = pt->next) ;
 
         if (!pt) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
         client.auth = pt->authenticated;
@@ -265,7 +265,7 @@ int drm_getclient(struct inode *inode, struct file *filp,
         client.uid = pt->uid;
         client.magic = pt->magic;
         client.iocs = pt->ioctl_count;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (copy_to_user(argp, &client, sizeof(client)))
                 return -EFAULT;
@@ -292,7 +292,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
 
         memset(&stats, 0, sizeof(stats));
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
 
         for (i = 0; i < dev->counters; i++) {
                 if (dev->types[i] == _DRM_STAT_LOCK)
@@ -305,7 +305,7 @@ int drm_getstats(struct inode *inode, struct file *filp,
 
         stats.count = dev->counters;
 
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (copy_to_user((drm_stats_t __user *) arg, &stats, sizeof(stats)))
                 return -EFAULT;
diff --git a/drivers/char/drm/drm_irq.c b/drivers/char/drm/drm_irq.c
index b0d4b236e837..611a1173091d 100644
--- a/drivers/char/drm/drm_irq.c
+++ b/drivers/char/drm/drm_irq.c
@@ -98,20 +98,20 @@ static int drm_irq_install(drm_device_t * dev)
         if (dev->irq == 0)
                 return -EINVAL;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
 
         /* Driver must have been initialized */
         if (!dev->dev_private) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EINVAL;
         }
 
         if (dev->irq_enabled) {
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return -EBUSY;
         }
         dev->irq_enabled = 1;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         DRM_DEBUG("%s: irq=%d\n", __FUNCTION__, dev->irq);
 
@@ -135,9 +135,9 @@ static int drm_irq_install(drm_device_t * dev)
         ret = request_irq(dev->irq, dev->driver->irq_handler,
                           sh_flags, dev->devname, dev);
         if (ret < 0) {
-                down(&dev->struct_sem);
+                mutex_lock(&dev->struct_mutex);
                 dev->irq_enabled = 0;
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
                 return ret;
         }
 
@@ -161,10 +161,10 @@ int drm_irq_uninstall(drm_device_t * dev)
         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
                 return -EINVAL;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         irq_enabled = dev->irq_enabled;
         dev->irq_enabled = 0;
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 
         if (!irq_enabled)
                 return -EINVAL;
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index 5b1d3a04458d..8fd6357a48da 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -3,6 +3,7 @@
    Please contact dri-devel@lists.sf.net to add new cards to this list
 */
 #define radeon_PCI_IDS \
+        {0x1002, 0x3150, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV350},\
         {0x1002, 0x4136, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS100|CHIP_IS_IGP}, \
         {0x1002, 0x4137, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS200|CHIP_IS_IGP}, \
         {0x1002, 0x4144, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R300}, \
@@ -242,5 +243,6 @@
         {0x8086, 0x2582, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x8086, 0x2592, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0x8086, 0x2772, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
+        {0x8086, 0x27a2, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, \
         {0, 0, 0}
 
diff --git a/drivers/char/drm/drm_proc.c b/drivers/char/drm/drm_proc.c
index 6f943e3309ef..362a270af0f1 100644
--- a/drivers/char/drm/drm_proc.c
+++ b/drivers/char/drm/drm_proc.c
@@ -258,7 +258,7 @@ static int drm__vm_info(char *buf, char **start, off_t offset, int request,
 }
 
 /**
- * Simply calls _vm_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _vm_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_vm_info(char *buf, char **start, off_t offset, int request,
                        int *eof, void *data)
@@ -266,9 +266,9 @@ static int drm_vm_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__vm_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -331,7 +331,7 @@ static int drm__queues_info(char *buf, char **start, off_t offset,
 }
 
 /**
- * Simply calls _queues_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _queues_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_queues_info(char *buf, char **start, off_t offset, int request,
                            int *eof, void *data)
@@ -339,9 +339,9 @@ static int drm_queues_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__queues_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -403,7 +403,7 @@ static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
 }
 
 /**
- * Simply calls _bufs_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _bufs_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
                          int *eof, void *data)
@@ -411,9 +411,9 @@ static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__bufs_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -459,7 +459,7 @@ static int drm__clients_info(char *buf, char **start, off_t offset,
 }
 
 /**
- * Simply calls _clients_info() while holding the drm_device::struct_sem lock.
+ * Simply calls _clients_info() while holding the drm_device::struct_mutex lock.
  */
 static int drm_clients_info(char *buf, char **start, off_t offset,
                             int request, int *eof, void *data)
@@ -467,9 +467,9 @@ static int drm_clients_info(char *buf, char **start, off_t offset,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__clients_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 
@@ -540,9 +540,9 @@ static int drm_vma_info(char *buf, char **start, off_t offset, int request,
         drm_device_t *dev = (drm_device_t *) data;
         int ret;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         ret = drm__vma_info(buf, start, offset, request, eof, data);
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
         return ret;
 }
 #endif
diff --git a/drivers/char/drm/drm_stub.c b/drivers/char/drm/drm_stub.c
index 42d766359caa..68073e14fdec 100644
--- a/drivers/char/drm/drm_stub.c
+++ b/drivers/char/drm/drm_stub.c
@@ -50,7 +50,7 @@ module_param_named(cards_limit, drm_cards_limit, int, 0444);
 module_param_named(debug, drm_debug, int, 0600);
 
 drm_head_t **drm_heads;
-struct drm_sysfs_class *drm_class;
+struct class *drm_class;
 struct proc_dir_entry *drm_proc_root;
 
 static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
@@ -61,8 +61,8 @@ static int drm_fill_in_dev(drm_device_t * dev, struct pci_dev *pdev,
 
         spin_lock_init(&dev->count_lock);
         init_timer(&dev->timer);
-        sema_init(&dev->struct_sem, 1);
-        sema_init(&dev->ctxlist_sem, 1);
+        mutex_init(&dev->struct_mutex);
+        mutex_init(&dev->ctxlist_mutex);
 
         dev->pdev = pdev;
 
diff --git a/drivers/char/drm/drm_sysfs.c b/drivers/char/drm/drm_sysfs.c
index 68e43ddc16ae..0b9f98a7eb10 100644
--- a/drivers/char/drm/drm_sysfs.c
+++ b/drivers/char/drm/drm_sysfs.c
@@ -1,3 +1,4 @@
+
 /*
  * drm_sysfs.c - Modifications to drm_sysfs_class.c to support
  *               extra sysfs attribute from DRM. Normal drm_sysfs_class
@@ -19,36 +20,6 @@
 #include "drm_core.h"
 #include "drmP.h"
 
-struct drm_sysfs_class {
-        struct class_device_attribute attr;
-        struct class class;
-};
-#define to_drm_sysfs_class(d) container_of(d, struct drm_sysfs_class, class)
-
-struct simple_dev {
-        dev_t dev;
-        struct class_device class_dev;
-};
-#define to_simple_dev(d) container_of(d, struct simple_dev, class_dev)
-
-static void release_simple_dev(struct class_device *class_dev)
-{
-        struct simple_dev *s_dev = to_simple_dev(class_dev);
-        kfree(s_dev);
-}
-
-static ssize_t show_dev(struct class_device *class_dev, char *buf)
-{
-        struct simple_dev *s_dev = to_simple_dev(class_dev);
-        return print_dev_t(buf, s_dev->dev);
-}
-
-static void drm_sysfs_class_release(struct class *class)
-{
-        struct drm_sysfs_class *cs = to_drm_sysfs_class(class);
-        kfree(cs);
-}
-
 /* Display the version of drm_core. This doesn't work right in current design */
 static ssize_t version_show(struct class *dev, char *buf)
 {
@@ -69,38 +40,16 @@ static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
  * Note, the pointer created here is to be destroyed when finished by making a
  * call to drm_sysfs_destroy().
  */
-struct drm_sysfs_class *drm_sysfs_create(struct module *owner, char *name)
+struct class *drm_sysfs_create(struct module *owner, char *name)
 {
-        struct drm_sysfs_class *cs;
-        int retval;
-
-        cs = kmalloc(sizeof(*cs), GFP_KERNEL);
-        if (!cs) {
-                retval = -ENOMEM;
-                goto error;
-        }
-        memset(cs, 0x00, sizeof(*cs));
-
-        cs->class.name = name;
-        cs->class.class_release = drm_sysfs_class_release;
-        cs->class.release = release_simple_dev;
-
-        cs->attr.attr.name = "dev";
-        cs->attr.attr.mode = S_IRUGO;
-        cs->attr.attr.owner = owner;
-        cs->attr.show = show_dev;
-        cs->attr.store = NULL;
-
-        retval = class_register(&cs->class);
-        if (retval)
-                goto error;
-        class_create_file(&cs->class, &class_attr_version);
-
-        return cs;
-
-      error:
-        kfree(cs);
-        return ERR_PTR(retval);
+        struct class *class;
+
+        class = class_create(owner, name);
+        if (!class)
+                return class;
+
+        class_create_file(class, &class_attr_version);
+        return class;
 }
 
 /**
@@ -110,12 +59,13 @@ struct drm_sysfs_class *drm_sysfs_create(struct module *owner, char *name)
  * Note, the pointer to be destroyed must have been created with a call to
  * drm_sysfs_create().
  */
-void drm_sysfs_destroy(struct drm_sysfs_class *cs)
+void drm_sysfs_destroy(struct class *class)
 {
-        if ((cs == NULL) || (IS_ERR(cs)))
+        if ((class == NULL) || (IS_ERR(class)))
                 return;
 
-        class_unregister(&cs->class);
+        class_remove_file(class, &class_attr_version);
+        class_destroy(class);
 }
 
 static ssize_t show_dri(struct class_device *class_device, char *buf)
@@ -132,7 +82,7 @@ static struct class_device_attribute class_device_attrs[] = {
 
 /**
  * drm_sysfs_device_add - adds a class device to sysfs for a character driver
- * @cs: pointer to the struct drm_sysfs_class that this device should be registered to.
+ * @cs: pointer to the struct class that this device should be registered to.
  * @dev: the dev_t for the device to be added.
  * @device: a pointer to a struct device that is assiociated with this class device.
  * @fmt: string for the class device's name
@@ -141,46 +91,26 @@ static struct class_device_attribute class_device_attrs[] = {
  * class.  A "dev" file will be created, showing the dev_t for the device.  The
  * pointer to the struct class_device will be returned from the call.  Any further
  * sysfs files that might be required can be created using this pointer.
- * Note: the struct drm_sysfs_class passed to this function must have previously been
+ * Note: the struct class passed to this function must have previously been
  * created with a call to drm_sysfs_create().
  */
-struct class_device *drm_sysfs_device_add(struct drm_sysfs_class *cs,
-                                          drm_head_t *head)
+struct class_device *drm_sysfs_device_add(struct class *cs, drm_head_t *head)
 {
-        struct simple_dev *s_dev = NULL;
-        int i, retval;
-
-        if ((cs == NULL) || (IS_ERR(cs))) {
-                retval = -ENODEV;
-                goto error;
-        }
-
-        s_dev = kmalloc(sizeof(*s_dev), GFP_KERNEL);
-        if (!s_dev) {
-                retval = -ENOMEM;
-                goto error;
-        }
-        memset(s_dev, 0x00, sizeof(*s_dev));
-
-        s_dev->dev = MKDEV(DRM_MAJOR, head->minor);
-        s_dev->class_dev.dev = &(head->dev->pdev)->dev;
-        s_dev->class_dev.class = &cs->class;
+        struct class_device *class_dev;
+        int i;
 
-        snprintf(s_dev->class_dev.class_id, BUS_ID_SIZE, "card%d", head->minor);
-        retval = class_device_register(&s_dev->class_dev);
-        if (retval)
-                goto error;
+        class_dev = class_device_create(cs, NULL,
+                                        MKDEV(DRM_MAJOR, head->minor),
+                                        &(head->dev->pdev)->dev,
+                                        "card%d", head->minor);
+        if (!class_dev)
+                return NULL;
 
-        class_device_create_file(&s_dev->class_dev, &cs->attr);
-        class_set_devdata(&s_dev->class_dev, head);
+        class_set_devdata(class_dev, head);
 
         for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_create_file(&s_dev->class_dev, &class_device_attrs[i]);
-        return &s_dev->class_dev;
-
-error:
-        kfree(s_dev);
-        return ERR_PTR(retval);
+                class_device_create_file(class_dev, &class_device_attrs[i]);
+        return class_dev;
 }
 
 /**
@@ -192,10 +122,9 @@ error:
  */
 void drm_sysfs_device_remove(struct class_device *class_dev)
 {
-        struct simple_dev *s_dev = to_simple_dev(class_dev);
         int i;
 
         for (i = 0; i < ARRAY_SIZE(class_device_attrs); i++)
-                class_device_remove_file(&s_dev->class_dev, &class_device_attrs[i]);
-        class_device_unregister(&s_dev->class_dev);
+                class_device_remove_file(class_dev, &class_device_attrs[i]);
+        class_device_unregister(class_dev);
 }
diff --git a/drivers/char/drm/drm_vm.c b/drivers/char/drm/drm_vm.c
index 3f73aa774c80..0291cd62c69f 100644
--- a/drivers/char/drm/drm_vm.c
+++ b/drivers/char/drm/drm_vm.c
@@ -188,7 +188,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
 
         map = vma->vm_private_data;
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->vmalist, prev = NULL; pt; pt = next) {
                 next = pt->next;
                 if (pt->vma->vm_private_data == map)
@@ -248,7 +248,7 @@ static void drm_vm_shm_close(struct vm_area_struct *vma)
                         drm_free(map, sizeof(*map), DRM_MEM_MAPS);
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 /**
@@ -404,12 +404,12 @@ static void drm_vm_open(struct vm_area_struct *vma)
 
         vma_entry = drm_alloc(sizeof(*vma_entry), DRM_MEM_VMAS);
         if (vma_entry) {
-                down(&dev->struct_sem);
+                mutex_lock(&dev->struct_mutex);
                 vma_entry->vma = vma;
                 vma_entry->next = dev->vmalist;
                 vma_entry->pid = current->pid;
                 dev->vmalist = vma_entry;
-                up(&dev->struct_sem);
+                mutex_unlock(&dev->struct_mutex);
         }
 }
 
@@ -431,7 +431,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
                   vma->vm_start, vma->vm_end - vma->vm_start);
         atomic_dec(&dev->vma_count);
 
-        down(&dev->struct_sem);
+        mutex_lock(&dev->struct_mutex);
         for (pt = dev->vmalist, prev = NULL; pt; prev = pt, pt = pt->next) {
                 if (pt->vma == vma) {
                         if (prev) {
@@ -443,7 +443,7 @@ static void drm_vm_close(struct vm_area_struct *vma)
                         break;
                 }
         }
-        up(&dev->struct_sem);
+        mutex_unlock(&dev->struct_mutex);
 }
 
 /**
diff --git a/drivers/char/drm/i810_dma.c b/drivers/char/drm/i810_dma.c
index cc1b89086876..ae0aa6d7e0bb 100644
--- a/drivers/char/drm/i810_dma.c
+++ b/drivers/char/drm/i810_dma.c
@@ -958,7 +958,7 @@ static int i810_flush_queue(drm_device_t * dev)
 }
 
 /* Must be called with the lock held */
-void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
+static void i810_reclaim_buffers(drm_device_t * dev, struct file *filp)
 {
         drm_device_dma_t *dma = dev->dma;
         int i;
diff --git a/drivers/char/drm/i810_drv.h b/drivers/char/drm/i810_drv.h
index a18b80d91920..e8cf3ff606f0 100644
--- a/drivers/char/drm/i810_drv.h
+++ b/drivers/char/drm/i810_drv.h
@@ -113,8 +113,6 @@ typedef struct drm_i810_private {
 } drm_i810_private_t;
 
                                 /* i810_dma.c */
-extern void i810_reclaim_buffers(drm_device_t * dev, struct file *filp);
-
 extern int i810_driver_dma_quiescent(drm_device_t * dev);
 extern void i810_driver_reclaim_buffers_locked(drm_device_t * dev,
                                                struct file *filp);
diff --git a/drivers/char/drm/i830_dma.c b/drivers/char/drm/i830_dma.c
index 4fea32aed6d2..163f2cbfe60d 100644
--- a/drivers/char/drm/i830_dma.c
+++ b/drivers/char/drm/i830_dma.c
@@ -1239,7 +1239,7 @@ static int i830_flush_queue(drm_device_t * dev)
 }
 
 /* Must be called with the lock held */
-void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
+static void i830_reclaim_buffers(drm_device_t * dev, struct file *filp)
 {
         drm_device_dma_t *dma = dev->dma;
         int i;
diff --git a/drivers/char/drm/i830_drv.h b/drivers/char/drm/i830_drv.h
index bf9075b576bd..85bc5be6f916 100644
--- a/drivers/char/drm/i830_drv.h
+++ b/drivers/char/drm/i830_drv.h
@@ -123,9 +123,6 @@ typedef struct drm_i830_private {
 extern drm_ioctl_desc_t i830_ioctls[];
 extern int i830_max_ioctl;
 
-/* i830_dma.c */
-extern void i830_reclaim_buffers(drm_device_t * dev, struct file *filp);
-
 /* i830_irq.c */
 extern int i830_irq_emit(struct inode *inode, struct file *filp,
                          unsigned int cmd, unsigned long arg);
diff --git a/drivers/char/drm/i915_dma.c b/drivers/char/drm/i915_dma.c
index 9140703da1ba..1ff4c7ca0bff 100644
--- a/drivers/char/drm/i915_dma.c
+++ b/drivers/char/drm/i915_dma.c
@@ -344,18 +344,20 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
         int i;
         RING_LOCALS;
 
+        if ((dwords+1) * sizeof(int) >= dev_priv->ring.Size - 8)
+                return DRM_ERR(EINVAL);
+
+        BEGIN_LP_RING(((dwords+1)&~1));
+
         for (i = 0; i < dwords;) {
                 int cmd, sz;
 
                 if (DRM_COPY_FROM_USER_UNCHECKED(&cmd, &buffer[i], sizeof(cmd)))
                         return DRM_ERR(EINVAL);
 
-/*              printk("%d/%d ", i, dwords); */
-
                 if ((sz = validate_cmd(cmd)) == 0 || i + sz > dwords)
                         return DRM_ERR(EINVAL);
 
-                BEGIN_LP_RING(sz);
                 OUT_RING(cmd);
 
                 while (++i, --sz) {
@@ -365,9 +367,13 @@ static int i915_emit_cmds(drm_device_t * dev, int __user * buffer, int dwords)
                         }
                         OUT_RING(cmd);
                 }
-                ADVANCE_LP_RING();
         }
 
+        if (dwords & 1)
+                OUT_RING(0);
+
+        ADVANCE_LP_RING();
+
         return 0;
 }
 
@@ -401,6 +407,21 @@ static int i915_emit_box(drm_device_t * dev,
         return 0;
 }
 
+static void i915_emit_breadcrumb(drm_device_t *dev)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        RING_LOCALS;
+
+        dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
+
+        BEGIN_LP_RING(4);
+        OUT_RING(CMD_STORE_DWORD_IDX);
+        OUT_RING(20);
+        OUT_RING(dev_priv->counter);
+        OUT_RING(0);
+        ADVANCE_LP_RING();
+}
+
 static int i915_dispatch_cmdbuffer(drm_device_t * dev,
                                    drm_i915_cmdbuffer_t * cmd)
 {
@@ -429,6 +450,7 @@ static int i915_dispatch_cmdbuffer(drm_device_t * dev,
                         return ret;
         }
 
+        i915_emit_breadcrumb(dev);
         return 0;
 }
 
@@ -475,12 +497,7 @@ static int i915_dispatch_batchbuffer(drm_device_t * dev,
 
         dev_priv->sarea_priv->last_enqueue = dev_priv->counter++;
 
-        BEGIN_LP_RING(4);
-        OUT_RING(CMD_STORE_DWORD_IDX);
-        OUT_RING(20);
-        OUT_RING(dev_priv->counter);
-        OUT_RING(0);
-        ADVANCE_LP_RING();
+        i915_emit_breadcrumb(dev);
 
         return 0;
 }
@@ -657,7 +674,7 @@ static int i915_getparam(DRM_IOCTL_ARGS)
                 value = READ_BREADCRUMB(dev_priv);
                 break;
         default:
-                DRM_ERROR("Unkown parameter %d\n", param.param);
+                DRM_ERROR("Unknown parameter %d\n", param.param);
                 return DRM_ERR(EINVAL);
         }
 
@@ -742,7 +759,8 @@ drm_ioctl_desc_t i915_ioctls[] = {
         [DRM_IOCTL_NR(DRM_I915_ALLOC)] = {i915_mem_alloc, DRM_AUTH},
         [DRM_IOCTL_NR(DRM_I915_FREE)] = {i915_mem_free, DRM_AUTH},
         [DRM_IOCTL_NR(DRM_I915_INIT_HEAP)] = {i915_mem_init_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
-        [DRM_IOCTL_NR(DRM_I915_CMDBUFFER)] = {i915_cmdbuffer, DRM_AUTH}
+        [DRM_IOCTL_NR(DRM_I915_CMDBUFFER)] = {i915_cmdbuffer, DRM_AUTH},
+        [DRM_IOCTL_NR(DRM_I915_DESTROY_HEAP)] = { i915_mem_destroy_heap, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY }
 };
 
 int i915_max_ioctl = DRM_ARRAY_SIZE(i915_ioctls);
diff --git a/drivers/char/drm/i915_drm.h b/drivers/char/drm/i915_drm.h
index 77412ddac007..4cb3da578330 100644
--- a/drivers/char/drm/i915_drm.h
+++ b/drivers/char/drm/i915_drm.h
@@ -74,6 +74,30 @@ typedef struct _drm_i915_sarea {
         int pf_active;
         int pf_current_page;    /* which buffer is being displayed? */
         int perf_boxes;         /* performance boxes to be displayed */
+        int width, height;      /* screen size in pixels */
+
+        drm_handle_t front_handle;
+        int front_offset;
+        int front_size;
+
+        drm_handle_t back_handle;
+        int back_offset;
+        int back_size;
+
+        drm_handle_t depth_handle;
+        int depth_offset;
+        int depth_size;
+
+        drm_handle_t tex_handle;
+        int tex_offset;
+        int tex_size;
+        int log_tex_granularity;
+        int pitch;
+        int rotation;           /* 0, 90, 180 or 270 */
+        int rotated_offset;
+        int rotated_size;
+        int rotated_pitch;
+        int virtualX, virtualY;
 } drm_i915_sarea_t;
 
 /* Flags for perf_boxes
@@ -99,6 +123,7 @@ typedef struct _drm_i915_sarea {
 #define DRM_I915_FREE           0x09
 #define DRM_I915_INIT_HEAP      0x0a
 #define DRM_I915_CMDBUFFER      0x0b
+#define DRM_I915_DESTROY_HEAP   0x0c
 
 #define DRM_IOCTL_I915_INIT             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)
 #define DRM_IOCTL_I915_FLUSH            DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
@@ -112,6 +137,7 @@ typedef struct _drm_i915_sarea {
 #define DRM_IOCTL_I915_FREE             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_FREE, drm_i915_mem_free_t)
 #define DRM_IOCTL_I915_INIT_HEAP        DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT_HEAP, drm_i915_mem_init_heap_t)
 #define DRM_IOCTL_I915_CMDBUFFER        DRM_IOW( DRM_COMMAND_BASE + DRM_I915_CMDBUFFER, drm_i915_cmdbuffer_t)
+#define DRM_IOCTL_I915_DESTROY_HEAP     DRM_IOW( DRM_COMMAND_BASE + DRM_I915_DESTROY_HEAP, drm_i915_mem_destroy_heap_t)
 
 /* Allow drivers to submit batchbuffers directly to hardware, relying
  * on the security mechanisms provided by hardware.
@@ -191,4 +217,11 @@ typedef struct drm_i915_mem_init_heap {
         int start;
 } drm_i915_mem_init_heap_t;
 
+/* Allow memory manager to be torn down and re-initialized (eg on
+ * rotate):
+ */
+typedef struct drm_i915_mem_destroy_heap {
+        int region;
+} drm_i915_mem_destroy_heap_t;
+
 #endif                          /* _I915_DRM_H_ */
diff --git a/drivers/char/drm/i915_drv.h b/drivers/char/drm/i915_drv.h
index c6c71b45f101..7a65666899e4 100644
--- a/drivers/char/drm/i915_drv.h
+++ b/drivers/char/drm/i915_drv.h
@@ -37,16 +37,17 @@
 
 #define DRIVER_NAME             "i915"
 #define DRIVER_DESC             "Intel Graphics"
-#define DRIVER_DATE             "20051209"
+#define DRIVER_DATE             "20060119"
 
 /* Interface history:
  *
  * 1.1: Original.
  * 1.2: Add Power Management
  * 1.3: Add vblank support
+ * 1.4: Fix cmdbuffer path, add heap destroy
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            3
+#define DRIVER_MINOR            4
 #define DRIVER_PATCHLEVEL       0
 
 typedef struct _drm_i915_ring_buffer {
@@ -123,6 +124,7 @@ extern void i915_driver_irq_uninstall(drm_device_t * dev);
 extern int i915_mem_alloc(DRM_IOCTL_ARGS);
 extern int i915_mem_free(DRM_IOCTL_ARGS);
 extern int i915_mem_init_heap(DRM_IOCTL_ARGS);
+extern int i915_mem_destroy_heap(DRM_IOCTL_ARGS);
 extern void i915_mem_takedown(struct mem_block **heap);
 extern void i915_mem_release(drm_device_t * dev,
                              DRMFILE filp, struct mem_block *heap);
diff --git a/drivers/char/drm/i915_mem.c b/drivers/char/drm/i915_mem.c
index ba87ff17ff64..52c67324df58 100644
--- a/drivers/char/drm/i915_mem.c
+++ b/drivers/char/drm/i915_mem.c
@@ -365,3 +365,34 @@ int i915_mem_init_heap(DRM_IOCTL_ARGS)
 
         return init_heap(heap, initheap.start, initheap.size);
 }
+
+int i915_mem_destroy_heap( DRM_IOCTL_ARGS )
+{
+        DRM_DEVICE;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        drm_i915_mem_destroy_heap_t destroyheap;
+        struct mem_block **heap;
+
+        if ( !dev_priv ) {
+                DRM_ERROR( "%s called with no initialization\n", __FUNCTION__ );
+                return DRM_ERR(EINVAL);
+        }
+
+        DRM_COPY_FROM_USER_IOCTL( destroyheap, (drm_i915_mem_destroy_heap_t *)data,
+                                  sizeof(destroyheap) );
+
+        heap = get_heap( dev_priv, destroyheap.region );
+        if (!heap) {
+                DRM_ERROR("get_heap failed");
+                return DRM_ERR(EFAULT);
+        }
+        
+        if (!*heap) {
+                DRM_ERROR("heap not initialized?");
+                return DRM_ERR(EFAULT);
+        }
+
+        i915_mem_takedown( heap );
+        return 0;
+}
+
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 915665c7fe7c..9bb8ae0c1c27 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -1640,7 +1640,7 @@ static int radeon_do_cleanup_cp(drm_device_t * dev)
                 if (dev_priv->gart_info.gart_table_location == DRM_ATI_GART_FB)
                 {
                         drm_core_ioremapfree(&dev_priv->gart_info.mapping, dev);
-                        dev_priv->gart_info.addr = 0;
+                        dev_priv->gart_info.addr = NULL;
                 }
         }
         /* only clear to the start of flags */
diff --git a/drivers/char/drm/savage_bci.c b/drivers/char/drm/savage_bci.c
index 0d426deeefec..59c7520bf9a2 100644
--- a/drivers/char/drm/savage_bci.c
+++ b/drivers/char/drm/savage_bci.c
@@ -32,6 +32,8 @@
 #define SAVAGE_EVENT_USEC_TIMEOUT       5000000 /* 5s */
 #define SAVAGE_FREELIST_DEBUG           0
 
+static int savage_do_cleanup_bci(drm_device_t *dev);
+
 static int
 savage_bci_wait_fifo_shadow(drm_savage_private_t * dev_priv, unsigned int n)
 {
@@ -895,7 +897,7 @@ static int savage_do_init_bci(drm_device_t * dev, drm_savage_init_t * init)
         return 0;
 }
 
-int savage_do_cleanup_bci(drm_device_t * dev)
+static int savage_do_cleanup_bci(drm_device_t * dev)
 {
         drm_savage_private_t *dev_priv = dev->dev_private;
 
diff --git a/drivers/char/drm/savage_drv.h b/drivers/char/drm/savage_drv.h
index dd46cb85439c..8f04b3d82292 100644
--- a/drivers/char/drm/savage_drv.h
+++ b/drivers/char/drm/savage_drv.h
@@ -212,7 +212,6 @@ extern int savage_driver_load(drm_device_t *dev, unsigned long chipset);
 extern int savage_driver_firstopen(drm_device_t *dev);
 extern void savage_driver_lastclose(drm_device_t *dev);
 extern int savage_driver_unload(drm_device_t *dev);
-extern int savage_do_cleanup_bci(drm_device_t * dev);
 extern void savage_reclaim_buffers(drm_device_t * dev, DRMFILE filp);
 
 /* state functions */
diff --git a/drivers/char/drm/via_dma.c b/drivers/char/drm/via_dma.c
index 593c0b8f650a..a691ae74129d 100644
--- a/drivers/char/drm/via_dma.c
+++ b/drivers/char/drm/via_dma.c
@@ -222,7 +222,7 @@ static int via_initialize(drm_device_t * dev,
         return 0;
 }
 
-int via_dma_init(DRM_IOCTL_ARGS)
+static int via_dma_init(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_private_t *dev_priv = (drm_via_private_t *) dev->dev_private;
@@ -321,7 +321,7 @@ int via_driver_dma_quiescent(drm_device_t * dev)
         return 0;
 }
 
-int via_flush_ioctl(DRM_IOCTL_ARGS)
+static int via_flush_ioctl(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
 
@@ -330,7 +330,7 @@ int via_flush_ioctl(DRM_IOCTL_ARGS)
         return via_driver_dma_quiescent(dev);
 }
 
-int via_cmdbuffer(DRM_IOCTL_ARGS)
+static int via_cmdbuffer(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuffer_t cmdbuf;
@@ -375,7 +375,7 @@ static int via_dispatch_pci_cmdbuffer(drm_device_t * dev,
         return ret;
 }
 
-int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
+static int via_pci_cmdbuffer(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuffer_t cmdbuf;
@@ -665,7 +665,7 @@ static void via_cmdbuf_reset(drm_via_private_t * dev_priv)
  * User interface to the space and lag functions.
  */
 
-int via_cmdbuf_size(DRM_IOCTL_ARGS)
+static int via_cmdbuf_size(DRM_IOCTL_ARGS)
 {
         DRM_DEVICE;
         drm_via_cmdbuf_size_t d_siz;
diff --git a/drivers/char/drm/via_dmablit.c b/drivers/char/drm/via_dmablit.c
index 9d5e027dae0e..b7f17457b424 100644
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -108,7 +108,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
         int num_desc = 0;
         int cur_line;
         dma_addr_t next = 0 | VIA_DMA_DPR_EC;
-        drm_via_descriptor_t *desc_ptr = 0;
+        drm_via_descriptor_t *desc_ptr = NULL;
 
         if (mode == 1) 
                 desc_ptr = vsg->desc_pages[cur_descriptor_page];
@@ -167,7 +167,7 @@ via_map_blit_for_device(struct pci_dev *pdev,
  */
 
 
-void
+static void
 via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg) 
 {
         struct page *page;
@@ -581,7 +581,7 @@ via_build_sg_info(drm_device_t *dev, drm_via_sg_info_t *vsg, drm_via_dmablit_t *
         int ret = 0;
         
         vsg->direction = (draw) ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
-        vsg->bounce_buffer = 0;
+        vsg->bounce_buffer = NULL;
 
         vsg->state = dr_via_sg_init;
 
diff --git a/drivers/char/drm/via_drv.h b/drivers/char/drm/via_drv.h
index aad4f99f5405..52bcc7b1ba45 100644
--- a/drivers/char/drm/via_drv.h
+++ b/drivers/char/drm/via_drv.h
@@ -110,11 +110,6 @@ extern int via_mem_free(DRM_IOCTL_ARGS);
 extern int via_agp_init(DRM_IOCTL_ARGS);
 extern int via_map_init(DRM_IOCTL_ARGS);
 extern int via_decoder_futex(DRM_IOCTL_ARGS);
-extern int via_dma_init(DRM_IOCTL_ARGS);
-extern int via_cmdbuffer(DRM_IOCTL_ARGS);
-extern int via_flush_ioctl(DRM_IOCTL_ARGS);
-extern int via_pci_cmdbuffer(DRM_IOCTL_ARGS);
-extern int via_cmdbuf_size(DRM_IOCTL_ARGS);
 extern int via_wait_irq(DRM_IOCTL_ARGS);
 extern int via_dma_blit_sync( DRM_IOCTL_ARGS );
 extern int via_dma_blit( DRM_IOCTL_ARGS );
@@ -139,8 +134,6 @@ extern int via_driver_dma_quiescent(drm_device_t * dev);
 extern void via_init_futex(drm_via_private_t * dev_priv);
 extern void via_cleanup_futex(drm_via_private_t * dev_priv);
 extern void via_release_futex(drm_via_private_t * dev_priv, int context);
-extern int via_driver_irq_wait(drm_device_t * dev, unsigned int irq,
-                               int force_sequence, unsigned int *sequence);
 
 extern void via_dmablit_handler(drm_device_t *dev, int engine, int from_irq);
 extern void via_init_dmablit(drm_device_t *dev);
diff --git a/drivers/char/drm/via_irq.c b/drivers/char/drm/via_irq.c
index 56d7e3daea12..6152415644e9 100644
--- a/drivers/char/drm/via_irq.c
+++ b/drivers/char/drm/via_irq.c
@@ -190,7 +190,7 @@ int via_driver_vblank_wait(drm_device_t * dev, unsigned int *sequence)
         return ret;
 }
 
-int
+static int
 via_driver_irq_wait(drm_device_t * dev, unsigned int irq, int force_sequence,
                     unsigned int *sequence)
 {
diff --git a/drivers/char/esp.c b/drivers/char/esp.c
index 3f3ac039f4d9..57539d8f9f7c 100644
--- a/drivers/char/esp.c
+++ b/drivers/char/esp.c
@@ -359,7 +359,7 @@ static inline void receive_chars_pio(struct esp_struct *info, int num_bytes)
                 }
         }
 
-        schedule_delayed_work(&tty->buf.work, 1);
+        tty_schedule_flip(tty);
 
         info->stat_flags &= ~ESP_STAT_RX_TIMEOUT;
         release_pio_buffer(pio_buf);
@@ -426,7 +426,7 @@ static inline void receive_chars_dma_done(struct esp_struct *info,
                         }
                         tty_insert_flip_char(tty, dma_buffer[num_bytes - 1], statflag);
                 }
-                schedule_delayed_work(&tty->buf.work, 1);
+                tty_schedule_flip(tty);
         }
 
         if (dma_bytes != num_bytes) {
diff --git a/drivers/char/ip2/i2cmd.c b/drivers/char/ip2/i2cmd.c
index cb8f4198e9a3..e7af647800b6 100644
--- a/drivers/char/ip2/i2cmd.c
+++ b/drivers/char/ip2/i2cmd.c
@@ -139,7 +139,6 @@ static UCHAR ct79[] = { 2, BYP,     0x4F,0                   }; // XMIT_NOW
 //static UCHAR ct86[]={ 2, BTH,     0x56,0                   }; // RCV_ENABLE
 static UCHAR ct87[] = { 1, BYP,     0x57                     }; // HW_TEST
 //static UCHAR ct88[]={ 3, BTH,     0x58,0,0                 }; // RCV_THRESHOLD
-static UCHAR ct89[]={ 1, BYP,     0x59                     }; // DSS_NOW
 //static UCHAR ct90[]={ 3, BYP,     0x5A,0,0                 }; // Set SILO
 //static UCHAR ct91[]={ 2, BYP,     0x5B,0                   }; // timed break
 
diff --git a/drivers/char/ip2main.c b/drivers/char/ip2main.c
index 56e93a5a1e24..48fcfba37bfa 100644
--- a/drivers/char/ip2main.c
+++ b/drivers/char/ip2main.c
@@ -2906,65 +2906,16 @@ ip2_ipl_ioctl ( struct inode *pInode, struct file *pFile, UINT cmd, ULONG arg )
                 rc = -EINVAL;
                 break;
         case 3:     // Trace device
-                if ( cmd == 1 ) {
-                        rc = put_user(iiSendPendingMail, pIndex++ );
-                        rc = put_user(i2InitChannels, pIndex++ );
-                        rc = put_user(i2QueueNeeds, pIndex++ );
-                        rc = put_user(i2QueueCommands, pIndex++ );
-                        rc = put_user(i2GetStatus, pIndex++ );
-                        rc = put_user(i2Input, pIndex++ );
-                        rc = put_user(i2InputFlush, pIndex++ );
-                        rc = put_user(i2Output, pIndex++ );
-                        rc = put_user(i2FlushOutput, pIndex++ );
-                        rc = put_user(i2DrainWakeup, pIndex++ );
-                        rc = put_user(i2DrainOutput, pIndex++ );
-                        rc = put_user(i2OutputFree, pIndex++ );
-                        rc = put_user(i2StripFifo, pIndex++ );
-                        rc = put_user(i2StuffFifoBypass, pIndex++ );
-                        rc = put_user(i2StuffFifoFlow, pIndex++ );
-                        rc = put_user(i2StuffFifoInline, pIndex++ );
-                        rc = put_user(i2ServiceBoard, pIndex++ );
-                        rc = put_user(serviceOutgoingFifo, pIndex++ );
-                        // rc = put_user(ip2_init, pIndex++ );
-                        rc = put_user(ip2_init_board, pIndex++ );
-                        rc = put_user(find_eisa_board, pIndex++ );
-                        rc = put_user(set_irq, pIndex++ );
-                        rc = put_user(ip2_interrupt, pIndex++ );
-                        rc = put_user(ip2_poll, pIndex++ );
-                        rc = put_user(service_all_boards, pIndex++ );
-                        rc = put_user(do_input, pIndex++ );
-                        rc = put_user(do_status, pIndex++ );
-#ifndef IP2DEBUG_OPEN
-                        rc = put_user(0, pIndex++ );
-#else
-                        rc = put_user(open_sanity_check, pIndex++ );
-#endif
-                        rc = put_user(ip2_open, pIndex++ );
-                        rc = put_user(ip2_close, pIndex++ );
-                        rc = put_user(ip2_hangup, pIndex++ );
-                        rc = put_user(ip2_write, pIndex++ );
-                        rc = put_user(ip2_putchar, pIndex++ );
-                        rc = put_user(ip2_flush_chars, pIndex++ );
-                        rc = put_user(ip2_write_room, pIndex++ );
-                        rc = put_user(ip2_chars_in_buf, pIndex++ );
-                        rc = put_user(ip2_flush_buffer, pIndex++ );
-
-                        //rc = put_user(ip2_wait_until_sent, pIndex++ );
-                        rc = put_user(0, pIndex++ );
-
-                        rc = put_user(ip2_throttle, pIndex++ );
-                        rc = put_user(ip2_unthrottle, pIndex++ );
-                        rc = put_user(ip2_ioctl, pIndex++ );
-                        rc = put_user(0, pIndex++ );
-                        rc = put_user(get_serial_info, pIndex++ );
-                        rc = put_user(set_serial_info, pIndex++ );
-                        rc = put_user(ip2_set_termios, pIndex++ );
-                        rc = put_user(ip2_set_line_discipline, pIndex++ );
-                        rc = put_user(set_params, pIndex++ );
-                } else {
+                /*
+                 * akpm: This used to write a whole bunch of function addresses
+                 * to userspace, which generated lots of put_user() warnings.
+                 * I killed it all.  Just return "success" and don't do
+                 * anything.
+                 */
+                if (cmd == 1)
+                        rc = 0;
+                else
                         rc = -EINVAL;
-                }
-
                 break;
 
         default:
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 0097f06fa67b..d745004281d0 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -481,7 +481,7 @@ int ipmi_validate_addr(struct ipmi_addr *addr, int len)
         }
 
         if ((addr->channel == IPMI_BMC_CHANNEL)
-            || (addr->channel >= IPMI_NUM_CHANNELS)
+            || (addr->channel >= IPMI_MAX_CHANNELS)
             || (addr->channel < 0))
                 return -EINVAL;
 
@@ -1321,7 +1321,7 @@ static int i_ipmi_request(ipmi_user_t          user,
                 unsigned char         ipmb_seq;
                 long                  seqid;
 
-                if (addr->channel >= IPMI_NUM_CHANNELS) {
+                if (addr->channel >= IPMI_MAX_CHANNELS) {
                         spin_lock_irqsave(&intf->counter_lock, flags);
                         intf->sent_invalid_commands++;
                         spin_unlock_irqrestore(&intf->counter_lock, flags);
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 6ed213bd702c..e59b638766ef 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -1270,36 +1270,36 @@ static int try_init_port(int intf_num, struct smi_info **new_info)
         return 0;
 }
 
-static unsigned char mem_inb(struct si_sm_io *io, unsigned int offset)
+static unsigned char intf_mem_inb(struct si_sm_io *io, unsigned int offset)
 {
         return readb((io->addr)+(offset * io->regspacing));
 }
 
-static void mem_outb(struct si_sm_io *io, unsigned int offset,
+static void intf_mem_outb(struct si_sm_io *io, unsigned int offset,
                      unsigned char b)
 {
         writeb(b, (io->addr)+(offset * io->regspacing));
 }
 
-static unsigned char mem_inw(struct si_sm_io *io, unsigned int offset)
+static unsigned char intf_mem_inw(struct si_sm_io *io, unsigned int offset)
 {
         return (readw((io->addr)+(offset * io->regspacing)) >> io->regshift)
                 && 0xff;
 }
 
-static void mem_outw(struct si_sm_io *io, unsigned int offset,
+static void intf_mem_outw(struct si_sm_io *io, unsigned int offset,
                      unsigned char b)
 {
         writeb(b << io->regshift, (io->addr)+(offset * io->regspacing));
 }
 
-static unsigned char mem_inl(struct si_sm_io *io, unsigned int offset)
+static unsigned char intf_mem_inl(struct si_sm_io *io, unsigned int offset)
 {
         return (readl((io->addr)+(offset * io->regspacing)) >> io->regshift)
                 && 0xff;
 }
 
-static void mem_outl(struct si_sm_io *io, unsigned int offset,
+static void intf_mem_outl(struct si_sm_io *io, unsigned int offset,
                      unsigned char b)
 {
         writel(b << io->regshift, (io->addr)+(offset * io->regspacing));
@@ -1349,16 +1349,16 @@ static int mem_setup(struct smi_info *info)
            upon the register size. */
         switch (info->io.regsize) {
         case 1:
-                info->io.inputb = mem_inb;
-                info->io.outputb = mem_outb;
+                info->io.inputb = intf_mem_inb;
+                info->io.outputb = intf_mem_outb;
                 break;
         case 2:
-                info->io.inputb = mem_inw;
-                info->io.outputb = mem_outw;
+                info->io.inputb = intf_mem_inw;
+                info->io.outputb = intf_mem_outw;
                 break;
         case 4:
-                info->io.inputb = mem_inl;
-                info->io.outputb = mem_outl;
+                info->io.inputb = intf_mem_inl;
+                info->io.outputb = intf_mem_outl;
                 break;
 #ifdef readq
         case 8:
diff --git a/drivers/char/rio/cirrus.h b/drivers/char/rio/cirrus.h
index 217ff09f2fa1..89bd94eb45be 100644
--- a/drivers/char/rio/cirrus.h
+++ b/drivers/char/rio/cirrus.h
@@ -40,148 +40,6 @@
 #endif
 #define _cirrus_h 1
 
-#ifdef RTA
-#define TO_UART RX
-#define TO_DRIVER TX
-#endif
-
-#ifdef HOST
-#define TO_UART TX
-#define TO_DRIVER RX
-#endif
-#ifdef RTA
-/* Miscellaneous defines for CIRRUS addresses and related logic for
-   interrupts etc.
-*/
-#define MAP(a)          ((short *)(cirrus_base + (a)))
-#define outp(a,b)       (*MAP (a) =(b))
-#define inp(a)          ((*MAP (a)) & 0xff)
-#define CIRRUS_FIRST    (short*)0x7300
-#define CIRRUS_SECOND   (short*)0x7200
-#define CIRRUS_THIRD    (short*)0x7100
-#define CIRRUS_FOURTH   (short*)0x7000
-#define PORTS_ON_CIRRUS 4
-#define CIRRUS_FIFO_SIZE        12
-#define SPACE           0x20
-#define TAB             0x09
-#define LINE_FEED       0x0a
-#define CARRIAGE_RETURN 0x0d
-#define BACKSPACE       0x08
-#define SPACES_IN_TABS  8
-#define SEND_ESCAPE     0x00
-#define START_BREAK     0x81
-#define TIMER_TICK      0x82
-#define STOP_BREAK      0x83
-#define BASE(a) ((a) < 4 ? (short*)CIRRUS_FIRST : ((a) < 8 ? (short *)CIRRUS_SECOND : ((a) < 12 ? (short*)CIRRUS_THIRD : (short *)CIRRUS_FOURTH)))
-#define txack1  ((short *)0x7104)
-#define rxack1  ((short *)0x7102)
-#define mdack1  ((short *)0x7106)
-#define txack2  ((short *)0x7006)
-#define rxack2  ((short *)0x7004)
-#define mdack2  ((short *)0x7100)
-#define int_latch       ((short *) 0x7800)
-#define int_status      ((short *) 0x7c00)
-#define tx1_pending     0x20
-#define rx1_pending     0x10
-#define md1_pending     0x40
-#define tx2_pending     0x02
-#define rx2_pending     0x01
-#define md2_pending     0x40
-#define module1_bits    0x07
-#define module1_modern  0x08
-#define module2_bits    0x70
-#define module2_modern  0x80
-#define module_blank    0xf
-#define rs232_d25       0x0
-#define rs232_rj45      0x1
-#define rs422_d25       0x3
-#define parallel        0x5
-
-#define CLK0    0x00
-#define CLK1    0x01
-#define CLK2    0x02
-#define CLK3    0x03
-#define CLK4    0x04
-
-#define CIRRUS_REVC    0x42
-#define CIRRUS_REVE    0x44
-
-#define TURNON  1
-#define TURNOFF 0
-
-/* The list of CIRRUS registers. 
-   NB. These registers are relative values on 8 bit boundaries whereas
-   on the RTA's the CIRRUS registers are on word boundaries. Use pointer
-   arithmetic (short *) to obtain the real addresses required */
-#define ccr     0x05            /* Channel Command Register     */
-#define ier     0x06            /* Interrupt Enable Register    */
-#define cor1    0x08            /* Channel Option Register 1    */
-#define cor2    0x09            /* Channel Option Register 2    */
-#define cor3    0x0a            /* Channel Option Register 3    */
-#define cor4    0x1e            /* Channel Option Register 4    */
-#define cor5    0x1f            /* Channel Option Register 5    */
-
-#define ccsr    0x0b            /* Channel Control Status Register */
-#define rdcr    0x0e            /* Receive Data Count Register  */
-#define tdcr    0x12            /* Transmit Data Count Register */
-#define mcor1   0x15            /* Modem Change Option Register 1 */
-#define mcor2   0x16            /* Modem Change Option Regsiter 2 */
-
-#define livr    0x18            /* Local Interrupt Vector Register */
-#define schr1   0x1a            /* Special Character Register 1 */
-#define schr2   0x1b            /* Special Character Register 2 */
-#define schr3   0x1c            /* Special Character Register 3 */
-#define schr4   0x1d            /* Special Character Register 4 */
-
-#define rtr     0x20            /* Receive Timer Register */
-#define rtpr    0x21            /* Receive Timeout Period Register */
-#define lnc     0x24            /* Lnext character */
-
-#define rivr    0x43            /* Receive Interrupt Vector Register    */
-#define tivr    0x42            /* Transmit Interrupt Vector Register   */
-#define mivr    0x41            /* Modem Interrupt Vector Register      */
-#define gfrcr   0x40            /* Global Firmware Revision code Reg    */
-#define ricr    0x44            /* Receive Interrupting Channel Reg     */
-#define ticr    0x45            /* Transmit Interrupting Channel Reg    */
-#define micr    0x46            /* Modem Interrupting Channel Register  */
-
-#define gcr     0x4b            /* Global configuration register */
-#define misr    0x4c            /* Modem interrupt status register */
-
-#define rbusr   0x59
-#define tbusr   0x5a
-#define mbusr   0x5b
-
-#define eoir    0x60            /* End Of Interrupt Register */
-#define rdsr    0x62            /* Receive Data / Status Register */
-#define tdr     0x63            /* Transmit Data Register */
-#define svrr    0x67            /* Service Request Register */
-
-#define car     0x68            /* Channel Access Register */
-#define mir     0x69            /* Modem Interrupt Register */
-#define tir     0x6a            /* Transmit Interrupt Register */
-#define rir     0x6b            /* Receive Interrupt Register */
-#define msvr1   0x6c            /* Modem Signal Value Register 1 */
-#define msvr2   0x6d            /* Modem Signal Value Register 2 */
-#define psvr    0x6f            /* Printer Signal Value Register */
-
-#define tbpr    0x72            /* Transmit Baud Rate Period Register */
-#define tcor    0x76            /* Transmit Clock Option Register */
-
-#define rbpr    0x78            /* Receive Baud Rate Period Register */
-#define rber    0x7a            /* Receive Baud Rate Extension Register */
-#define rcor    0x7c            /* Receive Clock Option Register */
-#define ppr     0x7e            /* Prescalar Period Register    */
-
-/* Misc registers used for forcing the 1400 out of its reset woes */
-#define airl    0x6d
-#define airm    0x6e
-#define airh    0x6f
-#define btcr    0x66
-#define mtcr    0x6c
-#define tber    0x74
-
-#endif                          /* #ifdef RTA */
 
 
 /* Bit fields for particular registers */
diff --git a/drivers/char/rio/defaults.h b/drivers/char/rio/defaults.h
index 5b600c32ac02..d55c2f6a9877 100644
--- a/drivers/char/rio/defaults.h
+++ b/drivers/char/rio/defaults.h
@@ -45,13 +45,6 @@ static char *_rio_defaults_h_sccs = "@(#)defaults.h	1.1";
 #define MILLISECOND           (int) (1000/64)   /* 15.625 low ticks */
 #define SECOND                (int) 15625       /* Low priority ticks */
 
-#ifdef RTA
-#define RX_LIMIT       (ushort) 3
-#endif
-#ifdef HOST
-#define RX_LIMIT       (ushort) 1
-#endif
-
 #define LINK_TIMEOUT          (int) (POLL_PERIOD / 2)
 
 
diff --git a/drivers/char/rio/link.h b/drivers/char/rio/link.h
index bfba5b0c033e..48d68ca7f825 100644
--- a/drivers/char/rio/link.h
+++ b/drivers/char/rio/link.h
@@ -102,30 +102,14 @@
 /*
 ** LED stuff
 */
-#if defined(RTA)
-#define LED_OFF            ((ushort) 0) /* LED off */
-#define LED_RED            ((ushort) 1) /* LED Red */
-#define LED_GREEN          ((ushort) 2) /* LED Green */
-#define LED_ORANGE         ((ushort) 4) /* LED Orange */
-#define LED_1TO8_OPEN      ((ushort) 1) /* Port 1->8 LED on */
-#define LED_9TO16_OPEN     ((ushort) 2) /* Port 9->16 LED on */
-#define LED_SET_COLOUR(colour)  (link->led = (colour))
-#define LED_OR_COLOUR(colour)   (link->led |= (colour))
-#define LED_TIMEOUT(time)    (link->led_timeout = RioTimePlus(RioTime(),(time)))
-#else
 #define LED_SET_COLOUR(colour)
 #define LED_OR_COLOUR(colour)
 #define LED_TIMEOUT(time)
-#endif                          /* RTA */
 
 struct LPB {
         WORD link_number;       /* Link Number */
         Channel_ptr in_ch;      /* Link In Channel */
         Channel_ptr out_ch;     /* Link Out Channel */
-#ifdef RTA
-        uchar stat_led;         /* Port open leds */
-        uchar led;              /* True, light led! */
-#endif
         BYTE attached_serial[4];        /* Attached serial number */
         BYTE attached_host_serial[4];
         /* Serial number of Host who
@@ -144,30 +128,12 @@ struct LPB {
         WORD WaitNoBoot;        /* Secs to hold off booting */
         PKT_ptr add_packet_list;        /* Add packets to here */
         PKT_ptr remove_packet_list;     /* Send packets from here */
-#ifdef RTA
-#ifdef DCIRRUS
-#define    QBUFS_PER_REDIRECT (4 / PKTS_PER_BUFFER + 1)
-#else
-#define    QBUFS_PER_REDIRECT (8 / PKTS_PER_BUFFER + 1)
-#endif
-        PKT_ptr_ptr rd_add;     /* Add a new Packet here */
-        Q_BUF_ptr rd_add_qb;    /* Pointer to the add Q buf */
-        PKT_ptr_ptr rd_add_st_qbb;      /* Pointer to start of the Q's buf */
-        PKT_ptr_ptr rd_add_end_qbb;     /* Pointer to the end of the Q's buf */
-        PKT_ptr_ptr rd_remove;  /* Remove a Packet here */
-        Q_BUF_ptr rd_remove_qb; /* Pointer to the remove Q buf */
-        PKT_ptr_ptr rd_remove_st_qbb;   /* Pointer to the start of the Q buf */
-        PKT_ptr_ptr rd_remove_end_qbb;  /* Pointer to the end of the Q buf */
-        ushort pkts_in_q;       /* Packets in queue */
-#endif
 
         Channel_ptr lrt_fail_chan;      /* Lrt's failure channel */
         Channel_ptr ltt_fail_chan;      /* Ltt's failure channel */
 
-#if defined (HOST) || defined (INKERNEL)
         /* RUP structure for HOST to driver communications */
         struct RUP rup;
-#endif
         struct RUP link_rup;    /* RUP for the link (POLL,
                                    topology etc.) */
         WORD attached_link;     /* Number of attached link */
diff --git a/drivers/char/rio/list.h b/drivers/char/rio/list.h
index 36aad4c9cb3a..79b853140ae5 100644
--- a/drivers/char/rio/list.h
+++ b/drivers/char/rio/list.h
@@ -44,8 +44,6 @@ static char *_rio_list_h_sccs = "@(#)list.h	1.9";
 
 #define PKT_IN_USE    0x1
 
-#ifdef INKERNEL
-
 #define ZERO_PTR (ushort) 0x8000
 #define CaD     PortP->Caddr
 
@@ -54,143 +52,5 @@ static char *_rio_list_h_sccs = "@(#)list.h	1.9";
 ** to by the TxAdd pointer has PKT_IN_USE clear in its address.
 */
 
-#ifndef linux
-#if defined( MIPS ) && !defined( MIPSEISA )
-/* May the shoes of the Devil dance on your grave for creating this */
-#define   can_add_transmit(PacketP,PortP) \
-          (!((uint)(PacketP = (struct PKT *)RIO_PTR(CaD,RINDW(PortP->TxAdd))) \
-          & (PKT_IN_USE<<2)))
-
-#elif  defined(MIPSEISA) || defined(nx6000) || \
-       defined(drs6000)  || defined(UWsparc)
-
-#define   can_add_transmit(PacketP,PortP) \
-          (!((uint)(PacketP = (struct PKT *)RIO_PTR(CaD,RINDW(PortP->TxAdd))) \
-          & PKT_IN_USE))
-
-#else
-#define   can_add_transmit(PacketP,PortP) \
-          (!((uint)(PacketP = (struct PKT *)RIO_PTR(CaD,*PortP->TxAdd)) \
-          & PKT_IN_USE))
-#endif
-
-/*
-** To add a packet to the queue, you set the PKT_IN_USE bit in the address,
-** and then move the TxAdd pointer along one position to point to the next
-** packet pointer. You must wrap the pointer from the end back to the start.
-*/
-#if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc)
-#   define add_transmit(PortP)  \
-        WINDW(PortP->TxAdd,RINDW(PortP->TxAdd) | PKT_IN_USE);\
-        if (PortP->TxAdd == PortP->TxEnd)\
-            PortP->TxAdd = PortP->TxStart;\
-        else\
-            PortP->TxAdd++;\
-        WWORD(PortP->PhbP->tx_add , RIO_OFF(CaD,PortP->TxAdd));
-#elif defined(AIX)
-#   define add_transmit(PortP)  \
-        {\
-            register ushort *TxAddP = (ushort *)RIO_PTR(Cad,PortP->TxAddO);\
-            WINDW( TxAddP, RINDW( TxAddP ) | PKT_IN_USE );\
-            if (PortP->TxAddO == PortP->TxEndO )\
-                PortP->TxAddO = PortP->TxStartO;\
-            else\
-                PortP->TxAddO += sizeof(ushort);\
-            WWORD(((PHB *)RIO_PTR(Cad,PortP->PhbO))->tx_add , PortP->TxAddO );\
-        }
-#else
-#   define add_transmit(PortP)  \
-        *PortP->TxAdd |= PKT_IN_USE;\
-        if (PortP->TxAdd == PortP->TxEnd)\
-            PortP->TxAdd = PortP->TxStart;\
-        else\
-            PortP->TxAdd++;\
-        PortP->PhbP->tx_add = RIO_OFF(CaD,PortP->TxAdd);
-#endif
-
-/*
-** can_remove_receive( PacketP, PortP ) returns non-zero if PKT_IN_USE is set
-** for the next packet on the queue. It will also set PacketP to point to the
-** relevant packet, [having cleared the PKT_IN_USE bit]. If PKT_IN_USE is clear,
-** then can_remove_receive() returns 0.
-*/
-#if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc)
-#   define can_remove_receive(PacketP,PortP) \
-        ((RINDW(PortP->RxRemove) & PKT_IN_USE) ? \
-        (PacketP=(struct PKT *)RIO_PTR(CaD,(RINDW(PortP->RxRemove) & ~PKT_IN_USE))):0)
-#elif defined(AIX)
-#   define can_remove_receive(PacketP,PortP) \
-        ((RINDW((ushort *)RIO_PTR(Cad,PortP->RxRemoveO)) & PKT_IN_USE) ? \
-        (PacketP=(struct PKT *)RIO_PTR(Cad,RINDW((ushort *)RIO_PTR(Cad,PortP->RxRemoveO)) & ~PKT_IN_USE)):0)
-#else
-#   define can_remove_receive(PacketP,PortP) \
-        ((*PortP->RxRemove & PKT_IN_USE) ? \
-        (PacketP=(struct PKT *)RIO_PTR(CaD,(*PortP->RxRemove & ~PKT_IN_USE))):0)
-#endif
-
-
-/*
-** Will God see it within his heart to forgive us for this thing that
-** we have created? To remove a packet from the receive queue you clear
-** its PKT_IN_USE bit, and then bump the pointers. Once the pointers
-** get to the end, they must be wrapped back to the start.
-*/
-#if defined(MIPS) || defined(nx6000) || defined(drs6000) || defined(UWsparc)
-#   define remove_receive(PortP) \
-        WINDW(PortP->RxRemove, (RINDW(PortP->RxRemove) & ~PKT_IN_USE));\
-        if (PortP->RxRemove == PortP->RxEnd)\
-            PortP->RxRemove = PortP->RxStart;\
-        else\
-            PortP->RxRemove++;\
-        WWORD(PortP->PhbP->rx_remove , RIO_OFF(CaD,PortP->RxRemove));
-#elif defined(AIX)
-#   define remove_receive(PortP) \
-    {\
-        register ushort *RxRemoveP = (ushort *)RIO_PTR(Cad,PortP->RxRemoveO);\
-        WINDW( RxRemoveP, RINDW( RxRemoveP ) & ~PKT_IN_USE );\
-        if (PortP->RxRemoveO == PortP->RxEndO)\
-            PortP->RxRemoveO = PortP->RxStartO;\
-        else\
-            PortP->RxRemoveO += sizeof(ushort);\
-        WWORD(((PHB *)RIO_PTR(Cad,PortP->PhbO))->rx_remove, PortP->RxRemoveO );\
-    }
-#else
-#   define remove_receive(PortP) \
-        *PortP->RxRemove &= ~PKT_IN_USE;\
-        if (PortP->RxRemove == PortP->RxEnd)\
-            PortP->RxRemove = PortP->RxStart;\
-        else\
-            PortP->RxRemove++;\
-        PortP->PhbP->rx_remove = RIO_OFF(CaD,PortP->RxRemove);
-#endif
-#endif
-
-
-#else                           /* !IN_KERNEL */
-
-#define ZERO_PTR NULL
-
-
-#ifdef HOST
-/* #define can_remove_transmit(pkt,phb) ((((char*)pkt = (*(char**)(phb->tx_remove))-1) || 1)) && (*phb->u3.s2.tx_remove_ptr & PKT_IN_USE))   */
-#define remove_transmit(phb) *phb->u3.s2.tx_remove_ptr &= ~(ushort)PKT_IN_USE;\
-                             if (phb->tx_remove == phb->tx_end)\
-                                phb->tx_remove = phb->tx_start;\
-                             else\
-                                phb->tx_remove++;
-#define can_add_receive(phb) !(*phb->u4.s2.rx_add_ptr & PKT_IN_USE)
-#define add_receive(pkt,phb) *phb->rx_add = pkt;\
-                             *phb->u4.s2.rx_add_ptr |= PKT_IN_USE;\
-                             if (phb->rx_add == phb->rx_end)\
-                                phb->rx_add = phb->rx_start;\
-                             else\
-                                phb->rx_add++;
-#endif
-#endif
-
-#ifdef RTA
-#define splx(oldspl)    if ((oldspl) == 0) spl0()
-#endif
-
 #endif                          /* ifndef _list.h */
 /*********** end of file ***********/
diff --git a/drivers/char/rio/parmmap.h b/drivers/char/rio/parmmap.h
index fe4e00567065..e24acc1d1844 100644
--- a/drivers/char/rio/parmmap.h
+++ b/drivers/char/rio/parmmap.h
@@ -78,14 +78,9 @@ struct PARM_MAP {
         WORD idle_count;        /* Idle time counter */
         WORD busy_count;        /* Busy counter */
         WORD idle_control;      /* Control Idle Process */
-#if defined(HOST) || defined(INKERNEL)
         WORD tx_intr;           /* TX interrupt pending */
         WORD rx_intr;           /* RX interrupt pending */
         WORD rup_intr;          /* RUP interrupt pending */
-#endif
-#if defined(RTA)
-        WORD dying_count;       /* Count of processes dead */
-#endif
 };
 
 #endif
diff --git a/drivers/char/rio/phb.h b/drivers/char/rio/phb.h
index 3baebf8513af..2663ca0306e2 100644
--- a/drivers/char/rio/phb.h
+++ b/drivers/char/rio/phb.h
@@ -44,17 +44,6 @@
 #endif
 
 
- /*************************************************
-  * Set the LIMIT values.
-  ************************************************/
-#ifdef RTA
-#define RX_LIMIT       (ushort) 3
-#endif
-#ifdef HOST
-#define RX_LIMIT       (ushort) 1
-#endif
-
-
 /*************************************************
  * Handshake asserted. Deasserted by the LTT(s)
  ************************************************/
@@ -69,11 +58,7 @@
 /*************************************************
  * Maximum number of PHB's
  ************************************************/
-#if defined (HOST) || defined (INKERNEL)
 #define MAX_PHB               ((ushort) 128)    /* range 0-127 */
-#else
-#define MAX_PHB               ((ushort) 8)      /* range 0-7 */
-#endif
 
 /*************************************************
  * Defines for the mode fields
@@ -139,141 +124,23 @@
  * the start. The pointer tx_add points to a SPACE to put a Packet.
  * The pointer tx_remove points to the next Packet to remove
  *************************************************************************/
-#ifndef INKERNEL
-#define src_unit     u2.s2.unit
-#define src_port     u2.s2.port
-#define dest_unit    u1.s1.unit
-#define dest_port    u1.s1.port
-#endif
-#ifdef HOST
-#define tx_start     u3.s1.tx_start_ptr_ptr
-#define tx_add       u3.s1.tx_add_ptr_ptr
-#define tx_end       u3.s1.tx_end_ptr_ptr
-#define tx_remove    u3.s1.tx_remove_ptr_ptr
-#define rx_start     u4.s1.rx_start_ptr_ptr
-#define rx_add       u4.s1.rx_add_ptr_ptr
-#define rx_end       u4.s1.rx_end_ptr_ptr
-#define rx_remove    u4.s1.rx_remove_ptr_ptr
-#endif
 typedef struct PHB PHB;
 struct PHB {
-#ifdef RTA
-        ushort port;
-#endif
-#ifdef INKERNEL
         WORD source;
-#else
-        union {
-                ushort source;  /* Complete source */
-                struct {
-                        unsigned char unit;     /* Source unit */
-                        unsigned char port;     /* Source port */
-                } s2;
-        } u2;
-#endif
         WORD handshake;
         WORD status;
         NUMBER timeout;         /* Maximum of 1.9 seconds */
         WORD link;              /* Send down this link */
-#ifdef INKERNEL
         WORD destination;
-#else
-        union {
-                ushort destination;     /* Complete destination */
-                struct {
-                        unsigned char unit;     /* Destination unit */
-                        unsigned char port;     /* Destination port */
-                } s1;
-        } u1;
-#endif
-#ifdef RTA
-        ushort tx_pkts_added;
-        ushort tx_pkts_removed;
-        Q_BUF_ptr tx_q_start;   /* Start of the Q list chain */
-        short num_tx_q_bufs;    /* Number of Q buffers in the chain */
-        PKT_ptr_ptr tx_add;     /* Add a new Packet here */
-        Q_BUF_ptr tx_add_qb;    /* Pointer to the add Q buf */
-        PKT_ptr_ptr tx_add_st_qbb;      /* Pointer to start of the Q's buf */
-        PKT_ptr_ptr tx_add_end_qbb;     /* Pointer to the end of the Q's buf */
-        PKT_ptr_ptr tx_remove;  /* Remove a Packet here */
-        Q_BUF_ptr tx_remove_qb; /* Pointer to the remove Q buf */
-        PKT_ptr_ptr tx_remove_st_qbb;   /* Pointer to the start of the Q buf */
-        PKT_ptr_ptr tx_remove_end_qbb;  /* Pointer to the end of the Q buf */
-#endif
-#ifdef INKERNEL
         PKT_ptr_ptr tx_start;
         PKT_ptr_ptr tx_end;
         PKT_ptr_ptr tx_add;
         PKT_ptr_ptr tx_remove;
-#endif
-#ifdef HOST
-        union {
-                struct {
-                        PKT_ptr_ptr tx_start_ptr_ptr;
-                        PKT_ptr_ptr tx_end_ptr_ptr;
-                        PKT_ptr_ptr tx_add_ptr_ptr;
-                        PKT_ptr_ptr tx_remove_ptr_ptr;
-                } s1;
-                struct {
-                        ushort *tx_start_ptr;
-                        ushort *tx_end_ptr;
-                        ushort *tx_add_ptr;
-                        ushort *tx_remove_ptr;
-                } s2;
-        } u3;
-#endif
 
-#ifdef  RTA
-        ushort rx_pkts_added;
-        ushort rx_pkts_removed;
-        Q_BUF_ptr rx_q_start;   /* Start of the Q list chain */
-        short num_rx_q_bufs;    /* Number of Q buffers in the chain */
-        PKT_ptr_ptr rx_add;     /* Add a new Packet here */
-        Q_BUF_ptr rx_add_qb;    /* Pointer to the add Q buf */
-        PKT_ptr_ptr rx_add_st_qbb;      /* Pointer to start of the Q's buf */
-        PKT_ptr_ptr rx_add_end_qbb;     /* Pointer to the end of the Q's buf */
-        PKT_ptr_ptr rx_remove;  /* Remove a Packet here */
-        Q_BUF_ptr rx_remove_qb; /* Pointer to the remove Q buf */
-        PKT_ptr_ptr rx_remove_st_qbb;   /* Pointer to the start of the Q buf */
-        PKT_ptr_ptr rx_remove_end_qbb;  /* Pointer to the end of the Q buf */
-#endif
-#ifdef INKERNEL
         PKT_ptr_ptr rx_start;
         PKT_ptr_ptr rx_end;
         PKT_ptr_ptr rx_add;
         PKT_ptr_ptr rx_remove;
-#endif
-#ifdef HOST
-        union {
-                struct {
-                        PKT_ptr_ptr rx_start_ptr_ptr;
-                        PKT_ptr_ptr rx_end_ptr_ptr;
-                        PKT_ptr_ptr rx_add_ptr_ptr;
-                        PKT_ptr_ptr rx_remove_ptr_ptr;
-                } s1;
-                struct {
-                        ushort *rx_start_ptr;
-                        ushort *rx_end_ptr;
-                        ushort *rx_add_ptr;
-                        ushort *rx_remove_ptr;
-                } s2;
-        } u4;
-#endif
-
-#ifdef RTA                      /* some fields for the remotes */
-        ushort flush_count;     /* Count of write flushes */
-        ushort txmode;          /* Modes for tx */
-        ushort rxmode;          /* Modes for rx */
-        ushort portmode;        /* Generic modes */
-        ushort column;          /* TAB3 column count */
-        ushort tx_subscript;    /* (TX) Subscript into data field */
-        ushort rx_subscript;    /* (RX) Subscript into data field */
-        PKT_ptr rx_incomplete;  /* Hold an incomplete packet here */
-        ushort modem_bits;      /* Modem bits to mask */
-        ushort lastModem;       /* Modem control lines. */
-        ushort addr;            /* Address for sub commands */
-        ushort MonitorTstate;   /* TRUE if monitoring tstop */
-#endif
 
 };
 
diff --git a/drivers/char/rio/pkt.h b/drivers/char/rio/pkt.h
index 882fd429ac2e..7011e52e82db 100644
--- a/drivers/char/rio/pkt.h
+++ b/drivers/char/rio/pkt.h
@@ -70,39 +70,12 @@
 #define CONTROL_DATA_WNDW  (DATA_WNDW << 8)
 
 struct PKT {
-#ifdef INKERNEL
         BYTE dest_unit;         /* Destination Unit Id */
         BYTE dest_port;         /* Destination POrt */
         BYTE src_unit;          /* Source Unit Id */
         BYTE src_port;          /* Source POrt */
-#else
-        union {
-                ushort destination;     /* Complete destination */
-                struct {
-                        unsigned char unit;     /* Destination unit */
-                        unsigned char port;     /* Destination port */
-                } s1;
-        } u1;
-        union {
-                ushort source;  /* Complete source */
-                struct {
-                        unsigned char unit;     /* Source unit */
-                        unsigned char port;     /* Source port */
-                } s2;
-        } u2;
-#endif
-#ifdef INKERNEL
         BYTE len;
         BYTE control;
-#else
-        union {
-                ushort control;
-                struct {
-                        unsigned char len;
-                        unsigned char control;
-                } s3;
-        } u3;
-#endif
         BYTE data[PKT_MAX_DATA_LEN];
         /* Actual data :-) */
         WORD csum;              /* C-SUM */
diff --git a/drivers/char/rio/qbuf.h b/drivers/char/rio/qbuf.h
index acd9e8e5307d..391ffc335535 100644
--- a/drivers/char/rio/qbuf.h
+++ b/drivers/char/rio/qbuf.h
@@ -46,11 +46,7 @@ static char *_rio_qbuf_h_sccs = "@(#)qbuf.h	1.1";
 
 
 
-#ifdef HOST
-#define PKTS_PER_BUFFER    1
-#else
 #define PKTS_PER_BUFFER    (220 / PKT_LENGTH)
-#endif
 
 typedef struct Q_BUF Q_BUF;
 struct Q_BUF {
diff --git a/drivers/char/rio/riotypes.h b/drivers/char/rio/riotypes.h
index 9b67e2468bec..46084d5c7e98 100644
--- a/drivers/char/rio/riotypes.h
+++ b/drivers/char/rio/riotypes.h
@@ -43,9 +43,6 @@
 #endif
 #endif
 
-#ifdef INKERNEL
-
-#if !defined(MIPSAT)
 typedef unsigned short NUMBER_ptr;
 typedef unsigned short WORD_ptr;
 typedef unsigned short BYTE_ptr;
@@ -65,69 +62,6 @@ typedef unsigned short RUP_ptr;
 typedef unsigned short short_ptr;
 typedef unsigned short u_short_ptr;
 typedef unsigned short ushort_ptr;
-#else
-/* MIPSAT types */
-typedef char RIO_POINTER[8];
-typedef RIO_POINTER NUMBER_ptr;
-typedef RIO_POINTER WORD_ptr;
-typedef RIO_POINTER BYTE_ptr;
-typedef RIO_POINTER char_ptr;
-typedef RIO_POINTER Channel_ptr;
-typedef RIO_POINTER FREE_LIST_ptr_ptr;
-typedef RIO_POINTER FREE_LIST_ptr;
-typedef RIO_POINTER LPB_ptr;
-typedef RIO_POINTER Process_ptr;
-typedef RIO_POINTER PHB_ptr;
-typedef RIO_POINTER PKT_ptr;
-typedef RIO_POINTER PKT_ptr_ptr;
-typedef RIO_POINTER Q_BUF_ptr;
-typedef RIO_POINTER Q_BUF_ptr_ptr;
-typedef RIO_POINTER ROUTE_STR_ptr;
-typedef RIO_POINTER RUP_ptr;
-typedef RIO_POINTER short_ptr;
-typedef RIO_POINTER u_short_ptr;
-typedef RIO_POINTER ushort_ptr;
-#endif
-
-#else                           /* not INKERNEL */
-typedef unsigned char BYTE;
-typedef unsigned short WORD;
-typedef unsigned long DWORD;
-typedef short NUMBER;
-typedef short *NUMBER_ptr;
-typedef unsigned short *WORD_ptr;
-typedef unsigned char *BYTE_ptr;
-typedef unsigned char uchar;
-typedef unsigned short ushort;
-typedef unsigned int uint;
-typedef unsigned long ulong;
-typedef unsigned char u_char;
-typedef unsigned short u_short;
-typedef unsigned int u_int;
-typedef unsigned long u_long;
-typedef unsigned short ERROR;
-typedef unsigned long ID;
-typedef char *char_ptr;
-typedef Channel *Channel_ptr;
-typedef struct FREE_LIST *FREE_LIST_ptr;
-typedef struct FREE_LIST **FREE_LIST_ptr_ptr;
-typedef struct LPB *LPB_ptr;
-typedef struct Process *Process_ptr;
-typedef struct PHB *PHB_ptr;
-typedef struct PKT *PKT_ptr;
-typedef struct PKT **PKT_ptr_ptr;
-typedef struct Q_BUF *Q_BUF_ptr;
-typedef struct Q_BUF **Q_BUF_ptr_ptr;
-typedef struct ROUTE_STR *ROUTE_STR_ptr;
-typedef struct RUP *RUP_ptr;
-typedef short *short_ptr;
-typedef u_short *u_short_ptr;
-typedef ushort *ushort_ptr;
-typedef struct PKT PKT;
-typedef struct LPB LPB;
-typedef struct RUP RUP;
-#endif
-
 
 #endif                          /* __riotypes__ */
 
diff --git a/drivers/char/rio/rup.h b/drivers/char/rio/rup.h
index 8d44fec91dd5..f74f67c6f702 100644
--- a/drivers/char/rio/rup.h
+++ b/drivers/char/rio/rup.h
@@ -43,12 +43,7 @@
 #endif
 #endif
 
-#if defined( HOST ) || defined( INKERNEL )
 #define MAX_RUP          ((short) 16)
-#endif
-#ifdef RTA
-#define MAX_RUP          ((short) 1)
-#endif
 
 #define PKTS_PER_RUP     ((short) 2)    /* They are always used in pairs */
 
diff --git a/drivers/char/rio/sam.h b/drivers/char/rio/sam.h
index 31494054b213..6f754e19015d 100644
--- a/drivers/char/rio/sam.h
+++ b/drivers/char/rio/sam.h
@@ -43,10 +43,6 @@
 #endif
 
 
-#if !defined( HOST ) && !defined( INKERNEL )
-#define RTA 1
-#endif
-
 #define NUM_FREE_LIST_UNITS     500
 
 #ifndef FALSE
diff --git a/drivers/char/rocket.c b/drivers/char/rocket.c
index 0949dcef0697..7edc6a4dbdc4 100644
--- a/drivers/char/rocket.c
+++ b/drivers/char/rocket.c
@@ -433,7 +433,7 @@ static void rp_do_receive(struct r_port *info,
                 count += ToRecv;
         }
         /*  Push the data up to the tty layer */
-        ld->receive_buf(tty, cbuf, fbuf, count);
+        ld->receive_buf(tty, chead, fhead, count);
 done:
         tty_ldisc_deref(ld);
 }
diff --git a/drivers/char/ser_a2232.c b/drivers/char/ser_a2232.c
index 80a5b840e22f..fee68cc895f8 100644
--- a/drivers/char/ser_a2232.c
+++ b/drivers/char/ser_a2232.c
@@ -103,6 +103,7 @@
 
 #include <linux/serial.h>
 #include <linux/generic_serial.h>
+#include <linux/tty_flip.h>
 
 #include "ser_a2232.h"
 #include "ser_a2232fw.h"
diff --git a/drivers/char/sx.c b/drivers/char/sx.c
index 64bf89cb574f..c2490e270f1f 100644
--- a/drivers/char/sx.c
+++ b/drivers/char/sx.c
@@ -931,7 +931,7 @@ static int sx_set_real_termios (void *ptr)
         case CS6:sx_write_channel_byte (port, hi_mask, 0x3f);break;
         case CS5:sx_write_channel_byte (port, hi_mask, 0x1f);break;
         default:
-                printk (KERN_INFO "sx: Invalid wordsize: %d\n", CFLAG & CSIZE);
+                printk (KERN_INFO "sx: Invalid wordsize: %u\n", CFLAG & CSIZE);
                 break;
         }
 
@@ -958,7 +958,7 @@ static int sx_set_real_termios (void *ptr)
         } else {
                 set_bit(TTY_HW_COOK_IN, &port->gs.tty->flags);
         }
-        sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ", 
+        sx_dprintk (SX_DEBUG_TERMIOS, "iflags: %x(%d) ",
                     port->gs.tty->termios->c_iflag, 
                     I_OTHER(port->gs.tty));
 
@@ -973,7 +973,7 @@ static int sx_set_real_termios (void *ptr)
         } else {
                 clear_bit(TTY_HW_COOK_OUT, &port->gs.tty->flags);
         }
-        sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n", 
+        sx_dprintk (SX_DEBUG_TERMIOS, "oflags: %x(%d)\n",
                     port->gs.tty->termios->c_oflag, 
                     O_OTHER(port->gs.tty));
         /* port->c_dcd = sx_get_CD (port); */
diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index eb8b5be4e249..076e07c1da38 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -253,6 +253,7 @@ static void tty_buffer_free_all(struct tty_struct *tty)
 
 static void tty_buffer_init(struct tty_struct *tty)
 {
+        spin_lock_init(&tty->buf.lock);
         tty->buf.head = NULL;
         tty->buf.tail = NULL;
         tty->buf.free = NULL;
@@ -266,6 +267,7 @@ static struct tty_buffer *tty_buffer_alloc(size_t size)
         p->used = 0;
         p->size = size;
         p->next = NULL;
+        p->active = 0;
         p->char_buf_ptr = (char *)(p->data);
         p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
 /*      printk("Flip create %p\n", p); */
@@ -312,25 +314,36 @@ static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
 
 int tty_buffer_request_room(struct tty_struct *tty, size_t size)
 {
-        struct tty_buffer *b = tty->buf.tail, *n;
-        int left = 0;
+        struct tty_buffer *b, *n;
+        int left;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tty->buf.lock, flags);
 
         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
            remove this conditional if its worth it. This would be invisible
            to the callers */
-        if(b != NULL)
+        if ((b = tty->buf.tail) != NULL) {
                 left = b->size - b->used;
-        if(left >= size)
-                return size;
-        /* This is the slow path - looking for new buffers to use */
-        n = tty_buffer_find(tty, size);
-        if(n == NULL)
-                return left;
-        if(b != NULL)
-                b->next = n;
-        else
-                tty->buf.head = n;
-        tty->buf.tail = n;
+                b->active = 1;
+        } else
+                left = 0;
+
+        if (left < size) {
+                /* This is the slow path - looking for new buffers to use */
+                if ((n = tty_buffer_find(tty, size)) != NULL) {
+                        if (b != NULL) {
+                                b->next = n;
+                                b->active = 0;
+                        } else
+                                tty->buf.head = n;
+                        tty->buf.tail = n;
+                        n->active = 1;
+                } else
+                        size = left;
+        }
+
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
         return size;
 }
 
@@ -396,10 +409,12 @@ EXPORT_SYMBOL_GPL(tty_insert_flip_string_flags);
 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
 {
         int space = tty_buffer_request_room(tty, size);
-        struct tty_buffer *tb = tty->buf.tail;
-        *chars = tb->char_buf_ptr + tb->used;
-        memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
-        tb->used += space;
+        if (likely(space)) {
+                struct tty_buffer *tb = tty->buf.tail;
+                *chars = tb->char_buf_ptr + tb->used;
+                memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
+                tb->used += space;
+        }
         return space;
 }
 
@@ -416,10 +431,12 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
 int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size)
 {
         int space = tty_buffer_request_room(tty, size);
-        struct tty_buffer *tb = tty->buf.tail;
-        *chars = tb->char_buf_ptr + tb->used;
-        *flags = tb->flag_buf_ptr + tb->used;
-        tb->used += space;
+        if (likely(space)) {
+                struct tty_buffer *tb = tty->buf.tail;
+                *chars = tb->char_buf_ptr + tb->used;
+                *flags = tb->flag_buf_ptr + tb->used;
+                tb->used += space;
+        }
         return space;
 }
 
@@ -2747,20 +2764,20 @@ static void flush_to_ldisc(void *private_)
                 schedule_delayed_work(&tty->buf.work, 1);
                 goto out;
         }
-        spin_lock_irqsave(&tty->read_lock, flags);
-        while((tbuf = tty->buf.head) != NULL) {
+        spin_lock_irqsave(&tty->buf.lock, flags);
+        while((tbuf = tty->buf.head) != NULL && !tbuf->active) {
                 tty->buf.head = tbuf->next;
                 if (tty->buf.head == NULL)
                         tty->buf.tail = NULL;
-                spin_unlock_irqrestore(&tty->read_lock, flags);
+                spin_unlock_irqrestore(&tty->buf.lock, flags);
                 /* printk("Process buffer %p for %d\n", tbuf, tbuf->used); */
                 disc->receive_buf(tty, tbuf->char_buf_ptr,
                                        tbuf->flag_buf_ptr,
                                        tbuf->used);
-                spin_lock_irqsave(&tty->read_lock, flags);
+                spin_lock_irqsave(&tty->buf.lock, flags);
                 tty_buffer_free(tty, tbuf);
         }
-        spin_unlock_irqrestore(&tty->read_lock, flags);
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
 out:
         tty_ldisc_deref(disc);
 }
@@ -2852,6 +2869,12 @@ EXPORT_SYMBOL(tty_get_baud_rate);
 
 void tty_flip_buffer_push(struct tty_struct *tty)
 {
+        unsigned long flags;
+        spin_lock_irqsave(&tty->buf.lock, flags);
+        if (tty->buf.tail != NULL)
+                tty->buf.tail->active = 0;
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
+
         if (tty->low_latency)
                 flush_to_ldisc((void *) tty);
         else
diff --git a/drivers/char/watchdog/sbc_epx_c3.c b/drivers/char/watchdog/sbc_epx_c3.c
index 951764614ebf..837b1ec3ffe3 100644
--- a/drivers/char/watchdog/sbc_epx_c3.c
+++ b/drivers/char/watchdog/sbc_epx_c3.c
@@ -25,6 +25,7 @@
 #include <linux/notifier.h>
 #include <linux/reboot.h>
 #include <linux/init.h>
+#include <linux/ioport.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
@@ -91,7 +92,7 @@ static int epx_c3_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-static ssize_t epx_c3_write(struct file *file, const char *data,
+static ssize_t epx_c3_write(struct file *file, const char __user *data,
                         size_t len, loff_t *ppos)
 {
         /* Refresh the timer. */
@@ -104,6 +105,7 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
                         unsigned int cmd, unsigned long arg)
 {
         int options, retval = -EINVAL;
+        int __user *argp = (void __user *)arg;
         static struct watchdog_info ident = {
                 .options                = WDIOF_KEEPALIVEPING |
                                           WDIOF_MAGICCLOSE,
@@ -113,20 +115,19 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
-                if (copy_to_user((struct watchdog_info *)arg,
-                                 &ident, sizeof(ident)))
+                if (copy_to_user(argp, &ident, sizeof(ident)))
                         return -EFAULT;
                 return 0;
         case WDIOC_GETSTATUS:
         case WDIOC_GETBOOTSTATUS:
-                return put_user(0,(int *)arg);
+                return put_user(0, argp);
         case WDIOC_KEEPALIVE:
                 epx_c3_pet();
                 return 0;
         case WDIOC_GETTIMEOUT:
-                return put_user(WATCHDOG_TIMEOUT,(int *)arg);
-        case WDIOC_SETOPTIONS: {
-                if (get_user(options, (int *)arg))
+                return put_user(WATCHDOG_TIMEOUT, argp);
+        case WDIOC_SETOPTIONS:
+                if (get_user(options, argp))
                         return -EFAULT;
 
                 if (options & WDIOS_DISABLECARD) {
@@ -140,7 +141,6 @@ static int epx_c3_ioctl(struct inode *inode, struct file *file,
                 }
 
                 return retval;
-        }
         default:
                 return -ENOIOCTLCMD;
         }
@@ -181,11 +181,14 @@ static int __init watchdog_init(void)
 {
         int ret;
 
+        if (!request_region(EPXC3_WATCHDOG_CTL_REG, 2, "epxc3_watchdog"))
+                return -EBUSY;
+
         ret = register_reboot_notifier(&epx_c3_notifier);
         if (ret) {
                 printk(KERN_ERR PFX "cannot register reboot notifier "
                         "(err=%d)\n", ret);
-                return ret;
+                goto out;
         }
 
         ret = misc_register(&epx_c3_miscdev);
@@ -193,18 +196,23 @@ static int __init watchdog_init(void)
                 printk(KERN_ERR PFX "cannot register miscdev on minor=%d "
                         "(err=%d)\n", WATCHDOG_MINOR, ret);
                 unregister_reboot_notifier(&epx_c3_notifier);
-                return ret;
+                goto out;
         }
 
         printk(banner);
 
         return 0;
+
+out:
+        release_region(EPXC3_WATCHDOG_CTL_REG, 2);
+        return ret;
 }
 
 static void __exit watchdog_exit(void)
 {
         misc_deregister(&epx_c3_miscdev);
         unregister_reboot_notifier(&epx_c3_notifier);
+        release_region(EPXC3_WATCHDOG_CTL_REG, 2);
 }
 
 module_init(watchdog_init);
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index 4819e7fc00dd..18a455651121 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -11,7 +11,6 @@ menu 'EDAC - error detection and reporting (RAS)'
 config EDAC
         tristate "EDAC core system error reporting"
         depends on X86
-        default y
         help
           EDAC is designed to report errors in the core system.
           These are low-level errors that are reported in the CPU or
@@ -46,7 +45,7 @@ config EDAC_MM_EDAC
 
 config EDAC_AMD76X
         tristate "AMD 76x (760, 762, 768)"
-        depends on EDAC_MM_EDAC  && PCI
+        depends on EDAC_MM_EDAC && PCI && X86_32
         help
           Support for error detection and correction on the AMD 76x
           series of chipsets used with the Athlon processor.
diff --git a/drivers/edac/e752x_edac.c b/drivers/edac/e752x_edac.c
index 770a5a633079..c454ded2b060 100644
--- a/drivers/edac/e752x_edac.c
+++ b/drivers/edac/e752x_edac.c
@@ -1039,10 +1039,10 @@ MODULE_DEVICE_TABLE(pci, e752x_pci_tbl);
 
 
 static struct pci_driver e752x_driver = {
-      name: BS_MOD_STR,
-      probe: e752x_init_one,
-      remove: __devexit_p(e752x_remove_one),
-      id_table: e752x_pci_tbl,
+        .name = BS_MOD_STR,
+        .probe = e752x_init_one,
+        .remove = __devexit_p(e752x_remove_one),
+        .id_table = e752x_pci_tbl,
 };
 
 
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index 4be9bd0a1267..b10ee4698b1d 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -14,7 +14,6 @@
 
 
 #include <linux/config.h>
-#include <linux/version.h>
 #include <linux/module.h>
 #include <linux/proc_fs.h>
 #include <linux/kernel.h>
diff --git a/drivers/edac/i82875p_edac.c b/drivers/edac/i82875p_edac.c
index 009c08fe5d69..1991f94af753 100644
--- a/drivers/edac/i82875p_edac.c
+++ b/drivers/edac/i82875p_edac.c
@@ -159,7 +159,7 @@ enum i82875p_chips {
 
 struct i82875p_pvt {
         struct pci_dev *ovrfl_pdev;
-        void *ovrfl_window;
+        void __iomem *ovrfl_window;
 };
 
 
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index c58295914365..7230d4e08196 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -113,6 +113,16 @@ config SENSORS_DS1621
           This driver can also be built as a module.  If so, the module
           will be called ds1621.
 
+config SENSORS_F71805F
+        tristate "Fintek F71805F/FG"
+        depends on HWMON && EXPERIMENTAL
+        help
+          If you say yes here you get support for hardware monitoring
+          features of the Fintek F71805F/FG chips.
+
+          This driver can also be built as a module.  If so, the module
+          will be called f71805f.
+
 config SENSORS_FSCHER
         tristate "FSC Hermes"
         depends on HWMON && I2C && EXPERIMENTAL
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 06d4a1d14105..fbdb8d911a72 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -18,6 +18,7 @@ obj-$(CONFIG_SENSORS_ADM1031)	+= adm1031.o
 obj-$(CONFIG_SENSORS_ADM9240)   += adm9240.o
 obj-$(CONFIG_SENSORS_ATXP1)     += atxp1.o
 obj-$(CONFIG_SENSORS_DS1621)    += ds1621.o
+obj-$(CONFIG_SENSORS_F71805F)   += f71805f.o
 obj-$(CONFIG_SENSORS_FSCHER)    += fscher.o
 obj-$(CONFIG_SENSORS_FSCPOS)    += fscpos.o
 obj-$(CONFIG_SENSORS_GL518SM)   += gl518sm.o
diff --git a/drivers/hwmon/f71805f.c b/drivers/hwmon/f71805f.c
new file mode 100644
index 000000000000..e029e0a94ecc
--- /dev/null
+++ b/drivers/hwmon/f71805f.c
@@ -0,0 +1,908 @@
+/*
+ * f71805f.c - driver for the Fintek F71805F/FG Super-I/O chip integrated
+ *             hardware monitoring features
+ * Copyright (C) 2005  Jean Delvare <khali@linux-fr.org>
+ *
+ * The F71805F/FG is a LPC Super-I/O chip made by Fintek. It integrates
+ * complete hardware monitoring features: voltage, fan and temperature
+ * sensors, and manual and automatic fan speed control.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/jiffies.h>
+#include <linux/platform_device.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+#include <asm/io.h>
+
+static struct platform_device *pdev;
+
+#define DRVNAME "f71805f"
+
+/*
+ * Super-I/O constants and functions
+ */
+
+#define F71805F_LD_HWM          0x04
+
+#define SIO_REG_LDSEL           0x07    /* Logical device select */
+#define SIO_REG_DEVID           0x20    /* Device ID (2 bytes) */
+#define SIO_REG_DEVREV          0x22    /* Device revision */
+#define SIO_REG_MANID           0x23    /* Fintek ID (2 bytes) */
+#define SIO_REG_ENABLE          0x30    /* Logical device enable */
+#define SIO_REG_ADDR            0x60    /* Logical device address (2 bytes) */
+
+#define SIO_FINTEK_ID           0x1934
+#define SIO_F71805F_ID          0x0406
+
+static inline int
+superio_inb(int base, int reg)
+{
+        outb(reg, base);
+        return inb(base + 1);
+}
+
+static int
+superio_inw(int base, int reg)
+{
+        int val;
+        outb(reg++, base);
+        val = inb(base + 1) << 8;
+        outb(reg, base);
+        val |= inb(base + 1);
+        return val;
+}
+
+static inline void
+superio_select(int base, int ld)
+{
+        outb(SIO_REG_LDSEL, base);
+        outb(ld, base + 1);
+}
+
+static inline void
+superio_enter(int base)
+{
+        outb(0x87, base);
+        outb(0x87, base);
+}
+
+static inline void
+superio_exit(int base)
+{
+        outb(0xaa, base);
+}
+
+/*
+ * ISA constants
+ */
+
+#define REGION_LENGTH           2
+#define ADDR_REG_OFFSET         0
+#define DATA_REG_OFFSET         1
+
+static struct resource f71805f_resource __initdata = {
+        .flags  = IORESOURCE_IO,
+};
+
+/*
+ * Registers
+ */
+
+/* in nr from 0 to 8 (8-bit values) */
+#define F71805F_REG_IN(nr)              (0x10 + (nr))
+#define F71805F_REG_IN_HIGH(nr)         (0x40 + 2 * (nr))
+#define F71805F_REG_IN_LOW(nr)          (0x41 + 2 * (nr))
+/* fan nr from 0 to 2 (12-bit values, two registers) */
+#define F71805F_REG_FAN(nr)             (0x20 + 2 * (nr))
+#define F71805F_REG_FAN_LOW(nr)         (0x28 + 2 * (nr))
+#define F71805F_REG_FAN_CTRL(nr)        (0x60 + 16 * (nr))
+/* temp nr from 0 to 2 (8-bit values) */
+#define F71805F_REG_TEMP(nr)            (0x1B + (nr))
+#define F71805F_REG_TEMP_HIGH(nr)       (0x54 + 2 * (nr))
+#define F71805F_REG_TEMP_HYST(nr)       (0x55 + 2 * (nr))
+#define F71805F_REG_TEMP_MODE           0x01
+
+#define F71805F_REG_START               0x00
+/* status nr from 0 to 2 */
+#define F71805F_REG_STATUS(nr)          (0x36 + (nr))
+
+/*
+ * Data structures and manipulation thereof
+ */
+
+struct f71805f_data {
+        unsigned short addr;
+        const char *name;
+        struct semaphore lock;
+        struct class_device *class_dev;
+
+        struct semaphore update_lock;
+        char valid;             /* !=0 if following fields are valid */
+        unsigned long last_updated;     /* In jiffies */
+        unsigned long last_limits;      /* In jiffies */
+
+        /* Register values */
+        u8 in[9];
+        u8 in_high[9];
+        u8 in_low[9];
+        u16 fan[3];
+        u16 fan_low[3];
+        u8 fan_enabled;         /* Read once at init time */
+        u8 temp[3];
+        u8 temp_high[3];
+        u8 temp_hyst[3];
+        u8 temp_mode;
+        u8 alarms[3];
+};
+
+static inline long in_from_reg(u8 reg)
+{
+        return (reg * 8);
+}
+
+/* The 2 least significant bits are not used */
+static inline u8 in_to_reg(long val)
+{
+        if (val <= 0)
+                return 0;
+        if (val >= 2016)
+                return 0xfc;
+        return (((val + 16) / 32) << 2);
+}
+
+/* in0 is downscaled by a factor 2 internally */
+static inline long in0_from_reg(u8 reg)
+{
+        return (reg * 16);
+}
+
+static inline u8 in0_to_reg(long val)
+{
+        if (val <= 0)
+                return 0;
+        if (val >= 4032)
+                return 0xfc;
+        return (((val + 32) / 64) << 2);
+}
+
+/* The 4 most significant bits are not used */
+static inline long fan_from_reg(u16 reg)
+{
+        reg &= 0xfff;
+        if (!reg || reg == 0xfff)
+                return 0;
+        return (1500000 / reg);
+}
+
+static inline u16 fan_to_reg(long rpm)
+{
+        /* If the low limit is set below what the chip can measure,
+           store the largest possible 12-bit value in the registers,
+           so that no alarm will ever trigger. */
+        if (rpm < 367)
+                return 0xfff;
+        return (1500000 / rpm);
+}
+
+static inline long temp_from_reg(u8 reg)
+{
+        return (reg * 1000);
+}
+
+static inline u8 temp_to_reg(long val)
+{
+        if (val < 0)
+                val = 0;
+        else if (val > 1000 * 0xff)
+                val = 0xff;
+        return ((val + 500) / 1000);
+}
+
+/*
+ * Device I/O access
+ */
+
+static u8 f71805f_read8(struct f71805f_data *data, u8 reg)
+{
+        u8 val;
+
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        val = inb(data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+
+        return val;
+}
+
+static void f71805f_write8(struct f71805f_data *data, u8 reg, u8 val)
+{
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        outb(val, data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+}
+
+/* It is important to read the MSB first, because doing so latches the
+   value of the LSB, so we are sure both bytes belong to the same value. */
+static u16 f71805f_read16(struct f71805f_data *data, u8 reg)
+{
+        u16 val;
+
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        val = inb(data->addr + DATA_REG_OFFSET) << 8;
+        outb(++reg, data->addr + ADDR_REG_OFFSET);
+        val |= inb(data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+
+        return val;
+}
+
+static void f71805f_write16(struct f71805f_data *data, u8 reg, u16 val)
+{
+        down(&data->lock);
+        outb(reg, data->addr + ADDR_REG_OFFSET);
+        outb(val >> 8, data->addr + DATA_REG_OFFSET);
+        outb(++reg, data->addr + ADDR_REG_OFFSET);
+        outb(val & 0xff, data->addr + DATA_REG_OFFSET);
+        up(&data->lock);
+}
+
+static struct f71805f_data *f71805f_update_device(struct device *dev)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        int nr;
+
+        down(&data->update_lock);
+
+        /* Limit registers cache is refreshed after 60 seconds */
+        if (time_after(jiffies, data->last_updated + 60 * HZ)
+         || !data->valid) {
+                for (nr = 0; nr < 9; nr++) {
+                        data->in_high[nr] = f71805f_read8(data,
+                                            F71805F_REG_IN_HIGH(nr));
+                        data->in_low[nr] = f71805f_read8(data,
+                                           F71805F_REG_IN_LOW(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        if (data->fan_enabled & (1 << nr))
+                                data->fan_low[nr] = f71805f_read16(data,
+                                                    F71805F_REG_FAN_LOW(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        data->temp_high[nr] = f71805f_read8(data,
+                                              F71805F_REG_TEMP_HIGH(nr));
+                        data->temp_hyst[nr] = f71805f_read8(data,
+                                              F71805F_REG_TEMP_HYST(nr));
+                }
+                data->temp_mode = f71805f_read8(data, F71805F_REG_TEMP_MODE);
+
+                data->last_limits = jiffies;
+        }
+
+        /* Measurement registers cache is refreshed after 1 second */
+        if (time_after(jiffies, data->last_updated + HZ)
+         || !data->valid) {
+                for (nr = 0; nr < 9; nr++) {
+                        data->in[nr] = f71805f_read8(data,
+                                       F71805F_REG_IN(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        if (data->fan_enabled & (1 << nr))
+                                data->fan[nr] = f71805f_read16(data,
+                                                F71805F_REG_FAN(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        data->temp[nr] = f71805f_read8(data,
+                                         F71805F_REG_TEMP(nr));
+                }
+                for (nr = 0; nr < 3; nr++) {
+                        data->alarms[nr] = f71805f_read8(data,
+                                           F71805F_REG_STATUS(nr));
+                }
+
+                data->last_updated = jiffies;
+                data->valid = 1;
+        }
+
+        up(&data->update_lock);
+
+        return data;
+}
+
+/*
+ * Sysfs interface
+ */
+
+static ssize_t show_in0(struct device *dev, struct device_attribute *devattr,
+                        char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+
+        return sprintf(buf, "%ld\n", in0_from_reg(data->in[0]));
+}
+
+static ssize_t show_in0_max(struct device *dev, struct device_attribute
+                            *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+
+        return sprintf(buf, "%ld\n", in0_from_reg(data->in_high[0]));
+}
+
+static ssize_t show_in0_min(struct device *dev, struct device_attribute
+                            *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+
+        return sprintf(buf, "%ld\n", in0_from_reg(data->in_low[0]));
+}
+
+static ssize_t set_in0_max(struct device *dev, struct device_attribute
+                           *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->in_high[0] = in0_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_HIGH(0), data->in_high[0]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t set_in0_min(struct device *dev, struct device_attribute
+                           *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->in_low[0] = in0_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_LOW(0), data->in_low[0]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+static DEVICE_ATTR(in0_input, S_IRUGO, show_in0, NULL);
+static DEVICE_ATTR(in0_max, S_IRUGO| S_IWUSR, show_in0_max, set_in0_max);
+static DEVICE_ATTR(in0_min, S_IRUGO| S_IWUSR, show_in0_min, set_in0_min);
+
+static ssize_t show_in(struct device *dev, struct device_attribute *devattr,
+                       char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", in_from_reg(data->in[nr]));
+}
+
+static ssize_t show_in_max(struct device *dev, struct device_attribute
+                           *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", in_from_reg(data->in_high[nr]));
+}
+
+static ssize_t show_in_min(struct device *dev, struct device_attribute
+                           *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", in_from_reg(data->in_low[nr]));
+}
+
+static ssize_t set_in_max(struct device *dev, struct device_attribute
+                          *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->in_high[nr] = in_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_HIGH(nr), data->in_high[nr]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t set_in_min(struct device *dev, struct device_attribute
+                          *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->in_low[nr] = in_to_reg(val);
+        f71805f_write8(data, F71805F_REG_IN_LOW(nr), data->in_low[nr]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+#define sysfs_in(offset)                                        \
+static SENSOR_DEVICE_ATTR(in##offset##_input, S_IRUGO,          \
+                show_in, NULL, offset);                         \
+static SENSOR_DEVICE_ATTR(in##offset##_max, S_IRUGO | S_IWUSR,  \
+                show_in_max, set_in_max, offset);               \
+static SENSOR_DEVICE_ATTR(in##offset##_min, S_IRUGO | S_IWUSR,  \
+                show_in_min, set_in_min, offset)
+
+sysfs_in(1);
+sysfs_in(2);
+sysfs_in(3);
+sysfs_in(4);
+sysfs_in(5);
+sysfs_in(6);
+sysfs_in(7);
+sysfs_in(8);
+
+static ssize_t show_fan(struct device *dev, struct device_attribute *devattr,
+                        char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", fan_from_reg(data->fan[nr]));
+}
+
+static ssize_t show_fan_min(struct device *dev, struct device_attribute
+                            *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", fan_from_reg(data->fan_low[nr]));
+}
+
+static ssize_t set_fan_min(struct device *dev, struct device_attribute
+                           *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->fan_low[nr] = fan_to_reg(val);
+        f71805f_write16(data, F71805F_REG_FAN_LOW(nr), data->fan_low[nr]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+#define sysfs_fan(offset)                                       \
+static SENSOR_DEVICE_ATTR(fan##offset##_input, S_IRUGO,         \
+                show_fan, NULL, offset - 1);                    \
+static SENSOR_DEVICE_ATTR(fan##offset##_min, S_IRUGO | S_IWUSR, \
+                show_fan_min, set_fan_min, offset - 1)
+
+sysfs_fan(1);
+sysfs_fan(2);
+sysfs_fan(3);
+
+static ssize_t show_temp(struct device *dev, struct device_attribute *devattr,
+                         char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp[nr]));
+}
+
+static ssize_t show_temp_max(struct device *dev, struct device_attribute
+                             *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp_high[nr]));
+}
+
+static ssize_t show_temp_hyst(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        return sprintf(buf, "%ld\n", temp_from_reg(data->temp_hyst[nr]));
+}
+
+static ssize_t show_temp_type(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+
+        /* 3 is diode, 4 is thermistor */
+        return sprintf(buf, "%u\n", (data->temp_mode & (1 << nr)) ? 3 : 4);
+}
+
+static ssize_t set_temp_max(struct device *dev, struct device_attribute
+                            *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->temp_high[nr] = temp_to_reg(val);
+        f71805f_write8(data, F71805F_REG_TEMP_HIGH(nr), data->temp_high[nr]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+static ssize_t set_temp_hyst(struct device *dev, struct device_attribute
+                             *devattr, const char *buf, size_t count)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+        struct sensor_device_attribute *attr = to_sensor_dev_attr(devattr);
+        int nr = attr->index;
+        long val = simple_strtol(buf, NULL, 10);
+
+        down(&data->update_lock);
+        data->temp_hyst[nr] = temp_to_reg(val);
+        f71805f_write8(data, F71805F_REG_TEMP_HYST(nr), data->temp_hyst[nr]);
+        up(&data->update_lock);
+
+        return count;
+}
+
+#define sysfs_temp(offset)                                              \
+static SENSOR_DEVICE_ATTR(temp##offset##_input, S_IRUGO,                \
+                show_temp, NULL, offset - 1);                           \
+static SENSOR_DEVICE_ATTR(temp##offset##_max, S_IRUGO | S_IWUSR,        \
+                show_temp_max, set_temp_max, offset - 1);               \
+static SENSOR_DEVICE_ATTR(temp##offset##_max_hyst, S_IRUGO | S_IWUSR,   \
+                show_temp_hyst, set_temp_hyst, offset - 1);             \
+static SENSOR_DEVICE_ATTR(temp##offset##_type, S_IRUGO,                 \
+                show_temp_type, NULL, offset - 1)
+
+sysfs_temp(1);
+sysfs_temp(2);
+sysfs_temp(3);
+
+static ssize_t show_alarms_in(struct device *dev, struct device_attribute
+                              *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+
+        return sprintf(buf, "%d\n", data->alarms[0] |
+                                    ((data->alarms[1] & 0x01) << 8));
+}
+
+static ssize_t show_alarms_fan(struct device *dev, struct device_attribute
+                               *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+
+        return sprintf(buf, "%d\n", data->alarms[2] & 0x07);
+}
+
+static ssize_t show_alarms_temp(struct device *dev, struct device_attribute
+                                *devattr, char *buf)
+{
+        struct f71805f_data *data = f71805f_update_device(dev);
+
+        return sprintf(buf, "%d\n", (data->alarms[1] >> 3) & 0x07);
+}
+
+static DEVICE_ATTR(alarms_in, S_IRUGO, show_alarms_in, NULL);
+static DEVICE_ATTR(alarms_fan, S_IRUGO, show_alarms_fan, NULL);
+static DEVICE_ATTR(alarms_temp, S_IRUGO, show_alarms_temp, NULL);
+
+static ssize_t show_name(struct device *dev, struct device_attribute
+                         *devattr, char *buf)
+{
+        struct f71805f_data *data = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%s\n", data->name);
+}
+
+static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
+
+/*
+ * Device registration and initialization
+ */
+
+static void __devinit f71805f_init_device(struct f71805f_data *data)
+{
+        u8 reg;
+        int i;
+
+        reg = f71805f_read8(data, F71805F_REG_START);
+        if ((reg & 0x41) != 0x01) {
+                printk(KERN_DEBUG DRVNAME ": Starting monitoring "
+                       "operations\n");
+                f71805f_write8(data, F71805F_REG_START, (reg | 0x01) & ~0x40);
+        }
+
+        /* Fan monitoring can be disabled. If it is, we won't be polling
+           the register values, and won't create the related sysfs files. */
+        for (i = 0; i < 3; i++) {
+                reg = f71805f_read8(data, F71805F_REG_FAN_CTRL(i));
+                if (!(reg & 0x80))
+                        data->fan_enabled |= (1 << i);
+        }
+}
+
+static int __devinit f71805f_probe(struct platform_device *pdev)
+{
+        struct f71805f_data *data;
+        struct resource *res;
+        int err;
+
+        if (!(data = kzalloc(sizeof(struct f71805f_data), GFP_KERNEL))) {
+                err = -ENOMEM;
+                printk(KERN_ERR DRVNAME ": Out of memory\n");
+                goto exit;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_IO, 0);
+        data->addr = res->start;
+        init_MUTEX(&data->lock);
+        data->name = "f71805f";
+        init_MUTEX(&data->update_lock);
+
+        platform_set_drvdata(pdev, data);
+
+        data->class_dev = hwmon_device_register(&pdev->dev);
+        if (IS_ERR(data->class_dev)) {
+                err = PTR_ERR(data->class_dev);
+                dev_err(&pdev->dev, "Class registration failed (%d)\n", err);
+                goto exit_free;
+        }
+
+        /* Initialize the F71805F chip */
+        f71805f_init_device(data);
+
+        /* Register sysfs interface files */
+        device_create_file(&pdev->dev, &dev_attr_in0_input);
+        device_create_file(&pdev->dev, &dev_attr_in0_max);
+        device_create_file(&pdev->dev, &dev_attr_in0_min);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in1_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in2_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in3_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in4_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in5_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in6_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in7_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in8_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in1_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in2_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in3_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in4_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in5_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in6_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in7_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in8_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in1_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in2_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in3_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in4_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in5_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in6_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in7_min.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_in8_min.dev_attr);
+        if (data->fan_enabled & (1 << 0)) {
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan1_input.dev_attr);
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan1_min.dev_attr);
+        }
+        if (data->fan_enabled & (1 << 1)) {
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan2_input.dev_attr);
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan2_min.dev_attr);
+        }
+        if (data->fan_enabled & (1 << 2)) {
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan3_input.dev_attr);
+                device_create_file(&pdev->dev,
+                                   &sensor_dev_attr_fan3_min.dev_attr);
+        }
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp1_input.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp2_input.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp3_input.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp1_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp2_max.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp3_max.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp1_max_hyst.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp2_max_hyst.dev_attr);
+        device_create_file(&pdev->dev,
+                           &sensor_dev_attr_temp3_max_hyst.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp1_type.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp2_type.dev_attr);
+        device_create_file(&pdev->dev, &sensor_dev_attr_temp3_type.dev_attr);
+        device_create_file(&pdev->dev, &dev_attr_alarms_in);
+        device_create_file(&pdev->dev, &dev_attr_alarms_fan);
+        device_create_file(&pdev->dev, &dev_attr_alarms_temp);
+        device_create_file(&pdev->dev, &dev_attr_name);
+
+        return 0;
+
+exit_free:
+        kfree(data);
+exit:
+        return err;
+}
+
+static int __devexit f71805f_remove(struct platform_device *pdev)
+{
+        struct f71805f_data *data = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        hwmon_device_unregister(data->class_dev);
+        kfree(data);
+
+        return 0;
+}
+
+static struct platform_driver f71805f_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = DRVNAME,
+        },
+        .probe          = f71805f_probe,
+        .remove         = __devexit_p(f71805f_remove),
+};
+
+static int __init f71805f_device_add(unsigned short address)
+{
+        int err;
+
+        pdev = platform_device_alloc(DRVNAME, address);
+        if (!pdev) {
+                err = -ENOMEM;
+                printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+                goto exit;
+        }
+
+        f71805f_resource.start = address;
+        f71805f_resource.end = address + REGION_LENGTH - 1;
+        f71805f_resource.name = pdev->name;
+        err = platform_device_add_resources(pdev, &f71805f_resource, 1);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device resource addition failed "
+                       "(%d)\n", err);
+                goto exit_device_put;
+        }
+
+        err = platform_device_add(pdev);
+        if (err) {
+                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
+                       err);
+                goto exit_device_put;
+        }
+
+        return 0;
+
+exit_device_put:
+        platform_device_put(pdev);
+exit:
+        return err;
+}
+
+static int __init f71805f_find(int sioaddr, unsigned short *address)
+{
+        int err = -ENODEV;
+        u16 devid;
+
+        superio_enter(sioaddr);
+
+        devid = superio_inw(sioaddr, SIO_REG_MANID);
+        if (devid != SIO_FINTEK_ID)
+                goto exit;
+
+        devid = superio_inw(sioaddr, SIO_REG_DEVID);
+        if (devid != SIO_F71805F_ID) {
+                printk(KERN_INFO DRVNAME ": Unsupported Fintek device, "
+                       "skipping\n");
+                goto exit;
+        }
+
+        superio_select(sioaddr, F71805F_LD_HWM);
+        if (!(superio_inb(sioaddr, SIO_REG_ENABLE) & 0x01)) {
+                printk(KERN_WARNING DRVNAME ": Device not activated, "
+                       "skipping\n");
+                goto exit;
+        }
+
+        *address = superio_inw(sioaddr, SIO_REG_ADDR);
+        if (*address == 0) {
+                printk(KERN_WARNING DRVNAME ": Base address not set, "
+                       "skipping\n");
+                goto exit;
+        }
+
+        err = 0;
+        printk(KERN_INFO DRVNAME ": Found F71805F chip at %#x, revision %u\n",
+               *address, superio_inb(sioaddr, SIO_REG_DEVREV));
+
+exit:
+        superio_exit(sioaddr);
+        return err;
+}
+
+static int __init f71805f_init(void)
+{
+        int err;
+        unsigned short address;
+
+        if (f71805f_find(0x2e, &address)
+         && f71805f_find(0x4e, &address))
+                return -ENODEV;
+
+        err = platform_driver_register(&f71805f_driver);
+        if (err)
+                goto exit;
+
+        /* Sets global pdev as a side effect */
+        err = f71805f_device_add(address);
+        if (err)
+                goto exit_driver;
+
+        return 0;
+
+exit_driver:
+        platform_driver_unregister(&f71805f_driver);
+exit:
+        return err;
+}
+
+static void __exit f71805f_exit(void)
+{
+        platform_device_unregister(pdev);
+        platform_driver_unregister(&f71805f_driver);
+}
+
+MODULE_AUTHOR("Jean Delvare <khali@linux-fr>");
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("F71805F hardware monitoring driver");
+
+module_init(f71805f_init);
+module_exit(f71805f_exit);
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index 0da7c9c508c3..e87d52c59940 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -45,8 +45,7 @@
 
 
 /* Addresses to scan */
-static unsigned short normal_i2c[] = { 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d,
-                                        0x2e, 0x2f, I2C_CLIENT_END };
+static unsigned short normal_i2c[] = { 0x2d, I2C_CLIENT_END };
 static unsigned short isa_address;
 
 /* Insmod parameters */
@@ -830,6 +829,11 @@ static int it87_detect(struct i2c_adapter *adapter, int address, int kind)
         if ((err = i2c_attach_client(new_client)))
                 goto ERROR2;
 
+        if (!is_isa)
+                dev_info(&new_client->dev, "The I2C interface to IT87xxF "
+                         "hardware monitoring chips is deprecated. Please "
+                         "report if you still rely on it.\n");
+
         /* Check PWM configuration */
         enable_pwm_interface = it87_check_pwm(new_client);
 
diff --git a/drivers/hwmon/lm77.c b/drivers/hwmon/lm77.c
index a2f420d01fb7..df9e02aaa70a 100644
--- a/drivers/hwmon/lm77.c
+++ b/drivers/hwmon/lm77.c
@@ -87,15 +87,15 @@ static struct i2c_driver lm77_driver = {
 
 /* In the temperature registers, the low 3 bits are not part of the
    temperature values; they are the status bits. */
-static inline u16 LM77_TEMP_TO_REG(int temp)
+static inline s16 LM77_TEMP_TO_REG(int temp)
 {
         int ntemp = SENSORS_LIMIT(temp, LM77_TEMP_MIN, LM77_TEMP_MAX);
-        return (u16)((ntemp / 500) * 8);
+        return (ntemp / 500) * 8;
 }
 
-static inline int LM77_TEMP_FROM_REG(u16 reg)
+static inline int LM77_TEMP_FROM_REG(s16 reg)
 {
-        return ((int)reg / 8) * 500;
+        return (reg / 8) * 500;
 }
 
 /* sysfs stuff */
diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index b176bf0c4c7b..a2f6bb676235 100644
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -303,10 +303,6 @@ struct w83792d_data {
 static int w83792d_attach_adapter(struct i2c_adapter *adapter);
 static int w83792d_detect(struct i2c_adapter *adapter, int address, int kind);
 static int w83792d_detach_client(struct i2c_client *client);
-
-static int w83792d_read_value(struct i2c_client *client, u8 register);
-static int w83792d_write_value(struct i2c_client *client, u8 register,
-                                u8 value);
 static struct w83792d_data *w83792d_update_device(struct device *dev);
 
 #ifdef DEBUG
@@ -329,6 +325,20 @@ static inline long in_count_from_reg(int nr, struct w83792d_data *data)
         return ((data->in[nr] << 2) | ((data->low_bits >> (2 * nr)) & 0x03));
 }
 
+/* The SMBus locks itself. The Winbond W83792D chip has a bank register,
+   but the driver only accesses registers in bank 0, so we don't have
+   to switch banks and lock access between switches. */
+static inline int w83792d_read_value(struct i2c_client *client, u8 reg)
+{
+        return i2c_smbus_read_byte_data(client, reg);
+}
+
+static inline int
+w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
+{
+        return i2c_smbus_write_byte_data(client, reg, value);
+}
+
 /* following are the sysfs callback functions */
 static ssize_t show_in(struct device *dev, struct device_attribute *attr,
                         char *buf)
@@ -1386,19 +1396,6 @@ w83792d_detach_client(struct i2c_client *client)
         return 0;
 }
 
-/* The SMBus locks itself. The Winbond W83792D chip has a bank register,
-   but the driver only accesses registers in bank 0, so we don't have
-   to switch banks and lock access between switches. */
-static int w83792d_read_value(struct i2c_client *client, u8 reg)
-{
-        return i2c_smbus_read_byte_data(client, reg);
-}
-
-static int w83792d_write_value(struct i2c_client *client, u8 reg, u8 value)
-{
-        return i2c_smbus_write_byte_data(client, reg, value);
-}
-
 static void
 w83792d_init_client(struct i2c_client *client)
 {
diff --git a/drivers/i2c/algos/i2c-algo-sibyte.c b/drivers/i2c/algos/i2c-algo-sibyte.c
index 938848ae162d..3df3f09995c2 100644
--- a/drivers/i2c/algos/i2c-algo-sibyte.c
+++ b/drivers/i2c/algos/i2c-algo-sibyte.c
@@ -202,7 +202,7 @@ EXPORT_SYMBOL(i2c_sibyte_del_bus);
 #ifdef MODULE
 MODULE_AUTHOR("Kip Walker, Broadcom Corp.");
 MODULE_DESCRIPTION("SiByte I2C-Bus algorithm");
-MODULE_PARM(bit_scan, "i");
+module_param(bit_scan, int, 0);
 MODULE_PARM_DESC(bit_scan, "Scan for active chips on the bus");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 08d5b8fed2dc..ff92735c7c85 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -124,6 +124,7 @@ config I2C_I801
             ICH6
             ICH7
             ESB2
+            ICH8
 
           This driver can also be built as a module.  If so, the module
           will be called i2c-i801.
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index 1c752ddc10e2..8e0f3158215f 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -32,6 +32,7 @@
     ICH6                266A
     ICH7                27DA
     ESB2                269B
+    ICH8                283E
     This driver supports several versions of Intel's I/O Controller Hubs (ICH).
     For SMBus support, they are similar to the PIIX4 and are part
     of Intel's '810' and other chipsets.
@@ -527,6 +528,7 @@ static struct pci_device_id i801_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH6_16) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_17) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_17) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_5) },
         { 0, }
 };
 
diff --git a/drivers/i2c/busses/i2c-parport-light.c b/drivers/i2c/busses/i2c-parport-light.c
index 3e5eba9fcacb..c63025a4c861 100644
--- a/drivers/i2c/busses/i2c-parport-light.c
+++ b/drivers/i2c/busses/i2c-parport-light.c
@@ -121,14 +121,11 @@ static struct i2c_adapter parport_adapter = {
 
 static int __init i2c_parport_init(void)
 {
-        int type_count;
-
-        type_count = sizeof(adapter_parm)/sizeof(struct adapter_parm);
-        if (type < 0 || type >= type_count) {
+        if (type < 0 || type >= ARRAY_SIZE(adapter_parm)) {
                 printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
                 type = 0;
         }
-        
+
         if (base == 0) {
                 printk(KERN_INFO "i2c-parport: using default base 0x%x\n", DEFAULT_BASE);
                 base = DEFAULT_BASE;
@@ -152,7 +149,7 @@ static int __init i2c_parport_init(void)
                 release_region(base, 3);
                 return -ENODEV;
         }
-        
+
         return 0;
 }
 
diff --git a/drivers/i2c/busses/i2c-parport.c b/drivers/i2c/busses/i2c-parport.c
index 2854d858fc9b..7e2e8cd1c14a 100644
--- a/drivers/i2c/busses/i2c-parport.c
+++ b/drivers/i2c/busses/i2c-parport.c
@@ -241,14 +241,11 @@ static struct parport_driver i2c_parport_driver = {
 
 static int __init i2c_parport_init(void)
 {
-        int type_count;
-
-        type_count = sizeof(adapter_parm)/sizeof(struct adapter_parm);
-        if (type < 0 || type >= type_count) {
+        if (type < 0 || type >= ARRAY_SIZE(adapter_parm)) {
                 printk(KERN_WARNING "i2c-parport: invalid type (%d)\n", type);
                 type = 0;
         }
-        
+
         return parport_register_driver(&i2c_parport_driver);
 }
 
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
index 86e2234faf80..7579f4b256a8 100644
--- a/drivers/i2c/busses/i2c-pxa.c
+++ b/drivers/i2c/busses/i2c-pxa.c
@@ -861,7 +861,7 @@ static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id, struct pt_regs *r
                 decode_ISR(isr);
         }
 
-        if (i2c->irqlogidx < sizeof(i2c->isrlog)/sizeof(u32))
+        if (i2c->irqlogidx < ARRAY_SIZE(i2c->isrlog))
                 i2c->isrlog[i2c->irqlogidx++] = isr;
 
         show_state(i2c);
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 0ce58b506046..1a2c9ab5d9e3 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -946,6 +946,20 @@ s32 i2c_smbus_read_i2c_block_data(struct i2c_client *client, u8 command, u8 *val
         }
 }
 
+s32 i2c_smbus_write_i2c_block_data(struct i2c_client *client, u8 command,
+                                   u8 length, u8 *values)
+{
+        union i2c_smbus_data data;
+
+        if (length > I2C_SMBUS_BLOCK_MAX)
+                length = I2C_SMBUS_BLOCK_MAX;
+        data.block[0] = length;
+        memcpy(data.block + 1, values, length);
+        return i2c_smbus_xfer(client->adapter, client->addr, client->flags,
+                              I2C_SMBUS_WRITE, command,
+                              I2C_SMBUS_I2C_BLOCK_DATA, &data);
+}
+
 /* Simulate a SMBus command using the i2c protocol 
    No checking of parameters is done!  */
 static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr, 
@@ -1150,6 +1164,7 @@ EXPORT_SYMBOL(i2c_smbus_read_word_data);
 EXPORT_SYMBOL(i2c_smbus_write_word_data);
 EXPORT_SYMBOL(i2c_smbus_write_block_data);
 EXPORT_SYMBOL(i2c_smbus_read_i2c_block_data);
+EXPORT_SYMBOL(i2c_smbus_write_i2c_block_data);
 
 MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
 MODULE_DESCRIPTION("I2C-Bus main module");
diff --git a/drivers/ide/Kconfig b/drivers/ide/Kconfig
index 1c81174595b3..d633081fa4c5 100644
--- a/drivers/ide/Kconfig
+++ b/drivers/ide/Kconfig
@@ -52,9 +52,9 @@ config IDE
 
 if IDE
 
-config IDE_MAX_HWIFS 
+config IDE_MAX_HWIFS
         int "Max IDE interfaces"
-        depends on ALPHA || SUPERH
+        depends on ALPHA || SUPERH || IA64
         default 4
         help
           This is the maximum number of IDE hardware interfaces that will
@@ -162,8 +162,8 @@ config BLK_DEV_IDECS
         tristate "PCMCIA IDE support"
         depends on PCMCIA
         help
-          Support for outboard IDE disks, tape drives, and CD-ROM drives
-          connected through a  PCMCIA card.
+          Support for Compact Flash cards, outboard IDE disks, tape drives,
+          and CD-ROM drives connected through a PCMCIA card.
 
 config BLK_DEV_IDECD
         tristate "Include IDE/ATAPI CDROM support"
@@ -267,7 +267,7 @@ config IDE_TASK_IOCTL
         help
           This is a direct raw access to the media.  It is a complex but
           elegant solution to test and validate the domain of the hardware and
-          perform below the driver data recover if needed.  This is the most
+          perform below the driver data recovery if needed.  This is the most
           basic form of media-forensics.
 
           If you are unsure, say N here.
@@ -525,7 +525,7 @@ config BLK_DEV_CS5520
         tristate "Cyrix CS5510/20 MediaGX chipset support (VERY EXPERIMENTAL)"
         depends on EXPERIMENTAL
         help
-          Include support for PIO tuning an virtual DMA on the Cyrix MediaGX 
+          Include support for PIO tuning and virtual DMA on the Cyrix MediaGX
           5510/5520 chipset. This will automatically be detected and
           configured if found.
 
@@ -662,7 +662,7 @@ config PDC202XX_BURST
 
           It was originally designed for the PDC20246/Ultra33, whose BIOS will
           only setup UDMA on the first two PDC20246 cards.  It has also been
-          used succesfully on a PDC20265/Ultra100, allowing use of UDMA modes
+          used successfully on a PDC20265/Ultra100, allowing use of UDMA modes
           when the PDC20265 BIOS has been disabled (for faster boot up).
 
           Please read the comments at the top of
@@ -673,13 +673,6 @@ config PDC202XX_BURST
 config BLK_DEV_PDC202XX_NEW
         tristate "PROMISE PDC202{68|69|70|71|75|76|77} support"
 
-# FIXME - probably wants to be one for old and for new
-config PDC202XX_FORCE
-        bool "Enable controller even if disabled by BIOS"
-        depends on BLK_DEV_PDC202XX_NEW
-        help
-          Enable the PDC202xx controller even if it has been disabled in the BIOS setup.
-
 config BLK_DEV_SVWKS
         tristate "ServerWorks OSB4/CSB5/CSB6 chipsets support"
         help
@@ -722,7 +715,7 @@ config BLK_DEV_SIS5513
 config BLK_DEV_SLC90E66
         tristate "SLC90E66 chipset support"
         help
-          This driver ensures (U)DMA support for Victroy66 SouthBridges for
+          This driver ensures (U)DMA support for Victory66 SouthBridges for
           SMsC with Intel NorthBridges.  This is an Ultra66 based chipset.
           The nice thing about it is that you can mix Ultra/DMA/PIO devices
           and it will handle timing cycles.  Since this is an improved
@@ -1060,7 +1053,7 @@ config IDEDMA_IVB
           in that mode with an 80c ribbon.
 
           If you are experiencing compatibility or performance problems, you
-          MAY try to answering Y here. However, it does not necessarily solve
+          MAY try to answer Y here. However, it does not necessarily solve
           any of your problems, it could even cause more of them.
 
           It is normally safe to answer Y; however, the default is N.
diff --git a/drivers/ide/ide-disk.c b/drivers/ide/ide-disk.c
index ca25f9e3d0f4..09086b8b6486 100644
--- a/drivers/ide/ide-disk.c
+++ b/drivers/ide/ide-disk.c
@@ -190,7 +190,8 @@ static ide_startstop_t __ide_do_rw_disk(ide_drive_t *drive, struct request *rq,
                 if (lba48) {
                         task_ioreg_t tasklets[10];
 
-                        pr_debug("%s: LBA=0x%012llx\n", drive->name, block);
+                        pr_debug("%s: LBA=0x%012llx\n", drive->name,
+                                        (unsigned long long)block);
 
                         tasklets[0] = 0;
                         tasklets[1] = 0;
@@ -317,7 +318,8 @@ static ide_startstop_t ide_do_rw_disk (ide_drive_t *drive, struct request *rq, s
 
         pr_debug("%s: %sing: block=%llu, sectors=%lu, buffer=0x%08lx\n",
                  drive->name, rq_data_dir(rq) == READ ? "read" : "writ",
-                 block, rq->nr_sectors, (unsigned long)rq->buffer);
+                 (unsigned long long)block, rq->nr_sectors,
+                 (unsigned long)rq->buffer);
 
         if (hwif->rw_disk)
                 hwif->rw_disk(drive, rq);
@@ -776,7 +778,7 @@ static void update_ordered(ide_drive_t *drive)
                          ide_id_has_flush_cache_ext(id));
 
                 printk(KERN_INFO "%s: cache flushes %ssupported\n",
-                       drive->name, barrier ? "" : "not");
+                       drive->name, barrier ? "" : "not ");
 
                 if (barrier) {
                         ordered = QUEUE_ORDERED_DRAIN_FLUSH;
@@ -889,11 +891,7 @@ static void idedisk_setup (ide_drive_t *drive)
         if (drive->id_read == 0)
                 return;
 
-        /*
-         * CompactFlash cards and their brethern look just like hard drives
-         * to us, but they are removable and don't have a doorlock mechanism.
-         */
-        if (drive->removable && !(drive->is_flash)) {
+        if (drive->removable) {
                 /*
                  * Removable disks (eg. SYQUEST); ignore 'WD' drives 
                  */
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 8d50df4526a4..c01615dec202 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -55,8 +55,8 @@
 #include <asm/io.h>
 #include <asm/bitops.h>
 
-int __ide_end_request(ide_drive_t *drive, struct request *rq, int uptodate,
-                      int nr_sectors)
+static int __ide_end_request(ide_drive_t *drive, struct request *rq,
+                             int uptodate, int nr_sectors)
 {
         int ret = 1;
 
@@ -91,7 +91,6 @@ int __ide_end_request(ide_drive_t *drive, struct request *rq, int uptodate,
 
         return ret;
 }
-EXPORT_SYMBOL(__ide_end_request);
 
 /**
  *      ide_end_request         -       complete an IDE I/O
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index af7af958ab3e..b72dde70840a 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -1243,6 +1243,7 @@ int ide_wait_not_busy(ide_hwif_t *hwif, unsigned long timeout)
                  */
                 if (stat == 0xff)
                         return -ENODEV;
+                touch_softlockup_watchdog();
         }
         return -EBUSY;
 }
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index e7425546b4b1..427d1c204174 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -125,45 +125,6 @@ static void ide_disk_init_mult_count(ide_drive_t *drive)
 }
 
 /**
- *      drive_is_flashcard      -       check for compact flash
- *      @drive: drive to check
- *
- *      CompactFlash cards and their brethern pretend to be removable
- *      hard disks, except:
- *              (1) they never have a slave unit, and
- *              (2) they don't have doorlock mechanisms.
- *      This test catches them, and is invoked elsewhere when setting
- *      appropriate config bits.
- *
- *      FIXME: This treatment is probably applicable for *all* PCMCIA (PC CARD)
- *      devices, so in linux 2.3.x we should change this to just treat all
- *      PCMCIA  drives this way, and get rid of the model-name tests below
- *      (too big of an interface change for 2.4.x).
- *      At that time, we might also consider parameterizing the timeouts and
- *      retries, since these are MUCH faster than mechanical drives. -M.Lord
- */
- 
-static inline int drive_is_flashcard (ide_drive_t *drive)
-{
-        struct hd_driveid *id = drive->id;
-
-        if (drive->removable) {
-                if (id->config == 0x848a) return 1;     /* CompactFlash */
-                if (!strncmp(id->model, "KODAK ATA_FLASH", 15)  /* Kodak */
-                 || !strncmp(id->model, "Hitachi CV", 10)       /* Hitachi */
-                 || !strncmp(id->model, "SunDisk SDCFB", 13)    /* old SanDisk */
-                 || !strncmp(id->model, "SanDisk SDCFB", 13)    /* SanDisk */
-                 || !strncmp(id->model, "HAGIWARA HPC", 12)     /* Hagiwara */
-                 || !strncmp(id->model, "LEXAR ATA_FLASH", 15)  /* Lexar */
-                 || !strncmp(id->model, "ATA_FLASH", 9))        /* Simple Tech */
-                {
-                        return 1;       /* yes, it is a flash memory card */
-                }
-        }
-        return 0;       /* no, it is not a flash memory card */
-}
-
-/**
  *      do_identify     -       identify a drive
  *      @drive: drive to identify 
  *      @cmd: command used
@@ -278,13 +239,17 @@ static inline void do_identify (ide_drive_t *drive, u8 cmd)
         /*
          * Not an ATAPI device: looks like a "regular" hard disk
          */
-        if (id->config & (1<<7))
+
+        /*
+         * 0x848a = CompactFlash device
+         * These are *not* removable in Linux definition of the term
+         */
+
+        if ((id->config != 0x848a) && (id->config & (1<<7)))
                 drive->removable = 1;
 
-        if (drive_is_flashcard(drive))
-                drive->is_flash = 1;
         drive->media = ide_disk;
-        printk("%s DISK drive\n", (drive->is_flash) ? "CFA" : "ATA" );
+        printk("%s DISK drive\n", (id->config == 0x848a) ? "CFA" : "ATA" );
         QUIRK_LIST(drive);
         return;
 
diff --git a/drivers/ide/ide.c b/drivers/ide/ide.c
index afeb02bbb722..b2cc43702f65 100644
--- a/drivers/ide/ide.c
+++ b/drivers/ide/ide.c
@@ -242,7 +242,6 @@ static void init_hwif_data(ide_hwif_t *hwif, unsigned int index)
                 drive->name[2]                  = 'a' + (index * MAX_DRIVES) + unit;
                 drive->max_failures             = IDE_DEFAULT_MAX_FAILURES;
                 drive->using_dma                = 0;
-                drive->is_flash                 = 0;
                 drive->vdma                     = 0;
                 INIT_LIST_HEAD(&drive->list);
                 init_completion(&drive->gendev_rel_comp);
diff --git a/drivers/ide/pci/aec62xx.c b/drivers/ide/pci/aec62xx.c
index a21b1e11eef4..c743e68c33aa 100644
--- a/drivers/ide/pci/aec62xx.c
+++ b/drivers/ide/pci/aec62xx.c
@@ -262,6 +262,21 @@ static unsigned int __devinit init_chipset_aec62xx(struct pci_dev *dev, const ch
         else
                 pci_set_drvdata(dev, (void *) aec6xxx_34_base);
 
+        /* These are necessary to get AEC6280 Macintosh cards to work */
+        if ((dev->device == PCI_DEVICE_ID_ARTOP_ATP865) ||
+            (dev->device == PCI_DEVICE_ID_ARTOP_ATP865R)) {
+                u8 reg49h = 0, reg4ah = 0;
+                /* Clear reset and test bits.  */
+                pci_read_config_byte(dev, 0x49, &reg49h);
+                pci_write_config_byte(dev, 0x49, reg49h & ~0x30);
+                /* Enable chip interrupt output.  */
+                pci_read_config_byte(dev, 0x4a, &reg4ah);
+                pci_write_config_byte(dev, 0x4a, reg4ah & ~0x01);
+                /* Enable burst mode. */
+                pci_read_config_byte(dev, 0x4a, &reg4ah);
+                pci_write_config_byte(dev, 0x4a, reg4ah | 0x80);
+        }
+
         return dev->irq;
 }
 
diff --git a/drivers/ide/pci/hpt366.c b/drivers/ide/pci/hpt366.c
index 7b589d948bf9..940bdd4c5784 100644
--- a/drivers/ide/pci/hpt366.c
+++ b/drivers/ide/pci/hpt366.c
@@ -1288,6 +1288,10 @@ static void __devinit hpt37x_clocking(ide_hwif_t *hwif)
                                 goto init_hpt37X_done;
                         }
                 }
+                if (!pci_get_drvdata(dev)) {
+                        printk("No Clock Stabilization!!!\n");
+                        return;
+                }
 pll_recal:
                 if (adjust & 1)
                         pll -= (adjust >> 1);
diff --git a/drivers/ide/pci/it821x.c b/drivers/ide/pci/it821x.c
index 108fda83fea4..38f41b377ff6 100644
--- a/drivers/ide/pci/it821x.c
+++ b/drivers/ide/pci/it821x.c
@@ -733,7 +733,7 @@ static void __devinit it8212_disable_raid(struct pci_dev *dev)
 
         pci_write_config_dword(dev,0x4C, 0x02040204);
         pci_write_config_byte(dev, 0x42, 0x36);
-        pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0);
+        pci_write_config_byte(dev, PCI_LATENCY_TIMER, 0x20);
 }
 
 static unsigned int __devinit init_chipset_it821x(struct pci_dev *dev, const char *name)
diff --git a/drivers/ide/pci/pdc202xx_new.c b/drivers/ide/pci/pdc202xx_new.c
index fe06ebb0e5bf..acd63173199b 100644
--- a/drivers/ide/pci/pdc202xx_new.c
+++ b/drivers/ide/pci/pdc202xx_new.c
@@ -420,9 +420,6 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .init_hwif      = init_hwif_pdc202new,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
         },{     /* 3 */
                 .name           = "PDC20271",
@@ -447,9 +444,6 @@ static ide_pci_device_t pdcnew_chipsets[] __devinitdata = {
                 .init_hwif      = init_hwif_pdc202new,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
         },{     /* 6 */
                 .name           = "PDC20277",
diff --git a/drivers/ide/pci/pdc202xx_old.c b/drivers/ide/pci/pdc202xx_old.c
index ad9d95817f95..6f8f8645b02c 100644
--- a/drivers/ide/pci/pdc202xx_old.c
+++ b/drivers/ide/pci/pdc202xx_old.c
@@ -786,9 +786,6 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_dma       = init_dma_pdc202xx,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
                 .extra          = 16,
         },{     /* 1 */
@@ -799,9 +796,6 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_dma       = init_dma_pdc202xx,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
                 .flags          = IDEPCI_FLAG_FORCE_PDC,
@@ -813,9 +807,6 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_dma       = init_dma_pdc202xx,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
         },{     /* 3 */
@@ -826,9 +817,6 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_dma       = init_dma_pdc202xx,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
                 .flags          = IDEPCI_FLAG_FORCE_PDC,
@@ -840,9 +828,6 @@ static ide_pci_device_t pdc202xx_chipsets[] __devinitdata = {
                 .init_dma       = init_dma_pdc202xx,
                 .channels       = 2,
                 .autodma        = AUTODMA,
-#ifndef CONFIG_PDC202XX_FORCE
-                .enablebits     = {{0x50,0x02,0x02}, {0x50,0x04,0x04}},
-#endif
                 .bootable       = OFF_BOARD,
                 .extra          = 48,
         }
diff --git a/drivers/ide/pci/piix.c b/drivers/ide/pci/piix.c
index b3e77df63cef..e9b83e1a3028 100644
--- a/drivers/ide/pci/piix.c
+++ b/drivers/ide/pci/piix.c
@@ -135,6 +135,7 @@ static u8 piix_ratemask (ide_drive_t *drive)
                 case PCI_DEVICE_ID_INTEL_ICH6_19:
                 case PCI_DEVICE_ID_INTEL_ICH7_21:
                 case PCI_DEVICE_ID_INTEL_ESB2_18:
+                case PCI_DEVICE_ID_INTEL_ICH8_6:
                         mode = 3;
                         break;
                 /* UDMA 66 capable */
@@ -449,6 +450,7 @@ static unsigned int __devinit init_chipset_piix (struct pci_dev *dev, const char
                 case PCI_DEVICE_ID_INTEL_ICH6_19:
                 case PCI_DEVICE_ID_INTEL_ICH7_21:
                 case PCI_DEVICE_ID_INTEL_ESB2_18:
+                case PCI_DEVICE_ID_INTEL_ICH8_6:
                 {
                         unsigned int extra = 0;
                         pci_read_config_dword(dev, 0x54, &extra);
@@ -575,6 +577,7 @@ static ide_pci_device_t piix_pci_info[] __devinitdata = {
         /* 21 */ DECLARE_PIIX_DEV("ICH7"),
         /* 22 */ DECLARE_PIIX_DEV("ICH4"),
         /* 23 */ DECLARE_PIIX_DEV("ESB2"),
+        /* 24 */ DECLARE_PIIX_DEV("ICH8M"),
 };
 
 /**
@@ -651,6 +654,7 @@ static struct pci_device_id piix_pci_tbl[] = {
         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH7_21, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 21},
         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82801DB_1, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 22},
         { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB2_18, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 23},
+        { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ICH8_6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 24},
         { 0, },
 };
 MODULE_DEVICE_TABLE(pci, piix_pci_tbl);
diff --git a/drivers/ide/pci/sgiioc4.c b/drivers/ide/pci/sgiioc4.c
index 4ee597d08797..2b286e865163 100644
--- a/drivers/ide/pci/sgiioc4.c
+++ b/drivers/ide/pci/sgiioc4.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003 Silicon Graphics, Inc.  All Rights Reserved.
+ * Copyright (c) 2003-2006 Silicon Graphics, Inc.  All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of version 2 of the GNU General Public License
@@ -510,7 +510,7 @@ sgiioc4_build_dma_table(ide_drive_t * drive, struct request *rq, int ddir)
                                        drive->name);
                                 goto use_pio_instead;
                         } else {
-                                u32 xcount, bcount =
+                                u32 bcount =
                                     0x10000 - (cur_addr & 0xffff);
 
                                 if (bcount > cur_len)
@@ -525,8 +525,7 @@ sgiioc4_build_dma_table(ide_drive_t * drive, struct request *rq, int ddir)
                                 *table = 0x0;
                                 table++;
 
-                                xcount = bcount & 0xffff;
-                                *table = cpu_to_be32(xcount);
+                                *table = cpu_to_be32(bcount);
                                 table++;
 
                                 cur_addr += bcount;
@@ -680,7 +679,7 @@ sgiioc4_ide_setup_pci_device(struct pci_dev *dev, ide_pci_device_t * d)
                 return -EIO;
 
         /* Create /proc/ide entries */
-        create_proc_ide_interfaces(); 
+        create_proc_ide_interfaces();
 
         return 0;
 }
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index e95c4293a496..f6a05965a4e8 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -1319,15 +1319,6 @@ static struct class ucm_class = {
         .release = ib_ucm_release_class_dev
 };
 
-static ssize_t show_dev(struct class_device *class_dev, char *buf)
-{
-        struct ib_ucm_device *dev;
-        
-        dev = container_of(class_dev, struct ib_ucm_device, class_dev);
-        return print_dev_t(buf, dev->dev.dev);
-}
-static CLASS_DEVICE_ATTR(dev, S_IRUGO, show_dev, NULL);
-
 static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
 {
         struct ib_ucm_device *dev;
@@ -1364,15 +1355,13 @@ static void ib_ucm_add_one(struct ib_device *device)
 
         ucm_dev->class_dev.class = &ucm_class;
         ucm_dev->class_dev.dev = device->dma_device;
+        ucm_dev->class_dev.devt = ucm_dev->dev.dev;
         snprintf(ucm_dev->class_dev.class_id, BUS_ID_SIZE, "ucm%d",
                  ucm_dev->devnum);
         if (class_device_register(&ucm_dev->class_dev))
                 goto err_cdev;
 
         if (class_device_create_file(&ucm_dev->class_dev,
-                                     &class_device_attr_dev))
-                goto err_class;
-        if (class_device_create_file(&ucm_dev->class_dev,
                                      &class_device_attr_ibdev))
                 goto err_class;
 
diff --git a/drivers/isdn/hisax/Kconfig b/drivers/isdn/hisax/Kconfig
index 0ef560144be3..6dfc94122dd9 100644
--- a/drivers/isdn/hisax/Kconfig
+++ b/drivers/isdn/hisax/Kconfig
@@ -351,7 +351,7 @@ config HISAX_ENTERNOW_PCI
 
 config HISAX_AMD7930
         bool "Am7930 (EXPERIMENTAL)"
-        depends on EXPERIMENTAL && SPARC
+        depends on EXPERIMENTAL && SPARC && BROKEN
         help
           This enables HiSax support for the AMD7930 chips on some SPARCs.
           This code is not finished yet.
diff --git a/drivers/isdn/hisax/hisax.h b/drivers/isdn/hisax/hisax.h
index 1b85ce166af8..11fe537e2f6f 100644
--- a/drivers/isdn/hisax/hisax.h
+++ b/drivers/isdn/hisax/hisax.h
@@ -216,7 +216,7 @@ struct Layer1 {
 #define GROUP_TEI       127
 #define TEI_SAPI        63
 #define CTRL_SAPI       0
-#define PACKET_NOACK    250
+#define PACKET_NOACK    7
 
 /* Layer2 Flags */
 
diff --git a/drivers/isdn/sc/ioctl.c b/drivers/isdn/sc/ioctl.c
index 3314a5a19854..94c9afb7017c 100644
--- a/drivers/isdn/sc/ioctl.c
+++ b/drivers/isdn/sc/ioctl.c
@@ -71,14 +71,14 @@ int sc_ioctl(int card, scs_ioctl *data)
                 /*
                  * Get the SRec from user space
                  */
-                if (copy_from_user(srec, data->dataptr, sizeof(srec))) {
+                if (copy_from_user(srec, data->dataptr, SCIOC_SRECSIZE)) {
                         kfree(rcvmsg);
                         kfree(srec);
                         return -EFAULT;
                 }
 
                 status = send_and_receive(card, CMPID, cmReqType2, cmReqClass0, cmReqLoadProc,
-                                0, sizeof(srec), srec, rcvmsg, SAR_TIMEOUT);
+                                0, SCIOC_SRECSIZE, srec, rcvmsg, SAR_TIMEOUT);
                 kfree(rcvmsg);
                 kfree(srec);
 
diff --git a/drivers/macintosh/Kconfig b/drivers/macintosh/Kconfig
index 7d4a0ac28c06..12ad462737ba 100644
--- a/drivers/macintosh/Kconfig
+++ b/drivers/macintosh/Kconfig
@@ -187,6 +187,14 @@ config WINDFARM_PM91
           This driver provides thermal control for the PowerMac9,1
           which is the recent (SMU based) single CPU desktop G5
 
+config WINDFARM_PM112
+        tristate "Support for thermal management on PowerMac11,2"
+        depends on WINDFARM && I2C && PMAC_SMU
+        select I2C_POWERMAC
+        help
+          This driver provides thermal control for the PowerMac11,2
+          which are the recent dual and quad G5 machines using the
+          970MP dual-core processor.
 
 config ANSLCD
         tristate "Support for ANS LCD display"
diff --git a/drivers/macintosh/Makefile b/drivers/macintosh/Makefile
index f4657aa81fb0..6081acdea404 100644
--- a/drivers/macintosh/Makefile
+++ b/drivers/macintosh/Makefile
@@ -35,3 +35,8 @@ obj-$(CONFIG_WINDFARM_PM91)     += windfarm_smu_controls.o \
                                    windfarm_smu_sensors.o \
                                    windfarm_lm75_sensor.o windfarm_pid.o \
                                    windfarm_cpufreq_clamp.o windfarm_pm91.o
+obj-$(CONFIG_WINDFARM_PM112)    += windfarm_pm112.o windfarm_smu_sat.o \
+                                   windfarm_smu_controls.o \
+                                   windfarm_smu_sensors.o \
+                                   windfarm_max6690_sensor.o \
+                                   windfarm_lm75_sensor.o windfarm_pid.o
diff --git a/drivers/macintosh/windfarm.h b/drivers/macintosh/windfarm.h
index 3f0cb0312ea3..7a2482cc26a7 100644
--- a/drivers/macintosh/windfarm.h
+++ b/drivers/macintosh/windfarm.h
@@ -14,6 +14,7 @@
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/notifier.h>
+#include <linux/device.h>
 
 /* Display a 16.16 fixed point value */
 #define FIX32TOPRINT(f) ((f) >> 16),((((f) & 0xffff) * 1000) >> 16)
@@ -39,6 +40,7 @@ struct wf_control {
         char                    *name;
         int                     type;
         struct kref             ref;
+        struct device_attribute attr;
 };
 
 #define WF_CONTROL_TYPE_GENERIC         0
@@ -87,6 +89,7 @@ struct wf_sensor {
         struct wf_sensor_ops    *ops;
         char                    *name;
         struct kref             ref;
+        struct device_attribute attr;
 };
 
 /* Same lifetime rules as controls */
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 6c2a471ea6c0..bb8d5efe19bf 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -33,6 +33,7 @@
 #include <linux/reboot.h>
 #include <linux/device.h>
 #include <linux/platform_device.h>
+#include <linux/mutex.h>
 
 #include "windfarm.h"
 
@@ -48,13 +49,17 @@
 
 static LIST_HEAD(wf_controls);
 static LIST_HEAD(wf_sensors);
-static DECLARE_MUTEX(wf_lock);
+static DEFINE_MUTEX(wf_lock);
 static struct notifier_block *wf_client_list;
 static int wf_client_count;
 static unsigned int wf_overtemp;
 static unsigned int wf_overtemp_counter;
 struct task_struct *wf_thread;
 
+static struct platform_device wf_platform_device = {
+        .name   = "windfarm",
+};
+
 /*
  * Utilities & tick thread
  */
@@ -156,26 +161,67 @@ static void wf_control_release(struct kref *kref)
                 kfree(ct);
 }
 
+static ssize_t wf_show_control(struct device *dev,
+                               struct device_attribute *attr, char *buf)
+{
+        struct wf_control *ctrl = container_of(attr, struct wf_control, attr);
+        s32 val = 0;
+        int err;
+
+        err = ctrl->ops->get_value(ctrl, &val);
+        if (err < 0)
+                return err;
+        return sprintf(buf, "%d\n", val);
+}
+
+/* This is really only for debugging... */
+static ssize_t wf_store_control(struct device *dev,
+                                struct device_attribute *attr,
+                                const char *buf, size_t count)
+{
+        struct wf_control *ctrl = container_of(attr, struct wf_control, attr);
+        int val;
+        int err;
+        char *endp;
+
+        val = simple_strtoul(buf, &endp, 0);
+        while (endp < buf + count && (*endp == ' ' || *endp == '\n'))
+                ++endp;
+        if (endp - buf < count)
+                return -EINVAL;
+        err = ctrl->ops->set_value(ctrl, val);
+        if (err < 0)
+                return err;
+        return count;
+}
+
 int wf_register_control(struct wf_control *new_ct)
 {
         struct wf_control *ct;
 
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         list_for_each_entry(ct, &wf_controls, link) {
                 if (!strcmp(ct->name, new_ct->name)) {
                         printk(KERN_WARNING "windfarm: trying to register"
                                " duplicate control %s\n", ct->name);
-                        up(&wf_lock);
+                        mutex_unlock(&wf_lock);
                         return -EEXIST;
                 }
         }
         kref_init(&new_ct->ref);
         list_add(&new_ct->link, &wf_controls);
 
+        new_ct->attr.attr.name = new_ct->name;
+        new_ct->attr.attr.owner = THIS_MODULE;
+        new_ct->attr.attr.mode = 0644;
+        new_ct->attr.show = wf_show_control;
+        new_ct->attr.store = wf_store_control;
+        device_create_file(&wf_platform_device.dev, &new_ct->attr);
+
         DBG("wf: Registered control %s\n", new_ct->name);
 
         wf_notify(WF_EVENT_NEW_CONTROL, new_ct);
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 
         return 0;
 }
@@ -183,9 +229,9 @@ EXPORT_SYMBOL_GPL(wf_register_control);
 
 void wf_unregister_control(struct wf_control *ct)
 {
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         list_del(&ct->link);
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 
         DBG("wf: Unregistered control %s\n", ct->name);
 
@@ -197,16 +243,16 @@ struct wf_control * wf_find_control(const char *name)
 {
         struct wf_control *ct;
 
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         list_for_each_entry(ct, &wf_controls, link) {
                 if (!strcmp(ct->name, name)) {
                         if (wf_get_control(ct))
                                 ct = NULL;
-                        up(&wf_lock);
+                        mutex_unlock(&wf_lock);
                         return ct;
                 }
         }
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
         return NULL;
 }
 EXPORT_SYMBOL_GPL(wf_find_control);
@@ -246,26 +292,46 @@ static void wf_sensor_release(struct kref *kref)
                 kfree(sr);
 }
 
+static ssize_t wf_show_sensor(struct device *dev,
+                              struct device_attribute *attr, char *buf)
+{
+        struct wf_sensor *sens = container_of(attr, struct wf_sensor, attr);
+        s32 val = 0;
+        int err;
+
+        err = sens->ops->get_value(sens, &val);
+        if (err < 0)
+                return err;
+        return sprintf(buf, "%d.%03d\n", FIX32TOPRINT(val));
+}
+
 int wf_register_sensor(struct wf_sensor *new_sr)
 {
         struct wf_sensor *sr;
 
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         list_for_each_entry(sr, &wf_sensors, link) {
                 if (!strcmp(sr->name, new_sr->name)) {
                         printk(KERN_WARNING "windfarm: trying to register"
                                " duplicate sensor %s\n", sr->name);
-                        up(&wf_lock);
+                        mutex_unlock(&wf_lock);
                         return -EEXIST;
                 }
         }
         kref_init(&new_sr->ref);
         list_add(&new_sr->link, &wf_sensors);
 
+        new_sr->attr.attr.name = new_sr->name;
+        new_sr->attr.attr.owner = THIS_MODULE;
+        new_sr->attr.attr.mode = 0444;
+        new_sr->attr.show = wf_show_sensor;
+        new_sr->attr.store = NULL;
+        device_create_file(&wf_platform_device.dev, &new_sr->attr);
+
         DBG("wf: Registered sensor %s\n", new_sr->name);
 
         wf_notify(WF_EVENT_NEW_SENSOR, new_sr);
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 
         return 0;
 }
@@ -273,9 +339,9 @@ EXPORT_SYMBOL_GPL(wf_register_sensor);
 
 void wf_unregister_sensor(struct wf_sensor *sr)
 {
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         list_del(&sr->link);
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 
         DBG("wf: Unregistered sensor %s\n", sr->name);
 
@@ -287,16 +353,16 @@ struct wf_sensor * wf_find_sensor(const char *name)
 {
         struct wf_sensor *sr;
 
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         list_for_each_entry(sr, &wf_sensors, link) {
                 if (!strcmp(sr->name, name)) {
                         if (wf_get_sensor(sr))
                                 sr = NULL;
-                        up(&wf_lock);
+                        mutex_unlock(&wf_lock);
                         return sr;
                 }
         }
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
         return NULL;
 }
 EXPORT_SYMBOL_GPL(wf_find_sensor);
@@ -329,7 +395,7 @@ int wf_register_client(struct notifier_block *nb)
         struct wf_control *ct;
         struct wf_sensor *sr;
 
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         rc = notifier_chain_register(&wf_client_list, nb);
         if (rc != 0)
                 goto bail;
@@ -341,19 +407,19 @@ int wf_register_client(struct notifier_block *nb)
         if (wf_client_count == 1)
                 wf_start_thread();
  bail:
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
         return rc;
 }
 EXPORT_SYMBOL_GPL(wf_register_client);
 
 int wf_unregister_client(struct notifier_block *nb)
 {
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         notifier_chain_unregister(&wf_client_list, nb);
         wf_client_count++;
         if (wf_client_count == 0)
                 wf_stop_thread();
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 
         return 0;
 }
@@ -361,23 +427,23 @@ EXPORT_SYMBOL_GPL(wf_unregister_client);
 
 void wf_set_overtemp(void)
 {
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         wf_overtemp++;
         if (wf_overtemp == 1) {
                 printk(KERN_WARNING "windfarm: Overtemp condition detected !\n");
                 wf_overtemp_counter = 0;
                 wf_notify(WF_EVENT_OVERTEMP, NULL);
         }
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 }
 EXPORT_SYMBOL_GPL(wf_set_overtemp);
 
 void wf_clear_overtemp(void)
 {
-        down(&wf_lock);
+        mutex_lock(&wf_lock);
         WARN_ON(wf_overtemp == 0);
         if (wf_overtemp == 0) {
-                up(&wf_lock);
+                mutex_unlock(&wf_lock);
                 return;
         }
         wf_overtemp--;
@@ -385,7 +451,7 @@ void wf_clear_overtemp(void)
                 printk(KERN_WARNING "windfarm: Overtemp condition cleared !\n");
                 wf_notify(WF_EVENT_NORMALTEMP, NULL);
         }
-        up(&wf_lock);
+        mutex_unlock(&wf_lock);
 }
 EXPORT_SYMBOL_GPL(wf_clear_overtemp);
 
@@ -395,10 +461,6 @@ int wf_is_overtemp(void)
 }
 EXPORT_SYMBOL_GPL(wf_is_overtemp);
 
-static struct platform_device wf_platform_device = {
-        .name   = "windfarm",
-};
-
 static int __init windfarm_core_init(void)
 {
         DBG("wf: core loaded\n");
diff --git a/drivers/macintosh/windfarm_max6690_sensor.c b/drivers/macintosh/windfarm_max6690_sensor.c
new file mode 100644
index 000000000000..5b9ad6ca7cba
--- /dev/null
+++ b/drivers/macintosh/windfarm_max6690_sensor.c
@@ -0,0 +1,169 @@
+/*
+ * Windfarm PowerMac thermal control.  MAX6690 sensor.
+ *
+ * Copyright (C) 2005 Paul Mackerras, IBM Corp. <paulus@samba.org>
+ *
+ * Use and redistribute under the terms of the GNU GPL v2.
+ */
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <asm/prom.h>
+#include <asm/pmac_low_i2c.h>
+
+#include "windfarm.h"
+
+#define VERSION "0.1"
+
+/* This currently only exports the external temperature sensor,
+   since that's all the control loops need. */
+
+/* Some MAX6690 register numbers */
+#define MAX6690_INTERNAL_TEMP   0
+#define MAX6690_EXTERNAL_TEMP   1
+
+struct wf_6690_sensor {
+        struct i2c_client       i2c;
+        struct wf_sensor        sens;
+};
+
+#define wf_to_6690(x)   container_of((x), struct wf_6690_sensor, sens)
+#define i2c_to_6690(x)  container_of((x), struct wf_6690_sensor, i2c)
+
+static int wf_max6690_attach(struct i2c_adapter *adapter);
+static int wf_max6690_detach(struct i2c_client *client);
+
+static struct i2c_driver wf_max6690_driver = {
+        .driver = {
+                .name           = "wf_max6690",
+        },
+        .attach_adapter = wf_max6690_attach,
+        .detach_client  = wf_max6690_detach,
+};
+
+static int wf_max6690_get(struct wf_sensor *sr, s32 *value)
+{
+        struct wf_6690_sensor *max = wf_to_6690(sr);
+        s32 data;
+
+        if (max->i2c.adapter == NULL)
+                return -ENODEV;
+
+        /* chip gets initialized by firmware */
+        data = i2c_smbus_read_byte_data(&max->i2c, MAX6690_EXTERNAL_TEMP);
+        if (data < 0)
+                return data;
+        *value = data << 16;
+        return 0;
+}
+
+static void wf_max6690_release(struct wf_sensor *sr)
+{
+        struct wf_6690_sensor *max = wf_to_6690(sr);
+
+        if (max->i2c.adapter) {
+                i2c_detach_client(&max->i2c);
+                max->i2c.adapter = NULL;
+        }
+        kfree(max);
+}
+
+static struct wf_sensor_ops wf_max6690_ops = {
+        .get_value      = wf_max6690_get,
+        .release        = wf_max6690_release,
+        .owner          = THIS_MODULE,
+};
+
+static void wf_max6690_create(struct i2c_adapter *adapter, u8 addr)
+{
+        struct wf_6690_sensor *max;
+        char *name = "u4-temp";
+
+        max = kzalloc(sizeof(struct wf_6690_sensor), GFP_KERNEL);
+        if (max == NULL) {
+                printk(KERN_ERR "windfarm: Couldn't create MAX6690 sensor %s: "
+                       "no memory\n", name);
+                return;
+        }
+
+        max->sens.ops = &wf_max6690_ops;
+        max->sens.name = name;
+        max->i2c.addr = addr >> 1;
+        max->i2c.adapter = adapter;
+        max->i2c.driver = &wf_max6690_driver;
+        strncpy(max->i2c.name, name, I2C_NAME_SIZE-1);
+
+        if (i2c_attach_client(&max->i2c)) {
+                printk(KERN_ERR "windfarm: failed to attach MAX6690 sensor\n");
+                goto fail;
+        }
+
+        if (wf_register_sensor(&max->sens)) {
+                i2c_detach_client(&max->i2c);
+                goto fail;
+        }
+
+        return;
+
+ fail:
+        kfree(max);
+}
+
+static int wf_max6690_attach(struct i2c_adapter *adapter)
+{
+        struct device_node *busnode, *dev = NULL;
+        struct pmac_i2c_bus *bus;
+        const char *loc;
+        u32 *reg;
+
+        bus = pmac_i2c_adapter_to_bus(adapter);
+        if (bus == NULL)
+                return -ENODEV;
+        busnode = pmac_i2c_get_bus_node(bus);
+
+        while ((dev = of_get_next_child(busnode, dev)) != NULL) {
+                if (!device_is_compatible(dev, "max6690"))
+                        continue;
+                loc = get_property(dev, "hwsensor-location", NULL);
+                reg = (u32 *) get_property(dev, "reg", NULL);
+                if (!loc || !reg)
+                        continue;
+                printk("found max6690, loc=%s reg=%x\n", loc, *reg);
+                if (strcmp(loc, "BACKSIDE"))
+                        continue;
+                wf_max6690_create(adapter, *reg);
+        }
+
+        return 0;
+}
+
+static int wf_max6690_detach(struct i2c_client *client)
+{
+        struct wf_6690_sensor *max = i2c_to_6690(client);
+
+        max->i2c.adapter = NULL;
+        wf_unregister_sensor(&max->sens);
+
+        return 0;
+}
+
+static int __init wf_max6690_sensor_init(void)
+{
+        return i2c_add_driver(&wf_max6690_driver);
+}
+
+static void __exit wf_max6690_sensor_exit(void)
+{
+        i2c_del_driver(&wf_max6690_driver);
+}
+
+module_init(wf_max6690_sensor_init);
+module_exit(wf_max6690_sensor_exit);
+
+MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>");
+MODULE_DESCRIPTION("MAX6690 sensor objects for PowerMac thermal control");
+MODULE_LICENSE("GPL");
diff --git a/drivers/macintosh/windfarm_pid.c b/drivers/macintosh/windfarm_pid.c
index 2e803b368757..0842432e27ad 100644
--- a/drivers/macintosh/windfarm_pid.c
+++ b/drivers/macintosh/windfarm_pid.c
@@ -88,8 +88,8 @@ EXPORT_SYMBOL_GPL(wf_cpu_pid_init);
 
 s32 wf_cpu_pid_run(struct wf_cpu_pid_state *st, s32 new_power, s32 new_temp)
 {
-        s64     error, integ, deriv, prop;
-        s32     target, sval, adj;
+        s64     integ, deriv, prop;
+        s32     error, target, sval, adj;
         int     i, hlen = st->param.history_len;
 
         /* Calculate error term */
@@ -117,7 +117,7 @@ s32 wf_cpu_pid_run(struct wf_cpu_pid_state *st, s32 new_power, s32 new_temp)
                 integ += st->errors[(st->index + hlen - i) % hlen];
         integ *= st->param.interval;
         integ *= st->param.gr;
-        sval = st->param.tmax - ((integ >> 20) & 0xffffffff);
+        sval = st->param.tmax - (s32)(integ >> 20);
         adj = min(st->param.ttarget, sval);
 
         DBG("integ: %lx, sval: %lx, adj: %lx\n", integ, sval, adj);
@@ -129,7 +129,7 @@ s32 wf_cpu_pid_run(struct wf_cpu_pid_state *st, s32 new_power, s32 new_temp)
         deriv *= st->param.gd;
 
         /* Calculate proportional term */
-        prop = (new_temp - adj);
+        prop = st->last_delta = (new_temp - adj);
         prop *= st->param.gp;
 
         DBG("deriv: %lx, prop: %lx\n", deriv, prop);
diff --git a/drivers/macintosh/windfarm_pid.h b/drivers/macintosh/windfarm_pid.h
index a364c2a2499c..bbccc22d42b8 100644
--- a/drivers/macintosh/windfarm_pid.h
+++ b/drivers/macintosh/windfarm_pid.h
@@ -72,6 +72,7 @@ struct wf_cpu_pid_state {
         int     index;                          /* index of current power */
         int     tindex;                         /* index of current temp */
         s32     target;                         /* current target value */
+        s32     last_delta;                     /* last Tactual - Ttarget */
         s32     powers[WF_PID_MAX_HISTORY];     /* power history buffer */
         s32     errors[WF_PID_MAX_HISTORY];     /* error history buffer */
         s32     temps[2];                       /* temp. history buffer */
diff --git a/drivers/macintosh/windfarm_pm112.c b/drivers/macintosh/windfarm_pm112.c
new file mode 100644
index 000000000000..c2a4e689c784
--- /dev/null
+++ b/drivers/macintosh/windfarm_pm112.c
@@ -0,0 +1,698 @@
+/*
+ * Windfarm PowerMac thermal control.
+ * Control loops for machines with SMU and PPC970MP processors.
+ *
+ * Copyright (C) 2005 Paul Mackerras, IBM Corp. <paulus@samba.org>
+ * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corp.
+ *
+ * Use and redistribute under the terms of the GNU GPL v2.
+ */
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/reboot.h>
+#include <asm/prom.h>
+#include <asm/smu.h>
+
+#include "windfarm.h"
+#include "windfarm_pid.h"
+
+#define VERSION "0.2"
+
+#define DEBUG
+#undef LOTSA_DEBUG
+
+#ifdef DEBUG
+#define DBG(args...)    printk(args)
+#else
+#define DBG(args...)    do { } while(0)
+#endif
+
+#ifdef LOTSA_DEBUG
+#define DBG_LOTS(args...)       printk(args)
+#else
+#define DBG_LOTS(args...)       do { } while(0)
+#endif
+
+/* define this to force CPU overtemp to 60 degree, useful for testing
+ * the overtemp code
+ */
+#undef HACKED_OVERTEMP
+
+/* We currently only handle 2 chips, 4 cores... */
+#define NR_CHIPS        2
+#define NR_CORES        4
+#define NR_CPU_FANS     3 * NR_CHIPS
+
+/* Controls and sensors */
+static struct wf_sensor *sens_cpu_temp[NR_CORES];
+static struct wf_sensor *sens_cpu_power[NR_CORES];
+static struct wf_sensor *hd_temp;
+static struct wf_sensor *slots_power;
+static struct wf_sensor *u4_temp;
+
+static struct wf_control *cpu_fans[NR_CPU_FANS];
+static char *cpu_fan_names[NR_CPU_FANS] = {
+        "cpu-rear-fan-0",
+        "cpu-rear-fan-1",
+        "cpu-front-fan-0",
+        "cpu-front-fan-1",
+        "cpu-pump-0",
+        "cpu-pump-1",
+};
+static struct wf_control *cpufreq_clamp;
+
+/* Second pump isn't required (and isn't actually present) */
+#define CPU_FANS_REQD           (NR_CPU_FANS - 2)
+#define FIRST_PUMP              4
+#define LAST_PUMP               5
+
+/* We keep a temperature history for average calculation of 180s */
+#define CPU_TEMP_HIST_SIZE      180
+
+/* Scale factor for fan speed, *100 */
+static int cpu_fan_scale[NR_CPU_FANS] = {
+        100,
+        100,
+        97,             /* inlet fans run at 97% of exhaust fan */
+        97,
+        100,            /* updated later */
+        100,            /* updated later */
+};
+
+static struct wf_control *backside_fan;
+static struct wf_control *slots_fan;
+static struct wf_control *drive_bay_fan;
+
+/* PID loop state */
+static struct wf_cpu_pid_state cpu_pid[NR_CORES];
+static u32 cpu_thist[CPU_TEMP_HIST_SIZE];
+static int cpu_thist_pt;
+static s64 cpu_thist_total;
+static s32 cpu_all_tmax = 100 << 16;
+static int cpu_last_target;
+static struct wf_pid_state backside_pid;
+static int backside_tick;
+static struct wf_pid_state slots_pid;
+static int slots_started;
+static struct wf_pid_state drive_bay_pid;
+static int drive_bay_tick;
+
+static int nr_cores;
+static int have_all_controls;
+static int have_all_sensors;
+static int started;
+
+static int failure_state;
+#define FAILURE_SENSOR          1
+#define FAILURE_FAN             2
+#define FAILURE_PERM            4
+#define FAILURE_LOW_OVERTEMP    8
+#define FAILURE_HIGH_OVERTEMP   16
+
+/* Overtemp values */
+#define LOW_OVER_AVERAGE        0
+#define LOW_OVER_IMMEDIATE      (10 << 16)
+#define LOW_OVER_CLEAR          ((-10) << 16)
+#define HIGH_OVER_IMMEDIATE     (14 << 16)
+#define HIGH_OVER_AVERAGE       (10 << 16)
+#define HIGH_OVER_IMMEDIATE     (14 << 16)
+
+
+/* Implementation... */
+static int create_cpu_loop(int cpu)
+{
+        int chip = cpu / 2;
+        int core = cpu & 1;
+        struct smu_sdbp_header *hdr;
+        struct smu_sdbp_cpupiddata *piddata;
+        struct wf_cpu_pid_param pid;
+        struct wf_control *main_fan = cpu_fans[0];
+        s32 tmax;
+        int fmin;
+
+        /* Get PID params from the appropriate SAT */
+        hdr = smu_sat_get_sdb_partition(chip, 0xC8 + core, NULL);
+        if (hdr == NULL) {
+                printk(KERN_WARNING"windfarm: can't get CPU PID fan config\n");
+                return -EINVAL;
+        }
+        piddata = (struct smu_sdbp_cpupiddata *)&hdr[1];
+
+        /* Get FVT params to get Tmax; if not found, assume default */
+        hdr = smu_sat_get_sdb_partition(chip, 0xC4 + core, NULL);
+        if (hdr) {
+                struct smu_sdbp_fvt *fvt = (struct smu_sdbp_fvt *)&hdr[1];
+                tmax = fvt->maxtemp << 16;
+        } else
+                tmax = 95 << 16;        /* default to 95 degrees C */
+
+        /* We keep a global tmax for overtemp calculations */
+        if (tmax < cpu_all_tmax)
+                cpu_all_tmax = tmax;
+
+        /*
+         * Darwin has a minimum fan speed of 1000 rpm for the 4-way and
+         * 515 for the 2-way.  That appears to be overkill, so for now,
+         * impose a minimum of 750 or 515.
+         */
+        fmin = (nr_cores > 2) ? 750 : 515;
+
+        /* Initialize PID loop */
+        pid.interval = 1;       /* seconds */
+        pid.history_len = piddata->history_len;
+        pid.gd = piddata->gd;
+        pid.gp = piddata->gp;
+        pid.gr = piddata->gr / piddata->history_len;
+        pid.pmaxadj = (piddata->max_power << 16) - (piddata->power_adj << 8);
+        pid.ttarget = tmax - (piddata->target_temp_delta << 16);
+        pid.tmax = tmax;
+        pid.min = main_fan->ops->get_min(main_fan);
+        pid.max = main_fan->ops->get_max(main_fan);
+        if (pid.min < fmin)
+                pid.min = fmin;
+
+        wf_cpu_pid_init(&cpu_pid[cpu], &pid);
+        return 0;
+}
+
+static void cpu_max_all_fans(void)
+{
+        int i;
+
+        /* We max all CPU fans in case of a sensor error. We also do the
+         * cpufreq clamping now, even if it's supposedly done later by the
+         * generic code anyway, we do it earlier here to react faster
+         */
+        if (cpufreq_clamp)
+                wf_control_set_max(cpufreq_clamp);
+        for (i = 0; i < NR_CPU_FANS; ++i)
+                if (cpu_fans[i])
+                        wf_control_set_max(cpu_fans[i]);
+}
+
+static int cpu_check_overtemp(s32 temp)
+{
+        int new_state = 0;
+        s32 t_avg, t_old;
+
+        /* First check for immediate overtemps */
+        if (temp >= (cpu_all_tmax + LOW_OVER_IMMEDIATE)) {
+                new_state |= FAILURE_LOW_OVERTEMP;
+                if ((failure_state & FAILURE_LOW_OVERTEMP) == 0)
+                        printk(KERN_ERR "windfarm: Overtemp due to immediate CPU"
+                               " temperature !\n");
+        }
+        if (temp >= (cpu_all_tmax + HIGH_OVER_IMMEDIATE)) {
+                new_state |= FAILURE_HIGH_OVERTEMP;
+                if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0)
+                        printk(KERN_ERR "windfarm: Critical overtemp due to"
+                               " immediate CPU temperature !\n");
+        }
+
+        /* We calculate a history of max temperatures and use that for the
+         * overtemp management
+         */
+        t_old = cpu_thist[cpu_thist_pt];
+        cpu_thist[cpu_thist_pt] = temp;
+        cpu_thist_pt = (cpu_thist_pt + 1) % CPU_TEMP_HIST_SIZE;
+        cpu_thist_total -= t_old;
+        cpu_thist_total += temp;
+        t_avg = cpu_thist_total / CPU_TEMP_HIST_SIZE;
+
+        DBG_LOTS("t_avg = %d.%03d (out: %d.%03d, in: %d.%03d)\n",
+                 FIX32TOPRINT(t_avg), FIX32TOPRINT(t_old), FIX32TOPRINT(temp));
+
+        /* Now check for average overtemps */
+        if (t_avg >= (cpu_all_tmax + LOW_OVER_AVERAGE)) {
+                new_state |= FAILURE_LOW_OVERTEMP;
+                if ((failure_state & FAILURE_LOW_OVERTEMP) == 0)
+                        printk(KERN_ERR "windfarm: Overtemp due to average CPU"
+                               " temperature !\n");
+        }
+        if (t_avg >= (cpu_all_tmax + HIGH_OVER_AVERAGE)) {
+                new_state |= FAILURE_HIGH_OVERTEMP;
+                if ((failure_state & FAILURE_HIGH_OVERTEMP) == 0)
+                        printk(KERN_ERR "windfarm: Critical overtemp due to"
+                               " average CPU temperature !\n");
+        }
+
+        /* Now handle overtemp conditions. We don't currently use the windfarm
+         * overtemp handling core as it's not fully suited to the needs of those
+         * new machine. This will be fixed later.
+         */
+        if (new_state) {
+                /* High overtemp -> immediate shutdown */
+                if (new_state & FAILURE_HIGH_OVERTEMP)
+                        machine_power_off();
+                if ((failure_state & new_state) != new_state)
+                        cpu_max_all_fans();
+                failure_state |= new_state;
+        } else if ((failure_state & FAILURE_LOW_OVERTEMP) &&
+                   (temp < (cpu_all_tmax + LOW_OVER_CLEAR))) {
+                printk(KERN_ERR "windfarm: Overtemp condition cleared !\n");
+                failure_state &= ~FAILURE_LOW_OVERTEMP;
+        }
+
+        return failure_state & (FAILURE_LOW_OVERTEMP | FAILURE_HIGH_OVERTEMP);
+}
+
+static void cpu_fans_tick(void)
+{
+        int err, cpu;
+        s32 greatest_delta = 0;
+        s32 temp, power, t_max = 0;
+        int i, t, target = 0;
+        struct wf_sensor *sr;
+        struct wf_control *ct;
+        struct wf_cpu_pid_state *sp;
+
+        DBG_LOTS(KERN_DEBUG);
+        for (cpu = 0; cpu < nr_cores; ++cpu) {
+                /* Get CPU core temperature */
+                sr = sens_cpu_temp[cpu];
+                err = sr->ops->get_value(sr, &temp);
+                if (err) {
+                        DBG("\n");
+                        printk(KERN_WARNING "windfarm: CPU %d temperature "
+                               "sensor error %d\n", cpu, err);
+                        failure_state |= FAILURE_SENSOR;
+                        cpu_max_all_fans();
+                        return;
+                }
+
+                /* Keep track of highest temp */
+                t_max = max(t_max, temp);
+
+                /* Get CPU power */
+                sr = sens_cpu_power[cpu];
+                err = sr->ops->get_value(sr, &power);
+                if (err) {
+                        DBG("\n");
+                        printk(KERN_WARNING "windfarm: CPU %d power "
+                               "sensor error %d\n", cpu, err);
+                        failure_state |= FAILURE_SENSOR;
+                        cpu_max_all_fans();
+                        return;
+                }
+
+                /* Run PID */
+                sp = &cpu_pid[cpu];
+                t = wf_cpu_pid_run(sp, power, temp);
+
+                if (cpu == 0 || sp->last_delta > greatest_delta) {
+                        greatest_delta = sp->last_delta;
+                        target = t;
+                }
+                DBG_LOTS("[%d] P=%d.%.3d T=%d.%.3d ",
+                    cpu, FIX32TOPRINT(power), FIX32TOPRINT(temp));
+        }
+        DBG_LOTS("fans = %d, t_max = %d.%03d\n", target, FIX32TOPRINT(t_max));
+
+        /* Darwin limits decrease to 20 per iteration */
+        if (target < (cpu_last_target - 20))
+                target = cpu_last_target - 20;
+        cpu_last_target = target;
+        for (cpu = 0; cpu < nr_cores; ++cpu)
+                cpu_pid[cpu].target = target;
+
+        /* Handle possible overtemps */
+        if (cpu_check_overtemp(t_max))
+                return;
+
+        /* Set fans */
+        for (i = 0; i < NR_CPU_FANS; ++i) {
+                ct = cpu_fans[i];
+                if (ct == NULL)
+                        continue;
+                err = ct->ops->set_value(ct, target * cpu_fan_scale[i] / 100);
+                if (err) {
+                        printk(KERN_WARNING "windfarm: fan %s reports "
+                               "error %d\n", ct->name, err);
+                        failure_state |= FAILURE_FAN;
+                        break;
+                }
+        }
+}
+
+/* Backside/U4 fan */
+static struct wf_pid_param backside_param = {
+        .interval       = 5,
+        .history_len    = 2,
+        .gd             = 48 << 20,
+        .gp             = 5 << 20,
+        .gr             = 0,
+        .itarget        = 64 << 16,
+        .additive       = 1,
+};
+
+static void backside_fan_tick(void)
+{
+        s32 temp;
+        int speed;
+        int err;
+
+        if (!backside_fan || !u4_temp)
+                return;
+        if (!backside_tick) {
+                /* first time; initialize things */
+                backside_param.min = backside_fan->ops->get_min(backside_fan);
+                backside_param.max = backside_fan->ops->get_max(backside_fan);
+                wf_pid_init(&backside_pid, &backside_param);
+                backside_tick = 1;
+        }
+        if (--backside_tick > 0)
+                return;
+        backside_tick = backside_pid.param.interval;
+
+        err = u4_temp->ops->get_value(u4_temp, &temp);
+        if (err) {
+                printk(KERN_WARNING "windfarm: U4 temp sensor error %d\n",
+                       err);
+                failure_state |= FAILURE_SENSOR;
+                wf_control_set_max(backside_fan);
+                return;
+        }
+        speed = wf_pid_run(&backside_pid, temp);
+        DBG_LOTS("backside PID temp=%d.%.3d speed=%d\n",
+                 FIX32TOPRINT(temp), speed);
+
+        err = backside_fan->ops->set_value(backside_fan, speed);
+        if (err) {
+                printk(KERN_WARNING "windfarm: backside fan error %d\n", err);
+                failure_state |= FAILURE_FAN;
+        }
+}
+
+/* Drive bay fan */
+static struct wf_pid_param drive_bay_prm = {
+        .interval       = 5,
+        .history_len    = 2,
+        .gd             = 30 << 20,
+        .gp             = 5 << 20,
+        .gr             = 0,
+        .itarget        = 40 << 16,
+        .additive       = 1,
+};
+
+static void drive_bay_fan_tick(void)
+{
+        s32 temp;
+        int speed;
+        int err;
+
+        if (!drive_bay_fan || !hd_temp)
+                return;
+        if (!drive_bay_tick) {
+                /* first time; initialize things */
+                drive_bay_prm.min = drive_bay_fan->ops->get_min(drive_bay_fan);
+                drive_bay_prm.max = drive_bay_fan->ops->get_max(drive_bay_fan);
+                wf_pid_init(&drive_bay_pid, &drive_bay_prm);
+                drive_bay_tick = 1;
+        }
+        if (--drive_bay_tick > 0)
+                return;
+        drive_bay_tick = drive_bay_pid.param.interval;
+
+        err = hd_temp->ops->get_value(hd_temp, &temp);
+        if (err) {
+                printk(KERN_WARNING "windfarm: drive bay temp sensor "
+                       "error %d\n", err);
+                failure_state |= FAILURE_SENSOR;
+                wf_control_set_max(drive_bay_fan);
+                return;
+        }
+        speed = wf_pid_run(&drive_bay_pid, temp);
+        DBG_LOTS("drive_bay PID temp=%d.%.3d speed=%d\n",
+                 FIX32TOPRINT(temp), speed);
+
+        err = drive_bay_fan->ops->set_value(drive_bay_fan, speed);
+        if (err) {
+                printk(KERN_WARNING "windfarm: drive bay fan error %d\n", err);
+                failure_state |= FAILURE_FAN;
+        }
+}
+
+/* PCI slots area fan */
+/* This makes the fan speed proportional to the power consumed */
+static struct wf_pid_param slots_param = {
+        .interval       = 1,
+        .history_len    = 2,
+        .gd             = 0,
+        .gp             = 0,
+        .gr             = 0x1277952,
+        .itarget        = 0,
+        .min            = 1560,
+        .max            = 3510,
+};
+
+static void slots_fan_tick(void)
+{
+        s32 power;
+        int speed;
+        int err;
+
+        if (!slots_fan || !slots_power)
+                return;
+        if (!slots_started) {
+                /* first time; initialize things */
+                wf_pid_init(&slots_pid, &slots_param);
+                slots_started = 1;
+        }
+
+        err = slots_power->ops->get_value(slots_power, &power);
+        if (err) {
+                printk(KERN_WARNING "windfarm: slots power sensor error %d\n",
+                       err);
+                failure_state |= FAILURE_SENSOR;
+                wf_control_set_max(slots_fan);
+                return;
+        }
+        speed = wf_pid_run(&slots_pid, power);
+        DBG_LOTS("slots PID power=%d.%.3d speed=%d\n",
+                 FIX32TOPRINT(power), speed);
+
+        err = slots_fan->ops->set_value(slots_fan, speed);
+        if (err) {
+                printk(KERN_WARNING "windfarm: slots fan error %d\n", err);
+                failure_state |= FAILURE_FAN;
+        }
+}
+
+static void set_fail_state(void)
+{
+        int i;
+
+        if (cpufreq_clamp)
+                wf_control_set_max(cpufreq_clamp);
+        for (i = 0; i < NR_CPU_FANS; ++i)
+                if (cpu_fans[i])
+                        wf_control_set_max(cpu_fans[i]);
+        if (backside_fan)
+                wf_control_set_max(backside_fan);
+        if (slots_fan)
+                wf_control_set_max(slots_fan);
+        if (drive_bay_fan)
+                wf_control_set_max(drive_bay_fan);
+}
+
+static void pm112_tick(void)
+{
+        int i, last_failure;
+
+        if (!started) {
+                started = 1;
+                for (i = 0; i < nr_cores; ++i) {
+                        if (create_cpu_loop(i) < 0) {
+                                failure_state = FAILURE_PERM;
+                                set_fail_state();
+                                break;
+                        }
+                }
+                DBG_LOTS("cpu_all_tmax=%d.%03d\n", FIX32TOPRINT(cpu_all_tmax));
+
+#ifdef HACKED_OVERTEMP
+                cpu_all_tmax = 60 << 16;
+#endif
+        }
+
+        /* Permanent failure, bail out */
+        if (failure_state & FAILURE_PERM)
+                return;
+        /* Clear all failure bits except low overtemp which will be eventually
+         * cleared by the control loop itself
+         */
+        last_failure = failure_state;
+        failure_state &= FAILURE_LOW_OVERTEMP;
+        cpu_fans_tick();
+        backside_fan_tick();
+        slots_fan_tick();
+        drive_bay_fan_tick();
+
+        DBG_LOTS("last_failure: 0x%x, failure_state: %x\n",
+                 last_failure, failure_state);
+
+        /* Check for failures. Any failure causes cpufreq clamping */
+        if (failure_state && last_failure == 0 && cpufreq_clamp)
+                wf_control_set_max(cpufreq_clamp);
+        if (failure_state == 0 && last_failure && cpufreq_clamp)
+                wf_control_set_min(cpufreq_clamp);
+
+        /* That's it for now, we might want to deal with other failures
+         * differently in the future though
+         */
+}
+
+static void pm112_new_control(struct wf_control *ct)
+{
+        int i, max_exhaust;
+
+        if (cpufreq_clamp == NULL && !strcmp(ct->name, "cpufreq-clamp")) {
+                if (wf_get_control(ct) == 0)
+                        cpufreq_clamp = ct;
+        }
+
+        for (i = 0; i < NR_CPU_FANS; ++i) {
+                if (!strcmp(ct->name, cpu_fan_names[i])) {
+                        if (cpu_fans[i] == NULL && wf_get_control(ct) == 0)
+                                cpu_fans[i] = ct;
+                        break;
+                }
+        }
+        if (i >= NR_CPU_FANS) {
+                /* not a CPU fan, try the others */
+                if (!strcmp(ct->name, "backside-fan")) {
+                        if (backside_fan == NULL && wf_get_control(ct) == 0)
+                                backside_fan = ct;
+                } else if (!strcmp(ct->name, "slots-fan")) {
+                        if (slots_fan == NULL && wf_get_control(ct) == 0)
+                                slots_fan = ct;
+                } else if (!strcmp(ct->name, "drive-bay-fan")) {
+                        if (drive_bay_fan == NULL && wf_get_control(ct) == 0)
+                                drive_bay_fan = ct;
+                }
+                return;
+        }
+
+        for (i = 0; i < CPU_FANS_REQD; ++i)
+                if (cpu_fans[i] == NULL)
+                        return;
+
+        /* work out pump scaling factors */
+        max_exhaust = cpu_fans[0]->ops->get_max(cpu_fans[0]);
+        for (i = FIRST_PUMP; i <= LAST_PUMP; ++i)
+                if ((ct = cpu_fans[i]) != NULL)
+                        cpu_fan_scale[i] =
+                                ct->ops->get_max(ct) * 100 / max_exhaust;
+
+        have_all_controls = 1;
+}
+
+static void pm112_new_sensor(struct wf_sensor *sr)
+{
+        unsigned int i;
+
+        if (have_all_sensors)
+                return;
+        if (!strncmp(sr->name, "cpu-temp-", 9)) {
+                i = sr->name[9] - '0';
+                if (sr->name[10] == 0 && i < NR_CORES &&
+                    sens_cpu_temp[i] == NULL && wf_get_sensor(sr) == 0)
+                        sens_cpu_temp[i] = sr;
+
+        } else if (!strncmp(sr->name, "cpu-power-", 10)) {
+                i = sr->name[10] - '0';
+                if (sr->name[11] == 0 && i < NR_CORES &&
+                    sens_cpu_power[i] == NULL && wf_get_sensor(sr) == 0)
+                        sens_cpu_power[i] = sr;
+        } else if (!strcmp(sr->name, "hd-temp")) {
+                if (hd_temp == NULL && wf_get_sensor(sr) == 0)
+                        hd_temp = sr;
+        } else if (!strcmp(sr->name, "slots-power")) {
+                if (slots_power == NULL && wf_get_sensor(sr) == 0)
+                        slots_power = sr;
+        } else if (!strcmp(sr->name, "u4-temp")) {
+                if (u4_temp == NULL && wf_get_sensor(sr) == 0)
+                        u4_temp = sr;
+        } else
+                return;
+
+        /* check if we have all the sensors we need */
+        for (i = 0; i < nr_cores; ++i)
+                if (sens_cpu_temp[i] == NULL || sens_cpu_power[i] == NULL)
+                        return;
+
+        have_all_sensors = 1;
+}
+
+static int pm112_wf_notify(struct notifier_block *self,
+                           unsigned long event, void *data)
+{
+        switch (event) {
+        case WF_EVENT_NEW_SENSOR:
+                pm112_new_sensor(data);
+                break;
+        case WF_EVENT_NEW_CONTROL:
+                pm112_new_control(data);
+                break;
+        case WF_EVENT_TICK:
+                if (have_all_controls && have_all_sensors)
+                        pm112_tick();
+        }
+        return 0;
+}
+
+static struct notifier_block pm112_events = {
+        .notifier_call = pm112_wf_notify,
+};
+
+static int wf_pm112_probe(struct device *dev)
+{
+        wf_register_client(&pm112_events);
+        return 0;
+}
+
+static int wf_pm112_remove(struct device *dev)
+{
+        wf_unregister_client(&pm112_events);
+        /* should release all sensors and controls */
+        return 0;
+}
+
+static struct device_driver wf_pm112_driver = {
+        .name = "windfarm",
+        .bus = &platform_bus_type,
+        .probe = wf_pm112_probe,
+        .remove = wf_pm112_remove,
+};
+
+static int __init wf_pm112_init(void)
+{
+        struct device_node *cpu;
+
+        if (!machine_is_compatible("PowerMac11,2"))
+                return -ENODEV;
+
+        /* Count the number of CPU cores */
+        nr_cores = 0;
+        for (cpu = NULL; (cpu = of_find_node_by_type(cpu, "cpu")) != NULL; )
+                ++nr_cores;
+
+        printk(KERN_INFO "windfarm: initializing for dual-core desktop G5\n");
+        driver_register(&wf_pm112_driver);
+        return 0;
+}
+
+static void __exit wf_pm112_exit(void)
+{
+        driver_unregister(&wf_pm112_driver);
+}
+
+module_init(wf_pm112_init);
+module_exit(wf_pm112_exit);
+
+MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>");
+MODULE_DESCRIPTION("Thermal control for PowerMac11,2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/macintosh/windfarm_pm81.c b/drivers/macintosh/windfarm_pm81.c
index eb69a601e765..f1df6efcbe68 100644
--- a/drivers/macintosh/windfarm_pm81.c
+++ b/drivers/macintosh/windfarm_pm81.c
@@ -538,45 +538,6 @@ static void wf_smu_cpu_fans_tick(struct wf_smu_cpu_fans_state *st)
         }
 }
 
-
-/*
- * ****** Attributes ******
- *
- */
-
-#define BUILD_SHOW_FUNC_FIX(name, data)                         \
-static ssize_t show_##name(struct device *dev,                  \
-                           struct device_attribute *attr,       \
-                           char *buf)                           \
-{                                                               \
-        ssize_t r;                                              \
-        s32 val = 0;                                            \
-        data->ops->get_value(data, &val);                       \
-        r = sprintf(buf, "%d.%03d", FIX32TOPRINT(val));         \
-        return r;                                               \
-}                                                               \
-static DEVICE_ATTR(name,S_IRUGO,show_##name, NULL);
-
-
-#define BUILD_SHOW_FUNC_INT(name, data)                         \
-static ssize_t show_##name(struct device *dev,                  \
-                           struct device_attribute *attr,       \
-                           char *buf)                           \
-{                                                               \
-        s32 val = 0;                                            \
-        data->ops->get_value(data, &val);                       \
-        return sprintf(buf, "%d", val);                         \
-}                                                               \
-static DEVICE_ATTR(name,S_IRUGO,show_##name, NULL);
-
-BUILD_SHOW_FUNC_INT(cpu_fan, fan_cpu_main);
-BUILD_SHOW_FUNC_INT(sys_fan, fan_system);
-BUILD_SHOW_FUNC_INT(hd_fan, fan_hd);
-
-BUILD_SHOW_FUNC_FIX(cpu_temp, sensor_cpu_temp);
-BUILD_SHOW_FUNC_FIX(cpu_power, sensor_cpu_power);
-BUILD_SHOW_FUNC_FIX(hd_temp, sensor_hd_temp);
-
 /*
  * ****** Setup / Init / Misc ... ******
  *
@@ -654,17 +615,13 @@ static void wf_smu_new_control(struct wf_control *ct)
                 return;
 
         if (fan_cpu_main == NULL && !strcmp(ct->name, "cpu-fan")) {
-                if (wf_get_control(ct) == 0) {
+                if (wf_get_control(ct) == 0)
                         fan_cpu_main = ct;
-                        device_create_file(wf_smu_dev, &dev_attr_cpu_fan);
-                }
         }
 
         if (fan_system == NULL && !strcmp(ct->name, "system-fan")) {
-                if (wf_get_control(ct) == 0) {
+                if (wf_get_control(ct) == 0)
                         fan_system = ct;
-                        device_create_file(wf_smu_dev, &dev_attr_sys_fan);
-                }
         }
 
         if (cpufreq_clamp == NULL && !strcmp(ct->name, "cpufreq-clamp")) {
@@ -683,10 +640,8 @@ static void wf_smu_new_control(struct wf_control *ct)
         }
 
         if (fan_hd == NULL && !strcmp(ct->name, "drive-bay-fan")) {
-                if (wf_get_control(ct) == 0) {
+                if (wf_get_control(ct) == 0)
                         fan_hd = ct;
-                        device_create_file(wf_smu_dev, &dev_attr_hd_fan);
-                }
         }
 
         if (fan_system && fan_hd && fan_cpu_main && cpufreq_clamp)
@@ -699,24 +654,18 @@ static void wf_smu_new_sensor(struct wf_sensor *sr)
                 return;
 
         if (sensor_cpu_power == NULL && !strcmp(sr->name, "cpu-power")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_cpu_power = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_cpu_power);
-                }
         }
 
         if (sensor_cpu_temp == NULL && !strcmp(sr->name, "cpu-temp")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_cpu_temp = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_cpu_temp);
-                }
         }
 
         if (sensor_hd_temp == NULL && !strcmp(sr->name, "hd-temp")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_hd_temp = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_hd_temp);
-                }
         }
 
         if (sensor_cpu_power && sensor_cpu_temp && sensor_hd_temp)
@@ -794,32 +743,20 @@ static int wf_smu_remove(struct device *ddev)
          * with that except by adding locks all over... I'll do that
          * eventually but heh, who ever rmmod this module anyway ?
          */
-        if (sensor_cpu_power) {
-                device_remove_file(wf_smu_dev, &dev_attr_cpu_power);
+        if (sensor_cpu_power)
                 wf_put_sensor(sensor_cpu_power);
-        }
-        if (sensor_cpu_temp) {
-                device_remove_file(wf_smu_dev, &dev_attr_cpu_temp);
+        if (sensor_cpu_temp)
                 wf_put_sensor(sensor_cpu_temp);
-        }
-        if (sensor_hd_temp) {
-                device_remove_file(wf_smu_dev, &dev_attr_hd_temp);
+        if (sensor_hd_temp)
                 wf_put_sensor(sensor_hd_temp);
-        }
 
         /* Release all controls */
-        if (fan_cpu_main) {
-                device_remove_file(wf_smu_dev, &dev_attr_cpu_fan);
+        if (fan_cpu_main)
                 wf_put_control(fan_cpu_main);
-        }
-        if (fan_hd) {
-                device_remove_file(wf_smu_dev, &dev_attr_hd_fan);
+        if (fan_hd)
                 wf_put_control(fan_hd);
-        }
-        if (fan_system) {
-                device_remove_file(wf_smu_dev, &dev_attr_sys_fan);
+        if (fan_system)
                 wf_put_control(fan_system);
-        }
         if (cpufreq_clamp)
                 wf_put_control(cpufreq_clamp);
 
diff --git a/drivers/macintosh/windfarm_pm91.c b/drivers/macintosh/windfarm_pm91.c
index 43243cf7410b..0d6372e96d32 100644
--- a/drivers/macintosh/windfarm_pm91.c
+++ b/drivers/macintosh/windfarm_pm91.c
@@ -458,45 +458,6 @@ static void wf_smu_slots_fans_tick(struct wf_smu_slots_fans_state *st)
 
 
 /*
- * ****** Attributes ******
- *
- */
-
-#define BUILD_SHOW_FUNC_FIX(name, data)                         \
-static ssize_t show_##name(struct device *dev,                  \
-                           struct device_attribute *attr,       \
-                           char *buf)                           \
-{                                                               \
-        ssize_t r;                                              \
-        s32 val = 0;                                            \
-        data->ops->get_value(data, &val);                       \
-        r = sprintf(buf, "%d.%03d", FIX32TOPRINT(val));         \
-        return r;                                               \
-}                                                               \
-static DEVICE_ATTR(name,S_IRUGO,show_##name, NULL);
-
-
-#define BUILD_SHOW_FUNC_INT(name, data)                         \
-static ssize_t show_##name(struct device *dev,                  \
-                           struct device_attribute *attr,       \
-                           char *buf)                           \
-{                                                               \
-        s32 val = 0;                                            \
-        data->ops->get_value(data, &val);                       \
-        return sprintf(buf, "%d", val);                         \
-}                                                               \
-static DEVICE_ATTR(name,S_IRUGO,show_##name, NULL);
-
-BUILD_SHOW_FUNC_INT(cpu_fan, fan_cpu_main);
-BUILD_SHOW_FUNC_INT(hd_fan, fan_hd);
-BUILD_SHOW_FUNC_INT(slots_fan, fan_slots);
-
-BUILD_SHOW_FUNC_FIX(cpu_temp, sensor_cpu_temp);
-BUILD_SHOW_FUNC_FIX(cpu_power, sensor_cpu_power);
-BUILD_SHOW_FUNC_FIX(hd_temp, sensor_hd_temp);
-BUILD_SHOW_FUNC_FIX(slots_power, sensor_slots_power);
-
-/*
  * ****** Setup / Init / Misc ... ******
  *
  */
@@ -581,10 +542,8 @@ static void wf_smu_new_control(struct wf_control *ct)
                 return;
 
         if (fan_cpu_main == NULL && !strcmp(ct->name, "cpu-rear-fan-0")) {
-                if (wf_get_control(ct) == 0) {
+                if (wf_get_control(ct) == 0)
                         fan_cpu_main = ct;
-                        device_create_file(wf_smu_dev, &dev_attr_cpu_fan);
-                }
         }
 
         if (fan_cpu_second == NULL && !strcmp(ct->name, "cpu-rear-fan-1")) {
@@ -603,17 +562,13 @@ static void wf_smu_new_control(struct wf_control *ct)
         }
 
         if (fan_hd == NULL && !strcmp(ct->name, "drive-bay-fan")) {
-                if (wf_get_control(ct) == 0) {
+                if (wf_get_control(ct) == 0)
                         fan_hd = ct;
-                        device_create_file(wf_smu_dev, &dev_attr_hd_fan);
-                }
         }
 
         if (fan_slots == NULL && !strcmp(ct->name, "slots-fan")) {
-                if (wf_get_control(ct) == 0) {
+                if (wf_get_control(ct) == 0)
                         fan_slots = ct;
-                        device_create_file(wf_smu_dev, &dev_attr_slots_fan);
-                }
         }
 
         if (fan_cpu_main && (fan_cpu_second || fan_cpu_third) && fan_hd &&
@@ -627,31 +582,23 @@ static void wf_smu_new_sensor(struct wf_sensor *sr)
                 return;
 
         if (sensor_cpu_power == NULL && !strcmp(sr->name, "cpu-power")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_cpu_power = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_cpu_power);
-                }
         }
 
         if (sensor_cpu_temp == NULL && !strcmp(sr->name, "cpu-temp")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_cpu_temp = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_cpu_temp);
-                }
         }
 
         if (sensor_hd_temp == NULL && !strcmp(sr->name, "hd-temp")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_hd_temp = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_hd_temp);
-                }
         }
 
         if (sensor_slots_power == NULL && !strcmp(sr->name, "slots-power")) {
-                if (wf_get_sensor(sr) == 0) {
+                if (wf_get_sensor(sr) == 0)
                         sensor_slots_power = sr;
-                        device_create_file(wf_smu_dev, &dev_attr_slots_power);
-                }
         }
 
         if (sensor_cpu_power && sensor_cpu_temp &&
@@ -720,40 +667,26 @@ static int wf_smu_remove(struct device *ddev)
          * with that except by adding locks all over... I'll do that
          * eventually but heh, who ever rmmod this module anyway ?
          */
-        if (sensor_cpu_power) {
-                device_remove_file(wf_smu_dev, &dev_attr_cpu_power);
+        if (sensor_cpu_power)
                 wf_put_sensor(sensor_cpu_power);
-        }
-        if (sensor_cpu_temp) {
-                device_remove_file(wf_smu_dev, &dev_attr_cpu_temp);
+        if (sensor_cpu_temp)
                 wf_put_sensor(sensor_cpu_temp);
-        }
-        if (sensor_hd_temp) {
-                device_remove_file(wf_smu_dev, &dev_attr_hd_temp);
+        if (sensor_hd_temp)
                 wf_put_sensor(sensor_hd_temp);
-        }
-        if (sensor_slots_power) {
-                device_remove_file(wf_smu_dev, &dev_attr_slots_power);
+        if (sensor_slots_power)
                 wf_put_sensor(sensor_slots_power);
-        }
 
         /* Release all controls */
-        if (fan_cpu_main) {
-                device_remove_file(wf_smu_dev, &dev_attr_cpu_fan);
+        if (fan_cpu_main)
                 wf_put_control(fan_cpu_main);
-        }
         if (fan_cpu_second)
                 wf_put_control(fan_cpu_second);
         if (fan_cpu_third)
                 wf_put_control(fan_cpu_third);
-        if (fan_hd) {
-                device_remove_file(wf_smu_dev, &dev_attr_hd_fan);
+        if (fan_hd)
                 wf_put_control(fan_hd);
-        }
-        if (fan_slots) {
-                device_remove_file(wf_smu_dev, &dev_attr_slots_fan);
+        if (fan_slots)
                 wf_put_control(fan_slots);
-        }
         if (cpufreq_clamp)
                 wf_put_control(cpufreq_clamp);
 
diff --git a/drivers/macintosh/windfarm_smu_controls.c b/drivers/macintosh/windfarm_smu_controls.c
index 4d811600bdab..a9e88edc0c72 100644
--- a/drivers/macintosh/windfarm_smu_controls.c
+++ b/drivers/macintosh/windfarm_smu_controls.c
@@ -24,7 +24,7 @@
 
 #include "windfarm.h"
 
-#define VERSION "0.3"
+#define VERSION "0.4"
 
 #undef DEBUG
 
@@ -34,6 +34,8 @@
 #define DBG(args...)    do { } while(0)
 #endif
 
+static int smu_supports_new_fans_ops = 1;
+
 /*
  * SMU fans control object
  */
@@ -59,23 +61,49 @@ static int smu_set_fan(int pwm, u8 id, u16 value)
 
         /* Fill SMU command structure */
         cmd.cmd = SMU_CMD_FAN_COMMAND;
-        cmd.data_len = 14;
+
+        /* The SMU has an "old" and a "new" way of setting the fan speed
+         * Unfortunately, I found no reliable way to know which one works
+         * on a given machine model. After some investigations it appears
+         * that MacOS X just tries the new one, and if it fails fallbacks
+         * to the old ones ... Ugh.
+         */
+ retry:
+        if (smu_supports_new_fans_ops) {
+                buffer[0] = 0x30;
+                buffer[1] = id;
+                *((u16 *)(&buffer[2])) = value;
+                cmd.data_len = 4;
+        } else {
+                if (id > 7)
+                        return -EINVAL;
+                /* Fill argument buffer */
+                memset(buffer, 0, 16);
+                buffer[0] = pwm ? 0x10 : 0x00;
+                buffer[1] = 0x01 << id;
+                *((u16 *)&buffer[2 + id * 2]) = value;
+                cmd.data_len = 14;
+        }
+
         cmd.reply_len = 16;
         cmd.data_buf = cmd.reply_buf = buffer;
         cmd.status = 0;
         cmd.done = smu_done_complete;
         cmd.misc = &comp;
 
-        /* Fill argument buffer */
-        memset(buffer, 0, 16);
-        buffer[0] = pwm ? 0x10 : 0x00;
-        buffer[1] = 0x01 << id;
-        *((u16 *)&buffer[2 + id * 2]) = value;
-
         rc = smu_queue_cmd(&cmd);
         if (rc)
                 return rc;
         wait_for_completion(&comp);
+
+        /* Handle fallback (see coment above) */
+        if (cmd.status != 0 && smu_supports_new_fans_ops) {
+                printk(KERN_WARNING "windfarm: SMU failed new fan command "
+                       "falling back to old method\n");
+                smu_supports_new_fans_ops = 0;
+                goto retry;
+        }
+
         return cmd.status;
 }
 
@@ -158,19 +186,29 @@ static struct smu_fan_control *smu_fan_create(struct device_node *node,
 
         /* Names used on desktop models */
         if (!strcmp(l, "Rear Fan 0") || !strcmp(l, "Rear Fan") ||
-            !strcmp(l, "Rear fan 0") || !strcmp(l, "Rear fan"))
+            !strcmp(l, "Rear fan 0") || !strcmp(l, "Rear fan") ||
+            !strcmp(l, "CPU A EXHAUST"))
                 fct->ctrl.name = "cpu-rear-fan-0";
-        else if (!strcmp(l, "Rear Fan 1") || !strcmp(l, "Rear fan 1"))
+        else if (!strcmp(l, "Rear Fan 1") || !strcmp(l, "Rear fan 1") ||
+                 !strcmp(l, "CPU B EXHAUST"))
                 fct->ctrl.name = "cpu-rear-fan-1";
         else if (!strcmp(l, "Front Fan 0") || !strcmp(l, "Front Fan") ||
-                 !strcmp(l, "Front fan 0") || !strcmp(l, "Front fan"))
+                 !strcmp(l, "Front fan 0") || !strcmp(l, "Front fan") ||
+                 !strcmp(l, "CPU A INTAKE"))
                 fct->ctrl.name = "cpu-front-fan-0";
-        else if (!strcmp(l, "Front Fan 1") || !strcmp(l, "Front fan 1"))
+        else if (!strcmp(l, "Front Fan 1") || !strcmp(l, "Front fan 1") ||
+                 !strcmp(l, "CPU B INTAKE"))
                 fct->ctrl.name = "cpu-front-fan-1";
-        else if (!strcmp(l, "Slots Fan") || !strcmp(l, "Slots fan"))
+        else if (!strcmp(l, "CPU A PUMP"))
+                fct->ctrl.name = "cpu-pump-0";
+        else if (!strcmp(l, "Slots Fan") || !strcmp(l, "Slots fan") ||
+                 !strcmp(l, "EXPANSION SLOTS INTAKE"))
                 fct->ctrl.name = "slots-fan";
-        else if (!strcmp(l, "Drive Bay") || !strcmp(l, "Drive bay"))
+        else if (!strcmp(l, "Drive Bay") || !strcmp(l, "Drive bay") ||
+                 !strcmp(l, "DRIVE BAY A INTAKE"))
                 fct->ctrl.name = "drive-bay-fan";
+        else if (!strcmp(l, "BACKSIDE"))
+                fct->ctrl.name = "backside-fan";
 
         /* Names used on iMac models */
         if (!strcmp(l, "System Fan") || !strcmp(l, "System fan"))
@@ -223,7 +261,8 @@ static int __init smu_controls_init(void)
 
         /* Look for RPM fans */
         for (fans = NULL; (fans = of_get_next_child(smu, fans)) != NULL;)
-                if (!strcmp(fans->name, "rpm-fans"))
+                if (!strcmp(fans->name, "rpm-fans") ||
+                    device_is_compatible(fans, "smu-rpm-fans"))
                         break;
         for (fan = NULL;
              fans && (fan = of_get_next_child(fans, fan)) != NULL;) {
diff --git a/drivers/macintosh/windfarm_smu_sat.c b/drivers/macintosh/windfarm_smu_sat.c
new file mode 100644
index 000000000000..3a32c59494f2
--- /dev/null
+++ b/drivers/macintosh/windfarm_smu_sat.c
@@ -0,0 +1,418 @@
+/*
+ * Windfarm PowerMac thermal control.  SMU "satellite" controller sensors.
+ *
+ * Copyright (C) 2005 Paul Mackerras, IBM Corp. <paulus@samba.org>
+ *
+ * Released under the terms of the GNU GPL v2.
+ */
+
+#include <linux/types.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/wait.h>
+#include <linux/i2c.h>
+#include <linux/i2c-dev.h>
+#include <asm/semaphore.h>
+#include <asm/prom.h>
+#include <asm/smu.h>
+#include <asm/pmac_low_i2c.h>
+
+#include "windfarm.h"
+
+#define VERSION "0.2"
+
+#define DEBUG
+
+#ifdef DEBUG
+#define DBG(args...)    printk(args)
+#else
+#define DBG(args...)    do { } while(0)
+#endif
+
+/* If the cache is older than 800ms we'll refetch it */
+#define MAX_AGE         msecs_to_jiffies(800)
+
+struct wf_sat {
+        int                     nr;
+        atomic_t                refcnt;
+        struct semaphore        mutex;
+        unsigned long           last_read; /* jiffies when cache last updated */
+        u8                      cache[16];
+        struct i2c_client       i2c;
+        struct device_node      *node;
+};
+
+static struct wf_sat *sats[2];
+
+struct wf_sat_sensor {
+        int             index;
+        int             index2;         /* used for power sensors */
+        int             shift;
+        struct wf_sat   *sat;
+        struct wf_sensor sens;
+};
+
+#define wf_to_sat(c)    container_of(c, struct wf_sat_sensor, sens)
+#define i2c_to_sat(c)   container_of(c, struct wf_sat, i2c)
+
+static int wf_sat_attach(struct i2c_adapter *adapter);
+static int wf_sat_detach(struct i2c_client *client);
+
+static struct i2c_driver wf_sat_driver = {
+        .driver = {
+                .name           = "wf_smu_sat",
+        },
+        .attach_adapter = wf_sat_attach,
+        .detach_client  = wf_sat_detach,
+};
+
+/*
+ * XXX i2c_smbus_read_i2c_block_data doesn't pass the requested
+ * length down to the low-level driver, so we use this, which
+ * works well enough with the SMU i2c driver code...
+ */
+static int sat_read_block(struct i2c_client *client, u8 command,
+                          u8 *values, int len)
+{
+        union i2c_smbus_data data;
+        int err;
+
+        data.block[0] = len;
+        err = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
+                             I2C_SMBUS_READ, command, I2C_SMBUS_I2C_BLOCK_DATA,
+                             &data);
+        if (!err)
+                memcpy(values, data.block, len);
+        return err;
+}
+
+struct smu_sdbp_header *smu_sat_get_sdb_partition(unsigned int sat_id, int id,
+                                                  unsigned int *size)
+{
+        struct wf_sat *sat;
+        int err;
+        unsigned int i, len;
+        u8 *buf;
+        u8 data[4];
+
+        /* TODO: Add the resulting partition to the device-tree */
+
+        if (sat_id > 1 || (sat = sats[sat_id]) == NULL)
+                return NULL;
+
+        err = i2c_smbus_write_word_data(&sat->i2c, 8, id << 8);
+        if (err) {
+                printk(KERN_ERR "smu_sat_get_sdb_part wr error %d\n", err);
+                return NULL;
+        }
+
+        len = i2c_smbus_read_word_data(&sat->i2c, 9);
+        if (len < 0) {
+                printk(KERN_ERR "smu_sat_get_sdb_part rd len error\n");
+                return NULL;
+        }
+        if (len == 0) {
+                printk(KERN_ERR "smu_sat_get_sdb_part no partition %x\n", id);
+                return NULL;
+        }
+
+        len = le16_to_cpu(len);
+        len = (len + 3) & ~3;
+        buf = kmalloc(len, GFP_KERNEL);
+        if (buf == NULL)
+                return NULL;
+
+        for (i = 0; i < len; i += 4) {
+                err = sat_read_block(&sat->i2c, 0xa, data, 4);
+                if (err) {
+                        printk(KERN_ERR "smu_sat_get_sdb_part rd err %d\n",
+                               err);
+                        goto fail;
+                }
+                buf[i] = data[1];
+                buf[i+1] = data[0];
+                buf[i+2] = data[3];
+                buf[i+3] = data[2];
+        }
+#ifdef DEBUG
+        DBG(KERN_DEBUG "sat %d partition %x:", sat_id, id);
+        for (i = 0; i < len; ++i)
+                DBG(" %x", buf[i]);
+        DBG("\n");
+#endif
+
+        if (size)
+                *size = len;
+        return (struct smu_sdbp_header *) buf;
+
+ fail:
+        kfree(buf);
+        return NULL;
+}
+
+/* refresh the cache */
+static int wf_sat_read_cache(struct wf_sat *sat)
+{
+        int err;
+
+        err = sat_read_block(&sat->i2c, 0x3f, sat->cache, 16);
+        if (err)
+                return err;
+        sat->last_read = jiffies;
+#ifdef LOTSA_DEBUG
+        {
+                int i;
+                DBG(KERN_DEBUG "wf_sat_get: data is");
+                for (i = 0; i < 16; ++i)
+                        DBG(" %.2x", sat->cache[i]);
+                DBG("\n");
+        }
+#endif
+        return 0;
+}
+
+static int wf_sat_get(struct wf_sensor *sr, s32 *value)
+{
+        struct wf_sat_sensor *sens = wf_to_sat(sr);
+        struct wf_sat *sat = sens->sat;
+        int i, err;
+        s32 val;
+
+        if (sat->i2c.adapter == NULL)
+                return -ENODEV;
+
+        down(&sat->mutex);
+        if (time_after(jiffies, (sat->last_read + MAX_AGE))) {
+                err = wf_sat_read_cache(sat);
+                if (err)
+                        goto fail;
+        }
+
+        i = sens->index * 2;
+        val = ((sat->cache[i] << 8) + sat->cache[i+1]) << sens->shift;
+        if (sens->index2 >= 0) {
+                i = sens->index2 * 2;
+                /* 4.12 * 8.8 -> 12.20; shift right 4 to get 16.16 */
+                val = (val * ((sat->cache[i] << 8) + sat->cache[i+1])) >> 4;
+        }
+
+        *value = val;
+        err = 0;
+
+ fail:
+        up(&sat->mutex);
+        return err;
+}
+
+static void wf_sat_release(struct wf_sensor *sr)
+{
+        struct wf_sat_sensor *sens = wf_to_sat(sr);
+        struct wf_sat *sat = sens->sat;
+
+        if (atomic_dec_and_test(&sat->refcnt)) {
+                if (sat->i2c.adapter) {
+                        i2c_detach_client(&sat->i2c);
+                        sat->i2c.adapter = NULL;
+                }
+                if (sat->nr >= 0)
+                        sats[sat->nr] = NULL;
+                kfree(sat);
+        }
+        kfree(sens);
+}
+
+static struct wf_sensor_ops wf_sat_ops = {
+        .get_value      = wf_sat_get,
+        .release        = wf_sat_release,
+        .owner          = THIS_MODULE,
+};
+
+static void wf_sat_create(struct i2c_adapter *adapter, struct device_node *dev)
+{
+        struct wf_sat *sat;
+        struct wf_sat_sensor *sens;
+        u32 *reg;
+        char *loc, *type;
+        u8 addr, chip, core;
+        struct device_node *child;
+        int shift, cpu, index;
+        char *name;
+        int vsens[2], isens[2];
+
+        reg = (u32 *) get_property(dev, "reg", NULL);
+        if (reg == NULL)
+                return;
+        addr = *reg;
+        DBG(KERN_DEBUG "wf_sat: creating sat at address %x\n", addr);
+
+        sat = kzalloc(sizeof(struct wf_sat), GFP_KERNEL);
+        if (sat == NULL)
+                return;
+        sat->nr = -1;
+        sat->node = of_node_get(dev);
+        atomic_set(&sat->refcnt, 0);
+        init_MUTEX(&sat->mutex);
+        sat->i2c.addr = (addr >> 1) & 0x7f;
+        sat->i2c.adapter = adapter;
+        sat->i2c.driver = &wf_sat_driver;
+        strncpy(sat->i2c.name, "smu-sat", I2C_NAME_SIZE-1);
+
+        if (i2c_attach_client(&sat->i2c)) {
+                printk(KERN_ERR "windfarm: failed to attach smu-sat to i2c\n");
+                goto fail;
+        }
+
+        vsens[0] = vsens[1] = -1;
+        isens[0] = isens[1] = -1;
+        child = NULL;
+        while ((child = of_get_next_child(dev, child)) != NULL) {
+                reg = (u32 *) get_property(child, "reg", NULL);
+                type = get_property(child, "device_type", NULL);
+                loc = get_property(child, "location", NULL);
+                if (reg == NULL || loc == NULL)
+                        continue;
+
+                /* the cooked sensors are between 0x30 and 0x37 */
+                if (*reg < 0x30 || *reg > 0x37)
+                        continue;
+                index = *reg - 0x30;
+
+                /* expect location to be CPU [AB][01] ... */
+                if (strncmp(loc, "CPU ", 4) != 0)
+                        continue;
+                chip = loc[4] - 'A';
+                core = loc[5] - '0';
+                if (chip > 1 || core > 1) {
+                        printk(KERN_ERR "wf_sat_create: don't understand "
+                               "location %s for %s\n", loc, child->full_name);
+                        continue;
+                }
+                cpu = 2 * chip + core;
+                if (sat->nr < 0)
+                        sat->nr = chip;
+                else if (sat->nr != chip) {
+                        printk(KERN_ERR "wf_sat_create: can't cope with "
+                               "multiple CPU chips on one SAT (%s)\n", loc);
+                        continue;
+                }
+
+                if (strcmp(type, "voltage-sensor") == 0) {
+                        name = "cpu-voltage";
+                        shift = 4;
+                        vsens[core] = index;
+                } else if (strcmp(type, "current-sensor") == 0) {
+                        name = "cpu-current";
+                        shift = 8;
+                        isens[core] = index;
+                } else if (strcmp(type, "temp-sensor") == 0) {
+                        name = "cpu-temp";
+                        shift = 10;
+                } else
+                        continue;       /* hmmm shouldn't happen */
+
+                /* the +16 is enough for "cpu-voltage-n" */
+                sens = kzalloc(sizeof(struct wf_sat_sensor) + 16, GFP_KERNEL);
+                if (sens == NULL) {
+                        printk(KERN_ERR "wf_sat_create: couldn't create "
+                               "%s sensor %d (no memory)\n", name, cpu);
+                        continue;
+                }
+                sens->index = index;
+                sens->index2 = -1;
+                sens->shift = shift;
+                sens->sat = sat;
+                atomic_inc(&sat->refcnt);
+                sens->sens.ops = &wf_sat_ops;
+                sens->sens.name = (char *) (sens + 1);
+                snprintf(sens->sens.name, 16, "%s-%d", name, cpu);
+
+                if (wf_register_sensor(&sens->sens)) {
+                        atomic_dec(&sat->refcnt);
+                        kfree(sens);
+                }
+        }
+
+        /* make the power sensors */
+        for (core = 0; core < 2; ++core) {
+                if (vsens[core] < 0 || isens[core] < 0)
+                        continue;
+                cpu = 2 * sat->nr + core;
+                sens = kzalloc(sizeof(struct wf_sat_sensor) + 16, GFP_KERNEL);
+                if (sens == NULL) {
+                        printk(KERN_ERR "wf_sat_create: couldn't create power "
+                               "sensor %d (no memory)\n", cpu);
+                        continue;
+                }
+                sens->index = vsens[core];
+                sens->index2 = isens[core];
+                sens->shift = 0;
+                sens->sat = sat;
+                atomic_inc(&sat->refcnt);
+                sens->sens.ops = &wf_sat_ops;
+                sens->sens.name = (char *) (sens + 1);
+                snprintf(sens->sens.name, 16, "cpu-power-%d", cpu);
+
+                if (wf_register_sensor(&sens->sens)) {
+                        atomic_dec(&sat->refcnt);
+                        kfree(sens);
+                }
+        }
+
+        if (sat->nr >= 0)
+                sats[sat->nr] = sat;
+
+        return;
+
+ fail:
+        kfree(sat);
+}
+
+static int wf_sat_attach(struct i2c_adapter *adapter)
+{
+        struct device_node *busnode, *dev = NULL;
+        struct pmac_i2c_bus *bus;
+
+        bus = pmac_i2c_adapter_to_bus(adapter);
+        if (bus == NULL)
+                return -ENODEV;
+        busnode = pmac_i2c_get_bus_node(bus);
+
+        while ((dev = of_get_next_child(busnode, dev)) != NULL)
+                if (device_is_compatible(dev, "smu-sat"))
+                        wf_sat_create(adapter, dev);
+        return 0;
+}
+
+static int wf_sat_detach(struct i2c_client *client)
+{
+        struct wf_sat *sat = i2c_to_sat(client);
+
+        /* XXX TODO */
+
+        sat->i2c.adapter = NULL;
+        return 0;
+}
+
+static int __init sat_sensors_init(void)
+{
+        int err;
+
+        err = i2c_add_driver(&wf_sat_driver);
+        if (err < 0)
+                return err;
+        return 0;
+}
+
+static void __exit sat_sensors_exit(void)
+{
+        i2c_del_driver(&wf_sat_driver);
+}
+
+module_init(sat_sensors_init);
+/*module_exit(sat_sensors_exit); Uncomment when cleanup is implemented */
+
+MODULE_AUTHOR("Paul Mackerras <paulus@samba.org>");
+MODULE_DESCRIPTION("SMU satellite sensors for PowerMac thermal control");
+MODULE_LICENSE("GPL");
diff --git a/drivers/macintosh/windfarm_smu_sensors.c b/drivers/macintosh/windfarm_smu_sensors.c
index 1a00d9c75a23..bed25dcf8a1e 100644
--- a/drivers/macintosh/windfarm_smu_sensors.c
+++ b/drivers/macintosh/windfarm_smu_sensors.c
@@ -220,14 +220,29 @@ static struct smu_ad_sensor *smu_ads_create(struct device_node *node)
             !strcmp(l, "CPU T-Diode")) {
                 ads->sens.ops = &smu_cputemp_ops;
                 ads->sens.name = "cpu-temp";
+                if (cpudiode == NULL) {
+                        DBG("wf: cpudiode partition (%02x) not found\n",
+                            SMU_SDB_CPUDIODE_ID);
+                        goto fail;
+                }
         } else if (!strcmp(c, "current-sensor") &&
                    !strcmp(l, "CPU Current")) {
                 ads->sens.ops = &smu_cpuamp_ops;
                 ads->sens.name = "cpu-current";
+                if (cpuvcp == NULL) {
+                        DBG("wf: cpuvcp partition (%02x) not found\n",
+                            SMU_SDB_CPUVCP_ID);
+                        goto fail;
+                }
         } else if (!strcmp(c, "voltage-sensor") &&
                    !strcmp(l, "CPU Voltage")) {
                 ads->sens.ops = &smu_cpuvolt_ops;
                 ads->sens.name = "cpu-voltage";
+                if (cpuvcp == NULL) {
+                        DBG("wf: cpuvcp partition (%02x) not found\n",
+                            SMU_SDB_CPUVCP_ID);
+                        goto fail;
+                }
         } else if (!strcmp(c, "power-sensor") &&
                    !strcmp(l, "Slots Power")) {
                 ads->sens.ops = &smu_slotspow_ops;
@@ -365,29 +380,22 @@ smu_cpu_power_create(struct wf_sensor *volts, struct wf_sensor *amps)
         return NULL;
 }
 
-static int smu_fetch_param_partitions(void)
+static void smu_fetch_param_partitions(void)
 {
         struct smu_sdbp_header *hdr;
 
         /* Get CPU voltage/current/power calibration data */
         hdr = smu_get_sdb_partition(SMU_SDB_CPUVCP_ID, NULL);
-        if (hdr == NULL) {
-                DBG("wf: cpuvcp partition (%02x) not found\n",
-                    SMU_SDB_CPUVCP_ID);
-                return -ENODEV;
+        if (hdr != NULL) {
+                cpuvcp = (struct smu_sdbp_cpuvcp *)&hdr[1];
+                /* Keep version around */
+                cpuvcp_version = hdr->version;
         }
-        cpuvcp = (struct smu_sdbp_cpuvcp *)&hdr[1];
-        /* Keep version around */
-        cpuvcp_version = hdr->version;
 
         /* Get CPU diode calibration data */
         hdr = smu_get_sdb_partition(SMU_SDB_CPUDIODE_ID, NULL);
-        if (hdr == NULL) {
-                DBG("wf: cpudiode partition (%02x) not found\n",
-                    SMU_SDB_CPUDIODE_ID);
-                return -ENODEV;
-        }
-        cpudiode = (struct smu_sdbp_cpudiode *)&hdr[1];
+        if (hdr != NULL)
+                cpudiode = (struct smu_sdbp_cpudiode *)&hdr[1];
 
         /* Get slots power calibration data if any */
         hdr = smu_get_sdb_partition(SMU_SDB_SLOTSPOW_ID, NULL);
@@ -398,23 +406,18 @@ static int smu_fetch_param_partitions(void)
         hdr = smu_get_sdb_partition(SMU_SDB_DEBUG_SWITCHES_ID, NULL);
         if (hdr != NULL)
                 debugswitches = (u8 *)&hdr[1];
-
-        return 0;
 }
 
 static int __init smu_sensors_init(void)
 {
         struct device_node *smu, *sensors, *s;
         struct smu_ad_sensor *volt_sensor = NULL, *curr_sensor = NULL;
-        int rc;
 
         if (!smu_present())
                 return -ENODEV;
 
         /* Get parameters partitions */
-        rc = smu_fetch_param_partitions();
-        if (rc)
-                return rc;
+        smu_fetch_param_partitions();
 
         smu = of_find_node_by_type(NULL, "smu");
         if (smu == NULL)
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index 74039db846ba..d73779a42417 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -545,7 +545,8 @@ static int core_get_resync_work(struct dirty_log *log, region_t *region)
                 return 0;
 
         do {
-                *region = find_next_zero_bit((unsigned long *) lc->sync_bits,
+                *region = ext2_find_next_zero_bit(
+                                             (unsigned long *) lc->sync_bits,
                                              lc->region_count,
                                              lc->sync_search);
                 lc->sync_search = *region + 1;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 7145cd150f7b..d05e3125d298 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -1024,7 +1024,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                 rdev-> sb_size = (rdev->sb_size | bmask)+1;
 
         if (refdev == 0)
-                return 1;
+                ret = 1;
         else {
                 __u64 ev1, ev2;
                 struct mdp_superblock_1 *refsb = 
@@ -1044,7 +1044,9 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
                 ev2 = le64_to_cpu(refsb->events);
 
                 if (ev1 > ev2)
-                        return 1;
+                        ret = 1;
+                else
+                        ret = 0;
         }
         if (minor_version) 
                 rdev->size = ((rdev->bdev->bd_inode->i_size>>9) - le64_to_cpu(sb->data_offset)) / 2;
@@ -1058,7 +1060,7 @@ static int super_1_load(mdk_rdev_t *rdev, mdk_rdev_t *refdev, int minor_version)
 
         if (le32_to_cpu(sb->size) > rdev->size*2)
                 return -EINVAL;
-        return 0;
+        return ret;
 }
 
 static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
@@ -1081,7 +1083,7 @@ static int super_1_validate(mddev_t *mddev, mdk_rdev_t *rdev)
                 mddev->size = le64_to_cpu(sb->size)/2;
                 mddev->events = le64_to_cpu(sb->events);
                 mddev->bitmap_offset = 0;
-                mddev->default_bitmap_offset = 1024;
+                mddev->default_bitmap_offset = 1024 >> 9;
                 
                 mddev->recovery_cp = le64_to_cpu(sb->resync_offset);
                 memcpy(mddev->uuid, sb->set_uuid, 16);
@@ -1161,6 +1163,9 @@ static void super_1_sync(mddev_t *mddev, mdk_rdev_t *rdev)
 
         sb->cnt_corrected_read = atomic_read(&rdev->corrected_errors);
 
+        sb->raid_disks = cpu_to_le32(mddev->raid_disks);
+        sb->size = cpu_to_le64(mddev->size<<1);
+
         if (mddev->bitmap && mddev->bitmap_file == NULL) {
                 sb->bitmap_offset = cpu_to_le32((__u32)mddev->bitmap_offset);
                 sb->feature_map = cpu_to_le32(MD_FEATURE_BITMAP_OFFSET);
@@ -2686,14 +2691,6 @@ static int do_md_stop(mddev_t * mddev, int ro)
                         set_disk_ro(disk, 1);
         }
 
-        bitmap_destroy(mddev);
-        if (mddev->bitmap_file) {
-                atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);
-                fput(mddev->bitmap_file);
-                mddev->bitmap_file = NULL;
-        }
-        mddev->bitmap_offset = 0;
-
         /*
          * Free resources if final stop
          */
@@ -2703,6 +2700,14 @@ static int do_md_stop(mddev_t * mddev, int ro)
                 struct gendisk *disk;
                 printk(KERN_INFO "md: %s stopped.\n", mdname(mddev));
 
+                bitmap_destroy(mddev);
+                if (mddev->bitmap_file) {
+                        atomic_set(&mddev->bitmap_file->f_dentry->d_inode->i_writecount, 1);
+                        fput(mddev->bitmap_file);
+                        mddev->bitmap_file = NULL;
+                }
+                mddev->bitmap_offset = 0;
+
                 ITERATE_RDEV(mddev,rdev,tmp)
                         if (rdev->raid_disk >= 0) {
                                 char nm[20];
@@ -2939,6 +2944,8 @@ static int get_array_info(mddev_t * mddev, void __user * arg)
         info.ctime         = mddev->ctime;
         info.level         = mddev->level;
         info.size          = mddev->size;
+        if (info.size != mddev->size) /* overflow */
+                info.size = -1;
         info.nr_disks      = nr;
         info.raid_disks    = mddev->raid_disks;
         info.md_minor      = mddev->md_minor;
@@ -3465,7 +3472,7 @@ static int update_size(mddev_t *mddev, unsigned long size)
                 bdev = bdget_disk(mddev->gendisk, 0);
                 if (bdev) {
                         mutex_lock(&bdev->bd_inode->i_mutex);
-                        i_size_write(bdev->bd_inode, mddev->array_size << 10);
+                        i_size_write(bdev->bd_inode, (loff_t)mddev->array_size << 10);
                         mutex_unlock(&bdev->bd_inode->i_mutex);
                         bdput(bdev);
                 }
@@ -3485,17 +3492,6 @@ static int update_raid_disks(mddev_t *mddev, int raid_disks)
         if (mddev->sync_thread)
                 return -EBUSY;
         rv = mddev->pers->reshape(mddev, raid_disks);
-        if (!rv) {
-                struct block_device *bdev;
-
-                bdev = bdget_disk(mddev->gendisk, 0);
-                if (bdev) {
-                        mutex_lock(&bdev->bd_inode->i_mutex);
-                        i_size_write(bdev->bd_inode, mddev->array_size << 10);
-                        mutex_unlock(&bdev->bd_inode->i_mutex);
-                        bdput(bdev);
-                }
-        }
         return rv;
 }
 
@@ -3531,7 +3527,7 @@ static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
                 )
                 return -EINVAL;
         /* Check there is only one change */
-        if (mddev->size != info->size) cnt++;
+        if (info->size >= 0 && mddev->size != info->size) cnt++;
         if (mddev->raid_disks != info->raid_disks) cnt++;
         if (mddev->layout != info->layout) cnt++;
         if ((state ^ info->state) & (1<<MD_SB_BITMAP_PRESENT)) cnt++;
@@ -3548,7 +3544,7 @@ static int update_array_info(mddev_t *mddev, mdu_array_info_t *info)
                 else
                         return mddev->pers->reconfig(mddev, info->layout, -1);
         }
-        if (mddev->size != info->size)
+        if (info->size >= 0 && mddev->size != info->size)
                 rv = update_size(mddev, info->size);
 
         if (mddev->raid_disks    != info->raid_disks)
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index d03f99cf4b7d..678f4dbbea1d 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -372,7 +372,7 @@ out_free_conf:
         kfree(conf);
         mddev->private = NULL;
 out:
-        return 1;
+        return -ENOMEM;
 }
 
 static int raid0_stop (mddev_t *mddev)
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 9130d051b474..ab90a6d12020 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -565,6 +565,8 @@ rb_out:
 
         if (disk >= 0 && (rdev=rcu_dereference(conf->mirrors[disk].rdev))!= NULL)
                 atomic_inc(&conf->mirrors[disk].rdev->nr_pending);
+        else
+                disk = -1;
         rcu_read_unlock();
 
         return disk;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 25976bfb6f9c..2dba305daf3c 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -350,7 +350,8 @@ static void shrink_stripes(raid5_conf_t *conf)
         while (drop_one_stripe(conf))
                 ;
 
-        kmem_cache_destroy(conf->slab_cache);
+        if (conf->slab_cache)
+                kmem_cache_destroy(conf->slab_cache);
         conf->slab_cache = NULL;
 }
 
diff --git a/drivers/md/raid6main.c b/drivers/md/raid6main.c
index f618a53b98be..cd477ebf2ee4 100644
--- a/drivers/md/raid6main.c
+++ b/drivers/md/raid6main.c
@@ -115,7 +115,7 @@ static void __release_stripe(raid6_conf_t *conf, struct stripe_head *sh)
                         list_add_tail(&sh->lru, &conf->inactive_list);
                         atomic_dec(&conf->active_stripes);
                         if (!conf->inactive_blocked ||
-                            atomic_read(&conf->active_stripes) < (NR_STRIPES*3/4))
+                            atomic_read(&conf->active_stripes) < (conf->max_nr_stripes*3/4))
                                 wake_up(&conf->wait_for_stripe);
                 }
         }
@@ -273,7 +273,8 @@ static struct stripe_head *get_active_stripe(raid6_conf_t *conf, sector_t sector
                                 conf->inactive_blocked = 1;
                                 wait_event_lock_irq(conf->wait_for_stripe,
                                                     !list_empty(&conf->inactive_list) &&
-                                                    (atomic_read(&conf->active_stripes) < (NR_STRIPES *3/4)
+                                                    (atomic_read(&conf->active_stripes)
+                                                     < (conf->max_nr_stripes *3/4)
                                                      || !conf->inactive_blocked),
                                                     conf->device_lock,
                                                     unplug_slaves(conf->mddev);
@@ -302,9 +303,31 @@ static struct stripe_head *get_active_stripe(raid6_conf_t *conf, sector_t sector
         return sh;
 }
 
-static int grow_stripes(raid6_conf_t *conf, int num)
+static int grow_one_stripe(raid6_conf_t *conf)
 {
         struct stripe_head *sh;
+        sh = kmem_cache_alloc(conf->slab_cache, GFP_KERNEL);
+        if (!sh)
+                return 0;
+        memset(sh, 0, sizeof(*sh) + (conf->raid_disks-1)*sizeof(struct r5dev));
+        sh->raid_conf = conf;
+        spin_lock_init(&sh->lock);
+
+        if (grow_buffers(sh, conf->raid_disks)) {
+                shrink_buffers(sh, conf->raid_disks);
+                kmem_cache_free(conf->slab_cache, sh);
+                return 0;
+        }
+        /* we just created an active stripe so... */
+        atomic_set(&sh->count, 1);
+        atomic_inc(&conf->active_stripes);
+        INIT_LIST_HEAD(&sh->lru);
+        release_stripe(sh);
+        return 1;
+}
+
+static int grow_stripes(raid6_conf_t *conf, int num)
+{
         kmem_cache_t *sc;
         int devs = conf->raid_disks;
 
@@ -316,45 +339,35 @@ static int grow_stripes(raid6_conf_t *conf, int num)
         if (!sc)
                 return 1;
         conf->slab_cache = sc;
-        while (num--) {
-                sh = kmem_cache_alloc(sc, GFP_KERNEL);
-                if (!sh)
-                        return 1;
-                memset(sh, 0, sizeof(*sh) + (devs-1)*sizeof(struct r5dev));
-                sh->raid_conf = conf;
-                spin_lock_init(&sh->lock);
-
-                if (grow_buffers(sh, conf->raid_disks)) {
-                        shrink_buffers(sh, conf->raid_disks);
-                        kmem_cache_free(sc, sh);
+        while (num--)
+                if (!grow_one_stripe(conf))
                         return 1;
-                }
-                /* we just created an active stripe so... */
-                atomic_set(&sh->count, 1);
-                atomic_inc(&conf->active_stripes);
-                INIT_LIST_HEAD(&sh->lru);
-                release_stripe(sh);
-        }
         return 0;
 }
 
-static void shrink_stripes(raid6_conf_t *conf)
+static int drop_one_stripe(raid6_conf_t *conf)
 {
         struct stripe_head *sh;
+        spin_lock_irq(&conf->device_lock);
+        sh = get_free_stripe(conf);
+        spin_unlock_irq(&conf->device_lock);
+        if (!sh)
+                return 0;
+        if (atomic_read(&sh->count))
+                BUG();
+        shrink_buffers(sh, conf->raid_disks);
+        kmem_cache_free(conf->slab_cache, sh);
+        atomic_dec(&conf->active_stripes);
+        return 1;
+}
 
-        while (1) {
-                spin_lock_irq(&conf->device_lock);
-                sh = get_free_stripe(conf);
-                spin_unlock_irq(&conf->device_lock);
-                if (!sh)
-                        break;
-                if (atomic_read(&sh->count))
-                        BUG();
-                shrink_buffers(sh, conf->raid_disks);
-                kmem_cache_free(conf->slab_cache, sh);
-                atomic_dec(&conf->active_stripes);
-        }
-        kmem_cache_destroy(conf->slab_cache);
+static void shrink_stripes(raid6_conf_t *conf)
+{
+        while (drop_one_stripe(conf))
+                ;
+
+        if (conf->slab_cache)
+                kmem_cache_destroy(conf->slab_cache);
         conf->slab_cache = NULL;
 }
 
@@ -1912,6 +1925,74 @@ static void raid6d (mddev_t *mddev)
         PRINTK("--- raid6d inactive\n");
 }
 
+static ssize_t
+raid6_show_stripe_cache_size(mddev_t *mddev, char *page)
+{
+        raid6_conf_t *conf = mddev_to_conf(mddev);
+        if (conf)
+                return sprintf(page, "%d\n", conf->max_nr_stripes);
+        else
+                return 0;
+}
+
+static ssize_t
+raid6_store_stripe_cache_size(mddev_t *mddev, const char *page, size_t len)
+{
+        raid6_conf_t *conf = mddev_to_conf(mddev);
+        char *end;
+        int new;
+        if (len >= PAGE_SIZE)
+                return -EINVAL;
+        if (!conf)
+                return -ENODEV;
+
+        new = simple_strtoul(page, &end, 10);
+        if (!*page || (*end && *end != '\n') )
+                return -EINVAL;
+        if (new <= 16 || new > 32768)
+                return -EINVAL;
+        while (new < conf->max_nr_stripes) {
+                if (drop_one_stripe(conf))
+                        conf->max_nr_stripes--;
+                else
+                        break;
+        }
+        while (new > conf->max_nr_stripes) {
+                if (grow_one_stripe(conf))
+                        conf->max_nr_stripes++;
+                else break;
+        }
+        return len;
+}
+
+static struct md_sysfs_entry
+raid6_stripecache_size = __ATTR(stripe_cache_size, S_IRUGO | S_IWUSR,
+                                raid6_show_stripe_cache_size,
+                                raid6_store_stripe_cache_size);
+
+static ssize_t
+stripe_cache_active_show(mddev_t *mddev, char *page)
+{
+        raid6_conf_t *conf = mddev_to_conf(mddev);
+        if (conf)
+                return sprintf(page, "%d\n", atomic_read(&conf->active_stripes));
+        else
+                return 0;
+}
+
+static struct md_sysfs_entry
+raid6_stripecache_active = __ATTR_RO(stripe_cache_active);
+
+static struct attribute *raid6_attrs[] =  {
+        &raid6_stripecache_size.attr,
+        &raid6_stripecache_active.attr,
+        NULL,
+};
+static struct attribute_group raid6_attrs_group = {
+        .name = NULL,
+        .attrs = raid6_attrs,
+};
+
 static int run(mddev_t *mddev)
 {
         raid6_conf_t *conf;
@@ -2095,6 +2176,7 @@ static int stop (mddev_t *mddev)
         shrink_stripes(conf);
         kfree(conf->stripe_hashtbl);
         blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
+        sysfs_remove_group(&mddev->kobj, &raid6_attrs_group);
         kfree(conf);
         mddev->private = NULL;
         return 0;
diff --git a/drivers/media/dvb/b2c2/Kconfig b/drivers/media/dvb/b2c2/Kconfig
index 2583a865a58e..2963605c0ecc 100644
--- a/drivers/media/dvb/b2c2/Kconfig
+++ b/drivers/media/dvb/b2c2/Kconfig
@@ -4,7 +4,7 @@ config DVB_B2C2_FLEXCOP
         select DVB_STV0299
         select DVB_MT352
         select DVB_MT312
-        select DVB_NXT2002
+        select DVB_NXT200X
         select DVB_STV0297
         select DVB_BCM3510
         select DVB_LGDT330X
diff --git a/drivers/media/dvb/b2c2/flexcop-common.h b/drivers/media/dvb/b2c2/flexcop-common.h
index 344a3c898460..7d7e1613c5a7 100644
--- a/drivers/media/dvb/b2c2/flexcop-common.h
+++ b/drivers/media/dvb/b2c2/flexcop-common.h
@@ -116,11 +116,9 @@ void flexcop_dma_free(struct flexcop_dma *dma);
 
 int flexcop_dma_control_timer_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff);
 int flexcop_dma_control_size_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff);
-int flexcop_dma_control_packet_irq(struct flexcop_device *fc, flexcop_dma_index_t no, int onoff);
 int flexcop_dma_config(struct flexcop_device *fc, struct flexcop_dma *dma, flexcop_dma_index_t dma_idx);
 int flexcop_dma_xfer_control(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, flexcop_dma_addr_index_t index, int onoff);
 int flexcop_dma_config_timer(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 cycles);
-int flexcop_dma_config_packet_count(struct flexcop_device *fc, flexcop_dma_index_t dma_idx, u8 packets);
 
 /* from flexcop-eeprom.c */
 /* the PCI part uses this call to get the MAC address, the USB part has its own */
diff --git a/drivers/media/dvb/b2c2/flexcop-dma.c b/drivers/media/dvb/b2c2/flexcop-dma.c
index cf4ed1df6086..6f592bc32d22 100644
--- a/drivers/media/dvb/b2c2/flexcop-dma.c
+++ b/drivers/media/dvb/b2c2/flexcop-dma.c
@@ -169,38 +169,3 @@ int flexcop_dma_config_timer(struct flexcop_device *fc,
 }
 EXPORT_SYMBOL(flexcop_dma_config_timer);
 
-/* packet IRQ does not exist in FCII or FCIIb - according to data book and tests */
-int flexcop_dma_control_packet_irq(struct flexcop_device *fc,
-                flexcop_dma_index_t no,
-                int onoff)
-{
-        flexcop_ibi_value v = fc->read_ibi_reg(fc,ctrl_208);
-
-        deb_rdump("reg: %03x: %x\n",ctrl_208,v.raw);
-        if (no & FC_DMA_1)
-                v.ctrl_208.DMA1_Size_IRQ_Enable_sig = onoff;
-
-        if (no & FC_DMA_2)
-                v.ctrl_208.DMA2_Size_IRQ_Enable_sig = onoff;
-
-        fc->write_ibi_reg(fc,ctrl_208,v);
-        deb_rdump("reg: %03x: %x\n",ctrl_208,v.raw);
-
-        return 0;
-}
-EXPORT_SYMBOL(flexcop_dma_control_packet_irq);
-
-int flexcop_dma_config_packet_count(struct flexcop_device *fc,
-                flexcop_dma_index_t dma_idx,
-                u8 packets)
-{
-        flexcop_ibi_register r = (dma_idx & FC_DMA_1) ? dma1_004 : dma2_014;
-        flexcop_ibi_value v = fc->read_ibi_reg(fc,r);
-
-        flexcop_dma_remap(fc,dma_idx,1);
-
-        v.dma_0x4_remap.DMA_maxpackets = packets;
-        fc->write_ibi_reg(fc,r,v);
-        return 0;
-}
-EXPORT_SYMBOL(flexcop_dma_config_packet_count);
diff --git a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
index 0b940e152b79..390cc3a99ce6 100644
--- a/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
+++ b/drivers/media/dvb/b2c2/flexcop-fe-tuner.c
@@ -9,7 +9,7 @@
 
 #include "stv0299.h"
 #include "mt352.h"
-#include "nxt2002.h"
+#include "nxt200x.h"
 #include "bcm3510.h"
 #include "stv0297.h"
 #include "mt312.h"
@@ -343,9 +343,10 @@ static struct lgdt330x_config air2pc_atsc_hd5000_config = {
         .clock_polarity_flip = 1,
 };
 
-static struct nxt2002_config samsung_tbmv_config = {
+static struct nxt200x_config samsung_tbmv_config = {
         .demod_address    = 0x0a,
-        .request_firmware = flexcop_fe_request_firmware,
+        .pll_address      = 0xc2,
+        .pll_desc         = &dvb_pll_samsung_tbmv,
 };
 
 static struct bcm3510_config air2pc_atsc_first_gen_config = {
@@ -505,7 +506,7 @@ int flexcop_frontend_init(struct flexcop_device *fc)
                 info("found the mt352 at i2c address: 0x%02x",samsung_tdtc9251dh0_config.demod_address);
         } else
         /* try the air atsc 2nd generation (nxt2002) */
-        if ((fc->fe = nxt2002_attach(&samsung_tbmv_config, &fc->i2c_adap)) != NULL) {
+        if ((fc->fe = nxt200x_attach(&samsung_tbmv_config, &fc->i2c_adap)) != NULL) {
                 fc->dev_type          = FC_AIR_ATSC2;
                 info("found the nxt2002 at i2c address: 0x%02x",samsung_tbmv_config.demod_address);
         } else
diff --git a/drivers/media/dvb/b2c2/flexcop-misc.c b/drivers/media/dvb/b2c2/flexcop-misc.c
index 62282d8dbfa8..167583bf0621 100644
--- a/drivers/media/dvb/b2c2/flexcop-misc.c
+++ b/drivers/media/dvb/b2c2/flexcop-misc.c
@@ -36,14 +36,14 @@ void flexcop_determine_revision(struct flexcop_device *fc)
         /* bus parts have to decide if hw pid filtering is used or not. */
 }
 
-const char *flexcop_revision_names[] = {
+static const char *flexcop_revision_names[] = {
         "Unkown chip",
         "FlexCopII",
         "FlexCopIIb",
         "FlexCopIII",
 };
 
-const char *flexcop_device_names[] = {
+static const char *flexcop_device_names[] = {
         "Unkown device",
         "Air2PC/AirStar 2 DVB-T",
         "Air2PC/AirStar 2 ATSC 1st generation",
@@ -54,7 +54,7 @@ const char *flexcop_device_names[] = {
         "Air2PC/AirStar 2 ATSC 3rd generation (HD5000)",
 };
 
-const char *flexcop_bus_names[] = {
+static const char *flexcop_bus_names[] = {
         "USB",
         "PCI",
 };
diff --git a/drivers/media/dvb/b2c2/flexcop-pci.c b/drivers/media/dvb/b2c2/flexcop-pci.c
index 2f76eb3fea40..9bc40bdcc282 100644
--- a/drivers/media/dvb/b2c2/flexcop-pci.c
+++ b/drivers/media/dvb/b2c2/flexcop-pci.c
@@ -161,8 +161,10 @@ static irqreturn_t flexcop_pci_isr(int irq, void *dev_id, struct pt_regs *regs)
                         fc->read_ibi_reg(fc,dma1_008).dma_0x8.dma_cur_addr << 2;
                 u32 cur_pos = cur_addr - fc_pci->dma[0].dma_addr0;
 
-                deb_irq("%u irq: %08x cur_addr: %08x: cur_pos: %08x, last_cur_pos: %08x ",
-                                jiffies_to_usecs(jiffies - fc_pci->last_irq),v.raw,cur_addr,cur_pos,fc_pci->last_dma1_cur_pos);
+                deb_irq("%u irq: %08x cur_addr: %llx: cur_pos: %08x, last_cur_pos: %08x ",
+                                jiffies_to_usecs(jiffies - fc_pci->last_irq),
+                                v.raw, (unsigned long long)cur_addr, cur_pos,
+                                fc_pci->last_dma1_cur_pos);
                 fc_pci->last_irq = jiffies;
 
                 /* buffer end was reached, restarted from the beginning
diff --git a/drivers/media/dvb/b2c2/flexcop-reg.h b/drivers/media/dvb/b2c2/flexcop-reg.h
index 3153f9513c63..491f9bd6e195 100644
--- a/drivers/media/dvb/b2c2/flexcop-reg.h
+++ b/drivers/media/dvb/b2c2/flexcop-reg.h
@@ -16,8 +16,6 @@ typedef enum {
         FLEXCOP_III,
 } flexcop_revision_t;
 
-extern const char *flexcop_revision_names[];
-
 typedef enum {
         FC_UNK = 0,
         FC_AIR_DVB,
@@ -34,8 +32,6 @@ typedef enum {
         FC_PCI,
 } flexcop_bus_t;
 
-extern const char *flexcop_device_names[];
-
 /* FlexCop IBI Registers */
 #if defined(__LITTLE_ENDIAN)
         #include "flexcop_ibi_value_le.h"
diff --git a/drivers/media/dvb/bt8xx/bt878.c b/drivers/media/dvb/bt8xx/bt878.c
index a04bb61f21f4..34c3189a1a33 100644
--- a/drivers/media/dvb/bt8xx/bt878.c
+++ b/drivers/media/dvb/bt8xx/bt878.c
@@ -381,6 +381,23 @@ bt878_device_control(struct bt878 *bt, unsigned int cmd, union dst_gpio_packet *
 
 EXPORT_SYMBOL(bt878_device_control);
 
+
+struct cards card_list[] __devinitdata = {
+
+        { 0x01010071, BTTV_BOARD_NEBULA_DIGITV,                 "Nebula Electronics DigiTV" },
+        { 0x07611461, BTTV_BOARD_AVDVBT_761,                    "AverMedia AverTV DVB-T 761" },
+        { 0x001c11bd, BTTV_BOARD_PINNACLESAT,                   "Pinnacle PCTV Sat" },
+        { 0x002611bd, BTTV_BOARD_TWINHAN_DST,                   "Pinnacle PCTV SAT CI" },
+        { 0x00011822, BTTV_BOARD_TWINHAN_DST,                   "Twinhan VisionPlus DVB" },
+        { 0xfc00270f, BTTV_BOARD_TWINHAN_DST,                   "ChainTech digitop DST-1000 DVB-S" },
+        { 0x07711461, BTTV_BOARD_AVDVBT_771,                    "AVermedia AverTV DVB-T 771" },
+        { 0xdb1018ac, BTTV_BOARD_DVICO_DVBT_LITE,               "DViCO FusionHDTV DVB-T Lite" },
+        { 0xd50018ac, BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE,       "DViCO FusionHDTV 5 Lite" },
+        { 0x20007063, BTTV_BOARD_PC_HDTV,                       "pcHDTV HD-2000 TV"},
+        { 0, -1, NULL }
+};
+
+
 /***********************/
 /* PCI device handling */
 /***********************/
@@ -388,18 +405,41 @@ EXPORT_SYMBOL(bt878_device_control);
 static int __devinit bt878_probe(struct pci_dev *dev,
                                  const struct pci_device_id *pci_id)
 {
-        int result;
+        int result = 0, has_dvb = 0, i;
         unsigned char lat;
         struct bt878 *bt;
 #if defined(__powerpc__)
         unsigned int cmd;
 #endif
+        unsigned int cardid;
+        unsigned short id;
+        struct cards *dvb_cards;
 
         printk(KERN_INFO "bt878: Bt878 AUDIO function found (%d).\n",
                bt878_num);
         if (pci_enable_device(dev))
                 return -EIO;
 
+        pci_read_config_word(dev, PCI_SUBSYSTEM_ID, &id);
+        cardid = id << 16;
+        pci_read_config_word(dev, PCI_SUBSYSTEM_VENDOR_ID, &id);
+        cardid |= id;
+
+        for (i = 0, dvb_cards = card_list; i < ARRAY_SIZE(card_list); i++, dvb_cards++) {
+                if (cardid == dvb_cards->pci_id) {
+                        printk("%s: card id=[0x%x],[ %s ] has DVB functions.\n",
+                                __func__, cardid, dvb_cards->name);
+                        has_dvb = 1;
+                }
+        }
+
+        if (!has_dvb) {
+                printk("%s: card id=[0x%x], Unknown card.\nExiting..\n", __func__, cardid);
+                result = -EINVAL;
+
+                goto fail0;
+        }
+
         bt = &bt878[bt878_num];
         bt->dev = dev;
         bt->nr = bt878_num;
@@ -416,6 +456,8 @@ static int __devinit bt878_probe(struct pci_dev *dev,
 
         pci_read_config_byte(dev, PCI_CLASS_REVISION, &bt->revision);
         pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
+
+
         printk(KERN_INFO "bt878(%d): Bt%x (rev %d) at %02x:%02x.%x, ",
                bt878_num, bt->id, bt->revision, dev->bus->number,
                PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
diff --git a/drivers/media/dvb/bt8xx/bt878.h b/drivers/media/dvb/bt8xx/bt878.h
index a73baf00ca39..9faf93770d08 100644
--- a/drivers/media/dvb/bt8xx/bt878.h
+++ b/drivers/media/dvb/bt8xx/bt878.h
@@ -88,6 +88,23 @@
 
 #define BT878_RISC_SYNC_MASK    (1 << 15)
 
+
+#define BTTV_BOARD_UNKNOWN                 0x00
+#define BTTV_BOARD_PINNACLESAT             0x5e
+#define BTTV_BOARD_NEBULA_DIGITV           0x68
+#define BTTV_BOARD_PC_HDTV                 0x70
+#define BTTV_BOARD_TWINHAN_DST             0x71
+#define BTTV_BOARD_AVDVBT_771              0x7b
+#define BTTV_BOARD_AVDVBT_761              0x7c
+#define BTTV_BOARD_DVICO_DVBT_LITE         0x80
+#define BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE 0x87
+
+struct cards {
+        __u32 pci_id;
+        __u16 card_id;
+        char  *name;
+};
+
 extern int bt878_num;
 
 struct bt878 {
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
index 90a69d343b79..d3df12039b06 100644
--- a/drivers/media/dvb/dvb-usb/Kconfig
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -83,12 +83,18 @@ config DVB_USB_UMT_010
           Say Y here to support the HanfTek UMT-010 USB2.0 stick-sized DVB-T receiver.
 
 config DVB_USB_CXUSB
-        tristate "Medion MD95700 hybrid USB2.0 (Conexant) support"
+        tristate "Conexant USB2.0 hybrid reference design support"
         depends on DVB_USB
         select DVB_CX22702
+        select DVB_LGDT330X
+        select DVB_MT352
         help
-          Say Y here to support the Medion MD95700 hybrid USB2.0 device. Currently
-          only the DVB-T part is supported.
+          Say Y here to support the Conexant USB2.0 hybrid reference design.
+          Currently, only DVB and ATSC modes are supported, analog mode
+          shall be added in the future. Devices that require this module:
+
+          Medion MD95700 hybrid USB2.0 device.
+          DViCO FusionHDTV (Bluebird) USB2.0 devices
 
 config DVB_USB_DIGITV
         tristate "Nebula Electronics uDigiTV DVB-T USB2.0 support"
diff --git a/drivers/media/dvb/dvb-usb/cxusb.c b/drivers/media/dvb/dvb-usb/cxusb.c
index a7fb06f4cd34..f327fac1688e 100644
--- a/drivers/media/dvb/dvb-usb/cxusb.c
+++ b/drivers/media/dvb/dvb-usb/cxusb.c
@@ -184,7 +184,7 @@ static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
         return 0;
 }
 
-struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
+static struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
         { 0xfe, 0x02, KEY_TV },
         { 0xfe, 0x0e, KEY_MP3 },
         { 0xfe, 0x1a, KEY_DVD },
@@ -234,7 +234,7 @@ struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
 
 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
 {
-        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x38 };
+        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
         static u8 reset []         = { RESET,      0x80 };
         static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
         static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0x20 };
@@ -255,7 +255,7 @@ static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
 
 static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
 {       /* used in both lgz201 and th7579 */
-        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x39 };
+        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x29 };
         static u8 reset []         = { RESET,      0x80 };
         static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
         static u8 agc_cfg []       = { AGC_TARGET, 0x24, 0x20 };
@@ -273,7 +273,7 @@ static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
         return 0;
 }
 
-struct cx22702_config cxusb_cx22702_config = {
+static struct cx22702_config cxusb_cx22702_config = {
         .demod_address = 0x63,
 
         .output_mode = CX22702_PARALLEL_OUTPUT,
@@ -282,13 +282,13 @@ struct cx22702_config cxusb_cx22702_config = {
         .pll_set  = dvb_usb_pll_set_i2c,
 };
 
-struct lgdt330x_config cxusb_lgdt330x_config = {
+static struct lgdt330x_config cxusb_lgdt330x_config = {
         .demod_address = 0x0e,
         .demod_chip    = LGDT3303,
         .pll_set       = dvb_usb_pll_set_i2c,
 };
 
-struct mt352_config cxusb_dee1601_config = {
+static struct mt352_config cxusb_dee1601_config = {
         .demod_address = 0x0f,
         .demod_init    = cxusb_dee1601_demod_init,
         .pll_set       = dvb_usb_pll_set,
diff --git a/drivers/media/dvb/dvb-usb/digitv.c b/drivers/media/dvb/dvb-usb/digitv.c
index e6c55c9c9417..caa1346e3063 100644
--- a/drivers/media/dvb/dvb-usb/digitv.c
+++ b/drivers/media/dvb/dvb-usb/digitv.c
@@ -175,11 +175,13 @@ static int digitv_probe(struct usb_interface *intf,
         if ((ret = dvb_usb_device_init(intf,&digitv_properties,THIS_MODULE,&d)) == 0) {
                 u8 b[4] = { 0 };
 
-                b[0] = 1;
-                digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0);
+                if (d != NULL) { /* do that only when the firmware is loaded */
+                        b[0] = 1;
+                        digitv_ctrl_msg(d,USB_WRITE_REMOTE_TYPE,0,b,4,NULL,0);
 
-                b[0] = 0;
-                digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
+                        b[0] = 0;
+                        digitv_ctrl_msg(d,USB_WRITE_REMOTE,0,b,4,NULL,0);
+                }
         }
         return ret;
 }
@@ -194,7 +196,7 @@ static struct dvb_usb_properties digitv_properties = {
         .caps = DVB_USB_IS_AN_I2C_ADAPTER,
 
         .usb_ctrl = CYPRESS_FX2,
-        .firmware = "dvb-usb-digitv-01.fw",
+        .firmware = "dvb-usb-digitv-02.fw",
 
         .size_of_priv     = 0,
 
@@ -229,6 +231,7 @@ static struct dvb_usb_properties digitv_properties = {
                         { &digitv_table[0], NULL },
                         { NULL },
                 },
+                { NULL },
         }
 };
 
diff --git a/drivers/media/dvb/dvb-usb/dtt200u.c b/drivers/media/dvb/dvb-usb/dtt200u.c
index 130ea7f21f5e..12ebaf8bddca 100644
--- a/drivers/media/dvb/dvb-usb/dtt200u.c
+++ b/drivers/media/dvb/dvb-usb/dtt200u.c
@@ -151,7 +151,7 @@ static struct dvb_usb_properties dtt200u_properties = {
                   .cold_ids = { &dtt200u_usb_table[0], NULL },
                   .warm_ids = { &dtt200u_usb_table[1], NULL },
                 },
-                { 0 },
+                { NULL },
         }
 };
 
@@ -192,7 +192,7 @@ static struct dvb_usb_properties wt220u_properties = {
                   .cold_ids = { &dtt200u_usb_table[2], NULL },
                   .warm_ids = { &dtt200u_usb_table[3], NULL },
                 },
-                { 0 },
+                { NULL },
         }
 };
 
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
index 8535895819fb..9222b0a81f74 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-firmware.c
@@ -24,6 +24,9 @@ static struct usb_cypress_controller cypress[] = {
         { .id = CYPRESS_FX2,     .name = "Cypress FX2",     .cpu_cs_register = 0xe600 },
 };
 
+static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx,
+                               int *pos);
+
 /*
  * load a firmware packet to the device
  */
@@ -112,7 +115,8 @@ int dvb_usb_download_firmware(struct usb_device *udev, struct dvb_usb_properties
         return ret;
 }
 
-int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos)
+static int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx,
+                               int *pos)
 {
         u8 *b = (u8 *) &fw->data[*pos];
         int data_offs = 4;
@@ -142,5 +146,3 @@ int dvb_usb_get_hexline(const struct firmware *fw, struct hexline *hx, int *pos)
 
         return *pos;
 }
-EXPORT_SYMBOL(dvb_usb_get_hexline);
-
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb.h b/drivers/media/dvb/dvb-usb/dvb-usb.h
index dd568396e594..5e5d21ad93c9 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb.h
@@ -341,7 +341,6 @@ struct hexline {
         u8 data[255];
         u8 chk;
 };
-extern int dvb_usb_get_hexline(const struct firmware *, struct hexline *, int *);
 extern int usb_cypress_load_firmware(struct usb_device *udev, const struct firmware *fw, int type);
 
 #endif
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c
index afa00fdb5ec0..4a95eca81c5c 100644
--- a/drivers/media/dvb/dvb-usb/vp702x.c
+++ b/drivers/media/dvb/dvb-usb/vp702x.c
@@ -53,7 +53,8 @@ int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8
         return ret;
 }
 
-int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
+static int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value,
+                             u16 index, u8 *b, int blen)
 {
         deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
         debug_dump(b,blen,deb_xfer);
@@ -88,7 +89,8 @@ unlock:
         return ret;
 }
 
-int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec)
+static int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o,
+                                int olen, u8 *i, int ilen, int msec)
 {
         u8 bout[olen+2];
         u8 bin[ilen+1];
diff --git a/drivers/media/dvb/dvb-usb/vp702x.h b/drivers/media/dvb/dvb-usb/vp702x.h
index a808d48e7bf2..c2f97f96c21f 100644
--- a/drivers/media/dvb/dvb-usb/vp702x.h
+++ b/drivers/media/dvb/dvb-usb/vp702x.h
@@ -101,8 +101,6 @@ extern int dvb_usb_vp702x_debug;
 extern struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d);
 
 extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec);
-extern int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec);
 extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen);
-extern int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen);
 
 #endif
diff --git a/drivers/media/dvb/dvb-usb/vp7045-fe.c b/drivers/media/dvb/dvb-usb/vp7045-fe.c
index 5242cca5db4a..9999336aeeb6 100644
--- a/drivers/media/dvb/dvb-usb/vp7045-fe.c
+++ b/drivers/media/dvb/dvb-usb/vp7045-fe.c
@@ -23,10 +23,11 @@
 
 struct vp7045_fe_state {
         struct dvb_frontend fe;
+        struct dvb_frontend_ops ops;
+
         struct dvb_usb_device *d;
 };
 
-
 static int vp7045_fe_read_status(struct dvb_frontend* fe, fe_status_t *status)
 {
         struct vp7045_fe_state *state = fe->demodulator_priv;
@@ -150,7 +151,8 @@ struct dvb_frontend * vp7045_fe_attach(struct dvb_usb_device *d)
                 goto error;
 
         s->d = d;
-        s->fe.ops = &vp7045_fe_ops;
+        memcpy(&s->ops, &vp7045_fe_ops, sizeof(struct dvb_frontend_ops));
+        s->fe.ops = &s->ops;
         s->fe.demodulator_priv = s;
 
         goto success;
diff --git a/drivers/media/dvb/dvb-usb/vp7045.c b/drivers/media/dvb/dvb-usb/vp7045.c
index 028204956bb0..3835235b68df 100644
--- a/drivers/media/dvb/dvb-usb/vp7045.c
+++ b/drivers/media/dvb/dvb-usb/vp7045.c
@@ -247,7 +247,7 @@ static struct dvb_usb_properties vp7045_properties = {
                   .cold_ids = { &vp7045_usb_table[2], NULL },
                   .warm_ids = { &vp7045_usb_table[3], NULL },
                 },
-                { 0 },
+                { NULL },
         }
 };
 
diff --git a/drivers/media/dvb/frontends/Kconfig b/drivers/media/dvb/frontends/Kconfig
index db3a8b40031e..76b6a2aef32f 100644
--- a/drivers/media/dvb/frontends/Kconfig
+++ b/drivers/media/dvb/frontends/Kconfig
@@ -28,12 +28,6 @@ config DVB_TDA8083
         help
           A DVB-S tuner module. Say Y when you want to support this frontend.
 
-config DVB_TDA80XX
-        tristate "Philips TDA8044 or TDA8083 based"
-        depends on DVB_CORE
-        help
-          A DVB-S tuner module. Say Y when you want to support this frontend.
-
 config DVB_MT312
         tristate "Zarlink MT312 based"
         depends on DVB_CORE
@@ -139,12 +133,6 @@ config DVB_DIB3000MC
 comment "DVB-C (cable) frontends"
         depends on DVB_CORE
 
-config DVB_ATMEL_AT76C651
-        tristate "Atmel AT76C651 based"
-        depends on DVB_CORE
-        help
-          A DVB-C tuner module. Say Y when you want to support this frontend.
-
 config DVB_VES1820
         tristate "VLSI VES1820 based"
         depends on DVB_CORE
@@ -166,18 +154,6 @@ config DVB_STV0297
 comment "ATSC (North American/Korean Terresterial DTV) frontends"
         depends on DVB_CORE
 
-config DVB_NXT2002
-        tristate "Nxt2002 based"
-        depends on DVB_CORE
-        select FW_LOADER
-        help
-          An ATSC 8VSB tuner module. Say Y when you want to support this frontend.
-
-          This driver needs external firmware. Please use the command
-          "<kerneldir>/Documentation/dvb/get_dvb_firmware nxt2002" to
-          download/extract it, and then copy it to /usr/lib/hotplug/firmware
-          or /lib/firmware (depending on configuration of firmware hotplug).
-
 config DVB_NXT200X
         tristate "Nextwave NXT2002/NXT2004 based"
         depends on DVB_CORE
diff --git a/drivers/media/dvb/frontends/Makefile b/drivers/media/dvb/frontends/Makefile
index 615ec830e1c9..1af769cd90c0 100644
--- a/drivers/media/dvb/frontends/Makefile
+++ b/drivers/media/dvb/frontends/Makefile
@@ -8,7 +8,6 @@ obj-$(CONFIG_DVB_CORE) += dvb-pll.o
 obj-$(CONFIG_DVB_STV0299) += stv0299.o
 obj-$(CONFIG_DVB_SP8870) += sp8870.o
 obj-$(CONFIG_DVB_CX22700) += cx22700.o
-obj-$(CONFIG_DVB_ATMEL_AT76C651) += at76c651.o
 obj-$(CONFIG_DVB_CX24110) += cx24110.o
 obj-$(CONFIG_DVB_TDA8083) += tda8083.o
 obj-$(CONFIG_DVB_L64781) += l64781.o
@@ -22,10 +21,8 @@ obj-$(CONFIG_DVB_SP887X) += sp887x.o
 obj-$(CONFIG_DVB_NXT6000) += nxt6000.o
 obj-$(CONFIG_DVB_MT352) += mt352.o
 obj-$(CONFIG_DVB_CX22702) += cx22702.o
-obj-$(CONFIG_DVB_TDA80XX) += tda80xx.o
 obj-$(CONFIG_DVB_TDA10021) += tda10021.o
 obj-$(CONFIG_DVB_STV0297) += stv0297.o
-obj-$(CONFIG_DVB_NXT2002) += nxt2002.o
 obj-$(CONFIG_DVB_NXT200X) += nxt200x.o
 obj-$(CONFIG_DVB_OR51211) += or51211.o
 obj-$(CONFIG_DVB_OR51132) += or51132.o
diff --git a/drivers/media/dvb/frontends/at76c651.c b/drivers/media/dvb/frontends/at76c651.c
deleted file mode 100644
index 8e0f4b3a1417..000000000000
--- a/drivers/media/dvb/frontends/at76c651.c
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
- * at76c651.c
- *
- * Atmel DVB-C Frontend Driver (at76c651/tua6010xs)
- *
- * Copyright (C) 2001 fnbrd <fnbrd@gmx.de>
- *             & 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *             & 2003 Wolfram Joost <dbox2@frokaschwei.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * AT76C651
- * http://www.nalanda.nitc.ac.in/industry/datasheets/atmel/acrobat/doc1293.pdf
- * http://www.atmel.com/atmel/acrobat/doc1320.pdf
- */
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/kernel.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/bitops.h>
-#include "dvb_frontend.h"
-#include "at76c651.h"
-
-
-struct at76c651_state {
-
-        struct i2c_adapter* i2c;
-
-        struct dvb_frontend_ops ops;
-
-        const struct at76c651_config* config;
-
-        struct dvb_frontend frontend;
-
-        /* revision of the chip */
-        u8 revision;
-
-        /* last QAM value set */
-        u8 qam;
-};
-
-static int debug;
-#define dprintk(args...) \
-        do { \
-                if (debug) printk(KERN_DEBUG "at76c651: " args); \
-        } while (0)
-
-
-#if ! defined(__powerpc__)
-static __inline__ int __ilog2(unsigned long x)
-{
-        int i;
-
-        if (x == 0)
-                return -1;
-
-        for (i = 0; x != 0; i++)
-                x >>= 1;
-
-        return i - 1;
-}
-#endif
-
-static int at76c651_writereg(struct at76c651_state* state, u8 reg, u8 data)
-{
-        int ret;
-        u8 buf[] = { reg, data };
-        struct i2c_msg msg =
-                { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
-
-        ret = i2c_transfer(state->i2c, &msg, 1);
-
-        if (ret != 1)
-                dprintk("%s: writereg error "
-                        "(reg == 0x%02x, val == 0x%02x, ret == %i)\n",
-                        __FUNCTION__, reg, data, ret);
-
-        msleep(10);
-
-        return (ret != 1) ? -EREMOTEIO : 0;
-}
-
-static u8 at76c651_readreg(struct at76c651_state* state, u8 reg)
-{
-        int ret;
-        u8 val;
-        struct i2c_msg msg[] = {
-                { .addr = state->config->demod_address, .flags = 0, .buf = &reg, .len = 1 },
-                { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = &val, .len = 1 }
-        };
-
-        ret = i2c_transfer(state->i2c, msg, 2);
-
-        if (ret != 2)
-                dprintk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
-
-        return val;
-}
-
-static int at76c651_reset(struct at76c651_state* state)
-{
-        return at76c651_writereg(state, 0x07, 0x01);
-}
-
-static void at76c651_disable_interrupts(struct at76c651_state* state)
-{
-        at76c651_writereg(state, 0x0b, 0x00);
-}
-
-static int at76c651_set_auto_config(struct at76c651_state *state)
-{
-        /*
-         * Autoconfig
-         */
-
-        at76c651_writereg(state, 0x06, 0x01);
-
-        /*
-         * Performance optimizations, should be done after autoconfig
-         */
-
-        at76c651_writereg(state, 0x10, 0x06);
-        at76c651_writereg(state, 0x11, ((state->qam == 5) || (state->qam == 7)) ? 0x12 : 0x10);
-        at76c651_writereg(state, 0x15, 0x28);
-        at76c651_writereg(state, 0x20, 0x09);
-        at76c651_writereg(state, 0x24, ((state->qam == 5) || (state->qam == 7)) ? 0xC0 : 0x90);
-        at76c651_writereg(state, 0x30, 0x90);
-        if (state->qam == 5)
-                at76c651_writereg(state, 0x35, 0x2A);
-
-        /*
-         * Initialize A/D-converter
-         */
-
-        if (state->revision == 0x11) {
-                at76c651_writereg(state, 0x2E, 0x38);
-                at76c651_writereg(state, 0x2F, 0x13);
-        }
-
-        at76c651_disable_interrupts(state);
-
-        /*
-         * Restart operation
-         */
-
-        at76c651_reset(state);
-
-        return 0;
-}
-
-static void at76c651_set_bbfreq(struct at76c651_state* state)
-{
-        at76c651_writereg(state, 0x04, 0x3f);
-        at76c651_writereg(state, 0x05, 0xee);
-}
-
-static int at76c651_set_symbol_rate(struct at76c651_state* state, u32 symbol_rate)
-{
-        u8 exponent;
-        u32 mantissa;
-
-        if (symbol_rate > 9360000)
-                return -EINVAL;
-
-        /*
-         * FREF = 57800 kHz
-         * exponent = 10 + floor (log2(symbol_rate / FREF))
-         * mantissa = (symbol_rate / FREF) * (1 << (30 - exponent))
-         */
-
-        exponent = __ilog2((symbol_rate << 4) / 903125);
-        mantissa = ((symbol_rate / 3125) * (1 << (24 - exponent))) / 289;
-
-        at76c651_writereg(state, 0x00, mantissa >> 13);
-        at76c651_writereg(state, 0x01, mantissa >> 5);
-        at76c651_writereg(state, 0x02, (mantissa << 3) | exponent);
-
-        return 0;
-}
-
-static int at76c651_set_qam(struct at76c651_state *state, fe_modulation_t qam)
-{
-        switch (qam) {
-        case QPSK:
-                state->qam = 0x02;
-                break;
-        case QAM_16:
-                state->qam = 0x04;
-                break;
-        case QAM_32:
-                state->qam = 0x05;
-                break;
-        case QAM_64:
-                state->qam = 0x06;
-                break;
-        case QAM_128:
-                state->qam = 0x07;
-                break;
-        case QAM_256:
-                state->qam = 0x08;
-                break;
-#if 0
-        case QAM_512:
-                state->qam = 0x09;
-                break;
-        case QAM_1024:
-                state->qam = 0x0A;
-                break;
-#endif
-        default:
-                return -EINVAL;
-
-        }
-
-        return at76c651_writereg(state, 0x03, state->qam);
-}
-
-static int at76c651_set_inversion(struct at76c651_state* state, fe_spectral_inversion_t inversion)
-{
-        u8 feciqinv = at76c651_readreg(state, 0x60);
-
-        switch (inversion) {
-        case INVERSION_OFF:
-                feciqinv |= 0x02;
-                feciqinv &= 0xFE;
-                break;
-
-        case INVERSION_ON:
-                feciqinv |= 0x03;
-                break;
-
-        case INVERSION_AUTO:
-                feciqinv &= 0xFC;
-                break;
-
-        default:
-                return -EINVAL;
-        }
-
-        return at76c651_writereg(state, 0x60, feciqinv);
-}
-
-static int at76c651_set_parameters(struct dvb_frontend* fe,
-                                   struct dvb_frontend_parameters *p)
-{
-        int ret;
-        struct at76c651_state* state = fe->demodulator_priv;
-
-        at76c651_writereg(state, 0x0c, 0xc3);
-        state->config->pll_set(fe, p);
-        at76c651_writereg(state, 0x0c, 0xc2);
-
-        if ((ret = at76c651_set_symbol_rate(state, p->u.qam.symbol_rate)))
-                return ret;
-
-        if ((ret = at76c651_set_inversion(state, p->inversion)))
-                return ret;
-
-        return at76c651_set_auto_config(state);
-}
-
-static int at76c651_set_defaults(struct dvb_frontend* fe)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-
-        at76c651_set_symbol_rate(state, 6900000);
-        at76c651_set_qam(state, QAM_64);
-        at76c651_set_bbfreq(state);
-        at76c651_set_auto_config(state);
-
-        if (state->config->pll_init) {
-                at76c651_writereg(state, 0x0c, 0xc3);
-                state->config->pll_init(fe);
-                at76c651_writereg(state, 0x0c, 0xc2);
-        }
-
-        return 0;
-}
-
-static int at76c651_read_status(struct dvb_frontend* fe, fe_status_t* status)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        u8 sync;
-
-        /*
-         * Bits: FEC, CAR, EQU, TIM, AGC2, AGC1, ADC, PLL (PLL=0)
-         */
-        sync = at76c651_readreg(state, 0x80);
-        *status = 0;
-
-        if (sync & (0x04 | 0x10))       /* AGC1 || TIM */
-                *status |= FE_HAS_SIGNAL;
-        if (sync & 0x10)                /* TIM */
-                *status |= FE_HAS_CARRIER;
-        if (sync & 0x80)                /* FEC */
-                *status |= FE_HAS_VITERBI;
-        if (sync & 0x40)                /* CAR */
-                *status |= FE_HAS_SYNC;
-        if ((sync & 0xF0) == 0xF0)      /* TIM && EQU && CAR && FEC */
-                *status |= FE_HAS_LOCK;
-
-        return 0;
-}
-
-static int at76c651_read_ber(struct dvb_frontend* fe, u32* ber)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-
-        *ber = (at76c651_readreg(state, 0x81) & 0x0F) << 16;
-        *ber |= at76c651_readreg(state, 0x82) << 8;
-        *ber |= at76c651_readreg(state, 0x83);
-        *ber *= 10;
-
-        return 0;
-}
-
-static int at76c651_read_signal_strength(struct dvb_frontend* fe, u16* strength)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-
-        u8 gain = ~at76c651_readreg(state, 0x91);
-        *strength = (gain << 8) | gain;
-
-        return 0;
-}
-
-static int at76c651_read_snr(struct dvb_frontend* fe, u16* snr)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-
-        *snr = 0xFFFF -
-            ((at76c651_readreg(state, 0x8F) << 8) |
-             at76c651_readreg(state, 0x90));
-
-        return 0;
-}
-
-static int at76c651_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-
-        *ucblocks = at76c651_readreg(state, 0x82);
-
-        return 0;
-}
-
-static int at76c651_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *fesettings)
-{
-        fesettings->min_delay_ms = 50;
-        fesettings->step_size = 0;
-        fesettings->max_drift = 0;
-        return 0;
-}
-
-static void at76c651_release(struct dvb_frontend* fe)
-{
-        struct at76c651_state* state = fe->demodulator_priv;
-        kfree(state);
-}
-
-static struct dvb_frontend_ops at76c651_ops;
-
-struct dvb_frontend* at76c651_attach(const struct at76c651_config* config,
-                                     struct i2c_adapter* i2c)
-{
-        struct at76c651_state* state = NULL;
-
-        /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct at76c651_state), GFP_KERNEL);
-        if (state == NULL) goto error;
-
-        /* setup the state */
-        state->config = config;
-        state->qam = 0;
-
-        /* check if the demod is there */
-        if (at76c651_readreg(state, 0x0e) != 0x65) goto error;
-
-        /* finalise state setup */
-        state->i2c = i2c;
-        state->revision = at76c651_readreg(state, 0x0f) & 0xfe;
-        memcpy(&state->ops, &at76c651_ops, sizeof(struct dvb_frontend_ops));
-
-        /* create dvb_frontend */
-        state->frontend.ops = &state->ops;
-        state->frontend.demodulator_priv = state;
-        return &state->frontend;
-
-error:
-        kfree(state);
-        return NULL;
-}
-
-static struct dvb_frontend_ops at76c651_ops = {
-
-        .info = {
-                .name = "Atmel AT76C651B DVB-C",
-                .type = FE_QAM,
-                .frequency_min = 48250000,
-                .frequency_max = 863250000,
-                .frequency_stepsize = 62500,
-                /*.frequency_tolerance = */     /* FIXME: 12% of SR */
-                .symbol_rate_min = 0,           /* FIXME */
-                .symbol_rate_max = 9360000,     /* FIXME */
-                .symbol_rate_tolerance = 4000,
-                .caps = FE_CAN_INVERSION_AUTO |
-                    FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
-                    FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
-                    FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
-                    FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 | FE_CAN_QAM_128 |
-                    FE_CAN_MUTE_TS | FE_CAN_QAM_256 | FE_CAN_RECOVER
-        },
-
-        .release = at76c651_release,
-
-        .init = at76c651_set_defaults,
-
-        .set_frontend = at76c651_set_parameters,
-        .get_tune_settings = at76c651_get_tune_settings,
-
-        .read_status = at76c651_read_status,
-        .read_ber = at76c651_read_ber,
-        .read_signal_strength = at76c651_read_signal_strength,
-        .read_snr = at76c651_read_snr,
-        .read_ucblocks = at76c651_read_ucblocks,
-};
-
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
-
-MODULE_DESCRIPTION("Atmel AT76C651 DVB-C Demodulator Driver");
-MODULE_AUTHOR("Andreas Oberritter <obi@linuxtv.org>");
-MODULE_LICENSE("GPL");
-
-EXPORT_SYMBOL(at76c651_attach);
diff --git a/drivers/media/dvb/frontends/at76c651.h b/drivers/media/dvb/frontends/at76c651.h
deleted file mode 100644
index 34054df93608..000000000000
--- a/drivers/media/dvb/frontends/at76c651.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * at76c651.c
- *
- * Atmel DVB-C Frontend Driver (at76c651)
- *
- * Copyright (C) 2001 fnbrd <fnbrd@gmx.de>
- *             & 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *             & 2003 Wolfram Joost <dbox2@frokaschwei.de>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * AT76C651
- * http://www.nalanda.nitc.ac.in/industry/datasheets/atmel/acrobat/doc1293.pdf
- * http://www.atmel.com/atmel/acrobat/doc1320.pdf
- */
-
-#ifndef AT76C651_H
-#define AT76C651_H
-
-#include <linux/dvb/frontend.h>
-
-struct at76c651_config
-{
-        /* the demodulator's i2c address */
-        u8 demod_address;
-
-        /* PLL maintenance */
-        int (*pll_init)(struct dvb_frontend* fe);
-        int (*pll_set)(struct dvb_frontend* fe, struct dvb_frontend_parameters* params);
-};
-
-extern struct dvb_frontend* at76c651_attach(const struct at76c651_config* config,
-                                            struct i2c_adapter* i2c);
-
-#endif // AT76C651_H
diff --git a/drivers/media/dvb/frontends/dvb-pll.c b/drivers/media/dvb/frontends/dvb-pll.c
index 1b9934ea5b06..4dcb6050d4fa 100644
--- a/drivers/media/dvb/frontends/dvb-pll.c
+++ b/drivers/media/dvb/frontends/dvb-pll.c
@@ -326,11 +326,11 @@ struct dvb_pll_desc dvb_pll_tuv1236d = {
 };
 EXPORT_SYMBOL(dvb_pll_tuv1236d);
 
-/* Samsung TBMV30111IN
+/* Samsung TBMV30111IN / TBMV30712IN1
  * used in Air2PC ATSC - 2nd generation (nxt2002)
  */
-struct dvb_pll_desc dvb_pll_tbmv30111in = {
-        .name = "Samsung TBMV30111IN",
+struct dvb_pll_desc dvb_pll_samsung_tbmv = {
+        .name = "Samsung TBMV30111IN / TBMV30712IN1",
         .min = 54000000,
         .max = 860000000,
         .count = 6,
@@ -343,7 +343,7 @@ struct dvb_pll_desc dvb_pll_tbmv30111in = {
                 { 999999999, 44000000, 166666, 0xfc, 0x02 },
         }
 };
-EXPORT_SYMBOL(dvb_pll_tbmv30111in);
+EXPORT_SYMBOL(dvb_pll_samsung_tbmv);
 
 /*
  * Philips SD1878 Tuner.
diff --git a/drivers/media/dvb/frontends/dvb-pll.h b/drivers/media/dvb/frontends/dvb-pll.h
index f682c09189b3..bb8d4b4eb183 100644
--- a/drivers/media/dvb/frontends/dvb-pll.h
+++ b/drivers/media/dvb/frontends/dvb-pll.h
@@ -38,7 +38,7 @@ extern struct dvb_pll_desc dvb_pll_tded4;
 
 extern struct dvb_pll_desc dvb_pll_tuv1236d;
 extern struct dvb_pll_desc dvb_pll_tdhu2;
-extern struct dvb_pll_desc dvb_pll_tbmv30111in;
+extern struct dvb_pll_desc dvb_pll_samsung_tbmv;
 extern struct dvb_pll_desc dvb_pll_philips_sd1878_tda8261;
 
 int dvb_pll_configure(struct dvb_pll_desc *desc, u8 *buf,
diff --git a/drivers/media/dvb/frontends/nxt2002.c b/drivers/media/dvb/frontends/nxt2002.c
deleted file mode 100644
index 4f263e65ba14..000000000000
--- a/drivers/media/dvb/frontends/nxt2002.c
+++ /dev/null
@@ -1,706 +0,0 @@
-/*
-    Support for B2C2/BBTI Technisat Air2PC - ATSC
-
-    Copyright (C) 2004 Taylor Jacob <rtjacob@earthlink.net>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-/*
- * This driver needs external firmware. Please use the command
- * "<kerneldir>/Documentation/dvb/get_dvb_firmware nxt2002" to
- * download/extract it, and then copy it to /usr/lib/hotplug/firmware
- * or /lib/firmware (depending on configuration of firmware hotplug).
- */
-#define NXT2002_DEFAULT_FIRMWARE "dvb-fe-nxt2002.fw"
-#define CRC_CCIT_MASK 0x1021
-
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/device.h>
-#include <linux/firmware.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-
-#include "dvb_frontend.h"
-#include "nxt2002.h"
-
-struct nxt2002_state {
-
-        struct i2c_adapter* i2c;
-        struct dvb_frontend_ops ops;
-        const struct nxt2002_config* config;
-        struct dvb_frontend frontend;
-
-        /* demodulator private data */
-        u8 initialised:1;
-};
-
-static int debug;
-#define dprintk(args...) \
-        do { \
-                if (debug) printk(KERN_DEBUG "nxt2002: " args); \
-        } while (0)
-
-static int i2c_writebytes (struct nxt2002_state* state, u8 reg, u8 *buf, u8 len)
-{
-        /* probbably a much better way or doing this */
-        u8 buf2 [256],x;
-        int err;
-        struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf2, .len = len + 1 };
-
-        buf2[0] = reg;
-        for (x = 0 ; x < len ; x++)
-                buf2[x+1] = buf[x];
-
-        if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
-                printk ("%s: i2c write error (addr %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
-                return -EREMOTEIO;
-        }
-
-        return 0;
-}
-
-static u8 i2c_readbytes (struct nxt2002_state* state, u8 reg, u8* buf, u8 len)
-{
-        u8 reg2 [] = { reg };
-
-        struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = reg2, .len = 1 },
-                        { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = buf, .len = len } };
-
-        int err;
-
-        if ((err = i2c_transfer (state->i2c, msg, 2)) != 2) {
-                printk ("%s: i2c read error (addr %02x, err == %i)\n",
-                        __FUNCTION__, state->config->demod_address, err);
-                return -EREMOTEIO;
-        }
-
-        return 0;
-}
-
-static u16 nxt2002_crc(u16 crc, u8 c)
-{
-
-        u8 i;
-        u16 input = (u16) c & 0xFF;
-
-        input<<=8;
-        for(i=0 ;i<8 ;i++) {
-                if((crc ^ input) & 0x8000)
-                        crc=(crc<<1)^CRC_CCIT_MASK;
-                else
-                        crc<<=1;
-        input<<=1;
-        }
-        return crc;
-}
-
-static int nxt2002_writereg_multibyte (struct nxt2002_state* state, u8 reg, u8* data, u8 len)
-{
-        u8 buf;
-        dprintk("%s\n", __FUNCTION__);
-
-        /* set multi register length */
-        i2c_writebytes(state,0x34,&len,1);
-
-        /* set mutli register register */
-        i2c_writebytes(state,0x35,&reg,1);
-
-        /* send the actual data */
-        i2c_writebytes(state,0x36,data,len);
-
-        /* toggle the multireg write bit*/
-        buf = 0x02;
-        i2c_writebytes(state,0x21,&buf,1);
-
-        i2c_readbytes(state,0x21,&buf,1);
-
-        if ((buf & 0x02) == 0)
-                return 0;
-
-        dprintk("Error writing multireg register %02X\n",reg);
-
-        return 0;
-}
-
-static int nxt2002_readreg_multibyte (struct nxt2002_state* state, u8 reg, u8* data, u8 len)
-{
-        u8 len2;
-        dprintk("%s\n", __FUNCTION__);
-
-        /* set multi register length */
-        len2 = len & 0x80;
-        i2c_writebytes(state,0x34,&len2,1);
-
-        /* set mutli register register */
-        i2c_writebytes(state,0x35,&reg,1);
-
-        /* send the actual data */
-        i2c_readbytes(state,reg,data,len);
-
-        return 0;
-}
-
-static void nxt2002_microcontroller_stop (struct nxt2002_state* state)
-{
-        u8 buf[2],counter = 0;
-        dprintk("%s\n", __FUNCTION__);
-
-        buf[0] = 0x80;
-        i2c_writebytes(state,0x22,buf,1);
-
-        while (counter < 20) {
-                i2c_readbytes(state,0x31,buf,1);
-                if (buf[0] & 0x40)
-                        return;
-                msleep(10);
-                counter++;
-        }
-
-        dprintk("Timeout waiting for micro to stop.. This is ok after firmware upload\n");
-        return;
-}
-
-static void nxt2002_microcontroller_start (struct nxt2002_state* state)
-{
-        u8 buf;
-        dprintk("%s\n", __FUNCTION__);
-
-        buf = 0x00;
-        i2c_writebytes(state,0x22,&buf,1);
-}
-
-static int nxt2002_writetuner (struct nxt2002_state* state, u8* data)
-{
-        u8 buf,count = 0;
-
-        dprintk("Tuner Bytes: %02X %02X %02X %02X\n",data[0],data[1],data[2],data[3]);
-
-        dprintk("%s\n", __FUNCTION__);
-        /* stop the micro first */
-        nxt2002_microcontroller_stop(state);
-
-        /* set the i2c transfer speed to the tuner */
-        buf = 0x03;
-        i2c_writebytes(state,0x20,&buf,1);
-
-        /* setup to transfer 4 bytes via i2c */
-        buf = 0x04;
-        i2c_writebytes(state,0x34,&buf,1);
-
-        /* write actual tuner bytes */
-        i2c_writebytes(state,0x36,data,4);
-
-        /* set tuner i2c address */
-        buf = 0xC2;
-        i2c_writebytes(state,0x35,&buf,1);
-
-        /* write UC Opmode to begin transfer */
-        buf = 0x80;
-        i2c_writebytes(state,0x21,&buf,1);
-
-        while (count < 20) {
-                i2c_readbytes(state,0x21,&buf,1);
-                if ((buf & 0x80)== 0x00)
-                        return 0;
-                msleep(100);
-                count++;
-        }
-
-        printk("nxt2002: timeout error writing tuner\n");
-        return 0;
-}
-
-static void nxt2002_agc_reset(struct nxt2002_state* state)
-{
-        u8 buf;
-        dprintk("%s\n", __FUNCTION__);
-
-        buf = 0x08;
-        i2c_writebytes(state,0x08,&buf,1);
-
-        buf = 0x00;
-        i2c_writebytes(state,0x08,&buf,1);
-
-        return;
-}
-
-static int nxt2002_load_firmware (struct dvb_frontend* fe, const struct firmware *fw)
-{
-
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 buf[256],written = 0,chunkpos = 0;
-        u16 rambase,position,crc = 0;
-
-        dprintk("%s\n", __FUNCTION__);
-        dprintk("Firmware is %zu bytes\n",fw->size);
-
-        /* Get the RAM base for this nxt2002 */
-        i2c_readbytes(state,0x10,buf,1);
-
-        if (buf[0] & 0x10)
-                rambase = 0x1000;
-        else
-                rambase = 0x0000;
-
-        dprintk("rambase on this nxt2002 is %04X\n",rambase);
-
-        /* Hold the micro in reset while loading firmware */
-        buf[0] = 0x80;
-        i2c_writebytes(state,0x2B,buf,1);
-
-        for (position = 0; position < fw->size ; position++) {
-                if (written == 0) {
-                        crc = 0;
-                        chunkpos = 0x28;
-                        buf[0] = ((rambase + position) >> 8);
-                        buf[1] = (rambase + position) & 0xFF;
-                        buf[2] = 0x81;
-                        /* write starting address */
-                        i2c_writebytes(state,0x29,buf,3);
-                }
-                written++;
-                chunkpos++;
-
-                if ((written % 4) == 0)
-                        i2c_writebytes(state,chunkpos,&fw->data[position-3],4);
-
-                crc = nxt2002_crc(crc,fw->data[position]);
-
-                if ((written == 255) || (position+1 == fw->size)) {
-                        /* write remaining bytes of firmware */
-                        i2c_writebytes(state, chunkpos+4-(written %4),
-                                &fw->data[position-(written %4) + 1],
-                                written %4);
-                        buf[0] = crc << 8;
-                        buf[1] = crc & 0xFF;
-
-                        /* write crc */
-                        i2c_writebytes(state,0x2C,buf,2);
-
-                        /* do a read to stop things */
-                        i2c_readbytes(state,0x2A,buf,1);
-
-                        /* set transfer mode to complete */
-                        buf[0] = 0x80;
-                        i2c_writebytes(state,0x2B,buf,1);
-
-                        written = 0;
-                }
-        }
-
-        printk ("done.\n");
-        return 0;
-};
-
-static int nxt2002_setup_frontend_parameters (struct dvb_frontend* fe,
-                                             struct dvb_frontend_parameters *p)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u32 freq = 0;
-        u16 tunerfreq = 0;
-        u8 buf[4];
-
-        freq = 44000 + ( p->frequency / 1000 );
-
-        dprintk("freq = %d      p->frequency = %d\n",freq,p->frequency);
-
-        tunerfreq = freq * 24/4000;
-
-        buf[0] = (tunerfreq >> 8) & 0x7F;
-        buf[1] = (tunerfreq & 0xFF);
-
-        if (p->frequency <= 214000000) {
-                buf[2] = 0x84 + (0x06 << 3);
-                buf[3] = (p->frequency <= 172000000) ? 0x01 : 0x02;
-        } else if (p->frequency <= 721000000) {
-                buf[2] = 0x84 + (0x07 << 3);
-                buf[3] = (p->frequency <= 467000000) ? 0x02 : 0x08;
-        } else if (p->frequency <= 841000000) {
-                buf[2] = 0x84 + (0x0E << 3);
-                buf[3] = 0x08;
-        } else {
-                buf[2] = 0x84 + (0x0F << 3);
-                buf[3] = 0x02;
-        }
-
-        /* write frequency information */
-        nxt2002_writetuner(state,buf);
-
-        /* reset the agc now that tuning has been completed */
-        nxt2002_agc_reset(state);
-
-        /* set target power level */
-        switch (p->u.vsb.modulation) {
-                case QAM_64:
-                case QAM_256:
-                                buf[0] = 0x74;
-                                break;
-                case VSB_8:
-                                buf[0] = 0x70;
-                                break;
-                default:
-                                return -EINVAL;
-                                break;
-        }
-        i2c_writebytes(state,0x42,buf,1);
-
-        /* configure sdm */
-        buf[0] = 0x87;
-        i2c_writebytes(state,0x57,buf,1);
-
-        /* write sdm1 input */
-        buf[0] = 0x10;
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x58,buf,2);
-
-        /* write sdmx input */
-        switch (p->u.vsb.modulation) {
-                case QAM_64:
-                                buf[0] = 0x68;
-                                break;
-                case QAM_256:
-                                buf[0] = 0x64;
-                                break;
-                case VSB_8:
-                                buf[0] = 0x60;
-                                break;
-                default:
-                                return -EINVAL;
-                                break;
-        }
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x5C,buf,2);
-
-        /* write adc power lpf fc */
-        buf[0] = 0x05;
-        i2c_writebytes(state,0x43,buf,1);
-
-        /* write adc power lpf fc */
-        buf[0] = 0x05;
-        i2c_writebytes(state,0x43,buf,1);
-
-        /* write accumulator2 input */
-        buf[0] = 0x80;
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x4B,buf,2);
-
-        /* write kg1 */
-        buf[0] = 0x00;
-        i2c_writebytes(state,0x4D,buf,1);
-
-        /* write sdm12 lpf fc */
-        buf[0] = 0x44;
-        i2c_writebytes(state,0x55,buf,1);
-
-        /* write agc control reg */
-        buf[0] = 0x04;
-        i2c_writebytes(state,0x41,buf,1);
-
-        /* write agc ucgp0 */
-        switch (p->u.vsb.modulation) {
-                case QAM_64:
-                                buf[0] = 0x02;
-                                break;
-                case QAM_256:
-                                buf[0] = 0x03;
-                                break;
-                case VSB_8:
-                                buf[0] = 0x00;
-                                break;
-                default:
-                                return -EINVAL;
-                                break;
-        }
-        i2c_writebytes(state,0x30,buf,1);
-
-        /* write agc control reg */
-        buf[0] = 0x00;
-        i2c_writebytes(state,0x41,buf,1);
-
-        /* write accumulator2 input */
-        buf[0] = 0x80;
-        buf[1] = 0x00;
-        nxt2002_writereg_multibyte(state,0x49,buf,2);
-        nxt2002_writereg_multibyte(state,0x4B,buf,2);
-
-        /* write agc control reg */
-        buf[0] = 0x04;
-        i2c_writebytes(state,0x41,buf,1);
-
-        nxt2002_microcontroller_start(state);
-
-        /* adjacent channel detection should be done here, but I don't
-        have any stations with this need so I cannot test it */
-
-        return 0;
-}
-
-static int nxt2002_read_status(struct dvb_frontend* fe, fe_status_t* status)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 lock;
-        i2c_readbytes(state,0x31,&lock,1);
-
-        *status = 0;
-        if (lock & 0x20) {
-                *status |= FE_HAS_SIGNAL;
-                *status |= FE_HAS_CARRIER;
-                *status |= FE_HAS_VITERBI;
-                *status |= FE_HAS_SYNC;
-                *status |= FE_HAS_LOCK;
-        }
-        return 0;
-}
-
-static int nxt2002_read_ber(struct dvb_frontend* fe, u32* ber)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[3];
-
-        nxt2002_readreg_multibyte(state,0xE6,b,3);
-
-        *ber = ((b[0] << 8) + b[1]) * 8;
-
-        return 0;
-}
-
-static int nxt2002_read_signal_strength(struct dvb_frontend* fe, u16* strength)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[2];
-        u16 temp = 0;
-
-        /* setup to read cluster variance */
-        b[0] = 0x00;
-        i2c_writebytes(state,0xA1,b,1);
-
-        /* get multreg val */
-        nxt2002_readreg_multibyte(state,0xA6,b,2);
-
-        temp = (b[0] << 8) | b[1];
-        *strength = ((0x7FFF - temp) & 0x0FFF) * 16;
-
-        return 0;
-}
-
-static int nxt2002_read_snr(struct dvb_frontend* fe, u16* snr)
-{
-
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[2];
-        u16 temp = 0, temp2;
-        u32 snrdb = 0;
-
-        /* setup to read cluster variance */
-        b[0] = 0x00;
-        i2c_writebytes(state,0xA1,b,1);
-
-        /* get multreg val from 0xA6 */
-        nxt2002_readreg_multibyte(state,0xA6,b,2);
-
-        temp = (b[0] << 8) | b[1];
-        temp2 = 0x7FFF - temp;
-
-        /* snr will be in db */
-        if (temp2 > 0x7F00)
-                snrdb = 1000*24 + ( 1000*(30-24) * ( temp2 - 0x7F00 ) / ( 0x7FFF - 0x7F00 ) );
-        else if (temp2 > 0x7EC0)
-                snrdb = 1000*18 + ( 1000*(24-18) * ( temp2 - 0x7EC0 ) / ( 0x7F00 - 0x7EC0 ) );
-        else if (temp2 > 0x7C00)
-                snrdb = 1000*12 + ( 1000*(18-12) * ( temp2 - 0x7C00 ) / ( 0x7EC0 - 0x7C00 ) );
-        else
-                snrdb = 1000*0 + ( 1000*(12-0) * ( temp2 - 0 ) / ( 0x7C00 - 0 ) );
-
-        /* the value reported back from the frontend will be FFFF=32db 0000=0db */
-
-        *snr = snrdb * (0xFFFF/32000);
-
-        return 0;
-}
-
-static int nxt2002_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        u8 b[3];
-
-        nxt2002_readreg_multibyte(state,0xE6,b,3);
-        *ucblocks = b[2];
-
-        return 0;
-}
-
-static int nxt2002_sleep(struct dvb_frontend* fe)
-{
-        return 0;
-}
-
-static int nxt2002_init(struct dvb_frontend* fe)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        const struct firmware *fw;
-        int ret;
-        u8 buf[2];
-
-        if (!state->initialised) {
-                /* request the firmware, this will block until someone uploads it */
-                printk("nxt2002: Waiting for firmware upload (%s)...\n", NXT2002_DEFAULT_FIRMWARE);
-                ret = state->config->request_firmware(fe, &fw, NXT2002_DEFAULT_FIRMWARE);
-                printk("nxt2002: Waiting for firmware upload(2)...\n");
-                if (ret) {
-                        printk("nxt2002: no firmware upload (timeout or file not found?)\n");
-                        return ret;
-                }
-
-                ret = nxt2002_load_firmware(fe, fw);
-                if (ret) {
-                        printk("nxt2002: writing firmware to device failed\n");
-                        release_firmware(fw);
-                        return ret;
-                }
-                printk("nxt2002: firmware upload complete\n");
-
-                /* Put the micro into reset */
-                nxt2002_microcontroller_stop(state);
-
-                /* ensure transfer is complete */
-                buf[0]=0;
-                i2c_writebytes(state,0x2B,buf,1);
-
-                /* Put the micro into reset for real this time */
-                nxt2002_microcontroller_stop(state);
-
-                /* soft reset everything (agc,frontend,eq,fec)*/
-                buf[0] = 0x0F;
-                i2c_writebytes(state,0x08,buf,1);
-                buf[0] = 0x00;
-                i2c_writebytes(state,0x08,buf,1);
-
-                /* write agc sdm configure */
-                buf[0] = 0xF1;
-                i2c_writebytes(state,0x57,buf,1);
-
-                /* write mod output format */
-                buf[0] = 0x20;
-                i2c_writebytes(state,0x09,buf,1);
-
-                /* write fec mpeg mode */
-                buf[0] = 0x7E;
-                buf[1] = 0x00;
-                i2c_writebytes(state,0xE9,buf,2);
-
-                /* write mux selection */
-                buf[0] = 0x00;
-                i2c_writebytes(state,0xCC,buf,1);
-
-                state->initialised = 1;
-        }
-
-        return 0;
-}
-
-static int nxt2002_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
-{
-        fesettings->min_delay_ms = 500;
-        fesettings->step_size = 0;
-        fesettings->max_drift = 0;
-        return 0;
-}
-
-static void nxt2002_release(struct dvb_frontend* fe)
-{
-        struct nxt2002_state* state = fe->demodulator_priv;
-        kfree(state);
-}
-
-static struct dvb_frontend_ops nxt2002_ops;
-
-struct dvb_frontend* nxt2002_attach(const struct nxt2002_config* config,
-                                   struct i2c_adapter* i2c)
-{
-        struct nxt2002_state* state = NULL;
-        u8 buf [] = {0,0,0,0,0};
-
-        /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct nxt2002_state), GFP_KERNEL);
-        if (state == NULL) goto error;
-
-        /* setup the state */
-        state->config = config;
-        state->i2c = i2c;
-        memcpy(&state->ops, &nxt2002_ops, sizeof(struct dvb_frontend_ops));
-        state->initialised = 0;
-
-        /* Check the first 5 registers to ensure this a revision we can handle */
-
-        i2c_readbytes(state, 0x00, buf, 5);
-        if (buf[0] != 0x04) goto error;         /* device id */
-        if (buf[1] != 0x02) goto error;         /* fab id */
-        if (buf[2] != 0x11) goto error;         /* month */
-        if (buf[3] != 0x20) goto error;         /* year msb */
-        if (buf[4] != 0x00) goto error;         /* year lsb */
-
-        /* create dvb_frontend */
-        state->frontend.ops = &state->ops;
-        state->frontend.demodulator_priv = state;
-        return &state->frontend;
-
-error:
-        kfree(state);
-        return NULL;
-}
-
-static struct dvb_frontend_ops nxt2002_ops = {
-
-        .info = {
-                .name = "Nextwave nxt2002 VSB/QAM frontend",
-                .type = FE_ATSC,
-                .frequency_min =  54000000,
-                .frequency_max = 860000000,
-                /* stepsize is just a guess */
-                .frequency_stepsize = 166666,
-                .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
-                        FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
-                        FE_CAN_8VSB | FE_CAN_QAM_64 | FE_CAN_QAM_256
-        },
-
-        .release = nxt2002_release,
-
-        .init = nxt2002_init,
-        .sleep = nxt2002_sleep,
-
-        .set_frontend = nxt2002_setup_frontend_parameters,
-        .get_tune_settings = nxt2002_get_tune_settings,
-
-        .read_status = nxt2002_read_status,
-        .read_ber = nxt2002_read_ber,
-        .read_signal_strength = nxt2002_read_signal_strength,
-        .read_snr = nxt2002_read_snr,
-        .read_ucblocks = nxt2002_read_ucblocks,
-
-};
-
-module_param(debug, int, 0644);
-MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
-
-MODULE_DESCRIPTION("NXT2002 ATSC (8VSB & ITU J83 AnnexB FEC QAM64/256) demodulator driver");
-MODULE_AUTHOR("Taylor Jacob");
-MODULE_LICENSE("GPL");
-
-EXPORT_SYMBOL(nxt2002_attach);
diff --git a/drivers/media/dvb/frontends/nxt2002.h b/drivers/media/dvb/frontends/nxt2002.h
deleted file mode 100644
index 462301f577ee..000000000000
--- a/drivers/media/dvb/frontends/nxt2002.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-   Driver for the Nxt2002 demodulator
-*/
-
-#ifndef NXT2002_H
-#define NXT2002_H
-
-#include <linux/dvb/frontend.h>
-#include <linux/firmware.h>
-
-struct nxt2002_config
-{
-        /* the demodulator's i2c address */
-        u8 demod_address;
-
-        /* request firmware for device */
-        int (*request_firmware)(struct dvb_frontend* fe, const struct firmware **fw, char* name);
-};
-
-extern struct dvb_frontend* nxt2002_attach(const struct nxt2002_config* config,
-                                           struct i2c_adapter* i2c);
-
-#endif // NXT2002_H
diff --git a/drivers/media/dvb/frontends/nxt200x.c b/drivers/media/dvb/frontends/nxt200x.c
index 78d2b93d35b9..9e3535394509 100644
--- a/drivers/media/dvb/frontends/nxt200x.c
+++ b/drivers/media/dvb/frontends/nxt200x.c
@@ -1,9 +1,10 @@
 /*
  *    Support for NXT2002 and NXT2004 - VSB/QAM
  *
- *    Copyright (C) 2005 Kirk Lapray (kirk.lapray@gmail.com)
+ *    Copyright (C) 2005 Kirk Lapray <kirk.lapray@gmail.com>
+ *    Copyright (C) 2006 Michael Krufky <mkrufky@m1k.net>
  *    based on nxt2002 by Taylor Jacob <rtjacob@earthlink.net>
- *    and nxt2004 by Jean-Francois Thibert (jeanfrancois@sagetv.com)
+ *    and nxt2004 by Jean-Francois Thibert <jeanfrancois@sagetv.com>
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -614,7 +615,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
         /* write sdm1 input */
         buf[0] = 0x10;
         buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x58, buf, 2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x58, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x58, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
 
         /* write sdmx input */
         switch (p->u.vsb.modulation) {
@@ -632,7 +643,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
                                 break;
         }
         buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x5C, buf, 2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x5C, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x5C, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
 
         /* write adc power lpf fc */
         buf[0] = 0x05;
@@ -648,7 +669,17 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
         /* write accumulator2 input */
         buf[0] = 0x80;
         buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x4B, buf, 2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x4B, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x4B, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
 
         /* write kg1 */
         buf[0] = 0x00;
@@ -714,8 +745,19 @@ static int nxt200x_setup_frontend_parameters (struct dvb_frontend* fe,
         /* write accumulator2 input */
         buf[0] = 0x80;
         buf[1] = 0x00;
-        nxt200x_writebytes(state, 0x49, buf,2);
-        nxt200x_writebytes(state, 0x4B, buf,2);
+        switch (state->demod_chip) {
+                case NXT2002:
+                        nxt200x_writereg_multibyte(state, 0x49, buf, 2);
+                        nxt200x_writereg_multibyte(state, 0x4B, buf, 2);
+                        break;
+                case NXT2004:
+                        nxt200x_writebytes(state, 0x49, buf, 2);
+                        nxt200x_writebytes(state, 0x4B, buf, 2);
+                        break;
+                default:
+                        return -EINVAL;
+                        break;
+        }
 
         /* write agc control reg */
         buf[0] = 0x04;
@@ -1199,7 +1241,7 @@ module_param(debug, int, 0644);
 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 
 MODULE_DESCRIPTION("NXT200X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
-MODULE_AUTHOR("Kirk Lapray, Jean-Francois Thibert, and Taylor Jacob");
+MODULE_AUTHOR("Kirk Lapray, Michael Krufky, Jean-Francois Thibert, and Taylor Jacob");
 MODULE_LICENSE("GPL");
 
 EXPORT_SYMBOL(nxt200x_attach);
diff --git a/drivers/media/dvb/frontends/tda80xx.c b/drivers/media/dvb/frontends/tda80xx.c
deleted file mode 100644
index d1cabb6a0a13..000000000000
--- a/drivers/media/dvb/frontends/tda80xx.c
+++ /dev/null
@@ -1,734 +0,0 @@
-/*
- * tda80xx.c
- *
- * Philips TDA8044 / TDA8083 QPSK demodulator driver
- *
- * Copyright (C) 2001 Felix Domke <tmbinc@elitedvb.net>
- * Copyright (C) 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <linux/config.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/spinlock.h>
-#include <linux/threads.h>
-#include <linux/interrupt.h>
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-#include <asm/irq.h>
-#include <asm/div64.h>
-
-#include "dvb_frontend.h"
-#include "tda80xx.h"
-
-enum {
-        ID_TDA8044 = 0x04,
-        ID_TDA8083 = 0x05,
-};
-
-
-struct tda80xx_state {
-
-        struct i2c_adapter* i2c;
-
-        struct dvb_frontend_ops ops;
-
-        /* configuration settings */
-        const struct tda80xx_config* config;
-
-        struct dvb_frontend frontend;
-
-        u32 clk;
-        int afc_loop;
-        struct work_struct worklet;
-        fe_code_rate_t code_rate;
-        fe_spectral_inversion_t spectral_inversion;
-        fe_status_t status;
-        u8 id;
-};
-
-static int debug = 1;
-#define dprintk if (debug) printk
-
-static u8 tda8044_inittab_pre[] = {
-        0x02, 0x00, 0x6f, 0xb5, 0x86, 0x22, 0x00, 0xea,
-        0x30, 0x42, 0x98, 0x68, 0x70, 0x42, 0x99, 0x58,
-        0x95, 0x10, 0xf5, 0xe7, 0x93, 0x0b, 0x15, 0x68,
-        0x9a, 0x90, 0x61, 0x80, 0x00, 0xe0, 0x40, 0x00,
-        0x0f, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00
-};
-
-static u8 tda8044_inittab_post[] = {
-        0x04, 0x00, 0x6f, 0xb5, 0x86, 0x22, 0x00, 0xea,
-        0x30, 0x42, 0x98, 0x68, 0x70, 0x42, 0x99, 0x50,
-        0x95, 0x10, 0xf5, 0xe7, 0x93, 0x0b, 0x15, 0x68,
-        0x9a, 0x90, 0x61, 0x80, 0x00, 0xe0, 0x40, 0x6c,
-        0x0f, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00
-};
-
-static u8 tda8083_inittab[] = {
-        0x04, 0x00, 0x4a, 0x79, 0x04, 0x00, 0xff, 0xea,
-        0x48, 0x42, 0x79, 0x60, 0x70, 0x52, 0x9a, 0x10,
-        0x0e, 0x10, 0xf2, 0xa7, 0x93, 0x0b, 0x05, 0xc8,
-        0x9d, 0x00, 0x42, 0x80, 0x00, 0x60, 0x40, 0x00,
-        0x00, 0x75, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00
-};
-
-static __inline__ u32 tda80xx_div(u32 a, u32 b)
-{
-        return (a + (b / 2)) / b;
-}
-
-static __inline__ u32 tda80xx_gcd(u32 a, u32 b)
-{
-        u32 r;
-
-        while ((r = a % b)) {
-                a = b;
-                b = r;
-        }
-
-        return b;
-}
-
-static int tda80xx_read(struct tda80xx_state* state, u8 reg, u8 *buf, u8 len)
-{
-        int ret;
-        struct i2c_msg msg[] = { { .addr = state->config->demod_address, .flags = 0, .buf = &reg, .len = 1 },
-                          { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = buf, .len = len } };
-
-        ret = i2c_transfer(state->i2c, msg, 2);
-
-        if (ret != 2)
-                dprintk("%s: readreg error (reg %02x, ret == %i)\n",
-                                __FUNCTION__, reg, ret);
-
-        mdelay(10);
-
-        return (ret == 2) ? 0 : -EREMOTEIO;
-}
-
-static int tda80xx_write(struct tda80xx_state* state, u8 reg, const u8 *buf, u8 len)
-{
-        int ret;
-        u8 wbuf[len + 1];
-        struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = wbuf, .len = len + 1 };
-
-        wbuf[0] = reg;
-        memcpy(&wbuf[1], buf, len);
-
-        ret = i2c_transfer(state->i2c, &msg, 1);
-
-        if (ret != 1)
-                dprintk("%s: i2c xfer error (ret == %i)\n", __FUNCTION__, ret);
-
-        mdelay(10);
-
-        return (ret == 1) ? 0 : -EREMOTEIO;
-}
-
-static __inline__ u8 tda80xx_readreg(struct tda80xx_state* state, u8 reg)
-{
-        u8 val;
-
-        tda80xx_read(state, reg, &val, 1);
-
-        return val;
-}
-
-static __inline__ int tda80xx_writereg(struct tda80xx_state* state, u8 reg, u8 data)
-{
-        return tda80xx_write(state, reg, &data, 1);
-}
-
-static int tda80xx_set_parameters(struct tda80xx_state* state,
-                                  fe_spectral_inversion_t inversion,
-                                  u32 symbol_rate,
-                                  fe_code_rate_t fec_inner)
-{
-        u8 buf[15];
-        u64 ratio;
-        u32 clk;
-        u32 k;
-        u32 sr = symbol_rate;
-        u32 gcd;
-        u8 scd;
-
-        if (symbol_rate > (state->clk * 3) / 16)
-                scd = 0;
-        else if (symbol_rate > (state->clk * 3) / 32)
-                scd = 1;
-        else if (symbol_rate > (state->clk * 3) / 64)
-                scd = 2;
-        else
-                scd = 3;
-
-        clk = scd ? (state->clk / (scd * 2)) : state->clk;
-
-        /*
-         * Viterbi decoder:
-         * Differential decoding off
-         * Spectral inversion unknown
-         * QPSK modulation
-         */
-        if (inversion == INVERSION_ON)
-                buf[0] = 0x60;
-        else if (inversion == INVERSION_OFF)
-                buf[0] = 0x20;
-        else
-                buf[0] = 0x00;
-
-        /*
-         * CLK ratio:
-         * system clock frequency is up to 64 or 96 MHz
-         *
-         * formula:
-         * r = k * clk / symbol_rate
-         *
-         * k:   2^21 for caa 0..3,
-         *      2^20 for caa 4..5,
-         *      2^19 for caa 6..7
-         */
-        if (symbol_rate <= (clk * 3) / 32)
-                k = (1 << 19);
-        else if (symbol_rate <= (clk * 3) / 16)
-                k = (1 << 20);
-        else
-                k = (1 << 21);
-
-        gcd = tda80xx_gcd(clk, sr);
-        clk /= gcd;
-        sr /= gcd;
-
-        gcd = tda80xx_gcd(k, sr);
-        k /= gcd;
-        sr /= gcd;
-
-        ratio = (u64)k * (u64)clk;
-        do_div(ratio, sr);
-
-        buf[1] = ratio >> 16;
-        buf[2] = ratio >> 8;
-        buf[3] = ratio;
-
-        /* nyquist filter roll-off factor 35% */
-        buf[4] = 0x20;
-
-        clk = scd ? (state->clk / (scd * 2)) : state->clk;
-
-        /* Anti Alias Filter */
-        if (symbol_rate < (clk * 3) / 64)
-                printk("tda80xx: unsupported symbol rate: %u\n", symbol_rate);
-        else if (symbol_rate <= clk / 16)
-                buf[4] |= 0x07;
-        else if (symbol_rate <= (clk * 3) / 32)
-                buf[4] |= 0x06;
-        else if (symbol_rate <= clk / 8)
-                buf[4] |= 0x05;
-        else if (symbol_rate <= (clk * 3) / 16)
-                buf[4] |= 0x04;
-        else if (symbol_rate <= clk / 4)
-                buf[4] |= 0x03;
-        else if (symbol_rate <= (clk * 3) / 8)
-                buf[4] |= 0x02;
-        else if (symbol_rate <= clk / 2)
-                buf[4] |= 0x01;
-        else
-                buf[4] |= 0x00;
-
-        /* Sigma Delta converter */
-        buf[5] = 0x00;
-
-        /* FEC: Possible puncturing rates */
-        if (fec_inner == FEC_NONE)
-                buf[6] = 0x00;
-        else if ((fec_inner >= FEC_1_2) && (fec_inner <= FEC_8_9))
-                buf[6] = (1 << (8 - fec_inner));
-        else if (fec_inner == FEC_AUTO)
-                buf[6] = 0xff;
-        else
-                return -EINVAL;
-
-        /* carrier lock detector threshold value */
-        buf[7] = 0x30;
-        /* AFC1: proportional part settings */
-        buf[8] = 0x42;
-        /* AFC1: integral part settings */
-        buf[9] = 0x98;
-        /* PD: Leaky integrator SCPC mode */
-        buf[10] = 0x28;
-        /* AFC2, AFC1 controls */
-        buf[11] = 0x30;
-        /* PD: proportional part settings */
-        buf[12] = 0x42;
-        /* PD: integral part settings */
-        buf[13] = 0x99;
-        /* AGC */
-        buf[14] = 0x50 | scd;
-
-        printk("symbol_rate=%u clk=%u\n", symbol_rate, clk);
-
-        return tda80xx_write(state, 0x01, buf, sizeof(buf));
-}
-
-static int tda80xx_set_clk(struct tda80xx_state* state)
-{
-        u8 buf[2];
-
-        /* CLK proportional part */
-        buf[0] = (0x06 << 5) | 0x08;    /* CMP[2:0], CSP[4:0] */
-        /* CLK integral part */
-        buf[1] = (0x04 << 5) | 0x1a;    /* CMI[2:0], CSI[4:0] */
-
-        return tda80xx_write(state, 0x17, buf, sizeof(buf));
-}
-
-#if 0
-static int tda80xx_set_scpc_freq_offset(struct tda80xx_state* state)
-{
-        /* a constant value is nonsense here imho */
-        return tda80xx_writereg(state, 0x22, 0xf9);
-}
-#endif
-
-static int tda80xx_close_loop(struct tda80xx_state* state)
-{
-        u8 buf[2];
-
-        /* PD: Loop closed, LD: lock detect enable, SCPC: Sweep mode - AFC1 loop closed */
-        buf[0] = 0x68;
-        /* AFC1: Loop closed, CAR Feedback: 8192 */
-        buf[1] = 0x70;
-
-        return tda80xx_write(state, 0x0b, buf, sizeof(buf));
-}
-
-static irqreturn_t tda80xx_irq(int irq, void *priv, struct pt_regs *pt)
-{
-        schedule_work(priv);
-
-        return IRQ_HANDLED;
-}
-
-static void tda80xx_read_status_int(struct tda80xx_state* state)
-{
-        u8 val;
-
-        static const fe_spectral_inversion_t inv_tab[] = {
-                INVERSION_OFF, INVERSION_ON
-        };
-
-        static const fe_code_rate_t fec_tab[] = {
-                FEC_8_9, FEC_1_2, FEC_2_3, FEC_3_4,
-                FEC_4_5, FEC_5_6, FEC_6_7, FEC_7_8,
-        };
-
-        val = tda80xx_readreg(state, 0x02);
-
-        state->status = 0;
-
-        if (val & 0x01) /* demodulator lock */
-                state->status |= FE_HAS_SIGNAL;
-        if (val & 0x02) /* clock recovery lock */
-                state->status |= FE_HAS_CARRIER;
-        if (val & 0x04) /* viterbi lock */
-                state->status |= FE_HAS_VITERBI;
-        if (val & 0x08) /* deinterleaver lock (packet sync) */
-                state->status |= FE_HAS_SYNC;
-        if (val & 0x10) /* derandomizer lock (frame sync) */
-                state->status |= FE_HAS_LOCK;
-        if (val & 0x20) /* frontend can not lock */
-                state->status |= FE_TIMEDOUT;
-
-        if ((state->status & (FE_HAS_CARRIER)) && (state->afc_loop)) {
-                printk("tda80xx: closing loop\n");
-                tda80xx_close_loop(state);
-                state->afc_loop = 0;
-        }
-
-        if (state->status & (FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK)) {
-                val = tda80xx_readreg(state, 0x0e);
-                state->code_rate = fec_tab[val & 0x07];
-                if (state->status & (FE_HAS_SYNC | FE_HAS_LOCK))
-                        state->spectral_inversion = inv_tab[(val >> 7) & 0x01];
-                else
-                        state->spectral_inversion = INVERSION_AUTO;
-        }
-        else {
-                state->code_rate = FEC_AUTO;
-        }
-}
-
-static void tda80xx_worklet(void *priv)
-{
-        struct tda80xx_state *state = priv;
-
-        tda80xx_writereg(state, 0x00, 0x04);
-        enable_irq(state->config->irq);
-
-        tda80xx_read_status_int(state);
-}
-
-static void tda80xx_wait_diseqc_fifo(struct tda80xx_state* state)
-{
-        size_t i;
-
-        for (i = 0; i < 100; i++) {
-                if (tda80xx_readreg(state, 0x02) & 0x80)
-                        break;
-                msleep(10);
-        }
-}
-
-static int tda8044_init(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        int ret;
-
-        /*
-         * this function is a mess...
-         */
-
-        if ((ret = tda80xx_write(state, 0x00, tda8044_inittab_pre, sizeof(tda8044_inittab_pre))))
-                return ret;
-
-        tda80xx_writereg(state, 0x0f, 0x50);
-#if 1
-        tda80xx_writereg(state, 0x20, 0x8F);            /* FIXME */
-        tda80xx_writereg(state, 0x20, state->config->volt18setting);    /* FIXME */
-        //tda80xx_writereg(state, 0x00, 0x04);
-        tda80xx_writereg(state, 0x00, 0x0C);
-#endif
-        //tda80xx_writereg(state, 0x00, 0x08); /* Reset AFC1 loop filter */
-
-        tda80xx_write(state, 0x00, tda8044_inittab_post, sizeof(tda8044_inittab_post));
-
-        if (state->config->pll_init) {
-                tda80xx_writereg(state, 0x1c, 0x80);
-                state->config->pll_init(fe);
-                tda80xx_writereg(state, 0x1c, 0x00);
-        }
-
-        return 0;
-}
-
-static int tda8083_init(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        tda80xx_write(state, 0x00, tda8083_inittab, sizeof(tda8083_inittab));
-
-        if (state->config->pll_init) {
-                tda80xx_writereg(state, 0x1c, 0x80);
-                state->config->pll_init(fe);
-                tda80xx_writereg(state, 0x1c, 0x00);
-        }
-
-        return 0;
-}
-
-static int tda80xx_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        switch (voltage) {
-        case SEC_VOLTAGE_13:
-                return tda80xx_writereg(state, 0x20, state->config->volt13setting);
-        case SEC_VOLTAGE_18:
-                return tda80xx_writereg(state, 0x20, state->config->volt18setting);
-        case SEC_VOLTAGE_OFF:
-                return tda80xx_writereg(state, 0x20, 0);
-        default:
-                return -EINVAL;
-        }
-}
-
-static int tda80xx_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        switch (tone) {
-        case SEC_TONE_OFF:
-                return tda80xx_writereg(state, 0x29, 0x00);
-        case SEC_TONE_ON:
-                return tda80xx_writereg(state, 0x29, 0x80);
-        default:
-                return -EINVAL;
-        }
-}
-
-static int tda80xx_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        if (cmd->msg_len > 6)
-                return -EINVAL;
-
-        tda80xx_writereg(state, 0x29, 0x08 | (cmd->msg_len - 3));
-        tda80xx_write(state, 0x23, cmd->msg, cmd->msg_len);
-        tda80xx_writereg(state, 0x29, 0x0c | (cmd->msg_len - 3));
-        tda80xx_wait_diseqc_fifo(state);
-
-        return 0;
-}
-
-static int tda80xx_send_diseqc_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t cmd)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        switch (cmd) {
-        case SEC_MINI_A:
-                tda80xx_writereg(state, 0x29, 0x14);
-                break;
-        case SEC_MINI_B:
-                tda80xx_writereg(state, 0x29, 0x1c);
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        tda80xx_wait_diseqc_fifo(state);
-
-        return 0;
-}
-
-static int tda80xx_sleep(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        tda80xx_writereg(state, 0x00, 0x02);    /* enter standby */
-
-        return 0;
-}
-
-static int tda80xx_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        tda80xx_writereg(state, 0x1c, 0x80);
-        state->config->pll_set(fe, p);
-        tda80xx_writereg(state, 0x1c, 0x00);
-
-        tda80xx_set_parameters(state, p->inversion, p->u.qpsk.symbol_rate, p->u.qpsk.fec_inner);
-        tda80xx_set_clk(state);
-        //tda80xx_set_scpc_freq_offset(state);
-        state->afc_loop = 1;
-
-        return 0;
-}
-
-static int tda80xx_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        if (!state->config->irq)
-                tda80xx_read_status_int(state);
-
-        p->inversion = state->spectral_inversion;
-        p->u.qpsk.fec_inner = state->code_rate;
-
-        return 0;
-}
-
-static int tda80xx_read_status(struct dvb_frontend* fe, fe_status_t* status)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        if (!state->config->irq)
-                tda80xx_read_status_int(state);
-        *status = state->status;
-
-        return 0;
-}
-
-static int tda80xx_read_ber(struct dvb_frontend* fe, u32* ber)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-        int ret;
-        u8 buf[3];
-
-        if ((ret = tda80xx_read(state, 0x0b, buf, sizeof(buf))))
-                return ret;
-
-        *ber = ((buf[0] & 0x1f) << 16) | (buf[1] << 8) | buf[2];
-
-        return 0;
-}
-
-static int tda80xx_read_signal_strength(struct dvb_frontend* fe, u16* strength)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        u8 gain = ~tda80xx_readreg(state, 0x01);
-        *strength = (gain << 8) | gain;
-
-        return 0;
-}
-
-static int tda80xx_read_snr(struct dvb_frontend* fe, u16* snr)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        u8 quality = tda80xx_readreg(state, 0x08);
-        *snr = (quality << 8) | quality;
-
-        return 0;
-}
-
-static int tda80xx_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        *ucblocks = tda80xx_readreg(state, 0x0f);
-        if (*ucblocks == 0xff)
-                *ucblocks = 0xffffffff;
-
-        return 0;
-}
-
-static int tda80xx_init(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        switch(state->id) {
-        case ID_TDA8044:
-                return tda8044_init(fe);
-
-        case ID_TDA8083:
-                return tda8083_init(fe);
-        }
-        return 0;
-}
-
-static void tda80xx_release(struct dvb_frontend* fe)
-{
-        struct tda80xx_state* state = fe->demodulator_priv;
-
-        if (state->config->irq)
-                free_irq(state->config->irq, &state->worklet);
-
-        kfree(state);
-}
-
-static struct dvb_frontend_ops tda80xx_ops;
-
-struct dvb_frontend* tda80xx_attach(const struct tda80xx_config* config,
-                                    struct i2c_adapter* i2c)
-{
-        struct tda80xx_state* state = NULL;
-        int ret;
-
-        /* allocate memory for the internal state */
-        state = kmalloc(sizeof(struct tda80xx_state), GFP_KERNEL);
-        if (state == NULL) goto error;
-
-        /* setup the state */
-        state->config = config;
-        state->i2c = i2c;
-        memcpy(&state->ops, &tda80xx_ops, sizeof(struct dvb_frontend_ops));
-        state->spectral_inversion = INVERSION_AUTO;
-        state->code_rate = FEC_AUTO;
-        state->status = 0;
-        state->afc_loop = 0;
-
-        /* check if the demod is there */
-        if (tda80xx_writereg(state, 0x89, 0x00) < 0) goto error;
-        state->id = tda80xx_readreg(state, 0x00);
-
-        switch (state->id) {
-        case ID_TDA8044:
-                state->clk = 96000000;
-                printk("tda80xx: Detected tda8044\n");
-                break;
-
-        case ID_TDA8083:
-                state->clk = 64000000;
-                printk("tda80xx: Detected tda8083\n");
-                break;
-
-        default:
-                goto error;
-        }
-
-        /* setup IRQ */
-        if (state->config->irq) {
-                INIT_WORK(&state->worklet, tda80xx_worklet, state);
-                if ((ret = request_irq(state->config->irq, tda80xx_irq, SA_ONESHOT, "tda80xx", &state->worklet)) < 0) {
-                        printk(KERN_ERR "tda80xx: request_irq failed (%d)\n", ret);
-                        goto error;
-                }
-        }
-
-        /* create dvb_frontend */
-        state->frontend.ops = &state->ops;
-        state->frontend.demodulator_priv = state;
-        return &state->frontend;
-
-error:
-        kfree(state);
-        return NULL;
-}
-
-static struct dvb_frontend_ops tda80xx_ops = {
-
-        .info = {
-                .name = "Philips TDA80xx DVB-S",
-                .type = FE_QPSK,
-                .frequency_min = 500000,
-                .frequency_max = 2700000,
-                .frequency_stepsize = 125,
-                .symbol_rate_min = 4500000,
-                .symbol_rate_max = 45000000,
-                .caps = FE_CAN_INVERSION_AUTO |
-                        FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
-                        FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
-                        FE_CAN_FEC_7_8 | FE_CAN_FEC_8_9 | FE_CAN_FEC_AUTO |
-                        FE_CAN_QPSK |
-                        FE_CAN_MUTE_TS
-        },
-
-        .release = tda80xx_release,
-
-        .init = tda80xx_init,
-        .sleep = tda80xx_sleep,
-
-        .set_frontend = tda80xx_set_frontend,
-        .get_frontend = tda80xx_get_frontend,
-
-        .read_status = tda80xx_read_status,
-        .read_ber = tda80xx_read_ber,
-        .read_signal_strength = tda80xx_read_signal_strength,
-        .read_snr = tda80xx_read_snr,
-        .read_ucblocks = tda80xx_read_ucblocks,
-
-        .diseqc_send_master_cmd = tda80xx_send_diseqc_msg,
-        .diseqc_send_burst = tda80xx_send_diseqc_burst,
-        .set_tone = tda80xx_set_tone,
-        .set_voltage = tda80xx_set_voltage,
-};
-
-module_param(debug, int, 0644);
-
-MODULE_DESCRIPTION("Philips TDA8044 / TDA8083 DVB-S Demodulator driver");
-MODULE_AUTHOR("Felix Domke, Andreas Oberritter");
-MODULE_LICENSE("GPL");
-
-EXPORT_SYMBOL(tda80xx_attach);
diff --git a/drivers/media/dvb/frontends/tda80xx.h b/drivers/media/dvb/frontends/tda80xx.h
deleted file mode 100644
index cd639a0aad55..000000000000
--- a/drivers/media/dvb/frontends/tda80xx.h
+++ /dev/null
@@ -1,51 +0,0 @@
-/*
- * tda80xx.c
- *
- * Philips TDA8044 / TDA8083 QPSK demodulator driver
- *
- * Copyright (C) 2001 Felix Domke <tmbinc@elitedvb.net>
- * Copyright (C) 2002-2004 Andreas Oberritter <obi@linuxtv.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef TDA80XX_H
-#define TDA80XX_H
-
-#include <linux/dvb/frontend.h>
-
-struct tda80xx_config
-{
-        /* the demodulator's i2c address */
-        u8 demod_address;
-
-        /* IRQ to use (0=>no IRQ used) */
-        u32 irq;
-
-        /* Register setting to use for 13v */
-        u8 volt13setting;
-
-        /* Register setting to use for 18v */
-        u8 volt18setting;
-
-        /* PLL maintenance */
-        int (*pll_init)(struct dvb_frontend* fe);
-        int (*pll_set)(struct dvb_frontend* fe, struct dvb_frontend_parameters* params);
-};
-
-extern struct dvb_frontend* tda80xx_attach(const struct tda80xx_config* config,
-                                           struct i2c_adapter* i2c);
-
-#endif // TDA80XX_H
diff --git a/drivers/media/dvb/ttpci/av7110.c b/drivers/media/dvb/ttpci/av7110.c
index 27494901975f..d36369e9e88f 100644
--- a/drivers/media/dvb/ttpci/av7110.c
+++ b/drivers/media/dvb/ttpci/av7110.c
@@ -2329,6 +2329,17 @@ static int frontend_init(struct av7110 *av7110)
                         av7110->fe = ves1820_attach(&alps_tdbe2_config, &av7110->i2c_adap, read_pwm(av7110));
                         break;
 
+                case 0x0004: // Galaxis DVB-S rev1.3
+                        /* ALPS BSRV2 */
+                        av7110->fe = ves1x93_attach(&alps_bsrv2_config, &av7110->i2c_adap);
+                        if (av7110->fe) {
+                                av7110->fe->ops->diseqc_send_master_cmd = av7110_diseqc_send_master_cmd;
+                                av7110->fe->ops->diseqc_send_burst = av7110_diseqc_send_burst;
+                                av7110->fe->ops->set_tone = av7110_set_tone;
+                                av7110->recover = dvb_s_recover;
+                        }
+                        break;
+
                 case 0x0006: /* Fujitsu-Siemens DVB-S rev 1.6 */
                         /* Grundig 29504-451 */
                         av7110->fe = tda8083_attach(&grundig_29504_451_config, &av7110->i2c_adap);
@@ -2930,6 +2941,7 @@ MAKE_AV7110_INFO(tts_1_3se,  "Technotrend/Hauppauge WinTV DVB-S rev1.3 SE");
 MAKE_AV7110_INFO(ttt,        "Technotrend/Hauppauge DVB-T");
 MAKE_AV7110_INFO(fsc,        "Fujitsu Siemens DVB-C");
 MAKE_AV7110_INFO(fss,        "Fujitsu Siemens DVB-S rev1.6");
+MAKE_AV7110_INFO(gxs_1_3,    "Galaxis DVB-S rev1.3");
 
 static struct pci_device_id pci_tbl[] = {
         MAKE_EXTENSION_PCI(fsc,         0x110a, 0x0000),
@@ -2937,13 +2949,13 @@ static struct pci_device_id pci_tbl[] = {
         MAKE_EXTENSION_PCI(ttt_1_X,     0x13c2, 0x0001),
         MAKE_EXTENSION_PCI(ttc_2_X,     0x13c2, 0x0002),
         MAKE_EXTENSION_PCI(tts_2_X,     0x13c2, 0x0003),
+        MAKE_EXTENSION_PCI(gxs_1_3,     0x13c2, 0x0004),
         MAKE_EXTENSION_PCI(fss,         0x13c2, 0x0006),
         MAKE_EXTENSION_PCI(ttt,         0x13c2, 0x0008),
         MAKE_EXTENSION_PCI(ttc_1_X,     0x13c2, 0x000a),
         MAKE_EXTENSION_PCI(tts_2_3,     0x13c2, 0x000e),
         MAKE_EXTENSION_PCI(tts_1_3se,   0x13c2, 0x1002),
 
-/*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0004), UNDEFINED CARD */ // Galaxis DVB PC-Sat-Carte
 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0005), UNDEFINED CARD */ // Technisat SkyStar1
 /*      MAKE_EXTENSION_PCI(???, 0x13c2, 0x0009), UNDEFINED CARD */ // TT/Hauppauge WinTV Nexus-CA v????
 
diff --git a/drivers/media/dvb/ttpci/av7110.h b/drivers/media/dvb/ttpci/av7110.h
index 6ea30df2e823..fafd25fab835 100644
--- a/drivers/media/dvb/ttpci/av7110.h
+++ b/drivers/media/dvb/ttpci/av7110.h
@@ -273,8 +273,6 @@ struct av7110 {
 extern int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
                        u16 subpid, u16 pcrpid);
 
-extern int av7110_setup_irc_config (struct av7110 *av7110, u32 ir_config);
-
 extern int av7110_ir_init(struct av7110 *av7110);
 extern void av7110_ir_exit(struct av7110 *av7110);
 
diff --git a/drivers/media/dvb/ttpci/av7110_ir.c b/drivers/media/dvb/ttpci/av7110_ir.c
index 9138132ad25f..617e4f6c0ed7 100644
--- a/drivers/media/dvb/ttpci/av7110_ir.c
+++ b/drivers/media/dvb/ttpci/av7110_ir.c
@@ -155,6 +155,19 @@ static void input_repeat_key(unsigned long data)
 }
 
 
+static int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
+{
+        int ret = 0;
+
+        dprintk(4, "%p\n", av7110);
+        if (av7110) {
+                ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
+                av7110->ir_config = ir_config;
+        }
+        return ret;
+}
+
+
 static int av7110_ir_write_proc(struct file *file, const char __user *buffer,
                                 unsigned long count, void *data)
 {
@@ -187,19 +200,6 @@ static int av7110_ir_write_proc(struct file *file, const char __user *buffer,
 }
 
 
-int av7110_setup_irc_config(struct av7110 *av7110, u32 ir_config)
-{
-        int ret = 0;
-
-        dprintk(4, "%p\n", av7110);
-        if (av7110) {
-                ret = av7110_fw_cmd(av7110, COMTYPE_PIDFILTER, SetIR, 1, ir_config);
-                av7110->ir_config = ir_config;
-        }
-        return ret;
-}
-
-
 static void ir_handler(struct av7110 *av7110, u32 ircom)
 {
         dprintk(4, "ircommand = %08x\n", ircom);
diff --git a/drivers/media/video/bttv-driver.c b/drivers/media/video/bttv-driver.c
index aa4c4c521880..578b20085082 100644
--- a/drivers/media/video/bttv-driver.c
+++ b/drivers/media/video/bttv-driver.c
@@ -214,7 +214,7 @@ const struct bttv_tvnorm bttv_tvnorms[] = {
                    we can capture, of the first and second field. */
                 .vbistart       = { 7,320 },
         },{
-                .v4l2_id        = V4L2_STD_NTSC_M,
+                .v4l2_id        = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
                 .name           = "NTSC",
                 .Fsc            = 28636363,
                 .swidth         = 768,
diff --git a/drivers/media/video/compat_ioctl32.c b/drivers/media/video/compat_ioctl32.c
index 297c32ab51e3..840fe0177121 100644
--- a/drivers/media/video/compat_ioctl32.c
+++ b/drivers/media/video/compat_ioctl32.c
@@ -167,29 +167,32 @@ static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user
         if (kp->clipcount > 2048)
                 return -EINVAL;
         if (kp->clipcount) {
-                struct v4l2_clip32 *uclips = compat_ptr(up->clips);
-                struct v4l2_clip *kclips;
+                struct v4l2_clip32 __user *uclips;
+                struct v4l2_clip __user *kclips;
                 int n = kp->clipcount;
+                compat_caddr_t p;
 
+                if (get_user(p, &up->clips))
+                        return -EFAULT;
+                uclips = compat_ptr(p);
                 kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
                 kp->clips = kclips;
                 while (--n >= 0) {
-                        if (!access_ok(VERIFY_READ, &uclips->c, sizeof(uclips->c)) ||
-                                copy_from_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
+                        if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
+                                return -EFAULT;
+                        if (put_user(n ? kclips + 1 : NULL, &kclips->next))
                                 return -EFAULT;
-                        kclips->next = n ? kclips + 1 : 0;
                         uclips += 1;
                         kclips += 1;
                 }
         } else
-                kp->clips = 0;
+                kp->clips = NULL;
         return 0;
 }
 
 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_window32)) ||
-                copy_to_user(&up->w, &kp->w, sizeof(up->w)) ||
+        if (copy_to_user(&up->w, &kp->w, sizeof(up->w)) ||
                 put_user(kp->field, &up->field) ||
                 put_user(kp->chromakey, &up->chromakey) ||
                 put_user(kp->clipcount, &up->clipcount))
@@ -199,33 +202,29 @@ static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user
 
 static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_pix_format)) ||
-                copy_from_user(kp, up, sizeof(struct v4l2_pix_format)))
-                        return -EFAULT;
+        if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format)))
+                return -EFAULT;
         return 0;
 }
 
 static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_pix_format)) ||
-                copy_to_user(up, kp, sizeof(struct v4l2_pix_format)))
-                        return -EFAULT;
+        if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format)))
+                return -EFAULT;
         return 0;
 }
 
 static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_vbi_format)) ||
-                copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)))
-                        return -EFAULT;
+        if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)))
+                return -EFAULT;
         return 0;
 }
 
 static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_vbi_format)) ||
-                copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)))
-                        return -EFAULT;
+        if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)))
+                return -EFAULT;
         return 0;
 }
 
@@ -279,18 +278,16 @@ static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user
 
 static inline int get_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard)) ||
-                copy_from_user(kp, up, sizeof(struct v4l2_standard)))
-                        return -EFAULT;
+        if (copy_from_user(kp, up, sizeof(struct v4l2_standard)))
+                return -EFAULT;
         return 0;
 
 }
 
 static inline int put_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard)) ||
-                copy_to_user(up, kp, sizeof(struct v4l2_standard)))
-                        return -EFAULT;
+        if (copy_to_user(up, kp, sizeof(struct v4l2_standard)))
+                return -EFAULT;
         return 0;
 }
 
@@ -328,18 +325,16 @@ static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32
 
 static inline int get_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_tuner)) ||
-                copy_from_user(kp, up, sizeof(struct v4l2_tuner)))
-                        return -EFAULT;
+        if (copy_from_user(kp, up, sizeof(struct v4l2_tuner)))
+                return -EFAULT;
         return 0;
 
 }
 
 static inline int put_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_tuner)) ||
-                copy_to_user(up, kp, sizeof(struct v4l2_tuner)))
-                        return -EFAULT;
+        if (copy_to_user(up, kp, sizeof(struct v4l2_tuner)))
+                return -EFAULT;
         return 0;
 }
 
@@ -380,11 +375,13 @@ static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user
                 break;
         case V4L2_MEMORY_USERPTR:
                 {
-                unsigned long tmp = (unsigned long)compat_ptr(up->m.userptr);
+                compat_long_t tmp;
 
-                if(get_user(kp->length, &up->length) ||
-                        get_user(kp->m.userptr, &tmp))
-                                return -EFAULT;
+                if (get_user(kp->length, &up->length) ||
+                    get_user(tmp, &up->m.userptr))
+                        return -EFAULT;
+
+                kp->m.userptr = (unsigned long)compat_ptr(tmp);
                 }
                 break;
         case V4L2_MEMORY_OVERLAY:
@@ -468,33 +465,29 @@ static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_frame
 
 static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_input) - 4) ||
-                copy_from_user(kp, up, sizeof(struct v4l2_input) - 4))
-                        return -EFAULT;
+        if (copy_from_user(kp, up, sizeof(struct v4l2_input) - 4))
+                return -EFAULT;
         return 0;
 }
 
 static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_input) - 4) ||
-                copy_to_user(up, kp, sizeof(struct v4l2_input) - 4))
-                        return -EFAULT;
+        if (copy_to_user(up, kp, sizeof(struct v4l2_input) - 4))
+                return -EFAULT;
         return 0;
 }
 
 static inline int get_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_input)) ||
-                copy_from_user(kp, up, sizeof(struct v4l2_input)))
-                        return -EFAULT;
+        if (copy_from_user(kp, up, sizeof(struct v4l2_input)))
+                return -EFAULT;
         return 0;
 }
 
 static inline int put_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
 {
-        if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_input)) ||
-                copy_to_user(up, kp, sizeof(struct v4l2_input)))
-                        return -EFAULT;
+        if (copy_to_user(up, kp, sizeof(struct v4l2_input)))
+                return -EFAULT;
         return 0;
 }
 
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index c66c2c1f4809..08ffd1f325fc 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -220,33 +220,23 @@ static void input_change(struct i2c_client *client)
                 cx25840_write(client, 0x808, 0xff);
                 cx25840_write(client, 0x80b, 0x10);
         } else if (std & V4L2_STD_NTSC) {
-                /* NTSC */
-                if (state->pvr150_workaround) {
-                        /* Certain Hauppauge PVR150 models have a hardware bug
-                           that causes audio to drop out. For these models the
-                           audio standard must be set explicitly.
-                           To be precise: it affects cards with tuner models
-                           85, 99 and 112 (model numbers from tveeprom). */
-                        if (std == V4L2_STD_NTSC_M_JP) {
-                                /* Japan uses EIAJ audio standard */
-                                cx25840_write(client, 0x808, 0x2f);
-                        } else {
-                                /* Others use the BTSC audio standard */
-                                cx25840_write(client, 0x808, 0x1f);
-                        }
-                        /* South Korea uses the A2-M (aka Zweiton M) audio
-                           standard, and should set 0x808 to 0x3f, but I don't
-                           know how to detect this. */
-                } else if (std == V4L2_STD_NTSC_M_JP) {
+                /* Certain Hauppauge PVR150 models have a hardware bug
+                   that causes audio to drop out. For these models the
+                   audio standard must be set explicitly.
+                   To be precise: it affects cards with tuner models
+                   85, 99 and 112 (model numbers from tveeprom). */
+                int hw_fix = state->pvr150_workaround;
+
+                if (std == V4L2_STD_NTSC_M_JP) {
                         /* Japan uses EIAJ audio standard */
-                        cx25840_write(client, 0x808, 0xf7);
+                        cx25840_write(client, 0x808, hw_fix ? 0x2f : 0xf7);
+                } else if (std == V4L2_STD_NTSC_M_KR) {
+                        /* South Korea uses A2 audio standard */
+                        cx25840_write(client, 0x808, hw_fix ? 0x3f : 0xf8);
                 } else {
                         /* Others use the BTSC audio standard */
-                        cx25840_write(client, 0x808, 0xf6);
+                        cx25840_write(client, 0x808, hw_fix ? 0x1f : 0xf6);
                 }
-                /* South Korea uses the A2-M (aka Zweiton M) audio standard,
-                   and should set 0x808 to 0xf8, but I don't know how to
-                   detect this. */
                 cx25840_write(client, 0x80b, 0x00);
         }
 
@@ -330,17 +320,17 @@ static int set_v4lstd(struct i2c_client *client, v4l2_std_id std)
         u8 fmt=0;       /* zero is autodetect */
 
         /* First tests should be against specific std */
-        if (std & V4L2_STD_NTSC_M_JP) {
+        if (std == V4L2_STD_NTSC_M_JP) {
                 fmt=0x2;
-        } else if (std & V4L2_STD_NTSC_443) {
+        } else if (std == V4L2_STD_NTSC_443) {
                 fmt=0x3;
-        } else if (std & V4L2_STD_PAL_M) {
+        } else if (std == V4L2_STD_PAL_M) {
                 fmt=0x5;
-        } else if (std & V4L2_STD_PAL_N) {
+        } else if (std == V4L2_STD_PAL_N) {
                 fmt=0x6;
-        } else if (std & V4L2_STD_PAL_Nc) {
+        } else if (std == V4L2_STD_PAL_Nc) {
                 fmt=0x7;
-        } else if (std & V4L2_STD_PAL_60) {
+        } else if (std == V4L2_STD_PAL_60) {
                 fmt=0x8;
         } else {
                 /* Then, test against generic ones */
@@ -369,7 +359,7 @@ v4l2_std_id cx25840_get_v4lstd(struct i2c_client * client)
         }
 
         switch (fmt) {
-        case 0x1: return V4L2_STD_NTSC_M;
+        case 0x1: return V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR;
         case 0x2: return V4L2_STD_NTSC_M_JP;
         case 0x3: return V4L2_STD_NTSC_443;
         case 0x4: return V4L2_STD_PAL;
diff --git a/drivers/media/video/cx88/Kconfig b/drivers/media/video/cx88/Kconfig
index 53308911ae6e..e99dfbbf3e95 100644
--- a/drivers/media/video/cx88/Kconfig
+++ b/drivers/media/video/cx88/Kconfig
@@ -32,6 +32,7 @@ config VIDEO_CX88_DVB
 config VIDEO_CX88_ALSA
         tristate "ALSA DMA audio support"
         depends on VIDEO_CX88 && SND && EXPERIMENTAL
+        select SND_PCM
         ---help---
           This is a video4linux driver for direct (DMA) audio on
           Conexant 2388x based TV cards.
@@ -48,6 +49,7 @@ config VIDEO_CX88_DVB_ALL_FRONTENDS
         default y
         depends on VIDEO_CX88_DVB
         select DVB_MT352
+        select VIDEO_CX88_VP3054
         select DVB_OR51132
         select DVB_CX22702
         select DVB_LGDT330X
@@ -69,6 +71,16 @@ config VIDEO_CX88_DVB_MT352
           This adds DVB-T support for cards based on the
           Connexant 2388x chip and the MT352 demodulator.
 
+config VIDEO_CX88_VP3054
+        tristate "VP-3054 Secondary I2C Bus Support"
+        default m
+        depends on DVB_MT352
+        ---help---
+          This adds DVB-T support for cards based on the
+          Connexant 2388x chip and the MT352 demodulator,
+          which also require support for the VP-3054
+          Secondary I2C bus, such at DNTV Live! DVB-T Pro.
+
 config VIDEO_CX88_DVB_OR51132
         bool "OR51132 ATSC Support"
         default y
diff --git a/drivers/media/video/cx88/Makefile b/drivers/media/video/cx88/Makefile
index 6e5eaa22619e..2b902784facc 100644
--- a/drivers/media/video/cx88/Makefile
+++ b/drivers/media/video/cx88/Makefile
@@ -4,8 +4,9 @@ cx8800-objs	:= cx88-video.o cx88-vbi.o
 cx8802-objs     := cx88-mpeg.o
 
 obj-$(CONFIG_VIDEO_CX88) += cx88xx.o cx8800.o cx8802.o cx88-blackbird.o
-obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o cx88-vp3054-i2c.o
+obj-$(CONFIG_VIDEO_CX88_DVB) += cx88-dvb.o
 obj-$(CONFIG_VIDEO_CX88_ALSA) += cx88-alsa.o
+obj-$(CONFIG_VIDEO_CX88_VP3054) += cx88-vp3054-i2c.o
 
 EXTRA_CFLAGS += -I$(src)/..
 EXTRA_CFLAGS += -I$(srctree)/drivers/media/dvb/dvb-core
@@ -18,6 +19,6 @@ extra-cflags-$(CONFIG_DVB_LGDT330X)  += -DHAVE_LGDT330X=1
 extra-cflags-$(CONFIG_DVB_MT352)     += -DHAVE_MT352=1
 extra-cflags-$(CONFIG_DVB_NXT200X)   += -DHAVE_NXT200X=1
 extra-cflags-$(CONFIG_DVB_CX24123)   += -DHAVE_CX24123=1
-extra-cflags-$(CONFIG_VIDEO_CX88_DVB)+= -DHAVE_VP3054_I2C=1
+extra-cflags-$(CONFIG_VIDEO_CX88_VP3054)+= -DHAVE_VP3054_I2C=1
 
 EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m)
diff --git a/drivers/media/video/cx88/cx88-alsa.c b/drivers/media/video/cx88/cx88-alsa.c
index a2e36a1e5f59..2acccd6d49bc 100644
--- a/drivers/media/video/cx88/cx88-alsa.c
+++ b/drivers/media/video/cx88/cx88-alsa.c
@@ -128,7 +128,7 @@ MODULE_PARM_DESC(debug,"enable debug messages");
  * BOARD Specific: Sets audio DMA
  */
 
-int _cx88_start_audio_dma(snd_cx88_card_t *chip)
+static int _cx88_start_audio_dma(snd_cx88_card_t *chip)
 {
         struct cx88_buffer   *buf = chip->buf;
         struct cx88_core *core=chip->core;
@@ -173,7 +173,7 @@ int _cx88_start_audio_dma(snd_cx88_card_t *chip)
 /*
  * BOARD Specific: Resets audio DMA
  */
-int _cx88_stop_audio_dma(snd_cx88_card_t *chip)
+static int _cx88_stop_audio_dma(snd_cx88_card_t *chip)
 {
         struct cx88_core *core=chip->core;
         dprintk(1, "Stopping audio DMA\n");
@@ -613,7 +613,7 @@ static snd_kcontrol_new_t snd_cx88_capture_volume = {
  * Only boards with eeprom and byte 1 at eeprom=1 have it
  */
 
-struct pci_device_id cx88_audio_pci_tbl[] = {
+static struct pci_device_id cx88_audio_pci_tbl[] = {
         {0x14f1,0x8801,PCI_ANY_ID,PCI_ANY_ID,0,0,0},
         {0x14f1,0x8811,PCI_ANY_ID,PCI_ANY_ID,0,0,0},
         {0, }
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index ad2f565f522c..1bc999247fdc 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1246,6 +1246,11 @@ struct cx88_subid cx88_subids[] = {
                 .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL,
         },{
                 .subvendor = 0x18ac,
+                .subdevice = 0xdb54,
+                .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL,
+                /* Re-branded DViCO: DigitalNow DVB-T Dual */
+        },{
+                .subvendor = 0x18ac,
                 .subdevice = 0xdb11,
                 .card      = CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS,
                 /* Re-branded DViCO: UltraView DVB-T Plus */
@@ -1293,6 +1298,7 @@ static void hauppauge_eeprom(struct cx88_core *core, u8 *eeprom_data)
         switch (tv.model)
         {
         case 28552: /* WinTV-PVR 'Roslyn' (No IR) */
+        case 34519: /* WinTV-PCI-FM */
         case 90002: /* Nova-T-PCI (9002) */
         case 92001: /* Nova-S-Plus (Video and IR) */
         case 92002: /* Nova-S-Plus (Video and IR) */
diff --git a/drivers/media/video/cx88/cx88-core.c b/drivers/media/video/cx88/cx88-core.c
index 8d6d6a6cf785..3720f24a25cf 100644
--- a/drivers/media/video/cx88/cx88-core.c
+++ b/drivers/media/video/cx88/cx88-core.c
@@ -787,12 +787,14 @@ static int set_pll(struct cx88_core *core, int prescale, u32 ofreq)
 
 int cx88_start_audio_dma(struct cx88_core *core)
 {
+        /* constant 128 made buzz in analog Nicam-stereo for bigger fifo_size */
+        int bpl = cx88_sram_channels[SRAM_CH25].fifo_size/4;
         /* setup fifo + format */
-        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], 128, 0);
-        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], 128, 0);
+        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH25], bpl, 0);
+        cx88_sram_channel_setup(core, &cx88_sram_channels[SRAM_CH26], bpl, 0);
 
-        cx_write(MO_AUDD_LNGTH,    128); /* fifo bpl size */
-        cx_write(MO_AUDR_LNGTH,    128); /* fifo bpl size */
+        cx_write(MO_AUDD_LNGTH, bpl); /* fifo bpl size */
+        cx_write(MO_AUDR_LNGTH, bpl); /* fifo bpl size */
 
         /* start dma */
         cx_write(MO_AUD_DMACNTRL, 0x0003); /* Up and Down fifo enable */
diff --git a/drivers/media/video/cx88/cx88-input.c b/drivers/media/video/cx88/cx88-input.c
index da2ad5c4b553..165d948624a3 100644
--- a/drivers/media/video/cx88/cx88-input.c
+++ b/drivers/media/video/cx88/cx88-input.c
@@ -482,6 +482,7 @@ int cx88_ir_init(struct cx88_core *core, struct pci_dev *pci)
         switch (core->board) {
         case CX88_BOARD_DNTV_LIVE_DVB_T:
         case CX88_BOARD_KWORLD_DVB_T:
+        case CX88_BOARD_KWORLD_DVB_T_CX22702:
                 ir_codes = ir_codes_dntv_live_dvb_t;
                 ir->gpio_addr = MO_GP1_IO;
                 ir->mask_keycode = 0x1f;
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
index dff3893f32fd..e5ee8bceb210 100644
--- a/drivers/media/video/em28xx/em28xx-core.c
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -139,6 +139,9 @@ int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
 {
         int ret, byte;
 
+        if (dev->state & DEV_DISCONNECTED)
+                return(-ENODEV);
+
         em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
 
         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
@@ -165,6 +168,9 @@ int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
         u8 val;
         int ret;
 
+        if (dev->state & DEV_DISCONNECTED)
+                return(-ENODEV);
+
         em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
 
         ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
@@ -195,7 +201,12 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
         int ret;
 
         /*usb_control_msg seems to expect a kmalloced buffer */
-        unsigned char *bufs = kmalloc(len, GFP_KERNEL);
+        unsigned char *bufs;
+
+        if (dev->state & DEV_DISCONNECTED)
+                return(-ENODEV);
+
+        bufs = kmalloc(len, GFP_KERNEL);
 
         em28xx_regdbg("req=%02x reg=%02x:", req, reg);
 
@@ -212,7 +223,7 @@ int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
         ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
                               0x0000, reg, bufs, len, HZ);
-        mdelay(5);              /* FIXME: magic number */
+        msleep(5);              /* FIXME: magic number */
         kfree(bufs);
         return ret;
 }
@@ -253,7 +264,7 @@ int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 * val)
         if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0)
                 return ret;
         else if (((u8) ret) & 0x01) {
-                em28xx_warn ("AC97 command still being exectuted: not handled properly!\n");
+                em28xx_warn ("AC97 command still being executed: not handled properly!\n");
         }
         return 0;
 }
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
index 0591a705b7a1..6ca8631bc36d 100644
--- a/drivers/media/video/em28xx/em28xx-i2c.c
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -78,7 +78,7 @@ static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
                 ret = dev->em28xx_read_reg(dev, 0x05);
                 if (ret == 0x80 + len - 1)
                         return len;
-                mdelay(5);
+                msleep(5);
         }
         em28xx_warn("i2c write timed out\n");
         return -EIO;
@@ -138,7 +138,7 @@ static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
                         return -ENODEV;
                 else if (msg == 0x84)
                         return 0;
-                mdelay(5);
+                msleep(5);
         }
         return -ENODEV;
 }
@@ -278,9 +278,9 @@ static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
                                                            msgs[i].buf,
                                                            msgs[i].len,
                                                            i == num - 1);
-                        if (rc < 0)
-                                goto err;
                 }
+                if (rc < 0)
+                        goto err;
                 if (i2c_debug>=2)
                         printk("\n");
         }
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index eea304f75176..94a14a2bb6d6 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -6,6 +6,9 @@
                       Mauro Carvalho Chehab <mchehab@brturbo.com.br>
                       Sascha Sommer <saschasommer@freenet.de>
 
+        Some parts based on SN9C10x PC Camera Controllers GPL driver made
+                by Luca Risolia <luca.risolia@studio.unibo.it>
+
    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
diff --git a/drivers/media/video/saa7134/saa7134-cards.c b/drivers/media/video/saa7134/saa7134-cards.c
index c64718aec9cb..5a35d3b6550d 100644
--- a/drivers/media/video/saa7134/saa7134-cards.c
+++ b/drivers/media/video/saa7134/saa7134-cards.c
@@ -136,7 +136,7 @@ struct saa7134_board saa7134_boards[] = {
         },
         [SAA7134_BOARD_FLYVIDEO2000] = {
                 /* "TC Wan" <tcwan@cs.usm.my> */
-                .name           = "LifeView FlyVIDEO2000",
+                .name           = "LifeView/Typhoon FlyVIDEO2000",
                 .audio_clock    = 0x00200000,
                 .tuner_type     = TUNER_LG_PAL_NEW_TAPC,
                 .radio_type     = UNSET,
@@ -1884,44 +1884,38 @@ struct saa7134_board saa7134_boards[] = {
                         .gpio = 0x000,
                 },
         },
-        [SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS] = {
-                .name           = "Typhoon DVB-T Duo Digital/Analog Cardbus",
+        [SAA7134_BOARD_FLYDVBT_DUO_CARDBUS] = {
+                .name           = "LifeView/Typhoon FlyDVB-T Duo Cardbus",
                 .audio_clock    = 0x00200000,
                 .tuner_type     = TUNER_PHILIPS_TDA8290,
                 .radio_type     = UNSET,
                 .tuner_addr     = ADDR_UNSET,
                 .radio_addr     = ADDR_UNSET,
                 .mpeg           = SAA7134_MPEG_DVB,
-                /* .gpiomask       = 0xe000, */
+                .gpiomask       = 0x00200000,
                 .inputs         = {{
                         .name = name_tv,
                         .vmux = 1,
                         .amux = TV,
-                /*      .gpio = 0x0000,      */
+                        .gpio = 0x200000,       /* GPIO21=High for TV input */
                         .tv   = 1,
                 },{
+                        .name = name_svideo,    /* S-Video signal on S-Video input */
+                        .vmux = 8,
+                        .amux = LINE2,
+                },{
                         .name = name_comp1,     /* Composite signal on S-Video input */
                         .vmux = 0,
                         .amux = LINE2,
-                /*      .gpio = 0x4000,      */
                 },{
                         .name = name_comp2,     /* Composite input */
                         .vmux = 3,
                         .amux = LINE2,
-                /*      .gpio = 0x4000,      */
-                },{
-                        .name = name_svideo,    /* S-Video signal on S-Video input */
-                        .vmux = 8,
-                        .amux = LINE2,
-                /*      .gpio = 0x4000,      */
                 }},
                 .radio = {
                         .name = name_radio,
-                        .amux = LINE2,
-                },
-                .mute = {
-                        .name = name_mute,
-                        .amux = LINE1,
+                        .amux = TV,
+                        .gpio = 0x000000,       /* GPIO21=Low for FM radio antenna */
                 },
         },
         [SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII] = {
@@ -2701,6 +2695,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .driver_data  = SAA7134_BOARD_FLYVIDEO2000,
         },{
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
+                .device       = PCI_DEVICE_ID_PHILIPS_SAA7130,
+                .subvendor    = 0x4e42,         /* Typhoon */
+                .subdevice    = 0x0138,         /* LifeView FlyTV Prime30 OEM */
+                .driver_data  = SAA7134_BOARD_FLYVIDEO2000,
+        },{
+                .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
                 .subvendor    = 0x5168,
                 .subdevice    = 0x0212, /* minipci, LR212 */
@@ -2935,7 +2935,7 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
                 .subvendor    = 0x5168,
                 .subdevice    = 0x0502,                /* Cardbus version */
-                .driver_data  = SAA7134_BOARD_FLYDVBTDUO,
+                .driver_data  = SAA7134_BOARD_FLYDVBT_DUO_CARDBUS,
         },{
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
@@ -2980,12 +2980,12 @@ struct pci_device_id saa7134_pci_tbl[] = {
                 .subdevice    = 0x1370,        /* cardbus version */
                 .driver_data  = SAA7134_BOARD_ADS_INSTANT_TV,
 
-        },{     /* Typhoon DVB-T Duo Digital/Analog Cardbus */
+        },{
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
-                .subvendor    = 0x4e42,
-                .subdevice    = 0x0502,
-                .driver_data  = SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS,
+                .subvendor    = 0x4e42,         /* Typhoon */
+                .subdevice    = 0x0502,         /* LifeView LR502 OEM */
+                .driver_data  = SAA7134_BOARD_FLYDVBT_DUO_CARDBUS,
         },{
                 .vendor       = PCI_VENDOR_ID_PHILIPS,
                 .device       = PCI_DEVICE_ID_PHILIPS_SAA7133,
@@ -3206,8 +3206,7 @@ int saa7134_board_init1(struct saa7134_dev *dev)
                 saa_andorl(SAA7134_GPIO_GPMODE0 >> 2,   0x00040000, 0x00040000);
                 saa_andorl(SAA7134_GPIO_GPSTATUS0 >> 2, 0x00040000, 0x00000004);
                 break;
-        case SAA7134_BOARD_FLYDVBTDUO:
-        case SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS:
+        case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS:
                 /* turn the fan on */
                 saa_writeb(SAA7134_GPIO_GPMODE3, 0x08);
                 saa_writeb(SAA7134_GPIO_GPSTATUS3, 0x06);
diff --git a/drivers/media/video/saa7134/saa7134-dvb.c b/drivers/media/video/saa7134/saa7134-dvb.c
index 399f9952596c..1a536e865277 100644
--- a/drivers/media/video/saa7134/saa7134-dvb.c
+++ b/drivers/media/video/saa7134/saa7134-dvb.c
@@ -861,7 +861,7 @@ static int dvb_init(struct saa7134_dev *dev)
                 dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                     &dev->i2c_adap);
                 break;
-        case SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS:
+        case SAA7134_BOARD_FLYDVBT_DUO_CARDBUS:
                 dev->dvb.frontend = tda10046_attach(&tda827x_lifeview_config,
                                                     &dev->i2c_adap);
                 break;
diff --git a/drivers/media/video/saa7134/saa7134.h b/drivers/media/video/saa7134/saa7134.h
index e70eae8d29bb..3261d8bebdd1 100644
--- a/drivers/media/video/saa7134/saa7134.h
+++ b/drivers/media/video/saa7134/saa7134.h
@@ -185,7 +185,7 @@ struct saa7134_format {
 #define SAA7134_BOARD_AVERMEDIA_GO_007_FM 57
 #define SAA7134_BOARD_ADS_INSTANT_TV 58
 #define SAA7134_BOARD_KWORLD_VSTREAM_XPERT 59
-#define SAA7134_BOARD_THYPHOON_DVBT_DUO_CARDBUS 60
+#define SAA7134_BOARD_FLYDVBT_DUO_CARDBUS 60
 #define SAA7134_BOARD_PHILIPS_TOUGH 61
 #define SAA7134_BOARD_VIDEOMATE_TV_GOLD_PLUSII 62
 #define SAA7134_BOARD_KWORLD_XPERT 63
diff --git a/drivers/media/video/stradis.c b/drivers/media/video/stradis.c
index 54fc33011ffb..9d769264a329 100644
--- a/drivers/media/video/stradis.c
+++ b/drivers/media/video/stradis.c
@@ -2012,7 +2012,6 @@ static int __devinit init_saa7146(struct pci_dev *pdev)
 {
         struct saa7146 *saa = pci_get_drvdata(pdev);
 
-        memset(saa, 0, sizeof(*saa));
         saa->user = 0;
         /* reset the saa7146 */
         saawrite(0xffff0000, SAA7146_MC1);
@@ -2062,16 +2061,16 @@ static int __devinit init_saa7146(struct pci_dev *pdev)
         }
         if (saa->audbuf == NULL && (saa->audbuf = vmalloc(65536)) == NULL) {
                 dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
-                goto errvid;
+                goto errfree;
         }
         if (saa->osdbuf == NULL && (saa->osdbuf = vmalloc(131072)) == NULL) {
                 dev_err(&pdev->dev, "%d: malloc failed\n", saa->nr);
-                goto erraud;
+                goto errfree;
         }
         /* allocate 81920 byte buffer for clipping */
         if ((saa->dmavid2 = kzalloc(VIDEO_CLIPMAP_SIZE, GFP_KERNEL)) == NULL) {
                 dev_err(&pdev->dev, "%d: clip kmalloc failed\n", saa->nr);
-                goto errosd;
+                goto errfree;
         }
         /* setup clipping registers */
         saawrite(virt_to_bus(saa->dmavid2), SAA7146_BASE_EVEN2);
@@ -2085,15 +2084,11 @@ static int __devinit init_saa7146(struct pci_dev *pdev)
         I2CBusScan(saa);
 
         return 0;
-errosd:
+errfree:
         vfree(saa->osdbuf);
-        saa->osdbuf = NULL;
-erraud:
         vfree(saa->audbuf);
-        saa->audbuf = NULL;
-errvid:
         vfree(saa->vidbuf);
-        saa->vidbuf = NULL;
+        saa->audbuf = saa->osdbuf = saa->vidbuf = NULL;
 err:
         return -ENOMEM;
 }
diff --git a/drivers/media/video/tda9887.c b/drivers/media/video/tda9887.c
index 5815649bdc78..0d54f6c1982b 100644
--- a/drivers/media/video/tda9887.c
+++ b/drivers/media/video/tda9887.c
@@ -231,7 +231,7 @@ static struct tvnorm tvnorms[] = {
                            cAudioIF_6_5   |
                            cVideoIF_38_90 ),
         },{
-                .std   = V4L2_STD_NTSC_M,
+                .std   = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
                 .name  = "NTSC-M",
                 .b     = ( cNegativeFmTV  |
                            cQSS           ),
@@ -619,6 +619,11 @@ static int tda9887_fixup_std(struct tda9887 *t)
                         tda9887_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
                         t->std = V4L2_STD_NTSC_M_JP;
                         break;
+                case 'k':
+                case 'K':
+                        tda9887_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
+                        t->std = V4L2_STD_NTSC_M_KR;
+                        break;
                 case '-':
                         /* default parameter, do nothing */
                         break;
@@ -876,7 +881,7 @@ static int tda9887_resume(struct device * dev)
 /* ----------------------------------------------------------------------- */
 
 static struct i2c_driver driver = {
-        .id             = -1, /* FIXME */
+        .id             = I2C_DRIVERID_TDA9887,
         .attach_adapter = tda9887_probe,
         .detach_client  = tda9887_detach,
         .command        = tda9887_command,
diff --git a/drivers/media/video/tuner-core.c b/drivers/media/video/tuner-core.c
index 2995b22acb43..e7ee619d62c5 100644
--- a/drivers/media/video/tuner-core.c
+++ b/drivers/media/video/tuner-core.c
@@ -216,6 +216,7 @@ static void set_type(struct i2c_client *c, unsigned int type,
                 buffer[3] = 0xa4;
                 i2c_master_send(c,buffer,4);
                 default_tuner_init(c);
+                break;
         default:
                 default_tuner_init(c);
                 break;
@@ -365,6 +366,11 @@ static int tuner_fixup_std(struct tuner *t)
                         tuner_dbg("insmod fixup: NTSC => NTSC_M_JP\n");
                         t->std = V4L2_STD_NTSC_M_JP;
                         break;
+                case 'k':
+                case 'K':
+                        tuner_dbg("insmod fixup: NTSC => NTSC_M_KR\n");
+                        t->std = V4L2_STD_NTSC_M_KR;
+                        break;
                 case '-':
                         /* default parameter, do nothing */
                         break;
@@ -448,7 +454,7 @@ static int tuner_attach(struct i2c_adapter *adap, int addr, int kind)
                         printk("%02x ",buffer[i]);
                 printk("\n");
         }
-        /* TEA5767 autodetection code - only for addr = 0xc0 */
+        /* autodetection code based on the i2c addr */
         if (!no_autodetect) {
                 switch (addr) {
                 case 0x42:
diff --git a/drivers/media/video/tvaudio.c b/drivers/media/video/tvaudio.c
index 6d03b9b05c6e..c8e5ad0e8185 100644
--- a/drivers/media/video/tvaudio.c
+++ b/drivers/media/video/tvaudio.c
@@ -390,6 +390,14 @@ static void tda9840_setmode(struct CHIPSTATE *chip, int mode)
                 chip_write(chip, TDA9840_SW, t);
 }
 
+static int tda9840_checkit(struct CHIPSTATE *chip)
+{
+        int rc;
+        rc = chip_read(chip);
+        /* lower 5 bits should be 0 */
+        return ((rc & 0x1f) == 0) ? 1 : 0;
+}
+
 /* ---------------------------------------------------------------------- */
 /* audio chip descriptions - defines+functions for tda985x                */
 
@@ -1264,6 +1272,7 @@ static struct CHIPDESC chiplist[] = {
                 .addr_hi    = I2C_TDA9840 >> 1,
                 .registers  = 5,
 
+                .checkit    = tda9840_checkit,
                 .getmode    = tda9840_getmode,
                 .setmode    = tda9840_setmode,
                 .checkmode  = generic_checkmode,
diff --git a/drivers/media/video/tvp5150.c b/drivers/media/video/tvp5150.c
index fad9ea0ae4f2..1864423b3046 100644
--- a/drivers/media/video/tvp5150.c
+++ b/drivers/media/video/tvp5150.c
@@ -746,24 +746,27 @@ static int tvp5150_set_std(struct i2c_client *c, v4l2_std_id std)
 
 static inline void tvp5150_reset(struct i2c_client *c)
 {
-        u8 type, ver_656, msb_id, lsb_id, msb_rom, lsb_rom;
+        u8 msb_id, lsb_id, msb_rom, lsb_rom;
         struct tvp5150 *decoder = i2c_get_clientdata(c);
 
-        type=tvp5150_read(c,TVP5150_AUTOSW_MSK);
         msb_id=tvp5150_read(c,TVP5150_MSB_DEV_ID);
         lsb_id=tvp5150_read(c,TVP5150_LSB_DEV_ID);
         msb_rom=tvp5150_read(c,TVP5150_ROM_MAJOR_VER);
         lsb_rom=tvp5150_read(c,TVP5150_ROM_MINOR_VER);
 
-        if (type==0xdc) {
-                ver_656=tvp5150_read(c,TVP5150_REV_SELECT);
-                tvp5150_info("tvp%02x%02xam1 detected 656 version is %d.\n",msb_id, lsb_id,ver_656);
-        } else if (type==0xfc) {
-                tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id);
+        if ((msb_rom==4)&&(lsb_rom==0)) { /* Is TVP5150AM1 */
+                tvp5150_info("tvp%02x%02xam1 detected.\n",msb_id, lsb_id);
+
+                /* ITU-T BT.656.4 timing */
+                tvp5150_write(c,TVP5150_REV_SELECT,0);
         } else {
-                tvp5150_info("unknown tvp%02x%02x chip detected(%d).\n",msb_id,lsb_id,type);
+                if ((msb_rom==3)||(lsb_rom==0x21)) { /* Is TVP5150A */
+                        tvp5150_info("tvp%02x%02xa detected.\n",msb_id, lsb_id);
+                } else {
+                        tvp5150_info("*** unknown tvp%02x%02x chip detected.\n",msb_id,lsb_id);
+                        tvp5150_info("*** Rom ver is %d.%d\n",msb_rom,lsb_rom);
+                }
         }
-        tvp5150_info("Rom ver is %d.%d\n",msb_rom,lsb_rom);
 
         /* Initializes TVP5150 to its default values */
         tvp5150_write_inittab(c, tvp5150_init_default);
@@ -893,6 +896,17 @@ static int tvp5150_command(struct i2c_client *c,
                 }
         case DECODER_GET_STATUS:
                 {
+                        int *iarg = arg;
+                        int status;
+                        int res=0;
+                        status = tvp5150_read(c, 0x88);
+                        if(status&0x08){
+                                res |= DECODER_STATUS_COLOR;
+                        }
+                        if(status&0x04 && status&0x02){
+                                res |= DECODER_STATUS_GOOD;
+                        }
+                        *iarg=res;
                         break;
                 }
 
diff --git a/drivers/message/i2o/core.h b/drivers/message/i2o/core.h
index 90628562851e..184974cc734d 100644
--- a/drivers/message/i2o/core.h
+++ b/drivers/message/i2o/core.h
@@ -60,4 +60,7 @@ extern void i2o_iop_remove(struct i2o_controller *);
 #define I2O_IN_PORT     0x40
 #define I2O_OUT_PORT    0x44
 
+/* Motorola/Freescale specific register offset */
+#define I2O_MOTOROLA_PORT_OFFSET        0x10400
+
 #define I2O_IRQ_OUTBOUND_POST   0x00000008
diff --git a/drivers/message/i2o/i2o_scsi.c b/drivers/message/i2o/i2o_scsi.c
index f9e5a23697a1..c08ddac3717d 100644
--- a/drivers/message/i2o/i2o_scsi.c
+++ b/drivers/message/i2o/i2o_scsi.c
@@ -732,7 +732,7 @@ static int i2o_scsi_abort(struct scsi_cmnd *SCpnt)
             cpu_to_le32(I2O_CMD_SCSI_ABORT << 24 | HOST_TID << 12 | tid);
         msg->body[0] = cpu_to_le32(i2o_cntxt_list_get_ptr(c, SCpnt));
 
-        if (i2o_msg_post_wait(c, msg, I2O_TIMEOUT_SCSI_SCB_ABORT))
+        if (!i2o_msg_post_wait(c, msg, I2O_TIMEOUT_SCSI_SCB_ABORT))
                 status = SUCCESS;
 
         return status;
diff --git a/drivers/message/i2o/pci.c b/drivers/message/i2o/pci.c
index d698d7709c31..4f1515cae5dc 100644
--- a/drivers/message/i2o/pci.c
+++ b/drivers/message/i2o/pci.c
@@ -88,6 +88,11 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
         struct device *dev = &pdev->dev;
         int i;
 
+        if (pci_request_regions(pdev, OSM_DESCRIPTION)) {
+                printk(KERN_ERR "%s: device already claimed\n", c->name);
+                return -ENODEV;
+        }
+
         for (i = 0; i < 6; i++) {
                 /* Skip I/O spaces */
                 if (!(pci_resource_flags(pdev, i) & IORESOURCE_IO)) {
@@ -163,6 +168,24 @@ static int __devinit i2o_pci_alloc(struct i2o_controller *c)
         c->in_port = c->base.virt + I2O_IN_PORT;
         c->out_port = c->base.virt + I2O_OUT_PORT;
 
+        /* Motorola/Freescale chip does not follow spec */
+        if (pdev->vendor == PCI_VENDOR_ID_MOTOROLA && pdev->device == 0x18c0) {
+                /* Check if CPU is enabled */
+                if (be32_to_cpu(readl(c->base.virt + 0x10000)) & 0x10000000) {
+                        printk(KERN_INFO "%s: MPC82XX needs CPU running to "
+                               "service I2O.\n", c->name);
+                        i2o_pci_free(c);
+                        return -ENODEV;
+                } else {
+                        c->irq_status += I2O_MOTOROLA_PORT_OFFSET;
+                        c->irq_mask += I2O_MOTOROLA_PORT_OFFSET;
+                        c->in_port += I2O_MOTOROLA_PORT_OFFSET;
+                        c->out_port += I2O_MOTOROLA_PORT_OFFSET;
+                        printk(KERN_INFO "%s: MPC82XX workarounds activated.\n",
+                               c->name);
+                }
+        }
+
         if (i2o_dma_alloc(dev, &c->status, 8, GFP_KERNEL)) {
                 i2o_pci_free(c);
                 return -ENOMEM;
@@ -298,7 +321,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
         struct i2o_controller *c;
         int rc;
         struct pci_dev *i960 = NULL;
-        int pci_dev_busy = 0;
+        int enabled = pdev->is_enabled;
 
         printk(KERN_INFO "i2o: Checking for PCI I2O controllers...\n");
 
@@ -308,16 +331,12 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
                 return -ENODEV;
         }
 
-        if ((rc = pci_enable_device(pdev))) {
-                printk(KERN_WARNING "i2o: couldn't enable device %s\n",
-                       pci_name(pdev));
-                return rc;
-        }
-
-        if (pci_request_regions(pdev, OSM_DESCRIPTION)) {
-                printk(KERN_ERR "i2o: device already claimed\n");
-                return -ENODEV;
-        }
+        if (!enabled)
+                if ((rc = pci_enable_device(pdev))) {
+                        printk(KERN_WARNING "i2o: couldn't enable device %s\n",
+                               pci_name(pdev));
+                        return rc;
+                }
 
         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)) {
                 printk(KERN_WARNING "i2o: no suitable DMA found for %s\n",
@@ -395,9 +414,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
 
         if ((rc = i2o_pci_alloc(c))) {
                 printk(KERN_ERR "%s: DMA / IO allocation for I2O controller "
-                       " failed\n", c->name);
-                if (rc == -ENODEV)
-                        pci_dev_busy = 1;
+                       "failed\n", c->name);
                 goto free_controller;
         }
 
@@ -425,7 +442,7 @@ static int __devinit i2o_pci_probe(struct pci_dev *pdev,
         i2o_iop_free(c);
 
       disable:
-        if (!pci_dev_busy)
+        if (!enabled)
                 pci_disable_device(pdev);
 
         return rc;
diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index c483a863b116..5d397b7a5497 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -65,7 +65,7 @@ config MMC_AU1X
         depends on SOC_AU1X00 && MMC
         help
           This selects the AMD Alchemy(R) Multimedia card interface.
-          iIf you have a Alchemy platform with a MMC slot, say Y or M here.
+          If you have a Alchemy platform with a MMC slot, say Y or M here.
 
           If unsure, say N.
 
diff --git a/drivers/mmc/au1xmmc.c b/drivers/mmc/au1xmmc.c
index aaf04638054e..227c39a7c1b4 100644
--- a/drivers/mmc/au1xmmc.c
+++ b/drivers/mmc/au1xmmc.c
@@ -194,7 +194,7 @@ static int au1xmmc_send_command(struct au1xmmc_host *host, int wait,
 
         u32 mmccmd = (cmd->opcode << SD_CMD_CI_SHIFT);
 
-        switch(cmd->flags) {
+        switch (mmc_rsp_type(cmd->flags)) {
         case MMC_RSP_R1:
                 mmccmd |= SD_CMD_RT_1;
                 break;
@@ -483,34 +483,35 @@ static void au1xmmc_cmd_complete(struct au1xmmc_host *host, u32 status)
         cmd = mrq->cmd;
         cmd->error = MMC_ERR_NONE;
 
-        if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_SHORT) {
-
-                /* Techincally, we should be getting all 48 bits of the response
-                 * (SD_RESP1 + SD_RESP2), but because our response omits the CRC,
-                 * our data ends up being shifted 8 bits to the right.  In this case,
-                 * that means that the OSR data starts at bit 31, so we can just
-                 * read RESP0 and return that
-                 */
-
-                cmd->resp[0] = au_readl(host->iobase + SD_RESP0);
-        }
-        else if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_LONG) {
-                u32 r[4];
-                int i;
-
-                r[0] = au_readl(host->iobase + SD_RESP3);
-                r[1] = au_readl(host->iobase + SD_RESP2);
-                r[2] = au_readl(host->iobase + SD_RESP1);
-                r[3] = au_readl(host->iobase + SD_RESP0);
-
-                /* The CRC is omitted from the response, so really we only got
-                 * 120 bytes, but the engine expects 128 bits, so we have to shift
-                 * things up
-                 */
-
-                for(i = 0; i < 4; i++) {
-                        cmd->resp[i] = (r[i] & 0x00FFFFFF) << 8;
-                        if (i != 3) cmd->resp[i] |= (r[i + 1] & 0xFF000000) >> 24;
+        if (cmd->flags & MMC_RSP_PRESENT) {
+                if (cmd->flags & MMC_RSP_136) {
+                        u32 r[4];
+                        int i;
+
+                        r[0] = au_readl(host->iobase + SD_RESP3);
+                        r[1] = au_readl(host->iobase + SD_RESP2);
+                        r[2] = au_readl(host->iobase + SD_RESP1);
+                        r[3] = au_readl(host->iobase + SD_RESP0);
+
+                        /* The CRC is omitted from the response, so really
+                         * we only got 120 bytes, but the engine expects
+                         * 128 bits, so we have to shift things up
+                         */
+
+                        for(i = 0; i < 4; i++) {
+                                cmd->resp[i] = (r[i] & 0x00FFFFFF) << 8;
+                                if (i != 3)
+                                        cmd->resp[i] |= (r[i + 1] & 0xFF000000) >> 24;
+                        }
+                } else {
+                        /* Techincally, we should be getting all 48 bits of
+                         * the response (SD_RESP1 + SD_RESP2), but because
+                         * our response omits the CRC, our data ends up
+                         * being shifted 8 bits to the right.  In this case,
+                         * that means that the OSR data starts at bit 31,
+                         * so we can just read RESP0 and return that
+                         */
+                        cmd->resp[0] = au_readl(host->iobase + SD_RESP0);
                 }
         }
 
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index bfca5c176e88..1888060c5e0c 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -211,7 +211,7 @@ int mmc_wait_for_app_cmd(struct mmc_host *host, unsigned int rca,
 
                 appcmd.opcode = MMC_APP_CMD;
                 appcmd.arg = rca << 16;
-                appcmd.flags = MMC_RSP_R1;
+                appcmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
                 appcmd.retries = 0;
                 memset(appcmd.resp, 0, sizeof(appcmd.resp));
                 appcmd.data = NULL;
@@ -331,7 +331,7 @@ static int mmc_select_card(struct mmc_host *host, struct mmc_card *card)
 
         cmd.opcode = MMC_SELECT_CARD;
         cmd.arg = card->rca << 16;
-        cmd.flags = MMC_RSP_R1;
+        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
         err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
         if (err != MMC_ERR_NONE)
@@ -358,7 +358,7 @@ static int mmc_select_card(struct mmc_host *host, struct mmc_card *card)
                         struct mmc_command cmd;
                         cmd.opcode = SD_APP_SET_BUS_WIDTH;
                         cmd.arg = SD_BUS_WIDTH_4;
-                        cmd.flags = MMC_RSP_R1;
+                        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
                         err = mmc_wait_for_app_cmd(host, card->rca, &cmd,
                                 CMD_RETRIES);
@@ -386,7 +386,7 @@ static void mmc_deselect_cards(struct mmc_host *host)
 
                 cmd.opcode = MMC_SELECT_CARD;
                 cmd.arg = 0;
-                cmd.flags = MMC_RSP_NONE;
+                cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
 
                 mmc_wait_for_cmd(host, &cmd, 0);
         }
@@ -677,7 +677,7 @@ static void mmc_idle_cards(struct mmc_host *host)
 
         cmd.opcode = MMC_GO_IDLE_STATE;
         cmd.arg = 0;
-        cmd.flags = MMC_RSP_NONE;
+        cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
 
         mmc_wait_for_cmd(host, &cmd, 0);
 
@@ -738,7 +738,7 @@ static int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 
         cmd.opcode = MMC_SEND_OP_COND;
         cmd.arg = ocr;
-        cmd.flags = MMC_RSP_R3;
+        cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
 
         for (i = 100; i; i--) {
                 err = mmc_wait_for_cmd(host, &cmd, 0);
@@ -766,7 +766,7 @@ static int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
 
         cmd.opcode = SD_APP_OP_COND;
         cmd.arg = ocr;
-        cmd.flags = MMC_RSP_R3;
+        cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
 
         for (i = 100; i; i--) {
                 err = mmc_wait_for_app_cmd(host, 0, &cmd, CMD_RETRIES);
@@ -805,7 +805,7 @@ static void mmc_discover_cards(struct mmc_host *host)
 
                 cmd.opcode = MMC_ALL_SEND_CID;
                 cmd.arg = 0;
-                cmd.flags = MMC_RSP_R2;
+                cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
 
                 err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
                 if (err == MMC_ERR_TIMEOUT) {
@@ -835,7 +835,7 @@ static void mmc_discover_cards(struct mmc_host *host)
 
                         cmd.opcode = SD_SEND_RELATIVE_ADDR;
                         cmd.arg = 0;
-                        cmd.flags = MMC_RSP_R6;
+                        cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
 
                         err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
                         if (err != MMC_ERR_NONE)
@@ -856,7 +856,7 @@ static void mmc_discover_cards(struct mmc_host *host)
                 } else {
                         cmd.opcode = MMC_SET_RELATIVE_ADDR;
                         cmd.arg = card->rca << 16;
-                        cmd.flags = MMC_RSP_R1;
+                        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
                         err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
                         if (err != MMC_ERR_NONE)
@@ -878,7 +878,7 @@ static void mmc_read_csds(struct mmc_host *host)
 
                 cmd.opcode = MMC_SEND_CSD;
                 cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R2;
+                cmd.flags = MMC_RSP_R2 | MMC_CMD_AC;
 
                 err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
                 if (err != MMC_ERR_NONE) {
@@ -920,7 +920,7 @@ static void mmc_read_scrs(struct mmc_host *host)
 
                 cmd.opcode = MMC_APP_CMD;
                 cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R1;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
                 err = mmc_wait_for_cmd(host, &cmd, 0);
                 if ((err != MMC_ERR_NONE) || !(cmd.resp[0] & R1_APP_CMD)) {
@@ -932,7 +932,7 @@ static void mmc_read_scrs(struct mmc_host *host)
 
                 cmd.opcode = SD_APP_SEND_SCR;
                 cmd.arg = 0;
-                cmd.flags = MMC_RSP_R1;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
 
                 memset(&data, 0, sizeof(struct mmc_data));
 
@@ -1003,7 +1003,7 @@ static void mmc_check_cards(struct mmc_host *host)
 
                 cmd.opcode = MMC_SEND_STATUS;
                 cmd.arg = card->rca << 16;
-                cmd.flags = MMC_RSP_R1;
+                cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
 
                 err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES);
                 if (err == MMC_ERR_NONE)
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index 5b014c370e80..8eb2a2ede64b 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -171,14 +171,14 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
                 brq.mrq.data = &brq.data;
 
                 brq.cmd.arg = req->sector << 9;
-                brq.cmd.flags = MMC_RSP_R1;
+                brq.cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
                 brq.data.timeout_ns = card->csd.tacc_ns * 10;
                 brq.data.timeout_clks = card->csd.tacc_clks * 10;
                 brq.data.blksz_bits = md->block_bits;
                 brq.data.blocks = req->nr_sectors >> (md->block_bits - 9);
                 brq.stop.opcode = MMC_STOP_TRANSMISSION;
                 brq.stop.arg = 0;
-                brq.stop.flags = MMC_RSP_R1B;
+                brq.stop.flags = MMC_RSP_R1B | MMC_CMD_AC;
 
                 if (rq_data_dir(req) == READ) {
                         brq.cmd.opcode = brq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK;
@@ -223,7 +223,7 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 
                         cmd.opcode = MMC_SEND_STATUS;
                         cmd.arg = card->rca << 16;
-                        cmd.flags = MMC_RSP_R1;
+                        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
                         err = mmc_wait_for_cmd(card->host, &cmd, 5);
                         if (err) {
                                 printk(KERN_ERR "%s: error %d requesting status\n",
@@ -430,7 +430,7 @@ mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card)
         mmc_card_claim_host(card);
         cmd.opcode = MMC_SET_BLOCKLEN;
         cmd.arg = 1 << md->block_bits;
-        cmd.flags = MMC_RSP_R1;
+        cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
         err = mmc_wait_for_cmd(card->host, &cmd, 5);
         mmc_card_release_host(card);
 
diff --git a/drivers/mmc/mmci.c b/drivers/mmc/mmci.c
index 634ef53e85a5..37ee7f8dc82f 100644
--- a/drivers/mmc/mmci.c
+++ b/drivers/mmc/mmci.c
@@ -124,15 +124,10 @@ mmci_start_command(struct mmci_host *host, struct mmc_command *cmd, u32 c)
         }
 
         c |= cmd->opcode | MCI_CPSM_ENABLE;
-        switch (cmd->flags & MMC_RSP_MASK) {
-        case MMC_RSP_NONE:
-        default:
-                break;
-        case MMC_RSP_LONG:
-                c |= MCI_CPSM_LONGRSP;
-        case MMC_RSP_SHORT:
+        if (cmd->flags & MMC_RSP_PRESENT) {
+                if (cmd->flags & MMC_RSP_136)
+                        c |= MCI_CPSM_LONGRSP;
                 c |= MCI_CPSM_RESPONSE;
-                break;
         }
         if (/*interrupt*/0)
                 c |= MCI_CPSM_INTERRUPT;
diff --git a/drivers/mmc/pxamci.c b/drivers/mmc/pxamci.c
index ee8f8a0420d1..285d7d068097 100644
--- a/drivers/mmc/pxamci.c
+++ b/drivers/mmc/pxamci.c
@@ -178,14 +178,15 @@ static void pxamci_start_cmd(struct pxamci_host *host, struct mmc_command *cmd,
         if (cmd->flags & MMC_RSP_BUSY)
                 cmdat |= CMDAT_BUSY;
 
-        switch (cmd->flags & (MMC_RSP_MASK | MMC_RSP_CRC)) {
-        case MMC_RSP_SHORT | MMC_RSP_CRC:
+#define RSP_TYPE(x)     ((x) & ~(MMC_RSP_BUSY|MMC_RSP_OPCODE))
+        switch (RSP_TYPE(mmc_resp_type(cmd))) {
+        case RSP_TYPE(MMC_RSP_R1): /* r1, r1b, r6 */
                 cmdat |= CMDAT_RESP_SHORT;
                 break;
-        case MMC_RSP_SHORT:
+        case RSP_TYPE(MMC_RSP_R3):
                 cmdat |= CMDAT_RESP_R3;
                 break;
-        case MMC_RSP_LONG | MMC_RSP_CRC:
+        case RSP_TYPE(MMC_RSP_R2):
                 cmdat |= CMDAT_RESP_R2;
                 break;
         default:
diff --git a/drivers/mmc/wbsd.c b/drivers/mmc/wbsd.c
index f25757625361..3be397d436fa 100644
--- a/drivers/mmc/wbsd.c
+++ b/drivers/mmc/wbsd.c
@@ -459,7 +459,7 @@ static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
         /*
          * Do we expect a reply?
          */
-        if ((cmd->flags & MMC_RSP_MASK) != MMC_RSP_NONE) {
+        if (cmd->flags & MMC_RSP_PRESENT) {
                 /*
                  * Read back status.
                  */
@@ -476,10 +476,10 @@ static void wbsd_send_command(struct wbsd_host *host, struct mmc_command *cmd)
                         cmd->error = MMC_ERR_BADCRC;
                 /* All ok */
                 else {
-                        if ((cmd->flags & MMC_RSP_MASK) == MMC_RSP_SHORT)
-                                wbsd_get_short_reply(host, cmd);
-                        else
+                        if (cmd->flags & MMC_RSP_136)
                                 wbsd_get_long_reply(host, cmd);
+                        else
+                                wbsd_get_short_reply(host, cmd);
                 }
         }
 
diff --git a/drivers/mtd/chips/Kconfig b/drivers/mtd/chips/Kconfig
index effa0d7a73ac..205bb7083335 100644
--- a/drivers/mtd/chips/Kconfig
+++ b/drivers/mtd/chips/Kconfig
@@ -301,7 +301,7 @@ config MTD_JEDEC
 
 config MTD_XIP
         bool "XIP aware MTD support"
-        depends on !SMP && (MTD_CFI_INTELEXT || MTD_CFI_AMDSTD) && EXPERIMENTAL && ARM
+        depends on !SMP && (MTD_CFI_INTELEXT || MTD_CFI_AMDSTD) && EXPERIMENTAL && ARCH_MTD_XIP
         default y if XIP_KERNEL
         help
           This allows MTD support to work with flash memory which is also
diff --git a/drivers/mtd/maps/dc21285.c b/drivers/mtd/maps/dc21285.c
index 701620b6baed..8b3784e2de89 100644
--- a/drivers/mtd/maps/dc21285.c
+++ b/drivers/mtd/maps/dc21285.c
@@ -110,8 +110,9 @@ static void dc21285_copy_to_32(struct map_info *map, unsigned long to, const voi
 {
         while (len > 0) {
                 map_word d;
-                d.x[0] = *((uint32_t*)from)++;
+                d.x[0] = *((uint32_t*)from);
                 dc21285_write32(map, d, to);
+                from += 4;
                 to += 4;
                 len -= 4;
         }
@@ -121,8 +122,9 @@ static void dc21285_copy_to_16(struct map_info *map, unsigned long to, const voi
 {
         while (len > 0) {
                 map_word d;
-                d.x[0] = *((uint16_t*)from)++;
+                d.x[0] = *((uint16_t*)from);
                 dc21285_write16(map, d, to);
+                from += 2;
                 to += 2;
                 len -= 2;
         }
@@ -131,8 +133,9 @@ static void dc21285_copy_to_16(struct map_info *map, unsigned long to, const voi
 static void dc21285_copy_to_8(struct map_info *map, unsigned long to, const void *from, ssize_t len)
 {
         map_word d;
-        d.x[0] = *((uint8_t*)from)++;
+        d.x[0] = *((uint8_t*)from);
         dc21285_write8(map, d, to);
+        from++;
         to++;
         len--;
 }
diff --git a/drivers/net/3c59x.c b/drivers/net/3c59x.c
index 7488ee7f7caf..7f47124f118d 100644
--- a/drivers/net/3c59x.c
+++ b/drivers/net/3c59x.c
@@ -753,9 +753,11 @@ enum tx_desc_status {
 enum ChipCaps { CapBusMaster=0x20, CapPwrMgmt=0x2000 };
 
 struct vortex_extra_stats {
-        unsigned long tx_deferred;
-        unsigned long tx_multiple_collisions;
-        unsigned long rx_bad_ssd;
+        unsigned long tx_deferred;
+        unsigned long tx_max_collisions;
+        unsigned long tx_multiple_collisions;
+        unsigned long tx_single_collisions;
+        unsigned long rx_bad_ssd;
 };
 
 struct vortex_private {
@@ -863,12 +865,14 @@ static struct {
         const char str[ETH_GSTRING_LEN];
 } ethtool_stats_keys[] = {
         { "tx_deferred" },
+        { "tx_max_collisions" },
         { "tx_multiple_collisions" },
+        { "tx_single_collisions" },
         { "rx_bad_ssd" },
 };
 
 /* number of ETHTOOL_GSTATS u64's */
-#define VORTEX_NUM_STATS     3
+#define VORTEX_NUM_STATS    5
 
 static int vortex_probe1(struct device *gendev, void __iomem *ioaddr, int irq,
                                    int chip_idx, int card_idx);
@@ -2108,9 +2112,12 @@ vortex_error(struct net_device *dev, int status)
                 iowrite8(0, ioaddr + TxStatus);
                 if (tx_status & 0x30) {                 /* txJabber or txUnderrun */
                         do_tx_reset = 1;
-                } else if ((tx_status & 0x08) && (vp->drv_flags & MAX_COLLISION_RESET)) {       /* maxCollisions */
-                        do_tx_reset = 1;
-                        reset_mask = 0x0108;            /* Reset interface logic, but not download logic */
+                } else if (tx_status & 0x08) {  /* maxCollisions */
+                        vp->xstats.tx_max_collisions++;
+                        if (vp->drv_flags & MAX_COLLISION_RESET) {
+                                do_tx_reset = 1;
+                                reset_mask = 0x0108;            /* Reset interface logic, but not download logic */
+                        }
                 } else {                                                /* Merely re-enable the transmitter. */
                         iowrite16(TxEnable, ioaddr + EL3_CMD);
                 }
@@ -2926,7 +2933,6 @@ static void update_stats(void __iomem *ioaddr, struct net_device *dev)
         EL3WINDOW(6);
         vp->stats.tx_carrier_errors             += ioread8(ioaddr + 0);
         vp->stats.tx_heartbeat_errors           += ioread8(ioaddr + 1);
-        vp->stats.collisions                    += ioread8(ioaddr + 3);
         vp->stats.tx_window_errors              += ioread8(ioaddr + 4);
         vp->stats.rx_fifo_errors                += ioread8(ioaddr + 5);
         vp->stats.tx_packets                    += ioread8(ioaddr + 6);
@@ -2939,10 +2945,15 @@ static void update_stats(void __iomem *ioaddr, struct net_device *dev)
         vp->stats.tx_bytes                      += ioread16(ioaddr + 12);
         /* Extra stats for get_ethtool_stats() */
         vp->xstats.tx_multiple_collisions       += ioread8(ioaddr + 2);
+        vp->xstats.tx_single_collisions         += ioread8(ioaddr + 3);
         vp->xstats.tx_deferred                  += ioread8(ioaddr + 8);
         EL3WINDOW(4);
         vp->xstats.rx_bad_ssd                   += ioread8(ioaddr + 12);
 
+        vp->stats.collisions = vp->xstats.tx_multiple_collisions
+                + vp->xstats.tx_single_collisions
+                + vp->xstats.tx_max_collisions;
+
         {
                 u8 up = ioread8(ioaddr + 13);
                 vp->stats.rx_bytes += (up & 0x0f) << 16;
@@ -3036,8 +3047,10 @@ static void vortex_get_ethtool_stats(struct net_device *dev,
         spin_unlock_irqrestore(&vp->lock, flags);
 
         data[0] = vp->xstats.tx_deferred;
-        data[1] = vp->xstats.tx_multiple_collisions;
-        data[2] = vp->xstats.rx_bad_ssd;
+        data[1] = vp->xstats.tx_max_collisions;
+        data[2] = vp->xstats.tx_multiple_collisions;
+        data[3] = vp->xstats.tx_single_collisions;
+        data[4] = vp->xstats.rx_bad_ssd;
 }
 
 
diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
index adfba44dac5a..2beac55b57d6 100644
--- a/drivers/net/8139too.c
+++ b/drivers/net/8139too.c
@@ -586,6 +586,7 @@ struct rtl8139_private {
         dma_addr_t tx_bufs_dma;
         signed char phys[4];            /* MII device addresses. */
         char twistie, twist_row, twist_col;     /* Twister tune state. */
+        unsigned int watchdog_fired : 1;
         unsigned int default_port : 4;  /* Last dev->if_port value. */
         unsigned int have_thread : 1;
         spinlock_t lock;
@@ -638,6 +639,7 @@ static void rtl8139_set_rx_mode (struct net_device *dev);
 static void __set_rx_mode (struct net_device *dev);
 static void rtl8139_hw_start (struct net_device *dev);
 static void rtl8139_thread (void *_data);
+static void rtl8139_tx_timeout_task(void *_data);
 static struct ethtool_ops rtl8139_ethtool_ops;
 
 /* write MMIO register, with flush */
@@ -1598,13 +1600,14 @@ static void rtl8139_thread (void *_data)
 {
         struct net_device *dev = _data;
         struct rtl8139_private *tp = netdev_priv(dev);
-        unsigned long thr_delay;
+        unsigned long thr_delay = next_tick;
 
-        if (rtnl_shlock_nowait() == 0) {
+        if (tp->watchdog_fired) {
+                tp->watchdog_fired = 0;
+                rtl8139_tx_timeout_task(_data);
+        } else if (rtnl_shlock_nowait() == 0) {
                 rtl8139_thread_iter (dev, tp, tp->mmio_addr);
                 rtnl_unlock ();
-
-                thr_delay = next_tick;
         } else {
                 /* unlikely race.  mitigate with fast poll. */
                 thr_delay = HZ / 2;
@@ -1631,7 +1634,8 @@ static void rtl8139_stop_thread(struct rtl8139_private *tp)
         if (tp->have_thread) {
                 cancel_rearming_delayed_work(&tp->thread);
                 tp->have_thread = 0;
-        }
+        } else
+                flush_scheduled_work();
 }
 
 static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
@@ -1642,14 +1646,13 @@ static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
         /* XXX account for unsent Tx packets in tp->stats.tx_dropped */
 }
 
-
-static void rtl8139_tx_timeout (struct net_device *dev)
+static void rtl8139_tx_timeout_task (void *_data)
 {
+        struct net_device *dev = _data;
         struct rtl8139_private *tp = netdev_priv(dev);
         void __iomem *ioaddr = tp->mmio_addr;
         int i;
         u8 tmp8;
-        unsigned long flags;
 
         printk (KERN_DEBUG "%s: Transmit timeout, status %2.2x %4.4x %4.4x "
                 "media %2.2x.\n", dev->name, RTL_R8 (ChipCmd),
@@ -1670,23 +1673,34 @@ static void rtl8139_tx_timeout (struct net_device *dev)
         if (tmp8 & CmdTxEnb)
                 RTL_W8 (ChipCmd, CmdRxEnb);
 
-        spin_lock(&tp->rx_lock);
+        spin_lock_bh(&tp->rx_lock);
         /* Disable interrupts by clearing the interrupt mask. */
         RTL_W16 (IntrMask, 0x0000);
 
         /* Stop a shared interrupt from scavenging while we are. */
-        spin_lock_irqsave (&tp->lock, flags);
+        spin_lock_irq(&tp->lock);
         rtl8139_tx_clear (tp);
-        spin_unlock_irqrestore (&tp->lock, flags);
+        spin_unlock_irq(&tp->lock);
 
         /* ...and finally, reset everything */
         if (netif_running(dev)) {
                 rtl8139_hw_start (dev);
                 netif_wake_queue (dev);
         }
-        spin_unlock(&tp->rx_lock);
+        spin_unlock_bh(&tp->rx_lock);
 }
 
+static void rtl8139_tx_timeout (struct net_device *dev)
+{
+        struct rtl8139_private *tp = netdev_priv(dev);
+
+        if (!tp->have_thread) {
+                INIT_WORK(&tp->thread, rtl8139_tx_timeout_task, dev);
+                schedule_delayed_work(&tp->thread, next_tick);
+        } else
+                tp->watchdog_fired = 1;
+
+}
 
 static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
 {
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 6a6a08441804..47c72a63dfe1 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -4,9 +4,9 @@
 #
 
 menu "Network device support"
+        depends on NET
 
 config NETDEVICES
-        depends on NET
         default y if UML
         bool "Network device support"
         ---help---
@@ -24,9 +24,6 @@ config NETDEVICES
 
           If unsure, say Y.
 
-# All the following symbols are dependent on NETDEVICES - do not repeat
-# that for each of the symbols.
-if NETDEVICES
 
 config IFB
         tristate "Intermediate Functional Block support"
@@ -2718,8 +2715,6 @@ config NETCONSOLE
         If you want to log kernel messages over the network, enable this.
         See <file:Documentation/networking/netconsole.txt> for details.
 
-endif #NETDEVICES
-
 config NETPOLL
         def_bool NETCONSOLE
 
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 4ff006c37626..e0f51afec778 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1145,7 +1145,8 @@ int bond_sethwaddr(struct net_device *bond_dev, struct net_device *slave_dev)
 }
 
 #define BOND_INTERSECT_FEATURES \
-        (NETIF_F_SG|NETIF_F_IP_CSUM|NETIF_F_NO_CSUM|NETIF_F_HW_CSUM)
+        (NETIF_F_SG|NETIF_F_IP_CSUM|NETIF_F_NO_CSUM|NETIF_F_HW_CSUM|\
+        NETIF_F_TSO|NETIF_F_UFO)
 
 /* 
  * Compute the common dev->feature set available to all slaves.  Some
@@ -1168,6 +1169,16 @@ static int bond_compute_features(struct bonding *bond)
                           NETIF_F_HW_CSUM)))
                 features &= ~NETIF_F_SG;
 
+        /* 
+         * features will include NETIF_F_TSO (NETIF_F_UFO) iff all 
+         * slave devices support NETIF_F_TSO (NETIF_F_UFO), which 
+         * implies that all slaves also support scatter-gather 
+         * (NETIF_F_SG), which implies that features also includes 
+         * NETIF_F_SG. So no need to check whether we have an  
+         * illegal combination of NETIF_F_{TSO,UFO} and 
+         * !NETIF_F_SG 
+         */
+
         features |= (bond_dev->features & ~BOND_INTERSECT_FEATURES);
         bond_dev->features = features;
 
@@ -4080,6 +4091,8 @@ static void bond_ethtool_get_drvinfo(struct net_device *bond_dev,
 
 static struct ethtool_ops bond_ethtool_ops = {
         .get_tx_csum            = ethtool_op_get_tx_csum,
+        .get_tso                = ethtool_op_get_tso,
+        .get_ufo                = ethtool_op_get_ufo,
         .get_sg                 = ethtool_op_get_sg,
         .get_drvinfo            = bond_ethtool_get_drvinfo,
 };
diff --git a/drivers/net/bonding/bond_sysfs.c b/drivers/net/bonding/bond_sysfs.c
index 32d13da43a0b..041bcc583557 100644
--- a/drivers/net/bonding/bond_sysfs.c
+++ b/drivers/net/bonding/bond_sysfs.c
@@ -260,7 +260,7 @@ static ssize_t bonding_store_slaves(struct class_device *cd, const char *buffer,
         char *ifname;
         int i, res, found, ret = count;
         struct slave *slave;
-        struct net_device *dev = 0;
+        struct net_device *dev = NULL;
         struct bonding *bond = to_bond(cd);
 
         /* Quick sanity check -- is the bond interface up? */
@@ -995,7 +995,7 @@ static ssize_t bonding_store_primary(struct class_device *cd, const char *buf, s
                         printk(KERN_INFO DRV_NAME
                                ": %s: Setting primary slave to None.\n",
                                bond->dev->name);
-                        bond->primary_slave = 0;
+                        bond->primary_slave = NULL;
                                 bond_select_active_slave(bond);
                 } else {
                         printk(KERN_INFO DRV_NAME
@@ -1123,7 +1123,7 @@ static ssize_t bonding_store_active_slave(struct class_device *cd, const char *b
                         printk(KERN_INFO DRV_NAME
                                ": %s: Setting active slave to None.\n",
                                bond->dev->name);
-                        bond->primary_slave = 0;
+                        bond->primary_slave = NULL;
                                 bond_select_active_slave(bond);
                 } else {
                         printk(KERN_INFO DRV_NAME
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index bf1fd2b98bf8..24253c807e55 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -2752,8 +2752,6 @@ static int e100_resume(struct pci_dev *pdev)
         retval = pci_enable_wake(pdev, 0, 0);
         if (retval)
                 DPRINTK(PROBE,ERR, "Error clearing wake events\n");
-        if(e100_hw_init(nic))
-                DPRINTK(HW, ERR, "e100_hw_init failed\n");
 
         netif_device_attach(netdev);
         if(netif_running(netdev))
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index 0c18dbd67d3b..0e8e3fcde9ff 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -199,8 +199,7 @@ static int gfar_probe(struct platform_device *pdev)
 
         /* get a pointer to the register memory */
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        priv->regs = (struct gfar *)
-                ioremap(r->start, sizeof (struct gfar));
+        priv->regs = ioremap(r->start, sizeof (struct gfar));
 
         if (NULL == priv->regs) {
                 err = -ENOMEM;
@@ -369,7 +368,7 @@ static int gfar_probe(struct platform_device *pdev)
         return 0;
 
 register_fail:
-        iounmap((void *) priv->regs);
+        iounmap(priv->regs);
 regs_fail:
         free_netdev(dev);
         return err;
@@ -382,7 +381,7 @@ static int gfar_remove(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, NULL);
 
-        iounmap((void *) priv->regs);
+        iounmap(priv->regs);
         free_netdev(dev);
 
         return 0;
@@ -454,8 +453,7 @@ static void init_registers(struct net_device *dev)
 
         /* Zero out the rmon mib registers if it has them */
         if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
-                memset((void *) &(priv->regs->rmon), 0,
-                       sizeof (struct rmon_mib));
+                memset_io(&(priv->regs->rmon), 0, sizeof (struct rmon_mib));
 
                 /* Mask off the CAM interrupts */
                 gfar_write(&priv->regs->rmon.cam1, 0xffffffff);
@@ -477,7 +475,7 @@ static void init_registers(struct net_device *dev)
 void gfar_halt(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
         u32 tempval;
 
         /* Mask all interrupts */
@@ -507,7 +505,7 @@ void gfar_halt(struct net_device *dev)
 void stop_gfar(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
         unsigned long flags;
 
         phy_stop(priv->phydev);
@@ -590,7 +588,7 @@ static void free_skb_resources(struct gfar_private *priv)
 void gfar_start(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
         u32 tempval;
 
         /* Enable Rx and Tx in MACCFG1 */
@@ -624,7 +622,7 @@ int startup_gfar(struct net_device *dev)
         unsigned long vaddr;
         int i;
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
         int err = 0;
         u32 rctrl = 0;
         u32 attrs = 0;
@@ -1622,7 +1620,7 @@ static irqreturn_t gfar_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 static void adjust_link(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
         unsigned long flags;
         struct phy_device *phydev = priv->phydev;
         int new_state = 0;
@@ -1703,7 +1701,7 @@ static void gfar_set_multi(struct net_device *dev)
 {
         struct dev_mc_list *mc_ptr;
         struct gfar_private *priv = netdev_priv(dev);
-        struct gfar *regs = priv->regs;
+        struct gfar __iomem *regs = priv->regs;
         u32 tempval;
 
         if(dev->flags & IFF_PROMISC) {
@@ -1842,7 +1840,7 @@ static void gfar_set_mac_for_addr(struct net_device *dev, int num, u8 *addr)
         int idx;
         char tmpbuf[MAC_ADDR_LEN];
         u32 tempval;
-        u32 *macptr = &priv->regs->macstnaddr1;
+        u32 __iomem *macptr = &priv->regs->macstnaddr1;
 
         macptr += num*2;
 
diff --git a/drivers/net/gianfar.h b/drivers/net/gianfar.h
index cb9d66ac3ab9..d37d5401be6e 100644
--- a/drivers/net/gianfar.h
+++ b/drivers/net/gianfar.h
@@ -682,8 +682,8 @@ struct gfar_private {
         struct rxbd8 *cur_rx;           /* Next free rx ring entry */
         struct txbd8 *cur_tx;           /* Next free ring entry */
         struct txbd8 *dirty_tx;         /* The Ring entry to be freed. */
-        struct gfar *regs;      /* Pointer to the GFAR memory mapped Registers */
-        u32 *hash_regs[16];
+        struct gfar __iomem *regs;      /* Pointer to the GFAR memory mapped Registers */
+        u32 __iomem *hash_regs[16];
         int hash_width;
         struct net_device_stats stats; /* linux network statistics */
         struct gfar_extra_stats extra_stats;
@@ -718,14 +718,14 @@ struct gfar_private {
         uint32_t msg_enable;
 };
 
-static inline u32 gfar_read(volatile unsigned *addr)
+static inline u32 gfar_read(volatile unsigned __iomem *addr)
 {
         u32 val;
         val = in_be32(addr);
         return val;
 }
 
-static inline void gfar_write(volatile unsigned *addr, u32 val)
+static inline void gfar_write(volatile unsigned __iomem *addr, u32 val)
 {
         out_be32(addr, val);
 }
diff --git a/drivers/net/gianfar_ethtool.c b/drivers/net/gianfar_ethtool.c
index 765e810620fe..5de7b2e259dc 100644
--- a/drivers/net/gianfar_ethtool.c
+++ b/drivers/net/gianfar_ethtool.c
@@ -144,11 +144,11 @@ static void gfar_fill_stats(struct net_device *dev, struct ethtool_stats *dummy,
         u64 *extra = (u64 *) & priv->extra_stats;
 
         if (priv->einfo->device_flags & FSL_GIANFAR_DEV_HAS_RMON) {
-                u32 *rmon = (u32 *) & priv->regs->rmon;
+                u32 __iomem *rmon = (u32 __iomem *) & priv->regs->rmon;
                 struct gfar_stats *stats = (struct gfar_stats *) buf;
 
                 for (i = 0; i < GFAR_RMON_LEN; i++)
-                        stats->rmon[i] = (u64) (rmon[i]);
+                        stats->rmon[i] = (u64) gfar_read(&rmon[i]);
 
                 for (i = 0; i < GFAR_EXTRA_STATS_LEN; i++)
                         stats->extra[i] = extra[i];
@@ -221,11 +221,11 @@ static void gfar_get_regs(struct net_device *dev, struct ethtool_regs *regs, voi
 {
         int i;
         struct gfar_private *priv = netdev_priv(dev);
-        u32 *theregs = (u32 *) priv->regs;
+        u32 __iomem *theregs = (u32 __iomem *) priv->regs;
         u32 *buf = (u32 *) regbuf;
 
         for (i = 0; i < sizeof (struct gfar) / sizeof (u32); i++)
-                buf[i] = theregs[i];
+                buf[i] = gfar_read(&theregs[i]);
 }
 
 /* Convert microseconds to ethernet clock ticks, which changes
diff --git a/drivers/net/gianfar_mii.c b/drivers/net/gianfar_mii.c
index 74e52fcbf806..c6b725529af5 100644
--- a/drivers/net/gianfar_mii.c
+++ b/drivers/net/gianfar_mii.c
@@ -50,7 +50,7 @@
  * All PHY configuration is done through the TSEC1 MIIM regs */
 int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
 {
-        struct gfar_mii *regs = bus->priv;
+        struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
 
         /* Set the PHY address and the register address we want to write */
         gfar_write(&regs->miimadd, (mii_id << 8) | regnum);
@@ -70,7 +70,7 @@ int gfar_mdio_write(struct mii_bus *bus, int mii_id, int regnum, u16 value)
  * configuration has to be done through the TSEC1 MIIM regs */
 int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 {
-        struct gfar_mii *regs = bus->priv;
+        struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
         u16 value;
 
         /* Set the PHY address and the register address we want to read */
@@ -94,7 +94,7 @@ int gfar_mdio_read(struct mii_bus *bus, int mii_id, int regnum)
 /* Reset the MIIM registers, and wait for the bus to free */
 int gfar_mdio_reset(struct mii_bus *bus)
 {
-        struct gfar_mii *regs = bus->priv;
+        struct gfar_mii __iomem *regs = (void __iomem *)bus->priv;
         unsigned int timeout = PHY_INIT_TIMEOUT;
 
         spin_lock_bh(&bus->mdio_lock);
@@ -126,7 +126,7 @@ int gfar_mdio_probe(struct device *dev)
 {
         struct platform_device *pdev = to_platform_device(dev);
         struct gianfar_mdio_data *pdata;
-        struct gfar_mii *regs;
+        struct gfar_mii __iomem *regs;
         struct mii_bus *new_bus;
         struct resource *r;
         int err = 0;
@@ -155,15 +155,14 @@ int gfar_mdio_probe(struct device *dev)
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
         /* Set the PHY base address */
-        regs = (struct gfar_mii *) ioremap(r->start,
-                        sizeof (struct gfar_mii));
+        regs = ioremap(r->start, sizeof (struct gfar_mii));
 
         if (NULL == regs) {
                 err = -ENOMEM;
                 goto reg_map_fail;
         }
 
-        new_bus->priv = regs;
+        new_bus->priv = (void __force *)regs;
 
         new_bus->irq = pdata->irq;
 
@@ -181,7 +180,7 @@ int gfar_mdio_probe(struct device *dev)
         return 0;
 
 bus_register_fail:
-        iounmap((void *) regs);
+        iounmap(regs);
 reg_map_fail:
         kfree(new_bus);
 
@@ -197,7 +196,7 @@ int gfar_mdio_remove(struct device *dev)
 
         dev_set_drvdata(dev, NULL);
 
-        iounmap((void *) (&bus->priv));
+        iounmap((void __iomem *)bus->priv);
         bus->priv = NULL;
         kfree(bus);
 
diff --git a/drivers/net/hamradio/baycom_par.c b/drivers/net/hamradio/baycom_par.c
index 3b1bef1ee215..77411a00d1ee 100644
--- a/drivers/net/hamradio/baycom_par.c
+++ b/drivers/net/hamradio/baycom_par.c
@@ -86,7 +86,6 @@
 #include <linux/bitops.h>
 #include <linux/jiffies.h>
 
-#include <asm/bug.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
 
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 7ef4b0434a3f..c0998ef938e0 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -32,6 +32,8 @@
  */
 #include <linux/init.h>
 #include <linux/dma-mapping.h>
+#include <linux/in.h>
+#include <linux/ip.h>
 #include <linux/tcp.h>
 #include <linux/udp.h>
 #include <linux/etherdevice.h>
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 1c6d328165bb..0245e40b51a1 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -1610,6 +1610,8 @@ ppp_receive_nonmp_frame(struct ppp *ppp, struct sk_buff *skb)
                 }
                 else if (!pskb_may_pull(skb, skb->len))
                         goto err;
+                else
+                        skb->ip_summed = CHECKSUM_NONE;
 
                 len = slhc_uncompress(ppp->vj, skb->data + 2, skb->len - 2);
                 if (len <= 0) {
@@ -1690,6 +1692,7 @@ ppp_receive_nonmp_frame(struct ppp *ppp, struct sk_buff *skb)
                         kfree_skb(skb);
                 } else {
                         skb_pull(skb, 2);       /* chop off protocol */
+                        skb_postpull_rcsum(skb, skb->data - 2, 2);
                         skb->dev = ppp->dev;
                         skb->protocol = htons(npindex_to_ethertype[npi]);
                         skb->mac.raw = skb->data;
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index 2e1bed153c39..6e1018448eea 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -484,13 +484,12 @@ static void mdio_write(void __iomem *ioaddr, int RegAddr, int value)
         int i;
 
         RTL_W32(PHYAR, 0x80000000 | (RegAddr & 0xFF) << 16 | value);
-        udelay(1000);
 
-        for (i = 2000; i > 0; i--) {
+        for (i = 20; i > 0; i--) {
                 /* Check if the RTL8169 has completed writing to the specified MII register */
                 if (!(RTL_R32(PHYAR) & 0x80000000)) 
                         break;
-                udelay(100);
+                udelay(25);
         }
 }
 
@@ -499,15 +498,14 @@ static int mdio_read(void __iomem *ioaddr, int RegAddr)
         int i, value = -1;
 
         RTL_W32(PHYAR, 0x0 | (RegAddr & 0xFF) << 16);
-        udelay(1000);
 
-        for (i = 2000; i > 0; i--) {
+        for (i = 20; i > 0; i--) {
                 /* Check if the RTL8169 has completed retrieving data from the specified MII register */
                 if (RTL_R32(PHYAR) & 0x80000000) {
                         value = (int) (RTL_R32(PHYAR) & 0xFFFF);
                         break;
                 }
-                udelay(100);
+                udelay(25);
         }
         return value;
 }
@@ -677,6 +675,9 @@ static int rtl8169_set_speed_xmii(struct net_device *dev,
 
                 if (duplex == DUPLEX_HALF)
                         auto_nego &= ~(PHY_Cap_10_Full | PHY_Cap_100_Full);
+
+                if (duplex == DUPLEX_FULL)
+                        auto_nego &= ~(PHY_Cap_10_Half | PHY_Cap_100_Half);
         }
 
         tp->phy_auto_nego_reg = auto_nego;
diff --git a/drivers/net/sis900.h b/drivers/net/sis900.h
index 4233ea55670f..50323941e3c0 100644
--- a/drivers/net/sis900.h
+++ b/drivers/net/sis900.h
@@ -33,7 +33,6 @@ enum sis900_registers {
         rxcfg=0x34,             //Receive Configuration Register
         flctrl=0x38,            //Flow Control Register
         rxlen=0x3c,             //Receive Packet Length Register
-        cfgpmcsr=0x44,          //Configuration Power Management Control/Status Register
         rfcr=0x48,              //Receive Filter Control Register
         rfdr=0x4C,              //Receive Filter Data Register
         pmctrl=0xB0,            //Power Management Control Register
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index f8b973a04b65..cae2edf23004 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -23,12 +23,6 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-/*
- * TOTEST
- *      - speed setting
- *      - suspend/resume
- */
-
 #include <linux/config.h>
 #include <linux/crc32.h>
 #include <linux/kernel.h>
@@ -57,7 +51,7 @@
 #include "sky2.h"
 
 #define DRV_NAME                "sky2"
-#define DRV_VERSION             "0.13"
+#define DRV_VERSION             "0.15"
 #define PFX                     DRV_NAME " "
 
 /*
@@ -102,6 +96,10 @@ static int copybreak __read_mostly = 256;
 module_param(copybreak, int, 0);
 MODULE_PARM_DESC(copybreak, "Receive copy threshold");
 
+static int disable_msi = 0;
+module_param(disable_msi, int, 0);
+MODULE_PARM_DESC(disable_msi, "Disable Message Signaled Interrupt (MSI)");
+
 static const struct pci_device_id sky2_id_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9000) },
         { PCI_DEVICE(PCI_VENDOR_ID_SYSKONNECT, 0x9E00) },
@@ -198,7 +196,7 @@ static int sky2_set_power_state(struct sky2_hw *hw, pci_power_t state)
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
 
         pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_PMC, &power_control);
-        vaux = (sky2_read8(hw, B0_CTST) & Y2_VAUX_AVAIL) &&
+        vaux = (sky2_read16(hw, B0_CTST) & Y2_VAUX_AVAIL) &&
                 (power_control & PCI_PM_CAP_PME_D3cold);
 
         pci_read_config_word(hw->pdev, hw->pm_cap + PCI_PM_CTRL, &power_control);
@@ -1834,6 +1832,8 @@ static int sky2_poll(struct net_device *dev0, int *budget)
         u16 hwidx;
         u16 tx_done[2] = { TX_NO_STATUS, TX_NO_STATUS };
 
+        sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
+
         hwidx = sky2_read16(hw, STAT_PUT_IDX);
         BUG_ON(hwidx >= STATUS_RING_SIZE);
         rmb();
@@ -1913,12 +1913,10 @@ static int sky2_poll(struct net_device *dev0, int *budget)
         }
 
 exit_loop:
-        sky2_write32(hw, STAT_CTRL, SC_STAT_CLR_IRQ);
-
         sky2_tx_check(hw, 0, tx_done[0]);
         sky2_tx_check(hw, 1, tx_done[1]);
 
-        if (sky2_read16(hw, STAT_PUT_IDX) == hw->st_idx) {
+        if (likely(work_done < to_do)) {
                 /* need to restart TX timer */
                 if (is_ec_a1(hw)) {
                         sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
@@ -2141,14 +2139,12 @@ static inline u32 sky2_clk2us(const struct sky2_hw *hw, u32 clk)
 
 static int sky2_reset(struct sky2_hw *hw)
 {
-        u32 ctst;
         u16 status;
         u8 t8, pmd_type;
-        int i;
-
-        ctst = sky2_read32(hw, B0_CTST);
+        int i, err;
 
         sky2_write8(hw, B0_CTST, CS_RST_CLR);
+
         hw->chip_id = sky2_read8(hw, B2_CHIP_ID);
         if (hw->chip_id < CHIP_ID_YUKON_XL || hw->chip_id > CHIP_ID_YUKON_FE) {
                 printk(KERN_ERR PFX "%s: unsupported chip type 0x%x\n",
@@ -2156,12 +2152,6 @@ static int sky2_reset(struct sky2_hw *hw)
                 return -EOPNOTSUPP;
         }
 
-        /* ring for status responses */
-        hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES,
-                                         &hw->st_dma);
-        if (!hw->st_le)
-                return -ENOMEM;
-
         /* disable ASF */
         if (hw->chip_id <= CHIP_ID_YUKON_EC) {
                 sky2_write8(hw, B28_Y2_ASF_STAT_CMD, Y2_ASF_RESET);
@@ -2173,19 +2163,24 @@ static int sky2_reset(struct sky2_hw *hw)
         sky2_write8(hw, B0_CTST, CS_RST_CLR);
 
         /* clear PCI errors, if any */
-        pci_read_config_word(hw->pdev, PCI_STATUS, &status);
+        err = pci_read_config_word(hw->pdev, PCI_STATUS, &status);
+        if (err)
+                goto pci_err;
+
         sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
-        pci_write_config_word(hw->pdev, PCI_STATUS,
-                              status | PCI_STATUS_ERROR_BITS);
+        err = pci_write_config_word(hw->pdev, PCI_STATUS,
+                                    status | PCI_STATUS_ERROR_BITS);
+        if (err)
+                goto pci_err;
 
         sky2_write8(hw, B0_CTST, CS_MRST_CLR);
 
         /* clear any PEX errors */
-        if (is_pciex(hw)) {
-                u16 lstat;
-                pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT,
-                                       0xffffffffUL);
-                pci_read_config_word(hw->pdev, PEX_LNK_STAT, &lstat);
+        if (pci_find_capability(hw->pdev, PCI_CAP_ID_EXP)) {
+                err = pci_write_config_dword(hw->pdev, PEX_UNC_ERR_STAT,
+                                                 0xffffffffUL);
+                if (err)
+                        goto pci_err;
         }
 
         pmd_type = sky2_read8(hw, B2_PMD_TYP);
@@ -2297,6 +2292,14 @@ static int sky2_reset(struct sky2_hw *hw)
         sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
 
         return 0;
+
+pci_err:
+        /* This is to catch a BIOS bug workaround where
+         * mmconfig table doesn't have other buses.
+         */
+        printk(KERN_ERR PFX "%s: can't access PCI config space\n",
+               pci_name(hw->pdev));
+        return err;
 }
 
 static u32 sky2_supported_modes(const struct sky2_hw *hw)
@@ -2551,19 +2554,24 @@ static struct net_device_stats *sky2_get_stats(struct net_device *dev)
 static int sky2_set_mac_address(struct net_device *dev, void *p)
 {
         struct sky2_port *sky2 = netdev_priv(dev);
-        struct sockaddr *addr = p;
+        struct sky2_hw *hw = sky2->hw;
+        unsigned port = sky2->port;
+        const struct sockaddr *addr = p;
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
         memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
-        memcpy_toio(sky2->hw->regs + B2_MAC_1 + sky2->port * 8,
+        memcpy_toio(hw->regs + B2_MAC_1 + port * 8,
                     dev->dev_addr, ETH_ALEN);
-        memcpy_toio(sky2->hw->regs + B2_MAC_2 + sky2->port * 8,
+        memcpy_toio(hw->regs + B2_MAC_2 + port * 8,
                     dev->dev_addr, ETH_ALEN);
 
-        if (netif_running(dev))
-                sky2_phy_reinit(sky2);
+        /* virtual address for data */
+        gma_set_addr(hw, port, GM_SRC_ADDR_2L, dev->dev_addr);
+
+        /* physical address: used for pause frames */
+        gma_set_addr(hw, port, GM_SRC_ADDR_1L, dev->dev_addr);
 
         return 0;
 }
@@ -2843,7 +2851,7 @@ static int sky2_set_coalesce(struct net_device *dev,
         if (ecmd->rx_coalesce_usecs_irq == 0)
                 sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_STOP);
         else {
-                sky2_write32(hw, STAT_TX_TIMER_INI,
+                sky2_write32(hw, STAT_ISR_TIMER_INI,
                              sky2_us2clk(hw, ecmd->rx_coalesce_usecs_irq));
                 sky2_write8(hw, STAT_ISR_TIMER_CTRL, TIM_START);
         }
@@ -3055,6 +3063,61 @@ static void __devinit sky2_show_addr(struct net_device *dev)
                        dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5]);
 }
 
+/* Handle software interrupt used during MSI test */
+static irqreturn_t __devinit sky2_test_intr(int irq, void *dev_id,
+                                            struct pt_regs *regs)
+{
+        struct sky2_hw *hw = dev_id;
+        u32 status = sky2_read32(hw, B0_Y2_SP_ISRC2);
+
+        if (status == 0)
+                return IRQ_NONE;
+
+        if (status & Y2_IS_IRQ_SW) {
+                sky2_write8(hw, B0_CTST, CS_CL_SW_IRQ);
+                hw->msi = 1;
+        }
+        sky2_write32(hw, B0_Y2_SP_ICR, 2);
+
+        sky2_read32(hw, B0_IMSK);
+        return IRQ_HANDLED;
+}
+
+/* Test interrupt path by forcing a a software IRQ */
+static int __devinit sky2_test_msi(struct sky2_hw *hw)
+{
+        struct pci_dev *pdev = hw->pdev;
+        int i, err;
+
+        sky2_write32(hw, B0_IMSK, Y2_IS_IRQ_SW);
+
+        err = request_irq(pdev->irq, sky2_test_intr, SA_SHIRQ, DRV_NAME, hw);
+        if (err) {
+                printk(KERN_ERR PFX "%s: cannot assign irq %d\n",
+                       pci_name(pdev), pdev->irq);
+                return err;
+        }
+
+        sky2_write8(hw, B0_CTST, CS_ST_SW_IRQ);
+        wmb();
+
+        for (i = 0; i < 10; i++) {
+                barrier();
+                if (hw->msi)
+                        goto found;
+                mdelay(1);
+        }
+
+        err = -EOPNOTSUPP;
+        sky2_write8(hw, B0_CTST, CS_CL_SW_IRQ);
+ found:
+        sky2_write32(hw, B0_IMSK, 0);
+
+        free_irq(pdev->irq, hw);
+
+        return err;
+}
+
 static int __devinit sky2_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *ent)
 {
@@ -3135,6 +3198,12 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
         }
         hw->pm_cap = pm_cap;
 
+        /* ring for status responses */
+        hw->st_le = pci_alloc_consistent(hw->pdev, STATUS_LE_BYTES,
+                                         &hw->st_dma);
+        if (!hw->st_le)
+                goto err_out_iounmap;
+
         err = sky2_reset(hw);
         if (err)
                 goto err_out_iounmap;
@@ -3169,7 +3238,22 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
                 }
         }
 
-        err = request_irq(pdev->irq, sky2_intr, SA_SHIRQ, DRV_NAME, hw);
+        if (!disable_msi && pci_enable_msi(pdev) == 0) {
+                err = sky2_test_msi(hw);
+                if (err == -EOPNOTSUPP) {
+                        /* MSI test failed, go back to INTx mode */
+                        printk(KERN_WARNING PFX "%s: No interrupt was generated using MSI, "
+                               "switching to INTx mode. Please report this failure to "
+                               "the PCI maintainer and include system chipset information.\n",
+                               pci_name(pdev));
+                        pci_disable_msi(pdev);
+                }
+                else if (err)
+                        goto err_out_unregister;
+        }
+
+        err = request_irq(pdev->irq, sky2_intr, SA_SHIRQ | SA_SAMPLE_RANDOM,
+                          DRV_NAME, hw);
         if (err) {
                 printk(KERN_ERR PFX "%s: cannot assign irq %d\n",
                        pci_name(pdev), pdev->irq);
@@ -3184,6 +3268,8 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
         return 0;
 
 err_out_unregister:
+        if (hw->msi)
+                pci_disable_msi(pdev);
         if (dev1) {
                 unregister_netdev(dev1);
                 free_netdev(dev1);
@@ -3226,6 +3312,8 @@ static void __devexit sky2_remove(struct pci_dev *pdev)
         sky2_read8(hw, B0_CTST);
 
         free_irq(pdev->irq, hw);
+        if (hw->msi)
+                pci_disable_msi(pdev);
         pci_free_consistent(pdev, STATUS_LE_BYTES, hw->st_le, hw->st_dma);
         pci_release_regions(pdev);
         pci_disable_device(pdev);
@@ -3263,25 +3351,33 @@ static int sky2_suspend(struct pci_dev *pdev, pm_message_t state)
 static int sky2_resume(struct pci_dev *pdev)
 {
         struct sky2_hw *hw = pci_get_drvdata(pdev);
-        int i;
+        int i, err;
 
         pci_restore_state(pdev);
         pci_enable_wake(pdev, PCI_D0, 0);
-        sky2_set_power_state(hw, PCI_D0);
+        err = sky2_set_power_state(hw, PCI_D0);
+        if (err)
+                goto out;
 
-        sky2_reset(hw);
+        err = sky2_reset(hw);
+        if (err)
+                goto out;
 
         for (i = 0; i < 2; i++) {
                 struct net_device *dev = hw->dev[i];
-                if (dev) {
-                        if (netif_running(dev)) {
-                                netif_device_attach(dev);
-                                if (sky2_up(dev))
-                                        dev_close(dev);
+                if (dev && netif_running(dev)) {
+                        netif_device_attach(dev);
+                        err = sky2_up(dev);
+                        if (err) {
+                                printk(KERN_ERR PFX "%s: could not up: %d\n",
+                                       dev->name, err);
+                                dev_close(dev);
+                                break;
                         }
                 }
         }
-        return 0;
+out:
+        return err;
 }
 #endif
 
diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
index 95518921001c..fd12c289a238 100644
--- a/drivers/net/sky2.h
+++ b/drivers/net/sky2.h
@@ -1841,6 +1841,7 @@ struct sky2_hw {
         struct net_device    *dev[2];
 
         int                  pm_cap;
+        int                  msi;
         u8                   chip_id;
         u8                   chip_rev;
         u8                   copper;
@@ -1867,14 +1868,6 @@ static inline u8 sky2_read8(const struct sky2_hw *hw, unsigned reg)
         return readb(hw->regs + reg);
 }
 
-/* This should probably go away, bus based tweeks suck */
-static inline int is_pciex(const struct sky2_hw *hw)
-{
-        u32 status;
-        pci_read_config_dword(hw->pdev, PCI_DEV_STATUS, &status);
-        return (status & PCI_OS_PCI_X) == 0;
-}
-
 static inline void sky2_write32(const struct sky2_hw *hw, unsigned reg, u32 val)
 {
         writel(val, hw->regs + reg);
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index f2d1dafde087..e7dc653d5bd6 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -69,8 +69,8 @@
 
 #define DRV_MODULE_NAME         "tg3"
 #define PFX DRV_MODULE_NAME     ": "
-#define DRV_MODULE_VERSION      "3.48"
-#define DRV_MODULE_RELDATE      "Jan 16, 2006"
+#define DRV_MODULE_VERSION      "3.49"
+#define DRV_MODULE_RELDATE      "Feb 2, 2006"
 
 #define TG3_DEF_MAC_MODE        0
 #define TG3_DEF_RX_MODE         0
@@ -3482,6 +3482,17 @@ static void tg3_reset_task(void *_data)
         struct tg3 *tp = _data;
         unsigned int restart_timer;
 
+        tg3_full_lock(tp, 0);
+        tp->tg3_flags |= TG3_FLAG_IN_RESET_TASK;
+
+        if (!netif_running(tp->dev)) {
+                tp->tg3_flags &= ~TG3_FLAG_IN_RESET_TASK;
+                tg3_full_unlock(tp);
+                return;
+        }
+
+        tg3_full_unlock(tp);
+
         tg3_netif_stop(tp);
 
         tg3_full_lock(tp, 1);
@@ -3494,10 +3505,12 @@ static void tg3_reset_task(void *_data)
 
         tg3_netif_start(tp);
 
-        tg3_full_unlock(tp);
-
         if (restart_timer)
                 mod_timer(&tp->timer, jiffies + 1);
+
+        tp->tg3_flags &= ~TG3_FLAG_IN_RESET_TASK;
+
+        tg3_full_unlock(tp);
 }
 
 static void tg3_tx_timeout(struct net_device *dev)
@@ -6786,6 +6799,13 @@ static int tg3_close(struct net_device *dev)
 {
         struct tg3 *tp = netdev_priv(dev);
 
+        /* Calling flush_scheduled_work() may deadlock because
+         * linkwatch_event() may be on the workqueue and it will try to get
+         * the rtnl_lock which we are holding.
+         */
+        while (tp->tg3_flags & TG3_FLAG_IN_RESET_TASK)
+                msleep(1);
+
         netif_stop_queue(dev);
 
         del_timer_sync(&tp->timer);
@@ -10880,6 +10900,7 @@ static void __devexit tg3_remove_one(struct pci_dev *pdev)
         if (dev) {
                 struct tg3 *tp = netdev_priv(dev);
 
+                flush_scheduled_work();
                 unregister_netdev(dev);
                 if (tp->regs) {
                         iounmap(tp->regs);
@@ -10901,6 +10922,7 @@ static int tg3_suspend(struct pci_dev *pdev, pm_message_t state)
         if (!netif_running(dev))
                 return 0;
 
+        flush_scheduled_work();
         tg3_netif_stop(tp);
 
         del_timer_sync(&tp->timer);
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index e8243305f0e8..7f4b7f6ac40d 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2162,6 +2162,7 @@ struct tg3 {
 #define TG3_FLAG_JUMBO_RING_ENABLE      0x00800000
 #define TG3_FLAG_10_100_ONLY            0x01000000
 #define TG3_FLAG_PAUSE_AUTONEG          0x02000000
+#define TG3_FLAG_IN_RESET_TASK          0x04000000
 #define TG3_FLAG_BROKEN_CHECKSUMS       0x10000000
 #define TG3_FLAG_GOT_SERDES_FLOWCTL     0x20000000
 #define TG3_FLAG_SPLIT_MODE             0x40000000
diff --git a/drivers/net/tulip/uli526x.c b/drivers/net/tulip/uli526x.c
index 983981666800..238e9c72cb3a 100644
--- a/drivers/net/tulip/uli526x.c
+++ b/drivers/net/tulip/uli526x.c
@@ -214,7 +214,7 @@ static u32 uli526x_cr6_user_set;
 /* For module input parameter */
 static int debug;
 static u32 cr6set;
-static unsigned char mode = 8;
+static int mode = 8;
 
 /* function declaration ------------------------------------- */
 static int uli526x_open(struct net_device *);
diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index 2f61a47b4716..1ff5de076d21 100644
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -1943,7 +1943,7 @@ static int dscc4_init_ring(struct net_device *dev)
                                         (++i%TX_RING_SIZE)*sizeof(*tx_fd));
         } while (i < TX_RING_SIZE);
 
-        if (dscc4_init_dummy_skb(dpriv) < 0)
+        if (!dscc4_init_dummy_skb(dpriv))
                 goto err_free_dma_tx;
 
         memset(dpriv->rx_skbuff, 0, sizeof(struct sk_buff *)*RX_RING_SIZE);
diff --git a/drivers/net/wan/pci200syn.c b/drivers/net/wan/pci200syn.c
index 8dea07b47999..eba8e5cfacc2 100644
--- a/drivers/net/wan/pci200syn.c
+++ b/drivers/net/wan/pci200syn.c
@@ -29,7 +29,7 @@
 #include <linux/netdevice.h>
 #include <linux/hdlc.h>
 #include <linux/pci.h>
-#include <asm/delay.h>
+#include <linux/delay.h>
 #include <asm/io.h>
 
 #include "hd64572.h"
diff --git a/drivers/net/wan/wanxl.c b/drivers/net/wan/wanxl.c
index 9c1e10602f2b..9d3b51c3ef54 100644
--- a/drivers/net/wan/wanxl.c
+++ b/drivers/net/wan/wanxl.c
@@ -27,8 +27,8 @@
 #include <linux/hdlc.h>
 #include <linux/pci.h>
 #include <linux/dma-mapping.h>
+#include <linux/delay.h>
 #include <asm/io.h>
-#include <asm/delay.h>
 
 #include "wanxl.h"
 
diff --git a/drivers/net/wireless/prism54/isl_ioctl.c b/drivers/net/wireless/prism54/isl_ioctl.c
index c5cd61c7f927..e5bb9f5ae429 100644
--- a/drivers/net/wireless/prism54/isl_ioctl.c
+++ b/drivers/net/wireless/prism54/isl_ioctl.c
@@ -748,7 +748,7 @@ prism54_get_essid(struct net_device *ndev, struct iw_request_info *info,
         if (essid->length) {
                 dwrq->flags = 1;        /* set ESSID to ON for Wireless Extensions */
                 /* if it is to big, trunk it */
-                dwrq->length = min(IW_ESSID_MAX_SIZE, essid->length);
+                dwrq->length = min((u8)IW_ESSID_MAX_SIZE, essid->length);
         } else {
                 dwrq->flags = 0;
                 dwrq->length = 0;
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 9e0229f7e25f..f46e8438e0d2 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -1423,7 +1423,7 @@ static void __init ccio_init_resources(struct ioc *ioc)
         struct resource *res = ioc->mmio_region;
         char *name = kmalloc(14, GFP_KERNEL);
 
-        sprintf(name, "GSC Bus [%d/]", ioc->hw_path);
+        snprintf(name, 14, "GSC Bus [%d/]", ioc->hw_path);
 
         ccio_init_resource(res, name, &ioc->ioc_regs->io_io_low);
         ccio_init_resource(res + 1, name, &ioc->ioc_regs->io_io_low_hv);
@@ -1557,12 +1557,11 @@ static int ccio_probe(struct parisc_device *dev)
         int i;
         struct ioc *ioc, **ioc_p = &ioc_list;
         
-        ioc = kmalloc(sizeof(struct ioc), GFP_KERNEL);
+        ioc = kzalloc(sizeof(struct ioc), GFP_KERNEL);
         if (ioc == NULL) {
                 printk(KERN_ERR MODULE_NAME ": memory allocation failure\n");
                 return 1;
         }
-        memset(ioc, 0, sizeof(struct ioc));
 
         ioc->name = dev->id.hversion == U2_IOA_RUNWAY ? "U2" : "UTurn";
 
@@ -1578,7 +1577,7 @@ static int ccio_probe(struct parisc_device *dev)
         ccio_ioc_init(ioc);
         ccio_init_resources(ioc);
         hppa_dma_ops = &ccio_ops;
-        dev->dev.platform_data = kmalloc(sizeof(struct pci_hba_data), GFP_KERNEL);
+        dev->dev.platform_data = kzalloc(sizeof(struct pci_hba_data), GFP_KERNEL);
 
         /* if this fails, no I/O cards will work, so may as well bug */
         BUG_ON(dev->dev.platform_data == NULL);
diff --git a/drivers/parisc/dino.c b/drivers/parisc/dino.c
index 216d1d859326..3d1a7f98c676 100644
--- a/drivers/parisc/dino.c
+++ b/drivers/parisc/dino.c
@@ -989,14 +989,12 @@ static int __init dino_probe(struct parisc_device *dev)
 */
         }
 
-        dino_dev = kmalloc(sizeof(struct dino_device), GFP_KERNEL);
+        dino_dev = kzalloc(sizeof(struct dino_device), GFP_KERNEL);
         if (!dino_dev) {
                 printk("dino_init_chip - couldn't alloc dino_device\n");
                 return 1;
         }
 
-        memset(dino_dev, 0, sizeof(struct dino_device));
-
         dino_dev->hba.dev = dev;
         dino_dev->hba.base_addr = ioremap(hpa, 4096);
         dino_dev->hba.lmmio_space_offset = 0;   /* CPU addrs == bus addrs */
diff --git a/drivers/parisc/hppb.c b/drivers/parisc/hppb.c
index 5edf93f80757..07dc2b6d4e93 100644
--- a/drivers/parisc/hppb.c
+++ b/drivers/parisc/hppb.c
@@ -60,12 +60,11 @@ static int hppb_probe(struct parisc_device *dev)
         }
 
         if(card->hpa) {
-                card->next = kmalloc(sizeof(struct hppb_card), GFP_KERNEL);
+                card->next = kzalloc(sizeof(struct hppb_card), GFP_KERNEL);
                 if(!card->next) {
                         printk(KERN_ERR "HP-PB: Unable to allocate memory.\n");
                         return 1;
                 }
-                memset(card->next, '\0', sizeof(struct hppb_card));
                 card = card->next;
         }
         printk(KERN_INFO "Found GeckoBoa at 0x%lx\n", dev->hpa.start);
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 19657efa8dc3..8d7a36392eb8 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -873,28 +873,24 @@ void *iosapic_register(unsigned long hpa)
                 return NULL;
         }
 
-        isi = (struct iosapic_info *)kmalloc(sizeof(struct iosapic_info), GFP_KERNEL);
+        isi = (struct iosapic_info *)kzalloc(sizeof(struct iosapic_info), GFP_KERNEL);
         if (!isi) {
                 BUG();
                 return NULL;
         }
 
-        memset(isi, 0, sizeof(struct iosapic_info));
-
         isi->addr = ioremap(hpa, 4096);
         isi->isi_hpa = hpa;
         isi->isi_version = iosapic_rd_version(isi);
         isi->isi_num_vectors = IOSAPIC_IRDT_MAX_ENTRY(isi->isi_version) + 1;
 
         vip = isi->isi_vector = (struct vector_info *)
-                kmalloc(sizeof(struct vector_info) * isi->isi_num_vectors, GFP_KERNEL);
+                kzalloc(sizeof(struct vector_info) * isi->isi_num_vectors, GFP_KERNEL);
         if (vip == NULL) {
                 kfree(isi);
                 return NULL;
         }
 
-        memset(vip, 0, sizeof(struct vector_info) * isi->isi_num_vectors);
-
         for (cnt=0; cnt < isi->isi_num_vectors; cnt++, vip++) {
                 vip->irqline = (unsigned char) cnt;
                 vip->iosapic = isi;
diff --git a/drivers/parisc/lasi.c b/drivers/parisc/lasi.c
index 2b3ba1dcf332..cb3d28176129 100644
--- a/drivers/parisc/lasi.c
+++ b/drivers/parisc/lasi.c
@@ -166,11 +166,12 @@ static void lasi_power_off(void)
 int __init
 lasi_init_chip(struct parisc_device *dev)
 {
+        extern void (*chassis_power_off)(void);
         struct gsc_asic *lasi;
         struct gsc_irq gsc_irq;
         int ret;
 
-        lasi = kmalloc(sizeof(*lasi), GFP_KERNEL);
+        lasi = kzalloc(sizeof(*lasi), GFP_KERNEL);
         if (!lasi)
                 return -ENOMEM;
 
@@ -222,7 +223,7 @@ lasi_init_chip(struct parisc_device *dev)
          * ensure that only the first LASI (the one controlling the power off)
          * should set the HPA here */
         lasi_power_off_hpa = lasi->hpa;
-        pm_power_off = lasi_power_off;
+        chassis_power_off = lasi_power_off;
         
         return ret;
 }
diff --git a/drivers/parisc/lba_pci.c b/drivers/parisc/lba_pci.c
index cbae8c8963fa..e8a2a4a852f5 100644
--- a/drivers/parisc/lba_pci.c
+++ b/drivers/parisc/lba_pci.c
@@ -1565,7 +1565,7 @@ lba_driver_probe(struct parisc_device *dev)
         } else if (IS_MERCURY(dev) || IS_QUICKSILVER(dev)) {
                 func_class &= 0xff;
                 version = kmalloc(6, GFP_KERNEL);
-                sprintf(version,"TR%d.%d",(func_class >> 4),(func_class & 0xf));
+                snprintf(version, 6, "TR%d.%d",(func_class >> 4),(func_class & 0xf));
                 /* We could use one printk for both Elroy and Mercury,
                  * but for the mask for func_class.
                  */ 
@@ -1586,14 +1586,12 @@ lba_driver_probe(struct parisc_device *dev)
         **      have an IRT entry will get NULL back from iosapic code.
         */
         
-        lba_dev = kmalloc(sizeof(struct lba_device), GFP_KERNEL);
+        lba_dev = kzalloc(sizeof(struct lba_device), GFP_KERNEL);
         if (!lba_dev) {
                 printk(KERN_ERR "lba_init_chip - couldn't alloc lba_device\n");
                 return(1);
         }
 
-        memset(lba_dev, 0, sizeof(struct lba_device));
-
 
         /* ---------- First : initialize data we already have --------- */
 
diff --git a/drivers/parisc/pdc_stable.c b/drivers/parisc/pdc_stable.c
index 42a3c54e8e6c..a28e17898fbd 100644
--- a/drivers/parisc/pdc_stable.c
+++ b/drivers/parisc/pdc_stable.c
@@ -1,7 +1,7 @@
 /* 
  *    Interfaces to retrieve and set PDC Stable options (firmware)
  *
- *    Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
+ *    Copyright (C) 2005-2006 Thibaut VARENE <varenet@parisc-linux.org>
  *
  *    This program is free software; you can redistribute it and/or modify
  *    it under the terms of the GNU General Public License as published by
@@ -26,11 +26,19 @@
  *
  *    Since locations between 96 and 192 are the various paths, most (if not
  *    all) PA-RISC machines should have them. Anyway, for safety reasons, the
- *    following code can deal with only 96 bytes of Stable Storage, and all
+ *    following code can deal with just 96 bytes of Stable Storage, and all
  *    sizes between 96 and 192 bytes (provided they are multiple of struct
  *    device_path size, eg: 128, 160 and 192) to provide full information.
  *    The code makes no use of data above 192 bytes. One last word: there's one
  *    path we can always count on: the primary path.
+ *
+ *    The current policy wrt file permissions is:
+ *      - write: root only
+ *      - read: (reading triggers PDC calls) ? root only : everyone
+ *    The rationale is that PDC calls could hog (DoS) the machine.
+ *
+ *      TODO:
+ *      - timer/fastsize write calls
  */
 
 #undef PDCS_DEBUG
@@ -50,13 +58,15 @@
 #include <linux/kobject.h>
 #include <linux/device.h>
 #include <linux/errno.h>
+#include <linux/spinlock.h>
 
 #include <asm/pdc.h>
 #include <asm/page.h>
 #include <asm/uaccess.h>
 #include <asm/hardware.h>
 
-#define PDCS_VERSION    "0.10"
+#define PDCS_VERSION    "0.22"
+#define PDCS_PREFIX     "PDC Stable Storage"
 
 #define PDCS_ADDR_PPRI  0x00
 #define PDCS_ADDR_OSID  0x40
@@ -70,10 +80,12 @@ MODULE_DESCRIPTION("sysfs interface to HP PDC Stable Storage data");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(PDCS_VERSION);
 
+/* holds Stable Storage size. Initialized once and for all, no lock needed */
 static unsigned long pdcs_size __read_mostly;
 
 /* This struct defines what we need to deal with a parisc pdc path entry */
 struct pdcspath_entry {
+        rwlock_t rw_lock;               /* to protect path entry access */
         short ready;                    /* entry record is valid if != 0 */
         unsigned long addr;             /* entry address in stable storage */
         char *name;                     /* entry name */
@@ -121,6 +133,8 @@ struct pdcspath_attribute paths_attr_##_name = { \
  * content of the stable storage WRT various paths in these structs. We read
  * these structs when reading the files, and we will write to these structs when
  * writing to the files, and only then write them back to the Stable Storage.
+ *
+ * This function expects to be called with @entry->rw_lock write-hold.
  */
 static int
 pdcspath_fetch(struct pdcspath_entry *entry)
@@ -160,14 +174,15 @@ pdcspath_fetch(struct pdcspath_entry *entry)
  * pointer, from which it'll find out the corresponding hardware path.
  * For now we do not handle the case where there's an error in writing to the
  * Stable Storage area, so you'd better not mess up the data :P
+ *
+ * This function expects to be called with @entry->rw_lock write-hold.
  */
-static int
+static void
 pdcspath_store(struct pdcspath_entry *entry)
 {
         struct device_path *devpath;
 
-        if (!entry)
-                return -EINVAL;
+        BUG_ON(!entry);
 
         devpath = &entry->devpath;
         
@@ -176,10 +191,8 @@ pdcspath_store(struct pdcspath_entry *entry)
            First case, we don't have a preset hwpath... */
         if (!entry->ready) {
                 /* ...but we have a device, map it */
-                if (entry->dev)
-                        device_to_hwpath(entry->dev, (struct hardware_path *)devpath);
-                else
-                        return -EINVAL;
+                BUG_ON(!entry->dev);
+                device_to_hwpath(entry->dev, (struct hardware_path *)devpath);
         }
         /* else, we expect the provided hwpath to be valid. */
         
@@ -191,15 +204,13 @@ pdcspath_store(struct pdcspath_entry *entry)
                 printk(KERN_ERR "%s: an error occured when writing to PDC.\n"
                                 "It is likely that the Stable Storage data has been corrupted.\n"
                                 "Please check it carefully upon next reboot.\n", __func__);
-                return -EIO;
+                WARN_ON(1);
         }
                 
         /* kobject is already registered */
         entry->ready = 2;
         
         DPRINTK("%s: device: 0x%p\n", __func__, entry->dev);
-        
-        return 0;
 }
 
 /**
@@ -214,14 +225,17 @@ pdcspath_hwpath_read(struct pdcspath_entry *entry, char *buf)
 {
         char *out = buf;
         struct device_path *devpath;
-        unsigned short i;
+        short i;
 
         if (!entry || !buf)
                 return -EINVAL;
 
+        read_lock(&entry->rw_lock);
         devpath = &entry->devpath;
+        i = entry->ready;
+        read_unlock(&entry->rw_lock);
 
-        if (!entry->ready)
+        if (!i) /* entry is not ready */
                 return -ENODATA;
         
         for (i = 0; i < 6; i++) {
@@ -242,7 +256,7 @@ pdcspath_hwpath_read(struct pdcspath_entry *entry, char *buf)
  * 
  * We will call this function to change the current hardware path.
  * Hardware paths are to be given '/'-delimited, without brackets.
- * We take care to make sure that the provided path actually maps to an existing
+ * We make sure that the provided path actually maps to an existing
  * device, BUT nothing would prevent some foolish user to set the path to some
  * PCI bridge or even a CPU...
  * A better work around would be to make sure we are at the end of a device tree
@@ -298,17 +312,19 @@ pdcspath_hwpath_write(struct pdcspath_entry *entry, const char *buf, size_t coun
         }
         
         /* So far so good, let's get in deep */
+        write_lock(&entry->rw_lock);
         entry->ready = 0;
         entry->dev = dev;
         
         /* Now, dive in. Write back to the hardware */
-        WARN_ON(pdcspath_store(entry)); /* this warn should *NEVER* happen */
+        pdcspath_store(entry);
         
         /* Update the symlink to the real device */
         sysfs_remove_link(&entry->kobj, "device");
         sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device");
+        write_unlock(&entry->rw_lock);
         
-        printk(KERN_INFO "PDC Stable Storage: changed \"%s\" path to \"%s\"\n",
+        printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" path to \"%s\"\n",
                 entry->name, buf);
         
         return count;
@@ -326,14 +342,17 @@ pdcspath_layer_read(struct pdcspath_entry *entry, char *buf)
 {
         char *out = buf;
         struct device_path *devpath;
-        unsigned short i;
+        short i;
 
         if (!entry || !buf)
                 return -EINVAL;
         
+        read_lock(&entry->rw_lock);
         devpath = &entry->devpath;
+        i = entry->ready;
+        read_unlock(&entry->rw_lock);
 
-        if (!entry->ready)
+        if (!i) /* entry is not ready */
                 return -ENODATA;
         
         for (i = 0; devpath->layers[i] && (likely(i < 6)); i++)
@@ -388,15 +407,17 @@ pdcspath_layer_write(struct pdcspath_entry *entry, const char *buf, size_t count
         }
                 
         /* So far so good, let's get in deep */
+        write_lock(&entry->rw_lock);
         
         /* First, overwrite the current layers with the new ones, not touching
            the hardware path. */
         memcpy(&entry->devpath.layers, &layers, sizeof(layers));
         
         /* Now, dive in. Write back to the hardware */
-        WARN_ON(pdcspath_store(entry)); /* this warn should *NEVER* happen */
+        pdcspath_store(entry);
+        write_unlock(&entry->rw_lock);
         
-        printk(KERN_INFO "PDC Stable Storage: changed \"%s\" layers to \"%s\"\n",
+        printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" layers to \"%s\"\n",
                 entry->name, buf);
         
         return count;
@@ -415,9 +436,6 @@ pdcspath_attr_show(struct kobject *kobj, struct attribute *attr, char *buf)
         struct pdcspath_attribute *pdcs_attr = to_pdcspath_attribute(attr);
         ssize_t ret = 0;
 
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-
         if (pdcs_attr->show)
                 ret = pdcs_attr->show(entry, buf);
 
@@ -454,8 +472,8 @@ static struct sysfs_ops pdcspath_attr_ops = {
 };
 
 /* These are the two attributes of any PDC path. */
-static PATHS_ATTR(hwpath, 0600, pdcspath_hwpath_read, pdcspath_hwpath_write);
-static PATHS_ATTR(layer, 0600, pdcspath_layer_read, pdcspath_layer_write);
+static PATHS_ATTR(hwpath, 0644, pdcspath_hwpath_read, pdcspath_hwpath_write);
+static PATHS_ATTR(layer, 0644, pdcspath_layer_read, pdcspath_layer_write);
 
 static struct attribute *paths_subsys_attrs[] = {
         &paths_attr_hwpath.attr,
@@ -484,36 +502,119 @@ static struct pdcspath_entry *pdcspath_entries[] = {
         NULL,
 };
 
+
+/* For more insight of what's going on here, refer to PDC Procedures doc,
+ * Section PDC_STABLE */
+
 /**
- * pdcs_info_read - Pretty printing of the remaining useful data.
+ * pdcs_size_read - Stable Storage size output.
  * @entry: An allocated and populated subsytem struct. We don't use it tho.
  * @buf: The output buffer to write to.
- * 
- * We will call this function to format the output of the 'info' attribute file.
- * Please refer to PDC Procedures documentation, section PDC_STABLE to get a
- * better insight of what we're doing here.
  */
 static ssize_t
-pdcs_info_read(struct subsystem *entry, char *buf)
+pdcs_size_read(struct subsystem *entry, char *buf)
 {
         char *out = buf;
-        __u32 result;
-        struct device_path devpath;
-        char *tmpstr = NULL;
         
         if (!entry || !buf)
                 return -EINVAL;
                 
         /* show the size of the stable storage */
-        out += sprintf(out, "Stable Storage size: %ld bytes\n", pdcs_size);
+        out += sprintf(out, "%ld\n", pdcs_size);
 
-        /* deal with flags */
-        if (pdc_stable_read(PDCS_ADDR_PPRI, &devpath, sizeof(devpath)) != PDC_OK)
-                return -EIO;
+        return out - buf;
+}
+
+/**
+ * pdcs_auto_read - Stable Storage autoboot/search flag output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag
+ */
+static ssize_t
+pdcs_auto_read(struct subsystem *entry, char *buf, int knob)
+{
+        char *out = buf;
+        struct pdcspath_entry *pathentry;
         
-        out += sprintf(out, "Autoboot: %s\n", (devpath.flags & PF_AUTOBOOT) ? "On" : "Off");
-        out += sprintf(out, "Autosearch: %s\n", (devpath.flags & PF_AUTOSEARCH) ? "On" : "Off");
-        out += sprintf(out, "Timer: %u s\n", (devpath.flags & PF_TIMER) ? (1 << (devpath.flags & PF_TIMER)) : 0);
+        if (!entry || !buf)
+                return -EINVAL;
+
+        /* Current flags are stored in primary boot path entry */
+        pathentry = &pdcspath_entry_primary;
+
+        read_lock(&pathentry->rw_lock);
+        out += sprintf(out, "%s\n", (pathentry->devpath.flags & knob) ?
+                                        "On" : "Off");
+        read_unlock(&pathentry->rw_lock);
+
+        return out - buf;
+}
+
+/**
+ * pdcs_autoboot_read - Stable Storage autoboot flag output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ */
+static inline ssize_t
+pdcs_autoboot_read(struct subsystem *entry, char *buf)
+{
+        return pdcs_auto_read(entry, buf, PF_AUTOBOOT);
+}
+
+/**
+ * pdcs_autosearch_read - Stable Storage autoboot flag output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ */
+static inline ssize_t
+pdcs_autosearch_read(struct subsystem *entry, char *buf)
+{
+        return pdcs_auto_read(entry, buf, PF_AUTOSEARCH);
+}
+
+/**
+ * pdcs_timer_read - Stable Storage timer count output (in seconds).
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * The value of the timer field correponds to a number of seconds in powers of 2.
+ */
+static ssize_t
+pdcs_timer_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        struct pdcspath_entry *pathentry;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        /* Current flags are stored in primary boot path entry */
+        pathentry = &pdcspath_entry_primary;
+
+        /* print the timer value in seconds */
+        read_lock(&pathentry->rw_lock);
+        out += sprintf(out, "%u\n", (pathentry->devpath.flags & PF_TIMER) ?
+                                (1 << (pathentry->devpath.flags & PF_TIMER)) : 0);
+        read_unlock(&pathentry->rw_lock);
+
+        return out - buf;
+}
+
+/**
+ * pdcs_osid_read - Stable Storage OS ID register output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ */
+static ssize_t
+pdcs_osid_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        __u32 result;
+        char *tmpstr = NULL;
+
+        if (!entry || !buf)
+                return -EINVAL;
 
         /* get OSID */
         if (pdc_stable_read(PDCS_ADDR_OSID, &result, sizeof(result)) != PDC_OK)
@@ -529,13 +630,31 @@ pdcs_info_read(struct subsystem *entry, char *buf)
                 case 0x0005:    tmpstr = "Novell Netware dependent data"; break;
                 default:        tmpstr = "Unknown"; break;
         }
-        out += sprintf(out, "OS ID: %s (0x%.4x)\n", tmpstr, (result >> 16));
+        out += sprintf(out, "%s (0x%.4x)\n", tmpstr, (result >> 16));
+
+        return out - buf;
+}
+
+/**
+ * pdcs_fastsize_read - Stable Storage FastSize register output.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The output buffer to write to.
+ *
+ * This register holds the amount of system RAM to be tested during boot sequence.
+ */
+static ssize_t
+pdcs_fastsize_read(struct subsystem *entry, char *buf)
+{
+        char *out = buf;
+        __u32 result;
+
+        if (!entry || !buf)
+                return -EINVAL;
 
         /* get fast-size */
         if (pdc_stable_read(PDCS_ADDR_FSIZ, &result, sizeof(result)) != PDC_OK)
                 return -EIO;
 
-        out += sprintf(out, "Memory tested: ");
         if ((result & 0x0F) < 0x0E)
                 out += sprintf(out, "%d kB", (1<<(result & 0x0F))*256);
         else
@@ -546,22 +665,18 @@ pdcs_info_read(struct subsystem *entry, char *buf)
 }
 
 /**
- * pdcs_info_write - This function handles boot flag modifying.
+ * pdcs_auto_write - This function handles autoboot/search flag modifying.
  * @entry: An allocated and populated subsytem struct. We don't use it tho.
  * @buf: The input buffer to read from.
  * @count: The number of bytes to be read.
+ * @knob: The PF_AUTOBOOT or PF_AUTOSEARCH flag
  * 
- * We will call this function to change the current boot flags.
+ * We will call this function to change the current autoboot flag.
  * We expect a precise syntax:
- *      \"n n\" (n == 0 or 1) to toggle respectively AutoBoot and AutoSearch
- *
- * As of now there is no incentive on my side to provide more "knobs" to that
- * interface, since modifying the rest of the data is pretty meaningless when
- * the machine is running and for the expected use of that facility, such as
- * PALO setting up the boot disk when installing a Linux distribution...
+ *      \"n\" (n == 0 or 1) to toggle AutoBoot Off or On
  */
 static ssize_t
-pdcs_info_write(struct subsystem *entry, const char *buf, size_t count)
+pdcs_auto_write(struct subsystem *entry, const char *buf, size_t count, int knob)
 {
         struct pdcspath_entry *pathentry;
         unsigned char flags;
@@ -582,7 +697,9 @@ pdcs_info_write(struct subsystem *entry, const char *buf, size_t count)
         pathentry = &pdcspath_entry_primary;
         
         /* Be nice to the existing flag record */
+        read_lock(&pathentry->rw_lock);
         flags = pathentry->devpath.flags;
+        read_unlock(&pathentry->rw_lock);
         
         DPRINTK("%s: flags before: 0x%X\n", __func__, flags);
                         
@@ -595,50 +712,85 @@ pdcs_info_write(struct subsystem *entry, const char *buf, size_t count)
         if ((c != 0) && (c != 1))
                 goto parse_error;
         if (c == 0)
-                flags &= ~PF_AUTOBOOT;
+                flags &= ~knob;
         else
-                flags |= PF_AUTOBOOT;
-        
-        if (*temp++ != ' ')
-                goto parse_error;
-        
-        c = *temp++ - '0';
-        if ((c != 0) && (c != 1))
-                goto parse_error;
-        if (c == 0)
-                flags &= ~PF_AUTOSEARCH;
-        else
-                flags |= PF_AUTOSEARCH;
+                flags |= knob;
         
         DPRINTK("%s: flags after: 0x%X\n", __func__, flags);
                 
         /* So far so good, let's get in deep */
+        write_lock(&pathentry->rw_lock);
         
         /* Change the path entry flags first */
         pathentry->devpath.flags = flags;
                 
         /* Now, dive in. Write back to the hardware */
-        WARN_ON(pdcspath_store(pathentry));     /* this warn should *NEVER* happen */
+        pdcspath_store(pathentry);
+        write_unlock(&pathentry->rw_lock);
         
-        printk(KERN_INFO "PDC Stable Storage: changed flags to \"%s\"\n", buf);
+        printk(KERN_INFO PDCS_PREFIX ": changed \"%s\" to \"%s\"\n",
+                (knob & PF_AUTOBOOT) ? "autoboot" : "autosearch",
+                (flags & knob) ? "On" : "Off");
         
         return count;
 
 parse_error:
-        printk(KERN_WARNING "%s: Parse error: expect \"n n\" (n == 0 or 1) for AB and AS\n", __func__);
+        printk(KERN_WARNING "%s: Parse error: expect \"n\" (n == 0 or 1)\n", __func__);
         return -EINVAL;
 }
 
-/* The last attribute (the 'root' one actually) with all remaining data. */
-static PDCS_ATTR(info, 0600, pdcs_info_read, pdcs_info_write);
+/**
+ * pdcs_autoboot_write - This function handles autoboot flag modifying.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The input buffer to read from.
+ * @count: The number of bytes to be read.
+ *
+ * We will call this function to change the current boot flags.
+ * We expect a precise syntax:
+ *      \"n\" (n == 0 or 1) to toggle AutoSearch Off or On
+ */
+static inline ssize_t
+pdcs_autoboot_write(struct subsystem *entry, const char *buf, size_t count)
+{
+        return pdcs_auto_write(entry, buf, count, PF_AUTOBOOT);
+}
+
+/**
+ * pdcs_autosearch_write - This function handles autosearch flag modifying.
+ * @entry: An allocated and populated subsytem struct. We don't use it tho.
+ * @buf: The input buffer to read from.
+ * @count: The number of bytes to be read.
+ *
+ * We will call this function to change the current boot flags.
+ * We expect a precise syntax:
+ *      \"n\" (n == 0 or 1) to toggle AutoSearch Off or On
+ */
+static inline ssize_t
+pdcs_autosearch_write(struct subsystem *entry, const char *buf, size_t count)
+{
+        return pdcs_auto_write(entry, buf, count, PF_AUTOSEARCH);
+}
+
+/* The remaining attributes. */
+static PDCS_ATTR(size, 0444, pdcs_size_read, NULL);
+static PDCS_ATTR(autoboot, 0644, pdcs_autoboot_read, pdcs_autoboot_write);
+static PDCS_ATTR(autosearch, 0644, pdcs_autosearch_read, pdcs_autosearch_write);
+static PDCS_ATTR(timer, 0444, pdcs_timer_read, NULL);
+static PDCS_ATTR(osid, 0400, pdcs_osid_read, NULL);
+static PDCS_ATTR(fastsize, 0400, pdcs_fastsize_read, NULL);
 
 static struct subsys_attribute *pdcs_subsys_attrs[] = {
-        &pdcs_attr_info,
-        NULL,   /* maybe more in the future? */
+        &pdcs_attr_size,
+        &pdcs_attr_autoboot,
+        &pdcs_attr_autosearch,
+        &pdcs_attr_timer,
+        &pdcs_attr_osid,
+        &pdcs_attr_fastsize,
+        NULL,
 };
 
 static decl_subsys(paths, &ktype_pdcspath, NULL);
-static decl_subsys(pdc, NULL, NULL);
+static decl_subsys(stable, NULL, NULL);
 
 /**
  * pdcs_register_pathentries - Prepares path entries kobjects for sysfs usage.
@@ -656,8 +808,16 @@ pdcs_register_pathentries(void)
         struct pdcspath_entry *entry;
         int err;
         
+        /* Initialize the entries rw_lock before anything else */
+        for (i = 0; (entry = pdcspath_entries[i]); i++)
+                rwlock_init(&entry->rw_lock);
+
         for (i = 0; (entry = pdcspath_entries[i]); i++) {
-                if (pdcspath_fetch(entry) < 0)
+                write_lock(&entry->rw_lock);
+                err = pdcspath_fetch(entry);
+                write_unlock(&entry->rw_lock);
+
+                if (err < 0)
                         continue;
 
                 if ((err = kobject_set_name(&entry->kobj, "%s", entry->name)))
@@ -667,13 +827,14 @@ pdcs_register_pathentries(void)
                         return err;
                 
                 /* kobject is now registered */
+                write_lock(&entry->rw_lock);
                 entry->ready = 2;
                 
-                if (!entry->dev)
-                        continue;
-
                 /* Add a nice symlink to the real device */
-                sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device");
+                if (entry->dev)
+                        sysfs_create_link(&entry->kobj, &entry->dev->kobj, "device");
+
+                write_unlock(&entry->rw_lock);
         }
         
         return 0;
@@ -688,14 +849,17 @@ pdcs_unregister_pathentries(void)
         unsigned short i;
         struct pdcspath_entry *entry;
         
-        for (i = 0; (entry = pdcspath_entries[i]); i++)
+        for (i = 0; (entry = pdcspath_entries[i]); i++) {
+                read_lock(&entry->rw_lock);
                 if (entry->ready >= 2)
-                        kobject_unregister(&entry->kobj);       
+                        kobject_unregister(&entry->kobj);
+                read_unlock(&entry->rw_lock);
+        }
 }
 
 /*
- * For now we register the pdc subsystem with the firmware subsystem
- * and the paths subsystem with the pdc subsystem
+ * For now we register the stable subsystem with the firmware subsystem
+ * and the paths subsystem with the stable subsystem
  */
 static int __init
 pdc_stable_init(void)
@@ -707,19 +871,23 @@ pdc_stable_init(void)
         if (pdc_stable_get_size(&pdcs_size) != PDC_OK) 
                 return -ENODEV;
 
-        printk(KERN_INFO "PDC Stable Storage facility v%s\n", PDCS_VERSION);
+        /* make sure we have enough data */
+        if (pdcs_size < 96)
+                return -ENODATA;
+
+        printk(KERN_INFO PDCS_PREFIX " facility v%s\n", PDCS_VERSION);
 
-        /* For now we'll register the pdc subsys within this driver */
-        if ((rc = firmware_register(&pdc_subsys)))
+        /* For now we'll register the stable subsys within this driver */
+        if ((rc = firmware_register(&stable_subsys)))
                 goto fail_firmreg;
 
-        /* Don't forget the info entry */
+        /* Don't forget the root entries */
         for (i = 0; (attr = pdcs_subsys_attrs[i]) && !error; i++)
                 if (attr->show)
-                        error = subsys_create_file(&pdc_subsys, attr);
+                        error = subsys_create_file(&stable_subsys, attr);
         
-        /* register the paths subsys as a subsystem of pdc subsys */
-        kset_set_kset_s(&paths_subsys, pdc_subsys);
+        /* register the paths subsys as a subsystem of stable subsys */
+        kset_set_kset_s(&paths_subsys, stable_subsys);
         if ((rc= subsystem_register(&paths_subsys)))
                 goto fail_subsysreg;
 
@@ -734,10 +902,10 @@ fail_pdcsreg:
         subsystem_unregister(&paths_subsys);
         
 fail_subsysreg:
-        firmware_unregister(&pdc_subsys);
+        firmware_unregister(&stable_subsys);
         
 fail_firmreg:
-        printk(KERN_INFO "PDC Stable Storage bailing out\n");
+        printk(KERN_INFO PDCS_PREFIX " bailing out\n");
         return rc;
 }
 
@@ -747,7 +915,7 @@ pdc_stable_exit(void)
         pdcs_unregister_pathentries();
         subsystem_unregister(&paths_subsys);
 
-        firmware_unregister(&pdc_subsys);
+        firmware_unregister(&stable_subsys);
 }
 
 
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index c85653f315aa..52f265e97729 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -2064,14 +2064,13 @@ sba_driver_callback(struct parisc_device *dev)
         printk(KERN_INFO "%s found %s at 0x%lx\n",
                 MODULE_NAME, version, dev->hpa.start);
 
-        sba_dev = kmalloc(sizeof(struct sba_device), GFP_KERNEL);
+        sba_dev = kzalloc(sizeof(struct sba_device), GFP_KERNEL);
         if (!sba_dev) {
                 printk(KERN_ERR MODULE_NAME " - couldn't alloc sba_device\n");
                 return -ENOMEM;
         }
 
         parisc_set_drvdata(dev, sba_dev);
-        memset(sba_dev, 0, sizeof(struct sba_device));
 
         for(i=0; i<MAX_IOC; i++)
                 spin_lock_init(&(sba_dev->ioc[i].res_lock));
diff --git a/drivers/parisc/superio.c b/drivers/parisc/superio.c
index d14888e149bb..ba971fecd0d8 100644
--- a/drivers/parisc/superio.c
+++ b/drivers/parisc/superio.c
@@ -89,6 +89,9 @@ static struct superio_device sio_dev;
 #define DBG_INIT(x...)
 #endif
 
+#define SUPERIO "SuperIO"
+#define PFX     SUPERIO ": "
+
 static irqreturn_t
 superio_interrupt(int parent_irq, void *devp, struct pt_regs *regs)
 {
@@ -117,7 +120,7 @@ superio_interrupt(int parent_irq, void *devp, struct pt_regs *regs)
         local_irq = results & 0x0f;
 
         if (local_irq == 2 || local_irq > 7) {
-                printk(KERN_ERR "SuperIO: slave interrupted!\n");
+                printk(KERN_ERR PFX "slave interrupted!\n");
                 return IRQ_HANDLED;
         }
 
@@ -128,7 +131,7 @@ superio_interrupt(int parent_irq, void *devp, struct pt_regs *regs)
                 outb(OCW3_ISR,IC_PIC1+0);
                 results = inb(IC_PIC1+0);
                 if ((results & 0x80) == 0) { /* if ISR7 not set: spurious */
-                        printk(KERN_WARNING "SuperIO: spurious interrupt!\n");
+                        printk(KERN_WARNING PFX "spurious interrupt!\n");
                         return IRQ_HANDLED;
                 }
         }
@@ -163,27 +166,27 @@ superio_init(struct pci_dev *pcidev)
         /* ...then properly fixup the USB to point at suckyio PIC */
         sio->usb_pdev->irq = superio_fixup_irq(sio->usb_pdev);
 
-        printk(KERN_INFO "SuperIO: Found NS87560 Legacy I/O device at %s (IRQ %i) \n",
+        printk(KERN_INFO PFX "Found NS87560 Legacy I/O device at %s (IRQ %i) \n",
                pci_name(pdev), pdev->irq);
 
         pci_read_config_dword (pdev, SIO_SP1BAR, &sio->sp1_base);
         sio->sp1_base &= ~1;
-        printk (KERN_INFO "SuperIO: Serial port 1 at 0x%x\n", sio->sp1_base);
+        printk(KERN_INFO PFX "Serial port 1 at 0x%x\n", sio->sp1_base);
 
         pci_read_config_dword (pdev, SIO_SP2BAR, &sio->sp2_base);
         sio->sp2_base &= ~1;
-        printk (KERN_INFO "SuperIO: Serial port 2 at 0x%x\n", sio->sp2_base);
+        printk(KERN_INFO PFX "Serial port 2 at 0x%x\n", sio->sp2_base);
 
         pci_read_config_dword (pdev, SIO_PPBAR, &sio->pp_base);
         sio->pp_base &= ~1;
-        printk (KERN_INFO "SuperIO: Parallel port at 0x%x\n", sio->pp_base);
+        printk(KERN_INFO PFX "Parallel port at 0x%x\n", sio->pp_base);
 
         pci_read_config_dword (pdev, SIO_FDCBAR, &sio->fdc_base);
         sio->fdc_base &= ~1;
-        printk (KERN_INFO "SuperIO: Floppy controller at 0x%x\n", sio->fdc_base);
+        printk(KERN_INFO PFX "Floppy controller at 0x%x\n", sio->fdc_base);
         pci_read_config_dword (pdev, SIO_ACPIBAR, &sio->acpi_base);
         sio->acpi_base &= ~1;
-        printk (KERN_INFO "SuperIO: ACPI at 0x%x\n", sio->acpi_base);
+        printk(KERN_INFO PFX "ACPI at 0x%x\n", sio->acpi_base);
 
         request_region (IC_PIC1, 0x1f, "pic1");
         request_region (IC_PIC2, 0x1f, "pic2");
@@ -263,14 +266,14 @@ superio_init(struct pci_dev *pcidev)
         /* Setup USB power regulation */
         outb(1, sio->acpi_base + USB_REG_CR);
         if (inb(sio->acpi_base + USB_REG_CR) & 1)
-                printk(KERN_INFO "SuperIO: USB regulator enabled\n");
+                printk(KERN_INFO PFX "USB regulator enabled\n");
         else
-                printk(KERN_ERR "USB regulator not initialized!\n");
+                printk(KERN_ERR PFX "USB regulator not initialized!\n");
 
         if (request_irq(pdev->irq, superio_interrupt, SA_INTERRUPT,
-                        "SuperIO", (void *)sio)) {
+                        SUPERIO, (void *)sio)) {
 
-                printk(KERN_ERR "SuperIO: could not get irq\n");
+                printk(KERN_ERR PFX "could not get irq\n");
                 BUG();
                 return;
         }
@@ -284,7 +287,7 @@ static void superio_disable_irq(unsigned int irq)
         u8 r8;
 
         if ((irq < 1) || (irq == 2) || (irq > 7)) {
-                printk(KERN_ERR "SuperIO: Illegal irq number.\n");
+                printk(KERN_ERR PFX "Illegal irq number.\n");
                 BUG();
                 return;
         }
@@ -301,7 +304,7 @@ static void superio_enable_irq(unsigned int irq)
         u8 r8;
 
         if ((irq < 1) || (irq == 2) || (irq > 7)) {
-                printk(KERN_ERR "SuperIO: Illegal irq number (%d).\n", irq);
+                printk(KERN_ERR PFX "Illegal irq number (%d).\n", irq);
                 BUG();
                 return;
         }
@@ -319,7 +322,7 @@ static unsigned int superio_startup_irq(unsigned int irq)
 }
 
 static struct hw_interrupt_type superio_interrupt_type = {
-        .typename =     "SuperIO",
+        .typename =     SUPERIO,
         .startup =      superio_startup_irq,
         .shutdown =     superio_disable_irq,
         .enable =       superio_enable_irq,
@@ -413,7 +416,7 @@ static void __devinit superio_serial_init(void)
 
         retval = early_serial_setup(&serial[0]);
         if (retval < 0) {
-                printk(KERN_WARNING "SuperIO: Register Serial #0 failed.\n");
+                printk(KERN_WARNING PFX "Register Serial #0 failed.\n");
                 return;
         }
 
@@ -423,7 +426,7 @@ static void __devinit superio_serial_init(void)
         retval = early_serial_setup(&serial[1]);
 
         if (retval < 0)
-                printk(KERN_WARNING "SuperIO: Register Serial #1 failed.\n");
+                printk(KERN_WARNING PFX "Register Serial #1 failed.\n");
 #endif /* CONFIG_SERIAL_8250 */
 }
 
@@ -437,7 +440,7 @@ static void __devinit superio_parport_init(void)
                         PARPORT_DMA_NONE /* dma */,
                         NULL /*struct pci_dev* */) )
 
-                printk(KERN_WARNING "SuperIO: Probing parallel port failed.\n");
+                printk(KERN_WARNING PFX "Probing parallel port failed.\n");
 #endif  /* CONFIG_PARPORT_PC */
 }
 
@@ -499,7 +502,7 @@ static struct pci_device_id superio_tbl[] = {
 };
 
 static struct pci_driver superio_driver = {
-        .name =         "SuperIO",
+        .name =         SUPERIO,
         .id_table =     superio_tbl,
         .probe =        superio_probe,
 };
diff --git a/drivers/parisc/wax.c b/drivers/parisc/wax.c
index 17dce2adf7fe..813c2c24ab1e 100644
--- a/drivers/parisc/wax.c
+++ b/drivers/parisc/wax.c
@@ -76,7 +76,7 @@ wax_init_chip(struct parisc_device *dev)
         struct gsc_irq gsc_irq;
         int ret;
 
-        wax = kmalloc(sizeof(*wax), GFP_KERNEL);
+        wax = kzalloc(sizeof(*wax), GFP_KERNEL);
         if (!wax)
                 return -ENOMEM;
 
diff --git a/drivers/parport/Kconfig b/drivers/parport/Kconfig
index f605dea57224..f63c387976cf 100644
--- a/drivers/parport/Kconfig
+++ b/drivers/parport/Kconfig
@@ -90,6 +90,15 @@ config PARPORT_ARC
         depends on ARM && PARPORT
         select PARPORT_NOT_PC
 
+config PARPORT_IP32
+        tristate "SGI IP32 builtin port (EXPERIMENTAL)"
+        depends on SGI_IP32 && PARPORT && EXPERIMENTAL
+        select PARPORT_NOT_PC
+        help
+          Say Y here if you need support for the parallel port on
+          SGI O2 machines. This code is also available as a module (say M),
+          called parport_ip32.  If in doubt, saying N is the safe plan.
+
 config PARPORT_AMIGA
         tristate "Amiga builtin port"
         depends on AMIGA && PARPORT
diff --git a/drivers/parport/Makefile b/drivers/parport/Makefile
index 5372212bb9d9..a19de35f8de2 100644
--- a/drivers/parport/Makefile
+++ b/drivers/parport/Makefile
@@ -17,3 +17,4 @@ obj-$(CONFIG_PARPORT_MFC3)	+= parport_mfc3.o
 obj-$(CONFIG_PARPORT_ATARI)     += parport_atari.o
 obj-$(CONFIG_PARPORT_SUNBPP)    += parport_sunbpp.o
 obj-$(CONFIG_PARPORT_GSC)       += parport_gsc.o
+obj-$(CONFIG_PARPORT_IP32)      += parport_ip32.o
diff --git a/drivers/parport/ieee1284.c b/drivers/parport/ieee1284.c
index 5b887ba5aaf9..690b239ad3a7 100644
--- a/drivers/parport/ieee1284.c
+++ b/drivers/parport/ieee1284.c
@@ -61,10 +61,10 @@ static void timeout_waiting_on_port (unsigned long cookie)
  *      set to zero, it returns immediately.
  *
  *      If an interrupt occurs before the timeout period elapses, this
- *      function returns one immediately.  If it times out, it returns
- *      a value greater than zero.  An error code less than zero
- *      indicates an error (most likely a pending signal), and the
- *      calling code should finish what it's doing as soon as it can.
+ *      function returns zero immediately.  If it times out, it returns
+ *      one.  An error code less than zero indicates an error (most
+ *      likely a pending signal), and the calling code should finish
+ *      what it's doing as soon as it can.
  */
 
 int parport_wait_event (struct parport *port, signed long timeout)
@@ -110,7 +110,7 @@ int parport_wait_event (struct parport *port, signed long timeout)
  *
  *      If the status lines take on the desired values before the
  *      timeout period elapses, parport_poll_peripheral() returns zero
- *      immediately.  A zero return value greater than zero indicates
+ *      immediately.  A return value greater than zero indicates
  *      a timeout.  An error code (less than zero) indicates an error,
  *      most likely a signal that arrived, and the caller should
  *      finish what it is doing as soon as possible.
diff --git a/drivers/parport/parport_gsc.c b/drivers/parport/parport_gsc.c
index fde29a75f888..1de52d9febf9 100644
--- a/drivers/parport/parport_gsc.c
+++ b/drivers/parport/parport_gsc.c
@@ -249,7 +249,7 @@ struct parport *__devinit parport_gsc_probe_port (unsigned long base,
         struct parport tmp;
         struct parport *p = &tmp;
 
-        priv = kmalloc (sizeof (struct parport_gsc_private), GFP_KERNEL);
+        priv = kzalloc (sizeof (struct parport_gsc_private), GFP_KERNEL);
         if (!priv) {
                 printk (KERN_DEBUG "parport (0x%lx): no memory!\n", base);
                 return NULL;
diff --git a/drivers/parport/parport_ip32.c b/drivers/parport/parport_ip32.c
new file mode 100644
index 000000000000..46e06e596d73
--- /dev/null
+++ b/drivers/parport/parport_ip32.c
@@ -0,0 +1,2253 @@
+/* Low-level parallel port routines for built-in port on SGI IP32
+ *
+ * Author: Arnaud Giersch <arnaud.giersch@free.fr>
+ *
+ * Based on parport_pc.c by
+ *      Phil Blundell, Tim Waugh, Jose Renau, David Campbell,
+ *      Andrea Arcangeli, et al.
+ *
+ * Thanks to Ilya A. Volynets-Evenbakh for his help.
+ *
+ * Copyright (C) 2005, 2006 Arnaud Giersch.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/* Current status:
+ *
+ *      Basic SPP and PS2 modes are supported.
+ *      Support for parallel port IRQ is present.
+ *      Hardware SPP (a.k.a. compatibility), EPP, and ECP modes are
+ *      supported.
+ *      SPP/ECP FIFO can be driven in PIO or DMA mode.  PIO mode can work with
+ *      or without interrupt support.
+ *
+ *      Hardware ECP mode is not fully implemented (ecp_read_data and
+ *      ecp_write_addr are actually missing).
+ *
+ * To do:
+ *
+ *      Fully implement ECP mode.
+ *      EPP and ECP mode need to be tested.  I currently do not own any
+ *      peripheral supporting these extended mode, and cannot test them.
+ *      If DMA mode works well, decide if support for PIO FIFO modes should be
+ *      dropped.
+ *      Use the io{read,write} family functions when they become available in
+ *      the linux-mips.org tree.  Note: the MIPS specific functions readsb()
+ *      and writesb() are to be translated by ioread8_rep() and iowrite8_rep()
+ *      respectively.
+ */
+
+/* The built-in parallel port on the SGI 02 workstation (a.k.a. IP32) is an
+ * IEEE 1284 parallel port driven by a Texas Instrument TL16PIR552PH chip[1].
+ * This chip supports SPP, bidirectional, EPP and ECP modes.  It has a 16 byte
+ * FIFO buffer and supports DMA transfers.
+ *
+ * [1] http://focus.ti.com/docs/prod/folders/print/tl16pir552.html
+ *
+ * Theoretically, we could simply use the parport_pc module.  It is however
+ * not so simple.  The parport_pc code assumes that the parallel port
+ * registers are port-mapped.  On the O2, they are memory-mapped.
+ * Furthermore, each register is replicated on 256 consecutive addresses (as
+ * it is for the built-in serial ports on the same chip).
+ */
+
+/*--- Some configuration defines ---------------------------------------*/
+
+/* DEBUG_PARPORT_IP32
+ *      0       disable debug
+ *      1       standard level: pr_debug1 is enabled
+ *      2       parport_ip32_dump_state is enabled
+ *      >=3     verbose level: pr_debug is enabled
+ */
+#if !defined(DEBUG_PARPORT_IP32)
+#       define DEBUG_PARPORT_IP32  0    /* 0 (disabled) for production */
+#endif
+
+/*----------------------------------------------------------------------*/
+
+/* Setup DEBUG macros.  This is done before any includes, just in case we
+ * activate pr_debug() with DEBUG_PARPORT_IP32 >= 3.
+ */
+#if DEBUG_PARPORT_IP32 == 1
+#       warning DEBUG_PARPORT_IP32 == 1
+#elif DEBUG_PARPORT_IP32 == 2
+#       warning DEBUG_PARPORT_IP32 == 2
+#elif DEBUG_PARPORT_IP32 >= 3
+#       warning DEBUG_PARPORT_IP32 >= 3
+#       if !defined(DEBUG)
+#               define DEBUG /* enable pr_debug() in kernel.h */
+#       endif
+#endif
+
+#include <linux/completion.h>
+#include <linux/delay.h>
+#include <linux/dma-mapping.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/jiffies.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/parport.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/stddef.h>
+#include <linux/types.h>
+#include <asm/io.h>
+#include <asm/ip32/ip32_ints.h>
+#include <asm/ip32/mace.h>
+
+/*--- Global variables -------------------------------------------------*/
+
+/* Verbose probing on by default for debugging. */
+#if DEBUG_PARPORT_IP32 >= 1
+#       define DEFAULT_VERBOSE_PROBING  1
+#else
+#       define DEFAULT_VERBOSE_PROBING  0
+#endif
+
+/* Default prefix for printk */
+#define PPIP32 "parport_ip32: "
+
+/*
+ * These are the module parameters:
+ * @features:           bit mask of features to enable/disable
+ *                      (all enabled by default)
+ * @verbose_probing:    log chit-chat during initialization
+ */
+#define PARPORT_IP32_ENABLE_IRQ (1U << 0)
+#define PARPORT_IP32_ENABLE_DMA (1U << 1)
+#define PARPORT_IP32_ENABLE_SPP (1U << 2)
+#define PARPORT_IP32_ENABLE_EPP (1U << 3)
+#define PARPORT_IP32_ENABLE_ECP (1U << 4)
+static unsigned int features =  ~0U;
+static int verbose_probing =    DEFAULT_VERBOSE_PROBING;
+
+/* We do not support more than one port. */
+static struct parport *this_port = NULL;
+
+/* Timing constants for FIFO modes.  */
+#define FIFO_NFAULT_TIMEOUT     100     /* milliseconds */
+#define FIFO_POLLING_INTERVAL   50      /* microseconds */
+
+/*--- I/O register definitions -----------------------------------------*/
+
+/**
+ * struct parport_ip32_regs - virtual addresses of parallel port registers
+ * @data:       Data Register
+ * @dsr:        Device Status Register
+ * @dcr:        Device Control Register
+ * @eppAddr:    EPP Address Register
+ * @eppData0:   EPP Data Register 0
+ * @eppData1:   EPP Data Register 1
+ * @eppData2:   EPP Data Register 2
+ * @eppData3:   EPP Data Register 3
+ * @ecpAFifo:   ECP Address FIFO
+ * @fifo:       General FIFO register.  The same address is used for:
+ *              - cFifo, the Parallel Port DATA FIFO
+ *              - ecpDFifo, the ECP Data FIFO
+ *              - tFifo, the ECP Test FIFO
+ * @cnfgA:      Configuration Register A
+ * @cnfgB:      Configuration Register B
+ * @ecr:        Extended Control Register
+ */
+struct parport_ip32_regs {
+        void __iomem *data;
+        void __iomem *dsr;
+        void __iomem *dcr;
+        void __iomem *eppAddr;
+        void __iomem *eppData0;
+        void __iomem *eppData1;
+        void __iomem *eppData2;
+        void __iomem *eppData3;
+        void __iomem *ecpAFifo;
+        void __iomem *fifo;
+        void __iomem *cnfgA;
+        void __iomem *cnfgB;
+        void __iomem *ecr;
+};
+
+/* Device Status Register */
+#define DSR_nBUSY               (1U << 7)       /* PARPORT_STATUS_BUSY */
+#define DSR_nACK                (1U << 6)       /* PARPORT_STATUS_ACK */
+#define DSR_PERROR              (1U << 5)       /* PARPORT_STATUS_PAPEROUT */
+#define DSR_SELECT              (1U << 4)       /* PARPORT_STATUS_SELECT */
+#define DSR_nFAULT              (1U << 3)       /* PARPORT_STATUS_ERROR */
+#define DSR_nPRINT              (1U << 2)       /* specific to TL16PIR552 */
+/* #define DSR_reserved         (1U << 1) */
+#define DSR_TIMEOUT             (1U << 0)       /* EPP timeout */
+
+/* Device Control Register */
+/* #define DCR_reserved         (1U << 7) | (1U <<  6) */
+#define DCR_DIR                 (1U << 5)       /* direction */
+#define DCR_IRQ                 (1U << 4)       /* interrupt on nAck */
+#define DCR_SELECT              (1U << 3)       /* PARPORT_CONTROL_SELECT */
+#define DCR_nINIT               (1U << 2)       /* PARPORT_CONTROL_INIT */
+#define DCR_AUTOFD              (1U << 1)       /* PARPORT_CONTROL_AUTOFD */
+#define DCR_STROBE              (1U << 0)       /* PARPORT_CONTROL_STROBE */
+
+/* ECP Configuration Register A */
+#define CNFGA_IRQ               (1U << 7)
+#define CNFGA_ID_MASK           ((1U << 6) | (1U << 5) | (1U << 4))
+#define CNFGA_ID_SHIFT          4
+#define CNFGA_ID_16             (00U << CNFGA_ID_SHIFT)
+#define CNFGA_ID_8              (01U << CNFGA_ID_SHIFT)
+#define CNFGA_ID_32             (02U << CNFGA_ID_SHIFT)
+/* #define CNFGA_reserved       (1U << 3) */
+#define CNFGA_nBYTEINTRANS      (1U << 2)
+#define CNFGA_PWORDLEFT         ((1U << 1) | (1U << 0))
+
+/* ECP Configuration Register B */
+#define CNFGB_COMPRESS          (1U << 7)
+#define CNFGB_INTRVAL           (1U << 6)
+#define CNFGB_IRQ_MASK          ((1U << 5) | (1U << 4) | (1U << 3))
+#define CNFGB_IRQ_SHIFT         3
+#define CNFGB_DMA_MASK          ((1U << 2) | (1U << 1) | (1U << 0))
+#define CNFGB_DMA_SHIFT         0
+
+/* Extended Control Register */
+#define ECR_MODE_MASK           ((1U << 7) | (1U << 6) | (1U << 5))
+#define ECR_MODE_SHIFT          5
+#define ECR_MODE_SPP            (00U << ECR_MODE_SHIFT)
+#define ECR_MODE_PS2            (01U << ECR_MODE_SHIFT)
+#define ECR_MODE_PPF            (02U << ECR_MODE_SHIFT)
+#define ECR_MODE_ECP            (03U << ECR_MODE_SHIFT)
+#define ECR_MODE_EPP            (04U << ECR_MODE_SHIFT)
+/* #define ECR_MODE_reserved    (05U << ECR_MODE_SHIFT) */
+#define ECR_MODE_TST            (06U << ECR_MODE_SHIFT)
+#define ECR_MODE_CFG            (07U << ECR_MODE_SHIFT)
+#define ECR_nERRINTR            (1U << 4)
+#define ECR_DMAEN               (1U << 3)
+#define ECR_SERVINTR            (1U << 2)
+#define ECR_F_FULL              (1U << 1)
+#define ECR_F_EMPTY             (1U << 0)
+
+/*--- Private data -----------------------------------------------------*/
+
+/**
+ * enum parport_ip32_irq_mode - operation mode of interrupt handler
+ * @PARPORT_IP32_IRQ_FWD:       forward interrupt to the upper parport layer
+ * @PARPORT_IP32_IRQ_HERE:      interrupt is handled locally
+ */
+enum parport_ip32_irq_mode { PARPORT_IP32_IRQ_FWD, PARPORT_IP32_IRQ_HERE };
+
+/**
+ * struct parport_ip32_private - private stuff for &struct parport
+ * @regs:               register addresses
+ * @dcr_cache:          cached contents of DCR
+ * @dcr_writable:       bit mask of writable DCR bits
+ * @pword:              number of bytes per PWord
+ * @fifo_depth:         number of PWords that FIFO will hold
+ * @readIntrThreshold:  minimum number of PWords we can read
+ *                      if we get an interrupt
+ * @writeIntrThreshold: minimum number of PWords we can write
+ *                      if we get an interrupt
+ * @irq_mode:           operation mode of interrupt handler for this port
+ * @irq_complete:       mutex used to wait for an interrupt to occur
+ */
+struct parport_ip32_private {
+        struct parport_ip32_regs        regs;
+        unsigned int                    dcr_cache;
+        unsigned int                    dcr_writable;
+        unsigned int                    pword;
+        unsigned int                    fifo_depth;
+        unsigned int                    readIntrThreshold;
+        unsigned int                    writeIntrThreshold;
+        enum parport_ip32_irq_mode      irq_mode;
+        struct completion               irq_complete;
+};
+
+/*--- Debug code -------------------------------------------------------*/
+
+/*
+ * pr_debug1 - print debug messages
+ *
+ * This is like pr_debug(), but is defined for %DEBUG_PARPORT_IP32 >= 1
+ */
+#if DEBUG_PARPORT_IP32 >= 1
+#       define pr_debug1(...)   printk(KERN_DEBUG __VA_ARGS__)
+#else /* DEBUG_PARPORT_IP32 < 1 */
+#       define pr_debug1(...)   do { } while (0)
+#endif
+
+/*
+ * pr_trace, pr_trace1 - trace function calls
+ * @p:          pointer to &struct parport
+ * @fmt:        printk format string
+ * @...:        parameters for format string
+ *
+ * Macros used to trace function calls.  The given string is formatted after
+ * function name.  pr_trace() uses pr_debug(), and pr_trace1() uses
+ * pr_debug1().  __pr_trace() is the low-level macro and is not to be used
+ * directly.
+ */
+#define __pr_trace(pr, p, fmt, ...)                                     \
+        pr("%s: %s" fmt "\n",                                           \
+           ({ const struct parport *__p = (p);                          \
+                   __p ? __p->name : "parport_ip32"; }),                \
+           __func__ , ##__VA_ARGS__)
+#define pr_trace(p, fmt, ...)   __pr_trace(pr_debug, p, fmt , ##__VA_ARGS__)
+#define pr_trace1(p, fmt, ...)  __pr_trace(pr_debug1, p, fmt , ##__VA_ARGS__)
+
+/*
+ * __pr_probe, pr_probe - print message if @verbose_probing is true
+ * @p:          pointer to &struct parport
+ * @fmt:        printk format string
+ * @...:        parameters for format string
+ *
+ * For new lines, use pr_probe().  Use __pr_probe() for continued lines.
+ */
+#define __pr_probe(...)                                                 \
+        do { if (verbose_probing) printk(__VA_ARGS__); } while (0)
+#define pr_probe(p, fmt, ...)                                           \
+        __pr_probe(KERN_INFO PPIP32 "0x%lx: " fmt, (p)->base , ##__VA_ARGS__)
+
+/*
+ * parport_ip32_dump_state - print register status of parport
+ * @p:          pointer to &struct parport
+ * @str:        string to add in message
+ * @show_ecp_config:    shall we dump ECP configuration registers too?
+ *
+ * This function is only here for debugging purpose, and should be used with
+ * care.  Reading the parallel port registers may have undesired side effects.
+ * Especially if @show_ecp_config is true, the parallel port is resetted.
+ * This function is only defined if %DEBUG_PARPORT_IP32 >= 2.
+ */
+#if DEBUG_PARPORT_IP32 >= 2
+static void parport_ip32_dump_state(struct parport *p, char *str,
+                                    unsigned int show_ecp_config)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        unsigned int i;
+
+        printk(KERN_DEBUG PPIP32 "%s: state (%s):\n", p->name, str);
+        {
+                static const char ecr_modes[8][4] = {"SPP", "PS2", "PPF",
+                                                     "ECP", "EPP", "???",
+                                                     "TST", "CFG"};
+                unsigned int ecr = readb(priv->regs.ecr);
+                printk(KERN_DEBUG PPIP32 "    ecr=0x%02x", ecr);
+                printk(" %s",
+                       ecr_modes[(ecr & ECR_MODE_MASK) >> ECR_MODE_SHIFT]);
+                if (ecr & ECR_nERRINTR)
+                        printk(",nErrIntrEn");
+                if (ecr & ECR_DMAEN)
+                        printk(",dmaEn");
+                if (ecr & ECR_SERVINTR)
+                        printk(",serviceIntr");
+                if (ecr & ECR_F_FULL)
+                        printk(",f_full");
+                if (ecr & ECR_F_EMPTY)
+                        printk(",f_empty");
+                printk("\n");
+        }
+        if (show_ecp_config) {
+                unsigned int oecr, cnfgA, cnfgB;
+                oecr = readb(priv->regs.ecr);
+                writeb(ECR_MODE_PS2, priv->regs.ecr);
+                writeb(ECR_MODE_CFG, priv->regs.ecr);
+                cnfgA = readb(priv->regs.cnfgA);
+                cnfgB = readb(priv->regs.cnfgB);
+                writeb(ECR_MODE_PS2, priv->regs.ecr);
+                writeb(oecr, priv->regs.ecr);
+                printk(KERN_DEBUG PPIP32 "    cnfgA=0x%02x", cnfgA);
+                printk(" ISA-%s", (cnfgA & CNFGA_IRQ) ? "Level" : "Pulses");
+                switch (cnfgA & CNFGA_ID_MASK) {
+                case CNFGA_ID_8:
+                        printk(",8 bits");
+                        break;
+                case CNFGA_ID_16:
+                        printk(",16 bits");
+                        break;
+                case CNFGA_ID_32:
+                        printk(",32 bits");
+                        break;
+                default:
+                        printk(",unknown ID");
+                        break;
+                }
+                if (!(cnfgA & CNFGA_nBYTEINTRANS))
+                        printk(",ByteInTrans");
+                if ((cnfgA & CNFGA_ID_MASK) != CNFGA_ID_8)
+                        printk(",%d byte%s left", cnfgA & CNFGA_PWORDLEFT,
+                               ((cnfgA & CNFGA_PWORDLEFT) > 1) ? "s" : "");
+                printk("\n");
+                printk(KERN_DEBUG PPIP32 "    cnfgB=0x%02x", cnfgB);
+                printk(" irq=%u,dma=%u",
+                       (cnfgB & CNFGB_IRQ_MASK) >> CNFGB_IRQ_SHIFT,
+                       (cnfgB & CNFGB_DMA_MASK) >> CNFGB_DMA_SHIFT);
+                printk(",intrValue=%d", !!(cnfgB & CNFGB_INTRVAL));
+                if (cnfgB & CNFGB_COMPRESS)
+                        printk(",compress");
+                printk("\n");
+        }
+        for (i = 0; i < 2; i++) {
+                unsigned int dcr = i ? priv->dcr_cache : readb(priv->regs.dcr);
+                printk(KERN_DEBUG PPIP32 "    dcr(%s)=0x%02x",
+                       i ? "soft" : "hard", dcr);
+                printk(" %s", (dcr & DCR_DIR) ? "rev" : "fwd");
+                if (dcr & DCR_IRQ)
+                        printk(",ackIntEn");
+                if (!(dcr & DCR_SELECT))
+                        printk(",nSelectIn");
+                if (dcr & DCR_nINIT)
+                        printk(",nInit");
+                if (!(dcr & DCR_AUTOFD))
+                        printk(",nAutoFD");
+                if (!(dcr & DCR_STROBE))
+                        printk(",nStrobe");
+                printk("\n");
+        }
+#define sep (f++ ? ',' : ' ')
+        {
+                unsigned int f = 0;
+                unsigned int dsr = readb(priv->regs.dsr);
+                printk(KERN_DEBUG PPIP32 "    dsr=0x%02x", dsr);
+                if (!(dsr & DSR_nBUSY))
+                        printk("%cBusy", sep);
+                if (dsr & DSR_nACK)
+                        printk("%cnAck", sep);
+                if (dsr & DSR_PERROR)
+                        printk("%cPError", sep);
+                if (dsr & DSR_SELECT)
+                        printk("%cSelect", sep);
+                if (dsr & DSR_nFAULT)
+                        printk("%cnFault", sep);
+                if (!(dsr & DSR_nPRINT))
+                        printk("%c(Print)", sep);
+                if (dsr & DSR_TIMEOUT)
+                        printk("%cTimeout", sep);
+                printk("\n");
+        }
+#undef sep
+}
+#else /* DEBUG_PARPORT_IP32 < 2 */
+#define parport_ip32_dump_state(...)    do { } while (0)
+#endif
+
+/*
+ * CHECK_EXTRA_BITS - track and log extra bits
+ * @p:          pointer to &struct parport
+ * @b:          byte to inspect
+ * @m:          bit mask of authorized bits
+ *
+ * This is used to track and log extra bits that should not be there in
+ * parport_ip32_write_control() and parport_ip32_frob_control().  It is only
+ * defined if %DEBUG_PARPORT_IP32 >= 1.
+ */
+#if DEBUG_PARPORT_IP32 >= 1
+#define CHECK_EXTRA_BITS(p, b, m)                                       \
+        do {                                                            \
+                unsigned int __b = (b), __m = (m);                      \
+                if (__b & ~__m)                                         \
+                        pr_debug1(PPIP32 "%s: extra bits in %s(%s): "   \
+                                  "0x%02x/0x%02x\n",                    \
+                                  (p)->name, __func__, #b, __b, __m);   \
+        } while (0)
+#else /* DEBUG_PARPORT_IP32 < 1 */
+#define CHECK_EXTRA_BITS(...)   do { } while (0)
+#endif
+
+/*--- IP32 parallel port DMA operations --------------------------------*/
+
+/**
+ * struct parport_ip32_dma_data - private data needed for DMA operation
+ * @dir:        DMA direction (from or to device)
+ * @buf:        buffer physical address
+ * @len:        buffer length
+ * @next:       address of next bytes to DMA transfer
+ * @left:       number of bytes remaining
+ * @ctx:        next context to write (0: context_a; 1: context_b)
+ * @irq_on:     are the DMA IRQs currently enabled?
+ * @lock:       spinlock to protect access to the structure
+ */
+struct parport_ip32_dma_data {
+        enum dma_data_direction         dir;
+        dma_addr_t                      buf;
+        dma_addr_t                      next;
+        size_t                          len;
+        size_t                          left;
+        unsigned int                    ctx;
+        unsigned int                    irq_on;
+        spinlock_t                      lock;
+};
+static struct parport_ip32_dma_data parport_ip32_dma;
+
+/**
+ * parport_ip32_dma_setup_context - setup next DMA context
+ * @limit:      maximum data size for the context
+ *
+ * The alignment constraints must be verified in caller function, and the
+ * parameter @limit must be set accordingly.
+ */
+static void parport_ip32_dma_setup_context(unsigned int limit)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&parport_ip32_dma.lock, flags);
+        if (parport_ip32_dma.left > 0) {
+                /* Note: ctxreg is "volatile" here only because
+                 * mace->perif.ctrl.parport.context_a and context_b are
+                 * "volatile".  */
+                volatile u64 __iomem *ctxreg = (parport_ip32_dma.ctx == 0) ?
+                        &mace->perif.ctrl.parport.context_a :
+                        &mace->perif.ctrl.parport.context_b;
+                u64 count;
+                u64 ctxval;
+                if (parport_ip32_dma.left <= limit) {
+                        count = parport_ip32_dma.left;
+                        ctxval = MACEPAR_CONTEXT_LASTFLAG;
+                } else {
+                        count = limit;
+                        ctxval = 0;
+                }
+
+                pr_trace(NULL,
+                         "(%u): 0x%04x:0x%04x, %u -> %u%s",
+                         limit,
+                         (unsigned int)parport_ip32_dma.buf,
+                         (unsigned int)parport_ip32_dma.next,
+                         (unsigned int)count,
+                         parport_ip32_dma.ctx, ctxval ? "*" : "");
+
+                ctxval |= parport_ip32_dma.next &
+                        MACEPAR_CONTEXT_BASEADDR_MASK;
+                ctxval |= ((count - 1) << MACEPAR_CONTEXT_DATALEN_SHIFT) &
+                        MACEPAR_CONTEXT_DATALEN_MASK;
+                writeq(ctxval, ctxreg);
+                parport_ip32_dma.next += count;
+                parport_ip32_dma.left -= count;
+                parport_ip32_dma.ctx ^= 1U;
+        }
+        /* If there is nothing more to send, disable IRQs to avoid to
+         * face an IRQ storm which can lock the machine.  Disable them
+         * only once. */
+        if (parport_ip32_dma.left == 0 && parport_ip32_dma.irq_on) {
+                pr_debug(PPIP32 "IRQ off (ctx)\n");
+                disable_irq_nosync(MACEISA_PAR_CTXA_IRQ);
+                disable_irq_nosync(MACEISA_PAR_CTXB_IRQ);
+                parport_ip32_dma.irq_on = 0;
+        }
+        spin_unlock_irqrestore(&parport_ip32_dma.lock, flags);
+}
+
+/**
+ * parport_ip32_dma_interrupt - DMA interrupt handler
+ * @irq:        interrupt number
+ * @dev_id:     unused
+ * @regs:       pointer to &struct pt_regs
+ */
+static irqreturn_t parport_ip32_dma_interrupt(int irq, void *dev_id,
+                                              struct pt_regs *regs)
+{
+        if (parport_ip32_dma.left)
+                pr_trace(NULL, "(%d): ctx=%d", irq, parport_ip32_dma.ctx);
+        parport_ip32_dma_setup_context(MACEPAR_CONTEXT_DATA_BOUND);
+        return IRQ_HANDLED;
+}
+
+#if DEBUG_PARPORT_IP32
+static irqreturn_t parport_ip32_merr_interrupt(int irq, void *dev_id,
+                                               struct pt_regs *regs)
+{
+        pr_trace1(NULL, "(%d)", irq);
+        return IRQ_HANDLED;
+}
+#endif
+
+/**
+ * parport_ip32_dma_start - begins a DMA transfer
+ * @dir:        DMA direction: DMA_TO_DEVICE or DMA_FROM_DEVICE
+ * @addr:       pointer to data buffer
+ * @count:      buffer size
+ *
+ * Calls to parport_ip32_dma_start() and parport_ip32_dma_stop() must be
+ * correctly balanced.
+ */
+static int parport_ip32_dma_start(enum dma_data_direction dir,
+                                  void *addr, size_t count)
+{
+        unsigned int limit;
+        u64 ctrl;
+
+        pr_trace(NULL, "(%d, %lu)", dir, (unsigned long)count);
+
+        /* FIXME - add support for DMA_FROM_DEVICE.  In this case, buffer must
+         * be 64 bytes aligned. */
+        BUG_ON(dir != DMA_TO_DEVICE);
+
+        /* Reset DMA controller */
+        ctrl = MACEPAR_CTLSTAT_RESET;
+        writeq(ctrl, &mace->perif.ctrl.parport.cntlstat);
+
+        /* DMA IRQs should normally be enabled */
+        if (!parport_ip32_dma.irq_on) {
+                WARN_ON(1);
+                enable_irq(MACEISA_PAR_CTXA_IRQ);
+                enable_irq(MACEISA_PAR_CTXB_IRQ);
+                parport_ip32_dma.irq_on = 1;
+        }
+
+        /* Prepare DMA pointers */
+        parport_ip32_dma.dir = dir;
+        parport_ip32_dma.buf = dma_map_single(NULL, addr, count, dir);
+        parport_ip32_dma.len = count;
+        parport_ip32_dma.next = parport_ip32_dma.buf;
+        parport_ip32_dma.left = parport_ip32_dma.len;
+        parport_ip32_dma.ctx = 0;
+
+        /* Setup DMA direction and first two contexts */
+        ctrl = (dir == DMA_TO_DEVICE) ? 0 : MACEPAR_CTLSTAT_DIRECTION;
+        writeq(ctrl, &mace->perif.ctrl.parport.cntlstat);
+        /* Single transfer should not cross a 4K page boundary */
+        limit = MACEPAR_CONTEXT_DATA_BOUND -
+                (parport_ip32_dma.next & (MACEPAR_CONTEXT_DATA_BOUND - 1));
+        parport_ip32_dma_setup_context(limit);
+        parport_ip32_dma_setup_context(MACEPAR_CONTEXT_DATA_BOUND);
+
+        /* Real start of DMA transfer */
+        ctrl |= MACEPAR_CTLSTAT_ENABLE;
+        writeq(ctrl, &mace->perif.ctrl.parport.cntlstat);
+
+        return 0;
+}
+
+/**
+ * parport_ip32_dma_stop - ends a running DMA transfer
+ *
+ * Calls to parport_ip32_dma_start() and parport_ip32_dma_stop() must be
+ * correctly balanced.
+ */
+static void parport_ip32_dma_stop(void)
+{
+        u64 ctx_a;
+        u64 ctx_b;
+        u64 ctrl;
+        u64 diag;
+        size_t res[2];  /* {[0] = res_a, [1] = res_b} */
+
+        pr_trace(NULL, "()");
+
+        /* Disable IRQs */
+        spin_lock_irq(&parport_ip32_dma.lock);
+        if (parport_ip32_dma.irq_on) {
+                pr_debug(PPIP32 "IRQ off (stop)\n");
+                disable_irq_nosync(MACEISA_PAR_CTXA_IRQ);
+                disable_irq_nosync(MACEISA_PAR_CTXB_IRQ);
+                parport_ip32_dma.irq_on = 0;
+        }
+        spin_unlock_irq(&parport_ip32_dma.lock);
+        /* Force IRQ synchronization, even if the IRQs were disabled
+         * elsewhere. */
+        synchronize_irq(MACEISA_PAR_CTXA_IRQ);
+        synchronize_irq(MACEISA_PAR_CTXB_IRQ);
+
+        /* Stop DMA transfer */
+        ctrl = readq(&mace->perif.ctrl.parport.cntlstat);
+        ctrl &= ~MACEPAR_CTLSTAT_ENABLE;
+        writeq(ctrl, &mace->perif.ctrl.parport.cntlstat);
+
+        /* Adjust residue (parport_ip32_dma.left) */
+        ctx_a = readq(&mace->perif.ctrl.parport.context_a);
+        ctx_b = readq(&mace->perif.ctrl.parport.context_b);
+        ctrl = readq(&mace->perif.ctrl.parport.cntlstat);
+        diag = readq(&mace->perif.ctrl.parport.diagnostic);
+        res[0] = (ctrl & MACEPAR_CTLSTAT_CTXA_VALID) ?
+                1 + ((ctx_a & MACEPAR_CONTEXT_DATALEN_MASK) >>
+                     MACEPAR_CONTEXT_DATALEN_SHIFT) :
+                0;
+        res[1] = (ctrl & MACEPAR_CTLSTAT_CTXB_VALID) ?
+                1 + ((ctx_b & MACEPAR_CONTEXT_DATALEN_MASK) >>
+                     MACEPAR_CONTEXT_DATALEN_SHIFT) :
+                0;
+        if (diag & MACEPAR_DIAG_DMACTIVE)
+                res[(diag & MACEPAR_DIAG_CTXINUSE) != 0] =
+                        1 + ((diag & MACEPAR_DIAG_CTRMASK) >>
+                             MACEPAR_DIAG_CTRSHIFT);
+        parport_ip32_dma.left += res[0] + res[1];
+
+        /* Reset DMA controller, and re-enable IRQs */
+        ctrl = MACEPAR_CTLSTAT_RESET;
+        writeq(ctrl, &mace->perif.ctrl.parport.cntlstat);
+        pr_debug(PPIP32 "IRQ on (stop)\n");
+        enable_irq(MACEISA_PAR_CTXA_IRQ);
+        enable_irq(MACEISA_PAR_CTXB_IRQ);
+        parport_ip32_dma.irq_on = 1;
+
+        dma_unmap_single(NULL, parport_ip32_dma.buf, parport_ip32_dma.len,
+                         parport_ip32_dma.dir);
+}
+
+/**
+ * parport_ip32_dma_get_residue - get residue from last DMA transfer
+ *
+ * Returns the number of bytes remaining from last DMA transfer.
+ */
+static inline size_t parport_ip32_dma_get_residue(void)
+{
+        return parport_ip32_dma.left;
+}
+
+/**
+ * parport_ip32_dma_register - initialize DMA engine
+ *
+ * Returns zero for success.
+ */
+static int parport_ip32_dma_register(void)
+{
+        int err;
+
+        spin_lock_init(&parport_ip32_dma.lock);
+        parport_ip32_dma.irq_on = 1;
+
+        /* Reset DMA controller */
+        writeq(MACEPAR_CTLSTAT_RESET, &mace->perif.ctrl.parport.cntlstat);
+
+        /* Request IRQs */
+        err = request_irq(MACEISA_PAR_CTXA_IRQ, parport_ip32_dma_interrupt,
+                          0, "parport_ip32", NULL);
+        if (err)
+                goto fail_a;
+        err = request_irq(MACEISA_PAR_CTXB_IRQ, parport_ip32_dma_interrupt,
+                          0, "parport_ip32", NULL);
+        if (err)
+                goto fail_b;
+#if DEBUG_PARPORT_IP32
+        /* FIXME - what is this IRQ for? */
+        err = request_irq(MACEISA_PAR_MERR_IRQ, parport_ip32_merr_interrupt,
+                          0, "parport_ip32", NULL);
+        if (err)
+                goto fail_merr;
+#endif
+        return 0;
+
+#if DEBUG_PARPORT_IP32
+fail_merr:
+        free_irq(MACEISA_PAR_CTXB_IRQ, NULL);
+#endif
+fail_b:
+        free_irq(MACEISA_PAR_CTXA_IRQ, NULL);
+fail_a:
+        return err;
+}
+
+/**
+ * parport_ip32_dma_unregister - release and free resources for DMA engine
+ */
+static void parport_ip32_dma_unregister(void)
+{
+#if DEBUG_PARPORT_IP32
+        free_irq(MACEISA_PAR_MERR_IRQ, NULL);
+#endif
+        free_irq(MACEISA_PAR_CTXB_IRQ, NULL);
+        free_irq(MACEISA_PAR_CTXA_IRQ, NULL);
+}
+
+/*--- Interrupt handlers and associates --------------------------------*/
+
+/**
+ * parport_ip32_wakeup - wakes up code waiting for an interrupt
+ * @p:          pointer to &struct parport
+ */
+static inline void parport_ip32_wakeup(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        complete(&priv->irq_complete);
+}
+
+/**
+ * parport_ip32_interrupt - interrupt handler
+ * @irq:        interrupt number
+ * @dev_id:     pointer to &struct parport
+ * @regs:       pointer to &struct pt_regs
+ *
+ * Caught interrupts are forwarded to the upper parport layer if IRQ_mode is
+ * %PARPORT_IP32_IRQ_FWD.
+ */
+static irqreturn_t parport_ip32_interrupt(int irq, void *dev_id,
+                                          struct pt_regs *regs)
+{
+        struct parport * const p = dev_id;
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        enum parport_ip32_irq_mode irq_mode = priv->irq_mode;
+        switch (irq_mode) {
+        case PARPORT_IP32_IRQ_FWD:
+                parport_generic_irq(irq, p, regs);
+                break;
+        case PARPORT_IP32_IRQ_HERE:
+                parport_ip32_wakeup(p);
+                break;
+        }
+        return IRQ_HANDLED;
+}
+
+/*--- Some utility function to manipulate ECR register -----------------*/
+
+/**
+ * parport_ip32_read_econtrol - read contents of the ECR register
+ * @p:          pointer to &struct parport
+ */
+static inline unsigned int parport_ip32_read_econtrol(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return readb(priv->regs.ecr);
+}
+
+/**
+ * parport_ip32_write_econtrol - write new contents to the ECR register
+ * @p:          pointer to &struct parport
+ * @c:          new value to write
+ */
+static inline void parport_ip32_write_econtrol(struct parport *p,
+                                               unsigned int c)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        writeb(c, priv->regs.ecr);
+}
+
+/**
+ * parport_ip32_frob_econtrol - change bits from the ECR register
+ * @p:          pointer to &struct parport
+ * @mask:       bit mask of bits to change
+ * @val:        new value for changed bits
+ *
+ * Read from the ECR, mask out the bits in @mask, exclusive-or with the bits
+ * in @val, and write the result to the ECR.
+ */
+static inline void parport_ip32_frob_econtrol(struct parport *p,
+                                              unsigned int mask,
+                                              unsigned int val)
+{
+        unsigned int c;
+        c = (parport_ip32_read_econtrol(p) & ~mask) ^ val;
+        parport_ip32_write_econtrol(p, c);
+}
+
+/**
+ * parport_ip32_set_mode - change mode of ECP port
+ * @p:          pointer to &struct parport
+ * @mode:       new mode to write in ECR
+ *
+ * ECR is reset in a sane state (interrupts and DMA disabled), and placed in
+ * mode @mode.  Go through PS2 mode if needed.
+ */
+static void parport_ip32_set_mode(struct parport *p, unsigned int mode)
+{
+        unsigned int omode;
+
+        mode &= ECR_MODE_MASK;
+        omode = parport_ip32_read_econtrol(p) & ECR_MODE_MASK;
+
+        if (!(mode == ECR_MODE_SPP || mode == ECR_MODE_PS2
+              || omode == ECR_MODE_SPP || omode == ECR_MODE_PS2)) {
+                /* We have to go through PS2 mode */
+                unsigned int ecr = ECR_MODE_PS2 | ECR_nERRINTR | ECR_SERVINTR;
+                parport_ip32_write_econtrol(p, ecr);
+        }
+        parport_ip32_write_econtrol(p, mode | ECR_nERRINTR | ECR_SERVINTR);
+}
+
+/*--- Basic functions needed for parport -------------------------------*/
+
+/**
+ * parport_ip32_read_data - return current contents of the DATA register
+ * @p:          pointer to &struct parport
+ */
+static inline unsigned char parport_ip32_read_data(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return readb(priv->regs.data);
+}
+
+/**
+ * parport_ip32_write_data - set new contents for the DATA register
+ * @p:          pointer to &struct parport
+ * @d:          new value to write
+ */
+static inline void parport_ip32_write_data(struct parport *p, unsigned char d)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        writeb(d, priv->regs.data);
+}
+
+/**
+ * parport_ip32_read_status - return current contents of the DSR register
+ * @p:          pointer to &struct parport
+ */
+static inline unsigned char parport_ip32_read_status(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return readb(priv->regs.dsr);
+}
+
+/**
+ * __parport_ip32_read_control - return cached contents of the DCR register
+ * @p:          pointer to &struct parport
+ */
+static inline unsigned int __parport_ip32_read_control(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return priv->dcr_cache; /* use soft copy */
+}
+
+/**
+ * __parport_ip32_write_control - set new contents for the DCR register
+ * @p:          pointer to &struct parport
+ * @c:          new value to write
+ */
+static inline void __parport_ip32_write_control(struct parport *p,
+                                                unsigned int c)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        CHECK_EXTRA_BITS(p, c, priv->dcr_writable);
+        c &= priv->dcr_writable; /* only writable bits */
+        writeb(c, priv->regs.dcr);
+        priv->dcr_cache = c;            /* update soft copy */
+}
+
+/**
+ * __parport_ip32_frob_control - change bits from the DCR register
+ * @p:          pointer to &struct parport
+ * @mask:       bit mask of bits to change
+ * @val:        new value for changed bits
+ *
+ * This is equivalent to read from the DCR, mask out the bits in @mask,
+ * exclusive-or with the bits in @val, and write the result to the DCR.
+ * Actually, the cached contents of the DCR is used.
+ */
+static inline void __parport_ip32_frob_control(struct parport *p,
+                                               unsigned int mask,
+                                               unsigned int val)
+{
+        unsigned int c;
+        c = (__parport_ip32_read_control(p) & ~mask) ^ val;
+        __parport_ip32_write_control(p, c);
+}
+
+/**
+ * parport_ip32_read_control - return cached contents of the DCR register
+ * @p:          pointer to &struct parport
+ *
+ * The return value is masked so as to only return the value of %DCR_STROBE,
+ * %DCR_AUTOFD, %DCR_nINIT, and %DCR_SELECT.
+ */
+static inline unsigned char parport_ip32_read_control(struct parport *p)
+{
+        const unsigned int rm =
+                DCR_STROBE | DCR_AUTOFD | DCR_nINIT | DCR_SELECT;
+        return __parport_ip32_read_control(p) & rm;
+}
+
+/**
+ * parport_ip32_write_control - set new contents for the DCR register
+ * @p:          pointer to &struct parport
+ * @c:          new value to write
+ *
+ * The value is masked so as to only change the value of %DCR_STROBE,
+ * %DCR_AUTOFD, %DCR_nINIT, and %DCR_SELECT.
+ */
+static inline void parport_ip32_write_control(struct parport *p,
+                                              unsigned char c)
+{
+        const unsigned int wm =
+                DCR_STROBE | DCR_AUTOFD | DCR_nINIT | DCR_SELECT;
+        CHECK_EXTRA_BITS(p, c, wm);
+        __parport_ip32_frob_control(p, wm, c & wm);
+}
+
+/**
+ * parport_ip32_frob_control - change bits from the DCR register
+ * @p:          pointer to &struct parport
+ * @mask:       bit mask of bits to change
+ * @val:        new value for changed bits
+ *
+ * This differs from __parport_ip32_frob_control() in that it only allows to
+ * change the value of %DCR_STROBE, %DCR_AUTOFD, %DCR_nINIT, and %DCR_SELECT.
+ */
+static inline unsigned char parport_ip32_frob_control(struct parport *p,
+                                                      unsigned char mask,
+                                                      unsigned char val)
+{
+        const unsigned int wm =
+                DCR_STROBE | DCR_AUTOFD | DCR_nINIT | DCR_SELECT;
+        CHECK_EXTRA_BITS(p, mask, wm);
+        CHECK_EXTRA_BITS(p, val, wm);
+        __parport_ip32_frob_control(p, mask & wm, val & wm);
+        return parport_ip32_read_control(p);
+}
+
+/**
+ * parport_ip32_disable_irq - disable interrupts on the rising edge of nACK
+ * @p:          pointer to &struct parport
+ */
+static inline void parport_ip32_disable_irq(struct parport *p)
+{
+        __parport_ip32_frob_control(p, DCR_IRQ, 0);
+}
+
+/**
+ * parport_ip32_enable_irq - enable interrupts on the rising edge of nACK
+ * @p:          pointer to &struct parport
+ */
+static inline void parport_ip32_enable_irq(struct parport *p)
+{
+        __parport_ip32_frob_control(p, DCR_IRQ, DCR_IRQ);
+}
+
+/**
+ * parport_ip32_data_forward - enable host-to-peripheral communications
+ * @p:          pointer to &struct parport
+ *
+ * Enable the data line drivers, for 8-bit host-to-peripheral communications.
+ */
+static inline void parport_ip32_data_forward(struct parport *p)
+{
+        __parport_ip32_frob_control(p, DCR_DIR, 0);
+}
+
+/**
+ * parport_ip32_data_reverse - enable peripheral-to-host communications
+ * @p:          pointer to &struct parport
+ *
+ * Place the data bus in a high impedance state, if @p->modes has the
+ * PARPORT_MODE_TRISTATE bit set.
+ */
+static inline void parport_ip32_data_reverse(struct parport *p)
+{
+        __parport_ip32_frob_control(p, DCR_DIR, DCR_DIR);
+}
+
+/**
+ * parport_ip32_init_state - for core parport code
+ * @dev:        pointer to &struct pardevice
+ * @s:          pointer to &struct parport_state to initialize
+ */
+static void parport_ip32_init_state(struct pardevice *dev,
+                                    struct parport_state *s)
+{
+        s->u.ip32.dcr = DCR_SELECT | DCR_nINIT;
+        s->u.ip32.ecr = ECR_MODE_PS2 | ECR_nERRINTR | ECR_SERVINTR;
+}
+
+/**
+ * parport_ip32_save_state - for core parport code
+ * @p:          pointer to &struct parport
+ * @s:          pointer to &struct parport_state to save state to
+ */
+static void parport_ip32_save_state(struct parport *p,
+                                    struct parport_state *s)
+{
+        s->u.ip32.dcr = __parport_ip32_read_control(p);
+        s->u.ip32.ecr = parport_ip32_read_econtrol(p);
+}
+
+/**
+ * parport_ip32_restore_state - for core parport code
+ * @p:          pointer to &struct parport
+ * @s:          pointer to &struct parport_state to restore state from
+ */
+static void parport_ip32_restore_state(struct parport *p,
+                                       struct parport_state *s)
+{
+        parport_ip32_set_mode(p, s->u.ip32.ecr & ECR_MODE_MASK);
+        parport_ip32_write_econtrol(p, s->u.ip32.ecr);
+        __parport_ip32_write_control(p, s->u.ip32.dcr);
+}
+
+/*--- EPP mode functions -----------------------------------------------*/
+
+/**
+ * parport_ip32_clear_epp_timeout - clear Timeout bit in EPP mode
+ * @p:          pointer to &struct parport
+ *
+ * Returns 1 if the Timeout bit is clear, and 0 otherwise.
+ */
+static unsigned int parport_ip32_clear_epp_timeout(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        unsigned int cleared;
+
+        if (!(parport_ip32_read_status(p) & DSR_TIMEOUT))
+                cleared = 1;
+        else {
+                unsigned int r;
+                /* To clear timeout some chips require double read */
+                parport_ip32_read_status(p);
+                r = parport_ip32_read_status(p);
+                /* Some reset by writing 1 */
+                writeb(r | DSR_TIMEOUT, priv->regs.dsr);
+                /* Others by writing 0 */
+                writeb(r & ~DSR_TIMEOUT, priv->regs.dsr);
+
+                r = parport_ip32_read_status(p);
+                cleared = !(r & DSR_TIMEOUT);
+        }
+
+        pr_trace(p, "(): %s", cleared ? "cleared" : "failed");
+        return cleared;
+}
+
+/**
+ * parport_ip32_epp_read - generic EPP read function
+ * @eppreg:     I/O register to read from
+ * @p:          pointer to &struct parport
+ * @buf:        buffer to store read data
+ * @len:        length of buffer @buf
+ * @flags:      may be PARPORT_EPP_FAST
+ */
+static size_t parport_ip32_epp_read(void __iomem *eppreg,
+                                    struct parport *p, void *buf,
+                                    size_t len, int flags)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        size_t got;
+        parport_ip32_set_mode(p, ECR_MODE_EPP);
+        parport_ip32_data_reverse(p);
+        parport_ip32_write_control(p, DCR_nINIT);
+        if ((flags & PARPORT_EPP_FAST) && (len > 1)) {
+                readsb(eppreg, buf, len);
+                if (readb(priv->regs.dsr) & DSR_TIMEOUT) {
+                        parport_ip32_clear_epp_timeout(p);
+                        return -EIO;
+                }
+                got = len;
+        } else {
+                u8 *bufp = buf;
+                for (got = 0; got < len; got++) {
+                        *bufp++ = readb(eppreg);
+                        if (readb(priv->regs.dsr) & DSR_TIMEOUT) {
+                                parport_ip32_clear_epp_timeout(p);
+                                break;
+                        }
+                }
+        }
+        parport_ip32_data_forward(p);
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        return got;
+}
+
+/**
+ * parport_ip32_epp_write - generic EPP write function
+ * @eppreg:     I/O register to write to
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ * @flags:      may be PARPORT_EPP_FAST
+ */
+static size_t parport_ip32_epp_write(void __iomem *eppreg,
+                                     struct parport *p, const void *buf,
+                                     size_t len, int flags)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        size_t written;
+        parport_ip32_set_mode(p, ECR_MODE_EPP);
+        parport_ip32_data_forward(p);
+        parport_ip32_write_control(p, DCR_nINIT);
+        if ((flags & PARPORT_EPP_FAST) && (len > 1)) {
+                writesb(eppreg, buf, len);
+                if (readb(priv->regs.dsr) & DSR_TIMEOUT) {
+                        parport_ip32_clear_epp_timeout(p);
+                        return -EIO;
+                }
+                written = len;
+        } else {
+                const u8 *bufp = buf;
+                for (written = 0; written < len; written++) {
+                        writeb(*bufp++, eppreg);
+                        if (readb(priv->regs.dsr) & DSR_TIMEOUT) {
+                                parport_ip32_clear_epp_timeout(p);
+                                break;
+                        }
+                }
+        }
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        return written;
+}
+
+/**
+ * parport_ip32_epp_read_data - read a block of data in EPP mode
+ * @p:          pointer to &struct parport
+ * @buf:        buffer to store read data
+ * @len:        length of buffer @buf
+ * @flags:      may be PARPORT_EPP_FAST
+ */
+static size_t parport_ip32_epp_read_data(struct parport *p, void *buf,
+                                         size_t len, int flags)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return parport_ip32_epp_read(priv->regs.eppData0, p, buf, len, flags);
+}
+
+/**
+ * parport_ip32_epp_write_data - write a block of data in EPP mode
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ * @flags:      may be PARPORT_EPP_FAST
+ */
+static size_t parport_ip32_epp_write_data(struct parport *p, const void *buf,
+                                          size_t len, int flags)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return parport_ip32_epp_write(priv->regs.eppData0, p, buf, len, flags);
+}
+
+/**
+ * parport_ip32_epp_read_addr - read a block of addresses in EPP mode
+ * @p:          pointer to &struct parport
+ * @buf:        buffer to store read data
+ * @len:        length of buffer @buf
+ * @flags:      may be PARPORT_EPP_FAST
+ */
+static size_t parport_ip32_epp_read_addr(struct parport *p, void *buf,
+                                         size_t len, int flags)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return parport_ip32_epp_read(priv->regs.eppAddr, p, buf, len, flags);
+}
+
+/**
+ * parport_ip32_epp_write_addr - write a block of addresses in EPP mode
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ * @flags:      may be PARPORT_EPP_FAST
+ */
+static size_t parport_ip32_epp_write_addr(struct parport *p, const void *buf,
+                                          size_t len, int flags)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        return parport_ip32_epp_write(priv->regs.eppAddr, p, buf, len, flags);
+}
+
+/*--- ECP mode functions (FIFO) ----------------------------------------*/
+
+/**
+ * parport_ip32_fifo_wait_break - check if the waiting function should return
+ * @p:          pointer to &struct parport
+ * @expire:     timeout expiring date, in jiffies
+ *
+ * parport_ip32_fifo_wait_break() checks if the waiting function should return
+ * immediately or not.  The break conditions are:
+ *      - expired timeout;
+ *      - a pending signal;
+ *      - nFault asserted low.
+ * This function also calls cond_resched().
+ */
+static unsigned int parport_ip32_fifo_wait_break(struct parport *p,
+                                                 unsigned long expire)
+{
+        cond_resched();
+        if (time_after(jiffies, expire)) {
+                pr_debug1(PPIP32 "%s: FIFO write timed out\n", p->name);
+                return 1;
+        }
+        if (signal_pending(current)) {
+                pr_debug1(PPIP32 "%s: Signal pending\n", p->name);
+                return 1;
+        }
+        if (!(parport_ip32_read_status(p) & DSR_nFAULT)) {
+                pr_debug1(PPIP32 "%s: nFault asserted low\n", p->name);
+                return 1;
+        }
+        return 0;
+}
+
+/**
+ * parport_ip32_fwp_wait_polling - wait for FIFO to empty (polling)
+ * @p:          pointer to &struct parport
+ *
+ * Returns the number of bytes that can safely be written in the FIFO.  A
+ * return value of zero means that the calling function should terminate as
+ * fast as possible.
+ */
+static unsigned int parport_ip32_fwp_wait_polling(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        struct parport * const physport = p->physport;
+        unsigned long expire;
+        unsigned int count;
+        unsigned int ecr;
+
+        expire = jiffies + physport->cad->timeout;
+        count = 0;
+        while (1) {
+                if (parport_ip32_fifo_wait_break(p, expire))
+                        break;
+
+                /* Check FIFO state.  We do nothing when the FIFO is nor full,
+                 * nor empty.  It appears that the FIFO full bit is not always
+                 * reliable, the FIFO state is sometimes wrongly reported, and
+                 * the chip gets confused if we give it another byte. */
+                ecr = parport_ip32_read_econtrol(p);
+                if (ecr & ECR_F_EMPTY) {
+                        /* FIFO is empty, fill it up */
+                        count = priv->fifo_depth;
+                        break;
+                }
+
+                /* Wait a moment... */
+                udelay(FIFO_POLLING_INTERVAL);
+        } /* while (1) */
+
+        return count;
+}
+
+/**
+ * parport_ip32_fwp_wait_interrupt - wait for FIFO to empty (interrupt-driven)
+ * @p:          pointer to &struct parport
+ *
+ * Returns the number of bytes that can safely be written in the FIFO.  A
+ * return value of zero means that the calling function should terminate as
+ * fast as possible.
+ */
+static unsigned int parport_ip32_fwp_wait_interrupt(struct parport *p)
+{
+        static unsigned int lost_interrupt = 0;
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        struct parport * const physport = p->physport;
+        unsigned long nfault_timeout;
+        unsigned long expire;
+        unsigned int count;
+        unsigned int ecr;
+
+        nfault_timeout = min((unsigned long)physport->cad->timeout,
+                             msecs_to_jiffies(FIFO_NFAULT_TIMEOUT));
+        expire = jiffies + physport->cad->timeout;
+        count = 0;
+        while (1) {
+                if (parport_ip32_fifo_wait_break(p, expire))
+                        break;
+
+                /* Initialize mutex used to take interrupts into account */
+                INIT_COMPLETION(priv->irq_complete);
+
+                /* Enable serviceIntr */
+                parport_ip32_frob_econtrol(p, ECR_SERVINTR, 0);
+
+                /* Enabling serviceIntr while the FIFO is empty does not
+                 * always generate an interrupt, so check for emptiness
+                 * now. */
+                ecr = parport_ip32_read_econtrol(p);
+                if (!(ecr & ECR_F_EMPTY)) {
+                        /* FIFO is not empty: wait for an interrupt or a
+                         * timeout to occur */
+                        wait_for_completion_interruptible_timeout(
+                                &priv->irq_complete, nfault_timeout);
+                        ecr = parport_ip32_read_econtrol(p);
+                        if ((ecr & ECR_F_EMPTY) && !(ecr & ECR_SERVINTR)
+                            && !lost_interrupt) {
+                                printk(KERN_WARNING PPIP32
+                                       "%s: lost interrupt in %s\n",
+                                       p->name, __func__);
+                                lost_interrupt = 1;
+                        }
+                }
+
+                /* Disable serviceIntr */
+                parport_ip32_frob_econtrol(p, ECR_SERVINTR, ECR_SERVINTR);
+
+                /* Check FIFO state */
+                if (ecr & ECR_F_EMPTY) {
+                        /* FIFO is empty, fill it up */
+                        count = priv->fifo_depth;
+                        break;
+                } else if (ecr & ECR_SERVINTR) {
+                        /* FIFO is not empty, but we know that can safely push
+                         * writeIntrThreshold bytes into it */
+                        count = priv->writeIntrThreshold;
+                        break;
+                }
+                /* FIFO is not empty, and we did not get any interrupt.
+                 * Either it's time to check for nFault, or a signal is
+                 * pending.  This is verified in
+                 * parport_ip32_fifo_wait_break(), so we continue the loop. */
+        } /* while (1) */
+
+        return count;
+}
+
+/**
+ * parport_ip32_fifo_write_block_pio - write a block of data (PIO mode)
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ *
+ * Uses PIO to write the contents of the buffer @buf into the parallel port
+ * FIFO.  Returns the number of bytes that were actually written.  It can work
+ * with or without the help of interrupts.  The parallel port must be
+ * correctly initialized before calling parport_ip32_fifo_write_block_pio().
+ */
+static size_t parport_ip32_fifo_write_block_pio(struct parport *p,
+                                                const void *buf, size_t len)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        const u8 *bufp = buf;
+        size_t left = len;
+
+        priv->irq_mode = PARPORT_IP32_IRQ_HERE;
+
+        while (left > 0) {
+                unsigned int count;
+
+                count = (p->irq == PARPORT_IRQ_NONE) ?
+                        parport_ip32_fwp_wait_polling(p) :
+                        parport_ip32_fwp_wait_interrupt(p);
+                if (count == 0)
+                        break;  /* Transmission should be stopped */
+                if (count > left)
+                        count = left;
+                if (count == 1) {
+                        writeb(*bufp, priv->regs.fifo);
+                        bufp++, left--;
+                } else {
+                        writesb(priv->regs.fifo, bufp, count);
+                        bufp += count, left -= count;
+                }
+        }
+
+        priv->irq_mode = PARPORT_IP32_IRQ_FWD;
+
+        return len - left;
+}
+
+/**
+ * parport_ip32_fifo_write_block_dma - write a block of data (DMA mode)
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ *
+ * Uses DMA to write the contents of the buffer @buf into the parallel port
+ * FIFO.  Returns the number of bytes that were actually written.  The
+ * parallel port must be correctly initialized before calling
+ * parport_ip32_fifo_write_block_dma().
+ */
+static size_t parport_ip32_fifo_write_block_dma(struct parport *p,
+                                                const void *buf, size_t len)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        struct parport * const physport = p->physport;
+        unsigned long nfault_timeout;
+        unsigned long expire;
+        size_t written;
+        unsigned int ecr;
+
+        priv->irq_mode = PARPORT_IP32_IRQ_HERE;
+
+        parport_ip32_dma_start(DMA_TO_DEVICE, (void *)buf, len);
+        INIT_COMPLETION(priv->irq_complete);
+        parport_ip32_frob_econtrol(p, ECR_DMAEN | ECR_SERVINTR, ECR_DMAEN);
+
+        nfault_timeout = min((unsigned long)physport->cad->timeout,
+                             msecs_to_jiffies(FIFO_NFAULT_TIMEOUT));
+        expire = jiffies + physport->cad->timeout;
+        while (1) {
+                if (parport_ip32_fifo_wait_break(p, expire))
+                        break;
+                wait_for_completion_interruptible_timeout(&priv->irq_complete,
+                                                          nfault_timeout);
+                ecr = parport_ip32_read_econtrol(p);
+                if (ecr & ECR_SERVINTR)
+                        break;  /* DMA transfer just finished */
+        }
+        parport_ip32_dma_stop();
+        written = len - parport_ip32_dma_get_residue();
+
+        priv->irq_mode = PARPORT_IP32_IRQ_FWD;
+
+        return written;
+}
+
+/**
+ * parport_ip32_fifo_write_block - write a block of data
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ *
+ * Uses PIO or DMA to write the contents of the buffer @buf into the parallel
+ * p FIFO.  Returns the number of bytes that were actually written.
+ */
+static size_t parport_ip32_fifo_write_block(struct parport *p,
+                                            const void *buf, size_t len)
+{
+        size_t written = 0;
+        if (len)
+                /* FIXME - Maybe some threshold value should be set for @len
+                 * under which we revert to PIO mode? */
+                written = (p->modes & PARPORT_MODE_DMA) ?
+                        parport_ip32_fifo_write_block_dma(p, buf, len) :
+                        parport_ip32_fifo_write_block_pio(p, buf, len);
+        return written;
+}
+
+/**
+ * parport_ip32_drain_fifo - wait for FIFO to empty
+ * @p:          pointer to &struct parport
+ * @timeout:    timeout, in jiffies
+ *
+ * This function waits for FIFO to empty.  It returns 1 when FIFO is empty, or
+ * 0 if the timeout @timeout is reached before, or if a signal is pending.
+ */
+static unsigned int parport_ip32_drain_fifo(struct parport *p,
+                                            unsigned long timeout)
+{
+        unsigned long expire = jiffies + timeout;
+        unsigned int polling_interval;
+        unsigned int counter;
+
+        /* Busy wait for approx. 200us */
+        for (counter = 0; counter < 40; counter++) {
+                if (parport_ip32_read_econtrol(p) & ECR_F_EMPTY)
+                        break;
+                if (time_after(jiffies, expire))
+                        break;
+                if (signal_pending(current))
+                        break;
+                udelay(5);
+        }
+        /* Poll slowly.  Polling interval starts with 1 millisecond, and is
+         * increased exponentially until 128.  */
+        polling_interval = 1; /* msecs */
+        while (!(parport_ip32_read_econtrol(p) & ECR_F_EMPTY)) {
+                if (time_after_eq(jiffies, expire))
+                        break;
+                msleep_interruptible(polling_interval);
+                if (signal_pending(current))
+                        break;
+                if (polling_interval < 128)
+                        polling_interval *= 2;
+        }
+
+        return !!(parport_ip32_read_econtrol(p) & ECR_F_EMPTY);
+}
+
+/**
+ * parport_ip32_get_fifo_residue - reset FIFO
+ * @p:          pointer to &struct parport
+ * @mode:       current operation mode (ECR_MODE_PPF or ECR_MODE_ECP)
+ *
+ * This function resets FIFO, and returns the number of bytes remaining in it.
+ */
+static unsigned int parport_ip32_get_fifo_residue(struct parport *p,
+                                                  unsigned int mode)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        unsigned int residue;
+        unsigned int cnfga;
+
+        /* FIXME - We are missing one byte if the printer is off-line.  I
+         * don't know how to detect this.  It looks that the full bit is not
+         * always reliable.  For the moment, the problem is avoided in most
+         * cases by testing for BUSY in parport_ip32_compat_write_data().
+         */
+        if (parport_ip32_read_econtrol(p) & ECR_F_EMPTY)
+                residue = 0;
+        else {
+                pr_debug1(PPIP32 "%s: FIFO is stuck\n", p->name);
+
+                /* Stop all transfers.
+                 *
+                 * Microsoft's document instructs to drive DCR_STROBE to 0,
+                 * but it doesn't work (at least in Compatibility mode, not
+                 * tested in ECP mode).  Switching directly to Test mode (as
+                 * in parport_pc) is not an option: it does confuse the port,
+                 * ECP service interrupts are no more working after that.  A
+                 * hard reset is then needed to revert to a sane state.
+                 *
+                 * Let's hope that the FIFO is really stuck and that the
+                 * peripheral doesn't wake up now.
+                 */
+                parport_ip32_frob_control(p, DCR_STROBE, 0);
+
+                /* Fill up FIFO */
+                for (residue = priv->fifo_depth; residue > 0; residue--) {
+                        if (parport_ip32_read_econtrol(p) & ECR_F_FULL)
+                                break;
+                        writeb(0x00, priv->regs.fifo);
+                }
+        }
+        if (residue)
+                pr_debug1(PPIP32 "%s: %d PWord%s left in FIFO\n",
+                          p->name, residue,
+                          (residue == 1) ? " was" : "s were");
+
+        /* Now reset the FIFO */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+
+        /* Host recovery for ECP mode */
+        if (mode == ECR_MODE_ECP) {
+                parport_ip32_data_reverse(p);
+                parport_ip32_frob_control(p, DCR_nINIT, 0);
+                if (parport_wait_peripheral(p, DSR_PERROR, 0))
+                        pr_debug1(PPIP32 "%s: PEerror timeout 1 in %s\n",
+                                  p->name, __func__);
+                parport_ip32_frob_control(p, DCR_STROBE, DCR_STROBE);
+                parport_ip32_frob_control(p, DCR_nINIT, DCR_nINIT);
+                if (parport_wait_peripheral(p, DSR_PERROR, DSR_PERROR))
+                        pr_debug1(PPIP32 "%s: PEerror timeout 2 in %s\n",
+                                  p->name, __func__);
+        }
+
+        /* Adjust residue if needed */
+        parport_ip32_set_mode(p, ECR_MODE_CFG);
+        cnfga = readb(priv->regs.cnfgA);
+        if (!(cnfga & CNFGA_nBYTEINTRANS)) {
+                pr_debug1(PPIP32 "%s: cnfgA contains 0x%02x\n",
+                          p->name, cnfga);
+                pr_debug1(PPIP32 "%s: Accounting for extra byte\n",
+                          p->name);
+                residue++;
+        }
+
+        /* Don't care about partial PWords since we do not support
+         * PWord != 1 byte. */
+
+        /* Back to forward PS2 mode. */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        parport_ip32_data_forward(p);
+
+        return residue;
+}
+
+/**
+ * parport_ip32_compat_write_data - write a block of data in SPP mode
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ * @flags:      ignored
+ */
+static size_t parport_ip32_compat_write_data(struct parport *p,
+                                             const void *buf, size_t len,
+                                             int flags)
+{
+        static unsigned int ready_before = 1;
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        struct parport * const physport = p->physport;
+        size_t written = 0;
+
+        /* Special case: a timeout of zero means we cannot call schedule().
+         * Also if O_NONBLOCK is set then use the default implementation. */
+        if (physport->cad->timeout <= PARPORT_INACTIVITY_O_NONBLOCK)
+                return parport_ieee1284_write_compat(p, buf, len, flags);
+
+        /* Reset FIFO, go in forward mode, and disable ackIntEn */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        parport_ip32_write_control(p, DCR_SELECT | DCR_nINIT);
+        parport_ip32_data_forward(p);
+        parport_ip32_disable_irq(p);
+        parport_ip32_set_mode(p, ECR_MODE_PPF);
+        physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
+
+        /* Wait for peripheral to become ready */
+        if (parport_wait_peripheral(p, DSR_nBUSY | DSR_nFAULT,
+                                       DSR_nBUSY | DSR_nFAULT)) {
+                /* Avoid to flood the logs */
+                if (ready_before)
+                        printk(KERN_INFO PPIP32 "%s: not ready in %s\n",
+                               p->name, __func__);
+                ready_before = 0;
+                goto stop;
+        }
+        ready_before = 1;
+
+        written = parport_ip32_fifo_write_block(p, buf, len);
+
+        /* Wait FIFO to empty.  Timeout is proportional to FIFO_depth.  */
+        parport_ip32_drain_fifo(p, physport->cad->timeout * priv->fifo_depth);
+
+        /* Check for a potential residue */
+        written -= parport_ip32_get_fifo_residue(p, ECR_MODE_PPF);
+
+        /* Then, wait for BUSY to get low. */
+        if (parport_wait_peripheral(p, DSR_nBUSY, DSR_nBUSY))
+                printk(KERN_DEBUG PPIP32 "%s: BUSY timeout in %s\n",
+                       p->name, __func__);
+
+stop:
+        /* Reset FIFO */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
+
+        return written;
+}
+
+/*
+ * FIXME - Insert here parport_ip32_ecp_read_data().
+ */
+
+/**
+ * parport_ip32_ecp_write_data - write a block of data in ECP mode
+ * @p:          pointer to &struct parport
+ * @buf:        buffer of data to write
+ * @len:        length of buffer @buf
+ * @flags:      ignored
+ */
+static size_t parport_ip32_ecp_write_data(struct parport *p,
+                                          const void *buf, size_t len,
+                                          int flags)
+{
+        static unsigned int ready_before = 1;
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        struct parport * const physport = p->physport;
+        size_t written = 0;
+
+        /* Special case: a timeout of zero means we cannot call schedule().
+         * Also if O_NONBLOCK is set then use the default implementation. */
+        if (physport->cad->timeout <= PARPORT_INACTIVITY_O_NONBLOCK)
+                return parport_ieee1284_ecp_write_data(p, buf, len, flags);
+
+        /* Negotiate to forward mode if necessary. */
+        if (physport->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
+                /* Event 47: Set nInit high. */
+                parport_ip32_frob_control(p, DCR_nINIT | DCR_AUTOFD,
+                                             DCR_nINIT | DCR_AUTOFD);
+
+                /* Event 49: PError goes high. */
+                if (parport_wait_peripheral(p, DSR_PERROR, DSR_PERROR)) {
+                        printk(KERN_DEBUG PPIP32 "%s: PError timeout in %s",
+                               p->name, __func__);
+                        physport->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
+                        return 0;
+                }
+        }
+
+        /* Reset FIFO, go in forward mode, and disable ackIntEn */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        parport_ip32_write_control(p, DCR_SELECT | DCR_nINIT);
+        parport_ip32_data_forward(p);
+        parport_ip32_disable_irq(p);
+        parport_ip32_set_mode(p, ECR_MODE_ECP);
+        physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
+
+        /* Wait for peripheral to become ready */
+        if (parport_wait_peripheral(p, DSR_nBUSY | DSR_nFAULT,
+                                       DSR_nBUSY | DSR_nFAULT)) {
+                /* Avoid to flood the logs */
+                if (ready_before)
+                        printk(KERN_INFO PPIP32 "%s: not ready in %s\n",
+                               p->name, __func__);
+                ready_before = 0;
+                goto stop;
+        }
+        ready_before = 1;
+
+        written = parport_ip32_fifo_write_block(p, buf, len);
+
+        /* Wait FIFO to empty.  Timeout is proportional to FIFO_depth.  */
+        parport_ip32_drain_fifo(p, physport->cad->timeout * priv->fifo_depth);
+
+        /* Check for a potential residue */
+        written -= parport_ip32_get_fifo_residue(p, ECR_MODE_ECP);
+
+        /* Then, wait for BUSY to get low. */
+        if (parport_wait_peripheral(p, DSR_nBUSY, DSR_nBUSY))
+                printk(KERN_DEBUG PPIP32 "%s: BUSY timeout in %s\n",
+                       p->name, __func__);
+
+stop:
+        /* Reset FIFO */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
+
+        return written;
+}
+
+/*
+ * FIXME - Insert here parport_ip32_ecp_write_addr().
+ */
+
+/*--- Default parport operations ---------------------------------------*/
+
+static __initdata struct parport_operations parport_ip32_ops = {
+        .write_data             = parport_ip32_write_data,
+        .read_data              = parport_ip32_read_data,
+
+        .write_control          = parport_ip32_write_control,
+        .read_control           = parport_ip32_read_control,
+        .frob_control           = parport_ip32_frob_control,
+
+        .read_status            = parport_ip32_read_status,
+
+        .enable_irq             = parport_ip32_enable_irq,
+        .disable_irq            = parport_ip32_disable_irq,
+
+        .data_forward           = parport_ip32_data_forward,
+        .data_reverse           = parport_ip32_data_reverse,
+
+        .init_state             = parport_ip32_init_state,
+        .save_state             = parport_ip32_save_state,
+        .restore_state          = parport_ip32_restore_state,
+
+        .epp_write_data         = parport_ieee1284_epp_write_data,
+        .epp_read_data          = parport_ieee1284_epp_read_data,
+        .epp_write_addr         = parport_ieee1284_epp_write_addr,
+        .epp_read_addr          = parport_ieee1284_epp_read_addr,
+
+        .ecp_write_data         = parport_ieee1284_ecp_write_data,
+        .ecp_read_data          = parport_ieee1284_ecp_read_data,
+        .ecp_write_addr         = parport_ieee1284_ecp_write_addr,
+
+        .compat_write_data      = parport_ieee1284_write_compat,
+        .nibble_read_data       = parport_ieee1284_read_nibble,
+        .byte_read_data         = parport_ieee1284_read_byte,
+
+        .owner                  = THIS_MODULE,
+};
+
+/*--- Device detection -------------------------------------------------*/
+
+/**
+ * parport_ip32_ecp_supported - check for an ECP port
+ * @p:          pointer to the &parport structure
+ *
+ * Returns 1 if an ECP port is found, and 0 otherwise.  This function actually
+ * checks if an Extended Control Register seems to be present.  On successful
+ * return, the port is placed in SPP mode.
+ */
+static __init unsigned int parport_ip32_ecp_supported(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        unsigned int ecr;
+
+        ecr = ECR_MODE_PS2 | ECR_nERRINTR | ECR_SERVINTR;
+        writeb(ecr, priv->regs.ecr);
+        if (readb(priv->regs.ecr) != (ecr | ECR_F_EMPTY))
+                goto fail;
+
+        pr_probe(p, "Found working ECR register\n");
+        parport_ip32_set_mode(p, ECR_MODE_SPP);
+        parport_ip32_write_control(p, DCR_SELECT | DCR_nINIT);
+        return 1;
+
+fail:
+        pr_probe(p, "ECR register not found\n");
+        return 0;
+}
+
+/**
+ * parport_ip32_fifo_supported - check for FIFO parameters
+ * @p:          pointer to the &parport structure
+ *
+ * Check for FIFO parameters of an Extended Capabilities Port.  Returns 1 on
+ * success, and 0 otherwise.  Adjust FIFO parameters in the parport structure.
+ * On return, the port is placed in SPP mode.
+ */
+static __init unsigned int parport_ip32_fifo_supported(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        unsigned int configa, configb;
+        unsigned int pword;
+        unsigned int i;
+
+        /* Configuration mode */
+        parport_ip32_set_mode(p, ECR_MODE_CFG);
+        configa = readb(priv->regs.cnfgA);
+        configb = readb(priv->regs.cnfgB);
+
+        /* Find out PWord size */
+        switch (configa & CNFGA_ID_MASK) {
+        case CNFGA_ID_8:
+                pword = 1;
+                break;
+        case CNFGA_ID_16:
+                pword = 2;
+                break;
+        case CNFGA_ID_32:
+                pword = 4;
+                break;
+        default:
+                pr_probe(p, "Unknown implementation ID: 0x%0x\n",
+                         (configa & CNFGA_ID_MASK) >> CNFGA_ID_SHIFT);
+                goto fail;
+                break;
+        }
+        if (pword != 1) {
+                pr_probe(p, "Unsupported PWord size: %u\n", pword);
+                goto fail;
+        }
+        priv->pword = pword;
+        pr_probe(p, "PWord is %u bits\n", 8 * priv->pword);
+
+        /* Check for compression support */
+        writeb(configb | CNFGB_COMPRESS, priv->regs.cnfgB);
+        if (readb(priv->regs.cnfgB) & CNFGB_COMPRESS)
+                pr_probe(p, "Hardware compression detected (unsupported)\n");
+        writeb(configb & ~CNFGB_COMPRESS, priv->regs.cnfgB);
+
+        /* Reset FIFO and go in test mode (no interrupt, no DMA) */
+        parport_ip32_set_mode(p, ECR_MODE_TST);
+
+        /* FIFO must be empty now */
+        if (!(readb(priv->regs.ecr) & ECR_F_EMPTY)) {
+                pr_probe(p, "FIFO not reset\n");
+                goto fail;
+        }
+
+        /* Find out FIFO depth. */
+        priv->fifo_depth = 0;
+        for (i = 0; i < 1024; i++) {
+                if (readb(priv->regs.ecr) & ECR_F_FULL) {
+                        /* FIFO full */
+                        priv->fifo_depth = i;
+                        break;
+                }
+                writeb((u8)i, priv->regs.fifo);
+        }
+        if (i >= 1024) {
+                pr_probe(p, "Can't fill FIFO\n");
+                goto fail;
+        }
+        if (!priv->fifo_depth) {
+                pr_probe(p, "Can't get FIFO depth\n");
+                goto fail;
+        }
+        pr_probe(p, "FIFO is %u PWords deep\n", priv->fifo_depth);
+
+        /* Enable interrupts */
+        parport_ip32_frob_econtrol(p, ECR_SERVINTR, 0);
+
+        /* Find out writeIntrThreshold: number of PWords we know we can write
+         * if we get an interrupt. */
+        priv->writeIntrThreshold = 0;
+        for (i = 0; i < priv->fifo_depth; i++) {
+                if (readb(priv->regs.fifo) != (u8)i) {
+                        pr_probe(p, "Invalid data in FIFO\n");
+                        goto fail;
+                }
+                if (!priv->writeIntrThreshold
+                    && readb(priv->regs.ecr) & ECR_SERVINTR)
+                        /* writeIntrThreshold reached */
+                        priv->writeIntrThreshold = i + 1;
+                if (i + 1 < priv->fifo_depth
+                    && readb(priv->regs.ecr) & ECR_F_EMPTY) {
+                        /* FIFO empty before the last byte? */
+                        pr_probe(p, "Data lost in FIFO\n");
+                        goto fail;
+                }
+        }
+        if (!priv->writeIntrThreshold) {
+                pr_probe(p, "Can't get writeIntrThreshold\n");
+                goto fail;
+        }
+        pr_probe(p, "writeIntrThreshold is %u\n", priv->writeIntrThreshold);
+
+        /* FIFO must be empty now */
+        if (!(readb(priv->regs.ecr) & ECR_F_EMPTY)) {
+                pr_probe(p, "Can't empty FIFO\n");
+                goto fail;
+        }
+
+        /* Reset FIFO */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        /* Set reverse direction (must be in PS2 mode) */
+        parport_ip32_data_reverse(p);
+        /* Test FIFO, no interrupt, no DMA */
+        parport_ip32_set_mode(p, ECR_MODE_TST);
+        /* Enable interrupts */
+        parport_ip32_frob_econtrol(p, ECR_SERVINTR, 0);
+
+        /* Find out readIntrThreshold: number of PWords we can read if we get
+         * an interrupt. */
+        priv->readIntrThreshold = 0;
+        for (i = 0; i < priv->fifo_depth; i++) {
+                writeb(0xaa, priv->regs.fifo);
+                if (readb(priv->regs.ecr) & ECR_SERVINTR) {
+                        /* readIntrThreshold reached */
+                        priv->readIntrThreshold = i + 1;
+                        break;
+                }
+        }
+        if (!priv->readIntrThreshold) {
+                pr_probe(p, "Can't get readIntrThreshold\n");
+                goto fail;
+        }
+        pr_probe(p, "readIntrThreshold is %u\n", priv->readIntrThreshold);
+
+        /* Reset ECR */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        parport_ip32_data_forward(p);
+        parport_ip32_set_mode(p, ECR_MODE_SPP);
+        return 1;
+
+fail:
+        priv->fifo_depth = 0;
+        parport_ip32_set_mode(p, ECR_MODE_SPP);
+        return 0;
+}
+
+/*--- Initialization code ----------------------------------------------*/
+
+/**
+ * parport_ip32_make_isa_registers - compute (ISA) register addresses
+ * @regs:       pointer to &struct parport_ip32_regs to fill
+ * @base:       base address of standard and EPP registers
+ * @base_hi:    base address of ECP registers
+ * @regshift:   how much to shift register offset by
+ *
+ * Compute register addresses, according to the ISA standard.  The addresses
+ * of the standard and EPP registers are computed from address @base.  The
+ * addresses of the ECP registers are computed from address @base_hi.
+ */
+static void __init
+parport_ip32_make_isa_registers(struct parport_ip32_regs *regs,
+                                void __iomem *base, void __iomem *base_hi,
+                                unsigned int regshift)
+{
+#define r_base(offset)    ((u8 __iomem *)base    + ((offset) << regshift))
+#define r_base_hi(offset) ((u8 __iomem *)base_hi + ((offset) << regshift))
+        *regs = (struct parport_ip32_regs){
+                .data           = r_base(0),
+                .dsr            = r_base(1),
+                .dcr            = r_base(2),
+                .eppAddr        = r_base(3),
+                .eppData0       = r_base(4),
+                .eppData1       = r_base(5),
+                .eppData2       = r_base(6),
+                .eppData3       = r_base(7),
+                .ecpAFifo       = r_base(0),
+                .fifo           = r_base_hi(0),
+                .cnfgA          = r_base_hi(0),
+                .cnfgB          = r_base_hi(1),
+                .ecr            = r_base_hi(2)
+        };
+#undef r_base_hi
+#undef r_base
+}
+
+/**
+ * parport_ip32_probe_port - probe and register IP32 built-in parallel port
+ *
+ * Returns the new allocated &parport structure.  On error, an error code is
+ * encoded in return value with the ERR_PTR function.
+ */
+static __init struct parport *parport_ip32_probe_port(void)
+{
+        struct parport_ip32_regs regs;
+        struct parport_ip32_private *priv = NULL;
+        struct parport_operations *ops = NULL;
+        struct parport *p = NULL;
+        int err;
+
+        parport_ip32_make_isa_registers(&regs, &mace->isa.parallel,
+                                        &mace->isa.ecp1284, 8 /* regshift */);
+
+        ops = kmalloc(sizeof(struct parport_operations), GFP_KERNEL);
+        priv = kmalloc(sizeof(struct parport_ip32_private), GFP_KERNEL);
+        p = parport_register_port(0, PARPORT_IRQ_NONE, PARPORT_DMA_NONE, ops);
+        if (ops == NULL || priv == NULL || p == NULL) {
+                err = -ENOMEM;
+                goto fail;
+        }
+        p->base = MACE_BASE + offsetof(struct sgi_mace, isa.parallel);
+        p->base_hi = MACE_BASE + offsetof(struct sgi_mace, isa.ecp1284);
+        p->private_data = priv;
+
+        *ops = parport_ip32_ops;
+        *priv = (struct parport_ip32_private){
+                .regs                   = regs,
+                .dcr_writable           = DCR_DIR | DCR_SELECT | DCR_nINIT |
+                                          DCR_AUTOFD | DCR_STROBE,
+                .irq_mode               = PARPORT_IP32_IRQ_FWD,
+        };
+        init_completion(&priv->irq_complete);
+
+        /* Probe port. */
+        if (!parport_ip32_ecp_supported(p)) {
+                err = -ENODEV;
+                goto fail;
+        }
+        parport_ip32_dump_state(p, "begin init", 0);
+
+        /* We found what looks like a working ECR register.  Simply assume
+         * that all modes are correctly supported.  Enable basic modes. */
+        p->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT;
+        p->modes |= PARPORT_MODE_TRISTATE;
+
+        if (!parport_ip32_fifo_supported(p)) {
+                printk(KERN_WARNING PPIP32
+                       "%s: error: FIFO disabled\n", p->name);
+                /* Disable hardware modes depending on a working FIFO. */
+                features &= ~PARPORT_IP32_ENABLE_SPP;
+                features &= ~PARPORT_IP32_ENABLE_ECP;
+                /* DMA is not needed if FIFO is not supported.  */
+                features &= ~PARPORT_IP32_ENABLE_DMA;
+        }
+
+        /* Request IRQ */
+        if (features & PARPORT_IP32_ENABLE_IRQ) {
+                int irq = MACEISA_PARALLEL_IRQ;
+                if (request_irq(irq, parport_ip32_interrupt, 0, p->name, p)) {
+                        printk(KERN_WARNING PPIP32
+                               "%s: error: IRQ disabled\n", p->name);
+                        /* DMA cannot work without interrupts. */
+                        features &= ~PARPORT_IP32_ENABLE_DMA;
+                } else {
+                        pr_probe(p, "Interrupt support enabled\n");
+                        p->irq = irq;
+                        priv->dcr_writable |= DCR_IRQ;
+                }
+        }
+
+        /* Allocate DMA resources */
+        if (features & PARPORT_IP32_ENABLE_DMA) {
+                if (parport_ip32_dma_register())
+                        printk(KERN_WARNING PPIP32
+                               "%s: error: DMA disabled\n", p->name);
+                else {
+                        pr_probe(p, "DMA support enabled\n");
+                        p->dma = 0; /* arbitrary value != PARPORT_DMA_NONE */
+                        p->modes |= PARPORT_MODE_DMA;
+                }
+        }
+
+        if (features & PARPORT_IP32_ENABLE_SPP) {
+                /* Enable compatibility FIFO mode */
+                p->ops->compat_write_data = parport_ip32_compat_write_data;
+                p->modes |= PARPORT_MODE_COMPAT;
+                pr_probe(p, "Hardware support for SPP mode enabled\n");
+        }
+        if (features & PARPORT_IP32_ENABLE_EPP) {
+                /* Set up access functions to use EPP hardware. */
+                p->ops->epp_read_data = parport_ip32_epp_read_data;
+                p->ops->epp_write_data = parport_ip32_epp_write_data;
+                p->ops->epp_read_addr = parport_ip32_epp_read_addr;
+                p->ops->epp_write_addr = parport_ip32_epp_write_addr;
+                p->modes |= PARPORT_MODE_EPP;
+                pr_probe(p, "Hardware support for EPP mode enabled\n");
+        }
+        if (features & PARPORT_IP32_ENABLE_ECP) {
+                /* Enable ECP FIFO mode */
+                p->ops->ecp_write_data = parport_ip32_ecp_write_data;
+                /* FIXME - not implemented */
+/*              p->ops->ecp_read_data  = parport_ip32_ecp_read_data; */
+/*              p->ops->ecp_write_addr = parport_ip32_ecp_write_addr; */
+                p->modes |= PARPORT_MODE_ECP;
+                pr_probe(p, "Hardware support for ECP mode enabled\n");
+        }
+
+        /* Initialize the port with sensible values */
+        parport_ip32_set_mode(p, ECR_MODE_PS2);
+        parport_ip32_write_control(p, DCR_SELECT | DCR_nINIT);
+        parport_ip32_data_forward(p);
+        parport_ip32_disable_irq(p);
+        parport_ip32_write_data(p, 0x00);
+        parport_ip32_dump_state(p, "end init", 0);
+
+        /* Print out what we found */
+        printk(KERN_INFO "%s: SGI IP32 at 0x%lx (0x%lx)",
+               p->name, p->base, p->base_hi);
+        if (p->irq != PARPORT_IRQ_NONE)
+                printk(", irq %d", p->irq);
+        printk(" [");
+#define printmode(x)    if (p->modes & PARPORT_MODE_##x)                \
+                                printk("%s%s", f++ ? "," : "", #x)
+        {
+                unsigned int f = 0;
+                printmode(PCSPP);
+                printmode(TRISTATE);
+                printmode(COMPAT);
+                printmode(EPP);
+                printmode(ECP);
+                printmode(DMA);
+        }
+#undef printmode
+        printk("]\n");
+
+        parport_announce_port(p);
+        return p;
+
+fail:
+        if (p)
+                parport_put_port(p);
+        kfree(priv);
+        kfree(ops);
+        return ERR_PTR(err);
+}
+
+/**
+ * parport_ip32_unregister_port - unregister a parallel port
+ * @p:          pointer to the &struct parport
+ *
+ * Unregisters a parallel port and free previously allocated resources
+ * (memory, IRQ, ...).
+ */
+static __exit void parport_ip32_unregister_port(struct parport *p)
+{
+        struct parport_ip32_private * const priv = p->physport->private_data;
+        struct parport_operations *ops = p->ops;
+
+        parport_remove_port(p);
+        if (p->modes & PARPORT_MODE_DMA)
+                parport_ip32_dma_unregister();
+        if (p->irq != PARPORT_IRQ_NONE)
+                free_irq(p->irq, p);
+        parport_put_port(p);
+        kfree(priv);
+        kfree(ops);
+}
+
+/**
+ * parport_ip32_init - module initialization function
+ */
+static int __init parport_ip32_init(void)
+{
+        pr_info(PPIP32 "SGI IP32 built-in parallel port driver v0.6\n");
+        pr_debug1(PPIP32 "Compiled on %s, %s\n", __DATE__, __TIME__);
+        this_port = parport_ip32_probe_port();
+        return IS_ERR(this_port) ? PTR_ERR(this_port) : 0;
+}
+
+/**
+ * parport_ip32_exit - module termination function
+ */
+static void __exit parport_ip32_exit(void)
+{
+        parport_ip32_unregister_port(this_port);
+}
+
+/*--- Module stuff -----------------------------------------------------*/
+
+MODULE_AUTHOR("Arnaud Giersch <arnaud.giersch@free.fr>");
+MODULE_DESCRIPTION("SGI IP32 built-in parallel port driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("0.6");          /* update in parport_ip32_init() too */
+
+module_init(parport_ip32_init);
+module_exit(parport_ip32_exit);
+
+module_param(verbose_probing, bool, S_IRUGO);
+MODULE_PARM_DESC(verbose_probing, "Log chit-chat during initialization");
+
+module_param(features, uint, S_IRUGO);
+MODULE_PARM_DESC(features,
+                 "Bit mask of features to enable"
+                 ", bit 0: IRQ support"
+                 ", bit 1: DMA support"
+                 ", bit 2: hardware SPP mode"
+                 ", bit 3: hardware EPP mode"
+                 ", bit 4: hardware ECP mode");
+
+/*--- Inform (X)Emacs about preferred coding style ---------------------*/
+/*
+ * Local Variables:
+ * mode: c
+ * c-file-style: "linux"
+ * indent-tabs-mode: t
+ * tab-width: 8
+ * fill-column: 78
+ * ispell-local-dictionary: "american"
+ * End:
+ */
diff --git a/drivers/parport/parport_serial.c b/drivers/parport/parport_serial.c
index 76dd077e3184..166de3507780 100644
--- a/drivers/parport/parport_serial.c
+++ b/drivers/parport/parport_serial.c
@@ -329,9 +329,9 @@ static int __devinit parport_register (struct pci_dev *dev,
 
                 if (priv->num_par == ARRAY_SIZE (priv->port)) {
                         printk (KERN_WARNING
-                                "parport_serial: %s: only %u parallel ports "
+                                "parport_serial: %s: only %zu parallel ports "
                                 "supported (%d reported)\n", pci_name (dev),
-                                ARRAY_SIZE (priv->port), card->numports);
+                                ARRAY_SIZE(priv->port), card->numports);
                         break;
                 }
 
diff --git a/drivers/parport/probe.c b/drivers/parport/probe.c
index b62aee8de3cb..ea83b70e0de2 100644
--- a/drivers/parport/probe.c
+++ b/drivers/parport/probe.c
@@ -199,7 +199,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
 
                 if (port->physport->ieee1284.phase != IEEE1284_PH_HBUSY_DAVAIL) {
                         if (belen != len) {
-                                printk (KERN_DEBUG "%s: Device ID was %d bytes"
+                                printk (KERN_DEBUG "%s: Device ID was %zd bytes"
                                         " while device told it would be %d"
                                         " bytes\n",
                                         port->name, len, belen);
@@ -214,7 +214,7 @@ static ssize_t parport_read_device_id (struct parport *port, char *buffer,
                 if (buffer[len-1] == ';') {
                         printk (KERN_DEBUG "%s: Device ID reading stopped"
                                 " before device told data not available. "
-                                "Current idlen %d of %d, len bytes %02X %02X\n",
+                                "Current idlen %u of %u, len bytes %02X %02X\n",
                                 port->name, current_idlen, numidlens,
                                 length[0], length[1]);
                         goto done;
diff --git a/drivers/s390/block/Kconfig b/drivers/s390/block/Kconfig
index 6f50cc9323d9..6912399d0937 100644
--- a/drivers/s390/block/Kconfig
+++ b/drivers/s390/block/Kconfig
@@ -55,13 +55,21 @@ config DASD_DIAG
           Disks under VM.  If you are not running under VM or unsure what it is,
           say "N".
 
+config DASD_EER
+        tristate "Extended error reporting (EER)"
+        depends on DASD
+        help
+          This driver provides a character device interface to the
+          DASD extended error reporting. This is only needed if you want to
+          use applications written for the EER facility.
+
 config DASD_CMB
         tristate "Compatibility interface for DASD channel measurement blocks"
         depends on DASD
         help
-          This driver provides an additional interface to the channel measurement
-          facility, which is normally accessed though sysfs, with a set of
-          ioctl functions specific to the dasd driver.
+          This driver provides an additional interface to the channel
+          measurement facility, which is normally accessed though sysfs, with
+          a set of ioctl functions specific to the dasd driver.
           This is only needed if you want to use applications written for
           linux-2.4 dasd channel measurement facility interface.
 
diff --git a/drivers/s390/block/Makefile b/drivers/s390/block/Makefile
index 58c6780134f7..0c0d871e8f51 100644
--- a/drivers/s390/block/Makefile
+++ b/drivers/s390/block/Makefile
@@ -5,6 +5,7 @@
 dasd_eckd_mod-objs := dasd_eckd.o dasd_3990_erp.o dasd_9343_erp.o
 dasd_fba_mod-objs  := dasd_fba.o dasd_3370_erp.o dasd_9336_erp.o
 dasd_diag_mod-objs := dasd_diag.o
+dasd_eer_mod-objs := dasd_eer.o
 dasd_mod-objs      := dasd.o dasd_ioctl.o dasd_proc.o dasd_devmap.o \
                         dasd_genhd.o dasd_erp.o
 
@@ -13,5 +14,6 @@ obj-$(CONFIG_DASD_DIAG) += dasd_diag_mod.o
 obj-$(CONFIG_DASD_ECKD) += dasd_eckd_mod.o
 obj-$(CONFIG_DASD_FBA)  += dasd_fba_mod.o
 obj-$(CONFIG_DASD_CMB)  += dasd_cmb.o
+obj-$(CONFIG_DASD_EER)  += dasd_eer.o
 obj-$(CONFIG_BLK_DEV_XPRAM) += xpram.o
 obj-$(CONFIG_DCSSBLK) += dcssblk.o
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index abdf1ee633e7..08c88fcd8963 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -18,6 +18,7 @@
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/hdreg.h>
+#include <linux/notifier.h>
 
 #include <asm/ccwdev.h>
 #include <asm/ebcdic.h>
@@ -57,6 +58,7 @@ static void dasd_int_handler(struct ccw_device *, unsigned long, struct irb *);
 static void dasd_flush_ccw_queue(struct dasd_device *, int);
 static void dasd_tasklet(struct dasd_device *);
 static void do_kick_device(void *data);
+static void dasd_disable_eer(struct dasd_device *device);
 
 /*
  * SECTION: Operations on the device structure.
@@ -151,6 +153,8 @@ dasd_state_new_to_known(struct dasd_device *device)
 static inline void
 dasd_state_known_to_new(struct dasd_device * device)
 {
+        /* disable extended error reporting for this device */
+        dasd_disable_eer(device);
         /* Forget the discipline information. */
         device->discipline = NULL;
         device->state = DASD_STATE_NEW;
@@ -867,6 +871,9 @@ dasd_handle_state_change_pending(struct dasd_device *device)
         struct dasd_ccw_req *cqr;
         struct list_head *l, *n;
 
+        /* first of all call extended error reporting */
+        dasd_write_eer_trigger(DASD_EER_STATECHANGE, device, NULL);
+
         device->stopped &= ~DASD_STOPPED_PENDING;
 
         /* restart all 'running' IO on queue */
@@ -1086,6 +1093,19 @@ restart:
                         }
                         goto restart;
                 }
+
+                /* first of all call extended error reporting */
+                if (device->eer && cqr->status == DASD_CQR_FAILED) {
+                        dasd_write_eer_trigger(DASD_EER_FATALERROR,
+                                               device, cqr);
+
+                        /* restart request  */
+                        cqr->status = DASD_CQR_QUEUED;
+                        cqr->retries = 255;
+                        device->stopped |= DASD_STOPPED_QUIESCE;
+                        goto restart;
+                }
+
                 /* Process finished ERP request. */
                 if (cqr->refers) {
                         __dasd_process_erp(device, cqr);
@@ -1223,7 +1243,8 @@ __dasd_start_head(struct dasd_device * device)
         cqr = list_entry(device->ccw_queue.next, struct dasd_ccw_req, list);
         /* check FAILFAST */
         if (device->stopped & ~DASD_STOPPED_PENDING &&
-            test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags)) {
+            test_bit(DASD_CQR_FLAGS_FAILFAST, &cqr->flags) &&
+            (!device->eer)) {
                 cqr->status = DASD_CQR_FAILED;
                 dasd_schedule_bh(device);
         }
@@ -1965,6 +1986,9 @@ dasd_generic_notify(struct ccw_device *cdev, int event)
         switch (event) {
         case CIO_GONE:
         case CIO_NO_PATH:
+                /* first of all call extended error reporting */
+                dasd_write_eer_trigger(DASD_EER_NOPATH, device, NULL);
+
                 if (device->state < DASD_STATE_BASIC)
                         break;
                 /* Device is active. We want to keep it. */
@@ -2022,6 +2046,51 @@ dasd_generic_auto_online (struct ccw_driver *dasd_discipline_driver)
         put_driver(drv);
 }
 
+/*
+ * notifications for extended error reports
+ */
+static struct notifier_block *dasd_eer_chain;
+
+int
+dasd_register_eer_notifier(struct notifier_block *nb)
+{
+        return notifier_chain_register(&dasd_eer_chain, nb);
+}
+
+int
+dasd_unregister_eer_notifier(struct notifier_block *nb)
+{
+        return notifier_chain_unregister(&dasd_eer_chain, nb);
+}
+
+/*
+ * Notify the registered error reporting module of a problem
+ */
+void
+dasd_write_eer_trigger(unsigned int id, struct dasd_device *device,
+                       struct dasd_ccw_req *cqr)
+{
+        if (device->eer) {
+                struct dasd_eer_trigger temp;
+                temp.id = id;
+                temp.device = device;
+                temp.cqr = cqr;
+                notifier_call_chain(&dasd_eer_chain, DASD_EER_TRIGGER,
+                                    (void *)&temp);
+        }
+}
+
+/*
+ * Tell the registered error reporting module to disable error reporting for
+ * a given device and to cleanup any private data structures on that device.
+ */
+static void
+dasd_disable_eer(struct dasd_device *device)
+{
+        notifier_call_chain(&dasd_eer_chain, DASD_EER_DISABLE, (void *)device);
+}
+
+
 static int __init
 dasd_init(void)
 {
@@ -2103,6 +2172,11 @@ EXPORT_SYMBOL_GPL(dasd_generic_set_online);
 EXPORT_SYMBOL_GPL(dasd_generic_set_offline);
 EXPORT_SYMBOL_GPL(dasd_generic_auto_online);
 
+EXPORT_SYMBOL(dasd_register_eer_notifier);
+EXPORT_SYMBOL(dasd_unregister_eer_notifier);
+EXPORT_SYMBOL(dasd_write_eer_trigger);
+
+
 /*
  * Overrides for Emacs so that we follow Linus's tabbing style.
  * Emacs will notice this stuff at the end of the file and automatically
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index 4ee0f934e325..c811380b9079 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -1108,6 +1108,9 @@ dasd_3990_handle_env_data(struct dasd_ccw_req * erp, char *sense)
                 case 0x0B:
                         DEV_MESSAGE(KERN_WARNING, device, "%s",
                                     "FORMAT F - Volume is suspended duplex");
+                        /* call extended error reporting (EER) */
+                        dasd_write_eer_trigger(DASD_EER_PPRCSUSPEND, device,
+                                               erp->refers);
                         break;
                 case 0x0C:
                         DEV_MESSAGE(KERN_WARNING, device, "%s",
diff --git a/drivers/s390/block/dasd_eckd.h b/drivers/s390/block/dasd_eckd.h
index bc3823d35223..e15dd7978050 100644
--- a/drivers/s390/block/dasd_eckd.h
+++ b/drivers/s390/block/dasd_eckd.h
@@ -29,6 +29,7 @@
 #define DASD_ECKD_CCW_PSF                0x27
 #define DASD_ECKD_CCW_RSSD               0x3e
 #define DASD_ECKD_CCW_LOCATE_RECORD      0x47
+#define DASD_ECKD_CCW_SNSS               0x54
 #define DASD_ECKD_CCW_DEFINE_EXTENT      0x63
 #define DASD_ECKD_CCW_WRITE_MT           0x85
 #define DASD_ECKD_CCW_READ_MT            0x86
diff --git a/drivers/s390/block/dasd_eer.c b/drivers/s390/block/dasd_eer.c
new file mode 100644
index 000000000000..f70cd7716b24
--- /dev/null
+++ b/drivers/s390/block/dasd_eer.c
@@ -0,0 +1,1090 @@
+/*
+ *      character device driver for extended error reporting
+ *
+ *
+ *      Copyright (C) 2005 IBM Corporation
+ *      extended error reporting for DASD ECKD devices
+ *      Author(s): Stefan Weinhuber <wein@de.ibm.com>
+ *
+ */
+
+#include <linux/init.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/workqueue.h>
+#include <linux/poll.h>
+#include <linux/notifier.h>
+
+#include <asm/uaccess.h>
+#include <asm/semaphore.h>
+#include <asm/atomic.h>
+#include <asm/ebcdic.h>
+
+#include "dasd_int.h"
+#include "dasd_eckd.h"
+
+
+MODULE_LICENSE("GPL");
+
+MODULE_AUTHOR("Stefan Weinhuber <wein@de.ibm.com>");
+MODULE_DESCRIPTION("DASD extended error reporting module");
+
+
+#ifdef PRINTK_HEADER
+#undef PRINTK_HEADER
+#endif                          /* PRINTK_HEADER */
+#define PRINTK_HEADER "dasd(eer):"
+
+
+
+
+
+/*****************************************************************************/
+/*      the internal buffer                                                  */
+/*****************************************************************************/
+
+/*
+ * The internal buffer is meant to store obaque blobs of data, so it doesn't
+ * know of higher level concepts like triggers.
+ * It consists of a number of pages that are used as a ringbuffer. Each data
+ * blob is stored in a simple record that consists of an integer, which
+ * contains the size of the following data, and the data bytes themselfes.
+ *
+ * To allow for multiple independent readers we create one internal buffer
+ * each time the device is opened and destroy the buffer when the file is
+ * closed again.
+ *
+ * One record can be written to a buffer by using the functions
+ * - dasd_eer_start_record (one time per record to write the size to the buffer
+ *                          and reserve the space for the data)
+ * - dasd_eer_write_buffer (one or more times per record to write the data)
+ * The data can be written in several steps but you will have to compute
+ * the total size up front for the invocation of dasd_eer_start_record.
+ * If the ringbuffer is full, dasd_eer_start_record will remove the required
+ * number of old records.
+ *
+ * A record is typically read in two steps, first read the integer that
+ * specifies the size of the following data, then read the data.
+ * Both can be done by
+ * - dasd_eer_read_buffer
+ *
+ * For all mentioned functions you need to get the bufferlock first and keep it
+ * until a complete record is written or read.
+ */
+
+
+/*
+ * Alle information necessary to keep track of an internal buffer is kept in
+ * a struct eerbuffer. The buffer specific to a file pointer is strored in
+ * the private_data field of that file. To be able to write data to all
+ * existing buffers, each buffer is also added to the bufferlist.
+ * If the user doesn't want to read a complete record in one go, we have to
+ * keep track of the rest of the record. residual stores the number of bytes
+ * that are still to deliver. If the rest of the record is invalidated between
+ * two reads then residual will be set to -1 so that the next read will fail.
+ * All entries in the eerbuffer structure are protected with the bufferlock.
+ * To avoid races between writing to a buffer on the one side and creating
+ * and destroying buffers on the other side, the bufferlock must also be used
+ * to protect the bufferlist.
+ */
+
+struct eerbuffer {
+        struct list_head list;
+        char **buffer;
+        int buffersize;
+        int buffer_page_count;
+        int head;
+        int tail;
+        int residual;
+};
+
+LIST_HEAD(bufferlist);
+
+static spinlock_t bufferlock = SPIN_LOCK_UNLOCKED;
+
+DECLARE_WAIT_QUEUE_HEAD(dasd_eer_read_wait_queue);
+
+/*
+ * How many free bytes are available on the buffer.
+ * needs to be called with bufferlock held
+ */
+static int
+dasd_eer_get_free_bytes(struct eerbuffer *eerb)
+{
+        if (eerb->head < eerb->tail) {
+                return eerb->tail - eerb->head - 1;
+        } else
+                return eerb->buffersize - eerb->head + eerb->tail -1;
+}
+
+/*
+ * How many bytes of buffer space are used.
+ * needs to be called with bufferlock held
+ */
+static int
+dasd_eer_get_filled_bytes(struct eerbuffer *eerb)
+{
+
+        if (eerb->head >= eerb->tail) {
+                return eerb->head - eerb->tail;
+        } else
+                return eerb->buffersize - eerb->tail + eerb->head;
+}
+
+/*
+ * The dasd_eer_write_buffer function just copies count bytes of data
+ * to the buffer. Make sure to call dasd_eer_start_record first, to
+ * make sure that enough free space is available.
+ * needs to be called with bufferlock held
+ */
+static void
+dasd_eer_write_buffer(struct eerbuffer *eerb, int count, char *data)
+{
+
+        unsigned long headindex,localhead;
+        unsigned long rest, len;
+        char *nextdata;
+
+        nextdata = data;
+        rest = count;
+        while (rest > 0) {
+                headindex = eerb->head / PAGE_SIZE;
+                localhead = eerb->head % PAGE_SIZE;
+                len = min(rest, (PAGE_SIZE - localhead));
+                memcpy(eerb->buffer[headindex]+localhead, nextdata, len);
+                nextdata += len;
+                rest -= len;
+                eerb->head += len;
+                if ( eerb->head == eerb->buffersize )
+                        eerb->head = 0; /* wrap around */
+                if (eerb->head > eerb->buffersize) {
+                        MESSAGE(KERN_ERR, "%s", "runaway buffer head.");
+                        BUG();
+                }
+        }
+}
+
+/*
+ * needs to be called with bufferlock held
+ */
+static int
+dasd_eer_read_buffer(struct eerbuffer *eerb, int count, char *data)
+{
+
+        unsigned long tailindex,localtail;
+        unsigned long rest, len, finalcount;
+        char *nextdata;
+
+        finalcount = min(count, dasd_eer_get_filled_bytes(eerb));
+        nextdata = data;
+        rest = finalcount;
+        while (rest > 0) {
+                tailindex = eerb->tail / PAGE_SIZE;
+                localtail = eerb->tail % PAGE_SIZE;
+                len = min(rest, (PAGE_SIZE - localtail));
+                memcpy(nextdata, eerb->buffer[tailindex]+localtail, len);
+                nextdata += len;
+                rest -= len;
+                eerb->tail += len;
+                if ( eerb->tail == eerb->buffersize )
+                        eerb->tail = 0; /* wrap around */
+                if (eerb->tail > eerb->buffersize) {
+                        MESSAGE(KERN_ERR, "%s", "runaway buffer tail.");
+                        BUG();
+                }
+        }
+        return finalcount;
+}
+
+/*
+ * Whenever you want to write a blob of data to the internal buffer you
+ * have to start by using this function first. It will write the number
+ * of bytes that will be written to the buffer. If necessary it will remove
+ * old records to make room for the new one.
+ * needs to be called with bufferlock held
+ */
+static int
+dasd_eer_start_record(struct eerbuffer *eerb, int count)
+{
+        int tailcount;
+        if (count + sizeof(count) > eerb->buffersize)
+                return -ENOMEM;
+        while (dasd_eer_get_free_bytes(eerb) < count + sizeof(count)) {
+                if (eerb->residual > 0) {
+                        eerb->tail += eerb->residual;
+                        if (eerb->tail >= eerb->buffersize)
+                                eerb->tail -= eerb->buffersize;
+                        eerb->residual = -1;
+                }
+                dasd_eer_read_buffer(eerb, sizeof(tailcount),
+                                     (char*)(&tailcount));
+                eerb->tail += tailcount;
+                if (eerb->tail >= eerb->buffersize)
+                        eerb->tail -= eerb->buffersize;
+        }
+        dasd_eer_write_buffer(eerb, sizeof(count), (char*)(&count));
+
+        return 0;
+};
+
+/*
+ * release pages that are not used anymore
+ */
+static void
+dasd_eer_free_buffer_pages(char **buf, int no_pages)
+{
+        int i;
+
+        for (i = 0; i < no_pages; ++i) {
+                free_page((unsigned long)buf[i]);
+        }
+}
+
+/*
+ * allocate a new set of memory pages
+ */
+static int
+dasd_eer_allocate_buffer_pages(char **buf, int no_pages)
+{
+        int i;
+
+        for (i = 0; i < no_pages; ++i) {
+                buf[i] = (char *) get_zeroed_page(GFP_KERNEL);
+                if (!buf[i]) {
+                        dasd_eer_free_buffer_pages(buf, i);
+                        return -ENOMEM;
+                }
+        }
+        return 0;
+}
+
+/*
+ * empty the buffer by resetting head and tail
+ * In case there is a half read data blob in the buffer, we set residual
+ * to -1 to indicate that the remainder of the blob is lost.
+ */
+static void
+dasd_eer_purge_buffer(struct eerbuffer *eerb)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&bufferlock, flags);
+        if (eerb->residual > 0)
+                eerb->residual = -1;
+        eerb->tail=0;
+        eerb->head=0;
+        spin_unlock_irqrestore(&bufferlock, flags);
+}
+
+/*
+ * set the size of the buffer, newsize is the new number of pages to be used
+ * we don't try to copy any data back an forth, so any resize will also purge
+ * the buffer
+ */
+static int
+dasd_eer_resize_buffer(struct eerbuffer *eerb, int newsize)
+{
+        int i, oldcount, reuse;
+        char **new;
+        char **old;
+        unsigned long flags;
+
+        if (newsize < 1)
+                return -EINVAL;
+        if (eerb->buffer_page_count == newsize) {
+                /* documented behaviour is that any successfull invocation
+                 * will purge all records */
+                dasd_eer_purge_buffer(eerb);
+                return 0;
+        }
+        new = kmalloc(newsize*sizeof(char*), GFP_KERNEL);
+        if (!new)
+                return -ENOMEM;
+
+        reuse=min(eerb->buffer_page_count, newsize);
+        for (i = 0; i < reuse; ++i) {
+                new[i] = eerb->buffer[i];
+        }
+        if (eerb->buffer_page_count < newsize) {
+                if (dasd_eer_allocate_buffer_pages(
+                            &new[eerb->buffer_page_count],
+                            newsize - eerb->buffer_page_count)) {
+                        kfree(new);
+                        return -ENOMEM;
+                }
+        }
+
+        spin_lock_irqsave(&bufferlock, flags);
+        old = eerb->buffer;
+        eerb->buffer = new;
+        if (eerb->residual > 0)
+                eerb->residual = -1;
+        eerb->tail = 0;
+        eerb->head = 0;
+        oldcount = eerb->buffer_page_count;
+        eerb->buffer_page_count = newsize;
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        if (oldcount > newsize) {
+                for (i = newsize; i < oldcount; ++i) {
+                        free_page((unsigned long)old[i]);
+                }
+        }
+        kfree(old);
+
+        return 0;
+}
+
+
+/*****************************************************************************/
+/*      The extended error reporting functionality                           */
+/*****************************************************************************/
+
+/*
+ * When a DASD device driver wants to report an error, it calls the
+ * function dasd_eer_write_trigger (via a notifier mechanism) and gives the
+ * respective trigger ID as parameter.
+ * Currently there are four kinds of triggers:
+ *
+ * DASD_EER_FATALERROR:  all kinds of unrecoverable I/O problems
+ * DASD_EER_PPRCSUSPEND: PPRC was suspended
+ * DASD_EER_NOPATH:      There is no path to the device left.
+ * DASD_EER_STATECHANGE: The state of the device has changed.
+ *
+ * For the first three triggers all required information can be supplied by
+ * the caller. For these triggers a record is written by the function
+ * dasd_eer_write_standard_trigger.
+ *
+ * When dasd_eer_write_trigger is called to write a DASD_EER_STATECHANGE
+ * trigger, we have to gather the necessary sense data first. We cannot queue
+ * the necessary SNSS (sense subsystem status) request immediatly, since we
+ * are likely to run in a deadlock situation. Instead, we schedule a
+ * work_struct that calls the function dasd_eer_sense_subsystem_status to
+ * create and start an SNSS  request asynchronously.
+ *
+ * To avoid memory allocations at runtime, the necessary memory is allocated
+ * when the extended error reporting is enabled for a device (by
+ * dasd_eer_probe). There is one private eer data structure for each eer
+ * enabled DASD device. It contains memory for the work_struct, one SNSS cqr
+ * and a flags field that is used to coordinate the use of the cqr. The call
+ * to write a state change trigger can come in at any time, so we have one flag
+ * CQR_IN_USE that protects the cqr itself. When this flag indicates that the
+ * cqr is currently in use, dasd_eer_sense_subsystem_status cannot start a
+ * second request but sets the SNSS_REQUESTED flag instead.
+ *
+ * When the request is finished, the callback function dasd_eer_SNSS_cb
+ * is called. This function will invoke the function
+ * dasd_eer_write_SNSS_trigger to finally write the trigger. It will also
+ * check the SNSS_REQUESTED flag and if it is set it will call
+ * dasd_eer_sense_subsystem_status again.
+ *
+ * To avoid race conditions during the handling of the lock, the flags must
+ * be protected by the snsslock.
+ */
+
+struct dasd_eer_private {
+        struct dasd_ccw_req *cqr;
+        unsigned long flags;
+        struct work_struct worker;
+};
+
+static void dasd_eer_destroy(struct dasd_device *device,
+                             struct dasd_eer_private *eer);
+static int
+dasd_eer_write_trigger(struct dasd_eer_trigger *trigger);
+static void dasd_eer_sense_subsystem_status(void *data);
+static int dasd_eer_notify(struct notifier_block *self,
+                           unsigned long action, void *data);
+
+struct workqueue_struct *dasd_eer_workqueue;
+
+#define SNSS_DATA_SIZE 44
+static spinlock_t snsslock = SPIN_LOCK_UNLOCKED;
+
+#define DASD_EER_BUSID_SIZE 10
+struct dasd_eer_header {
+        __u32 total_size;
+        __u32 trigger;
+        __u64 tv_sec;
+        __u64 tv_usec;
+        char busid[DASD_EER_BUSID_SIZE];
+} __attribute__ ((packed));
+
+static struct notifier_block dasd_eer_nb = {
+        .notifier_call = dasd_eer_notify,
+};
+
+/*
+ * flags for use with dasd_eer_private
+ */
+#define CQR_IN_USE     0
+#define SNSS_REQUESTED 1
+
+/*
+ * This function checks if extended error reporting is available for a given
+ * dasd_device. If yes, then it creates and returns a struct dasd_eer,
+ * otherwise it returns an -EPERM error pointer.
+ */
+struct dasd_eer_private *
+dasd_eer_probe(struct dasd_device *device)
+{
+        struct dasd_eer_private *private;
+
+        if (!(device && device->discipline
+              && !strcmp(device->discipline->name, "ECKD"))) {
+                return ERR_PTR(-EPERM);
+        }
+        /* allocate the private data structure */
+        private = (struct dasd_eer_private *)kmalloc(
+                sizeof(struct dasd_eer_private), GFP_KERNEL);
+        if (!private) {
+                return ERR_PTR(-ENOMEM);
+        }
+        INIT_WORK(&private->worker, dasd_eer_sense_subsystem_status,
+                  (void *)device);
+        private->cqr = dasd_kmalloc_request("ECKD",
+                                            1 /* SNSS */ ,
+                                            SNSS_DATA_SIZE ,
+                                            device);
+        if (!private->cqr) {
+                kfree(private);
+                return ERR_PTR(-ENOMEM);
+        }
+        private->flags = 0;
+        return private;
+};
+
+/*
+ * If our private SNSS request is queued, remove it from the
+ * dasd ccw queue so we can free the requests memory.
+ */
+static void
+dasd_eer_dequeue_SNSS_request(struct dasd_device *device,
+                              struct dasd_eer_private *eer)
+{
+        struct list_head *lst, *nxt;
+        struct dasd_ccw_req *cqr, *erpcqr;
+        dasd_erp_fn_t erp_fn;
+
+        spin_lock_irq(get_ccwdev_lock(device->cdev));
+        list_for_each_safe(lst, nxt, &device->ccw_queue) {
+                cqr = list_entry(lst, struct dasd_ccw_req, list);
+                /* we are looking for two kinds or requests */
+                /* first kind: our SNSS request: */
+                if (cqr == eer->cqr) {
+                        if (cqr->status == DASD_CQR_IN_IO)
+                                device->discipline->term_IO(cqr);
+                        list_del(&cqr->list);
+                        break;
+                }
+                /* second kind: ERP requests for our SNSS request */
+                if (cqr->refers) {
+                        /* If this erp request chain ends in our cqr, then */
+                        /* cal the erp_postaction to clean it up  */
+                        erpcqr = cqr;
+                        while (erpcqr->refers) {
+                                erpcqr = erpcqr->refers;
+                        }
+                        if (erpcqr == eer->cqr) {
+                                erp_fn = device->discipline->erp_postaction(
+                                         cqr);
+                                erp_fn(cqr);
+                        }
+                        continue;
+                }
+        }
+        spin_unlock_irq(get_ccwdev_lock(device->cdev));
+}
+
+/*
+ * This function dismantles a struct dasd_eer that was created by
+ * dasd_eer_probe. Since we want to free our private data structure,
+ * we must make sure that the memory is not in use anymore.
+ * We have to flush the work queue and remove a possible SNSS request
+ * from the dasd queue.
+ */
+static void
+dasd_eer_destroy(struct dasd_device *device, struct dasd_eer_private *eer)
+{
+        flush_workqueue(dasd_eer_workqueue);
+        dasd_eer_dequeue_SNSS_request(device, eer);
+        dasd_kfree_request(eer->cqr, device);
+        kfree(eer);
+};
+
+/*
+ * enable the extended error reporting for a particular device
+ */
+static int
+dasd_eer_enable_on_device(struct dasd_device *device)
+{
+        void *eer;
+        if (!device)
+                return -ENODEV;
+        if (device->eer)
+                return 0;
+        if (!try_module_get(THIS_MODULE)) {
+                return -EINVAL;
+        }
+        eer = (void *)dasd_eer_probe(device);
+        if (IS_ERR(eer)) {
+                module_put(THIS_MODULE);
+                return PTR_ERR(eer);
+        }
+        device->eer = eer;
+        return 0;
+}
+
+/*
+ * enable the extended error reporting for a particular device
+ */
+static int
+dasd_eer_disable_on_device(struct dasd_device *device)
+{
+        struct dasd_eer_private *eer = device->eer;
+
+        if (!device)
+                return -ENODEV;
+        if (!device->eer)
+                return 0;
+        device->eer = NULL;
+        dasd_eer_destroy(device,eer);
+        module_put(THIS_MODULE);
+
+        return 0;
+}
+
+/*
+ * Set extended error reporting (eer)
+ * Note: This will be registered as a DASD ioctl, to be called on DASD devices.
+ */
+static int
+dasd_ioctl_set_eer(struct block_device *bdev, int no, long args)
+{
+        struct dasd_device *device;
+        int intval;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+        if (bdev != bdev->bd_contains)
+                /* Error-reporting is not allowed for partitions */
+                return -EINVAL;
+        if (get_user(intval, (int __user *) args))
+                return -EFAULT;
+        device =  bdev->bd_disk->private_data;
+        if (device == NULL)
+                return -ENODEV;
+
+        intval = (intval != 0);
+        DEV_MESSAGE (KERN_DEBUG, device,
+                     "set eer on device to %d", intval);
+        if (intval)
+                return dasd_eer_enable_on_device(device);
+        else
+                return dasd_eer_disable_on_device(device);
+}
+
+/*
+ * Get value of extended error reporting.
+ * Note: This will be registered as a DASD ioctl, to be called on DASD devices.
+ */
+static int
+dasd_ioctl_get_eer(struct block_device *bdev, int no, long args)
+{
+        struct dasd_device *device;
+
+        device =  bdev->bd_disk->private_data;
+        if (device == NULL)
+                return -ENODEV;
+        return put_user((device->eer != NULL), (int __user *) args);
+}
+
+/*
+ * The following function can be used for those triggers that have
+ * all necessary data available when the function is called.
+ * If the parameter cqr is not NULL, the chain of requests will be searched
+ * for valid sense data, and all valid sense data sets will be added to
+ * the triggers data.
+ */
+static int
+dasd_eer_write_standard_trigger(int trigger, struct dasd_device *device,
+                                struct dasd_ccw_req *cqr)
+{
+        struct dasd_ccw_req *temp_cqr;
+        int data_size;
+        struct timeval tv;
+        struct dasd_eer_header header;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        /* go through cqr chain and count the valid sense data sets */
+        temp_cqr = cqr;
+        data_size = 0;
+        while (temp_cqr) {
+                if (temp_cqr->irb.esw.esw0.erw.cons)
+                        data_size += 32;
+                temp_cqr = temp_cqr->refers;
+        }
+
+        header.total_size = sizeof(header) + data_size + 4; /* "EOR" */
+        header.trigger = trigger;
+        do_gettimeofday(&tv);
+        header.tv_sec = tv.tv_sec;
+        header.tv_usec = tv.tv_usec;
+        strncpy(header.busid, device->cdev->dev.bus_id, DASD_EER_BUSID_SIZE);
+
+        spin_lock_irqsave(&bufferlock, flags);
+        list_for_each_entry(eerb, &bufferlist, list) {
+                dasd_eer_start_record(eerb, header.total_size);
+                dasd_eer_write_buffer(eerb, sizeof(header), (char*)(&header));
+                temp_cqr = cqr;
+                while (temp_cqr) {
+                        if (temp_cqr->irb.esw.esw0.erw.cons)
+                                dasd_eer_write_buffer(eerb, 32, cqr->irb.ecw);
+                        temp_cqr = temp_cqr->refers;
+                }
+                dasd_eer_write_buffer(eerb, 4,"EOR");
+        }
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        wake_up_interruptible(&dasd_eer_read_wait_queue);
+
+        return 0;
+}
+
+/*
+ * This function writes a DASD_EER_STATECHANGE trigger.
+ */
+static void
+dasd_eer_write_SNSS_trigger(struct dasd_device *device,
+                            struct dasd_ccw_req *cqr)
+{
+        int data_size;
+        int snss_rc;
+        struct timeval tv;
+        struct dasd_eer_header header;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        snss_rc = (cqr->status == DASD_CQR_FAILED) ? -EIO : 0;
+        if (snss_rc)
+                data_size = 0;
+        else
+                data_size = SNSS_DATA_SIZE;
+
+        header.total_size = sizeof(header) + data_size + 4; /* "EOR" */
+        header.trigger = DASD_EER_STATECHANGE;
+        do_gettimeofday(&tv);
+        header.tv_sec = tv.tv_sec;
+        header.tv_usec = tv.tv_usec;
+        strncpy(header.busid, device->cdev->dev.bus_id, DASD_EER_BUSID_SIZE);
+
+        spin_lock_irqsave(&bufferlock, flags);
+        list_for_each_entry(eerb, &bufferlist, list) {
+                dasd_eer_start_record(eerb, header.total_size);
+                dasd_eer_write_buffer(eerb, sizeof(header),(char*)(&header));
+                if (!snss_rc)
+                        dasd_eer_write_buffer(eerb, SNSS_DATA_SIZE, cqr->data);
+                dasd_eer_write_buffer(eerb, 4,"EOR");
+        }
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        wake_up_interruptible(&dasd_eer_read_wait_queue);
+}
+
+/*
+ * callback function for use with SNSS request
+ */
+static void
+dasd_eer_SNSS_cb(struct dasd_ccw_req *cqr, void *data)
+{
+        struct dasd_device *device;
+        struct dasd_eer_private *private;
+        unsigned long irqflags;
+
+        device = (struct dasd_device *)data;
+        private = (struct dasd_eer_private *)device->eer;
+        dasd_eer_write_SNSS_trigger(device, cqr);
+        spin_lock_irqsave(&snsslock, irqflags);
+        if(!test_and_clear_bit(SNSS_REQUESTED, &private->flags)) {
+                clear_bit(CQR_IN_USE, &private->flags);
+                spin_unlock_irqrestore(&snsslock, irqflags);
+                return;
+        };
+        clear_bit(CQR_IN_USE, &private->flags);
+        spin_unlock_irqrestore(&snsslock, irqflags);
+        dasd_eer_sense_subsystem_status(device);
+        return;
+}
+
+/*
+ * clean a used cqr before using it again
+ */
+static void
+dasd_eer_clean_SNSS_request(struct dasd_ccw_req *cqr)
+{
+        struct ccw1 *cpaddr = cqr->cpaddr;
+        void *data = cqr->data;
+
+        memset(cqr, 0, sizeof(struct dasd_ccw_req));
+        memset(cpaddr, 0, sizeof(struct ccw1));
+        memset(data, 0, SNSS_DATA_SIZE);
+        cqr->cpaddr = cpaddr;
+        cqr->data = data;
+        strncpy((char *) &cqr->magic, "ECKD", 4);
+        ASCEBC((char *) &cqr->magic, 4);
+        set_bit(DASD_CQR_FLAGS_USE_ERP, &cqr->flags);
+}
+
+/*
+ * build and start an SNSS request
+ * This function is called from a work queue so we have to
+ * pass the dasd_device pointer as a void pointer.
+ */
+static void
+dasd_eer_sense_subsystem_status(void *data)
+{
+        struct dasd_device *device;
+        struct dasd_eer_private *private;
+        struct dasd_ccw_req *cqr;
+        struct ccw1 *ccw;
+        unsigned long irqflags;
+
+        device = (struct dasd_device *)data;
+        private = (struct dasd_eer_private *)device->eer;
+        if (!private) /* device not eer enabled any more */
+                return;
+        cqr = private->cqr;
+        spin_lock_irqsave(&snsslock, irqflags);
+        if(test_and_set_bit(CQR_IN_USE, &private->flags)) {
+                set_bit(SNSS_REQUESTED, &private->flags);
+                spin_unlock_irqrestore(&snsslock, irqflags);
+                return;
+        };
+        spin_unlock_irqrestore(&snsslock, irqflags);
+        dasd_eer_clean_SNSS_request(cqr);
+        cqr->device = device;
+        cqr->retries = 255;
+        cqr->expires = 10 * HZ;
+
+        ccw = cqr->cpaddr;
+        ccw->cmd_code = DASD_ECKD_CCW_SNSS;
+        ccw->count = SNSS_DATA_SIZE;
+        ccw->flags = 0;
+        ccw->cda = (__u32)(addr_t)cqr->data;
+
+        cqr->buildclk = get_clock();
+        cqr->status = DASD_CQR_FILLED;
+        cqr->callback = dasd_eer_SNSS_cb;
+        cqr->callback_data = (void *)device;
+        dasd_add_request_head(cqr);
+
+        return;
+}
+
+/*
+ * This function is called for all triggers. It calls the appropriate
+ * function that writes the actual trigger records.
+ */
+static int
+dasd_eer_write_trigger(struct dasd_eer_trigger *trigger)
+{
+        int rc;
+        struct dasd_eer_private *private = trigger->device->eer;
+
+        switch (trigger->id) {
+        case DASD_EER_FATALERROR:
+        case DASD_EER_PPRCSUSPEND:
+                rc = dasd_eer_write_standard_trigger(
+                        trigger->id, trigger->device, trigger->cqr);
+                break;
+        case DASD_EER_NOPATH:
+                rc = dasd_eer_write_standard_trigger(
+                        trigger->id, trigger->device, NULL);
+                break;
+        case DASD_EER_STATECHANGE:
+                if (queue_work(dasd_eer_workqueue, &private->worker)) {
+                        rc=0;
+                } else {
+                        /* If the work_struct was already queued, it can't
+                         * be queued again. But this is OK since we don't
+                         * need to have it queued twice.
+                         */
+                        rc = -EBUSY;
+                }
+                break;
+        default: /* unknown trigger, so we write it without any sense data */
+                rc = dasd_eer_write_standard_trigger(
+                        trigger->id, trigger->device, NULL);
+                break;
+        }
+        return rc;
+}
+
+/*
+ * This function is registered with the dasd device driver and gets called
+ * for all dasd eer notifications.
+ */
+static int dasd_eer_notify(struct notifier_block *self,
+                            unsigned long action, void *data)
+{
+        switch (action) {
+        case DASD_EER_DISABLE:
+                dasd_eer_disable_on_device((struct dasd_device *)data);
+                break;
+        case DASD_EER_TRIGGER:
+                dasd_eer_write_trigger((struct dasd_eer_trigger *)data);
+                break;
+        }
+        return NOTIFY_OK;
+}
+
+
+/*****************************************************************************/
+/*      the device operations                                                */
+/*****************************************************************************/
+
+/*
+ * On the one side we need a lock to access our internal buffer, on the
+ * other side a copy_to_user can sleep. So we need to copy the data we have
+ * to transfer in a readbuffer, which is protected by the readbuffer_mutex.
+ */
+static char readbuffer[PAGE_SIZE];
+DECLARE_MUTEX(readbuffer_mutex);
+
+
+static int
+dasd_eer_open(struct inode *inp, struct file *filp)
+{
+        struct eerbuffer *eerb;
+        unsigned long flags;
+
+        eerb = kmalloc(sizeof(struct eerbuffer), GFP_KERNEL);
+        eerb->head = 0;
+        eerb->tail = 0;
+        eerb->residual = 0;
+        eerb->buffer_page_count = 1;
+        eerb->buffersize = eerb->buffer_page_count * PAGE_SIZE;
+        eerb->buffer = kmalloc(eerb->buffer_page_count*sizeof(char*),
+                               GFP_KERNEL);
+        if (!eerb->buffer)
+                return -ENOMEM;
+        if (dasd_eer_allocate_buffer_pages(eerb->buffer,
+                                           eerb->buffer_page_count)) {
+                kfree(eerb->buffer);
+                return -ENOMEM;
+        }
+        filp->private_data = eerb;
+        spin_lock_irqsave(&bufferlock, flags);
+        list_add(&eerb->list, &bufferlist);
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        return nonseekable_open(inp,filp);
+}
+
+static int
+dasd_eer_close(struct inode *inp, struct file *filp)
+{
+        struct eerbuffer *eerb;
+        unsigned long flags;
+
+        eerb = (struct eerbuffer *)filp->private_data;
+        spin_lock_irqsave(&bufferlock, flags);
+        list_del(&eerb->list);
+        spin_unlock_irqrestore(&bufferlock, flags);
+        dasd_eer_free_buffer_pages(eerb->buffer, eerb->buffer_page_count);
+        kfree(eerb->buffer);
+        kfree(eerb);
+
+        return 0;
+}
+
+static long
+dasd_eer_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+        int intval;
+        struct eerbuffer *eerb;
+
+        eerb = (struct eerbuffer *)filp->private_data;
+        switch (cmd) {
+        case DASD_EER_PURGE:
+                dasd_eer_purge_buffer(eerb);
+                return 0;
+        case DASD_EER_SETBUFSIZE:
+                if (get_user(intval, (int __user *)arg))
+                        return -EFAULT;
+                return dasd_eer_resize_buffer(eerb, intval);
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
+
+static ssize_t
+dasd_eer_read(struct file *filp, char __user *buf, size_t count, loff_t *ppos)
+{
+        int tc,rc;
+        int tailcount,effective_count;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        eerb = (struct eerbuffer *)filp->private_data;
+        if(down_interruptible(&readbuffer_mutex))
+                return -ERESTARTSYS;
+
+        spin_lock_irqsave(&bufferlock, flags);
+
+        if (eerb->residual < 0) { /* the remainder of this record */
+                                  /* has been deleted             */
+                eerb->residual = 0;
+                spin_unlock_irqrestore(&bufferlock, flags);
+                up(&readbuffer_mutex);
+                return -EIO;
+        } else if (eerb->residual > 0) {
+                /* OK we still have a second half of a record to deliver */
+                effective_count = min(eerb->residual, (int)count);
+                eerb->residual -= effective_count;
+        } else {
+                tc = 0;
+                while (!tc) {
+                        tc = dasd_eer_read_buffer(eerb,
+                                sizeof(tailcount), (char*)(&tailcount));
+                        if (!tc) {
+                                /* no data available */
+                                spin_unlock_irqrestore(&bufferlock, flags);
+                                up(&readbuffer_mutex);
+                                if (filp->f_flags & O_NONBLOCK)
+                                        return -EAGAIN;
+                                rc = wait_event_interruptible(
+                                        dasd_eer_read_wait_queue,
+                                        eerb->head != eerb->tail);
+                                if (rc) {
+                                        return rc;
+                                }
+                                if(down_interruptible(&readbuffer_mutex))
+                                        return -ERESTARTSYS;
+                                spin_lock_irqsave(&bufferlock, flags);
+                        }
+                }
+                WARN_ON(tc != sizeof(tailcount));
+                effective_count = min(tailcount,(int)count);
+                eerb->residual = tailcount - effective_count;
+        }
+
+        tc = dasd_eer_read_buffer(eerb, effective_count, readbuffer);
+        WARN_ON(tc != effective_count);
+
+        spin_unlock_irqrestore(&bufferlock, flags);
+
+        if (copy_to_user(buf, readbuffer, effective_count)) {
+                up(&readbuffer_mutex);
+                return -EFAULT;
+        }
+
+        up(&readbuffer_mutex);
+        return effective_count;
+}
+
+static unsigned int
+dasd_eer_poll (struct file *filp, poll_table *ptable)
+{
+        unsigned int mask;
+        unsigned long flags;
+        struct eerbuffer *eerb;
+
+        eerb = (struct eerbuffer *)filp->private_data;
+        poll_wait(filp, &dasd_eer_read_wait_queue, ptable);
+        spin_lock_irqsave(&bufferlock, flags);
+        if (eerb->head != eerb->tail)
+                mask = POLLIN | POLLRDNORM ;
+        else
+                mask = 0;
+        spin_unlock_irqrestore(&bufferlock, flags);
+        return mask;
+}
+
+static struct file_operations dasd_eer_fops = {
+        .open           = &dasd_eer_open,
+        .release        = &dasd_eer_close,
+        .unlocked_ioctl = &dasd_eer_ioctl,
+        .compat_ioctl   = &dasd_eer_ioctl,
+        .read           = &dasd_eer_read,
+        .poll           = &dasd_eer_poll,
+        .owner          = THIS_MODULE,
+};
+
+static struct miscdevice dasd_eer_dev = {
+        .minor      = MISC_DYNAMIC_MINOR,
+        .name       = "dasd_eer",
+        .fops       = &dasd_eer_fops,
+};
+
+
+/*****************************************************************************/
+/*      Init and exit                                                        */
+/*****************************************************************************/
+
+static int
+__init dasd_eer_init(void)
+{
+        int rc;
+
+        dasd_eer_workqueue = create_singlethread_workqueue("dasd_eer");
+        if (!dasd_eer_workqueue) {
+                MESSAGE(KERN_ERR , "%s", "dasd_eer_init could not "
+                       "create workqueue \n");
+                rc = -ENOMEM;
+                goto out;
+        }
+
+        rc = dasd_register_eer_notifier(&dasd_eer_nb);
+        if (rc) {
+                MESSAGE(KERN_ERR, "%s", "dasd_eer_init could not "
+                       "register error reporting");
+                goto queue;
+        }
+
+        dasd_ioctl_no_register(THIS_MODULE, BIODASDEERSET, dasd_ioctl_set_eer);
+        dasd_ioctl_no_register(THIS_MODULE, BIODASDEERGET, dasd_ioctl_get_eer);
+
+        /* we don't need our own character device,
+         * so we just register as misc device */
+        rc = misc_register(&dasd_eer_dev);
+        if (rc) {
+                MESSAGE(KERN_ERR, "%s", "dasd_eer_init could not "
+                       "register misc device");
+                goto unregister;
+        }
+
+        return 0;
+
+unregister:
+        dasd_unregister_eer_notifier(&dasd_eer_nb);
+        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERSET,
+                                 dasd_ioctl_set_eer);
+        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERGET,
+                                 dasd_ioctl_get_eer);
+queue:
+        destroy_workqueue(dasd_eer_workqueue);
+out:
+        return rc;
+
+}
+module_init(dasd_eer_init);
+
+static void
+__exit dasd_eer_exit(void)
+{
+        dasd_unregister_eer_notifier(&dasd_eer_nb);
+        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERSET,
+                                 dasd_ioctl_set_eer);
+        dasd_ioctl_no_unregister(THIS_MODULE, BIODASDEERGET,
+                                 dasd_ioctl_get_eer);
+        destroy_workqueue(dasd_eer_workqueue);
+
+        WARN_ON(misc_deregister(&dasd_eer_dev) != 0);
+}
+module_exit(dasd_eer_exit);
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index c20af9874500..d1b08fa13fd2 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -275,6 +275,34 @@ struct dasd_discipline {
 
 extern struct dasd_discipline *dasd_diag_discipline_pointer;
 
+
+/*
+ * Notification numbers for extended error reporting notifications:
+ * The DASD_EER_DISABLE notification is sent before a dasd_device (and it's
+ * eer pointer) is freed. The error reporting module needs to do all necessary
+ * cleanup steps.
+ * The DASD_EER_TRIGGER notification sends the actual error reports (triggers).
+ */
+#define DASD_EER_DISABLE 0
+#define DASD_EER_TRIGGER 1
+
+/* Trigger IDs for extended error reporting DASD_EER_TRIGGER notification */
+#define DASD_EER_FATALERROR  1
+#define DASD_EER_NOPATH      2
+#define DASD_EER_STATECHANGE 3
+#define DASD_EER_PPRCSUSPEND 4
+
+/*
+ * The dasd_eer_trigger structure contains all data that we need to send
+ * along with an DASD_EER_TRIGGER notification.
+ */
+struct dasd_eer_trigger {
+        unsigned int id;
+        struct dasd_device *device;
+        struct dasd_ccw_req *cqr;
+};
+
+
 struct dasd_device {
         /* Block device stuff. */
         struct gendisk *gdp;
@@ -288,6 +316,9 @@ struct dasd_device {
         unsigned long flags;            /* per device flags */
         unsigned short features;        /* copy of devmap-features (read-only!) */
 
+        /* extended error reporting stuff (eer) */
+        void *eer;
+
         /* Device discipline stuff. */
         struct dasd_discipline *discipline;
         char *private;
@@ -488,6 +519,12 @@ int dasd_generic_set_online(struct ccw_device *, struct dasd_discipline *);
 int dasd_generic_set_offline (struct ccw_device *cdev);
 int dasd_generic_notify(struct ccw_device *, int);
 void dasd_generic_auto_online (struct ccw_driver *);
+int dasd_register_eer_notifier(struct notifier_block *);
+int dasd_unregister_eer_notifier(struct notifier_block *);
+void dasd_write_eer_trigger(unsigned int , struct dasd_device *,
+                        struct dasd_ccw_req *);
+
+
 
 /* externals in dasd_devmap.c */
 extern int dasd_max_devindex;
diff --git a/drivers/s390/cio/chsc.h b/drivers/s390/cio/chsc.h
index 44e4b4bb1c5a..3e75095f35d0 100644
--- a/drivers/s390/cio/chsc.h
+++ b/drivers/s390/cio/chsc.h
@@ -68,6 +68,6 @@ extern void *chsc_get_chp_desc(struct subchannel*, int);
 
 extern int chsc_enable_facility(int);
 
-#define to_channelpath(dev) container_of(dev, struct channel_path, dev)
+#define to_channelpath(device) container_of(device, struct channel_path, dev)
 
 #endif
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index 38d6d00fb0fc..014cc8d54a9f 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -38,10 +38,10 @@
 #include <linux/slab.h>
 #include <linux/completion.h>
 #include <linux/blkdev.h>
+#include <linux/delay.h>
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <asm/semaphore.h>
-#include <asm/delay.h>
 
 #include "aacraid.h"
 
diff --git a/drivers/scsi/mac53c94.c b/drivers/scsi/mac53c94.c
index 311a4122bd70..93edaa8696cf 100644
--- a/drivers/scsi/mac53c94.c
+++ b/drivers/scsi/mac53c94.c
@@ -537,9 +537,9 @@ static int mac53c94_remove(struct macio_dev *mdev)
         free_irq(fp->intr, fp);
 
         if (fp->regs)
-                iounmap((void *) fp->regs);
+                iounmap(fp->regs);
         if (fp->dma)
-                iounmap((void *) fp->dma);
+                iounmap(fp->dma);
         kfree(fp->dma_cmd_space);
 
         scsi_host_put(host);
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 245ca99a641e..c551bb84dbfb 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -1245,7 +1245,7 @@ static int __init init_scsi(void)
         if (error)
                 goto cleanup_sysctl;
 
-        for (i = 0; i < NR_CPUS; i++)
+        for_each_cpu(i)
                 INIT_LIST_HEAD(&per_cpu(scsi_done_q, i));
 
         devfs_mk_dir("scsi");
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index 59a1c9d9d3bd..723f7acbeb12 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -463,7 +463,7 @@ static inline struct list_head *skb_to_lh(struct sk_buff *skb)
 }
 
 static void*
-mempool_zone_alloc_skb(unsigned int gfp_mask, void *pool_data)
+mempool_zone_alloc_skb(gfp_t gfp_mask, void *pool_data)
 {
         struct mempool_zone *zone = pool_data;
 
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 7d0700091f3d..2a547538d444 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -1679,7 +1679,7 @@ static int
 sg_build_sgat(Sg_scatter_hold * schp, const Sg_fd * sfp, int tablesize)
 {
         int sg_bufflen = tablesize * sizeof(struct scatterlist);
-        unsigned int gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
+        gfp_t gfp_flags = GFP_ATOMIC | __GFP_NOWARN;
 
         /*
          * TODO: test without low_dma, we should not need it since
diff --git a/drivers/serial/21285.c b/drivers/serial/21285.c
index 7aef7518b0d1..8c5c276c5577 100644
--- a/drivers/serial/21285.c
+++ b/drivers/serial/21285.c
@@ -362,7 +362,7 @@ static struct uart_ops serial21285_ops = {
 
 static struct uart_port serial21285_port = {
         .mapbase        = 0x42000160,
-        .iotype         = SERIAL_IO_MEM,
+        .iotype         = UPIO_MEM,
         .irq            = NO_IRQ,
         .fifosize       = 16,
         .ops            = &serial21285_ops,
diff --git a/drivers/serial/68328serial.c b/drivers/serial/68328serial.c
index 8cbf0fc5a225..7f0f35a05dca 100644
--- a/drivers/serial/68328serial.c
+++ b/drivers/serial/68328serial.c
@@ -332,7 +332,7 @@ static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *reg
                  * Make sure that we do not overflow the buffer
                  */
                 if (tty_request_buffer_room(tty, 1) == 0) {
-                        schedule_work(&tty->flip.work);
+                        tty_schedule_flip(tty);
                         return;
                 }
 
@@ -353,7 +353,7 @@ static _INLINE_ void receive_chars(struct m68k_serial *info, struct pt_regs *reg
         } while((rx = uart->urx.w) & URX_DATA_READY);
 #endif
 
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
 
 clear_and_exit:
         return;
diff --git a/drivers/serial/68360serial.c b/drivers/serial/68360serial.c
index 60f5a5dc17f1..9843ae3d420e 100644
--- a/drivers/serial/68360serial.c
+++ b/drivers/serial/68360serial.c
@@ -509,7 +509,7 @@ static _INLINE_ void receive_chars(ser_info_t *info)
 
         info->rx_cur = (QUICC_BD *)bdp;
 
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
 }
 
 static _INLINE_ void receive_break(ser_info_t *info)
@@ -521,7 +521,7 @@ static _INLINE_ void receive_break(ser_info_t *info)
          * the break.  If not, we exit now, losing the break.  FIXME
          */
         tty_insert_flip_char(tty, 0, TTY_BREAK);
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
 }
 
 static _INLINE_ void transmit_chars(ser_info_t *info)
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 179c1f065e60..b1fc97d5f643 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2229,6 +2229,7 @@ serial8250_console_write(struct console *co, const char *s, unsigned int count)
          *      and restore the IER
          */
         wait_for_xmitr(up, BOTH_EMPTY);
+        up->ier |= UART_IER_THRI;
         serial_out(up, UART_IER, ier | UART_IER_THRI);
 }
 
diff --git a/drivers/serial/8250_au1x00.c b/drivers/serial/8250_au1x00.c
index 06ae8fbcc947..8d8d7a70d03e 100644
--- a/drivers/serial/8250_au1x00.c
+++ b/drivers/serial/8250_au1x00.c
@@ -56,7 +56,6 @@ static struct plat_serial8250_port au1x00_data[] = {
 #elif defined(CONFIG_SOC_AU1550)
         PORT(UART0_ADDR, AU1550_UART0_INT),
         PORT(UART1_ADDR, AU1550_UART1_INT),
-        PORT(UART2_ADDR, AU1550_UART2_INT),
         PORT(UART3_ADDR, AU1550_UART3_INT),
 #elif defined(CONFIG_SOC_AU1200)
         PORT(UART0_ADDR, AU1200_UART0_INT),
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index 2a912153321e..94886c000d2a 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -439,6 +439,20 @@ static int pci_siig_init(struct pci_dev *dev)
         return -ENODEV;
 }
 
+static int pci_siig_setup(struct serial_private *priv,
+                          struct pciserial_board *board,
+                          struct uart_port *port, int idx)
+{
+        unsigned int bar = FL_GET_BASE(board->flags) + idx, offset = 0;
+
+        if (idx > 3) {
+                bar = 4;
+                offset = (idx - 4) * 8;
+        }
+
+        return setup_port(priv, port, bar, offset, 0);
+}
+
 /*
  * Timedia has an explosion of boards, and to avoid the PCI table from
  * growing *huge*, we use this function to collapse some 70 entries
@@ -748,7 +762,7 @@ static struct pci_serial_quirk pci_serial_quirks[] = {
                 .subvendor      = PCI_ANY_ID,
                 .subdevice      = PCI_ANY_ID,
                 .init           = pci_siig_init,
-                .setup          = pci_default_setup,
+                .setup          = pci_siig_setup,
         },
         /*
          * Titan cards
@@ -1868,6 +1882,10 @@ static struct pci_device_id serial_pci_tbl[] = {
                 PCI_SUBVENDOR_ID_CONNECT_TECH,
                 PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_4, 0, 0,
                 pbn_b0_4_1843200 },
+        {       PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
+                PCI_VENDOR_ID_AFAVLAB,
+                PCI_SUBDEVICE_ID_AFAVLAB_P061, 0, 0,
+                pbn_b0_4_1152000 },
         {       PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
                 PCI_SUBVENDOR_ID_CONNECT_TECH,
                 PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_232, 0, 0,
@@ -2141,6 +2159,15 @@ static struct pci_device_id serial_pci_tbl[] = {
         {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_850,
                 PCI_ANY_ID, PCI_ANY_ID, 0, 0,
                 pbn_b0_bt_4_921600 },
+        {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_550,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_bt_8_921600 },
+        {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_650,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_bt_8_921600 },
+        {       PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_850,
+                PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+                pbn_b0_bt_8_921600 },
 
         /*
          * Computone devices submitted by Doug McNash dmcnash@computone.com
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 0d38f0f2ae29..0f4361c8466b 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -98,6 +98,7 @@ config SERIAL_8250_NR_UARTS
 config SERIAL_8250_RUNTIME_UARTS
         int "Number of 8250/16550 serial ports to register at runtime"
         depends on SERIAL_8250
+        range 0 SERIAL_8250_NR_UARTS
         default "4"
         help
           Set this to the maximum number of serial ports you want
@@ -892,20 +893,20 @@ config SERIAL_VR41XX_CONSOLE
           a console on a serial port, say Y.  Otherwise, say N.
 
 config SERIAL_JSM
-        tristate "Digi International NEO PCI Support"
-        depends on PCI && BROKEN
-        select SERIAL_CORE
-        help
-          This is a driver for Digi International's Neo series
-          of cards which provide multiple serial ports. You would need
-          something like this to connect more than two modems to your Linux
-          box, for instance in order to become a dial-in server. This driver
-          supports PCI boards only.
-          If you have a card like this, say Y here and read the file
-          <file:Documentation/jsm.txt>.
-
-          To compile this driver as a module, choose M here: the
-          module will be called jsm.
+        tristate "Digi International NEO PCI Support"
+        depends on PCI
+        select SERIAL_CORE
+        help
+          This is a driver for Digi International's Neo series
+          of cards which provide multiple serial ports. You would need
+          something like this to connect more than two modems to your Linux
+          box, for instance in order to become a dial-in server. This driver
+          supports PCI boards only.
+          If you have a card like this, say Y here and read the file
+          <file:Documentation/jsm.txt>.
+
+          To compile this driver as a module, choose M here: the
+          module will be called jsm.
 
 config SERIAL_SGI_IOC4
         tristate "SGI IOC4 controller serial support"
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 429de2723a1c..321a3b3a5728 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -561,7 +561,7 @@ static struct uart_amba_port amba_ports[UART_NR] = {
                 .port   = {
                         .membase        = (void *)IO_ADDRESS(INTEGRATOR_UART0_BASE),
                         .mapbase        = INTEGRATOR_UART0_BASE,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = IRQ_UARTINT0,
                         .uartclk        = 14745600,
                         .fifosize       = 16,
@@ -576,7 +576,7 @@ static struct uart_amba_port amba_ports[UART_NR] = {
                 .port   = {
                         .membase        = (void *)IO_ADDRESS(INTEGRATOR_UART1_BASE),
                         .mapbase        = INTEGRATOR_UART1_BASE,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = IRQ_UARTINT1,
                         .uartclk        = 14745600,
                         .fifosize       = 16,
diff --git a/drivers/serial/au1x00_uart.c b/drivers/serial/au1x00_uart.c
index ceb5d7f37bbd..344022fe53ef 100644
--- a/drivers/serial/au1x00_uart.c
+++ b/drivers/serial/au1x00_uart.c
@@ -892,7 +892,7 @@ serial8250_request_std_resource(struct uart_8250_port *up, struct resource **res
         int ret = 0;
 
         switch (up->port.iotype) {
-        case SERIAL_IO_MEM:
+        case UPIO_MEM:
                 if (up->port.mapbase) {
                         *res = request_mem_region(up->port.mapbase, size, "serial");
                         if (!*res)
@@ -900,8 +900,8 @@ serial8250_request_std_resource(struct uart_8250_port *up, struct resource **res
                 }
                 break;
 
-        case SERIAL_IO_HUB6:
-        case SERIAL_IO_PORT:
+        case UPIO_HUB6:
+        case UPIO_PORT:
                 *res = request_region(up->port.iobase, size, "serial");
                 if (!*res)
                         ret = -EBUSY;
@@ -919,7 +919,7 @@ static void serial8250_release_port(struct uart_port *port)
         size <<= up->port.regshift;
 
         switch (up->port.iotype) {
-        case SERIAL_IO_MEM:
+        case UPIO_MEM:
                 if (up->port.mapbase) {
                         /*
                          * Unmap the area.
@@ -935,8 +935,8 @@ static void serial8250_release_port(struct uart_port *port)
                 }
                 break;
 
-        case SERIAL_IO_HUB6:
-        case SERIAL_IO_PORT:
+        case UPIO_HUB6:
+        case UPIO_PORT:
                 start = up->port.iobase;
 
                 if (size)
diff --git a/drivers/serial/cpm_uart/cpm_uart_core.c b/drivers/serial/cpm_uart/cpm_uart_core.c
index 16af5626c243..b7bf4c698a47 100644
--- a/drivers/serial/cpm_uart/cpm_uart_core.c
+++ b/drivers/serial/cpm_uart/cpm_uart_core.c
@@ -252,12 +252,9 @@ static void cpm_uart_int_rx(struct uart_port *port, struct pt_regs *regs)
                 /* If we have not enough room in tty flip buffer, then we try
                  * later, which will be the next rx-interrupt or a timeout
                  */
-                if ((tty->flip.count + i) >= TTY_FLIPBUF_SIZE) {
-                        tty->flip.work.func((void *)tty);
-                        if ((tty->flip.count + i) >= TTY_FLIPBUF_SIZE) {
-                                printk(KERN_WARNING "TTY_DONT_FLIP set\n");
-                                return;
-                        }
+                if(tty_buffer_request_room(tty, i) < i) {
+                        printk(KERN_WARNING "No room in flip buffer\n");
+                        return;
                 }
 
                 /* get pointer */
@@ -276,9 +273,7 @@ static void cpm_uart_int_rx(struct uart_port *port, struct pt_regs *regs)
                                 continue;
 
                       error_return:
-                        *tty->flip.char_buf_ptr++ = ch;
-                        *tty->flip.flag_buf_ptr++ = flg;
-                        tty->flip.count++;
+                        tty_insert_flip_char(tty, ch, flg);
 
                 }               /* End while (i--) */
 
@@ -908,7 +903,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                 .port = {
                         .irq            = SMC1_IRQ,
                         .ops            = &cpm_uart_pops,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .lock           = SPIN_LOCK_UNLOCKED,
                 },
                 .flags = FLAG_SMC,
@@ -922,7 +917,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                 .port = {
                         .irq            = SMC2_IRQ,
                         .ops            = &cpm_uart_pops,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .lock           = SPIN_LOCK_UNLOCKED,
                 },
                 .flags = FLAG_SMC,
@@ -939,7 +934,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                 .port = {
                         .irq            = SCC1_IRQ,
                         .ops            = &cpm_uart_pops,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .lock           = SPIN_LOCK_UNLOCKED,
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
@@ -953,7 +948,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                 .port = {
                         .irq            = SCC2_IRQ,
                         .ops            = &cpm_uart_pops,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .lock           = SPIN_LOCK_UNLOCKED,
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
@@ -967,7 +962,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                 .port = {
                         .irq            = SCC3_IRQ,
                         .ops            = &cpm_uart_pops,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .lock           = SPIN_LOCK_UNLOCKED,
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
@@ -981,7 +976,7 @@ struct uart_cpm_port cpm_uart_ports[UART_NR] = {
                 .port = {
                         .irq            = SCC4_IRQ,
                         .ops            = &cpm_uart_pops,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .lock           = SPIN_LOCK_UNLOCKED,
                 },
                 .tx_nrfifos = TX_NUM_FIFO,
diff --git a/drivers/serial/dz.c b/drivers/serial/dz.c
index a64ba26a94e8..ba5541de673b 100644
--- a/drivers/serial/dz.c
+++ b/drivers/serial/dz.c
@@ -262,6 +262,7 @@ static inline void dz_receive_chars(struct dz_port *dport)
                 }
                 tty_insert_flip_char(tty, ch, flag);
               ignore_char:
+                        ;
         } while (status & DZ_DVAL);
 
         if (tty)
@@ -650,7 +651,7 @@ static void __init dz_init_ports(void)
         for (i = 0, dport = dz_ports; i < DZ_NB_PORT; i++, dport++) {
                 spin_lock_init(&dport->port.lock);
                 dport->port.membase     = (char *) base;
-                dport->port.iotype      = SERIAL_IO_PORT;
+                dport->port.iotype      = UPIO_PORT;
                 dport->port.irq         = dec_interrupt[DEC_IRQ_DZ11];
                 dport->port.line        = i;
                 dport->port.fifosize    = 1;
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index 858048efe1ed..4d53fb5ca87b 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -668,7 +668,7 @@ static struct imx_port imx_ports[] = {
         .rtsirq = UART1_MINT_RTS,
         .port   = {
                 .type           = PORT_IMX,
-                .iotype         = SERIAL_IO_MEM,
+                .iotype         = UPIO_MEM,
                 .membase        = (void *)IMX_UART1_BASE,
                 .mapbase        = IMX_UART1_BASE, /* FIXME */
                 .irq            = UART1_MINT_RX,
@@ -684,7 +684,7 @@ static struct imx_port imx_ports[] = {
         .rtsirq = UART2_MINT_RTS,
         .port   = {
                 .type           = PORT_IMX,
-                .iotype         = SERIAL_IO_MEM,
+                .iotype         = UPIO_MEM,
                 .membase        = (void *)IMX_UART2_BASE,
                 .mapbase        = IMX_UART2_BASE, /* FIXME */
                 .irq            = UART2_MINT_RX,
diff --git a/drivers/serial/ip22zilog.c b/drivers/serial/ip22zilog.c
index 66f117d15065..419dd3cd7862 100644
--- a/drivers/serial/ip22zilog.c
+++ b/drivers/serial/ip22zilog.c
@@ -215,7 +215,7 @@ static void __load_zsregs(struct zilog_channel *channel, unsigned char *regs)
         /* Lower and upper byte of baud rate generator divisor.  */
         write_zsreg(channel, R12, regs[R12]);
         write_zsreg(channel, R13, regs[R13]);
-        
+
         /* Now rewrite R14, with BRENAB (if set).  */
         write_zsreg(channel, R14, regs[R14]);
 
@@ -571,7 +571,7 @@ static void ip22zilog_set_mctrl(struct uart_port *port, unsigned int mctrl)
         else
                 clear_bits |= DTR;
 
-        /* NOTE: Not subject to 'transmitter active' rule.  */ 
+        /* NOTE: Not subject to 'transmitter active' rule.  */
         up->curregs[R5] |= set_bits;
         up->curregs[R5] &= ~clear_bits;
         write_zsreg(channel, R5, up->curregs[R5]);
@@ -654,7 +654,7 @@ static void ip22zilog_enable_ms(struct uart_port *port)
         if (new_reg != up->curregs[R15]) {
                 up->curregs[R15] = new_reg;
 
-                /* NOTE: Not subject to 'transmitter active' rule.  */ 
+                /* NOTE: Not subject to 'transmitter active' rule.  */
                 write_zsreg(channel, R15, up->curregs[R15]);
         }
 }
@@ -680,7 +680,7 @@ static void ip22zilog_break_ctl(struct uart_port *port, int break_state)
         if (new_reg != up->curregs[R5]) {
                 up->curregs[R5] = new_reg;
 
-                /* NOTE: Not subject to 'transmitter active' rule.  */ 
+                /* NOTE: Not subject to 'transmitter active' rule.  */
                 write_zsreg(channel, R5, up->curregs[R5]);
         }
 
diff --git a/drivers/serial/jsm/jsm.h b/drivers/serial/jsm/jsm.h
index 18753193f59b..dfc1e86d3aa1 100644
--- a/drivers/serial/jsm/jsm.h
+++ b/drivers/serial/jsm/jsm.h
@@ -380,7 +380,6 @@ struct neo_uart_struct {
 extern struct   uart_driver jsm_uart_driver;
 extern struct   board_ops jsm_neo_ops;
 extern int      jsm_debug;
-extern int      jsm_rawreadok;
 
 /*************************************************************************
  *
diff --git a/drivers/serial/jsm/jsm_driver.c b/drivers/serial/jsm/jsm_driver.c
index 7e56c7824194..b1b66e71d281 100644
--- a/drivers/serial/jsm/jsm_driver.c
+++ b/drivers/serial/jsm/jsm_driver.c
@@ -49,11 +49,8 @@ struct uart_driver jsm_uart_driver = {
 };
 
 int jsm_debug;
-int jsm_rawreadok;
 module_param(jsm_debug, int, 0);
-module_param(jsm_rawreadok, int, 0);
 MODULE_PARM_DESC(jsm_debug, "Driver debugging level");
-MODULE_PARM_DESC(jsm_rawreadok, "Bypass flip buffers on input");
 
 static int jsm_probe_one(struct pci_dev *pdev, const struct pci_device_id *ent)
 {
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 6fa0d62d6f68..4d48b625cd3d 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -20,8 +20,10 @@
  *
  * Contact Information:
  * Scott H Kilau <Scott_Kilau@digi.com>
- * Wendy Xiong   <wendyx@us.ltcfwd.linux.ibm.com>
- *
+ * Ananda Venkatarman <mansarov@us.ibm.com>
+ * Modifications:
+ * 01/19/06:    changed jsm_input routine to use the dynamically allocated
+ *              tty_buffer changes. Contributors: Scott Kilau and Ananda V.
  ***********************************************************************/
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
@@ -497,16 +499,15 @@ void jsm_input(struct jsm_channel *ch)
 {
         struct jsm_board *bd;
         struct tty_struct *tp;
+        struct tty_ldisc *ld;
         u32 rmask;
         u16 head;
         u16 tail;
         int data_len;
         unsigned long lock_flags;
-        int flip_len;
+        int flip_len = 0;
         int len = 0;
         int n = 0;
-        char *buf = NULL;
-        char *buf2 = NULL;
         int s = 0;
         int i = 0;
 
@@ -574,56 +575,50 @@ void jsm_input(struct jsm_channel *ch)
 
         /*
          * If the rxbuf is empty and we are not throttled, put as much
-         * as we can directly into the linux TTY flip buffer.
-         * The jsm_rawreadok case takes advantage of carnal knowledge that
-         * the char_buf and the flag_buf are next to each other and
-         * are each of (2 * TTY_FLIPBUF_SIZE) size.
+         * as we can directly into the linux TTY buffer.
          *
-         * NOTE: if(!tty->real_raw), the call to ldisc.receive_buf
-         *actually still uses the flag buffer, so you can't
-         *use it for input data
          */
-        if (jsm_rawreadok) {
-                if (tp->real_raw)
-                        flip_len = MYFLIPLEN;
-                else
-                        flip_len = 2 * TTY_FLIPBUF_SIZE;
-        } else
-                flip_len = TTY_FLIPBUF_SIZE - tp->flip.count;
+        flip_len = TTY_FLIPBUF_SIZE;
 
         len = min(data_len, flip_len);
         len = min(len, (N_TTY_BUF_SIZE - 1) - tp->read_cnt);
+        ld = tty_ldisc_ref(tp);
 
-        if (len <= 0) {
-                spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
-                jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "jsm_input 1\n");
-                return;
-        }
+        /*
+         * If the DONT_FLIP flag is on, don't flush our buffer, and act
+         * like the ld doesn't have any space to put the data right now.
+         */
+        if (test_bit(TTY_DONT_FLIP, &tp->flags))
+                len = 0;
 
         /*
-         * If we're bypassing flip buffers on rx, we can blast it
-         * right into the beginning of the buffer.
+         * If we were unable to get a reference to the ld,
+         * don't flush our buffer, and act like the ld doesn't
+         * have any space to put the data right now.
          */
-        if (jsm_rawreadok) {
-                if (tp->real_raw) {
-                        if (ch->ch_flags & CH_FLIPBUF_IN_USE) {
-                                jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
-                                        "JSM - FLIPBUF in use. delaying input\n");
-                                spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
-                                return;
-                        }
-                        ch->ch_flags |= CH_FLIPBUF_IN_USE;
-                        buf = ch->ch_bd->flipbuf;
-                        buf2 = NULL;
-                } else {
-                        buf = tp->flip.char_buf;
-                        buf2 = tp->flip.flag_buf;
-                }
+        if (!ld) {
+                len = 0;
         } else {
-                buf = tp->flip.char_buf_ptr;
-                buf2 = tp->flip.flag_buf_ptr;
+                /*
+                 * If ld doesn't have a pointer to a receive_buf function,
+                 * flush the data, then act like the ld doesn't have any
+                 * space to put the data right now.
+                 */
+                if (!ld->receive_buf) {
+                                ch->ch_r_head = ch->ch_r_tail;
+                                len = 0;
+                }
         }
 
+        if (len <= 0) {
+                spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
+                jsm_printk(READ, INFO, &ch->ch_bd->pci_dev, "jsm_input 1\n");
+                if (ld)
+                        tty_ldisc_deref(ld);
+                return;
+        }
+
+        len = tty_buffer_request_room(tp, len);
         n = len;
 
         /*
@@ -638,121 +633,47 @@ void jsm_input(struct jsm_channel *ch)
                 if (s <= 0)
                         break;
 
-                memcpy(buf, ch->ch_rqueue + tail, s);
-
-                /* buf2 is only set when port isn't raw */
-                if (buf2)
-                        memcpy(buf2, ch->ch_equeue + tail, s);
-
-                tail += s;
-                buf += s;
-                if (buf2)
-                        buf2 += s;
-                n -= s;
-                /* Flip queue if needed */
-                tail &= rmask;
-        }
+                        /*
+                         * If conditions are such that ld needs to see all
+                         * UART errors, we will have to walk each character
+                         * and error byte and send them to the buffer one at
+                         * a time.
+                         */
 
-        /*
-         * In high performance mode, we don't have to update
-         * flag_buf or any of the counts or pointers into flip buf.
-         */
-        if (!jsm_rawreadok) {
                 if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
-                        for (i = 0; i < len; i++) {
+                        for (i = 0; i < s; i++) {
                                 /*
                                  * Give the Linux ld the flags in the
                                  * format it likes.
                                  */
-                                if (tp->flip.flag_buf_ptr[i] & UART_LSR_BI)
-                                        tp->flip.flag_buf_ptr[i] = TTY_BREAK;
-                                else if (tp->flip.flag_buf_ptr[i] & UART_LSR_PE)
-                                        tp->flip.flag_buf_ptr[i] = TTY_PARITY;
-                                else if (tp->flip.flag_buf_ptr[i] & UART_LSR_FE)
-                                        tp->flip.flag_buf_ptr[i] = TTY_FRAME;
+                                if (*(ch->ch_equeue +tail +i) & UART_LSR_BI)
+                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i),  TTY_BREAK);
+                                else if (*(ch->ch_equeue +tail +i) & UART_LSR_PE)
+                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_PARITY);
+                                else if (*(ch->ch_equeue +tail +i) & UART_LSR_FE)
+                                        tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_FRAME);
                                 else
-                                        tp->flip.flag_buf_ptr[i] = TTY_NORMAL;
+                                tty_insert_flip_char(tp, *(ch->ch_rqueue +tail +i), TTY_NORMAL);
                         }
                 } else {
-                        memset(tp->flip.flag_buf_ptr, 0, len);
+                        tty_insert_flip_string(tp, ch->ch_rqueue + tail, s) ;
                 }
-
-                tp->flip.char_buf_ptr += len;
-                tp->flip.flag_buf_ptr += len;
-                tp->flip.count += len;
-        }
-        else if (!tp->real_raw) {
-                if (I_PARMRK(tp) || I_BRKINT(tp) || I_INPCK(tp)) {
-                        for (i = 0; i < len; i++) {
-                                /*
-                                 * Give the Linux ld the flags in the
-                                 * format it likes.
-                                 */
-                                if (tp->flip.flag_buf_ptr[i] & UART_LSR_BI)
-                                        tp->flip.flag_buf_ptr[i] = TTY_BREAK;
-                                else if (tp->flip.flag_buf_ptr[i] & UART_LSR_PE)
-                                        tp->flip.flag_buf_ptr[i] = TTY_PARITY;
-                                else if (tp->flip.flag_buf_ptr[i] & UART_LSR_FE)
-                                        tp->flip.flag_buf_ptr[i] = TTY_FRAME;
-                                else
-                                        tp->flip.flag_buf_ptr[i] = TTY_NORMAL;
-                        }
-                } else
-                        memset(tp->flip.flag_buf, 0, len);
+                tail += s;
+                n -= s;
+                /* Flip queue if needed */
+                tail &= rmask;
         }
 
-        /*
-         * If we're doing raw reads, jam it right into the
-         * line disc bypassing the flip buffers.
-         */
-        if (jsm_rawreadok) {
-                if (tp->real_raw) {
-                        ch->ch_r_tail = tail & rmask;
-                        ch->ch_e_tail = tail & rmask;
-
-                        jsm_check_queue_flow_control(ch);
-
-                        /* !!! WE *MUST* LET GO OF ALL LOCKS BEFORE CALLING RECEIVE BUF !!! */
+        ch->ch_r_tail = tail & rmask;
+        ch->ch_e_tail = tail & rmask;
+        jsm_check_queue_flow_control(ch);
+        spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
 
-                        spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
+        /* Tell the tty layer its okay to "eat" the data now */
+        tty_flip_buffer_push(tp);
 
-                        jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
-                                "jsm_input. %d real_raw len:%d calling receive_buf for board %d\n",
-                                __LINE__, len, ch->ch_bd->boardnum);
-                        tp->ldisc.receive_buf(tp, ch->ch_bd->flipbuf, NULL, len);
-
-                        /* Allow use of channel flip buffer again */
-                        spin_lock_irqsave(&ch->ch_lock, lock_flags);
-                        ch->ch_flags &= ~CH_FLIPBUF_IN_USE;
-                        spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
-
-                } else {
-                        ch->ch_r_tail = tail & rmask;
-                        ch->ch_e_tail = tail & rmask;
-
-                        jsm_check_queue_flow_control(ch);
-
-                        /* !!! WE *MUST* LET GO OF ALL LOCKS BEFORE CALLING RECEIVE BUF !!! */
-                        spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
-
-                        jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
-                                "jsm_input. %d not real_raw len:%d calling receive_buf for board %d\n",
-                                __LINE__, len, ch->ch_bd->boardnum);
-
-                        tp->ldisc.receive_buf(tp, tp->flip.char_buf, tp->flip.flag_buf, len);
-                }
-        } else {
-                ch->ch_r_tail = tail & rmask;
-                ch->ch_e_tail = tail & rmask;
-
-                jsm_check_queue_flow_control(ch);
-
-                spin_unlock_irqrestore(&ch->ch_lock, lock_flags);
-
-                jsm_printk(READ, INFO, &ch->ch_bd->pci_dev,
-                        "jsm_input. %d not jsm_read raw okay scheduling flip\n", __LINE__);
-                tty_schedule_flip(tp);
-        }
+        if (ld)
+                tty_ldisc_deref(ld);
 
         jsm_printk(IOCTL, INFO, &ch->ch_bd->pci_dev, "finish\n");
 }
diff --git a/drivers/serial/m32r_sio.c b/drivers/serial/m32r_sio.c
index b48066a64a7d..242a04104393 100644
--- a/drivers/serial/m32r_sio.c
+++ b/drivers/serial/m32r_sio.c
@@ -80,7 +80,7 @@
 #include <asm/serial.h>
 
 /* Standard COM flags */
-#define STD_COM_FLAGS (ASYNC_BOOT_AUTOCONF | ASYNC_SKIP_TEST)
+#define STD_COM_FLAGS (UPF_BOOT_AUTOCONF | UPF_SKIP_TEST)
 
 /*
  * SERIAL_PORT_DFNS tells us about built-in ports that have no
diff --git a/drivers/serial/m32r_sio.h b/drivers/serial/m32r_sio.h
index 07d0dd80aa3d..7c3ec24f7e50 100644
--- a/drivers/serial/m32r_sio.h
+++ b/drivers/serial/m32r_sio.h
@@ -37,7 +37,7 @@ struct old_serial_port {
         unsigned int irq;
         unsigned int flags;
         unsigned char io_type;
-        unsigned char *iomem_base;
+        unsigned char __iomem *iomem_base;
         unsigned short iomem_reg_shift;
 };
 
diff --git a/drivers/serial/mcfserial.c b/drivers/serial/mcfserial.c
index d957a3a9edf1..8cbbb954df2c 100644
--- a/drivers/serial/mcfserial.c
+++ b/drivers/serial/mcfserial.c
@@ -57,20 +57,16 @@ struct timer_list mcfrs_timer_struct;
  *      keep going.  Perhaps one day the cflag settings for the
  *      console can be used instead.
  */
-#if defined(CONFIG_ARNEWSH) || defined(CONFIG_FREESCALE) || \
-    defined(CONFIG_senTec) || defined(CONFIG_SNEHA)
-#define CONSOLE_BAUD_RATE       19200
-#define DEFAULT_CBAUD           B19200
-#endif
-
 #if defined(CONFIG_HW_FEITH)
 #define CONSOLE_BAUD_RATE       38400
 #define DEFAULT_CBAUD           B38400
-#endif
-
-#if defined(CONFIG_MOD5272) || defined(CONFIG_M5208EVB)
+#elif defined(CONFIG_MOD5272) || defined(CONFIG_M5208EVB)
 #define CONSOLE_BAUD_RATE       115200
 #define DEFAULT_CBAUD           B115200
+#elif defined(CONFIG_ARNEWSH) || defined(CONFIG_FREESCALE) || \
+      defined(CONFIG_senTec) || defined(CONFIG_SNEHA)
+#define CONSOLE_BAUD_RATE       19200
+#define DEFAULT_CBAUD           B19200
 #endif
 
 #ifndef CONSOLE_BAUD_RATE
@@ -350,8 +346,7 @@ static inline void receive_chars(struct mcf_serial *info)
                 }
                 tty_insert_flip_char(tty, ch, flag);
         }
-
-        schedule_work(&tty->flip.work);
+        tty_schedule_flip(tty);
         return;
 }
 
diff --git a/drivers/serial/mux.c b/drivers/serial/mux.c
index 4e49168c3176..868eaf4a1a68 100644
--- a/drivers/serial/mux.c
+++ b/drivers/serial/mux.c
@@ -462,7 +462,7 @@ static int __init mux_probe(struct parisc_device *dev)
                 port->mapbase   = dev->hpa.start + MUX_OFFSET +
                                                 (i * MUX_LINE_OFFSET);
                 port->membase   = ioremap(port->mapbase, MUX_LINE_OFFSET);
-                port->iotype    = SERIAL_IO_MEM;
+                port->iotype    = UPIO_MEM;
                 port->type      = PORT_MUX;
                 port->irq       = NO_IRQ;
                 port->uartclk   = 0;
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 4e03a87f3fb4..9b7ed58cb53b 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -1492,7 +1492,7 @@ no_dma:
         /*
          * Init remaining bits of "port" structure
          */
-        uap->port.iotype = SERIAL_IO_MEM;
+        uap->port.iotype = UPIO_MEM;
         uap->port.irq = np->intrs[0].line;
         uap->port.uartclk = ZS_CLOCK;
         uap->port.fifosize = 1;
diff --git a/drivers/serial/s3c2410.c b/drivers/serial/s3c2410.c
index 0a2dd6c5b95f..7410e093a6b9 100644
--- a/drivers/serial/s3c2410.c
+++ b/drivers/serial/s3c2410.c
@@ -161,7 +161,11 @@ s3c24xx_serial_dbg(const char *fmt, ...)
 
 /* we can support 3 uarts, but not always use them */
 
+#ifdef CONFIG_CPU_S3C2400
+#define NR_PORTS (2)
+#else
 #define NR_PORTS (3)
+#endif
 
 /* port irq numbers */
 
diff --git a/drivers/serial/sa1100.c b/drivers/serial/sa1100.c
index ff7b60b4de37..2c00b8625852 100644
--- a/drivers/serial/sa1100.c
+++ b/drivers/serial/sa1100.c
@@ -628,7 +628,7 @@ static void __init sa1100_init_ports(void)
                 sa1100_ports[i].port.ops       = &sa1100_pops;
                 sa1100_ports[i].port.fifosize  = 8;
                 sa1100_ports[i].port.line      = i;
-                sa1100_ports[i].port.iotype    = SERIAL_IO_MEM;
+                sa1100_ports[i].port.iotype    = UPIO_MEM;
                 init_timer(&sa1100_ports[i].timer);
                 sa1100_ports[i].timer.function = sa1100_timeout;
                 sa1100_ports[i].timer.data     = (unsigned long)&sa1100_ports[i];
diff --git a/drivers/serial/serial_core.c b/drivers/serial/serial_core.c
index 0717abfdae06..95fb4939c675 100644
--- a/drivers/serial/serial_core.c
+++ b/drivers/serial/serial_core.c
@@ -2237,7 +2237,7 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
          * If this port is a console, then the spinlock is already
          * initialised.
          */
-        if (!uart_console(port))
+        if (!(uart_console(port) && (port->cons->flags & CON_ENABLED)))
                 spin_lock_init(&port->lock);
 
         uart_configure_port(drv, state, port);
diff --git a/drivers/serial/serial_lh7a40x.c b/drivers/serial/serial_lh7a40x.c
index d0490f67f597..04186eaae227 100644
--- a/drivers/serial/serial_lh7a40x.c
+++ b/drivers/serial/serial_lh7a40x.c
@@ -501,7 +501,7 @@ static struct uart_port_lh7a40x lh7a40x_ports[DEV_NR] = {
                 .port = {
                         .membase        = (void*) io_p2v (UART1_PHYS),
                         .mapbase        = UART1_PHYS,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = IRQ_UART1INTR,
                         .uartclk        = 14745600/2,
                         .fifosize       = 16,
@@ -514,7 +514,7 @@ static struct uart_port_lh7a40x lh7a40x_ports[DEV_NR] = {
                 .port = {
                         .membase        = (void*) io_p2v (UART2_PHYS),
                         .mapbase        = UART2_PHYS,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = IRQ_UART2INTR,
                         .uartclk        = 14745600/2,
                         .fifosize       = 16,
@@ -527,7 +527,7 @@ static struct uart_port_lh7a40x lh7a40x_ports[DEV_NR] = {
                 .port = {
                         .membase        = (void*) io_p2v (UART3_PHYS),
                         .mapbase        = UART3_PHYS,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = IRQ_UART3INTR,
                         .uartclk        = 14745600/2,
                         .fifosize       = 16,
diff --git a/drivers/serial/sh-sci.c b/drivers/serial/sh-sci.c
index 80737c131ce7..44f6bf79bbe1 100644
--- a/drivers/serial/sh-sci.c
+++ b/drivers/serial/sh-sci.c
@@ -1468,10 +1468,10 @@ static struct sci_port sci_ports[] = {
                 .port   = {
                         .membase        = (void *)0xff923000,
                         .mapbase        = 0xff923000,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = 61,
                         .ops            = &sci_uart_ops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 0,
                 },
                 .type           = PORT_SCIF,
@@ -1482,10 +1482,10 @@ static struct sci_port sci_ports[] = {
                 .port   = {
                         .membase        = (void *)0xff924000,
                         .mapbase        = 0xff924000,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = 62,
                         .ops            = &sci_uart_ops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 1,
                 },
                 .type           = PORT_SCIF,
@@ -1496,10 +1496,10 @@ static struct sci_port sci_ports[] = {
                 .port   = {
                         .membase        = (void *)0xff925000,
                         .mapbase        = 0xff925000,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = 63,
                         .ops            = &sci_uart_ops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 2,
                 },
                 .type           = PORT_SCIF,
@@ -1511,10 +1511,10 @@ static struct sci_port sci_ports[] = {
                 .port   = {
                         .membase        = (void *)0xffe00000,
                         .mapbase        = 0xffe00000,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = 43,
                         .ops            = &sci_uart_ops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 0,
                 },
                 .type           = PORT_SCIF,
@@ -1525,10 +1525,10 @@ static struct sci_port sci_ports[] = {
                 .port   = {
                         .membase        = (void *)0xffe10000,
                         .mapbase        = 0xffe10000,
-                        .iotype         = SERIAL_IO_MEM,
+                        .iotype         = UPIO_MEM,
                         .irq            = 79,
                         .ops            = &sci_uart_ops,
-                        .flags          = ASYNC_BOOT_AUTOCONF,
+                        .flags          = UPF_BOOT_AUTOCONF,
                         .line           = 1,
                 },
                 .type           = PORT_SCIF,
diff --git a/drivers/serial/sunsab.c b/drivers/serial/sunsab.c
index 8bcaebcc0ad7..85664228a0b6 100644
--- a/drivers/serial/sunsab.c
+++ b/drivers/serial/sunsab.c
@@ -1036,7 +1036,7 @@ static void __init sab_attach_callback(struct linux_ebus_device *edev, void *arg
                 up->port.irq = edev->irqs[0];
                 up->port.fifosize = SAB82532_XMIT_FIFO_SIZE;
                 up->port.mapbase = (unsigned long)up->regs;
-                up->port.iotype = SERIAL_IO_MEM;
+                up->port.iotype = UPIO_MEM;
 
                 writeb(SAB82532_IPC_IC_ACT_LOW, &up->regs->w.ipc);
 
diff --git a/drivers/serial/sunsu.c b/drivers/serial/sunsu.c
index bc67442c6b4c..308704566948 100644
--- a/drivers/serial/sunsu.c
+++ b/drivers/serial/sunsu.c
@@ -109,11 +109,11 @@ static _INLINE_ unsigned int serial_in(struct uart_sunsu_port *up, int offset)
         offset <<= up->port.regshift;
 
         switch (up->port.iotype) {
-        case SERIAL_IO_HUB6:
+        case UPIO_HUB6:
                 outb(up->port.hub6 - 1 + offset, up->port.iobase);
                 return inb(up->port.iobase + 1);
 
-        case SERIAL_IO_MEM:
+        case UPIO_MEM:
                 return readb(up->port.membase + offset);
 
         default:
@@ -139,12 +139,12 @@ serial_out(struct uart_sunsu_port *up, int offset, int value)
         offset <<= up->port.regshift;
 
         switch (up->port.iotype) {
-        case SERIAL_IO_HUB6:
+        case UPIO_HUB6:
                 outb(up->port.hub6 - 1 + offset, up->port.iobase);
                 outb(value, up->port.iobase + 1);
                 break;
 
-        case SERIAL_IO_MEM:
+        case UPIO_MEM:
                 writeb(value, up->port.membase + offset);
                 break;
 
@@ -1052,7 +1052,7 @@ static void sunsu_autoconfig(struct uart_sunsu_port *up)
                 return;
 
         up->type_probed = PORT_UNKNOWN;
-        up->port.iotype = SERIAL_IO_MEM;
+        up->port.iotype = UPIO_MEM;
 
         /*
          * First we look for Ebus-bases su's
diff --git a/drivers/serial/sunzilog.c b/drivers/serial/sunzilog.c
index 3c72484adea7..5cc4d4c2935c 100644
--- a/drivers/serial/sunzilog.c
+++ b/drivers/serial/sunzilog.c
@@ -1487,7 +1487,7 @@ static void __init sunzilog_prepare(void)
                 up[(chip * 2) + 1].port.membase = (void __iomem *)&rp->channelB;
 
                 /* Channel A */
-                up[(chip * 2) + 0].port.iotype = SERIAL_IO_MEM;
+                up[(chip * 2) + 0].port.iotype = UPIO_MEM;
                 up[(chip * 2) + 0].port.irq = zilog_irq;
                 up[(chip * 2) + 0].port.uartclk = ZS_CLOCK;
                 up[(chip * 2) + 0].port.fifosize = 1;
@@ -1498,7 +1498,7 @@ static void __init sunzilog_prepare(void)
                 up[(chip * 2) + 0].flags |= SUNZILOG_FLAG_IS_CHANNEL_A;
 
                 /* Channel B */
-                up[(chip * 2) + 1].port.iotype = SERIAL_IO_MEM;
+                up[(chip * 2) + 1].port.iotype = UPIO_MEM;
                 up[(chip * 2) + 1].port.irq = zilog_irq;
                 up[(chip * 2) + 1].port.uartclk = ZS_CLOCK;
                 up[(chip * 2) + 1].port.fifosize = 1;
diff --git a/drivers/serial/v850e_uart.c b/drivers/serial/v850e_uart.c
index 9378895a8d56..df705fda4243 100644
--- a/drivers/serial/v850e_uart.c
+++ b/drivers/serial/v850e_uart.c
@@ -496,7 +496,7 @@ static int __init v850e_uart_init (void)
 
                         port->ops = &v850e_uart_ops;
                         port->line = chan;
-                        port->iotype = SERIAL_IO_MEM;
+                        port->iotype = UPIO_MEM;
                         port->flags = UPF_BOOT_AUTOCONF;
 
                         /* We actually use multiple IRQs, but the serial
diff --git a/drivers/sn/ioc3.c b/drivers/sn/ioc3.c
index c70ae81b5d98..12357e1fa558 100644
--- a/drivers/sn/ioc3.c
+++ b/drivers/sn/ioc3.c
@@ -38,10 +38,10 @@ static inline unsigned mcr_pack(unsigned pulse, unsigned sample)
 
 static int nic_wait(struct ioc3_driver_data *idd)
 {
-        volatile unsigned mcr;
+        unsigned mcr;
 
         do {
-                mcr = (volatile unsigned)idd->vma->mcr;
+                mcr = readl(&idd->vma->mcr);
         } while (!(mcr & 2));
 
         return mcr & 1;
@@ -53,7 +53,7 @@ static int nic_reset(struct ioc3_driver_data *idd)
         unsigned long flags;
 
         local_irq_save(flags);
-        idd->vma->mcr = mcr_pack(500, 65);
+        writel(mcr_pack(500, 65), &idd->vma->mcr);
         presence = nic_wait(idd);
         local_irq_restore(flags);
 
@@ -68,7 +68,7 @@ static inline int nic_read_bit(struct ioc3_driver_data *idd)
         unsigned long flags;
 
         local_irq_save(flags);
-        idd->vma->mcr = mcr_pack(6, 13);
+        writel(mcr_pack(6, 13), &idd->vma->mcr);
         result = nic_wait(idd);
         local_irq_restore(flags);
 
@@ -80,9 +80,9 @@ static inline int nic_read_bit(struct ioc3_driver_data *idd)
 static inline void nic_write_bit(struct ioc3_driver_data *idd, int bit)
 {
         if (bit)
-                idd->vma->mcr = mcr_pack(6, 110);
+                writel(mcr_pack(6, 110), &idd->vma->mcr);
         else
-                idd->vma->mcr = mcr_pack(80, 30);
+                writel(mcr_pack(80, 30), &idd->vma->mcr);
 
         nic_wait(idd);
 }
@@ -337,7 +337,7 @@ static void probe_nic(struct ioc3_driver_data *idd)
         int save = 0, loops = 3;
         unsigned long first, addr;
 
-        idd->vma->gpcr_s = GPCR_MLAN_EN;
+        writel(GPCR_MLAN_EN, &idd->vma->gpcr_s);
 
         while(loops>0) {
                 idd->nic_part[0] = 0;
@@ -408,7 +408,7 @@ static irqreturn_t ioc3_intr_io(int irq, void *arg, struct pt_regs *regs)
 
         read_lock_irqsave(&ioc3_submodules_lock, flags);
 
-        if(idd->dual_irq && idd->vma->eisr) {
+        if(idd->dual_irq && readb(&idd->vma->eisr)) {
                 /* send Ethernet IRQ to the driver */
                 if(ioc3_ethernet && idd->active[ioc3_ethernet->id] &&
                                                 ioc3_ethernet->intr) {
@@ -682,7 +682,7 @@ static int ioc3_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
         idd->id = ioc3_counter++;
         up_write(&ioc3_devices_rwsem);
 
-        idd->gpdr_shadow = idd->vma->gpdr;
+        idd->gpdr_shadow = readl(&idd->vma->gpdr);
 
         /* Read IOC3 NIC contents */
         probe_nic(idd);
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index b77dbd63e596..7a75faeb0526 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -75,16 +75,6 @@ config SPI_BUTTERFLY
           inexpensive battery powered microcontroller evaluation board.
           This same cable can be used to flash new firmware.
 
-config SPI_BUTTERFLY
-        tristate "Parallel port adapter for AVR Butterfly (DEVELOPMENT)"
-        depends on SPI_MASTER && PARPORT && EXPERIMENTAL
-        select SPI_BITBANG
-        help
-          This uses a custom parallel port cable to connect to an AVR
-          Butterfly <http://www.atmel.com/products/avr/butterfly>, an
-          inexpensive battery powered microcontroller evaluation board.
-          This same cable can be used to flash new firmware.
-
 #
 # Add new SPI master controllers in alphabetical order above this line
 #
diff --git a/drivers/spi/spi_butterfly.c b/drivers/spi/spi_butterfly.c
index 79a3c59615ab..ff9e5faa4dc9 100644
--- a/drivers/spi/spi_butterfly.c
+++ b/drivers/spi/spi_butterfly.c
@@ -163,21 +163,20 @@ static void butterfly_chipselect(struct spi_device *spi, int value)
         struct butterfly        *pp = spidev_to_pp(spi);
 
         /* set default clock polarity */
-        if (value)
+        if (value != BITBANG_CS_INACTIVE)
                 setsck(spi, spi->mode & SPI_CPOL);
 
         /* no chipselect on this USI link config */
         if (is_usidev(spi))
                 return;
 
-        /* here, value == "activate or not" */
-
-        /* most PARPORT_CONTROL_* bits are negated */
+        /* here, value == "activate or not";
+         * most PARPORT_CONTROL_* bits are negated, so we must
+         * morph it to value == "bit value to write in control register"
+         */
         if (spi_cs_bit == PARPORT_CONTROL_INIT)
                 value = !value;
 
-        /* here, value == "bit value to write in control register"  */
-
         parport_frob_control(pp->port, spi_cs_bit, value ? spi_cs_bit : 0);
 }
 
@@ -202,7 +201,9 @@ butterfly_txrx_word_mode0(struct spi_device *spi,
 
 /* override default partitioning with cmdlinepart */
 static struct mtd_partition partitions[] = { {
-        /* JFFS2 wants partitions of 4*N blocks for this device ... */
+        /* JFFS2 wants partitions of 4*N blocks for this device,
+         * so sectors 0 and 1 can't be partitions by themselves.
+         */
 
         /* sector 0 = 8 pages * 264 bytes/page (1 block)
          * sector 1 = 248 pages * 264 bytes/page
@@ -316,8 +317,9 @@ static void butterfly_attach(struct parport *p)
         if (status < 0)
                 goto clean2;
 
-        /* Bus 1 lets us talk to at45db041b (firmware disables AVR)
-         * or AVR (firmware resets at45, acts as spi slave)
+        /* Bus 1 lets us talk to at45db041b (firmware disables AVR SPI), AVR
+         * (firmware resets at45, acts as spi slave) or neither (we ignore
+         * both, AVR uses AT45).  Here we expect firmware for the first option.
          */
         pp->info[0].max_speed_hz = 15 * 1000 * 1000;
         strcpy(pp->info[0].modalias, "mtd_dataflash");
@@ -330,7 +332,9 @@ static void butterfly_attach(struct parport *p)
                                 pp->dataflash->dev.bus_id);
 
 #ifdef  HAVE_USI
-        /* even more custom AVR firmware */
+        /* Bus 2 is only for talking to the AVR, and it can work no
+         * matter who masters bus 1; needs appropriate AVR firmware.
+         */
         pp->info[1].max_speed_hz = 10 /* ?? */ * 1000 * 1000;
         strcpy(pp->info[1].modalias, "butterfly");
         // pp->info[1].platform_data = ... TBD ... ;
@@ -378,13 +382,8 @@ static void butterfly_detach(struct parport *p)
         pp = butterfly;
         butterfly = NULL;
 
-#ifdef  HAVE_USI
-        spi_unregister_device(pp->butterfly);
-        pp->butterfly = NULL;
-#endif
-        spi_unregister_device(pp->dataflash);
-        pp->dataflash = NULL;
-
+        /* stop() unregisters child devices too */
+        pdev = to_platform_device(pp->bitbang.master->cdev.dev);
         status = spi_bitbang_stop(&pp->bitbang);
 
         /* turn off VCC */
@@ -394,8 +393,6 @@ static void butterfly_detach(struct parport *p)
         parport_release(pp->pd);
         parport_unregister_device(pp->pd);
 
-        pdev = to_platform_device(pp->bitbang.master->cdev.dev);
-
         (void) spi_master_put(pp->bitbang.master);
 
         platform_device_unregister(pdev);
@@ -420,4 +417,5 @@ static void __exit butterfly_exit(void)
 }
 module_exit(butterfly_exit);
 
+MODULE_DESCRIPTION("Parport Adapter driver for AVR Butterfly");
 MODULE_LICENSE("GPL");
diff --git a/drivers/tc/tc.c b/drivers/tc/tc.c
index a0e5af638e0e..4a51e56f85b6 100644
--- a/drivers/tc/tc.c
+++ b/drivers/tc/tc.c
@@ -17,7 +17,6 @@
 #include <linux/types.h>
 
 #include <asm/addrspace.h>
-#include <asm/bug.h>
 #include <asm/errno.h>
 #include <asm/io.h>
 #include <asm/paccess.h>
diff --git a/drivers/telephony/ixj.c b/drivers/telephony/ixj.c
index f6704688ee8c..5578a9dd04e8 100644
--- a/drivers/telephony/ixj.c
+++ b/drivers/telephony/ixj.c
@@ -3558,10 +3558,16 @@ static void ixj_write_frame(IXJ *j)
                                 }
                         /* Add word 0 to G.729 frames for the 8021.  Right now we don't do VAD/CNG  */
                                 if (j->play_codec == G729 && (cnt == 0 || cnt == 10 || cnt == 20)) {
-                                        if(j->write_buffer_rp + cnt == 0 && j->write_buffer_rp + cnt + 1 == 0 && j->write_buffer_rp + cnt + 2 == 0 &&
-                                           j->write_buffer_rp + cnt + 3 == 0 && j->write_buffer_rp + cnt + 4 == 0 && j->write_buffer_rp + cnt + 5 == 0 &&
-                                           j->write_buffer_rp + cnt + 6 == 0 && j->write_buffer_rp + cnt + 7 == 0 && j->write_buffer_rp + cnt + 8 == 0 &&
-                                           j->write_buffer_rp + cnt + 9 == 0) {
+                                        if (j->write_buffer_rp[cnt] == 0 &&
+                                            j->write_buffer_rp[cnt + 1] == 0 &&
+                                            j->write_buffer_rp[cnt + 2] == 0 &&
+                                            j->write_buffer_rp[cnt + 3] == 0 &&
+                                            j->write_buffer_rp[cnt + 4] == 0 &&
+                                            j->write_buffer_rp[cnt + 5] == 0 &&
+                                            j->write_buffer_rp[cnt + 6] == 0 &&
+                                            j->write_buffer_rp[cnt + 7] == 0 &&
+                                            j->write_buffer_rp[cnt + 8] == 0 &&
+                                            j->write_buffer_rp[cnt + 9] == 0) {
                                         /* someone is trying to write silence lets make this a type 0 frame. */
                                                 outb_p(0x00, j->DSPbase + 0x0C);
                                                 outb_p(0x00, j->DSPbase + 0x0D);
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 076462c8ba2a..dce9d987f0fc 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -378,7 +378,7 @@ const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 
         return NULL;
 }
-EXPORT_SYMBOL_GPL(usb_match_id);
+EXPORT_SYMBOL(usb_match_id);
 
 int usb_device_match(struct device *dev, struct device_driver *drv)
 {
@@ -446,7 +446,7 @@ int usb_register_driver(struct usb_driver *new_driver, struct module *owner)
 
         return retval;
 }
-EXPORT_SYMBOL_GPL(usb_register_driver);
+EXPORT_SYMBOL(usb_register_driver);
 
 /**
  * usb_deregister - unregister a USB driver
@@ -469,4 +469,4 @@ void usb_deregister(struct usb_driver *driver)
 
         usbfs_update_special();
 }
-EXPORT_SYMBOL_GPL(usb_deregister);
+EXPORT_SYMBOL(usb_deregister);
diff --git a/drivers/video/backlight/backlight.c b/drivers/video/backlight/backlight.c
index 9d5015e99372..bd39bbd88d41 100644
--- a/drivers/video/backlight/backlight.c
+++ b/drivers/video/backlight/backlight.c
@@ -13,7 +13,6 @@
 #include <linux/ctype.h>
 #include <linux/err.h>
 #include <linux/fb.h>
-#include <asm/bug.h>
 
 static ssize_t backlight_show_power(struct class_device *cdev, char *buf)
 {
diff --git a/drivers/video/backlight/lcd.c b/drivers/video/backlight/lcd.c
index 68c690605aa7..9e32485ee7bb 100644
--- a/drivers/video/backlight/lcd.c
+++ b/drivers/video/backlight/lcd.c
@@ -13,7 +13,6 @@
 #include <linux/ctype.h>
 #include <linux/err.h>
 #include <linux/fb.h>
-#include <asm/bug.h>
 
 static ssize_t lcd_show_power(struct class_device *cdev, char *buf)
 {
diff --git a/drivers/video/console/sticore.c b/drivers/video/console/sticore.c
index a7bcd17112c0..0339f5640a78 100644
--- a/drivers/video/console/sticore.c
+++ b/drivers/video/console/sticore.c
@@ -30,10 +30,11 @@
 
 #define STI_DRIVERVERSION "Version 0.9a"
 
-struct sti_struct *default_sti;
+struct sti_struct *default_sti __read_mostly;
 
-static int num_sti_roms;                          /* # of STI ROMS found */
-static struct sti_struct *sti_roms[MAX_STI_ROMS]; /* ptr to each sti_struct */
+/* number of STI ROMS found and their ptrs to each struct */
+static int num_sti_roms __read_mostly;
+static struct sti_struct *sti_roms[MAX_STI_ROMS] __read_mostly;
 
 
 /* The colour indices used by STI are
@@ -266,7 +267,7 @@ sti_rom_copy(unsigned long base, unsigned long count, void *dest)
 
 
 
-static char default_sti_path[21];
+static char default_sti_path[21] __read_mostly;
 
 #ifndef MODULE
 static int __init sti_setup(char *str)
@@ -414,10 +415,10 @@ sti_init_glob_cfg(struct sti_struct *sti,
         if (!sti->sti_mem_request)
                 sti->sti_mem_request = 256; /* STI default */
 
-        glob_cfg = kmalloc(sizeof(*sti->glob_cfg), GFP_KERNEL);
-        glob_cfg_ext = kmalloc(sizeof(*glob_cfg_ext), GFP_KERNEL);
-        save_addr = kmalloc(save_addr_size, GFP_KERNEL);
-        sti_mem_addr = kmalloc(sti->sti_mem_request, GFP_KERNEL);
+        glob_cfg = kzalloc(sizeof(*sti->glob_cfg), GFP_KERNEL);
+        glob_cfg_ext = kzalloc(sizeof(*glob_cfg_ext), GFP_KERNEL);
+        save_addr = kzalloc(save_addr_size, GFP_KERNEL);
+        sti_mem_addr = kzalloc(sti->sti_mem_request, GFP_KERNEL);
 
         if (!(glob_cfg && glob_cfg_ext && save_addr && sti_mem_addr)) {
                 kfree(glob_cfg);
@@ -427,11 +428,6 @@ sti_init_glob_cfg(struct sti_struct *sti,
                 return -ENOMEM;
         }
 
-        memset(glob_cfg, 0, sizeof(*glob_cfg));
-        memset(glob_cfg_ext, 0, sizeof(*glob_cfg_ext));
-        memset(save_addr, 0, save_addr_size);
-        memset(sti_mem_addr, 0, sti->sti_mem_request);
-
         glob_cfg->ext_ptr = STI_PTR(glob_cfg_ext);
         glob_cfg->save_addr = STI_PTR(save_addr);
         for (i=0; i<8; i++) {
@@ -502,9 +498,9 @@ sti_init_glob_cfg(struct sti_struct *sti,
 
 #ifdef CONFIG_FB
 struct sti_cooked_font * __init
-sti_select_fbfont( struct sti_cooked_rom *cooked_rom, char *fbfont_name )
+sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
 {
-        struct font_desc *fbfont;
+        const struct font_desc *fbfont;
         unsigned int size, bpc;
         void *dest;
         struct sti_rom_font *nf;
@@ -525,10 +521,9 @@ sti_select_fbfont( struct sti_cooked_rom *cooked_rom, char *fbfont_name )
         size = bpc * 256;
         size += sizeof(struct sti_rom_font);
 
-        nf = kmalloc(size, GFP_KERNEL);
+        nf = kzalloc(size, GFP_KERNEL);
         if (!nf)
                 return NULL;
-        memset(nf, 0, size);
 
         nf->first_char = 0;
         nf->last_char = 255;
@@ -544,7 +539,7 @@ sti_select_fbfont( struct sti_cooked_rom *cooked_rom, char *fbfont_name )
         dest += sizeof(struct sti_rom_font);
         memcpy(dest, fbfont->data, bpc*256);
 
-        cooked_font = kmalloc(sizeof(*cooked_font), GFP_KERNEL);
+        cooked_font = kzalloc(sizeof(*cooked_font), GFP_KERNEL);
         if (!cooked_font) {
                 kfree(nf);
                 return NULL;
@@ -559,7 +554,7 @@ sti_select_fbfont( struct sti_cooked_rom *cooked_rom, char *fbfont_name )
 }
 #else
 struct sti_cooked_font * __init
-sti_select_fbfont(struct sti_cooked_rom *cooked_rom, char *fbfont_name)
+sti_select_fbfont(struct sti_cooked_rom *cooked_rom, const char *fbfont_name)
 {
         return NULL;
 }
@@ -617,7 +612,7 @@ sti_cook_fonts(struct sti_cooked_rom *cooked_rom,
         struct sti_rom_font *raw_font, *font_start;
         struct sti_cooked_font *cooked_font;
         
-        cooked_font = kmalloc(sizeof(*cooked_font), GFP_KERNEL);
+        cooked_font = kzalloc(sizeof(*cooked_font), GFP_KERNEL);
         if (!cooked_font)
                 return 0;
 
@@ -631,7 +626,7 @@ sti_cook_fonts(struct sti_cooked_rom *cooked_rom,
         while (raw_font->next_font) {
                 raw_font = ((void *)font_start) + (raw_font->next_font);
 
-                cooked_font->next_font = kmalloc(sizeof(*cooked_font), GFP_KERNEL);
+                cooked_font->next_font = kzalloc(sizeof(*cooked_font), GFP_KERNEL);
                 if (!cooked_font->next_font)
                         return 1;
 
@@ -668,10 +663,9 @@ sti_bmode_font_raw(struct sti_cooked_font *f)
         unsigned char *n, *p, *q;
         int size = f->raw->bytes_per_char*256+sizeof(struct sti_rom_font);
         
-        n = kmalloc (4*size, GFP_KERNEL);
+        n = kzalloc (4*size, GFP_KERNEL);
         if (!n)
                 return NULL;
-        memset (n, 0, 4*size);
         p = n + 3;
         q = (unsigned char *)f->raw;
         while (size--) {
@@ -816,13 +810,12 @@ sti_try_rom_generic(unsigned long address, unsigned long hpa, struct pci_dev *pd
                 return NULL;
         }
         
-        sti = kmalloc(sizeof(*sti), GFP_KERNEL);
+        sti = kzalloc(sizeof(*sti), GFP_KERNEL);
         if (!sti) {
                 printk(KERN_ERR "Not enough memory !\n");
                 return NULL;
         }
 
-        memset(sti, 0, sizeof(*sti));
         spin_lock_init(&sti->lock);
 
 test_rom:
@@ -1035,7 +1028,7 @@ static struct parisc_driver pa_sti_driver = {
  * sti_init_roms() - detects all STI ROMs and stores them in sti_roms[]
  */
 
-static int sticore_initialized;
+static int sticore_initialized __read_mostly;
 
 static void __init sti_init_roms(void)
 {
diff --git a/drivers/video/pmag-ba-fb.c b/drivers/video/pmag-ba-fb.c
index f3927b6cda9d..f5361cd8ccce 100644
--- a/drivers/video/pmag-ba-fb.c
+++ b/drivers/video/pmag-ba-fb.c
@@ -30,7 +30,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 
-#include <asm/bug.h>
 #include <asm/io.h>
 #include <asm/system.h>
 
diff --git a/drivers/video/pmagb-b-fb.c b/drivers/video/pmagb-b-fb.c
index 25148de5fe67..eeeac924b500 100644
--- a/drivers/video/pmagb-b-fb.c
+++ b/drivers/video/pmagb-b-fb.c
@@ -27,7 +27,6 @@
 #include <linux/module.h>
 #include <linux/types.h>
 
-#include <asm/bug.h>
 #include <asm/io.h>
 #include <asm/system.h>