246 files changed, 6385 insertions, 3513 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index 81e36596b1e9..34f1e1064dbc 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -99,6 +99,7 @@ obj-$(CONFIG_SGI_SN)		+= sn/
 obj-y                           += firmware/
 obj-$(CONFIG_CRYPTO)            += crypto/
 obj-$(CONFIG_SUPERH)            += sh/
+obj-$(CONFIG_ARCH_SHMOBILE)     += sh/
 obj-$(CONFIG_GENERIC_TIME)      += clocksource/
 obj-$(CONFIG_DMA_ENGINE)        += dma/
 obj-$(CONFIG_DCA)               += dca/
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index a206a12da78a..743f2445e2a1 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -101,6 +101,7 @@ static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
         struct acpi_table_header *header = NULL;
         struct acpi_table_attr *attr = NULL;
 
+        sysfs_attr_init(&table_attr->attr.attr);
         if (table_header->signature[0] != '\0')
                 memcpy(table_attr->name, table_header->signature,
                         ACPI_NAME_SIZE);
@@ -475,6 +476,7 @@ void acpi_irq_stats_init(void)
                         goto fail;
                 strncpy(name, buffer, strlen(buffer) + 1);
 
+                sysfs_attr_init(&counter_attrs[i].attr);
                 counter_attrs[i].attr.name = name;
                 counter_attrs[i].attr.mode = 0644;
                 counter_attrs[i].show = counter_show;
diff --git a/drivers/auxdisplay/cfag12864bfb.c b/drivers/auxdisplay/cfag12864bfb.c
index fe3a865be4e5..b0ca5a47f47d 100644
--- a/drivers/auxdisplay/cfag12864bfb.c
+++ b/drivers/auxdisplay/cfag12864bfb.c
@@ -81,7 +81,7 @@ static struct fb_ops cfag12864bfb_ops = {
         .fb_mmap = cfag12864bfb_mmap,
 };
 
-static int __init cfag12864bfb_probe(struct platform_device *device)
+static int __devinit cfag12864bfb_probe(struct platform_device *device)
 {
         int ret = -EINVAL;
         struct fb_info *info = framebuffer_alloc(0, &device->dev);
diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index ee377270beb9..fd52c48ee762 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -3,35 +3,50 @@ menu "Generic Driver Options"
 config UEVENT_HELPER_PATH
         string "path to uevent helper"
         depends on HOTPLUG
-        default "/sbin/hotplug"
+        default ""
         help
           Path to uevent helper program forked by the kernel for
           every uevent.
+          Before the switch to the netlink-based uevent source, this was
+          used to hook hotplug scripts into kernel device events. It
+          usually pointed to a shell script at /sbin/hotplug.
+          This should not be used today, because usual systems create
+          many events at bootup or device discovery in a very short time
+          frame. One forked process per event can create so many processes
+          that it creates a high system load, or on smaller systems
+          it is known to create out-of-memory situations during bootup.
 
 config DEVTMPFS
-        bool "Create a kernel maintained /dev tmpfs (EXPERIMENTAL)"
+        bool "Maintain a devtmpfs filesystem to mount at /dev"
         depends on HOTPLUG && SHMEM && TMPFS
         help
-          This creates a tmpfs filesystem, and mounts it at bootup
-          and mounts it at /dev. The kernel driver core creates device
-          nodes for all registered devices in that filesystem. All device
-          nodes are owned by root and have the default mode of 0600.
-          Userspace can add and delete the nodes as needed. This is
-          intended to simplify bootup, and make it possible to delay
-          the initial coldplug at bootup done by udev in userspace.
-          It should also provide a simpler way for rescue systems
-          to bring up a kernel with dynamic major/minor numbers.
-          Meaningful symlinks, permissions and device ownership must
-          still be handled by userspace.
-          If unsure, say N here.
+          This creates a tmpfs filesystem instance early at bootup.
+          In this filesystem, the kernel driver core maintains device
+          nodes with their default names and permissions for all
+          registered devices with an assigned major/minor number.
+          Userspace can modify the filesystem content as needed, add
+          symlinks, and apply needed permissions.
+          It provides a fully functional /dev directory, where usually
+          udev runs on top, managing permissions and adding meaningful
+          symlinks.
+          In very limited environments, it may provide a sufficient
+          functional /dev without any further help. It also allows simple
+          rescue systems, and reliably handles dynamic major/minor numbers.
 
 config DEVTMPFS_MOUNT
-        bool "Automount devtmpfs at /dev"
+        bool "Automount devtmpfs at /dev, after the kernel mounted the rootfs"
         depends on DEVTMPFS
         help
-          This will mount devtmpfs at /dev if the kernel mounts the root
-          filesystem. It will not affect initramfs based mounting.
-          If unsure, say N here.
+          This will instruct the kernel to automatically mount the
+          devtmpfs filesystem at /dev, directly after the kernel has
+          mounted the root filesystem. The behavior can be overridden
+          with the commandline parameter: devtmpfs.mount=0|1.
+          This option does not affect initramfs based booting, here
+          the devtmpfs filesystem always needs to be mounted manually
+          after the roots is mounted.
+          With this option enabled, it allows to bring up a system in
+          rescue mode with init=/bin/sh, even when the /dev directory
+          on the rootfs is completely empty.
 
 config STANDALONE
         bool "Select only drivers that don't need compile-time external firmware" if EXPERIMENTAL
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index c0c5a43d9fb3..71f6af5c8b0b 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -70,7 +70,7 @@ static ssize_t drv_attr_store(struct kobject *kobj, struct attribute *attr,
         return ret;
 }
 
-static struct sysfs_ops driver_sysfs_ops = {
+static const struct sysfs_ops driver_sysfs_ops = {
         .show   = drv_attr_show,
         .store  = drv_attr_store,
 };
@@ -115,7 +115,7 @@ static ssize_t bus_attr_store(struct kobject *kobj, struct attribute *attr,
         return ret;
 }
 
-static struct sysfs_ops bus_sysfs_ops = {
+static const struct sysfs_ops bus_sysfs_ops = {
         .show   = bus_attr_show,
         .store  = bus_attr_store,
 };
@@ -154,7 +154,7 @@ static int bus_uevent_filter(struct kset *kset, struct kobject *kobj)
         return 0;
 }
 
-static struct kset_uevent_ops bus_uevent_ops = {
+static const struct kset_uevent_ops bus_uevent_ops = {
         .filter = bus_uevent_filter,
 };
 
@@ -173,10 +173,10 @@ static ssize_t driver_unbind(struct device_driver *drv,
         dev = bus_find_device_by_name(bus, NULL, buf);
         if (dev && dev->driver == drv) {
                 if (dev->parent)        /* Needed for USB */
-                        down(&dev->parent->sem);
+                        device_lock(dev->parent);
                 device_release_driver(dev);
                 if (dev->parent)
-                        up(&dev->parent->sem);
+                        device_unlock(dev->parent);
                 err = count;
         }
         put_device(dev);
@@ -200,12 +200,12 @@ static ssize_t driver_bind(struct device_driver *drv,
         dev = bus_find_device_by_name(bus, NULL, buf);
         if (dev && dev->driver == NULL && driver_match_device(drv, dev)) {
                 if (dev->parent)        /* Needed for USB */
-                        down(&dev->parent->sem);
-                down(&dev->sem);
+                        device_lock(dev->parent);
+                device_lock(dev);
                 err = driver_probe_device(drv, dev);
-                up(&dev->sem);
+                device_unlock(dev);
                 if (dev->parent)
-                        up(&dev->parent->sem);
+                        device_unlock(dev->parent);
 
                 if (err > 0) {
                         /* success */
@@ -744,10 +744,10 @@ static int __must_check bus_rescan_devices_helper(struct device *dev,
 
         if (!dev->driver) {
                 if (dev->parent)        /* Needed for USB */
-                        down(&dev->parent->sem);
+                        device_lock(dev->parent);
                 ret = device_attach(dev);
                 if (dev->parent)
-                        up(&dev->parent->sem);
+                        device_unlock(dev->parent);
         }
         return ret < 0 ? ret : 0;
 }
@@ -779,10 +779,10 @@ int device_reprobe(struct device *dev)
 {
         if (dev->driver) {
                 if (dev->parent)        /* Needed for USB */
-                        down(&dev->parent->sem);
+                        device_lock(dev->parent);
                 device_release_driver(dev);
                 if (dev->parent)
-                        up(&dev->parent->sem);
+                        device_unlock(dev->parent);
         }
         return bus_rescan_devices_helper(dev, NULL);
 }
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 6e2c3b064f53..0147f476b8a9 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -31,7 +31,7 @@ static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
         ssize_t ret = -EIO;
 
         if (class_attr->show)
-                ret = class_attr->show(cp->class, buf);
+                ret = class_attr->show(cp->class, class_attr, buf);
         return ret;
 }
 
@@ -43,7 +43,7 @@ static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
         ssize_t ret = -EIO;
 
         if (class_attr->store)
-                ret = class_attr->store(cp->class, buf, count);
+                ret = class_attr->store(cp->class, class_attr, buf, count);
         return ret;
 }
 
@@ -63,7 +63,7 @@ static void class_release(struct kobject *kobj)
         kfree(cp);
 }
 
-static struct sysfs_ops class_sysfs_ops = {
+static const struct sysfs_ops class_sysfs_ops = {
         .show   = class_attr_show,
         .store  = class_attr_store,
 };
@@ -490,6 +490,16 @@ void class_interface_unregister(struct class_interface *class_intf)
         class_put(parent);
 }
 
+ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
+                                char *buf)
+{
+        struct class_attribute_string *cs;
+        cs = container_of(attr, struct class_attribute_string, attr);
+        return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);
+}
+
+EXPORT_SYMBOL_GPL(show_class_attr_string);
+
 struct class_compat {
         struct kobject *kobj;
 };
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 282025770429..ef55df34ddd0 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -100,7 +100,7 @@ static ssize_t dev_attr_store(struct kobject *kobj, struct attribute *attr,
         return ret;
 }
 
-static struct sysfs_ops dev_sysfs_ops = {
+static const struct sysfs_ops dev_sysfs_ops = {
         .show   = dev_attr_show,
         .store  = dev_attr_store,
 };
@@ -252,7 +252,7 @@ static int dev_uevent(struct kset *kset, struct kobject *kobj,
         return retval;
 }
 
-static struct kset_uevent_ops device_uevent_ops = {
+static const struct kset_uevent_ops device_uevent_ops = {
         .filter =       dev_uevent_filter,
         .name =         dev_uevent_name,
         .uevent =       dev_uevent,
@@ -306,15 +306,10 @@ static ssize_t store_uevent(struct device *dev, struct device_attribute *attr,
 {
         enum kobject_action action;
 
-        if (kobject_action_type(buf, count, &action) == 0) {
+        if (kobject_action_type(buf, count, &action) == 0)
                 kobject_uevent(&dev->kobj, action);
-                goto out;
-        }
-
-        dev_err(dev, "uevent: unsupported action-string; this will "
-                     "be ignored in a future kernel version\n");
-        kobject_uevent(&dev->kobj, KOBJ_ADD);
-out:
+        else
+                dev_err(dev, "uevent: unknown action-string\n");
         return count;
 }
 
@@ -607,6 +602,7 @@ static struct kobject *get_device_parent(struct device *dev,
         int retval;
 
         if (dev->class) {
+                static DEFINE_MUTEX(gdp_mutex);
                 struct kobject *kobj = NULL;
                 struct kobject *parent_kobj;
                 struct kobject *k;
@@ -623,6 +619,8 @@ static struct kobject *get_device_parent(struct device *dev,
                 else
                         parent_kobj = &parent->kobj;
 
+                mutex_lock(&gdp_mutex);
+
                 /* find our class-directory at the parent and reference it */
                 spin_lock(&dev->class->p->class_dirs.list_lock);
                 list_for_each_entry(k, &dev->class->p->class_dirs.list, entry)
@@ -631,20 +629,26 @@ static struct kobject *get_device_parent(struct device *dev,
                                 break;
                         }
                 spin_unlock(&dev->class->p->class_dirs.list_lock);
-                if (kobj)
+                if (kobj) {
+                        mutex_unlock(&gdp_mutex);
                         return kobj;
+                }
 
                 /* or create a new class-directory at the parent device */
                 k = kobject_create();
-                if (!k)
+                if (!k) {
+                        mutex_unlock(&gdp_mutex);
                         return NULL;
+                }
                 k->kset = &dev->class->p->class_dirs;
                 retval = kobject_add(k, parent_kobj, "%s", dev->class->name);
                 if (retval < 0) {
+                        mutex_unlock(&gdp_mutex);
                         kobject_put(k);
                         return NULL;
                 }
                 /* do not emit an uevent for this simple "glue" directory */
+                mutex_unlock(&gdp_mutex);
                 return k;
         }
 
@@ -1574,22 +1578,16 @@ int device_rename(struct device *dev, char *new_name)
         if (old_class_name) {
                 new_class_name = make_class_name(dev->class->name, &dev->kobj);
                 if (new_class_name) {
-                        error = sysfs_create_link_nowarn(&dev->parent->kobj,
-                                                         &dev->kobj,
-                                                         new_class_name);
-                        if (error)
-                                goto out;
-                        sysfs_remove_link(&dev->parent->kobj, old_class_name);
+                        error = sysfs_rename_link(&dev->parent->kobj,
+                                                  &dev->kobj,
+                                                  old_class_name,
+                                                  new_class_name);
                 }
         }
 #else
         if (dev->class) {
-                error = sysfs_create_link_nowarn(&dev->class->p->class_subsys.kobj,
-                                                 &dev->kobj, dev_name(dev));
-                if (error)
-                        goto out;
-                sysfs_remove_link(&dev->class->p->class_subsys.kobj,
-                                  old_device_name);
+                error = sysfs_rename_link(&dev->class->p->class_subsys.kobj,
+                                          &dev->kobj, old_device_name, new_name);
         }
 #endif
 
diff --git a/drivers/base/cpu.c b/drivers/base/cpu.c
index 958bd1540c30..7036e8e96ab8 100644
--- a/drivers/base/cpu.c
+++ b/drivers/base/cpu.c
@@ -13,8 +13,11 @@
 
 #include "base.h"
 
+static struct sysdev_class_attribute *cpu_sysdev_class_attrs[];
+
 struct sysdev_class cpu_sysdev_class = {
         .name = "cpu",
+        .attrs = cpu_sysdev_class_attrs,
 };
 EXPORT_SYMBOL(cpu_sysdev_class);
 
@@ -76,34 +79,24 @@ void unregister_cpu(struct cpu *cpu)
 }
 
 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
-static ssize_t cpu_probe_store(struct class *class, const char *buf,
+static ssize_t cpu_probe_store(struct sys_device *dev,
+                                struct sysdev_attribute *attr,
+                                const char *buf,
                                size_t count)
 {
         return arch_cpu_probe(buf, count);
 }
 
-static ssize_t cpu_release_store(struct class *class, const char *buf,
+static ssize_t cpu_release_store(struct sys_device *dev,
+                                struct sysdev_attribute *attr,
+                                const char *buf,
                                  size_t count)
 {
         return arch_cpu_release(buf, count);
 }
 
-static CLASS_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
-static CLASS_ATTR(release, S_IWUSR, NULL, cpu_release_store);
-
-int __init cpu_probe_release_init(void)
-{
-        int rc;
-
-        rc = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
-                               &class_attr_probe.attr);
-        if (!rc)
-                rc = sysfs_create_file(&cpu_sysdev_class.kset.kobj,
-                                       &class_attr_release.attr);
-
-        return rc;
-}
-device_initcall(cpu_probe_release_init);
+static SYSDEV_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
+static SYSDEV_ATTR(release, S_IWUSR, NULL, cpu_release_store);
 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
 
 #else /* ... !CONFIG_HOTPLUG_CPU */
@@ -141,31 +134,39 @@ static SYSDEV_ATTR(crash_notes, 0400, show_crash_notes, NULL);
 /*
  * Print cpu online, possible, present, and system maps
  */
-static ssize_t print_cpus_map(char *buf, const struct cpumask *map)
+
+struct cpu_attr {
+        struct sysdev_class_attribute attr;
+        const struct cpumask *const * const map;
+};
+
+static ssize_t show_cpus_attr(struct sysdev_class *class,
+                              struct sysdev_class_attribute *attr,
+                              char *buf)
 {
-        int n = cpulist_scnprintf(buf, PAGE_SIZE-2, map);
+        struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
+        int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *(ca->map));
 
         buf[n++] = '\n';
         buf[n] = '\0';
         return n;
 }
 
-#define print_cpus_func(type) \
-static ssize_t print_cpus_##type(struct sysdev_class *class, char *buf) \
-{                                                                       \
-        return print_cpus_map(buf, cpu_##type##_mask);                  \
-}                                                                       \
-static struct sysdev_class_attribute attr_##type##_map =                \
-        _SYSDEV_CLASS_ATTR(type, 0444, print_cpus_##type, NULL)
+#define _CPU_ATTR(name, map)                                            \
+        { _SYSDEV_CLASS_ATTR(name, 0444, show_cpus_attr, NULL), map }
 
-print_cpus_func(online);
-print_cpus_func(possible);
-print_cpus_func(present);
+/* Keep in sync with cpu_sysdev_class_attrs */
+static struct cpu_attr cpu_attrs[] = {
+        _CPU_ATTR(online, &cpu_online_mask),
+        _CPU_ATTR(possible, &cpu_possible_mask),
+        _CPU_ATTR(present, &cpu_present_mask),
+};
 
 /*
  * Print values for NR_CPUS and offlined cpus
  */
-static ssize_t print_cpus_kernel_max(struct sysdev_class *class, char *buf)
+static ssize_t print_cpus_kernel_max(struct sysdev_class *class,
+                                     struct sysdev_class_attribute *attr, char *buf)
 {
         int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
         return n;
@@ -175,7 +176,8 @@ static SYSDEV_CLASS_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
 unsigned int total_cpus;
 
-static ssize_t print_cpus_offline(struct sysdev_class *class, char *buf)
+static ssize_t print_cpus_offline(struct sysdev_class *class,
+                                  struct sysdev_class_attribute *attr, char *buf)
 {
         int n = 0, len = PAGE_SIZE-2;
         cpumask_var_t offline;
@@ -204,29 +206,6 @@ static ssize_t print_cpus_offline(struct sysdev_class *class, char *buf)
 }
 static SYSDEV_CLASS_ATTR(offline, 0444, print_cpus_offline, NULL);
 
-static struct sysdev_class_attribute *cpu_state_attr[] = {
-        &attr_online_map,
-        &attr_possible_map,
-        &attr_present_map,
-        &attr_kernel_max,
-        &attr_offline,
-};
-
-static int cpu_states_init(void)
-{
-        int i;
-        int err = 0;
-
-        for (i = 0;  i < ARRAY_SIZE(cpu_state_attr); i++) {
-                int ret;
-                ret = sysdev_class_create_file(&cpu_sysdev_class,
-                                                cpu_state_attr[i]);
-                if (!err)
-                        err = ret;
-        }
-        return err;
-}
-
 /*
  * register_cpu - Setup a sysfs device for a CPU.
  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
@@ -272,9 +251,6 @@ int __init cpu_dev_init(void)
         int err;
 
         err = sysdev_class_register(&cpu_sysdev_class);
-        if (!err)
-                err = cpu_states_init();
-
 #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
         if (!err)
                 err = sched_create_sysfs_power_savings_entries(&cpu_sysdev_class);
@@ -282,3 +258,16 @@ int __init cpu_dev_init(void)
 
         return err;
 }
+
+static struct sysdev_class_attribute *cpu_sysdev_class_attrs[] = {
+#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
+        &attr_probe,
+        &attr_release,
+#endif
+        &cpu_attrs[0].attr,
+        &cpu_attrs[1].attr,
+        &cpu_attrs[2].attr,
+        &attr_kernel_max,
+        &attr_offline,
+        NULL
+};
diff --git a/drivers/base/dd.c b/drivers/base/dd.c
index ee95c76bfd3d..c89291f8a16b 100644
--- a/drivers/base/dd.c
+++ b/drivers/base/dd.c
@@ -85,7 +85,7 @@ static void driver_sysfs_remove(struct device *dev)
  * for before calling this. (It is ok to call with no other effort
  * from a driver's probe() method.)
  *
- * This function must be called with @dev->sem held.
+ * This function must be called with the device lock held.
  */
 int device_bind_driver(struct device *dev)
 {
@@ -190,8 +190,8 @@ EXPORT_SYMBOL_GPL(wait_for_device_probe);
  * This function returns -ENODEV if the device is not registered,
  * 1 if the device is bound successfully and 0 otherwise.
  *
- * This function must be called with @dev->sem held.  When called for a
- * USB interface, @dev->parent->sem must be held as well.
+ * This function must be called with @dev lock held.  When called for a
+ * USB interface, @dev->parent lock must be held as well.
  */
 int driver_probe_device(struct device_driver *drv, struct device *dev)
 {
@@ -233,13 +233,13 @@ static int __device_attach(struct device_driver *drv, void *data)
  * 0 if no matching driver was found;
  * -ENODEV if the device is not registered.
  *
- * When called for a USB interface, @dev->parent->sem must be held.
+ * When called for a USB interface, @dev->parent lock must be held.
  */
 int device_attach(struct device *dev)
 {
         int ret = 0;
 
-        down(&dev->sem);
+        device_lock(dev);
         if (dev->driver) {
                 ret = device_bind_driver(dev);
                 if (ret == 0)
@@ -253,7 +253,7 @@ int device_attach(struct device *dev)
                 ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
                 pm_runtime_put_sync(dev);
         }
-        up(&dev->sem);
+        device_unlock(dev);
         return ret;
 }
 EXPORT_SYMBOL_GPL(device_attach);
@@ -276,13 +276,13 @@ static int __driver_attach(struct device *dev, void *data)
                 return 0;
 
         if (dev->parent)        /* Needed for USB */
-                down(&dev->parent->sem);
-        down(&dev->sem);
+                device_lock(dev->parent);
+        device_lock(dev);
         if (!dev->driver)
                 driver_probe_device(drv, dev);
-        up(&dev->sem);
+        device_unlock(dev);
         if (dev->parent)
-                up(&dev->parent->sem);
+                device_unlock(dev->parent);
 
         return 0;
 }
@@ -303,8 +303,8 @@ int driver_attach(struct device_driver *drv)
 EXPORT_SYMBOL_GPL(driver_attach);
 
 /*
- * __device_release_driver() must be called with @dev->sem held.
- * When called for a USB interface, @dev->parent->sem must be held as well.
+ * __device_release_driver() must be called with @dev lock held.
+ * When called for a USB interface, @dev->parent lock must be held as well.
  */
 static void __device_release_driver(struct device *dev)
 {
@@ -343,7 +343,7 @@ static void __device_release_driver(struct device *dev)
  * @dev: device.
  *
  * Manually detach device from driver.
- * When called for a USB interface, @dev->parent->sem must be held.
+ * When called for a USB interface, @dev->parent lock must be held.
  */
 void device_release_driver(struct device *dev)
 {
@@ -352,9 +352,9 @@ void device_release_driver(struct device *dev)
          * within their ->remove callback for the same device, they
          * will deadlock right here.
          */
-        down(&dev->sem);
+        device_lock(dev);
         __device_release_driver(dev);
-        up(&dev->sem);
+        device_unlock(dev);
 }
 EXPORT_SYMBOL_GPL(device_release_driver);
 
@@ -381,13 +381,13 @@ void driver_detach(struct device_driver *drv)
                 spin_unlock(&drv->p->klist_devices.k_lock);
 
                 if (dev->parent)        /* Needed for USB */
-                        down(&dev->parent->sem);
-                down(&dev->sem);
+                        device_lock(dev->parent);
+                device_lock(dev);
                 if (dev->driver == drv)
                         __device_release_driver(dev);
-                up(&dev->sem);
+                device_unlock(dev);
                 if (dev->parent)
-                        up(&dev->parent->sem);
+                        device_unlock(dev->parent);
                 put_device(dev);
         }
 }
diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 42ae452b36b0..dac478c6e460 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -301,6 +301,19 @@ int devtmpfs_delete_node(struct device *dev)
                 if (dentry->d_inode) {
                         err = vfs_getattr(nd.path.mnt, dentry, &stat);
                         if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {
+                                struct iattr newattrs;
+                                /*
+                                 * before unlinking this node, reset permissions
+                                 * of possible references like hardlinks
+                                 */
+                                newattrs.ia_uid = 0;
+                                newattrs.ia_gid = 0;
+                                newattrs.ia_mode = stat.mode & ~0777;
+                                newattrs.ia_valid =
+                                        ATTR_UID|ATTR_GID|ATTR_MODE;
+                                mutex_lock(&dentry->d_inode->i_mutex);
+                                notify_change(dentry, &newattrs);
+                                mutex_unlock(&dentry->d_inode->i_mutex);
                                 err = vfs_unlink(nd.path.dentry->d_inode,
                                                  dentry);
                                 if (!err || err == -ENOENT)
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index a95024166b66..d0dc26ad5387 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -19,7 +19,6 @@
 #include <linux/kthread.h>
 #include <linux/highmem.h>
 #include <linux/firmware.h>
-#include "base.h"
 
 #define to_dev(obj) container_of(obj, struct device, kobj)
 
@@ -69,7 +68,9 @@ fw_load_abort(struct firmware_priv *fw_priv)
 }
 
 static ssize_t
-firmware_timeout_show(struct class *class, char *buf)
+firmware_timeout_show(struct class *class,
+                      struct class_attribute *attr,
+                      char *buf)
 {
         return sprintf(buf, "%d\n", loading_timeout);
 }
@@ -87,7 +88,9 @@ firmware_timeout_show(struct class *class, char *buf)
  *      Note: zero means 'wait forever'.
  **/
 static ssize_t
-firmware_timeout_store(struct class *class, const char *buf, size_t count)
+firmware_timeout_store(struct class *class,
+                        struct class_attribute *attr,
+                        const char *buf, size_t count)
 {
         loading_timeout = simple_strtol(buf, NULL, 10);
         if (loading_timeout < 0)
@@ -610,7 +613,7 @@ request_firmware_work_func(void *arg)
 }
 
 /**
- * request_firmware_nowait: asynchronous version of request_firmware
+ * request_firmware_nowait - asynchronous version of request_firmware
  * @module: module requesting the firmware
  * @uevent: sends uevent to copy the firmware image if this flag
  *      is non-zero else the firmware copy must be done manually.
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index bd025059711f..2f8691511190 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -44,7 +44,7 @@ static int memory_uevent(struct kset *kset, struct kobject *obj, struct kobj_uev
         return retval;
 }
 
-static struct kset_uevent_ops memory_uevent_ops = {
+static const struct kset_uevent_ops memory_uevent_ops = {
         .name           = memory_uevent_name,
         .uevent         = memory_uevent,
 };
@@ -309,17 +309,18 @@ static SYSDEV_ATTR(removable, 0444, show_mem_removable, NULL);
  * Block size attribute stuff
  */
 static ssize_t
-print_block_size(struct class *class, char *buf)
+print_block_size(struct sysdev_class *class, struct sysdev_class_attribute *attr,
+                 char *buf)
 {
         return sprintf(buf, "%#lx\n", (unsigned long)PAGES_PER_SECTION * PAGE_SIZE);
 }
 
-static CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
+static SYSDEV_CLASS_ATTR(block_size_bytes, 0444, print_block_size, NULL);
 
 static int block_size_init(void)
 {
         return sysfs_create_file(&memory_sysdev_class.kset.kobj,
-                                &class_attr_block_size_bytes.attr);
+                                &attr_block_size_bytes.attr);
 }
 
 /*
@@ -330,7 +331,8 @@ static int block_size_init(void)
  */
 #ifdef CONFIG_ARCH_MEMORY_PROBE
 static ssize_t
-memory_probe_store(struct class *class, const char *buf, size_t count)
+memory_probe_store(struct class *class, struct class_attribute *attr,
+                   const char *buf, size_t count)
 {
         u64 phys_addr;
         int nid;
@@ -367,7 +369,9 @@ static inline int memory_probe_init(void)
 
 /* Soft offline a page */
 static ssize_t
-store_soft_offline_page(struct class *class, const char *buf, size_t count)
+store_soft_offline_page(struct class *class,
+                        struct class_attribute *attr,
+                        const char *buf, size_t count)
 {
         int ret;
         u64 pfn;
@@ -384,7 +388,9 @@ store_soft_offline_page(struct class *class, const char *buf, size_t count)
 
 /* Forcibly offline a page, including killing processes. */
 static ssize_t
-store_hard_offline_page(struct class *class, const char *buf, size_t count)
+store_hard_offline_page(struct class *class,
+                        struct class_attribute *attr,
+                        const char *buf, size_t count)
 {
         int ret;
         u64 pfn;
diff --git a/drivers/base/node.c b/drivers/base/node.c
index 70122791683d..ad43185ec15a 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -16,8 +16,11 @@
 #include <linux/device.h>
 #include <linux/swap.h>
 
+static struct sysdev_class_attribute *node_state_attrs[];
+
 static struct sysdev_class node_class = {
         .name = "node",
+        .attrs = node_state_attrs,
 };
 
 
@@ -544,76 +547,52 @@ static ssize_t print_nodes_state(enum node_states state, char *buf)
         return n;
 }
 
-static ssize_t print_nodes_possible(struct sysdev_class *class, char *buf)
-{
-        return print_nodes_state(N_POSSIBLE, buf);
-}
-
-static ssize_t print_nodes_online(struct sysdev_class *class, char *buf)
-{
-        return print_nodes_state(N_ONLINE, buf);
-}
-
-static ssize_t print_nodes_has_normal_memory(struct sysdev_class *class,
-                                                char *buf)
-{
-        return print_nodes_state(N_NORMAL_MEMORY, buf);
-}
+struct node_attr {
+        struct sysdev_class_attribute attr;
+        enum node_states state;
+};
 
-static ssize_t print_nodes_has_cpu(struct sysdev_class *class, char *buf)
+static ssize_t show_node_state(struct sysdev_class *class,
+                               struct sysdev_class_attribute *attr, char *buf)
 {
-        return print_nodes_state(N_CPU, buf);
+        struct node_attr *na = container_of(attr, struct node_attr, attr);
+        return print_nodes_state(na->state, buf);
 }
 
-static SYSDEV_CLASS_ATTR(possible, 0444, print_nodes_possible, NULL);
-static SYSDEV_CLASS_ATTR(online, 0444, print_nodes_online, NULL);
-static SYSDEV_CLASS_ATTR(has_normal_memory, 0444, print_nodes_has_normal_memory,
-                                                                        NULL);
-static SYSDEV_CLASS_ATTR(has_cpu, 0444, print_nodes_has_cpu, NULL);
+#define _NODE_ATTR(name, state) \
+        { _SYSDEV_CLASS_ATTR(name, 0444, show_node_state, NULL), state }
 
+static struct node_attr node_state_attr[] = {
+        _NODE_ATTR(possible, N_POSSIBLE),
+        _NODE_ATTR(online, N_ONLINE),
+        _NODE_ATTR(has_normal_memory, N_NORMAL_MEMORY),
+        _NODE_ATTR(has_cpu, N_CPU),
 #ifdef CONFIG_HIGHMEM
-static ssize_t print_nodes_has_high_memory(struct sysdev_class *class,
-                                                 char *buf)
-{
-        return print_nodes_state(N_HIGH_MEMORY, buf);
-}
-
-static SYSDEV_CLASS_ATTR(has_high_memory, 0444, print_nodes_has_high_memory,
-                                                                         NULL);
+        _NODE_ATTR(has_high_memory, N_HIGH_MEMORY),
 #endif
+};
 
-struct sysdev_class_attribute *node_state_attr[] = {
-        &attr_possible,
-        &attr_online,
-        &attr_has_normal_memory,
+static struct sysdev_class_attribute *node_state_attrs[] = {
+        &node_state_attr[0].attr,
+        &node_state_attr[1].attr,
+        &node_state_attr[2].attr,
+        &node_state_attr[3].attr,
 #ifdef CONFIG_HIGHMEM
-        &attr_has_high_memory,
+        &node_state_attr[4].attr,
 #endif
-        &attr_has_cpu,
+        NULL
 };
 
-static int node_states_init(void)
-{
-        int i;
-        int err = 0;
-
-        for (i = 0;  i < NR_NODE_STATES; i++) {
-                int ret;
-                ret = sysdev_class_create_file(&node_class, node_state_attr[i]);
-                if (!err)
-                        err = ret;
-        }
-        return err;
-}
-
 #define NODE_CALLBACK_PRI       2       /* lower than SLAB */
 static int __init register_node_type(void)
 {
         int ret;
 
+        BUILD_BUG_ON(ARRAY_SIZE(node_state_attr) != NR_NODE_STATES);
+        BUILD_BUG_ON(ARRAY_SIZE(node_state_attrs)-1 != NR_NODE_STATES);
+
         ret = sysdev_class_register(&node_class);
         if (!ret) {
-                ret = node_states_init();
                 hotplug_memory_notifier(node_memory_callback,
                                         NODE_CALLBACK_PRI);
         }
diff --git a/drivers/base/platform.c b/drivers/base/platform.c
index 58efaf2f1259..1ba9d617d241 100644
--- a/drivers/base/platform.c
+++ b/drivers/base/platform.c
@@ -128,7 +128,7 @@ struct platform_object {
 };
 
 /**
- * platform_device_put
+ * platform_device_put - destroy a platform device
  * @pdev: platform device to free
  *
  * Free all memory associated with a platform device.  This function must
@@ -152,7 +152,7 @@ static void platform_device_release(struct device *dev)
 }
 
 /**
- * platform_device_alloc
+ * platform_device_alloc - create a platform device
  * @name: base name of the device we're adding
  * @id: instance id
  *
@@ -177,7 +177,7 @@ struct platform_device *platform_device_alloc(const char *name, int id)
 EXPORT_SYMBOL_GPL(platform_device_alloc);
 
 /**
- * platform_device_add_resources
+ * platform_device_add_resources - add resources to a platform device
  * @pdev: platform device allocated by platform_device_alloc to add resources to
  * @res: set of resources that needs to be allocated for the device
  * @num: number of resources
@@ -202,7 +202,7 @@ int platform_device_add_resources(struct platform_device *pdev,
 EXPORT_SYMBOL_GPL(platform_device_add_resources);
 
 /**
- * platform_device_add_data
+ * platform_device_add_data - add platform-specific data to a platform device
  * @pdev: platform device allocated by platform_device_alloc to add resources to
  * @data: platform specific data for this platform device
  * @size: size of platform specific data
@@ -344,7 +344,7 @@ void platform_device_unregister(struct platform_device *pdev)
 EXPORT_SYMBOL_GPL(platform_device_unregister);
 
 /**
- * platform_device_register_simple
+ * platform_device_register_simple - add a platform-level device and its resources
  * @name: base name of the device we're adding
  * @id: instance id
  * @res: set of resources that needs to be allocated for the device
@@ -396,7 +396,7 @@ error:
 EXPORT_SYMBOL_GPL(platform_device_register_simple);
 
 /**
- * platform_device_register_data
+ * platform_device_register_data - add a platform-level device with platform-specific data
  * @parent: parent device for the device we're adding
  * @name: base name of the device we're adding
  * @id: instance id
@@ -473,7 +473,7 @@ static void platform_drv_shutdown(struct device *_dev)
 }
 
 /**
- * platform_driver_register
+ * platform_driver_register - register a driver for platform-level devices
  * @drv: platform driver structure
  */
 int platform_driver_register(struct platform_driver *drv)
@@ -491,7 +491,7 @@ int platform_driver_register(struct platform_driver *drv)
 EXPORT_SYMBOL_GPL(platform_driver_register);
 
 /**
- * platform_driver_unregister
+ * platform_driver_unregister - unregister a driver for platform-level devices
  * @drv: platform driver structure
  */
 void platform_driver_unregister(struct platform_driver *drv)
@@ -548,6 +548,64 @@ int __init_or_module platform_driver_probe(struct platform_driver *drv,
 }
 EXPORT_SYMBOL_GPL(platform_driver_probe);
 
+/**
+ * platform_create_bundle - register driver and create corresponding device
+ * @driver: platform driver structure
+ * @probe: the driver probe routine, probably from an __init section
+ * @res: set of resources that needs to be allocated for the device
+ * @n_res: number of resources
+ * @data: platform specific data for this platform device
+ * @size: size of platform specific data
+ *
+ * Use this in legacy-style modules that probe hardware directly and
+ * register a single platform device and corresponding platform driver.
+ */
+struct platform_device * __init_or_module platform_create_bundle(
+                        struct platform_driver *driver,
+                        int (*probe)(struct platform_device *),
+                        struct resource *res, unsigned int n_res,
+                        const void *data, size_t size)
+{
+        struct platform_device *pdev;
+        int error;
+
+        pdev = platform_device_alloc(driver->driver.name, -1);
+        if (!pdev) {
+                error = -ENOMEM;
+                goto err_out;
+        }
+
+        if (res) {
+                error = platform_device_add_resources(pdev, res, n_res);
+                if (error)
+                        goto err_pdev_put;
+        }
+
+        if (data) {
+                error = platform_device_add_data(pdev, data, size);
+                if (error)
+                        goto err_pdev_put;
+        }
+
+        error = platform_device_add(pdev);
+        if (error)
+                goto err_pdev_put;
+
+        error = platform_driver_probe(driver, probe);
+        if (error)
+                goto err_pdev_del;
+
+        return pdev;
+
+err_pdev_del:
+        platform_device_del(pdev);
+err_pdev_put:
+        platform_device_put(pdev);
+err_out:
+        return ERR_PTR(error);
+}
+EXPORT_SYMBOL_GPL(platform_create_bundle);
+
 /* modalias support enables more hands-off userspace setup:
  * (a) environment variable lets new-style hotplug events work once system is
  *     fully running:  "modprobe $MODALIAS"
@@ -578,7 +636,7 @@ static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)
 }
 
 static const struct platform_device_id *platform_match_id(
-                        struct platform_device_id *id,
+                        const struct platform_device_id *id,
                         struct platform_device *pdev)
 {
         while (id->name[0]) {
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 0e26a6f6fd48..d477f4dc5e51 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -35,8 +35,8 @@
  * because children are guaranteed to be discovered after parents, and
  * are inserted at the back of the list on discovery.
  *
- * Since device_pm_add() may be called with a device semaphore held,
- * we must never try to acquire a device semaphore while holding
+ * Since device_pm_add() may be called with a device lock held,
+ * we must never try to acquire a device lock while holding
  * dpm_list_mutex.
  */
 
@@ -508,7 +508,7 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
         TRACE_RESUME(0);
 
         dpm_wait(dev->parent, async);
-        down(&dev->sem);
+        device_lock(dev);
 
         dev->power.status = DPM_RESUMING;
 
@@ -543,7 +543,7 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
                 }
         }
  End:
-        up(&dev->sem);
+        device_unlock(dev);
         complete_all(&dev->power.completion);
 
         TRACE_RESUME(error);
@@ -629,7 +629,7 @@ static void dpm_resume(pm_message_t state)
  */
 static void device_complete(struct device *dev, pm_message_t state)
 {
-        down(&dev->sem);
+        device_lock(dev);
 
         if (dev->class && dev->class->pm && dev->class->pm->complete) {
                 pm_dev_dbg(dev, state, "completing class ");
@@ -646,7 +646,7 @@ static void device_complete(struct device *dev, pm_message_t state)
                 dev->bus->pm->complete(dev);
         }
 
-        up(&dev->sem);
+        device_unlock(dev);
 }
 
 /**
@@ -809,7 +809,7 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         int error = 0;
 
         dpm_wait_for_children(dev, async);
-        down(&dev->sem);
+        device_lock(dev);
 
         if (async_error)
                 goto End;
@@ -849,7 +849,7 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                 dev->power.status = DPM_OFF;
 
  End:
-        up(&dev->sem);
+        device_unlock(dev);
         complete_all(&dev->power.completion);
 
         return error;
@@ -938,7 +938,7 @@ static int device_prepare(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
-        down(&dev->sem);
+        device_lock(dev);
 
         if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
                 pm_dev_dbg(dev, state, "preparing ");
@@ -962,7 +962,7 @@ static int device_prepare(struct device *dev, pm_message_t state)
                 suspend_report_result(dev->class->pm->prepare, error);
         }
  End:
-        up(&dev->sem);
+        device_unlock(dev);
 
         return error;
 }
diff --git a/drivers/base/sys.c b/drivers/base/sys.c
index 0d903909af7e..8980feec5d14 100644
--- a/drivers/base/sys.c
+++ b/drivers/base/sys.c
@@ -54,7 +54,7 @@ sysdev_store(struct kobject *kobj, struct attribute *attr,
         return -EIO;
 }
 
-static struct sysfs_ops sysfs_ops = {
+static const struct sysfs_ops sysfs_ops = {
         .show   = sysdev_show,
         .store  = sysdev_store,
 };
@@ -89,7 +89,7 @@ static ssize_t sysdev_class_show(struct kobject *kobj, struct attribute *attr,
         struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
 
         if (class_attr->show)
-                return class_attr->show(class, buffer);
+                return class_attr->show(class, class_attr, buffer);
         return -EIO;
 }
 
@@ -100,11 +100,11 @@ static ssize_t sysdev_class_store(struct kobject *kobj, struct attribute *attr,
         struct sysdev_class_attribute *class_attr = to_sysdev_class_attr(attr);
 
         if (class_attr->store)
-                return class_attr->store(class, buffer, count);
+                return class_attr->store(class, class_attr, buffer, count);
         return -EIO;
 }
 
-static struct sysfs_ops sysfs_class_ops = {
+static const struct sysfs_ops sysfs_class_ops = {
         .show   = sysdev_class_show,
         .store  = sysdev_class_store,
 };
@@ -145,13 +145,20 @@ int sysdev_class_register(struct sysdev_class *cls)
         if (retval)
                 return retval;
 
-        return kset_register(&cls->kset);
+        retval = kset_register(&cls->kset);
+        if (!retval && cls->attrs)
+                retval = sysfs_create_files(&cls->kset.kobj,
+                                            (const struct attribute **)cls->attrs);
+        return retval;
 }
 
 void sysdev_class_unregister(struct sysdev_class *cls)
 {
         pr_debug("Unregistering sysdev class '%s'\n",
                  kobject_name(&cls->kset.kobj));
+        if (cls->attrs)
+                sysfs_remove_files(&cls->kset.kobj,
+                                   (const struct attribute **)cls->attrs);
         kset_unregister(&cls->kset);
 }
 
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index b9b117059b62..90c4038702da 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -144,13 +144,23 @@
  * Better audit of register_blkdev.
  */
 
-#define FLOPPY_SANITY_CHECK
 #undef  FLOPPY_SILENT_DCL_CLEAR
 
 #define REALLY_SLOW_IO
 
 #define DEBUGT 2
-#define DCL_DEBUG       /* debug disk change line */
+
+#define DPRINT(format, args...) \
+        pr_info("floppy%d: " format, current_drive, ##args)
+
+#define DCL_DEBUG               /* debug disk change line */
+#ifdef DCL_DEBUG
+#define debug_dcl(test, fmt, args...) \
+        do { if ((test) & FD_DEBUG) DPRINT(fmt, ##args); } while (0)
+#else
+#define debug_dcl(test, fmt, args...) \
+        do { if (0) DPRINT(fmt, ##args); } while (0)
+#endif
 
 /* do print messages for unexpected interrupts */
 static int print_unex = 1;
@@ -180,6 +190,8 @@ static int print_unex = 1;
 #include <linux/mod_devicetable.h>
 #include <linux/buffer_head.h>  /* for invalidate_buffers() */
 #include <linux/mutex.h>
+#include <linux/io.h>
+#include <linux/uaccess.h>
 
 /*
  * PS/2 floppies have much slower step rates than regular floppies.
@@ -191,8 +203,6 @@ static int slow_floppy;
 #include <asm/dma.h>
 #include <asm/irq.h>
 #include <asm/system.h>
-#include <asm/io.h>
-#include <asm/uaccess.h>
 
 static int FLOPPY_IRQ = 6;
 static int FLOPPY_DMA = 2;
@@ -241,8 +251,6 @@ static int allowed_drive_mask = 0x33;
 
 static int irqdma_allocated;
 
-#define DEVICE_NAME "floppy"
-
 #include <linux/blkdev.h>
 #include <linux/blkpg.h>
 #include <linux/cdrom.h>        /* for the compatibility eject ioctl */
@@ -250,7 +258,7 @@ static int irqdma_allocated;
 
 static struct request *current_req;
 static struct request_queue *floppy_queue;
-static void do_fd_request(struct request_queue * q);
+static void do_fd_request(struct request_queue *q);
 
 #ifndef fd_get_dma_residue
 #define fd_get_dma_residue() get_dma_residue(FLOPPY_DMA)
@@ -263,7 +271,7 @@ static void do_fd_request(struct request_queue * q);
 #endif
 
 #ifndef fd_dma_mem_alloc
-#define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL,get_order(size))
+#define fd_dma_mem_alloc(size) __get_dma_pages(GFP_KERNEL, get_order(size))
 #endif
 
 static inline void fallback_on_nodma_alloc(char **addr, size_t l)
@@ -273,7 +281,7 @@ static inline void fallback_on_nodma_alloc(char **addr, size_t l)
                 return;         /* we have the memory */
         if (can_use_virtual_dma != 2)
                 return;         /* no fallback allowed */
-        printk("DMA memory shortage. Temporarily falling back on virtual DMA\n");
+        pr_info("DMA memory shortage. Temporarily falling back on virtual DMA\n");
         *addr = (char *)nodma_mem_alloc(l);
 #else
         return;
@@ -283,59 +291,50 @@ static inline void fallback_on_nodma_alloc(char **addr, size_t l)
 /* End dma memory related stuff */
 
 static unsigned long fake_change;
-static int initialising = 1;
+static bool initialized;
 
-#define ITYPE(x) (((x)>>2) & 0x1f)
-#define TOMINOR(x) ((x & 3) | ((x & 4) << 5))
-#define UNIT(x) ((x) & 0x03)    /* drive on fdc */
-#define FDC(x) (((x) & 0x04) >> 2)      /* fdc of drive */
+#define ITYPE(x)        (((x) >> 2) & 0x1f)
+#define TOMINOR(x)      ((x & 3) | ((x & 4) << 5))
+#define UNIT(x)         ((x) & 0x03)            /* drive on fdc */
+#define FDC(x)          (((x) & 0x04) >> 2)     /* fdc of drive */
         /* reverse mapping from unit and fdc to drive */
 #define REVDRIVE(fdc, unit) ((unit) + ((fdc) << 2))
-#define DP (&drive_params[current_drive])
-#define DRS (&drive_state[current_drive])
-#define DRWE (&write_errors[current_drive])
-#define FDCS (&fdc_state[fdc])
-#define CLEARF(x) clear_bit(x##_BIT, &DRS->flags)
-#define SETF(x) set_bit(x##_BIT, &DRS->flags)
-#define TESTF(x) test_bit(x##_BIT, &DRS->flags)
 
-#define UDP (&drive_params[drive])
-#define UDRS (&drive_state[drive])
-#define UDRWE (&write_errors[drive])
-#define UFDCS (&fdc_state[FDC(drive)])
-#define UCLEARF(x) clear_bit(x##_BIT, &UDRS->flags)
-#define USETF(x) set_bit(x##_BIT, &UDRS->flags)
-#define UTESTF(x) test_bit(x##_BIT, &UDRS->flags)
+#define DP      (&drive_params[current_drive])
+#define DRS     (&drive_state[current_drive])
+#define DRWE    (&write_errors[current_drive])
+#define FDCS    (&fdc_state[fdc])
 
-#define DPRINT(format, args...) printk(DEVICE_NAME "%d: " format, current_drive , ## args)
+#define UDP     (&drive_params[drive])
+#define UDRS    (&drive_state[drive])
+#define UDRWE   (&write_errors[drive])
+#define UFDCS   (&fdc_state[FDC(drive)])
 
-#define PH_HEAD(floppy,head) (((((floppy)->stretch & 2) >>1) ^ head) << 2)
-#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
-
-#define CLEARSTRUCT(x) memset((x), 0, sizeof(*(x)))
+#define PH_HEAD(floppy, head) (((((floppy)->stretch & 2) >> 1) ^ head) << 2)
+#define STRETCH(floppy) ((floppy)->stretch & FD_STRETCH)
 
 /* read/write */
-#define COMMAND raw_cmd->cmd[0]
-#define DR_SELECT raw_cmd->cmd[1]
-#define TRACK raw_cmd->cmd[2]
-#define HEAD raw_cmd->cmd[3]
-#define SECTOR raw_cmd->cmd[4]
-#define SIZECODE raw_cmd->cmd[5]
-#define SECT_PER_TRACK raw_cmd->cmd[6]
-#define GAP raw_cmd->cmd[7]
-#define SIZECODE2 raw_cmd->cmd[8]
+#define COMMAND         (raw_cmd->cmd[0])
+#define DR_SELECT       (raw_cmd->cmd[1])
+#define TRACK           (raw_cmd->cmd[2])
+#define HEAD            (raw_cmd->cmd[3])
+#define SECTOR          (raw_cmd->cmd[4])
+#define SIZECODE        (raw_cmd->cmd[5])
+#define SECT_PER_TRACK  (raw_cmd->cmd[6])
+#define GAP             (raw_cmd->cmd[7])
+#define SIZECODE2       (raw_cmd->cmd[8])
 #define NR_RW 9
 
 /* format */
-#define F_SIZECODE raw_cmd->cmd[2]
-#define F_SECT_PER_TRACK raw_cmd->cmd[3]
-#define F_GAP raw_cmd->cmd[4]
-#define F_FILL raw_cmd->cmd[5]
+#define F_SIZECODE      (raw_cmd->cmd[2])
+#define F_SECT_PER_TRACK (raw_cmd->cmd[3])
+#define F_GAP           (raw_cmd->cmd[4])
+#define F_FILL          (raw_cmd->cmd[5])
 #define NR_F 6
 
 /*
- * Maximum disk size (in kilobytes). This default is used whenever the
- * current disk size is unknown.
+ * Maximum disk size (in kilobytes).
+ * This default is used whenever the current disk size is unknown.
  * [Now it is rather a minimum]
  */
 #define MAX_DISK_SIZE 4         /* 3984 */
@@ -345,16 +344,17 @@ static int initialising = 1;
  */
 #define MAX_REPLIES 16
 static unsigned char reply_buffer[MAX_REPLIES];
-static int inr;                 /* size of reply buffer, when called from interrupt */
-#define ST0 (reply_buffer[0])
-#define ST1 (reply_buffer[1])
-#define ST2 (reply_buffer[2])
-#define ST3 (reply_buffer[0])   /* result of GETSTATUS */
-#define R_TRACK (reply_buffer[3])
-#define R_HEAD (reply_buffer[4])
-#define R_SECTOR (reply_buffer[5])
-#define R_SIZECODE (reply_buffer[6])
-#define SEL_DLY (2*HZ/100)
+static int inr;         /* size of reply buffer, when called from interrupt */
+#define ST0             (reply_buffer[0])
+#define ST1             (reply_buffer[1])
+#define ST2             (reply_buffer[2])
+#define ST3             (reply_buffer[0])       /* result of GETSTATUS */
+#define R_TRACK         (reply_buffer[3])
+#define R_HEAD          (reply_buffer[4])
+#define R_SECTOR        (reply_buffer[5])
+#define R_SIZECODE      (reply_buffer[6])
+
+#define SEL_DLY         (2 * HZ / 100)
 
 /*
  * this struct defines the different floppy drive types.
@@ -505,9 +505,9 @@ static char floppy_device_name[] = "floppy";
 static int probing;
 
 /* Synchronization of FDC access. */
-#define FD_COMMAND_NONE -1
-#define FD_COMMAND_ERROR 2
-#define FD_COMMAND_OKAY 3
+#define FD_COMMAND_NONE         -1
+#define FD_COMMAND_ERROR        2
+#define FD_COMMAND_OKAY         3
 
 static volatile int command_status = FD_COMMAND_NONE;
 static unsigned long fdc_busy;
@@ -515,11 +515,6 @@ static DECLARE_WAIT_QUEUE_HEAD(fdc_wait);
 static DECLARE_WAIT_QUEUE_HEAD(command_done);
 
 #define NO_SIGNAL (!interruptible || !signal_pending(current))
-#define CALL(x) if ((x) == -EINTR) return -EINTR
-#define ECALL(x) if ((ret = (x))) return ret;
-#define _WAIT(x,i) CALL(ret=wait_til_done((x),i))
-#define WAIT(x) _WAIT((x),interruptible)
-#define IWAIT(x) _WAIT((x),1)
 
 /* Errors during formatting are counted here. */
 static int format_errors;
@@ -545,8 +540,9 @@ static int max_buffer_sectors;
 static int *errors;
 typedef void (*done_f)(int);
 static struct cont_t {
-        void (*interrupt)(void);        /* this is called after the interrupt of the
-                                         * main command */
+        void (*interrupt)(void);
+                                /* this is called after the interrupt of the
+                                 * main command */
         void (*redo)(void);     /* this is called to retry the operation */
         void (*error)(void);    /* this is called to tally an error */
         done_f done;            /* this is called to say if the operation has
@@ -571,7 +567,6 @@ static void floppy_release_irq_and_dma(void);
  * reset doesn't need to be tested before sending commands, because
  * output_byte is automatically disabled when reset is set.
  */
-#define CHECK_RESET { if (FDCS->reset){ reset_fdc(); return; } }
 static void reset_fdc(void);
 
 /*
@@ -579,9 +574,9 @@ static void reset_fdc(void);
  * information to interrupts. They are the data used for the current
  * request.
  */
-#define NO_TRACK -1
-#define NEED_1_RECAL -2
-#define NEED_2_RECAL -3
+#define NO_TRACK        -1
+#define NEED_1_RECAL    -2
+#define NEED_2_RECAL    -3
 
 static int usage_count;
 
@@ -621,39 +616,35 @@ static inline void set_debugt(void)
         debugtimer = jiffies;
 }
 
-static inline void debugt(const char *message)
+static inline void debugt(const char *func, const char *msg)
 {
         if (DP->flags & DEBUGT)
-                printk("%s dtime=%lu\n", message, jiffies - debugtimer);
+                pr_info("%s:%s dtime=%lu\n", func, msg, jiffies - debugtimer);
 }
 #else
 static inline void set_debugt(void) { }
-static inline void debugt(const char *message) { }
+static inline void debugt(const char *func, const char *msg) { }
 #endif /* DEBUGT */
 
-typedef void (*timeout_fn) (unsigned long);
+typedef void (*timeout_fn)(unsigned long);
 static DEFINE_TIMER(fd_timeout, floppy_shutdown, 0, 0);
 
 static const char *timeout_message;
 
-#ifdef FLOPPY_SANITY_CHECK
-static void is_alive(const char *message)
+static void is_alive(const char *func, const char *message)
 {
         /* this routine checks whether the floppy driver is "alive" */
-        if (test_bit(0, &fdc_busy) && command_status < 2
-            && !timer_pending(&fd_timeout)) {
-                DPRINT("timeout handler died: %s\n", message);
+        if (test_bit(0, &fdc_busy) && command_status < 2 &&
+            !timer_pending(&fd_timeout)) {
+                DPRINT("%s: timeout handler died.  %s\n", func, message);
         }
 }
-#endif
 
-static void (*do_floppy) (void) = NULL;
-
-#ifdef FLOPPY_SANITY_CHECK
+static void (*do_floppy)(void) = NULL;
 
 #define OLOGSIZE 20
 
-static void (*lasthandler) (void);
+static void (*lasthandler)(void);
 static unsigned long interruptjiffies;
 static unsigned long resultjiffies;
 static int resultsize;
@@ -666,12 +657,11 @@ static struct output_log {
 } output_log[OLOGSIZE];
 
 static int output_log_pos;
-#endif
 
 #define current_reqD -1
 #define MAXTIMEOUT -2
 
-static void __reschedule_timeout(int drive, const char *message, int marg)
+static void __reschedule_timeout(int drive, const char *message)
 {
         if (drive == current_reqD)
                 drive = current_drive;
@@ -682,25 +672,22 @@ static void __reschedule_timeout(int drive, const char *message, int marg)
         } else
                 fd_timeout.expires = jiffies + UDP->timeout;
         add_timer(&fd_timeout);
-        if (UDP->flags & FD_DEBUG) {
-                DPRINT("reschedule timeout ");
-                printk(message, marg);
-                printk("\n");
-        }
+        if (UDP->flags & FD_DEBUG)
+                DPRINT("reschedule timeout %s\n", message);
         timeout_message = message;
 }
 
-static void reschedule_timeout(int drive, const char *message, int marg)
+static void reschedule_timeout(int drive, const char *message)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&floppy_lock, flags);
-        __reschedule_timeout(drive, message, marg);
+        __reschedule_timeout(drive, message);
         spin_unlock_irqrestore(&floppy_lock, flags);
 }
 
-#define INFBOUND(a,b) (a)=max_t(int, a, b)
-#define SUPBOUND(a,b) (a)=min_t(int, a, b)
+#define INFBOUND(a, b) (a) = max_t(int, a, b)
+#define SUPBOUND(a, b) (a) = min_t(int, a, b)
 
 /*
  * Bottom half floppy driver.
@@ -739,7 +726,6 @@ static int disk_change(int drive)
 {
         int fdc = FDC(drive);
 
-#ifdef FLOPPY_SANITY_CHECK
         if (time_before(jiffies, UDRS->select_date + UDP->select_delay))
                 DPRINT("WARNING disk change called early\n");
         if (!(FDCS->dor & (0x10 << UNIT(drive))) ||
@@ -748,31 +734,27 @@ static int disk_change(int drive)
                 DPRINT("drive=%d fdc=%d dor=%x\n", drive, FDC(drive),
                        (unsigned int)FDCS->dor);
         }
-#endif
 
-#ifdef DCL_DEBUG
-        if (UDP->flags & FD_DEBUG) {
-                DPRINT("checking disk change line for drive %d\n", drive);
-                DPRINT("jiffies=%lu\n", jiffies);
-                DPRINT("disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
-                DPRINT("flags=%lx\n", UDRS->flags);
-        }
-#endif
+        debug_dcl(UDP->flags,
+                  "checking disk change line for drive %d\n", drive);
+        debug_dcl(UDP->flags, "jiffies=%lu\n", jiffies);
+        debug_dcl(UDP->flags, "disk change line=%x\n", fd_inb(FD_DIR) & 0x80);
+        debug_dcl(UDP->flags, "flags=%lx\n", UDRS->flags);
+
         if (UDP->flags & FD_BROKEN_DCL)
-                return UTESTF(FD_DISK_CHANGED);
+                return test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
         if ((fd_inb(FD_DIR) ^ UDP->flags) & 0x80) {
-                USETF(FD_VERIFY);       /* verify write protection */
-                if (UDRS->maxblock) {
-                        /* mark it changed */
-                        USETF(FD_DISK_CHANGED);
-                }
+                set_bit(FD_VERIFY_BIT, &UDRS->flags);
+                                        /* verify write protection */
+
+                if (UDRS->maxblock)     /* mark it changed */
+                        set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
 
                 /* invalidate its geometry */
                 if (UDRS->keep_data >= 0) {
                         if ((UDP->flags & FTD_MSG) &&
                             current_type[drive] != NULL)
-                                DPRINT("Disk type is undefined after "
-                                       "disk change\n");
+                                DPRINT("Disk type is undefined after disk change\n");
                         current_type[drive] = NULL;
                         floppy_sizes[TOMINOR(drive)] = MAX_DISK_SIZE << 1;
                 }
@@ -780,7 +762,7 @@ static int disk_change(int drive)
                 return 1;
         } else {
                 UDRS->last_checked = jiffies;
-                UCLEARF(FD_DISK_NEWCHANGE);
+                clear_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
         }
         return 0;
 }
@@ -790,6 +772,12 @@ static inline int is_selected(int dor, int unit)
         return ((dor & (0x10 << unit)) && (dor & 3) == unit);
 }
 
+static bool is_ready_state(int status)
+{
+        int state = status & (STATUS_READY | STATUS_DIR | STATUS_DMA);
+        return state == STATUS_READY;
+}
+
 static int set_dor(int fdc, char mask, char data)
 {
         unsigned char unit;
@@ -806,11 +794,8 @@ static int set_dor(int fdc, char mask, char data)
                 unit = olddor & 0x3;
                 if (is_selected(olddor, unit) && !is_selected(newdor, unit)) {
                         drive = REVDRIVE(fdc, unit);
-#ifdef DCL_DEBUG
-                        if (UDP->flags & FD_DEBUG) {
-                                DPRINT("calling disk change from set_dor\n");
-                        }
-#endif
+                        debug_dcl(UDP->flags,
+                                  "calling disk change from set_dor\n");
                         disk_change(drive);
                 }
                 FDCS->dor = newdor;
@@ -834,8 +819,10 @@ static void twaddle(void)
         DRS->select_date = jiffies;
 }
 
-/* reset all driver information about the current fdc. This is needed after
- * a reset, and after a raw command. */
+/*
+ * Reset all driver information about the current fdc.
+ * This is needed after a reset, and after a raw command.
+ */
 static void reset_fdc_info(int mode)
 {
         int drive;
@@ -857,7 +844,7 @@ static void set_fdc(int drive)
                 current_drive = drive;
         }
         if (fdc != 1 && fdc != 0) {
-                printk("bad fdc value\n");
+                pr_info("bad fdc value\n");
                 return;
         }
         set_dor(fdc, ~0, 8);
@@ -871,11 +858,10 @@ static void set_fdc(int drive)
 }
 
 /* locks the driver */
-static int _lock_fdc(int drive, int interruptible, int line)
+static int _lock_fdc(int drive, bool interruptible, int line)
 {
         if (!usage_count) {
-                printk(KERN_ERR
-                       "Trying to lock fdc while usage count=0 at line %d\n",
+                pr_err("Trying to lock fdc while usage count=0 at line %d\n",
                        line);
                 return -1;
         }
@@ -904,15 +890,13 @@ static int _lock_fdc(int drive, int interruptible, int line)
         }
         command_status = FD_COMMAND_NONE;
 
-        __reschedule_timeout(drive, "lock fdc", 0);
+        __reschedule_timeout(drive, "lock fdc");
         set_fdc(drive);
         return 0;
 }
 
-#define lock_fdc(drive,interruptible) _lock_fdc(drive,interruptible, __LINE__)
-
-#define LOCK_FDC(drive,interruptible) \
-if (lock_fdc(drive,interruptible)) return -EINTR;
+#define lock_fdc(drive, interruptible)                  \
+        _lock_fdc(drive, interruptible, __LINE__)
 
 /* unlocks the driver */
 static inline void unlock_fdc(void)
@@ -924,7 +908,7 @@ static inline void unlock_fdc(void)
                 DPRINT("FDC access conflict!\n");
 
         if (do_floppy)
-                DPRINT("device interrupt still active at FDC release: %p!\n",
+                DPRINT("device interrupt still active at FDC release: %pf!\n",
                        do_floppy);
         command_status = FD_COMMAND_NONE;
         spin_lock_irqsave(&floppy_lock, flags);
@@ -1003,7 +987,7 @@ static void empty(void)
 
 static DECLARE_WORK(floppy_work, NULL);
 
-static void schedule_bh(void (*handler) (void))
+static void schedule_bh(void (*handler)(void))
 {
         PREPARE_WORK(&floppy_work, (work_func_t)handler);
         schedule_work(&floppy_work);
@@ -1026,11 +1010,7 @@ static void cancel_activity(void)
  * transfer */
 static void fd_watchdog(void)
 {
-#ifdef DCL_DEBUG
-        if (DP->flags & FD_DEBUG) {
-                DPRINT("calling disk change from watchdog\n");
-        }
-#endif
+        debug_dcl(DP->flags, "calling disk change from watchdog\n");
 
         if (disk_change(current_drive)) {
                 DPRINT("disk removed during i/o\n");
@@ -1039,7 +1019,7 @@ static void fd_watchdog(void)
                 reset_fdc();
         } else {
                 del_timer(&fd_timer);
-                fd_timer.function = (timeout_fn) fd_watchdog;
+                fd_timer.function = (timeout_fn)fd_watchdog;
                 fd_timer.expires = jiffies + HZ / 10;
                 add_timer(&fd_timer);
         }
@@ -1105,25 +1085,23 @@ static void setup_DMA(void)
 {
         unsigned long f;
 
-#ifdef FLOPPY_SANITY_CHECK
         if (raw_cmd->length == 0) {
                 int i;
 
-                printk("zero dma transfer size:");
+                pr_info("zero dma transfer size:");
                 for (i = 0; i < raw_cmd->cmd_count; i++)
-                        printk("%x,", raw_cmd->cmd[i]);
-                printk("\n");
+                        pr_cont("%x,", raw_cmd->cmd[i]);
+                pr_cont("\n");
                 cont->done(0);
                 FDCS->reset = 1;
                 return;
         }
         if (((unsigned long)raw_cmd->kernel_data) % 512) {
-                printk("non aligned address: %p\n", raw_cmd->kernel_data);
+                pr_info("non aligned address: %p\n", raw_cmd->kernel_data);
                 cont->done(0);
                 FDCS->reset = 1;
                 return;
         }
-#endif
         f = claim_dma_lock();
         fd_disable_dma();
 #ifdef fd_dma_setup
@@ -1165,7 +1143,7 @@ static int wait_til_ready(void)
                 if (status & STATUS_READY)
                         return status;
         }
-        if (!initialising) {
+        if (initialized) {
                 DPRINT("Getstatus times out (%x) on fdc %d\n", status, fdc);
                 show_floppy();
         }
@@ -1176,22 +1154,21 @@ static int wait_til_ready(void)
 /* sends a command byte to the fdc */
 static int output_byte(char byte)
 {
-        int status;
+        int status = wait_til_ready();
 
-        if ((status = wait_til_ready()) < 0)
+        if (status < 0)
                 return -1;
-        if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY) {
+
+        if (is_ready_state(status)) {
                 fd_outb(byte, FD_DATA);
-#ifdef FLOPPY_SANITY_CHECK
                 output_log[output_log_pos].data = byte;
                 output_log[output_log_pos].status = status;
                 output_log[output_log_pos].jiffies = jiffies;
                 output_log_pos = (output_log_pos + 1) % OLOGSIZE;
-#endif
                 return 0;
         }
         FDCS->reset = 1;
-        if (!initialising) {
+        if (initialized) {
                 DPRINT("Unable to send byte %x to FDC. Fdc=%x Status=%x\n",
                        byte, fdc, status);
                 show_floppy();
@@ -1199,8 +1176,6 @@ static int output_byte(char byte)
         return -1;
 }
 
-#define LAST_OUT(x) if (output_byte(x)<0){ reset_fdc();return;}
-
 /* gets the response from the fdc */
 static int result(void)
 {
@@ -1208,14 +1183,13 @@ static int result(void)
         int status = 0;
 
         for (i = 0; i < MAX_REPLIES; i++) {
-                if ((status = wait_til_ready()) < 0)
+                status = wait_til_ready();
+                if (status < 0)
                         break;
                 status &= STATUS_DIR | STATUS_READY | STATUS_BUSY | STATUS_DMA;
                 if ((status & ~STATUS_BUSY) == STATUS_READY) {
-#ifdef FLOPPY_SANITY_CHECK
                         resultjiffies = jiffies;
                         resultsize = i;
-#endif
                         return i;
                 }
                 if (status == (STATUS_DIR | STATUS_READY | STATUS_BUSY))
@@ -1223,10 +1197,9 @@ static int result(void)
                 else
                         break;
         }
-        if (!initialising) {
-                DPRINT
-                    ("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
-                     fdc, status, i);
+        if (initialized) {
+                DPRINT("get result error. Fdc=%d Last status=%x Read bytes=%d\n",
+                       fdc, status, i);
                 show_floppy();
         }
         FDCS->reset = 1;
@@ -1237,12 +1210,14 @@ static int result(void)
 /* does the fdc need more output? */
 static int need_more_output(void)
 {
-        int status;
+        int status = wait_til_ready();
 
-        if ((status = wait_til_ready()) < 0)
+        if (status < 0)
                 return -1;
-        if ((status & (STATUS_READY | STATUS_DIR | STATUS_DMA)) == STATUS_READY)
+
+        if (is_ready_state(status))
                 return MORE_OUTPUT;
+
         return result();
 }
 
@@ -1264,9 +1239,12 @@ static inline void perpendicular_mode(void)
                 default:
                         DPRINT("Invalid data rate for perpendicular mode!\n");
                         cont->done(0);
-                        FDCS->reset = 1;        /* convenient way to return to
-                                                 * redo without to much hassle (deep
-                                                 * stack et al. */
+                        FDCS->reset = 1;
+                                        /*
+                                         * convenient way to return to
+                                         * redo without too much hassle
+                                         * (deep stack et al.)
+                                         */
                         return;
                 }
         } else
@@ -1366,9 +1344,9 @@ static void fdc_specify(void)
 
         /* Convert step rate from microseconds to milliseconds and 4 bits */
         srt = 16 - DIV_ROUND_UP(DP->srt * scale_dtr / 1000, NOMINAL_DTR);
-        if (slow_floppy) {
+        if (slow_floppy)
                 srt = srt / 4;
-        }
+
         SUPBOUND(srt, 0xf);
         INFBOUND(srt, 0);
 
@@ -1415,16 +1393,46 @@ static int fdc_dtr(void)
          * Pause 5 msec to avoid trouble. (Needs to be 2 jiffies)
          */
         FDCS->dtr = raw_cmd->rate & 3;
-        return (fd_wait_for_completion(jiffies + 2UL * HZ / 100,
-                                       (timeout_fn) floppy_ready));
+        return fd_wait_for_completion(jiffies + 2UL * HZ / 100,
+                                      (timeout_fn)floppy_ready);
 }                               /* fdc_dtr */
 
 static void tell_sector(void)
 {
-        printk(": track %d, head %d, sector %d, size %d",
-               R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
+        pr_cont(": track %d, head %d, sector %d, size %d",
+                R_TRACK, R_HEAD, R_SECTOR, R_SIZECODE);
 }                               /* tell_sector */
 
+static void print_errors(void)
+{
+        DPRINT("");
+        if (ST0 & ST0_ECE) {
+                pr_cont("Recalibrate failed!");
+        } else if (ST2 & ST2_CRC) {
+                pr_cont("data CRC error");
+                tell_sector();
+        } else if (ST1 & ST1_CRC) {
+                pr_cont("CRC error");
+                tell_sector();
+        } else if ((ST1 & (ST1_MAM | ST1_ND)) ||
+                   (ST2 & ST2_MAM)) {
+                if (!probing) {
+                        pr_cont("sector not found");
+                        tell_sector();
+                } else
+                        pr_cont("probe failed...");
+        } else if (ST2 & ST2_WC) {      /* seek error */
+                pr_cont("wrong cylinder");
+        } else if (ST2 & ST2_BC) {      /* cylinder marked as bad */
+                pr_cont("bad cylinder");
+        } else {
+                pr_cont("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
+                        ST0, ST1, ST2);
+                tell_sector();
+        }
+        pr_cont("\n");
+}
+
 /*
  * OK, this error interpreting routine is called after a
  * DMA read/write has succeeded
@@ -1437,7 +1445,7 @@ static int interpret_errors(void)
         char bad;
 
         if (inr != 7) {
-                DPRINT("-- FDC reply error");
+                DPRINT("-- FDC reply error\n");
                 FDCS->reset = 1;
                 return 1;
         }
@@ -1450,43 +1458,17 @@ static int interpret_errors(void)
                 bad = 1;
                 if (ST1 & ST1_WP) {
                         DPRINT("Drive is write protected\n");
-                        CLEARF(FD_DISK_WRITABLE);
+                        clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
                         cont->done(0);
                         bad = 2;
                 } else if (ST1 & ST1_ND) {
-                        SETF(FD_NEED_TWADDLE);
+                        set_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
                 } else if (ST1 & ST1_OR) {
                         if (DP->flags & FTD_MSG)
                                 DPRINT("Over/Underrun - retrying\n");
                         bad = 0;
                 } else if (*errors >= DP->max_errors.reporting) {
-                        DPRINT("");
-                        if (ST0 & ST0_ECE) {
-                                printk("Recalibrate failed!");
-                        } else if (ST2 & ST2_CRC) {
-                                printk("data CRC error");
-                                tell_sector();
-                        } else if (ST1 & ST1_CRC) {
-                                printk("CRC error");
-                                tell_sector();
-                        } else if ((ST1 & (ST1_MAM | ST1_ND))
-                                   || (ST2 & ST2_MAM)) {
-                                if (!probing) {
-                                        printk("sector not found");
-                                        tell_sector();
-                                } else
-                                        printk("probe failed...");
-                        } else if (ST2 & ST2_WC) {      /* seek error */
-                                printk("wrong cylinder");
-                        } else if (ST2 & ST2_BC) {      /* cylinder marked as bad */
-                                printk("bad cylinder");
-                        } else {
-                                printk
-                                    ("unknown error. ST[0..2] are: 0x%x 0x%x 0x%x",
-                                     ST0, ST1, ST2);
-                                tell_sector();
-                        }
-                        printk("\n");
+                        print_errors();
                 }
                 if (ST2 & ST2_WC || ST2 & ST2_BC)
                         /* wrong cylinder => recal */
@@ -1531,9 +1513,9 @@ static void setup_rw_floppy(void)
                  */
                 if (time_after(ready_date, jiffies + DP->select_delay)) {
                         ready_date -= DP->select_delay;
-                        function = (timeout_fn) floppy_start;
+                        function = (timeout_fn)floppy_start;
                 } else
-                        function = (timeout_fn) setup_rw_floppy;
+                        function = (timeout_fn)setup_rw_floppy;
 
                 /* wait until the floppy is spinning fast enough */
                 if (fd_wait_for_completion(ready_date, function))
@@ -1551,7 +1533,7 @@ static void setup_rw_floppy(void)
         for (i = 0; i < raw_cmd->cmd_count; i++)
                 r |= output_byte(raw_cmd->cmd[i]);
 
-        debugt("rw_command: ");
+        debugt(__func__, "rw_command");
 
         if (r) {
                 cont->error();
@@ -1574,7 +1556,7 @@ static int blind_seek;
  */
 static void seek_interrupt(void)
 {
-        debugt("seek interrupt:");
+        debugt(__func__, "");
         if (inr != 2 || (ST0 & 0xF8) != 0x20) {
                 DPRINT("seek failed\n");
                 DRS->track = NEED_2_RECAL;
@@ -1583,14 +1565,11 @@ static void seek_interrupt(void)
                 return;
         }
         if (DRS->track >= 0 && DRS->track != ST1 && !blind_seek) {
-#ifdef DCL_DEBUG
-                if (DP->flags & FD_DEBUG) {
-                        DPRINT
-                            ("clearing NEWCHANGE flag because of effective seek\n");
-                        DPRINT("jiffies=%lu\n", jiffies);
-                }
-#endif
-                CLEARF(FD_DISK_NEWCHANGE);      /* effective seek */
+                debug_dcl(DP->flags,
+                          "clearing NEWCHANGE flag because of effective seek\n");
+                debug_dcl(DP->flags, "jiffies=%lu\n", jiffies);
+                clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
+                                        /* effective seek */
                 DRS->select_date = jiffies;
         }
         DRS->track = ST1;
@@ -1599,26 +1578,23 @@ static void seek_interrupt(void)
 
 static void check_wp(void)
 {
-        if (TESTF(FD_VERIFY)) {
-                /* check write protection */
+        if (test_bit(FD_VERIFY_BIT, &DRS->flags)) {
+                                        /* check write protection */
                 output_byte(FD_GETSTATUS);
                 output_byte(UNIT(current_drive));
                 if (result() != 1) {
                         FDCS->reset = 1;
                         return;
                 }
-                CLEARF(FD_VERIFY);
-                CLEARF(FD_NEED_TWADDLE);
-#ifdef DCL_DEBUG
-                if (DP->flags & FD_DEBUG) {
-                        DPRINT("checking whether disk is write protected\n");
-                        DPRINT("wp=%x\n", ST3 & 0x40);
-                }
-#endif
+                clear_bit(FD_VERIFY_BIT, &DRS->flags);
+                clear_bit(FD_NEED_TWADDLE_BIT, &DRS->flags);
+                debug_dcl(DP->flags,
+                          "checking whether disk is write protected\n");
+                debug_dcl(DP->flags, "wp=%x\n", ST3 & 0x40);
                 if (!(ST3 & 0x40))
-                        SETF(FD_DISK_WRITABLE);
+                        set_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
                 else
-                        CLEARF(FD_DISK_WRITABLE);
+                        clear_bit(FD_DISK_WRITABLE_BIT, &DRS->flags);
         }
 }
 
@@ -1628,19 +1604,15 @@ static void seek_floppy(void)
 
         blind_seek = 0;
 
-#ifdef DCL_DEBUG
-        if (DP->flags & FD_DEBUG) {
-                DPRINT("calling disk change from seek\n");
-        }
-#endif
+        debug_dcl(DP->flags, "calling disk change from %s\n", __func__);
 
-        if (!TESTF(FD_DISK_NEWCHANGE) &&
+        if (!test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
             disk_change(current_drive) && (raw_cmd->flags & FD_RAW_NEED_DISK)) {
                 /* the media changed flag should be cleared after the seek.
                  * If it isn't, this means that there is really no disk in
                  * the drive.
                  */
-                SETF(FD_DISK_CHANGED);
+                set_bit(FD_DISK_CHANGED_BIT, &DRS->flags);
                 cont->done(0);
                 cont->redo();
                 return;
@@ -1648,7 +1620,7 @@ static void seek_floppy(void)
         if (DRS->track <= NEED_1_RECAL) {
                 recalibrate_floppy();
                 return;
-        } else if (TESTF(FD_DISK_NEWCHANGE) &&
+        } else if (test_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags) &&
                    (raw_cmd->flags & FD_RAW_NEED_DISK) &&
                    (DRS->track <= NO_TRACK || DRS->track == raw_cmd->track)) {
                 /* we seek to clear the media-changed condition. Does anybody
@@ -1677,19 +1649,22 @@ static void seek_floppy(void)
         do_floppy = seek_interrupt;
         output_byte(FD_SEEK);
         output_byte(UNIT(current_drive));
-        LAST_OUT(track);
-        debugt("seek command:");
+        if (output_byte(track) < 0) {
+                reset_fdc();
+                return;
+        }
+        debugt(__func__, "");
 }
 
 static void recal_interrupt(void)
 {
-        debugt("recal interrupt:");
+        debugt(__func__, "");
         if (inr != 2)
                 FDCS->reset = 1;
         else if (ST0 & ST0_ECE) {
                 switch (DRS->track) {
                 case NEED_1_RECAL:
-                        debugt("recal interrupt need 1 recal:");
+                        debugt(__func__, "need 1 recal");
                         /* after a second recalibrate, we still haven't
                          * reached track 0. Probably no drive. Raise an
                          * error, as failing immediately might upset
@@ -1698,25 +1673,21 @@ static void recal_interrupt(void)
                         cont->redo();
                         return;
                 case NEED_2_RECAL:
-                        debugt("recal interrupt need 2 recal:");
+                        debugt(__func__, "need 2 recal");
                         /* If we already did a recalibrate,
                          * and we are not at track 0, this
                          * means we have moved. (The only way
                          * not to move at recalibration is to
                          * be already at track 0.) Clear the
                          * new change flag */
-#ifdef DCL_DEBUG
-                        if (DP->flags & FD_DEBUG) {
-                                DPRINT
-                                    ("clearing NEWCHANGE flag because of second recalibrate\n");
-                        }
-#endif
+                        debug_dcl(DP->flags,
+                                  "clearing NEWCHANGE flag because of second recalibrate\n");
 
-                        CLEARF(FD_DISK_NEWCHANGE);
+                        clear_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
                         DRS->select_date = jiffies;
                         /* fall through */
                 default:
-                        debugt("recal interrupt default:");
+                        debugt(__func__, "default");
                         /* Recalibrate moves the head by at
                          * most 80 steps. If after one
                          * recalibrate we don't have reached
@@ -1738,8 +1709,8 @@ static void print_result(char *message, int inr)
         DPRINT("%s ", message);
         if (inr >= 0)
                 for (i = 0; i < inr; i++)
-                        printk("repl[%d]=%x ", i, reply_buffer[i]);
-        printk("\n");
+                        pr_cont("repl[%d]=%x ", i, reply_buffer[i]);
+        pr_cont("\n");
 }
 
 /* interrupt handler. Note that this can be called externally on the Sparc */
@@ -1760,10 +1731,10 @@ irqreturn_t floppy_interrupt(int irq, void *dev_id)
         do_floppy = NULL;
         if (fdc >= N_FDC || FDCS->address == -1) {
                 /* we don't even know which FDC is the culprit */
-                printk("DOR0=%x\n", fdc_state[0].dor);
-                printk("floppy interrupt on bizarre fdc %d\n", fdc);
-                printk("handler=%p\n", handler);
-                is_alive("bizarre fdc");
+                pr_info("DOR0=%x\n", fdc_state[0].dor);
+                pr_info("floppy interrupt on bizarre fdc %d\n", fdc);
+                pr_info("handler=%pf\n", handler);
+                is_alive(__func__, "bizarre fdc");
                 return IRQ_NONE;
         }
 
@@ -1777,7 +1748,7 @@ irqreturn_t floppy_interrupt(int irq, void *dev_id)
          * activity.
          */
 
-        do_print = !handler && print_unex && !initialising;
+        do_print = !handler && print_unex && initialized;
 
         inr = result();
         if (do_print)
@@ -1790,15 +1761,15 @@ irqreturn_t floppy_interrupt(int irq, void *dev_id)
                         if (do_print)
                                 print_result("sensei", inr);
                         max_sensei--;
-                } while ((ST0 & 0x83) != UNIT(current_drive) && inr == 2
-                         && max_sensei);
+                } while ((ST0 & 0x83) != UNIT(current_drive) &&
+                         inr == 2 && max_sensei);
         }
         if (!handler) {
                 FDCS->reset = 1;
                 return IRQ_NONE;
         }
         schedule_bh(handler);
-        is_alive("normal interrupt end");
+        is_alive(__func__, "normal interrupt end");
 
         /* FIXME! Was it really for us? */
         return IRQ_HANDLED;
@@ -1806,10 +1777,11 @@ irqreturn_t floppy_interrupt(int irq, void *dev_id)
 
 static void recalibrate_floppy(void)
 {
-        debugt("recalibrate floppy:");
+        debugt(__func__, "");
         do_floppy = recal_interrupt;
         output_byte(FD_RECALIBRATE);
-        LAST_OUT(UNIT(current_drive));
+        if (output_byte(UNIT(current_drive)) < 0)
+                reset_fdc();
 }
 
 /*
@@ -1817,10 +1789,10 @@ static void recalibrate_floppy(void)
  */
 static void reset_interrupt(void)
 {
-        debugt("reset interrupt:");
+        debugt(__func__, "");
         result();               /* get the status ready for set_fdc */
         if (FDCS->reset) {
-                printk("reset set in interrupt, calling %p\n", cont->error);
+                pr_info("reset set in interrupt, calling %pf\n", cont->error);
                 cont->error();  /* a reset just after a reset. BAD! */
         }
         cont->redo();
@@ -1858,53 +1830,49 @@ static void show_floppy(void)
 {
         int i;
 
-        printk("\n");
-        printk("floppy driver state\n");
-        printk("-------------------\n");
-        printk("now=%lu last interrupt=%lu diff=%lu last called handler=%p\n",
-               jiffies, interruptjiffies, jiffies - interruptjiffies,
-               lasthandler);
+        pr_info("\n");
+        pr_info("floppy driver state\n");
+        pr_info("-------------------\n");
+        pr_info("now=%lu last interrupt=%lu diff=%lu last called handler=%pf\n",
+                jiffies, interruptjiffies, jiffies - interruptjiffies,
+                lasthandler);
 
-#ifdef FLOPPY_SANITY_CHECK
-        printk("timeout_message=%s\n", timeout_message);
-        printk("last output bytes:\n");
+        pr_info("timeout_message=%s\n", timeout_message);
+        pr_info("last output bytes:\n");
         for (i = 0; i < OLOGSIZE; i++)
-                printk("%2x %2x %lu\n",
-                       output_log[(i + output_log_pos) % OLOGSIZE].data,
-                       output_log[(i + output_log_pos) % OLOGSIZE].status,
-                       output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
-        printk("last result at %lu\n", resultjiffies);
-        printk("last redo_fd_request at %lu\n", lastredo);
-        for (i = 0; i < resultsize; i++) {
-                printk("%2x ", reply_buffer[i]);
-        }
-        printk("\n");
-#endif
-
-        printk("status=%x\n", fd_inb(FD_STATUS));
-        printk("fdc_busy=%lu\n", fdc_busy);
+                pr_info("%2x %2x %lu\n",
+                        output_log[(i + output_log_pos) % OLOGSIZE].data,
+                        output_log[(i + output_log_pos) % OLOGSIZE].status,
+                        output_log[(i + output_log_pos) % OLOGSIZE].jiffies);
+        pr_info("last result at %lu\n", resultjiffies);
+        pr_info("last redo_fd_request at %lu\n", lastredo);
+        print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1,
+                       reply_buffer, resultsize, true);
+
+        pr_info("status=%x\n", fd_inb(FD_STATUS));
+        pr_info("fdc_busy=%lu\n", fdc_busy);
         if (do_floppy)
-                printk("do_floppy=%p\n", do_floppy);
+                pr_info("do_floppy=%pf\n", do_floppy);
         if (work_pending(&floppy_work))
-                printk("floppy_work.func=%p\n", floppy_work.func);
+                pr_info("floppy_work.func=%pf\n", floppy_work.func);
         if (timer_pending(&fd_timer))
-                printk("fd_timer.function=%p\n", fd_timer.function);
+                pr_info("fd_timer.function=%pf\n", fd_timer.function);
         if (timer_pending(&fd_timeout)) {
-                printk("timer_function=%p\n", fd_timeout.function);
-                printk("expires=%lu\n", fd_timeout.expires - jiffies);
-                printk("now=%lu\n", jiffies);
-        }
-        printk("cont=%p\n", cont);
-        printk("current_req=%p\n", current_req);
-        printk("command_status=%d\n", command_status);
-        printk("\n");
+                pr_info("timer_function=%pf\n", fd_timeout.function);
+                pr_info("expires=%lu\n", fd_timeout.expires - jiffies);
+                pr_info("now=%lu\n", jiffies);
+        }
+        pr_info("cont=%p\n", cont);
+        pr_info("current_req=%p\n", current_req);
+        pr_info("command_status=%d\n", command_status);
+        pr_info("\n");
 }
 
 static void floppy_shutdown(unsigned long data)
 {
         unsigned long flags;
 
-        if (!initialising)
+        if (initialized)
                 show_floppy();
         cancel_activity();
 
@@ -1916,17 +1884,17 @@ static void floppy_shutdown(unsigned long data)
 
         /* avoid dma going to a random drive after shutdown */
 
-        if (!initialising)
+        if (initialized)
                 DPRINT("floppy timeout called\n");
         FDCS->reset = 1;
         if (cont) {
                 cont->done(0);
                 cont->redo();   /* this will recall reset when needed */
         } else {
-                printk("no cont in shutdown!\n");
+                pr_info("no cont in shutdown!\n");
                 process_fd_request();
         }
-        is_alive("floppy shutdown");
+        is_alive(__func__, "");
 }
 
 /* start motor, check media-changed condition and write protection */
@@ -1954,27 +1922,26 @@ static int start_motor(void (*function)(void))
         set_dor(fdc, mask, data);
 
         /* wait_for_completion also schedules reset if needed. */
-        return (fd_wait_for_completion(DRS->select_date + DP->select_delay,
-                                       (timeout_fn) function));
+        return fd_wait_for_completion(DRS->select_date + DP->select_delay,
+                                      (timeout_fn)function);
 }
 
 static void floppy_ready(void)
 {
-        CHECK_RESET;
+        if (FDCS->reset) {
+                reset_fdc();
+                return;
+        }
         if (start_motor(floppy_ready))
                 return;
         if (fdc_dtr())
                 return;
 
-#ifdef DCL_DEBUG
-        if (DP->flags & FD_DEBUG) {
-                DPRINT("calling disk change from floppy_ready\n");
-        }
-#endif
+        debug_dcl(DP->flags, "calling disk change from floppy_ready\n");
         if (!(raw_cmd->flags & FD_RAW_NO_MOTOR) &&
             disk_change(current_drive) && !DP->select_delay)
-                twaddle();      /* this clears the dcl on certain drive/controller
-                                 * combinations */
+                twaddle();      /* this clears the dcl on certain
+                                 * drive/controller combinations */
 
 #ifdef fd_chose_dma_mode
         if ((raw_cmd->flags & FD_RAW_READ) || (raw_cmd->flags & FD_RAW_WRITE)) {
@@ -1998,15 +1965,11 @@ static void floppy_ready(void)
 
 static void floppy_start(void)
 {
-        reschedule_timeout(current_reqD, "floppy start", 0);
+        reschedule_timeout(current_reqD, "floppy start");
 
         scandrives();
-#ifdef DCL_DEBUG
-        if (DP->flags & FD_DEBUG) {
-                DPRINT("setting NEWCHANGE in floppy_start\n");
-        }
-#endif
-        SETF(FD_DISK_NEWCHANGE);
+        debug_dcl(DP->flags, "setting NEWCHANGE in floppy_start\n");
+        set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
         floppy_ready();
 }
 
@@ -2026,7 +1989,7 @@ static void floppy_start(void)
 
 static void do_wakeup(void)
 {
-        reschedule_timeout(MAXTIMEOUT, "do wakeup", 0);
+        reschedule_timeout(MAXTIMEOUT, "do wakeup");
         cont = NULL;
         command_status += 2;
         wake_up(&command_done);
@@ -2046,7 +2009,7 @@ static struct cont_t intr_cont = {
         .done           = (done_f)empty
 };
 
-static int wait_til_done(void (*handler)(void), int interruptible)
+static int wait_til_done(void (*handler)(void), bool interruptible)
 {
         int ret;
 
@@ -2064,7 +2027,7 @@ static int wait_til_done(void (*handler)(void), int interruptible)
                         if (command_status >= 2 || !NO_SIGNAL)
                                 break;
 
-                        is_alive("wait_til_done");
+                        is_alive(__func__, "");
                         schedule();
                 }
 
@@ -2180,9 +2143,9 @@ static void format_interrupt(void)
         cont->redo();
 }
 
-#define CODE2SIZE (ssize = ((1 << SIZECODE) + 3) >> 2)
-#define FM_MODE(x,y) ((y) & ~(((x)->rate & 0x80) >>1))
+#define FM_MODE(x, y) ((y) & ~(((x)->rate & 0x80) >> 1))
 #define CT(x) ((x) | 0xc0)
+
 static void setup_format_params(int track)
 {
         int n;
@@ -2197,8 +2160,8 @@ static void setup_format_params(int track)
         raw_cmd = &default_raw_cmd;
         raw_cmd->track = track;
 
-        raw_cmd->flags = FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
-            FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK;
+        raw_cmd->flags = (FD_RAW_WRITE | FD_RAW_INTR | FD_RAW_SPIN |
+                          FD_RAW_NEED_DISK | FD_RAW_NEED_SEEK);
         raw_cmd->rate = _floppy->rate & 0x43;
         raw_cmd->cmd_count = NR_F;
         COMMAND = FM_MODE(_floppy, FD_FORMAT);
@@ -2257,7 +2220,7 @@ static void redo_format(void)
         buffer_track = -1;
         setup_format_params(format_req.track << STRETCH(_floppy));
         floppy_start();
-        debugt("queue format request");
+        debugt(__func__, "queue format request");
 }
 
 static struct cont_t format_cont = {
@@ -2271,7 +2234,9 @@ static int do_format(int drive, struct format_descr *tmp_format_req)
 {
         int ret;
 
-        LOCK_FDC(drive, 1);
+        if (lock_fdc(drive, true))
+                return -EINTR;
+
         set_floppy(drive);
         if (!_floppy ||
             _floppy->track > DP->tracks ||
@@ -2286,7 +2251,9 @@ static int do_format(int drive, struct format_descr *tmp_format_req)
         format_errors = 0;
         cont = &format_cont;
         errors = &format_errors;
-        IWAIT(redo_format);
+        ret = wait_til_done(redo_format, true);
+        if (ret == -EINTR)
+                return -EINTR;
         process_fd_request();
         return ret;
 }
@@ -2320,12 +2287,14 @@ static void request_done(int uptodate)
         struct request *req = current_req;
         unsigned long flags;
         int block;
+        char msg[sizeof("request done ") + sizeof(int) * 3];
 
         probing = 0;
-        reschedule_timeout(MAXTIMEOUT, "request done %d", uptodate);
+        snprintf(msg, sizeof(msg), "request done %d", uptodate);
+        reschedule_timeout(MAXTIMEOUT, msg);
 
         if (!req) {
-                printk("floppy.c: no request in request_done\n");
+                pr_info("floppy.c: no request in request_done\n");
                 return;
         }
 
@@ -2377,7 +2346,7 @@ static void rw_interrupt(void)
                 DRS->first_read_date = jiffies;
 
         nr_sectors = 0;
-        CODE2SIZE;
+        ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
 
         if (ST1 & ST1_EOC)
                 eoc = 1;
@@ -2393,20 +2362,18 @@ static void rw_interrupt(void)
                        R_HEAD - HEAD) * SECT_PER_TRACK +
                       R_SECTOR - SECTOR + eoc) << SIZECODE >> 2;
 
-#ifdef FLOPPY_SANITY_CHECK
         if (nr_sectors / ssize >
             DIV_ROUND_UP(in_sector_offset + current_count_sectors, ssize)) {
                 DPRINT("long rw: %x instead of %lx\n",
                        nr_sectors, current_count_sectors);
-                printk("rs=%d s=%d\n", R_SECTOR, SECTOR);
-                printk("rh=%d h=%d\n", R_HEAD, HEAD);
-                printk("rt=%d t=%d\n", R_TRACK, TRACK);
-                printk("heads=%d eoc=%d\n", heads, eoc);
-                printk("spt=%d st=%d ss=%d\n", SECT_PER_TRACK,
-                       fsector_t, ssize);
-                printk("in_sector_offset=%d\n", in_sector_offset);
+                pr_info("rs=%d s=%d\n", R_SECTOR, SECTOR);
+                pr_info("rh=%d h=%d\n", R_HEAD, HEAD);
+                pr_info("rt=%d t=%d\n", R_TRACK, TRACK);
+                pr_info("heads=%d eoc=%d\n", heads, eoc);
+                pr_info("spt=%d st=%d ss=%d\n",
+                        SECT_PER_TRACK, fsector_t, ssize);
+                pr_info("in_sector_offset=%d\n", in_sector_offset);
         }
-#endif
 
         nr_sectors -= in_sector_offset;
         INFBOUND(nr_sectors, 0);
@@ -2511,19 +2478,17 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
                                               blk_rq_sectors(current_req));
 
         remaining = current_count_sectors << 9;
-#ifdef FLOPPY_SANITY_CHECK
         if (remaining > blk_rq_bytes(current_req) && CT(COMMAND) == FD_WRITE) {
                 DPRINT("in copy buffer\n");
-                printk("current_count_sectors=%ld\n", current_count_sectors);
-                printk("remaining=%d\n", remaining >> 9);
-                printk("current_req->nr_sectors=%u\n",
-                       blk_rq_sectors(current_req));
-                printk("current_req->current_nr_sectors=%u\n",
-                       blk_rq_cur_sectors(current_req));
-                printk("max_sector=%d\n", max_sector);
-                printk("ssize=%d\n", ssize);
+                pr_info("current_count_sectors=%ld\n", current_count_sectors);
+                pr_info("remaining=%d\n", remaining >> 9);
+                pr_info("current_req->nr_sectors=%u\n",
+                        blk_rq_sectors(current_req));
+                pr_info("current_req->current_nr_sectors=%u\n",
+                        blk_rq_cur_sectors(current_req));
+                pr_info("max_sector=%d\n", max_sector);
+                pr_info("ssize=%d\n", ssize);
         }
-#endif
 
         buffer_max = max(max_sector, buffer_max);
 
@@ -2539,26 +2504,24 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
                 SUPBOUND(size, remaining);
 
                 buffer = page_address(bv->bv_page) + bv->bv_offset;
-#ifdef FLOPPY_SANITY_CHECK
                 if (dma_buffer + size >
                     floppy_track_buffer + (max_buffer_sectors << 10) ||
                     dma_buffer < floppy_track_buffer) {
                         DPRINT("buffer overrun in copy buffer %d\n",
-                               (int)((floppy_track_buffer -
-                                      dma_buffer) >> 9));
-                        printk("fsector_t=%d buffer_min=%d\n",
-                               fsector_t, buffer_min);
-                        printk("current_count_sectors=%ld\n",
-                               current_count_sectors);
+                               (int)((floppy_track_buffer - dma_buffer) >> 9));
+                        pr_info("fsector_t=%d buffer_min=%d\n",
+                                fsector_t, buffer_min);
+                        pr_info("current_count_sectors=%ld\n",
+                                current_count_sectors);
                         if (CT(COMMAND) == FD_READ)
-                                printk("read\n");
+                                pr_info("read\n");
                         if (CT(COMMAND) == FD_WRITE)
-                                printk("write\n");
+                                pr_info("write\n");
                         break;
                 }
                 if (((unsigned long)buffer) % 512)
                         DPRINT("%p buffer not aligned\n", buffer);
-#endif
+
                 if (CT(COMMAND) == FD_READ)
                         memcpy(buffer, dma_buffer, size);
                 else
@@ -2567,13 +2530,11 @@ static void copy_buffer(int ssize, int max_sector, int max_sector_2)
                 remaining -= size;
                 dma_buffer += size;
         }
-#ifdef FLOPPY_SANITY_CHECK
         if (remaining) {
                 if (remaining > 0)
                         max_sector -= remaining >> 9;
                 DPRINT("weirdness: remaining %d\n", remaining >> 9);
         }
-#endif
 }
 
 /* work around a bug in pseudo DMA
@@ -2593,15 +2554,14 @@ static void virtualdmabug_workaround(void)
 
                 hard_sectors = raw_cmd->length >> (7 + SIZECODE);
                 end_sector = SECTOR + hard_sectors - 1;
-#ifdef FLOPPY_SANITY_CHECK
                 if (end_sector > SECT_PER_TRACK) {
-                        printk("too many sectors %d > %d\n",
-                               end_sector, SECT_PER_TRACK);
+                        pr_info("too many sectors %d > %d\n",
+                                end_sector, SECT_PER_TRACK);
                         return;
                 }
-#endif
-                SECT_PER_TRACK = end_sector;    /* make sure SECT_PER_TRACK points
-                                                 * to end of transfer */
+                SECT_PER_TRACK = end_sector;
+                                        /* make sure SECT_PER_TRACK
+                                         * points to end of transfer */
         }
 }
 
@@ -2624,7 +2584,7 @@ static int make_raw_rw_request(void)
         int ssize;
 
         if (max_buffer_sectors == 0) {
-                printk("VFS: Block I/O scheduled on unopened device\n");
+                pr_info("VFS: Block I/O scheduled on unopened device\n");
                 return 0;
         }
 
@@ -2641,7 +2601,7 @@ static int make_raw_rw_request(void)
                 raw_cmd->flags |= FD_RAW_WRITE;
                 COMMAND = FM_MODE(_floppy, FD_WRITE);
         } else {
-                DPRINT("make_raw_rw_request: unknown command\n");
+                DPRINT("%s: unknown command\n", __func__);
                 return 0;
         }
 
@@ -2659,7 +2619,8 @@ static int make_raw_rw_request(void)
         HEAD = fsector_t / _floppy->sect;
 
         if (((_floppy->stretch & (FD_SWAPSIDES | FD_SECTBASEMASK)) ||
-             TESTF(FD_NEED_TWADDLE)) && fsector_t < _floppy->sect)
+             test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags)) &&
+            fsector_t < _floppy->sect)
                 max_sector = _floppy->sect;
 
         /* 2M disks have phantom sectors on the first track */
@@ -2685,7 +2646,7 @@ static int make_raw_rw_request(void)
         raw_cmd->track = TRACK << STRETCH(_floppy);
         DR_SELECT = UNIT(current_drive) + PH_HEAD(_floppy, HEAD);
         GAP = _floppy->gap;
-        CODE2SIZE;
+        ssize = DIV_ROUND_UP(1 << SIZECODE, 4);
         SECT_PER_TRACK = _floppy->sect << 2 >> SIZECODE;
         SECTOR = ((fsector_t % _floppy->sect) << 2 >> SIZECODE) +
             FD_SECTBASE(_floppy);
@@ -2730,8 +2691,10 @@ static int make_raw_rw_request(void)
                 }
         } else if (in_sector_offset || blk_rq_sectors(current_req) < ssize) {
                 if (CT(COMMAND) == FD_WRITE) {
-                        if (fsector_t + blk_rq_sectors(current_req) > ssize &&
-                            fsector_t + blk_rq_sectors(current_req) < ssize + ssize)
+                        unsigned int sectors;
+
+                        sectors = fsector_t + blk_rq_sectors(current_req);
+                        if (sectors > ssize && sectors < ssize + ssize)
                                 max_size = ssize + ssize;
                         else
                                 max_size = ssize;
@@ -2752,12 +2715,10 @@ static int make_raw_rw_request(void)
                  * on a 64 bit machine!
                  */
                 max_size = buffer_chain_size();
-                dma_limit =
-                    (MAX_DMA_ADDRESS -
-                     ((unsigned long)current_req->buffer)) >> 9;
-                if ((unsigned long)max_size > dma_limit) {
+                dma_limit = (MAX_DMA_ADDRESS -
+                             ((unsigned long)current_req->buffer)) >> 9;
+                if ((unsigned long)max_size > dma_limit)
                         max_size = dma_limit;
-                }
                 /* 64 kb boundaries */
                 if (CROSS_64KB(current_req->buffer, max_size << 9))
                         max_size = (K_64 -
@@ -2773,16 +2734,16 @@ static int make_raw_rw_request(void)
                  */
                 if (!direct ||
                     (indirect * 2 > direct * 3 &&
-                     *errors < DP->max_errors.read_track && ((!probing
-                       || (DP->read_track & (1 << DRS->probed_format)))))) {
+                     *errors < DP->max_errors.read_track &&
+                     ((!probing ||
+                       (DP->read_track & (1 << DRS->probed_format)))))) {
                         max_size = blk_rq_sectors(current_req);
                 } else {
                         raw_cmd->kernel_data = current_req->buffer;
                         raw_cmd->length = current_count_sectors << 9;
                         if (raw_cmd->length == 0) {
-                                DPRINT
-                                    ("zero dma transfer attempted from make_raw_request\n");
-                                DPRINT("indirect=%d direct=%d fsector_t=%d",
+                                DPRINT("%s: zero dma transfer attempted\n", __func__);
+                                DPRINT("indirect=%d direct=%d fsector_t=%d\n",
                                        indirect, direct, fsector_t);
                                 return 0;
                         }
@@ -2802,25 +2763,22 @@ static int make_raw_rw_request(void)
             ((CT(COMMAND) == FD_READ ||
               (!in_sector_offset && blk_rq_sectors(current_req) >= ssize)) &&
              max_sector > 2 * max_buffer_sectors + buffer_min &&
-             max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)
-            /* not enough space */
-            ) {
+             max_size + fsector_t > 2 * max_buffer_sectors + buffer_min)) {
+                /* not enough space */
                 buffer_track = -1;
                 buffer_drive = current_drive;
                 buffer_max = buffer_min = aligned_sector_t;
         }
         raw_cmd->kernel_data = floppy_track_buffer +
-            ((aligned_sector_t - buffer_min) << 9);
+                ((aligned_sector_t - buffer_min) << 9);
 
         if (CT(COMMAND) == FD_WRITE) {
                 /* copy write buffer to track buffer.
                  * if we get here, we know that the write
                  * is either aligned or the data already in the buffer
                  * (buffer will be overwritten) */
-#ifdef FLOPPY_SANITY_CHECK
                 if (in_sector_offset && buffer_track == -1)
                         DPRINT("internal error offset !=0 on write\n");
-#endif
                 buffer_track = raw_cmd->track;
                 buffer_drive = current_drive;
                 copy_buffer(ssize, max_sector,
@@ -2834,7 +2792,6 @@ static int make_raw_rw_request(void)
         raw_cmd->length = in_sector_offset + current_count_sectors;
         raw_cmd->length = ((raw_cmd->length - 1) | (ssize - 1)) + 1;
         raw_cmd->length <<= 9;
-#ifdef FLOPPY_SANITY_CHECK
         if ((raw_cmd->length < current_count_sectors << 9) ||
             (raw_cmd->kernel_data != current_req->buffer &&
              CT(COMMAND) == FD_WRITE &&
@@ -2845,19 +2802,19 @@ static int make_raw_rw_request(void)
                 DPRINT("fractionary current count b=%lx s=%lx\n",
                        raw_cmd->length, current_count_sectors);
                 if (raw_cmd->kernel_data != current_req->buffer)
-                        printk("addr=%d, length=%ld\n",
-                               (int)((raw_cmd->kernel_data -
-                                      floppy_track_buffer) >> 9),
-                               current_count_sectors);
-                printk("st=%d ast=%d mse=%d msi=%d\n",
-                       fsector_t, aligned_sector_t, max_sector, max_size);
-                printk("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
-                printk("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
-                       COMMAND, SECTOR, HEAD, TRACK);
-                printk("buffer drive=%d\n", buffer_drive);
-                printk("buffer track=%d\n", buffer_track);
-                printk("buffer_min=%d\n", buffer_min);
-                printk("buffer_max=%d\n", buffer_max);
+                        pr_info("addr=%d, length=%ld\n",
+                                (int)((raw_cmd->kernel_data -
+                                       floppy_track_buffer) >> 9),
+                                current_count_sectors);
+                pr_info("st=%d ast=%d mse=%d msi=%d\n",
+                        fsector_t, aligned_sector_t, max_sector, max_size);
+                pr_info("ssize=%x SIZECODE=%d\n", ssize, SIZECODE);
+                pr_info("command=%x SECTOR=%d HEAD=%d, TRACK=%d\n",
+                        COMMAND, SECTOR, HEAD, TRACK);
+                pr_info("buffer drive=%d\n", buffer_drive);
+                pr_info("buffer track=%d\n", buffer_track);
+                pr_info("buffer_min=%d\n", buffer_min);
+                pr_info("buffer_max=%d\n", buffer_max);
                 return 0;
         }
 
@@ -2868,14 +2825,14 @@ static int make_raw_rw_request(void)
                     raw_cmd->kernel_data + raw_cmd->length >
                     floppy_track_buffer + (max_buffer_sectors << 10)) {
                         DPRINT("buffer overrun in schedule dma\n");
-                        printk("fsector_t=%d buffer_min=%d current_count=%ld\n",
-                               fsector_t, buffer_min, raw_cmd->length >> 9);
-                        printk("current_count_sectors=%ld\n",
-                               current_count_sectors);
+                        pr_info("fsector_t=%d buffer_min=%d current_count=%ld\n",
+                                fsector_t, buffer_min, raw_cmd->length >> 9);
+                        pr_info("current_count_sectors=%ld\n",
+                                current_count_sectors);
                         if (CT(COMMAND) == FD_READ)
-                                printk("read\n");
+                                pr_info("read\n");
                         if (CT(COMMAND) == FD_WRITE)
-                                printk("write\n");
+                                pr_info("write\n");
                         return 0;
                 }
         } else if (raw_cmd->length > blk_rq_bytes(current_req) ||
@@ -2884,14 +2841,13 @@ static int make_raw_rw_request(void)
                 return 0;
         } else if (raw_cmd->length < current_count_sectors << 9) {
                 DPRINT("more sectors than bytes\n");
-                printk("bytes=%ld\n", raw_cmd->length >> 9);
-                printk("sectors=%ld\n", current_count_sectors);
+                pr_info("bytes=%ld\n", raw_cmd->length >> 9);
+                pr_info("sectors=%ld\n", current_count_sectors);
         }
         if (raw_cmd->length == 0) {
                 DPRINT("zero dma transfer attempted from make_raw_request\n");
                 return 0;
         }
-#endif
 
         virtualdmabug_workaround();
         return 2;
@@ -2899,7 +2855,6 @@ static int make_raw_rw_request(void)
 
 static void redo_fd_request(void)
 {
-#define REPEAT {request_done(0); continue; }
         int drive;
         int tmp;
 
@@ -2907,63 +2862,63 @@ static void redo_fd_request(void)
         if (current_drive < N_DRIVE)
                 floppy_off(current_drive);
 
-        for (;;) {
-                if (!current_req) {
-                        struct request *req;
-
-                        spin_lock_irq(floppy_queue->queue_lock);
-                        req = blk_fetch_request(floppy_queue);
-                        spin_unlock_irq(floppy_queue->queue_lock);
-                        if (!req) {
-                                do_floppy = NULL;
-                                unlock_fdc();
-                                return;
-                        }
-                        current_req = req;
-                }
-                drive = (long)current_req->rq_disk->private_data;
-                set_fdc(drive);
-                reschedule_timeout(current_reqD, "redo fd request", 0);
+do_request:
+        if (!current_req) {
+                struct request *req;
 
-                set_floppy(drive);
-                raw_cmd = &default_raw_cmd;
-                raw_cmd->flags = 0;
-                if (start_motor(redo_fd_request))
+                spin_lock_irq(floppy_queue->queue_lock);
+                req = blk_fetch_request(floppy_queue);
+                spin_unlock_irq(floppy_queue->queue_lock);
+                if (!req) {
+                        do_floppy = NULL;
+                        unlock_fdc();
                         return;
-                disk_change(current_drive);
-                if (test_bit(current_drive, &fake_change) ||
-                    TESTF(FD_DISK_CHANGED)) {
-                        DPRINT("disk absent or changed during operation\n");
-                        REPEAT;
-                }
-                if (!_floppy) { /* Autodetection */
-                        if (!probing) {
-                                DRS->probed_format = 0;
-                                if (next_valid_format()) {
-                                        DPRINT("no autodetectable formats\n");
-                                        _floppy = NULL;
-                                        REPEAT;
-                                }
-                        }
-                        probing = 1;
-                        _floppy =
-                            floppy_type + DP->autodetect[DRS->probed_format];
-                } else
-                        probing = 0;
-                errors = &(current_req->errors);
-                tmp = make_raw_rw_request();
-                if (tmp < 2) {
-                        request_done(tmp);
-                        continue;
                 }
+                current_req = req;
+        }
+        drive = (long)current_req->rq_disk->private_data;
+        set_fdc(drive);
+        reschedule_timeout(current_reqD, "redo fd request");
 
-                if (TESTF(FD_NEED_TWADDLE))
-                        twaddle();
-                schedule_bh(floppy_start);
-                debugt("queue fd request");
+        set_floppy(drive);
+        raw_cmd = &default_raw_cmd;
+        raw_cmd->flags = 0;
+        if (start_motor(redo_fd_request))
                 return;
+
+        disk_change(current_drive);
+        if (test_bit(current_drive, &fake_change) ||
+            test_bit(FD_DISK_CHANGED_BIT, &DRS->flags)) {
+                DPRINT("disk absent or changed during operation\n");
+                request_done(0);
+                goto do_request;
+        }
+        if (!_floppy) { /* Autodetection */
+                if (!probing) {
+                        DRS->probed_format = 0;
+                        if (next_valid_format()) {
+                                DPRINT("no autodetectable formats\n");
+                                _floppy = NULL;
+                                request_done(0);
+                                goto do_request;
+                        }
+                }
+                probing = 1;
+                _floppy = floppy_type + DP->autodetect[DRS->probed_format];
+        } else
+                probing = 0;
+        errors = &(current_req->errors);
+        tmp = make_raw_rw_request();
+        if (tmp < 2) {
+                request_done(tmp);
+                goto do_request;
         }
-#undef REPEAT
+
+        if (test_bit(FD_NEED_TWADDLE_BIT, &DRS->flags))
+                twaddle();
+        schedule_bh(floppy_start);
+        debugt(__func__, "queue fd request");
+        return;
 }
 
 static struct cont_t rw_cont = {
@@ -2979,30 +2934,30 @@ static void process_fd_request(void)
         schedule_bh(redo_fd_request);
 }
 
-static void do_fd_request(struct request_queue * q)
+static void do_fd_request(struct request_queue *q)
 {
         if (max_buffer_sectors == 0) {
-                printk("VFS: do_fd_request called on non-open device\n");
+                pr_info("VFS: %s called on non-open device\n", __func__);
                 return;
         }
 
         if (usage_count == 0) {
-                printk("warning: usage count=0, current_req=%p exiting\n",
-                       current_req);
-                printk("sect=%ld type=%x flags=%x\n",
-                       (long)blk_rq_pos(current_req), current_req->cmd_type,
-                       current_req->cmd_flags);
+                pr_info("warning: usage count=0, current_req=%p exiting\n",
+                        current_req);
+                pr_info("sect=%ld type=%x flags=%x\n",
+                        (long)blk_rq_pos(current_req), current_req->cmd_type,
+                        current_req->cmd_flags);
                 return;
         }
         if (test_bit(0, &fdc_busy)) {
                 /* fdc busy, this new request will be treated when the
                    current one is done */
-                is_alive("do fd request, old request running");
+                is_alive(__func__, "old request running");
                 return;
         }
-        lock_fdc(MAXTIMEOUT, 0);
+        lock_fdc(MAXTIMEOUT, false);
         process_fd_request();
-        is_alive("do fd request");
+        is_alive(__func__, "");
 }
 
 static struct cont_t poll_cont = {
@@ -3012,24 +2967,18 @@ static struct cont_t poll_cont = {
         .done           = generic_done
 };
 
-static int poll_drive(int interruptible, int flag)
+static int poll_drive(bool interruptible, int flag)
 {
-        int ret;
-
         /* no auto-sense, just clear dcl */
         raw_cmd = &default_raw_cmd;
         raw_cmd->flags = flag;
         raw_cmd->track = 0;
         raw_cmd->cmd_count = 0;
         cont = &poll_cont;
-#ifdef DCL_DEBUG
-        if (DP->flags & FD_DEBUG) {
-                DPRINT("setting NEWCHANGE in poll_drive\n");
-        }
-#endif
-        SETF(FD_DISK_NEWCHANGE);
-        WAIT(floppy_ready);
-        return ret;
+        debug_dcl(DP->flags, "setting NEWCHANGE in poll_drive\n");
+        set_bit(FD_DISK_NEWCHANGE_BIT, &DRS->flags);
+
+        return wait_til_done(floppy_ready, interruptible);
 }
 
 /*
@@ -3039,7 +2988,7 @@ static int poll_drive(int interruptible, int flag)
 
 static void reset_intr(void)
 {
-        printk("weird, reset interrupt called\n");
+        pr_info("weird, reset interrupt called\n");
 }
 
 static struct cont_t reset_cont = {
@@ -3049,20 +2998,23 @@ static struct cont_t reset_cont = {
         .done           = generic_done
 };
 
-static int user_reset_fdc(int drive, int arg, int interruptible)
+static int user_reset_fdc(int drive, int arg, bool interruptible)
 {
         int ret;
 
-        ret = 0;
-        LOCK_FDC(drive, interruptible);
+        if (lock_fdc(drive, interruptible))
+                return -EINTR;
+
         if (arg == FD_RESET_ALWAYS)
                 FDCS->reset = 1;
         if (FDCS->reset) {
                 cont = &reset_cont;
-                WAIT(reset_fdc);
+                ret = wait_til_done(reset_fdc, interruptible);
+                if (ret == -EINTR)
+                        return -EINTR;
         }
         process_fd_request();
-        return ret;
+        return 0;
 }
 
 /*
@@ -3075,17 +3027,12 @@ static inline int fd_copyout(void __user *param, const void *address,
         return copy_to_user(param, address, size) ? -EFAULT : 0;
 }
 
-static inline int fd_copyin(void __user *param, void *address, unsigned long size)
+static inline int fd_copyin(void __user *param, void *address,
+                            unsigned long size)
 {
         return copy_from_user(address, param, size) ? -EFAULT : 0;
 }
 
-#define _COPYOUT(x) (copy_to_user((void __user *)param, &(x), sizeof(x)) ? -EFAULT : 0)
-#define _COPYIN(x) (copy_from_user(&(x), (void __user *)param, sizeof(x)) ? -EFAULT : 0)
-
-#define COPYOUT(x) ECALL(_COPYOUT(x))
-#define COPYIN(x) ECALL(_COPYIN(x))
-
 static inline const char *drive_name(int type, int drive)
 {
         struct floppy_struct *floppy;
@@ -3156,23 +3103,29 @@ static struct cont_t raw_cmd_cont = {
         .done           = raw_cmd_done
 };
 
-static inline int raw_cmd_copyout(int cmd, char __user *param,
+static inline int raw_cmd_copyout(int cmd, void __user *param,
                                   struct floppy_raw_cmd *ptr)
 {
         int ret;
 
         while (ptr) {
-                COPYOUT(*ptr);
+                ret = copy_to_user(param, ptr, sizeof(*ptr));
+                if (ret)
+                        return -EFAULT;
                 param += sizeof(struct floppy_raw_cmd);
                 if ((ptr->flags & FD_RAW_READ) && ptr->buffer_length) {
-                        if (ptr->length >= 0
-                            && ptr->length <= ptr->buffer_length)
-                                ECALL(fd_copyout
-                                      (ptr->data, ptr->kernel_data,
-                                       ptr->buffer_length - ptr->length));
+                        if (ptr->length >= 0 &&
+                            ptr->length <= ptr->buffer_length) {
+                                long length = ptr->buffer_length - ptr->length;
+                                ret = fd_copyout(ptr->data, ptr->kernel_data,
+                                                 length);
+                                if (ret)
+                                        return ret;
+                        }
                 }
                 ptr = ptr->next;
         }
+
         return 0;
 }
 
@@ -3195,7 +3148,7 @@ static void raw_cmd_free(struct floppy_raw_cmd **ptr)
         }
 }
 
-static inline int raw_cmd_copyin(int cmd, char __user *param,
+static inline int raw_cmd_copyin(int cmd, void __user *param,
                                  struct floppy_raw_cmd **rcmd)
 {
         struct floppy_raw_cmd *ptr;
@@ -3203,17 +3156,19 @@ static inline int raw_cmd_copyin(int cmd, char __user *param,
         int i;
 
         *rcmd = NULL;
-        while (1) {
-                ptr = (struct floppy_raw_cmd *)
-                    kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
-                if (!ptr)
-                        return -ENOMEM;
-                *rcmd = ptr;
-                COPYIN(*ptr);
-                ptr->next = NULL;
-                ptr->buffer_length = 0;
-                param += sizeof(struct floppy_raw_cmd);
-                if (ptr->cmd_count > 33)
+
+loop:
+        ptr = kmalloc(sizeof(struct floppy_raw_cmd), GFP_USER);
+        if (!ptr)
+                return -ENOMEM;
+        *rcmd = ptr;
+        ret = copy_from_user(ptr, param, sizeof(*ptr));
+        if (ret)
+                return -EFAULT;
+        ptr->next = NULL;
+        ptr->buffer_length = 0;
+        param += sizeof(struct floppy_raw_cmd);
+        if (ptr->cmd_count > 33)
                         /* the command may now also take up the space
                          * initially intended for the reply & the
                          * reply count. Needed for long 82078 commands
@@ -3222,31 +3177,35 @@ static inline int raw_cmd_copyin(int cmd, char __user *param,
                          * 16 bytes for a structure, you'll one day
                          * discover that you really need 17...
                          */
+                return -EINVAL;
+
+        for (i = 0; i < 16; i++)
+                ptr->reply[i] = 0;
+        ptr->resultcode = 0;
+        ptr->kernel_data = NULL;
+
+        if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
+                if (ptr->length <= 0)
                         return -EINVAL;
+                ptr->kernel_data = (char *)fd_dma_mem_alloc(ptr->length);
+                fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
+                if (!ptr->kernel_data)
+                        return -ENOMEM;
+                ptr->buffer_length = ptr->length;
+        }
+        if (ptr->flags & FD_RAW_WRITE) {
+                ret = fd_copyin(ptr->data, ptr->kernel_data, ptr->length);
+                if (ret)
+                        return ret;
+        }
 
-                for (i = 0; i < 16; i++)
-                        ptr->reply[i] = 0;
-                ptr->resultcode = 0;
-                ptr->kernel_data = NULL;
-
-                if (ptr->flags & (FD_RAW_READ | FD_RAW_WRITE)) {
-                        if (ptr->length <= 0)
-                                return -EINVAL;
-                        ptr->kernel_data =
-                            (char *)fd_dma_mem_alloc(ptr->length);
-                        fallback_on_nodma_alloc(&ptr->kernel_data, ptr->length);
-                        if (!ptr->kernel_data)
-                                return -ENOMEM;
-                        ptr->buffer_length = ptr->length;
-                }
-                if (ptr->flags & FD_RAW_WRITE)
-                        ECALL(fd_copyin(ptr->data, ptr->kernel_data,
-                                        ptr->length));
+        if (ptr->flags & FD_RAW_MORE) {
                 rcmd = &(ptr->next);
-                if (!(ptr->flags & FD_RAW_MORE))
-                        return 0;
                 ptr->rate &= 0x43;
+                goto loop;
         }
+
+        return 0;
 }
 
 static int raw_cmd_ioctl(int cmd, void __user *param)
@@ -3283,12 +3242,8 @@ static int raw_cmd_ioctl(int cmd, void __user *param)
 
         raw_cmd = my_raw_cmd;
         cont = &raw_cmd_cont;
-        ret = wait_til_done(floppy_start, 1);
-#ifdef DCL_DEBUG
-        if (DP->flags & FD_DEBUG) {
-                DPRINT("calling disk change from raw_cmd ioctl\n");
-        }
-#endif
+        ret = wait_til_done(floppy_start, true);
+        debug_dcl(DP->flags, "calling disk change from raw_cmd ioctl\n");
 
         if (ret != -EINTR && FDCS->reset)
                 ret = -EIO;
@@ -3327,7 +3282,7 @@ static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
                 mutex_lock(&open_lock);
-                if (lock_fdc(drive, 1)) {
+                if (lock_fdc(drive, true)) {
                         mutex_unlock(&open_lock);
                         return -EINTR;
                 }
@@ -3346,11 +3301,15 @@ static inline int set_geometry(unsigned int cmd, struct floppy_struct *g,
                 mutex_unlock(&open_lock);
         } else {
                 int oldStretch;
-                LOCK_FDC(drive, 1);
-                if (cmd != FDDEFPRM)
+
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                if (cmd != FDDEFPRM) {
                         /* notice a disk change immediately, else
                          * we lose our settings immediately*/
-                        CALL(poll_drive(1, FD_RAW_NEED_DISK));
+                        if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
+                                return -EINTR;
+                }
                 oldStretch = g->stretch;
                 user_params[drive] = *g;
                 if (buffer_drive == drive)
@@ -3415,7 +3374,7 @@ static inline int normalize_ioctl(int *cmd, int *size)
                         *size = _IOC_SIZE(*cmd);
                         *cmd = ioctl_table[i];
                         if (*size > _IOC_SIZE(*cmd)) {
-                                printk("ioctl not yet supported\n");
+                                pr_info("ioctl not yet supported\n");
                                 return -EFAULT;
                         }
                         return 0;
@@ -3429,8 +3388,10 @@ static int get_floppy_geometry(int drive, int type, struct floppy_struct **g)
         if (type)
                 *g = &floppy_type[type];
         else {
-                LOCK_FDC(drive, 0);
-                CALL(poll_drive(0, 0));
+                if (lock_fdc(drive, false))
+                        return -EINTR;
+                if (poll_drive(false, 0) == -EINTR)
+                        return -EINTR;
                 process_fd_request();
                 *g = current_type[drive];
         }
@@ -3459,10 +3420,6 @@ static int fd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
 static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
                     unsigned long param)
 {
-#define FD_IOCTL_ALLOWED (mode & (FMODE_WRITE|FMODE_WRITE_IOCTL))
-#define OUT(c,x) case c: outparam = (const char *) (x); break
-#define IN(c,x,tag) case c: *(x) = inparam. tag ; return 0
-
         int drive = (long)bdev->bd_disk->private_data;
         int type = ITYPE(UDRS->fd_device);
         int i;
@@ -3474,26 +3431,28 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
                 struct floppy_max_errors max_errors;
                 struct floppy_drive_params dp;
         } inparam;              /* parameters coming from user space */
-        const char *outparam;   /* parameters passed back to user space */
+        const void *outparam;   /* parameters passed back to user space */
 
         /* convert compatibility eject ioctls into floppy eject ioctl.
          * We do this in order to provide a means to eject floppy disks before
          * installing the new fdutils package */
         if (cmd == CDROMEJECT ||        /* CD-ROM eject */
-            cmd == 0x6470 /* SunOS floppy eject */ ) {
+            cmd == 0x6470) {            /* SunOS floppy eject */
                 DPRINT("obsolete eject ioctl\n");
                 DPRINT("please use floppycontrol --eject\n");
                 cmd = FDEJECT;
         }
 
-        /* convert the old style command into a new style command */
-        if ((cmd & 0xff00) == 0x0200) {
-                ECALL(normalize_ioctl(&cmd, &size));
-        } else
+        if (!((cmd & 0xff00) == 0x0200))
                 return -EINVAL;
 
+        /* convert the old style command into a new style command */
+        ret = normalize_ioctl(&cmd, &size);
+        if (ret)
+                return ret;
+
         /* permission checks */
-        if (((cmd & 0x40) && !FD_IOCTL_ALLOWED) ||
+        if (((cmd & 0x40) && !(mode & (FMODE_WRITE | FMODE_WRITE_IOCTL))) ||
             ((cmd & 0x80) && !capable(CAP_SYS_ADMIN)))
                 return -EPERM;
 
@@ -3501,129 +3460,142 @@ static int fd_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
                 return -EINVAL;
 
         /* copyin */
-        CLEARSTRUCT(&inparam);
-        if (_IOC_DIR(cmd) & _IOC_WRITE)
-            ECALL(fd_copyin((void __user *)param, &inparam, size))
-
-                switch (cmd) {
-                case FDEJECT:
-                        if (UDRS->fd_ref != 1)
-                                /* somebody else has this drive open */
-                                return -EBUSY;
-                        LOCK_FDC(drive, 1);
-
-                        /* do the actual eject. Fails on
-                         * non-Sparc architectures */
-                        ret = fd_eject(UNIT(drive));
-
-                        USETF(FD_DISK_CHANGED);
-                        USETF(FD_VERIFY);
-                        process_fd_request();
+        memset(&inparam, 0, sizeof(inparam));
+        if (_IOC_DIR(cmd) & _IOC_WRITE) {
+                ret = fd_copyin((void __user *)param, &inparam, size);
+                if (ret)
                         return ret;
-                case FDCLRPRM:
-                        LOCK_FDC(drive, 1);
-                        current_type[drive] = NULL;
-                        floppy_sizes[drive] = MAX_DISK_SIZE << 1;
-                        UDRS->keep_data = 0;
-                        return invalidate_drive(bdev);
-                case FDSETPRM:
-                case FDDEFPRM:
-                        return set_geometry(cmd, &inparam.g,
-                                            drive, type, bdev);
-                case FDGETPRM:
-                        ECALL(get_floppy_geometry(drive, type,
-                                                  (struct floppy_struct **)
-                                                  &outparam));
-                        break;
-
-                case FDMSGON:
-                        UDP->flags |= FTD_MSG;
-                        return 0;
-                case FDMSGOFF:
-                        UDP->flags &= ~FTD_MSG;
-                        return 0;
-
-                case FDFMTBEG:
-                        LOCK_FDC(drive, 1);
-                        CALL(poll_drive(1, FD_RAW_NEED_DISK));
-                        ret = UDRS->flags;
-                        process_fd_request();
-                        if (ret & FD_VERIFY)
-                                return -ENODEV;
-                        if (!(ret & FD_DISK_WRITABLE))
-                                return -EROFS;
-                        return 0;
-                case FDFMTTRK:
-                        if (UDRS->fd_ref != 1)
-                                return -EBUSY;
-                        return do_format(drive, &inparam.f);
-                case FDFMTEND:
-                case FDFLUSH:
-                        LOCK_FDC(drive, 1);
-                        return invalidate_drive(bdev);
-
-                case FDSETEMSGTRESH:
-                        UDP->max_errors.reporting =
-                            (unsigned short)(param & 0x0f);
-                        return 0;
-                        OUT(FDGETMAXERRS, &UDP->max_errors);
-                        IN(FDSETMAXERRS, &UDP->max_errors, max_errors);
-
-                case FDGETDRVTYP:
-                        outparam = drive_name(type, drive);
-                        SUPBOUND(size, strlen(outparam) + 1);
-                        break;
-
-                        IN(FDSETDRVPRM, UDP, dp);
-                        OUT(FDGETDRVPRM, UDP);
-
-                case FDPOLLDRVSTAT:
-                        LOCK_FDC(drive, 1);
-                        CALL(poll_drive(1, FD_RAW_NEED_DISK));
-                        process_fd_request();
-                        /* fall through */
-                        OUT(FDGETDRVSTAT, UDRS);
-
-                case FDRESET:
-                        return user_reset_fdc(drive, (int)param, 1);
-
-                        OUT(FDGETFDCSTAT, UFDCS);
+        }
 
-                case FDWERRORCLR:
-                        CLEARSTRUCT(UDRWE);
-                        return 0;
-                        OUT(FDWERRORGET, UDRWE);
-
-                case FDRAWCMD:
-                        if (type)
-                                return -EINVAL;
-                        LOCK_FDC(drive, 1);
-                        set_floppy(drive);
-                        CALL(i = raw_cmd_ioctl(cmd, (void __user *)param));
-                        process_fd_request();
-                        return i;
+        switch (cmd) {
+        case FDEJECT:
+                if (UDRS->fd_ref != 1)
+                        /* somebody else has this drive open */
+                        return -EBUSY;
+                if (lock_fdc(drive, true))
+                        return -EINTR;
 
-                case FDTWADDLE:
-                        LOCK_FDC(drive, 1);
-                        twaddle();
-                        process_fd_request();
-                        return 0;
+                /* do the actual eject. Fails on
+                 * non-Sparc architectures */
+                ret = fd_eject(UNIT(drive));
 
-                default:
+                set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
+                set_bit(FD_VERIFY_BIT, &UDRS->flags);
+                process_fd_request();
+                return ret;
+        case FDCLRPRM:
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                current_type[drive] = NULL;
+                floppy_sizes[drive] = MAX_DISK_SIZE << 1;
+                UDRS->keep_data = 0;
+                return invalidate_drive(bdev);
+        case FDSETPRM:
+        case FDDEFPRM:
+                return set_geometry(cmd, &inparam.g, drive, type, bdev);
+        case FDGETPRM:
+                ret = get_floppy_geometry(drive, type,
+                                          (struct floppy_struct **)&outparam);
+                if (ret)
+                        return ret;
+                break;
+        case FDMSGON:
+                UDP->flags |= FTD_MSG;
+                return 0;
+        case FDMSGOFF:
+                UDP->flags &= ~FTD_MSG;
+                return 0;
+        case FDFMTBEG:
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
+                        return -EINTR;
+                ret = UDRS->flags;
+                process_fd_request();
+                if (ret & FD_VERIFY)
+                        return -ENODEV;
+                if (!(ret & FD_DISK_WRITABLE))
+                        return -EROFS;
+                return 0;
+        case FDFMTTRK:
+                if (UDRS->fd_ref != 1)
+                        return -EBUSY;
+                return do_format(drive, &inparam.f);
+        case FDFMTEND:
+        case FDFLUSH:
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                return invalidate_drive(bdev);
+        case FDSETEMSGTRESH:
+                UDP->max_errors.reporting = (unsigned short)(param & 0x0f);
+                return 0;
+        case FDGETMAXERRS:
+                outparam = &UDP->max_errors;
+                break;
+        case FDSETMAXERRS:
+                UDP->max_errors = inparam.max_errors;
+                break;
+        case FDGETDRVTYP:
+                outparam = drive_name(type, drive);
+                SUPBOUND(size, strlen((const char *)outparam) + 1);
+                break;
+        case FDSETDRVPRM:
+                *UDP = inparam.dp;
+                break;
+        case FDGETDRVPRM:
+                outparam = UDP;
+                break;
+        case FDPOLLDRVSTAT:
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                if (poll_drive(true, FD_RAW_NEED_DISK) == -EINTR)
+                        return -EINTR;
+                process_fd_request();
+                /* fall through */
+        case FDGETDRVSTAT:
+                outparam = UDRS;
+                break;
+        case FDRESET:
+                return user_reset_fdc(drive, (int)param, true);
+        case FDGETFDCSTAT:
+                outparam = UFDCS;
+                break;
+        case FDWERRORCLR:
+                memset(UDRWE, 0, sizeof(*UDRWE));
+                return 0;
+        case FDWERRORGET:
+                outparam = UDRWE;
+                break;
+        case FDRAWCMD:
+                if (type)
                         return -EINVAL;
-                }
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                set_floppy(drive);
+                i = raw_cmd_ioctl(cmd, (void __user *)param);
+                if (i == -EINTR)
+                        return -EINTR;
+                process_fd_request();
+                return i;
+        case FDTWADDLE:
+                if (lock_fdc(drive, true))
+                        return -EINTR;
+                twaddle();
+                process_fd_request();
+                return 0;
+        default:
+                return -EINVAL;
+        }
 
         if (_IOC_DIR(cmd) & _IOC_READ)
                 return fd_copyout((void __user *)param, outparam, size);
-        else
-                return 0;
-#undef OUT
-#undef IN
+
+        return 0;
 }
 
 static void __init config_types(void)
 {
-        int first = 1;
+        bool has_drive = false;
         int drive;
 
         /* read drive info out of physical CMOS */
@@ -3655,17 +3627,22 @@ static void __init config_types(void)
                         name = temparea;
                 }
                 if (name) {
-                        const char *prepend = ",";
-                        if (first) {
-                                prepend = KERN_INFO "Floppy drive(s):";
-                                first = 0;
+                        const char *prepend;
+                        if (!has_drive) {
+                                prepend = "";
+                                has_drive = true;
+                                pr_info("Floppy drive(s):");
+                        } else {
+                                prepend = ",";
                         }
-                        printk("%s fd%d is %s", prepend, drive, name);
+
+                        pr_cont("%s fd%d is %s", prepend, drive, name);
                 }
                 *UDP = *params;
         }
-        if (!first)
-                printk("\n");
+
+        if (has_drive)
+                pr_cont("\n");
 }
 
 static int floppy_release(struct gendisk *disk, fmode_t mode)
@@ -3705,8 +3682,8 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
                 goto out2;
 
         if (!UDRS->fd_ref && (UDP->flags & FD_BROKEN_DCL)) {
-                USETF(FD_DISK_CHANGED);
-                USETF(FD_VERIFY);
+                set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
+                set_bit(FD_VERIFY_BIT, &UDRS->flags);
         }
 
         if (UDRS->fd_ref == -1 || (UDRS->fd_ref && (mode & FMODE_EXCL)))
@@ -3735,9 +3712,8 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
                         INFBOUND(try, 16);
                         tmp = (char *)fd_dma_mem_alloc(1024 * try);
                 }
-                if (!tmp && !floppy_track_buffer) {
+                if (!tmp && !floppy_track_buffer)
                         fallback_on_nodma_alloc(&tmp, 2048 * try);
-                }
                 if (!tmp && !floppy_track_buffer) {
                         DPRINT("Unable to allocate DMA memory\n");
                         goto out;
@@ -3767,11 +3743,12 @@ static int floppy_open(struct block_device *bdev, fmode_t mode)
                 if (mode & (FMODE_READ|FMODE_WRITE)) {
                         UDRS->last_checked = 0;
                         check_disk_change(bdev);
-                        if (UTESTF(FD_DISK_CHANGED))
+                        if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags))
                                 goto out;
                 }
                 res = -EROFS;
-                if ((mode & FMODE_WRITE) && !(UTESTF(FD_DISK_WRITABLE)))
+                if ((mode & FMODE_WRITE) &&
+                    !test_bit(FD_DISK_WRITABLE_BIT, &UDRS->flags))
                         goto out;
         }
         mutex_unlock(&open_lock);
@@ -3795,17 +3772,18 @@ static int check_floppy_change(struct gendisk *disk)
 {
         int drive = (long)disk->private_data;
 
-        if (UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY))
+        if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
+            test_bit(FD_VERIFY_BIT, &UDRS->flags))
                 return 1;
 
         if (time_after(jiffies, UDRS->last_checked + UDP->checkfreq)) {
-                lock_fdc(drive, 0);
-                poll_drive(0, 0);
+                lock_fdc(drive, false);
+                poll_drive(false, 0);
                 process_fd_request();
         }
 
-        if (UTESTF(FD_DISK_CHANGED) ||
-            UTESTF(FD_VERIFY) ||
+        if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
+            test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
             test_bit(drive, &fake_change) ||
             (!ITYPE(UDRS->fd_device) && !current_type[drive]))
                 return 1;
@@ -3818,8 +3796,7 @@ static int check_floppy_change(struct gendisk *disk)
  * a disk in the drive, and whether that disk is writable.
  */
 
-static void floppy_rb0_complete(struct bio *bio,
-                               int err)
+static void floppy_rb0_complete(struct bio *bio, int err)
 {
         complete((struct completion *)bio->bi_private);
 }
@@ -3877,14 +3854,16 @@ static int floppy_revalidate(struct gendisk *disk)
         int cf;
         int res = 0;
 
-        if (UTESTF(FD_DISK_CHANGED) ||
-            UTESTF(FD_VERIFY) || test_bit(drive, &fake_change) || NO_GEOM) {
+        if (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
+            test_bit(FD_VERIFY_BIT, &UDRS->flags) ||
+            test_bit(drive, &fake_change) || NO_GEOM) {
                 if (usage_count == 0) {
-                        printk("VFS: revalidate called on non-open device.\n");
+                        pr_info("VFS: revalidate called on non-open device.\n");
                         return -EFAULT;
                 }
-                lock_fdc(drive, 0);
-                cf = UTESTF(FD_DISK_CHANGED) || UTESTF(FD_VERIFY);
+                lock_fdc(drive, false);
+                cf = (test_bit(FD_DISK_CHANGED_BIT, &UDRS->flags) ||
+                      test_bit(FD_VERIFY_BIT, &UDRS->flags));
                 if (!(cf || test_bit(drive, &fake_change) || NO_GEOM)) {
                         process_fd_request();   /*already done by another thread */
                         return 0;
@@ -3894,7 +3873,7 @@ static int floppy_revalidate(struct gendisk *disk)
                 if (buffer_drive == drive)
                         buffer_track = -1;
                 clear_bit(drive, &fake_change);
-                UCLEARF(FD_DISK_CHANGED);
+                clear_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
                 if (cf)
                         UDRS->generation++;
                 if (NO_GEOM) {
@@ -3902,7 +3881,7 @@ static int floppy_revalidate(struct gendisk *disk)
                         res = __floppy_read_block_0(opened_bdev[drive]);
                 } else {
                         if (cf)
-                                poll_drive(0, FD_RAW_NEED_DISK);
+                                poll_drive(false, FD_RAW_NEED_DISK);
                         process_fd_request();
                 }
         }
@@ -3934,21 +3913,21 @@ static char __init get_fdc_version(void)
         output_byte(FD_DUMPREGS);       /* 82072 and better know DUMPREGS */
         if (FDCS->reset)
                 return FDC_NONE;
-        if ((r = result()) <= 0x00)
+        r = result();
+        if (r <= 0x00)
                 return FDC_NONE;        /* No FDC present ??? */
         if ((r == 1) && (reply_buffer[0] == 0x80)) {
-                printk(KERN_INFO "FDC %d is an 8272A\n", fdc);
+                pr_info("FDC %d is an 8272A\n", fdc);
                 return FDC_8272A;       /* 8272a/765 don't know DUMPREGS */
         }
         if (r != 10) {
-                printk
-                    ("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
-                     fdc, r);
+                pr_info("FDC %d init: DUMPREGS: unexpected return of %d bytes.\n",
+                        fdc, r);
                 return FDC_UNKNOWN;
         }
 
         if (!fdc_configure()) {
-                printk(KERN_INFO "FDC %d is an 82072\n", fdc);
+                pr_info("FDC %d is an 82072\n", fdc);
                 return FDC_82072;       /* 82072 doesn't know CONFIGURE */
         }
 
@@ -3956,52 +3935,50 @@ static char __init get_fdc_version(void)
         if (need_more_output() == MORE_OUTPUT) {
                 output_byte(0);
         } else {
-                printk(KERN_INFO "FDC %d is an 82072A\n", fdc);
+                pr_info("FDC %d is an 82072A\n", fdc);
                 return FDC_82072A;      /* 82072A as found on Sparcs. */
         }
 
         output_byte(FD_UNLOCK);
         r = result();
         if ((r == 1) && (reply_buffer[0] == 0x80)) {
-                printk(KERN_INFO "FDC %d is a pre-1991 82077\n", fdc);
-                return FDC_82077_ORIG;  /* Pre-1991 82077, doesn't know 
+                pr_info("FDC %d is a pre-1991 82077\n", fdc);
+                return FDC_82077_ORIG;  /* Pre-1991 82077, doesn't know
                                          * LOCK/UNLOCK */
         }
         if ((r != 1) || (reply_buffer[0] != 0x00)) {
-                printk("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
-                       fdc, r);
+                pr_info("FDC %d init: UNLOCK: unexpected return of %d bytes.\n",
+                        fdc, r);
                 return FDC_UNKNOWN;
         }
         output_byte(FD_PARTID);
         r = result();
         if (r != 1) {
-                printk("FDC %d init: PARTID: unexpected return of %d bytes.\n",
-                       fdc, r);
+                pr_info("FDC %d init: PARTID: unexpected return of %d bytes.\n",
+                        fdc, r);
                 return FDC_UNKNOWN;
         }
         if (reply_buffer[0] == 0x80) {
-                printk(KERN_INFO "FDC %d is a post-1991 82077\n", fdc);
+                pr_info("FDC %d is a post-1991 82077\n", fdc);
                 return FDC_82077;       /* Revised 82077AA passes all the tests */
         }
         switch (reply_buffer[0] >> 5) {
         case 0x0:
                 /* Either a 82078-1 or a 82078SL running at 5Volt */
-                printk(KERN_INFO "FDC %d is an 82078.\n", fdc);
+                pr_info("FDC %d is an 82078.\n", fdc);
                 return FDC_82078;
         case 0x1:
-                printk(KERN_INFO "FDC %d is a 44pin 82078\n", fdc);
+                pr_info("FDC %d is a 44pin 82078\n", fdc);
                 return FDC_82078;
         case 0x2:
-                printk(KERN_INFO "FDC %d is a S82078B\n", fdc);
+                pr_info("FDC %d is a S82078B\n", fdc);
                 return FDC_S82078B;
         case 0x3:
-                printk(KERN_INFO "FDC %d is a National Semiconductor PC87306\n",
-                       fdc);
+                pr_info("FDC %d is a National Semiconductor PC87306\n", fdc);
                 return FDC_87306;
         default:
-                printk(KERN_INFO
-                       "FDC %d init: 82078 variant with unknown PARTID=%d.\n",
-                       fdc, reply_buffer[0] >> 5);
+                pr_info("FDC %d init: 82078 variant with unknown PARTID=%d.\n",
+                        fdc, reply_buffer[0] >> 5);
                 return FDC_82078_UNKN;
         }
 }                               /* get_fdc_version */
@@ -4113,9 +4090,9 @@ static int __init floppy_setup(char *str)
                                 else
                                         param = config_params[i].def_param;
                                 if (config_params[i].fn)
-                                        config_params[i].
-                                            fn(ints, param,
-                                               config_params[i].param2);
+                                        config_params[i].fn(ints, param,
+                                                            config_params[i].
+                                                            param2);
                                 if (config_params[i].var) {
                                         DPRINT("%s=%d\n", str, param);
                                         *config_params[i].var = param;
@@ -4129,8 +4106,8 @@ static int __init floppy_setup(char *str)
 
                 DPRINT("allowed options are:");
                 for (i = 0; i < ARRAY_SIZE(config_params); i++)
-                        printk(" %s", config_params[i].name);
-                printk("\n");
+                        pr_cont(" %s", config_params[i].name);
+                pr_cont("\n");
         } else
                 DPRINT("botched floppy option\n");
         DPRINT("Read Documentation/blockdev/floppy.txt\n");
@@ -4148,7 +4125,8 @@ static ssize_t floppy_cmos_show(struct device *dev,
         drive = p->id;
         return sprintf(buf, "%X\n", UDP->cmos);
 }
-DEVICE_ATTR(cmos,S_IRUGO,floppy_cmos_show,NULL);
+
+DEVICE_ATTR(cmos, S_IRUGO, floppy_cmos_show, NULL);
 
 static void floppy_device_release(struct device *dev)
 {
@@ -4160,7 +4138,7 @@ static int floppy_resume(struct device *dev)
 
         for (fdc = 0; fdc < N_FDC; fdc++)
                 if (FDCS->address != -1)
-                        user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
+                        user_reset_fdc(-1, FD_RESET_ALWAYS, false);
 
         return 0;
 }
@@ -4172,8 +4150,8 @@ static const struct dev_pm_ops floppy_pm_ops = {
 
 static struct platform_driver floppy_driver = {
         .driver = {
-                .name = "floppy",
-                .pm = &floppy_pm_ops,
+                   .name = "floppy",
+                   .pm = &floppy_pm_ops,
         },
 };
 
@@ -4245,16 +4223,16 @@ static int __init floppy_init(void)
                 else
                         floppy_sizes[i] = MAX_DISK_SIZE << 1;
 
-        reschedule_timeout(MAXTIMEOUT, "floppy init", MAXTIMEOUT);
+        reschedule_timeout(MAXTIMEOUT, "floppy init");
         config_types();
 
         for (i = 0; i < N_FDC; i++) {
                 fdc = i;
-                CLEARSTRUCT(FDCS);
+                memset(FDCS, 0, sizeof(*FDCS));
                 FDCS->dtr = -1;
                 FDCS->dor = 0x4;
 #if defined(__sparc__) || defined(__mc68000__)
-                /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
+        /*sparcs/sun3x don't have a DOR reset which we can fall back on to */
 #ifdef __mc68000__
                 if (MACH_IS_SUN3X)
 #endif
@@ -4283,11 +4261,11 @@ static int __init floppy_init(void)
 
         /* initialise drive state */
         for (drive = 0; drive < N_DRIVE; drive++) {
-                CLEARSTRUCT(UDRS);
-                CLEARSTRUCT(UDRWE);
-                USETF(FD_DISK_NEWCHANGE);
-                USETF(FD_DISK_CHANGED);
-                USETF(FD_VERIFY);
+                memset(UDRS, 0, sizeof(*UDRS));
+                memset(UDRWE, 0, sizeof(*UDRWE));
+                set_bit(FD_DISK_NEWCHANGE_BIT, &UDRS->flags);
+                set_bit(FD_DISK_CHANGED_BIT, &UDRS->flags);
+                set_bit(FD_VERIFY_BIT, &UDRS->flags);
                 UDRS->fd_device = -1;
                 floppy_track_buffer = NULL;
                 max_buffer_sectors = 0;
@@ -4307,7 +4285,7 @@ static int __init floppy_init(void)
                 if (FDCS->address == -1)
                         continue;
                 FDCS->rawcmd = 2;
-                if (user_reset_fdc(-1, FD_RESET_ALWAYS, 0)) {
+                if (user_reset_fdc(-1, FD_RESET_ALWAYS, false)) {
                         /* free ioports reserved by floppy_grab_irq_and_dma() */
                         floppy_release_regions(fdc);
                         FDCS->address = -1;
@@ -4330,12 +4308,12 @@ static int __init floppy_init(void)
                  * properly, so force a reset for the standard FDC clones,
                  * to avoid interrupt garbage.
                  */
-                user_reset_fdc(-1, FD_RESET_ALWAYS, 0);
+                user_reset_fdc(-1, FD_RESET_ALWAYS, false);
         }
         fdc = 0;
         del_timer(&fd_timeout);
         current_drive = 0;
-        initialising = 0;
+        initialized = true;
         if (have_no_fdc) {
                 DPRINT("no floppy controllers found\n");
                 err = have_no_fdc;
@@ -4356,7 +4334,8 @@ static int __init floppy_init(void)
                 if (err)
                         goto out_flush_work;
 
-                err = device_create_file(&floppy_device[drive].dev,&dev_attr_cmos);
+                err = device_create_file(&floppy_device[drive].dev,
+                                         &dev_attr_cmos);
                 if (err)
                         goto out_unreg_platform_dev;
 
@@ -4420,8 +4399,10 @@ static int floppy_request_regions(int fdc)
         const struct io_region *p;
 
         for (p = io_regions; p < ARRAY_END(io_regions); p++) {
-                if (!request_region(FDCS->address + p->offset, p->size, "floppy")) {
-                        DPRINT("Floppy io-port 0x%04lx in use\n", FDCS->address + p->offset);
+                if (!request_region(FDCS->address + p->offset,
+                                    p->size, "floppy")) {
+                        DPRINT("Floppy io-port 0x%04lx in use\n",
+                               FDCS->address + p->offset);
                         floppy_release_allocated_regions(fdc, p);
                         return -EBUSY;
                 }
@@ -4512,11 +4493,9 @@ cleanup:
 static void floppy_release_irq_and_dma(void)
 {
         int old_fdc;
-#ifdef FLOPPY_SANITY_CHECK
 #ifndef __sparc__
         int drive;
 #endif
-#endif
         long tmpsize;
         unsigned long tmpaddr;
         unsigned long flags;
@@ -4547,20 +4526,18 @@ static void floppy_release_irq_and_dma(void)
                 buffer_min = buffer_max = -1;
                 fd_dma_mem_free(tmpaddr, tmpsize);
         }
-#ifdef FLOPPY_SANITY_CHECK
 #ifndef __sparc__
         for (drive = 0; drive < N_FDC * 4; drive++)
                 if (timer_pending(motor_off_timer + drive))
-                        printk("motor off timer %d still active\n", drive);
+                        pr_info("motor off timer %d still active\n", drive);
 #endif
 
         if (timer_pending(&fd_timeout))
-                printk("floppy timer still active:%s\n", timeout_message);
+                pr_info("floppy timer still active:%s\n", timeout_message);
         if (timer_pending(&fd_timer))
-                printk("auxiliary floppy timer still active\n");
+                pr_info("auxiliary floppy timer still active\n");
         if (work_pending(&floppy_work))
-                printk("work still pending\n");
-#endif
+                pr_info("work still pending\n");
         old_fdc = fdc;
         for (fdc = 0; fdc < N_FDC; fdc++)
                 if (FDCS->address != -1)
@@ -4577,7 +4554,9 @@ static void __init parse_floppy_cfg_string(char *cfg)
         char *ptr;
 
         while (*cfg) {
-                for (ptr = cfg; *cfg && *cfg != ' ' && *cfg != '\t'; cfg++) ;
+                ptr = cfg;
+                while (*cfg && *cfg != ' ' && *cfg != '\t')
+                        cfg++;
                 if (*cfg) {
                         *cfg = '\0';
                         cfg++;
@@ -4625,6 +4604,7 @@ static void __exit floppy_module_exit(void)
         /* eject disk, if any */
         fd_eject(0);
 }
+
 module_exit(floppy_module_exit);
 
 module_param(floppy, charp, 0);
@@ -4636,9 +4616,10 @@ MODULE_LICENSE("GPL");
 
 /* This doesn't actually get used other than for module information */
 static const struct pnp_device_id floppy_pnpids[] = {
-        { "PNP0700", 0 },
-        { }
+        {"PNP0700", 0},
+        {}
 };
+
 MODULE_DEVICE_TABLE(pnp, floppy_pnpids);
 
 #else
diff --git a/drivers/block/osdblk.c b/drivers/block/osdblk.c
index a808b1530b3b..eb2091aa1c19 100644
--- a/drivers/block/osdblk.c
+++ b/drivers/block/osdblk.c
@@ -476,7 +476,9 @@ static void class_osdblk_release(struct class *cls)
         kfree(cls);
 }
 
-static ssize_t class_osdblk_list(struct class *c, char *data)
+static ssize_t class_osdblk_list(struct class *c,
+                                struct class_attribute *attr,
+                                char *data)
 {
         int n = 0;
         struct list_head *tmp;
@@ -500,7 +502,9 @@ static ssize_t class_osdblk_list(struct class *c, char *data)
         return n;
 }
 
-static ssize_t class_osdblk_add(struct class *c, const char *buf, size_t count)
+static ssize_t class_osdblk_add(struct class *c,
+                                struct class_attribute *attr,
+                                const char *buf, size_t count)
 {
         struct osdblk_device *osdev;
         ssize_t rc;
@@ -592,7 +596,9 @@ err_out_mod:
         return rc;
 }
 
-static ssize_t class_osdblk_remove(struct class *c, const char *buf,
+static ssize_t class_osdblk_remove(struct class *c,
+                                        struct class_attribute *attr,
+                                        const char *buf,
                                         size_t count)
 {
         struct osdblk_device *osdev = NULL;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index b72935b8f203..39c8514442eb 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -284,7 +284,7 @@ static ssize_t kobj_pkt_store(struct kobject *kobj,
         return len;
 }
 
-static struct sysfs_ops kobj_pkt_ops = {
+static const struct sysfs_ops kobj_pkt_ops = {
         .show = kobj_pkt_show,
         .store = kobj_pkt_store
 };
@@ -337,7 +337,9 @@ static void class_pktcdvd_release(struct class *cls)
 {
         kfree(cls);
 }
-static ssize_t class_pktcdvd_show_map(struct class *c, char *data)
+static ssize_t class_pktcdvd_show_map(struct class *c,
+                                        struct class_attribute *attr,
+                                        char *data)
 {
         int n = 0;
         int idx;
@@ -356,7 +358,9 @@ static ssize_t class_pktcdvd_show_map(struct class *c, char *data)
         return n;
 }
 
-static ssize_t class_pktcdvd_store_add(struct class *c, const char *buf,
+static ssize_t class_pktcdvd_store_add(struct class *c,
+                                        struct class_attribute *attr,
+                                        const char *buf,
                                         size_t count)
 {
         unsigned int major, minor;
@@ -376,7 +380,9 @@ static ssize_t class_pktcdvd_store_add(struct class *c, const char *buf,
         return -EINVAL;
 }
 
-static ssize_t class_pktcdvd_store_remove(struct class *c, const char *buf,
+static ssize_t class_pktcdvd_store_remove(struct class *c,
+                                          struct class_attribute *attr,
+                                          const char *buf,
                                         size_t count)
 {
         unsigned int major, minor;
diff --git a/drivers/char/hvc_iucv.c b/drivers/char/hvc_iucv.c
index 21681a81cc35..37b0542a4eeb 100644
--- a/drivers/char/hvc_iucv.c
+++ b/drivers/char/hvc_iucv.c
@@ -139,6 +139,8 @@ struct hvc_iucv_private *hvc_iucv_get_private(uint32_t num)
  *
  * This function allocates a new struct iucv_tty_buffer element and, optionally,
  * allocates an internal data buffer with the specified size @size.
+ * The internal data buffer is always allocated with GFP_DMA which is
+ * required for receiving and sending data with IUCV.
  * Note: The total message size arises from the internal buffer size and the
  *       members of the iucv_tty_msg structure.
  * The function returns NULL if memory allocation has failed.
@@ -154,7 +156,7 @@ static struct iucv_tty_buffer *alloc_tty_buffer(size_t size, gfp_t flags)
 
         if (size > 0) {
                 bufp->msg.length = MSG_SIZE(size);
-                bufp->mbuf = kmalloc(bufp->msg.length, flags);
+                bufp->mbuf = kmalloc(bufp->msg.length, flags | GFP_DMA);
                 if (!bufp->mbuf) {
                         mempool_free(bufp, hvc_iucv_mempool);
                         return NULL;
@@ -237,7 +239,7 @@ static int hvc_iucv_write(struct hvc_iucv_private *priv,
         if (!rb->mbuf) { /* message not yet received ... */
                 /* allocate mem to store msg data; if no memory is available
                  * then leave the buffer on the list and re-try later */
-                rb->mbuf = kmalloc(rb->msg.length, GFP_ATOMIC);
+                rb->mbuf = kmalloc(rb->msg.length, GFP_ATOMIC | GFP_DMA);
                 if (!rb->mbuf)
                         return -ENOMEM;
 
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 176f1751237f..4462b113ba3f 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -295,6 +295,9 @@ struct smi_info {
 static int force_kipmid[SI_MAX_PARMS];
 static int num_force_kipmid;
 
+static unsigned int kipmid_max_busy_us[SI_MAX_PARMS];
+static int num_max_busy_us;
+
 static int unload_when_empty = 1;
 
 static int try_smi_init(struct smi_info *smi);
@@ -925,23 +928,77 @@ static void set_run_to_completion(void *send_info, int i_run_to_completion)
         }
 }
 
+/*
+ * Use -1 in the nsec value of the busy waiting timespec to tell that
+ * we are spinning in kipmid looking for something and not delaying
+ * between checks
+ */
+static inline void ipmi_si_set_not_busy(struct timespec *ts)
+{
+        ts->tv_nsec = -1;
+}
+static inline int ipmi_si_is_busy(struct timespec *ts)
+{
+        return ts->tv_nsec != -1;
+}
+
+static int ipmi_thread_busy_wait(enum si_sm_result smi_result,
+                                 const struct smi_info *smi_info,
+                                 struct timespec *busy_until)
+{
+        unsigned int max_busy_us = 0;
+
+        if (smi_info->intf_num < num_max_busy_us)
+                max_busy_us = kipmid_max_busy_us[smi_info->intf_num];
+        if (max_busy_us == 0 || smi_result != SI_SM_CALL_WITH_DELAY)
+                ipmi_si_set_not_busy(busy_until);
+        else if (!ipmi_si_is_busy(busy_until)) {
+                getnstimeofday(busy_until);
+                timespec_add_ns(busy_until, max_busy_us*NSEC_PER_USEC);
+        } else {
+                struct timespec now;
+                getnstimeofday(&now);
+                if (unlikely(timespec_compare(&now, busy_until) > 0)) {
+                        ipmi_si_set_not_busy(busy_until);
+                        return 0;
+                }
+        }
+        return 1;
+}
+
+
+/*
+ * A busy-waiting loop for speeding up IPMI operation.
+ *
+ * Lousy hardware makes this hard.  This is only enabled for systems
+ * that are not BT and do not have interrupts.  It starts spinning
+ * when an operation is complete or until max_busy tells it to stop
+ * (if that is enabled).  See the paragraph on kimid_max_busy_us in
+ * Documentation/IPMI.txt for details.
+ */
 static int ipmi_thread(void *data)
 {
         struct smi_info *smi_info = data;
         unsigned long flags;
         enum si_sm_result smi_result;
+        struct timespec busy_until;
 
+        ipmi_si_set_not_busy(&busy_until);
         set_user_nice(current, 19);
         while (!kthread_should_stop()) {
+                int busy_wait;
+
                 spin_lock_irqsave(&(smi_info->si_lock), flags);
                 smi_result = smi_event_handler(smi_info, 0);
                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
+                busy_wait = ipmi_thread_busy_wait(smi_result, smi_info,
+                                                  &busy_until);
                 if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
                         ; /* do nothing */
-                else if (smi_result == SI_SM_CALL_WITH_DELAY)
+                else if (smi_result == SI_SM_CALL_WITH_DELAY && busy_wait)
                         schedule();
                 else
-                        schedule_timeout_interruptible(1);
+                        schedule_timeout_interruptible(0);
         }
         return 0;
 }
@@ -1144,7 +1201,7 @@ static int           regsizes[SI_MAX_PARMS];
 static unsigned int num_regsizes;
 static int           regshifts[SI_MAX_PARMS];
 static unsigned int num_regshifts;
-static int slave_addrs[SI_MAX_PARMS];
+static int slave_addrs[SI_MAX_PARMS]; /* Leaving 0 chooses the default value */
 static unsigned int num_slave_addrs;
 
 #define IPMI_IO_ADDR_SPACE  0
@@ -1212,6 +1269,11 @@ module_param(unload_when_empty, int, 0);
 MODULE_PARM_DESC(unload_when_empty, "Unload the module if no interfaces are"
                  " specified or found, default is 1.  Setting to 0"
                  " is useful for hot add of devices using hotmod.");
+module_param_array(kipmid_max_busy_us, uint, &num_max_busy_us, 0644);
+MODULE_PARM_DESC(kipmid_max_busy_us,
+                 "Max time (in microseconds) to busy-wait for IPMI data before"
+                 " sleeping. 0 (default) means to wait forever. Set to 100-500"
+                 " if kipmid is using up a lot of CPU time.");
 
 
 static void std_irq_cleanup(struct smi_info *info)
@@ -1607,7 +1669,7 @@ static int hotmod_handler(const char *val, struct kernel_param *kp)
                 regsize = 1;
                 regshift = 0;
                 irq = 0;
-                ipmb = 0x20;
+                ipmb = 0; /* Choose the default if not specified */
 
                 next = strchr(curr, ':');
                 if (next) {
@@ -1799,6 +1861,7 @@ static __devinit void hardcode_find_bmc(void)
                 info->irq = irqs[i];
                 if (info->irq)
                         info->irq_setup = std_irq_setup;
+                info->slave_addr = slave_addrs[i];
 
                 try_smi_init(info);
         }
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 48788db4e280..1f3215ac085b 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
- *  Added devfs support. 
+ *  Added devfs support.
  *    Jan-11-1998, C. Scott Ananian <cananian@alumni.princeton.edu>
  *  Shared /dev/zero mmapping support, Feb 2000, Kanoj Sarcar <kanoj@sgi.com>
  */
@@ -44,36 +44,6 @@ static inline unsigned long size_inside_page(unsigned long start,
         return min(sz, size);
 }
 
-/*
- * Architectures vary in how they handle caching for addresses
- * outside of main memory.
- *
- */
-static inline int uncached_access(struct file *file, unsigned long addr)
-{
-#if defined(CONFIG_IA64)
-        /*
-         * On ia64, we ignore O_DSYNC because we cannot tolerate memory attribute aliases.
-         */
-        return !(efi_mem_attributes(addr) & EFI_MEMORY_WB);
-#elif defined(CONFIG_MIPS)
-        {
-                extern int __uncached_access(struct file *file,
-                                             unsigned long addr);
-
-                return __uncached_access(file, addr);
-        }
-#else
-        /*
-         * Accessing memory above the top the kernel knows about or through a file pointer
-         * that was marked O_DSYNC will be done non-cached.
-         */
-        if (file->f_flags & O_DSYNC)
-                return 1;
-        return addr >= __pa(high_memory);
-#endif
-}
-
 #ifndef ARCH_HAS_VALID_PHYS_ADDR_RANGE
 static inline int valid_phys_addr_range(unsigned long addr, size_t count)
 {
@@ -115,15 +85,15 @@ static inline int range_is_allowed(unsigned long pfn, unsigned long size)
 }
 #endif
 
-void __attribute__((weak)) unxlate_dev_mem_ptr(unsigned long phys, void *addr)
+void __weak unxlate_dev_mem_ptr(unsigned long phys, void *addr)
 {
 }
 
 /*
- * This funcion reads the *physical* memory. The f_pos points directly to the 
- * memory location. 
+ * This funcion reads the *physical* memory. The f_pos points directly to the
+ * memory location.
  */
-static ssize_t read_mem(struct file * file, char __user * buf,
+static ssize_t read_mem(struct file *file, char __user *buf,
                         size_t count, loff_t *ppos)
 {
         unsigned long p = *ppos;
@@ -140,10 +110,10 @@ static ssize_t read_mem(struct file * file, char __user * buf,
                 if (sz > 0) {
                         if (clear_user(buf, sz))
                                 return -EFAULT;
-                        buf += sz; 
-                        p += sz; 
-                        count -= sz; 
-                        read += sz; 
+                        buf += sz;
+                        p += sz;
+                        count -= sz;
+                        read += sz;
                 }
         }
 #endif
@@ -157,9 +127,9 @@ static ssize_t read_mem(struct file * file, char __user * buf,
                         return -EPERM;
 
                 /*
-                 * On ia64 if a page has been mapped somewhere as
-                 * uncached, then it must also be accessed uncached
-                 * by the kernel or data corruption may occur
+                 * On ia64 if a page has been mapped somewhere as uncached, then
+                 * it must also be accessed uncached by the kernel or data
+                 * corruption may occur.
                  */
                 ptr = xlate_dev_mem_ptr(p);
                 if (!ptr)
@@ -180,7 +150,7 @@ static ssize_t read_mem(struct file * file, char __user * buf,
         return read;
 }
 
-static ssize_t write_mem(struct file * file, const char __user * buf, 
+static ssize_t write_mem(struct file *file, const char __user *buf,
                          size_t count, loff_t *ppos)
 {
         unsigned long p = *ppos;
@@ -212,9 +182,9 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
                         return -EPERM;
 
                 /*
-                 * On ia64 if a page has been mapped somewhere as
-                 * uncached, then it must also be accessed uncached
-                 * by the kernel or data corruption may occur
+                 * On ia64 if a page has been mapped somewhere as uncached, then
+                 * it must also be accessed uncached by the kernel or data
+                 * corruption may occur.
                  */
                 ptr = xlate_dev_mem_ptr(p);
                 if (!ptr) {
@@ -242,13 +212,46 @@ static ssize_t write_mem(struct file * file, const char __user * buf,
         return written;
 }
 
-int __attribute__((weak)) phys_mem_access_prot_allowed(struct file *file,
+int __weak phys_mem_access_prot_allowed(struct file *file,
         unsigned long pfn, unsigned long size, pgprot_t *vma_prot)
 {
         return 1;
 }
 
 #ifndef __HAVE_PHYS_MEM_ACCESS_PROT
+
+/*
+ * Architectures vary in how they handle caching for addresses
+ * outside of main memory.
+ *
+ */
+static int uncached_access(struct file *file, unsigned long addr)
+{
+#if defined(CONFIG_IA64)
+        /*
+         * On ia64, we ignore O_DSYNC because we cannot tolerate memory
+         * attribute aliases.
+         */
+        return !(efi_mem_attributes(addr) & EFI_MEMORY_WB);
+#elif defined(CONFIG_MIPS)
+        {
+                extern int __uncached_access(struct file *file,
+                                             unsigned long addr);
+
+                return __uncached_access(file, addr);
+        }
+#else
+        /*
+         * Accessing memory above the top the kernel knows about or through a
+         * file pointer
+         * that was marked O_DSYNC will be done non-cached.
+         */
+        if (file->f_flags & O_DSYNC)
+                return 1;
+        return addr >= __pa(high_memory);
+#endif
+}
+
 static pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
                                      unsigned long size, pgprot_t vma_prot)
 {
@@ -294,7 +297,7 @@ static const struct vm_operations_struct mmap_mem_ops = {
 #endif
 };
 
-static int mmap_mem(struct file * file, struct vm_area_struct * vma)
+static int mmap_mem(struct file *file, struct vm_area_struct *vma)
 {
         size_t size = vma->vm_end - vma->vm_start;
 
@@ -329,7 +332,7 @@ static int mmap_mem(struct file * file, struct vm_area_struct * vma)
 }
 
 #ifdef CONFIG_DEVKMEM
-static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
+static int mmap_kmem(struct file *file, struct vm_area_struct *vma)
 {
         unsigned long pfn;
 
@@ -337,9 +340,9 @@ static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
         pfn = __pa((u64)vma->vm_pgoff << PAGE_SHIFT) >> PAGE_SHIFT;
 
         /*
-         * RED-PEN: on some architectures there is more mapped memory
-         * than available in mem_map which pfn_valid checks
-         * for. Perhaps should add a new macro here.
+         * RED-PEN: on some architectures there is more mapped memory than
+         * available in mem_map which pfn_valid checks for. Perhaps should add a
+         * new macro here.
          *
          * RED-PEN: vmalloc is not supported right now.
          */
@@ -389,7 +392,7 @@ static ssize_t read_oldmem(struct file *file, char __user *buf,
 /*
  * This function reads the *virtual* memory as seen by the kernel.
  */
-static ssize_t read_kmem(struct file *file, char __user *buf, 
+static ssize_t read_kmem(struct file *file, char __user *buf,
                          size_t count, loff_t *ppos)
 {
         unsigned long p = *ppos;
@@ -400,8 +403,8 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
         read = 0;
         if (p < (unsigned long) high_memory) {
                 low_count = count;
-                if (count > (unsigned long) high_memory - p)
-                        low_count = (unsigned long) high_memory - p;
+                if (count > (unsigned long)high_memory - p)
+                        low_count = (unsigned long)high_memory - p;
 
 #ifdef __ARCH_HAS_NO_PAGE_ZERO_MAPPED
                 /* we don't have page 0 mapped on sparc and m68k.. */
@@ -465,9 +468,8 @@ static ssize_t read_kmem(struct file *file, char __user *buf,
 }
 
 
-static inline ssize_t
-do_write_kmem(unsigned long p, const char __user *buf,
-              size_t count, loff_t *ppos)
+static ssize_t do_write_kmem(unsigned long p, const char __user *buf,
+                                size_t count, loff_t *ppos)
 {
         ssize_t written, sz;
         unsigned long copied;
@@ -491,9 +493,9 @@ do_write_kmem(unsigned long p, const char __user *buf,
                 sz = size_inside_page(p, count);
 
                 /*
-                 * On ia64 if a page has been mapped somewhere as
-                 * uncached, then it must also be accessed uncached
-                 * by the kernel or data corruption may occur
+                 * On ia64 if a page has been mapped somewhere as uncached, then
+                 * it must also be accessed uncached by the kernel or data
+                 * corruption may occur.
                  */
                 ptr = xlate_dev_kmem_ptr((char *)p);
 
@@ -514,11 +516,10 @@ do_write_kmem(unsigned long p, const char __user *buf,
         return written;
 }
 
-
 /*
  * This function writes to the *virtual* memory as seen by the kernel.
  */
-static ssize_t write_kmem(struct file * file, const char __user * buf, 
+static ssize_t write_kmem(struct file *file, const char __user *buf,
                           size_t count, loff_t *ppos)
 {
         unsigned long p = *ppos;
@@ -570,17 +571,17 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
 #endif
 
 #ifdef CONFIG_DEVPORT
-static ssize_t read_port(struct file * file, char __user * buf,
+static ssize_t read_port(struct file *file, char __user *buf,
                          size_t count, loff_t *ppos)
 {
         unsigned long i = *ppos;
         char __user *tmp = buf;
 
         if (!access_ok(VERIFY_WRITE, buf, count))
-                return -EFAULT; 
+                return -EFAULT;
         while (count-- > 0 && i < 65536) {
-                if (__put_user(inb(i),tmp) < 0) 
-                        return -EFAULT;  
+                if (__put_user(inb(i), tmp) < 0)
+                        return -EFAULT;
                 i++;
                 tmp++;
         }
@@ -588,22 +589,22 @@ static ssize_t read_port(struct file * file, char __user * buf,
         return tmp-buf;
 }
 
-static ssize_t write_port(struct file * file, const char __user * buf,
+static ssize_t write_port(struct file *file, const char __user *buf,
                           size_t count, loff_t *ppos)
 {
         unsigned long i = *ppos;
         const char __user * tmp = buf;
 
-        if (!access_ok(VERIFY_READ,buf,count))
+        if (!access_ok(VERIFY_READ, buf, count))
                 return -EFAULT;
         while (count-- > 0 && i < 65536) {
                 char c;
                 if (__get_user(c, tmp)) {
                         if (tmp > buf)
                                 break;
-                        return -EFAULT; 
+                        return -EFAULT;
                 }
-                outb(c,i);
+                outb(c, i);
                 i++;
                 tmp++;
         }
@@ -612,13 +613,13 @@ static ssize_t write_port(struct file * file, const char __user * buf,
 }
 #endif
 
-static ssize_t read_null(struct file * file, char __user * buf,
+static ssize_t read_null(struct file *file, char __user *buf,
                          size_t count, loff_t *ppos)
 {
         return 0;
 }
 
-static ssize_t write_null(struct file * file, const char __user * buf,
+static ssize_t write_null(struct file *file, const char __user *buf,
                           size_t count, loff_t *ppos)
 {
         return count;
@@ -630,13 +631,13 @@ static int pipe_to_null(struct pipe_inode_info *info, struct pipe_buffer *buf,
         return sd->len;
 }
 
-static ssize_t splice_write_null(struct pipe_inode_info *pipe,struct file *out,
+static ssize_t splice_write_null(struct pipe_inode_info *pipe, struct file *out,
                                  loff_t *ppos, size_t len, unsigned int flags)
 {
         return splice_from_pipe(pipe, out, ppos, len, flags, pipe_to_null);
 }
 
-static ssize_t read_zero(struct file * file, char __user * buf, 
+static ssize_t read_zero(struct file *file, char __user *buf,
                          size_t count, loff_t *ppos)
 {
         size_t written;
@@ -667,7 +668,7 @@ static ssize_t read_zero(struct file * file, char __user * buf,
         return written ? written : -EFAULT;
 }
 
-static int mmap_zero(struct file * file, struct vm_area_struct * vma)
+static int mmap_zero(struct file *file, struct vm_area_struct *vma)
 {
 #ifndef CONFIG_MMU
         return -ENOSYS;
@@ -677,7 +678,7 @@ static int mmap_zero(struct file * file, struct vm_area_struct * vma)
         return 0;
 }
 
-static ssize_t write_full(struct file * file, const char __user * buf,
+static ssize_t write_full(struct file *file, const char __user *buf,
                           size_t count, loff_t *ppos)
 {
         return -ENOSPC;
@@ -688,8 +689,7 @@ static ssize_t write_full(struct file * file, const char __user * buf,
  * can fopen() both devices with "a" now.  This was previously impossible.
  * -- SRB.
  */
-
-static loff_t null_lseek(struct file * file, loff_t offset, int orig)
+static loff_t null_lseek(struct file *file, loff_t offset, int orig)
 {
         return file->f_pos = 0;
 }
@@ -702,24 +702,31 @@ static loff_t null_lseek(struct file * file, loff_t offset, int orig)
  * also note that seeking relative to the "end of file" isn't supported:
  * it has no meaning, so it returns -EINVAL.
  */
-static loff_t memory_lseek(struct file * file, loff_t offset, int orig)
+static loff_t memory_lseek(struct file *file, loff_t offset, int orig)
 {
         loff_t ret;
 
         mutex_lock(&file->f_path.dentry->d_inode->i_mutex);
         switch (orig) {
-                case 0:
-                        file->f_pos = offset;
-                        ret = file->f_pos;
-                        force_successful_syscall_return();
+        case SEEK_CUR:
+                offset += file->f_pos;
+                if ((unsigned long long)offset <
+                    (unsigned long long)file->f_pos) {
+                        ret = -EOVERFLOW;
                         break;
-                case 1:
-                        file->f_pos += offset;
-                        ret = file->f_pos;
-                        force_successful_syscall_return();
+                }
+        case SEEK_SET:
+                /* to avoid userland mistaking f_pos=-9 as -EBADF=-9 */
+                if ((unsigned long long)offset >= ~0xFFFULL) {
+                        ret = -EOVERFLOW;
                         break;
-                default:
-                        ret = -EINVAL;
+                }
+                file->f_pos = offset;
+                ret = file->f_pos;
+                force_successful_syscall_return();
+                break;
+        default:
+                ret = -EINVAL;
         }
         mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
         return ret;
@@ -803,7 +810,7 @@ static const struct file_operations oldmem_fops = {
 };
 #endif
 
-static ssize_t kmsg_write(struct file * file, const char __user * buf,
+static ssize_t kmsg_write(struct file *file, const char __user *buf,
                           size_t count, loff_t *ppos)
 {
         char *tmp;
@@ -825,7 +832,7 @@ static ssize_t kmsg_write(struct file * file, const char __user * buf,
 }
 
 static const struct file_operations kmsg_fops = {
-        .write =        kmsg_write,
+        .write = kmsg_write,
 };
 
 static const struct memdev {
@@ -876,7 +883,7 @@ static int memory_open(struct inode *inode, struct file *filp)
 }
 
 static const struct file_operations memory_fops = {
-        .open           = memory_open,
+        .open = memory_open,
 };
 
 static char *mem_devnode(struct device *dev, mode_t *mode)
@@ -897,7 +904,7 @@ static int __init chr_dev_init(void)
         if (err)
                 return err;
 
-        if (register_chrdev(MEM_MAJOR,"mem",&memory_fops))
+        if (register_chrdev(MEM_MAJOR, "mem", &memory_fops))
                 printk("unable to get major %d for memory devs\n", MEM_MAJOR);
 
         mem_class = class_create(THIS_MODULE, "mem");
diff --git a/drivers/char/mmtimer.c b/drivers/char/mmtimer.c
index 918711aa56f3..04fd0d843b3b 100644
--- a/drivers/char/mmtimer.c
+++ b/drivers/char/mmtimer.c
@@ -546,7 +546,7 @@ static void mmtimer_tasklet(unsigned long data)
 {
         int nodeid = data;
         struct mmtimer_node *mn = &timers[nodeid];
-        struct mmtimer *x = rb_entry(mn->next, struct mmtimer, list);
+        struct mmtimer *x;
         struct k_itimer *t;
         unsigned long flags;
 
diff --git a/drivers/char/n_tty.c b/drivers/char/n_tty.c
index 2e50f4dfc79c..bdae8327143c 100644
--- a/drivers/char/n_tty.c
+++ b/drivers/char/n_tty.c
@@ -48,6 +48,7 @@
 #include <linux/audit.h>
 #include <linux/file.h>
 #include <linux/uaccess.h>
+#include <linux/module.h>
 
 #include <asm/system.h>
 
@@ -2091,3 +2092,19 @@ struct tty_ldisc_ops tty_ldisc_N_TTY = {
         .receive_buf     = n_tty_receive_buf,
         .write_wakeup    = n_tty_write_wakeup
 };
+
+/**
+ *      n_tty_inherit_ops       -       inherit N_TTY methods
+ *      @ops: struct tty_ldisc_ops where to save N_TTY methods
+ *
+ *      Used by a generic struct tty_ldisc_ops to easily inherit N_TTY
+ *      methods.
+ */
+
+void n_tty_inherit_ops(struct tty_ldisc_ops *ops)
+{
+        *ops = tty_ldisc_N_TTY;
+        ops->owner = NULL;
+        ops->refcount = ops->flags = 0;
+}
+EXPORT_SYMBOL_GPL(n_tty_inherit_ops);
diff --git a/drivers/char/tty_audit.c b/drivers/char/tty_audit.c
index ac16fbec72d0..283a15bc84e3 100644
--- a/drivers/char/tty_audit.c
+++ b/drivers/char/tty_audit.c
@@ -148,7 +148,6 @@ void tty_audit_fork(struct signal_struct *sig)
         spin_lock_irq(&current->sighand->siglock);
         sig->audit_tty = current->signal->audit_tty;
         spin_unlock_irq(&current->sighand->siglock);
-        sig->tty_audit_buf = NULL;
 }
 
 /**
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 67bc2ece7b4b..2d5d575e889d 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -766,7 +766,7 @@ static void cpufreq_sysfs_release(struct kobject *kobj)
         complete(&policy->kobj_unregister);
 }
 
-static struct sysfs_ops sysfs_ops = {
+static const struct sysfs_ops sysfs_ops = {
         .show   = show,
         .store  = store,
 };
diff --git a/drivers/cpuidle/sysfs.c b/drivers/cpuidle/sysfs.c
index 97b003839fb6..8719b36e1a4d 100644
--- a/drivers/cpuidle/sysfs.c
+++ b/drivers/cpuidle/sysfs.c
@@ -22,6 +22,7 @@ static int __init cpuidle_sysfs_setup(char *unused)
 __setup("cpuidle_sysfs_switch", cpuidle_sysfs_setup);
 
 static ssize_t show_available_governors(struct sysdev_class *class,
+                                        struct sysdev_class_attribute *attr,
                                         char *buf)
 {
         ssize_t i = 0;
@@ -41,6 +42,7 @@ out:
 }
 
 static ssize_t show_current_driver(struct sysdev_class *class,
+                                   struct sysdev_class_attribute *attr,
                                    char *buf)
 {
         ssize_t ret;
@@ -56,6 +58,7 @@ static ssize_t show_current_driver(struct sysdev_class *class,
 }
 
 static ssize_t show_current_governor(struct sysdev_class *class,
+                                     struct sysdev_class_attribute *attr,
                                      char *buf)
 {
         ssize_t ret;
@@ -71,6 +74,7 @@ static ssize_t show_current_governor(struct sysdev_class *class,
 }
 
 static ssize_t store_current_governor(struct sysdev_class *class,
+                                      struct sysdev_class_attribute *attr,
                                       const char *buf, size_t count)
 {
         char gov_name[CPUIDLE_NAME_LEN];
@@ -191,7 +195,7 @@ static ssize_t cpuidle_store(struct kobject * kobj, struct attribute * attr,
         return ret;
 }
 
-static struct sysfs_ops cpuidle_sysfs_ops = {
+static const struct sysfs_ops cpuidle_sysfs_ops = {
         .show = cpuidle_show,
         .store = cpuidle_store,
 };
@@ -277,7 +281,7 @@ static ssize_t cpuidle_state_show(struct kobject * kobj,
         return ret;
 }
 
-static struct sysfs_ops cpuidle_state_sysfs_ops = {
+static const struct sysfs_ops cpuidle_state_sysfs_ops = {
         .show = cpuidle_state_show,
 };
 
diff --git a/drivers/dma/ioat/dma.c b/drivers/dma/ioat/dma.c
index af14c9a5b8d4..0099340b9616 100644
--- a/drivers/dma/ioat/dma.c
+++ b/drivers/dma/ioat/dma.c
@@ -1138,7 +1138,7 @@ ioat_attr_show(struct kobject *kobj, struct attribute *attr, char *page)
         return entry->show(&chan->common, page);
 }
 
-struct sysfs_ops ioat_sysfs_ops = {
+const struct sysfs_ops ioat_sysfs_ops = {
         .show   = ioat_attr_show,
 };
 
diff --git a/drivers/dma/ioat/dma.h b/drivers/dma/ioat/dma.h
index 4f747a254074..86b97ac8774e 100644
--- a/drivers/dma/ioat/dma.h
+++ b/drivers/dma/ioat/dma.h
@@ -346,7 +346,7 @@ bool ioat_cleanup_preamble(struct ioat_chan_common *chan,
                            unsigned long *phys_complete);
 void ioat_kobject_add(struct ioatdma_device *device, struct kobj_type *type);
 void ioat_kobject_del(struct ioatdma_device *device);
-extern struct sysfs_ops ioat_sysfs_ops;
+extern const struct sysfs_ops ioat_sysfs_ops;
 extern struct ioat_sysfs_entry ioat_version_attr;
 extern struct ioat_sysfs_entry ioat_cap_attr;
 #endif /* IOATDMA_H */
diff --git a/drivers/edac/e752x_edac.c b/drivers/edac/e752x_edac.c
index d205d493a68a..243e9aacad69 100644
--- a/drivers/edac/e752x_edac.c
+++ b/drivers/edac/e752x_edac.c
@@ -75,6 +75,14 @@ static struct edac_pci_ctl_info *e752x_pci;
 #define E752X_NR_CSROWS         8       /* number of csrows */
 
 /* E752X register addresses - device 0 function 0 */
+#define E752X_MCHSCRB           0x52    /* Memory Scrub register (16b) */
+                                        /*
+                                         * 6:5     Scrub Completion Count
+                                         * 3:2     Scrub Rate (i3100 only)
+                                         *      01=fast 10=normal
+                                         * 1:0     Scrub Mode enable
+                                         *      00=off 10=on
+                                         */
 #define E752X_DRB               0x60    /* DRAM row boundary register (8b) */
 #define E752X_DRA               0x70    /* DRAM row attribute register (8b) */
                                         /*
@@ -240,6 +248,41 @@ static const struct e752x_dev_info e752x_devs[] = {
                 .ctl_name = "3100"},
 };
 
+/* Valid scrub rates for the e752x/3100 hardware memory scrubber. We
+ * map the scrubbing bandwidth to a hardware register value. The 'set'
+ * operation finds the 'matching or higher value'.  Note that scrubbing
+ * on the e752x can only be enabled/disabled.  The 3100 supports
+ * a normal and fast mode.
+ */
+
+#define SDRATE_EOT 0xFFFFFFFF
+
+struct scrubrate {
+        u32 bandwidth;  /* bandwidth consumed by scrubbing in bytes/sec */
+        u16 scrubval;   /* register value for scrub rate */
+};
+
+/* Rate below assumes same performance as i3100 using PC3200 DDR2 in
+ * normal mode.  e752x bridges don't support choosing normal or fast mode,
+ * so the scrubbing bandwidth value isn't all that important - scrubbing is
+ * either on or off.
+ */
+static const struct scrubrate scrubrates_e752x[] = {
+        {0,             0x00},  /* Scrubbing Off */
+        {500000,        0x02},  /* Scrubbing On */
+        {SDRATE_EOT,    0x00}   /* End of Table */
+};
+
+/* Fast mode: 2 GByte PC3200 DDR2 scrubbed in 33s = 63161283 bytes/s
+ * Normal mode: 125 (32000 / 256) times slower than fast mode.
+ */
+static const struct scrubrate scrubrates_i3100[] = {
+        {0,             0x00},  /* Scrubbing Off */
+        {500000,        0x0a},  /* Normal mode - 32k clocks */
+        {62500000,      0x06},  /* Fast mode - 256 clocks */
+        {SDRATE_EOT,    0x00}   /* End of Table */
+};
+
 static unsigned long ctl_page_to_phys(struct mem_ctl_info *mci,
                                 unsigned long page)
 {
@@ -915,6 +958,68 @@ static void e752x_check(struct mem_ctl_info *mci)
         e752x_process_error_info(mci, &info, 1);
 }
 
+/* Program byte/sec bandwidth scrub rate to hardware */
+static int set_sdram_scrub_rate(struct mem_ctl_info *mci, u32 *new_bw)
+{
+        const struct scrubrate *scrubrates;
+        struct e752x_pvt *pvt = (struct e752x_pvt *) mci->pvt_info;
+        struct pci_dev *pdev = pvt->dev_d0f0;
+        int i;
+
+        if (pvt->dev_info->ctl_dev == PCI_DEVICE_ID_INTEL_3100_0)
+                scrubrates = scrubrates_i3100;
+        else
+                scrubrates = scrubrates_e752x;
+
+        /* Translate the desired scrub rate to a e752x/3100 register value.
+         * Search for the bandwidth that is equal or greater than the
+         * desired rate and program the cooresponding register value.
+         */
+        for (i = 0; scrubrates[i].bandwidth != SDRATE_EOT; i++)
+                if (scrubrates[i].bandwidth >= *new_bw)
+                        break;
+
+        if (scrubrates[i].bandwidth == SDRATE_EOT)
+                return -1;
+
+        pci_write_config_word(pdev, E752X_MCHSCRB, scrubrates[i].scrubval);
+
+        return 0;
+}
+
+/* Convert current scrub rate value into byte/sec bandwidth */
+static int get_sdram_scrub_rate(struct mem_ctl_info *mci, u32 *bw)
+{
+        const struct scrubrate *scrubrates;
+        struct e752x_pvt *pvt = (struct e752x_pvt *) mci->pvt_info;
+        struct pci_dev *pdev = pvt->dev_d0f0;
+        u16 scrubval;
+        int i;
+
+        if (pvt->dev_info->ctl_dev == PCI_DEVICE_ID_INTEL_3100_0)
+                scrubrates = scrubrates_i3100;
+        else
+                scrubrates = scrubrates_e752x;
+
+        /* Find the bandwidth matching the memory scrubber configuration */
+        pci_read_config_word(pdev, E752X_MCHSCRB, &scrubval);
+        scrubval = scrubval & 0x0f;
+
+        for (i = 0; scrubrates[i].bandwidth != SDRATE_EOT; i++)
+                if (scrubrates[i].scrubval == scrubval)
+                        break;
+
+        if (scrubrates[i].bandwidth == SDRATE_EOT) {
+                e752x_printk(KERN_WARNING,
+                        "Invalid sdram scrub control value: 0x%x\n", scrubval);
+                return -1;
+        }
+
+        *bw = scrubrates[i].bandwidth;
+
+        return 0;
+}
+
 /* Return 1 if dual channel mode is active.  Else return 0. */
 static inline int dual_channel_active(u16 ddrcsr)
 {
@@ -1073,10 +1178,7 @@ fail:
 
 /* Setup system bus parity mask register.
  * Sysbus parity supported on:
- *   e7320/e7520/e7525 + Xeon
- *   i3100 + Xeon/Celeron
- * Sysbus parity not supported on:
- *   i3100 + Pentium M/Celeron M/Core Duo/Core2 Duo
+ * e7320/e7520/e7525 + Xeon
  */
 static void e752x_init_sysbus_parity_mask(struct e752x_pvt *pvt)
 {
@@ -1087,10 +1189,7 @@ static void e752x_init_sysbus_parity_mask(struct e752x_pvt *pvt)
         /* Allow module parameter override, else see if CPU supports parity */
         if (sysbus_parity != -1) {
                 enable = sysbus_parity;
-        } else if (cpu_id[0] &&
-                   ((strstr(cpu_id, "Pentium") && strstr(cpu_id, " M ")) ||
-                    (strstr(cpu_id, "Celeron") && strstr(cpu_id, " M ")) ||
-                    (strstr(cpu_id, "Core") && strstr(cpu_id, "Duo")))) {
+        } else if (cpu_id[0] && !strstr(cpu_id, "Xeon")) {
                 e752x_printk(KERN_INFO, "System Bus Parity not "
                              "supported by CPU, disabling\n");
                 enable = 0;
@@ -1187,6 +1286,8 @@ static int e752x_probe1(struct pci_dev *pdev, int dev_idx)
         mci->dev_name = pci_name(pdev);
         mci->edac_check = e752x_check;
         mci->ctl_page_to_phys = ctl_page_to_phys;
+        mci->set_sdram_scrub_rate = set_sdram_scrub_rate;
+        mci->get_sdram_scrub_rate = get_sdram_scrub_rate;
 
         /* set the map type.  1 = normal, 0 = reversed
          * Must be set before e752x_init_csrows in case csrow mapping
diff --git a/drivers/edac/edac_device_sysfs.c b/drivers/edac/edac_device_sysfs.c
index 53764577035f..5fdedbc0f545 100644
--- a/drivers/edac/edac_device_sysfs.c
+++ b/drivers/edac/edac_device_sysfs.c
@@ -137,7 +137,7 @@ static ssize_t edac_dev_ctl_info_store(struct kobject *kobj,
 }
 
 /* edac_dev file operations for an 'ctl_info' */
-static struct sysfs_ops device_ctl_info_ops = {
+static const struct sysfs_ops device_ctl_info_ops = {
         .show = edac_dev_ctl_info_show,
         .store = edac_dev_ctl_info_store
 };
@@ -373,7 +373,7 @@ static ssize_t edac_dev_instance_store(struct kobject *kobj,
 }
 
 /* edac_dev file operations for an 'instance' */
-static struct sysfs_ops device_instance_ops = {
+static const struct sysfs_ops device_instance_ops = {
         .show = edac_dev_instance_show,
         .store = edac_dev_instance_store
 };
@@ -476,7 +476,7 @@ static ssize_t edac_dev_block_store(struct kobject *kobj,
 }
 
 /* edac_dev file operations for a 'block' */
-static struct sysfs_ops device_block_ops = {
+static const struct sysfs_ops device_block_ops = {
         .show = edac_dev_block_show,
         .store = edac_dev_block_store
 };
diff --git a/drivers/edac/edac_mc_sysfs.c b/drivers/edac/edac_mc_sysfs.c
index e1d4ce083481..88840e9fa3e0 100644
--- a/drivers/edac/edac_mc_sysfs.c
+++ b/drivers/edac/edac_mc_sysfs.c
@@ -245,7 +245,7 @@ static ssize_t csrowdev_store(struct kobject *kobj, struct attribute *attr,
         return -EIO;
 }
 
-static struct sysfs_ops csrowfs_ops = {
+static const struct sysfs_ops csrowfs_ops = {
         .show = csrowdev_show,
         .store = csrowdev_store
 };
@@ -575,7 +575,7 @@ static ssize_t mcidev_store(struct kobject *kobj, struct attribute *attr,
 }
 
 /* Intermediate show/store table */
-static struct sysfs_ops mci_ops = {
+static const struct sysfs_ops mci_ops = {
         .show = mcidev_show,
         .store = mcidev_store
 };
diff --git a/drivers/edac/edac_pci_sysfs.c b/drivers/edac/edac_pci_sysfs.c
index fb60a877d768..bef94e3d9944 100644
--- a/drivers/edac/edac_pci_sysfs.c
+++ b/drivers/edac/edac_pci_sysfs.c
@@ -121,7 +121,7 @@ static ssize_t edac_pci_instance_store(struct kobject *kobj,
 }
 
 /* fs_ops table */
-static struct sysfs_ops pci_instance_ops = {
+static const struct sysfs_ops pci_instance_ops = {
         .show = edac_pci_instance_show,
         .store = edac_pci_instance_store
 };
@@ -261,7 +261,7 @@ static ssize_t edac_pci_dev_store(struct kobject *kobj,
         return -EIO;
 }
 
-static struct sysfs_ops edac_pci_sysfs_ops = {
+static const struct sysfs_ops edac_pci_sysfs_ops = {
         .show = edac_pci_dev_show,
         .store = edac_pci_dev_store
 };
diff --git a/drivers/edac/mpc85xx_edac.c b/drivers/edac/mpc85xx_edac.c
index ecd5928d7110..94cac0aacea3 100644
--- a/drivers/edac/mpc85xx_edac.c
+++ b/drivers/edac/mpc85xx_edac.c
@@ -239,16 +239,15 @@ static int __devinit mpc85xx_pci_err_probe(struct of_device *op,
         /* we only need the error registers */
         r.start += 0xe00;
 
-        if (!devm_request_mem_region(&op->dev, r.start,
-                                        r.end - r.start + 1, pdata->name)) {
+        if (!devm_request_mem_region(&op->dev, r.start, resource_size(&r),
+                                        pdata->name)) {
                 printk(KERN_ERR "%s: Error while requesting mem region\n",
                        __func__);
                 res = -EBUSY;
                 goto err;
         }
 
-        pdata->pci_vbase = devm_ioremap(&op->dev, r.start,
-                                        r.end - r.start + 1);
+        pdata->pci_vbase = devm_ioremap(&op->dev, r.start, resource_size(&r));
         if (!pdata->pci_vbase) {
                 printk(KERN_ERR "%s: Unable to setup PCI err regs\n", __func__);
                 res = -ENOMEM;
@@ -668,15 +667,125 @@ static struct of_platform_driver mpc85xx_l2_err_driver = {
 
 /**************************** MC Err device ***************************/
 
+/*
+ * Taken from table 8-55 in the MPC8641 User's Manual and/or 9-61 in the
+ * MPC8572 User's Manual.  Each line represents a syndrome bit column as a
+ * 64-bit value, but split into an upper and lower 32-bit chunk.  The labels
+ * below correspond to Freescale's manuals.
+ */
+static unsigned int ecc_table[16] = {
+        /* MSB           LSB */
+        /* [0:31]    [32:63] */
+        0xf00fe11e, 0xc33c0ff7, /* Syndrome bit 7 */
+        0x00ff00ff, 0x00fff0ff,
+        0x0f0f0f0f, 0x0f0fff00,
+        0x11113333, 0x7777000f,
+        0x22224444, 0x8888222f,
+        0x44448888, 0xffff4441,
+        0x8888ffff, 0x11118882,
+        0xffff1111, 0x22221114, /* Syndrome bit 0 */
+};
+
+/*
+ * Calculate the correct ECC value for a 64-bit value specified by high:low
+ */
+static u8 calculate_ecc(u32 high, u32 low)
+{
+        u32 mask_low;
+        u32 mask_high;
+        int bit_cnt;
+        u8 ecc = 0;
+        int i;
+        int j;
+
+        for (i = 0; i < 8; i++) {
+                mask_high = ecc_table[i * 2];
+                mask_low = ecc_table[i * 2 + 1];
+                bit_cnt = 0;
+
+                for (j = 0; j < 32; j++) {
+                        if ((mask_high >> j) & 1)
+                                bit_cnt ^= (high >> j) & 1;
+                        if ((mask_low >> j) & 1)
+                                bit_cnt ^= (low >> j) & 1;
+                }
+
+                ecc |= bit_cnt << i;
+        }
+
+        return ecc;
+}
+
+/*
+ * Create the syndrome code which is generated if the data line specified by
+ * 'bit' failed.  Eg generate an 8-bit codes seen in Table 8-55 in the MPC8641
+ * User's Manual and 9-61 in the MPC8572 User's Manual.
+ */
+static u8 syndrome_from_bit(unsigned int bit) {
+        int i;
+        u8 syndrome = 0;
+
+        /*
+         * Cycle through the upper or lower 32-bit portion of each value in
+         * ecc_table depending on if 'bit' is in the upper or lower half of
+         * 64-bit data.
+         */
+        for (i = bit < 32; i < 16; i += 2)
+                syndrome |= ((ecc_table[i] >> (bit % 32)) & 1) << (i / 2);
+
+        return syndrome;
+}
+
+/*
+ * Decode data and ecc syndrome to determine what went wrong
+ * Note: This can only decode single-bit errors
+ */
+static void sbe_ecc_decode(u32 cap_high, u32 cap_low, u32 cap_ecc,
+                       int *bad_data_bit, int *bad_ecc_bit)
+{
+        int i;
+        u8 syndrome;
+
+        *bad_data_bit = -1;
+        *bad_ecc_bit = -1;
+
+        /*
+         * Calculate the ECC of the captured data and XOR it with the captured
+         * ECC to find an ECC syndrome value we can search for
+         */
+        syndrome = calculate_ecc(cap_high, cap_low) ^ cap_ecc;
+
+        /* Check if a data line is stuck... */
+        for (i = 0; i < 64; i++) {
+                if (syndrome == syndrome_from_bit(i)) {
+                        *bad_data_bit = i;
+                        return;
+                }
+        }
+
+        /* If data is correct, check ECC bits for errors... */
+        for (i = 0; i < 8; i++) {
+                if ((syndrome >> i) & 0x1) {
+                        *bad_ecc_bit = i;
+                        return;
+                }
+        }
+}
+
 static void mpc85xx_mc_check(struct mem_ctl_info *mci)
 {
         struct mpc85xx_mc_pdata *pdata = mci->pvt_info;
         struct csrow_info *csrow;
+        u32 bus_width;
         u32 err_detect;
         u32 syndrome;
         u32 err_addr;
         u32 pfn;
         int row_index;
+        u32 cap_high;
+        u32 cap_low;
+        int bad_data_bit;
+        int bad_ecc_bit;
 
         err_detect = in_be32(pdata->mc_vbase + MPC85XX_MC_ERR_DETECT);
         if (!err_detect)
@@ -692,6 +801,15 @@ static void mpc85xx_mc_check(struct mem_ctl_info *mci)
         }
 
         syndrome = in_be32(pdata->mc_vbase + MPC85XX_MC_CAPTURE_ECC);
+
+        /* Mask off appropriate bits of syndrome based on bus width */
+        bus_width = (in_be32(pdata->mc_vbase + MPC85XX_MC_DDR_SDRAM_CFG) &
+                        DSC_DBW_MASK) ? 32 : 64;
+        if (bus_width == 64)
+                syndrome &= 0xff;
+        else
+                syndrome &= 0xffff;
+
         err_addr = in_be32(pdata->mc_vbase + MPC85XX_MC_CAPTURE_ADDRESS);
         pfn = err_addr >> PAGE_SHIFT;
 
@@ -701,14 +819,35 @@ static void mpc85xx_mc_check(struct mem_ctl_info *mci)
                         break;
         }
 
-        mpc85xx_mc_printk(mci, KERN_ERR, "Capture Data High: %#8.8x\n",
-                          in_be32(pdata->mc_vbase +
-                                  MPC85XX_MC_CAPTURE_DATA_HI));
-        mpc85xx_mc_printk(mci, KERN_ERR, "Capture Data Low: %#8.8x\n",
-                          in_be32(pdata->mc_vbase +
-                                  MPC85XX_MC_CAPTURE_DATA_LO));
-        mpc85xx_mc_printk(mci, KERN_ERR, "syndrome: %#8.8x\n", syndrome);
-        mpc85xx_mc_printk(mci, KERN_ERR, "err addr: %#8.8x\n", err_addr);
+        cap_high = in_be32(pdata->mc_vbase + MPC85XX_MC_CAPTURE_DATA_HI);
+        cap_low = in_be32(pdata->mc_vbase + MPC85XX_MC_CAPTURE_DATA_LO);
+
+        /*
+         * Analyze single-bit errors on 64-bit wide buses
+         * TODO: Add support for 32-bit wide buses
+         */
+        if ((err_detect & DDR_EDE_SBE) && (bus_width == 64)) {
+                sbe_ecc_decode(cap_high, cap_low, syndrome,
+                                &bad_data_bit, &bad_ecc_bit);
+
+                if (bad_data_bit != -1)
+                        mpc85xx_mc_printk(mci, KERN_ERR,
+                                "Faulty Data bit: %d\n", bad_data_bit);
+                if (bad_ecc_bit != -1)
+                        mpc85xx_mc_printk(mci, KERN_ERR,
+                                "Faulty ECC bit: %d\n", bad_ecc_bit);
+
+                mpc85xx_mc_printk(mci, KERN_ERR,
+                        "Expected Data / ECC:\t%#8.8x_%08x / %#2.2x\n",
+                        cap_high ^ (1 << (bad_data_bit - 32)),
+                        cap_low ^ (1 << bad_data_bit),
+                        syndrome ^ (1 << bad_ecc_bit));
+        }
+
+        mpc85xx_mc_printk(mci, KERN_ERR,
+                        "Captured Data / ECC:\t%#8.8x_%08x / %#2.2x\n",
+                        cap_high, cap_low, syndrome);
+        mpc85xx_mc_printk(mci, KERN_ERR, "Err addr: %#8.8x\n", err_addr);
         mpc85xx_mc_printk(mci, KERN_ERR, "PFN: %#8.8x\n", pfn);
 
         /* we are out of range */
diff --git a/drivers/edac/mpc85xx_edac.h b/drivers/edac/mpc85xx_edac.h
index 52432ee7c4b9..cb24df839460 100644
--- a/drivers/edac/mpc85xx_edac.h
+++ b/drivers/edac/mpc85xx_edac.h
@@ -48,6 +48,9 @@
 #define DSC_MEM_EN      0x80000000
 #define DSC_ECC_EN      0x20000000
 #define DSC_RD_EN       0x10000000
+#define DSC_DBW_MASK    0x00180000
+#define DSC_DBW_32      0x00080000
+#define DSC_DBW_64      0x00000000
 
 #define DSC_SDTYPE_MASK         0x07000000
 
diff --git a/drivers/firewire/core-device.c b/drivers/firewire/core-device.c
index 014cabd3afda..5db0518c66da 100644
--- a/drivers/firewire/core-device.c
+++ b/drivers/firewire/core-device.c
@@ -33,7 +33,6 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/rwsem.h>
-#include <linux/semaphore.h>
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/workqueue.h>
@@ -828,9 +827,9 @@ static int update_unit(struct device *dev, void *data)
         struct fw_driver *driver = (struct fw_driver *)dev->driver;
 
         if (is_fw_unit(dev) && driver != NULL && driver->update != NULL) {
-                down(&dev->sem);
+                device_lock(dev);
                 driver->update(unit);
-                up(&dev->sem);
+                device_unlock(dev);
         }
 
         return 0;
diff --git a/drivers/firmware/edd.c b/drivers/firmware/edd.c
index 9e4f59dc7f1e..110e24e50883 100644
--- a/drivers/firmware/edd.c
+++ b/drivers/firmware/edd.c
@@ -122,7 +122,7 @@ edd_attr_show(struct kobject * kobj, struct attribute *attr, char *buf)
         return ret;
 }
 
-static struct sysfs_ops edd_attr_ops = {
+static const struct sysfs_ops edd_attr_ops = {
         .show = edd_attr_show,
 };
 
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efivars.c
index f4f709d1370b..082f06ecd327 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efivars.c
@@ -362,7 +362,7 @@ static ssize_t efivar_attr_store(struct kobject *kobj, struct attribute *attr,
         return ret;
 }
 
-static struct sysfs_ops efivar_attr_ops = {
+static const struct sysfs_ops efivar_attr_ops = {
         .show = efivar_attr_show,
         .store = efivar_attr_store,
 };
diff --git a/drivers/firmware/iscsi_ibft.c b/drivers/firmware/iscsi_ibft.c
index a3600e3ed0fa..ed2801c378de 100644
--- a/drivers/firmware/iscsi_ibft.c
+++ b/drivers/firmware/iscsi_ibft.c
@@ -519,7 +519,7 @@ static ssize_t ibft_show_attribute(struct kobject *kobj,
         return ret;
 }
 
-static struct sysfs_ops ibft_attr_ops = {
+static const struct sysfs_ops ibft_attr_ops = {
         .show = ibft_show_attribute,
 };
 
diff --git a/drivers/firmware/memmap.c b/drivers/firmware/memmap.c
index 20f645743ead..d59f7cad2269 100644
--- a/drivers/firmware/memmap.c
+++ b/drivers/firmware/memmap.c
@@ -74,7 +74,7 @@ static struct attribute *def_attrs[] = {
         NULL
 };
 
-static struct sysfs_ops memmap_attr_ops = {
+static const struct sysfs_ops memmap_attr_ops = {
         .show = memmap_attr_show,
 };
 
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 9006fdb26fea..6d1b86661e63 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -623,7 +623,9 @@ static const struct attribute_group gpiochip_attr_group = {
  * /sys/class/gpio/unexport ... write-only
  *      integer N ... number of GPIO to unexport
  */
-static ssize_t export_store(struct class *class, const char *buf, size_t len)
+static ssize_t export_store(struct class *class,
+                                struct class_attribute *attr,
+                                const char *buf, size_t len)
 {
         long    gpio;
         int     status;
@@ -653,7 +655,9 @@ done:
         return status ? : len;
 }
 
-static ssize_t unexport_store(struct class *class, const char *buf, size_t len)
+static ssize_t unexport_store(struct class *class,
+                                struct class_attribute *attr,
+                                const char *buf, size_t len)
 {
         long    gpio;
         int     status;
diff --git a/drivers/gpu/drm/drm_sysfs.c b/drivers/gpu/drm/drm_sysfs.c
index 7e42b7e9d43a..014ce24761b9 100644
--- a/drivers/gpu/drm/drm_sysfs.c
+++ b/drivers/gpu/drm/drm_sysfs.c
@@ -70,19 +70,17 @@ static int drm_class_resume(struct device *dev)
         return 0;
 }
 
-/* Display the version of drm_core. This doesn't work right in current design */
-static ssize_t version_show(struct class *dev, char *buf)
-{
-        return sprintf(buf, "%s %d.%d.%d %s\n", CORE_NAME, CORE_MAJOR,
-                       CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
-}
-
 static char *drm_devnode(struct device *dev, mode_t *mode)
 {
         return kasprintf(GFP_KERNEL, "dri/%s", dev_name(dev));
 }
 
-static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
+static CLASS_ATTR_STRING(version, S_IRUGO,
+                CORE_NAME " "
+                __stringify(CORE_MAJOR) "."
+                __stringify(CORE_MINOR) "."
+                __stringify(CORE_PATCHLEVEL) " "
+                CORE_DATE);
 
 /**
  * drm_sysfs_create - create a struct drm_sysfs_class structure
@@ -109,7 +107,7 @@ struct class *drm_sysfs_create(struct module *owner, char *name)
         class->suspend = drm_class_suspend;
         class->resume = drm_class_resume;
 
-        err = class_create_file(class, &class_attr_version);
+        err = class_create_file(class, &class_attr_version.attr);
         if (err)
                 goto err_out_class;
 
@@ -132,7 +130,7 @@ void drm_sysfs_destroy(void)
 {
         if ((drm_class == NULL) || (IS_ERR(drm_class)))
                 return;
-        class_remove_file(drm_class, &class_attr_version);
+        class_remove_file(drm_class, &class_attr_version.attr);
         class_destroy(drm_class);
 }
 
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index c7320ce4567d..89c38c49066f 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -128,7 +128,7 @@ static struct attribute *ttm_bo_global_attrs[] = {
         NULL
 };
 
-static struct sysfs_ops ttm_bo_global_ops = {
+static const struct sysfs_ops ttm_bo_global_ops = {
         .show = &ttm_bo_global_show
 };
 
diff --git a/drivers/gpu/drm/ttm/ttm_memory.c b/drivers/gpu/drm/ttm/ttm_memory.c
index f5245c02b8fd..eb143e04d402 100644
--- a/drivers/gpu/drm/ttm/ttm_memory.c
+++ b/drivers/gpu/drm/ttm/ttm_memory.c
@@ -152,7 +152,7 @@ static struct attribute *ttm_mem_zone_attrs[] = {
         NULL
 };
 
-static struct sysfs_ops ttm_mem_zone_ops = {
+static const struct sysfs_ops ttm_mem_zone_ops = {
         .show = &ttm_mem_zone_show,
         .store = &ttm_mem_zone_store
 };
diff --git a/drivers/i2c/busses/i2c-omap.c b/drivers/i2c/busses/i2c-omap.c
index 913abd7c172f..c7c237537f81 100644
--- a/drivers/i2c/busses/i2c-omap.c
+++ b/drivers/i2c/busses/i2c-omap.c
@@ -850,7 +850,7 @@ static const struct i2c_algorithm omap_i2c_algo = {
         .functionality  = omap_i2c_func,
 };
 
-static int __init
+static int __devinit
 omap_i2c_probe(struct platform_device *pdev)
 {
         struct omap_i2c_dev     *dev;
diff --git a/drivers/ieee1394/nodemgr.c b/drivers/ieee1394/nodemgr.c
index 5122b5a8aa2d..18350213479e 100644
--- a/drivers/ieee1394/nodemgr.c
+++ b/drivers/ieee1394/nodemgr.c
@@ -19,7 +19,6 @@
 #include <linux/moduleparam.h>
 #include <linux/mutex.h>
 #include <linux/freezer.h>
-#include <linux/semaphore.h>
 #include <asm/atomic.h>
 
 #include "csr.h"
@@ -1397,9 +1396,9 @@ static int update_pdrv(struct device *dev, void *data)
                         pdrv = container_of(drv, struct hpsb_protocol_driver,
                                             driver);
                         if (pdrv->update) {
-                                down(&ud->device.sem);
+                                device_lock(&ud->device);
                                 error = pdrv->update(ud);
-                                up(&ud->device.sem);
+                                device_unlock(&ud->device);
                         }
                         if (error)
                                 device_release_driver(&ud->device);
diff --git a/drivers/infiniband/core/cm.c b/drivers/infiniband/core/cm.c
index 5130fc55b8e2..764787ebe8d8 100644
--- a/drivers/infiniband/core/cm.c
+++ b/drivers/infiniband/core/cm.c
@@ -3597,7 +3597,7 @@ static ssize_t cm_show_counter(struct kobject *obj, struct attribute *attr,
                        atomic_long_read(&group->counter[cm_attr->index]));
 }
 
-static struct sysfs_ops cm_counter_ops = {
+static const struct sysfs_ops cm_counter_ops = {
         .show = cm_show_counter
 };
 
diff --git a/drivers/infiniband/core/sysfs.c b/drivers/infiniband/core/sysfs.c
index 158a214da2f7..1558bb7fc74d 100644
--- a/drivers/infiniband/core/sysfs.c
+++ b/drivers/infiniband/core/sysfs.c
@@ -79,7 +79,7 @@ static ssize_t port_attr_show(struct kobject *kobj,
         return port_attr->show(p, port_attr, buf);
 }
 
-static struct sysfs_ops port_sysfs_ops = {
+static const struct sysfs_ops port_sysfs_ops = {
         .show = port_attr_show
 };
 
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index 1b09b735c5a8..017d6e24448f 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -1336,11 +1336,8 @@ static void ib_ucm_remove_one(struct ib_device *device)
         device_unregister(&ucm_dev->dev);
 }
 
-static ssize_t show_abi_version(struct class *class, char *buf)
-{
-        return sprintf(buf, "%d\n", IB_USER_CM_ABI_VERSION);
-}
-static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
+static CLASS_ATTR_STRING(abi_version, S_IRUGO,
+                         __stringify(IB_USER_CM_ABI_VERSION));
 
 static int __init ib_ucm_init(void)
 {
@@ -1353,7 +1350,7 @@ static int __init ib_ucm_init(void)
                 goto error1;
         }
 
-        ret = class_create_file(&cm_class, &class_attr_abi_version);
+        ret = class_create_file(&cm_class, &class_attr_abi_version.attr);
         if (ret) {
                 printk(KERN_ERR "ucm: couldn't create abi_version attribute\n");
                 goto error2;
@@ -1367,7 +1364,7 @@ static int __init ib_ucm_init(void)
         return 0;
 
 error3:
-        class_remove_file(&cm_class, &class_attr_abi_version);
+        class_remove_file(&cm_class, &class_attr_abi_version.attr);
 error2:
         unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES);
 error1:
@@ -1377,7 +1374,7 @@ error1:
 static void __exit ib_ucm_cleanup(void)
 {
         ib_unregister_client(&ucm_client);
-        class_remove_file(&cm_class, &class_attr_abi_version);
+        class_remove_file(&cm_class, &class_attr_abi_version.attr);
         unregister_chrdev_region(IB_UCM_BASE_DEV, IB_UCM_MAX_DEVICES);
         if (overflow_maj)
                 unregister_chrdev_region(overflow_maj, IB_UCM_MAX_DEVICES);
diff --git a/drivers/infiniband/core/user_mad.c b/drivers/infiniband/core/user_mad.c
index 02d360cfc2f7..04b585e86cb2 100644
--- a/drivers/infiniband/core/user_mad.c
+++ b/drivers/infiniband/core/user_mad.c
@@ -965,11 +965,8 @@ static ssize_t show_port(struct device *dev, struct device_attribute *attr,
 }
 static DEVICE_ATTR(port, S_IRUGO, show_port, NULL);
 
-static ssize_t show_abi_version(struct class *class, char *buf)
-{
-        return sprintf(buf, "%d\n", IB_USER_MAD_ABI_VERSION);
-}
-static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
+static CLASS_ATTR_STRING(abi_version, S_IRUGO,
+                         __stringify(IB_USER_MAD_ABI_VERSION));
 
 static dev_t overflow_maj;
 static DECLARE_BITMAP(overflow_map, IB_UMAD_MAX_PORTS);
@@ -1194,7 +1191,7 @@ static int __init ib_umad_init(void)
                 goto out_chrdev;
         }
 
-        ret = class_create_file(umad_class, &class_attr_abi_version);
+        ret = class_create_file(umad_class, &class_attr_abi_version.attr);
         if (ret) {
                 printk(KERN_ERR "user_mad: couldn't create abi_version attribute\n");
                 goto out_class;
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 4fa2e6516441..d805cf365c8d 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -691,11 +691,8 @@ static ssize_t show_dev_abi_version(struct device *device,
 }
 static DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);
 
-static ssize_t show_abi_version(struct class *class, char *buf)
-{
-        return sprintf(buf, "%d\n", IB_USER_VERBS_ABI_VERSION);
-}
-static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
+static CLASS_ATTR_STRING(abi_version, S_IRUGO,
+                         __stringify(IB_USER_VERBS_ABI_VERSION));
 
 static dev_t overflow_maj;
 static DECLARE_BITMAP(overflow_map, IB_UVERBS_MAX_DEVICES);
@@ -841,7 +838,7 @@ static int __init ib_uverbs_init(void)
                 goto out_chrdev;
         }
 
-        ret = class_create_file(uverbs_class, &class_attr_abi_version);
+        ret = class_create_file(uverbs_class, &class_attr_abi_version.attr);
         if (ret) {
                 printk(KERN_ERR "user_verbs: couldn't create abi_version attribute\n");
                 goto out_class;
diff --git a/drivers/input/keyboard/locomokbd.c b/drivers/input/keyboard/locomokbd.c
index 9caed30f3bbb..b1ab29861e1c 100644
--- a/drivers/input/keyboard/locomokbd.c
+++ b/drivers/input/keyboard/locomokbd.c
@@ -192,11 +192,18 @@ static void locomokbd_scankeyboard(struct locomokbd *locomokbd)
 static irqreturn_t locomokbd_interrupt(int irq, void *dev_id)
 {
         struct locomokbd *locomokbd = dev_id;
+        u16 r;
+
+        r = locomo_readl(locomokbd->base + LOCOMO_KIC);
+        if ((r & 0x0001) == 0)
+                return IRQ_HANDLED;
+
+        locomo_writel(r & ~0x0100, locomokbd->base + LOCOMO_KIC); /* Ack */
+
         /** wait chattering delay **/
         udelay(100);
 
         locomokbd_scankeyboard(locomokbd);
-
         return IRQ_HANDLED;
 }
 
@@ -210,6 +217,25 @@ static void locomokbd_timer_callback(unsigned long data)
         locomokbd_scankeyboard(locomokbd);
 }
 
+static int locomokbd_open(struct input_dev *dev)
+{
+        struct locomokbd *locomokbd = input_get_drvdata(dev);
+        u16 r;
+        
+        r = locomo_readl(locomokbd->base + LOCOMO_KIC) | 0x0010;
+        locomo_writel(r, locomokbd->base + LOCOMO_KIC);
+        return 0;
+}
+
+static void locomokbd_close(struct input_dev *dev)
+{
+        struct locomokbd *locomokbd = input_get_drvdata(dev);
+        u16 r;
+        
+        r = locomo_readl(locomokbd->base + LOCOMO_KIC) & ~0x0010;
+        locomo_writel(r, locomokbd->base + LOCOMO_KIC);
+}
+
 static int __devinit locomokbd_probe(struct locomo_dev *dev)
 {
         struct locomokbd *locomokbd;
@@ -253,6 +279,8 @@ static int __devinit locomokbd_probe(struct locomo_dev *dev)
         input_dev->id.vendor = 0x0001;
         input_dev->id.product = 0x0001;
         input_dev->id.version = 0x0100;
+        input_dev->open = locomokbd_open;
+        input_dev->close = locomokbd_close;
         input_dev->dev.parent = &dev->dev;
 
         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP) |
@@ -261,6 +289,8 @@ static int __devinit locomokbd_probe(struct locomo_dev *dev)
         input_dev->keycodesize = sizeof(locomokbd_keycode[0]);
         input_dev->keycodemax = ARRAY_SIZE(locomokbd_keycode);
 
+        input_set_drvdata(input_dev, locomokbd);
+
         memcpy(locomokbd->keycode, locomokbd_keycode, sizeof(locomokbd->keycode));
         for (i = 0; i < LOCOMOKBD_NUMKEYS; i++)
                 set_bit(locomokbd->keycode[i], input_dev->keybit);
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 437f55c5d18d..419795f4a2aa 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -321,6 +321,7 @@ int wf_register_sensor(struct wf_sensor *new_sr)
         kref_init(&new_sr->ref);
         list_add(&new_sr->link, &wf_sensors);
 
+        sysfs_attr_init(&new_sr->attr.attr);
         new_sr->attr.attr.name = new_sr->name;
         new_sr->attr.attr.mode = 0444;
         new_sr->attr.show = wf_show_sensor;
diff --git a/drivers/macintosh/windfarm_smu_controls.c b/drivers/macintosh/windfarm_smu_controls.c
index 6c68b9e5f5c4..43137b421f92 100644
--- a/drivers/macintosh/windfarm_smu_controls.c
+++ b/drivers/macintosh/windfarm_smu_controls.c
@@ -173,6 +173,7 @@ static struct smu_fan_control *smu_fan_create(struct device_node *node,
 
         fct->fan_type = pwm_fan;
         fct->ctrl.type = pwm_fan ? WF_CONTROL_PWM_FAN : WF_CONTROL_RPM_FAN;
+        sysfs_attr_init(&fct->ctrl.attr.attr);
 
         /* We use the name & location here the same way we do for SMU sensors,
          * see the comment in windfarm_smu_sensors.c. The locations are a bit
diff --git a/drivers/md/dm-sysfs.c b/drivers/md/dm-sysfs.c
index f91b40942e07..84d2b91e4efb 100644
--- a/drivers/md/dm-sysfs.c
+++ b/drivers/md/dm-sysfs.c
@@ -75,7 +75,7 @@ static struct attribute *dm_attrs[] = {
         NULL,
 };
 
-static struct sysfs_ops dm_sysfs_ops = {
+static const struct sysfs_ops dm_sysfs_ops = {
         .show   = dm_attr_show,
 };
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index a20a71e5efd3..fdc1890b6ac5 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -2642,7 +2642,7 @@ static void rdev_free(struct kobject *ko)
         mdk_rdev_t *rdev = container_of(ko, mdk_rdev_t, kobj);
         kfree(rdev);
 }
-static struct sysfs_ops rdev_sysfs_ops = {
+static const struct sysfs_ops rdev_sysfs_ops = {
         .show           = rdev_attr_show,
         .store          = rdev_attr_store,
 };
@@ -4059,7 +4059,7 @@ static void md_free(struct kobject *ko)
         kfree(mddev);
 }
 
-static struct sysfs_ops md_sysfs_ops = {
+static const struct sysfs_ops md_sysfs_ops = {
         .show   = md_attr_show,
         .store  = md_attr_store,
 };
diff --git a/drivers/media/video/omap24xxcam.c b/drivers/media/video/omap24xxcam.c
index 7400eacb4d64..142c327afb32 100644
--- a/drivers/media/video/omap24xxcam.c
+++ b/drivers/media/video/omap24xxcam.c
@@ -1735,7 +1735,7 @@ static struct v4l2_int_device omap24xxcam = {
  *
  */
 
-static int __init omap24xxcam_probe(struct platform_device *pdev)
+static int __devinit omap24xxcam_probe(struct platform_device *pdev)
 {
         struct omap24xxcam_device *cam;
         struct resource *mem;
diff --git a/drivers/misc/phantom.c b/drivers/misc/phantom.c
index 04c27266f567..779aa8ebe4cf 100644
--- a/drivers/misc/phantom.c
+++ b/drivers/misc/phantom.c
@@ -497,12 +497,7 @@ static struct pci_driver phantom_pci_driver = {
         .resume = phantom_resume
 };
 
-static ssize_t phantom_show_version(struct class *cls, char *buf)
-{
-        return sprintf(buf, PHANTOM_VERSION "\n");
-}
-
-static CLASS_ATTR(version, 0444, phantom_show_version, NULL);
+static CLASS_ATTR_STRING(version, 0444, PHANTOM_VERSION);
 
 static int __init phantom_init(void)
 {
@@ -515,7 +510,7 @@ static int __init phantom_init(void)
                 printk(KERN_ERR "phantom: can't register phantom class\n");
                 goto err;
         }
-        retval = class_create_file(phantom_class, &class_attr_version);
+        retval = class_create_file(phantom_class, &class_attr_version.attr);
         if (retval) {
                 printk(KERN_ERR "phantom: can't create sysfs version file\n");
                 goto err_class;
@@ -541,7 +536,7 @@ static int __init phantom_init(void)
 err_unchr:
         unregister_chrdev_region(dev, PHANTOM_MAX_MINORS);
 err_attr:
-        class_remove_file(phantom_class, &class_attr_version);
+        class_remove_file(phantom_class, &class_attr_version.attr);
 err_class:
         class_destroy(phantom_class);
 err:
@@ -554,7 +549,7 @@ static void __exit phantom_exit(void)
 
         unregister_chrdev_region(MKDEV(phantom_major, 0), PHANTOM_MAX_MINORS);
 
-        class_remove_file(phantom_class, &class_attr_version);
+        class_remove_file(phantom_class, &class_attr_version.attr);
         class_destroy(phantom_class);
 
         pr_debug("phantom: module successfully removed\n");
diff --git a/drivers/misc/sgi-gru/grutables.h b/drivers/misc/sgi-gru/grutables.h
index 02a77b8b8eef..7a8b9068ea03 100644
--- a/drivers/misc/sgi-gru/grutables.h
+++ b/drivers/misc/sgi-gru/grutables.h
@@ -516,8 +516,7 @@ struct gru_blade_state {
 
 /* Scan all active GRUs in a GRU bitmap */
 #define for_each_gru_in_bitmap(gid, map)                                \
-        for ((gid) = find_first_bit((map), GRU_MAX_GRUS); (gid) < GRU_MAX_GRUS;\
-                (gid)++, (gid) = find_next_bit((map), GRU_MAX_GRUS, (gid)))
+        for_each_set_bit((gid), (map), GRU_MAX_GRUS)
 
 /* Scan all active GRUs on a specific blade */
 #define for_each_gru_on_blade(gru, nid, i)                              \
@@ -536,23 +535,17 @@ struct gru_blade_state {
 
 /* Scan each CBR whose bit is set in a TFM (or copy of) */
 #define for_each_cbr_in_tfm(i, map)                                     \
-        for ((i) = find_first_bit(map, GRU_NUM_CBE);                    \
-                        (i) < GRU_NUM_CBE;                              \
-                        (i)++, (i) = find_next_bit(map, GRU_NUM_CBE, i))
+        for_each_set_bit((i), (map), GRU_NUM_CBE)
 
 /* Scan each CBR in a CBR bitmap. Note: multiple CBRs in an allocation unit */
 #define for_each_cbr_in_allocation_map(i, map, k)                       \
-        for ((k) = find_first_bit(map, GRU_CBR_AU); (k) < GRU_CBR_AU;   \
-                        (k) = find_next_bit(map, GRU_CBR_AU, (k) + 1))  \
+        for_each_set_bit((k), (map), GRU_CBR_AU)                        \
                 for ((i) = (k)*GRU_CBR_AU_SIZE;                         \
                                 (i) < ((k) + 1) * GRU_CBR_AU_SIZE; (i)++)
 
 /* Scan each DSR in a DSR bitmap. Note: multiple DSRs in an allocation unit */
 #define for_each_dsr_in_allocation_map(i, map, k)                       \
-        for ((k) = find_first_bit((const unsigned long *)map, GRU_DSR_AU);\
-                        (k) < GRU_DSR_AU;                               \
-                        (k) = find_next_bit((const unsigned long *)map, \
-                                          GRU_DSR_AU, (k) + 1))         \
+        for_each_set_bit((k), (const unsigned long *)(map), GRU_DSR_AU) \
                 for ((i) = (k) * GRU_DSR_AU_CL;                         \
                                 (i) < ((k) + 1) * GRU_DSR_AU_CL; (i)++)
 
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index f4b97d3c3d0f..3168ebd616b2 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -1089,6 +1089,7 @@ void mmc_rescan(struct work_struct *work)
         mmc_claim_host(host);
 
         mmc_power_up(host);
+        sdio_reset(host);
         mmc_go_idle(host);
 
         mmc_send_if_cond(host, host->ocr_avail);
diff --git a/drivers/mmc/core/sdio_ops.c b/drivers/mmc/core/sdio_ops.c
index 4eb7825fd1a7..dea36d9c22e6 100644
--- a/drivers/mmc/core/sdio_ops.c
+++ b/drivers/mmc/core/sdio_ops.c
@@ -67,13 +67,13 @@ int mmc_send_io_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr)
         return err;
 }
 
-int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
-        unsigned addr, u8 in, u8* out)
+static int mmc_io_rw_direct_host(struct mmc_host *host, int write, unsigned fn,
+        unsigned addr, u8 in, u8 *out)
 {
         struct mmc_command cmd;
         int err;
 
-        BUG_ON(!card);
+        BUG_ON(!host);
         BUG_ON(fn > 7);
 
         /* sanity check */
@@ -90,11 +90,11 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         cmd.arg |= in;
         cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
 
-        err = mmc_wait_for_cmd(card->host, &cmd, 0);
+        err = mmc_wait_for_cmd(host, &cmd, 0);
         if (err)
                 return err;
 
-        if (mmc_host_is_spi(card->host)) {
+        if (mmc_host_is_spi(host)) {
                 /* host driver already reported errors */
         } else {
                 if (cmd.resp[0] & R5_ERROR)
@@ -106,7 +106,7 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         }
 
         if (out) {
-                if (mmc_host_is_spi(card->host))
+                if (mmc_host_is_spi(host))
                         *out = (cmd.resp[0] >> 8) & 0xFF;
                 else
                         *out = cmd.resp[0] & 0xFF;
@@ -115,6 +115,13 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         return 0;
 }
 
+int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
+        unsigned addr, u8 in, u8 *out)
+{
+        BUG_ON(!card);
+        return mmc_io_rw_direct_host(card->host, write, fn, addr, in, out);
+}
+
 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz)
 {
@@ -182,3 +189,20 @@ int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         return 0;
 }
 
+int sdio_reset(struct mmc_host *host)
+{
+        int ret;
+        u8 abort;
+
+        /* SDIO Simplified Specification V2.0, 4.4 Reset for SDIO */
+
+        ret = mmc_io_rw_direct_host(host, 0, 0, SDIO_CCCR_ABORT, 0, &abort);
+        if (ret)
+                abort = 0x08;
+        else
+                abort |= 0x08;
+
+        ret = mmc_io_rw_direct_host(host, 1, 0, SDIO_CCCR_ABORT, abort, NULL);
+        return ret;
+}
+
diff --git a/drivers/mmc/core/sdio_ops.h b/drivers/mmc/core/sdio_ops.h
index e2e74b0d17d8..12a4d3ab174c 100644
--- a/drivers/mmc/core/sdio_ops.h
+++ b/drivers/mmc/core/sdio_ops.h
@@ -17,6 +17,7 @@ int mmc_io_rw_direct(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, u8 in, u8* out);
 int mmc_io_rw_extended(struct mmc_card *card, int write, unsigned fn,
         unsigned addr, int incr_addr, u8 *buf, unsigned blocks, unsigned blksz);
+int sdio_reset(struct mmc_host *host);
 
 #endif
 
diff --git a/drivers/mmc/host/mxcmmc.c b/drivers/mmc/host/mxcmmc.c
index 16cc91c827c9..2df90412abb5 100644
--- a/drivers/mmc/host/mxcmmc.c
+++ b/drivers/mmc/host/mxcmmc.c
@@ -708,7 +708,7 @@ static int mxcmci_probe(struct platform_device *pdev)
         mmc->max_blk_size = 2048;
         mmc->max_blk_count = 65535;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
-        mmc->max_seg_size = mmc->max_seg_size;
+        mmc->max_seg_size = mmc->max_req_size;
 
         host = mmc_priv(mmc);
         host->base = ioremap(r->start, resource_size(r));
diff --git a/drivers/mtd/maps/pismo.c b/drivers/mtd/maps/pismo.c
index c48cad271f5d..30e12c88d1da 100644
--- a/drivers/mtd/maps/pismo.c
+++ b/drivers/mtd/maps/pismo.c
@@ -118,7 +118,7 @@ static int __devinit pismo_add_device(struct pismo_data *pismo, int i,
 {
         struct platform_device *dev;
         struct resource res = { };
-        phys_addr_t base = region.base;
+        phys_addr_t base = region->base;
         int ret;
 
         if (base == ~0)
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index bb6465604235..1157d5679e66 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -444,7 +444,7 @@ config MTD_NAND_FSL_UPM
 
 config MTD_NAND_MXC
         tristate "MXC NAND support"
-        depends on ARCH_MX2 || ARCH_MX3
+        depends on ARCH_MX2 || ARCH_MX25 || ARCH_MX3
         help
           This enables the driver for the NAND flash controller on the
           MXC processors.
diff --git a/drivers/mtd/ubi/build.c b/drivers/mtd/ubi/build.c
index bc45ef9af17d..fad40aa6f099 100644
--- a/drivers/mtd/ubi/build.c
+++ b/drivers/mtd/ubi/build.c
@@ -89,7 +89,8 @@ DEFINE_MUTEX(ubi_devices_mutex);
 static DEFINE_SPINLOCK(ubi_devices_lock);
 
 /* "Show" method for files in '/<sysfs>/class/ubi/' */
-static ssize_t ubi_version_show(struct class *class, char *buf)
+static ssize_t ubi_version_show(struct class *class, struct class_attribute *attr,
+                                char *buf)
 {
         return sprintf(buf, "%d\n", UBI_VERSION);
 }
diff --git a/drivers/net/bonding/bond_sysfs.c b/drivers/net/bonding/bond_sysfs.c
index 5acd557cea9b..b8bec086daa1 100644
--- a/drivers/net/bonding/bond_sysfs.c
+++ b/drivers/net/bonding/bond_sysfs.c
@@ -51,7 +51,9 @@
  * "show" function for the bond_masters attribute.
  * The class parameter is ignored.
  */
-static ssize_t bonding_show_bonds(struct class *cls, char *buf)
+static ssize_t bonding_show_bonds(struct class *cls,
+                                  struct class_attribute *attr,
+                                  char *buf)
 {
         struct net *net = current->nsproxy->net_ns;
         struct bond_net *bn = net_generic(net, bond_net_id);
@@ -98,6 +100,7 @@ static struct net_device *bond_get_by_name(struct net *net, const char *ifname)
  */
 
 static ssize_t bonding_store_bonds(struct class *cls,
+                                   struct class_attribute *attr,
                                    const char *buffer, size_t count)
 {
         struct net *net = current->nsproxy->net_ns;
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index f2b937966950..0bc777bac9b4 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -1577,7 +1577,7 @@ static struct attribute * veth_pool_attrs[] = {
         NULL,
 };
 
-static struct sysfs_ops veth_pool_ops = {
+static const struct sysfs_ops veth_pool_ops = {
         .show   = veth_pool_show,
         .store  = veth_pool_store,
 };
diff --git a/drivers/net/iseries_veth.c b/drivers/net/iseries_veth.c
index 966de5d69521..e6e972d9b7ca 100644
--- a/drivers/net/iseries_veth.c
+++ b/drivers/net/iseries_veth.c
@@ -384,7 +384,7 @@ static struct attribute *veth_cnx_default_attrs[] = {
         NULL
 };
 
-static struct sysfs_ops veth_cnx_sysfs_ops = {
+static const struct sysfs_ops veth_cnx_sysfs_ops = {
                 .show = veth_cnx_attribute_show
 };
 
@@ -441,7 +441,7 @@ static struct attribute *veth_port_default_attrs[] = {
         NULL
 };
 
-static struct sysfs_ops veth_port_sysfs_ops = {
+static const struct sysfs_ops veth_port_sysfs_ops = {
         .show = veth_port_attribute_show
 };
 
diff --git a/drivers/parisc/pdc_stable.c b/drivers/parisc/pdc_stable.c
index 0bc5d474b168..1062b8ffe244 100644
--- a/drivers/parisc/pdc_stable.c
+++ b/drivers/parisc/pdc_stable.c
@@ -481,7 +481,7 @@ pdcspath_attr_store(struct kobject *kobj, struct attribute *attr,
         return ret;
 }
 
-static struct sysfs_ops pdcspath_attr_ops = {
+static const struct sysfs_ops pdcspath_attr_ops = {
         .show = pdcspath_attr_show,
         .store = pdcspath_attr_store,
 };
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index 712250f5874a..26301cb25e7f 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -288,9 +288,9 @@ void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
                         next = dev->bus_list.next;
 
                 /* Run device routines with the device locked */
-                down(&dev->dev.sem);
+                device_lock(&dev->dev);
                 retval = cb(dev, userdata);
-                up(&dev->dev.sem);
+                device_unlock(&dev->dev);
                 if (retval)
                         break;
         }
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 6151389fd903..0a894efd4b9b 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -73,7 +73,7 @@ static void legacy_release(struct kobject *kobj)
 }
 
 static struct kobj_type legacy_ktype = {
-        .sysfs_ops = &(struct sysfs_ops){
+        .sysfs_ops = &(const struct sysfs_ops){
                 .store = legacy_store, .show = legacy_show
         },
         .release = &legacy_release,
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index 807224ec8351..de296452c957 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -642,6 +642,7 @@ void pci_create_legacy_files(struct pci_bus *b)
         if (!b->legacy_io)
                 goto kzalloc_err;
 
+        sysfs_bin_attr_init(b->legacy_io);
         b->legacy_io->attr.name = "legacy_io";
         b->legacy_io->size = 0xffff;
         b->legacy_io->attr.mode = S_IRUSR | S_IWUSR;
@@ -654,6 +655,7 @@ void pci_create_legacy_files(struct pci_bus *b)
                 goto legacy_io_err;
 
         /* Allocated above after the legacy_io struct */
+        sysfs_bin_attr_init(b->legacy_mem);
         b->legacy_mem = b->legacy_io + 1;
         b->legacy_mem->attr.name = "legacy_mem";
         b->legacy_mem->size = 1024*1024;
@@ -800,6 +802,7 @@ static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
         if (res_attr) {
                 char *res_attr_name = (char *)(res_attr + 1);
 
+                sysfs_bin_attr_init(res_attr);
                 if (write_combine) {
                         pdev->res_attr_wc[num] = res_attr;
                         sprintf(res_attr_name, "resource%d_wc", num);
@@ -972,6 +975,7 @@ static int pci_create_capabilities_sysfs(struct pci_dev *dev)
                 if (!attr)
                         return -ENOMEM;
 
+                sysfs_bin_attr_init(attr);
                 attr->size = dev->vpd->len;
                 attr->attr.name = "vpd";
                 attr->attr.mode = S_IRUSR | S_IWUSR;
@@ -1038,6 +1042,7 @@ int __must_check pci_create_sysfs_dev_files (struct pci_dev *pdev)
                         retval = -ENOMEM;
                         goto err_resource_files;
                 }
+                sysfs_bin_attr_init(attr);
                 attr->size = rom_size;
                 attr->attr.name = "rom";
                 attr->attr.mode = S_IRUSR;
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 77b493b3d97b..cb1dd5f4988c 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1583,8 +1583,10 @@ void pci_pm_init(struct pci_dev *dev)
         int pm;
         u16 pmc;
 
+        pm_runtime_forbid(&dev->dev);
         device_enable_async_suspend(&dev->dev);
         dev->wakeup_prepared = false;
+
         dev->pm_cap = 0;
 
         /* find PCI PM capability in list */
@@ -2296,35 +2298,6 @@ void pci_msi_off(struct pci_dev *dev)
         }
 }
 
-#ifndef HAVE_ARCH_PCI_SET_DMA_MASK
-/*
- * These can be overridden by arch-specific implementations
- */
-int
-pci_set_dma_mask(struct pci_dev *dev, u64 mask)
-{
-        if (!pci_dma_supported(dev, mask))
-                return -EIO;
-
-        dev->dma_mask = mask;
-        dev_dbg(&dev->dev, "using %dbit DMA mask\n", fls64(mask));
-
-        return 0;
-}
-    
-int
-pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
-{
-        if (!pci_dma_supported(dev, mask))
-                return -EIO;
-
-        dev->dev.coherent_dma_mask = mask;
-        dev_dbg(&dev->dev, "using %dbit consistent DMA mask\n", fls64(mask));
-
-        return 0;
-}
-#endif
-
 #ifndef HAVE_ARCH_PCI_SET_DMA_MAX_SEGMENT_SIZE
 int pci_set_dma_max_seg_size(struct pci_dev *dev, unsigned int size)
 {
@@ -2486,7 +2459,7 @@ static int pci_dev_reset(struct pci_dev *dev, int probe)
         if (!probe) {
                 pci_block_user_cfg_access(dev);
                 /* block PM suspend, driver probe, etc. */
-                down(&dev->dev.sem);
+                device_lock(&dev->dev);
         }
 
         rc = pci_dev_specific_reset(dev, probe);
@@ -2508,7 +2481,7 @@ static int pci_dev_reset(struct pci_dev *dev, int probe)
         rc = pci_parent_bus_reset(dev, probe);
 done:
         if (!probe) {
-                up(&dev->dev.sem);
+                device_unlock(&dev->dev);
                 pci_unblock_user_cfg_access(dev);
         }
 
@@ -3066,8 +3039,6 @@ EXPORT_SYMBOL(pci_set_mwi);
 EXPORT_SYMBOL(pci_try_set_mwi);
 EXPORT_SYMBOL(pci_clear_mwi);
 EXPORT_SYMBOL_GPL(pci_intx);
-EXPORT_SYMBOL(pci_set_dma_mask);
-EXPORT_SYMBOL(pci_set_consistent_dma_mask);
 EXPORT_SYMBOL(pci_assign_resource);
 EXPORT_SYMBOL(pci_find_parent_resource);
 EXPORT_SYMBOL(pci_select_bars);
diff --git a/drivers/pci/slot.c b/drivers/pci/slot.c
index 49c9e6c9779a..f75a44d37fbe 100644
--- a/drivers/pci/slot.c
+++ b/drivers/pci/slot.c
@@ -29,7 +29,7 @@ static ssize_t pci_slot_attr_store(struct kobject *kobj,
         return attribute->store ? attribute->store(slot, buf, len) : -EIO;
 }
 
-static struct sysfs_ops pci_slot_sysfs_ops = {
+static const struct sysfs_ops pci_slot_sysfs_ops = {
         .show = pci_slot_attr_show,
         .store = pci_slot_attr_store,
 };
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index 0f98be4450b7..ad93ebd7b2a2 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -971,9 +971,9 @@ static int runtime_suspend(struct device *dev)
 {
         int rc;
 
-        down(&dev->sem);
+        device_lock(dev);
         rc = pcmcia_dev_suspend(dev, PMSG_SUSPEND);
-        up(&dev->sem);
+        device_unlock(dev);
         return rc;
 }
 
@@ -981,9 +981,9 @@ static int runtime_resume(struct device *dev)
 {
         int rc;
 
-        down(&dev->sem);
+        device_lock(dev);
         rc = pcmcia_dev_resume(dev);
-        up(&dev->sem);
+        device_unlock(dev);
         return rc;
 }
 
diff --git a/drivers/pcmcia/sa1111_generic.c b/drivers/pcmcia/sa1111_generic.c
index de6bc333d299..db79ca61cf96 100644
--- a/drivers/pcmcia/sa1111_generic.c
+++ b/drivers/pcmcia/sa1111_generic.c
@@ -21,11 +21,18 @@
 
 #include "sa1111_generic.h"
 
+#define IDX_IRQ_S0_READY_NINT   (0)
+#define IDX_IRQ_S0_CD_VALID     (1)
+#define IDX_IRQ_S0_BVD1_STSCHG  (2)
+#define IDX_IRQ_S1_READY_NINT   (3)
+#define IDX_IRQ_S1_CD_VALID     (4)
+#define IDX_IRQ_S1_BVD1_STSCHG  (5)
+
 static struct pcmcia_irqs irqs[] = {
-        { 0, IRQ_S0_CD_VALID,    "SA1111 PCMCIA card detect" },
-        { 0, IRQ_S0_BVD1_STSCHG, "SA1111 PCMCIA BVD1"        },
-        { 1, IRQ_S1_CD_VALID,    "SA1111 CF card detect"     },
-        { 1, IRQ_S1_BVD1_STSCHG, "SA1111 CF BVD1"            },
+        { 0, NO_IRQ, "SA1111 PCMCIA card detect" },
+        { 0, NO_IRQ, "SA1111 PCMCIA BVD1"        },
+        { 1, NO_IRQ, "SA1111 CF card detect"     },
+        { 1, NO_IRQ, "SA1111 CF BVD1"            },
 };
 
 static int sa1111_pcmcia_hw_init(struct soc_pcmcia_socket *skt)
@@ -136,7 +143,9 @@ int sa1111_pcmcia_add(struct sa1111_dev *dev, struct pcmcia_low_level *ops,
                 s->soc.ops = ops;
                 s->soc.socket.owner = ops->owner;
                 s->soc.socket.dev.parent = &dev->dev;
-                s->soc.socket.pci_irq = s->soc.nr ? IRQ_S1_READY_NINT : IRQ_S0_READY_NINT;
+                s->soc.socket.pci_irq = s->soc.nr ?
+                                dev->irq[IDX_IRQ_S0_READY_NINT] :
+                                dev->irq[IDX_IRQ_S1_READY_NINT];
                 s->dev = dev;
 
                 ret = add(&s->soc);
@@ -162,6 +171,12 @@ static int pcmcia_probe(struct sa1111_dev *dev)
 
         base = dev->mapbase;
 
+        /* Initialize PCMCIA IRQs */
+        irqs[0].irq = dev->irq[IDX_IRQ_S0_CD_VALID];
+        irqs[1].irq = dev->irq[IDX_IRQ_S0_BVD1_STSCHG];
+        irqs[2].irq = dev->irq[IDX_IRQ_S1_CD_VALID];
+        irqs[3].irq = dev->irq[IDX_IRQ_S1_BVD1_STSCHG];
+
         /*
          * Initialise the suspend state.
          */
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index cd2ee6fce1b4..e631dbeafd79 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -150,6 +150,7 @@ config MSI_LAPTOP
         tristate "MSI Laptop Extras"
         depends on ACPI
         depends on BACKLIGHT_CLASS_DEVICE
+        depends on RFKILL
         ---help---
           This is a driver for laptops built by MSI (MICRO-STAR
           INTERNATIONAL):
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 3aa57da8b43b..7ccf33c08967 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -57,7 +57,7 @@ enum hp_wmi_radio {
         HPWMI_WWAN = 2,
 };
 
-static int __init hp_wmi_bios_setup(struct platform_device *device);
+static int __devinit hp_wmi_bios_setup(struct platform_device *device);
 static int __exit hp_wmi_bios_remove(struct platform_device *device);
 static int hp_wmi_resume_handler(struct device *device);
 
@@ -447,7 +447,7 @@ static void cleanup_sysfs(struct platform_device *device)
         device_remove_file(&device->dev, &dev_attr_tablet);
 }
 
-static int __init hp_wmi_bios_setup(struct platform_device *device)
+static int __devinit hp_wmi_bios_setup(struct platform_device *device)
 {
         int err;
         int wireless = hp_wmi_perform_query(HPWMI_WIRELESS_QUERY, 0, 0);
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 759763d18e4c..c2b05da4289a 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -58,6 +58,7 @@
 #include <linux/dmi.h>
 #include <linux/backlight.h>
 #include <linux/platform_device.h>
+#include <linux/rfkill.h>
 
 #define MSI_DRIVER_VERSION "0.5"
 
@@ -66,6 +67,20 @@
 #define MSI_EC_COMMAND_WIRELESS 0x10
 #define MSI_EC_COMMAND_LCD_LEVEL 0x11
 
+#define MSI_STANDARD_EC_COMMAND_ADDRESS 0x2e
+#define MSI_STANDARD_EC_BLUETOOTH_MASK  (1 << 0)
+#define MSI_STANDARD_EC_WEBCAM_MASK     (1 << 1)
+#define MSI_STANDARD_EC_WLAN_MASK       (1 << 3)
+#define MSI_STANDARD_EC_3G_MASK         (1 << 4)
+
+/* For set SCM load flag to disable BIOS fn key */
+#define MSI_STANDARD_EC_SCM_LOAD_ADDRESS        0x2d
+#define MSI_STANDARD_EC_SCM_LOAD_MASK           (1 << 0)
+
+static int msi_laptop_resume(struct platform_device *device);
+
+#define MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS  0x2f
+
 static int force;
 module_param(force, bool, 0);
 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
@@ -74,6 +89,23 @@ static int auto_brightness;
 module_param(auto_brightness, int, 0);
 MODULE_PARM_DESC(auto_brightness, "Enable automatic brightness control (0: disabled; 1: enabled; 2: don't touch)");
 
+static bool old_ec_model;
+static int wlan_s, bluetooth_s, threeg_s;
+static int threeg_exists;
+
+/* Some MSI 3G netbook only have one fn key to control Wlan/Bluetooth/3G,
+ * those netbook will load the SCM (windows app) to disable the original
+ * Wlan/Bluetooth control by BIOS when user press fn key, then control
+ * Wlan/Bluetooth/3G by SCM (software control by OS). Without SCM, user
+ * cann't on/off 3G module on those 3G netbook.
+ * On Linux, msi-laptop driver will do the same thing to disable the
+ * original BIOS control, then might need use HAL or other userland
+ * application to do the software control that simulate with SCM.
+ * e.g. MSI N034 netbook
+ */
+static bool load_scm_model;
+static struct rfkill *rfk_wlan, *rfk_bluetooth, *rfk_threeg;
+
 /* Hardware access */
 
 static int set_lcd_level(int level)
@@ -130,6 +162,35 @@ static int set_auto_brightness(int enable)
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2, NULL, 0, 1);
 }
 
+static ssize_t set_device_state(const char *buf, size_t count, u8 mask)
+{
+        int status;
+        u8 wdata = 0, rdata;
+        int result;
+
+        if (sscanf(buf, "%i", &status) != 1 || (status < 0 || status > 1))
+                return -EINVAL;
+
+        /* read current device state */
+        result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata);
+        if (result < 0)
+                return -EINVAL;
+
+        if (!!(rdata & mask) != status) {
+                /* reverse device bit */
+                if (rdata & mask)
+                        wdata = rdata & ~mask;
+                else
+                        wdata = rdata | mask;
+
+                result = ec_write(MSI_STANDARD_EC_COMMAND_ADDRESS, wdata);
+                if (result < 0)
+                        return -EINVAL;
+        }
+
+        return count;
+}
+
 static int get_wireless_state(int *wlan, int *bluetooth)
 {
         u8 wdata = 0, rdata;
@@ -148,6 +209,38 @@ static int get_wireless_state(int *wlan, int *bluetooth)
         return 0;
 }
 
+static int get_wireless_state_ec_standard(void)
+{
+        u8 rdata;
+        int result;
+
+        result = ec_read(MSI_STANDARD_EC_COMMAND_ADDRESS, &rdata);
+        if (result < 0)
+                return -1;
+
+        wlan_s = !!(rdata & MSI_STANDARD_EC_WLAN_MASK);
+
+        bluetooth_s = !!(rdata & MSI_STANDARD_EC_BLUETOOTH_MASK);
+
+        threeg_s = !!(rdata & MSI_STANDARD_EC_3G_MASK);
+
+        return 0;
+}
+
+static int get_threeg_exists(void)
+{
+        u8 rdata;
+        int result;
+
+        result = ec_read(MSI_STANDARD_EC_DEVICES_EXISTS_ADDRESS, &rdata);
+        if (result < 0)
+                return -1;
+
+        threeg_exists = !!(rdata & MSI_STANDARD_EC_3G_MASK);
+
+        return 0;
+}
+
 /* Backlight device stuff */
 
 static int bl_get_brightness(struct backlight_device *b)
@@ -176,26 +269,71 @@ static ssize_t show_wlan(struct device *dev,
 
         int ret, enabled;
 
-        ret = get_wireless_state(&enabled, NULL);
+        if (old_ec_model) {
+                ret = get_wireless_state(&enabled, NULL);
+        } else {
+                ret = get_wireless_state_ec_standard();
+                enabled = wlan_s;
+        }
         if (ret < 0)
                 return ret;
 
         return sprintf(buf, "%i\n", enabled);
 }
 
+static ssize_t store_wlan(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        return set_device_state(buf, count, MSI_STANDARD_EC_WLAN_MASK);
+}
+
 static ssize_t show_bluetooth(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
 
         int ret, enabled;
 
-        ret = get_wireless_state(NULL, &enabled);
+        if (old_ec_model) {
+                ret = get_wireless_state(NULL, &enabled);
+        } else {
+                ret = get_wireless_state_ec_standard();
+                enabled = bluetooth_s;
+        }
         if (ret < 0)
                 return ret;
 
         return sprintf(buf, "%i\n", enabled);
 }
 
+static ssize_t store_bluetooth(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        return set_device_state(buf, count, MSI_STANDARD_EC_BLUETOOTH_MASK);
+}
+
+static ssize_t show_threeg(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+
+        int ret;
+
+        /* old msi ec not support 3G */
+        if (old_ec_model)
+                return -1;
+
+        ret = get_wireless_state_ec_standard();
+        if (ret < 0)
+                return ret;
+
+        return sprintf(buf, "%i\n", threeg_s);
+}
+
+static ssize_t store_threeg(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        return set_device_state(buf, count, MSI_STANDARD_EC_3G_MASK);
+}
+
 static ssize_t show_lcd_level(struct device *dev,
         struct device_attribute *attr, char *buf)
 {
@@ -258,6 +396,7 @@ static DEVICE_ATTR(lcd_level, 0644, show_lcd_level, store_lcd_level);
 static DEVICE_ATTR(auto_brightness, 0644, show_auto_brightness, store_auto_brightness);
 static DEVICE_ATTR(bluetooth, 0444, show_bluetooth, NULL);
 static DEVICE_ATTR(wlan, 0444, show_wlan, NULL);
+static DEVICE_ATTR(threeg, 0444, show_threeg, NULL);
 
 static struct attribute *msipf_attributes[] = {
         &dev_attr_lcd_level.attr,
@@ -275,7 +414,8 @@ static struct platform_driver msipf_driver = {
         .driver = {
                 .name = "msi-laptop-pf",
                 .owner = THIS_MODULE,
-        }
+        },
+        .resume = msi_laptop_resume,
 };
 
 static struct platform_device *msipf_device;
@@ -332,6 +472,192 @@ static struct dmi_system_id __initdata msi_dmi_table[] = {
         { }
 };
 
+static struct dmi_system_id __initdata msi_load_scm_models_dmi_table[] = {
+        {
+                .ident = "MSI N034",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR,
+                                "MICRO-STAR INTERNATIONAL CO., LTD"),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "MS-N034"),
+                        DMI_MATCH(DMI_CHASSIS_VENDOR,
+                        "MICRO-STAR INTERNATIONAL CO., LTD")
+                },
+                .callback = dmi_check_cb
+        },
+        { }
+};
+
+static int rfkill_bluetooth_set(void *data, bool blocked)
+{
+        /* Do something with blocked...*/
+        /*
+         * blocked == false is on
+         * blocked == true is off
+         */
+        if (blocked)
+                set_device_state("0", 0, MSI_STANDARD_EC_BLUETOOTH_MASK);
+        else
+                set_device_state("1", 0, MSI_STANDARD_EC_BLUETOOTH_MASK);
+
+        return 0;
+}
+
+static int rfkill_wlan_set(void *data, bool blocked)
+{
+        if (blocked)
+                set_device_state("0", 0, MSI_STANDARD_EC_WLAN_MASK);
+        else
+                set_device_state("1", 0, MSI_STANDARD_EC_WLAN_MASK);
+
+        return 0;
+}
+
+static int rfkill_threeg_set(void *data, bool blocked)
+{
+        if (blocked)
+                set_device_state("0", 0, MSI_STANDARD_EC_3G_MASK);
+        else
+                set_device_state("1", 0, MSI_STANDARD_EC_3G_MASK);
+
+        return 0;
+}
+
+static struct rfkill_ops rfkill_bluetooth_ops = {
+        .set_block = rfkill_bluetooth_set
+};
+
+static struct rfkill_ops rfkill_wlan_ops = {
+        .set_block = rfkill_wlan_set
+};
+
+static struct rfkill_ops rfkill_threeg_ops = {
+        .set_block = rfkill_threeg_set
+};
+
+static void rfkill_cleanup(void)
+{
+        if (rfk_bluetooth) {
+                rfkill_unregister(rfk_bluetooth);
+                rfkill_destroy(rfk_bluetooth);
+        }
+
+        if (rfk_threeg) {
+                rfkill_unregister(rfk_threeg);
+                rfkill_destroy(rfk_threeg);
+        }
+
+        if (rfk_wlan) {
+                rfkill_unregister(rfk_wlan);
+                rfkill_destroy(rfk_wlan);
+        }
+}
+
+static int rfkill_init(struct platform_device *sdev)
+{
+        /* add rfkill */
+        int retval;
+
+        rfk_bluetooth = rfkill_alloc("msi-bluetooth", &sdev->dev,
+                                RFKILL_TYPE_BLUETOOTH,
+                                &rfkill_bluetooth_ops, NULL);
+        if (!rfk_bluetooth) {
+                retval = -ENOMEM;
+                goto err_bluetooth;
+        }
+        retval = rfkill_register(rfk_bluetooth);
+        if (retval)
+                goto err_bluetooth;
+
+        rfk_wlan = rfkill_alloc("msi-wlan", &sdev->dev, RFKILL_TYPE_WLAN,
+                                &rfkill_wlan_ops, NULL);
+        if (!rfk_wlan) {
+                retval = -ENOMEM;
+                goto err_wlan;
+        }
+        retval = rfkill_register(rfk_wlan);
+        if (retval)
+                goto err_wlan;
+
+        if (threeg_exists) {
+                rfk_threeg = rfkill_alloc("msi-threeg", &sdev->dev,
+                                RFKILL_TYPE_WWAN, &rfkill_threeg_ops, NULL);
+                if (!rfk_threeg) {
+                        retval = -ENOMEM;
+                        goto err_threeg;
+                }
+                retval = rfkill_register(rfk_threeg);
+                if (retval)
+                        goto err_threeg;
+        }
+
+        return 0;
+
+err_threeg:
+        rfkill_destroy(rfk_threeg);
+        if (rfk_wlan)
+                rfkill_unregister(rfk_wlan);
+err_wlan:
+        rfkill_destroy(rfk_wlan);
+        if (rfk_bluetooth)
+                rfkill_unregister(rfk_bluetooth);
+err_bluetooth:
+        rfkill_destroy(rfk_bluetooth);
+
+        return retval;
+}
+
+static int msi_laptop_resume(struct platform_device *device)
+{
+        u8 data;
+        int result;
+
+        if (!load_scm_model)
+                return 0;
+
+        /* set load SCM to disable hardware control by fn key */
+        result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data);
+        if (result < 0)
+                return result;
+
+        result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS,
+                data | MSI_STANDARD_EC_SCM_LOAD_MASK);
+        if (result < 0)
+                return result;
+
+        return 0;
+}
+
+static int load_scm_model_init(struct platform_device *sdev)
+{
+        u8 data;
+        int result;
+
+        /* allow userland write sysfs file  */
+        dev_attr_bluetooth.store = store_bluetooth;
+        dev_attr_wlan.store = store_wlan;
+        dev_attr_threeg.store = store_threeg;
+        dev_attr_bluetooth.attr.mode |= S_IWUSR;
+        dev_attr_wlan.attr.mode |= S_IWUSR;
+        dev_attr_threeg.attr.mode |= S_IWUSR;
+
+        /* disable hardware control by fn key */
+        result = ec_read(MSI_STANDARD_EC_SCM_LOAD_ADDRESS, &data);
+        if (result < 0)
+                return result;
+
+        result = ec_write(MSI_STANDARD_EC_SCM_LOAD_ADDRESS,
+                data | MSI_STANDARD_EC_SCM_LOAD_MASK);
+        if (result < 0)
+                return result;
+
+        /* initial rfkill */
+        result = rfkill_init(sdev);
+        if (result < 0)
+                return result;
+
+        return 0;
+}
+
 static int __init msi_init(void)
 {
         int ret;
@@ -339,8 +665,14 @@ static int __init msi_init(void)
         if (acpi_disabled)
                 return -ENODEV;
 
-        if (!force && !dmi_check_system(msi_dmi_table))
-                return -ENODEV;
+        if (force || dmi_check_system(msi_dmi_table))
+                old_ec_model = 1;
+
+        if (!old_ec_model)
+                get_threeg_exists();
+
+        if (!old_ec_model && dmi_check_system(msi_load_scm_models_dmi_table))
+                load_scm_model = 1;
 
         if (auto_brightness < 0 || auto_brightness > 2)
                 return -EINVAL;
@@ -374,10 +706,23 @@ static int __init msi_init(void)
         if (ret)
                 goto fail_platform_device1;
 
+        if (load_scm_model && (load_scm_model_init(msipf_device) < 0)) {
+                ret = -EINVAL;
+                goto fail_platform_device1;
+        }
+
         ret = sysfs_create_group(&msipf_device->dev.kobj, &msipf_attribute_group);
         if (ret)
                 goto fail_platform_device2;
 
+        if (!old_ec_model) {
+                if (threeg_exists)
+                        ret = device_create_file(&msipf_device->dev,
+                                                &dev_attr_threeg);
+                if (ret)
+                        goto fail_platform_device2;
+        }
+
         /* Disable automatic brightness control by default because
          * this module was probably loaded to do brightness control in
          * software. */
@@ -412,10 +757,14 @@ static void __exit msi_cleanup(void)
 {
 
         sysfs_remove_group(&msipf_device->dev.kobj, &msipf_attribute_group);
+        if (!old_ec_model && threeg_exists)
+                device_remove_file(&msipf_device->dev, &dev_attr_threeg);
         platform_device_unregister(msipf_device);
         platform_driver_unregister(&msipf_driver);
         backlight_device_unregister(msibl_device);
 
+        rfkill_cleanup();
+
         /* Enable automatic brightness control again */
         if (auto_brightness != 2)
                 set_auto_brightness(1);
@@ -435,3 +784,4 @@ MODULE_ALIAS("dmi:*:svnMICRO-STARINT'LCO.,LTD:pnMS-1013:pvr0131*:cvnMICRO-STARIN
 MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1058:pvr0581:rvnMSI:rnMS-1058:*:ct10:*");
 MODULE_ALIAS("dmi:*:svnMicro-StarInternational:pnMS-1412:*:rvnMSI:rnMS-1412:*:cvnMICRO-STARINT'LCO.,LTD:ct10:*");
 MODULE_ALIAS("dmi:*:svnNOTEBOOK:pnSAM2000:pvr0131*:cvnMICRO-STARINT'LCO.,LTD:ct10:*");
+MODULE_ALIAS("dmi:*:svnMICRO-STARINTERNATIONAL*:pnMS-N034:*");
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
index cc2eb8edb514..1afe4e03440f 100644
--- a/drivers/pps/Kconfig
+++ b/drivers/pps/Kconfig
@@ -30,4 +30,6 @@ config PPS_DEBUG
           messages to the system log.  Select this if you are having a
           problem with PPS support and want to see more of what is going on.
 
+source drivers/pps/clients/Kconfig
+
 endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
index 19ea582f431d..98960ddd3188 100644
--- a/drivers/pps/Makefile
+++ b/drivers/pps/Makefile
@@ -4,5 +4,6 @@
 
 pps_core-y                      := pps.o kapi.o sysfs.o
 obj-$(CONFIG_PPS)               := pps_core.o
+obj-y                           += clients/
 
 ccflags-$(CONFIG_PPS_DEBUG) := -DDEBUG
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
new file mode 100644
index 000000000000..4e801bd7254f
--- /dev/null
+++ b/drivers/pps/clients/Kconfig
@@ -0,0 +1,25 @@
+#
+# PPS clients configuration
+#
+
+if PPS
+
+comment "PPS clients support"
+
+config PPS_CLIENT_KTIMER
+        tristate "Kernel timer client (Testing client, use for debug)"
+        help
+          If you say yes here you get support for a PPS debugging client
+          which uses a kernel timer to generate the PPS signal.
+
+          This driver can also be built as a module.  If so, the module
+          will be called pps-ktimer.
+
+config PPS_CLIENT_LDISC
+        tristate "PPS line discipline"
+        depends on PPS
+        help
+          If you say yes here you get support for a PPS source connected
+          with the CD (Carrier Detect) pin of your serial port.
+
+endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
new file mode 100644
index 000000000000..812c9b19b430
--- /dev/null
+++ b/drivers/pps/clients/Makefile
@@ -0,0 +1,10 @@
+#
+# Makefile for PPS clients.
+#
+
+obj-$(CONFIG_PPS_CLIENT_KTIMER) += pps-ktimer.o
+obj-$(CONFIG_PPS_CLIENT_LDISC)  += pps-ldisc.o
+
+ifeq ($(CONFIG_PPS_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
diff --git a/drivers/pps/clients/pps-ktimer.c b/drivers/pps/clients/pps-ktimer.c
new file mode 100644
index 000000000000..e7ef5b8186d0
--- /dev/null
+++ b/drivers/pps/clients/pps-ktimer.c
@@ -0,0 +1,123 @@
+/*
+ * pps-ktimer.c -- kernel timer test client
+ *
+ *
+ * Copyright (C) 2005-2006   Rodolfo Giometti <giometti@linux.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
+ *   (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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/timer.h>
+#include <linux/pps_kernel.h>
+
+/*
+ * Global variables
+ */
+
+static int source;
+static struct timer_list ktimer;
+
+/*
+ * The kernel timer
+ */
+
+static void pps_ktimer_event(unsigned long ptr)
+{
+        struct timespec __ts;
+        struct pps_ktime ts;
+
+        /* First of all we get the time stamp... */
+        getnstimeofday(&__ts);
+
+        pr_info("PPS event at %lu\n", jiffies);
+
+        /* ... and translate it to PPS time data struct */
+        ts.sec = __ts.tv_sec;
+        ts.nsec = __ts.tv_nsec;
+
+        pps_event(source, &ts, PPS_CAPTUREASSERT, NULL);
+
+        mod_timer(&ktimer, jiffies + HZ);
+}
+
+/*
+ * The echo function
+ */
+
+static void pps_ktimer_echo(int source, int event, void *data)
+{
+        pr_info("echo %s %s for source %d\n",
+                event & PPS_CAPTUREASSERT ? "assert" : "",
+                event & PPS_CAPTURECLEAR ? "clear" : "",
+                source);
+}
+
+/*
+ * The PPS info struct
+ */
+
+static struct pps_source_info pps_ktimer_info = {
+        .name           = "ktimer",
+        .path           = "",
+        .mode           = PPS_CAPTUREASSERT | PPS_OFFSETASSERT |
+                          PPS_ECHOASSERT |
+                          PPS_CANWAIT | PPS_TSFMT_TSPEC,
+        .echo           = pps_ktimer_echo,
+        .owner          = THIS_MODULE,
+};
+
+/*
+ * Module staff
+ */
+
+static void __exit pps_ktimer_exit(void)
+{
+        del_timer_sync(&ktimer);
+        pps_unregister_source(source);
+
+        pr_info("ktimer PPS source unregistered\n");
+}
+
+static int __init pps_ktimer_init(void)
+{
+        int ret;
+
+        ret = pps_register_source(&pps_ktimer_info,
+                                PPS_CAPTUREASSERT | PPS_OFFSETASSERT);
+        if (ret < 0) {
+                printk(KERN_ERR "cannot register ktimer source\n");
+                return ret;
+        }
+        source = ret;
+
+        setup_timer(&ktimer, pps_ktimer_event, 0);
+        mod_timer(&ktimer, jiffies + HZ);
+
+        pr_info("ktimer PPS source registered at %d\n", source);
+
+        return  0;
+}
+
+module_init(pps_ktimer_init);
+module_exit(pps_ktimer_exit);
+
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("dummy PPS source by using a kernel timer (just for debug)");
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/clients/pps-ldisc.c b/drivers/pps/clients/pps-ldisc.c
new file mode 100644
index 000000000000..8e1932d29fd4
--- /dev/null
+++ b/drivers/pps/clients/pps-ldisc.c
@@ -0,0 +1,154 @@
+/*
+ * pps-ldisc.c -- PPS line discipline
+ *
+ *
+ * Copyright (C) 2008   Rodolfo Giometti <giometti@linux.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
+ *   (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/serial_core.h>
+#include <linux/tty.h>
+#include <linux/pps_kernel.h>
+
+#define PPS_TTY_MAGIC           0x0001
+
+static void pps_tty_dcd_change(struct tty_struct *tty, unsigned int status,
+                                struct timespec *ts)
+{
+        int id = (long)tty->disc_data;
+        struct timespec __ts;
+        struct pps_ktime pps_ts;
+
+        /* First of all we get the time stamp... */
+        getnstimeofday(&__ts);
+
+        /* Does caller give us a timestamp? */
+        if (ts) {       /* Yes. Let's use it! */
+                pps_ts.sec = ts->tv_sec;
+                pps_ts.nsec = ts->tv_nsec;
+        } else {        /* No. Do it ourself! */
+                pps_ts.sec = __ts.tv_sec;
+                pps_ts.nsec = __ts.tv_nsec;
+        }
+
+        /* Now do the PPS event report */
+        pps_event(id, &pps_ts, status ? PPS_CAPTUREASSERT : PPS_CAPTURECLEAR,
+                        NULL);
+
+        pr_debug("PPS %s at %lu on source #%d\n",
+                        status ? "assert" : "clear", jiffies, id);
+}
+
+static int (*alias_n_tty_open)(struct tty_struct *tty);
+
+static int pps_tty_open(struct tty_struct *tty)
+{
+        struct pps_source_info info;
+        struct tty_driver *drv = tty->driver;
+        int index = tty->index + drv->name_base;
+        int ret;
+
+        info.owner = THIS_MODULE;
+        info.dev = NULL;
+        snprintf(info.name, PPS_MAX_NAME_LEN, "%s%d", drv->driver_name, index);
+        snprintf(info.path, PPS_MAX_NAME_LEN, "/dev/%s%d", drv->name, index);
+        info.mode = PPS_CAPTUREBOTH | \
+                        PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+                        PPS_CANWAIT | PPS_TSFMT_TSPEC;
+
+        ret = pps_register_source(&info, PPS_CAPTUREBOTH | \
+                                PPS_OFFSETASSERT | PPS_OFFSETCLEAR);
+        if (ret < 0) {
+                pr_err("cannot register PPS source \"%s\"\n", info.path);
+                return ret;
+        }
+        tty->disc_data = (void *)(long)ret;
+
+        /* Should open N_TTY ldisc too */
+        ret = alias_n_tty_open(tty);
+        if (ret < 0)
+                pps_unregister_source((long)tty->disc_data);
+
+        pr_info("PPS source #%d \"%s\" added\n", ret, info.path);
+
+        return 0;
+}
+
+static void (*alias_n_tty_close)(struct tty_struct *tty);
+
+static void pps_tty_close(struct tty_struct *tty)
+{
+        int id = (long)tty->disc_data;
+
+        pps_unregister_source(id);
+        alias_n_tty_close(tty);
+
+        pr_info("PPS source #%d removed\n", id);
+}
+
+static struct tty_ldisc_ops pps_ldisc_ops;
+
+/*
+ * Module stuff
+ */
+
+static int __init pps_tty_init(void)
+{
+        int err;
+
+        /* Inherit the N_TTY's ops */
+        n_tty_inherit_ops(&pps_ldisc_ops);
+
+        /* Save N_TTY's open()/close() methods */
+        alias_n_tty_open = pps_ldisc_ops.open;
+        alias_n_tty_close = pps_ldisc_ops.close;
+
+        /* Init PPS_TTY data */
+        pps_ldisc_ops.owner = THIS_MODULE;
+        pps_ldisc_ops.magic = PPS_TTY_MAGIC;
+        pps_ldisc_ops.name = "pps_tty";
+        pps_ldisc_ops.dcd_change = pps_tty_dcd_change;
+        pps_ldisc_ops.open = pps_tty_open;
+        pps_ldisc_ops.close = pps_tty_close;
+
+        err = tty_register_ldisc(N_PPS, &pps_ldisc_ops);
+        if (err)
+                pr_err("can't register PPS line discipline\n");
+        else
+                pr_info("PPS line discipline registered\n");
+
+        return err;
+}
+
+static void __exit pps_tty_cleanup(void)
+{
+        int err;
+
+        err = tty_unregister_ldisc(N_PPS);
+        if (err)
+                pr_err("can't unregister PPS line discipline\n");
+        else
+                pr_info("PPS line discipline removed\n");
+}
+
+module_init(pps_tty_init);
+module_exit(pps_tty_cleanup);
+
+MODULE_ALIAS_LDISC(N_PPS);
+MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>");
+MODULE_DESCRIPTION("PPS TTY device driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/rtc/hctosys.c b/drivers/rtc/hctosys.c
index 33c0e98243ee..bc90b091f195 100644
--- a/drivers/rtc/hctosys.c
+++ b/drivers/rtc/hctosys.c
@@ -22,48 +22,57 @@
  * the best guess is to add 0.5s.
  */
 
+int rtc_hctosys_ret = -ENODEV;
+
 static int __init rtc_hctosys(void)
 {
-        int err;
+        int err = -ENODEV;
         struct rtc_time tm;
+        struct timespec tv = {
+                .tv_nsec = NSEC_PER_SEC >> 1,
+        };
         struct rtc_device *rtc = rtc_class_open(CONFIG_RTC_HCTOSYS_DEVICE);
 
         if (rtc == NULL) {
-                printk("%s: unable to open rtc device (%s)\n",
+                pr_err("%s: unable to open rtc device (%s)\n",
                         __FILE__, CONFIG_RTC_HCTOSYS_DEVICE);
-                return -ENODEV;
+                goto err_open;
         }
 
         err = rtc_read_time(rtc, &tm);
-        if (err == 0) {
-                err = rtc_valid_tm(&tm);
-                if (err == 0) {
-                        struct timespec tv;
+        if (err) {
+                dev_err(rtc->dev.parent,
+                        "hctosys: unable to read the hardware clock\n");
+                goto err_read;
 
-                        tv.tv_nsec = NSEC_PER_SEC >> 1;
+        }
 
-                        rtc_tm_to_time(&tm, &tv.tv_sec);
+        err = rtc_valid_tm(&tm);
+        if (err) {
+                dev_err(rtc->dev.parent,
+                        "hctosys: invalid date/time\n");
+                goto err_invalid;
+        }
 
-                        do_settimeofday(&tv);
+        rtc_tm_to_time(&tm, &tv.tv_sec);
 
-                        dev_info(rtc->dev.parent,
-                                "setting system clock to "
-                                "%d-%02d-%02d %02d:%02d:%02d UTC (%u)\n",
-                                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
-                                tm.tm_hour, tm.tm_min, tm.tm_sec,
-                                (unsigned int) tv.tv_sec);
-                }
-                else
-                        dev_err(rtc->dev.parent,
-                                "hctosys: invalid date/time\n");
-        }
-        else
-                dev_err(rtc->dev.parent,
-                        "hctosys: unable to read the hardware clock\n");
+        do_settimeofday(&tv);
 
+        dev_info(rtc->dev.parent,
+                "setting system clock to "
+                "%d-%02d-%02d %02d:%02d:%02d UTC (%u)\n",
+                tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                tm.tm_hour, tm.tm_min, tm.tm_sec,
+                (unsigned int) tv.tv_sec);
+
+err_invalid:
+err_read:
         rtc_class_close(rtc);
 
-        return 0;
+err_open:
+        rtc_hctosys_ret = err;
+
+        return err;
 }
 
 late_initcall(rtc_hctosys);
diff --git a/drivers/rtc/rtc-sysfs.c b/drivers/rtc/rtc-sysfs.c
index 7dd23a6fc825..380083ca572f 100644
--- a/drivers/rtc/rtc-sysfs.c
+++ b/drivers/rtc/rtc-sysfs.c
@@ -107,8 +107,9 @@ rtc_sysfs_show_hctosys(struct device *dev, struct device_attribute *attr,
                 char *buf)
 {
 #ifdef CONFIG_RTC_HCTOSYS_DEVICE
-        if (strcmp(dev_name(&to_rtc_device(dev)->dev),
-                   CONFIG_RTC_HCTOSYS_DEVICE) == 0)
+        if (rtc_hctosys_ret == 0 &&
+                        strcmp(dev_name(&to_rtc_device(dev)->dev),
+                                CONFIG_RTC_HCTOSYS_DEVICE) == 0)
                 return sprintf(buf, "1\n");
         else
 #endif
diff --git a/drivers/s390/block/dasd.c b/drivers/s390/block/dasd.c
index 4951aa82e9f5..bbea90baf98f 100644
--- a/drivers/s390/block/dasd.c
+++ b/drivers/s390/block/dasd.c
@@ -26,6 +26,7 @@
 #include <asm/ebcdic.h>
 #include <asm/idals.h>
 #include <asm/itcw.h>
+#include <asm/diag.h>
 
 /* This is ugly... */
 #define PRINTK_HEADER "dasd:"
@@ -2212,6 +2213,13 @@ static int dasd_open(struct block_device *bdev, fmode_t mode)
                 goto out;
         }
 
+        if ((mode & FMODE_WRITE) &&
+            (test_bit(DASD_FLAG_DEVICE_RO, &base->flags) ||
+             (base->features & DASD_FEATURE_READONLY))) {
+                rc = -EROFS;
+                goto out;
+        }
+
         return 0;
 
 out:
@@ -2289,6 +2297,34 @@ dasd_exit(void)
  * SECTION: common functions for ccw_driver use
  */
 
+/*
+ * Is the device read-only?
+ * Note that this function does not report the setting of the
+ * readonly device attribute, but how it is configured in z/VM.
+ */
+int dasd_device_is_ro(struct dasd_device *device)
+{
+        struct ccw_dev_id dev_id;
+        struct diag210 diag_data;
+        int rc;
+
+        if (!MACHINE_IS_VM)
+                return 0;
+        ccw_device_get_id(device->cdev, &dev_id);
+        memset(&diag_data, 0, sizeof(diag_data));
+        diag_data.vrdcdvno = dev_id.devno;
+        diag_data.vrdclen = sizeof(diag_data);
+        rc = diag210(&diag_data);
+        if (rc == 0 || rc == 2) {
+                return diag_data.vrdcvfla & 0x80;
+        } else {
+                DBF_EVENT(DBF_WARNING, "diag210 failed for dev=%04x with rc=%d",
+                          dev_id.devno, rc);
+                return 0;
+        }
+}
+EXPORT_SYMBOL_GPL(dasd_device_is_ro);
+
 static void dasd_generic_auto_online(void *data, async_cookie_t cookie)
 {
         struct ccw_device *cdev = data;
diff --git a/drivers/s390/block/dasd_3990_erp.c b/drivers/s390/block/dasd_3990_erp.c
index 44796ba4eb9b..51224f76b980 100644
--- a/drivers/s390/block/dasd_3990_erp.c
+++ b/drivers/s390/block/dasd_3990_erp.c
@@ -1045,6 +1045,10 @@ dasd_3990_erp_com_rej(struct dasd_ccw_req * erp, char *sense)
 
                 erp->retries = 5;
 
+        } else if (sense[1] & SNS1_WRITE_INHIBITED) {
+                dev_err(&device->cdev->dev, "An I/O request was rejected"
+                        " because writing is inhibited\n");
+                erp = dasd_3990_erp_cleanup(erp, DASD_CQR_FAILED);
         } else {
                 /* fatal error -  set status to FAILED
                    internal error 09 - Command Reject */
diff --git a/drivers/s390/block/dasd_devmap.c b/drivers/s390/block/dasd_devmap.c
index d49766f3b940..8e23919c8704 100644
--- a/drivers/s390/block/dasd_devmap.c
+++ b/drivers/s390/block/dasd_devmap.c
@@ -742,6 +742,7 @@ dasd_ro_store(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
 {
         struct dasd_devmap *devmap;
+        struct dasd_device *device;
         int val;
         char *endp;
 
@@ -758,12 +759,14 @@ dasd_ro_store(struct device *dev, struct device_attribute *attr,
                 devmap->features |= DASD_FEATURE_READONLY;
         else
                 devmap->features &= ~DASD_FEATURE_READONLY;
-        if (devmap->device)
-                devmap->device->features = devmap->features;
-        if (devmap->device && devmap->device->block
-            && devmap->device->block->gdp)
-                set_disk_ro(devmap->device->block->gdp, val);
+        device = devmap->device;
+        if (device) {
+                device->features = devmap->features;
+                val = val || test_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+        }
         spin_unlock(&dasd_devmap_lock);
+        if (device && device->block && device->block->gdp)
+                set_disk_ro(device->block->gdp, val);
         return count;
 }
 
diff --git a/drivers/s390/block/dasd_diag.c b/drivers/s390/block/dasd_diag.c
index 6e14863f5c70..687f323cdc38 100644
--- a/drivers/s390/block/dasd_diag.c
+++ b/drivers/s390/block/dasd_diag.c
@@ -145,12 +145,10 @@ dasd_diag_erp(struct dasd_device *device)
         mdsk_term_io(device);
         rc = mdsk_init_io(device, device->block->bp_block, 0, NULL);
         if (rc == 4) {
-                if (!(device->features & DASD_FEATURE_READONLY)) {
+                if (!(test_and_set_bit(DASD_FLAG_DEVICE_RO, &device->flags)))
                         pr_warning("%s: The access mode of a DIAG device "
                                    "changed to read-only\n",
                                    dev_name(&device->cdev->dev));
-                        device->features |= DASD_FEATURE_READONLY;
-                }
                 rc = 0;
         }
         if (rc)
@@ -449,7 +447,7 @@ dasd_diag_check_device(struct dasd_device *device)
                 rc = -EIO;
         } else {
                 if (rc == 4)
-                        device->features |= DASD_FEATURE_READONLY;
+                        set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
                 pr_info("%s: New DASD with %ld byte/block, total size %ld "
                         "KB%s\n", dev_name(&device->cdev->dev),
                         (unsigned long) block->bp_block,
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 1cca21aafaba..01f4e7a34aa8 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1089,6 +1089,7 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         struct dasd_eckd_private *private;
         struct dasd_block *block;
         int is_known, rc;
+        int readonly;
 
         if (!ccw_device_is_pathgroup(device->cdev)) {
                 dev_warn(&device->cdev->dev,
@@ -1182,15 +1183,20 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
         else
                 private->real_cyl = private->rdc_data.no_cyl;
 
+        readonly = dasd_device_is_ro(device);
+        if (readonly)
+                set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+
         dev_info(&device->cdev->dev, "New DASD %04X/%02X (CU %04X/%02X) "
-                 "with %d cylinders, %d heads, %d sectors\n",
+                 "with %d cylinders, %d heads, %d sectors%s\n",
                  private->rdc_data.dev_type,
                  private->rdc_data.dev_model,
                  private->rdc_data.cu_type,
                  private->rdc_data.cu_model.model,
                  private->real_cyl,
                  private->rdc_data.trk_per_cyl,
-                 private->rdc_data.sec_per_trk);
+                 private->rdc_data.sec_per_trk,
+                 readonly ? ", read-only device" : "");
         return 0;
 
 out_err3:
@@ -2839,8 +2845,13 @@ static int dasd_symm_io(struct dasd_device *device, void __user *argp)
         char *psf_data, *rssd_result;
         struct dasd_ccw_req *cqr;
         struct ccw1 *ccw;
+        char psf0, psf1;
         int rc;
 
+        if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RAWIO))
+                return -EACCES;
+        psf0 = psf1 = 0;
+
         /* Copy parms from caller */
         rc = -EFAULT;
         if (copy_from_user(&usrparm, argp, sizeof(usrparm)))
@@ -2869,12 +2880,8 @@ static int dasd_symm_io(struct dasd_device *device, void __user *argp)
                            (void __user *)(unsigned long) usrparm.psf_data,
                            usrparm.psf_data_len))
                 goto out_free;
-
-        /* sanity check on syscall header */
-        if (psf_data[0] != 0x17 && psf_data[1] != 0xce) {
-                rc = -EINVAL;
-                goto out_free;
-        }
+        psf0 = psf_data[0];
+        psf1 = psf_data[1];
 
         /* setup CCWs for PSF + RSSD */
         cqr = dasd_smalloc_request(DASD_ECKD_MAGIC, 2 , 0, device);
@@ -2925,7 +2932,9 @@ out_free:
         kfree(rssd_result);
         kfree(psf_data);
 out:
-        DBF_DEV_EVENT(DBF_WARNING, device, "Symmetrix ioctl: rc=%d", rc);
+        DBF_DEV_EVENT(DBF_WARNING, device,
+                      "Symmetrix ioctl (0x%02x 0x%02x): rc=%d",
+                      (int) psf0, (int) psf1, rc);
         return rc;
 }
 
diff --git a/drivers/s390/block/dasd_fba.c b/drivers/s390/block/dasd_fba.c
index 0f152444ac77..37282b90eecc 100644
--- a/drivers/s390/block/dasd_fba.c
+++ b/drivers/s390/block/dasd_fba.c
@@ -124,6 +124,7 @@ dasd_fba_check_characteristics(struct dasd_device *device)
         struct dasd_fba_private *private;
         struct ccw_device *cdev = device->cdev;
         int rc;
+        int readonly;
 
         private = (struct dasd_fba_private *) device->private;
         if (!private) {
@@ -162,16 +163,21 @@ dasd_fba_check_characteristics(struct dasd_device *device)
                 return rc;
         }
 
+        readonly = dasd_device_is_ro(device);
+        if (readonly)
+                set_bit(DASD_FLAG_DEVICE_RO, &device->flags);
+
         dev_info(&device->cdev->dev,
                  "New FBA DASD %04X/%02X (CU %04X/%02X) with %d MB "
-                 "and %d B/blk\n",
+                 "and %d B/blk%s\n",
                  cdev->id.dev_type,
                  cdev->id.dev_model,
                  cdev->id.cu_type,
                  cdev->id.cu_model,
                  ((private->rdc_data.blk_bdsa *
                    (private->rdc_data.blk_size >> 9)) >> 11),
-                 private->rdc_data.blk_size);
+                 private->rdc_data.blk_size,
+                 readonly ? ", read-only device" : "");
         return 0;
 }
 
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index 94f92a1247f2..30a1ca3d08b7 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -70,7 +70,8 @@ int dasd_gendisk_alloc(struct dasd_block *block)
         }
         len += sprintf(gdp->disk_name + len, "%c", 'a'+(base->devindex%26));
 
-        if (block->base->features & DASD_FEATURE_READONLY)
+        if (base->features & DASD_FEATURE_READONLY ||
+            test_bit(DASD_FLAG_DEVICE_RO, &base->flags))
                 set_disk_ro(gdp, 1);
         gdp->private_data = block;
         gdp->queue = block->request_queue;
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index ed73ce550822..a91d4a97d4f2 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -436,6 +436,10 @@ struct dasd_block {
 #define DASD_FLAG_OFFLINE       3       /* device is in offline processing */
 #define DASD_FLAG_EER_SNSS      4       /* A SNSS is required */
 #define DASD_FLAG_EER_IN_USE    5       /* A SNSS request is running */
+#define DASD_FLAG_DEVICE_RO     6       /* The device itself is read-only. Don't
+                                         * confuse this with the user specified
+                                         * read-only feature.
+                                         */
 
 void dasd_put_device_wake(struct dasd_device *);
 
@@ -609,6 +613,9 @@ char *dasd_get_sense(struct irb *);
 void dasd_device_set_stop_bits(struct dasd_device *, int);
 void dasd_device_remove_stop_bits(struct dasd_device *, int);
 
+int dasd_device_is_ro(struct dasd_device *);
+
+
 /* externals in dasd_devmap.c */
 extern int dasd_max_devindex;
 extern int dasd_probeonly;
diff --git a/drivers/s390/block/dasd_ioctl.c b/drivers/s390/block/dasd_ioctl.c
index 7039d9cf0fb4..3479f8158a1b 100644
--- a/drivers/s390/block/dasd_ioctl.c
+++ b/drivers/s390/block/dasd_ioctl.c
@@ -199,7 +199,8 @@ dasd_ioctl_format(struct block_device *bdev, void __user *argp)
         if (!argp)
                 return -EINVAL;
 
-        if (block->base->features & DASD_FEATURE_READONLY)
+        if (block->base->features & DASD_FEATURE_READONLY ||
+            test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags))
                 return -EROFS;
         if (copy_from_user(&fdata, argp, sizeof(struct format_data_t)))
                 return -EFAULT;
@@ -349,7 +350,8 @@ dasd_ioctl_set_ro(struct block_device *bdev, void __user *argp)
                 return -EINVAL;
         if (get_user(intval, (int __user *)argp))
                 return -EFAULT;
-
+        if (!intval && test_bit(DASD_FLAG_DEVICE_RO, &block->base->flags))
+                return -EROFS;
         set_disk_ro(bdev->bd_disk, intval);
         return dasd_set_feature(block->base->cdev, DASD_FEATURE_READONLY, intval);
 }
diff --git a/drivers/s390/cio/device.c b/drivers/s390/cio/device.c
index c6abb75c4615..6d229f3523a0 100644
--- a/drivers/s390/cio/device.c
+++ b/drivers/s390/cio/device.c
@@ -764,7 +764,7 @@ static void sch_create_and_recog_new_device(struct subchannel *sch)
 static void io_subchannel_register(struct ccw_device *cdev)
 {
         struct subchannel *sch;
-        int ret;
+        int ret, adjust_init_count = 1;
         unsigned long flags;
 
         sch = to_subchannel(cdev->dev.parent);
@@ -793,6 +793,7 @@ static void io_subchannel_register(struct ccw_device *cdev)
                                               cdev->private->dev_id.ssid,
                                               cdev->private->dev_id.devno);
                 }
+                adjust_init_count = 0;
                 goto out;
         }
         /*
@@ -818,7 +819,7 @@ out:
         cdev->private->flags.recog_done = 1;
         wake_up(&cdev->private->wait_q);
 out_err:
-        if (atomic_dec_and_test(&ccw_device_init_count))
+        if (adjust_init_count && atomic_dec_and_test(&ccw_device_init_count))
                 wake_up(&ccw_device_init_wq);
 }
 
diff --git a/drivers/s390/cio/qdio_debug.c b/drivers/s390/cio/qdio_debug.c
index c94eb2a0fa2e..6ce83f56d537 100644
--- a/drivers/s390/cio/qdio_debug.c
+++ b/drivers/s390/cio/qdio_debug.c
@@ -33,7 +33,6 @@ void qdio_allocate_dbf(struct qdio_initialize *init_data,
         DBF_HEX(&init_data->input_handler, sizeof(void *));
         DBF_HEX(&init_data->output_handler, sizeof(void *));
         DBF_HEX(&init_data->int_parm, sizeof(long));
-        DBF_HEX(&init_data->flags, sizeof(long));
         DBF_HEX(&init_data->input_sbal_addr_array, sizeof(void *));
         DBF_HEX(&init_data->output_sbal_addr_array, sizeof(void *));
         DBF_EVENT("irq:%8lx", (unsigned long)irq_ptr);
diff --git a/drivers/s390/cio/qdio_main.c b/drivers/s390/cio/qdio_main.c
index 232ef047ba34..4f8f74311778 100644
--- a/drivers/s390/cio/qdio_main.c
+++ b/drivers/s390/cio/qdio_main.c
@@ -588,10 +588,11 @@ static void qdio_kick_handler(struct qdio_q *q)
         if (q->is_input_q) {
                 qperf_inc(q, inbound_handler);
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "kih s:%02x c:%02x", start, count);
-        } else
+        } else {
                 qperf_inc(q, outbound_handler);
                 DBF_DEV_EVENT(DBF_INFO, q->irq_ptr, "koh: s:%02x c:%02x",
                               start, count);
+        }
 
         q->handler(q->irq_ptr->cdev, q->qdio_error, q->nr, start, count,
                    q->irq_ptr->int_parm);
diff --git a/drivers/s390/net/Kconfig b/drivers/s390/net/Kconfig
index cb909a5b5047..977bb4d4ed15 100644
--- a/drivers/s390/net/Kconfig
+++ b/drivers/s390/net/Kconfig
@@ -43,6 +43,16 @@ config SMSGIUCV
           Select this option if you want to be able to receive SMSG messages
           from other VM guest systems.
 
+config SMSGIUCV_EVENT
+        tristate "Deliver IUCV special messages as uevents (VM only)"
+        depends on SMSGIUCV
+        help
+          Select this option to deliver CP special messages (SMSGs) as
+          uevents.  The driver handles only those special messages that
+          start with "APP".
+
+          To compile as a module, choose M. The module name is "smsgiucv_app".
+
 config CLAW
         tristate "CLAW device support"
         depends on CCW && NETDEVICES
diff --git a/drivers/s390/net/Makefile b/drivers/s390/net/Makefile
index 6cab5a62f99e..4dfe8c1092da 100644
--- a/drivers/s390/net/Makefile
+++ b/drivers/s390/net/Makefile
@@ -6,6 +6,7 @@ ctcm-y += ctcm_main.o ctcm_fsms.o ctcm_mpc.o ctcm_sysfs.o ctcm_dbug.o
 obj-$(CONFIG_CTCM) += ctcm.o fsm.o
 obj-$(CONFIG_NETIUCV) += netiucv.o fsm.o
 obj-$(CONFIG_SMSGIUCV) += smsgiucv.o
+obj-$(CONFIG_SMSGIUCV_EVENT) += smsgiucv_app.o
 obj-$(CONFIG_LCS) += lcs.o
 obj-$(CONFIG_CLAW) += claw.o
 qeth-y += qeth_core_sys.o qeth_core_main.o qeth_core_mpc.o
diff --git a/drivers/s390/net/qeth_core_main.c b/drivers/s390/net/qeth_core_main.c
index fa8a519218ac..7d25bdd443cd 100644
--- a/drivers/s390/net/qeth_core_main.c
+++ b/drivers/s390/net/qeth_core_main.c
@@ -3805,9 +3805,6 @@ static int qeth_qdio_establish(struct qeth_card *card)
         init_data.input_handler          = card->discipline.input_handler;
         init_data.output_handler         = card->discipline.output_handler;
         init_data.int_parm               = (unsigned long) card;
-        init_data.flags                  = QDIO_INBOUND_0COPY_SBALS |
-                                           QDIO_OUTBOUND_0COPY_SBALS |
-                                           QDIO_USE_OUTBOUND_PCIS;
         init_data.input_sbal_addr_array  = (void **) in_sbal_ptrs;
         init_data.output_sbal_addr_array = (void **) out_sbal_ptrs;
 
diff --git a/drivers/s390/net/smsgiucv.c b/drivers/s390/net/smsgiucv.c
index 67f2485d2372..ecef1edee701 100644
--- a/drivers/s390/net/smsgiucv.c
+++ b/drivers/s390/net/smsgiucv.c
@@ -31,9 +31,9 @@
 
 struct smsg_callback {
         struct list_head list;
-        char *prefix;
+        const char *prefix;
         int len;
-        void (*callback)(char *from, char *str);
+        void (*callback)(const char *from, char *str);
 };
 
 MODULE_AUTHOR
@@ -100,8 +100,8 @@ static void smsg_message_pending(struct iucv_path *path,
         kfree(buffer);
 }
 
-int smsg_register_callback(char *prefix,
-                           void (*callback)(char *from, char *str))
+int smsg_register_callback(const char *prefix,
+                           void (*callback)(const char *from, char *str))
 {
         struct smsg_callback *cb;
 
@@ -117,8 +117,9 @@ int smsg_register_callback(char *prefix,
         return 0;
 }
 
-void smsg_unregister_callback(char *prefix,
-                              void (*callback)(char *from, char *str))
+void smsg_unregister_callback(const char *prefix,
+                              void (*callback)(const char *from,
+                                               char *str))
 {
         struct smsg_callback *cb, *tmp;
 
@@ -176,7 +177,7 @@ static const struct dev_pm_ops smsg_pm_ops = {
 
 static struct device_driver smsg_driver = {
         .owner = THIS_MODULE,
-        .name = "SMSGIUCV",
+        .name = SMSGIUCV_DRV_NAME,
         .bus  = &iucv_bus,
         .pm = &smsg_pm_ops,
 };
diff --git a/drivers/s390/net/smsgiucv.h b/drivers/s390/net/smsgiucv.h
index 67f5d4f8378d..149a1151608d 100644
--- a/drivers/s390/net/smsgiucv.h
+++ b/drivers/s390/net/smsgiucv.h
@@ -5,6 +5,10 @@
  * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
  */
 
-int  smsg_register_callback(char *, void (*)(char *, char *));
-void smsg_unregister_callback(char *, void (*)(char *, char *));
+#define SMSGIUCV_DRV_NAME     "SMSGIUCV"
+
+int  smsg_register_callback(const char *,
+                            void (*)(const char *, char *));
+void smsg_unregister_callback(const char *,
+                              void (*)(const char *, char *));
 
diff --git a/drivers/s390/net/smsgiucv_app.c b/drivers/s390/net/smsgiucv_app.c
new file mode 100644
index 000000000000..91579dc6a2b0
--- /dev/null
+++ b/drivers/s390/net/smsgiucv_app.c
@@ -0,0 +1,211 @@
+/*
+ * Deliver z/VM CP special messages (SMSG) as uevents.
+ *
+ * The driver registers for z/VM CP special messages with the
+ * "APP" prefix. Incoming messages are delivered to user space
+ * as uevents.
+ *
+ * Copyright IBM Corp. 2010
+ * Author(s): Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
+ *
+ */
+#define KMSG_COMPONENT          "smsgiucv_app"
+#define pr_fmt(fmt)             KMSG_COMPONENT ": " fmt
+
+#include <linux/ctype.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <net/iucv/iucv.h>
+#include "smsgiucv.h"
+
+/* prefix used for SMSG registration */
+#define SMSG_PREFIX             "APP"
+
+/* SMSG related uevent environment variables */
+#define ENV_SENDER_STR          "SMSG_SENDER="
+#define ENV_SENDER_LEN          (strlen(ENV_SENDER_STR) + 8 + 1)
+#define ENV_PREFIX_STR          "SMSG_ID="
+#define ENV_PREFIX_LEN          (strlen(ENV_PREFIX_STR) + \
+                                 strlen(SMSG_PREFIX) + 1)
+#define ENV_TEXT_STR            "SMSG_TEXT="
+#define ENV_TEXT_LEN(msg)       (strlen(ENV_TEXT_STR) + strlen((msg)) + 1)
+
+/* z/VM user ID which is permitted to send SMSGs
+ * If the value is undefined or empty (""), special messages are
+ * accepted from any z/VM user ID. */
+static char *sender;
+module_param(sender, charp, 0400);
+MODULE_PARM_DESC(sender, "z/VM user ID from which CP SMSGs are accepted");
+
+/* SMSG device representation */
+static struct device *smsg_app_dev;
+
+/* list element for queuing received messages for delivery */
+struct smsg_app_event {
+        struct list_head list;
+        char *buf;
+        char *envp[4];
+};
+
+/* queue for outgoing uevents */
+static LIST_HEAD(smsg_event_queue);
+static DEFINE_SPINLOCK(smsg_event_queue_lock);
+
+static void smsg_app_event_free(struct smsg_app_event *ev)
+{
+        kfree(ev->buf);
+        kfree(ev);
+}
+
+static struct smsg_app_event *smsg_app_event_alloc(const char *from,
+                                                   const char *msg)
+{
+        struct smsg_app_event *ev;
+
+        ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
+        if (!ev)
+                return NULL;
+
+        ev->buf = kzalloc(ENV_SENDER_LEN + ENV_PREFIX_LEN +
+                          ENV_TEXT_LEN(msg), GFP_ATOMIC);
+        if (!ev->buf) {
+                kfree(ev);
+                return NULL;
+        }
+
+        /* setting up environment pointers into buf */
+        ev->envp[0] = ev->buf;
+        ev->envp[1] = ev->envp[0] + ENV_SENDER_LEN;
+        ev->envp[2] = ev->envp[1] + ENV_PREFIX_LEN;
+        ev->envp[3] = NULL;
+
+        /* setting up environment: sender, prefix name, and message text */
+        snprintf(ev->envp[0], ENV_SENDER_LEN, ENV_SENDER_STR "%s", from);
+        snprintf(ev->envp[1], ENV_PREFIX_LEN, ENV_PREFIX_STR "%s", SMSG_PREFIX);
+        snprintf(ev->envp[2], ENV_TEXT_LEN(msg), ENV_TEXT_STR "%s", msg);
+
+        return ev;
+}
+
+static void smsg_event_work_fn(struct work_struct *work)
+{
+        LIST_HEAD(event_queue);
+        struct smsg_app_event *p, *n;
+        struct device *dev;
+
+        dev = get_device(smsg_app_dev);
+        if (!dev)
+                return;
+
+        spin_lock_bh(&smsg_event_queue_lock);
+        list_splice_init(&smsg_event_queue, &event_queue);
+        spin_unlock_bh(&smsg_event_queue_lock);
+
+        list_for_each_entry_safe(p, n, &event_queue, list) {
+                list_del(&p->list);
+                kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, p->envp);
+                smsg_app_event_free(p);
+        }
+
+        put_device(dev);
+}
+static DECLARE_WORK(smsg_event_work, smsg_event_work_fn);
+
+static void smsg_app_callback(const char *from, char *msg)
+{
+        struct smsg_app_event *se;
+
+        /* check if the originating z/VM user ID matches
+         * the configured sender. */
+        if (sender && strlen(sender) > 0 && strcmp(from, sender) != 0)
+                return;
+
+        /* get start of message text (skip prefix and leading blanks) */
+        msg += strlen(SMSG_PREFIX);
+        while (*msg && isspace(*msg))
+                msg++;
+        if (*msg == '\0')
+                return;
+
+        /* allocate event list element and its environment */
+        se = smsg_app_event_alloc(from, msg);
+        if (!se)
+                return;
+
+        /* queue event and schedule work function */
+        spin_lock(&smsg_event_queue_lock);
+        list_add_tail(&se->list, &smsg_event_queue);
+        spin_unlock(&smsg_event_queue_lock);
+
+        schedule_work(&smsg_event_work);
+        return;
+}
+
+static int __init smsgiucv_app_init(void)
+{
+        struct device_driver *smsgiucv_drv;
+        int rc;
+
+        if (!MACHINE_IS_VM)
+                return -ENODEV;
+
+        smsg_app_dev = kzalloc(sizeof(*smsg_app_dev), GFP_KERNEL);
+        if (!smsg_app_dev)
+                return -ENOMEM;
+
+        smsgiucv_drv = driver_find(SMSGIUCV_DRV_NAME, &iucv_bus);
+        if (!smsgiucv_drv) {
+                kfree(smsg_app_dev);
+                return -ENODEV;
+        }
+
+        rc = dev_set_name(smsg_app_dev, KMSG_COMPONENT);
+        if (rc) {
+                kfree(smsg_app_dev);
+                goto fail_put_driver;
+        }
+        smsg_app_dev->bus = &iucv_bus;
+        smsg_app_dev->parent = iucv_root;
+        smsg_app_dev->release = (void (*)(struct device *)) kfree;
+        smsg_app_dev->driver = smsgiucv_drv;
+        rc = device_register(smsg_app_dev);
+        if (rc) {
+                put_device(smsg_app_dev);
+                goto fail_put_driver;
+        }
+
+        /* register with the smsgiucv device driver */
+        rc = smsg_register_callback(SMSG_PREFIX, smsg_app_callback);
+        if (rc) {
+                device_unregister(smsg_app_dev);
+                goto fail_put_driver;
+        }
+
+        rc = 0;
+fail_put_driver:
+        put_driver(smsgiucv_drv);
+        return rc;
+}
+module_init(smsgiucv_app_init);
+
+static void __exit smsgiucv_app_exit(void)
+{
+        /* unregister callback */
+        smsg_unregister_callback(SMSG_PREFIX, smsg_app_callback);
+
+        /* cancel pending work and flush any queued event work */
+        cancel_work_sync(&smsg_event_work);
+        smsg_event_work_fn(&smsg_event_work);
+
+        device_unregister(smsg_app_dev);
+}
+module_exit(smsgiucv_app_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Deliver z/VM CP SMSG as uevents");
+MODULE_AUTHOR("Hendrik Brueckner <brueckner@linux.vnet.ibm.com>");
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index 71b97ff77cf0..6479273a3094 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -319,8 +319,6 @@ static void zfcp_qdio_setup_init_data(struct qdio_initialize *id,
         id->input_handler = zfcp_qdio_int_resp;
         id->output_handler = zfcp_qdio_int_req;
         id->int_parm = (unsigned long) qdio;
-        id->flags = QDIO_INBOUND_0COPY_SBALS |
-                    QDIO_OUTBOUND_0COPY_SBALS | QDIO_USE_OUTBOUND_PCIS;
         id->input_sbal_addr_array = (void **) (qdio->resp_q.sbal);
         id->output_sbal_addr_array = (void **) (qdio->req_q.sbal);
 
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 1d7a8780e00c..0d9d6f7567f5 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -595,8 +595,6 @@ static int ses_intf_add(struct device *cdev,
                 ses_dev->page10_len = len;
                 buf = NULL;
         }
-        kfree(hdr_buf);
-
         scomp = kzalloc(sizeof(struct ses_component) * components, GFP_KERNEL);
         if (!scomp)
                 goto err_free;
@@ -608,6 +606,8 @@ static int ses_intf_add(struct device *cdev,
                 goto err_free;
         }
 
+        kfree(hdr_buf);
+
         edev->scratch = ses_dev;
         for (i = 0; i < components; i++)
                 edev->component[i].scratch = scomp + i;
diff --git a/drivers/scsi/sgiwd93.c b/drivers/scsi/sgiwd93.c
index 0807b260268b..fef0e3c75b16 100644
--- a/drivers/scsi/sgiwd93.c
+++ b/drivers/scsi/sgiwd93.c
@@ -226,7 +226,7 @@ static struct scsi_host_template sgiwd93_template = {
         .use_clustering         = DISABLE_CLUSTERING,
 };
 
-static int __init sgiwd93_probe(struct platform_device *pdev)
+static int __devinit sgiwd93_probe(struct platform_device *pdev)
 {
         struct sgiwd93_platform_data *pd = pdev->dev.platform_data;
         unsigned char *wdregs = pd->wdregs;
diff --git a/drivers/scsi/sni_53c710.c b/drivers/scsi/sni_53c710.c
index 37b3359e863e..56cf0bb4ed1f 100644
--- a/drivers/scsi/sni_53c710.c
+++ b/drivers/scsi/sni_53c710.c
@@ -64,7 +64,7 @@ static struct scsi_host_template snirm710_template = {
         .module         = THIS_MODULE,
 };
 
-static int __init snirm710_probe(struct platform_device *dev)
+static int __devinit snirm710_probe(struct platform_device *dev)
 {
         unsigned long base;
         struct NCR_700_Host_Parameters *hostdata;
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 7c4ebe6ee18b..c3db16b7afa1 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -2408,6 +2408,21 @@ serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
 }
 
 static void
+serial8250_set_ldisc(struct uart_port *port)
+{
+        int line = port->line;
+
+        if (line >= port->state->port.tty->driver->num)
+                return;
+
+        if (port->state->port.tty->ldisc->ops->num == N_PPS) {
+                port->flags |= UPF_HARDPPS_CD;
+                serial8250_enable_ms(port);
+        } else
+                port->flags &= ~UPF_HARDPPS_CD;
+}
+
+static void
 serial8250_pm(struct uart_port *port, unsigned int state,
               unsigned int oldstate)
 {
@@ -2628,6 +2643,7 @@ static struct uart_ops serial8250_pops = {
         .startup        = serial8250_startup,
         .shutdown       = serial8250_shutdown,
         .set_termios    = serial8250_set_termios,
+        .set_ldisc      = serial8250_set_ldisc,
         .pm             = serial8250_pm,
         .type           = serial8250_type,
         .release_port   = serial8250_release_port,
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index d6ff73395623..f55c49475a8c 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -447,7 +447,7 @@ config SERIAL_CLPS711X_CONSOLE
 
 config SERIAL_SAMSUNG
         tristate "Samsung SoC serial support"
-        depends on ARM && PLAT_S3C
+        depends on ARM && PLAT_SAMSUNG
         select SERIAL_CORE
         help
           Support for the on-chip UARTs on the Samsung S3C24XX series CPUs,
@@ -455,11 +455,18 @@ config SERIAL_SAMSUNG
           provide all of these ports, depending on how the serial port
           pins are configured.
 
+config SERIAL_SAMSUNG_UARTS_4
+        bool
+        depends on ARM && PLAT_SAMSUNG
+        default y if CPU_S3C2443
+        help
+          Internal node for the common case of 4 Samsung compatible UARTs
+
 config SERIAL_SAMSUNG_UARTS
         int
-        depends on ARM && PLAT_S3C
+        depends on ARM && PLAT_SAMSUNG
         default 2 if ARCH_S3C2400
-        default 4 if ARCH_S5PC1XX || ARCH_S3C64XX || CPU_S3C2443
+        default 4 if SERIAL_SAMSUNG_UARTS_4
         default 3
         help
           Select the number of available UART ports for the Samsung S3C
@@ -526,20 +533,30 @@ config SERIAL_S3C24A0
           Serial port support for the Samsung S3C24A0 SoC
 
 config SERIAL_S3C6400
-        tristate "Samsung S3C6400/S3C6410 Serial port support"
-        depends on SERIAL_SAMSUNG && (CPU_S3C6400 || CPU_S3C6410)
+        tristate "Samsung S3C6400/S3C6410/S5P6440 Seria port support"
+        depends on SERIAL_SAMSUNG && (CPU_S3C6400 || CPU_S3C6410 || CPU_S5P6440)
+        select SERIAL_SAMSUNG_UARTS_4
         default y
         help
-          Serial port support for the Samsung S3C6400 and S3C6410
+          Serial port support for the Samsung S3C6400, S3C6410 and S5P6440
           SoCs
 
 config SERIAL_S5PC100
         tristate "Samsung S5PC100 Serial port support"
         depends on SERIAL_SAMSUNG && CPU_S5PC100
+        select SERIAL_SAMSUNG_UARTS_4
         default y
         help
           Serial port support for the Samsung S5PC100 SoCs
 
+config SERIAL_S5PV210
+        tristate "Samsung S5PV210 Serial port support"
+        depends on SERIAL_SAMSUNG && (CPU_S5PV210 || CPU_S5P6442)
+        select SERIAL_SAMSUNG_UARTS_4 if CPU_S5PV210
+        default y
+        help
+          Serial port support for Samsung's S5P Family of SoC's
+
 config SERIAL_MAX3100
         tristate "MAX3100 support"
         depends on SPI
@@ -996,7 +1013,7 @@ config SERIAL_IP22_ZILOG_CONSOLE
 
 config SERIAL_SH_SCI
         tristate "SuperH SCI(F) serial port support"
-        depends on HAVE_CLK && (SUPERH || H8300)
+        depends on HAVE_CLK && (SUPERH || H8300 || ARCH_SHMOBILE)
         select SERIAL_CORE
 
 config SERIAL_SH_SCI_NR_UARTS
diff --git a/drivers/serial/Makefile b/drivers/serial/Makefile
index 5548fe7df61d..6aa4723b74ee 100644
--- a/drivers/serial/Makefile
+++ b/drivers/serial/Makefile
@@ -45,6 +45,7 @@ obj-$(CONFIG_SERIAL_S3C2440) += s3c2440.o
 obj-$(CONFIG_SERIAL_S3C24A0) += s3c24a0.o
 obj-$(CONFIG_SERIAL_S3C6400) += s3c6400.o
 obj-$(CONFIG_SERIAL_S5PC100) += s3c6400.o
+obj-$(CONFIG_SERIAL_S5PV210) += s5pv210.o
 obj-$(CONFIG_SERIAL_MAX3100) += max3100.o
 obj-$(CONFIG_SERIAL_IP22_ZILOG) += ip22zilog.o
 obj-$(CONFIG_SERIAL_MUX) += mux.o
diff --git a/drivers/serial/amba-pl010.c b/drivers/serial/amba-pl010.c
index 429a8ae86933..e4b3c2c88bb6 100644
--- a/drivers/serial/amba-pl010.c
+++ b/drivers/serial/amba-pl010.c
@@ -471,6 +471,20 @@ pl010_set_termios(struct uart_port *port, struct ktermios *termios,
         spin_unlock_irqrestore(&uap->port.lock, flags);
 }
 
+static void pl010_set_ldisc(struct uart_port *port)
+{
+        int line = port->line;
+
+        if (line >= port->state->port.tty->driver->num)
+                return;
+
+        if (port->state->port.tty->ldisc->ops->num == N_PPS) {
+                port->flags |= UPF_HARDPPS_CD;
+                pl010_enable_ms(port);
+        } else
+                port->flags &= ~UPF_HARDPPS_CD;
+}
+
 static const char *pl010_type(struct uart_port *port)
 {
         return port->type == PORT_AMBA ? "AMBA" : NULL;
@@ -531,6 +545,7 @@ static struct uart_ops amba_pl010_pops = {
         .startup        = pl010_startup,
         .shutdown       = pl010_shutdown,
         .set_termios    = pl010_set_termios,
+        .set_ldisc      = pl010_set_ldisc,
         .type           = pl010_type,
         .release_port   = pl010_release_port,
         .request_port   = pl010_request_port,
diff --git a/drivers/serial/imx.c b/drivers/serial/imx.c
index d00fcf8e6c70..e579d7a1807a 100644
--- a/drivers/serial/imx.c
+++ b/drivers/serial/imx.c
@@ -440,7 +440,7 @@ static irqreturn_t imx_rxint(int irq, void *dev_id)
 
                 temp = readl(sport->port.membase + USR2);
                 if (temp & USR2_BRCD) {
-                        writel(temp | USR2_BRCD, sport->port.membase + USR2);
+                        writel(USR2_BRCD, sport->port.membase + USR2);
                         if (uart_handle_break(&sport->port))
                                 continue;
                 }
diff --git a/drivers/serial/s3c2412.c b/drivers/serial/s3c2412.c
index ce75e28e36ef..1700b1a2fb7e 100644
--- a/drivers/serial/s3c2412.c
+++ b/drivers/serial/s3c2412.c
@@ -102,6 +102,7 @@ static struct s3c24xx_uart_info s3c2412_uart_inf = {
         .name           = "Samsung S3C2412 UART",
         .type           = PORT_S3C2412,
         .fifosize       = 64,
+        .has_divslot    = 1,
         .rx_fifomask    = S3C2440_UFSTAT_RXMASK,
         .rx_fifoshift   = S3C2440_UFSTAT_RXSHIFT,
         .rx_fifofull    = S3C2440_UFSTAT_RXFULL,
diff --git a/drivers/serial/s5pv210.c b/drivers/serial/s5pv210.c
new file mode 100644
index 000000000000..8dc03837617b
--- /dev/null
+++ b/drivers/serial/s5pv210.c
@@ -0,0 +1,154 @@
+/* linux/drivers/serial/s5pv210.c
+ *
+ * Copyright (c) 2010 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com/
+ *
+ * Based on drivers/serial/s3c6400.c
+ *
+ * Driver for Samsung S5PV210 SoC UARTs.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+#include <linux/init.h>
+#include <linux/serial_core.h>
+#include <linux/serial.h>
+
+#include <asm/irq.h>
+#include <mach/hardware.h>
+#include <plat/regs-serial.h>
+#include "samsung.h"
+
+static int s5pv210_serial_setsource(struct uart_port *port,
+                                        struct s3c24xx_uart_clksrc *clk)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        if (strcmp(clk->name, "pclk") == 0)
+                ucon &= ~S5PV210_UCON_CLKMASK;
+        else if (strcmp(clk->name, "uclk1") == 0)
+                ucon |= S5PV210_UCON_CLKMASK;
+        else {
+                printk(KERN_ERR "unknown clock source %s\n", clk->name);
+                return -EINVAL;
+        }
+
+        wr_regl(port, S3C2410_UCON, ucon);
+        return 0;
+}
+
+
+static int s5pv210_serial_getsource(struct uart_port *port,
+                                        struct s3c24xx_uart_clksrc *clk)
+{
+        u32 ucon = rd_regl(port, S3C2410_UCON);
+
+        clk->divisor = 1;
+
+        switch (ucon & S5PV210_UCON_CLKMASK) {
+        case S5PV210_UCON_PCLK:
+                clk->name = "pclk";
+                break;
+        case S5PV210_UCON_UCLK:
+                clk->name = "uclk1";
+                break;
+        }
+
+        return 0;
+}
+
+static int s5pv210_serial_resetport(struct uart_port *port,
+                                        struct s3c2410_uartcfg *cfg)
+{
+        unsigned long ucon = rd_regl(port, S3C2410_UCON);
+
+        ucon &= S5PV210_UCON_CLKMASK;
+        wr_regl(port, S3C2410_UCON,  ucon | cfg->ucon);
+        wr_regl(port, S3C2410_ULCON, cfg->ulcon);
+
+        /* reset both fifos */
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon | S3C2410_UFCON_RESETBOTH);
+        wr_regl(port, S3C2410_UFCON, cfg->ufcon);
+
+        return 0;
+}
+
+#define S5PV210_UART_DEFAULT_INFO(fifo_size)                    \
+                .name           = "Samsung S5PV210 UART0",      \
+                .type           = PORT_S3C6400,                 \
+                .fifosize       = fifo_size,                    \
+                .has_divslot    = 1,                            \
+                .rx_fifomask    = S5PV210_UFSTAT_RXMASK,        \
+                .rx_fifoshift   = S5PV210_UFSTAT_RXSHIFT,       \
+                .rx_fifofull    = S5PV210_UFSTAT_RXFULL,        \
+                .tx_fifofull    = S5PV210_UFSTAT_TXFULL,        \
+                .tx_fifomask    = S5PV210_UFSTAT_TXMASK,        \
+                .tx_fifoshift   = S5PV210_UFSTAT_TXSHIFT,       \
+                .get_clksrc     = s5pv210_serial_getsource,     \
+                .set_clksrc     = s5pv210_serial_setsource,     \
+                .reset_port     = s5pv210_serial_resetport
+
+static struct s3c24xx_uart_info s5p_port_fifo256 = {
+        S5PV210_UART_DEFAULT_INFO(256),
+};
+
+static struct s3c24xx_uart_info s5p_port_fifo64 = {
+        S5PV210_UART_DEFAULT_INFO(64),
+};
+
+static struct s3c24xx_uart_info s5p_port_fifo16 = {
+        S5PV210_UART_DEFAULT_INFO(16),
+};
+
+static struct s3c24xx_uart_info *s5p_uart_inf[] = {
+        [0] = &s5p_port_fifo256,
+        [1] = &s5p_port_fifo64,
+        [2] = &s5p_port_fifo16,
+        [3] = &s5p_port_fifo16,
+};
+
+/* device management */
+static int s5p_serial_probe(struct platform_device *pdev)
+{
+        return s3c24xx_serial_probe(pdev, s5p_uart_inf[pdev->id]);
+}
+
+static struct platform_driver s5p_serial_drv = {
+        .probe          = s5p_serial_probe,
+        .remove         = __devexit_p(s3c24xx_serial_remove),
+        .driver         = {
+                .name   = "s5pv210-uart",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init s5pv210_serial_console_init(void)
+{
+        return s3c24xx_serial_initconsole(&s5p_serial_drv, s5p_uart_inf);
+}
+
+console_initcall(s5pv210_serial_console_init);
+
+static int __init s5p_serial_init(void)
+{
+        return s3c24xx_serial_init(&s5p_serial_drv, *s5p_uart_inf);
+}
+
+static void __exit s5p_serial_exit(void)
+{
+        platform_driver_unregister(&s5p_serial_drv);
+}
+
+module_init(s5p_serial_init);
+module_exit(s5p_serial_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:s5pv210-uart");
+MODULE_DESCRIPTION("Samsung S5PV210 UART Driver support");
+MODULE_AUTHOR("Thomas Abraham <thomas.ab@samsung.com>");
diff --git a/drivers/serial/samsung.c b/drivers/serial/samsung.c
index 03c010af966b..a9d6c5626a0a 100644
--- a/drivers/serial/samsung.c
+++ b/drivers/serial/samsung.c
@@ -1374,7 +1374,7 @@ s3c24xx_serial_get_options(struct uart_port *port, int *baud,
  * data.
 */
 
-static int s3c24xx_serial_init_ports(struct s3c24xx_uart_info *info)
+static int s3c24xx_serial_init_ports(struct s3c24xx_uart_info **info)
 {
         struct s3c24xx_uart_port *ptr = s3c24xx_serial_ports;
         struct platform_device **platdev_ptr;
@@ -1385,7 +1385,7 @@ static int s3c24xx_serial_init_ports(struct s3c24xx_uart_info *info)
         platdev_ptr = s3c24xx_uart_devs;
 
         for (i = 0; i < CONFIG_SERIAL_SAMSUNG_UARTS; i++, ptr++, platdev_ptr++) {
-                s3c24xx_serial_init_port(ptr, info, *platdev_ptr);
+                s3c24xx_serial_init_port(ptr, info[i], *platdev_ptr);
         }
 
         return 0;
@@ -1451,7 +1451,7 @@ static struct console s3c24xx_serial_console = {
 };
 
 int s3c24xx_serial_initconsole(struct platform_driver *drv,
-                               struct s3c24xx_uart_info *info)
+                               struct s3c24xx_uart_info **info)
 
 {
         struct platform_device *dev = s3c24xx_uart_devs[0];
diff --git a/drivers/serial/samsung.h b/drivers/serial/samsung.h
index 1fb22343df42..0ac06a07d25f 100644
--- a/drivers/serial/samsung.h
+++ b/drivers/serial/samsung.h
@@ -75,19 +75,24 @@ extern int s3c24xx_serial_probe(struct platform_device *dev,
 extern int __devexit s3c24xx_serial_remove(struct platform_device *dev);
 
 extern int s3c24xx_serial_initconsole(struct platform_driver *drv,
-                                      struct s3c24xx_uart_info *uart);
+                                      struct s3c24xx_uart_info **uart);
 
 extern int s3c24xx_serial_init(struct platform_driver *drv,
                                struct s3c24xx_uart_info *info);
 
 #ifdef CONFIG_SERIAL_SAMSUNG_CONSOLE
 
-#define s3c24xx_console_init(__drv, __inf)                      \
-static int __init s3c_serial_console_init(void)                 \
-{                                                               \
-        return s3c24xx_serial_initconsole(__drv, __inf);        \
-}                                                               \
-                                                                \
+#define s3c24xx_console_init(__drv, __inf)                              \
+static int __init s3c_serial_console_init(void)                         \
+{                                                                       \
+        struct s3c24xx_uart_info *uinfo[CONFIG_SERIAL_SAMSUNG_UARTS];   \
+        int i;                                                          \
+                                                                        \
+        for (i = 0; i < CONFIG_SERIAL_SAMSUNG_UARTS; i++)               \
+                uinfo[i] = __inf;                                       \
+        return s3c24xx_serial_initconsole(__drv, uinfo);                \
+}                                                                       \
+                                                                        \
 console_initcall(s3c_serial_console_init)
 
 #else
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index f7d2589926d2..fad67d33b0bd 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -30,7 +30,8 @@
  */
 # define SCSCR_INIT(port) (port->mapbase == SCIF2) ? 0xF3 : 0xF0
 #elif defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7721)
+      defined(CONFIG_CPU_SUBTYPE_SH7721) || \
+      defined(CONFIG_ARCH_SHMOBILE)
 # define SCSCR_INIT(port)  0x0030 /* TIE=0,RIE=0,TE=1,RE=1 */
 # define PORT_PTCR         0xA405011EUL
 # define PORT_PVCR         0xA4050122UL
@@ -228,7 +229,8 @@
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
     defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721)
+    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
+    defined(CONFIG_ARCH_SHMOBILE)
 # define SCIF_ORER    0x0200
 # define SCIF_ERRORS ( SCIF_PER | SCIF_FER | SCIF_ER | SCIF_BRK | SCIF_ORER)
 # define SCIF_RFDC_MASK 0x007f
@@ -261,7 +263,8 @@
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
     defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721)
+    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
+    defined(CONFIG_ARCH_SHMOBILE)
 # define SCxSR_RDxF_CLEAR(port)  (sci_in(port, SCxSR) & 0xfffc)
 # define SCxSR_ERROR_CLEAR(port) (sci_in(port, SCxSR) & 0xfd73)
 # define SCxSR_TDxE_CLEAR(port)  (sci_in(port, SCxSR) & 0xffdf)
@@ -356,7 +359,7 @@
     SCI_OUT(sci_size, sci_offset, value);                               \
   }
 
-#ifdef CONFIG_CPU_SH3
+#if defined(CONFIG_CPU_SH3) || defined(CONFIG_ARCH_SHMOBILE)
 #if defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
 #define SCIx_FNS(name, sh3_sci_offset, sh3_sci_size, sh4_sci_offset, sh4_sci_size, \
                                 sh3_scif_offset, sh3_scif_size, sh4_scif_offset, sh4_scif_size, \
@@ -366,7 +369,8 @@
           CPU_SCIF_FNS(name, sh4_scif_offset, sh4_scif_size)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
       defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7721)
+      defined(CONFIG_CPU_SUBTYPE_SH7721) || \
+      defined(CONFIG_ARCH_SHMOBILE)
 #define SCIF_FNS(name, scif_offset, scif_size) \
   CPU_SCIF_FNS(name, scif_offset, scif_size)
 #else
@@ -401,7 +405,8 @@
 
 #if defined(CONFIG_CPU_SUBTYPE_SH7705) || \
     defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-    defined(CONFIG_CPU_SUBTYPE_SH7721)
+    defined(CONFIG_CPU_SUBTYPE_SH7721) || \
+    defined(CONFIG_ARCH_SHMOBILE)
 
 SCIF_FNS(SCSMR,  0x00, 16)
 SCIF_FNS(SCBRR,  0x04,  8)
@@ -413,7 +418,7 @@ SCIF_FNS(SCFCR,  0x18, 16)
 SCIF_FNS(SCFDR,  0x1c, 16)
 SCIF_FNS(SCxTDR, 0x20,  8)
 SCIF_FNS(SCxRDR, 0x24,  8)
-SCIF_FNS(SCLSR,  0x24, 16)
+SCIF_FNS(SCLSR,  0x00,  0)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
       defined(CONFIG_CPU_SUBTYPE_SH7724)
 SCIx_FNS(SCSMR,  0x00, 16, 0x00, 16)
@@ -583,7 +588,8 @@ static inline int sci_rxd_in(struct uart_port *port)
 #define SCBRR_VALUE(bps, clk) ((clk+16*bps)/(16*bps)-1)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7705) || \
       defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7721)
+      defined(CONFIG_CPU_SUBTYPE_SH7721) || \
+      defined(CONFIG_ARCH_SHMOBILE)
 #define SCBRR_VALUE(bps, clk) (((clk*2)+16*bps)/(32*bps)-1)
 #elif defined(CONFIG_CPU_SUBTYPE_SH7723) ||\
       defined(CONFIG_CPU_SUBTYPE_SH7724)
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index 3a5a17db9474..c2750391fd34 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -762,6 +762,10 @@ static void __init intc_register_irq(struct intc_desc *desc,
 
         if (desc->hw.ack_regs)
                 ack_handle[irq] = intc_ack_data(desc, d, enum_id);
+
+#ifdef CONFIG_ARM
+        set_irq_flags(irq, IRQF_VALID); /* Enable IRQ on ARM systems */
+#endif
 }
 
 static unsigned int __init save_reg(struct intc_desc_int *d,
@@ -1024,8 +1028,12 @@ unsigned int create_irq_nr(unsigned int irq_want, int node)
 out_unlock:
         spin_unlock_irqrestore(&vector_lock, flags);
 
-        if (irq > 0)
+        if (irq > 0) {
                 dynamic_irq_init(irq);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID); /* Enable IRQ on ARM systems */
+#endif
+        }
 
         return irq;
 }
diff --git a/drivers/staging/asus_oled/asus_oled.c b/drivers/staging/asus_oled/asus_oled.c
index cadb6f7321ad..7ebecc92c61b 100644
--- a/drivers/staging/asus_oled/asus_oled.c
+++ b/drivers/staging/asus_oled/asus_oled.c
@@ -770,13 +770,8 @@ static struct usb_driver oled_driver = {
         .id_table =     id_table,
 };
 
-static ssize_t version_show(struct class *dev, char *buf)
-{
-        return sprintf(buf, ASUS_OLED_UNDERSCORE_NAME " %s\n",
-                       ASUS_OLED_VERSION);
-}
-
-static CLASS_ATTR(version, S_IRUGO, version_show, NULL);
+static CLASS_ATTR_STRING(version, S_IRUGO,
+                        ASUS_OLED_UNDERSCORE_NAME " " ASUS_OLED_VERSION);
 
 static int __init asus_oled_init(void)
 {
@@ -788,7 +783,7 @@ static int __init asus_oled_init(void)
                 return PTR_ERR(oled_class);
         }
 
-        retval = class_create_file(oled_class, &class_attr_version);
+        retval = class_create_file(oled_class, &class_attr_version.attr);
         if (retval) {
                 err("Error creating class version file");
                 goto error;
@@ -810,7 +805,7 @@ error:
 
 static void __exit asus_oled_exit(void)
 {
-        class_remove_file(oled_class, &class_attr_version);
+        class_remove_file(oled_class, &class_attr_version.attr);
         class_destroy(oled_class);
 
         usb_deregister(&oled_driver);
diff --git a/drivers/uio/Kconfig b/drivers/uio/Kconfig
index 8aa1955f35ed..1da73ecd9799 100644
--- a/drivers/uio/Kconfig
+++ b/drivers/uio/Kconfig
@@ -44,17 +44,6 @@ config UIO_PDRV_GENIRQ
 
           If you don't know what to do here, say N.
 
-config UIO_SMX
-        tristate "SMX cryptengine UIO interface"
-        help
-          Userspace IO interface to the Cryptography engine found on the
-          Nias Digital SMX boards.  These will be available from Q4 2008
-          from http://www.niasdigital.com.  The userspace part of this
-          driver will be released under the GPL at the same time as the
-          hardware and will be able to be downloaded from the same site.
-
-          If you compile this as a module, it will be called uio_smx.
-
 config UIO_AEC
         tristate "AEC video timestamp device"
         depends on PCI
@@ -74,6 +63,7 @@ config UIO_AEC
 
 config UIO_SERCOS3
         tristate "Automata Sercos III PCI card driver"
+        depends on PCI
         help
           Userspace I/O interface for the Sercos III PCI card from
           Automata GmbH. The userspace part of this driver will be
@@ -87,11 +77,21 @@ config UIO_SERCOS3
 config UIO_PCI_GENERIC
         tristate "Generic driver for PCI 2.3 and PCI Express cards"
         depends on PCI
-        default n
         help
           Generic driver that you can bind, dynamically, to any
           PCI 2.3 compliant and PCI Express card. It is useful,
           primarily, for virtualization scenarios.
           If you compile this as a module, it will be called uio_pci_generic.
 
+config UIO_NETX
+        tristate "Hilscher NetX Card driver"
+        depends on PCI
+        help
+          Driver for Hilscher NetX based fieldbus cards (cifX, comX).
+          This driver requires a userspace component that comes with the card
+          or is available from Hilscher (http://www.hilscher.com).
+
+          To compile this driver as a module, choose M here; the module
+          will be called uio_netx.
+
 endif
diff --git a/drivers/uio/Makefile b/drivers/uio/Makefile
index 73b2e7516729..18fd818c5b97 100644
--- a/drivers/uio/Makefile
+++ b/drivers/uio/Makefile
@@ -2,7 +2,7 @@ obj-$(CONFIG_UIO)	+= uio.o
 obj-$(CONFIG_UIO_CIF)   += uio_cif.o
 obj-$(CONFIG_UIO_PDRV)  += uio_pdrv.o
 obj-$(CONFIG_UIO_PDRV_GENIRQ)   += uio_pdrv_genirq.o
-obj-$(CONFIG_UIO_SMX)   += uio_smx.o
 obj-$(CONFIG_UIO_AEC)   += uio_aec.o
 obj-$(CONFIG_UIO_SERCOS3)       += uio_sercos3.o
 obj-$(CONFIG_UIO_PCI_GENERIC)   += uio_pci_generic.o
+obj-$(CONFIG_UIO_NETX)  += uio_netx.o
diff --git a/drivers/uio/uio.c b/drivers/uio/uio.c
index e941367dd28f..4de382acd8f2 100644
--- a/drivers/uio/uio.c
+++ b/drivers/uio/uio.c
@@ -129,7 +129,7 @@ static ssize_t map_type_show(struct kobject *kobj, struct attribute *attr,
         return entry->show(mem, buf);
 }
 
-static struct sysfs_ops map_sysfs_ops = {
+static const struct sysfs_ops map_sysfs_ops = {
         .show = map_type_show,
 };
 
@@ -217,7 +217,7 @@ static ssize_t portio_type_show(struct kobject *kobj, struct attribute *attr,
         return entry->show(port, buf);
 }
 
-static struct sysfs_ops portio_sysfs_ops = {
+static const struct sysfs_ops portio_sysfs_ops = {
         .show = portio_type_show,
 };
 
diff --git a/drivers/uio/uio_netx.c b/drivers/uio/uio_netx.c
new file mode 100644
index 000000000000..afbf0bd55cc9
--- /dev/null
+++ b/drivers/uio/uio_netx.c
@@ -0,0 +1,172 @@
+/*
+ * UIO driver for Hilscher NetX based fieldbus cards (cifX, comX).
+ * See http://www.hilscher.com for details.
+ *
+ * (C) 2007 Hans J. Koch <hjk@linutronix.de>
+ * (C) 2008 Manuel Traut <manut@linutronix.de>
+ *
+ * Licensed under GPL version 2 only.
+ *
+ */
+
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/uio_driver.h>
+
+#define PCI_VENDOR_ID_HILSCHER          0x15CF
+#define PCI_DEVICE_ID_HILSCHER_NETX     0x0000
+#define PCI_SUBDEVICE_ID_NXSB_PCA       0x3235
+#define PCI_SUBDEVICE_ID_NXPCA          0x3335
+
+#define DPM_HOST_INT_EN0        0xfff0
+#define DPM_HOST_INT_STAT0      0xffe0
+
+#define DPM_HOST_INT_MASK       0xe600ffff
+#define DPM_HOST_INT_GLOBAL_EN  0x80000000
+
+static irqreturn_t netx_handler(int irq, struct uio_info *dev_info)
+{
+        void __iomem *int_enable_reg = dev_info->mem[0].internal_addr
+                                        + DPM_HOST_INT_EN0;
+        void __iomem *int_status_reg = dev_info->mem[0].internal_addr
+                                        + DPM_HOST_INT_STAT0;
+
+        /* Is one of our interrupts enabled and active ? */
+        if (!(ioread32(int_enable_reg) & ioread32(int_status_reg)
+                & DPM_HOST_INT_MASK))
+                return IRQ_NONE;
+
+        /* Disable interrupt */
+        iowrite32(ioread32(int_enable_reg) & ~DPM_HOST_INT_GLOBAL_EN,
+                int_enable_reg);
+        return IRQ_HANDLED;
+}
+
+static int __devinit netx_pci_probe(struct pci_dev *dev,
+                                        const struct pci_device_id *id)
+{
+        struct uio_info *info;
+        int bar;
+
+        info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
+        if (!info)
+                return -ENOMEM;
+
+        if (pci_enable_device(dev))
+                goto out_free;
+
+        if (pci_request_regions(dev, "netx"))
+                goto out_disable;
+
+        switch (id->device) {
+        case PCI_DEVICE_ID_HILSCHER_NETX:
+                bar = 0;
+                info->name = "netx";
+                break;
+        default:
+                bar = 2;
+                info->name = "netx_plx";
+        }
+
+        /* BAR0 or 2 points to the card's dual port memory */
+        info->mem[0].addr = pci_resource_start(dev, bar);
+        if (!info->mem[0].addr)
+                goto out_release;
+        info->mem[0].internal_addr = ioremap(pci_resource_start(dev, bar),
+                                                pci_resource_len(dev, bar));
+
+        if (!info->mem[0].internal_addr)
+                        goto out_release;
+
+        info->mem[0].size = pci_resource_len(dev, bar);
+        info->mem[0].memtype = UIO_MEM_PHYS;
+        info->irq = dev->irq;
+        info->irq_flags = IRQF_SHARED;
+        info->handler = netx_handler;
+        info->version = "0.0.1";
+
+        /* Make sure all interrupts are disabled */
+        iowrite32(0, info->mem[0].internal_addr + DPM_HOST_INT_EN0);
+
+        if (uio_register_device(&dev->dev, info))
+                goto out_unmap;
+
+        pci_set_drvdata(dev, info);
+        dev_info(&dev->dev, "Found %s card, registered UIO device.\n",
+                                info->name);
+
+        return 0;
+
+out_unmap:
+        iounmap(info->mem[0].internal_addr);
+out_release:
+        pci_release_regions(dev);
+out_disable:
+        pci_disable_device(dev);
+out_free:
+        kfree(info);
+        return -ENODEV;
+}
+
+static void netx_pci_remove(struct pci_dev *dev)
+{
+        struct uio_info *info = pci_get_drvdata(dev);
+
+        /* Disable all interrupts */
+        iowrite32(0, info->mem[0].internal_addr + DPM_HOST_INT_EN0);
+        uio_unregister_device(info);
+        pci_release_regions(dev);
+        pci_disable_device(dev);
+        pci_set_drvdata(dev, NULL);
+        iounmap(info->mem[0].internal_addr);
+
+        kfree(info);
+}
+
+static struct pci_device_id netx_pci_ids[] = {
+        {
+                .vendor =       PCI_VENDOR_ID_HILSCHER,
+                .device =       PCI_DEVICE_ID_HILSCHER_NETX,
+                .subvendor =    0,
+                .subdevice =    0,
+        },
+        {
+                .vendor =       PCI_VENDOR_ID_PLX,
+                .device =       PCI_DEVICE_ID_PLX_9030,
+                .subvendor =    PCI_VENDOR_ID_PLX,
+                .subdevice =    PCI_SUBDEVICE_ID_NXSB_PCA,
+        },
+        {
+                .vendor =       PCI_VENDOR_ID_PLX,
+                .device =       PCI_DEVICE_ID_PLX_9030,
+                .subvendor =    PCI_VENDOR_ID_PLX,
+                .subdevice =    PCI_SUBDEVICE_ID_NXPCA,
+        },
+        { 0, }
+};
+
+static struct pci_driver netx_pci_driver = {
+        .name = "netx",
+        .id_table = netx_pci_ids,
+        .probe = netx_pci_probe,
+        .remove = netx_pci_remove,
+};
+
+static int __init netx_init_module(void)
+{
+        return pci_register_driver(&netx_pci_driver);
+}
+
+static void __exit netx_exit_module(void)
+{
+        pci_unregister_driver(&netx_pci_driver);
+}
+
+module_init(netx_init_module);
+module_exit(netx_exit_module);
+
+MODULE_DEVICE_TABLE(pci, netx_pci_ids);
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Hans J. Koch, Manuel Traut");
diff --git a/drivers/uio/uio_smx.c b/drivers/uio/uio_smx.c
deleted file mode 100644
index 44054a650a8a..000000000000
--- a/drivers/uio/uio_smx.c
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * UIO SMX Cryptengine driver.
- *
- * (C) 2008 Nias Digital P/L <bn@niasdigital.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- */
-
-#include <linux/device.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/uio_driver.h>
-#include <linux/io.h>
-
-#define DRV_NAME "smx-ce"
-#define DRV_VERSION "0.03"
-
-#define SMX_CSR  0x00000000
-#define SMX_EnD  0x00000001
-#define SMX_RUN  0x00000002
-#define SMX_DRDY 0x00000004
-#define SMX_ERR  0x00000008
-
-static irqreturn_t smx_handler(int irq, struct uio_info *dev_info)
-{
-        void __iomem *csr = dev_info->mem[0].internal_addr + SMX_CSR;
-
-        u32 status = ioread32(csr);
-
-        if (!(status & SMX_DRDY))
-                return IRQ_NONE;
-
-        /* Disable interrupt */
-        iowrite32(status & ~SMX_DRDY, csr);
-        return IRQ_HANDLED;
-}
-
-static int __devinit smx_ce_probe(struct platform_device *dev)
-{
-
-        int ret = -ENODEV;
-        struct uio_info *info;
-        struct resource *regs;
-
-        info = kzalloc(sizeof(struct uio_info), GFP_KERNEL);
-        if (!info)
-                return -ENOMEM;
-
-        regs = platform_get_resource(dev, IORESOURCE_MEM, 0);
-        if (!regs) {
-                dev_err(&dev->dev, "No memory resource specified\n");
-                goto out_free;
-        }
-
-        info->mem[0].addr = regs->start;
-        if (!info->mem[0].addr) {
-                dev_err(&dev->dev, "Invalid memory resource\n");
-                goto out_free;
-        }
-
-        info->mem[0].size = regs->end - regs->start + 1;
-        info->mem[0].internal_addr = ioremap(regs->start, info->mem[0].size);
-
-        if (!info->mem[0].internal_addr) {
-                dev_err(&dev->dev, "Can't remap memory address range\n");
-                goto out_free;
-        }
-
-        info->mem[0].memtype = UIO_MEM_PHYS;
-
-        info->name = "smx-ce";
-        info->version = "0.03";
-
-        info->irq = platform_get_irq(dev, 0);
-        if (info->irq < 0) {
-                ret = info->irq;
-                dev_err(&dev->dev, "No (or invalid) IRQ resource specified\n");
-                goto out_unmap;
-        }
-
-        info->irq_flags = IRQF_SHARED;
-        info->handler = smx_handler;
-
-        platform_set_drvdata(dev, info);
-
-        ret = uio_register_device(&dev->dev, info);
-
-        if (ret)
-                goto out_unmap;
-
-        return 0;
-
-out_unmap:
-        iounmap(info->mem[0].internal_addr);
-out_free:
-        kfree(info);
-
-        return ret;
-}
-
-static int __devexit smx_ce_remove(struct platform_device *dev)
-{
-        struct uio_info *info = platform_get_drvdata(dev);
-
-        uio_unregister_device(info);
-        platform_set_drvdata(dev, NULL);
-        iounmap(info->mem[0].internal_addr);
-
-        kfree(info);
-
-        return 0;
-}
-
-static struct platform_driver smx_ce_driver = {
-        .probe          = smx_ce_probe,
-        .remove         = __devexit_p(smx_ce_remove),
-        .driver         = {
-                .name   = DRV_NAME,
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init smx_ce_init_module(void)
-{
-        return platform_driver_register(&smx_ce_driver);
-}
-module_init(smx_ce_init_module);
-
-static void __exit smx_ce_exit_module(void)
-{
-        platform_driver_unregister(&smx_ce_driver);
-}
-module_exit(smx_ce_exit_module);
-
-MODULE_LICENSE("GPL v2");
-MODULE_VERSION(DRV_VERSION);
-MODULE_AUTHOR("Ben Nizette <bn@niasdigital.com>");
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index a7037bf81688..f3c233806fa3 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -489,10 +489,10 @@ void usb_driver_release_interface(struct usb_driver *driver,
         if (device_is_registered(dev)) {
                 device_release_driver(dev);
         } else {
-                down(&dev->sem);
+                device_lock(dev);
                 usb_unbind_interface(dev);
                 dev->driver = NULL;
-                up(&dev->sem);
+                device_unlock(dev);
         }
 }
 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
diff --git a/drivers/usb/gadget/fsl_mx3_udc.c b/drivers/usb/gadget/fsl_mx3_udc.c
index 4bc2bf3d602e..20a802ecaa15 100644
--- a/drivers/usb/gadget/fsl_mx3_udc.c
+++ b/drivers/usb/gadget/fsl_mx3_udc.c
@@ -17,6 +17,8 @@
 #include <linux/fsl_devices.h>
 #include <linux/platform_device.h>
 
+#include <mach/hardware.h>
+
 static struct clk *mxc_ahb_clk;
 static struct clk *mxc_usb_clk;
 
@@ -28,14 +30,16 @@ int fsl_udc_clk_init(struct platform_device *pdev)
 
         pdata = pdev->dev.platform_data;
 
-        mxc_ahb_clk = clk_get(&pdev->dev, "usb_ahb");
-        if (IS_ERR(mxc_ahb_clk))
-                return PTR_ERR(mxc_ahb_clk);
+        if (!cpu_is_mx35()) {
+                mxc_ahb_clk = clk_get(&pdev->dev, "usb_ahb");
+                if (IS_ERR(mxc_ahb_clk))
+                        return PTR_ERR(mxc_ahb_clk);
 
-        ret = clk_enable(mxc_ahb_clk);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "clk_enable(\"usb_ahb\") failed\n");
-                goto eenahb;
+                ret = clk_enable(mxc_ahb_clk);
+                if (ret < 0) {
+                        dev_err(&pdev->dev, "clk_enable(\"usb_ahb\") failed\n");
+                        goto eenahb;
+                }
         }
 
         /* make sure USB_CLK is running at 60 MHz +/- 1000 Hz */
@@ -50,6 +54,7 @@ int fsl_udc_clk_init(struct platform_device *pdev)
         if (pdata->phy_mode != FSL_USB2_PHY_ULPI &&
             (freq < 59999000 || freq > 60001000)) {
                 dev_err(&pdev->dev, "USB_CLK=%lu, should be 60MHz\n", freq);
+                ret = -EINVAL;
                 goto eclkrate;
         }
 
@@ -66,9 +71,11 @@ eclkrate:
         clk_put(mxc_usb_clk);
         mxc_usb_clk = NULL;
 egusb:
-        clk_disable(mxc_ahb_clk);
+        if (!cpu_is_mx35())
+                clk_disable(mxc_ahb_clk);
 eenahb:
-        clk_put(mxc_ahb_clk);
+        if (!cpu_is_mx35())
+                clk_put(mxc_ahb_clk);
         return ret;
 }
 
@@ -90,6 +97,8 @@ void fsl_udc_clk_release(void)
                 clk_disable(mxc_usb_clk);
                 clk_put(mxc_usb_clk);
         }
-        clk_disable(mxc_ahb_clk);
-        clk_put(mxc_ahb_clk);
+        if (!cpu_is_mx35()) {
+                clk_disable(mxc_ahb_clk);
+                clk_put(mxc_ahb_clk);
+        }
 }
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index e6fedbd5a654..be5fb34d9602 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -65,6 +65,10 @@
 #include <mach/pxa25x-udc.h>
 #endif
 
+#ifdef CONFIG_ARCH_LUBBOCK
+#include <mach/lubbock.h>
+#endif
+
 #include <asm/mach/udc_pxa2xx.h>
 
 
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index 7e5bf593d386..f742c8e7397c 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -30,7 +30,7 @@
 
 #include <plat/regs-usb-hsotg-phy.h>
 #include <plat/regs-usb-hsotg.h>
-#include <plat/regs-sys.h>
+#include <mach/regs-sys.h>
 #include <plat/udc-hs.h>
 
 #define DMA_ADDR_INVALID (~((dma_addr_t)0))
diff --git a/drivers/uwb/driver.c b/drivers/uwb/driver.c
index da77e41de990..08bd6dbfd4a6 100644
--- a/drivers/uwb/driver.c
+++ b/drivers/uwb/driver.c
@@ -74,13 +74,16 @@
 unsigned long beacon_timeout_ms = 500;
 
 static
-ssize_t beacon_timeout_ms_show(struct class *class, char *buf)
+ssize_t beacon_timeout_ms_show(struct class *class,
+                                struct class_attribute *attr,
+                                char *buf)
 {
         return scnprintf(buf, PAGE_SIZE, "%lu\n", beacon_timeout_ms);
 }
 
 static
 ssize_t beacon_timeout_ms_store(struct class *class,
+                                struct class_attribute *attr,
                                 const char *buf, size_t size)
 {
         unsigned long bt;
diff --git a/drivers/uwb/umc-bus.c b/drivers/uwb/umc-bus.c
index cdd6c8efc9f8..5fad4e791b3e 100644
--- a/drivers/uwb/umc-bus.c
+++ b/drivers/uwb/umc-bus.c
@@ -62,12 +62,12 @@ int umc_controller_reset(struct umc_dev *umc)
         struct device *parent = umc->dev.parent;
         int ret = 0;
 
-        if(down_trylock(&parent->sem))
+        if (device_trylock(parent))
                 return -EAGAIN;
         ret = device_for_each_child(parent, parent, umc_bus_pre_reset_helper);
         if (ret >= 0)
                 ret = device_for_each_child(parent, parent, umc_bus_post_reset_helper);
-        up(&parent->sem);
+        device_unlock(parent);
 
         return ret;
 }
diff --git a/drivers/uwb/uwb-internal.h b/drivers/uwb/uwb-internal.h
index d5bcfc1c227a..157485c862c0 100644
--- a/drivers/uwb/uwb-internal.h
+++ b/drivers/uwb/uwb-internal.h
@@ -366,12 +366,12 @@ struct dentry *uwb_dbg_create_pal_dir(struct uwb_pal *pal);
 
 static inline void uwb_dev_lock(struct uwb_dev *uwb_dev)
 {
-        down(&uwb_dev->dev.sem);
+        device_lock(&uwb_dev->dev);
 }
 
 static inline void uwb_dev_unlock(struct uwb_dev *uwb_dev)
 {
-        up(&uwb_dev->dev.sem);
+        device_unlock(&uwb_dev->dev);
 }
 
 #endif /* #ifndef __UWB_INTERNAL_H__ */
diff --git a/drivers/uwb/wlp/sysfs.c b/drivers/uwb/wlp/sysfs.c
index 0370399ff4bb..6627c94cc854 100644
--- a/drivers/uwb/wlp/sysfs.c
+++ b/drivers/uwb/wlp/sysfs.c
@@ -615,8 +615,7 @@ ssize_t wlp_wss_attr_store(struct kobject *kobj, struct attribute *attr,
         return ret;
 }
 
-static
-struct sysfs_ops wss_sysfs_ops = {
+static const struct sysfs_ops wss_sysfs_ops = {
         .show   = wlp_wss_attr_show,
         .store  = wlp_wss_attr_store,
 };
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 5a5c303a6373..1c60053439a9 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -400,9 +400,12 @@ config FB_SA1100
           If you plan to use the LCD display with your SA-1100 system, say
           Y here.
 
+config HAVE_FB_IMX
+        bool
+
 config FB_IMX
         tristate "Motorola i.MX LCD support"
-        depends on FB && (ARCH_MX1 || ARCH_MX2)
+        depends on FB && (HAVE_FB_IMX || ARCH_MX1 || ARCH_MX2)
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
@@ -1494,7 +1497,6 @@ config FB_VIA
        select FB_CFB_FILLRECT
        select FB_CFB_COPYAREA
        select FB_CFB_IMAGEBLIT
-       select FB_SOFT_CURSOR
        select I2C_ALGOBIT
        select I2C
        help
@@ -1945,6 +1947,27 @@ config FB_S3C2410_DEBUG
           Turn on debugging messages. Note that you can set/unset at run time
           through sysfs
 
+config FB_NUC900
+        bool "NUC900 LCD framebuffer support"
+        depends on FB && ARCH_W90X900
+        select FB_CFB_FILLRECT
+        select FB_CFB_COPYAREA
+        select FB_CFB_IMAGEBLIT
+        ---help---
+          Frame buffer driver for the built-in LCD controller in the Nuvoton
+          NUC900 processor
+
+config GPM1040A0_320X240
+        bool "Giantplus Technology GPM1040A0 320x240 Color TFT LCD"
+        depends on FB_NUC900
+
+config FB_NUC900_DEBUG
+        bool "NUC900 lcd debug messages"
+        depends on FB_NUC900
+        help
+          Turn on debugging messages. Note that you can set/unset at run time
+          through sysfs
+
 config FB_SM501
         tristate "Silicon Motion SM501 framebuffer support"
         depends on FB && MFD_SM501
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index 4ecb30c4f3f2..a42ad55e3a15 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -129,6 +129,7 @@ obj-$(CONFIG_XEN_FBDEV_FRONTEND)  += xen-fbfront.o
 obj-$(CONFIG_FB_CARMINE)          += carminefb.o
 obj-$(CONFIG_FB_MB862XX)          += mb862xx/
 obj-$(CONFIG_FB_MSM)              += msm/
+obj-$(CONFIG_FB_NUC900)           += nuc900fb.o
 
 # Platform or fallback drivers go here
 obj-$(CONFIG_FB_UVESA)            += uvesafb.o
diff --git a/drivers/video/acornfb.c b/drivers/video/acornfb.c
index 0bcc59eb37fa..43d7d5067361 100644
--- a/drivers/video/acornfb.c
+++ b/drivers/video/acornfb.c
@@ -1221,7 +1221,7 @@ free_unused_pages(unsigned int virtual_start, unsigned int virtual_end)
         printk("acornfb: freed %dK memory\n", mb_freed);
 }
 
-static int __init acornfb_probe(struct platform_device *dev)
+static int __devinit acornfb_probe(struct platform_device *dev)
 {
         unsigned long size;
         u_int h_sync, v_sync;
diff --git a/drivers/video/arcfb.c b/drivers/video/arcfb.c
index c3431691c9f2..01554d696528 100644
--- a/drivers/video/arcfb.c
+++ b/drivers/video/arcfb.c
@@ -504,7 +504,7 @@ static struct fb_ops arcfb_ops = {
         .fb_ioctl       = arcfb_ioctl,
 };
 
-static int __init arcfb_probe(struct platform_device *dev)
+static int __devinit arcfb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
         int retval = -ENOMEM;
diff --git a/drivers/video/asiliantfb.c b/drivers/video/asiliantfb.c
index 9fe90ce928fb..e70bc225fe31 100644
--- a/drivers/video/asiliantfb.c
+++ b/drivers/video/asiliantfb.c
@@ -140,7 +140,7 @@ static void asiliant_calc_dclk2(u32 *ppixclock, u8 *dclk2_m, u8 *dclk2_n, u8 *dc
 
                 /* 3 <= m <= 257 */
                 if (m >= 3 && m <= 257) {
-                        unsigned new_error = ((Ftarget * n) - (Fref * m)) >= 0 ?
+                        unsigned new_error = Ftarget * n >= Fref * m ?
                                                ((Ftarget * n) - (Fref * m)) : ((Fref * m) - (Ftarget * n));
                         if (new_error < best_error) {
                                 best_n = n;
@@ -152,7 +152,7 @@ static void asiliant_calc_dclk2(u32 *ppixclock, u8 *dclk2_m, u8 *dclk2_n, u8 *dc
                 else if (m <= 1028) {
                         /* remember there are still only 8-bits of precision in m, so
                          * avoid over-optimistic error calculations */
-                        unsigned new_error = ((Ftarget * n) - (Fref * (m & ~3))) >= 0 ?
+                        unsigned new_error = Ftarget * n >= Fref * (m & ~3) ?
                                                ((Ftarget * n) - (Fref * (m & ~3))) : ((Fref * (m & ~3)) - (Ftarget * n));
                         if (new_error < best_error) {
                                 best_n = n;
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index e49ae5edcc00..814312a7452f 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -82,7 +82,6 @@ struct bfin_bf54xfb_info {
         unsigned char *fb_buffer;       /* RGB Buffer */
 
         dma_addr_t dma_handle;
-        int lq043_mmap;
         int lq043_open_cnt;
         int irq;
         spinlock_t lock;        /* lock */
@@ -316,7 +315,6 @@ static int bfin_bf54x_fb_release(struct fb_info *info, int user)
         spin_lock(&fbi->lock);
 
         fbi->lq043_open_cnt--;
-        fbi->lq043_mmap = 0;
 
         if (fbi->lq043_open_cnt <= 0) {
 
@@ -374,33 +372,6 @@ static int bfin_bf54x_fb_check_var(struct fb_var_screeninfo *var,
         return 0;
 }
 
-static int bfin_bf54x_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
-{
-
-        struct bfin_bf54xfb_info *fbi = info->par;
-
-        if (fbi->lq043_mmap)
-                return -1;
-
-        spin_lock(&fbi->lock);
-        fbi->lq043_mmap = 1;
-        spin_unlock(&fbi->lock);
-
-        vma->vm_start = (unsigned long)(fbi->fb_buffer);
-
-        vma->vm_end = vma->vm_start + info->fix.smem_len;
-        /* For those who don't understand how mmap works, go read
-         *   Documentation/nommu-mmap.txt.
-         * For those that do, you will know that the VM_MAYSHARE flag
-         * must be set in the vma->vm_flags structure on noMMU
-         *   Other flags can be set, and are documented in
-         *   include/linux/mm.h
-         */
-        vma->vm_flags |=  VM_MAYSHARE | VM_SHARED;
-
-        return 0;
-}
-
 int bfin_bf54x_fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
         if (nocursor)
@@ -452,7 +423,6 @@ static struct fb_ops bfin_bf54x_fb_ops = {
         .fb_fillrect = cfb_fillrect,
         .fb_copyarea = cfb_copyarea,
         .fb_imageblit = cfb_imageblit,
-        .fb_mmap = bfin_bf54x_fb_mmap,
         .fb_cursor = bfin_bf54x_fb_cursor,
         .fb_setcolreg = bfin_bf54x_fb_setcolreg,
 };
diff --git a/drivers/video/bfin-lq035q1-fb.c b/drivers/video/bfin-lq035q1-fb.c
index b690c269784a..03872365a36d 100644
--- a/drivers/video/bfin-lq035q1-fb.c
+++ b/drivers/video/bfin-lq035q1-fb.c
@@ -22,7 +22,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
-#include <linux/dma-mapping.h>
 
 #include <asm/blackfin.h>
 #include <asm/irq.h>
diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c
index 2549c53b26a0..5653d083a983 100644
--- a/drivers/video/bfin-t350mcqb-fb.c
+++ b/drivers/video/bfin-t350mcqb-fb.c
@@ -87,7 +87,6 @@ struct bfin_t350mcqbfb_info {
         struct device *dev;
         unsigned char *fb_buffer;       /* RGB Buffer */
         dma_addr_t dma_handle;
-        int lq043_mmap;
         int lq043_open_cnt;
         int irq;
         spinlock_t lock;        /* lock */
@@ -235,7 +234,6 @@ static int bfin_t350mcqb_fb_release(struct fb_info *info, int user)
         spin_lock(&fbi->lock);
 
         fbi->lq043_open_cnt--;
-        fbi->lq043_mmap = 0;
 
         if (fbi->lq043_open_cnt <= 0) {
                 bfin_t350mcqb_disable_ppi();
@@ -293,32 +291,6 @@ static int bfin_t350mcqb_fb_check_var(struct fb_var_screeninfo *var,
         return 0;
 }
 
-static int bfin_t350mcqb_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
-{
-        struct bfin_t350mcqbfb_info *fbi = info->par;
-
-        if (fbi->lq043_mmap)
-                return -1;
-
-        spin_lock(&fbi->lock);
-        fbi->lq043_mmap = 1;
-        spin_unlock(&fbi->lock);
-
-        vma->vm_start = (unsigned long)(fbi->fb_buffer + ACTIVE_VIDEO_MEM_OFFSET);
-
-        vma->vm_end = vma->vm_start + info->fix.smem_len;
-        /* For those who don't understand how mmap works, go read
-         *   Documentation/nommu-mmap.txt.
-         * For those that do, you will know that the VM_MAYSHARE flag
-         * must be set in the vma->vm_flags structure on noMMU
-         *   Other flags can be set, and are documented in
-         *   include/linux/mm.h
-         */
-        vma->vm_flags |= VM_MAYSHARE | VM_SHARED;
-
-        return 0;
-}
-
 int bfin_t350mcqb_fb_cursor(struct fb_info *info, struct fb_cursor *cursor)
 {
         if (nocursor)
@@ -370,7 +342,6 @@ static struct fb_ops bfin_t350mcqb_fb_ops = {
         .fb_fillrect = cfb_fillrect,
         .fb_copyarea = cfb_copyarea,
         .fb_imageblit = cfb_imageblit,
-        .fb_mmap = bfin_t350mcqb_fb_mmap,
         .fb_cursor = bfin_t350mcqb_fb_cursor,
         .fb_setcolreg = bfin_t350mcqb_fb_setcolreg,
 };
diff --git a/drivers/video/broadsheetfb.c b/drivers/video/broadsheetfb.c
index df9ccb901d86..ebda6876d3a9 100644
--- a/drivers/video/broadsheetfb.c
+++ b/drivers/video/broadsheetfb.c
@@ -29,11 +29,65 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/list.h>
+#include <linux/firmware.h>
 #include <linux/uaccess.h>
 
 #include <video/broadsheetfb.h>
 
-/* Display specific information */
+/* track panel specific parameters */
+struct panel_info {
+        int w;
+        int h;
+        u16 sdcfg;
+        u16 gdcfg;
+        u16 lutfmt;
+        u16 fsynclen;
+        u16 fendfbegin;
+        u16 lsynclen;
+        u16 lendlbegin;
+        u16 pixclk;
+};
+
+/* table of panel specific parameters to be indexed into by the board drivers */
+static struct panel_info panel_table[] = {
+        {       /* standard 6" on TFT backplane */
+                .w = 800,
+                .h = 600,
+                .sdcfg = (100 | (1 << 8) | (1 << 9)),
+                .gdcfg = 2,
+                .lutfmt = (4 | (1 << 7)),
+                .fsynclen = 4,
+                .fendfbegin = (10 << 8) | 4,
+                .lsynclen = 10,
+                .lendlbegin = (100 << 8) | 4,
+                .pixclk = 6,
+        },
+        {       /* custom 3.7" flexible on PET or steel */
+                .w = 320,
+                .h = 240,
+                .sdcfg = (67 | (0 << 8) | (0 << 9) | (0 << 10) | (0 << 12)),
+                .gdcfg = 3,
+                .lutfmt = (4 | (1 << 7)),
+                .fsynclen = 0,
+                .fendfbegin = (80 << 8) | 4,
+                .lsynclen = 10,
+                .lendlbegin = (80 << 8) | 20,
+                .pixclk = 14,
+        },
+        {       /* standard 9.7" on TFT backplane */
+                .w = 1200,
+                .h = 825,
+                .sdcfg = (100 | (1 << 8) | (1 << 9) | (0 << 10) | (0 << 12)),
+                .gdcfg = 2,
+                .lutfmt = (4 | (1 << 7)),
+                .fsynclen = 0,
+                .fendfbegin = (4 << 8) | 4,
+                .lsynclen = 4,
+                .lendlbegin = (60 << 8) | 10,
+                .pixclk = 3,
+        },
+};
+
 #define DPY_W 800
 #define DPY_H 600
 
@@ -62,30 +116,30 @@ static struct fb_var_screeninfo broadsheetfb_var __devinitdata = {
 };
 
 /* main broadsheetfb functions */
-static void broadsheet_issue_data(struct broadsheetfb_par *par, u16 data)
+static void broadsheet_gpio_issue_data(struct broadsheetfb_par *par, u16 data)
 {
         par->board->set_ctl(par, BS_WR, 0);
         par->board->set_hdb(par, data);
         par->board->set_ctl(par, BS_WR, 1);
 }
 
-static void broadsheet_issue_cmd(struct broadsheetfb_par *par, u16 data)
+static void broadsheet_gpio_issue_cmd(struct broadsheetfb_par *par, u16 data)
 {
         par->board->set_ctl(par, BS_DC, 0);
-        broadsheet_issue_data(par, data);
+        broadsheet_gpio_issue_data(par, data);
 }
 
-static void broadsheet_send_command(struct broadsheetfb_par *par, u16 data)
+static void broadsheet_gpio_send_command(struct broadsheetfb_par *par, u16 data)
 {
         par->board->wait_for_rdy(par);
 
         par->board->set_ctl(par, BS_CS, 0);
-        broadsheet_issue_cmd(par, data);
+        broadsheet_gpio_issue_cmd(par, data);
         par->board->set_ctl(par, BS_DC, 1);
         par->board->set_ctl(par, BS_CS, 1);
 }
 
-static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
+static void broadsheet_gpio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
                                         int argc, u16 *argv)
 {
         int i;
@@ -93,15 +147,43 @@ static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
         par->board->wait_for_rdy(par);
 
         par->board->set_ctl(par, BS_CS, 0);
-        broadsheet_issue_cmd(par, cmd);
+        broadsheet_gpio_issue_cmd(par, cmd);
         par->board->set_ctl(par, BS_DC, 1);
 
         for (i = 0; i < argc; i++)
-                broadsheet_issue_data(par, argv[i]);
+                broadsheet_gpio_issue_data(par, argv[i]);
         par->board->set_ctl(par, BS_CS, 1);
 }
 
-static void broadsheet_burst_write(struct broadsheetfb_par *par, int size,
+static void broadsheet_mmio_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
+                                    int argc, u16 *argv)
+{
+        int i;
+
+        par->board->mmio_write(par, BS_MMIO_CMD, cmd);
+
+        for (i = 0; i < argc; i++)
+                par->board->mmio_write(par, BS_MMIO_DATA, argv[i]);
+}
+
+static void broadsheet_send_command(struct broadsheetfb_par *par, u16 data)
+{
+        if (par->board->mmio_write)
+                par->board->mmio_write(par, BS_MMIO_CMD, data);
+        else
+                broadsheet_gpio_send_command(par, data);
+}
+
+static void broadsheet_send_cmdargs(struct broadsheetfb_par *par, u16 cmd,
+                                    int argc, u16 *argv)
+{
+        if (par->board->mmio_write)
+                broadsheet_mmio_send_cmdargs(par, cmd, argc, argv);
+        else
+                broadsheet_gpio_send_cmdargs(par, cmd, argc, argv);
+}
+
+static void broadsheet_gpio_burst_write(struct broadsheetfb_par *par, int size,
                                         u16 *data)
 {
         int i;
@@ -121,7 +203,30 @@ static void broadsheet_burst_write(struct broadsheetfb_par *par, int size,
         par->board->set_ctl(par, BS_CS, 1);
 }
 
-static u16 broadsheet_get_data(struct broadsheetfb_par *par)
+static void broadsheet_mmio_burst_write(struct broadsheetfb_par *par, int size,
+                                   u16 *data)
+{
+        int i;
+        u16 tmp;
+
+        for (i = 0; i < size; i++) {
+                tmp = (data[i] & 0x0F) << 4;
+                tmp |= (data[i] & 0x0F00) << 4;
+                par->board->mmio_write(par, BS_MMIO_DATA, tmp);
+        }
+
+}
+
+static void broadsheet_burst_write(struct broadsheetfb_par *par, int size,
+                                   u16 *data)
+{
+        if (par->board->mmio_write)
+                broadsheet_mmio_burst_write(par, size, data);
+        else
+                broadsheet_gpio_burst_write(par, size, data);
+}
+
+static u16 broadsheet_gpio_get_data(struct broadsheetfb_par *par)
 {
         u16 res;
         /* wait for ready to go hi. (lo is busy) */
@@ -141,7 +246,16 @@ static u16 broadsheet_get_data(struct broadsheetfb_par *par)
         return res;
 }
 
-static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg,
+
+static u16 broadsheet_get_data(struct broadsheetfb_par *par)
+{
+        if (par->board->mmio_read)
+                return par->board->mmio_read(par);
+        else
+                return broadsheet_gpio_get_data(par);
+}
+
+static void broadsheet_gpio_write_reg(struct broadsheetfb_par *par, u16 reg,
                                         u16 data)
 {
         /* wait for ready to go hi. (lo is busy) */
@@ -150,44 +264,541 @@ static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg,
         /* cs lo, dc lo for cmd, we lo for each data, db as usual */
         par->board->set_ctl(par, BS_CS, 0);
 
-        broadsheet_issue_cmd(par, BS_CMD_WR_REG);
+        broadsheet_gpio_issue_cmd(par, BS_CMD_WR_REG);
 
         par->board->set_ctl(par, BS_DC, 1);
 
-        broadsheet_issue_data(par, reg);
-        broadsheet_issue_data(par, data);
+        broadsheet_gpio_issue_data(par, reg);
+        broadsheet_gpio_issue_data(par, data);
 
         par->board->set_ctl(par, BS_CS, 1);
 }
 
+static void broadsheet_mmio_write_reg(struct broadsheetfb_par *par, u16 reg,
+                                 u16 data)
+{
+        par->board->mmio_write(par, BS_MMIO_CMD, BS_CMD_WR_REG);
+        par->board->mmio_write(par, BS_MMIO_DATA, reg);
+        par->board->mmio_write(par, BS_MMIO_DATA, data);
+
+}
+
+static void broadsheet_write_reg(struct broadsheetfb_par *par, u16 reg,
+                                        u16 data)
+{
+        if (par->board->mmio_write)
+                broadsheet_mmio_write_reg(par, reg, data);
+        else
+                broadsheet_gpio_write_reg(par, reg, data);
+}
+
+static void broadsheet_write_reg32(struct broadsheetfb_par *par, u16 reg,
+                                        u32 data)
+{
+        broadsheet_write_reg(par, reg, cpu_to_le32(data) & 0xFFFF);
+        broadsheet_write_reg(par, reg + 2, (cpu_to_le32(data) >> 16) & 0xFFFF);
+}
+
+
 static u16 broadsheet_read_reg(struct broadsheetfb_par *par, u16 reg)
 {
-        broadsheet_send_command(par, reg);
-        msleep(100);
+        broadsheet_send_cmdargs(par, BS_CMD_RD_REG, 1, &reg);
+        par->board->wait_for_rdy(par);
         return broadsheet_get_data(par);
 }
 
+/* functions for waveform manipulation */
+static int is_broadsheet_pll_locked(struct broadsheetfb_par *par)
+{
+        return broadsheet_read_reg(par, 0x000A) & 0x0001;
+}
+
+static int broadsheet_setup_plls(struct broadsheetfb_par *par)
+{
+        int retry_count = 0;
+        u16 tmp;
+
+        /* disable arral saemipu mode */
+        broadsheet_write_reg(par, 0x0006, 0x0000);
+
+        broadsheet_write_reg(par, 0x0010, 0x0004);
+        broadsheet_write_reg(par, 0x0012, 0x5949);
+        broadsheet_write_reg(par, 0x0014, 0x0040);
+        broadsheet_write_reg(par, 0x0016, 0x0000);
+
+        do {
+                if (retry_count++ > 100)
+                        return -ETIMEDOUT;
+                mdelay(1);
+        } while (!is_broadsheet_pll_locked(par));
+
+        tmp = broadsheet_read_reg(par, 0x0006);
+        tmp &= ~0x1;
+        broadsheet_write_reg(par, 0x0006, tmp);
+
+        return 0;
+}
+
+static int broadsheet_setup_spi(struct broadsheetfb_par *par)
+{
+
+        broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1));
+        broadsheet_write_reg(par, 0x0208, 0x0001);
+
+        return 0;
+}
+
+static int broadsheet_setup_spiflash(struct broadsheetfb_par *par,
+                                                u16 *orig_sfmcd)
+{
+
+        *orig_sfmcd = broadsheet_read_reg(par, 0x0204);
+        broadsheet_write_reg(par, 0x0208, 0);
+        broadsheet_write_reg(par, 0x0204, 0);
+        broadsheet_write_reg(par, 0x0204, ((3 << 3) | 1));
+
+        return 0;
+}
+
+static int broadsheet_spiflash_wait_for_bit(struct broadsheetfb_par *par,
+                                                u16 reg, int bitnum, int val,
+                                                int timeout)
+{
+        u16 tmp;
+
+        do {
+                tmp = broadsheet_read_reg(par, reg);
+                if (((tmp >> bitnum) & 1) == val)
+                        return 0;
+                mdelay(1);
+        } while (timeout--);
+
+        return -ETIMEDOUT;
+}
+
+static int broadsheet_spiflash_write_byte(struct broadsheetfb_par *par, u8 data)
+{
+        broadsheet_write_reg(par, 0x0202, (data | 0x100));
+
+        return broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100);
+}
+
+static int broadsheet_spiflash_read_byte(struct broadsheetfb_par *par, u8 *data)
+{
+        int err;
+        u16 tmp;
+
+        broadsheet_write_reg(par, 0x0202, 0);
+
+        err = broadsheet_spiflash_wait_for_bit(par, 0x0206, 3, 0, 100);
+        if (err)
+                return err;
+
+        tmp = broadsheet_read_reg(par, 0x200);
+
+        *data = tmp & 0xFF;
+
+        return 0;
+}
+
+static int broadsheet_spiflash_wait_for_status(struct broadsheetfb_par *par,
+                                                                int timeout)
+{
+        u8 tmp;
+        int err;
+
+        do {
+                broadsheet_write_reg(par, 0x0208, 1);
+
+                err = broadsheet_spiflash_write_byte(par, 0x05);
+                if (err)
+                        goto failout;
+
+                err = broadsheet_spiflash_read_byte(par, &tmp);
+                if (err)
+                        goto failout;
+
+                broadsheet_write_reg(par, 0x0208, 0);
+
+                if (!(tmp & 0x1))
+                        return 0;
+
+                mdelay(5);
+        } while (timeout--);
+
+        dev_err(par->info->device, "Timed out waiting for spiflash status\n");
+        return -ETIMEDOUT;
+
+failout:
+        broadsheet_write_reg(par, 0x0208, 0);
+        return err;
+}
+
+static int broadsheet_spiflash_op_on_address(struct broadsheetfb_par *par,
+                                                        u8 op, u32 addr)
+{
+        int i;
+        u8 tmp;
+        int err;
+
+        broadsheet_write_reg(par, 0x0208, 1);
+
+        err = broadsheet_spiflash_write_byte(par, op);
+        if (err)
+                return err;
+
+        for (i = 2; i >= 0; i--) {
+                tmp = ((addr >> (i * 8)) & 0xFF);
+                err = broadsheet_spiflash_write_byte(par, tmp);
+                if (err)
+                        return err;
+        }
+
+        return err;
+}
+
+static int broadsheet_verify_spiflash(struct broadsheetfb_par *par,
+                                                int *flash_type)
+{
+        int err = 0;
+        u8 sig;
+
+        err = broadsheet_spiflash_op_on_address(par, 0xAB, 0x00000000);
+        if (err)
+                goto failout;
+
+        err = broadsheet_spiflash_read_byte(par, &sig);
+        if (err)
+                goto failout;
+
+        if ((sig != 0x10) && (sig != 0x11)) {
+                dev_err(par->info->device, "Unexpected flash type\n");
+                err = -EINVAL;
+                goto failout;
+        }
+
+        *flash_type = sig;
+
+failout:
+        broadsheet_write_reg(par, 0x0208, 0);
+        return err;
+}
+
+static int broadsheet_setup_for_wfm_write(struct broadsheetfb_par *par,
+                                        u16 *initial_sfmcd, int *flash_type)
+
+{
+        int err;
+
+        err = broadsheet_setup_plls(par);
+        if (err)
+                return err;
+
+        broadsheet_write_reg(par, 0x0106, 0x0203);
+
+        err = broadsheet_setup_spi(par);
+        if (err)
+                return err;
+
+        err = broadsheet_setup_spiflash(par, initial_sfmcd);
+        if (err)
+                return err;
+
+        return broadsheet_verify_spiflash(par, flash_type);
+}
+
+static int broadsheet_spiflash_write_control(struct broadsheetfb_par *par,
+                                                int mode)
+{
+        int err;
+
+        broadsheet_write_reg(par, 0x0208, 1);
+        if (mode)
+                err = broadsheet_spiflash_write_byte(par, 0x06);
+        else
+                err = broadsheet_spiflash_write_byte(par, 0x04);
+
+        broadsheet_write_reg(par, 0x0208, 0);
+        return err;
+}
+
+static int broadsheet_spiflash_erase_sector(struct broadsheetfb_par *par,
+                                                int addr)
+{
+        int err;
+
+        broadsheet_spiflash_write_control(par, 1);
+
+        err = broadsheet_spiflash_op_on_address(par, 0xD8, addr);
+
+        broadsheet_write_reg(par, 0x0208, 0);
+
+        if (err)
+                return err;
+
+        err = broadsheet_spiflash_wait_for_status(par, 1000);
+
+        return err;
+}
+
+static int broadsheet_spiflash_read_range(struct broadsheetfb_par *par,
+                                                int addr, int size, char *data)
+{
+        int err;
+        int i;
+
+        err = broadsheet_spiflash_op_on_address(par, 0x03, addr);
+        if (err)
+                goto failout;
+
+        for (i = 0; i < size; i++) {
+                err = broadsheet_spiflash_read_byte(par, &data[i]);
+                if (err)
+                        goto failout;
+        }
+
+failout:
+        broadsheet_write_reg(par, 0x0208, 0);
+        return err;
+}
+
+#define BS_SPIFLASH_PAGE_SIZE 256
+static int broadsheet_spiflash_write_page(struct broadsheetfb_par *par,
+                                                int addr, const char *data)
+{
+        int err;
+        int i;
+
+        broadsheet_spiflash_write_control(par, 1);
+
+        err = broadsheet_spiflash_op_on_address(par, 0x02, addr);
+        if (err)
+                goto failout;
+
+        for (i = 0; i < BS_SPIFLASH_PAGE_SIZE; i++) {
+                err = broadsheet_spiflash_write_byte(par, data[i]);
+                if (err)
+                        goto failout;
+        }
+
+        broadsheet_write_reg(par, 0x0208, 0);
+
+        err = broadsheet_spiflash_wait_for_status(par, 100);
+
+failout:
+        return err;
+}
+
+static int broadsheet_spiflash_write_sector(struct broadsheetfb_par *par,
+                                int addr, const char *data, int sector_size)
+{
+        int i;
+        int err;
+
+        for (i = 0; i < sector_size; i += BS_SPIFLASH_PAGE_SIZE) {
+                err = broadsheet_spiflash_write_page(par, addr + i, &data[i]);
+                if (err)
+                        return err;
+        }
+        return 0;
+}
+
+/*
+ * The caller must guarantee that the data to be rewritten is entirely
+ * contained within this sector. That is, data_start_addr + data_len
+ * must be less than sector_start_addr + sector_size.
+ */
+static int broadsheet_spiflash_rewrite_sector(struct broadsheetfb_par *par,
+                                        int sector_size, int data_start_addr,
+                                        int data_len, const char *data)
+{
+        int err;
+        char *sector_buffer;
+        int tail_start_addr;
+        int start_sector_addr;
+
+        sector_buffer = kzalloc(sizeof(char)*sector_size, GFP_KERNEL);
+        if (!sector_buffer)
+                return -ENOMEM;
+
+        /* the start address of the sector is the 0th byte of that sector */
+        start_sector_addr = (data_start_addr / sector_size) * sector_size;
+
+        /*
+         * check if there is head data that we need to readback into our sector
+         * buffer first
+         */
+        if (data_start_addr != start_sector_addr) {
+                /*
+                 * we need to read every byte up till the start address of our
+                 * data and we put it into our sector buffer.
+                 */
+                err = broadsheet_spiflash_read_range(par, start_sector_addr,
+                                                data_start_addr, sector_buffer);
+                if (err)
+                        return err;
+        }
+
+        /* now we copy our data into the right place in the sector buffer */
+        memcpy(sector_buffer + data_start_addr, data, data_len);
+
+        /*
+         * now we check if there is a tail section of the sector that we need to
+         * readback.
+         */
+        tail_start_addr = (data_start_addr + data_len) % sector_size;
+
+        if (tail_start_addr) {
+                int tail_len;
+
+                tail_len = sector_size - tail_start_addr;
+
+                /* now we read this tail into our sector buffer */
+                err = broadsheet_spiflash_read_range(par, tail_start_addr,
+                        tail_len, sector_buffer + tail_start_addr);
+                if (err)
+                        return err;
+        }
+
+        /* if we got here we have the full sector that we want to rewrite. */
+
+        /* first erase the sector */
+        err = broadsheet_spiflash_erase_sector(par, start_sector_addr);
+        if (err)
+                return err;
+
+        /* now write it */
+        err = broadsheet_spiflash_write_sector(par, start_sector_addr,
+                                        sector_buffer, sector_size);
+        return err;
+}
+
+static int broadsheet_write_spiflash(struct broadsheetfb_par *par, u32 wfm_addr,
+                                const u8 *wfm, int bytecount, int flash_type)
+{
+        int sector_size;
+        int err;
+        int cur_addr;
+        int writecount;
+        int maxlen;
+        int offset = 0;
+
+        switch (flash_type) {
+        case 0x10:
+                sector_size = 32*1024;
+                break;
+        case 0x11:
+        default:
+                sector_size = 64*1024;
+                break;
+        }
+
+        while (bytecount) {
+                cur_addr = wfm_addr + offset;
+                maxlen = roundup(cur_addr, sector_size) - cur_addr;
+                writecount = min(bytecount, maxlen);
+
+                err = broadsheet_spiflash_rewrite_sector(par, sector_size,
+                                cur_addr, writecount, wfm + offset);
+                if (err)
+                        return err;
+
+                offset += writecount;
+                bytecount -= writecount;
+        }
+
+        return 0;
+}
+
+static int broadsheet_store_waveform_to_spiflash(struct broadsheetfb_par *par,
+                                                const u8 *wfm, size_t wfm_size)
+{
+        int err = 0;
+        u16 initial_sfmcd = 0;
+        int flash_type = 0;
+
+        err = broadsheet_setup_for_wfm_write(par, &initial_sfmcd, &flash_type);
+        if (err)
+                goto failout;
+
+        err = broadsheet_write_spiflash(par, 0x886, wfm, wfm_size, flash_type);
+
+failout:
+        broadsheet_write_reg(par, 0x0204, initial_sfmcd);
+        return err;
+}
+
+static ssize_t broadsheet_loadstore_waveform(struct device *dev,
+                                                struct device_attribute *attr,
+                                                const char *buf, size_t len)
+{
+        int err;
+        struct fb_info *info = dev_get_drvdata(dev);
+        struct broadsheetfb_par *par = info->par;
+        const struct firmware *fw_entry;
+
+        if (len < 1)
+                return -EINVAL;
+
+        err = request_firmware(&fw_entry, "broadsheet.wbf", dev);
+        if (err < 0) {
+                dev_err(dev, "Failed to get broadsheet waveform\n");
+                goto err_failed;
+        }
+
+        /* try to enforce reasonable min max on waveform */
+        if ((fw_entry->size < 8*1024) || (fw_entry->size > 64*1024)) {
+                dev_err(dev, "Invalid waveform\n");
+                err = -EINVAL;
+                goto err_failed;
+        }
+
+        mutex_lock(&(par->io_lock));
+        err = broadsheet_store_waveform_to_spiflash(par, fw_entry->data,
+                                                        fw_entry->size);
+
+        mutex_unlock(&(par->io_lock));
+        if (err < 0) {
+                dev_err(dev, "Failed to store broadsheet waveform\n");
+                goto err_failed;
+        }
+
+        dev_info(dev, "Stored broadsheet waveform, size %zd\n", fw_entry->size);
+
+        return len;
+
+err_failed:
+        return err;
+}
+static DEVICE_ATTR(loadstore_waveform, S_IWUSR, NULL,
+                        broadsheet_loadstore_waveform);
+
+/* upper level functions that manipulate the display and other stuff */
 static void __devinit broadsheet_init_display(struct broadsheetfb_par *par)
 {
         u16 args[5];
-
-        args[0] = DPY_W;
-        args[1] = DPY_H;
-        args[2] = (100 | (1 << 8) | (1 << 9)); /* sdcfg */
-        args[3] = 2; /* gdrv cfg */
-        args[4] = (4 | (1 << 7)); /* lut index format */
+        int xres = par->info->var.xres;
+        int yres = par->info->var.yres;
+
+        args[0] = panel_table[par->panel_index].w;
+        args[1] = panel_table[par->panel_index].h;
+        args[2] = panel_table[par->panel_index].sdcfg;
+        args[3] = panel_table[par->panel_index].gdcfg;
+        args[4] = panel_table[par->panel_index].lutfmt;
         broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
 
         /* did the controller really set it? */
         broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_CFG, 5, args);
 
-        args[0] = 4; /* fsync len */
-        args[1] = (10 << 8) | 4; /* fend/fbegin len */
-        args[2] = 10; /* line sync len */
-        args[3] = (100 << 8) | 4; /* line end/begin len */
-        args[4] = 6; /* pixel clock cfg */
+        args[0] = panel_table[par->panel_index].fsynclen;
+        args[1] = panel_table[par->panel_index].fendfbegin;
+        args[2] = panel_table[par->panel_index].lsynclen;
+        args[3] = panel_table[par->panel_index].lendlbegin;
+        args[4] = panel_table[par->panel_index].pixclk;
         broadsheet_send_cmdargs(par, BS_CMD_INIT_DSPE_TMG, 5, args);
 
+        broadsheet_write_reg32(par, 0x310, xres*yres*2);
+
         /* setup waveform */
         args[0] = 0x886;
         args[1] = 0;
@@ -207,8 +818,9 @@ static void __devinit broadsheet_init_display(struct broadsheetfb_par *par)
         args[0] = 0x154;
         broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
 
-        broadsheet_burst_write(par, DPY_W*DPY_H/2,
-                                (u16 *) par->info->screen_base);
+        broadsheet_burst_write(par, (panel_table[par->panel_index].w *
+                                        panel_table[par->panel_index].h)/2,
+                                        (u16 *) par->info->screen_base);
 
         broadsheet_send_command(par, BS_CMD_LD_IMG_END);
 
@@ -222,6 +834,21 @@ static void __devinit broadsheet_init_display(struct broadsheetfb_par *par)
         par->board->wait_for_rdy(par);
 }
 
+static void __devinit broadsheet_identify(struct broadsheetfb_par *par)
+{
+        u16 rev, prc;
+        struct device *dev = par->info->device;
+
+        rev = broadsheet_read_reg(par, BS_REG_REV);
+        prc = broadsheet_read_reg(par, BS_REG_PRC);
+        dev_info(dev, "Broadsheet Rev 0x%x, Product Code 0x%x\n", rev, prc);
+
+        if (prc != 0x0047)
+                dev_warn(dev, "Unrecognized Broadsheet Product Code\n");
+        if (rev != 0x0100)
+                dev_warn(dev, "Unrecognized Broadsheet Revision\n");
+}
+
 static void __devinit broadsheet_init(struct broadsheetfb_par *par)
 {
         broadsheet_send_command(par, BS_CMD_INIT_SYS_RUN);
@@ -236,6 +863,7 @@ static void broadsheetfb_dpy_update_pages(struct broadsheetfb_par *par,
         u16 args[5];
         unsigned char *buf = (unsigned char *)par->info->screen_base;
 
+        mutex_lock(&(par->io_lock));
         /* y1 must be a multiple of 4 so drop the lower bits */
         y1 &= 0xFFFC;
         /* y2 must be a multiple of 4 , but - 1 so up the lower bits */
@@ -265,6 +893,7 @@ static void broadsheetfb_dpy_update_pages(struct broadsheetfb_par *par,
         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
 
         par->board->wait_for_rdy(par);
+        mutex_unlock(&(par->io_lock));
 
 }
 
@@ -272,13 +901,15 @@ static void broadsheetfb_dpy_update(struct broadsheetfb_par *par)
 {
         u16 args[5];
 
+        mutex_lock(&(par->io_lock));
         args[0] = 0x3 << 4;
         broadsheet_send_cmdargs(par, BS_CMD_LD_IMG, 1, args);
 
         args[0] = 0x154;
         broadsheet_send_cmdargs(par, BS_CMD_WR_REG, 1, args);
-        broadsheet_burst_write(par, DPY_W*DPY_H/2,
-                                (u16 *) par->info->screen_base);
+        broadsheet_burst_write(par, (panel_table[par->panel_index].w *
+                                        panel_table[par->panel_index].h)/2,
+                                        (u16 *) par->info->screen_base);
 
         broadsheet_send_command(par, BS_CMD_LD_IMG_END);
 
@@ -290,7 +921,7 @@ static void broadsheetfb_dpy_update(struct broadsheetfb_par *par)
         broadsheet_send_command(par, BS_CMD_WAIT_DSPE_FREND);
 
         par->board->wait_for_rdy(par);
-
+        mutex_unlock(&(par->io_lock));
 }
 
 /* this is called back from the deferred io workqueue */
@@ -436,6 +1067,8 @@ static int __devinit broadsheetfb_probe(struct platform_device *dev)
         unsigned char *videomemory;
         struct broadsheetfb_par *par;
         int i;
+        int dpyw, dpyh;
+        int panel_index;
 
         /* pick up board specific routines */
         board = dev->dev.platform_data;
@@ -450,7 +1083,24 @@ static int __devinit broadsheetfb_probe(struct platform_device *dev)
         if (!info)
                 goto err;
 
-        videomemorysize = (DPY_W*DPY_H);
+        switch (board->get_panel_type()) {
+        case 37:
+                panel_index = 1;
+                break;
+        case 97:
+                panel_index = 2;
+                break;
+        case 6:
+        default:
+                panel_index = 0;
+                break;
+        }
+
+        dpyw = panel_table[panel_index].w;
+        dpyh = panel_table[panel_index].h;
+
+        videomemorysize = roundup((dpyw*dpyh), PAGE_SIZE);
+
         videomemory = vmalloc(videomemorysize);
         if (!videomemory)
                 goto err_fb_rel;
@@ -460,16 +1110,25 @@ static int __devinit broadsheetfb_probe(struct platform_device *dev)
         info->screen_base = (char *)videomemory;
         info->fbops = &broadsheetfb_ops;
 
+        broadsheetfb_var.xres = dpyw;
+        broadsheetfb_var.yres = dpyh;
+        broadsheetfb_var.xres_virtual = dpyw;
+        broadsheetfb_var.yres_virtual = dpyh;
         info->var = broadsheetfb_var;
+
+        broadsheetfb_fix.line_length = dpyw;
         info->fix = broadsheetfb_fix;
         info->fix.smem_len = videomemorysize;
         par = info->par;
+        par->panel_index = panel_index;
         par->info = info;
         par->board = board;
         par->write_reg = broadsheet_write_reg;
         par->read_reg = broadsheet_read_reg;
         init_waitqueue_head(&par->waitq);
 
+        mutex_init(&par->io_lock);
+
         info->flags = FBINFO_FLAG_DEFAULT | FBINFO_VIRTFB;
 
         info->fbdefio = &broadsheetfb_defio;
@@ -496,13 +1155,20 @@ static int __devinit broadsheetfb_probe(struct platform_device *dev)
         if (retval < 0)
                 goto err_free_irq;
 
+        broadsheet_identify(par);
+
         broadsheet_init(par);
 
         retval = register_framebuffer(info);
         if (retval < 0)
                 goto err_free_irq;
+
         platform_set_drvdata(dev, info);
 
+        retval = device_create_file(&dev->dev, &dev_attr_loadstore_waveform);
+        if (retval < 0)
+                goto err_unreg_fb;
+
         printk(KERN_INFO
                "fb%d: Broadsheet frame buffer, using %dK of video memory\n",
                info->node, videomemorysize >> 10);
@@ -510,6 +1176,8 @@ static int __devinit broadsheetfb_probe(struct platform_device *dev)
 
         return 0;
 
+err_unreg_fb:
+        unregister_framebuffer(info);
 err_free_irq:
         board->cleanup(par);
 err_cmap:
@@ -530,6 +1198,8 @@ static int __devexit broadsheetfb_remove(struct platform_device *dev)
 
         if (info) {
                 struct broadsheetfb_par *par = info->par;
+
+                device_remove_file(info->dev, &dev_attr_loadstore_waveform);
                 unregister_framebuffer(info);
                 fb_deferred_io_cleanup(info);
                 par->board->cleanup(par);
diff --git a/drivers/video/cobalt_lcdfb.c b/drivers/video/cobalt_lcdfb.c
index 108b89e09a80..5eb61b5adfe8 100644
--- a/drivers/video/cobalt_lcdfb.c
+++ b/drivers/video/cobalt_lcdfb.c
@@ -287,7 +287,7 @@ static struct fb_ops cobalt_lcd_fbops = {
         .fb_cursor      = cobalt_lcdfb_cursor,
 };
 
-static int __init cobalt_lcdfb_probe(struct platform_device *dev)
+static int __devinit cobalt_lcdfb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
         struct resource *res;
diff --git a/drivers/video/efifb.c b/drivers/video/efifb.c
index d25df51bb0d2..581d2dbf675a 100644
--- a/drivers/video/efifb.c
+++ b/drivers/video/efifb.c
@@ -210,7 +210,7 @@ static int __init efifb_setup(char *options)
         return 0;
 }
 
-static int __init efifb_probe(struct platform_device *dev)
+static int __devinit efifb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
         int err;
diff --git a/drivers/video/epson1355fb.c b/drivers/video/epson1355fb.c
index 2735b79e52a1..6d755bb3a2bc 100644
--- a/drivers/video/epson1355fb.c
+++ b/drivers/video/epson1355fb.c
@@ -602,7 +602,7 @@ static int epson1355fb_remove(struct platform_device *dev)
         return 0;
 }
 
-int __init epson1355fb_probe(struct platform_device *dev)
+int __devinit epson1355fb_probe(struct platform_device *dev)
 {
         struct epson1355_par *default_par;
         struct fb_info *info;
diff --git a/drivers/video/gbefb.c b/drivers/video/gbefb.c
index 695fa013fe7e..5643a35c1746 100644
--- a/drivers/video/gbefb.c
+++ b/drivers/video/gbefb.c
@@ -1128,7 +1128,7 @@ static int __init gbefb_setup(char *options)
         return 0;
 }
 
-static int __init gbefb_probe(struct platform_device *p_dev)
+static int __devinit gbefb_probe(struct platform_device *p_dev)
 {
         int i, ret = 0;
         struct fb_info *info;
diff --git a/drivers/video/hgafb.c b/drivers/video/hgafb.c
index 0129c044f6d6..db9b785b56eb 100644
--- a/drivers/video/hgafb.c
+++ b/drivers/video/hgafb.c
@@ -551,7 +551,7 @@ static struct fb_ops hgafb_ops = {
          *  Initialization
          */
 
-static int __init hgafb_probe(struct platform_device *pdev)
+static int __devinit hgafb_probe(struct platform_device *pdev)
 {
         struct fb_info *info;
 
diff --git a/drivers/video/hitfb.c b/drivers/video/hitfb.c
index 73c83a8de2d3..bf78779199c6 100644
--- a/drivers/video/hitfb.c
+++ b/drivers/video/hitfb.c
@@ -325,7 +325,7 @@ static struct fb_ops hitfb_ops = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-static int __init hitfb_probe(struct platform_device *dev)
+static int __devinit hitfb_probe(struct platform_device *dev)
 {
         unsigned short lcdclor, ldr3, ldvndr;
         struct fb_info *info;
diff --git a/drivers/video/mb862xx/mb862xxfb.c b/drivers/video/mb862xx/mb862xxfb.c
index fabb0c59a211..8280a58a0e55 100644
--- a/drivers/video/mb862xx/mb862xxfb.c
+++ b/drivers/video/mb862xx/mb862xxfb.c
@@ -31,15 +31,6 @@
 #define CARMINE_MEM_SIZE        0x8000000
 #define DRV_NAME                "mb862xxfb"
 
-#if defined(CONFIG_LWMON5)
-static struct mb862xx_gc_mode lwmon5_gc_mode = {
-        /* Mode for Sharp LQ104V1DG61 TFT LCD Panel */
-        { "640x480", 60, 640, 480, 40000, 48, 16, 32, 11, 96, 2, 0, 0, 0 },
-        /* 16 bits/pixel, 32MB, 100MHz, SDRAM memory mode value */
-        16, 0x2000000, GC_CCF_COT_100, 0x414fb7f2
-};
-#endif
-
 #if defined(CONFIG_SOCRATES)
 static struct mb862xx_gc_mode socrates_gc_mode = {
         /* Mode for Prime View PM070WL4 TFT LCD Panel */
@@ -600,10 +591,6 @@ static int __devinit of_platform_mb862xx_probe(struct of_device *ofdev,
                 goto irqdisp;
         }
 
-#if defined(CONFIG_LWMON5)
-        par->gc_mode = &lwmon5_gc_mode;
-#endif
-
 #if defined(CONFIG_SOCRATES)
         par->gc_mode = &socrates_gc_mode;
 #endif
diff --git a/drivers/video/modedb.c b/drivers/video/modedb.c
index 0129f1bc3522..b895aae41630 100644
--- a/drivers/video/modedb.c
+++ b/drivers/video/modedb.c
@@ -893,7 +893,7 @@ const struct fb_videomode *fb_match_mode(const struct fb_var_screeninfo *var,
 }
 
 /**
- * fb_add_videomode: adds videomode entry to modelist
+ * fb_add_videomode - adds videomode entry to modelist
  * @mode: videomode to add
  * @head: struct list_head of modelist
  *
@@ -928,7 +928,7 @@ int fb_add_videomode(const struct fb_videomode *mode, struct list_head *head)
 }
 
 /**
- * fb_delete_videomode: removed videomode entry from modelist
+ * fb_delete_videomode - removed videomode entry from modelist
  * @mode: videomode to remove
  * @head: struct list_head of modelist
  *
@@ -953,7 +953,7 @@ void fb_delete_videomode(const struct fb_videomode *mode,
 }
 
 /**
- * fb_destroy_modelist: destroy modelist
+ * fb_destroy_modelist - destroy modelist
  * @head: struct list_head of modelist
  */
 void fb_destroy_modelist(struct list_head *head)
@@ -968,7 +968,7 @@ void fb_destroy_modelist(struct list_head *head)
 EXPORT_SYMBOL_GPL(fb_destroy_modelist);
 
 /**
- * fb_videomode_to_modelist: convert mode array to mode list
+ * fb_videomode_to_modelist - convert mode array to mode list
  * @modedb: array of struct fb_videomode
  * @num: number of entries in array
  * @head: struct list_head of modelist
diff --git a/drivers/video/nuc900fb.c b/drivers/video/nuc900fb.c
new file mode 100644
index 000000000000..6bf0d460a738
--- /dev/null
+++ b/drivers/video/nuc900fb.c
@@ -0,0 +1,779 @@
+/*
+ *
+ * Copyright (c) 2009 Nuvoton technology corporation
+ * 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.
+ *
+ *  Description:
+ *    Nuvoton LCD Controller Driver
+ *  Author:
+ *    Wang Qiang (rurality.linux@gmail.com) 2009/12/11
+ */
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/mm.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include <linux/fb.h>
+#include <linux/init.h>
+#include <linux/dma-mapping.h>
+#include <linux/interrupt.h>
+#include <linux/workqueue.h>
+#include <linux/wait.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/cpufreq.h>
+#include <linux/io.h>
+#include <linux/pm.h>
+#include <linux/device.h>
+
+#include <mach/map.h>
+#include <mach/regs-clock.h>
+#include <mach/regs-ldm.h>
+#include <mach/fb.h>
+#include <mach/clkdev.h>
+
+#include "nuc900fb.h"
+
+
+/*
+ *  Initialize the nuc900 video (dual) buffer address
+ */
+static void nuc900fb_set_lcdaddr(struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        void __iomem *regs = fbi->io;
+        unsigned long vbaddr1, vbaddr2;
+
+        vbaddr1  = info->fix.smem_start;
+        vbaddr2  = info->fix.smem_start;
+        vbaddr2 += info->fix.line_length * info->var.yres;
+
+        /* set frambuffer start phy addr*/
+        writel(vbaddr1, regs + REG_LCM_VA_BADDR0);
+        writel(vbaddr2, regs + REG_LCM_VA_BADDR1);
+
+        writel(fbi->regs.lcd_va_fbctrl, regs + REG_LCM_VA_FBCTRL);
+        writel(fbi->regs.lcd_va_scale, regs + REG_LCM_VA_SCALE);
+}
+
+/*
+ *      calculate divider for lcd div
+ */
+static unsigned int nuc900fb_calc_pixclk(struct nuc900fb_info *fbi,
+                                         unsigned long pixclk)
+{
+        unsigned long clk = fbi->clk_rate;
+        unsigned long long div;
+
+        /* pixclk is in picseconds. our clock is in Hz*/
+        /* div = (clk * pixclk)/10^12 */
+        div = (unsigned long long)clk * pixclk;
+        div >>= 12;
+        do_div(div, 625 * 625UL * 625);
+
+        dev_dbg(fbi->dev, "pixclk %ld, divisor is %lld\n", pixclk, div);
+
+        return div;
+}
+
+/*
+ *      Check the video params of 'var'.
+ */
+static int nuc900fb_check_var(struct fb_var_screeninfo *var,
+                               struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        struct nuc900fb_mach_info *mach_info = fbi->dev->platform_data;
+        struct nuc900fb_display *display = NULL;
+        struct nuc900fb_display *default_display = mach_info->displays +
+                                                   mach_info->default_display;
+        int i;
+
+        dev_dbg(fbi->dev, "check_var(var=%p, info=%p)\n", var, info);
+
+        /* validate x/y resolution */
+        /* choose default mode if possible */
+        if (var->xres == default_display->xres &&
+            var->yres == default_display->yres &&
+            var->bits_per_pixel == default_display->bpp)
+                display = default_display;
+        else
+                for (i = 0; i < mach_info->num_displays; i++)
+                        if (var->xres == mach_info->displays[i].xres &&
+                            var->yres == mach_info->displays[i].yres &&
+                            var->bits_per_pixel == mach_info->displays[i].bpp) {
+                                display = mach_info->displays + i;
+                                break;
+                        }
+
+        if (display == NULL) {
+                printk(KERN_ERR "wrong resolution or depth %dx%d at %d bit per pixel\n",
+                        var->xres, var->yres, var->bits_per_pixel);
+                return -EINVAL;
+        }
+
+        /* it should be the same size as the display */
+        var->xres_virtual       = display->xres;
+        var->yres_virtual       = display->yres;
+        var->height             = display->height;
+        var->width              = display->width;
+
+        /* copy lcd settings */
+        var->pixclock           = display->pixclock;
+        var->left_margin        = display->left_margin;
+        var->right_margin       = display->right_margin;
+        var->upper_margin       = display->upper_margin;
+        var->lower_margin       = display->lower_margin;
+        var->vsync_len          = display->vsync_len;
+        var->hsync_len          = display->hsync_len;
+
+        var->transp.offset      = 0;
+        var->transp.length      = 0;
+
+        fbi->regs.lcd_dccs = display->dccs;
+        fbi->regs.lcd_device_ctrl = display->devctl;
+        fbi->regs.lcd_va_fbctrl = display->fbctrl;
+        fbi->regs.lcd_va_scale = display->scale;
+
+        /* set R/G/B possions */
+        switch (var->bits_per_pixel) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+        default:
+                var->red.offset         = 0;
+                var->red.length         = var->bits_per_pixel;
+                var->green              = var->red;
+                var->blue               = var->red;
+                break;
+        case 12:
+                var->red.length         = 4;
+                var->green.length       = 4;
+                var->blue.length        = 4;
+                var->red.offset         = 8;
+                var->green.offset       = 4;
+                var->blue.offset        = 0;
+                break;
+        case 16:
+                var->red.length         = 5;
+                var->green.length       = 6;
+                var->blue.length        = 5;
+                var->red.offset         = 11;
+                var->green.offset       = 5;
+                var->blue.offset        = 0;
+                break;
+        case 18:
+                var->red.length         = 6;
+                var->green.length       = 6;
+                var->blue.length        = 6;
+                var->red.offset         = 12;
+                var->green.offset       = 6;
+                var->blue.offset        = 0;
+                break;
+        case 32:
+                var->red.length         = 8;
+                var->green.length       = 8;
+                var->blue.length        = 8;
+                var->red.offset         = 16;
+                var->green.offset       = 8;
+                var->blue.offset        = 0;
+                break;
+        }
+
+        return 0;
+}
+
+/*
+ *      Calculate lcd register values from var setting & save into hw
+ */
+static void nuc900fb_calculate_lcd_regs(const struct fb_info *info,
+                                        struct nuc900fb_hw *regs)
+{
+        const struct fb_var_screeninfo *var = &info->var;
+        int vtt = var->height + var->upper_margin + var->lower_margin;
+        int htt = var->width + var->left_margin + var->right_margin;
+        int hsync = var->width + var->right_margin;
+        int vsync = var->height + var->lower_margin;
+
+        regs->lcd_crtc_size = LCM_CRTC_SIZE_VTTVAL(vtt) |
+                              LCM_CRTC_SIZE_HTTVAL(htt);
+        regs->lcd_crtc_dend = LCM_CRTC_DEND_VDENDVAL(var->height) |
+                              LCM_CRTC_DEND_HDENDVAL(var->width);
+        regs->lcd_crtc_hr = LCM_CRTC_HR_EVAL(var->width + 5) |
+                            LCM_CRTC_HR_SVAL(var->width + 1);
+        regs->lcd_crtc_hsync = LCM_CRTC_HSYNC_EVAL(hsync + var->hsync_len) |
+                               LCM_CRTC_HSYNC_SVAL(hsync);
+        regs->lcd_crtc_vr = LCM_CRTC_VR_EVAL(vsync + var->vsync_len) |
+                            LCM_CRTC_VR_SVAL(vsync);
+
+}
+
+/*
+ *      Activate (set) the controller from the given framebuffer
+ *      information
+ */
+static void nuc900fb_activate_var(struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        void __iomem *regs = fbi->io;
+        struct fb_var_screeninfo *var = &info->var;
+        int clkdiv;
+
+        clkdiv = nuc900fb_calc_pixclk(fbi, var->pixclock) - 1;
+        if (clkdiv < 0)
+                clkdiv = 0;
+
+        nuc900fb_calculate_lcd_regs(info, &fbi->regs);
+
+        /* set the new lcd registers*/
+
+        dev_dbg(fbi->dev, "new lcd register set:\n");
+        dev_dbg(fbi->dev, "dccs       = 0x%08x\n", fbi->regs.lcd_dccs);
+        dev_dbg(fbi->dev, "dev_ctl    = 0x%08x\n", fbi->regs.lcd_device_ctrl);
+        dev_dbg(fbi->dev, "crtc_size  = 0x%08x\n", fbi->regs.lcd_crtc_size);
+        dev_dbg(fbi->dev, "crtc_dend  = 0x%08x\n", fbi->regs.lcd_crtc_dend);
+        dev_dbg(fbi->dev, "crtc_hr    = 0x%08x\n", fbi->regs.lcd_crtc_hr);
+        dev_dbg(fbi->dev, "crtc_hsync = 0x%08x\n", fbi->regs.lcd_crtc_hsync);
+        dev_dbg(fbi->dev, "crtc_vr    = 0x%08x\n", fbi->regs.lcd_crtc_vr);
+
+        writel(fbi->regs.lcd_device_ctrl, regs + REG_LCM_DEV_CTRL);
+        writel(fbi->regs.lcd_crtc_size, regs + REG_LCM_CRTC_SIZE);
+        writel(fbi->regs.lcd_crtc_dend, regs + REG_LCM_CRTC_DEND);
+        writel(fbi->regs.lcd_crtc_hr, regs + REG_LCM_CRTC_HR);
+        writel(fbi->regs.lcd_crtc_hsync, regs + REG_LCM_CRTC_HSYNC);
+        writel(fbi->regs.lcd_crtc_vr, regs + REG_LCM_CRTC_VR);
+
+        /* set lcd address pointers */
+        nuc900fb_set_lcdaddr(info);
+
+        writel(fbi->regs.lcd_dccs, regs + REG_LCM_DCCS);
+}
+
+/*
+ *      Alters the hardware state.
+ *
+ */
+static int nuc900fb_set_par(struct fb_info *info)
+{
+        struct fb_var_screeninfo *var = &info->var;
+
+        switch (var->bits_per_pixel) {
+        case 32:
+        case 24:
+        case 18:
+        case 16:
+        case 12:
+                info->fix.visual = FB_VISUAL_TRUECOLOR;
+                break;
+        case 1:
+                info->fix.visual = FB_VISUAL_MONO01;
+                break;
+        default:
+                info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
+                break;
+        }
+
+        info->fix.line_length = (var->xres_virtual * var->bits_per_pixel) / 8;
+
+        /* activate this new configuration */
+        nuc900fb_activate_var(info);
+        return 0;
+}
+
+static inline unsigned int chan_to_field(unsigned int chan,
+                                         struct fb_bitfield *bf)
+{
+        chan &= 0xffff;
+        chan >>= 16 - bf->length;
+        return chan << bf->offset;
+}
+
+static int nuc900fb_setcolreg(unsigned regno,
+                               unsigned red, unsigned green, unsigned blue,
+                               unsigned transp, struct fb_info *info)
+{
+        unsigned int val;
+
+        switch (info->fix.visual) {
+        case FB_VISUAL_TRUECOLOR:
+                /* true-colour, use pseuo-palette */
+                if (regno < 16) {
+                        u32 *pal = info->pseudo_palette;
+
+                        val  = chan_to_field(red, &info->var.red);
+                        val |= chan_to_field(green, &info->var.green);
+                        val |= chan_to_field(blue, &info->var.blue);
+                        pal[regno] = val;
+                }
+                break;
+
+        default:
+                return 1;   /* unknown type */
+        }
+        return 0;
+}
+
+/**
+ *      nuc900fb_blank
+ *
+ */
+static int nuc900fb_blank(int blank_mode, struct fb_info *info)
+{
+
+        return 0;
+}
+
+static struct fb_ops nuc900fb_ops = {
+        .owner                  = THIS_MODULE,
+        .fb_check_var           = nuc900fb_check_var,
+        .fb_set_par             = nuc900fb_set_par,
+        .fb_blank               = nuc900fb_blank,
+        .fb_setcolreg           = nuc900fb_setcolreg,
+        .fb_fillrect            = cfb_fillrect,
+        .fb_copyarea            = cfb_copyarea,
+        .fb_imageblit           = cfb_imageblit,
+};
+
+
+static inline void modify_gpio(void __iomem *reg,
+                               unsigned long set, unsigned long mask)
+{
+        unsigned long tmp;
+        tmp = readl(reg) & ~mask;
+        writel(tmp | set, reg);
+}
+
+/*
+ * Initialise LCD-related registers
+ */
+static int nuc900fb_init_registers(struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        struct nuc900fb_mach_info *mach_info = fbi->dev->platform_data;
+        void __iomem *regs = fbi->io;
+
+        /*reset the display engine*/
+        writel(0, regs + REG_LCM_DCCS);
+        writel(readl(regs + REG_LCM_DCCS) | LCM_DCCS_ENG_RST,
+               regs + REG_LCM_DCCS);
+        ndelay(100);
+        writel(readl(regs + REG_LCM_DCCS) & (~LCM_DCCS_ENG_RST),
+               regs + REG_LCM_DCCS);
+        ndelay(100);
+
+        writel(0, regs + REG_LCM_DEV_CTRL);
+
+        /* config gpio output */
+        modify_gpio(W90X900_VA_GPIO + 0x54, mach_info->gpio_dir,
+                    mach_info->gpio_dir_mask);
+        modify_gpio(W90X900_VA_GPIO + 0x58, mach_info->gpio_data,
+                    mach_info->gpio_data_mask);
+
+        return 0;
+}
+
+
+/*
+ *    Alloc the SDRAM region of NUC900 for the frame buffer.
+ *    The buffer should be a non-cached, non-buffered, memory region
+ *    to allow palette and pixel writes without flushing the cache.
+ */
+static int __init nuc900fb_map_video_memory(struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        dma_addr_t map_dma;
+        unsigned long map_size = PAGE_ALIGN(info->fix.smem_len);
+
+        dev_dbg(fbi->dev, "nuc900fb_map_video_memory(fbi=%p) map_size %lu\n",
+                fbi, map_size);
+
+        info->screen_base = dma_alloc_writecombine(fbi->dev, map_size,
+                                                        &map_dma, GFP_KERNEL);
+
+        if (!info->screen_base)
+                return -ENOMEM;
+
+        memset(info->screen_base, 0x00, map_size);
+        info->fix.smem_start = map_dma;
+
+        return 0;
+}
+
+static inline void nuc900fb_unmap_video_memory(struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
+                              info->screen_base, info->fix.smem_start);
+}
+
+static irqreturn_t nuc900fb_irqhandler(int irq, void *dev_id)
+{
+        struct nuc900fb_info *fbi = dev_id;
+        void __iomem *regs = fbi->io;
+        void __iomem *irq_base = fbi->irq_base;
+        unsigned long lcdirq = readl(regs + REG_LCM_INT_CS);
+
+        if (lcdirq & LCM_INT_CS_DISP_F_STATUS) {
+                writel(readl(irq_base) | 1<<30, irq_base);
+
+                /* wait VA_EN low */
+                if ((readl(regs + REG_LCM_DCCS) &
+                    LCM_DCCS_SINGLE) == LCM_DCCS_SINGLE)
+                        while ((readl(regs + REG_LCM_DCCS) &
+                               LCM_DCCS_VA_EN) == LCM_DCCS_VA_EN)
+                                ;
+                /* display_out-enable */
+                writel(readl(regs + REG_LCM_DCCS) | LCM_DCCS_DISP_OUT_EN,
+                        regs + REG_LCM_DCCS);
+                /* va-enable*/
+                writel(readl(regs + REG_LCM_DCCS) | LCM_DCCS_VA_EN,
+                        regs + REG_LCM_DCCS);
+        } else if (lcdirq & LCM_INT_CS_UNDERRUN_INT) {
+                writel(readl(irq_base) | LCM_INT_CS_UNDERRUN_INT, irq_base);
+        } else if (lcdirq & LCM_INT_CS_BUS_ERROR_INT) {
+                writel(readl(irq_base) | LCM_INT_CS_BUS_ERROR_INT, irq_base);
+        }
+
+        return IRQ_HANDLED;
+}
+
+#ifdef CONFIG_CPU_FREQ
+
+static int nuc900fb_cpufreq_transition(struct notifier_block *nb,
+                                       unsigned long val, void *data)
+{
+        struct nuc900fb_info *info;
+        struct fb_info *fbinfo;
+        long delta_f;
+        info = container_of(nb, struct nuc900fb_info, freq_transition);
+        fbinfo = platform_get_drvdata(to_platform_device(info->dev));
+
+        delta_f = info->clk_rate - clk_get_rate(info->clk);
+
+        if ((val == CPUFREQ_POSTCHANGE && delta_f > 0) ||
+           (val == CPUFREQ_PRECHANGE && delta_f < 0)) {
+                info->clk_rate = clk_get_rate(info->clk);
+                nuc900fb_activate_var(fbinfo);
+        }
+
+        return 0;
+}
+
+static inline int nuc900fb_cpufreq_register(struct nuc900fb_info *fbi)
+{
+        fbi->freq_transition.notifier_call = nuc900fb_cpufreq_transition;
+        return cpufreq_register_notifier(&fbi->freq_transition,
+                                  CPUFREQ_TRANSITION_NOTIFIER);
+}
+
+static inline void nuc900fb_cpufreq_deregister(struct nuc900fb_info *fbi)
+{
+        cpufreq_unregister_notifier(&fbi->freq_transition,
+                                    CPUFREQ_TRANSITION_NOTIFIER);
+}
+#else
+static inline int nuc900fb_cpufreq_transition(struct notifier_block *nb,
+                                       unsigned long val, void *data)
+{
+        return 0;
+}
+
+static inline int nuc900fb_cpufreq_register(struct nuc900fb_info *fbi)
+{
+        return 0;
+}
+
+static inline void nuc900fb_cpufreq_deregister(struct nuc900fb_info *info)
+{
+}
+#endif
+
+static char driver_name[] = "nuc900fb";
+
+static int __devinit nuc900fb_probe(struct platform_device *pdev)
+{
+        struct nuc900fb_info *fbi;
+        struct nuc900fb_display *display;
+        struct fb_info     *fbinfo;
+        struct nuc900fb_mach_info *mach_info;
+        struct resource *res;
+        int ret;
+        int irq;
+        int i;
+        int size;
+
+        dev_dbg(&pdev->dev, "devinit\n");
+        mach_info = pdev->dev.platform_data;
+        if (mach_info == NULL) {
+                dev_err(&pdev->dev,
+                        "no platform data for lcd, cannot attach\n");
+                return -EINVAL;
+        }
+
+        if (mach_info->default_display > mach_info->num_displays) {
+                dev_err(&pdev->dev,
+                        "default display No. is %d but only %d displays \n",
+                        mach_info->default_display, mach_info->num_displays);
+                return -EINVAL;
+        }
+
+
+        display = mach_info->displays + mach_info->default_display;
+
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "no irq for device\n");
+                return -ENOENT;
+        }
+
+        fbinfo = framebuffer_alloc(sizeof(struct nuc900fb_info), &pdev->dev);
+        if (!fbinfo)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, fbinfo);
+
+        fbi = fbinfo->par;
+        fbi->dev = &pdev->dev;
+
+#ifdef CONFIG_CPU_NUC950
+        fbi->drv_type = LCDDRV_NUC950;
+#endif
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        size = (res->end - res->start) + 1;
+        fbi->mem = request_mem_region(res->start, size, pdev->name);
+        if (fbi->mem == NULL) {
+                dev_err(&pdev->dev, "failed to alloc memory region\n");
+                ret = -ENOENT;
+                goto free_fb;
+        }
+
+        fbi->io = ioremap(res->start, size);
+        if (fbi->io == NULL) {
+                dev_err(&pdev->dev, "ioremap() of lcd registers failed\n");
+                ret = -ENXIO;
+                goto release_mem_region;
+        }
+
+        fbi->irq_base = fbi->io + REG_LCM_INT_CS;
+
+
+        /* Stop the LCD */
+        writel(0, fbi->io + REG_LCM_DCCS);
+
+        /* fill the fbinfo*/
+        strcpy(fbinfo->fix.id, driver_name);
+        fbinfo->fix.type                = FB_TYPE_PACKED_PIXELS;
+        fbinfo->fix.type_aux            = 0;
+        fbinfo->fix.xpanstep            = 0;
+        fbinfo->fix.ypanstep            = 0;
+        fbinfo->fix.ywrapstep           = 0;
+        fbinfo->fix.accel               = FB_ACCEL_NONE;
+        fbinfo->var.nonstd              = 0;
+        fbinfo->var.activate            = FB_ACTIVATE_NOW;
+        fbinfo->var.accel_flags         = 0;
+        fbinfo->var.vmode               = FB_VMODE_NONINTERLACED;
+        fbinfo->fbops                   = &nuc900fb_ops;
+        fbinfo->flags                   = FBINFO_FLAG_DEFAULT;
+        fbinfo->pseudo_palette          = &fbi->pseudo_pal;
+
+        ret = request_irq(irq, nuc900fb_irqhandler, IRQF_DISABLED,
+                          pdev->name, fbinfo);
+        if (ret) {
+                dev_err(&pdev->dev, "cannot register irq handler %d -err %d\n",
+                        irq, ret);
+                ret = -EBUSY;
+                goto release_regs;
+        }
+
+        nuc900_driver_clksrc_div(&pdev->dev, "ext", 0x2);
+
+        fbi->clk = clk_get(&pdev->dev, NULL);
+        if (!fbi->clk || IS_ERR(fbi->clk)) {
+                printk(KERN_ERR "nuc900-lcd:failed to get lcd clock source\n");
+                ret = -ENOENT;
+                goto release_irq;
+        }
+
+        clk_enable(fbi->clk);
+        dev_dbg(&pdev->dev, "got and enabled clock\n");
+
+        fbi->clk_rate = clk_get_rate(fbi->clk);
+
+        /* calutate the video buffer size */
+        for (i = 0; i < mach_info->num_displays; i++) {
+                unsigned long smem_len = mach_info->displays[i].xres;
+                smem_len *= mach_info->displays[i].yres;
+                smem_len *= mach_info->displays[i].bpp;
+                smem_len >>= 3;
+                if (fbinfo->fix.smem_len < smem_len)
+                        fbinfo->fix.smem_len = smem_len;
+        }
+
+        /* Initialize Video Memory */
+        ret = nuc900fb_map_video_memory(fbinfo);
+        if (ret) {
+                printk(KERN_ERR "Failed to allocate video RAM: %x\n", ret);
+                goto release_clock;
+        }
+
+        dev_dbg(&pdev->dev, "got video memory\n");
+
+        fbinfo->var.xres = display->xres;
+        fbinfo->var.yres = display->yres;
+        fbinfo->var.bits_per_pixel = display->bpp;
+
+        nuc900fb_init_registers(fbinfo);
+
+        nuc900fb_check_var(&fbinfo->var, fbinfo);
+
+        ret = nuc900fb_cpufreq_register(fbi);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to register cpufreq\n");
+                goto free_video_memory;
+        }
+
+        ret = register_framebuffer(fbinfo);
+        if (ret) {
+                printk(KERN_ERR "failed to register framebuffer device: %d\n",
+                        ret);
+                goto free_cpufreq;
+        }
+
+        printk(KERN_INFO "fb%d: %s frame buffer device\n",
+                fbinfo->node, fbinfo->fix.id);
+
+        return 0;
+
+free_cpufreq:
+        nuc900fb_cpufreq_deregister(fbi);
+free_video_memory:
+        nuc900fb_unmap_video_memory(fbinfo);
+release_clock:
+        clk_disable(fbi->clk);
+        clk_put(fbi->clk);
+release_irq:
+        free_irq(irq, fbi);
+release_regs:
+        iounmap(fbi->io);
+release_mem_region:
+        release_mem_region((unsigned long)fbi->mem, size);
+free_fb:
+        framebuffer_release(fbinfo);
+        return ret;
+}
+
+/*
+ * shutdown the lcd controller
+ */
+static void nuc900fb_stop_lcd(struct fb_info *info)
+{
+        struct nuc900fb_info *fbi = info->par;
+        void __iomem *regs = fbi->io;
+
+        writel((~LCM_DCCS_DISP_INT_EN) | (~LCM_DCCS_VA_EN) | (~LCM_DCCS_OSD_EN),
+                regs + REG_LCM_DCCS);
+}
+
+/*
+ *  Cleanup
+ */
+static int nuc900fb_remove(struct platform_device *pdev)
+{
+        struct fb_info *fbinfo = platform_get_drvdata(pdev);
+        struct nuc900fb_info *fbi = fbinfo->par;
+        int irq;
+
+        nuc900fb_stop_lcd(fbinfo);
+        msleep(1);
+
+        nuc900fb_unmap_video_memory(fbinfo);
+
+        iounmap(fbi->io);
+
+        irq = platform_get_irq(pdev, 0);
+        free_irq(irq, fbi);
+
+        release_resource(fbi->mem);
+        kfree(fbi->mem);
+
+        platform_set_drvdata(pdev, NULL);
+        framebuffer_release(fbinfo);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+/*
+ *      suspend and resume support for the lcd controller
+ */
+
+static int nuc900fb_suspend(struct platform_device *dev, pm_message_t state)
+{
+        struct fb_info     *fbinfo = platform_get_drvdata(dev);
+        struct nuc900fb_info *info = fbinfo->par;
+
+        nuc900fb_stop_lcd();
+        msleep(1);
+        clk_disable(info->clk);
+        return 0;
+}
+
+static int nuc900fb_resume(struct platform_device *dev)
+{
+        struct fb_info     *fbinfo = platform_get_drvdata(dev);
+        struct nuc900fb_info *fbi = fbinfo->par;
+
+        printk(KERN_INFO "nuc900fb resume\n");
+
+        clk_enable(fbi->clk);
+        msleep(1);
+
+        nuc900fb_init_registers(fbinfo);
+        nuc900fb_activate_var(bfinfo);
+
+        return 0;
+}
+
+#else
+#define nuc900fb_suspend NULL
+#define nuc900fb_resume  NULL
+#endif
+
+static struct platform_driver nuc900fb_driver = {
+        .probe          = nuc900fb_probe,
+        .remove         = nuc900fb_remove,
+        .suspend        = nuc900fb_suspend,
+        .resume         = nuc900fb_resume,
+        .driver         = {
+                .name   = "nuc900-lcd",
+                .owner  = THIS_MODULE,
+        },
+};
+
+int __devinit nuc900fb_init(void)
+{
+        return platform_driver_register(&nuc900fb_driver);
+}
+
+static void __exit nuc900fb_cleanup(void)
+{
+        platform_driver_unregister(&nuc900fb_driver);
+}
+
+module_init(nuc900fb_init);
+module_exit(nuc900fb_cleanup);
+
+MODULE_DESCRIPTION("Framebuffer driver for the NUC900");
+MODULE_LICENSE("GPL");
diff --git a/drivers/video/nuc900fb.h b/drivers/video/nuc900fb.h
new file mode 100644
index 000000000000..6c23aa3d3b89
--- /dev/null
+++ b/drivers/video/nuc900fb.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright (c) 2009 Nuvoton technology corporation
+ * 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.
+ *
+ *   Auther:
+ *        Wang Qiang(rurality.linux@gmail.com)  2009/12/16
+ */
+
+#ifndef __NUC900FB_H
+#define __NUC900FB_H
+
+#include <mach/map.h>
+#include <mach/fb.h>
+
+enum nuc900_lcddrv_type {
+        LCDDRV_NUC910,
+        LCDDRV_NUC930,
+        LCDDRV_NUC932,
+        LCDDRV_NUC950,
+        LCDDRV_NUC960,
+};
+
+
+#define PALETTE_BUFFER_SIZE     256
+#define PALETTE_BUFF_CLEAR      (0x80000000) /* entry is clear/invalid */
+
+struct nuc900fb_info {
+        struct device           *dev;
+        struct clk              *clk;
+
+        struct resource         *mem;
+        void __iomem            *io;
+        void __iomem            *irq_base;
+        int                     drv_type;
+        struct nuc900fb_hw      regs;
+        unsigned long           clk_rate;
+
+#ifdef CONFIG_CPU_FREQ
+        struct notifier_block   freq_transition;
+#endif
+
+        /* keep these registers in case we need to re-write palette */
+        u32                     palette_buffer[PALETTE_BUFFER_SIZE];
+        u32                     pseudo_pal[16];
+};
+
+int nuc900fb_init(void);
+
+#endif /* __NUC900FB_H */
diff --git a/drivers/video/omap2/dss/manager.c b/drivers/video/omap2/dss/manager.c
index 913142d4cab1..9acef00c47ea 100644
--- a/drivers/video/omap2/dss/manager.c
+++ b/drivers/video/omap2/dss/manager.c
@@ -341,7 +341,7 @@ static ssize_t manager_attr_store(struct kobject *kobj, struct attribute *attr,
         return manager_attr->store(manager, buf, size);
 }
 
-static struct sysfs_ops manager_sysfs_ops = {
+static const struct sysfs_ops manager_sysfs_ops = {
         .show = manager_attr_show,
         .store = manager_attr_store,
 };
diff --git a/drivers/video/omap2/dss/overlay.c b/drivers/video/omap2/dss/overlay.c
index 0c5bea263ac6..aed3f3194347 100644
--- a/drivers/video/omap2/dss/overlay.c
+++ b/drivers/video/omap2/dss/overlay.c
@@ -320,7 +320,7 @@ static ssize_t overlay_attr_store(struct kobject *kobj, struct attribute *attr,
         return overlay_attr->store(overlay, buf, size);
 }
 
-static struct sysfs_ops overlay_sysfs_ops = {
+static const struct sysfs_ops overlay_sysfs_ops = {
         .show = overlay_attr_show,
         .store = overlay_attr_store,
 };
diff --git a/drivers/video/q40fb.c b/drivers/video/q40fb.c
index 4beac1df617b..de40a626dc76 100644
--- a/drivers/video/q40fb.c
+++ b/drivers/video/q40fb.c
@@ -85,7 +85,7 @@ static struct fb_ops q40fb_ops = {
         .fb_imageblit   = cfb_imageblit,
 };
 
-static int __init q40fb_probe(struct platform_device *dev)
+static int __devinit q40fb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
 
diff --git a/drivers/video/s3c2410fb.c b/drivers/video/s3c2410fb.c
index aac661225c78..2b094dec4a56 100644
--- a/drivers/video/s3c2410fb.c
+++ b/drivers/video/s3c2410fb.c
@@ -1004,12 +1004,12 @@ dealloc_fb:
         return ret;
 }
 
-static int __init s3c2410fb_probe(struct platform_device *pdev)
+static int __devinit s3c2410fb_probe(struct platform_device *pdev)
 {
         return s3c24xxfb_probe(pdev, DRV_S3C2410);
 }
 
-static int __init s3c2412fb_probe(struct platform_device *pdev)
+static int __devinit s3c2412fb_probe(struct platform_device *pdev)
 {
         return s3c24xxfb_probe(pdev, DRV_S3C2412);
 }
diff --git a/drivers/video/sa1100fb.c b/drivers/video/sa1100fb.c
index cdaa873a6054..e8b76d65a070 100644
--- a/drivers/video/sa1100fb.c
+++ b/drivers/video/sa1100fb.c
@@ -1435,7 +1435,7 @@ static struct sa1100fb_info * __init sa1100fb_init_fbinfo(struct device *dev)
         return fbi;
 }
 
-static int __init sa1100fb_probe(struct platform_device *pdev)
+static int __devinit sa1100fb_probe(struct platform_device *pdev)
 {
         struct sa1100fb_info *fbi;
         int ret, irq;
diff --git a/drivers/video/sgivwfb.c b/drivers/video/sgivwfb.c
index f86012239bff..7a3a5e28eca1 100644
--- a/drivers/video/sgivwfb.c
+++ b/drivers/video/sgivwfb.c
@@ -745,7 +745,7 @@ int __init sgivwfb_setup(char *options)
 /*
  *  Initialisation
  */
-static int __init sgivwfb_probe(struct platform_device *dev)
+static int __devinit sgivwfb_probe(struct platform_device *dev)
 {
         struct sgivw_par *par;
         struct fb_info *info;
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index 8d7653e56df5..bbd1dbf4026a 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -943,7 +943,7 @@ static const struct dev_pm_ops sh_mobile_lcdc_dev_pm_ops = {
 
 static int sh_mobile_lcdc_remove(struct platform_device *pdev);
 
-static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
+static int __devinit sh_mobile_lcdc_probe(struct platform_device *pdev)
 {
         struct fb_info *info;
         struct sh_mobile_lcdc_priv *priv;
diff --git a/drivers/video/sis/sis_main.c b/drivers/video/sis/sis_main.c
index 9d2b6bc49036..a531a0f7cdf2 100644
--- a/drivers/video/sis/sis_main.c
+++ b/drivers/video/sis/sis_main.c
@@ -1891,9 +1891,6 @@ static struct fb_ops sisfb_ops = {
         .fb_fillrect    = fbcon_sis_fillrect,
         .fb_copyarea    = fbcon_sis_copyarea,
         .fb_imageblit   = cfb_imageblit,
-#ifdef CONFIG_FB_SOFT_CURSOR
-        .fb_cursor      = soft_cursor,
-#endif
         .fb_sync        = fbcon_sis_sync,
 #ifdef SIS_NEW_CONFIG_COMPAT
         .fb_compat_ioctl= sisfb_ioctl,
diff --git a/drivers/video/vesafb.c b/drivers/video/vesafb.c
index bd37ee1f6a25..ef4128c8e57a 100644
--- a/drivers/video/vesafb.c
+++ b/drivers/video/vesafb.c
@@ -226,7 +226,7 @@ static int __init vesafb_setup(char *options)
         return 0;
 }
 
-static int __init vesafb_probe(struct platform_device *dev)
+static int __devinit vesafb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
         int i, err;
diff --git a/drivers/video/vfb.c b/drivers/video/vfb.c
index 050d432c7d95..b8ab995fbda7 100644
--- a/drivers/video/vfb.c
+++ b/drivers/video/vfb.c
@@ -479,7 +479,7 @@ static int __init vfb_setup(char *options)
      *  Initialisation
      */
 
-static int __init vfb_probe(struct platform_device *dev)
+static int __devinit vfb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
         int retval = -ENOMEM;
diff --git a/drivers/video/vga16fb.c b/drivers/video/vga16fb.c
index 5b2938903ac2..76d8dae5b1bb 100644
--- a/drivers/video/vga16fb.c
+++ b/drivers/video/vga16fb.c
@@ -1293,7 +1293,7 @@ static int vga16fb_setup(char *options)
 }
 #endif
 
-static int __init vga16fb_probe(struct platform_device *dev)
+static int __devinit vga16fb_probe(struct platform_device *dev)
 {
         struct fb_info *info;
         struct vga16fb_par *par;
diff --git a/drivers/video/via/Makefile b/drivers/video/via/Makefile
index e533b4b6aba4..eeed238ad6a2 100644
--- a/drivers/video/via/Makefile
+++ b/drivers/video/via/Makefile
@@ -4,4 +4,4 @@
 
 obj-$(CONFIG_FB_VIA) += viafb.o
 
-viafb-y :=viafbdev.o hw.o iface.o  via_i2c.o dvi.o lcd.o ioctl.o accel.o via_utility.o vt1636.o global.o tblDPASetting.o viamode.o tbl1636.o
+viafb-y :=viafbdev.o hw.o via_i2c.o dvi.o lcd.o ioctl.o accel.o via_utility.o vt1636.o global.o tblDPASetting.o viamode.o tbl1636.o
diff --git a/drivers/video/via/chip.h b/drivers/video/via/chip.h
index 474f428aea92..8c06bd3c0b4d 100644
--- a/drivers/video/via/chip.h
+++ b/drivers/video/via/chip.h
@@ -107,7 +107,6 @@
 struct tmds_chip_information {
         int tmds_chip_name;
         int tmds_chip_slave_addr;
-        int dvi_panel_id;
         int data_mode;
         int output_interface;
         int i2c_port;
@@ -142,14 +141,9 @@ struct tmds_setting_information {
         int iga_path;
         int h_active;
         int v_active;
-        int bpp;
-        int refresh_rate;
-        int get_dvi_size_method;
         int max_pixel_clock;
-        int dvi_panel_size;
-        int dvi_panel_hres;
-        int dvi_panel_vres;
-        int native_size;
+        int max_hres;
+        int max_vres;
 };
 
 struct lvds_setting_information {
@@ -160,7 +154,6 @@ struct lvds_setting_information {
         int refresh_rate;
         int get_lcd_size_method;
         int lcd_panel_id;
-        int lcd_panel_size;
         int lcd_panel_hres;
         int lcd_panel_vres;
         int display_method;
diff --git a/drivers/video/via/dvi.c b/drivers/video/via/dvi.c
index 67b36932212b..abe59b8c7a05 100644
--- a/drivers/video/via/dvi.c
+++ b/drivers/video/via/dvi.c
@@ -23,11 +23,10 @@
 static void tmds_register_write(int index, u8 data);
 static int tmds_register_read(int index);
 static int tmds_register_read_bytes(int index, u8 *buff, int buff_len);
-static int check_reduce_blanking_mode(int mode_index,
-        int refresh_rate);
-static int dvi_get_panel_size_from_DDCv1(void);
-static int dvi_get_panel_size_from_DDCv2(void);
-static unsigned char dvi_get_panel_info(void);
+static void dvi_get_panel_size_from_DDCv1(struct tmds_chip_information
+        *tmds_chip, struct tmds_setting_information *tmds_setting);
+static void dvi_get_panel_size_from_DDCv2(struct tmds_chip_information
+        *tmds_chip, struct tmds_setting_information *tmds_setting);
 static int viafb_dvi_query_EDID(void);
 
 static int check_tmds_chip(int device_id_subaddr, int device_id)
@@ -38,23 +37,24 @@ static int check_tmds_chip(int device_id_subaddr, int device_id)
                 return FAIL;
 }
 
-void viafb_init_dvi_size(void)
+void viafb_init_dvi_size(struct tmds_chip_information *tmds_chip,
+        struct tmds_setting_information *tmds_setting)
 {
         DEBUG_MSG(KERN_INFO "viafb_init_dvi_size()\n");
-        DEBUG_MSG(KERN_INFO
-                "viaparinfo->tmds_setting_info->get_dvi_size_method %d\n",
-                  viaparinfo->tmds_setting_info->get_dvi_size_method);
 
-        switch (viaparinfo->tmds_setting_info->get_dvi_size_method) {
-        case GET_DVI_SIZE_BY_SYSTEM_BIOS:
+        viafb_dvi_sense();
+        switch (viafb_dvi_query_EDID()) {
+        case 1:
+                dvi_get_panel_size_from_DDCv1(tmds_chip, tmds_setting);
                 break;
-        case GET_DVI_SZIE_BY_HW_STRAPPING:
+        case 2:
+                dvi_get_panel_size_from_DDCv2(tmds_chip, tmds_setting);
                 break;
-        case GET_DVI_SIZE_BY_VGA_BIOS:
         default:
-                dvi_get_panel_info();
+                printk(KERN_WARNING "viafb_init_dvi_size: DVI panel size undetected!\n");
                 break;
         }
+
         return;
 }
 
@@ -189,42 +189,14 @@ static int tmds_register_read_bytes(int index, u8 *buff, int buff_len)
         return 0;
 }
 
-static int check_reduce_blanking_mode(int mode_index,
-        int refresh_rate)
-{
-        if (refresh_rate != 60)
-                return false;
-
-        switch (mode_index) {
-                /* Following modes have reduce blanking mode. */
-        case VIA_RES_1360X768:
-        case VIA_RES_1400X1050:
-        case VIA_RES_1440X900:
-        case VIA_RES_1600X900:
-        case VIA_RES_1680X1050:
-        case VIA_RES_1920X1080:
-        case VIA_RES_1920X1200:
-                break;
-
-        default:
-                DEBUG_MSG(KERN_INFO
-                          "This dvi mode %d have no reduce blanking mode!\n",
-                          mode_index);
-                return false;
-        }
-
-        return true;
-}
-
 /* DVI Set Mode */
-void viafb_dvi_set_mode(int video_index, int mode_bpp, int set_iga)
+void viafb_dvi_set_mode(struct VideoModeTable *mode, int mode_bpp,
+        int set_iga)
 {
-        struct VideoModeTable *videoMode = NULL;
+        struct VideoModeTable *rb_mode;
         struct crt_mode_table *pDviTiming;
         unsigned long desirePixelClock, maxPixelClock;
-        int status = 0;
-        videoMode = viafb_get_modetbl_pointer(video_index);
-        pDviTiming = videoMode->crtc;
+        pDviTiming = mode->crtc;
         desirePixelClock = pDviTiming->clk / 1000000;
         maxPixelClock = (unsigned long)viaparinfo->
                 tmds_setting_info->max_pixel_clock;
@@ -232,20 +204,14 @@ void viafb_dvi_set_mode(int video_index, int mode_bpp, int set_iga)
         DEBUG_MSG(KERN_INFO "\nDVI_set_mode!!\n");
 
         if ((maxPixelClock != 0) && (desirePixelClock > maxPixelClock)) {
-                /*Check if reduce-blanking mode is exist */
-                status =
-                    check_reduce_blanking_mode(video_index,
-                                               pDviTiming->refresh_rate);
-                if (status) {
-                        video_index += 100;     /*Use reduce-blanking mode */
-                        videoMode = viafb_get_modetbl_pointer(video_index);
-                        pDviTiming = videoMode->crtc;
-                        DEBUG_MSG(KERN_INFO
-                                  "DVI use reduce blanking mode %d!!\n",
-                                  video_index);
+                rb_mode = viafb_get_rb_mode(mode->crtc[0].crtc.hor_addr,
+                        mode->crtc[0].crtc.ver_addr);
+                if (rb_mode) {
+                        mode = rb_mode;
+                        pDviTiming = rb_mode->crtc;
                 }
         }
-        viafb_fill_crtc_timing(pDviTiming, video_index, mode_bpp / 8, set_iga);
+        viafb_fill_crtc_timing(pDviTiming, mode, mode_bpp / 8, set_iga);
         viafb_set_output_path(DEVICE_DVI, set_iga,
                         viaparinfo->chip_info->tmds_chip_info.output_interface);
 }
@@ -350,25 +316,18 @@ static int viafb_dvi_query_EDID(void)
                 return false;
 }
 
-/*
- *
- * int dvi_get_panel_size_from_DDCv1(void)
- *
- *     - Get Panel Size Using EDID1 Table
- *
- * Return Type:    int
- *
- */
-static int dvi_get_panel_size_from_DDCv1(void)
+/* Get Panel Size Using EDID1 Table */
+static void dvi_get_panel_size_from_DDCv1(struct tmds_chip_information
+        *tmds_chip, struct tmds_setting_information *tmds_setting)
 {
-        int i, max_h = 0, max_v = 0, tmp, restore;
+        int i, max_h = 0, tmp, restore;
         unsigned char rData;
         unsigned char EDID_DATA[18];
 
         DEBUG_MSG(KERN_INFO "\n dvi_get_panel_size_from_DDCv1 \n");
 
-        restore = viaparinfo->chip_info->tmds_chip_info.tmds_chip_slave_addr;
-        viaparinfo->chip_info->tmds_chip_info.tmds_chip_slave_addr = 0xA0;
+        restore = tmds_chip->tmds_chip_slave_addr;
+        tmds_chip->tmds_chip_slave_addr = 0xA0;
 
         rData = tmds_register_read(0x23);
         if (rData & 0x3C)
@@ -414,8 +373,8 @@ static int dvi_get_panel_size_from_DDCv1(void)
                                 /* The first two byte must be zero. */
                                 if (EDID_DATA[3] == 0xFD) {
                                         /* To get max pixel clock. */
-                                        viaparinfo->tmds_setting_info->
-                                        max_pixel_clock = EDID_DATA[9] * 10;
+                                        tmds_setting->max_pixel_clock =
+                                                EDID_DATA[9] * 10;
                                 }
                         }
                         break;
@@ -425,154 +384,88 @@ static int dvi_get_panel_size_from_DDCv1(void)
                 }
         }
 
+        tmds_setting->max_hres = max_h;
         switch (max_h) {
         case 640:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_640X480;
+                tmds_setting->max_vres = 480;
                 break;
         case 800:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_800X600;
+                tmds_setting->max_vres = 600;
                 break;
         case 1024:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1024X768;
+                tmds_setting->max_vres = 768;
                 break;
         case 1280:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1280X1024;
+                tmds_setting->max_vres = 1024;
                 break;
         case 1400:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1400X1050;
+                tmds_setting->max_vres = 1050;
                 break;
         case 1440:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1440X1050;
+                tmds_setting->max_vres = 1050;
                 break;
         case 1600:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1600X1200;
+                tmds_setting->max_vres = 1200;
                 break;
         case 1920:
-                if (max_v == 1200) {
-                        viaparinfo->tmds_setting_info->dvi_panel_size =
-                                VIA_RES_1920X1200;
-                } else {
-                        viaparinfo->tmds_setting_info->dvi_panel_size =
-                                VIA_RES_1920X1080;
-                }
-
+                tmds_setting->max_vres = 1080;
                 break;
         default:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1024X768;
-                DEBUG_MSG(KERN_INFO "Unknown panel size max resolution = %d !\
-                                         set default panel size.\n", max_h);
+                DEBUG_MSG(KERN_INFO "Unknown panel size max resolution = %d ! "
+                                         "set default panel size.\n", max_h);
                 break;
         }
 
         DEBUG_MSG(KERN_INFO "DVI max pixelclock = %d\n",
-                  viaparinfo->tmds_setting_info->max_pixel_clock);
-        viaparinfo->chip_info->tmds_chip_info.tmds_chip_slave_addr = restore;
-        return viaparinfo->tmds_setting_info->dvi_panel_size;
+                tmds_setting->max_pixel_clock);
+        tmds_chip->tmds_chip_slave_addr = restore;
 }
 
-/*
- *
- * int dvi_get_panel_size_from_DDCv2(void)
- *
- *     - Get Panel Size Using EDID2 Table
- *
- * Return Type:    int
- *
- */
-static int dvi_get_panel_size_from_DDCv2(void)
+/* Get Panel Size Using EDID2 Table */
+static void dvi_get_panel_size_from_DDCv2(struct tmds_chip_information
+        *tmds_chip, struct tmds_setting_information *tmds_setting)
 {
-        int HSize = 0, restore;
+        int restore;
         unsigned char R_Buffer[2];
 
         DEBUG_MSG(KERN_INFO "\n dvi_get_panel_size_from_DDCv2 \n");
 
-        restore = viaparinfo->chip_info->tmds_chip_info.tmds_chip_slave_addr;
-        viaparinfo->chip_info->tmds_chip_info.tmds_chip_slave_addr = 0xA2;
+        restore = tmds_chip->tmds_chip_slave_addr;
+        tmds_chip->tmds_chip_slave_addr = 0xA2;
 
         /* Horizontal: 0x76, 0x77 */
         tmds_register_read_bytes(0x76, R_Buffer, 2);
-        HSize = R_Buffer[0];
-        HSize += R_Buffer[1] << 8;
+        tmds_setting->max_hres = R_Buffer[0] + (R_Buffer[1] << 8);
 
-        switch (HSize) {
+        switch (tmds_setting->max_hres) {
         case 640:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_640X480;
+                tmds_setting->max_vres = 480;
                 break;
         case 800:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_800X600;
+                tmds_setting->max_vres = 600;
                 break;
         case 1024:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1024X768;
+                tmds_setting->max_vres = 768;
                 break;
         case 1280:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1280X1024;
+                tmds_setting->max_vres = 1024;
                 break;
         case 1400:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1400X1050;
+                tmds_setting->max_vres = 1050;
                 break;
         case 1440:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1440X1050;
+                tmds_setting->max_vres = 1050;
                 break;
         case 1600:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1600X1200;
-                break;
-        default:
-                viaparinfo->tmds_setting_info->dvi_panel_size =
-                        VIA_RES_1024X768;
-                DEBUG_MSG(KERN_INFO "Unknown panel size max resolution = %d!\
-                                        set default panel size.\n", HSize);
-                break;
-        }
-
-        viaparinfo->chip_info->tmds_chip_info.tmds_chip_slave_addr = restore;
-        return viaparinfo->tmds_setting_info->dvi_panel_size;
-}
-
-/*
- *
- * unsigned char dvi_get_panel_info(void)
- *
- *     - Get Panel Size
- *
- * Return Type:    unsigned char
- */
-static unsigned char dvi_get_panel_info(void)
-{
-        unsigned char dvipanelsize;
-        DEBUG_MSG(KERN_INFO "dvi_get_panel_info! \n");
-
-        viafb_dvi_sense();
-        switch (viafb_dvi_query_EDID()) {
-        case 1:
-                dvi_get_panel_size_from_DDCv1();
-                break;
-        case 2:
-                dvi_get_panel_size_from_DDCv2();
+                tmds_setting->max_vres = 1200;
                 break;
         default:
+                DEBUG_MSG(KERN_INFO "Unknown panel size max resolution = %d! "
+                        "set default panel size.\n", tmds_setting->max_hres);
                 break;
         }
 
-        DEBUG_MSG(KERN_INFO "dvi panel size is %2d \n",
-                  viaparinfo->tmds_setting_info->dvi_panel_size);
-        dvipanelsize = (unsigned char)(viaparinfo->
-                tmds_setting_info->dvi_panel_size);
-        return dvipanelsize;
+        tmds_chip->tmds_chip_slave_addr = restore;
 }
 
 /* If Disable DVI, turn off pad */
diff --git a/drivers/video/via/dvi.h b/drivers/video/via/dvi.h
index e1ec37fb0dc3..0dffcfd395f3 100644
--- a/drivers/video/via/dvi.h
+++ b/drivers/video/via/dvi.h
@@ -53,12 +53,13 @@
 #define     DEV_CONNECT_DVI     0x01
 #define     DEV_CONNECT_HDMI    0x02
 
-struct VideoModeTable *viafb_get_cea_mode_tbl_pointer(int Index);
 int viafb_dvi_sense(void);
 void viafb_dvi_disable(void);
 void viafb_dvi_enable(void);
 int viafb_tmds_trasmitter_identify(void);
-void viafb_init_dvi_size(void);
-void viafb_dvi_set_mode(int video_index, int mode_bpp, int set_iga);
+void viafb_init_dvi_size(struct tmds_chip_information *tmds_chip,
+        struct tmds_setting_information *tmds_setting);
+void viafb_dvi_set_mode(struct VideoModeTable *videoMode, int mode_bpp,
+        int set_iga);
 
 #endif /* __DVI_H__ */
diff --git a/drivers/video/via/global.c b/drivers/video/via/global.c
index b675cdbb03ad..1ee511b73307 100644
--- a/drivers/video/via/global.c
+++ b/drivers/video/via/global.c
@@ -23,15 +23,12 @@ int viafb_platform_epia_dvi = STATE_OFF;
 int viafb_device_lcd_dualedge = STATE_OFF;
 int viafb_bus_width = 12;
 int viafb_display_hardware_layout = HW_LAYOUT_LCD_DVI;
-int viafb_memsize;
 int viafb_DeviceStatus = CRT_Device;
 int viafb_hotplug;
 int viafb_refresh = 60;
 int viafb_refresh1 = 60;
 int viafb_lcd_dsp_method = LCD_EXPANDSION;
 int viafb_lcd_mode = LCD_OPENLDI;
-int viafb_bpp = 32;
-int viafb_bpp1 = 32;
 int viafb_CRT_ON = 1;
 int viafb_DVI_ON;
 int viafb_LCD_ON ;
@@ -42,8 +39,6 @@ int viafb_hotplug_Xres = 640;
 int viafb_hotplug_Yres = 480;
 int viafb_hotplug_bpp = 32;
 int viafb_hotplug_refresh = 60;
-unsigned int viafb_second_offset;
-int viafb_second_size;
 int viafb_primary_dev = None_Device;
 unsigned int viafb_second_xres = 640;
 unsigned int viafb_second_yres = 480;
diff --git a/drivers/video/via/global.h b/drivers/video/via/global.h
index d69d0ca99c2f..8d95d5fd1388 100644
--- a/drivers/video/via/global.h
+++ b/drivers/video/via/global.h
@@ -35,7 +35,6 @@
 
 #include "debug.h"
 
-#include "iface.h"
 #include "viafbdev.h"
 #include "chip.h"
 #include "accel.h"
@@ -68,8 +67,6 @@ extern int viafb_refresh;
 extern int viafb_refresh1;
 extern int viafb_lcd_dsp_method;
 extern int viafb_lcd_mode;
-extern int viafb_bpp;
-extern int viafb_bpp1;
 
 extern int viafb_CRT_ON;
 extern int viafb_hotplug_Xres;
diff --git a/drivers/video/via/hw.c b/drivers/video/via/hw.c
index 3e083ff67ae2..f2583b1b527f 100644
--- a/drivers/video/via/hw.c
+++ b/drivers/video/via/hw.c
@@ -524,7 +524,6 @@ static void dvi_patch_skew_dvp1(void);
 static void dvi_patch_skew_dvp_low(void);
 static void set_dvi_output_path(int set_iga, int output_interface);
 static void set_lcd_output_path(int set_iga, int output_interface);
-static int search_mode_setting(int ModeInfoIndex);
 static void load_fix_bit_crtc_reg(void);
 static void init_gfx_chip_info(struct pci_dev *pdev,
                                 const struct pci_device_id *pdi);
@@ -686,6 +685,84 @@ void viafb_set_secondary_pitch(u32 pitch)
         viafb_write_reg_mask(0x71, VIACR, (pitch >> (10 - 7)) & 0x80, 0x80);
 }
 
+void viafb_set_primary_color_depth(u8 depth)
+{
+        u8 value;
+
+        DEBUG_MSG(KERN_DEBUG "viafb_set_primary_color_depth(%d)\n", depth);
+        switch (depth) {
+        case 8:
+                value = 0x00;
+                break;
+        case 15:
+                value = 0x04;
+                break;
+        case 16:
+                value = 0x14;
+                break;
+        case 24:
+                value = 0x0C;
+                break;
+        case 30:
+                value = 0x08;
+                break;
+        default:
+                printk(KERN_WARNING "viafb_set_primary_color_depth: "
+                        "Unsupported depth: %d\n", depth);
+                return;
+        }
+
+        viafb_write_reg_mask(0x15, VIASR, value, 0x1C);
+}
+
+void viafb_set_secondary_color_depth(u8 depth)
+{
+        u8 value;
+
+        DEBUG_MSG(KERN_DEBUG "viafb_set_secondary_color_depth(%d)\n", depth);
+        switch (depth) {
+        case 8:
+                value = 0x00;
+                break;
+        case 16:
+                value = 0x40;
+                break;
+        case 24:
+                value = 0xC0;
+                break;
+        case 30:
+                value = 0x80;
+                break;
+        default:
+                printk(KERN_WARNING "viafb_set_secondary_color_depth: "
+                        "Unsupported depth: %d\n", depth);
+                return;
+        }
+
+        viafb_write_reg_mask(0x67, VIACR, value, 0xC0);
+}
+
+static void set_color_register(u8 index, u8 red, u8 green, u8 blue)
+{
+        outb(0xFF, 0x3C6); /* bit mask of palette */
+        outb(index, 0x3C8);
+        outb(red, 0x3C9);
+        outb(green, 0x3C9);
+        outb(blue, 0x3C9);
+}
+
+void viafb_set_primary_color_register(u8 index, u8 red, u8 green, u8 blue)
+{
+        viafb_write_reg_mask(0x1A, VIASR, 0x00, 0x01);
+        set_color_register(index, red, green, blue);
+}
+
+void viafb_set_secondary_color_register(u8 index, u8 red, u8 green, u8 blue)
+{
+        viafb_write_reg_mask(0x1A, VIASR, 0x01, 0x01);
+        set_color_register(index, red, green, blue);
+}
+
 void viafb_set_output_path(int device, int set_iga, int output_interface)
 {
         switch (device) {
@@ -710,11 +787,8 @@ static void set_crt_output_path(int set_iga)
                 viafb_write_reg_mask(SR16, VIASR, 0x00, BIT6);
                 break;
         case IGA2:
-        case IGA1_IGA2:
                 viafb_write_reg_mask(CR6A, VIACR, 0xC0, BIT6 + BIT7);
                 viafb_write_reg_mask(SR16, VIASR, 0x40, BIT6);
-                if (set_iga == IGA1_IGA2)
-                        viafb_write_reg_mask(CR6B, VIACR, 0x08, BIT3);
                 break;
         }
 }
@@ -904,13 +978,6 @@ static void set_lcd_output_path(int set_iga, int output_interface)
 
                 enable_second_display_channel();
                 break;
-
-        case IGA1_IGA2:
-                viafb_write_reg_mask(CR6B, VIACR, 0x08, BIT3);
-                viafb_write_reg_mask(CR6A, VIACR, 0x08, BIT3);
-
-                disable_second_display_channel();
-                break;
         }
 
         switch (output_interface) {
@@ -987,49 +1054,6 @@ static void set_lcd_output_path(int set_iga, int output_interface)
         }
 }
 
-/* Search Mode Index */
-static int search_mode_setting(int ModeInfoIndex)
-{
-        int i = 0;
-
-        while ((i < NUM_TOTAL_MODETABLE) &&
-                        (ModeInfoIndex != CLE266Modes[i].ModeIndex))
-                i++;
-        if (i >= NUM_TOTAL_MODETABLE)
-                i = 0;
-        return i;
-
-}
-
-struct VideoModeTable *viafb_get_modetbl_pointer(int Index)
-{
-        struct VideoModeTable *TmpTbl = NULL;
-        TmpTbl = &CLE266Modes[search_mode_setting(Index)];
-        return TmpTbl;
-}
-
-struct VideoModeTable *viafb_get_cea_mode_tbl_pointer(int Index)
-{
-        struct VideoModeTable *TmpTbl = NULL;
-        int i = 0;
-        while ((i < NUM_TOTAL_CEA_MODES) &&
-                        (Index != CEA_HDMI_Modes[i].ModeIndex))
-                i++;
-        if ((i < NUM_TOTAL_CEA_MODES))
-                TmpTbl = &CEA_HDMI_Modes[i];
-         else {
-                /*Still use general timing if don't find CEA timing */
-                i = 0;
-                while ((i < NUM_TOTAL_MODETABLE) &&
-                                (Index != CLE266Modes[i].ModeIndex))
-                       i++;
-                if (i >= NUM_TOTAL_MODETABLE)
-                        i = 0;
-                TmpTbl = &CLE266Modes[i];
-        }
-        return TmpTbl;
-}
-
 static void load_fix_bit_crtc_reg(void)
 {
         /* always set to 1 */
@@ -1121,15 +1145,13 @@ void viafb_load_fetch_count_reg(int h_addr, int bpp_byte, int set_iga)
         struct io_register *reg = NULL;
 
         switch (set_iga) {
-        case IGA1_IGA2:
         case IGA1:
                 reg_value = IGA1_FETCH_COUNT_FORMULA(h_addr, bpp_byte);
                 viafb_load_reg_num = fetch_count_reg.
                         iga1_fetch_count_reg.reg_num;
                 reg = fetch_count_reg.iga1_fetch_count_reg.reg;
                 viafb_load_reg(reg_value, viafb_load_reg_num, reg, VIASR);
-                if (set_iga == IGA1)
-                        break;
+                break;
         case IGA2:
                 reg_value = IGA2_FETCH_COUNT_FORMULA(h_addr, bpp_byte);
                 viafb_load_reg_num = fetch_count_reg.
@@ -1499,7 +1521,7 @@ void viafb_set_vclock(u32 CLK, int set_iga)
         /* H.W. Reset : ON */
         viafb_write_reg_mask(CR17, VIACR, 0x00, BIT7);
 
-        if ((set_iga == IGA1) || (set_iga == IGA1_IGA2)) {
+        if (set_iga == IGA1) {
                 /* Change D,N FOR VCLK */
                 switch (viaparinfo->chip_info->gfx_chip_name) {
                 case UNICHROME_CLE266:
@@ -1528,7 +1550,7 @@ void viafb_set_vclock(u32 CLK, int set_iga)
                 }
         }
 
-        if ((set_iga == IGA2) || (set_iga == IGA1_IGA2)) {
+        if (set_iga == IGA2) {
                 /* Change D,N FOR LCK */
                 switch (viaparinfo->chip_info->gfx_chip_name) {
                 case UNICHROME_CLE266:
@@ -1557,12 +1579,12 @@ void viafb_set_vclock(u32 CLK, int set_iga)
         viafb_write_reg_mask(CR17, VIACR, 0x80, BIT7);
 
         /* Reset PLL */
-        if ((set_iga == IGA1) || (set_iga == IGA1_IGA2)) {
+        if (set_iga == IGA1) {
                 viafb_write_reg_mask(SR40, VIASR, 0x02, BIT1);
                 viafb_write_reg_mask(SR40, VIASR, 0x00, BIT1);
         }
 
-        if ((set_iga == IGA2) || (set_iga == IGA1_IGA2)) {
+        if (set_iga == IGA2) {
                 viafb_write_reg_mask(SR40, VIASR, 0x01, BIT0);
                 viafb_write_reg_mask(SR40, VIASR, 0x00, BIT0);
         }
@@ -1805,47 +1827,15 @@ void viafb_load_crtc_timing(struct display_timing device_timing,
         viafb_lock_crt();
 }
 
-void viafb_set_color_depth(int bpp_byte, int set_iga)
-{
-        if (set_iga == IGA1) {
-                switch (bpp_byte) {
-                case MODE_8BPP:
-                        viafb_write_reg_mask(SR15, VIASR, 0x22, 0x7E);
-                        break;
-                case MODE_16BPP:
-                        viafb_write_reg_mask(SR15, VIASR, 0xB6, 0xFE);
-                        break;
-                case MODE_32BPP:
-                        viafb_write_reg_mask(SR15, VIASR, 0xAE, 0xFE);
-                        break;
-                }
-        } else {
-                switch (bpp_byte) {
-                case MODE_8BPP:
-                        viafb_write_reg_mask(CR67, VIACR, 0x00, BIT6 + BIT7);
-                        break;
-                case MODE_16BPP:
-                        viafb_write_reg_mask(CR67, VIACR, 0x40, BIT6 + BIT7);
-                        break;
-                case MODE_32BPP:
-                        viafb_write_reg_mask(CR67, VIACR, 0xC0, BIT6 + BIT7);
-                        break;
-                }
-        }
-}
-
 void viafb_fill_crtc_timing(struct crt_mode_table *crt_table,
-        int mode_index, int bpp_byte, int set_iga)
+        struct VideoModeTable *video_mode, int bpp_byte, int set_iga)
 {
-        struct VideoModeTable *video_mode;
         struct display_timing crt_reg;
         int i;
         int index = 0;
         int h_addr, v_addr;
         u32 pll_D_N;
 
-        video_mode = &CLE266Modes[search_mode_setting(mode_index)];
-
         for (i = 0; i < video_mode->mode_array; i++) {
                 index = i;
 
@@ -1858,8 +1848,10 @@ void viafb_fill_crtc_timing(struct crt_mode_table *crt_table,
 
         /* Mode 640x480 has border, but LCD/DFP didn't have border. */
         /* So we would delete border. */
-        if ((viafb_LCD_ON | viafb_DVI_ON) && (mode_index == VIA_RES_640X480)
-            && (viaparinfo->crt_setting_info->refresh_rate == 60)) {
+        if ((viafb_LCD_ON | viafb_DVI_ON)
+            && video_mode->crtc[0].crtc.hor_addr == 640
+            && video_mode->crtc[0].crtc.ver_addr == 480
+            && viaparinfo->crt_setting_info->refresh_rate == 60) {
                 /* The border is 8 pixels. */
                 crt_reg.hor_blank_start = crt_reg.hor_blank_start - 8;
 
@@ -1912,9 +1904,6 @@ void viafb_fill_crtc_timing(struct crt_mode_table *crt_table,
             && (viaparinfo->chip_info->gfx_chip_name != UNICHROME_K400))
                 viafb_load_FIFO_reg(set_iga, h_addr, v_addr);
 
-        /* load SR Register About Memory and Color part */
-        viafb_set_color_depth(bpp_byte, set_iga);
-
         pll_D_N = viafb_get_clk_value(crt_table[index].clk);
         DEBUG_MSG(KERN_INFO "PLL=%x", pll_D_N);
         viafb_set_vclock(pll_D_N, set_iga);
@@ -1956,9 +1945,6 @@ void viafb_update_device_setting(int hres, int vres,
 
                 viaparinfo->tmds_setting_info->h_active = hres;
                 viaparinfo->tmds_setting_info->v_active = vres;
-                viaparinfo->tmds_setting_info->bpp = bpp;
-                viaparinfo->tmds_setting_info->refresh_rate =
-                        vmode_refresh;
 
                 viaparinfo->lvds_setting_info->h_active = hres;
                 viaparinfo->lvds_setting_info->v_active = vres;
@@ -1975,9 +1961,6 @@ void viafb_update_device_setting(int hres, int vres,
                 if (viaparinfo->tmds_setting_info->iga_path == IGA2) {
                         viaparinfo->tmds_setting_info->h_active = hres;
                         viaparinfo->tmds_setting_info->v_active = vres;
-                        viaparinfo->tmds_setting_info->bpp = bpp;
-                        viaparinfo->tmds_setting_info->refresh_rate =
-                                vmode_refresh;
                 }
 
                 if (viaparinfo->lvds_setting_info->iga_path == IGA2) {
@@ -2076,9 +2059,8 @@ static void init_tmds_chip_info(void)
 
         DEBUG_MSG(KERN_INFO "TMDS Chip = %d\n",
                   viaparinfo->chip_info->tmds_chip_info.tmds_chip_name);
-        viaparinfo->tmds_setting_info->get_dvi_size_method =
-                GET_DVI_SIZE_BY_VGA_BIOS;
-        viafb_init_dvi_size();
+        viafb_init_dvi_size(&viaparinfo->shared->chip_info.tmds_chip_info,
+                &viaparinfo->shared->tmds_setting_info);
 }
 
 static void init_lvds_chip_info(void)
@@ -2195,28 +2177,19 @@ static void set_display_channel(void)
         }
 }
 
-int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
-        int vmode_index1, int hor_res1, int ver_res1, int video_bpp1)
+int viafb_setmode(struct VideoModeTable *vmode_tbl, int video_bpp,
+        struct VideoModeTable *vmode_tbl1, int video_bpp1)
 {
         int i, j;
         int port;
         u8 value, index, mask;
-        struct VideoModeTable *vmode_tbl;
         struct crt_mode_table *crt_timing;
-        struct VideoModeTable *vmode_tbl1 = NULL;
         struct crt_mode_table *crt_timing1 = NULL;
 
-        DEBUG_MSG(KERN_INFO "Set Mode!!\n");
-        DEBUG_MSG(KERN_INFO
-                  "vmode_index=%d hor_res=%d ver_res=%d video_bpp=%d\n",
-                  vmode_index, hor_res, ver_res, video_bpp);
-
         device_screen_off();
-        vmode_tbl = &CLE266Modes[search_mode_setting(vmode_index)];
         crt_timing = vmode_tbl->crtc;
 
         if (viafb_SAMM_ON == 1) {
-                vmode_tbl1 = &CLE266Modes[search_mode_setting(vmode_index1)];
                 crt_timing1 = vmode_tbl1->crtc;
         }
 
@@ -2267,12 +2240,11 @@ int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
                 outb(VPIT.SR[i - 1], VIASR + 1);
         }
 
-        viafb_set_primary_address(0);
-        viafb_set_secondary_address(viafb_SAMM_ON ? viafb_second_offset : 0);
+        viafb_write_reg_mask(0x15, VIASR, 0xA2, 0xA2);
         viafb_set_iga_path();
 
         /* Write CRTC */
-        viafb_fill_crtc_timing(crt_timing, vmode_index, video_bpp / 8, IGA1);
+        viafb_fill_crtc_timing(crt_timing, vmode_tbl, video_bpp / 8, IGA1);
 
         /* Write Graphic Controller */
         for (i = 0; i < StdGR; i++) {
@@ -2292,65 +2264,25 @@ int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
 
         /* Update Patch Register */
 
-        if ((viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266)
-            || (viaparinfo->chip_info->gfx_chip_name == UNICHROME_K400)) {
-                for (i = 0; i < NUM_TOTAL_PATCH_MODE; i++) {
-                        if (res_patch_table[i].mode_index == vmode_index) {
-                                for (j = 0;
-                                     j < res_patch_table[i].table_length; j++) {
-                                        index =
-                                            res_patch_table[i].
-                                            io_reg_table[j].index;
-                                        port =
-                                            res_patch_table[i].
-                                            io_reg_table[j].port;
-                                        value =
-                                            res_patch_table[i].
-                                            io_reg_table[j].value;
-                                        mask =
-                                            res_patch_table[i].
-                                            io_reg_table[j].mask;
-                                        viafb_write_reg_mask(index, port, value,
-                                                       mask);
-                                }
-                        }
-                }
-        }
-
-        if (viafb_SAMM_ON == 1) {
-                if ((viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266)
-                    || (viaparinfo->chip_info->gfx_chip_name ==
-                    UNICHROME_K400)) {
-                        for (i = 0; i < NUM_TOTAL_PATCH_MODE; i++) {
-                                if (res_patch_table[i].mode_index ==
-                                    vmode_index1) {
-                                        for (j = 0;
-                                             j <
-                                             res_patch_table[i].
-                                             table_length; j++) {
-                                                index =
-                                                    res_patch_table[i].
-                                                    io_reg_table[j].index;
-                                                port =
-                                                    res_patch_table[i].
-                                                    io_reg_table[j].port;
-                                                value =
-                                                    res_patch_table[i].
-                                                    io_reg_table[j].value;
-                                                mask =
-                                                    res_patch_table[i].
-                                                    io_reg_table[j].mask;
-                                                viafb_write_reg_mask(index,
-                                                        port, value, mask);
-                                        }
-                                }
-                        }
+        if ((viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266
+            || viaparinfo->chip_info->gfx_chip_name == UNICHROME_K400)
+            && vmode_tbl->crtc[0].crtc.hor_addr == 1024
+            && vmode_tbl->crtc[0].crtc.ver_addr == 768) {
+                for (j = 0; j < res_patch_table[0].table_length; j++) {
+                        index = res_patch_table[0].io_reg_table[j].index;
+                        port = res_patch_table[0].io_reg_table[j].port;
+                        value = res_patch_table[0].io_reg_table[j].value;
+                        mask = res_patch_table[0].io_reg_table[j].mask;
+                        viafb_write_reg_mask(index, port, value, mask);
                 }
         }
 
         viafb_set_primary_pitch(viafbinfo->fix.line_length);
         viafb_set_secondary_pitch(viafb_dual_fb ? viafbinfo1->fix.line_length
                 : viafbinfo->fix.line_length);
+        viafb_set_primary_color_depth(viaparinfo->depth);
+        viafb_set_secondary_color_depth(viafb_dual_fb ? viaparinfo1->depth
+                : viaparinfo->depth);
         /* Update Refresh Rate Setting */
 
         /* Clear On Screen */
@@ -2359,11 +2291,11 @@ int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
         if (viafb_CRT_ON) {
                 if (viafb_SAMM_ON && (viaparinfo->crt_setting_info->iga_path ==
                         IGA2)) {
-                        viafb_fill_crtc_timing(crt_timing1, vmode_index1,
+                        viafb_fill_crtc_timing(crt_timing1, vmode_tbl1,
                                 video_bpp1 / 8,
                                 viaparinfo->crt_setting_info->iga_path);
                 } else {
-                        viafb_fill_crtc_timing(crt_timing, vmode_index,
+                        viafb_fill_crtc_timing(crt_timing, vmode_tbl,
                                 video_bpp / 8,
                                 viaparinfo->crt_setting_info->iga_path);
                 }
@@ -2373,7 +2305,7 @@ int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
                 /* Patch if set_hres is not 8 alignment (1366) to viafb_setmode
                 to 8 alignment (1368),there is several pixels (2 pixels)
                 on right side of screen. */
-                if (hor_res % 8) {
+                if (vmode_tbl->crtc[0].crtc.hor_addr % 8) {
                         viafb_unlock_crt();
                         viafb_write_reg(CR02, VIACR,
                                 viafb_read_reg(VIACR, CR02) - 1);
@@ -2384,14 +2316,14 @@ int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
         if (viafb_DVI_ON) {
                 if (viafb_SAMM_ON &&
                         (viaparinfo->tmds_setting_info->iga_path == IGA2)) {
-                        viafb_dvi_set_mode(viafb_get_mode_index
+                        viafb_dvi_set_mode(viafb_get_mode
                                      (viaparinfo->tmds_setting_info->h_active,
                                       viaparinfo->tmds_setting_info->
                                       v_active),
                                      video_bpp1, viaparinfo->
                                      tmds_setting_info->iga_path);
                 } else {
-                        viafb_dvi_set_mode(viafb_get_mode_index
+                        viafb_dvi_set_mode(viafb_get_mode
                                      (viaparinfo->tmds_setting_info->h_active,
                                       viaparinfo->
                                       tmds_setting_info->v_active),
@@ -2445,8 +2377,8 @@ int viafb_setmode(int vmode_index, int hor_res, int ver_res, int video_bpp,
 
         /* If set mode normally, save resolution information for hot-plug . */
         if (!viafb_hotplug) {
-                viafb_hotplug_Xres = hor_res;
-                viafb_hotplug_Yres = ver_res;
+                viafb_hotplug_Xres = vmode_tbl->crtc[0].crtc.hor_addr;
+                viafb_hotplug_Yres = vmode_tbl->crtc[0].crtc.ver_addr;
                 viafb_hotplug_bpp = video_bpp;
                 viafb_hotplug_refresh = viafb_refresh;
 
@@ -2706,13 +2638,11 @@ void viafb_set_dpa_gfx(int output_interface, struct GFX_DPA_SETTING\
 
 /*According var's xres, yres fill var's other timing information*/
 void viafb_fill_var_timing_info(struct fb_var_screeninfo *var, int refresh,
-                          int mode_index)
+        struct VideoModeTable *vmode_tbl)
 {
-        struct VideoModeTable *vmode_tbl = NULL;
         struct crt_mode_table *crt_timing = NULL;
         struct display_timing crt_reg;
         int i = 0, index = 0;
-        vmode_tbl = &CLE266Modes[search_mode_setting(mode_index)];
         crt_timing = vmode_tbl->crtc;
         for (i = 0; i < vmode_tbl->mode_array; i++) {
                 index = i;
@@ -2721,36 +2651,6 @@ void viafb_fill_var_timing_info(struct fb_var_screeninfo *var, int refresh,
         }
 
         crt_reg = crt_timing[index].crtc;
-        switch (var->bits_per_pixel) {
-        case 8:
-                var->red.offset = 0;
-                var->green.offset = 0;
-                var->blue.offset = 0;
-                var->red.length = 6;
-                var->green.length = 6;
-                var->blue.length = 6;
-                break;
-        case 16:
-                var->red.offset = 11;
-                var->green.offset = 5;
-                var->blue.offset = 0;
-                var->red.length = 5;
-                var->green.length = 6;
-                var->blue.length = 5;
-                break;
-        case 32:
-                var->red.offset = 16;
-                var->green.offset = 8;
-                var->blue.offset = 0;
-                var->red.length = 8;
-                var->green.length = 8;
-                var->blue.length = 8;
-                break;
-        default:
-                /* never happed, put here to keep consistent */
-                break;
-        }
-
         var->pixclock = viafb_get_pixclock(var->xres, var->yres, refresh);
         var->left_margin =
             crt_reg.hor_total - (crt_reg.hor_sync_start + crt_reg.hor_sync_end);
diff --git a/drivers/video/via/hw.h b/drivers/video/via/hw.h
index b874d952b446..12ef32d334cb 100644
--- a/drivers/video/via/hw.h
+++ b/drivers/video/via/hw.h
@@ -22,6 +22,7 @@
 #ifndef __HW_H__
 #define __HW_H__
 
+#include "viamode.h"
 #include "global.h"
 
 /***************************************************
@@ -862,8 +863,6 @@ struct pci_device_id_info {
 };
 
 extern unsigned int viafb_second_virtual_xres;
-extern unsigned int viafb_second_offset;
-extern int viafb_second_size;
 extern int viafb_SAMM_ON;
 extern int viafb_dual_fb;
 extern int viafb_LCD2_ON;
@@ -874,8 +873,9 @@ extern int viafb_hotplug;
 void viafb_write_reg_mask(u8 index, int io_port, u8 data, u8 mask);
 void viafb_set_output_path(int device, int set_iga,
         int output_interface);
+
 void viafb_fill_crtc_timing(struct crt_mode_table *crt_table,
-                      int mode_index, int bpp_byte, int set_iga);
+        struct VideoModeTable *video_mode, int bpp_byte, int set_iga);
 
 void viafb_set_vclock(u32 CLK, int set_iga);
 void viafb_load_reg(int timing_value, int viafb_load_reg_num,
@@ -891,16 +891,15 @@ void viafb_lock_crt(void);
 void viafb_unlock_crt(void);
 void viafb_load_fetch_count_reg(int h_addr, int bpp_byte, int set_iga);
 void viafb_write_regx(struct io_reg RegTable[], int ItemNum);
-struct VideoModeTable *viafb_get_modetbl_pointer(int Index);
 u32 viafb_get_clk_value(int clk);
 void viafb_load_FIFO_reg(int set_iga, int hor_active, int ver_active);
-void viafb_set_color_depth(int bpp_byte, int set_iga);
 void viafb_set_dpa_gfx(int output_interface, struct GFX_DPA_SETTING\
                                         *p_gfx_dpa_setting);
 
-int viafb_setmode(int vmode_index, int hor_res, int ver_res,
-            int video_bpp, int vmode_index1, int hor_res1,
-            int ver_res1, int video_bpp1);
+int viafb_setmode(struct VideoModeTable *vmode_tbl, int video_bpp,
+        struct VideoModeTable *vmode_tbl1, int video_bpp1);
+void viafb_fill_var_timing_info(struct fb_var_screeninfo *var, int refresh,
+        struct VideoModeTable *vmode_tbl);
 void viafb_init_chip_info(struct pci_dev *pdev,
                           const struct pci_device_id *pdi);
 void viafb_init_dac(int set_iga);
@@ -915,6 +914,8 @@ void viafb_set_primary_address(u32 addr);
 void viafb_set_secondary_address(u32 addr);
 void viafb_set_primary_pitch(u32 pitch);
 void viafb_set_secondary_pitch(u32 pitch);
+void viafb_set_primary_color_register(u8 index, u8 red, u8 green, u8 blue);
+void viafb_set_secondary_color_register(u8 index, u8 red, u8 green, u8 blue);
 void viafb_get_fb_info(unsigned int *fb_base, unsigned int *fb_len);
 
 #endif /* __HW_H__ */
diff --git a/drivers/video/via/iface.c b/drivers/video/via/iface.c
deleted file mode 100644
index 1570636c8d51..000000000000
--- a/drivers/video/via/iface.c
+++ /dev/null
@@ -1,78 +0,0 @@
-/*
- * Copyright 1998-2008 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2008 S3 Graphics, Inc. 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, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; without even
- * the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE.See the GNU General Public License
- * for more details.
-
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc.,
- * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
- */
-
-#include "global.h"
-
-/* Get frame buffer size from VGA BIOS */
-
-unsigned int viafb_get_memsize(void)
-{
-        unsigned int m;
-
-        /* If memory size provided by user */
-        if (viafb_memsize)
-                m = viafb_memsize * Mb;
-        else {
-                m = (unsigned int)viafb_read_reg(VIASR, SR39);
-                m = m * (4 * Mb);
-
-                if ((m < (16 * Mb)) || (m > (64 * Mb)))
-                        m = 16 * Mb;
-        }
-        DEBUG_MSG(KERN_INFO "framebuffer size = %d Mb\n", m / Mb);
-        return m;
-}
-
-/* Get Video Buffer Starting Physical Address(back door)*/
-
-unsigned long viafb_get_videobuf_addr(void)
-{
-        struct pci_dev *pdev = NULL;
-        unsigned char sys_mem;
-        unsigned char video_mem;
-        unsigned long sys_mem_size;
-        unsigned long video_mem_size;
-        /*system memory = 256 MB, video memory 64 MB */
-        unsigned long vmem_starting_adr = 0x0C000000;
-
-        pdev =
-            (struct pci_dev *)pci_get_device(VIA_K800_BRIDGE_VID,
-                                             VIA_K800_BRIDGE_DID, NULL);
-        if (pdev != NULL) {
-                pci_read_config_byte(pdev, VIA_K800_SYSTEM_MEMORY_REG,
-                                     &sys_mem);
-                pci_read_config_byte(pdev, VIA_K800_VIDEO_MEMORY_REG,
-                                     &video_mem);
-                video_mem = (video_mem & 0x70) >> 4;
-                sys_mem_size = ((unsigned long)sys_mem) << 24;
-                if (video_mem != 0)
-                        video_mem_size = (1 << (video_mem)) * 1024 * 1024;
-                else
-                        video_mem_size = 0;
-
-                vmem_starting_adr = sys_mem_size - video_mem_size;
-                pci_dev_put(pdev);
-        }
-
-        DEBUG_MSG(KERN_INFO "Video Memory Starting Address = %lx \n",
-                  vmem_starting_adr);
-        return vmem_starting_adr;
-}
diff --git a/drivers/video/via/iface.h b/drivers/video/via/iface.h
deleted file mode 100644
index 790ec3e3aea2..000000000000
--- a/drivers/video/via/iface.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright 1998-2008 VIA Technologies, Inc. All Rights Reserved.
- * Copyright 2001-2008 S3 Graphics, Inc. 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, or (at your option) any later version.
-
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTIES OR REPRESENTATIONS; 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.
- */
-
-#ifndef __IFACE_H__
-#define __IFACE_H__
-
-#define Kb  (1024)
-#define Mb  (Kb*Kb)
-
-#define VIA_K800_BRIDGE_VID         0x1106
-#define VIA_K800_BRIDGE_DID         0x3204
-
-#define VIA_K800_SYSTEM_MEMORY_REG  0x47
-#define VIA_K800_VIDEO_MEMORY_REG   0xA1
-
-extern int viafb_memsize;
-unsigned int viafb_get_memsize(void);
-unsigned long viafb_get_videobuf_addr(void);
-
-#endif /* __IFACE_H__ */
diff --git a/drivers/video/via/lcd.c b/drivers/video/via/lcd.c
index 09353e2b92f6..1b1ccdc2d83d 100644
--- a/drivers/video/via/lcd.c
+++ b/drivers/video/via/lcd.c
@@ -22,25 +22,7 @@
 #include "global.h"
 #include "lcdtbl.h"
 
-static struct iga2_shadow_crtc_timing iga2_shadow_crtc_reg = {
-        /* IGA2 Shadow Horizontal Total */
-        {IGA2_SHADOW_HOR_TOTAL_REG_NUM, {{CR6D, 0, 7}, {CR71, 3, 3} } },
-        /* IGA2 Shadow Horizontal Blank End */
-        {IGA2_SHADOW_HOR_BLANK_END_REG_NUM, {{CR6E, 0, 7} } },
-        /* IGA2 Shadow Vertical Total */
-        {IGA2_SHADOW_VER_TOTAL_REG_NUM, {{CR6F, 0, 7}, {CR71, 0, 2} } },
-        /* IGA2 Shadow Vertical Addressable Video */
-        {IGA2_SHADOW_VER_ADDR_REG_NUM, {{CR70, 0, 7}, {CR71, 4, 6} } },
-        /* IGA2 Shadow Vertical Blank Start */
-        {IGA2_SHADOW_VER_BLANK_START_REG_NUM,
-         {{CR72, 0, 7}, {CR74, 4, 6} } },
-        /* IGA2 Shadow Vertical Blank End */
-        {IGA2_SHADOW_VER_BLANK_END_REG_NUM, {{CR73, 0, 7}, {CR74, 0, 2} } },
-        /* IGA2 Shadow Vertical Sync Start */
-        {IGA2_SHADOW_VER_SYNC_START_REG_NUM, {{CR75, 0, 7}, {CR76, 4, 6} } },
-        /* IGA2 Shadow Vertical Sync End */
-        {IGA2_SHADOW_VER_SYNC_END_REG_NUM, {{CR76, 0, 3} } }
-};
+#define viafb_compact_res(x, y) (((x)<<16)|(y))
 
 static struct _lcd_scaling_factor lcd_scaling_factor = {
         /* LCD Horizontal Scaling Factor Register */
@@ -59,16 +41,10 @@ static struct _lcd_scaling_factor lcd_scaling_factor_CLE = {
 
 static int check_lvds_chip(int device_id_subaddr, int device_id);
 static bool lvds_identify_integratedlvds(void);
-static int fp_id_to_vindex(int panel_id);
+static void fp_id_to_vindex(int panel_id);
 static int lvds_register_read(int index);
 static void load_lcd_scaling(int set_hres, int set_vres, int panel_hres,
                       int panel_vres);
-static void load_lcd_k400_patch_tbl(int set_hres, int set_vres,
-        int panel_id);
-static void load_lcd_p880_patch_tbl(int set_hres, int set_vres,
-        int panel_id);
-static void load_lcd_patch_regs(int set_hres, int set_vres,
-        int panel_id, int set_iga);
 static void via_pitch_alignment_patch_lcd(
         struct lvds_setting_information *plvds_setting_info,
                                    struct lvds_chip_information
@@ -98,8 +74,6 @@ static void check_diport_of_integrated_lvds(
 static struct display_timing lcd_centering_timging(struct display_timing
                                             mode_crt_reg,
                                            struct display_timing panel_crt_reg);
-static void load_crtc_shadow_timing(struct display_timing mode_timing,
-                             struct display_timing panel_timing);
 static void viafb_load_scaling_factor_for_p4m900(int set_hres,
         int set_vres, int panel_hres, int panel_vres);
 
@@ -125,33 +99,24 @@ void viafb_init_lcd_size(void)
                 break;
         case GET_LCD_SIZE_BY_VGA_BIOS:
                 DEBUG_MSG(KERN_INFO "Get LCD Size method by VGA BIOS !!\n");
-                viaparinfo->lvds_setting_info->lcd_panel_size =
-                    fp_id_to_vindex(viafb_lcd_panel_id);
+                fp_id_to_vindex(viafb_lcd_panel_id);
                 DEBUG_MSG(KERN_INFO "LCD Panel_ID = %d\n",
                           viaparinfo->lvds_setting_info->lcd_panel_id);
-                DEBUG_MSG(KERN_INFO "LCD Panel Size = %d\n",
-                          viaparinfo->lvds_setting_info->lcd_panel_size);
                 break;
         case GET_LCD_SIZE_BY_USER_SETTING:
                 DEBUG_MSG(KERN_INFO "Get LCD Size method by user setting !!\n");
-                viaparinfo->lvds_setting_info->lcd_panel_size =
-                    fp_id_to_vindex(viafb_lcd_panel_id);
+                fp_id_to_vindex(viafb_lcd_panel_id);
                 DEBUG_MSG(KERN_INFO "LCD Panel_ID = %d\n",
                           viaparinfo->lvds_setting_info->lcd_panel_id);
-                DEBUG_MSG(KERN_INFO "LCD Panel Size = %d\n",
-                          viaparinfo->lvds_setting_info->lcd_panel_size);
                 break;
         default:
                 DEBUG_MSG(KERN_INFO "viafb_init_lcd_size fail\n");
                 viaparinfo->lvds_setting_info->lcd_panel_id =
                         LCD_PANEL_ID1_800X600;
-                viaparinfo->lvds_setting_info->lcd_panel_size =
-                    fp_id_to_vindex(LCD_PANEL_ID1_800X600);
+                fp_id_to_vindex(LCD_PANEL_ID1_800X600);
         }
         viaparinfo->lvds_setting_info2->lcd_panel_id =
                 viaparinfo->lvds_setting_info->lcd_panel_id;
-        viaparinfo->lvds_setting_info2->lcd_panel_size =
-                viaparinfo->lvds_setting_info->lcd_panel_size;
         viaparinfo->lvds_setting_info2->lcd_panel_hres =
                 viaparinfo->lvds_setting_info->lcd_panel_hres;
         viaparinfo->lvds_setting_info2->lcd_panel_vres =
@@ -171,13 +136,13 @@ static bool lvds_identify_integratedlvds(void)
                 if (viaparinfo->chip_info->lvds_chip_info.lvds_chip_name) {
                         viaparinfo->chip_info->lvds_chip_info2.lvds_chip_name =
                             INTEGRATED_LVDS;
-                        DEBUG_MSG(KERN_INFO "Support two dual channel LVDS!\
-                                  (Internal LVDS + External LVDS)\n");
+                        DEBUG_MSG(KERN_INFO "Support two dual channel LVDS! "
+                                  "(Internal LVDS + External LVDS)\n");
                 } else {
                         viaparinfo->chip_info->lvds_chip_info.lvds_chip_name =
                             INTEGRATED_LVDS;
-                        DEBUG_MSG(KERN_INFO "Not found external LVDS,\
-                                  so can't support two dual channel LVDS!\n");
+                        DEBUG_MSG(KERN_INFO "Not found external LVDS, "
+                                  "so can't support two dual channel LVDS!\n");
                 }
         } else if (viafb_display_hardware_layout == HW_LAYOUT_LCD1_LCD2) {
                 /* Two single channel LCD (Internal LVDS + Internal LVDS): */
@@ -185,8 +150,8 @@ static bool lvds_identify_integratedlvds(void)
                 INTEGRATED_LVDS;
                 viaparinfo->chip_info->lvds_chip_info2.lvds_chip_name =
                         INTEGRATED_LVDS;
-                DEBUG_MSG(KERN_INFO "Support two single channel LVDS!\
-                          (Internal LVDS + Internal LVDS)\n");
+                DEBUG_MSG(KERN_INFO "Support two single channel LVDS! "
+                          "(Internal LVDS + Internal LVDS)\n");
         } else if (viafb_display_hardware_layout != HW_LAYOUT_DVI_ONLY) {
                 /* If we have found external LVDS, just use it,
                    otherwise, we will use internal LVDS as default. */
@@ -248,7 +213,7 @@ int viafb_lvds_trasmitter_identify(void)
         return FAIL;
 }
 
-static int fp_id_to_vindex(int panel_id)
+static void fp_id_to_vindex(int panel_id)
 {
         DEBUG_MSG(KERN_INFO "fp_get_panel_id()\n");
 
@@ -264,7 +229,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID0_640X480;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_640X480;
                 break;
         case 0x1:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 800;
@@ -273,7 +237,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID1_800X600;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_800X600;
                 break;
         case 0x2:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1024;
@@ -282,7 +245,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID2_1024X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1024X768;
                 break;
         case 0x3:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -291,7 +253,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID3_1280X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1280X768;
                 break;
         case 0x4:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -300,7 +261,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID4_1280X1024;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1280X1024;
                 break;
         case 0x5:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1400;
@@ -309,7 +269,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID5_1400X1050;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1400X1050;
                 break;
         case 0x6:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1600;
@@ -318,7 +277,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID6_1600X1200;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1600X1200;
                 break;
         case 0x8:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 800;
@@ -327,7 +285,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_IDA_800X480;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_800X480;
                 break;
         case 0x9:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1024;
@@ -336,7 +293,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID2_1024X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1024X768;
                 break;
         case 0xA:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1024;
@@ -345,7 +301,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID2_1024X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1024X768;
                 break;
         case 0xB:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1024;
@@ -354,7 +309,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID2_1024X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1024X768;
                 break;
         case 0xC:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -363,7 +317,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID3_1280X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1280X768;
                 break;
         case 0xD:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -372,7 +325,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID4_1280X1024;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1280X1024;
                 break;
         case 0xE:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1400;
@@ -381,7 +333,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID5_1400X1050;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1400X1050;
                 break;
         case 0xF:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1600;
@@ -390,7 +341,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID6_1600X1200;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1600X1200;
                 break;
         case 0x10:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1366;
@@ -399,7 +349,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID7_1366X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1368X768;
                 break;
         case 0x11:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1024;
@@ -408,7 +357,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID8_1024X600;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1024X600;
                 break;
         case 0x12:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -417,7 +365,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID3_1280X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1280X768;
                 break;
         case 0x13:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -426,7 +373,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID9_1280X800;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_1280X800;
                 break;
         case 0x14:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1360;
@@ -435,7 +381,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_IDB_1360X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1360X768;
                 break;
         case 0x15:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 1280;
@@ -444,7 +389,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID3_1280X768;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 1;
                 viaparinfo->lvds_setting_info->LCDDithering = 0;
-                return VIA_RES_1280X768;
                 break;
         case 0x16:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 480;
@@ -453,7 +397,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_IDC_480X640;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_480X640;
                 break;
         default:
                 viaparinfo->lvds_setting_info->lcd_panel_hres = 800;
@@ -462,7 +405,6 @@ static int fp_id_to_vindex(int panel_id)
                         LCD_PANEL_ID1_800X600;
                 viaparinfo->lvds_setting_info->device_lcd_dualedge = 0;
                 viaparinfo->lvds_setting_info->LCDDithering = 1;
-                return VIA_RES_800X600;
         }
 }
 
@@ -573,284 +515,6 @@ static void load_lcd_scaling(int set_hres, int set_vres, int panel_hres,
         }
 }
 
-static void load_lcd_k400_patch_tbl(int set_hres, int set_vres,
-        int panel_id)
-{
-        int vmode_index;
-        int reg_num = 0;
-        struct io_reg *lcd_patch_reg = NULL;
-
-        vmode_index = viafb_get_mode_index(set_hres, set_vres);
-        switch (panel_id) {
-                /* LCD 800x600 */
-        case LCD_PANEL_ID1_800X600:
-                switch (vmode_index) {
-                case VIA_RES_640X400:
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_6X4_8X6;
-                        lcd_patch_reg = K400_LCD_RES_6X4_8X6;
-                        break;
-                case VIA_RES_720X480:
-                case VIA_RES_720X576:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_7X4_8X6;
-                        lcd_patch_reg = K400_LCD_RES_7X4_8X6;
-                        break;
-                }
-                break;
-
-                /* LCD 1024x768 */
-        case LCD_PANEL_ID2_1024X768:
-                switch (vmode_index) {
-                case VIA_RES_640X400:
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_6X4_10X7;
-                        lcd_patch_reg = K400_LCD_RES_6X4_10X7;
-                        break;
-                case VIA_RES_720X480:
-                case VIA_RES_720X576:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_7X4_10X7;
-                        lcd_patch_reg = K400_LCD_RES_7X4_10X7;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_8X6_10X7;
-                        lcd_patch_reg = K400_LCD_RES_8X6_10X7;
-                        break;
-                }
-                break;
-
-                /* LCD 1280x1024 */
-        case LCD_PANEL_ID4_1280X1024:
-                switch (vmode_index) {
-                case VIA_RES_640X400:
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_6X4_12X10;
-                        lcd_patch_reg = K400_LCD_RES_6X4_12X10;
-                        break;
-                case VIA_RES_720X480:
-                case VIA_RES_720X576:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_7X4_12X10;
-                        lcd_patch_reg = K400_LCD_RES_7X4_12X10;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_8X6_12X10;
-                        lcd_patch_reg = K400_LCD_RES_8X6_12X10;
-                        break;
-                case VIA_RES_1024X768:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_10X7_12X10;
-                        lcd_patch_reg = K400_LCD_RES_10X7_12X10;
-                        break;
-
-                }
-                break;
-
-                /* LCD 1400x1050 */
-        case LCD_PANEL_ID5_1400X1050:
-                switch (vmode_index) {
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_6X4_14X10;
-                        lcd_patch_reg = K400_LCD_RES_6X4_14X10;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_8X6_14X10;
-                        lcd_patch_reg = K400_LCD_RES_8X6_14X10;
-                        break;
-                case VIA_RES_1024X768:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_10X7_14X10;
-                        lcd_patch_reg = K400_LCD_RES_10X7_14X10;
-                        break;
-                case VIA_RES_1280X768:
-                case VIA_RES_1280X800:
-                case VIA_RES_1280X960:
-                case VIA_RES_1280X1024:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_12X10_14X10;
-                        lcd_patch_reg = K400_LCD_RES_12X10_14X10;
-                        break;
-                }
-                break;
-
-                /* LCD 1600x1200 */
-        case LCD_PANEL_ID6_1600X1200:
-                switch (vmode_index) {
-                case VIA_RES_640X400:
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_6X4_16X12;
-                        lcd_patch_reg = K400_LCD_RES_6X4_16X12;
-                        break;
-                case VIA_RES_720X480:
-                case VIA_RES_720X576:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_7X4_16X12;
-                        lcd_patch_reg = K400_LCD_RES_7X4_16X12;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_8X6_16X12;
-                        lcd_patch_reg = K400_LCD_RES_8X6_16X12;
-                        break;
-                case VIA_RES_1024X768:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_10X7_16X12;
-                        lcd_patch_reg = K400_LCD_RES_10X7_16X12;
-                        break;
-                case VIA_RES_1280X768:
-                case VIA_RES_1280X800:
-                case VIA_RES_1280X960:
-                case VIA_RES_1280X1024:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_12X10_16X12;
-                        lcd_patch_reg = K400_LCD_RES_12X10_16X12;
-                        break;
-                }
-                break;
-
-                /* LCD 1366x768 */
-        case LCD_PANEL_ID7_1366X768:
-                switch (vmode_index) {
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_6X4_1366X7;
-                        lcd_patch_reg = K400_LCD_RES_6X4_1366X7;
-                        break;
-                case VIA_RES_720X480:
-                case VIA_RES_720X576:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_7X4_1366X7;
-                        lcd_patch_reg = K400_LCD_RES_7X4_1366X7;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_8X6_1366X7;
-                        lcd_patch_reg = K400_LCD_RES_8X6_1366X7;
-                        break;
-                case VIA_RES_1024X768:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_10X7_1366X7;
-                        lcd_patch_reg = K400_LCD_RES_10X7_1366X7;
-                        break;
-                case VIA_RES_1280X768:
-                case VIA_RES_1280X800:
-                case VIA_RES_1280X960:
-                case VIA_RES_1280X1024:
-                        reg_num = NUM_TOTAL_K400_LCD_RES_12X10_1366X7;
-                        lcd_patch_reg = K400_LCD_RES_12X10_1366X7;
-                        break;
-                }
-                break;
-
-                /* LCD 1360x768 */
-        case LCD_PANEL_IDB_1360X768:
-                break;
-        }
-        if (reg_num != 0) {
-                /* H.W. Reset : ON */
-                viafb_write_reg_mask(CR17, VIACR, 0x00, BIT7);
-
-                viafb_write_regx(lcd_patch_reg, reg_num);
-
-                /* H.W. Reset : OFF */
-                viafb_write_reg_mask(CR17, VIACR, 0x80, BIT7);
-
-                /* Reset PLL */
-                viafb_write_reg_mask(SR40, VIASR, 0x02, BIT1);
-                viafb_write_reg_mask(SR40, VIASR, 0x00, BIT1);
-
-                /* Fire! */
-                outb(inb(VIARMisc) | (BIT2 + BIT3), VIAWMisc);
-        }
-}
-
-static void load_lcd_p880_patch_tbl(int set_hres, int set_vres,
-        int panel_id)
-{
-        int vmode_index;
-        int reg_num = 0;
-        struct io_reg *lcd_patch_reg = NULL;
-
-        vmode_index = viafb_get_mode_index(set_hres, set_vres);
-
-        switch (panel_id) {
-        case LCD_PANEL_ID5_1400X1050:
-                switch (vmode_index) {
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_6X4_14X10;
-                        lcd_patch_reg = P880_LCD_RES_6X4_14X10;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_8X6_14X10;
-                        lcd_patch_reg = P880_LCD_RES_8X6_14X10;
-                        break;
-                }
-                break;
-        case LCD_PANEL_ID6_1600X1200:
-                switch (vmode_index) {
-                case VIA_RES_640X400:
-                case VIA_RES_640X480:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_6X4_16X12;
-                        lcd_patch_reg = P880_LCD_RES_6X4_16X12;
-                        break;
-                case VIA_RES_720X480:
-                case VIA_RES_720X576:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_7X4_16X12;
-                        lcd_patch_reg = P880_LCD_RES_7X4_16X12;
-                        break;
-                case VIA_RES_800X600:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_8X6_16X12;
-                        lcd_patch_reg = P880_LCD_RES_8X6_16X12;
-                        break;
-                case VIA_RES_1024X768:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_10X7_16X12;
-                        lcd_patch_reg = P880_LCD_RES_10X7_16X12;
-                        break;
-                case VIA_RES_1280X768:
-                case VIA_RES_1280X960:
-                case VIA_RES_1280X1024:
-                        reg_num = NUM_TOTAL_P880_LCD_RES_12X10_16X12;
-                        lcd_patch_reg = P880_LCD_RES_12X10_16X12;
-                        break;
-                }
-                break;
-
-        }
-        if (reg_num != 0) {
-                /* H.W. Reset : ON */
-                viafb_write_reg_mask(CR17, VIACR, 0x00, BIT7);
-
-                viafb_write_regx(lcd_patch_reg, reg_num);
-
-                /* H.W. Reset : OFF */
-                viafb_write_reg_mask(CR17, VIACR, 0x80, BIT7);
-
-                /* Reset PLL */
-                viafb_write_reg_mask(SR40, VIASR, 0x02, BIT1);
-                viafb_write_reg_mask(SR40, VIASR, 0x00, BIT1);
-
-                /* Fire! */
-                outb(inb(VIARMisc) | (BIT2 + BIT3), VIAWMisc);
-        }
-}
-
-static void load_lcd_patch_regs(int set_hres, int set_vres,
-        int panel_id, int set_iga)
-{
-        int vmode_index;
-
-        vmode_index = viafb_get_mode_index(set_hres, set_vres);
-
-        viafb_unlock_crt();
-
-        /* Patch for simultaneous & Expansion */
-        if ((set_iga == IGA1_IGA2) &&
-                (viaparinfo->lvds_setting_info->display_method ==
-            LCD_EXPANDSION)) {
-                switch (viaparinfo->chip_info->gfx_chip_name) {
-                case UNICHROME_CLE266:
-                case UNICHROME_K400:
-                        load_lcd_k400_patch_tbl(set_hres, set_vres, panel_id);
-                        break;
-                case UNICHROME_K800:
-                        break;
-                case UNICHROME_PM800:
-                case UNICHROME_CN700:
-                case UNICHROME_CX700:
-                        load_lcd_p880_patch_tbl(set_hres, set_vres, panel_id);
-                }
-        }
-
-        viafb_lock_crt();
-}
-
 static void via_pitch_alignment_patch_lcd(
         struct lvds_setting_information *plvds_setting_info,
                                    struct lvds_chip_information
@@ -949,29 +613,25 @@ void viafb_lcd_set_mode(struct crt_mode_table *mode_crt_table,
                   struct lvds_setting_information *plvds_setting_info,
                   struct lvds_chip_information *plvds_chip_info)
 {
-        int video_index = plvds_setting_info->lcd_panel_size;
         int set_iga = plvds_setting_info->iga_path;
         int mode_bpp = plvds_setting_info->bpp;
-        int set_hres, set_vres;
-        int panel_hres, panel_vres;
+        int set_hres = plvds_setting_info->h_active;
+        int set_vres = plvds_setting_info->v_active;
+        int panel_hres = plvds_setting_info->lcd_panel_hres;
+        int panel_vres = plvds_setting_info->lcd_panel_vres;
         u32 pll_D_N;
-        int offset;
         struct display_timing mode_crt_reg, panel_crt_reg;
         struct crt_mode_table *panel_crt_table = NULL;
-        struct VideoModeTable *vmode_tbl = NULL;
+        struct VideoModeTable *vmode_tbl = viafb_get_mode(panel_hres,
+                panel_vres);
 
         DEBUG_MSG(KERN_INFO "viafb_lcd_set_mode!!\n");
         /* Get mode table */
         mode_crt_reg = mode_crt_table->crtc;
         /* Get panel table Pointer */
-        vmode_tbl = viafb_get_modetbl_pointer(video_index);
         panel_crt_table = vmode_tbl->crtc;
         panel_crt_reg = panel_crt_table->crtc;
         DEBUG_MSG(KERN_INFO "bellow viafb_lcd_set_mode!!\n");
-        set_hres = plvds_setting_info->h_active;
-        set_vres = plvds_setting_info->v_active;
-        panel_hres = plvds_setting_info->lcd_panel_hres;
-        panel_vres = plvds_setting_info->lcd_panel_vres;
         if (VT1636_LVDS == plvds_chip_info->lvds_chip_name)
                 viafb_init_lvds_vt1636(plvds_setting_info, plvds_chip_info);
         plvds_setting_info->vclk = panel_crt_table->clk;
@@ -1001,54 +661,12 @@ void viafb_lcd_set_mode(struct crt_mode_table *mode_crt_table,
                 }
         }
 
-        if (set_iga == IGA1_IGA2) {
-                load_crtc_shadow_timing(mode_crt_reg, panel_crt_reg);
-                /* Fill shadow registers */
-
-                switch (plvds_setting_info->lcd_panel_id) {
-                case LCD_PANEL_ID0_640X480:
-                        offset = 80;
-                        break;
-                case LCD_PANEL_ID1_800X600:
-                case LCD_PANEL_IDA_800X480:
-                        offset = 110;
-                        break;
-                case LCD_PANEL_ID2_1024X768:
-                        offset = 150;
-                        break;
-                case LCD_PANEL_ID3_1280X768:
-                case LCD_PANEL_ID4_1280X1024:
-                case LCD_PANEL_ID5_1400X1050:
-                case LCD_PANEL_ID9_1280X800:
-                        offset = 190;
-                        break;
-                case LCD_PANEL_ID6_1600X1200:
-                        offset = 250;
-                        break;
-                case LCD_PANEL_ID7_1366X768:
-                case LCD_PANEL_IDB_1360X768:
-                        offset = 212;
-                        break;
-                default:
-                        offset = 140;
-                        break;
-                }
-
-                /* Offset for simultaneous */
-                viafb_set_secondary_pitch(offset << 3);
-                DEBUG_MSG(KERN_INFO "viafb_load_reg!!\n");
-                viafb_load_fetch_count_reg(set_hres, 4, IGA2);
-                /* Fetch count for simultaneous */
-        } else {                /* SAMM */
-                /* Fetch count for IGA2 only */
-                viafb_load_fetch_count_reg(set_hres, mode_bpp / 8, set_iga);
-
-                if ((viaparinfo->chip_info->gfx_chip_name != UNICHROME_CLE266)
-                    && (viaparinfo->chip_info->gfx_chip_name != UNICHROME_K400))
-                        viafb_load_FIFO_reg(set_iga, set_hres, set_vres);
+        /* Fetch count for IGA2 only */
+        viafb_load_fetch_count_reg(set_hres, mode_bpp / 8, set_iga);
 
-                viafb_set_color_depth(mode_bpp / 8, set_iga);
-        }
+        if ((viaparinfo->chip_info->gfx_chip_name != UNICHROME_CLE266)
+                && (viaparinfo->chip_info->gfx_chip_name != UNICHROME_K400))
+                viafb_load_FIFO_reg(set_iga, set_hres, set_vres);
 
         fill_lcd_format();
 
@@ -1065,11 +683,6 @@ void viafb_lcd_set_mode(struct crt_mode_table *mode_crt_table,
             || (UNICHROME_K8M890 == viaparinfo->chip_info->gfx_chip_name))
                 viafb_write_reg_mask(CR6A, VIACR, 0x01, BIT0);
 
-        load_lcd_patch_regs(set_hres, set_vres,
-                            plvds_setting_info->lcd_panel_id, set_iga);
-
-        DEBUG_MSG(KERN_INFO "load_lcd_patch_regs!!\n");
-
         /* Patch for non 32bit alignment mode */
         via_pitch_alignment_patch_lcd(plvds_setting_info, plvds_chip_info);
 }
@@ -1283,8 +896,7 @@ void viafb_lcd_enable(void)
                 viafb_write_reg_mask(CR6A, VIACR, 0x48, 0x48);
         }
 
-        if ((viaparinfo->lvds_setting_info->iga_path == IGA1)
-            || (viaparinfo->lvds_setting_info->iga_path == IGA1_IGA2)) {
+        if (viaparinfo->lvds_setting_info->iga_path == IGA1) {
                 /* CRT path set to IGA2    */
                 viafb_write_reg_mask(SR16, VIASR, 0x40, 0x40);
                 /* IGA2 path disabled      */
@@ -1476,210 +1088,6 @@ static struct display_timing lcd_centering_timging(struct display_timing
         return crt_reg;
 }
 
-static void load_crtc_shadow_timing(struct display_timing mode_timing,
-                             struct display_timing panel_timing)
-{
-        struct io_register *reg = NULL;
-        int i;
-        int viafb_load_reg_Num = 0;
-        int reg_value = 0;
-
-        if (viaparinfo->lvds_setting_info->display_method == LCD_EXPANDSION) {
-                /* Expansion */
-                for (i = 12; i < 20; i++) {
-                        switch (i) {
-                        case H_TOTAL_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_HOR_TOTAL_SHADOW_FORMULA
-                                    (panel_timing.hor_total);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.hor_total_shadow.
-                                    reg_num;
-                                reg = iga2_shadow_crtc_reg.hor_total_shadow.reg;
-                                break;
-                        case H_BLANK_END_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_HOR_BLANK_END_SHADOW_FORMULA
-                                    (panel_timing.hor_blank_start,
-                                     panel_timing.hor_blank_end);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    hor_blank_end_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    hor_blank_end_shadow.reg;
-                                break;
-                        case V_TOTAL_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_TOTAL_SHADOW_FORMULA
-                                    (panel_timing.ver_total);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.ver_total_shadow.
-                                    reg_num;
-                                reg = iga2_shadow_crtc_reg.ver_total_shadow.reg;
-                                break;
-                        case V_ADDR_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_ADDR_SHADOW_FORMULA
-                                    (panel_timing.ver_addr);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.ver_addr_shadow.
-                                    reg_num;
-                                reg = iga2_shadow_crtc_reg.ver_addr_shadow.reg;
-                                break;
-                        case V_BLANK_SATRT_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_BLANK_START_SHADOW_FORMULA
-                                    (panel_timing.ver_blank_start);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_start_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_start_shadow.reg;
-                                break;
-                        case V_BLANK_END_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_BLANK_END_SHADOW_FORMULA
-                                    (panel_timing.ver_blank_start,
-                                     panel_timing.ver_blank_end);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_end_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_end_shadow.reg;
-                                break;
-                        case V_SYNC_SATRT_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_SYNC_START_SHADOW_FORMULA
-                                    (panel_timing.ver_sync_start);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    ver_sync_start_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    ver_sync_start_shadow.reg;
-                                break;
-                        case V_SYNC_END_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_SYNC_END_SHADOW_FORMULA
-                                    (panel_timing.ver_sync_start,
-                                     panel_timing.ver_sync_end);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    ver_sync_end_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    ver_sync_end_shadow.reg;
-                                break;
-                        }
-                        viafb_load_reg(reg_value,
-                                viafb_load_reg_Num, reg, VIACR);
-                }
-        } else {                /* Centering */
-                for (i = 12; i < 20; i++) {
-                        switch (i) {
-                        case H_TOTAL_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_HOR_TOTAL_SHADOW_FORMULA
-                                    (panel_timing.hor_total);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.hor_total_shadow.
-                                    reg_num;
-                                reg = iga2_shadow_crtc_reg.hor_total_shadow.reg;
-                                break;
-                        case H_BLANK_END_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_HOR_BLANK_END_SHADOW_FORMULA
-                                    (panel_timing.hor_blank_start,
-                                     panel_timing.hor_blank_end);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    hor_blank_end_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    hor_blank_end_shadow.reg;
-                                break;
-                        case V_TOTAL_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_TOTAL_SHADOW_FORMULA
-                                    (panel_timing.ver_total);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.ver_total_shadow.
-                                    reg_num;
-                                reg = iga2_shadow_crtc_reg.ver_total_shadow.reg;
-                                break;
-                        case V_ADDR_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_ADDR_SHADOW_FORMULA
-                                    (mode_timing.ver_addr);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.ver_addr_shadow.
-                                    reg_num;
-                                reg = iga2_shadow_crtc_reg.ver_addr_shadow.reg;
-                                break;
-                        case V_BLANK_SATRT_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_BLANK_START_SHADOW_FORMULA
-                                    (mode_timing.ver_blank_start);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_start_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_start_shadow.reg;
-                                break;
-                        case V_BLANK_END_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_BLANK_END_SHADOW_FORMULA
-                                    (panel_timing.ver_blank_start,
-                                     panel_timing.ver_blank_end);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_end_shadow.reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.
-                                    ver_blank_end_shadow.reg;
-                                break;
-                        case V_SYNC_SATRT_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_SYNC_START_SHADOW_FORMULA(
-                                    (panel_timing.ver_sync_start -
-                                    panel_timing.ver_blank_start) +
-                                    (panel_timing.ver_addr -
-                                    mode_timing.ver_addr) / 2 +
-                                    mode_timing.ver_addr);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.ver_sync_start_shadow.
-                                    reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.ver_sync_start_shadow.
-                                    reg;
-                                break;
-                        case V_SYNC_END_SHADOW_INDEX:
-                                reg_value =
-                                    IGA2_VER_SYNC_END_SHADOW_FORMULA(
-                                    (panel_timing.ver_sync_start -
-                                    panel_timing.ver_blank_start) +
-                                    (panel_timing.ver_addr -
-                                    mode_timing.ver_addr) / 2 +
-                                    mode_timing.ver_addr,
-                                    panel_timing.ver_sync_end);
-                                viafb_load_reg_Num =
-                                    iga2_shadow_crtc_reg.ver_sync_end_shadow.
-                                    reg_num;
-                                reg =
-                                    iga2_shadow_crtc_reg.ver_sync_end_shadow.
-                                    reg;
-                                break;
-                        }
-                        viafb_load_reg(reg_value,
-                                viafb_load_reg_Num, reg, VIACR);
-                }
-        }
-}
-
 bool viafb_lcd_get_mobile_state(bool *mobile)
 {
         unsigned char *romptr, *tableptr;
diff --git a/drivers/video/via/share.h b/drivers/video/via/share.h
index 7cd03e2a1275..d55aaa7b912c 100644
--- a/drivers/video/via/share.h
+++ b/drivers/video/via/share.h
@@ -43,61 +43,6 @@
 /* Video Memory Size */
 #define VIDEO_MEMORY_SIZE_16M    0x1000000
 
-/* Definition Mode Index
-*/
-#define     VIA_RES_640X480                     0
-#define     VIA_RES_800X600                     1
-#define     VIA_RES_1024X768                    2
-#define     VIA_RES_1152X864                    3
-#define     VIA_RES_1280X1024                   4
-#define     VIA_RES_1600X1200                   5
-#define     VIA_RES_1440X1050                   6
-#define     VIA_RES_1280X768                    7
-#define     VIA_RES_1280X960                    8
-#define     VIA_RES_1920X1440                   9
-#define     VIA_RES_848X480                     10
-#define     VIA_RES_1400X1050                   11
-#define     VIA_RES_720X480                     12
-#define     VIA_RES_720X576                     13
-#define     VIA_RES_1024X512                    14
-#define     VIA_RES_856X480                     15
-#define     VIA_RES_1024X576                    16
-#define     VIA_RES_640X400                     17
-#define     VIA_RES_1280X720                    18
-#define     VIA_RES_1920X1080                   19
-#define     VIA_RES_800X480                     20
-#define     VIA_RES_1368X768                    21
-#define     VIA_RES_1024X600                    22
-#define     VIA_RES_1280X800                    23
-#define     VIA_RES_1680X1050                   24
-#define     VIA_RES_960X600                     25
-#define     VIA_RES_1000X600                    26
-#define     VIA_RES_1088X612                    27
-#define     VIA_RES_1152X720                    28
-#define     VIA_RES_1200X720                    29
-#define     VIA_RES_1280X600                    30
-#define     VIA_RES_1360X768                    31
-#define     VIA_RES_1366X768                    32
-#define     VIA_RES_1440X900                    33
-#define     VIA_RES_1600X900                    34
-#define     VIA_RES_1600X1024                   35
-#define     VIA_RES_1792X1344                   36
-#define     VIA_RES_1856X1392                   37
-#define     VIA_RES_1920X1200                   38
-#define     VIA_RES_2048X1536                   39
-#define     VIA_RES_480X640                     40
-
-/*Reduce Blanking*/
-#define     VIA_RES_1360X768_RB                 131
-#define     VIA_RES_1440X900_RB                 133
-#define     VIA_RES_1400X1050_RB                111
-#define     VIA_RES_1600X900_RB                 134
-#define     VIA_RES_1680X1050_RB                124
-#define     VIA_RES_1920X1080_RB                119
-#define     VIA_RES_1920X1200_RB                138
-
-#define     VIA_RES_INVALID                     255
-
 /* standard VGA IO port
 */
 #define VIARMisc    0x3CC
@@ -118,7 +63,6 @@
 /* Display path */
 #define IGA1        1
 #define IGA2        2
-#define IGA1_IGA2   3
 
 /* Define Color Depth  */
 #define MODE_8BPP       1
diff --git a/drivers/video/via/via_utility.c b/drivers/video/via/via_utility.c
index d53c3d54ed8e..aefdeeec89b1 100644
--- a/drivers/video/via/via_utility.c
+++ b/drivers/video/via/via_utility.c
@@ -239,15 +239,3 @@ void viafb_get_gamma_support_state(int bpp, unsigned int *support_state)
         else
                 *support_state = CRT_Device | DVI_Device | LCD_Device;
 }
-
-int viafb_input_parameter_converter(int parameter_value)
-{
-        int result;
-
-        if (parameter_value >= 1 && parameter_value <= 9)
-                result = 1 << (parameter_value - 1);
-        else
-                result = 1;
-
-        return result;
-}
diff --git a/drivers/video/via/via_utility.h b/drivers/video/via/via_utility.h
index 2fd455202ebd..1670ba82143f 100644
--- a/drivers/video/via/via_utility.h
+++ b/drivers/video/via/via_utility.h
@@ -30,6 +30,5 @@ bool viafb_lcd_get_support_expand_state(u32 xres, u32 yres);
 void viafb_set_gamma_table(int bpp, unsigned int *gamma_table);
 void viafb_get_gamma_table(unsigned int *gamma_table);
 void viafb_get_gamma_support_state(int bpp, unsigned int *support_state);
-int viafb_input_parameter_converter(int parameter_value);
 
 #endif /* __VIAUTILITY_H__ */
diff --git a/drivers/video/via/viafbdev.c b/drivers/video/via/viafbdev.c
index 3028e7ddc3b5..ce7783b63f6a 100644
--- a/drivers/video/via/viafbdev.c
+++ b/drivers/video/via/viafbdev.c
@@ -26,18 +26,22 @@
 
 #include "global.h"
 
-static struct fb_var_screeninfo default_var;
 static char *viafb_name = "Via";
 static u32 pseudo_pal[17];
 
 /* video mode */
-static char *viafb_mode = "640x480";
-static char *viafb_mode1 = "640x480";
+static char *viafb_mode;
+static char *viafb_mode1;
+static int viafb_bpp = 32;
+static int viafb_bpp1 = 32;
+
+static unsigned int viafb_second_offset;
+static int viafb_second_size;
 
 static int viafb_accel = 1;
 
 /* Added for specifying active devices.*/
-char *viafb_active_dev = "";
+char *viafb_active_dev;
 
 /*Added for specify lcd output port*/
 char *viafb_lcd_port = "";
@@ -50,18 +54,78 @@ static void apply_second_mode_setting(struct fb_var_screeninfo
         *sec_var);
 static void retrieve_device_setting(struct viafb_ioctl_setting
         *setting_info);
+static int viafb_pan_display(struct fb_var_screeninfo *var,
+        struct fb_info *info);
 
 static struct fb_ops viafb_ops;
 
 
+static void viafb_fill_var_color_info(struct fb_var_screeninfo *var, u8 depth)
+{
+        var->grayscale = 0;
+        var->red.msb_right = 0;
+        var->green.msb_right = 0;
+        var->blue.msb_right = 0;
+        var->transp.offset = 0;
+        var->transp.length = 0;
+        var->transp.msb_right = 0;
+        var->nonstd = 0;
+        switch (depth) {
+        case 8:
+                var->bits_per_pixel = 8;
+                var->red.offset = 0;
+                var->green.offset = 0;
+                var->blue.offset = 0;
+                var->red.length = 8;
+                var->green.length = 8;
+                var->blue.length = 8;
+                break;
+        case 15:
+                var->bits_per_pixel = 16;
+                var->red.offset = 10;
+                var->green.offset = 5;
+                var->blue.offset = 0;
+                var->red.length = 5;
+                var->green.length = 5;
+                var->blue.length = 5;
+                break;
+        case 16:
+                var->bits_per_pixel = 16;
+                var->red.offset = 11;
+                var->green.offset = 5;
+                var->blue.offset = 0;
+                var->red.length = 5;
+                var->green.length = 6;
+                var->blue.length = 5;
+                break;
+        case 24:
+                var->bits_per_pixel = 32;
+                var->red.offset = 16;
+                var->green.offset = 8;
+                var->blue.offset = 0;
+                var->red.length = 8;
+                var->green.length = 8;
+                var->blue.length = 8;
+                break;
+        case 30:
+                var->bits_per_pixel = 32;
+                var->red.offset = 20;
+                var->green.offset = 10;
+                var->blue.offset = 0;
+                var->red.length = 10;
+                var->green.length = 10;
+                var->blue.length = 10;
+                break;
+        }
+}
+
 static void viafb_update_fix(struct fb_info *info)
 {
         u32 bpp = info->var.bits_per_pixel;
 
         info->fix.visual =
                 bpp == 8 ? FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
-        info->fix.line_length =
-                ((info->var.xres_virtual + 7) & ~7) * bpp / 8;
+        info->fix.line_length = (info->var.xres_virtual * bpp / 8 + 7) & ~7;
 }
 
 static void viafb_setup_fixinfo(struct fb_fix_screeninfo *fix,
@@ -75,6 +139,7 @@ static void viafb_setup_fixinfo(struct fb_fix_screeninfo *fix,
 
         fix->type = FB_TYPE_PACKED_PIXELS;
         fix->type_aux = 0;
+        fix->visual = FB_VISUAL_TRUECOLOR;
 
         fix->xpanstep = fix->ywrapstep = 0;
         fix->ypanstep = 1;
@@ -97,9 +162,10 @@ static int viafb_release(struct fb_info *info, int user)
 static int viafb_check_var(struct fb_var_screeninfo *var,
         struct fb_info *info)
 {
-        int vmode_index, htotal, vtotal;
+        int htotal, vtotal, depth;
+        struct VideoModeTable *vmode_entry;
         struct viafb_par *ppar = info->par;
-        u32 long_refresh;
+        u32 long_refresh, line;
 
         DEBUG_MSG(KERN_INFO "viafb_check_var!\n");
         /* Sanity check */
@@ -107,26 +173,36 @@ static int viafb_check_var(struct fb_var_screeninfo *var,
         if (var->vmode & FB_VMODE_INTERLACED || var->vmode & FB_VMODE_DOUBLE)
                 return -EINVAL;
 
-        vmode_index = viafb_get_mode_index(var->xres, var->yres);
-        if (vmode_index == VIA_RES_INVALID) {
+        vmode_entry = viafb_get_mode(var->xres, var->yres);
+        if (!vmode_entry) {
                 DEBUG_MSG(KERN_INFO
                           "viafb: Mode %dx%dx%d not supported!!\n",
                           var->xres, var->yres, var->bits_per_pixel);
                 return -EINVAL;
         }
 
-        if (24 == var->bits_per_pixel)
-                var->bits_per_pixel = 32;
+        depth = fb_get_color_depth(var, &info->fix);
+        if (!depth)
+                depth = var->bits_per_pixel;
 
-        if (var->bits_per_pixel != 8 && var->bits_per_pixel != 16 &&
-                var->bits_per_pixel != 32)
+        if (depth < 0 || depth > 32)
                 return -EINVAL;
+        else if (!depth)
+                depth = 24;
+        else if (depth == 15 && viafb_dual_fb && ppar->iga_path == IGA1)
+                depth = 15;
+        else if (depth == 30)
+                depth = 30;
+        else if (depth <= 8)
+                depth = 8;
+        else if (depth <= 16)
+                depth = 16;
+        else
+                depth = 24;
 
-        if ((var->xres_virtual * (var->bits_per_pixel >> 3)) & 0x1F)
-                /*32 pixel alignment */
-                var->xres_virtual = (var->xres_virtual + 31) & ~31;
-        if (var->xres_virtual * var->yres_virtual * var->bits_per_pixel / 8 >
-                ppar->memsize)
+        viafb_fill_var_color_info(var, depth);
+        line = (var->xres_virtual * var->bits_per_pixel / 8 + 7) & ~7;
+        if (line * var->yres_virtual > ppar->memsize)
                 return -EINVAL;
 
         /* Based on var passed in to calculate the refresh,
@@ -142,7 +218,7 @@ static int viafb_check_var(struct fb_var_screeninfo *var,
         viafb_refresh = viafb_get_refresh(var->xres, var->yres, long_refresh);
 
         /* Adjust var according to our driver's own table */
-        viafb_fill_var_timing_info(var, viafb_refresh, vmode_index);
+        viafb_fill_var_timing_info(var, viafb_refresh, vmode_entry);
         if (info->var.accel_flags & FB_ACCELF_TEXT &&
                 !ppar->shared->engine_mmio)
                 info->var.accel_flags = 0;
@@ -153,39 +229,45 @@ static int viafb_check_var(struct fb_var_screeninfo *var,
 static int viafb_set_par(struct fb_info *info)
 {
         struct viafb_par *viapar = info->par;
-        int vmode_index;
-        int vmode_index1 = 0;
+        struct VideoModeTable *vmode_entry, *vmode_entry1 = NULL;
         DEBUG_MSG(KERN_INFO "viafb_set_par!\n");
 
         viapar->depth = fb_get_color_depth(&info->var, &info->fix);
-        viafb_update_device_setting(info->var.xres, info->var.yres,
-                              info->var.bits_per_pixel, viafb_refresh, 0);
+        viafb_update_device_setting(viafbinfo->var.xres, viafbinfo->var.yres,
+                viafbinfo->var.bits_per_pixel, viafb_refresh, 0);
 
-        vmode_index = viafb_get_mode_index(info->var.xres, info->var.yres);
-
-        if (viafb_SAMM_ON == 1) {
+        vmode_entry = viafb_get_mode(viafbinfo->var.xres, viafbinfo->var.yres);
+        if (viafb_dual_fb) {
+                vmode_entry1 = viafb_get_mode(viafbinfo1->var.xres,
+                        viafbinfo1->var.yres);
+                viafb_update_device_setting(viafbinfo1->var.xres,
+                        viafbinfo1->var.yres, viafbinfo1->var.bits_per_pixel,
+                        viafb_refresh1, 1);
+        } else if (viafb_SAMM_ON == 1) {
                 DEBUG_MSG(KERN_INFO
                 "viafb_second_xres = %d, viafb_second_yres = %d, bpp = %d\n",
                           viafb_second_xres, viafb_second_yres, viafb_bpp1);
-                vmode_index1 = viafb_get_mode_index(viafb_second_xres,
+                vmode_entry1 = viafb_get_mode(viafb_second_xres,
                         viafb_second_yres);
-                DEBUG_MSG(KERN_INFO "->viafb_SAMM_ON: index=%d\n",
-                        vmode_index1);
 
                 viafb_update_device_setting(viafb_second_xres,
                         viafb_second_yres, viafb_bpp1, viafb_refresh1, 1);
         }
 
-        if (vmode_index != VIA_RES_INVALID) {
+        if (vmode_entry) {
                 viafb_update_fix(info);
-                viafb_bpp = info->var.bits_per_pixel;
+                if (viafb_dual_fb && viapar->iga_path == IGA2)
+                        viafb_bpp1 = info->var.bits_per_pixel;
+                else
+                        viafb_bpp = info->var.bits_per_pixel;
+
                 if (info->var.accel_flags & FB_ACCELF_TEXT)
                         info->flags &= ~FBINFO_HWACCEL_DISABLED;
                 else
                         info->flags |= FBINFO_HWACCEL_DISABLED;
-                viafb_setmode(vmode_index, info->var.xres, info->var.yres,
-                        info->var.bits_per_pixel, vmode_index1,
-                        viafb_second_xres, viafb_second_yres, viafb_bpp1);
+                viafb_setmode(vmode_entry, info->var.bits_per_pixel,
+                        vmode_entry1, viafb_bpp1);
+                viafb_pan_display(&info->var, info);
         }
 
         return 0;
@@ -195,234 +277,52 @@ static int viafb_set_par(struct fb_info *info)
 static int viafb_setcolreg(unsigned regno, unsigned red, unsigned green,
 unsigned blue, unsigned transp, struct fb_info *info)
 {
-        u8 sr1a, sr1b, cr67, cr6a, rev = 0, shift = 10;
-        unsigned cmap_entries = (info->var.bits_per_pixel == 8) ? 256 : 16;
-        DEBUG_MSG(KERN_INFO "viafb_setcolreg!\n");
-        if (regno >= cmap_entries)
-                return 1;
-        if (UNICHROME_CLE266 == viaparinfo->chip_info->gfx_chip_name) {
-                /*
-                 * Read PCI bus 0,dev 0,function 0,index 0xF6 to get chip rev.
-                 */
-                outl(0x80000000 | (0xf6 & ~3), (unsigned long)0xCF8);
-                rev = (inl((unsigned long)0xCFC) >> ((0xf6 & 3) * 8)) & 0xff;
-        }
-        switch (info->var.bits_per_pixel) {
-        case 8:
-                outb(0x1A, 0x3C4);
-                sr1a = inb(0x3C5);
-                outb(0x1B, 0x3C4);
-                sr1b = inb(0x3C5);
-                outb(0x67, 0x3D4);
-                cr67 = inb(0x3D5);
-                outb(0x6A, 0x3D4);
-                cr6a = inb(0x3D5);
-
-                /* Map the 3C6/7/8/9 to the IGA2 */
-                outb(0x1A, 0x3C4);
-                outb(sr1a | 0x01, 0x3C5);
-                /* Second Display Engine colck always on */
-                outb(0x1B, 0x3C4);
-                outb(sr1b | 0x80, 0x3C5);
-                /* Second Display Color Depth 8 */
-                outb(0x67, 0x3D4);
-                outb(cr67 & 0x3F, 0x3D5);
-                outb(0x6A, 0x3D4);
-                /* Second Display Channel Reset CR6A[6]) */
-                outb(cr6a & 0xBF, 0x3D5);
-                /* Second Display Channel Enable CR6A[7] */
-                outb(cr6a | 0x80, 0x3D5);
-                /* Second Display Channel stop reset) */
-                outb(cr6a | 0x40, 0x3D5);
-
-                /* Bit mask of palette */
-                outb(0xFF, 0x3c6);
-                /* Write one register of IGA2 */
-                outb(regno, 0x3C8);
-                if (UNICHROME_CLE266 == viaparinfo->chip_info->gfx_chip_name &&
-                        rev >= 15) {
-                        shift = 8;
-                        viafb_write_reg_mask(CR6A, VIACR, BIT5, BIT5);
-                        viafb_write_reg_mask(SR15, VIASR, BIT7, BIT7);
-                } else {
-                        shift = 10;
-                        viafb_write_reg_mask(CR6A, VIACR, 0, BIT5);
-                        viafb_write_reg_mask(SR15, VIASR, 0, BIT7);
-                }
-                outb(red >> shift, 0x3C9);
-                outb(green >> shift, 0x3C9);
-                outb(blue >> shift, 0x3C9);
-
-                /* Map the 3C6/7/8/9 to the IGA1 */
-                outb(0x1A, 0x3C4);
-                outb(sr1a & 0xFE, 0x3C5);
-                /* Bit mask of palette */
-                outb(0xFF, 0x3c6);
-                /* Write one register of IGA1 */
-                outb(regno, 0x3C8);
-                outb(red >> shift, 0x3C9);
-                outb(green >> shift, 0x3C9);
-                outb(blue >> shift, 0x3C9);
-
-                outb(0x1A, 0x3C4);
-                outb(sr1a, 0x3C5);
-                outb(0x1B, 0x3C4);
-                outb(sr1b, 0x3C5);
-                outb(0x67, 0x3D4);
-                outb(cr67, 0x3D5);
-                outb(0x6A, 0x3D4);
-                outb(cr6a, 0x3D5);
-                break;
-        case 16:
-                ((u32 *) info->pseudo_palette)[regno] = (red & 0xF800) |
-                    ((green & 0xFC00) >> 5) | ((blue & 0xF800) >> 11);
-                break;
-        case 32:
-                ((u32 *) info->pseudo_palette)[regno] =
-                    ((transp & 0xFF00) << 16) |
-                    ((red & 0xFF00) << 8) |
-                    ((green & 0xFF00)) | ((blue & 0xFF00) >> 8);
-                break;
-        }
-
-        return 0;
+        struct viafb_par *viapar = info->par;
+        u32 r, g, b;
 
-}
+        if (info->fix.visual == FB_VISUAL_PSEUDOCOLOR) {
+                if (regno > 255)
+                        return -EINVAL;
 
-/*CALLED BY: fb_set_cmap */
-/*           fb_set_var, pass 256 colors */
-/*CALLED BY: fb_set_cmap */
-/*           fbcon_set_palette, pass 16 colors */
-static int viafb_setcmap(struct fb_cmap *cmap, struct fb_info *info)
-{
-        u32 len = cmap->len;
-        u32 i;
-        u16 *pred = cmap->red;
-        u16 *pgreen = cmap->green;
-        u16 *pblue = cmap->blue;
-        u16 *ptransp = cmap->transp;
-        u8 sr1a, sr1b, cr67, cr6a, rev = 0, shift = 10;
-        if (len > 256)
-                return 1;
-        if (UNICHROME_CLE266 == viaparinfo->chip_info->gfx_chip_name) {
-                /*
-                 * Read PCI bus 0, dev 0, function 0, index 0xF6 to get chip
-                 * rev.
-                 */
-                outl(0x80000000 | (0xf6 & ~3), (unsigned long)0xCF8);
-                rev = (inl((unsigned long)0xCFC) >> ((0xf6 & 3) * 8)) & 0xff;
-        }
-        switch (info->var.bits_per_pixel) {
-        case 8:
-                outb(0x1A, 0x3C4);
-                sr1a = inb(0x3C5);
-                outb(0x1B, 0x3C4);
-                sr1b = inb(0x3C5);
-                outb(0x67, 0x3D4);
-                cr67 = inb(0x3D5);
-                outb(0x6A, 0x3D4);
-                cr6a = inb(0x3D5);
-                /* Map the 3C6/7/8/9 to the IGA2 */
-                outb(0x1A, 0x3C4);
-                outb(sr1a | 0x01, 0x3C5);
-                outb(0x1B, 0x3C4);
-                /* Second Display Engine colck always on */
-                outb(sr1b | 0x80, 0x3C5);
-                outb(0x67, 0x3D4);
-                /* Second Display Color Depth 8 */
-                outb(cr67 & 0x3F, 0x3D5);
-                outb(0x6A, 0x3D4);
-                /* Second Display Channel Reset CR6A[6]) */
-                outb(cr6a & 0xBF, 0x3D5);
-                /* Second Display Channel Enable CR6A[7] */
-                outb(cr6a | 0x80, 0x3D5);
-                /* Second Display Channel stop reset) */
-                outb(cr6a | 0xC0, 0x3D5);
-
-                /* Bit mask of palette */
-                outb(0xFF, 0x3c6);
-                outb(0x00, 0x3C8);
-                if (UNICHROME_CLE266 == viaparinfo->chip_info->gfx_chip_name &&
-                        rev >= 15) {
-                        shift = 8;
-                        viafb_write_reg_mask(CR6A, VIACR, BIT5, BIT5);
-                        viafb_write_reg_mask(SR15, VIASR, BIT7, BIT7);
-                } else {
-                        shift = 10;
-                        viafb_write_reg_mask(CR6A, VIACR, 0, BIT5);
-                        viafb_write_reg_mask(SR15, VIASR, 0, BIT7);
-                }
-                for (i = 0; i < len; i++) {
-                        outb((*(pred + i)) >> shift, 0x3C9);
-                        outb((*(pgreen + i)) >> shift, 0x3C9);
-                        outb((*(pblue + i)) >> shift, 0x3C9);
-                }
+                if (!viafb_dual_fb || viapar->iga_path == IGA1)
+                        viafb_set_primary_color_register(regno, red >> 8,
+                                green >> 8, blue >> 8);
 
-                outb(0x1A, 0x3C4);
-                /* Map the 3C6/7/8/9 to the IGA1 */
-                outb(sr1a & 0xFE, 0x3C5);
-                /* Bit mask of palette */
-                outb(0xFF, 0x3c6);
-                outb(0x00, 0x3C8);
-                for (i = 0; i < len; i++) {
-                        outb((*(pred + i)) >> shift, 0x3C9);
-                        outb((*(pgreen + i)) >> shift, 0x3C9);
-                        outb((*(pblue + i)) >> shift, 0x3C9);
-                }
+                if (!viafb_dual_fb || viapar->iga_path == IGA2)
+                        viafb_set_secondary_color_register(regno, red >> 8,
+                                green >> 8, blue >> 8);
+        } else {
+                if (regno > 15)
+                        return -EINVAL;
 
-                outb(0x1A, 0x3C4);
-                outb(sr1a, 0x3C5);
-                outb(0x1B, 0x3C4);
-                outb(sr1b, 0x3C5);
-                outb(0x67, 0x3D4);
-                outb(cr67, 0x3D5);
-                outb(0x6A, 0x3D4);
-                outb(cr6a, 0x3D5);
-                break;
-        case 16:
-                if (len > 17)
-                        return 0;       /* Because static u32 pseudo_pal[17]; */
-                for (i = 0; i < len; i++)
-                        ((u32 *) info->pseudo_palette)[i] =
-                            (*(pred + i) & 0xF800) |
-                            ((*(pgreen + i) & 0xFC00) >> 5) |
-                            ((*(pblue + i) & 0xF800) >> 11);
-                break;
-        case 32:
-                if (len > 17)
-                        return 0;
-                if (ptransp) {
-                        for (i = 0; i < len; i++)
-                                ((u32 *) info->pseudo_palette)[i] =
-                                    ((*(ptransp + i) & 0xFF00) << 16) |
-                                    ((*(pred + i) & 0xFF00) << 8) |
-                                    ((*(pgreen + i) & 0xFF00)) |
-                                    ((*(pblue + i) & 0xFF00) >> 8);
-                } else {
-                        for (i = 0; i < len; i++)
-                                ((u32 *) info->pseudo_palette)[i] =
-                                    0x00000000 |
-                                    ((*(pred + i) & 0xFF00) << 8) |
-                                    ((*(pgreen + i) & 0xFF00)) |
-                                    ((*(pblue + i) & 0xFF00) >> 8);
-                }
-                break;
+                r = (red >> (16 - info->var.red.length))
+                        << info->var.red.offset;
+                b = (blue >> (16 - info->var.blue.length))
+                        << info->var.blue.offset;
+                g = (green >> (16 - info->var.green.length))
+                        << info->var.green.offset;
+                ((u32 *) info->pseudo_palette)[regno] = r | g | b;
         }
+
         return 0;
 }
 
 static int viafb_pan_display(struct fb_var_screeninfo *var,
         struct fb_info *info)
 {
-        unsigned int offset;
-
-        DEBUG_MSG(KERN_INFO "viafb_pan_display!\n");
-
-        offset = (var->xoffset + (var->yoffset * var->xres_virtual)) *
-            var->bits_per_pixel / 16;
+        struct viafb_par *viapar = info->par;
+        u32 vram_addr = (var->yoffset * var->xres_virtual + var->xoffset)
+                * (var->bits_per_pixel / 8) + viapar->vram_addr;
+
+        DEBUG_MSG(KERN_DEBUG "viafb_pan_display, address = %d\n", vram_addr);
+        if (!viafb_dual_fb) {
+                viafb_set_primary_address(vram_addr);
+                viafb_set_secondary_address(vram_addr);
+        } else if (viapar->iga_path == IGA1)
+                viafb_set_primary_address(vram_addr);
+        else
+                viafb_set_secondary_address(vram_addr);
 
-        DEBUG_MSG(KERN_INFO "\nviafb_pan_display,offset =%d ", offset);
-        viafb_set_primary_address(offset);
         return 0;
 }
 
@@ -476,6 +376,7 @@ static int viafb_ioctl(struct fb_info *info, u_int cmd, u_long arg)
         u32 gpu32;
 
         DEBUG_MSG(KERN_INFO "viafb_ioctl: 0x%X !!\n", cmd);
+        printk(KERN_WARNING "viafb_ioctl: Please avoid this interface as it is unstable and might change or vanish at any time!\n");
         memset(&u, 0, sizeof(u));
 
         switch (cmd) {
@@ -1015,23 +916,6 @@ static int viafb_sync(struct fb_info *info)
         return 0;
 }
 
-int viafb_get_mode_index(int hres, int vres)
-{
-        u32 i;
-        DEBUG_MSG(KERN_INFO "viafb_get_mode_index!\n");
-
-        for (i = 0; i < NUM_TOTAL_MODETABLE; i++)
-                if (CLE266Modes[i].mode_array &&
-                        CLE266Modes[i].crtc[0].crtc.hor_addr == hres &&
-                        CLE266Modes[i].crtc[0].crtc.ver_addr == vres)
-                        break;
-
-        if (i == NUM_TOTAL_MODETABLE)
-                return VIA_RES_INVALID;
-
-        return CLE266Modes[i].ModeIndex;
-}
-
 static void check_available_device_to_enable(int device_id)
 {
         int device_num = 0;
@@ -1330,7 +1214,7 @@ static void retrieve_device_setting(struct viafb_ioctl_setting
         setting_info->lcd_attributes.lcd_mode = viafb_lcd_mode;
 }
 
-static void parse_active_dev(void)
+static int parse_active_dev(void)
 {
         viafb_CRT_ON = STATE_OFF;
         viafb_DVI_ON = STATE_OFF;
@@ -1341,60 +1225,63 @@ static void parse_active_dev(void)
            IGA path to devices in SAMM case. */
         /*    Note: The previous of active_dev is primary device,
            and the following is secondary device. */
-        if (!strncmp(viafb_active_dev, "CRT+DVI", 7)) {
+        if (!viafb_active_dev) {
+                viafb_CRT_ON = STATE_ON;
+                viafb_SAMM_ON = STATE_OFF;
+        } else if (!strcmp(viafb_active_dev, "CRT+DVI")) {
                 /* CRT+DVI */
                 viafb_CRT_ON = STATE_ON;
                 viafb_DVI_ON = STATE_ON;
                 viafb_primary_dev = CRT_Device;
-        } else if (!strncmp(viafb_active_dev, "DVI+CRT", 7)) {
+        } else if (!strcmp(viafb_active_dev, "DVI+CRT")) {
                 /* DVI+CRT */
                 viafb_CRT_ON = STATE_ON;
                 viafb_DVI_ON = STATE_ON;
                 viafb_primary_dev = DVI_Device;
-        } else if (!strncmp(viafb_active_dev, "CRT+LCD", 7)) {
+        } else if (!strcmp(viafb_active_dev, "CRT+LCD")) {
                 /* CRT+LCD */
                 viafb_CRT_ON = STATE_ON;
                 viafb_LCD_ON = STATE_ON;
                 viafb_primary_dev = CRT_Device;
-        } else if (!strncmp(viafb_active_dev, "LCD+CRT", 7)) {
+        } else if (!strcmp(viafb_active_dev, "LCD+CRT")) {
                 /* LCD+CRT */
                 viafb_CRT_ON = STATE_ON;
                 viafb_LCD_ON = STATE_ON;
                 viafb_primary_dev = LCD_Device;
-        } else if (!strncmp(viafb_active_dev, "DVI+LCD", 7)) {
+        } else if (!strcmp(viafb_active_dev, "DVI+LCD")) {
                 /* DVI+LCD */
                 viafb_DVI_ON = STATE_ON;
                 viafb_LCD_ON = STATE_ON;
                 viafb_primary_dev = DVI_Device;
-        } else if (!strncmp(viafb_active_dev, "LCD+DVI", 7)) {
+        } else if (!strcmp(viafb_active_dev, "LCD+DVI")) {
                 /* LCD+DVI */
                 viafb_DVI_ON = STATE_ON;
                 viafb_LCD_ON = STATE_ON;
                 viafb_primary_dev = LCD_Device;
-        } else if (!strncmp(viafb_active_dev, "LCD+LCD2", 8)) {
+        } else if (!strcmp(viafb_active_dev, "LCD+LCD2")) {
                 viafb_LCD_ON = STATE_ON;
                 viafb_LCD2_ON = STATE_ON;
                 viafb_primary_dev = LCD_Device;
-        } else if (!strncmp(viafb_active_dev, "LCD2+LCD", 8)) {
+        } else if (!strcmp(viafb_active_dev, "LCD2+LCD")) {
                 viafb_LCD_ON = STATE_ON;
                 viafb_LCD2_ON = STATE_ON;
                 viafb_primary_dev = LCD2_Device;
-        } else if (!strncmp(viafb_active_dev, "CRT", 3)) {
+        } else if (!strcmp(viafb_active_dev, "CRT")) {
                 /* CRT only */
                 viafb_CRT_ON = STATE_ON;
                 viafb_SAMM_ON = STATE_OFF;
-        } else if (!strncmp(viafb_active_dev, "DVI", 3)) {
+        } else if (!strcmp(viafb_active_dev, "DVI")) {
                 /* DVI only */
                 viafb_DVI_ON = STATE_ON;
                 viafb_SAMM_ON = STATE_OFF;
-        } else if (!strncmp(viafb_active_dev, "LCD", 3)) {
+        } else if (!strcmp(viafb_active_dev, "LCD")) {
                 /* LCD only */
                 viafb_LCD_ON = STATE_ON;
                 viafb_SAMM_ON = STATE_OFF;
-        } else {
-                viafb_CRT_ON = STATE_ON;
-                viafb_SAMM_ON = STATE_OFF;
-        }
+        } else
+                return -EINVAL;
+
+        return 0;
 }
 
 static int parse_port(char *opt_str, int *output_interface)
@@ -1823,35 +1710,37 @@ static void viafb_remove_proc(struct proc_dir_entry *viafb_entry)
         remove_proc_entry("viafb", NULL);
 }
 
-static void parse_mode(const char *str, u32 *xres, u32 *yres)
+static int parse_mode(const char *str, u32 *xres, u32 *yres)
 {
         char *ptr;
 
+        if (!str) {
+                *xres = 640;
+                *yres = 480;
+                return 0;
+        }
+
         *xres = simple_strtoul(str, &ptr, 10);
         if (ptr[0] != 'x')
-                goto out_default;
+                return -EINVAL;
 
         *yres = simple_strtoul(&ptr[1], &ptr, 10);
         if (ptr[0])
-                goto out_default;
-
-        return;
+                return -EINVAL;
 
-out_default:
-        printk(KERN_WARNING "viafb received invalid mode string: %s\n", str);
-        *xres = 640;
-        *yres = 480;
+        return 0;
 }
 
 static int __devinit via_pci_probe(struct pci_dev *pdev,
                                    const struct pci_device_id *ent)
 {
         u32 default_xres, default_yres;
-        int vmode_index;
+        struct VideoModeTable *vmode_entry;
+        struct fb_var_screeninfo default_var;
         u32 viafb_par_length;
 
         DEBUG_MSG(KERN_INFO "VIAFB PCI Probe!!\n");
-
+        memset(&default_var, 0, sizeof(default_var));
         viafb_par_length = ALIGN(sizeof(struct viafb_par), BITS_PER_LONG/8);
 
         /* Allocate fb_info and ***_par here, also including some other needed
@@ -1877,7 +1766,6 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
 
         if (viafb_dual_fb)
                 viafb_SAMM_ON = 1;
-        parse_active_dev();
         parse_lcd_port();
         parse_dvi_port();
 
@@ -1926,9 +1814,7 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
         }
 
         parse_mode(viafb_mode, &default_xres, &default_yres);
-        vmode_index = viafb_get_mode_index(default_xres, default_yres);
-        DEBUG_MSG(KERN_INFO "0->index=%d\n", vmode_index);
-
+        vmode_entry = viafb_get_mode(default_xres, default_yres);
         if (viafb_SAMM_ON == 1) {
                 parse_mode(viafb_mode1, &viafb_second_xres,
                         &viafb_second_yres);
@@ -1947,19 +1833,6 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
                         viafb_second_virtual_yres = viafb_second_yres;
         }
 
-        switch (viafb_bpp) {
-        case 0 ... 8:
-                viafb_bpp = 8;
-                break;
-        case 9 ... 16:
-                viafb_bpp = 16;
-                break;
-        case 17 ... 32:
-                viafb_bpp = 32;
-                break;
-        default:
-                viafb_bpp = 8;
-        }
         default_var.xres = default_xres;
         default_var.yres = default_yres;
         switch (default_xres) {
@@ -1972,8 +1845,6 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
         }
         default_var.yres_virtual = default_yres;
         default_var.bits_per_pixel = viafb_bpp;
-        if (default_var.bits_per_pixel == 15)
-                default_var.bits_per_pixel = 16;
         default_var.pixclock =
             viafb_get_pixclock(default_xres, default_yres, viafb_refresh);
         default_var.left_margin = (default_xres >> 3) & 0xf8;
@@ -1982,6 +1853,8 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
         default_var.lower_margin = 4;
         default_var.hsync_len = default_var.left_margin;
         default_var.vsync_len = 4;
+        viafb_setup_fixinfo(&viafbinfo->fix, viaparinfo);
+        viafbinfo->var = default_var;
 
         if (viafb_dual_fb) {
                 viafbinfo1 = framebuffer_alloc(viafb_par_length, &pdev->dev);
@@ -2016,8 +1889,6 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
                 default_var.yres = viafb_second_yres;
                 default_var.xres_virtual = viafb_second_virtual_xres;
                 default_var.yres_virtual = viafb_second_virtual_yres;
-                if (viafb_bpp1 != viafb_bpp)
-                        viafb_bpp1 = viafb_bpp;
                 default_var.bits_per_pixel = viafb_bpp1;
                 default_var.pixclock =
                     viafb_get_pixclock(viafb_second_xres, viafb_second_yres,
@@ -2037,9 +1908,7 @@ static int __devinit via_pci_probe(struct pci_dev *pdev,
                         &viafbinfo1->fix);
         }
 
-        viafb_setup_fixinfo(&viafbinfo->fix, viaparinfo);
-        viafb_check_var(&default_var, viafbinfo);
-        viafbinfo->var = default_var;
+        viafb_check_var(&viafbinfo->var, viafbinfo);
         viafb_update_fix(viafbinfo);
         viaparinfo->depth = fb_get_color_depth(&viafbinfo->var,
                 &viafbinfo->fix);
@@ -2197,12 +2066,20 @@ static struct pci_driver viafb_driver = {
 
 static int __init viafb_init(void)
 {
+        u32 dummy;
 #ifndef MODULE
         char *option = NULL;
         if (fb_get_options("viafb", &option))
                 return -ENODEV;
         viafb_setup(option);
 #endif
+        if (parse_mode(viafb_mode, &dummy, &dummy)
+                || parse_mode(viafb_mode1, &dummy, &dummy)
+                || viafb_bpp < 0 || viafb_bpp > 32
+                || viafb_bpp1 < 0 || viafb_bpp1 > 32
+                || parse_active_dev())
+                return -EINVAL;
+
         printk(KERN_INFO
        "VIA Graphics Intergration Chipset framebuffer %d.%d initializing\n",
                VERSION_MAJOR, VERSION_MINOR);
@@ -2230,15 +2107,12 @@ static struct fb_ops viafb_ops = {
         .fb_cursor = viafb_cursor,
         .fb_ioctl = viafb_ioctl,
         .fb_sync = viafb_sync,
-        .fb_setcmap = viafb_setcmap,
 };
 
 module_init(viafb_init);
 module_exit(viafb_exit);
 
 #ifdef MODULE
-module_param(viafb_memsize, int, S_IRUSR);
-
 module_param(viafb_mode, charp, S_IRUSR);
 MODULE_PARM_DESC(viafb_mode, "Set resolution (default=640x480)");
 
diff --git a/drivers/video/via/viafbdev.h b/drivers/video/via/viafbdev.h
index 0c94d2441922..61b5953cd159 100644
--- a/drivers/video/via/viafbdev.h
+++ b/drivers/video/via/viafbdev.h
@@ -83,22 +83,16 @@ struct viafb_par {
 
 extern unsigned int viafb_second_virtual_yres;
 extern unsigned int viafb_second_virtual_xres;
-extern unsigned int viafb_second_offset;
-extern int viafb_second_size;
 extern int viafb_SAMM_ON;
 extern int viafb_dual_fb;
 extern int viafb_LCD2_ON;
 extern int viafb_LCD_ON;
 extern int viafb_DVI_ON;
 extern int viafb_hotplug;
-extern int viafb_memsize;
 
 extern int strict_strtoul(const char *cp, unsigned int base,
         unsigned long *res);
 
-void viafb_fill_var_timing_info(struct fb_var_screeninfo *var, int refresh,
-                          int mode_index);
-int viafb_get_mode_index(int hres, int vres);
 u8 viafb_gpio_i2c_read_lvds(struct lvds_setting_information
         *plvds_setting_info, struct lvds_chip_information
         *plvds_chip_info, u8 index);
diff --git a/drivers/video/via/viamode.c b/drivers/video/via/viamode.c
index b74f8a67923c..af50e244016c 100644
--- a/drivers/video/via/viamode.c
+++ b/drivers/video/via/viamode.c
@@ -412,7 +412,7 @@ struct io_reg PM1024x768[] = { {VIASR, 0x16, 0xBF, 0x0C},
 };
 
 struct patch_table res_patch_table[] = {
-        {VIA_RES_1024X768, ARRAY_SIZE(PM1024x768), PM1024x768}
+        {ARRAY_SIZE(PM1024x768), PM1024x768}
 };
 
 /* struct VPITTable {
@@ -879,169 +879,151 @@ struct crt_mode_table CRTM2048x1536[] = {
          {2800, 2048, 2048, 752, 2200, 224, 1592, 1536, 1536, 56, 1539, 4} }
 };
 
-/* Video Mode Table */
-/* struct VideoModeTable {*/
-/*  int                               ModeIndex;*/
-/*  struct crt_mode_table             *crtc;*/
-/*  int                               mode_array;*/
-/* };*/
-struct VideoModeTable CLE266Modes[] = {
+struct VideoModeTable viafb_modes[] = {
         /* Display : 480x640 (GTF) */
-        {VIA_RES_480X640, CRTM480x640, ARRAY_SIZE(CRTM480x640)},
+        {CRTM480x640, ARRAY_SIZE(CRTM480x640)},
 
         /* Display : 640x480 */
-        {VIA_RES_640X480, CRTM640x480, ARRAY_SIZE(CRTM640x480)},
+        {CRTM640x480, ARRAY_SIZE(CRTM640x480)},
 
         /* Display : 720x480 (GTF) */
-        {VIA_RES_720X480, CRTM720x480, ARRAY_SIZE(CRTM720x480)},
+        {CRTM720x480, ARRAY_SIZE(CRTM720x480)},
 
         /* Display : 720x576 (GTF) */
-        {VIA_RES_720X576, CRTM720x576, ARRAY_SIZE(CRTM720x576)},
+        {CRTM720x576, ARRAY_SIZE(CRTM720x576)},
 
         /* Display : 800x600 */
-        {VIA_RES_800X600, CRTM800x600, ARRAY_SIZE(CRTM800x600)},
+        {CRTM800x600, ARRAY_SIZE(CRTM800x600)},
 
         /* Display : 800x480 (CVT) */
-        {VIA_RES_800X480, CRTM800x480, ARRAY_SIZE(CRTM800x480)},
+        {CRTM800x480, ARRAY_SIZE(CRTM800x480)},
 
         /* Display : 848x480 (CVT) */
-        {VIA_RES_848X480, CRTM848x480, ARRAY_SIZE(CRTM848x480)},
+        {CRTM848x480, ARRAY_SIZE(CRTM848x480)},
 
         /* Display : 852x480 (GTF) */
-        {VIA_RES_856X480, CRTM852x480, ARRAY_SIZE(CRTM852x480)},
+        {CRTM852x480, ARRAY_SIZE(CRTM852x480)},
 
         /* Display : 1024x512 (GTF) */
-        {VIA_RES_1024X512, CRTM1024x512, ARRAY_SIZE(CRTM1024x512)},
+        {CRTM1024x512, ARRAY_SIZE(CRTM1024x512)},
 
         /* Display : 1024x600 */
-        {VIA_RES_1024X600, CRTM1024x600, ARRAY_SIZE(CRTM1024x600)},
-
-        /* Display : 1024x576 (GTF) */
-        /*{ VIA_RES_1024X576, CRTM1024x576, ARRAY_SIZE(CRTM1024x576)}, */
+        {CRTM1024x600, ARRAY_SIZE(CRTM1024x600)},
 
         /* Display : 1024x768 */
-        {VIA_RES_1024X768, CRTM1024x768, ARRAY_SIZE(CRTM1024x768)},
+        {CRTM1024x768, ARRAY_SIZE(CRTM1024x768)},
 
         /* Display : 1152x864 */
-        {VIA_RES_1152X864, CRTM1152x864, ARRAY_SIZE(CRTM1152x864)},
+        {CRTM1152x864, ARRAY_SIZE(CRTM1152x864)},
 
         /* Display : 1280x768 (GTF) */
-        {VIA_RES_1280X768, CRTM1280x768, ARRAY_SIZE(CRTM1280x768)},
+        {CRTM1280x768, ARRAY_SIZE(CRTM1280x768)},
 
         /* Display : 960x600 (CVT) */
-        {VIA_RES_960X600, CRTM960x600, ARRAY_SIZE(CRTM960x600)},
+        {CRTM960x600, ARRAY_SIZE(CRTM960x600)},
 
         /* Display : 1000x600 (GTF) */
-        {VIA_RES_1000X600, CRTM1000x600, ARRAY_SIZE(CRTM1000x600)},
+        {CRTM1000x600, ARRAY_SIZE(CRTM1000x600)},
 
         /* Display : 1024x576 (GTF) */
-        {VIA_RES_1024X576, CRTM1024x576, ARRAY_SIZE(CRTM1024x576)},
+        {CRTM1024x576, ARRAY_SIZE(CRTM1024x576)},
 
         /* Display : 1088x612 (GTF) */
-        {VIA_RES_1088X612, CRTM1088x612, ARRAY_SIZE(CRTM1088x612)},
+        {CRTM1088x612, ARRAY_SIZE(CRTM1088x612)},
 
         /* Display : 1152x720 (CVT) */
-        {VIA_RES_1152X720, CRTM1152x720, ARRAY_SIZE(CRTM1152x720)},
+        {CRTM1152x720, ARRAY_SIZE(CRTM1152x720)},
 
         /* Display : 1200x720 (GTF) */
-        {VIA_RES_1200X720, CRTM1200x720, ARRAY_SIZE(CRTM1200x720)},
+        {CRTM1200x720, ARRAY_SIZE(CRTM1200x720)},
 
         /* Display : 1280x600 (GTF) */
-        {VIA_RES_1280X600, CRTM1280x600, ARRAY_SIZE(CRTM1280x600)},
+        {CRTM1280x600, ARRAY_SIZE(CRTM1280x600)},
 
         /* Display : 1280x800 (CVT) */
-        {VIA_RES_1280X800, CRTM1280x800, ARRAY_SIZE(CRTM1280x800)},
-
-        /* Display : 1280x800 (GTF) */
-        /*{ M1280x800, CRTM1280x800, ARRAY_SIZE(CRTM1280x800)}, */
+        {CRTM1280x800, ARRAY_SIZE(CRTM1280x800)},
 
         /* Display : 1280x960 */
-        {VIA_RES_1280X960, CRTM1280x960, ARRAY_SIZE(CRTM1280x960)},
+        {CRTM1280x960, ARRAY_SIZE(CRTM1280x960)},
 
         /* Display : 1280x1024 */
-        {VIA_RES_1280X1024, CRTM1280x1024, ARRAY_SIZE(CRTM1280x1024)},
+        {CRTM1280x1024, ARRAY_SIZE(CRTM1280x1024)},
 
         /* Display : 1360x768 (CVT) */
-        {VIA_RES_1360X768, CRTM1360x768, ARRAY_SIZE(CRTM1360x768)},
-
-        /* Display : 1360x768 (CVT Reduce Blanking) */
-        {VIA_RES_1360X768_RB, CRTM1360x768_RB,
-         ARRAY_SIZE(CRTM1360x768_RB)},
+        {CRTM1360x768, ARRAY_SIZE(CRTM1360x768)},
 
         /* Display : 1366x768 */
-        {VIA_RES_1366X768, CRTM1366x768, ARRAY_SIZE(CRTM1366x768)},
+        {CRTM1366x768, ARRAY_SIZE(CRTM1366x768)},
 
         /* Display : 1368x768 (GTF) */
-        /*{ M1368x768,CRTM1368x768,ARRAY_SIZE(CRTM1368x768)}, */
-        /* Display : 1368x768 (GTF) */
-        {VIA_RES_1368X768, CRTM1368x768, ARRAY_SIZE(CRTM1368x768)},
+        {CRTM1368x768, ARRAY_SIZE(CRTM1368x768)},
 
         /* Display : 1440x900 (CVT) */
-        {VIA_RES_1440X900, CRTM1440x900, ARRAY_SIZE(CRTM1440x900)},
-
-        /* Display : 1440x900 (CVT Reduce Blanking) */
-        {VIA_RES_1440X900_RB, CRTM1440x900_RB,
-         ARRAY_SIZE(CRTM1440x900_RB)},
+        {CRTM1440x900, ARRAY_SIZE(CRTM1440x900)},
 
         /* Display : 1440x1050 (GTF) */
-        {VIA_RES_1440X1050, CRTM1440x1050, ARRAY_SIZE(CRTM1440x1050)},
-
-        /* Display : 1400x1050 (CVT Reduce Blanking) */
-        {VIA_RES_1400X1050_RB, CRTM1400x1050_RB,
-         ARRAY_SIZE(CRTM1400x1050_RB)},
+        {CRTM1440x1050, ARRAY_SIZE(CRTM1440x1050)},
 
         /* Display : 1600x900 (CVT) */
-        {VIA_RES_1600X900, CRTM1600x900, ARRAY_SIZE(CRTM1600x900)},
-
-        /* Display : 1600x900 (CVT Reduce Blanking) */
-        {VIA_RES_1600X900_RB, CRTM1600x900_RB,
-         ARRAY_SIZE(CRTM1600x900_RB)},
+        {CRTM1600x900, ARRAY_SIZE(CRTM1600x900)},
 
         /* Display : 1600x1024 (GTF) */
-        {VIA_RES_1600X1024, CRTM1600x1024, ARRAY_SIZE(CRTM1600x1024)},
+        {CRTM1600x1024, ARRAY_SIZE(CRTM1600x1024)},
 
         /* Display : 1600x1200 */
-        {VIA_RES_1600X1200, CRTM1600x1200, ARRAY_SIZE(CRTM1600x1200)},
+        {CRTM1600x1200, ARRAY_SIZE(CRTM1600x1200)},
 
         /* Display : 1680x1050 (CVT) */
-        {VIA_RES_1680X1050, CRTM1680x1050, ARRAY_SIZE(CRTM1680x1050)},
-
-        /* Display : 1680x1050 (CVT Reduce Blanking) */
-        {VIA_RES_1680X1050_RB, CRTM1680x1050_RB,
-         ARRAY_SIZE(CRTM1680x1050_RB)},
+        {CRTM1680x1050, ARRAY_SIZE(CRTM1680x1050)},
 
         /* Display : 1792x1344 (DMT) */
-        {VIA_RES_1792X1344, CRTM1792x1344, ARRAY_SIZE(CRTM1792x1344)},
+        {CRTM1792x1344, ARRAY_SIZE(CRTM1792x1344)},
 
         /* Display : 1856x1392 (DMT) */
-        {VIA_RES_1856X1392, CRTM1856x1392, ARRAY_SIZE(CRTM1856x1392)},
+        {CRTM1856x1392, ARRAY_SIZE(CRTM1856x1392)},
 
         /* Display : 1920x1440 */
-        {VIA_RES_1920X1440, CRTM1920x1440, ARRAY_SIZE(CRTM1920x1440)},
+        {CRTM1920x1440, ARRAY_SIZE(CRTM1920x1440)},
 
         /* Display : 2048x1536 */
-        {VIA_RES_2048X1536, CRTM2048x1536, ARRAY_SIZE(CRTM2048x1536)},
+        {CRTM2048x1536, ARRAY_SIZE(CRTM2048x1536)},
 
         /* Display : 1280x720 */
-        {VIA_RES_1280X720, CRTM1280x720, ARRAY_SIZE(CRTM1280x720)},
+        {CRTM1280x720, ARRAY_SIZE(CRTM1280x720)},
 
         /* Display : 1920x1080 (CVT) */
-        {VIA_RES_1920X1080, CRTM1920x1080, ARRAY_SIZE(CRTM1920x1080)},
-
-        /* Display : 1920x1080 (CVT Reduce Blanking) */
-        {VIA_RES_1920X1080_RB, CRTM1920x1080_RB,
-         ARRAY_SIZE(CRTM1920x1080_RB)},
+        {CRTM1920x1080, ARRAY_SIZE(CRTM1920x1080)},
 
         /* Display : 1920x1200 (CVT) */
-        {VIA_RES_1920X1200, CRTM1920x1200, ARRAY_SIZE(CRTM1920x1200)},
-
-        /* Display : 1920x1200 (CVT Reduce Blanking) */
-        {VIA_RES_1920X1200_RB, CRTM1920x1200_RB,
-         ARRAY_SIZE(CRTM1920x1200_RB)},
+        {CRTM1920x1200, ARRAY_SIZE(CRTM1920x1200)},
 
         /* Display : 1400x1050 (CVT) */
-        {VIA_RES_1400X1050, CRTM1400x1050, ARRAY_SIZE(CRTM1400x1050)}
+        {CRTM1400x1050, ARRAY_SIZE(CRTM1400x1050)}
 };
+
+struct VideoModeTable viafb_rb_modes[] = {
+        /* Display : 1360x768 (CVT Reduce Blanking) */
+        {CRTM1360x768_RB, ARRAY_SIZE(CRTM1360x768_RB)},
+
+        /* Display : 1440x900 (CVT Reduce Blanking) */
+        {CRTM1440x900_RB, ARRAY_SIZE(CRTM1440x900_RB)},
+
+        /* Display : 1400x1050 (CVT Reduce Blanking) */
+        {CRTM1400x1050_RB, ARRAY_SIZE(CRTM1400x1050_RB)},
+
+        /* Display : 1600x900 (CVT Reduce Blanking) */
+        {CRTM1600x900_RB, ARRAY_SIZE(CRTM1600x900_RB)},
+
+        /* Display : 1680x1050 (CVT Reduce Blanking) */
+        {CRTM1680x1050_RB, ARRAY_SIZE(CRTM1680x1050_RB)},
+
+        /* Display : 1920x1080 (CVT Reduce Blanking) */
+        {CRTM1920x1080_RB, ARRAY_SIZE(CRTM1920x1080_RB)},
+
+        /* Display : 1920x1200 (CVT Reduce Blanking) */
+        {CRTM1920x1200_RB, ARRAY_SIZE(CRTM1920x1200_RB)}
+};
+
 struct crt_mode_table CEAM1280x720[] = {
         {REFRESH_60, CLK_74_270M, M1280X720_CEA_R60_HSP,
          M1280X720_CEA_R60_VSP,
@@ -1056,8 +1038,8 @@ struct crt_mode_table CEAM1920x1080[] = {
 };
 struct VideoModeTable CEA_HDMI_Modes[] = {
         /* Display : 1280x720 */
-        {VIA_RES_1280X720, CEAM1280x720, ARRAY_SIZE(CEAM1280x720)},
-        {VIA_RES_1920X1080, CEAM1920x1080, ARRAY_SIZE(CEAM1920x1080)}
+        {CEAM1280x720, ARRAY_SIZE(CEAM1280x720)},
+        {CEAM1920x1080, ARRAY_SIZE(CEAM1920x1080)}
 };
 
 int NUM_TOTAL_RES_MAP_REFRESH = ARRAY_SIZE(res_map_refresh_tbl);
@@ -1069,4 +1051,28 @@ int NUM_TOTAL_CX700_ModeXregs = ARRAY_SIZE(CX700_ModeXregs);
 int NUM_TOTAL_VX855_ModeXregs = ARRAY_SIZE(VX855_ModeXregs);
 int NUM_TOTAL_CLE266_ModeXregs = ARRAY_SIZE(CLE266_ModeXregs);
 int NUM_TOTAL_PATCH_MODE = ARRAY_SIZE(res_patch_table);
-int NUM_TOTAL_MODETABLE = ARRAY_SIZE(CLE266Modes);
+
+
+struct VideoModeTable *viafb_get_mode(int hres, int vres)
+{
+        u32 i;
+        for (i = 0; i < ARRAY_SIZE(viafb_modes); i++)
+                if (viafb_modes[i].mode_array &&
+                        viafb_modes[i].crtc[0].crtc.hor_addr == hres &&
+                        viafb_modes[i].crtc[0].crtc.ver_addr == vres)
+                        return &viafb_modes[i];
+
+        return NULL;
+}
+
+struct VideoModeTable *viafb_get_rb_mode(int hres, int vres)
+{
+        u32 i;
+        for (i = 0; i < ARRAY_SIZE(viafb_rb_modes); i++)
+                if (viafb_rb_modes[i].mode_array &&
+                        viafb_rb_modes[i].crtc[0].crtc.hor_addr == hres &&
+                        viafb_rb_modes[i].crtc[0].crtc.ver_addr == vres)
+                        return &viafb_rb_modes[i];
+
+        return NULL;
+}
diff --git a/drivers/video/via/viamode.h b/drivers/video/via/viamode.h
index a9d6554fabdf..5b1ced86514b 100644
--- a/drivers/video/via/viamode.h
+++ b/drivers/video/via/viamode.h
@@ -32,13 +32,11 @@ struct VPITTable {
 };
 
 struct VideoModeTable {
-        int ModeIndex;
         struct crt_mode_table *crtc;
         int mode_array;
 };
 
 struct patch_table {
-        int mode_index;
         int table_length;
         struct io_reg *io_reg_table;
 };
@@ -59,13 +57,11 @@ extern int NUM_TOTAL_CX700_ModeXregs;
 extern int NUM_TOTAL_VX855_ModeXregs;
 extern int NUM_TOTAL_CLE266_ModeXregs;
 extern int NUM_TOTAL_PATCH_MODE;
-extern int NUM_TOTAL_MODETABLE;
 
 /********************/
 /* Mode Table       */
 /********************/
 
-extern struct VideoModeTable CLE266Modes[];
 extern struct crt_mode_table CEAM1280x720[];
 extern struct crt_mode_table CEAM1920x1080[];
 extern struct VideoModeTable CEA_HDMI_Modes[];
@@ -81,4 +77,8 @@ extern struct io_reg CLE266_ModeXregs[];
 extern struct io_reg PM1024x768[];
 extern struct patch_table res_patch_table[];
 extern struct VPITTable VPIT;
+
+struct VideoModeTable *viafb_get_mode(int hres, int vres);
+struct VideoModeTable *viafb_get_rb_mode(int hres, int vres);
+
 #endif /* __VIAMODE_H__ */
diff --git a/drivers/video/w100fb.c b/drivers/video/w100fb.c
index 2376f688ec8b..5d223959778a 100644
--- a/drivers/video/w100fb.c
+++ b/drivers/video/w100fb.c
@@ -628,7 +628,7 @@ static int w100fb_resume(struct platform_device *dev)
 #endif
 
 
-int __init w100fb_probe(struct platform_device *pdev)
+int __devinit w100fb_probe(struct platform_device *pdev)
 {
         int err = -EIO;
         struct w100fb_mach_info *inf;
diff --git a/drivers/w1/masters/ds2482.c b/drivers/w1/masters/ds2482.c
index 406caa6a71cb..e5f74416d4b7 100644
--- a/drivers/w1/masters/ds2482.c
+++ b/drivers/w1/masters/ds2482.c
@@ -214,7 +214,7 @@ static int ds2482_wait_1wire_idle(struct ds2482_data *pdev)
                          (++retries < DS2482_WAIT_IDLE_TIMEOUT));
         }
 
-        if (retries > DS2482_WAIT_IDLE_TIMEOUT)
+        if (retries >= DS2482_WAIT_IDLE_TIMEOUT)
                 printk(KERN_ERR "%s: timeout on channel %d\n",
                        __func__, pdev->channel);
 
diff --git a/drivers/w1/masters/mxc_w1.c b/drivers/w1/masters/mxc_w1.c
index 65244c02551b..492670358cbf 100644
--- a/drivers/w1/masters/mxc_w1.c
+++ b/drivers/w1/masters/mxc_w1.c
@@ -102,7 +102,7 @@ static u8 mxc_w1_ds2_touch_bit(void *data, u8 bit)
         return ((__raw_readb(ctrl_addr)) >> 3) & 0x1;
 }
 
-static int __init mxc_w1_probe(struct platform_device *pdev)
+static int __devinit mxc_w1_probe(struct platform_device *pdev)
 {
         struct mxc_w1_device *mdev;
         struct resource *res;
@@ -166,7 +166,7 @@ failed_clk:
 /*
  * disassociate the w1 device from the driver
  */
-static int mxc_w1_remove(struct platform_device *pdev)
+static int __devexit mxc_w1_remove(struct platform_device *pdev)
 {
         struct mxc_w1_device *mdev = platform_get_drvdata(pdev);
         struct resource *res;
diff --git a/drivers/w1/masters/omap_hdq.c b/drivers/w1/masters/omap_hdq.c
index 0d92969404c3..22977d30f89e 100644
--- a/drivers/w1/masters/omap_hdq.c
+++ b/drivers/w1/masters/omap_hdq.c
@@ -72,7 +72,7 @@ struct hdq_data {
         int                     init_trans;
 };
 
-static int __init omap_hdq_probe(struct platform_device *pdev);
+static int __devinit omap_hdq_probe(struct platform_device *pdev);
 static int omap_hdq_remove(struct platform_device *pdev);
 
 static struct platform_driver omap_hdq_driver = {
@@ -558,7 +558,7 @@ static void omap_w1_write_byte(void *_hdq, u8 byte)
         return;
 }
 
-static int __init omap_hdq_probe(struct platform_device *pdev)
+static int __devinit omap_hdq_probe(struct platform_device *pdev)
 {
         struct hdq_data *hdq_data;
         struct resource *res;
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index 3da3f48720a7..bdcdbd53da89 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -55,6 +55,11 @@ config SOFT_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called softdog.
 
+config MAX63XX_WATCHDOG
+       tristate "Max63xx watchdog"
+       help
+         Support for memory mapped max63{69,70,71,72,73,74} watchdog timer.
+
 config WM831X_WATCHDOG
         tristate "WM831x watchdog"
         depends on MFD_WM831X
@@ -289,6 +294,17 @@ config ADX_WATCHDOG
           Say Y here if you want support for the watchdog timer on Avionic
           Design Xanthos boards.
 
+config TS72XX_WATCHDOG
+        tristate "TS-72XX SBC Watchdog"
+        depends on MACH_TS72XX
+        help
+          Technologic Systems TS-7200, TS-7250 and TS-7260 boards have
+          watchdog timer implemented in a external CPLD chip. Say Y here
+          if you want to support for the watchdog timer on TS-72XX boards.
+
+          To compile this driver as a module, choose M here: the
+          module will be called ts72xx_wdt.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
@@ -845,10 +861,10 @@ config TXX9_WDT
 # POWERPC Architecture
 
 config GEF_WDT
-        tristate "GE Fanuc Watchdog Timer"
+        tristate "GE Watchdog Timer"
         depends on GEF_SBC610 || GEF_SBC310 || GEF_PPC9A
         ---help---
-          Watchdog timer found in a number of GE Fanuc single board computers.
+          Watchdog timer found in a number of GE single board computers.
 
 config MPC5200_WDT
         bool "MPC52xx Watchdog Timer"
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index 475c61100069..5e3cb95bb0e9 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -46,6 +46,7 @@ obj-$(CONFIG_COH901327_WATCHDOG) += coh901327_wdt.o
 obj-$(CONFIG_STMP3XXX_WATCHDOG) += stmp3xxx_wdt.o
 obj-$(CONFIG_NUC900_WATCHDOG) += nuc900_wdt.o
 obj-$(CONFIG_ADX_WATCHDOG) += adx_wdt.o
+obj-$(CONFIG_TS72XX_WATCHDOG) += ts72xx_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
@@ -142,4 +143,5 @@ obj-$(CONFIG_WATCHDOG_CP1XXX)		+= cpwd.o
 # Architecture Independant
 obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o
 obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o
+obj-$(CONFIG_MAX63XX_WATCHDOG) += max63xx_wdt.o
 obj-$(CONFIG_SOFT_WATCHDOG) += softdog.o
diff --git a/drivers/watchdog/acquirewdt.c b/drivers/watchdog/acquirewdt.c
index 4d18c874d963..2ffce4d75443 100644
--- a/drivers/watchdog/acquirewdt.c
+++ b/drivers/watchdog/acquirewdt.c
@@ -150,7 +150,7 @@ static long acq_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int options, retval = -EINVAL;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = WATCHDOG_NAME,
diff --git a/drivers/watchdog/advantechwdt.c b/drivers/watchdog/advantechwdt.c
index 824d076a5cd6..4d40965d2c9f 100644
--- a/drivers/watchdog/advantechwdt.c
+++ b/drivers/watchdog/advantechwdt.c
@@ -137,7 +137,7 @@ static long advwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int new_timeout;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING |
                            WDIOF_SETTIMEOUT |
                            WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/adx_wdt.c b/drivers/watchdog/adx_wdt.c
index 9d7d155364f8..a5ca7a6ee133 100644
--- a/drivers/watchdog/adx_wdt.c
+++ b/drivers/watchdog/adx_wdt.c
@@ -37,7 +37,7 @@ struct adx_wdt {
         spinlock_t lock;
 };
 
-static struct watchdog_info adx_wdt_info = {
+static const struct watchdog_info adx_wdt_info = {
         .identity = "Avionic Design Xanthos Watchdog",
         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
 };
diff --git a/drivers/watchdog/alim1535_wdt.c b/drivers/watchdog/alim1535_wdt.c
index 937a80fb61e1..1e9caea8ff8a 100644
--- a/drivers/watchdog/alim1535_wdt.c
+++ b/drivers/watchdog/alim1535_wdt.c
@@ -180,7 +180,7 @@ static long ali_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_KEEPALIVEPING |
                                         WDIOF_SETTIMEOUT |
                                         WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/alim7101_wdt.c b/drivers/watchdog/alim7101_wdt.c
index f90afdb1b255..d8d4da9a483d 100644
--- a/drivers/watchdog/alim7101_wdt.c
+++ b/drivers/watchdog/alim7101_wdt.c
@@ -238,7 +238,7 @@ static long fop_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
                                                         | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
diff --git a/drivers/watchdog/ar7_wdt.c b/drivers/watchdog/ar7_wdt.c
index 2bb95cd308c1..c764c52412e4 100644
--- a/drivers/watchdog/ar7_wdt.c
+++ b/drivers/watchdog/ar7_wdt.c
@@ -219,7 +219,7 @@ static ssize_t ar7_wdt_write(struct file *file, const char *data,
 static long ar7_wdt_ioctl(struct file *file,
                                         unsigned int cmd, unsigned long arg)
 {
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .identity = LONGNAME,
                 .firmware_version = 1,
                 .options = (WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
diff --git a/drivers/watchdog/at32ap700x_wdt.c b/drivers/watchdog/at32ap700x_wdt.c
index 037847923dcb..6873376f986c 100644
--- a/drivers/watchdog/at32ap700x_wdt.c
+++ b/drivers/watchdog/at32ap700x_wdt.c
@@ -202,7 +202,7 @@ static int at32_wdt_get_status(void)
         return status;
 }
 
-static struct watchdog_info at32_wdt_info = {
+static const struct watchdog_info at32_wdt_info = {
         .identity       = "at32ap700x watchdog",
         .options        = WDIOF_SETTIMEOUT |
                           WDIOF_KEEPALIVEPING |
diff --git a/drivers/watchdog/at91rm9200_wdt.c b/drivers/watchdog/at91rm9200_wdt.c
index b185dafe1494..b3046dc4b56c 100644
--- a/drivers/watchdog/at91rm9200_wdt.c
+++ b/drivers/watchdog/at91rm9200_wdt.c
@@ -121,7 +121,7 @@ static int at91_wdt_settimeout(int new_time)
         return 0;
 }
 
-static struct watchdog_info at91_wdt_info = {
+static const struct watchdog_info at91_wdt_info = {
         .identity       = "at91 watchdog",
         .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
 };
diff --git a/drivers/watchdog/bcm47xx_wdt.c b/drivers/watchdog/bcm47xx_wdt.c
index 751c003864ad..5f245522397b 100644
--- a/drivers/watchdog/bcm47xx_wdt.c
+++ b/drivers/watchdog/bcm47xx_wdt.c
@@ -149,7 +149,7 @@ static ssize_t bcm47xx_wdt_write(struct file *file, const char __user *data,
         return len;
 }
 
-static struct watchdog_info bcm47xx_wdt_info = {
+static const struct watchdog_info bcm47xx_wdt_info = {
         .identity       = DRV_NAME,
         .options        = WDIOF_SETTIMEOUT |
                                 WDIOF_KEEPALIVEPING |
diff --git a/drivers/watchdog/bfin_wdt.c b/drivers/watchdog/bfin_wdt.c
index 2159e668751c..9c7ccd1e9088 100644
--- a/drivers/watchdog/bfin_wdt.c
+++ b/drivers/watchdog/bfin_wdt.c
@@ -19,8 +19,6 @@
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/fs.h>
-#include <linux/notifier.h>
-#include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/uaccess.h>
@@ -74,7 +72,7 @@
 
 static unsigned int timeout = WATCHDOG_TIMEOUT;
 static int nowayout = WATCHDOG_NOWAYOUT;
-static struct watchdog_info bfin_wdt_info;
+static const struct watchdog_info bfin_wdt_info;
 static unsigned long open_check;
 static char expect_close;
 static DEFINE_SPINLOCK(bfin_wdt_spinlock);
@@ -309,26 +307,6 @@ static long bfin_wdt_ioctl(struct file *file,
         }
 }
 
-/**
- *      bfin_wdt_notify_sys - Notifier Handler
- *      @this: notifier block
- *      @code: notifier event
- *      @unused: unused
- *
- *      Handles specific events, such as turning off the watchdog during a
- *      shutdown event.
- */
-static int bfin_wdt_notify_sys(struct notifier_block *this,
-                                        unsigned long code, void *unused)
-{
-        stampit();
-
-        if (code == SYS_DOWN || code == SYS_HALT)
-                bfin_wdt_stop();
-
-        return NOTIFY_DONE;
-}
-
 #ifdef CONFIG_PM
 static int state_before_suspend;
 
@@ -388,40 +366,28 @@ static struct miscdevice bfin_wdt_miscdev = {
         .fops     = &bfin_wdt_fops,
 };
 
-static struct watchdog_info bfin_wdt_info = {
+static const struct watchdog_info bfin_wdt_info = {
         .identity = "Blackfin Watchdog",
         .options  = WDIOF_SETTIMEOUT |
                     WDIOF_KEEPALIVEPING |
                     WDIOF_MAGICCLOSE,
 };
 
-static struct notifier_block bfin_wdt_notifier = {
-        .notifier_call = bfin_wdt_notify_sys,
-};
-
 /**
  *      bfin_wdt_probe - Initialize module
  *
- *      Registers the misc device and notifier handler.  Actual device
+ *      Registers the misc device.  Actual device
  *      initialization is handled by bfin_wdt_open().
  */
 static int __devinit bfin_wdt_probe(struct platform_device *pdev)
 {
         int ret;
 
-        ret = register_reboot_notifier(&bfin_wdt_notifier);
-        if (ret) {
-                pr_devinit(KERN_ERR PFX
-                        "cannot register reboot notifier (err=%d)\n", ret);
-                return ret;
-        }
-
         ret = misc_register(&bfin_wdt_miscdev);
         if (ret) {
                 pr_devinit(KERN_ERR PFX
                         "cannot register miscdev on minor=%d (err=%d)\n",
                                 WATCHDOG_MINOR, ret);
-                unregister_reboot_notifier(&bfin_wdt_notifier);
                 return ret;
         }
 
@@ -434,21 +400,33 @@ static int __devinit bfin_wdt_probe(struct platform_device *pdev)
 /**
  *      bfin_wdt_remove - Initialize module
  *
- *      Unregisters the misc device and notifier handler.  Actual device
+ *      Unregisters the misc device.  Actual device
  *      deinitialization is handled by bfin_wdt_close().
  */
 static int __devexit bfin_wdt_remove(struct platform_device *pdev)
 {
         misc_deregister(&bfin_wdt_miscdev);
-        unregister_reboot_notifier(&bfin_wdt_notifier);
         return 0;
 }
 
+/**
+ *      bfin_wdt_shutdown - Soft Shutdown Handler
+ *
+ *      Handles the soft shutdown event.
+ */
+static void bfin_wdt_shutdown(struct platform_device *pdev)
+{
+        stampit();
+
+        bfin_wdt_stop();
+}
+
 static struct platform_device *bfin_wdt_device;
 
 static struct platform_driver bfin_wdt_driver = {
         .probe     = bfin_wdt_probe,
         .remove    = __devexit_p(bfin_wdt_remove),
+        .shutdown  = bfin_wdt_shutdown,
         .suspend   = bfin_wdt_suspend,
         .resume    = bfin_wdt_resume,
         .driver    = {
diff --git a/drivers/watchdog/booke_wdt.c b/drivers/watchdog/booke_wdt.c
index e8380ef65c1c..8b724aad6825 100644
--- a/drivers/watchdog/booke_wdt.c
+++ b/drivers/watchdog/booke_wdt.c
@@ -121,7 +121,7 @@ static ssize_t booke_wdt_write(struct file *file, const char __user *buf,
         return count;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
         .identity = "PowerPC Book-E Watchdog",
 };
diff --git a/drivers/watchdog/coh901327_wdt.c b/drivers/watchdog/coh901327_wdt.c
index 923cc68dba26..9291506b8b23 100644
--- a/drivers/watchdog/coh901327_wdt.c
+++ b/drivers/watchdog/coh901327_wdt.c
@@ -257,7 +257,7 @@ static long coh901327_ioctl(struct file *file, unsigned int cmd,
                 struct watchdog_info __user *ident;
                 int __user *i;
         } uarg;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options                = WDIOF_CARDRESET |
                                           WDIOF_SETTIMEOUT |
                                           WDIOF_KEEPALIVEPING,
diff --git a/drivers/watchdog/cpu5wdt.c b/drivers/watchdog/cpu5wdt.c
index 71f6d7eec9a8..edd3475f41db 100644
--- a/drivers/watchdog/cpu5wdt.c
+++ b/drivers/watchdog/cpu5wdt.c
@@ -154,7 +154,7 @@ static long cpu5wdt_ioctl(struct file *file, unsigned int cmd,
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         unsigned int value;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_CARDRESET,
                 .identity = "CPU5 WDT",
         };
diff --git a/drivers/watchdog/cpwd.c b/drivers/watchdog/cpwd.c
index 081f2955419e..37ea052d4dee 100644
--- a/drivers/watchdog/cpwd.c
+++ b/drivers/watchdog/cpwd.c
@@ -403,7 +403,7 @@ static int cpwd_release(struct inode *inode, struct file *file)
 
 static long cpwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
-        static struct watchdog_info info = {
+        static const struct watchdog_info info = {
                 .options                = WDIOF_SETTIMEOUT,
                 .firmware_version       = 1,
                 .identity               = DRIVER_NAME,
diff --git a/drivers/watchdog/davinci_wdt.c b/drivers/watchdog/davinci_wdt.c
index 887136de1857..56162c87f5d8 100644
--- a/drivers/watchdog/davinci_wdt.c
+++ b/drivers/watchdog/davinci_wdt.c
@@ -142,7 +142,7 @@ davinci_wdt_write(struct file *file, const char *data, size_t len,
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_KEEPALIVEPING,
         .identity = "DaVinci Watchdog",
 };
diff --git a/drivers/watchdog/ep93xx_wdt.c b/drivers/watchdog/ep93xx_wdt.c
index cdd55e0d09f8..88ed54e50f74 100644
--- a/drivers/watchdog/ep93xx_wdt.c
+++ b/drivers/watchdog/ep93xx_wdt.c
@@ -131,7 +131,7 @@ ep93xx_wdt_write(struct file *file, const char __user *data, size_t len,
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_CARDRESET | WDIOF_MAGICCLOSE,
         .identity = "EP93xx Watchdog",
 };
diff --git a/drivers/watchdog/eurotechwdt.c b/drivers/watchdog/eurotechwdt.c
index 9add3541fb42..d1c4e55b1db0 100644
--- a/drivers/watchdog/eurotechwdt.c
+++ b/drivers/watchdog/eurotechwdt.c
@@ -238,7 +238,7 @@ static long eurwdt_ioctl(struct file *file,
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options          = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
                                                         | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
diff --git a/drivers/watchdog/gef_wdt.c b/drivers/watchdog/gef_wdt.c
index 734d9806a872..abdbad034a6c 100644
--- a/drivers/watchdog/gef_wdt.c
+++ b/drivers/watchdog/gef_wdt.c
@@ -1,9 +1,9 @@
 /*
- * GE Fanuc watchdog userspace interface
+ * GE watchdog userspace interface
  *
- * Author:  Martyn Welch <martyn.welch@gefanuc.com>
+ * Author:  Martyn Welch <martyn.welch@ge.com>
  *
- * Copyright 2008 GE Fanuc Intelligent Platforms Embedded Systems, Inc.
+ * Copyright 2008 GE Intelligent Platforms Embedded Systems, Inc.
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
@@ -161,11 +161,11 @@ static long gef_wdt_ioctl(struct file *file, unsigned int cmd,
         int timeout;
         int options;
         void __user *argp = (void __user *)arg;
-        static struct watchdog_info info = {
+        static const struct watchdog_info info = {
                 .options =      WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE |
                                 WDIOF_KEEPALIVEPING,
                 .firmware_version = 0,
-                .identity = "GE Fanuc watchdog",
+                .identity = "GE watchdog",
         };
 
         switch (cmd) {
@@ -311,7 +311,7 @@ static struct of_platform_driver gef_wdt_driver = {
 
 static int __init gef_wdt_init(void)
 {
-        printk(KERN_INFO "GE Fanuc watchdog driver\n");
+        printk(KERN_INFO "GE watchdog driver\n");
         return of_register_platform_driver(&gef_wdt_driver);
 }
 
@@ -323,8 +323,8 @@ static void __exit gef_wdt_exit(void)
 module_init(gef_wdt_init);
 module_exit(gef_wdt_exit);
 
-MODULE_AUTHOR("Martyn Welch <martyn.welch@gefanuc.com>");
-MODULE_DESCRIPTION("GE Fanuc watchdog driver");
+MODULE_AUTHOR("Martyn Welch <martyn.welch@ge.com>");
+MODULE_DESCRIPTION("GE watchdog driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
 MODULE_ALIAS("platform: gef_wdt");
diff --git a/drivers/watchdog/geodewdt.c b/drivers/watchdog/geodewdt.c
index 38252ff828ca..9b49b125ad5a 100644
--- a/drivers/watchdog/geodewdt.c
+++ b/drivers/watchdog/geodewdt.c
@@ -142,7 +142,7 @@ static long geodewdt_ioctl(struct file *file, unsigned int cmd,
         int __user *p = argp;
         int interval;
 
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING
                 | WDIOF_MAGICCLOSE,
                 .firmware_version =     1,
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index a6c5674c78e6..70c2c24660d0 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -554,7 +554,7 @@ static ssize_t hpwdt_write(struct file *file, const char __user *data,
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_SETTIMEOUT |
                    WDIOF_KEEPALIVEPING |
                    WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/i6300esb.c b/drivers/watchdog/i6300esb.c
index 7ba0b11ec525..bb9750a03942 100644
--- a/drivers/watchdog/i6300esb.c
+++ b/drivers/watchdog/i6300esb.c
@@ -34,7 +34,6 @@
 #include <linux/mm.h>
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
-#include <linux/platform_device.h>
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/ioport.h>
@@ -42,7 +41,7 @@
 #include <linux/io.h>
 
 /* Module and version information */
-#define ESB_VERSION "0.04"
+#define ESB_VERSION "0.05"
 #define ESB_MODULE_NAME "i6300ESB timer"
 #define ESB_DRIVER_NAME ESB_MODULE_NAME ", v" ESB_VERSION
 #define PFX ESB_MODULE_NAME ": "
@@ -65,7 +64,7 @@
 /* Config register bits */
 #define ESB_WDT_REBOOT  (0x01 << 5)   /* Enable reboot on timeout          */
 #define ESB_WDT_FREQ    (0x01 << 2)   /* Decrement frequency               */
-#define ESB_WDT_INTTYPE (0x11 << 0)   /* Interrupt type on timer1 timeout  */
+#define ESB_WDT_INTTYPE (0x03 << 0)   /* Interrupt type on timer1 timeout  */
 
 /* Reload register bits */
 #define ESB_WDT_TIMEOUT (0x01 << 9)    /* Watchdog timed out                */
@@ -82,7 +81,9 @@ static unsigned long timer_alive;
 static struct pci_dev *esb_pci;
 static unsigned short triggered; /* The status of the watchdog upon boot */
 static char esb_expect_close;
-static struct platform_device *esb_platform_device;
+
+/* We can only use 1 card due to the /dev/watchdog restriction */
+static int cards_found;
 
 /* module parameters */
 /* 30 sec default heartbeat (1 < heartbeat < 2*1023) */
@@ -111,8 +112,8 @@ MODULE_PARM_DESC(nowayout,
  */
 static inline void esb_unlock_registers(void)
 {
-        writeb(ESB_UNLOCK1, ESB_RELOAD_REG);
-        writeb(ESB_UNLOCK2, ESB_RELOAD_REG);
+        writew(ESB_UNLOCK1, ESB_RELOAD_REG);
+        writew(ESB_UNLOCK2, ESB_RELOAD_REG);
 }
 
 static int esb_timer_start(void)
@@ -256,7 +257,7 @@ static long esb_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int new_heartbeat;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT |
                                         WDIOF_KEEPALIVEPING |
                                         WDIOF_MAGICCLOSE,
@@ -332,11 +333,6 @@ static struct miscdevice esb_miscdev = {
 
 /*
  * Data for PCI driver interface
- *
- * This data only exists for exporting the supported
- * PCI ids via MODULE_DEVICE_TABLE.  We do not actually
- * register a pci_driver, because someone else might one day
- * want to register another driver on the same PCI id.
  */
 static struct pci_device_id esb_pci_tbl[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ESB_9), },
@@ -348,29 +344,19 @@ MODULE_DEVICE_TABLE(pci, esb_pci_tbl);
  *      Init & exit routines
  */
 
-static unsigned char __devinit esb_getdevice(void)
+static unsigned char __devinit esb_getdevice(struct pci_dev *pdev)
 {
-        /*
-         *      Find the PCI device
-         */
-
-        esb_pci = pci_get_device(PCI_VENDOR_ID_INTEL,
-                                        PCI_DEVICE_ID_INTEL_ESB_9, NULL);
-
-        if (!esb_pci)
-                return 0;
-
-        if (pci_enable_device(esb_pci)) {
+        if (pci_enable_device(pdev)) {
                 printk(KERN_ERR PFX "failed to enable device\n");
                 goto err_devput;
         }
 
-        if (pci_request_region(esb_pci, 0, ESB_MODULE_NAME)) {
+        if (pci_request_region(pdev, 0, ESB_MODULE_NAME)) {
                 printk(KERN_ERR PFX "failed to request region\n");
                 goto err_disable;
         }
 
-        BASEADDR = pci_ioremap_bar(esb_pci, 0);
+        BASEADDR = pci_ioremap_bar(pdev, 0);
         if (BASEADDR == NULL) {
                 /* Something's wrong here, BASEADDR has to be set */
                 printk(KERN_ERR PFX "failed to get BASEADDR\n");
@@ -378,14 +364,14 @@ static unsigned char __devinit esb_getdevice(void)
         }
 
         /* Done */
+        esb_pci = pdev;
         return 1;
 
 err_release:
-        pci_release_region(esb_pci, 0);
+        pci_release_region(pdev, 0);
 err_disable:
-        pci_disable_device(esb_pci);
+        pci_disable_device(pdev);
 err_devput:
-        pci_dev_put(esb_pci);
         return 0;
 }
 
@@ -430,12 +416,23 @@ static void __devinit esb_initdevice(void)
         esb_timer_set_heartbeat(heartbeat);
 }
 
-static int __devinit esb_probe(struct platform_device *dev)
+static int __devinit esb_probe(struct pci_dev *pdev,
+                const struct pci_device_id *ent)
 {
         int ret;
 
+        cards_found++;
+        if (cards_found == 1)
+                printk(KERN_INFO PFX "Intel 6300ESB WatchDog Timer Driver v%s\n",
+                        ESB_VERSION);
+
+        if (cards_found > 1) {
+                printk(KERN_ERR PFX "This driver only supports 1 device\n");
+                return -ENODEV;
+        }
+
         /* Check whether or not the hardware watchdog is there */
-        if (!esb_getdevice() || esb_pci == NULL)
+        if (!esb_getdevice(pdev) || esb_pci == NULL)
                 return -ENODEV;
 
         /* Check that the heartbeat value is within it's range;
@@ -467,11 +464,11 @@ err_unmap:
         iounmap(BASEADDR);
         pci_release_region(esb_pci, 0);
         pci_disable_device(esb_pci);
-        pci_dev_put(esb_pci);
+        esb_pci = NULL;
         return ret;
 }
 
-static int __devexit esb_remove(struct platform_device *dev)
+static void __devexit esb_remove(struct pci_dev *pdev)
 {
         /* Stop the timer before we leave */
         if (!nowayout)
@@ -482,54 +479,30 @@ static int __devexit esb_remove(struct platform_device *dev)
         iounmap(BASEADDR);
         pci_release_region(esb_pci, 0);
         pci_disable_device(esb_pci);
-        pci_dev_put(esb_pci);
-        return 0;
+        esb_pci = NULL;
 }
 
-static void esb_shutdown(struct platform_device *dev)
+static void esb_shutdown(struct pci_dev *pdev)
 {
         esb_timer_stop();
 }
 
-static struct platform_driver esb_platform_driver = {
+static struct pci_driver esb_driver = {
+        .name           = ESB_MODULE_NAME,
+        .id_table       = esb_pci_tbl,
         .probe          = esb_probe,
         .remove         = __devexit_p(esb_remove),
         .shutdown       = esb_shutdown,
-        .driver         = {
-                .owner  = THIS_MODULE,
-                .name   = ESB_MODULE_NAME,
-        },
 };
 
 static int __init watchdog_init(void)
 {
-        int err;
-
-        printk(KERN_INFO PFX "Intel 6300ESB WatchDog Timer Driver v%s\n",
-                ESB_VERSION);
-
-        err = platform_driver_register(&esb_platform_driver);
-        if (err)
-                return err;
-
-        esb_platform_device = platform_device_register_simple(ESB_MODULE_NAME,
-                                                                -1, NULL, 0);
-        if (IS_ERR(esb_platform_device)) {
-                err = PTR_ERR(esb_platform_device);
-                goto unreg_platform_driver;
-        }
-
-        return 0;
-
-unreg_platform_driver:
-        platform_driver_unregister(&esb_platform_driver);
-        return err;
+        return pci_register_driver(&esb_driver);
 }
 
 static void __exit watchdog_cleanup(void)
 {
-        platform_device_unregister(esb_platform_device);
-        platform_driver_unregister(&esb_platform_driver);
+        pci_unregister_driver(&esb_driver);
         printk(KERN_INFO PFX "Watchdog Module Unloaded.\n");
 }
 
diff --git a/drivers/watchdog/iTCO_wdt.c b/drivers/watchdog/iTCO_wdt.c
index 4bdb7f1a9077..44bc6aa46edf 100644
--- a/drivers/watchdog/iTCO_wdt.c
+++ b/drivers/watchdog/iTCO_wdt.c
@@ -584,7 +584,7 @@ static long iTCO_wdt_ioctl(struct file *file, unsigned int cmd,
         int new_heartbeat;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT |
                                         WDIOF_KEEPALIVEPING |
                                         WDIOF_MAGICCLOSE,
@@ -698,7 +698,7 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
         if (iTCO_wdt_private.iTCO_version == 2) {
                 pci_read_config_dword(pdev, 0xf0, &base_address);
                 if ((base_address & 1) == 0) {
-                        printk(KERN_ERR PFX "RCBA is disabled by harddware\n");
+                        printk(KERN_ERR PFX "RCBA is disabled by hardware\n");
                         ret = -ENODEV;
                         goto out;
                 }
@@ -708,8 +708,8 @@ static int __devinit iTCO_wdt_init(struct pci_dev *pdev,
 
         /* Check chipset's NO_REBOOT bit */
         if (iTCO_wdt_unset_NO_REBOOT_bit() && iTCO_vendor_check_noreboot_on()) {
-                printk(KERN_ERR PFX "failed to reset NO_REBOOT flag, "
-                                        "reboot disabled by hardware\n");
+                printk(KERN_INFO PFX "unable to reset NO_REBOOT flag, "
+                                        "platform may have disabled it\n");
                 ret = -ENODEV;  /* Cannot reset NO_REBOOT bit */
                 goto out_unmap;
         }
@@ -805,6 +805,7 @@ static void __devexit iTCO_wdt_cleanup(void)
 
 static int __devinit iTCO_wdt_probe(struct platform_device *dev)
 {
+        int ret = -ENODEV;
         int found = 0;
         struct pci_dev *pdev = NULL;
         const struct pci_device_id *ent;
@@ -814,19 +815,17 @@ static int __devinit iTCO_wdt_probe(struct platform_device *dev)
         for_each_pci_dev(pdev) {
                 ent = pci_match_id(iTCO_wdt_pci_tbl, pdev);
                 if (ent) {
-                        if (!(iTCO_wdt_init(pdev, ent, dev))) {
-                                found++;
+                        found++;
+                        ret = iTCO_wdt_init(pdev, ent, dev);
+                        if (!ret)
                                 break;
-                        }
                 }
         }
 
-        if (!found) {
+        if (!found)
                 printk(KERN_INFO PFX "No card detected\n");
-                return -ENODEV;
-        }
 
-        return 0;
+        return ret;
 }
 
 static int __devexit iTCO_wdt_remove(struct platform_device *dev)
diff --git a/drivers/watchdog/ib700wdt.c b/drivers/watchdog/ib700wdt.c
index 4bef3ddff4a5..0149d8dfc81d 100644
--- a/drivers/watchdog/ib700wdt.c
+++ b/drivers/watchdog/ib700wdt.c
@@ -174,7 +174,7 @@ static long ibwdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
 
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT
                                                         | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
diff --git a/drivers/watchdog/indydog.c b/drivers/watchdog/indydog.c
index bea8a124a559..1cc5609666d1 100644
--- a/drivers/watchdog/indydog.c
+++ b/drivers/watchdog/indydog.c
@@ -111,7 +111,7 @@ static long indydog_ioctl(struct file *file, unsigned int cmd,
                                                         unsigned long arg)
 {
         int options, retval = -EINVAL;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options                = WDIOF_KEEPALIVEPING,
                 .firmware_version       = 0,
                 .identity               = "Hardware Watchdog for SGI IP22",
diff --git a/drivers/watchdog/it8712f_wdt.c b/drivers/watchdog/it8712f_wdt.c
index daed48ded7fe..f52c162b1bea 100644
--- a/drivers/watchdog/it8712f_wdt.c
+++ b/drivers/watchdog/it8712f_wdt.c
@@ -236,7 +236,7 @@ static long it8712f_wdt_ioctl(struct file *file, unsigned int cmd,
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .identity = "IT8712F Watchdog",
                 .firmware_version = 1,
                 .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING |
diff --git a/drivers/watchdog/it87_wdt.c b/drivers/watchdog/it87_wdt.c
index cc133c531d08..b709b3b2d1ef 100644
--- a/drivers/watchdog/it87_wdt.c
+++ b/drivers/watchdog/it87_wdt.c
@@ -421,7 +421,7 @@ static ssize_t wdt_write(struct file *file, const char __user *buf,
         return count;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
         .firmware_version =     1,
         .identity = WATCHDOG_NAME,
diff --git a/drivers/watchdog/ixp2000_wdt.c b/drivers/watchdog/ixp2000_wdt.c
index 3c79dc587958..e86952a7168c 100644
--- a/drivers/watchdog/ixp2000_wdt.c
+++ b/drivers/watchdog/ixp2000_wdt.c
@@ -100,7 +100,7 @@ static ssize_t ixp2000_wdt_write(struct file *file, const char *data,
 }
 
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options        = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
                                 WDIOF_KEEPALIVEPING,
         .identity       = "IXP2000 Watchdog",
diff --git a/drivers/watchdog/ixp4xx_wdt.c b/drivers/watchdog/ixp4xx_wdt.c
index 147b4d5c63b3..e02c0ecda26b 100644
--- a/drivers/watchdog/ixp4xx_wdt.c
+++ b/drivers/watchdog/ixp4xx_wdt.c
@@ -89,7 +89,7 @@ ixp4xx_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options        = WDIOF_CARDRESET | WDIOF_MAGICCLOSE |
                           WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
         .identity       = "IXP4xx Watchdog",
diff --git a/drivers/watchdog/ks8695_wdt.c b/drivers/watchdog/ks8695_wdt.c
index e1c82769b08e..2852bb2e3fd9 100644
--- a/drivers/watchdog/ks8695_wdt.c
+++ b/drivers/watchdog/ks8695_wdt.c
@@ -145,7 +145,7 @@ static int ks8695_wdt_close(struct inode *inode, struct file *file)
         return 0;
 }
 
-static struct watchdog_info ks8695_wdt_info = {
+static const struct watchdog_info ks8695_wdt_info = {
         .identity       = "ks8695 watchdog",
         .options        = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING,
 };
diff --git a/drivers/watchdog/machzwd.c b/drivers/watchdog/machzwd.c
index 47d719717a3b..2d118cf022fc 100644
--- a/drivers/watchdog/machzwd.c
+++ b/drivers/watchdog/machzwd.c
@@ -101,7 +101,7 @@ MODULE_PARM_DESC(nowayout,
 
 #define PFX "machzwd"
 
-static struct watchdog_info zf_info = {
+static const struct watchdog_info zf_info = {
         .options                = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
         .firmware_version       = 1,
         .identity               = "ZF-Logic watchdog",
diff --git a/drivers/watchdog/max63xx_wdt.c b/drivers/watchdog/max63xx_wdt.c
new file mode 100644
index 000000000000..6eb91d757604
--- /dev/null
+++ b/drivers/watchdog/max63xx_wdt.c
@@ -0,0 +1,397 @@
+/*
+ * drivers/char/watchdog/max63xx_wdt.c
+ *
+ * Driver for max63{69,70,71,72,73,74} watchdog timers
+ *
+ * Copyright (C) 2009 Marc Zyngier <maz@misterjones.org>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ *
+ * This driver assumes the watchdog pins are memory mapped (as it is
+ * the case for the Arcom Zeus). Should it be connected over GPIOs or
+ * another interface, some abstraction will have to be introduced.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
+#include <linux/device.h>
+
+#define DEFAULT_HEARTBEAT 60
+#define MAX_HEARTBEAT     60
+
+static int heartbeat = DEFAULT_HEARTBEAT;
+static int nowayout  = WATCHDOG_NOWAYOUT;
+
+/*
+ * Memory mapping: a single byte, 3 first lower bits to select bit 3
+ * to ping the watchdog.
+ */
+#define MAX6369_WDSET   (7 << 0)
+#define MAX6369_WDI     (1 << 3)
+
+static DEFINE_SPINLOCK(io_lock);
+
+static unsigned long wdt_status;
+#define WDT_IN_USE      0
+#define WDT_RUNNING     1
+#define WDT_OK_TO_CLOSE 2
+
+static int nodelay;
+static struct resource  *wdt_mem;
+static void __iomem     *wdt_base;
+static struct platform_device *max63xx_pdev;
+
+/*
+ * The timeout values used are actually the absolute minimum the chip
+ * offers. Typical values on my board are slightly over twice as long
+ * (10s setting ends up with a 25s timeout), and can be up to 3 times
+ * the nominal setting (according to the datasheet). So please take
+ * these values with a grain of salt. Same goes for the initial delay
+ * "feature". Only max6373/74 have a few settings without this initial
+ * delay (selected with the "nodelay" parameter).
+ *
+ * I also decided to remove from the tables any timeout smaller than a
+ * second, as it looked completly overkill...
+ */
+
+/* Timeouts in second */
+struct max63xx_timeout {
+        u8 wdset;
+        u8 tdelay;
+        u8 twd;
+};
+
+static struct max63xx_timeout max6369_table[] = {
+        { 5,  1,  1 },
+        { 6, 10, 10 },
+        { 7, 60, 60 },
+        { },
+};
+
+static struct max63xx_timeout max6371_table[] = {
+        { 6, 60,  3 },
+        { 7, 60, 60 },
+        { },
+};
+
+static struct max63xx_timeout max6373_table[] = {
+        { 2, 60,  1 },
+        { 5,  0,  1 },
+        { 1,  3,  3 },
+        { 7, 60, 10 },
+        { 6,  0, 10 },
+        { },
+};
+
+static struct max63xx_timeout *current_timeout;
+
+static struct max63xx_timeout *
+max63xx_select_timeout(struct max63xx_timeout *table, int value)
+{
+        while (table->twd) {
+                if (value <= table->twd) {
+                        if (nodelay && table->tdelay == 0)
+                                return table;
+
+                        if (!nodelay)
+                                return table;
+                }
+
+                table++;
+        }
+
+        return NULL;
+}
+
+static void max63xx_wdt_ping(void)
+{
+        u8 val;
+
+        spin_lock(&io_lock);
+
+        val = __raw_readb(wdt_base);
+
+        __raw_writeb(val | MAX6369_WDI, wdt_base);
+        __raw_writeb(val & ~MAX6369_WDI, wdt_base);
+
+        spin_unlock(&io_lock);
+}
+
+static void max63xx_wdt_enable(struct max63xx_timeout *entry)
+{
+        u8 val;
+
+        if (test_and_set_bit(WDT_RUNNING, &wdt_status))
+                return;
+
+        spin_lock(&io_lock);
+
+        val = __raw_readb(wdt_base);
+        val &= ~MAX6369_WDSET;
+        val |= entry->wdset;
+        __raw_writeb(val, wdt_base);
+
+        spin_unlock(&io_lock);
+
+        /* check for a edge triggered startup */
+        if (entry->tdelay == 0)
+                max63xx_wdt_ping();
+}
+
+static void max63xx_wdt_disable(void)
+{
+        spin_lock(&io_lock);
+
+        __raw_writeb(3, wdt_base);
+
+        spin_unlock(&io_lock);
+
+        clear_bit(WDT_RUNNING, &wdt_status);
+}
+
+static int max63xx_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(WDT_IN_USE, &wdt_status))
+                return -EBUSY;
+
+        max63xx_wdt_enable(current_timeout);
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        return nonseekable_open(inode, file);
+}
+
+static ssize_t max63xx_wdt_write(struct file *file, const char *data,
+                                 size_t len, loff_t *ppos)
+{
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                        for (i = 0; i != len; i++) {
+                                char c;
+
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+
+                                if (c == 'V')
+                                        set_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                        }
+                }
+
+                max63xx_wdt_ping();
+        }
+
+        return len;
+}
+
+static const struct watchdog_info ident = {
+        .options = WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
+        .identity = "max63xx Watchdog",
+};
+
+static long max63xx_wdt_ioctl(struct file *file, unsigned int cmd,
+                              unsigned long arg)
+{
+        int ret = -ENOTTY;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user((struct watchdog_info *)arg, &ident,
+                                   sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(0, (int *)arg);
+                break;
+
+        case WDIOC_KEEPALIVE:
+                max63xx_wdt_ping();
+                ret = 0;
+                break;
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(heartbeat, (int *)arg);
+                break;
+        }
+        return ret;
+}
+
+static int max63xx_wdt_release(struct inode *inode, struct file *file)
+{
+        if (test_bit(WDT_OK_TO_CLOSE, &wdt_status))
+                max63xx_wdt_disable();
+        else
+                dev_crit(&max63xx_pdev->dev,
+                         "device closed unexpectedly - timer will not stop\n");
+
+        clear_bit(WDT_IN_USE, &wdt_status);
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+
+        return 0;
+}
+
+static const struct file_operations max63xx_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = max63xx_wdt_write,
+        .unlocked_ioctl = max63xx_wdt_ioctl,
+        .open           = max63xx_wdt_open,
+        .release        = max63xx_wdt_release,
+};
+
+static struct miscdevice max63xx_wdt_miscdev = {
+        .minor  = WATCHDOG_MINOR,
+        .name   = "watchdog",
+        .fops   = &max63xx_wdt_fops,
+};
+
+static int __devinit max63xx_wdt_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        int size;
+        struct resource *res;
+        struct device *dev = &pdev->dev;
+        struct max63xx_timeout *table;
+
+        table = (struct max63xx_timeout *)pdev->id_entry->driver_data;
+
+        if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
+                heartbeat = DEFAULT_HEARTBEAT;
+
+        dev_info(dev, "requesting %ds heartbeat\n", heartbeat);
+        current_timeout = max63xx_select_timeout(table, heartbeat);
+
+        if (!current_timeout) {
+                dev_err(dev, "unable to satisfy heartbeat request\n");
+                return -EINVAL;
+        }
+
+        dev_info(dev, "using %ds heartbeat with %ds initial delay\n",
+                 current_timeout->twd, current_timeout->tdelay);
+
+        heartbeat = current_timeout->twd;
+
+        max63xx_pdev = pdev;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(dev, "failed to get memory region resource\n");
+                return -ENOENT;
+        }
+
+        size = resource_size(res);
+        wdt_mem = request_mem_region(res->start, size, pdev->name);
+
+        if (wdt_mem == NULL) {
+                dev_err(dev, "failed to get memory region\n");
+                return -ENOENT;
+        }
+
+        wdt_base = ioremap(res->start, size);
+        if (!wdt_base) {
+                dev_err(dev, "failed to map memory region\n");
+                ret = -ENOMEM;
+                goto out_request;
+        }
+
+        ret = misc_register(&max63xx_wdt_miscdev);
+        if (ret < 0) {
+                dev_err(dev, "cannot register misc device\n");
+                goto out_unmap;
+        }
+
+        return 0;
+
+out_unmap:
+        iounmap(wdt_base);
+out_request:
+        release_resource(wdt_mem);
+        kfree(wdt_mem);
+
+        return ret;
+}
+
+static int __devexit max63xx_wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&max63xx_wdt_miscdev);
+        if (wdt_mem) {
+                release_resource(wdt_mem);
+                kfree(wdt_mem);
+                wdt_mem = NULL;
+        }
+
+        if (wdt_base)
+                iounmap(wdt_base);
+
+        return 0;
+}
+
+static struct platform_device_id max63xx_id_table[] = {
+        { "max6369_wdt", (kernel_ulong_t)max6369_table, },
+        { "max6370_wdt", (kernel_ulong_t)max6369_table, },
+        { "max6371_wdt", (kernel_ulong_t)max6371_table, },
+        { "max6372_wdt", (kernel_ulong_t)max6371_table, },
+        { "max6373_wdt", (kernel_ulong_t)max6373_table, },
+        { "max6374_wdt", (kernel_ulong_t)max6373_table, },
+        { },
+};
+MODULE_DEVICE_TABLE(platform, max63xx_id_table);
+
+static struct platform_driver max63xx_wdt_driver = {
+        .probe          = max63xx_wdt_probe,
+        .remove         = __devexit_p(max63xx_wdt_remove),
+        .id_table       = max63xx_id_table,
+        .driver         = {
+                .name   = "max63xx_wdt",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init max63xx_wdt_init(void)
+{
+        return platform_driver_register(&max63xx_wdt_driver);
+}
+
+static void __exit max63xx_wdt_exit(void)
+{
+        platform_driver_unregister(&max63xx_wdt_driver);
+}
+
+module_init(max63xx_wdt_init);
+module_exit(max63xx_wdt_exit);
+
+MODULE_AUTHOR("Marc Zyngier <maz@misterjones.org>");
+MODULE_DESCRIPTION("max63xx Watchdog Driver");
+
+module_param(heartbeat, int, 0);
+MODULE_PARM_DESC(heartbeat,
+                 "Watchdog heartbeat period in seconds from 1 to "
+                 __MODULE_STRING(MAX_HEARTBEAT) ", default "
+                 __MODULE_STRING(DEFAULT_HEARTBEAT));
+
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+module_param(nodelay, int, 0);
+MODULE_PARM_DESC(nodelay,
+                 "Force selection of a timeout setting without initial delay "
+                 "(max6373/74 only, default=0)");
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/mixcomwd.c b/drivers/watchdog/mixcomwd.c
index 407b025cb104..bc820d16699a 100644
--- a/drivers/watchdog/mixcomwd.c
+++ b/drivers/watchdog/mixcomwd.c
@@ -201,7 +201,7 @@ static long mixcomwd_ioctl(struct file *file,
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int status;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
                 .identity = "MixCOM watchdog",
diff --git a/drivers/watchdog/mpc8xxx_wdt.c b/drivers/watchdog/mpc8xxx_wdt.c
index 38c588ee694f..4e3941c5e293 100644
--- a/drivers/watchdog/mpc8xxx_wdt.c
+++ b/drivers/watchdog/mpc8xxx_wdt.c
@@ -148,7 +148,7 @@ static long mpc8xxx_wdt_ioctl(struct file *file, unsigned int cmd,
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING,
                 .firmware_version = 1,
                 .identity = "MPC8xxx",
diff --git a/drivers/watchdog/mpcore_wdt.c b/drivers/watchdog/mpcore_wdt.c
index a2dc07c2ed49..b0646dac924e 100644
--- a/drivers/watchdog/mpcore_wdt.c
+++ b/drivers/watchdog/mpcore_wdt.c
@@ -213,7 +213,7 @@ static ssize_t mpcore_wdt_write(struct file *file, const char *data,
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options                = WDIOF_SETTIMEOUT |
                                   WDIOF_KEEPALIVEPING |
                                   WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/mv64x60_wdt.c b/drivers/watchdog/mv64x60_wdt.c
index a51dbe4c43da..97f8a48d8b78 100644
--- a/drivers/watchdog/mv64x60_wdt.c
+++ b/drivers/watchdog/mv64x60_wdt.c
@@ -179,7 +179,7 @@ static long mv64x60_wdt_ioctl(struct file *file,
         int timeout;
         int options;
         void __user *argp = (void __user *)arg;
-        static struct watchdog_info info = {
+        static const struct watchdog_info info = {
                 .options =      WDIOF_SETTIMEOUT        |
                                 WDIOF_MAGICCLOSE        |
                                 WDIOF_KEEPALIVEPING,
diff --git a/drivers/watchdog/pc87413_wdt.c b/drivers/watchdog/pc87413_wdt.c
index 1a2b916e3f8d..d3aa2f1fe61d 100644
--- a/drivers/watchdog/pc87413_wdt.c
+++ b/drivers/watchdog/pc87413_wdt.c
@@ -407,7 +407,7 @@ static long pc87413_ioctl(struct file *file, unsigned int cmd,
                 int __user *i;
         } uarg;
 
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options          = WDIOF_KEEPALIVEPING |
                                     WDIOF_SETTIMEOUT |
                                     WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/pcwd.c b/drivers/watchdog/pcwd.c
index aa9512321f3a..06f7922606c0 100644
--- a/drivers/watchdog/pcwd.c
+++ b/drivers/watchdog/pcwd.c
@@ -606,7 +606,7 @@ static long pcwd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int temperature;
         int new_heartbeat;
         int __user *argp = (int __user *)arg;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_OVERHEAT |
                                         WDIOF_CARDRESET |
                                         WDIOF_KEEPALIVEPING |
diff --git a/drivers/watchdog/pcwd_pci.c b/drivers/watchdog/pcwd_pci.c
index 698f51bff1bc..64374d636f09 100644
--- a/drivers/watchdog/pcwd_pci.c
+++ b/drivers/watchdog/pcwd_pci.c
@@ -481,7 +481,7 @@ static long pcipcwd_ioctl(struct file *file, unsigned int cmd,
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_OVERHEAT |
                                         WDIOF_CARDRESET |
                                         WDIOF_KEEPALIVEPING |
diff --git a/drivers/watchdog/pcwd_usb.c b/drivers/watchdog/pcwd_usb.c
index 052fe451851f..8e4eacc5bb52 100644
--- a/drivers/watchdog/pcwd_usb.c
+++ b/drivers/watchdog/pcwd_usb.c
@@ -404,7 +404,7 @@ static long usb_pcwd_ioctl(struct file *file, unsigned int cmd,
 {
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_KEEPALIVEPING |
                                         WDIOF_SETTIMEOUT |
                                         WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/pika_wdt.c b/drivers/watchdog/pika_wdt.c
index 2d22e996e996..435ec2aed4fe 100644
--- a/drivers/watchdog/pika_wdt.c
+++ b/drivers/watchdog/pika_wdt.c
@@ -52,7 +52,7 @@ static struct {
         struct timer_list timer;        /* The timer that pings the watchdog */
 } pikawdt_private;
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .identity       = DRV_NAME,
         .options        = WDIOF_CARDRESET |
                           WDIOF_SETTIMEOUT |
diff --git a/drivers/watchdog/pnx833x_wdt.c b/drivers/watchdog/pnx833x_wdt.c
index 538ec2c05197..09102f09e681 100644
--- a/drivers/watchdog/pnx833x_wdt.c
+++ b/drivers/watchdog/pnx833x_wdt.c
@@ -141,7 +141,7 @@ static long pnx833x_wdt_ioctl(struct file *file, unsigned int cmd,
         int options, new_timeout = 0;
         uint32_t timeout, timeout_left = 0;
 
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT,
                 .firmware_version = 0,
                 .identity = "Hardware Watchdog for PNX833x",
diff --git a/drivers/watchdog/rc32434_wdt.c b/drivers/watchdog/rc32434_wdt.c
index bf12d06b5877..d4c29b5311a4 100644
--- a/drivers/watchdog/rc32434_wdt.c
+++ b/drivers/watchdog/rc32434_wdt.c
@@ -198,7 +198,7 @@ static long rc32434_wdt_ioctl(struct file *file, unsigned int cmd,
         void __user *argp = (void __user *)arg;
         int new_timeout;
         unsigned int value;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT |
                                         WDIOF_KEEPALIVEPING |
                                         WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/rdc321x_wdt.c b/drivers/watchdog/rdc321x_wdt.c
index 4976bfd1fce6..69c6adbd8205 100644
--- a/drivers/watchdog/rdc321x_wdt.c
+++ b/drivers/watchdog/rdc321x_wdt.c
@@ -149,7 +149,7 @@ static long rdc321x_wdt_ioctl(struct file *file, unsigned int cmd,
 {
         void __user *argp = (void __user *)arg;
         unsigned int value;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_CARDRESET,
                 .identity = "RDC321x WDT",
         };
diff --git a/drivers/watchdog/riowd.c b/drivers/watchdog/riowd.c
index c14ae8676903..ae57bf9e1b03 100644
--- a/drivers/watchdog/riowd.c
+++ b/drivers/watchdog/riowd.c
@@ -85,7 +85,7 @@ static int riowd_release(struct inode *inode, struct file *filp)
 
 static long riowd_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        static struct watchdog_info info = {
+        static const struct watchdog_info info = {
                 .options                = WDIOF_SETTIMEOUT,
                 .firmware_version       = 1,
                 .identity               = DRIVER_NAME,
diff --git a/drivers/watchdog/sbc_fitpc2_wdt.c b/drivers/watchdog/sbc_fitpc2_wdt.c
index e6763d2a567b..8d44c9b6fb5b 100644
--- a/drivers/watchdog/sbc_fitpc2_wdt.c
+++ b/drivers/watchdog/sbc_fitpc2_wdt.c
@@ -111,7 +111,7 @@ out:
 }
 
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options        = WDIOF_MAGICCLOSE | WDIOF_SETTIMEOUT |
                                 WDIOF_KEEPALIVEPING,
         .identity       = WATCHDOG_NAME,
diff --git a/drivers/watchdog/sch311x_wdt.c b/drivers/watchdog/sch311x_wdt.c
index 569eb295a7a8..9c40f48804f5 100644
--- a/drivers/watchdog/sch311x_wdt.c
+++ b/drivers/watchdog/sch311x_wdt.c
@@ -250,7 +250,7 @@ static long sch311x_wdt_ioctl(struct file *file, unsigned int cmd,
         int new_timeout;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options                = WDIOF_KEEPALIVEPING |
                                           WDIOF_SETTIMEOUT |
                                           WDIOF_MAGICCLOSE,
diff --git a/drivers/watchdog/stmp3xxx_wdt.c b/drivers/watchdog/stmp3xxx_wdt.c
index 5dd952681f32..b3421fd2cda8 100644
--- a/drivers/watchdog/stmp3xxx_wdt.c
+++ b/drivers/watchdog/stmp3xxx_wdt.c
@@ -94,7 +94,7 @@ static ssize_t stmp3xxx_wdt_write(struct file *file, const char __user *data,
         return len;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options        = WDIOF_CARDRESET |
                           WDIOF_MAGICCLOSE |
                           WDIOF_SETTIMEOUT |
diff --git a/drivers/watchdog/ts72xx_wdt.c b/drivers/watchdog/ts72xx_wdt.c
new file mode 100644
index 000000000000..565a2c3321e5
--- /dev/null
+++ b/drivers/watchdog/ts72xx_wdt.c
@@ -0,0 +1,520 @@
+/*
+ * Watchdog driver for Technologic Systems TS-72xx based SBCs
+ * (TS-7200, TS-7250 and TS-7260). These boards have external
+ * glue logic CPLD chip, which includes programmable watchdog
+ * timer.
+ *
+ * Copyright (c) 2009 Mika Westerberg <mika.westerberg@iki.fi>
+ *
+ * This driver is based on ep93xx_wdt and wm831x_wdt drivers.
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/fs.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/miscdevice.h>
+#include <linux/mutex.h>
+#include <linux/platform_device.h>
+#include <linux/watchdog.h>
+#include <linux/uaccess.h>
+
+#define TS72XX_WDT_FEED_VAL             0x05
+#define TS72XX_WDT_DEFAULT_TIMEOUT      8
+
+static int timeout = TS72XX_WDT_DEFAULT_TIMEOUT;
+module_param(timeout, int, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds. "
+                          "(1 <= timeout <= 8, default="
+                          __MODULE_STRING(TS72XX_WDT_DEFAULT_TIMEOUT)
+                          ")");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Disable watchdog shutdown on close");
+
+/**
+ * struct ts72xx_wdt - watchdog control structure
+ * @lock: lock that protects this structure
+ * @regval: watchdog timeout value suitable for control register
+ * @flags: flags controlling watchdog device state
+ * @control_reg: watchdog control register
+ * @feed_reg: watchdog feed register
+ * @pdev: back pointer to platform dev
+ */
+struct ts72xx_wdt {
+        struct mutex    lock;
+        int             regval;
+
+#define TS72XX_WDT_BUSY_FLAG            1
+#define TS72XX_WDT_EXPECT_CLOSE_FLAG    2
+        int             flags;
+
+        void __iomem    *control_reg;
+        void __iomem    *feed_reg;
+
+        struct platform_device *pdev;
+};
+
+struct platform_device *ts72xx_wdt_pdev;
+
+/*
+ * TS-72xx Watchdog supports following timeouts (value written
+ * to control register):
+ *      value   description
+ *      -------------------------
+ *      0x00    watchdog disabled
+ *      0x01    250ms
+ *      0x02    500ms
+ *      0x03    1s
+ *      0x04    reserved
+ *      0x05    2s
+ *      0x06    4s
+ *      0x07    8s
+ *
+ * Timeouts below 1s are not very usable so we don't
+ * allow them at all.
+ *
+ * We provide two functions that convert between these:
+ * timeout_to_regval() and regval_to_timeout().
+ */
+static const struct {
+        int     timeout;
+        int     regval;
+} ts72xx_wdt_map[] = {
+        { 1, 3 },
+        { 2, 5 },
+        { 4, 6 },
+        { 8, 7 },
+};
+
+/**
+ * timeout_to_regval() - converts given timeout to control register value
+ * @new_timeout: timeout in seconds to be converted
+ *
+ * Function converts given @new_timeout into valid value that can
+ * be programmed into watchdog control register. When conversion is
+ * not possible, function returns %-EINVAL.
+ */
+static int timeout_to_regval(int new_timeout)
+{
+        int i;
+
+        /* first limit it to 1 - 8 seconds */
+        new_timeout = clamp_val(new_timeout, 1, 8);
+
+        for (i = 0; i < ARRAY_SIZE(ts72xx_wdt_map); i++) {
+                if (ts72xx_wdt_map[i].timeout >= new_timeout)
+                        return ts72xx_wdt_map[i].regval;
+        }
+
+        return -EINVAL;
+}
+
+/**
+ * regval_to_timeout() - converts control register value to timeout
+ * @regval: control register value to be converted
+ *
+ * Function converts given @regval to timeout in seconds (1, 2, 4 or 8).
+ * If @regval cannot be converted, function returns %-EINVAL.
+ */
+static int regval_to_timeout(int regval)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(ts72xx_wdt_map); i++) {
+                if (ts72xx_wdt_map[i].regval == regval)
+                        return ts72xx_wdt_map[i].timeout;
+        }
+
+        return -EINVAL;
+}
+
+/**
+ * ts72xx_wdt_kick() - kick the watchdog
+ * @wdt: watchdog to be kicked
+ *
+ * Called with @wdt->lock held.
+ */
+static inline void ts72xx_wdt_kick(struct ts72xx_wdt *wdt)
+{
+        __raw_writeb(TS72XX_WDT_FEED_VAL, wdt->feed_reg);
+}
+
+/**
+ * ts72xx_wdt_start() - starts the watchdog timer
+ * @wdt: watchdog to be started
+ *
+ * This function programs timeout to watchdog timer
+ * and starts it.
+ *
+ * Called with @wdt->lock held.
+ */
+static void ts72xx_wdt_start(struct ts72xx_wdt *wdt)
+{
+        /*
+         * To program the wdt, it first must be "fed" and
+         * only after that (within 30 usecs) the configuration
+         * can be changed.
+         */
+        ts72xx_wdt_kick(wdt);
+        __raw_writeb((u8)wdt->regval, wdt->control_reg);
+}
+
+/**
+ * ts72xx_wdt_stop() - stops the watchdog timer
+ * @wdt: watchdog to be stopped
+ *
+ * Called with @wdt->lock held.
+ */
+static void ts72xx_wdt_stop(struct ts72xx_wdt *wdt)
+{
+        ts72xx_wdt_kick(wdt);
+        __raw_writeb(0, wdt->control_reg);
+}
+
+static int ts72xx_wdt_open(struct inode *inode, struct file *file)
+{
+        struct ts72xx_wdt *wdt = platform_get_drvdata(ts72xx_wdt_pdev);
+        int regval;
+
+        /*
+         * Try to convert default timeout to valid register
+         * value first.
+         */
+        regval = timeout_to_regval(timeout);
+        if (regval < 0) {
+                dev_err(&wdt->pdev->dev,
+                        "failed to convert timeout (%d) to register value\n",
+                        timeout);
+                return -EINVAL;
+        }
+
+        if (mutex_lock_interruptible(&wdt->lock))
+                return -ERESTARTSYS;
+
+        if ((wdt->flags & TS72XX_WDT_BUSY_FLAG) != 0) {
+                mutex_unlock(&wdt->lock);
+                return -EBUSY;
+        }
+
+        wdt->flags = TS72XX_WDT_BUSY_FLAG;
+        wdt->regval = regval;
+        file->private_data = wdt;
+
+        ts72xx_wdt_start(wdt);
+
+        mutex_unlock(&wdt->lock);
+        return nonseekable_open(inode, file);
+}
+
+static int ts72xx_wdt_release(struct inode *inode, struct file *file)
+{
+        struct ts72xx_wdt *wdt = file->private_data;
+
+        if (mutex_lock_interruptible(&wdt->lock))
+                return -ERESTARTSYS;
+
+        if ((wdt->flags & TS72XX_WDT_EXPECT_CLOSE_FLAG) != 0) {
+                ts72xx_wdt_stop(wdt);
+        } else {
+                dev_warn(&wdt->pdev->dev,
+                         "TS-72XX WDT device closed unexpectly. "
+                         "Watchdog timer will not stop!\n");
+                /*
+                 * Kick it one more time, to give userland some time
+                 * to recover (for example, respawning the kicker
+                 * daemon).
+                 */
+                ts72xx_wdt_kick(wdt);
+        }
+
+        wdt->flags = 0;
+
+        mutex_unlock(&wdt->lock);
+        return 0;
+}
+
+static ssize_t ts72xx_wdt_write(struct file *file,
+                                const char __user *data,
+                                size_t len,
+                                loff_t *ppos)
+{
+        struct ts72xx_wdt *wdt = file->private_data;
+
+        if (!len)
+                return 0;
+
+        if (mutex_lock_interruptible(&wdt->lock))
+                return -ERESTARTSYS;
+
+        ts72xx_wdt_kick(wdt);
+
+        /*
+         * Support for magic character closing. User process
+         * writes 'V' into the device, just before it is closed.
+         * This means that we know that the wdt timer can be
+         * stopped after user closes the device.
+         */
+        if (!nowayout) {
+                int i;
+
+                for (i = 0; i < len; i++) {
+                        char c;
+
+                        /* In case it was set long ago */
+                        wdt->flags &= ~TS72XX_WDT_EXPECT_CLOSE_FLAG;
+
+                        if (get_user(c, data + i)) {
+                                mutex_unlock(&wdt->lock);
+                                return -EFAULT;
+                        }
+                        if (c == 'V') {
+                                wdt->flags |= TS72XX_WDT_EXPECT_CLOSE_FLAG;
+                                break;
+                        }
+                }
+        }
+
+        mutex_unlock(&wdt->lock);
+        return len;
+}
+
+static const struct watchdog_info winfo = {
+        .options                = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
+                                  WDIOF_MAGICCLOSE,
+        .firmware_version       = 1,
+        .identity               = "TS-72XX WDT",
+};
+
+static long ts72xx_wdt_ioctl(struct file *file, unsigned int cmd,
+                             unsigned long arg)
+{
+        struct ts72xx_wdt *wdt = file->private_data;
+        void __user *argp = (void __user *)arg;
+        int __user *p = (int __user *)argp;
+        int error = 0;
+
+        if (mutex_lock_interruptible(&wdt->lock))
+                return -ERESTARTSYS;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                error = copy_to_user(argp, &winfo, sizeof(winfo));
+                break;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_KEEPALIVE:
+                ts72xx_wdt_kick(wdt);
+                break;
+
+        case WDIOC_SETOPTIONS: {
+                int options;
+
+                if (get_user(options, p)) {
+                        error = -EFAULT;
+                        break;
+                }
+
+                error = -EINVAL;
+
+                if ((options & WDIOS_DISABLECARD) != 0) {
+                        ts72xx_wdt_stop(wdt);
+                        error = 0;
+                }
+                if ((options & WDIOS_ENABLECARD) != 0) {
+                        ts72xx_wdt_start(wdt);
+                        error = 0;
+                }
+
+                break;
+        }
+
+        case WDIOC_SETTIMEOUT: {
+                int new_timeout;
+
+                if (get_user(new_timeout, p)) {
+                        error = -EFAULT;
+                } else {
+                        int regval;
+
+                        regval = timeout_to_regval(new_timeout);
+                        if (regval < 0) {
+                                error = -EINVAL;
+                        } else {
+                                ts72xx_wdt_stop(wdt);
+                                wdt->regval = regval;
+                                ts72xx_wdt_start(wdt);
+                        }
+                }
+                if (error)
+                        break;
+
+                /*FALLTHROUGH*/
+        }
+
+        case WDIOC_GETTIMEOUT:
+                if (put_user(regval_to_timeout(wdt->regval), p))
+                        error = -EFAULT;
+                break;
+
+        default:
+                error = -ENOTTY;
+                break;
+        }
+
+        mutex_unlock(&wdt->lock);
+        return error;
+}
+
+static const struct file_operations ts72xx_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .open           = ts72xx_wdt_open,
+        .release        = ts72xx_wdt_release,
+        .write          = ts72xx_wdt_write,
+        .unlocked_ioctl = ts72xx_wdt_ioctl,
+};
+
+static struct miscdevice ts72xx_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &ts72xx_wdt_fops,
+};
+
+static __devinit int ts72xx_wdt_probe(struct platform_device *pdev)
+{
+        struct ts72xx_wdt *wdt;
+        struct resource *r1, *r2;
+        int error = 0;
+
+        wdt = kzalloc(sizeof(struct ts72xx_wdt), GFP_KERNEL);
+        if (!wdt) {
+                dev_err(&pdev->dev, "failed to allocate memory\n");
+                return -ENOMEM;
+        }
+
+        r1 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!r1) {
+                dev_err(&pdev->dev, "failed to get memory resource\n");
+                error = -ENODEV;
+                goto fail;
+        }
+
+        r1 = request_mem_region(r1->start, resource_size(r1), pdev->name);
+        if (!r1) {
+                dev_err(&pdev->dev, "cannot request memory region\n");
+                error = -EBUSY;
+                goto fail;
+        }
+
+        wdt->control_reg = ioremap(r1->start, resource_size(r1));
+        if (!wdt->control_reg) {
+                dev_err(&pdev->dev, "failed to map memory\n");
+                error = -ENODEV;
+                goto fail_free_control;
+        }
+
+        r2 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!r2) {
+                dev_err(&pdev->dev, "failed to get memory resource\n");
+                error = -ENODEV;
+                goto fail_unmap_control;
+        }
+
+        r2 = request_mem_region(r2->start, resource_size(r2), pdev->name);
+        if (!r2) {
+                dev_err(&pdev->dev, "cannot request memory region\n");
+                error = -EBUSY;
+                goto fail_unmap_control;
+        }
+
+        wdt->feed_reg = ioremap(r2->start, resource_size(r2));
+        if (!wdt->feed_reg) {
+                dev_err(&pdev->dev, "failed to map memory\n");
+                error = -ENODEV;
+                goto fail_free_feed;
+        }
+
+        platform_set_drvdata(pdev, wdt);
+        ts72xx_wdt_pdev = pdev;
+        wdt->pdev = pdev;
+        mutex_init(&wdt->lock);
+
+        error = misc_register(&ts72xx_wdt_miscdev);
+        if (error) {
+                dev_err(&pdev->dev, "failed to register miscdev\n");
+                goto fail_unmap_feed;
+        }
+
+        dev_info(&pdev->dev, "TS-72xx Watchdog driver\n");
+
+        return 0;
+
+fail_unmap_feed:
+        platform_set_drvdata(pdev, NULL);
+        iounmap(wdt->feed_reg);
+fail_free_feed:
+        release_mem_region(r2->start, resource_size(r2));
+fail_unmap_control:
+        iounmap(wdt->control_reg);
+fail_free_control:
+        release_mem_region(r1->start, resource_size(r1));
+fail:
+        kfree(wdt);
+        return error;
+}
+
+static __devexit int ts72xx_wdt_remove(struct platform_device *pdev)
+{
+        struct ts72xx_wdt *wdt = platform_get_drvdata(pdev);
+        struct resource *res;
+        int error;
+
+        error = misc_deregister(&ts72xx_wdt_miscdev);
+        platform_set_drvdata(pdev, NULL);
+
+        iounmap(wdt->feed_reg);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        release_mem_region(res->start, resource_size(res));
+
+        iounmap(wdt->control_reg);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
+
+        kfree(wdt);
+        return error;
+}
+
+static struct platform_driver ts72xx_wdt_driver = {
+        .probe          = ts72xx_wdt_probe,
+        .remove         = __devexit_p(ts72xx_wdt_remove),
+        .driver         = {
+                .name   = "ts72xx-wdt",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int ts72xx_wdt_init(void)
+{
+        return platform_driver_register(&ts72xx_wdt_driver);
+}
+module_init(ts72xx_wdt_init);
+
+static __exit void ts72xx_wdt_exit(void)
+{
+        platform_driver_unregister(&ts72xx_wdt_driver);
+}
+module_exit(ts72xx_wdt_exit);
+
+MODULE_AUTHOR("Mika Westerberg <mika.westerberg@iki.fi>");
+MODULE_DESCRIPTION("TS-72xx SBC Watchdog");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:ts72xx-wdt");
diff --git a/drivers/watchdog/txx9wdt.c b/drivers/watchdog/txx9wdt.c
index d635566e9307..9e9ed7bfabcb 100644
--- a/drivers/watchdog/txx9wdt.c
+++ b/drivers/watchdog/txx9wdt.c
@@ -13,7 +13,6 @@
 #include <linux/miscdevice.h>
 #include <linux/watchdog.h>
 #include <linux/fs.h>
-#include <linux/reboot.h>
 #include <linux/init.h>
 #include <linux/uaccess.h>
 #include <linux/platform_device.h>
@@ -166,14 +165,6 @@ static long txx9wdt_ioctl(struct file *file, unsigned int cmd,
         }
 }
 
-static int txx9wdt_notify_sys(struct notifier_block *this, unsigned long code,
-        void *unused)
-{
-        if (code == SYS_DOWN || code == SYS_HALT)
-                txx9wdt_stop();
-        return NOTIFY_DONE;
-}
-
 static const struct file_operations txx9wdt_fops = {
         .owner          =       THIS_MODULE,
         .llseek         =       no_llseek,
@@ -189,10 +180,6 @@ static struct miscdevice txx9wdt_miscdev = {
         .fops   =       &txx9wdt_fops,
 };
 
-static struct notifier_block txx9wdt_notifier = {
-        .notifier_call = txx9wdt_notify_sys,
-};
-
 static int __init txx9wdt_probe(struct platform_device *dev)
 {
         struct resource *res;
@@ -221,13 +208,8 @@ static int __init txx9wdt_probe(struct platform_device *dev)
         if (!txx9wdt_reg)
                 goto exit_busy;
 
-        ret = register_reboot_notifier(&txx9wdt_notifier);
-        if (ret)
-                goto exit;
-
         ret = misc_register(&txx9wdt_miscdev);
         if (ret) {
-                unregister_reboot_notifier(&txx9wdt_notifier);
                 goto exit;
         }
 
@@ -249,14 +231,19 @@ exit:
 static int __exit txx9wdt_remove(struct platform_device *dev)
 {
         misc_deregister(&txx9wdt_miscdev);
-        unregister_reboot_notifier(&txx9wdt_notifier);
         clk_disable(txx9_imclk);
         clk_put(txx9_imclk);
         return 0;
 }
 
+static void txx9wdt_shutdown(struct platform_device *dev)
+{
+        txx9wdt_stop();
+}
+
 static struct platform_driver txx9wdt_driver = {
         .remove = __exit_p(txx9wdt_remove),
+        .shutdown = txx9wdt_shutdown,
         .driver = {
                 .name = "txx9wdt",
                 .owner = THIS_MODULE,
diff --git a/drivers/watchdog/w83627hf_wdt.c b/drivers/watchdog/w83627hf_wdt.c
index f201accc4e3d..0f5288df0091 100644
--- a/drivers/watchdog/w83627hf_wdt.c
+++ b/drivers/watchdog/w83627hf_wdt.c
@@ -201,7 +201,7 @@ static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
         int new_timeout;
-        static struct watchdog_info ident = {
+        static const struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
                                                         WDIOF_MAGICCLOSE,
                 .firmware_version = 1,
diff --git a/drivers/watchdog/w83977f_wdt.c b/drivers/watchdog/w83977f_wdt.c
index 0560182a1d09..6e6743d1066f 100644
--- a/drivers/watchdog/w83977f_wdt.c
+++ b/drivers/watchdog/w83977f_wdt.c
@@ -371,7 +371,7 @@ static ssize_t wdt_write(struct file *file, const char __user *buf,
  *      according to their available features.
  */
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE | WDIOF_KEEPALIVEPING,
         .firmware_version =     1,
         .identity = WATCHDOG_NAME,
diff --git a/drivers/watchdog/wdrtas.c b/drivers/watchdog/wdrtas.c
index 5bfb1f2c5319..94ec22b9e66b 100644
--- a/drivers/watchdog/wdrtas.c
+++ b/drivers/watchdog/wdrtas.c
@@ -312,7 +312,7 @@ static long wdrtas_ioctl(struct file *file, unsigned int cmd,
 {
         int __user *argp = (void __user *)arg;
         int i;
-        static struct watchdog_info wdinfo = {
+        static const struct watchdog_info wdinfo = {
                 .options = WDRTAS_SUPPORTED_MASK,
                 .firmware_version = 0,
                 .identity = "wdrtas",
diff --git a/drivers/watchdog/wdt.c b/drivers/watchdog/wdt.c
index 3bbefe9a2634..bfda2e99dd89 100644
--- a/drivers/watchdog/wdt.c
+++ b/drivers/watchdog/wdt.c
@@ -358,7 +358,7 @@ static long wdt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
         int new_heartbeat;
         int status;
 
-        static struct watchdog_info ident = {
+        struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT|
                                         WDIOF_MAGICCLOSE|
                                         WDIOF_KEEPALIVEPING,
diff --git a/drivers/watchdog/wdt_pci.c b/drivers/watchdog/wdt_pci.c
index f368dd87083a..7b22e3cdbc81 100644
--- a/drivers/watchdog/wdt_pci.c
+++ b/drivers/watchdog/wdt_pci.c
@@ -412,7 +412,7 @@ static long wdtpci_ioctl(struct file *file, unsigned int cmd,
         int new_heartbeat;
         int status;
 
-        static struct watchdog_info ident = {
+        struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT|
                                         WDIOF_MAGICCLOSE|
                                         WDIOF_KEEPALIVEPING,
diff --git a/drivers/watchdog/wm831x_wdt.c b/drivers/watchdog/wm831x_wdt.c
index 775bcd807f31..8c4b2d5bb7da 100644
--- a/drivers/watchdog/wm831x_wdt.c
+++ b/drivers/watchdog/wm831x_wdt.c
@@ -213,7 +213,7 @@ static ssize_t wm831x_wdt_write(struct file *file,
         return count;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
         .identity = "WM831x Watchdog",
 };
diff --git a/drivers/watchdog/wm8350_wdt.c b/drivers/watchdog/wm8350_wdt.c
index a2d2e8eb2282..89dd7b035295 100644
--- a/drivers/watchdog/wm8350_wdt.c
+++ b/drivers/watchdog/wm8350_wdt.c
@@ -177,7 +177,7 @@ static ssize_t wm8350_wdt_write(struct file *file,
         return count;
 }
 
-static struct watchdog_info ident = {
+static const struct watchdog_info ident = {
         .options = WDIOF_SETTIMEOUT | WDIOF_KEEPALIVEPING | WDIOF_MAGICCLOSE,
         .identity = "WM8350 Watchdog",
 };
diff --git a/drivers/xen/sys-hypervisor.c b/drivers/xen/sys-hypervisor.c
index ae5cb05a1a1c..bb71ab2336c8 100644
--- a/drivers/xen/sys-hypervisor.c
+++ b/drivers/xen/sys-hypervisor.c
@@ -426,7 +426,7 @@ static ssize_t hyp_sysfs_store(struct kobject *kobj,
         return 0;
 }
 
-static struct sysfs_ops hyp_sysfs_ops = {
+static const struct sysfs_ops hyp_sysfs_ops = {
         .show = hyp_sysfs_show,
         .store = hyp_sysfs_store,
 };