268 files changed, 16200 insertions, 3723 deletions

diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 88e42abf5d88..0df8fcb687d6 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -61,6 +61,7 @@ static int acpi_ac_open_fs(struct inode *inode, struct file *file);
 static int acpi_ac_add(struct acpi_device *device);
 static int acpi_ac_remove(struct acpi_device *device, int type);
 static int acpi_ac_resume(struct acpi_device *device);
+static void acpi_ac_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id ac_device_ids[] = {
         {"ACPI0003", 0},
@@ -72,10 +73,12 @@ static struct acpi_driver acpi_ac_driver = {
         .name = "ac",
         .class = ACPI_AC_CLASS,
         .ids = ac_device_ids,
+        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = acpi_ac_add,
                 .remove = acpi_ac_remove,
                 .resume = acpi_ac_resume,
+                .notify = acpi_ac_notify,
                 },
 };
 
@@ -220,16 +223,14 @@ static int acpi_ac_remove_fs(struct acpi_device *device)
                                    Driver Model
    -------------------------------------------------------------------------- */
 
-static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
+static void acpi_ac_notify(struct acpi_device *device, u32 event)
 {
-        struct acpi_ac *ac = data;
-        struct acpi_device *device = NULL;
+        struct acpi_ac *ac = acpi_driver_data(device);
 
 
         if (!ac)
                 return;
 
-        device = ac->device;
         switch (event) {
         default:
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -253,7 +254,6 @@ static void acpi_ac_notify(acpi_handle handle, u32 event, void *data)
 static int acpi_ac_add(struct acpi_device *device)
 {
         int result = 0;
-        acpi_status status = AE_OK;
         struct acpi_ac *ac = NULL;
 
 
@@ -286,13 +286,6 @@ static int acpi_ac_add(struct acpi_device *device)
         ac->charger.get_property = get_ac_property;
         power_supply_register(&ac->device->dev, &ac->charger);
 #endif
-        status = acpi_install_notify_handler(device->handle,
-                                             ACPI_ALL_NOTIFY, acpi_ac_notify,
-                                             ac);
-        if (ACPI_FAILURE(status)) {
-                result = -ENODEV;
-                goto end;
-        }
 
         printk(KERN_INFO PREFIX "%s [%s] (%s)\n",
                acpi_device_name(device), acpi_device_bid(device),
@@ -328,7 +321,6 @@ static int acpi_ac_resume(struct acpi_device *device)
 
 static int acpi_ac_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = AE_OK;
         struct acpi_ac *ac = NULL;
 
 
@@ -337,8 +329,6 @@ static int acpi_ac_remove(struct acpi_device *device, int type)
 
         ac = acpi_driver_data(device);
 
-        status = acpi_remove_notify_handler(device->handle,
-                                            ACPI_ALL_NOTIFY, acpi_ac_notify);
 #ifdef CONFIG_ACPI_SYSFS_POWER
         if (ac->charger.dev)
                 power_supply_unregister(&ac->charger);
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index b0de6312919a..58b4517ce712 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -796,13 +796,12 @@ static void acpi_battery_remove_fs(struct acpi_device *device)
                                  Driver Interface
    -------------------------------------------------------------------------- */
 
-static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
+static void acpi_battery_notify(struct acpi_device *device, u32 event)
 {
-        struct acpi_battery *battery = data;
-        struct acpi_device *device;
+        struct acpi_battery *battery = acpi_driver_data(device);
+
         if (!battery)
                 return;
-        device = battery->device;
         acpi_battery_update(battery);
         acpi_bus_generate_proc_event(device, event,
                                      acpi_battery_present(battery));
@@ -819,7 +818,6 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
 static int acpi_battery_add(struct acpi_device *device)
 {
         int result = 0;
-        acpi_status status = 0;
         struct acpi_battery *battery = NULL;
         if (!device)
                 return -EINVAL;
@@ -834,22 +832,12 @@ static int acpi_battery_add(struct acpi_device *device)
         acpi_battery_update(battery);
 #ifdef CONFIG_ACPI_PROCFS_POWER
         result = acpi_battery_add_fs(device);
-        if (result)
-                goto end;
 #endif
-        status = acpi_install_notify_handler(device->handle,
-                                             ACPI_ALL_NOTIFY,
-                                             acpi_battery_notify, battery);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "Installing notify handler"));
-                result = -ENODEV;
-                goto end;
-        }
-        printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
-               ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
-               device->status.battery_present ? "present" : "absent");
-      end:
-        if (result) {
+        if (!result) {
+                printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
+                        ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
+                        device->status.battery_present ? "present" : "absent");
+        } else {
 #ifdef CONFIG_ACPI_PROCFS_POWER
                 acpi_battery_remove_fs(device);
 #endif
@@ -860,15 +848,11 @@ static int acpi_battery_add(struct acpi_device *device)
 
 static int acpi_battery_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = 0;
         struct acpi_battery *battery = NULL;
 
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
         battery = acpi_driver_data(device);
-        status = acpi_remove_notify_handler(device->handle,
-                                            ACPI_ALL_NOTIFY,
-                                            acpi_battery_notify);
 #ifdef CONFIG_ACPI_PROCFS_POWER
         acpi_battery_remove_fs(device);
 #endif
@@ -896,10 +880,12 @@ static struct acpi_driver acpi_battery_driver = {
         .name = "battery",
         .class = ACPI_BATTERY_CLASS,
         .ids = battery_device_ids,
+        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = acpi_battery_add,
                 .resume = acpi_battery_resume,
                 .remove = acpi_battery_remove,
+                .notify = acpi_battery_notify,
                 },
 };
 
diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c
index 09c69806c1fc..f6baa77deefb 100644
--- a/drivers/acpi/blacklist.c
+++ b/drivers/acpi/blacklist.c
@@ -192,6 +192,22 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                      DMI_MATCH(DMI_PRODUCT_NAME, "ESPRIMO Mobile V5505"),
                 },
         },
+        {
+        .callback = dmi_disable_osi_vista,
+        .ident = "Sony VGN-NS10J_S",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NS10J_S"),
+                },
+        },
+        {
+        .callback = dmi_disable_osi_vista,
+        .ident = "Sony VGN-SR290J",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "Sony VGN-SR290J"),
+                },
+        },
 
         /*
          * BIOS invocation of _OSI(Linux) is almost always a BIOS bug.
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index ae862f1798dc..2876fc70c3a9 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -450,18 +450,16 @@ int acpi_bus_receive_event(struct acpi_bus_event *event)
                              Notification Handling
    -------------------------------------------------------------------------- */
 
-static int
-acpi_bus_check_device(struct acpi_device *device, int *status_changed)
+static void acpi_bus_check_device(acpi_handle handle)
 {
-        acpi_status status = 0;
+        struct acpi_device *device;
+        acpi_status status;
         struct acpi_device_status old_status;
 
-
+        if (acpi_bus_get_device(handle, &device))
+                return;
         if (!device)
-                return -EINVAL;
-
-        if (status_changed)
-                *status_changed = 0;
+                return;
 
         old_status = device->status;
 
@@ -471,22 +469,15 @@ acpi_bus_check_device(struct acpi_device *device, int *status_changed)
          */
         if (device->parent && !device->parent->status.present) {
                 device->status = device->parent->status;
-                if (STRUCT_TO_INT(old_status) != STRUCT_TO_INT(device->status)) {
-                        if (status_changed)
-                                *status_changed = 1;
-                }
-                return 0;
+                return;
         }
 
         status = acpi_bus_get_status(device);
         if (ACPI_FAILURE(status))
-                return -ENODEV;
+                return;
 
         if (STRUCT_TO_INT(old_status) == STRUCT_TO_INT(device->status))
-                return 0;
-
-        if (status_changed)
-                *status_changed = 1;
+                return;
 
         /*
          * Device Insertion/Removal
@@ -498,33 +489,17 @@ acpi_bus_check_device(struct acpi_device *device, int *status_changed)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device removal detected\n"));
                 /* TBD: Handle device removal */
         }
-
-        return 0;
 }
 
-static int acpi_bus_check_scope(struct acpi_device *device)
+static void acpi_bus_check_scope(acpi_handle handle)
 {
-        int result = 0;
-        int status_changed = 0;
-
-
-        if (!device)
-                return -EINVAL;
-
         /* Status Change? */
-        result = acpi_bus_check_device(device, &status_changed);
-        if (result)
-                return result;
-
-        if (!status_changed)
-                return 0;
+        acpi_bus_check_device(handle);
 
         /*
          * TBD: Enumerate child devices within this device's scope and
          *       run acpi_bus_check_device()'s on them.
          */
-
-        return 0;
 }
 
 static BLOCKING_NOTIFIER_HEAD(acpi_bus_notify_list);
@@ -547,22 +522,19 @@ EXPORT_SYMBOL_GPL(unregister_acpi_bus_notifier);
  */
 static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
 {
-        int result = 0;
         struct acpi_device *device = NULL;
+        struct acpi_driver *driver;
+
+        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Notification %#02x to handle %p\n",
+                          type, handle));
 
         blocking_notifier_call_chain(&acpi_bus_notify_list,
                 type, (void *)handle);
 
-        if (acpi_bus_get_device(handle, &device))
-                return;
-
         switch (type) {
 
         case ACPI_NOTIFY_BUS_CHECK:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received BUS CHECK notification for device [%s]\n",
-                                  device->pnp.bus_id));
-                result = acpi_bus_check_scope(device);
+                acpi_bus_check_scope(handle);
                 /*
                  * TBD: We'll need to outsource certain events to non-ACPI
                  *      drivers via the device manager (device.c).
@@ -570,10 +542,7 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
                 break;
 
         case ACPI_NOTIFY_DEVICE_CHECK:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received DEVICE CHECK notification for device [%s]\n",
-                                  device->pnp.bus_id));
-                result = acpi_bus_check_device(device, NULL);
+                acpi_bus_check_device(handle);
                 /*
                  * TBD: We'll need to outsource certain events to non-ACPI
                  *      drivers via the device manager (device.c).
@@ -581,44 +550,26 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
                 break;
 
         case ACPI_NOTIFY_DEVICE_WAKE:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received DEVICE WAKE notification for device [%s]\n",
-                                  device->pnp.bus_id));
                 /* TBD */
                 break;
 
         case ACPI_NOTIFY_EJECT_REQUEST:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received EJECT REQUEST notification for device [%s]\n",
-                                  device->pnp.bus_id));
                 /* TBD */
                 break;
 
         case ACPI_NOTIFY_DEVICE_CHECK_LIGHT:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received DEVICE CHECK LIGHT notification for device [%s]\n",
-                                  device->pnp.bus_id));
                 /* TBD: Exactly what does 'light' mean? */
                 break;
 
         case ACPI_NOTIFY_FREQUENCY_MISMATCH:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received FREQUENCY MISMATCH notification for device [%s]\n",
-                                  device->pnp.bus_id));
                 /* TBD */
                 break;
 
         case ACPI_NOTIFY_BUS_MODE_MISMATCH:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received BUS MODE MISMATCH notification for device [%s]\n",
-                                  device->pnp.bus_id));
                 /* TBD */
                 break;
 
         case ACPI_NOTIFY_POWER_FAULT:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Received POWER FAULT notification for device [%s]\n",
-                                  device->pnp.bus_id));
                 /* TBD */
                 break;
 
@@ -629,7 +580,13 @@ static void acpi_bus_notify(acpi_handle handle, u32 type, void *data)
                 break;
         }
 
-        return;
+        acpi_bus_get_device(handle, &device);
+        if (device) {
+                driver = device->driver;
+                if (driver && driver->ops.notify &&
+                    (driver->flags & ACPI_DRIVER_ALL_NOTIFY_EVENTS))
+                        driver->ops.notify(device, type);
+        }
 }
 
 /* --------------------------------------------------------------------------
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 8bd2c2a6884d..a8a5c29958c8 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -140,46 +140,6 @@ struct device *acpi_get_physical_device(acpi_handle handle)
 
 EXPORT_SYMBOL(acpi_get_physical_device);
 
-/* ToDo: When a PCI bridge is found, return the PCI device behind the bridge
- *       This should work in general, but did not on a Lenovo T61 for the
- *       graphics card. But this must be fixed when the PCI device is
- *       bound and the kernel device struct is attached to the acpi device
- * Note: A success call will increase reference count by one
- *       Do call put_device(dev) on the returned device then
- */
-struct device *acpi_get_physical_pci_device(acpi_handle handle)
-{
-        struct device *dev;
-        long long device_id;
-        acpi_status status;
-
-        status =
-                acpi_evaluate_integer(handle, "_ADR", NULL, &device_id);
-
-        if (ACPI_FAILURE(status))
-                return NULL;
-
-        /* We need to attempt to determine whether the _ADR refers to a
-           PCI device or not. There's no terribly good way to do this,
-           so the best we can hope for is to assume that there'll never
-           be a device in the host bridge */
-        if (device_id >= 0x10000) {
-                /* It looks like a PCI device. Does it exist? */
-                dev = acpi_get_physical_device(handle);
-        } else {
-                /* It doesn't look like a PCI device. Does its parent
-                   exist? */
-                acpi_handle phandle;
-                if (acpi_get_parent(handle, &phandle))
-                        return NULL;
-                dev = acpi_get_physical_device(phandle);
-        }
-        if (!dev)
-                return NULL;
-        return dev;
-}
-EXPORT_SYMBOL(acpi_get_physical_pci_device);
-
 static int acpi_bind_one(struct device *dev, acpi_handle handle)
 {
         struct acpi_device *acpi_dev;
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index d916bea729f1..71670719d61a 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -79,6 +79,7 @@ static acpi_osd_handler acpi_irq_handler;
 static void *acpi_irq_context;
 static struct workqueue_struct *kacpid_wq;
 static struct workqueue_struct *kacpi_notify_wq;
+static struct workqueue_struct *kacpi_hotplug_wq;
 
 struct acpi_res_list {
         resource_size_t start;
@@ -192,8 +193,10 @@ acpi_status acpi_os_initialize1(void)
 {
         kacpid_wq = create_singlethread_workqueue("kacpid");
         kacpi_notify_wq = create_singlethread_workqueue("kacpi_notify");
+        kacpi_hotplug_wq = create_singlethread_workqueue("kacpi_hotplug");
         BUG_ON(!kacpid_wq);
         BUG_ON(!kacpi_notify_wq);
+        BUG_ON(!kacpi_hotplug_wq);
         return AE_OK;
 }
 
@@ -206,6 +209,7 @@ acpi_status acpi_os_terminate(void)
 
         destroy_workqueue(kacpid_wq);
         destroy_workqueue(kacpi_notify_wq);
+        destroy_workqueue(kacpi_hotplug_wq);
 
         return AE_OK;
 }
@@ -716,6 +720,7 @@ static acpi_status __acpi_os_execute(acpi_execute_type type,
         acpi_status status = AE_OK;
         struct acpi_os_dpc *dpc;
         struct workqueue_struct *queue;
+        work_func_t func;
         int ret;
         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
                           "Scheduling function [%p(%p)] for deferred execution.\n",
@@ -740,15 +745,17 @@ static acpi_status __acpi_os_execute(acpi_execute_type type,
         dpc->function = function;
         dpc->context = context;
 
-        if (!hp) {
-                INIT_WORK(&dpc->work, acpi_os_execute_deferred);
-                queue = (type == OSL_NOTIFY_HANDLER) ?
-                        kacpi_notify_wq : kacpid_wq;
-                ret = queue_work(queue, &dpc->work);
-        } else {
-                INIT_WORK(&dpc->work, acpi_os_execute_hp_deferred);
-                ret = schedule_work(&dpc->work);
-        }
+        /*
+         * We can't run hotplug code in keventd_wq/kacpid_wq/kacpid_notify_wq
+         * because the hotplug code may call driver .remove() functions,
+         * which invoke flush_scheduled_work/acpi_os_wait_events_complete
+         * to flush these workqueues.
+         */
+        queue = hp ? kacpi_hotplug_wq :
+                (type == OSL_NOTIFY_HANDLER ? kacpi_notify_wq : kacpid_wq);
+        func = hp ? acpi_os_execute_hp_deferred : acpi_os_execute_deferred;
+        INIT_WORK(&dpc->work, func);
+        ret = queue_work(queue, &dpc->work);
 
         if (!ret) {
                 printk(KERN_ERR PREFIX
diff --git a/drivers/acpi/pci_bind.c b/drivers/acpi/pci_bind.c
index bc46de3d967f..a5a77b78a723 100644
--- a/drivers/acpi/pci_bind.c
+++ b/drivers/acpi/pci_bind.c
@@ -24,12 +24,7 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/init.h>
 #include <linux/types.h>
-#include <linux/proc_fs.h>
-#include <linux/spinlock.h>
-#include <linux/pm.h>
 #include <linux/pci.h>
 #include <linux/acpi.h>
 #include <acpi/acpi_bus.h>
@@ -38,310 +33,76 @@
 #define _COMPONENT              ACPI_PCI_COMPONENT
 ACPI_MODULE_NAME("pci_bind");
 
-struct acpi_pci_data {
-        struct acpi_pci_id id;
-        struct pci_bus *bus;
-        struct pci_dev *dev;
-};
-
-static int acpi_pci_unbind(struct acpi_device *device);
-
-static void acpi_pci_data_handler(acpi_handle handle, u32 function,
-                                  void *context)
-{
-
-        /* TBD: Anything we need to do here? */
-
-        return;
-}
-
-/**
- * acpi_get_pci_id
- * ------------------
- * This function is used by the ACPI Interpreter (a.k.a. Core Subsystem)
- * to resolve PCI information for ACPI-PCI devices defined in the namespace.
- * This typically occurs when resolving PCI operation region information.
- */
-acpi_status acpi_get_pci_id(acpi_handle handle, struct acpi_pci_id *id)
+static int acpi_pci_unbind(struct acpi_device *device)
 {
-        int result = 0;
-        acpi_status status = AE_OK;
-        struct acpi_device *device = NULL;
-        struct acpi_pci_data *data = NULL;
-
-
-        if (!id)
-                return AE_BAD_PARAMETER;
-
-        result = acpi_bus_get_device(handle, &device);
-        if (result) {
-                printk(KERN_ERR PREFIX
-                            "Invalid ACPI Bus context for device %s\n",
-                            acpi_device_bid(device));
-                return AE_NOT_EXIST;
-        }
-
-        status = acpi_get_data(handle, acpi_pci_data_handler, (void **)&data);
-        if (ACPI_FAILURE(status) || !data) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "Invalid ACPI-PCI context for device %s",
-                                acpi_device_bid(device)));
-                return status;
-        }
+        struct pci_dev *dev;
 
-        *id = data->id;
+        dev = acpi_get_pci_dev(device->handle);
+        if (!dev || !dev->subordinate)
+                goto out;
 
-        /*
-           id->segment = data->id.segment;
-           id->bus = data->id.bus;
-           id->device = data->id.device;
-           id->function = data->id.function;
-         */
+        acpi_pci_irq_del_prt(dev->subordinate);
 
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                          "Device %s has PCI address %04x:%02x:%02x.%d\n",
-                          acpi_device_bid(device), id->segment, id->bus,
-                          id->device, id->function));
+        device->ops.bind = NULL;
+        device->ops.unbind = NULL;
 
-        return AE_OK;
+out:
+        pci_dev_put(dev);
+        return 0;
 }
 
-EXPORT_SYMBOL(acpi_get_pci_id);
-
-int acpi_pci_bind(struct acpi_device *device)
+static int acpi_pci_bind(struct acpi_device *device)
 {
-        int result = 0;
         acpi_status status;
-        struct acpi_pci_data *data;
-        struct acpi_pci_data *pdata;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         acpi_handle handle;
+        struct pci_bus *bus;
+        struct pci_dev *dev;
 
-        if (!device || !device->parent)
-                return -EINVAL;
-
-        data = kzalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        status = acpi_get_name(device->handle, ACPI_FULL_PATHNAME, &buffer);
-        if (ACPI_FAILURE(status)) {
-                kfree(data);
-                return -ENODEV;
-        }
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Binding PCI device [%s]...\n",
-                          (char *)buffer.pointer));
-
-        /* 
-         * Segment & Bus
-         * -------------
-         * These are obtained via the parent device's ACPI-PCI context.
-         */
-        status = acpi_get_data(device->parent->handle, acpi_pci_data_handler,
-                               (void **)&pdata);
-        if (ACPI_FAILURE(status) || !pdata || !pdata->bus) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "Invalid ACPI-PCI context for parent device %s",
-                                acpi_device_bid(device->parent)));
-                result = -ENODEV;
-                goto end;
-        }
-        data->id.segment = pdata->id.segment;
-        data->id.bus = pdata->bus->number;
-
-        /*
-         * Device & Function
-         * -----------------
-         * These are simply obtained from the device's _ADR method.  Note
-         * that a value of zero is valid.
-         */
-        data->id.device = device->pnp.bus_address >> 16;
-        data->id.function = device->pnp.bus_address & 0xFFFF;
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "...to %04x:%02x:%02x.%d\n",
-                          data->id.segment, data->id.bus, data->id.device,
-                          data->id.function));
-
-        /*
-         * TBD: Support slot devices (e.g. function=0xFFFF).
-         */
-
-        /* 
-         * Locate PCI Device
-         * -----------------
-         * Locate matching device in PCI namespace.  If it doesn't exist
-         * this typically means that the device isn't currently inserted
-         * (e.g. docking station, port replicator, etc.).
-         */
-        data->dev = pci_get_slot(pdata->bus,
-                                PCI_DEVFN(data->id.device, data->id.function));
-        if (!data->dev) {
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Device %04x:%02x:%02x.%d not present in PCI namespace\n",
-                                  data->id.segment, data->id.bus,
-                                  data->id.device, data->id.function));
-                result = -ENODEV;
-                goto end;
-        }
-        if (!data->dev->bus) {
-                printk(KERN_ERR PREFIX
-                            "Device %04x:%02x:%02x.%d has invalid 'bus' field\n",
-                            data->id.segment, data->id.bus,
-                            data->id.device, data->id.function);
-                result = -ENODEV;
-                goto end;
-        }
+        dev = acpi_get_pci_dev(device->handle);
+        if (!dev)
+                return 0;
 
         /*
-         * PCI Bridge?
-         * -----------
-         * If so, set the 'bus' field and install the 'bind' function to 
-         * facilitate callbacks for all of its children.
+         * Install the 'bind' function to facilitate callbacks for
+         * children of the P2P bridge.
          */
-        if (data->dev->subordinate) {
+        if (dev->subordinate) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Device %04x:%02x:%02x.%d is a PCI bridge\n",
-                                  data->id.segment, data->id.bus,
-                                  data->id.device, data->id.function));
-                data->bus = data->dev->subordinate;
+                                  pci_domain_nr(dev->bus), dev->bus->number,
+                                  PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)));
                 device->ops.bind = acpi_pci_bind;
                 device->ops.unbind = acpi_pci_unbind;
         }
 
         /*
-         * Attach ACPI-PCI Context
-         * -----------------------
-         * Thus binding the ACPI and PCI devices.
-         */
-        status = acpi_attach_data(device->handle, acpi_pci_data_handler, data);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "Unable to attach ACPI-PCI context to device %s",
-                                acpi_device_bid(device)));
-                result = -ENODEV;
-                goto end;
-        }
-
-        /*
-         * PCI Routing Table
-         * -----------------
-         * Evaluate and parse _PRT, if exists.  This code is independent of 
-         * PCI bridges (above) to allow parsing of _PRT objects within the
-         * scope of non-bridge devices.  Note that _PRTs within the scope of
-         * a PCI bridge assume the bridge's subordinate bus number.
+         * Evaluate and parse _PRT, if exists.  This code allows parsing of
+         * _PRT objects within the scope of non-bridge devices.  Note that
+         * _PRTs within the scope of a PCI bridge assume the bridge's
+         * subordinate bus number.
          *
          * TBD: Can _PRTs exist within the scope of non-bridge PCI devices?
          */
         status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
-        if (ACPI_SUCCESS(status)) {
-                if (data->bus)  /* PCI-PCI bridge */
-                        acpi_pci_irq_add_prt(device->handle, data->id.segment,
-                                             data->bus->number);
-                else            /* non-bridge PCI device */
-                        acpi_pci_irq_add_prt(device->handle, data->id.segment,
-                                             data->id.bus);
-        }
-
-      end:
-        kfree(buffer.pointer);
-        if (result) {
-                pci_dev_put(data->dev);
-                kfree(data);
-        }
-        return result;
-}
-
-static int acpi_pci_unbind(struct acpi_device *device)
-{
-        int result = 0;
-        acpi_status status;
-        struct acpi_pci_data *data;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-
-
-        if (!device || !device->parent)
-                return -EINVAL;
-
-        status = acpi_get_name(device->handle, ACPI_FULL_PATHNAME, &buffer);
         if (ACPI_FAILURE(status))
-                return -ENODEV;
+                goto out;
 
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Unbinding PCI device [%s]...\n",
-                          (char *) buffer.pointer));
-        kfree(buffer.pointer);
+        if (dev->subordinate)
+                bus = dev->subordinate;
+        else
+                bus = dev->bus;
 
-        status =
-            acpi_get_data(device->handle, acpi_pci_data_handler,
-                          (void **)&data);
-        if (ACPI_FAILURE(status)) {
-                result = -ENODEV;
-                goto end;
-        }
+        acpi_pci_irq_add_prt(device->handle, bus);
 
-        status = acpi_detach_data(device->handle, acpi_pci_data_handler);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "Unable to detach data from device %s",
-                                acpi_device_bid(device)));
-                result = -ENODEV;
-                goto end;
-        }
-        if (data->dev->subordinate) {
-                acpi_pci_irq_del_prt(data->id.segment, data->bus->number);
-        }
-        pci_dev_put(data->dev);
-        kfree(data);
-
-      end:
-        return result;
+out:
+        pci_dev_put(dev);
+        return 0;
 }
 
-int
-acpi_pci_bind_root(struct acpi_device *device,
-                   struct acpi_pci_id *id, struct pci_bus *bus)
+int acpi_pci_bind_root(struct acpi_device *device)
 {
-        int result = 0;
-        acpi_status status;
-        struct acpi_pci_data *data = NULL;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-
-        if (!device || !id || !bus) {
-                return -EINVAL;
-        }
-
-        data = kzalloc(sizeof(struct acpi_pci_data), GFP_KERNEL);
-        if (!data)
-                return -ENOMEM;
-
-        data->id = *id;
-        data->bus = bus;
         device->ops.bind = acpi_pci_bind;
         device->ops.unbind = acpi_pci_unbind;
 
-        status = acpi_get_name(device->handle, ACPI_FULL_PATHNAME, &buffer);
-        if (ACPI_FAILURE(status)) {
-                kfree (data);
-                return -ENODEV;
-        }
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Binding PCI root bridge [%s] to "
-                        "%04x:%02x\n", (char *)buffer.pointer,
-                        id->segment, id->bus));
-
-        status = acpi_attach_data(device->handle, acpi_pci_data_handler, data);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "Unable to attach ACPI-PCI context to device %s",
-                                (char *)buffer.pointer));
-                result = -ENODEV;
-                goto end;
-        }
-
-      end:
-        kfree(buffer.pointer);
-        if (result != 0)
-                kfree(data);
-
-        return result;
+        return 0;
 }
diff --git a/drivers/acpi/pci_irq.c b/drivers/acpi/pci_irq.c
index 2faa9e2ac893..b794eb88ab90 100644
--- a/drivers/acpi/pci_irq.c
+++ b/drivers/acpi/pci_irq.c
@@ -182,7 +182,7 @@ static void do_prt_fixups(struct acpi_prt_entry *entry,
         }
 }
 
-static int acpi_pci_irq_add_entry(acpi_handle handle, int segment, int bus,
+static int acpi_pci_irq_add_entry(acpi_handle handle, struct pci_bus *bus,
                                   struct acpi_pci_routing_table *prt)
 {
         struct acpi_prt_entry *entry;
@@ -196,8 +196,8 @@ static int acpi_pci_irq_add_entry(acpi_handle handle, int segment, int bus,
          * 1=INTA, 2=INTB.  We use the PCI encoding throughout, so convert
          * it here.
          */
-        entry->id.segment = segment;
-        entry->id.bus = bus;
+        entry->id.segment = pci_domain_nr(bus);
+        entry->id.bus = bus->number;
         entry->id.device = (prt->address >> 16) & 0xFFFF;
         entry->pin = prt->pin + 1;
 
@@ -242,7 +242,7 @@ static int acpi_pci_irq_add_entry(acpi_handle handle, int segment, int bus,
         return 0;
 }
 
-int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
+int acpi_pci_irq_add_prt(acpi_handle handle, struct pci_bus *bus)
 {
         acpi_status status;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
@@ -271,7 +271,7 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
 
         entry = buffer.pointer;
         while (entry && (entry->length > 0)) {
-                acpi_pci_irq_add_entry(handle, segment, bus, entry);
+                acpi_pci_irq_add_entry(handle, bus, entry);
                 entry = (struct acpi_pci_routing_table *)
                     ((unsigned long)entry + entry->length);
         }
@@ -280,16 +280,17 @@ int acpi_pci_irq_add_prt(acpi_handle handle, int segment, int bus)
         return 0;
 }
 
-void acpi_pci_irq_del_prt(int segment, int bus)
+void acpi_pci_irq_del_prt(struct pci_bus *bus)
 {
         struct acpi_prt_entry *entry, *tmp;
 
         printk(KERN_DEBUG
                "ACPI: Delete PCI Interrupt Routing Table for %04x:%02x\n",
-               segment, bus);
+               pci_domain_nr(bus), bus->number);
         spin_lock(&acpi_prt_lock);
         list_for_each_entry_safe(entry, tmp, &acpi_prt_list, list) {
-                if (segment == entry->id.segment && bus == entry->id.bus) {
+                if (pci_domain_nr(bus) == entry->id.segment
+                        && bus->number == entry->id.bus) {
                         list_del(&entry->list);
                         kfree(entry);
                 }
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 196f97d00956..55b5b90c2a44 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -63,9 +63,10 @@ static struct acpi_driver acpi_pci_root_driver = {
 
 struct acpi_pci_root {
         struct list_head node;
-        struct acpi_device * device;
-        struct acpi_pci_id id;
+        struct acpi_device *device;
         struct pci_bus *bus;
+        u16 segment;
+        u8 bus_nr;
 
         u32 osc_support_set;    /* _OSC state of support bits */
         u32 osc_control_set;    /* _OSC state of control bits */
@@ -82,7 +83,7 @@ static DEFINE_MUTEX(osc_lock);
 int acpi_pci_register_driver(struct acpi_pci_driver *driver)
 {
         int n = 0;
-        struct list_head *entry;
+        struct acpi_pci_root *root;
 
         struct acpi_pci_driver **pptr = &sub_driver;
         while (*pptr)
@@ -92,9 +93,7 @@ int acpi_pci_register_driver(struct acpi_pci_driver *driver)
         if (!driver->add)
                 return 0;
 
-        list_for_each(entry, &acpi_pci_roots) {
-                struct acpi_pci_root *root;
-                root = list_entry(entry, struct acpi_pci_root, node);
+        list_for_each_entry(root, &acpi_pci_roots, node) {
                 driver->add(root->device->handle);
                 n++;
         }
@@ -106,7 +105,7 @@ EXPORT_SYMBOL(acpi_pci_register_driver);
 
 void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
 {
-        struct list_head *entry;
+        struct acpi_pci_root *root;
 
         struct acpi_pci_driver **pptr = &sub_driver;
         while (*pptr) {
@@ -120,28 +119,48 @@ void acpi_pci_unregister_driver(struct acpi_pci_driver *driver)
         if (!driver->remove)
                 return;
 
-        list_for_each(entry, &acpi_pci_roots) {
-                struct acpi_pci_root *root;
-                root = list_entry(entry, struct acpi_pci_root, node);
+        list_for_each_entry(root, &acpi_pci_roots, node)
                 driver->remove(root->device->handle);
-        }
 }
 
 EXPORT_SYMBOL(acpi_pci_unregister_driver);
 
 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int seg, unsigned int bus)
 {
-        struct acpi_pci_root *tmp;
+        struct acpi_pci_root *root;
         
-        list_for_each_entry(tmp, &acpi_pci_roots, node) {
-                if ((tmp->id.segment == (u16) seg) && (tmp->id.bus == (u16) bus))
-                        return tmp->device->handle;
-        }
+        list_for_each_entry(root, &acpi_pci_roots, node)
+                if ((root->segment == (u16) seg) && (root->bus_nr == (u16) bus))
+                        return root->device->handle;
         return NULL;            
 }
 
 EXPORT_SYMBOL_GPL(acpi_get_pci_rootbridge_handle);
 
+/**
+ * acpi_is_root_bridge - determine whether an ACPI CA node is a PCI root bridge
+ * @handle - the ACPI CA node in question.
+ *
+ * Note: we could make this API take a struct acpi_device * instead, but
+ * for now, it's more convenient to operate on an acpi_handle.
+ */
+int acpi_is_root_bridge(acpi_handle handle)
+{
+        int ret;
+        struct acpi_device *device;
+
+        ret = acpi_bus_get_device(handle, &device);
+        if (ret)
+                return 0;
+
+        ret = acpi_match_device_ids(device, root_device_ids);
+        if (ret)
+                return 0;
+        else
+                return 1;
+}
+EXPORT_SYMBOL_GPL(acpi_is_root_bridge);
+
 static acpi_status
 get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
 {
@@ -161,19 +180,22 @@ get_root_bridge_busnr_callback(struct acpi_resource *resource, void *data)
         return AE_OK;
 }
 
-static acpi_status try_get_root_bridge_busnr(acpi_handle handle, int *busnum)
+static acpi_status try_get_root_bridge_busnr(acpi_handle handle,
+                                             unsigned long long *bus)
 {
         acpi_status status;
+        int busnum;
 
-        *busnum = -1;
+        busnum = -1;
         status =
             acpi_walk_resources(handle, METHOD_NAME__CRS,
-                                get_root_bridge_busnr_callback, busnum);
+                                get_root_bridge_busnr_callback, &busnum);
         if (ACPI_FAILURE(status))
                 return status;
         /* Check if we really get a bus number from _CRS */
-        if (*busnum == -1)
+        if (busnum == -1)
                 return AE_ERROR;
+        *bus = busnum;
         return AE_OK;
 }
 
@@ -298,6 +320,7 @@ static acpi_status acpi_pci_osc_support(struct acpi_pci_root *root, u32 flags)
 static struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
 {
         struct acpi_pci_root *root;
+
         list_for_each_entry(root, &acpi_pci_roots, node) {
                 if (root->device->handle == handle)
                         return root;
@@ -305,6 +328,87 @@ static struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle)
         return NULL;
 }
 
+struct acpi_handle_node {
+        struct list_head node;
+        acpi_handle handle;
+};
+
+/**
+ * acpi_get_pci_dev - convert ACPI CA handle to struct pci_dev
+ * @handle: the handle in question
+ *
+ * Given an ACPI CA handle, the desired PCI device is located in the
+ * list of PCI devices.
+ *
+ * If the device is found, its reference count is increased and this
+ * function returns a pointer to its data structure.  The caller must
+ * decrement the reference count by calling pci_dev_put().
+ * If no device is found, %NULL is returned.
+ */
+struct pci_dev *acpi_get_pci_dev(acpi_handle handle)
+{
+        int dev, fn;
+        unsigned long long adr;
+        acpi_status status;
+        acpi_handle phandle;
+        struct pci_bus *pbus;
+        struct pci_dev *pdev = NULL;
+        struct acpi_handle_node *node, *tmp;
+        struct acpi_pci_root *root;
+        LIST_HEAD(device_list);
+
+        /*
+         * Walk up the ACPI CA namespace until we reach a PCI root bridge.
+         */
+        phandle = handle;
+        while (!acpi_is_root_bridge(phandle)) {
+                node = kzalloc(sizeof(struct acpi_handle_node), GFP_KERNEL);
+                if (!node)
+                        goto out;
+
+                INIT_LIST_HEAD(&node->node);
+                node->handle = phandle;
+                list_add(&node->node, &device_list);
+
+                status = acpi_get_parent(phandle, &phandle);
+                if (ACPI_FAILURE(status))
+                        goto out;
+        }
+
+        root = acpi_pci_find_root(phandle);
+        if (!root)
+                goto out;
+
+        pbus = root->bus;
+
+        /*
+         * Now, walk back down the PCI device tree until we return to our
+         * original handle. Assumes that everything between the PCI root
+         * bridge and the device we're looking for must be a P2P bridge.
+         */
+        list_for_each_entry(node, &device_list, node) {
+                acpi_handle hnd = node->handle;
+                status = acpi_evaluate_integer(hnd, "_ADR", NULL, &adr);
+                if (ACPI_FAILURE(status))
+                        goto out;
+                dev = (adr >> 16) & 0xffff;
+                fn  = adr & 0xffff;
+
+                pdev = pci_get_slot(pbus, PCI_DEVFN(dev, fn));
+                if (!pdev || hnd == handle)
+                        break;
+
+                pbus = pdev->subordinate;
+                pci_dev_put(pdev);
+        }
+out:
+        list_for_each_entry_safe(node, tmp, &device_list, node)
+                kfree(node);
+
+        return pdev;
+}
+EXPORT_SYMBOL_GPL(acpi_get_pci_dev);
+
 /**
  * acpi_pci_osc_control_set - commit requested control to Firmware
  * @handle: acpi_handle for the target ACPI object
@@ -363,31 +467,46 @@ EXPORT_SYMBOL(acpi_pci_osc_control_set);
 
 static int __devinit acpi_pci_root_add(struct acpi_device *device)
 {
-        int result = 0;
-        struct acpi_pci_root *root = NULL;
-        struct acpi_pci_root *tmp;
-        acpi_status status = AE_OK;
-        unsigned long long value = 0;
-        acpi_handle handle = NULL;
+        unsigned long long segment, bus;
+        acpi_status status;
+        int result;
+        struct acpi_pci_root *root;
+        acpi_handle handle;
         struct acpi_device *child;
         u32 flags, base_flags;
 
+        segment = 0;
+        status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
+                                       &segment);
+        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+                printk(KERN_ERR PREFIX "can't evaluate _SEG\n");
+                return -ENODEV;
+        }
 
-        if (!device)
-                return -EINVAL;
+        /* Check _CRS first, then _BBN.  If no _BBN, default to zero. */
+        bus = 0;
+        status = try_get_root_bridge_busnr(device->handle, &bus);
+        if (ACPI_FAILURE(status)) {
+                status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN,                                               NULL, &bus);
+                if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+                        printk(KERN_ERR PREFIX
+                             "no bus number in _CRS and can't evaluate _BBN\n");
+                        return -ENODEV;
+                }
+        }
 
         root = kzalloc(sizeof(struct acpi_pci_root), GFP_KERNEL);
         if (!root)
                 return -ENOMEM;
-        INIT_LIST_HEAD(&root->node);
 
+        INIT_LIST_HEAD(&root->node);
         root->device = device;
+        root->segment = segment & 0xFFFF;
+        root->bus_nr = bus & 0xFF;
         strcpy(acpi_device_name(device), ACPI_PCI_ROOT_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_PCI_ROOT_CLASS);
         device->driver_data = root;
 
-        device->ops.bind = acpi_pci_bind;
-
         /*
          * All supported architectures that use ACPI have support for
          * PCI domains, so we indicate this in _OSC support capabilities.
@@ -395,79 +514,6 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
         flags = base_flags = OSC_PCI_SEGMENT_GROUPS_SUPPORT;
         acpi_pci_osc_support(root, flags);
 
-        /* 
-         * Segment
-         * -------
-         * Obtained via _SEG, if exists, otherwise assumed to be zero (0).
-         */
-        status = acpi_evaluate_integer(device->handle, METHOD_NAME__SEG, NULL,
-                                       &value);
-        switch (status) {
-        case AE_OK:
-                root->id.segment = (u16) value;
-                break;
-        case AE_NOT_FOUND:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                  "Assuming segment 0 (no _SEG)\n"));
-                root->id.segment = 0;
-                break;
-        default:
-                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _SEG"));
-                result = -ENODEV;
-                goto end;
-        }
-
-        /* 
-         * Bus
-         * ---
-         * Obtained via _BBN, if exists, otherwise assumed to be zero (0).
-         */
-        status = acpi_evaluate_integer(device->handle, METHOD_NAME__BBN, NULL,
-                                       &value);
-        switch (status) {
-        case AE_OK:
-                root->id.bus = (u16) value;
-                break;
-        case AE_NOT_FOUND:
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Assuming bus 0 (no _BBN)\n"));
-                root->id.bus = 0;
-                break;
-        default:
-                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BBN"));
-                result = -ENODEV;
-                goto end;
-        }
-
-        /* Some systems have wrong _BBN */
-        list_for_each_entry(tmp, &acpi_pci_roots, node) {
-                if ((tmp->id.segment == root->id.segment)
-                    && (tmp->id.bus == root->id.bus)) {
-                        int bus = 0;
-                        acpi_status status;
-
-                        printk(KERN_ERR PREFIX
-                                    "Wrong _BBN value, reboot"
-                                    " and use option 'pci=noacpi'\n");
-
-                        status = try_get_root_bridge_busnr(device->handle, &bus);
-                        if (ACPI_FAILURE(status))
-                                break;
-                        if (bus != root->id.bus) {
-                                printk(KERN_INFO PREFIX
-                                       "PCI _CRS %d overrides _BBN 0\n", bus);
-                                root->id.bus = bus;
-                        }
-                        break;
-                }
-        }
-        /*
-         * Device & Function
-         * -----------------
-         * Obtained from _ADR (which has already been evaluated for us).
-         */
-        root->id.device = device->pnp.bus_address >> 16;
-        root->id.function = device->pnp.bus_address & 0xFFFF;
-
         /*
          * TBD: Need PCI interface for enumeration/configuration of roots.
          */
@@ -477,7 +523,7 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
 
         printk(KERN_INFO PREFIX "%s [%s] (%04x:%02x)\n",
                acpi_device_name(device), acpi_device_bid(device),
-               root->id.segment, root->id.bus);
+               root->segment, root->bus_nr);
 
         /*
          * Scan the Root Bridge
@@ -486,11 +532,11 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
          * PCI namespace does not get created until this call is made (and 
          * thus the root bridge's pci_dev does not exist).
          */
-        root->bus = pci_acpi_scan_root(device, root->id.segment, root->id.bus);
+        root->bus = pci_acpi_scan_root(device, segment, bus);
         if (!root->bus) {
                 printk(KERN_ERR PREFIX
                             "Bus %04x:%02x not present in PCI namespace\n",
-                            root->id.segment, root->id.bus);
+                            root->segment, root->bus_nr);
                 result = -ENODEV;
                 goto end;
         }
@@ -500,7 +546,7 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
          * -----------------------
          * Thus binding the ACPI and PCI devices.
          */
-        result = acpi_pci_bind_root(device, &root->id, root->bus);
+        result = acpi_pci_bind_root(device);
         if (result)
                 goto end;
 
@@ -511,8 +557,7 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
          */
         status = acpi_get_handle(device->handle, METHOD_NAME__PRT, &handle);
         if (ACPI_SUCCESS(status))
-                result = acpi_pci_irq_add_prt(device->handle, root->id.segment,
-                                              root->id.bus);
+                result = acpi_pci_irq_add_prt(device->handle, root->bus);
 
         /*
          * Scan and bind all _ADR-Based Devices
@@ -531,42 +576,28 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
         if (flags != base_flags)
                 acpi_pci_osc_support(root, flags);
 
-      end:
-        if (result) {
-                if (!list_empty(&root->node))
-                        list_del(&root->node);
-                kfree(root);
-        }
+        return 0;
 
+end:
+        if (!list_empty(&root->node))
+                list_del(&root->node);
+        kfree(root);
         return result;
 }
 
 static int acpi_pci_root_start(struct acpi_device *device)
 {
-        struct acpi_pci_root *root;
+        struct acpi_pci_root *root = acpi_driver_data(device);
 
-
-        list_for_each_entry(root, &acpi_pci_roots, node) {
-                if (root->device == device) {
-                        pci_bus_add_devices(root->bus);
-                        return 0;
-                }
-        }
-        return -ENODEV;
+        pci_bus_add_devices(root->bus);
+        return 0;
 }
 
 static int acpi_pci_root_remove(struct acpi_device *device, int type)
 {
-        struct acpi_pci_root *root = NULL;
-
-
-        if (!device || !acpi_driver_data(device))
-                return -EINVAL;
-
-        root = acpi_driver_data(device);
+        struct acpi_pci_root *root = acpi_driver_data(device);
 
         kfree(root);
-
         return 0;
 }
 
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 56665a63bf19..d74365d4a6e7 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -194,7 +194,7 @@ static int acpi_power_get_list_state(struct acpi_handle_list *list, int *state)
 
 static int acpi_power_on(acpi_handle handle, struct acpi_device *dev)
 {
-        int result = 0, state;
+        int result = 0;
         int found = 0;
         acpi_status status = AE_OK;
         struct acpi_power_resource *resource = NULL;
@@ -236,18 +236,6 @@ static int acpi_power_on(acpi_handle handle, struct acpi_device *dev)
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
-        if (!acpi_power_nocheck) {
-                /*
-                 * If acpi_power_nocheck is set, it is unnecessary to check
-                 * the power state after power transition.
-                 */
-                result = acpi_power_get_state(resource->device->handle,
-                                &state);
-                if (result)
-                        return result;
-                if (state != ACPI_POWER_RESOURCE_STATE_ON)
-                        return -ENOEXEC;
-        }
         /* Update the power resource's _device_ power state */
         resource->device->power.state = ACPI_STATE_D0;
 
@@ -258,7 +246,7 @@ static int acpi_power_on(acpi_handle handle, struct acpi_device *dev)
 
 static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
 {
-        int result = 0, state;
+        int result = 0;
         acpi_status status = AE_OK;
         struct acpi_power_resource *resource = NULL;
         struct list_head *node, *next;
@@ -293,18 +281,6 @@ static int acpi_power_off_device(acpi_handle handle, struct acpi_device *dev)
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
-        if (!acpi_power_nocheck) {
-                /*
-                 * If acpi_power_nocheck is set, it is unnecessary to check
-                 * the power state after power transition.
-                 */
-                result = acpi_power_get_state(handle, &state);
-                if (result)
-                        return result;
-                if (state != ACPI_POWER_RESOURCE_STATE_OFF)
-                        return -ENOEXEC;
-        }
-
         /* Update the power resource's _device_ power state */
         resource->device->power.state = ACPI_STATE_D3;
 
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 23f0fb84f1c1..84e0f3c07442 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -89,7 +89,7 @@ static int acpi_processor_handle_eject(struct acpi_processor *pr);
 
 static const struct acpi_device_id processor_device_ids[] = {
         {ACPI_PROCESSOR_OBJECT_HID, 0},
-        {ACPI_PROCESSOR_HID, 0},
+        {"ACPI0007", 0},
         {"", 0},
 };
 MODULE_DEVICE_TABLE(acpi, processor_device_ids);
@@ -596,7 +596,21 @@ static int acpi_processor_get_info(struct acpi_device *device)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "No bus mastering arbitration control\n"));
 
-        if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_HID)) {
+        if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) {
+                /* Declared with "Processor" statement; match ProcessorID */
+                status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
+                if (ACPI_FAILURE(status)) {
+                        printk(KERN_ERR PREFIX "Evaluating processor object\n");
+                        return -ENODEV;
+                }
+
+                /*
+                 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
+                 *      >>> 'acpi_get_processor_id(acpi_id, &id)' in
+                 *      arch/xxx/acpi.c
+                 */
+                pr->acpi_id = object.processor.proc_id;
+        } else {
                 /*
                  * Declared with "Device" statement; match _UID.
                  * Note that we don't handle string _UIDs yet.
@@ -611,20 +625,6 @@ static int acpi_processor_get_info(struct acpi_device *device)
                 }
                 device_declaration = 1;
                 pr->acpi_id = value;
-        } else {
-                /* Declared with "Processor" statement; match ProcessorID */
-                status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer);
-                if (ACPI_FAILURE(status)) {
-                        printk(KERN_ERR PREFIX "Evaluating processor object\n");
-                        return -ENODEV;
-                }
-
-                /*
-                 * TBD: Synch processor ID (via LAPIC/LSAPIC structures) on SMP.
-                 *      >>> 'acpi_get_processor_id(acpi_id, &id)' in
-                 *      arch/xxx/acpi.c
-                 */
-                pr->acpi_id = object.processor.proc_id;
         }
         cpu_index = get_cpu_id(pr->handle, device_declaration, pr->acpi_id);
 
@@ -649,7 +649,16 @@ static int acpi_processor_get_info(struct acpi_device *device)
                         return -ENODEV;
                 }
         }
-
+        /*
+         * On some boxes several processors use the same processor bus id.
+         * But they are located in different scope. For example:
+         * \_SB.SCK0.CPU0
+         * \_SB.SCK1.CPU0
+         * Rename the processor device bus id. And the new bus id will be
+         * generated as the following format:
+         * CPU+CPU ID.
+         */
+        sprintf(acpi_device_bid(device), "CPU%X", pr->id);
         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id,
                           pr->acpi_id));
 
@@ -731,6 +740,8 @@ static int __cpuinit acpi_processor_start(struct acpi_device *device)
         /* _PDC call should be done before doing anything else (if reqd.). */
         arch_acpi_processor_init_pdc(pr);
         acpi_processor_set_pdc(pr);
+        arch_acpi_processor_cleanup_pdc(pr);
+
 #ifdef CONFIG_CPU_FREQ
         acpi_processor_ppc_has_changed(pr);
 #endif
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 10a2d913635a..0efa59e7e3af 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -139,7 +139,7 @@ static void acpi_safe_halt(void)
  * are affected too. We pick the most conservative approach: we assume
  * that the local APIC stops in both C2 and C3.
  */
-static void acpi_timer_check_state(int state, struct acpi_processor *pr,
+static void lapic_timer_check_state(int state, struct acpi_processor *pr,
                                    struct acpi_processor_cx *cx)
 {
         struct acpi_processor_power *pwr = &pr->power;
@@ -162,7 +162,7 @@ static void acpi_timer_check_state(int state, struct acpi_processor *pr,
                 pr->power.timer_broadcast_on_state = state;
 }
 
-static void acpi_propagate_timer_broadcast(struct acpi_processor *pr)
+static void lapic_timer_propagate_broadcast(struct acpi_processor *pr)
 {
         unsigned long reason;
 
@@ -173,7 +173,7 @@ static void acpi_propagate_timer_broadcast(struct acpi_processor *pr)
 }
 
 /* Power(C) State timer broadcast control */
-static void acpi_state_timer_broadcast(struct acpi_processor *pr,
+static void lapic_timer_state_broadcast(struct acpi_processor *pr,
                                        struct acpi_processor_cx *cx,
                                        int broadcast)
 {
@@ -190,10 +190,10 @@ static void acpi_state_timer_broadcast(struct acpi_processor *pr,
 
 #else
 
-static void acpi_timer_check_state(int state, struct acpi_processor *pr,
+static void lapic_timer_check_state(int state, struct acpi_processor *pr,
                                    struct acpi_processor_cx *cstate) { }
-static void acpi_propagate_timer_broadcast(struct acpi_processor *pr) { }
-static void acpi_state_timer_broadcast(struct acpi_processor *pr,
+static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
+static void lapic_timer_state_broadcast(struct acpi_processor *pr,
                                        struct acpi_processor_cx *cx,
                                        int broadcast)
 {
@@ -515,7 +515,8 @@ static void acpi_processor_power_verify_c2(struct acpi_processor_cx *cx)
 static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
                                            struct acpi_processor_cx *cx)
 {
-        static int bm_check_flag;
+        static int bm_check_flag = -1;
+        static int bm_control_flag = -1;
 
 
         if (!cx->address)
@@ -545,12 +546,14 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
         }
 
         /* All the logic here assumes flags.bm_check is same across all CPUs */
-        if (!bm_check_flag) {
+        if (bm_check_flag == -1) {
                 /* Determine whether bm_check is needed based on CPU  */
                 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
                 bm_check_flag = pr->flags.bm_check;
+                bm_control_flag = pr->flags.bm_control;
         } else {
                 pr->flags.bm_check = bm_check_flag;
+                pr->flags.bm_control = bm_control_flag;
         }
 
         if (pr->flags.bm_check) {
@@ -614,29 +617,25 @@ static int acpi_processor_power_verify(struct acpi_processor *pr)
                 switch (cx->type) {
                 case ACPI_STATE_C1:
                         cx->valid = 1;
-                        acpi_timer_check_state(i, pr, cx);
                         break;
 
                 case ACPI_STATE_C2:
                         acpi_processor_power_verify_c2(cx);
-                        if (cx->valid)
-                                acpi_timer_check_state(i, pr, cx);
                         break;
 
                 case ACPI_STATE_C3:
                         acpi_processor_power_verify_c3(pr, cx);
-                        if (cx->valid)
-                                acpi_timer_check_state(i, pr, cx);
                         break;
                 }
-                if (cx->valid)
-                        tsc_check_state(cx->type);
+                if (!cx->valid)
+                        continue;
 
-                if (cx->valid)
-                        working++;
+                lapic_timer_check_state(i, pr, cx);
+                tsc_check_state(cx->type);
+                working++;
         }
 
-        acpi_propagate_timer_broadcast(pr);
+        lapic_timer_propagate_broadcast(pr);
 
         return (working);
 }
@@ -839,7 +838,7 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev,
                 return 0;
         }
 
-        acpi_state_timer_broadcast(pr, cx, 1);
+        lapic_timer_state_broadcast(pr, cx, 1);
         kt1 = ktime_get_real();
         acpi_idle_do_entry(cx);
         kt2 = ktime_get_real();
@@ -847,7 +846,7 @@ static int acpi_idle_enter_c1(struct cpuidle_device *dev,
 
         local_irq_enable();
         cx->usage++;
-        acpi_state_timer_broadcast(pr, cx, 0);
+        lapic_timer_state_broadcast(pr, cx, 0);
 
         return idle_time;
 }
@@ -892,7 +891,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
          * Must be done before busmaster disable as we might need to
          * access HPET !
          */
-        acpi_state_timer_broadcast(pr, cx, 1);
+        lapic_timer_state_broadcast(pr, cx, 1);
 
         if (cx->type == ACPI_STATE_C3)
                 ACPI_FLUSH_CPU_CACHE();
@@ -914,7 +913,7 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
 
         cx->usage++;
 
-        acpi_state_timer_broadcast(pr, cx, 0);
+        lapic_timer_state_broadcast(pr, cx, 0);
         cx->time += sleep_ticks;
         return idle_time;
 }
@@ -981,7 +980,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
          * Must be done before busmaster disable as we might need to
          * access HPET !
          */
-        acpi_state_timer_broadcast(pr, cx, 1);
+        lapic_timer_state_broadcast(pr, cx, 1);
 
         kt1 = ktime_get_real();
         /*
@@ -1026,7 +1025,7 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
 
         cx->usage++;
 
-        acpi_state_timer_broadcast(pr, cx, 0);
+        lapic_timer_state_broadcast(pr, cx, 0);
         cx->time += sleep_ticks;
         return idle_time;
 }
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index 8ff510b91d88..781435d7e369 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -95,7 +95,7 @@ acpi_device_modalias_show(struct device *dev, struct device_attribute *attr, cha
 }
 static DEVICE_ATTR(modalias, 0444, acpi_device_modalias_show, NULL);
 
-static int acpi_bus_hot_remove_device(void *context)
+static void acpi_bus_hot_remove_device(void *context)
 {
         struct acpi_device *device;
         acpi_handle handle = context;
@@ -104,10 +104,10 @@ static int acpi_bus_hot_remove_device(void *context)
         acpi_status status = AE_OK;
 
         if (acpi_bus_get_device(handle, &device))
-                return 0;
+                return;
 
         if (!device)
-                return 0;
+                return;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                 "Hot-removing device %s...\n", dev_name(&device->dev)));
@@ -115,7 +115,7 @@ static int acpi_bus_hot_remove_device(void *context)
         if (acpi_bus_trim(device, 1)) {
                 printk(KERN_ERR PREFIX
                                 "Removing device failed\n");
-                return -1;
+                return;
         }
 
         /* power off device */
@@ -142,9 +142,10 @@ static int acpi_bus_hot_remove_device(void *context)
          */
         status = acpi_evaluate_object(handle, "_EJ0", &arg_list, NULL);
         if (ACPI_FAILURE(status))
-                return -ENODEV;
+                printk(KERN_WARNING PREFIX
+                                "Eject device failed\n");
 
-        return 0;
+        return;
 }
 
 static ssize_t
@@ -155,7 +156,6 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
         acpi_status status;
         acpi_object_type type = 0;
         struct acpi_device *acpi_device = to_acpi_device(d);
-        struct task_struct *task;
 
         if ((!count) || (buf[0] != '1')) {
                 return -EINVAL;
@@ -172,11 +172,7 @@ acpi_eject_store(struct device *d, struct device_attribute *attr,
                 goto err;
         }
 
-        /* remove the device in another thread to fix the deadlock issue */
-        task = kthread_run(acpi_bus_hot_remove_device,
-                                acpi_device->handle, "acpi_hot_remove_device");
-        if (IS_ERR(task))
-                ret = PTR_ERR(task);
+        acpi_os_hotplug_execute(acpi_bus_hot_remove_device, acpi_device->handle);
 err:
         return ret;
 }
@@ -198,12 +194,12 @@ acpi_device_path_show(struct device *dev, struct device_attribute *attr, char *b
         int result;
 
         result = acpi_get_name(acpi_dev->handle, ACPI_FULL_PATHNAME, &path);
-        if(result)
+        if (result)
                 goto end;
 
         result = sprintf(buf, "%s\n", (char*)path.pointer);
         kfree(path.pointer);
-  end:
+end:
         return result;
 }
 static DEVICE_ATTR(path, 0444, acpi_device_path_show, NULL);
@@ -217,21 +213,21 @@ static int acpi_device_setup_files(struct acpi_device *dev)
         /*
          * Devices gotten from FADT don't have a "path" attribute
          */
-        if(dev->handle) {
+        if (dev->handle) {
                 result = device_create_file(&dev->dev, &dev_attr_path);
-                if(result)
+                if (result)
                         goto end;
         }
 
-        if(dev->flags.hardware_id) {
+        if (dev->flags.hardware_id) {
                 result = device_create_file(&dev->dev, &dev_attr_hid);
-                if(result)
+                if (result)
                         goto end;
         }
 
-        if (dev->flags.hardware_id || dev->flags.compatible_ids){
+        if (dev->flags.hardware_id || dev->flags.compatible_ids) {
                 result = device_create_file(&dev->dev, &dev_attr_modalias);
-                if(result)
+                if (result)
                         goto end;
         }
 
@@ -242,7 +238,7 @@ static int acpi_device_setup_files(struct acpi_device *dev)
         status = acpi_get_handle(dev->handle, "_EJ0", &temp);
         if (ACPI_SUCCESS(status))
                 result = device_create_file(&dev->dev, &dev_attr_eject);
-  end:
+end:
         return result;
 }
 
@@ -262,9 +258,9 @@ static void acpi_device_remove_files(struct acpi_device *dev)
         if (dev->flags.hardware_id || dev->flags.compatible_ids)
                 device_remove_file(&dev->dev, &dev_attr_modalias);
 
-        if(dev->flags.hardware_id)
+        if (dev->flags.hardware_id)
                 device_remove_file(&dev->dev, &dev_attr_hid);
-        if(dev->handle)
+        if (dev->handle)
                 device_remove_file(&dev->dev, &dev_attr_path);
 }
 /* --------------------------------------------------------------------------
@@ -512,7 +508,7 @@ static int acpi_device_register(struct acpi_device *device,
                         break;
                 }
         }
-        if(!found) {
+        if (!found) {
                 acpi_device_bus_id = new_bus_id;
                 strcpy(acpi_device_bus_id->bus_id, device->flags.hardware_id ? device->pnp.hardware_id : "device");
                 acpi_device_bus_id->instance_no = 0;
@@ -530,22 +526,21 @@ static int acpi_device_register(struct acpi_device *device,
         if (device->parent)
                 device->dev.parent = &parent->dev;
         device->dev.bus = &acpi_bus_type;
-        device_initialize(&device->dev);
         device->dev.release = &acpi_device_release;
-        result = device_add(&device->dev);
-        if(result) {
-                dev_err(&device->dev, "Error adding device\n");
+        result = device_register(&device->dev);
+        if (result) {
+                dev_err(&device->dev, "Error registering device\n");
                 goto end;
         }
 
         result = acpi_device_setup_files(device);
-        if(result)
+        if (result)
                 printk(KERN_ERR PREFIX "Error creating sysfs interface for device %s\n",
                        dev_name(&device->dev));
 
         device->removal_type = ACPI_BUS_REMOVAL_NORMAL;
         return 0;
-  end:
+end:
         mutex_lock(&acpi_device_lock);
         if (device->parent)
                 list_del(&device->node);
@@ -577,7 +572,7 @@ static void acpi_device_unregister(struct acpi_device *device, int type)
  * @device: the device to add and initialize
  * @driver: driver for the device
  *
- * Used to initialize a device via its device driver.  Called whenever a 
+ * Used to initialize a device via its device driver.  Called whenever a
  * driver is bound to a device.  Invokes the driver's add() ops.
  */
 static int
@@ -585,7 +580,6 @@ acpi_bus_driver_init(struct acpi_device *device, struct acpi_driver *driver)
 {
         int result = 0;
 
-
         if (!device || !driver)
                 return -EINVAL;
 
@@ -802,7 +796,7 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
         if (!acpi_match_device_ids(device, button_device_ids))
                 device->wakeup.flags.run_wake = 1;
 
-      end:
+end:
         if (ACPI_FAILURE(status))
                 device->flags.wake_capable = 0;
         return 0;
@@ -1070,7 +1064,7 @@ static void acpi_device_set_id(struct acpi_device *device,
                 break;
         }
 
-        /* 
+        /*
          * \_SB
          * ----
          * Fix for the system root bus device -- the only root-level device.
@@ -1320,7 +1314,7 @@ acpi_add_single_object(struct acpi_device **child,
                         device->parent->ops.bind(device);
         }
 
-      end:
+end:
         if (!result)
                 *child = device;
         else {
@@ -1464,7 +1458,6 @@ acpi_bus_add(struct acpi_device **child,
 
         return result;
 }
-
 EXPORT_SYMBOL(acpi_bus_add);
 
 int acpi_bus_start(struct acpi_device *device)
@@ -1484,7 +1477,6 @@ int acpi_bus_start(struct acpi_device *device)
         }
         return result;
 }
-
 EXPORT_SYMBOL(acpi_bus_start);
 
 int acpi_bus_trim(struct acpi_device *start, int rmdevice)
@@ -1542,7 +1534,6 @@ int acpi_bus_trim(struct acpi_device *start, int rmdevice)
 }
 EXPORT_SYMBOL_GPL(acpi_bus_trim);
 
-
 static int acpi_bus_scan_fixed(struct acpi_device *root)
 {
         int result = 0;
@@ -1610,6 +1601,6 @@ int __init acpi_scan_init(void)
         if (result)
                 acpi_device_unregister(acpi_root, ACPI_BUS_REMOVAL_NORMAL);
 
-      Done:
+Done:
         return result;
 }
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 1bdfb37377e3..8851315ce858 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -76,6 +76,7 @@ MODULE_LICENSE("GPL");
 static int brightness_switch_enabled = 1;
 module_param(brightness_switch_enabled, bool, 0644);
 
+static int register_count = 0;
 static int acpi_video_bus_add(struct acpi_device *device);
 static int acpi_video_bus_remove(struct acpi_device *device, int type);
 static int acpi_video_resume(struct acpi_device *device);
@@ -586,6 +587,14 @@ static struct dmi_system_id video_dmi_table[] __initdata = {
                 DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 5315"),
                 },
         },
+        {
+         .callback = video_set_bqc_offset,
+         .ident = "Acer Aspire 7720",
+         .matches = {
+                DMI_MATCH(DMI_BOARD_VENDOR, "Acer"),
+                DMI_MATCH(DMI_PRODUCT_NAME, "Aspire 7720"),
+                },
+        },
         {}
 };
 
@@ -976,6 +985,11 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 device->backlight->props.max_brightness = device->brightness->count-3;
                 kfree(name);
 
+                result = sysfs_create_link(&device->backlight->dev.kobj,
+                                           &device->dev->dev.kobj, "device");
+                if (result)
+                        printk(KERN_ERR PREFIX "Create sysfs link\n");
+
                 device->cdev = thermal_cooling_device_register("LCD",
                                         device->dev, &video_cooling_ops);
                 if (IS_ERR(device->cdev))
@@ -1054,15 +1068,15 @@ static void acpi_video_bus_find_cap(struct acpi_video_bus *video)
 static int acpi_video_bus_check(struct acpi_video_bus *video)
 {
         acpi_status status = -ENOENT;
-        struct device *dev;
+        struct pci_dev *dev;
 
         if (!video)
                 return -EINVAL;
 
-        dev = acpi_get_physical_pci_device(video->device->handle);
+        dev = acpi_get_pci_dev(video->device->handle);
         if (!dev)
                 return -ENODEV;
-        put_device(dev);
+        pci_dev_put(dev);
 
         /* Since there is no HID, CID and so on for VGA driver, we have
          * to check well known required nodes.
@@ -1990,6 +2004,7 @@ static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
         status = acpi_remove_notify_handler(device->dev->handle,
                                             ACPI_DEVICE_NOTIFY,
                                             acpi_video_device_notify);
+        sysfs_remove_link(&device->backlight->dev.kobj, "device");
         backlight_device_unregister(device->backlight);
         if (device->cdev) {
                 sysfs_remove_link(&device->dev->dev.kobj,
@@ -2318,6 +2333,13 @@ static int __init intel_opregion_present(void)
 int acpi_video_register(void)
 {
         int result = 0;
+        if (register_count) {
+                /*
+                 * if the function of acpi_video_register is already called,
+                 * don't register the acpi_vide_bus again and return no error.
+                 */
+                return 0;
+        }
 
         acpi_video_dir = proc_mkdir(ACPI_VIDEO_CLASS, acpi_root_dir);
         if (!acpi_video_dir)
@@ -2329,10 +2351,35 @@ int acpi_video_register(void)
                 return -ENODEV;
         }
 
+        /*
+         * When the acpi_video_bus is loaded successfully, increase
+         * the counter reference.
+         */
+        register_count = 1;
+
         return 0;
 }
 EXPORT_SYMBOL(acpi_video_register);
 
+void acpi_video_unregister(void)
+{
+        if (!register_count) {
+                /*
+                 * If the acpi video bus is already unloaded, don't
+                 * unload it again and return directly.
+                 */
+                return;
+        }
+        acpi_bus_unregister_driver(&acpi_video_bus);
+
+        remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
+
+        register_count = 0;
+
+        return;
+}
+EXPORT_SYMBOL(acpi_video_unregister);
+
 /*
  * This is kind of nasty. Hardware using Intel chipsets may require
  * the video opregion code to be run first in order to initialise
@@ -2350,16 +2397,12 @@ static int __init acpi_video_init(void)
         return acpi_video_register();
 }
 
-void acpi_video_exit(void)
+static void __exit acpi_video_exit(void)
 {
-
-        acpi_bus_unregister_driver(&acpi_video_bus);
-
-        remove_proc_entry(ACPI_VIDEO_CLASS, acpi_root_dir);
+        acpi_video_unregister();
 
         return;
 }
-EXPORT_SYMBOL(acpi_video_exit);
 
 module_init(acpi_video_init);
 module_exit(acpi_video_exit);
diff --git a/drivers/acpi/video_detect.c b/drivers/acpi/video_detect.c
index 09737275e25f..7cd2b63435ea 100644
--- a/drivers/acpi/video_detect.c
+++ b/drivers/acpi/video_detect.c
@@ -10,7 +10,7 @@
  * assinged
  *
  * After PCI devices are glued with ACPI devices
- * acpi_get_physical_pci_device() can be called to identify ACPI graphics
+ * acpi_get_pci_dev() can be called to identify ACPI graphics
  * devices for which a real graphics card is plugged in
  *
  * Now acpi_video_get_capabilities() can be called to check which
@@ -36,6 +36,7 @@
 
 #include <linux/acpi.h>
 #include <linux/dmi.h>
+#include <linux/pci.h>
 
 ACPI_MODULE_NAME("video");
 #define _COMPONENT              ACPI_VIDEO_COMPONENT
@@ -109,7 +110,7 @@ static acpi_status
 find_video(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
         long *cap = context;
-        struct device *dev;
+        struct pci_dev *dev;
         struct acpi_device *acpi_dev;
 
         const struct acpi_device_id video_ids[] = {
@@ -120,10 +121,10 @@ find_video(acpi_handle handle, u32 lvl, void *context, void **rv)
                 return AE_OK;
 
         if (!acpi_match_device_ids(acpi_dev, video_ids)) {
-                dev = acpi_get_physical_pci_device(handle);
+                dev = acpi_get_pci_dev(handle);
                 if (!dev)
                         return AE_OK;
-                put_device(dev);
+                pci_dev_put(dev);
                 *cap |= acpi_is_video_device(acpi_dev);
         }
         return AE_OK;
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 2aa1908e5ce0..b17c57f85032 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -679,6 +679,14 @@ config PATA_PLATFORM
 
           If unsure, say N.
 
+config PATA_AT91
+        tristate "PATA support for AT91SAM9260"
+        depends on ARM && ARCH_AT91
+        help
+          This option enables support for IDE devices on the Atmel AT91SAM9260 SoC.
+
+          If unsure, say N.
+
 config PATA_OF_PLATFORM
         tristate "OpenFirmware platform device PATA support"
         depends on PATA_PLATFORM && PPC_OF
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 1558059874f0..38906f9bbb4e 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -72,6 +72,7 @@ obj-$(CONFIG_PATA_SCH)		+= pata_sch.o
 obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
 obj-$(CONFIG_PATA_OCTEON_CF)    += pata_octeon_cf.o
 obj-$(CONFIG_PATA_PLATFORM)     += pata_platform.o
+obj-$(CONFIG_PATA_AT91) += pata_at91.o
 obj-$(CONFIG_PATA_OF_PLATFORM)  += pata_of_platform.o
 obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
 # Should be last but two libata driver
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index ca4d208ddf3b..045a486a09ea 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -125,19 +125,19 @@ MODULE_PARM_DESC(force, "Force ATA configurations including cable type, link spe
 
 static int atapi_enabled = 1;
 module_param(atapi_enabled, int, 0444);
-MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on)");
+MODULE_PARM_DESC(atapi_enabled, "Enable discovery of ATAPI devices (0=off, 1=on [default])");
 
 static int atapi_dmadir = 0;
 module_param(atapi_dmadir, int, 0444);
-MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off, 1=on)");
+MODULE_PARM_DESC(atapi_dmadir, "Enable ATAPI DMADIR bridge support (0=off [default], 1=on)");
 
 int atapi_passthru16 = 1;
 module_param(atapi_passthru16, int, 0444);
-MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices; on by default (0=off, 1=on)");
+MODULE_PARM_DESC(atapi_passthru16, "Enable ATA_16 passthru for ATAPI devices (0=off, 1=on [default])");
 
 int libata_fua = 0;
 module_param_named(fua, libata_fua, int, 0444);
-MODULE_PARM_DESC(fua, "FUA support (0=off, 1=on)");
+MODULE_PARM_DESC(fua, "FUA support (0=off [default], 1=on)");
 
 static int ata_ignore_hpa;
 module_param_named(ignore_hpa, ata_ignore_hpa, int, 0644);
@@ -153,11 +153,11 @@ MODULE_PARM_DESC(ata_probe_timeout, "Set ATA probing timeout (seconds)");
 
 int libata_noacpi = 0;
 module_param_named(noacpi, libata_noacpi, int, 0444);
-MODULE_PARM_DESC(noacpi, "Disables the use of ACPI in probe/suspend/resume when set");
+MODULE_PARM_DESC(noacpi, "Disable the use of ACPI in probe/suspend/resume (0=off [default], 1=on)");
 
 int libata_allow_tpm = 0;
 module_param_named(allow_tpm, libata_allow_tpm, int, 0444);
-MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands");
+MODULE_PARM_DESC(allow_tpm, "Permit the use of TPM commands (0=off [default], 1=on)");
 
 MODULE_AUTHOR("Jeff Garzik");
 MODULE_DESCRIPTION("Library module for ATA devices");
@@ -1993,11 +1993,17 @@ unsigned int ata_do_simple_cmd(struct ata_device *dev, u8 cmd)
  *      Check if the current speed of the device requires IORDY. Used
  *      by various controllers for chip configuration.
  */
-
 unsigned int ata_pio_need_iordy(const struct ata_device *adev)
 {
-        /* Controller doesn't support  IORDY. Probably a pointless check
-           as the caller should know this */
+        /* Don't set IORDY if we're preparing for reset.  IORDY may
+         * lead to controller lock up on certain controllers if the
+         * port is not occupied.  See bko#11703 for details.
+         */
+        if (adev->link->ap->pflags & ATA_PFLAG_RESETTING)
+                return 0;
+        /* Controller doesn't support IORDY.  Probably a pointless
+         * check as the caller should know this.
+         */
         if (adev->link->ap->flags & ATA_FLAG_NO_IORDY)
                 return 0;
         /* CF spec. r4.1 Table 22 says no iordy on PIO5 and PIO6.  */
@@ -2020,7 +2026,6 @@ unsigned int ata_pio_need_iordy(const struct ata_device *adev)
  *      Compute the highest mode possible if we are not using iordy. Return
  *      -1 if no iordy mode is available.
  */
-
 static u32 ata_pio_mask_no_iordy(const struct ata_device *adev)
 {
         /* If we have no drive specific rule, then PIO 2 is non IORDY */
diff --git a/drivers/ata/pata_at91.c b/drivers/ata/pata_at91.c
new file mode 100644
index 000000000000..4b27617be26d
--- /dev/null
+++ b/drivers/ata/pata_at91.c
@@ -0,0 +1,361 @@
+/*
+ * PATA driver for AT91SAM9260 Static Memory Controller
+ * with CompactFlash interface in True IDE mode
+ *
+ * Copyright (C) 2009 Matyukevich Sergey
+ *
+ * Based on:
+ *      * generic platform driver by Paul Mundt: drivers/ata/pata_platform.c
+ *      * pata_at32 driver by Kristoffer Nyborg Gregertsen
+ *      * at91_ide driver by Stanislaw Gruszka
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/blkdev.h>
+#include <scsi/scsi_host.h>
+#include <linux/ata.h>
+#include <linux/clk.h>
+#include <linux/libata.h>
+#include <linux/platform_device.h>
+#include <linux/ata_platform.h>
+
+#include <mach/at91sam9260_matrix.h>
+#include <mach/at91sam9_smc.h>
+#include <mach/at91sam9260.h>
+#include <mach/board.h>
+#include <mach/gpio.h>
+
+
+#define DRV_NAME "pata_at91"
+#define DRV_VERSION "0.1"
+
+#define CF_IDE_OFFSET       0x00c00000
+#define CF_ALT_IDE_OFFSET   0x00e00000
+#define CF_IDE_RES_SIZE     0x08
+
+struct at91_ide_info {
+        unsigned long mode;
+        unsigned int cs;
+
+        void __iomem *ide_addr;
+        void __iomem *alt_addr;
+};
+
+const struct ata_timing initial_timing =
+        {XFER_PIO_0, 70, 290, 240, 600, 165, 150, 600, 0};
+
+static unsigned int calc_mck_cycles(unsigned int ns, unsigned int mck_hz)
+{
+        unsigned long mul;
+
+    /*
+     * cycles = x [nsec] * f [Hz] / 10^9 [ns in sec] =
+     *     x * (f / 1_000_000_000) =
+     *     x * ((f * 65536) / 1_000_000_000) / 65536 =
+     *     x * (((f / 10_000) * 65536) / 100_000) / 65536 =
+     */
+
+    mul = (mck_hz / 10000) << 16;
+    mul /= 100000;
+
+    return (ns * mul + 65536) >> 16;    /* rounding */
+}
+
+static void set_smc_mode(struct at91_ide_info *info)
+{
+    at91_sys_write(AT91_SMC_MODE(info->cs), info->mode);
+    return;
+}
+
+static void set_smc_timing(struct device *dev,
+                struct at91_ide_info *info, const struct ata_timing *ata)
+{
+        int read_cycle, write_cycle, active, recover;
+        int nrd_setup, nrd_pulse, nrd_recover;
+        int nwe_setup, nwe_pulse;
+
+        int ncs_write_setup, ncs_write_pulse;
+        int ncs_read_setup, ncs_read_pulse;
+
+        unsigned int mck_hz;
+        struct clk *mck;
+
+        read_cycle  = ata->cyc8b;
+        nrd_setup   = ata->setup;
+        nrd_pulse   = ata->act8b;
+        nrd_recover = ata->rec8b;
+
+        mck = clk_get(NULL, "mck");
+        BUG_ON(IS_ERR(mck));
+        mck_hz = clk_get_rate(mck);
+
+        read_cycle  = calc_mck_cycles(read_cycle, mck_hz);
+        nrd_setup   = calc_mck_cycles(nrd_setup, mck_hz);
+        nrd_pulse   = calc_mck_cycles(nrd_pulse, mck_hz);
+        nrd_recover = calc_mck_cycles(nrd_recover, mck_hz);
+
+        clk_put(mck);
+
+        active  = nrd_setup + nrd_pulse;
+        recover = read_cycle - active;
+
+        /* Need at least two cycles recovery */
+        if (recover < 2)
+                read_cycle = active + 2;
+
+        /* (CS0, CS1, DIR, OE) <= (CFCE1, CFCE2, CFRNW, NCSX) timings */
+        ncs_read_setup = 1;
+        ncs_read_pulse = read_cycle - 2;
+
+        /* Write timings same as read timings */
+        write_cycle = read_cycle;
+        nwe_setup = nrd_setup;
+        nwe_pulse = nrd_pulse;
+        ncs_write_setup = ncs_read_setup;
+        ncs_write_pulse = ncs_read_pulse;
+
+        dev_dbg(dev, "ATA timings: nrd_setup = %d nrd_pulse = %d nrd_cycle = %d\n",
+                        nrd_setup, nrd_pulse, read_cycle);
+        dev_dbg(dev, "ATA timings: nwe_setup = %d nwe_pulse = %d nwe_cycle = %d\n",
+                        nwe_setup, nwe_pulse, write_cycle);
+        dev_dbg(dev, "ATA timings: ncs_read_setup = %d ncs_read_pulse = %d\n",
+                        ncs_read_setup, ncs_read_pulse);
+        dev_dbg(dev, "ATA timings: ncs_write_setup = %d ncs_write_pulse = %d\n",
+                        ncs_write_setup, ncs_write_pulse);
+
+        at91_sys_write(AT91_SMC_SETUP(info->cs),
+                        AT91_SMC_NWESETUP_(nwe_setup) |
+                        AT91_SMC_NRDSETUP_(nrd_setup) |
+                        AT91_SMC_NCS_WRSETUP_(ncs_write_setup) |
+                        AT91_SMC_NCS_RDSETUP_(ncs_read_setup));
+
+        at91_sys_write(AT91_SMC_PULSE(info->cs),
+                        AT91_SMC_NWEPULSE_(nwe_pulse) |
+                        AT91_SMC_NRDPULSE_(nrd_pulse) |
+                        AT91_SMC_NCS_WRPULSE_(ncs_write_pulse) |
+                        AT91_SMC_NCS_RDPULSE_(ncs_read_pulse));
+
+        at91_sys_write(AT91_SMC_CYCLE(info->cs),
+                        AT91_SMC_NWECYCLE_(write_cycle) |
+                        AT91_SMC_NRDCYCLE_(read_cycle));
+
+        return;
+}
+
+static void pata_at91_set_piomode(struct ata_port *ap, struct ata_device *adev)
+{
+        struct at91_ide_info *info = ap->host->private_data;
+        struct ata_timing timing;
+        int ret;
+
+        /* Compute ATA timing and set it to SMC */
+        ret = ata_timing_compute(adev, adev->pio_mode, &timing, 1000, 0);
+        if (ret) {
+                dev_warn(ap->dev, "Failed to compute ATA timing %d, \
+                                set PIO_0 timing\n", ret);
+                set_smc_timing(ap->dev, info, &initial_timing);
+        } else {
+                set_smc_timing(ap->dev, info, &timing);
+        }
+
+        /* Setup SMC mode */
+        set_smc_mode(info);
+
+        return;
+}
+
+static unsigned int pata_at91_data_xfer_noirq(struct ata_device *dev,
+                unsigned char *buf, unsigned int buflen, int rw)
+{
+        struct at91_ide_info *info = dev->link->ap->host->private_data;
+        unsigned int consumed;
+        unsigned long flags;
+        unsigned int mode;
+
+        local_irq_save(flags);
+        mode = at91_sys_read(AT91_SMC_MODE(info->cs));
+
+        /* set 16bit mode before writing data */
+        at91_sys_write(AT91_SMC_MODE(info->cs),
+                        (mode & ~AT91_SMC_DBW) | AT91_SMC_DBW_16);
+
+        consumed = ata_sff_data_xfer(dev, buf, buflen, rw);
+
+        /* restore 8bit mode after data is written */
+        at91_sys_write(AT91_SMC_MODE(info->cs),
+                        (mode & ~AT91_SMC_DBW) | AT91_SMC_DBW_8);
+
+        local_irq_restore(flags);
+        return consumed;
+}
+
+static struct scsi_host_template pata_at91_sht = {
+        ATA_PIO_SHT(DRV_NAME),
+};
+
+static struct ata_port_operations pata_at91_port_ops = {
+        .inherits       = &ata_sff_port_ops,
+
+        .sff_data_xfer  = pata_at91_data_xfer_noirq,
+        .set_piomode    = pata_at91_set_piomode,
+        .cable_detect   = ata_cable_40wire,
+        .port_start     = ATA_OP_NULL,
+};
+
+static int __devinit pata_at91_probe(struct platform_device *pdev)
+{
+        struct at91_cf_data *board = pdev->dev.platform_data;
+        struct device *dev = &pdev->dev;
+        struct at91_ide_info *info;
+        struct resource *mem_res;
+        struct ata_host *host;
+        struct ata_port *ap;
+        int irq_flags = 0;
+        int irq = 0;
+        int ret;
+
+        /*  get platform resources: IO/CTL memories and irq/rst pins */
+
+        if (pdev->num_resources != 1) {
+                dev_err(&pdev->dev, "invalid number of resources\n");
+                return -EINVAL;
+        }
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        if (!mem_res) {
+                dev_err(dev, "failed to get mem resource\n");
+                return -EINVAL;
+        }
+
+        irq = board->irq_pin;
+
+        /* init ata host */
+
+        host = ata_host_alloc(dev, 1);
+
+        if (!host)
+                return -ENOMEM;
+
+        ap = host->ports[0];
+        ap->ops = &pata_at91_port_ops;
+        ap->flags |= ATA_FLAG_SLAVE_POSS;
+        ap->pio_mask = ATA_PIO4;
+
+        if (!irq) {
+                ap->flags |= ATA_FLAG_PIO_POLLING;
+                ata_port_desc(ap, "no IRQ, using PIO polling");
+        }
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+
+        if (!info) {
+                dev_err(dev, "failed to allocate memory for private data\n");
+                return -ENOMEM;
+        }
+
+        info->cs    = board->chipselect;
+        info->mode  = AT91_SMC_READMODE | AT91_SMC_WRITEMODE |
+                AT91_SMC_EXNWMODE_READY | AT91_SMC_BAT_SELECT |
+                AT91_SMC_DBW_8 | AT91_SMC_TDF_(0);
+
+        info->ide_addr = devm_ioremap(dev,
+                        mem_res->start + CF_IDE_OFFSET, CF_IDE_RES_SIZE);
+
+        if (!info->ide_addr) {
+                dev_err(dev, "failed to map IO base\n");
+                ret = -ENOMEM;
+                goto err_ide_ioremap;
+        }
+
+        info->alt_addr = devm_ioremap(dev,
+                        mem_res->start + CF_ALT_IDE_OFFSET, CF_IDE_RES_SIZE);
+
+        if (!info->alt_addr) {
+                dev_err(dev, "failed to map CTL base\n");
+                ret = -ENOMEM;
+                goto err_alt_ioremap;
+        }
+
+        ap->ioaddr.cmd_addr = info->ide_addr;
+        ap->ioaddr.ctl_addr = info->alt_addr + 0x06;
+        ap->ioaddr.altstatus_addr = ap->ioaddr.ctl_addr;
+
+        ata_sff_std_ports(&ap->ioaddr);
+
+        ata_port_desc(ap, "mmio cmd 0x%llx ctl 0x%llx",
+                        (unsigned long long)mem_res->start + CF_IDE_OFFSET,
+                        (unsigned long long)mem_res->start + CF_ALT_IDE_OFFSET);
+
+        host->private_data = info;
+
+        return ata_host_activate(host, irq ? gpio_to_irq(irq) : 0,
+                        irq ? ata_sff_interrupt : NULL,
+                        irq_flags, &pata_at91_sht);
+
+err_alt_ioremap:
+        devm_iounmap(dev, info->ide_addr);
+
+err_ide_ioremap:
+        kfree(info);
+
+        return ret;
+}
+
+static int __devexit pata_at91_remove(struct platform_device *pdev)
+{
+        struct ata_host *host = dev_get_drvdata(&pdev->dev);
+        struct at91_ide_info *info = host->private_data;
+        struct device *dev = &pdev->dev;
+
+        if (!host)
+                return 0;
+
+        ata_host_detach(host);
+
+        if (!info)
+                return 0;
+
+        devm_iounmap(dev, info->ide_addr);
+        devm_iounmap(dev, info->alt_addr);
+
+        kfree(info);
+        return 0;
+}
+
+static struct platform_driver pata_at91_driver = {
+        .probe          = pata_at91_probe,
+        .remove         = __devexit_p(pata_at91_remove),
+        .driver         = {
+                .name           = DRV_NAME,
+                .owner          = THIS_MODULE,
+        },
+};
+
+static int __init pata_at91_init(void)
+{
+        return platform_driver_register(&pata_at91_driver);
+}
+
+static void __exit pata_at91_exit(void)
+{
+        platform_driver_unregister(&pata_at91_driver);
+}
+
+
+module_init(pata_at91_init);
+module_exit(pata_at91_exit);
+
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Driver for CF in True IDE mode on AT91SAM9260 SoC");
+MODULE_AUTHOR("Matyukevich Sergey");
+MODULE_VERSION(DRV_VERSION);
+
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 36b8629203be..94eaa432c40a 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -1378,6 +1378,37 @@ static int sata_fsl_remove(struct of_device *ofdev)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int sata_fsl_suspend(struct of_device *op, pm_message_t state)
+{
+        struct ata_host *host = dev_get_drvdata(&op->dev);
+        return ata_host_suspend(host, state);
+}
+
+static int sata_fsl_resume(struct of_device *op)
+{
+        struct ata_host *host = dev_get_drvdata(&op->dev);
+        struct sata_fsl_host_priv *host_priv = host->private_data;
+        int ret;
+        void __iomem *hcr_base = host_priv->hcr_base;
+        struct ata_port *ap = host->ports[0];
+        struct sata_fsl_port_priv *pp = ap->private_data;
+
+        ret = sata_fsl_init_controller(host);
+        if (ret) {
+                dev_printk(KERN_ERR, &op->dev,
+                        "Error initialize hardware\n");
+                return ret;
+        }
+
+        /* Recovery the CHBA register in host controller cmd register set */
+        iowrite32(pp->cmdslot_paddr & 0xffffffff, hcr_base + CHBA);
+
+        ata_host_resume(host);
+        return 0;
+}
+#endif
+
 static struct of_device_id fsl_sata_match[] = {
         {
                 .compatible = "fsl,pq-sata",
@@ -1392,6 +1423,10 @@ static struct of_platform_driver fsl_sata_driver = {
         .match_table    = fsl_sata_match,
         .probe          = sata_fsl_probe,
         .remove         = sata_fsl_remove,
+#ifdef CONFIG_PM
+        .suspend        = sata_fsl_suspend,
+        .resume         = sata_fsl_resume,
+#endif
 };
 
 static int __init sata_fsl_init(void)
diff --git a/drivers/char/bsr.c b/drivers/char/bsr.c
index 140ea10ecb88..c02db01f736e 100644
--- a/drivers/char/bsr.c
+++ b/drivers/char/bsr.c
@@ -27,6 +27,7 @@
 #include <linux/cdev.h>
 #include <linux/list.h>
 #include <linux/mm.h>
+#include <asm/pgtable.h>
 #include <asm/io.h>
 
 /*
@@ -75,12 +76,13 @@ static struct class *bsr_class;
 static int bsr_major;
 
 enum {
-        BSR_8   = 0,
-        BSR_16  = 1,
-        BSR_64  = 2,
-        BSR_128 = 3,
-        BSR_UNKNOWN = 4,
-        BSR_MAX = 5,
+        BSR_8    = 0,
+        BSR_16   = 1,
+        BSR_64   = 2,
+        BSR_128  = 3,
+        BSR_4096 = 4,
+        BSR_UNKNOWN = 5,
+        BSR_MAX  = 6,
 };
 
 static unsigned bsr_types[BSR_MAX];
@@ -117,15 +119,22 @@ static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
 {
         unsigned long size   = vma->vm_end - vma->vm_start;
         struct bsr_dev *dev = filp->private_data;
+        int ret;
 
-        if (size > dev->bsr_len || (size & (PAGE_SIZE-1)))
-                return -EINVAL;
-
-        vma->vm_flags |= (VM_IO | VM_DONTEXPAND);
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
-        if (io_remap_pfn_range(vma, vma->vm_start, dev->bsr_addr >> PAGE_SHIFT,
-                               size, vma->vm_page_prot))
+        /* check for the case of a small BSR device and map one 4k page for it*/
+        if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
+                ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
+                                   vma->vm_page_prot);
+        else if (size <= dev->bsr_len)
+                ret = io_remap_pfn_range(vma, vma->vm_start,
+                                         dev->bsr_addr >> PAGE_SHIFT,
+                                         size, vma->vm_page_prot);
+        else
+                return -EINVAL;
+
+        if (ret)
                 return -EAGAIN;
 
         return 0;
@@ -205,6 +214,11 @@ static int bsr_add_node(struct device_node *bn)
                 cur->bsr_stride = bsr_stride[i];
                 cur->bsr_dev    = MKDEV(bsr_major, i + total_bsr_devs);
 
+                /* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
+                /* we can only map 4k of it, so only advertise the 4k in sysfs */
+                if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
+                        cur->bsr_len = 4096;
+
                 switch(cur->bsr_bytes) {
                 case 8:
                         cur->bsr_type = BSR_8;
@@ -218,9 +232,11 @@ static int bsr_add_node(struct device_node *bn)
                 case 128:
                         cur->bsr_type = BSR_128;
                         break;
+                case 4096:
+                        cur->bsr_type = BSR_4096;
+                        break;
                 default:
                         cur->bsr_type = BSR_UNKNOWN;
-                        printk(KERN_INFO "unknown BSR size %d\n",cur->bsr_bytes);
                 }
 
                 cur->bsr_num = bsr_types[cur->bsr_type];
diff --git a/drivers/char/mxser.c b/drivers/char/mxser.c
index 9533f43a30bb..52d953eb30c3 100644
--- a/drivers/char/mxser.c
+++ b/drivers/char/mxser.c
@@ -1048,8 +1048,6 @@ static int mxser_open(struct tty_struct *tty, struct file *filp)
         if (retval)
                 return retval;
 
-        /* unmark here for very high baud rate (ex. 921600 bps) used */
-        tty->low_latency = 1;
         return 0;
 }
 
diff --git a/drivers/char/nozomi.c b/drivers/char/nozomi.c
index d6102b644b55..574f1c79b6e6 100644
--- a/drivers/char/nozomi.c
+++ b/drivers/char/nozomi.c
@@ -1591,8 +1591,6 @@ static int ntty_open(struct tty_struct *tty, struct file *file)
 
         /* Enable interrupt downlink for channel */
         if (port->port.count == 1) {
-                /* FIXME: is this needed now ? */
-                tty->low_latency = 1;
                 tty->driver_data = port;
                 tty_port_tty_set(&port->port, tty);
                 DBG1("open: %d", port->token_dl);
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 1386625fc4ca..a2e67e6df3a1 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -467,7 +467,6 @@ static unsigned int free_tbuf_count(struct slgt_info *info);
 static unsigned int tbuf_bytes(struct slgt_info *info);
 static void reset_tbufs(struct slgt_info *info);
 static void tdma_reset(struct slgt_info *info);
-static void tdma_start(struct slgt_info *info);
 static void tx_load(struct slgt_info *info, const char *buf, unsigned int count);
 
 static void get_signals(struct slgt_info *info);
@@ -795,6 +794,18 @@ static void set_termios(struct tty_struct *tty, struct ktermios *old_termios)
         }
 }
 
+static void update_tx_timer(struct slgt_info *info)
+{
+        /*
+         * use worst case speed of 1200bps to calculate transmit timeout
+         * based on data in buffers (tbuf_bytes) and FIFO (128 bytes)
+         */
+        if (info->params.mode == MGSL_MODE_HDLC) {
+                int timeout  = (tbuf_bytes(info) * 7) + 1000;
+                mod_timer(&info->tx_timer, jiffies + msecs_to_jiffies(timeout));
+        }
+}
+
 static int write(struct tty_struct *tty,
                  const unsigned char *buf, int count)
 {
@@ -838,8 +849,18 @@ start:
                 spin_lock_irqsave(&info->lock,flags);
                 if (!info->tx_active)
                         tx_start(info);
-                else
-                        tdma_start(info);
+                else if (!(rd_reg32(info, TDCSR) & BIT0)) {
+                        /* transmit still active but transmit DMA stopped */
+                        unsigned int i = info->tbuf_current;
+                        if (!i)
+                                i = info->tbuf_count;
+                        i--;
+                        /* if DMA buf unsent must try later after tx idle */
+                        if (desc_count(info->tbufs[i]))
+                                ret = 0;
+                }
+                if (ret > 0)
+                        update_tx_timer(info);
                 spin_unlock_irqrestore(&info->lock,flags);
         }
 
@@ -1502,10 +1523,9 @@ static int hdlcdev_xmit(struct sk_buff *skb, struct net_device *dev)
         /* save start time for transmit timeout detection */
         dev->trans_start = jiffies;
 
-        /* start hardware transmitter if necessary */
         spin_lock_irqsave(&info->lock,flags);
-        if (!info->tx_active)
-                tx_start(info);
+        tx_start(info);
+        update_tx_timer(info);
         spin_unlock_irqrestore(&info->lock,flags);
 
         return 0;
@@ -3946,50 +3966,19 @@ static void tx_start(struct slgt_info *info)
                         slgt_irq_on(info, IRQ_TXUNDER + IRQ_TXIDLE);
                         /* clear tx idle and underrun status bits */
                         wr_reg16(info, SSR, (unsigned short)(IRQ_TXIDLE + IRQ_TXUNDER));
-                        if (info->params.mode == MGSL_MODE_HDLC)
-                                mod_timer(&info->tx_timer, jiffies +
-                                                msecs_to_jiffies(5000));
                 } else {
                         slgt_irq_off(info, IRQ_TXDATA);
                         slgt_irq_on(info, IRQ_TXIDLE);
                         /* clear tx idle status bit */
                         wr_reg16(info, SSR, IRQ_TXIDLE);
                 }
-                tdma_start(info);
+                /* set 1st descriptor address and start DMA */
+                wr_reg32(info, TDDAR, info->tbufs[info->tbuf_start].pdesc);
+                wr_reg32(info, TDCSR, BIT2 + BIT0);
                 info->tx_active = true;
         }
 }
 
-/*
- * start transmit DMA if inactive and there are unsent buffers
- */
-static void tdma_start(struct slgt_info *info)
-{
-        unsigned int i;
-
-        if (rd_reg32(info, TDCSR) & BIT0)
-                return;
-
-        /* transmit DMA inactive, check for unsent buffers */
-        i = info->tbuf_start;
-        while (!desc_count(info->tbufs[i])) {
-                if (++i == info->tbuf_count)
-                        i = 0;
-                if (i == info->tbuf_current)
-                        return;
-        }
-        info->tbuf_start = i;
-
-        /* there are unsent buffers, start transmit DMA */
-
-        /* reset needed if previous error condition */
-        tdma_reset(info);
-
-        /* set 1st descriptor address */
-        wr_reg32(info, TDDAR, info->tbufs[info->tbuf_start].pdesc);
-        wr_reg32(info, TDCSR, BIT2 + BIT0); /* IRQ + DMA enable */
-}
-
 static void tx_stop(struct slgt_info *info)
 {
         unsigned short val;
@@ -5004,8 +4993,7 @@ static void tx_timeout(unsigned long context)
                 info->icount.txtimeout++;
         }
         spin_lock_irqsave(&info->lock,flags);
-        info->tx_active = false;
-        info->tx_count = 0;
+        tx_stop(info);
         spin_unlock_irqrestore(&info->lock,flags);
 
 #if SYNCLINK_GENERIC_HDLC
diff --git a/drivers/char/tty_port.c b/drivers/char/tty_port.c
index 62dadfc95e34..4e862a75f7ff 100644
--- a/drivers/char/tty_port.c
+++ b/drivers/char/tty_port.c
@@ -193,7 +193,7 @@ int tty_port_block_til_ready(struct tty_port *port,
 {
         int do_clocal = 0, retval;
         unsigned long flags;
-        DECLARE_WAITQUEUE(wait, current);
+        DEFINE_WAIT(wait);
         int cd;
 
         /* block if port is in the process of being closed */
diff --git a/drivers/dma/txx9dmac.c b/drivers/dma/txx9dmac.c
index 9aa9ea9822c8..88dab52926f4 100644
--- a/drivers/dma/txx9dmac.c
+++ b/drivers/dma/txx9dmac.c
@@ -432,23 +432,27 @@ txx9dmac_descriptor_complete(struct txx9dmac_chan *dc,
         list_splice_init(&txd->tx_list, &dc->free_list);
         list_move(&desc->desc_node, &dc->free_list);
 
-        /*
-         * We use dma_unmap_page() regardless of how the buffers were
-         * mapped before they were submitted...
-         */
         if (!ds) {
                 dma_addr_t dmaaddr;
                 if (!(txd->flags & DMA_COMPL_SKIP_DEST_UNMAP)) {
                         dmaaddr = is_dmac64(dc) ?
                                 desc->hwdesc.DAR : desc->hwdesc32.DAR;
-                        dma_unmap_page(chan2parent(&dc->chan), dmaaddr,
-                                       desc->len, DMA_FROM_DEVICE);
+                        if (txd->flags & DMA_COMPL_DEST_UNMAP_SINGLE)
+                                dma_unmap_single(chan2parent(&dc->chan),
+                                        dmaaddr, desc->len, DMA_FROM_DEVICE);
+                        else
+                                dma_unmap_page(chan2parent(&dc->chan),
+                                        dmaaddr, desc->len, DMA_FROM_DEVICE);
                 }
                 if (!(txd->flags & DMA_COMPL_SKIP_SRC_UNMAP)) {
                         dmaaddr = is_dmac64(dc) ?
                                 desc->hwdesc.SAR : desc->hwdesc32.SAR;
-                        dma_unmap_page(chan2parent(&dc->chan), dmaaddr,
-                                       desc->len, DMA_TO_DEVICE);
+                        if (txd->flags & DMA_COMPL_SRC_UNMAP_SINGLE)
+                                dma_unmap_single(chan2parent(&dc->chan),
+                                        dmaaddr, desc->len, DMA_TO_DEVICE);
+                        else
+                                dma_unmap_page(chan2parent(&dc->chan),
+                                        dmaaddr, desc->len, DMA_TO_DEVICE);
                 }
         }
 
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
index c36bf40568cf..858fe6037223 100644
--- a/drivers/edac/amd64_edac.c
+++ b/drivers/edac/amd64_edac.c
@@ -754,13 +754,13 @@ static void amd64_cpu_display_info(struct amd64_pvt *pvt)
 static enum edac_type amd64_determine_edac_cap(struct amd64_pvt *pvt)
 {
         int bit;
-        enum dev_type edac_cap = EDAC_NONE;
+        enum dev_type edac_cap = EDAC_FLAG_NONE;
 
         bit = (boot_cpu_data.x86 > 0xf || pvt->ext_model >= OPTERON_CPU_REV_F)
                 ? 19
                 : 17;
 
-        if (pvt->dclr0 >> BIT(bit))
+        if (pvt->dclr0 & BIT(bit))
                 edac_cap = EDAC_FLAG_SECDED;
 
         return edac_cap;
@@ -1269,7 +1269,7 @@ static int f10_early_channel_count(struct amd64_pvt *pvt)
         if (channels == 0)
                 channels = 1;
 
-        debugf0("DIMM count= %d\n", channels);
+        debugf0("MCT channel count: %d\n", channels);
 
         return channels;
 
@@ -2966,7 +2966,12 @@ static int amd64_check_ecc_enabled(struct amd64_pvt *pvt)
                                 "    Use of the override can cause "
                                 "unknown side effects.\n");
                         ret = -ENODEV;
-                }
+                } else
+                        /*
+                         * enable further driver loading if ECC enable is
+                         * overridden.
+                         */
+                        ret = 0;
         } else {
                 amd64_printk(KERN_INFO,
                         "ECC is enabled by BIOS, Proceeding "
@@ -3006,7 +3011,6 @@ static void amd64_setup_mci_misc_attributes(struct mem_ctl_info *mci)
 
         mci->mtype_cap          = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
         mci->edac_ctl_cap       = EDAC_FLAG_NONE;
-        mci->edac_cap           = EDAC_FLAG_NONE;
 
         if (pvt->nbcap & K8_NBCAP_SECDED)
                 mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
@@ -3052,7 +3056,7 @@ static int amd64_probe_one_instance(struct pci_dev *dram_f2_ctl,
         if (!pvt)
                 goto err_exit;
 
-        pvt->mc_node_id = get_mc_node_id_from_pdev(dram_f2_ctl);
+        pvt->mc_node_id = get_node_id(dram_f2_ctl);
 
         pvt->dram_f2_ctl        = dram_f2_ctl;
         pvt->ext_model          = boot_cpu_data.x86_model >> 4;
@@ -3179,8 +3183,7 @@ static int __devinit amd64_init_one_instance(struct pci_dev *pdev,
 {
         int ret = 0;
 
-        debugf0("(MC node=%d,mc_type='%s')\n",
-                get_mc_node_id_from_pdev(pdev),
+        debugf0("(MC node=%d,mc_type='%s')\n", get_node_id(pdev),
                 get_amd_family_name(mc_type->driver_data));
 
         ret = pci_enable_device(pdev);
@@ -3319,15 +3322,17 @@ static int __init amd64_edac_init(void)
 
                 err = amd64_init_2nd_stage(pvt_lookup[nb]);
                 if (err)
-                        goto err_exit;
+                        goto err_2nd_stage;
         }
 
         amd64_setup_pci_device();
 
         return 0;
 
+err_2nd_stage:
+        debugf0("2nd stage failed\n");
+
 err_exit:
-        debugf0("'finish_setup' stage failed\n");
         pci_unregister_driver(&amd64_pci_driver);
 
         return err;
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h
index a159957e167b..ba73015af8e4 100644
--- a/drivers/edac/amd64_edac.h
+++ b/drivers/edac/amd64_edac.h
@@ -444,7 +444,7 @@ enum {
 #define K8_MSR_MC4ADDR                  0x0412
 
 /* AMD sets the first MC device at device ID 0x18. */
-static inline int get_mc_node_id_from_pdev(struct pci_dev *pdev)
+static inline int get_node_id(struct pci_dev *pdev)
 {
         return PCI_SLOT(pdev->devfn) - 0x18;
 }
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig
index c961fe415aef..39b393d38bb3 100644
--- a/drivers/gpu/drm/Kconfig
+++ b/drivers/gpu/drm/Kconfig
@@ -81,6 +81,7 @@ config DRM_I830
 
 config DRM_I915
         tristate "i915 driver"
+        depends on AGP_INTEL
         select FB_CFB_FILLRECT
         select FB_CFB_COPYAREA
         select FB_CFB_IMAGEBLIT
diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 4e89ab08b7b8..fe23f29f7cba 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -16,6 +16,7 @@ drm-y       :=	drm_auth.o drm_bufs.o drm_cache.o \
 drm-$(CONFIG_COMPAT) += drm_ioc32.o
 
 obj-$(CONFIG_DRM)       += drm.o
+obj-$(CONFIG_DRM_TTM)   += ttm/
 obj-$(CONFIG_DRM_TDFX)  += tdfx/
 obj-$(CONFIG_DRM_R128)  += r128/
 obj-$(CONFIG_DRM_RADEON)+= radeon/
@@ -26,4 +27,3 @@ obj-$(CONFIG_DRM_I915)  += i915/
 obj-$(CONFIG_DRM_SIS)   += sis/
 obj-$(CONFIG_DRM_SAVAGE)+= savage/
 obj-$(CONFIG_DRM_VIA)   +=via/
-obj-$(CONFIG_DRM_TTM)   += ttm/
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 7d0835226f6e..80cc6d06d61b 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -294,10 +294,10 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
         unsigned vactive = (pt->vactive_vblank_hi & 0xf0) << 4 | pt->vactive_lo;
         unsigned hblank = (pt->hactive_hblank_hi & 0xf) << 8 | pt->hblank_lo;
         unsigned vblank = (pt->vactive_vblank_hi & 0xf) << 8 | pt->vblank_lo;
-        unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 8 | pt->hsync_offset_lo;
-        unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) << 6 | pt->hsync_pulse_width_lo;
-        unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) | (pt->vsync_offset_pulse_width_lo & 0xf);
-        unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) >> 2 | pt->vsync_offset_pulse_width_lo >> 4;
+        unsigned hsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc0) << 2 | pt->hsync_offset_lo;
+        unsigned hsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x30) << 4 | pt->hsync_pulse_width_lo;
+        unsigned vsync_offset = (pt->hsync_vsync_offset_pulse_width_hi & 0xc) >> 2 | pt->vsync_offset_pulse_width_lo >> 4;
+        unsigned vsync_pulse_width = (pt->hsync_vsync_offset_pulse_width_hi & 0x3) << 4 | (pt->vsync_offset_pulse_width_lo & 0xf);
 
         /* ignore tiny modes */
         if (hactive < 64 || vactive < 64)
@@ -347,8 +347,8 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
         mode->flags |= (pt->misc & DRM_EDID_PT_VSYNC_POSITIVE) ?
                 DRM_MODE_FLAG_PVSYNC : DRM_MODE_FLAG_NVSYNC;
 
-        mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
-        mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
+        mode->width_mm = pt->width_mm_lo | (pt->width_height_mm_hi & 0xf0) << 4;
+        mode->height_mm = pt->height_mm_lo | (pt->width_height_mm_hi & 0xf) << 8;
 
         if (quirks & EDID_QUIRK_DETAILED_IN_CM) {
                 mode->width_mm *= 10;
diff --git a/drivers/gpu/drm/i915/Makefile b/drivers/gpu/drm/i915/Makefile
index 51c5a050aa73..30d6b99fb302 100644
--- a/drivers/gpu/drm/i915/Makefile
+++ b/drivers/gpu/drm/i915/Makefile
@@ -13,6 +13,8 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \
           intel_crt.o \
           intel_lvds.o \
           intel_bios.o \
+          intel_dp.o \
+          intel_dp_i2c.o \
           intel_hdmi.o \
           intel_sdvo.o \
           intel_modes.o \
diff --git a/drivers/gpu/drm/i915/dvo.h b/drivers/gpu/drm/i915/dvo.h
index e747ac42fe3a..288fc50627e2 100644
--- a/drivers/gpu/drm/i915/dvo.h
+++ b/drivers/gpu/drm/i915/dvo.h
@@ -37,7 +37,7 @@ struct intel_dvo_device {
         /* GPIO register used for i2c bus to control this device */
         u32 gpio;
         int slave_addr;
-        struct intel_i2c_chan *i2c_bus;
+        struct i2c_adapter *i2c_bus;
 
         const struct intel_dvo_dev_ops *dev_ops;
         void *dev_priv;
@@ -52,7 +52,7 @@ struct intel_dvo_dev_ops {
          * Returns NULL if the device does not exist.
          */
         bool (*init)(struct intel_dvo_device *dvo,
-                     struct intel_i2c_chan *i2cbus);
+                     struct i2c_adapter *i2cbus);
 
         /*
          * Called to allow the output a chance to create properties after the
diff --git a/drivers/gpu/drm/i915/dvo_ch7017.c b/drivers/gpu/drm/i915/dvo_ch7017.c
index 03d4b4973b02..621815b531db 100644
--- a/drivers/gpu/drm/i915/dvo_ch7017.c
+++ b/drivers/gpu/drm/i915/dvo_ch7017.c
@@ -176,19 +176,20 @@ static void ch7017_dpms(struct intel_dvo_device *dvo, int mode);
 
 static bool ch7017_read(struct intel_dvo_device *dvo, int addr, uint8_t *val)
 {
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -208,10 +209,11 @@ static bool ch7017_read(struct intel_dvo_device *dvo, int addr, uint8_t *val)
 
 static bool ch7017_write(struct intel_dvo_device *dvo, int addr, uint8_t val)
 {
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -228,8 +230,9 @@ static bool ch7017_write(struct intel_dvo_device *dvo, int addr, uint8_t val)
 
 /** Probes for a CH7017 on the given bus and slave address. */
 static bool ch7017_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         struct ch7017_priv *priv;
         uint8_t val;
 
@@ -237,8 +240,7 @@ static bool ch7017_init(struct intel_dvo_device *dvo,
         if (priv == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = priv;
 
         if (!ch7017_read(dvo, CH7017_DEVICE_ID, &val))
@@ -248,7 +250,7 @@ static bool ch7017_init(struct intel_dvo_device *dvo,
             val != CH7018_DEVICE_ID_VALUE &&
             val != CH7019_DEVICE_ID_VALUE) {
                 DRM_DEBUG("ch701x not detected, got %d: from %s Slave %d.\n",
-                          val, i2cbus->adapter.name,i2cbus->slave_addr);
+                          val, i2cbus->adapter.name,dvo->slave_addr);
                 goto fail;
         }
 
diff --git a/drivers/gpu/drm/i915/dvo_ch7xxx.c b/drivers/gpu/drm/i915/dvo_ch7xxx.c
index d2fd95dbd034..a9b896289680 100644
--- a/drivers/gpu/drm/i915/dvo_ch7xxx.c
+++ b/drivers/gpu/drm/i915/dvo_ch7xxx.c
@@ -123,19 +123,20 @@ static char *ch7xxx_get_id(uint8_t vid)
 static bool ch7xxx_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 {
         struct ch7xxx_priv *ch7xxx= dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -152,7 +153,7 @@ static bool ch7xxx_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 
         if (!ch7xxx->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -161,10 +162,11 @@ static bool ch7xxx_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 static bool ch7xxx_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 {
         struct ch7xxx_priv *ch7xxx = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -178,14 +180,14 @@ static bool ch7xxx_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
         if (!ch7xxx->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
 }
 
 static bool ch7xxx_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
         /* this will detect the CH7xxx chip on the specified i2c bus */
         struct ch7xxx_priv *ch7xxx;
@@ -196,8 +198,7 @@ static bool ch7xxx_init(struct intel_dvo_device *dvo,
         if (ch7xxx == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = ch7xxx;
         ch7xxx->quiet = true;
 
@@ -207,7 +208,7 @@ static bool ch7xxx_init(struct intel_dvo_device *dvo,
         name = ch7xxx_get_id(vendor);
         if (!name) {
                 DRM_DEBUG("ch7xxx not detected; got 0x%02x from %s slave %d.\n",
-                          vendor, i2cbus->adapter.name, i2cbus->slave_addr);
+                          vendor, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
@@ -217,7 +218,7 @@ static bool ch7xxx_init(struct intel_dvo_device *dvo,
 
         if (device != CH7xxx_DID) {
                 DRM_DEBUG("ch7xxx not detected; got 0x%02x from %s slave %d.\n",
-                          vendor, i2cbus->adapter.name, i2cbus->slave_addr);
+                          vendor, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
diff --git a/drivers/gpu/drm/i915/dvo_ivch.c b/drivers/gpu/drm/i915/dvo_ivch.c
index 0c8d375e8e37..aa176f9921fe 100644
--- a/drivers/gpu/drm/i915/dvo_ivch.c
+++ b/drivers/gpu/drm/i915/dvo_ivch.c
@@ -169,13 +169,14 @@ static void ivch_dump_regs(struct intel_dvo_device *dvo);
 static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
 {
         struct ivch_priv *priv = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[1];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 0,
                 },
@@ -186,7 +187,7 @@ static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD | I2C_M_NOSTART,
                         .len = 2,
                         .buf = in_buf,
@@ -202,7 +203,7 @@ static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
 
         if (!priv->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -211,10 +212,11 @@ static bool ivch_read(struct intel_dvo_device *dvo, int addr, uint16_t *data)
 static bool ivch_write(struct intel_dvo_device *dvo, int addr, uint16_t data)
 {
         struct ivch_priv *priv = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[3];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 3,
                 .buf = out_buf,
@@ -229,7 +231,7 @@ static bool ivch_write(struct intel_dvo_device *dvo, int addr, uint16_t data)
 
         if (!priv->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
@@ -237,7 +239,7 @@ static bool ivch_write(struct intel_dvo_device *dvo, int addr, uint16_t data)
 
 /** Probes the given bus and slave address for an ivch */
 static bool ivch_init(struct intel_dvo_device *dvo,
-                      struct intel_i2c_chan *i2cbus)
+                      struct i2c_adapter *adapter)
 {
         struct ivch_priv *priv;
         uint16_t temp;
@@ -246,8 +248,7 @@ static bool ivch_init(struct intel_dvo_device *dvo,
         if (priv == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = priv;
         priv->quiet = true;
 
diff --git a/drivers/gpu/drm/i915/dvo_sil164.c b/drivers/gpu/drm/i915/dvo_sil164.c
index 033a4bb070b2..e1c1f7341e5c 100644
--- a/drivers/gpu/drm/i915/dvo_sil164.c
+++ b/drivers/gpu/drm/i915/dvo_sil164.c
@@ -76,19 +76,20 @@ struct sil164_priv {
 static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 {
         struct sil164_priv *sil = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -105,7 +106,7 @@ static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 
         if (!sil->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -113,10 +114,11 @@ static bool sil164_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 {
         struct sil164_priv *sil= dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -130,7 +132,7 @@ static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
         if (!sil->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
@@ -138,7 +140,7 @@ static bool sil164_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
 /* Silicon Image 164 driver for chip on i2c bus */
 static bool sil164_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
         /* this will detect the SIL164 chip on the specified i2c bus */
         struct sil164_priv *sil;
@@ -148,8 +150,7 @@ static bool sil164_init(struct intel_dvo_device *dvo,
         if (sil == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = sil;
         sil->quiet = true;
 
@@ -158,7 +159,7 @@ static bool sil164_init(struct intel_dvo_device *dvo,
 
         if (ch != (SIL164_VID & 0xff)) {
                 DRM_DEBUG("sil164 not detected got %d: from %s Slave %d.\n",
-                          ch, i2cbus->adapter.name, i2cbus->slave_addr);
+                          ch, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
@@ -167,7 +168,7 @@ static bool sil164_init(struct intel_dvo_device *dvo,
 
         if (ch != (SIL164_DID & 0xff)) {
                 DRM_DEBUG("sil164 not detected got %d: from %s Slave %d.\n",
-                          ch, i2cbus->adapter.name, i2cbus->slave_addr);
+                          ch, adapter->name, dvo->slave_addr);
                 goto out;
         }
         sil->quiet = false;
diff --git a/drivers/gpu/drm/i915/dvo_tfp410.c b/drivers/gpu/drm/i915/dvo_tfp410.c
index 207fda806ebf..9ecc907384ec 100644
--- a/drivers/gpu/drm/i915/dvo_tfp410.c
+++ b/drivers/gpu/drm/i915/dvo_tfp410.c
@@ -101,19 +101,20 @@ struct tfp410_priv {
 static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 {
         struct tfp410_priv *tfp = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         u8 out_buf[2];
         u8 in_buf[2];
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = i2cbus->slave_addr,
+                        .addr = dvo->slave_addr,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = in_buf,
@@ -130,7 +131,7 @@ static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 
         if (!tfp->quiet) {
                 DRM_DEBUG("Unable to read register 0x%02x from %s:%02x.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
         return false;
 }
@@ -138,10 +139,11 @@ static bool tfp410_readb(struct intel_dvo_device *dvo, int addr, uint8_t *ch)
 static bool tfp410_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 {
         struct tfp410_priv *tfp = dvo->dev_priv;
-        struct intel_i2c_chan *i2cbus = dvo->i2c_bus;
+        struct i2c_adapter *adapter = dvo->i2c_bus;
+        struct intel_i2c_chan *i2cbus = container_of(adapter, struct intel_i2c_chan, adapter);
         uint8_t out_buf[2];
         struct i2c_msg msg = {
-                .addr = i2cbus->slave_addr,
+                .addr = dvo->slave_addr,
                 .flags = 0,
                 .len = 2,
                 .buf = out_buf,
@@ -155,7 +157,7 @@ static bool tfp410_writeb(struct intel_dvo_device *dvo, int addr, uint8_t ch)
 
         if (!tfp->quiet) {
                 DRM_DEBUG("Unable to write register 0x%02x to %s:%d.\n",
-                          addr, i2cbus->adapter.name, i2cbus->slave_addr);
+                          addr, i2cbus->adapter.name, dvo->slave_addr);
         }
 
         return false;
@@ -174,7 +176,7 @@ static int tfp410_getid(struct intel_dvo_device *dvo, int addr)
 
 /* Ti TFP410 driver for chip on i2c bus */
 static bool tfp410_init(struct intel_dvo_device *dvo,
-                        struct intel_i2c_chan *i2cbus)
+                        struct i2c_adapter *adapter)
 {
         /* this will detect the tfp410 chip on the specified i2c bus */
         struct tfp410_priv *tfp;
@@ -184,20 +186,19 @@ static bool tfp410_init(struct intel_dvo_device *dvo,
         if (tfp == NULL)
                 return false;
 
-        dvo->i2c_bus = i2cbus;
-        dvo->i2c_bus->slave_addr = dvo->slave_addr;
+        dvo->i2c_bus = adapter;
         dvo->dev_priv = tfp;
         tfp->quiet = true;
 
         if ((id = tfp410_getid(dvo, TFP410_VID_LO)) != TFP410_VID) {
                 DRM_DEBUG("tfp410 not detected got VID %X: from %s Slave %d.\n",
-                          id, i2cbus->adapter.name, i2cbus->slave_addr);
+                          id, adapter->name, dvo->slave_addr);
                 goto out;
         }
 
         if ((id = tfp410_getid(dvo, TFP410_DID_LO)) != TFP410_DID) {
                 DRM_DEBUG("tfp410 not detected got DID %X: from %s Slave %d.\n",
-                          id, i2cbus->adapter.name, i2cbus->slave_addr);
+                          id, adapter->name, dvo->slave_addr);
                 goto out;
         }
         tfp->quiet = false;
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 98560e1e899a..e3cb4025e323 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -67,8 +67,6 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
 
         pci_save_state(dev->pdev);
 
-        i915_save_state(dev);
-
         /* If KMS is active, we do the leavevt stuff here */
         if (drm_core_check_feature(dev, DRIVER_MODESET)) {
                 if (i915_gem_idle(dev))
@@ -77,6 +75,8 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
                 drm_irq_uninstall(dev);
         }
 
+        i915_save_state(dev);
+
         intel_opregion_free(dev, 1);
 
         if (state.event == PM_EVENT_SUSPEND) {
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 7a84f04e8439..bb4c2d387b6c 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -306,6 +306,17 @@ typedef struct drm_i915_private {
         u32 saveCURBPOS;
         u32 saveCURBBASE;
         u32 saveCURSIZE;
+        u32 saveDP_B;
+        u32 saveDP_C;
+        u32 saveDP_D;
+        u32 savePIPEA_GMCH_DATA_M;
+        u32 savePIPEB_GMCH_DATA_M;
+        u32 savePIPEA_GMCH_DATA_N;
+        u32 savePIPEB_GMCH_DATA_N;
+        u32 savePIPEA_DP_LINK_M;
+        u32 savePIPEB_DP_LINK_M;
+        u32 savePIPEA_DP_LINK_N;
+        u32 savePIPEB_DP_LINK_N;
 
         struct {
                 struct drm_mm gtt_space;
@@ -857,6 +868,7 @@ extern int i915_wait_ring(struct drm_device * dev, int n, const char *caller);
 #define HAS_128_BYTE_Y_TILING(dev) (IS_I9XX(dev) && !(IS_I915G(dev) || \
                                                       IS_I915GM(dev)))
 #define SUPPORTS_INTEGRATED_HDMI(dev)   (IS_G4X(dev) || IS_IGDNG(dev))
+#define SUPPORTS_INTEGRATED_DP(dev)     (IS_G4X(dev) || IS_IGDNG(dev))
 #define I915_HAS_HOTPLUG(dev) (IS_I945G(dev) || IS_I945GM(dev) || IS_I965G(dev))
 
 #define PRIMARY_RINGBUFFER_SIZE         (128*1024)
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index fd2b8bdffe3f..876b65cb7629 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -1006,7 +1006,7 @@ i915_gem_set_domain_ioctl(struct drm_device *dev, void *data,
 
         mutex_lock(&dev->struct_mutex);
 #if WATCH_BUF
-        DRM_INFO("set_domain_ioctl %p(%d), %08x %08x\n",
+        DRM_INFO("set_domain_ioctl %p(%zd), %08x %08x\n",
                  obj, obj->size, read_domains, write_domain);
 #endif
         if (read_domains & I915_GEM_DOMAIN_GTT) {
@@ -1050,7 +1050,7 @@ i915_gem_sw_finish_ioctl(struct drm_device *dev, void *data,
         }
 
 #if WATCH_BUF
-        DRM_INFO("%s: sw_finish %d (%p %d)\n",
+        DRM_INFO("%s: sw_finish %d (%p %zd)\n",
                  __func__, args->handle, obj, obj->size);
 #endif
         obj_priv = obj->driver_private;
@@ -2423,7 +2423,7 @@ i915_gem_object_bind_to_gtt(struct drm_gem_object *obj, unsigned alignment)
         }
 
 #if WATCH_BUF
-        DRM_INFO("Binding object of size %d at 0x%08x\n",
+        DRM_INFO("Binding object of size %zd at 0x%08x\n",
                  obj->size, obj_priv->gtt_offset);
 #endif
         ret = i915_gem_object_get_pages(obj);
@@ -4227,6 +4227,7 @@ i915_gem_lastclose(struct drm_device *dev)
 void
 i915_gem_load(struct drm_device *dev)
 {
+        int i;
         drm_i915_private_t *dev_priv = dev->dev_private;
 
         spin_lock_init(&dev_priv->mm.active_list_lock);
@@ -4246,6 +4247,18 @@ i915_gem_load(struct drm_device *dev)
         else
                 dev_priv->num_fence_regs = 8;
 
+        /* Initialize fence registers to zero */
+        if (IS_I965G(dev)) {
+                for (i = 0; i < 16; i++)
+                        I915_WRITE64(FENCE_REG_965_0 + (i * 8), 0);
+        } else {
+                for (i = 0; i < 8; i++)
+                        I915_WRITE(FENCE_REG_830_0 + (i * 4), 0);
+                if (IS_I945G(dev) || IS_I945GM(dev) || IS_G33(dev))
+                        for (i = 0; i < 8; i++)
+                                I915_WRITE(FENCE_REG_945_8 + (i * 4), 0);
+        }
+
         i915_gem_detect_bit_6_swizzle(dev);
 }
 
diff --git a/drivers/gpu/drm/i915/i915_gem_debug.c b/drivers/gpu/drm/i915/i915_gem_debug.c
index 8d0b943e2c5a..e602614bd3f8 100644
--- a/drivers/gpu/drm/i915/i915_gem_debug.c
+++ b/drivers/gpu/drm/i915/i915_gem_debug.c
@@ -87,7 +87,7 @@ i915_gem_dump_object(struct drm_gem_object *obj, int len,
                         chunk_len = page_len - chunk;
                         if (chunk_len > 128)
                                 chunk_len = 128;
-                        i915_gem_dump_page(obj_priv->page_list[page],
+                        i915_gem_dump_page(obj_priv->pages[page],
                                            chunk, chunk + chunk_len,
                                            obj_priv->gtt_offset +
                                            page * PAGE_SIZE,
@@ -143,7 +143,7 @@ i915_gem_object_check_coherency(struct drm_gem_object *obj, int handle)
         uint32_t *backing_map = NULL;
         int bad_count = 0;
 
-        DRM_INFO("%s: checking coherency of object %p@0x%08x (%d, %dkb):\n",
+        DRM_INFO("%s: checking coherency of object %p@0x%08x (%d, %zdkb):\n",
                  __func__, obj, obj_priv->gtt_offset, handle,
                  obj->size / 1024);
 
@@ -157,7 +157,7 @@ i915_gem_object_check_coherency(struct drm_gem_object *obj, int handle)
         for (page = 0; page < obj->size / PAGE_SIZE; page++) {
                 int i;
 
-                backing_map = kmap_atomic(obj_priv->page_list[page], KM_USER0);
+                backing_map = kmap_atomic(obj_priv->pages[page], KM_USER0);
 
                 if (backing_map == NULL) {
                         DRM_ERROR("failed to map backing page\n");
diff --git a/drivers/gpu/drm/i915/i915_gem_tiling.c b/drivers/gpu/drm/i915/i915_gem_tiling.c
index 5c1ceec49f5b..daeae62e1c28 100644
--- a/drivers/gpu/drm/i915/i915_gem_tiling.c
+++ b/drivers/gpu/drm/i915/i915_gem_tiling.c
@@ -114,11 +114,13 @@ intel_alloc_mchbar_resource(struct drm_device *dev)
         mchbar_addr = ((u64)temp_hi << 32) | temp_lo;
 
         /* If ACPI doesn't have it, assume we need to allocate it ourselves */
+#ifdef CONFIG_PNP
         if (mchbar_addr &&
             pnp_range_reserved(mchbar_addr, mchbar_addr + MCHBAR_SIZE)) {
                 ret = 0;
                 goto out_put;
         }
+#endif
 
         /* Get some space for it */
         ret = pci_bus_alloc_resource(bridge_dev->bus, &dev_priv->mch_res,
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index b86b7b7130c6..228546f6eaa4 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -232,7 +232,17 @@ static void i915_hotplug_work_func(struct work_struct *work)
         drm_i915_private_t *dev_priv = container_of(work, drm_i915_private_t,
                                                     hotplug_work);
         struct drm_device *dev = dev_priv->dev;
-
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_connector *connector;
+
+        if (mode_config->num_connector) {
+                list_for_each_entry(connector, &mode_config->connector_list, head) {
+                        struct intel_output *intel_output = to_intel_output(connector);
+        
+                        if (intel_output->hot_plug)
+                                (*intel_output->hot_plug) (intel_output);
+                }
+        }
         /* Just fire off a uevent and let userspace tell us what to do */
         drm_sysfs_hotplug_event(dev);
 }
diff --git a/drivers/gpu/drm/i915/i915_opregion.c b/drivers/gpu/drm/i915/i915_opregion.c
index dc425e74a268..e4b4e8898e39 100644
--- a/drivers/gpu/drm/i915/i915_opregion.c
+++ b/drivers/gpu/drm/i915/i915_opregion.c
@@ -419,7 +419,7 @@ void intel_opregion_free(struct drm_device *dev, int suspend)
                 return;
 
         if (!suspend)
-                acpi_video_exit();
+                acpi_video_unregister();
 
         opregion->acpi->drdy = 0;
 
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index f6237a0b1133..88bf7521405f 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -569,6 +569,19 @@
 #define C0DRB3                  0x10206
 #define C1DRB3                  0x10606
 
+/* Clocking configuration register */
+#define CLKCFG                  0x10c00
+#define CLKCFG_FSB_400                                  (0 << 0)        /* hrawclk 100 */
+#define CLKCFG_FSB_533                                  (1 << 0)        /* hrawclk 133 */
+#define CLKCFG_FSB_667                                  (3 << 0)        /* hrawclk 166 */
+#define CLKCFG_FSB_800                                  (2 << 0)        /* hrawclk 200 */
+#define CLKCFG_FSB_1067                                 (6 << 0)        /* hrawclk 266 */
+#define CLKCFG_FSB_1333                                 (7 << 0)        /* hrawclk 333 */
+/* this is a guess, could be 5 as well */
+#define CLKCFG_FSB_1600                                 (4 << 0)        /* hrawclk 400 */
+#define CLKCFG_FSB_1600_ALT                             (5 << 0)        /* hrawclk 400 */
+#define CLKCFG_FSB_MASK                                 (7 << 0)
+ 
 /** GM965 GM45 render standby register */
 #define MCHBAR_RENDER_STANDBY   0x111B8
 
@@ -834,9 +847,25 @@
 #define   HORIZ_INTERP_MASK     (3 << 6)
 #define   HORIZ_AUTO_SCALE      (1 << 5)
 #define   PANEL_8TO6_DITHER_ENABLE (1 << 3)
+#define   PFIT_FILTER_FUZZY     (0 << 24)
+#define   PFIT_SCALING_AUTO     (0 << 26)
+#define   PFIT_SCALING_PROGRAMMED (1 << 26)
+#define   PFIT_SCALING_PILLAR   (2 << 26)
+#define   PFIT_SCALING_LETTER   (3 << 26)
 #define PFIT_PGM_RATIOS 0x61234
 #define   PFIT_VERT_SCALE_MASK                  0xfff00000
 #define   PFIT_HORIZ_SCALE_MASK                 0x0000fff0
+/* Pre-965 */
+#define         PFIT_VERT_SCALE_SHIFT           20
+#define         PFIT_VERT_SCALE_MASK            0xfff00000
+#define         PFIT_HORIZ_SCALE_SHIFT          4
+#define         PFIT_HORIZ_SCALE_MASK           0x0000fff0
+/* 965+ */
+#define         PFIT_VERT_SCALE_SHIFT_965       16
+#define         PFIT_VERT_SCALE_MASK_965        0x1fff0000
+#define         PFIT_HORIZ_SCALE_SHIFT_965      0
+#define         PFIT_HORIZ_SCALE_MASK_965       0x00001fff
+
 #define PFIT_AUTO_RATIOS 0x61238
 
 /* Backlight control */
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index a98e2831ed31..8d8e083d14ab 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -322,6 +322,20 @@ int i915_save_state(struct drm_device *dev)
         dev_priv->savePP_OFF_DELAYS = I915_READ(PP_OFF_DELAYS);
         dev_priv->savePP_DIVISOR = I915_READ(PP_DIVISOR);
 
+        /* Display Port state */
+        if (SUPPORTS_INTEGRATED_DP(dev)) {
+                dev_priv->saveDP_B = I915_READ(DP_B);
+                dev_priv->saveDP_C = I915_READ(DP_C);
+                dev_priv->saveDP_D = I915_READ(DP_D);
+                dev_priv->savePIPEA_GMCH_DATA_M = I915_READ(PIPEA_GMCH_DATA_M);
+                dev_priv->savePIPEB_GMCH_DATA_M = I915_READ(PIPEB_GMCH_DATA_M);
+                dev_priv->savePIPEA_GMCH_DATA_N = I915_READ(PIPEA_GMCH_DATA_N);
+                dev_priv->savePIPEB_GMCH_DATA_N = I915_READ(PIPEB_GMCH_DATA_N);
+                dev_priv->savePIPEA_DP_LINK_M = I915_READ(PIPEA_DP_LINK_M);
+                dev_priv->savePIPEB_DP_LINK_M = I915_READ(PIPEB_DP_LINK_M);
+                dev_priv->savePIPEA_DP_LINK_N = I915_READ(PIPEA_DP_LINK_N);
+                dev_priv->savePIPEB_DP_LINK_N = I915_READ(PIPEB_DP_LINK_N);
+        }
         /* FIXME: save TV & SDVO state */
 
         /* FBC state */
@@ -404,7 +418,19 @@ int i915_restore_state(struct drm_device *dev)
                         for (i = 0; i < 8; i++)
                                 I915_WRITE(FENCE_REG_945_8 + (i * 4), dev_priv->saveFENCE[i+8]);
         }
-
+        
+        /* Display port ratios (must be done before clock is set) */
+        if (SUPPORTS_INTEGRATED_DP(dev)) {
+                I915_WRITE(PIPEA_GMCH_DATA_M, dev_priv->savePIPEA_GMCH_DATA_M);
+                I915_WRITE(PIPEB_GMCH_DATA_M, dev_priv->savePIPEB_GMCH_DATA_M);
+                I915_WRITE(PIPEA_GMCH_DATA_N, dev_priv->savePIPEA_GMCH_DATA_N);
+                I915_WRITE(PIPEB_GMCH_DATA_N, dev_priv->savePIPEB_GMCH_DATA_N);
+                I915_WRITE(PIPEA_DP_LINK_M, dev_priv->savePIPEA_DP_LINK_M);
+                I915_WRITE(PIPEB_DP_LINK_M, dev_priv->savePIPEB_DP_LINK_M);
+                I915_WRITE(PIPEA_DP_LINK_N, dev_priv->savePIPEA_DP_LINK_N);
+                I915_WRITE(PIPEB_DP_LINK_N, dev_priv->savePIPEB_DP_LINK_N);
+        }
+        
         /* Pipe & plane A info */
         /* Prime the clock */
         if (dev_priv->saveDPLL_A & DPLL_VCO_ENABLE) {
@@ -518,6 +544,12 @@ int i915_restore_state(struct drm_device *dev)
         I915_WRITE(PP_DIVISOR, dev_priv->savePP_DIVISOR);
         I915_WRITE(PP_CONTROL, dev_priv->savePP_CONTROL);
 
+        /* Display Port state */
+        if (SUPPORTS_INTEGRATED_DP(dev)) {
+                I915_WRITE(DP_B, dev_priv->saveDP_B);
+                I915_WRITE(DP_C, dev_priv->saveDP_C);
+                I915_WRITE(DP_D, dev_priv->saveDP_D);
+        }
         /* FIXME: restore TV & SDVO state */
 
         /* FBC info */
diff --git a/drivers/gpu/drm/i915/intel_bios.c b/drivers/gpu/drm/i915/intel_bios.c
index cdd126d068a7..716409a57244 100644
--- a/drivers/gpu/drm/i915/intel_bios.c
+++ b/drivers/gpu/drm/i915/intel_bios.c
@@ -99,9 +99,11 @@ parse_lfp_panel_data(struct drm_i915_private *dev_priv,
 {
         struct bdb_lvds_options *lvds_options;
         struct bdb_lvds_lfp_data *lvds_lfp_data;
+        struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs;
         struct bdb_lvds_lfp_data_entry *entry;
         struct lvds_dvo_timing *dvo_timing;
         struct drm_display_mode *panel_fixed_mode;
+        int lfp_data_size;
 
         /* Defaults if we can't find VBT info */
         dev_priv->lvds_dither = 0;
@@ -119,9 +121,17 @@ parse_lfp_panel_data(struct drm_i915_private *dev_priv,
         if (!lvds_lfp_data)
                 return;
 
+        lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS);
+        if (!lvds_lfp_data_ptrs)
+                return;
+
         dev_priv->lvds_vbt = 1;
 
-        entry = &lvds_lfp_data->data[lvds_options->panel_type];
+        lfp_data_size = lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset -
+                lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset;
+        entry = (struct bdb_lvds_lfp_data_entry *)
+                ((uint8_t *)lvds_lfp_data->data + (lfp_data_size *
+                                                   lvds_options->panel_type));
         dvo_timing = &entry->dvo_timing;
 
         panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 3e1c78162119..73e7b9cecac8 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -29,6 +29,7 @@
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
+#include "intel_dp.h"
 
 #include "drm_crtc_helper.h"
 
@@ -127,19 +128,6 @@ struct intel_limit {
 #define I9XX_P2_LVDS_FAST                     7
 #define I9XX_P2_LVDS_SLOW_LIMIT          112000
 
-#define INTEL_LIMIT_I8XX_DVO_DAC    0
-#define INTEL_LIMIT_I8XX_LVDS       1
-#define INTEL_LIMIT_I9XX_SDVO_DAC   2
-#define INTEL_LIMIT_I9XX_LVDS       3
-#define INTEL_LIMIT_G4X_SDVO        4
-#define INTEL_LIMIT_G4X_HDMI_DAC   5
-#define INTEL_LIMIT_G4X_SINGLE_CHANNEL_LVDS   6
-#define INTEL_LIMIT_G4X_DUAL_CHANNEL_LVDS   7
-#define INTEL_LIMIT_IGD_SDVO_DAC    8
-#define INTEL_LIMIT_IGD_LVDS        9
-#define INTEL_LIMIT_IGDNG_SDVO_DAC  10
-#define INTEL_LIMIT_IGDNG_LVDS      11
-
 /*The parameter is for SDVO on G4x platform*/
 #define G4X_DOT_SDVO_MIN           25000
 #define G4X_DOT_SDVO_MAX           270000
@@ -218,6 +206,25 @@ struct intel_limit {
 #define G4X_P2_DUAL_CHANNEL_LVDS_FAST           7
 #define G4X_P2_DUAL_CHANNEL_LVDS_LIMIT          0
 
+/*The parameter is for DISPLAY PORT on G4x platform*/
+#define G4X_DOT_DISPLAY_PORT_MIN           161670
+#define G4X_DOT_DISPLAY_PORT_MAX           227000
+#define G4X_N_DISPLAY_PORT_MIN             1
+#define G4X_N_DISPLAY_PORT_MAX             2
+#define G4X_M_DISPLAY_PORT_MIN             97
+#define G4X_M_DISPLAY_PORT_MAX             108
+#define G4X_M1_DISPLAY_PORT_MIN            0x10
+#define G4X_M1_DISPLAY_PORT_MAX            0x12
+#define G4X_M2_DISPLAY_PORT_MIN            0x05
+#define G4X_M2_DISPLAY_PORT_MAX            0x06
+#define G4X_P_DISPLAY_PORT_MIN             10
+#define G4X_P_DISPLAY_PORT_MAX             20
+#define G4X_P1_DISPLAY_PORT_MIN            1
+#define G4X_P1_DISPLAY_PORT_MAX            2
+#define G4X_P2_DISPLAY_PORT_SLOW           10
+#define G4X_P2_DISPLAY_PORT_FAST           10
+#define G4X_P2_DISPLAY_PORT_LIMIT          0
+
 /* IGDNG */
 /* as we calculate clock using (register_value + 2) for
    N/M1/M2, so here the range value for them is (actual_value-2).
@@ -256,8 +263,11 @@ static bool
 intel_igdng_find_best_PLL(const intel_limit_t *limit, struct drm_crtc *crtc,
                         int target, int refclk, intel_clock_t *best_clock);
 
-static const intel_limit_t intel_limits[] = {
-    { /* INTEL_LIMIT_I8XX_DVO_DAC */
+static bool
+intel_find_pll_g4x_dp(const intel_limit_t *, struct drm_crtc *crtc,
+                      int target, int refclk, intel_clock_t *best_clock);
+
+static const intel_limit_t intel_limits_i8xx_dvo = {
         .dot = { .min = I8XX_DOT_MIN,           .max = I8XX_DOT_MAX },
         .vco = { .min = I8XX_VCO_MIN,           .max = I8XX_VCO_MAX },
         .n   = { .min = I8XX_N_MIN,             .max = I8XX_N_MAX },
@@ -269,8 +279,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I8XX_P2_SLOW_LIMIT,
                  .p2_slow = I8XX_P2_SLOW,       .p2_fast = I8XX_P2_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_I8XX_LVDS */
+};
+
+static const intel_limit_t intel_limits_i8xx_lvds = {
         .dot = { .min = I8XX_DOT_MIN,           .max = I8XX_DOT_MAX },
         .vco = { .min = I8XX_VCO_MIN,           .max = I8XX_VCO_MAX },
         .n   = { .min = I8XX_N_MIN,             .max = I8XX_N_MAX },
@@ -282,8 +293,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I8XX_P2_SLOW_LIMIT,
                  .p2_slow = I8XX_P2_LVDS_SLOW,  .p2_fast = I8XX_P2_LVDS_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_I9XX_SDVO_DAC */
+};
+        
+static const intel_limit_t intel_limits_i9xx_sdvo = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX },
         .vco = { .min = I9XX_VCO_MIN,           .max = I9XX_VCO_MAX },
         .n   = { .min = I9XX_N_MIN,             .max = I9XX_N_MAX },
@@ -295,8 +307,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_SDVO_DAC_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_SDVO_DAC_SLOW,      .p2_fast = I9XX_P2_SDVO_DAC_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_I9XX_LVDS */
+};
+
+static const intel_limit_t intel_limits_i9xx_lvds = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX },
         .vco = { .min = I9XX_VCO_MIN,           .max = I9XX_VCO_MAX },
         .n   = { .min = I9XX_N_MIN,             .max = I9XX_N_MAX },
@@ -311,9 +324,10 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_LVDS_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_LVDS_SLOW,  .p2_fast = I9XX_P2_LVDS_FAST },
         .find_pll = intel_find_best_PLL,
-    },
+};
+
     /* below parameter and function is for G4X Chipset Family*/
-    { /* INTEL_LIMIT_G4X_SDVO */
+static const intel_limit_t intel_limits_g4x_sdvo = {
         .dot = { .min = G4X_DOT_SDVO_MIN,       .max = G4X_DOT_SDVO_MAX },
         .vco = { .min = G4X_VCO_MIN,            .max = G4X_VCO_MAX},
         .n   = { .min = G4X_N_SDVO_MIN,         .max = G4X_N_SDVO_MAX },
@@ -327,8 +341,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_SDVO_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_G4X_HDMI_DAC */
+};
+
+static const intel_limit_t intel_limits_g4x_hdmi = {
         .dot = { .min = G4X_DOT_HDMI_DAC_MIN,   .max = G4X_DOT_HDMI_DAC_MAX },
         .vco = { .min = G4X_VCO_MIN,            .max = G4X_VCO_MAX},
         .n   = { .min = G4X_N_HDMI_DAC_MIN,     .max = G4X_N_HDMI_DAC_MAX },
@@ -342,8 +357,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_HDMI_DAC_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_G4X_SINGLE_CHANNEL_LVDS */
+};
+
+static const intel_limit_t intel_limits_g4x_single_channel_lvds = {
         .dot = { .min = G4X_DOT_SINGLE_CHANNEL_LVDS_MIN,
                  .max = G4X_DOT_SINGLE_CHANNEL_LVDS_MAX },
         .vco = { .min = G4X_VCO_MIN,
@@ -365,8 +381,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_SINGLE_CHANNEL_LVDS_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_G4X_DUAL_CHANNEL_LVDS */
+};
+
+static const intel_limit_t intel_limits_g4x_dual_channel_lvds = {
         .dot = { .min = G4X_DOT_DUAL_CHANNEL_LVDS_MIN,
                  .max = G4X_DOT_DUAL_CHANNEL_LVDS_MAX },
         .vco = { .min = G4X_VCO_MIN,
@@ -388,8 +405,32 @@ static const intel_limit_t intel_limits[] = {
                  .p2_fast = G4X_P2_DUAL_CHANNEL_LVDS_FAST
         },
         .find_pll = intel_g4x_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGD_SDVO */
+};
+
+static const intel_limit_t intel_limits_g4x_display_port = {
+        .dot = { .min = G4X_DOT_DISPLAY_PORT_MIN,
+                 .max = G4X_DOT_DISPLAY_PORT_MAX },
+        .vco = { .min = G4X_VCO_MIN,
+                 .max = G4X_VCO_MAX},
+        .n   = { .min = G4X_N_DISPLAY_PORT_MIN,
+                 .max = G4X_N_DISPLAY_PORT_MAX },
+        .m   = { .min = G4X_M_DISPLAY_PORT_MIN,
+                 .max = G4X_M_DISPLAY_PORT_MAX },
+        .m1  = { .min = G4X_M1_DISPLAY_PORT_MIN,
+                 .max = G4X_M1_DISPLAY_PORT_MAX },
+        .m2  = { .min = G4X_M2_DISPLAY_PORT_MIN,
+                 .max = G4X_M2_DISPLAY_PORT_MAX },
+        .p   = { .min = G4X_P_DISPLAY_PORT_MIN,
+                 .max = G4X_P_DISPLAY_PORT_MAX },
+        .p1  = { .min = G4X_P1_DISPLAY_PORT_MIN,
+                 .max = G4X_P1_DISPLAY_PORT_MAX},
+        .p2  = { .dot_limit = G4X_P2_DISPLAY_PORT_LIMIT,
+                 .p2_slow = G4X_P2_DISPLAY_PORT_SLOW,
+                 .p2_fast = G4X_P2_DISPLAY_PORT_FAST },
+        .find_pll = intel_find_pll_g4x_dp,
+};
+
+static const intel_limit_t intel_limits_igd_sdvo = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX},
         .vco = { .min = IGD_VCO_MIN,            .max = IGD_VCO_MAX },
         .n   = { .min = IGD_N_MIN,              .max = IGD_N_MAX },
@@ -401,8 +442,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_SDVO_DAC_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_SDVO_DAC_SLOW,      .p2_fast = I9XX_P2_SDVO_DAC_FAST },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGD_LVDS */
+};
+
+static const intel_limit_t intel_limits_igd_lvds = {
         .dot = { .min = I9XX_DOT_MIN,           .max = I9XX_DOT_MAX },
         .vco = { .min = IGD_VCO_MIN,            .max = IGD_VCO_MAX },
         .n   = { .min = IGD_N_MIN,              .max = IGD_N_MAX },
@@ -415,8 +457,9 @@ static const intel_limit_t intel_limits[] = {
         .p2  = { .dot_limit = I9XX_P2_LVDS_SLOW_LIMIT,
                  .p2_slow = I9XX_P2_LVDS_SLOW,  .p2_fast = I9XX_P2_LVDS_SLOW },
         .find_pll = intel_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGDNG_SDVO_DAC */
+};
+
+static const intel_limit_t intel_limits_igdng_sdvo = {
         .dot = { .min = IGDNG_DOT_MIN,          .max = IGDNG_DOT_MAX },
         .vco = { .min = IGDNG_VCO_MIN,          .max = IGDNG_VCO_MAX },
         .n   = { .min = IGDNG_N_MIN,            .max = IGDNG_N_MAX },
@@ -429,8 +472,9 @@ static const intel_limit_t intel_limits[] = {
                  .p2_slow = IGDNG_P2_SDVO_DAC_SLOW,
                  .p2_fast = IGDNG_P2_SDVO_DAC_FAST },
         .find_pll = intel_igdng_find_best_PLL,
-    },
-    { /* INTEL_LIMIT_IGDNG_LVDS */
+};
+
+static const intel_limit_t intel_limits_igdng_lvds = {
         .dot = { .min = IGDNG_DOT_MIN,          .max = IGDNG_DOT_MAX },
         .vco = { .min = IGDNG_VCO_MIN,          .max = IGDNG_VCO_MAX },
         .n   = { .min = IGDNG_N_MIN,            .max = IGDNG_N_MAX },
@@ -443,16 +487,15 @@ static const intel_limit_t intel_limits[] = {
                  .p2_slow = IGDNG_P2_LVDS_SLOW,
                  .p2_fast = IGDNG_P2_LVDS_FAST },
         .find_pll = intel_igdng_find_best_PLL,
-    },
 };
 
 static const intel_limit_t *intel_igdng_limit(struct drm_crtc *crtc)
 {
         const intel_limit_t *limit;
         if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                limit = &intel_limits[INTEL_LIMIT_IGDNG_LVDS];
+                limit = &intel_limits_igdng_lvds;
         else
-                limit = &intel_limits[INTEL_LIMIT_IGDNG_SDVO_DAC];
+                limit = &intel_limits_igdng_sdvo;
 
         return limit;
 }
@@ -467,19 +510,19 @@ static const intel_limit_t *intel_g4x_limit(struct drm_crtc *crtc)
                 if ((I915_READ(LVDS) & LVDS_CLKB_POWER_MASK) ==
                     LVDS_CLKB_POWER_UP)
                         /* LVDS with dual channel */
-                        limit = &intel_limits
-                                        [INTEL_LIMIT_G4X_DUAL_CHANNEL_LVDS];
+                        limit = &intel_limits_g4x_dual_channel_lvds;
                 else
                         /* LVDS with dual channel */
-                        limit = &intel_limits
-                                        [INTEL_LIMIT_G4X_SINGLE_CHANNEL_LVDS];
+                        limit = &intel_limits_g4x_single_channel_lvds;
         } else if (intel_pipe_has_type(crtc, INTEL_OUTPUT_HDMI) ||
                    intel_pipe_has_type(crtc, INTEL_OUTPUT_ANALOG)) {
-                limit = &intel_limits[INTEL_LIMIT_G4X_HDMI_DAC];
+                limit = &intel_limits_g4x_hdmi;
         } else if (intel_pipe_has_type(crtc, INTEL_OUTPUT_SDVO)) {
-                limit = &intel_limits[INTEL_LIMIT_G4X_SDVO];
+                limit = &intel_limits_g4x_sdvo;
+        } else if (intel_pipe_has_type (crtc, INTEL_OUTPUT_DISPLAYPORT)) {
+                limit = &intel_limits_g4x_display_port;
         } else /* The option is for other outputs */
-                limit = &intel_limits[INTEL_LIMIT_I9XX_SDVO_DAC];
+                limit = &intel_limits_i9xx_sdvo;
 
         return limit;
 }
@@ -495,19 +538,19 @@ static const intel_limit_t *intel_limit(struct drm_crtc *crtc)
                 limit = intel_g4x_limit(crtc);
         } else if (IS_I9XX(dev) && !IS_IGD(dev)) {
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                        limit = &intel_limits[INTEL_LIMIT_I9XX_LVDS];
+                        limit = &intel_limits_i9xx_lvds;
                 else
-                        limit = &intel_limits[INTEL_LIMIT_I9XX_SDVO_DAC];
+                        limit = &intel_limits_i9xx_sdvo;
         } else if (IS_IGD(dev)) {
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                        limit = &intel_limits[INTEL_LIMIT_IGD_LVDS];
+                        limit = &intel_limits_igd_lvds;
                 else
-                        limit = &intel_limits[INTEL_LIMIT_IGD_SDVO_DAC];
+                        limit = &intel_limits_igd_sdvo;
         } else {
                 if (intel_pipe_has_type(crtc, INTEL_OUTPUT_LVDS))
-                        limit = &intel_limits[INTEL_LIMIT_I8XX_LVDS];
+                        limit = &intel_limits_i8xx_lvds;
                 else
-                        limit = &intel_limits[INTEL_LIMIT_I8XX_DVO_DAC];
+                        limit = &intel_limits_i8xx_dvo;
         }
         return limit;
 }
@@ -764,6 +807,35 @@ out:
         return found;
 }
 
+/* DisplayPort has only two frequencies, 162MHz and 270MHz */
+static bool
+intel_find_pll_g4x_dp(const intel_limit_t *limit, struct drm_crtc *crtc,
+                      int target, int refclk, intel_clock_t *best_clock)
+{
+    intel_clock_t clock;
+    if (target < 200000) {
+        clock.dot = 161670;
+        clock.p = 20;
+        clock.p1 = 2;
+        clock.p2 = 10;
+        clock.n = 0x01;
+        clock.m = 97;
+        clock.m1 = 0x10;
+        clock.m2 = 0x05;
+    } else {
+        clock.dot = 270000;
+        clock.p = 10;
+        clock.p1 = 1;
+        clock.p2 = 10;
+        clock.n = 0x02;
+        clock.m = 108;
+        clock.m1 = 0x12;
+        clock.m2 = 0x06;
+    }
+    memcpy(best_clock, &clock, sizeof(intel_clock_t));
+    return true;
+}
+
 void
 intel_wait_for_vblank(struct drm_device *dev)
 {
@@ -1541,7 +1613,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         intel_clock_t clock;
         u32 dpll = 0, fp = 0, dspcntr, pipeconf;
         bool ok, is_sdvo = false, is_dvo = false;
-        bool is_crt = false, is_lvds = false, is_tv = false;
+        bool is_crt = false, is_lvds = false, is_tv = false, is_dp = false;
         struct drm_mode_config *mode_config = &dev->mode_config;
         struct drm_connector *connector;
         const intel_limit_t *limit;
@@ -1585,6 +1657,9 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 case INTEL_OUTPUT_ANALOG:
                         is_crt = true;
                         break;
+                case INTEL_OUTPUT_DISPLAYPORT:
+                        is_dp = true;
+                        break;
                 }
 
                 num_outputs++;
@@ -1600,6 +1675,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
         } else {
                 refclk = 48000;
         }
+        
 
         /*
          * Returns a set of divisors for the desired target clock with the given
@@ -1662,6 +1738,8 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                         else if (IS_IGDNG(dev))
                                 dpll |= (sdvo_pixel_multiply - 1) << PLL_REF_SDVO_HDMI_MULTIPLIER_SHIFT;
                 }
+                if (is_dp)
+                        dpll |= DPLL_DVO_HIGH_SPEED;
 
                 /* compute bitmask from p1 value */
                 if (IS_IGD(dev))
@@ -1809,6 +1887,8 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 I915_WRITE(lvds_reg, lvds);
                 I915_READ(lvds_reg);
         }
+        if (is_dp)
+                intel_dp_set_m_n(crtc, mode, adjusted_mode);
 
         I915_WRITE(fp_reg, fp);
         I915_WRITE(dpll_reg, dpll);
@@ -2475,6 +2555,8 @@ static void intel_setup_outputs(struct drm_device *dev)
                         found = intel_sdvo_init(dev, SDVOB);
                         if (!found && SUPPORTS_INTEGRATED_HDMI(dev))
                                 intel_hdmi_init(dev, SDVOB);
+                        if (!found && SUPPORTS_INTEGRATED_DP(dev))
+                                intel_dp_init(dev, DP_B);
                 }
 
                 /* Before G4X SDVOC doesn't have its own detect register */
@@ -2487,7 +2569,11 @@ static void intel_setup_outputs(struct drm_device *dev)
                         found = intel_sdvo_init(dev, SDVOC);
                         if (!found && SUPPORTS_INTEGRATED_HDMI(dev))
                                 intel_hdmi_init(dev, SDVOC);
+                        if (!found && SUPPORTS_INTEGRATED_DP(dev))
+                                intel_dp_init(dev, DP_C);
                 }
+                if (SUPPORTS_INTEGRATED_DP(dev) && (I915_READ(DP_D) & DP_DETECTED))
+                        intel_dp_init(dev, DP_D);
         } else
                 intel_dvo_init(dev);
 
@@ -2530,6 +2616,11 @@ static void intel_setup_outputs(struct drm_device *dev)
                                      (1 << 1));
                         clone_mask = (1 << INTEL_OUTPUT_TVOUT);
                         break;
+                case INTEL_OUTPUT_DISPLAYPORT:
+                        crtc_mask = ((1 << 0) |
+                                     (1 << 1));
+                        clone_mask = (1 << INTEL_OUTPUT_DISPLAYPORT);
+                        break;
                 }
                 encoder->possible_crtcs = crtc_mask;
                 encoder->possible_clones = intel_connector_clones(dev, clone_mask);
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
new file mode 100644
index 000000000000..8f8d37d5663a
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -0,0 +1,1153 @@
+/*
+ * Copyright © 2008 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ *
+ * Authors:
+ *    Keith Packard <keithp@keithp.com>
+ *
+ */
+
+#include <linux/i2c.h>
+#include "drmP.h"
+#include "drm.h"
+#include "drm_crtc.h"
+#include "drm_crtc_helper.h"
+#include "intel_drv.h"
+#include "i915_drm.h"
+#include "i915_drv.h"
+#include "intel_dp.h"
+
+#define DP_LINK_STATUS_SIZE     6
+#define DP_LINK_CHECK_TIMEOUT   (10 * 1000)
+
+#define DP_LINK_CONFIGURATION_SIZE      9
+
+struct intel_dp_priv {
+        uint32_t output_reg;
+        uint32_t DP;
+        uint8_t  link_configuration[DP_LINK_CONFIGURATION_SIZE];
+        uint32_t save_DP;
+        uint8_t  save_link_configuration[DP_LINK_CONFIGURATION_SIZE];
+        bool has_audio;
+        int dpms_mode;
+        uint8_t link_bw;
+        uint8_t lane_count;
+        uint8_t dpcd[4];
+        struct intel_output *intel_output;
+        struct i2c_adapter adapter;
+        struct i2c_algo_dp_aux_data algo;
+};
+
+static void
+intel_dp_link_train(struct intel_output *intel_output, uint32_t DP,
+                    uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE]);
+
+static void
+intel_dp_link_down(struct intel_output *intel_output, uint32_t DP);
+
+static int
+intel_dp_max_lane_count(struct intel_output *intel_output)
+{
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+        int max_lane_count = 4;
+
+        if (dp_priv->dpcd[0] >= 0x11) {
+                max_lane_count = dp_priv->dpcd[2] & 0x1f;
+                switch (max_lane_count) {
+                case 1: case 2: case 4:
+                        break;
+                default:
+                        max_lane_count = 4;
+                }
+        }
+        return max_lane_count;
+}
+
+static int
+intel_dp_max_link_bw(struct intel_output *intel_output)
+{
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+        int max_link_bw = dp_priv->dpcd[1];
+
+        switch (max_link_bw) {
+        case DP_LINK_BW_1_62:
+        case DP_LINK_BW_2_7:
+                break;
+        default:
+                max_link_bw = DP_LINK_BW_1_62;
+                break;
+        }
+        return max_link_bw;
+}
+
+static int
+intel_dp_link_clock(uint8_t link_bw)
+{
+        if (link_bw == DP_LINK_BW_2_7)
+                return 270000;
+        else
+                return 162000;
+}
+
+/* I think this is a fiction */
+static int
+intel_dp_link_required(int pixel_clock)
+{
+        return pixel_clock * 3;
+}
+
+static int
+intel_dp_mode_valid(struct drm_connector *connector,
+                    struct drm_display_mode *mode)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        int max_link_clock = intel_dp_link_clock(intel_dp_max_link_bw(intel_output));
+        int max_lanes = intel_dp_max_lane_count(intel_output);
+
+        if (intel_dp_link_required(mode->clock) > max_link_clock * max_lanes)
+                return MODE_CLOCK_HIGH;
+
+        if (mode->clock < 10000)
+                return MODE_CLOCK_LOW;
+
+        return MODE_OK;
+}
+
+static uint32_t
+pack_aux(uint8_t *src, int src_bytes)
+{
+        int     i;
+        uint32_t v = 0;
+
+        if (src_bytes > 4)
+                src_bytes = 4;
+        for (i = 0; i < src_bytes; i++)
+                v |= ((uint32_t) src[i]) << ((3-i) * 8);
+        return v;
+}
+
+static void
+unpack_aux(uint32_t src, uint8_t *dst, int dst_bytes)
+{
+        int i;
+        if (dst_bytes > 4)
+                dst_bytes = 4;
+        for (i = 0; i < dst_bytes; i++)
+                dst[i] = src >> ((3-i) * 8);
+}
+
+/* hrawclock is 1/4 the FSB frequency */
+static int
+intel_hrawclk(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t clkcfg;
+
+        clkcfg = I915_READ(CLKCFG);
+        switch (clkcfg & CLKCFG_FSB_MASK) {
+        case CLKCFG_FSB_400:
+                return 100;
+        case CLKCFG_FSB_533:
+                return 133;
+        case CLKCFG_FSB_667:
+                return 166;
+        case CLKCFG_FSB_800:
+                return 200;
+        case CLKCFG_FSB_1067:
+                return 266;
+        case CLKCFG_FSB_1333:
+                return 333;
+        /* these two are just a guess; one of them might be right */
+        case CLKCFG_FSB_1600:
+        case CLKCFG_FSB_1600_ALT:
+                return 400;
+        default:
+                return 133;
+        }
+}
+
+static int
+intel_dp_aux_ch(struct intel_output *intel_output,
+                uint8_t *send, int send_bytes,
+                uint8_t *recv, int recv_size)
+{
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint32_t output_reg = dp_priv->output_reg;
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t ch_ctl = output_reg + 0x10;
+        uint32_t ch_data = ch_ctl + 4;
+        int i;
+        int recv_bytes;
+        uint32_t ctl;
+        uint32_t status;
+        uint32_t aux_clock_divider;
+        int try;
+
+        /* The clock divider is based off the hrawclk,
+         * and would like to run at 2MHz. So, take the
+         * hrawclk value and divide by 2 and use that
+         */
+        aux_clock_divider = intel_hrawclk(dev) / 2;
+        /* Must try at least 3 times according to DP spec */
+        for (try = 0; try < 5; try++) {
+                /* Load the send data into the aux channel data registers */
+                for (i = 0; i < send_bytes; i += 4) {
+                        uint32_t    d = pack_aux(send + i, send_bytes - i);;
+        
+                        I915_WRITE(ch_data + i, d);
+                }
+        
+                ctl = (DP_AUX_CH_CTL_SEND_BUSY |
+                       DP_AUX_CH_CTL_TIME_OUT_400us |
+                       (send_bytes << DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT) |
+                       (5 << DP_AUX_CH_CTL_PRECHARGE_2US_SHIFT) |
+                       (aux_clock_divider << DP_AUX_CH_CTL_BIT_CLOCK_2X_SHIFT) |
+                       DP_AUX_CH_CTL_DONE |
+                       DP_AUX_CH_CTL_TIME_OUT_ERROR |
+                       DP_AUX_CH_CTL_RECEIVE_ERROR);
+        
+                /* Send the command and wait for it to complete */
+                I915_WRITE(ch_ctl, ctl);
+                (void) I915_READ(ch_ctl);
+                for (;;) {
+                        udelay(100);
+                        status = I915_READ(ch_ctl);
+                        if ((status & DP_AUX_CH_CTL_SEND_BUSY) == 0)
+                                break;
+                }
+        
+                /* Clear done status and any errors */
+                I915_WRITE(ch_ctl, (ctl |
+                                DP_AUX_CH_CTL_DONE |
+                                DP_AUX_CH_CTL_TIME_OUT_ERROR |
+                                DP_AUX_CH_CTL_RECEIVE_ERROR));
+                (void) I915_READ(ch_ctl);
+                if ((status & DP_AUX_CH_CTL_TIME_OUT_ERROR) == 0)
+                        break;
+        }
+
+        if ((status & DP_AUX_CH_CTL_DONE) == 0) {
+                printk(KERN_ERR "dp_aux_ch not done status 0x%08x\n", status);
+                return -EBUSY;
+        }
+
+        /* Check for timeout or receive error.
+         * Timeouts occur when the sink is not connected
+         */
+        if (status & DP_AUX_CH_CTL_RECEIVE_ERROR) {
+                printk(KERN_ERR "dp_aux_ch receive error status 0x%08x\n", status);
+                return -EIO;
+        }
+        if (status & DP_AUX_CH_CTL_TIME_OUT_ERROR) {
+                printk(KERN_ERR "dp_aux_ch timeout status 0x%08x\n", status);
+                return -ETIMEDOUT;
+        }
+
+        /* Unload any bytes sent back from the other side */
+        recv_bytes = ((status & DP_AUX_CH_CTL_MESSAGE_SIZE_MASK) >>
+                      DP_AUX_CH_CTL_MESSAGE_SIZE_SHIFT);
+
+        if (recv_bytes > recv_size)
+                recv_bytes = recv_size;
+        
+        for (i = 0; i < recv_bytes; i += 4) {
+                uint32_t    d = I915_READ(ch_data + i);
+
+                unpack_aux(d, recv + i, recv_bytes - i);
+        }
+
+        return recv_bytes;
+}
+
+/* Write data to the aux channel in native mode */
+static int
+intel_dp_aux_native_write(struct intel_output *intel_output,
+                          uint16_t address, uint8_t *send, int send_bytes)
+{
+        int ret;
+        uint8_t msg[20];
+        int msg_bytes;
+        uint8_t ack;
+
+        if (send_bytes > 16)
+                return -1;
+        msg[0] = AUX_NATIVE_WRITE << 4;
+        msg[1] = address >> 8;
+        msg[2] = address;
+        msg[3] = send_bytes - 1;
+        memcpy(&msg[4], send, send_bytes);
+        msg_bytes = send_bytes + 4;
+        for (;;) {
+                ret = intel_dp_aux_ch(intel_output, msg, msg_bytes, &ack, 1);
+                if (ret < 0)
+                        return ret;
+                if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK)
+                        break;
+                else if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_DEFER)
+                        udelay(100);
+                else
+                        return -EIO;
+        }
+        return send_bytes;
+}
+
+/* Write a single byte to the aux channel in native mode */
+static int
+intel_dp_aux_native_write_1(struct intel_output *intel_output,
+                            uint16_t address, uint8_t byte)
+{
+        return intel_dp_aux_native_write(intel_output, address, &byte, 1);
+}
+
+/* read bytes from a native aux channel */
+static int
+intel_dp_aux_native_read(struct intel_output *intel_output,
+                         uint16_t address, uint8_t *recv, int recv_bytes)
+{
+        uint8_t msg[4];
+        int msg_bytes;
+        uint8_t reply[20];
+        int reply_bytes;
+        uint8_t ack;
+        int ret;
+
+        msg[0] = AUX_NATIVE_READ << 4;
+        msg[1] = address >> 8;
+        msg[2] = address & 0xff;
+        msg[3] = recv_bytes - 1;
+
+        msg_bytes = 4;
+        reply_bytes = recv_bytes + 1;
+
+        for (;;) {
+                ret = intel_dp_aux_ch(intel_output, msg, msg_bytes,
+                                      reply, reply_bytes);
+                if (ret == 0)
+                        return -EPROTO;
+                if (ret < 0)
+                        return ret;
+                ack = reply[0];
+                if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_ACK) {
+                        memcpy(recv, reply + 1, ret - 1);
+                        return ret - 1;
+                }
+                else if ((ack & AUX_NATIVE_REPLY_MASK) == AUX_NATIVE_REPLY_DEFER)
+                        udelay(100);
+                else
+                        return -EIO;
+        }
+}
+
+static int
+intel_dp_i2c_aux_ch(struct i2c_adapter *adapter,
+                    uint8_t *send, int send_bytes,
+                    uint8_t *recv, int recv_bytes)
+{
+        struct intel_dp_priv *dp_priv = container_of(adapter,
+                                                     struct intel_dp_priv,
+                                                     adapter);
+        struct intel_output *intel_output = dp_priv->intel_output;
+
+        return intel_dp_aux_ch(intel_output,
+                               send, send_bytes, recv, recv_bytes);
+}
+
+static int
+intel_dp_i2c_init(struct intel_output *intel_output, const char *name)
+{
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+
+        DRM_ERROR("i2c_init %s\n", name);
+        dp_priv->algo.running = false;
+        dp_priv->algo.address = 0;
+        dp_priv->algo.aux_ch = intel_dp_i2c_aux_ch;
+
+        memset(&dp_priv->adapter, '\0', sizeof (dp_priv->adapter));
+        dp_priv->adapter.owner = THIS_MODULE;
+        dp_priv->adapter.class = I2C_CLASS_DDC;
+        strncpy (dp_priv->adapter.name, name, sizeof dp_priv->adapter.name - 1);
+        dp_priv->adapter.name[sizeof dp_priv->adapter.name - 1] = '\0';
+        dp_priv->adapter.algo_data = &dp_priv->algo;
+        dp_priv->adapter.dev.parent = &intel_output->base.kdev;
+        
+        return i2c_dp_aux_add_bus(&dp_priv->adapter);
+}
+
+static bool
+intel_dp_mode_fixup(struct drm_encoder *encoder, struct drm_display_mode *mode,
+                    struct drm_display_mode *adjusted_mode)
+{
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_dp_priv   *dp_priv = intel_output->dev_priv;
+        int lane_count, clock;
+        int max_lane_count = intel_dp_max_lane_count(intel_output);
+        int max_clock = intel_dp_max_link_bw(intel_output) == DP_LINK_BW_2_7 ? 1 : 0;
+        static int bws[2] = { DP_LINK_BW_1_62, DP_LINK_BW_2_7 };
+
+        for (lane_count = 1; lane_count <= max_lane_count; lane_count <<= 1) {
+                for (clock = 0; clock <= max_clock; clock++) {
+                        int link_avail = intel_dp_link_clock(bws[clock]) * lane_count;
+
+                        if (intel_dp_link_required(mode->clock) <= link_avail) {
+                                dp_priv->link_bw = bws[clock];
+                                dp_priv->lane_count = lane_count;
+                                adjusted_mode->clock = intel_dp_link_clock(dp_priv->link_bw);
+                                printk(KERN_ERR "link bw %02x lane count %d clock %d\n",
+                                       dp_priv->link_bw, dp_priv->lane_count,
+                                       adjusted_mode->clock);
+                                return true;
+                        }
+                }
+        }
+        return false;
+}
+
+struct intel_dp_m_n {
+        uint32_t        tu;
+        uint32_t        gmch_m;
+        uint32_t        gmch_n;
+        uint32_t        link_m;
+        uint32_t        link_n;
+};
+
+static void
+intel_reduce_ratio(uint32_t *num, uint32_t *den)
+{
+        while (*num > 0xffffff || *den > 0xffffff) {
+                *num >>= 1;
+                *den >>= 1;
+        }
+}
+
+static void
+intel_dp_compute_m_n(int bytes_per_pixel,
+                     int nlanes,
+                     int pixel_clock,
+                     int link_clock,
+                     struct intel_dp_m_n *m_n)
+{
+        m_n->tu = 64;
+        m_n->gmch_m = pixel_clock * bytes_per_pixel;
+        m_n->gmch_n = link_clock * nlanes;
+        intel_reduce_ratio(&m_n->gmch_m, &m_n->gmch_n);
+        m_n->link_m = pixel_clock;
+        m_n->link_n = link_clock;
+        intel_reduce_ratio(&m_n->link_m, &m_n->link_n);
+}
+
+void
+intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode,
+                 struct drm_display_mode *adjusted_mode)
+{
+        struct drm_device *dev = crtc->dev;
+        struct drm_mode_config *mode_config = &dev->mode_config;
+        struct drm_connector *connector;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+        int lane_count = 4;
+        struct intel_dp_m_n m_n;
+
+        /*
+         * Find the lane count in the intel_output private
+         */
+        list_for_each_entry(connector, &mode_config->connector_list, head) {
+                struct intel_output *intel_output = to_intel_output(connector);
+                struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+                if (!connector->encoder || connector->encoder->crtc != crtc)
+                        continue;
+
+                if (intel_output->type == INTEL_OUTPUT_DISPLAYPORT) {
+                        lane_count = dp_priv->lane_count;
+                        break;
+                }
+        }
+
+        /*
+         * Compute the GMCH and Link ratios. The '3' here is
+         * the number of bytes_per_pixel post-LUT, which we always
+         * set up for 8-bits of R/G/B, or 3 bytes total.
+         */
+        intel_dp_compute_m_n(3, lane_count,
+                             mode->clock, adjusted_mode->clock, &m_n);
+
+        if (intel_crtc->pipe == 0) {
+                I915_WRITE(PIPEA_GMCH_DATA_M,
+                       ((m_n.tu - 1) << PIPE_GMCH_DATA_M_TU_SIZE_SHIFT) |
+                       m_n.gmch_m);
+                I915_WRITE(PIPEA_GMCH_DATA_N,
+                       m_n.gmch_n);
+                I915_WRITE(PIPEA_DP_LINK_M, m_n.link_m);
+                I915_WRITE(PIPEA_DP_LINK_N, m_n.link_n);
+        } else {
+                I915_WRITE(PIPEB_GMCH_DATA_M,
+                       ((m_n.tu - 1) << PIPE_GMCH_DATA_M_TU_SIZE_SHIFT) |
+                       m_n.gmch_m);
+                I915_WRITE(PIPEB_GMCH_DATA_N,
+                       m_n.gmch_n);
+                I915_WRITE(PIPEB_DP_LINK_M, m_n.link_m);
+                I915_WRITE(PIPEB_DP_LINK_N, m_n.link_n);
+        }
+}
+
+static void
+intel_dp_mode_set(struct drm_encoder *encoder, struct drm_display_mode *mode,
+                  struct drm_display_mode *adjusted_mode)
+{
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        struct drm_crtc *crtc = intel_output->enc.crtc;
+        struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
+
+        dp_priv->DP = (DP_LINK_TRAIN_OFF |
+                        DP_VOLTAGE_0_4 |
+                        DP_PRE_EMPHASIS_0 |
+                        DP_SYNC_VS_HIGH |
+                        DP_SYNC_HS_HIGH);
+
+        switch (dp_priv->lane_count) {
+        case 1:
+                dp_priv->DP |= DP_PORT_WIDTH_1;
+                break;
+        case 2:
+                dp_priv->DP |= DP_PORT_WIDTH_2;
+                break;
+        case 4:
+                dp_priv->DP |= DP_PORT_WIDTH_4;
+                break;
+        }
+        if (dp_priv->has_audio)
+                dp_priv->DP |= DP_AUDIO_OUTPUT_ENABLE;
+
+        memset(dp_priv->link_configuration, 0, DP_LINK_CONFIGURATION_SIZE);
+        dp_priv->link_configuration[0] = dp_priv->link_bw;
+        dp_priv->link_configuration[1] = dp_priv->lane_count;
+
+        /*
+         * Check for DPCD version > 1.1,
+         * enable enahanced frame stuff in that case
+         */
+        if (dp_priv->dpcd[0] >= 0x11) {
+                dp_priv->link_configuration[1] |= DP_LANE_COUNT_ENHANCED_FRAME_EN;
+                dp_priv->DP |= DP_ENHANCED_FRAMING;
+        }
+
+        if (intel_crtc->pipe == 1)
+                dp_priv->DP |= DP_PIPEB_SELECT;
+}
+
+
+static void
+intel_dp_dpms(struct drm_encoder *encoder, int mode)
+{
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        uint32_t dp_reg = I915_READ(dp_priv->output_reg);
+
+        if (mode != DRM_MODE_DPMS_ON) {
+                if (dp_reg & DP_PORT_EN)
+                        intel_dp_link_down(intel_output, dp_priv->DP);
+        } else {
+                if (!(dp_reg & DP_PORT_EN))
+                        intel_dp_link_train(intel_output, dp_priv->DP, dp_priv->link_configuration);
+        }
+        dp_priv->dpms_mode = mode;
+}
+
+/*
+ * Fetch AUX CH registers 0x202 - 0x207 which contain
+ * link status information
+ */
+static bool
+intel_dp_get_link_status(struct intel_output *intel_output,
+                         uint8_t link_status[DP_LINK_STATUS_SIZE])
+{
+        int ret;
+
+        ret = intel_dp_aux_native_read(intel_output,
+                                       DP_LANE0_1_STATUS,
+                                       link_status, DP_LINK_STATUS_SIZE);
+        if (ret != DP_LINK_STATUS_SIZE)
+                return false;
+        return true;
+}
+
+static uint8_t
+intel_dp_link_status(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                     int r)
+{
+        return link_status[r - DP_LANE0_1_STATUS];
+}
+
+static void
+intel_dp_save(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        dp_priv->save_DP = I915_READ(dp_priv->output_reg);
+        intel_dp_aux_native_read(intel_output, DP_LINK_BW_SET,
+                                 dp_priv->save_link_configuration,
+                                 sizeof (dp_priv->save_link_configuration));
+}
+
+static uint8_t
+intel_get_adjust_request_voltage(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                                 int lane)
+{
+        int         i = DP_ADJUST_REQUEST_LANE0_1 + (lane >> 1);
+        int         s = ((lane & 1) ?
+                         DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT :
+                         DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT);
+        uint8_t l = intel_dp_link_status(link_status, i);
+
+        return ((l >> s) & 3) << DP_TRAIN_VOLTAGE_SWING_SHIFT;
+}
+
+static uint8_t
+intel_get_adjust_request_pre_emphasis(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                                      int lane)
+{
+        int         i = DP_ADJUST_REQUEST_LANE0_1 + (lane >> 1);
+        int         s = ((lane & 1) ?
+                         DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT :
+                         DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT);
+        uint8_t l = intel_dp_link_status(link_status, i);
+
+        return ((l >> s) & 3) << DP_TRAIN_PRE_EMPHASIS_SHIFT;
+}
+
+
+#if 0
+static char     *voltage_names[] = {
+        "0.4V", "0.6V", "0.8V", "1.2V"
+};
+static char     *pre_emph_names[] = {
+        "0dB", "3.5dB", "6dB", "9.5dB"
+};
+static char     *link_train_names[] = {
+        "pattern 1", "pattern 2", "idle", "off"
+};
+#endif
+
+/*
+ * These are source-specific values; current Intel hardware supports
+ * a maximum voltage of 800mV and a maximum pre-emphasis of 6dB
+ */
+#define I830_DP_VOLTAGE_MAX         DP_TRAIN_VOLTAGE_SWING_800
+
+static uint8_t
+intel_dp_pre_emphasis_max(uint8_t voltage_swing)
+{
+        switch (voltage_swing & DP_TRAIN_VOLTAGE_SWING_MASK) {
+        case DP_TRAIN_VOLTAGE_SWING_400:
+                return DP_TRAIN_PRE_EMPHASIS_6;
+        case DP_TRAIN_VOLTAGE_SWING_600:
+                return DP_TRAIN_PRE_EMPHASIS_6;
+        case DP_TRAIN_VOLTAGE_SWING_800:
+                return DP_TRAIN_PRE_EMPHASIS_3_5;
+        case DP_TRAIN_VOLTAGE_SWING_1200:
+        default:
+                return DP_TRAIN_PRE_EMPHASIS_0;
+        }
+}
+
+static void
+intel_get_adjust_train(struct intel_output *intel_output,
+                       uint8_t link_status[DP_LINK_STATUS_SIZE],
+                       int lane_count,
+                       uint8_t train_set[4])
+{
+        uint8_t v = 0;
+        uint8_t p = 0;
+        int lane;
+
+        for (lane = 0; lane < lane_count; lane++) {
+                uint8_t this_v = intel_get_adjust_request_voltage(link_status, lane);
+                uint8_t this_p = intel_get_adjust_request_pre_emphasis(link_status, lane);
+
+                if (this_v > v)
+                        v = this_v;
+                if (this_p > p)
+                        p = this_p;
+        }
+
+        if (v >= I830_DP_VOLTAGE_MAX)
+                v = I830_DP_VOLTAGE_MAX | DP_TRAIN_MAX_SWING_REACHED;
+
+        if (p >= intel_dp_pre_emphasis_max(v))
+                p = intel_dp_pre_emphasis_max(v) | DP_TRAIN_MAX_PRE_EMPHASIS_REACHED;
+
+        for (lane = 0; lane < 4; lane++)
+                train_set[lane] = v | p;
+}
+
+static uint32_t
+intel_dp_signal_levels(uint8_t train_set, int lane_count)
+{
+        uint32_t        signal_levels = 0;
+
+        switch (train_set & DP_TRAIN_VOLTAGE_SWING_MASK) {
+        case DP_TRAIN_VOLTAGE_SWING_400:
+        default:
+                signal_levels |= DP_VOLTAGE_0_4;
+                break;
+        case DP_TRAIN_VOLTAGE_SWING_600:
+                signal_levels |= DP_VOLTAGE_0_6;
+                break;
+        case DP_TRAIN_VOLTAGE_SWING_800:
+                signal_levels |= DP_VOLTAGE_0_8;
+                break;
+        case DP_TRAIN_VOLTAGE_SWING_1200:
+                signal_levels |= DP_VOLTAGE_1_2;
+                break;
+        }
+        switch (train_set & DP_TRAIN_PRE_EMPHASIS_MASK) {
+        case DP_TRAIN_PRE_EMPHASIS_0:
+        default:
+                signal_levels |= DP_PRE_EMPHASIS_0;
+                break;
+        case DP_TRAIN_PRE_EMPHASIS_3_5:
+                signal_levels |= DP_PRE_EMPHASIS_3_5;
+                break;
+        case DP_TRAIN_PRE_EMPHASIS_6:
+                signal_levels |= DP_PRE_EMPHASIS_6;
+                break;
+        case DP_TRAIN_PRE_EMPHASIS_9_5:
+                signal_levels |= DP_PRE_EMPHASIS_9_5;
+                break;
+        }
+        return signal_levels;
+}
+
+static uint8_t
+intel_get_lane_status(uint8_t link_status[DP_LINK_STATUS_SIZE],
+                      int lane)
+{
+        int i = DP_LANE0_1_STATUS + (lane >> 1);
+        int s = (lane & 1) * 4;
+        uint8_t l = intel_dp_link_status(link_status, i);
+
+        return (l >> s) & 0xf;
+}
+
+/* Check for clock recovery is done on all channels */
+static bool
+intel_clock_recovery_ok(uint8_t link_status[DP_LINK_STATUS_SIZE], int lane_count)
+{
+        int lane;
+        uint8_t lane_status;
+
+        for (lane = 0; lane < lane_count; lane++) {
+                lane_status = intel_get_lane_status(link_status, lane);
+                if ((lane_status & DP_LANE_CR_DONE) == 0)
+                        return false;
+        }
+        return true;
+}
+
+/* Check to see if channel eq is done on all channels */
+#define CHANNEL_EQ_BITS (DP_LANE_CR_DONE|\
+                         DP_LANE_CHANNEL_EQ_DONE|\
+                         DP_LANE_SYMBOL_LOCKED)
+static bool
+intel_channel_eq_ok(uint8_t link_status[DP_LINK_STATUS_SIZE], int lane_count)
+{
+        uint8_t lane_align;
+        uint8_t lane_status;
+        int lane;
+
+        lane_align = intel_dp_link_status(link_status,
+                                          DP_LANE_ALIGN_STATUS_UPDATED);
+        if ((lane_align & DP_INTERLANE_ALIGN_DONE) == 0)
+                return false;
+        for (lane = 0; lane < lane_count; lane++) {
+                lane_status = intel_get_lane_status(link_status, lane);
+                if ((lane_status & CHANNEL_EQ_BITS) != CHANNEL_EQ_BITS)
+                        return false;
+        }
+        return true;
+}
+
+static bool
+intel_dp_set_link_train(struct intel_output *intel_output,
+                        uint32_t dp_reg_value,
+                        uint8_t dp_train_pat,
+                        uint8_t train_set[4],
+                        bool first)
+{
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        int ret;
+
+        I915_WRITE(dp_priv->output_reg, dp_reg_value);
+        POSTING_READ(dp_priv->output_reg);
+        if (first)
+                intel_wait_for_vblank(dev);
+
+        intel_dp_aux_native_write_1(intel_output,
+                                    DP_TRAINING_PATTERN_SET,
+                                    dp_train_pat);
+
+        ret = intel_dp_aux_native_write(intel_output,
+                                        DP_TRAINING_LANE0_SET, train_set, 4);
+        if (ret != 4)
+                return false;
+
+        return true;
+}
+
+static void
+intel_dp_link_train(struct intel_output *intel_output, uint32_t DP,
+                    uint8_t link_configuration[DP_LINK_CONFIGURATION_SIZE])
+{
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint8_t train_set[4];
+        uint8_t link_status[DP_LINK_STATUS_SIZE];
+        int i;
+        uint8_t voltage;
+        bool clock_recovery = false;
+        bool channel_eq = false;
+        bool first = true;
+        int tries;
+
+        /* Write the link configuration data */
+        intel_dp_aux_native_write(intel_output, 0x100,
+                                  link_configuration, DP_LINK_CONFIGURATION_SIZE);
+
+        DP |= DP_PORT_EN;
+        DP &= ~DP_LINK_TRAIN_MASK;
+        memset(train_set, 0, 4);
+        voltage = 0xff;
+        tries = 0;
+        clock_recovery = false;
+        for (;;) {
+                /* Use train_set[0] to set the voltage and pre emphasis values */
+                uint32_t    signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count);
+                DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels;
+
+                if (!intel_dp_set_link_train(intel_output, DP | DP_LINK_TRAIN_PAT_1,
+                                             DP_TRAINING_PATTERN_1, train_set, first))
+                        break;
+                first = false;
+                /* Set training pattern 1 */
+
+                udelay(100);
+                if (!intel_dp_get_link_status(intel_output, link_status))
+                        break;
+
+                if (intel_clock_recovery_ok(link_status, dp_priv->lane_count)) {
+                        clock_recovery = true;
+                        break;
+                }
+
+                /* Check to see if we've tried the max voltage */
+                for (i = 0; i < dp_priv->lane_count; i++)
+                        if ((train_set[i] & DP_TRAIN_MAX_SWING_REACHED) == 0)
+                                break;
+                if (i == dp_priv->lane_count)
+                        break;
+
+                /* Check to see if we've tried the same voltage 5 times */
+                if ((train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK) == voltage) {
+                        ++tries;
+                        if (tries == 5)
+                                break;
+                } else
+                        tries = 0;
+                voltage = train_set[0] & DP_TRAIN_VOLTAGE_SWING_MASK;
+
+                /* Compute new train_set as requested by target */
+                intel_get_adjust_train(intel_output, link_status, dp_priv->lane_count, train_set);
+        }
+
+        /* channel equalization */
+        tries = 0;
+        channel_eq = false;
+        for (;;) {
+                /* Use train_set[0] to set the voltage and pre emphasis values */
+                uint32_t    signal_levels = intel_dp_signal_levels(train_set[0], dp_priv->lane_count);
+                DP = (DP & ~(DP_VOLTAGE_MASK|DP_PRE_EMPHASIS_MASK)) | signal_levels;
+
+                /* channel eq pattern */
+                if (!intel_dp_set_link_train(intel_output, DP | DP_LINK_TRAIN_PAT_2,
+                                             DP_TRAINING_PATTERN_2, train_set,
+                                             false))
+                        break;
+
+                udelay(400);
+                if (!intel_dp_get_link_status(intel_output, link_status))
+                        break;
+
+                if (intel_channel_eq_ok(link_status, dp_priv->lane_count)) {
+                        channel_eq = true;
+                        break;
+                }
+
+                /* Try 5 times */
+                if (tries > 5)
+                        break;
+
+                /* Compute new train_set as requested by target */
+                intel_get_adjust_train(intel_output, link_status, dp_priv->lane_count, train_set);
+                ++tries;
+        }
+
+        I915_WRITE(dp_priv->output_reg, DP | DP_LINK_TRAIN_OFF);
+        POSTING_READ(dp_priv->output_reg);
+        intel_dp_aux_native_write_1(intel_output,
+                                    DP_TRAINING_PATTERN_SET, DP_TRAINING_PATTERN_DISABLE);
+}
+
+static void
+intel_dp_link_down(struct intel_output *intel_output, uint32_t DP)
+{
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        I915_WRITE(dp_priv->output_reg, DP & ~DP_PORT_EN);
+        POSTING_READ(dp_priv->output_reg);
+}
+
+static void
+intel_dp_restore(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        if (dp_priv->save_DP & DP_PORT_EN)
+                intel_dp_link_train(intel_output, dp_priv->save_DP, dp_priv->save_link_configuration);
+        else
+                intel_dp_link_down(intel_output,  dp_priv->save_DP);
+}
+
+/*
+ * According to DP spec
+ * 5.1.2:
+ *  1. Read DPCD
+ *  2. Configure link according to Receiver Capabilities
+ *  3. Use Link Training from 2.5.3.3 and 3.5.1.3
+ *  4. Check link status on receipt of hot-plug interrupt
+ */
+
+static void
+intel_dp_check_link_status(struct intel_output *intel_output)
+{
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint8_t link_status[DP_LINK_STATUS_SIZE];
+
+        if (!intel_output->enc.crtc)
+                return;
+
+        if (!intel_dp_get_link_status(intel_output, link_status)) {
+                intel_dp_link_down(intel_output, dp_priv->DP);
+                return;
+        }
+
+        if (!intel_channel_eq_ok(link_status, dp_priv->lane_count))
+                intel_dp_link_train(intel_output, dp_priv->DP, dp_priv->link_configuration);
+}
+
+/**
+ * Uses CRT_HOTPLUG_EN and CRT_HOTPLUG_STAT to detect DP connection.
+ *
+ * \return true if DP port is connected.
+ * \return false if DP port is disconnected.
+ */
+static enum drm_connector_status
+intel_dp_detect(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+        struct drm_device *dev = intel_output->base.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+        uint32_t temp, bit;
+        enum drm_connector_status status;
+
+        dp_priv->has_audio = false;
+
+        temp = I915_READ(PORT_HOTPLUG_EN);
+
+        I915_WRITE(PORT_HOTPLUG_EN,
+               temp |
+               DPB_HOTPLUG_INT_EN |
+               DPC_HOTPLUG_INT_EN |
+               DPD_HOTPLUG_INT_EN);
+
+        POSTING_READ(PORT_HOTPLUG_EN);
+
+        switch (dp_priv->output_reg) {
+        case DP_B:
+                bit = DPB_HOTPLUG_INT_STATUS;
+                break;
+        case DP_C:
+                bit = DPC_HOTPLUG_INT_STATUS;
+                break;
+        case DP_D:
+                bit = DPD_HOTPLUG_INT_STATUS;
+                break;
+        default:
+                return connector_status_unknown;
+        }
+
+        temp = I915_READ(PORT_HOTPLUG_STAT);
+
+        if ((temp & bit) == 0)
+                return connector_status_disconnected;
+
+        status = connector_status_disconnected;
+        if (intel_dp_aux_native_read(intel_output,
+                                     0x000, dp_priv->dpcd,
+                                     sizeof (dp_priv->dpcd)) == sizeof (dp_priv->dpcd))
+        {
+                if (dp_priv->dpcd[0] != 0)
+                        status = connector_status_connected;
+        }
+        return status;
+}
+
+static int intel_dp_get_modes(struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+
+        /* We should parse the EDID data and find out if it has an audio sink
+         */
+
+        return intel_ddc_get_modes(intel_output);
+}
+
+static void
+intel_dp_destroy (struct drm_connector *connector)
+{
+        struct intel_output *intel_output = to_intel_output(connector);
+
+        if (intel_output->i2c_bus)
+                intel_i2c_destroy(intel_output->i2c_bus);
+        drm_sysfs_connector_remove(connector);
+        drm_connector_cleanup(connector);
+        kfree(intel_output);
+}
+
+static const struct drm_encoder_helper_funcs intel_dp_helper_funcs = {
+        .dpms = intel_dp_dpms,
+        .mode_fixup = intel_dp_mode_fixup,
+        .prepare = intel_encoder_prepare,
+        .mode_set = intel_dp_mode_set,
+        .commit = intel_encoder_commit,
+};
+
+static const struct drm_connector_funcs intel_dp_connector_funcs = {
+        .dpms = drm_helper_connector_dpms,
+        .save = intel_dp_save,
+        .restore = intel_dp_restore,
+        .detect = intel_dp_detect,
+        .fill_modes = drm_helper_probe_single_connector_modes,
+        .destroy = intel_dp_destroy,
+};
+
+static const struct drm_connector_helper_funcs intel_dp_connector_helper_funcs = {
+        .get_modes = intel_dp_get_modes,
+        .mode_valid = intel_dp_mode_valid,
+        .best_encoder = intel_best_encoder,
+};
+
+static void intel_dp_enc_destroy(struct drm_encoder *encoder)
+{
+        drm_encoder_cleanup(encoder);
+}
+
+static const struct drm_encoder_funcs intel_dp_enc_funcs = {
+        .destroy = intel_dp_enc_destroy,
+};
+
+void
+intel_dp_hot_plug(struct intel_output *intel_output)
+{
+        struct intel_dp_priv *dp_priv = intel_output->dev_priv;
+
+        if (dp_priv->dpms_mode == DRM_MODE_DPMS_ON)
+                intel_dp_check_link_status(intel_output);
+}
+
+void
+intel_dp_init(struct drm_device *dev, int output_reg)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_connector *connector;
+        struct intel_output *intel_output;
+        struct intel_dp_priv *dp_priv;
+
+        intel_output = kcalloc(sizeof(struct intel_output) + 
+                               sizeof(struct intel_dp_priv), 1, GFP_KERNEL);
+        if (!intel_output)
+                return;
+
+        dp_priv = (struct intel_dp_priv *)(intel_output + 1);
+
+        connector = &intel_output->base;
+        drm_connector_init(dev, connector, &intel_dp_connector_funcs,
+                           DRM_MODE_CONNECTOR_DisplayPort);
+        drm_connector_helper_add(connector, &intel_dp_connector_helper_funcs);
+
+        intel_output->type = INTEL_OUTPUT_DISPLAYPORT;
+
+        connector->interlace_allowed = true;
+        connector->doublescan_allowed = 0;
+
+        dp_priv->intel_output = intel_output;
+        dp_priv->output_reg = output_reg;
+        dp_priv->has_audio = false;
+        dp_priv->dpms_mode = DRM_MODE_DPMS_ON;
+        intel_output->dev_priv = dp_priv;
+
+        drm_encoder_init(dev, &intel_output->enc, &intel_dp_enc_funcs,
+                         DRM_MODE_ENCODER_TMDS);
+        drm_encoder_helper_add(&intel_output->enc, &intel_dp_helper_funcs);
+
+        drm_mode_connector_attach_encoder(&intel_output->base,
+                                          &intel_output->enc);
+        drm_sysfs_connector_add(connector);
+
+        /* Set up the DDC bus. */
+        intel_dp_i2c_init(intel_output,
+                          (output_reg == DP_B) ? "DPDDC-B" :
+                          (output_reg == DP_C) ? "DPDDC-C" : "DPDDC-D");
+        intel_output->ddc_bus = &dp_priv->adapter;
+        intel_output->hot_plug = intel_dp_hot_plug;
+
+        /* For G4X desktop chip, PEG_BAND_GAP_DATA 3:0 must first be written
+         * 0xd.  Failure to do so will result in spurious interrupts being
+         * generated on the port when a cable is not attached.
+         */
+        if (IS_G4X(dev) && !IS_GM45(dev)) {
+                u32 temp = I915_READ(PEG_BAND_GAP_DATA);
+                I915_WRITE(PEG_BAND_GAP_DATA, (temp & ~0xf) | 0xd);
+        }
+}
diff --git a/drivers/gpu/drm/i915/intel_dp.h b/drivers/gpu/drm/i915/intel_dp.h
new file mode 100644
index 000000000000..2b38054d3b6d
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_dp.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright © 2008 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifndef _INTEL_DP_H_
+#define _INTEL_DP_H_
+
+/* From the VESA DisplayPort spec */
+
+#define AUX_NATIVE_WRITE        0x8
+#define AUX_NATIVE_READ         0x9
+#define AUX_I2C_WRITE           0x0
+#define AUX_I2C_READ            0x1
+#define AUX_I2C_STATUS          0x2
+#define AUX_I2C_MOT             0x4
+
+#define AUX_NATIVE_REPLY_ACK    (0x0 << 4)
+#define AUX_NATIVE_REPLY_NACK   (0x1 << 4)
+#define AUX_NATIVE_REPLY_DEFER  (0x2 << 4)
+#define AUX_NATIVE_REPLY_MASK   (0x3 << 4)
+
+#define AUX_I2C_REPLY_ACK       (0x0 << 6)
+#define AUX_I2C_REPLY_NACK      (0x1 << 6)
+#define AUX_I2C_REPLY_DEFER     (0x2 << 6)
+#define AUX_I2C_REPLY_MASK      (0x3 << 6)
+
+/* AUX CH addresses */
+#define DP_LINK_BW_SET          0x100
+# define DP_LINK_BW_1_62                    0x06
+# define DP_LINK_BW_2_7                     0x0a
+
+#define DP_LANE_COUNT_SET       0x101
+# define DP_LANE_COUNT_MASK                 0x0f
+# define DP_LANE_COUNT_ENHANCED_FRAME_EN    (1 << 7)
+
+#define DP_TRAINING_PATTERN_SET 0x102
+
+# define DP_TRAINING_PATTERN_DISABLE        0
+# define DP_TRAINING_PATTERN_1              1
+# define DP_TRAINING_PATTERN_2              2
+# define DP_TRAINING_PATTERN_MASK           0x3
+
+# define DP_LINK_QUAL_PATTERN_DISABLE       (0 << 2)
+# define DP_LINK_QUAL_PATTERN_D10_2         (1 << 2)
+# define DP_LINK_QUAL_PATTERN_ERROR_RATE    (2 << 2)
+# define DP_LINK_QUAL_PATTERN_PRBS7         (3 << 2)
+# define DP_LINK_QUAL_PATTERN_MASK          (3 << 2)
+
+# define DP_RECOVERED_CLOCK_OUT_EN          (1 << 4)
+# define DP_LINK_SCRAMBLING_DISABLE         (1 << 5)
+
+# define DP_SYMBOL_ERROR_COUNT_BOTH         (0 << 6)
+# define DP_SYMBOL_ERROR_COUNT_DISPARITY    (1 << 6)
+# define DP_SYMBOL_ERROR_COUNT_SYMBOL       (2 << 6)
+# define DP_SYMBOL_ERROR_COUNT_MASK         (3 << 6)
+
+#define DP_TRAINING_LANE0_SET               0x103
+#define DP_TRAINING_LANE1_SET               0x104
+#define DP_TRAINING_LANE2_SET               0x105
+#define DP_TRAINING_LANE3_SET               0x106
+
+# define DP_TRAIN_VOLTAGE_SWING_MASK        0x3
+# define DP_TRAIN_VOLTAGE_SWING_SHIFT       0
+# define DP_TRAIN_MAX_SWING_REACHED         (1 << 2)
+# define DP_TRAIN_VOLTAGE_SWING_400         (0 << 0)
+# define DP_TRAIN_VOLTAGE_SWING_600         (1 << 0)
+# define DP_TRAIN_VOLTAGE_SWING_800         (2 << 0)
+# define DP_TRAIN_VOLTAGE_SWING_1200        (3 << 0)
+
+# define DP_TRAIN_PRE_EMPHASIS_MASK         (3 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_0            (0 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_3_5          (1 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_6            (2 << 3)
+# define DP_TRAIN_PRE_EMPHASIS_9_5          (3 << 3)
+
+# define DP_TRAIN_PRE_EMPHASIS_SHIFT        3
+# define DP_TRAIN_MAX_PRE_EMPHASIS_REACHED  (1 << 5)
+
+#define DP_DOWNSPREAD_CTRL                  0x107
+# define DP_SPREAD_AMP_0_5                  (1 << 4)
+
+#define DP_MAIN_LINK_CHANNEL_CODING_SET     0x108
+# define DP_SET_ANSI_8B10B                  (1 << 0)
+
+#define DP_LANE0_1_STATUS                   0x202
+#define DP_LANE2_3_STATUS                   0x203
+
+# define DP_LANE_CR_DONE                    (1 << 0)
+# define DP_LANE_CHANNEL_EQ_DONE            (1 << 1)
+# define DP_LANE_SYMBOL_LOCKED              (1 << 2)
+
+#define DP_LANE_ALIGN_STATUS_UPDATED        0x204
+
+#define DP_INTERLANE_ALIGN_DONE             (1 << 0)
+#define DP_DOWNSTREAM_PORT_STATUS_CHANGED   (1 << 6)
+#define DP_LINK_STATUS_UPDATED              (1 << 7)
+
+#define DP_SINK_STATUS                      0x205
+
+#define DP_RECEIVE_PORT_0_STATUS            (1 << 0)
+#define DP_RECEIVE_PORT_1_STATUS            (1 << 1)
+
+#define DP_ADJUST_REQUEST_LANE0_1           0x206
+#define DP_ADJUST_REQUEST_LANE2_3           0x207
+
+#define DP_ADJUST_VOLTAGE_SWING_LANE0_MASK  0x03
+#define DP_ADJUST_VOLTAGE_SWING_LANE0_SHIFT 0
+#define DP_ADJUST_PRE_EMPHASIS_LANE0_MASK   0x0c
+#define DP_ADJUST_PRE_EMPHASIS_LANE0_SHIFT  2
+#define DP_ADJUST_VOLTAGE_SWING_LANE1_MASK  0x30
+#define DP_ADJUST_VOLTAGE_SWING_LANE1_SHIFT 4
+#define DP_ADJUST_PRE_EMPHASIS_LANE1_MASK   0xc0
+#define DP_ADJUST_PRE_EMPHASIS_LANE1_SHIFT  6
+
+struct i2c_algo_dp_aux_data {
+        bool running;
+        u16 address;
+        int (*aux_ch) (struct i2c_adapter *adapter,
+                       uint8_t *send, int send_bytes,
+                       uint8_t *recv, int recv_bytes);
+};
+
+int
+i2c_dp_aux_add_bus(struct i2c_adapter *adapter);
+
+#endif /* _INTEL_DP_H_ */
diff --git a/drivers/gpu/drm/i915/intel_dp_i2c.c b/drivers/gpu/drm/i915/intel_dp_i2c.c
new file mode 100644
index 000000000000..4e60f14b1a6d
--- /dev/null
+++ b/drivers/gpu/drm/i915/intel_dp_i2c.c
@@ -0,0 +1,272 @@
+/*
+ * Copyright © 2009 Keith Packard
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no representations
+ * about the suitability of this software for any purpose.  It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/i2c.h>
+#include "intel_dp.h"
+
+/* Run a single AUX_CH I2C transaction, writing/reading data as necessary */
+
+#define MODE_I2C_START  1
+#define MODE_I2C_WRITE  2
+#define MODE_I2C_READ   4
+#define MODE_I2C_STOP   8
+
+static int
+i2c_algo_dp_aux_transaction(struct i2c_adapter *adapter, int mode,
+                            uint8_t write_byte, uint8_t *read_byte)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        uint16_t address = algo_data->address;
+        uint8_t msg[5];
+        uint8_t reply[2];
+        int msg_bytes;
+        int reply_bytes;
+        int ret;
+
+        /* Set up the command byte */
+        if (mode & MODE_I2C_READ)
+                msg[0] = AUX_I2C_READ << 4;
+        else
+                msg[0] = AUX_I2C_WRITE << 4;
+
+        if (!(mode & MODE_I2C_STOP))
+                msg[0] |= AUX_I2C_MOT << 4;
+
+        msg[1] = address >> 8;
+        msg[2] = address;
+
+        switch (mode) {
+        case MODE_I2C_WRITE:
+                msg[3] = 0;
+                msg[4] = write_byte;
+                msg_bytes = 5;
+                reply_bytes = 1;
+                break;
+        case MODE_I2C_READ:
+                msg[3] = 0;
+                msg_bytes = 4;
+                reply_bytes = 2;
+                break;
+        default:
+                msg_bytes = 3;
+                reply_bytes = 1;
+                break;
+        }
+
+        for (;;) {
+                ret = (*algo_data->aux_ch)(adapter,
+                                           msg, msg_bytes,
+                                           reply, reply_bytes);
+                if (ret < 0) {
+                        printk(KERN_ERR "aux_ch failed %d\n", ret);
+                        return ret;
+                }
+                switch (reply[0] & AUX_I2C_REPLY_MASK) {
+                case AUX_I2C_REPLY_ACK:
+                        if (mode == MODE_I2C_READ) {
+                                *read_byte = reply[1];
+                        }
+                        return reply_bytes - 1;
+                case AUX_I2C_REPLY_NACK:
+                        printk(KERN_ERR "aux_ch nack\n");
+                        return -EREMOTEIO;
+                case AUX_I2C_REPLY_DEFER:
+                        printk(KERN_ERR "aux_ch defer\n");
+                        udelay(100);
+                        break;
+                default:
+                        printk(KERN_ERR "aux_ch invalid reply 0x%02x\n", reply[0]);
+                        return -EREMOTEIO;
+                }
+        }
+}
+
+/*
+ * I2C over AUX CH
+ */
+
+/*
+ * Send the address. If the I2C link is running, this 'restarts'
+ * the connection with the new address, this is used for doing
+ * a write followed by a read (as needed for DDC)
+ */
+static int
+i2c_algo_dp_aux_address(struct i2c_adapter *adapter, u16 address, bool reading)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int mode = MODE_I2C_START;
+        int ret;
+
+        if (reading)
+                mode |= MODE_I2C_READ;
+        else
+                mode |= MODE_I2C_WRITE;
+        algo_data->address = address;
+        algo_data->running = true;
+        ret = i2c_algo_dp_aux_transaction(adapter, mode, 0, NULL);
+        return ret;
+}
+
+/*
+ * Stop the I2C transaction. This closes out the link, sending
+ * a bare address packet with the MOT bit turned off
+ */
+static void
+i2c_algo_dp_aux_stop(struct i2c_adapter *adapter, bool reading)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int mode = MODE_I2C_STOP;
+
+        if (reading)
+                mode |= MODE_I2C_READ;
+        else
+                mode |= MODE_I2C_WRITE;
+        if (algo_data->running) {
+                (void) i2c_algo_dp_aux_transaction(adapter, mode, 0, NULL);
+                algo_data->running = false;
+        }
+}
+
+/*
+ * Write a single byte to the current I2C address, the
+ * the I2C link must be running or this returns -EIO
+ */
+static int
+i2c_algo_dp_aux_put_byte(struct i2c_adapter *adapter, u8 byte)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int ret;
+
+        if (!algo_data->running)
+                return -EIO;
+
+        ret = i2c_algo_dp_aux_transaction(adapter, MODE_I2C_WRITE, byte, NULL);
+        return ret;
+}
+
+/*
+ * Read a single byte from the current I2C address, the
+ * I2C link must be running or this returns -EIO
+ */
+static int
+i2c_algo_dp_aux_get_byte(struct i2c_adapter *adapter, u8 *byte_ret)
+{
+        struct i2c_algo_dp_aux_data *algo_data = adapter->algo_data;
+        int ret;
+
+        if (!algo_data->running)
+                return -EIO;
+
+        ret = i2c_algo_dp_aux_transaction(adapter, MODE_I2C_READ, 0, byte_ret);
+        return ret;
+}
+
+static int
+i2c_algo_dp_aux_xfer(struct i2c_adapter *adapter,
+                     struct i2c_msg *msgs,
+                     int num)
+{
+        int ret = 0;
+        bool reading = false;
+        int m;
+        int b;
+
+        for (m = 0; m < num; m++) {
+                u16 len = msgs[m].len;
+                u8 *buf = msgs[m].buf;
+                reading = (msgs[m].flags & I2C_M_RD) != 0;
+                ret = i2c_algo_dp_aux_address(adapter, msgs[m].addr, reading);
+                if (ret < 0)
+                        break;
+                if (reading) {
+                        for (b = 0; b < len; b++) {
+                                ret = i2c_algo_dp_aux_get_byte(adapter, &buf[b]);
+                                if (ret < 0)
+                                        break;
+                        }
+                } else {
+                        for (b = 0; b < len; b++) {
+                                ret = i2c_algo_dp_aux_put_byte(adapter, buf[b]);
+                                if (ret < 0)
+                                        break;
+                        }
+                }
+                if (ret < 0)
+                        break;
+        }
+        if (ret >= 0)
+                ret = num;
+        i2c_algo_dp_aux_stop(adapter, reading);
+        printk(KERN_ERR "dp_aux_xfer return %d\n", ret);
+        return ret;
+}
+
+static u32
+i2c_algo_dp_aux_functionality(struct i2c_adapter *adapter)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL |
+               I2C_FUNC_SMBUS_READ_BLOCK_DATA |
+               I2C_FUNC_SMBUS_BLOCK_PROC_CALL |
+               I2C_FUNC_10BIT_ADDR;
+}
+
+static const struct i2c_algorithm i2c_dp_aux_algo = {
+        .master_xfer    = i2c_algo_dp_aux_xfer,
+        .functionality  = i2c_algo_dp_aux_functionality,
+};
+
+static void
+i2c_dp_aux_reset_bus(struct i2c_adapter *adapter)
+{
+        (void) i2c_algo_dp_aux_address(adapter, 0, false);
+        (void) i2c_algo_dp_aux_stop(adapter, false);
+                                           
+}
+
+static int
+i2c_dp_aux_prepare_bus(struct i2c_adapter *adapter)
+{
+        adapter->algo = &i2c_dp_aux_algo;
+        adapter->retries = 3;
+        i2c_dp_aux_reset_bus(adapter);
+        return 0;
+}
+
+int
+i2c_dp_aux_add_bus(struct i2c_adapter *adapter)
+{
+        int error;
+        
+        error = i2c_dp_aux_prepare_bus(adapter);
+        if (error)
+                return error;
+        error = i2c_add_adapter(adapter);
+        return error;
+}
+EXPORT_SYMBOL(i2c_dp_aux_add_bus);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index cd4b9c5f715e..004541c935a8 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -54,6 +54,7 @@
 #define INTEL_OUTPUT_LVDS 4
 #define INTEL_OUTPUT_TVOUT 5
 #define INTEL_OUTPUT_HDMI 6
+#define INTEL_OUTPUT_DISPLAYPORT 7
 
 #define INTEL_DVO_CHIP_NONE 0
 #define INTEL_DVO_CHIP_LVDS 1
@@ -65,7 +66,6 @@ struct intel_i2c_chan {
         u32 reg; /* GPIO reg */
         struct i2c_adapter adapter;
         struct i2c_algo_bit_data algo;
-        u8 slave_addr;
 };
 
 struct intel_framebuffer {
@@ -79,11 +79,12 @@ struct intel_output {
 
         struct drm_encoder enc;
         int type;
-        struct intel_i2c_chan *i2c_bus; /* for control functions */
-        struct intel_i2c_chan *ddc_bus; /* for DDC only stuff */
+        struct i2c_adapter *i2c_bus;
+        struct i2c_adapter *ddc_bus;
         bool load_detect_temp;
         bool needs_tv_clock;
         void *dev_priv;
+        void (*hot_plug)(struct intel_output *);
 };
 
 struct intel_crtc {
@@ -104,9 +105,9 @@ struct intel_crtc {
 #define enc_to_intel_output(x) container_of(x, struct intel_output, enc)
 #define to_intel_framebuffer(x) container_of(x, struct intel_framebuffer, base)
 
-struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
-                                        const char *name);
-void intel_i2c_destroy(struct intel_i2c_chan *chan);
+struct i2c_adapter *intel_i2c_create(struct drm_device *dev, const u32 reg,
+                                     const char *name);
+void intel_i2c_destroy(struct i2c_adapter *adapter);
 int intel_ddc_get_modes(struct intel_output *intel_output);
 extern bool intel_ddc_probe(struct intel_output *intel_output);
 void intel_i2c_quirk_set(struct drm_device *dev, bool enable);
@@ -116,6 +117,10 @@ extern bool intel_sdvo_init(struct drm_device *dev, int output_device);
 extern void intel_dvo_init(struct drm_device *dev);
 extern void intel_tv_init(struct drm_device *dev);
 extern void intel_lvds_init(struct drm_device *dev);
+extern void intel_dp_init(struct drm_device *dev, int dp_reg);
+void
+intel_dp_set_m_n(struct drm_crtc *crtc, struct drm_display_mode *mode,
+                 struct drm_display_mode *adjusted_mode);
 
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
 extern void intel_encoder_prepare (struct drm_encoder *encoder);
diff --git a/drivers/gpu/drm/i915/intel_dvo.c b/drivers/gpu/drm/i915/intel_dvo.c
index 1ee3007d6ec0..13bff20930e8 100644
--- a/drivers/gpu/drm/i915/intel_dvo.c
+++ b/drivers/gpu/drm/i915/intel_dvo.c
@@ -384,10 +384,9 @@ void intel_dvo_init(struct drm_device *dev)
 {
         struct intel_output *intel_output;
         struct intel_dvo_device *dvo;
-        struct intel_i2c_chan *i2cbus = NULL;
+        struct i2c_adapter *i2cbus = NULL;
         int ret = 0;
         int i;
-        int gpio_inited = 0;
         int encoder_type = DRM_MODE_ENCODER_NONE;
         intel_output = kzalloc (sizeof(struct intel_output), GFP_KERNEL);
         if (!intel_output)
@@ -420,14 +419,11 @@ void intel_dvo_init(struct drm_device *dev)
                  * It appears that everything is on GPIOE except for panels
                  * on i830 laptops, which are on GPIOB (DVOA).
                  */
-                if (gpio_inited != gpio) {
-                        if (i2cbus != NULL)
-                                intel_i2c_destroy(i2cbus);
-                        if (!(i2cbus = intel_i2c_create(dev, gpio,
-                                gpio == GPIOB ? "DVOI2C_B" : "DVOI2C_E"))) {
-                                continue;
-                        }
-                        gpio_inited = gpio;
+                if (i2cbus != NULL)
+                        intel_i2c_destroy(i2cbus);
+                if (!(i2cbus = intel_i2c_create(dev, gpio,
+                        gpio == GPIOB ? "DVOI2C_B" : "DVOI2C_E"))) {
+                        continue;
                 }
 
                 if (dvo->dev_ops!= NULL)
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index 4ea2a651b92c..9e30daae37dc 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -31,6 +31,7 @@
 #include "drmP.h"
 #include "drm.h"
 #include "drm_crtc.h"
+#include "drm_edid.h"
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
@@ -56,8 +57,7 @@ static void intel_hdmi_mode_set(struct drm_encoder *encoder,
         sdvox = SDVO_ENCODING_HDMI |
                 SDVO_BORDER_ENABLE |
                 SDVO_VSYNC_ACTIVE_HIGH |
-                SDVO_HSYNC_ACTIVE_HIGH |
-                SDVO_NULL_PACKETS_DURING_VSYNC;
+                SDVO_HSYNC_ACTIVE_HIGH;
 
         if (hdmi_priv->has_hdmi_sink)
                 sdvox |= SDVO_AUDIO_ENABLE;
@@ -129,20 +129,26 @@ static bool intel_hdmi_mode_fixup(struct drm_encoder *encoder,
         return true;
 }
 
-static void
-intel_hdmi_sink_detect(struct drm_connector *connector)
+static enum drm_connector_status
+intel_hdmi_edid_detect(struct drm_connector *connector)
 {
         struct intel_output *intel_output = to_intel_output(connector);
         struct intel_hdmi_priv *hdmi_priv = intel_output->dev_priv;
         struct edid *edid = NULL;
+        enum drm_connector_status status = connector_status_disconnected;
 
         edid = drm_get_edid(&intel_output->base,
-                            &intel_output->ddc_bus->adapter);
-        if (edid != NULL) {
-                hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
-                kfree(edid);
+                            intel_output->ddc_bus);
+        hdmi_priv->has_hdmi_sink = false;
+        if (edid) {
+                if (edid->input & DRM_EDID_INPUT_DIGITAL) {
+                        status = connector_status_connected;
+                        hdmi_priv->has_hdmi_sink = drm_detect_hdmi_monitor(edid);
+                }
                 intel_output->base.display_info.raw_edid = NULL;
+                kfree(edid);
         }
+        return status;
 }
 
 static enum drm_connector_status
@@ -154,11 +160,7 @@ igdng_hdmi_detect(struct drm_connector *connector)
         /* FIXME hotplug detect */
 
         hdmi_priv->has_hdmi_sink = false;
-        intel_hdmi_sink_detect(connector);
-        if (hdmi_priv->has_hdmi_sink)
-                return connector_status_connected;
-        else
-                return connector_status_disconnected;
+        return intel_hdmi_edid_detect(connector);
 }
 
 static enum drm_connector_status
@@ -201,10 +203,9 @@ intel_hdmi_detect(struct drm_connector *connector)
                 return connector_status_unknown;
         }
 
-        if ((I915_READ(PORT_HOTPLUG_STAT) & bit) != 0) {
-                intel_hdmi_sink_detect(connector);
-                return connector_status_connected;
-        } else
+        if ((I915_READ(PORT_HOTPLUG_STAT) & bit) != 0)
+                return intel_hdmi_edid_detect(connector);
+        else
                 return connector_status_disconnected;
 }
 
diff --git a/drivers/gpu/drm/i915/intel_i2c.c b/drivers/gpu/drm/i915/intel_i2c.c
index f7061f68d050..62b8bead7652 100644
--- a/drivers/gpu/drm/i915/intel_i2c.c
+++ b/drivers/gpu/drm/i915/intel_i2c.c
@@ -124,6 +124,7 @@ static void set_data(void *data, int state_high)
  * @output: driver specific output device
  * @reg: GPIO reg to use
  * @name: name for this bus
+ * @slave_addr: slave address (if fixed)
  *
  * Creates and registers a new i2c bus with the Linux i2c layer, for use
  * in output probing and control (e.g. DDC or SDVO control functions).
@@ -139,8 +140,8 @@ static void set_data(void *data, int state_high)
  *   %GPIOH
  * see PRM for details on how these different busses are used.
  */
-struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
-                                        const char *name)
+struct i2c_adapter *intel_i2c_create(struct drm_device *dev, const u32 reg,
+                                     const char *name)
 {
         struct intel_i2c_chan *chan;
 
@@ -174,7 +175,7 @@ struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
         intel_i2c_quirk_set(dev, false);
         udelay(20);
 
-        return chan;
+        return &chan->adapter;
 
 out_free:
         kfree(chan);
@@ -187,11 +188,16 @@ out_free:
  *
  * Unregister the adapter from the i2c layer, then free the structure.
  */
-void intel_i2c_destroy(struct intel_i2c_chan *chan)
+void intel_i2c_destroy(struct i2c_adapter *adapter)
 {
-        if (!chan)
+        struct intel_i2c_chan *chan;
+
+        if (!adapter)
                 return;
 
+        chan = container_of(adapter,
+                            struct intel_i2c_chan,
+                            adapter);
         i2c_del_adapter(&chan->adapter);
         kfree(chan);
 }
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index f073ed8432e8..9564ca44a977 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -39,6 +39,21 @@
 
 #define I915_LVDS "i915_lvds"
 
+/*
+ * the following four scaling options are defined.
+ * #define DRM_MODE_SCALE_NON_GPU       0
+ * #define DRM_MODE_SCALE_FULLSCREEN    1
+ * #define DRM_MODE_SCALE_NO_SCALE      2
+ * #define DRM_MODE_SCALE_ASPECT        3
+ */
+
+/* Private structure for the integrated LVDS support */
+struct intel_lvds_priv {
+        int fitting_mode;
+        u32 pfit_control;
+        u32 pfit_pgm_ratios;
+};
+
 /**
  * Sets the backlight level.
  *
@@ -213,10 +228,27 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
                                   struct drm_display_mode *mode,
                                   struct drm_display_mode *adjusted_mode)
 {
+        /*
+         * float point operation is not supported . So the PANEL_RATIO_FACTOR
+         * is defined, which can avoid the float point computation when
+         * calculating the panel ratio.
+         */
+#define PANEL_RATIO_FACTOR 8192
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
         struct drm_encoder *tmp_encoder;
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_lvds_priv *lvds_priv = intel_output->dev_priv;
+        u32 pfit_control = 0, pfit_pgm_ratios = 0;
+        int left_border = 0, right_border = 0, top_border = 0;
+        int bottom_border = 0;
+        bool border = 0;
+        int panel_ratio, desired_ratio, vert_scale, horiz_scale;
+        int horiz_ratio, vert_ratio;
+        u32 hsync_width, vsync_width;
+        u32 hblank_width, vblank_width;
+        u32 hsync_pos, vsync_pos;
 
         /* Should never happen!! */
         if (!IS_I965G(dev) && intel_crtc->pipe == 0) {
@@ -232,7 +264,9 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
                         return false;
                 }
         }
-
+        /* If we don't have a panel mode, there is nothing we can do */
+        if (dev_priv->panel_fixed_mode == NULL)
+                return true;
         /*
          * If we have timings from the BIOS for the panel, put them in
          * to the adjusted mode.  The CRTC will be set up for this mode,
@@ -256,6 +290,243 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
                 drm_mode_set_crtcinfo(adjusted_mode, CRTC_INTERLACE_HALVE_V);
         }
 
+        /* Make sure pre-965s set dither correctly */
+        if (!IS_I965G(dev)) {
+                if (dev_priv->panel_wants_dither || dev_priv->lvds_dither)
+                        pfit_control |= PANEL_8TO6_DITHER_ENABLE;
+        }
+
+        /* Native modes don't need fitting */
+        if (adjusted_mode->hdisplay == mode->hdisplay &&
+                        adjusted_mode->vdisplay == mode->vdisplay) {
+                pfit_pgm_ratios = 0;
+                border = 0;
+                goto out;
+        }
+
+        /* 965+ wants fuzzy fitting */
+        if (IS_I965G(dev))
+                pfit_control |= (intel_crtc->pipe << PFIT_PIPE_SHIFT) |
+                                        PFIT_FILTER_FUZZY;
+
+        hsync_width = adjusted_mode->crtc_hsync_end -
+                                        adjusted_mode->crtc_hsync_start;
+        vsync_width = adjusted_mode->crtc_vsync_end -
+                                        adjusted_mode->crtc_vsync_start;
+        hblank_width = adjusted_mode->crtc_hblank_end -
+                                        adjusted_mode->crtc_hblank_start;
+        vblank_width = adjusted_mode->crtc_vblank_end -
+                                        adjusted_mode->crtc_vblank_start;
+        /*
+         * Deal with panel fitting options. Figure out how to stretch the
+         * image based on its aspect ratio & the current panel fitting mode.
+         */
+        panel_ratio = adjusted_mode->hdisplay * PANEL_RATIO_FACTOR /
+                                adjusted_mode->vdisplay;
+        desired_ratio = mode->hdisplay * PANEL_RATIO_FACTOR /
+                                mode->vdisplay;
+        /*
+         * Enable automatic panel scaling for non-native modes so that they fill
+         * the screen.  Should be enabled before the pipe is enabled, according
+         * to register description and PRM.
+         * Change the value here to see the borders for debugging
+         */
+        I915_WRITE(BCLRPAT_A, 0);
+        I915_WRITE(BCLRPAT_B, 0);
+
+        switch (lvds_priv->fitting_mode) {
+        case DRM_MODE_SCALE_NO_SCALE:
+                /*
+                 * For centered modes, we have to calculate border widths &
+                 * heights and modify the values programmed into the CRTC.
+                 */
+                left_border = (adjusted_mode->hdisplay - mode->hdisplay) / 2;
+                right_border = left_border;
+                if (mode->hdisplay & 1)
+                        right_border++;
+                top_border = (adjusted_mode->vdisplay - mode->vdisplay) / 2;
+                bottom_border = top_border;
+                if (mode->vdisplay & 1)
+                        bottom_border++;
+                /* Set active & border values */
+                adjusted_mode->crtc_hdisplay = mode->hdisplay;
+                /* Keep the boder be even */
+                if (right_border & 1)
+                        right_border++;
+                /* use the border directly instead of border minuse one */
+                adjusted_mode->crtc_hblank_start = mode->hdisplay +
+                                                right_border;
+                /* keep the blank width constant */
+                adjusted_mode->crtc_hblank_end =
+                        adjusted_mode->crtc_hblank_start + hblank_width;
+                /* get the hsync pos relative to hblank start */
+                hsync_pos = (hblank_width - hsync_width) / 2;
+                /* keep the hsync pos be even */
+                if (hsync_pos & 1)
+                        hsync_pos++;
+                adjusted_mode->crtc_hsync_start =
+                                adjusted_mode->crtc_hblank_start + hsync_pos;
+                /* keep the hsync width constant */
+                adjusted_mode->crtc_hsync_end =
+                                adjusted_mode->crtc_hsync_start + hsync_width;
+                adjusted_mode->crtc_vdisplay = mode->vdisplay;
+                /* use the border instead of border minus one */
+                adjusted_mode->crtc_vblank_start = mode->vdisplay +
+                                                bottom_border;
+                /* keep the vblank width constant */
+                adjusted_mode->crtc_vblank_end =
+                                adjusted_mode->crtc_vblank_start + vblank_width;
+                /* get the vsync start postion relative to vblank start */
+                vsync_pos = (vblank_width - vsync_width) / 2;
+                adjusted_mode->crtc_vsync_start =
+                                adjusted_mode->crtc_vblank_start + vsync_pos;
+                /* keep the vsync width constant */
+                adjusted_mode->crtc_vsync_end =
+                                adjusted_mode->crtc_vblank_start + vsync_width;
+                border = 1;
+                break;
+        case DRM_MODE_SCALE_ASPECT:
+                /* Scale but preserve the spect ratio */
+                pfit_control |= PFIT_ENABLE;
+                if (IS_I965G(dev)) {
+                        /* 965+ is easy, it does everything in hw */
+                        if (panel_ratio > desired_ratio)
+                                pfit_control |= PFIT_SCALING_PILLAR;
+                        else if (panel_ratio < desired_ratio)
+                                pfit_control |= PFIT_SCALING_LETTER;
+                        else
+                                pfit_control |= PFIT_SCALING_AUTO;
+                } else {
+                        /*
+                         * For earlier chips we have to calculate the scaling
+                         * ratio by hand and program it into the
+                         * PFIT_PGM_RATIO register
+                         */
+                        u32 horiz_bits, vert_bits, bits = 12;
+                        horiz_ratio = mode->hdisplay * PANEL_RATIO_FACTOR/
+                                                adjusted_mode->hdisplay;
+                        vert_ratio = mode->vdisplay * PANEL_RATIO_FACTOR/
+                                                adjusted_mode->vdisplay;
+                        horiz_scale = adjusted_mode->hdisplay *
+                                        PANEL_RATIO_FACTOR / mode->hdisplay;
+                        vert_scale = adjusted_mode->vdisplay *
+                                        PANEL_RATIO_FACTOR / mode->vdisplay;
+
+                        /* retain aspect ratio */
+                        if (panel_ratio > desired_ratio) { /* Pillar */
+                                u32 scaled_width;
+                                scaled_width = mode->hdisplay * vert_scale /
+                                                PANEL_RATIO_FACTOR;
+                                horiz_ratio = vert_ratio;
+                                pfit_control |= (VERT_AUTO_SCALE |
+                                                 VERT_INTERP_BILINEAR |
+                                                 HORIZ_INTERP_BILINEAR);
+                                /* Pillar will have left/right borders */
+                                left_border = (adjusted_mode->hdisplay -
+                                                scaled_width) / 2;
+                                right_border = left_border;
+                                if (mode->hdisplay & 1) /* odd resolutions */
+                                        right_border++;
+                                /* keep the border be even */
+                                if (right_border & 1)
+                                        right_border++;
+                                adjusted_mode->crtc_hdisplay = scaled_width;
+                                /* use border instead of border minus one */
+                                adjusted_mode->crtc_hblank_start =
+                                        scaled_width + right_border;
+                                /* keep the hblank width constant */
+                                adjusted_mode->crtc_hblank_end =
+                                        adjusted_mode->crtc_hblank_start +
+                                                        hblank_width;
+                                /*
+                                 * get the hsync start pos relative to
+                                 * hblank start
+                                 */
+                                hsync_pos = (hblank_width - hsync_width) / 2;
+                                /* keep the hsync_pos be even */
+                                if (hsync_pos & 1)
+                                        hsync_pos++;
+                                adjusted_mode->crtc_hsync_start =
+                                        adjusted_mode->crtc_hblank_start +
+                                                        hsync_pos;
+                                /* keept hsync width constant */
+                                adjusted_mode->crtc_hsync_end =
+                                        adjusted_mode->crtc_hsync_start +
+                                                        hsync_width;
+                                border = 1;
+                        } else if (panel_ratio < desired_ratio) { /* letter */
+                                u32 scaled_height = mode->vdisplay *
+                                        horiz_scale / PANEL_RATIO_FACTOR;
+                                vert_ratio = horiz_ratio;
+                                pfit_control |= (HORIZ_AUTO_SCALE |
+                                                 VERT_INTERP_BILINEAR |
+                                                 HORIZ_INTERP_BILINEAR);
+                                /* Letterbox will have top/bottom border */
+                                top_border = (adjusted_mode->vdisplay -
+                                        scaled_height) / 2;
+                                bottom_border = top_border;
+                                if (mode->vdisplay & 1)
+                                        bottom_border++;
+                                adjusted_mode->crtc_vdisplay = scaled_height;
+                                /* use border instead of border minus one */
+                                adjusted_mode->crtc_vblank_start =
+                                        scaled_height + bottom_border;
+                                /* keep the vblank width constant */
+                                adjusted_mode->crtc_vblank_end =
+                                        adjusted_mode->crtc_vblank_start +
+                                                        vblank_width;
+                                /*
+                                 * get the vsync start pos relative to
+                                 * vblank start
+                                 */
+                                vsync_pos = (vblank_width - vsync_width) / 2;
+                                adjusted_mode->crtc_vsync_start =
+                                        adjusted_mode->crtc_vblank_start +
+                                                        vsync_pos;
+                                /* keep the vsync width constant */
+                                adjusted_mode->crtc_vsync_end =
+                                        adjusted_mode->crtc_vsync_start +
+                                                        vsync_width;
+                                border = 1;
+                        } else {
+                        /* Aspects match, Let hw scale both directions */
+                                pfit_control |= (VERT_AUTO_SCALE |
+                                                 HORIZ_AUTO_SCALE |
+                                                 VERT_INTERP_BILINEAR |
+                                                 HORIZ_INTERP_BILINEAR);
+                        }
+                        horiz_bits = (1 << bits) * horiz_ratio /
+                                        PANEL_RATIO_FACTOR;
+                        vert_bits = (1 << bits) * vert_ratio /
+                                        PANEL_RATIO_FACTOR;
+                        pfit_pgm_ratios =
+                                ((vert_bits << PFIT_VERT_SCALE_SHIFT) &
+                                                PFIT_VERT_SCALE_MASK) |
+                                ((horiz_bits << PFIT_HORIZ_SCALE_SHIFT) &
+                                                PFIT_HORIZ_SCALE_MASK);
+                }
+                break;
+
+        case DRM_MODE_SCALE_FULLSCREEN:
+                /*
+                 * Full scaling, even if it changes the aspect ratio.
+                 * Fortunately this is all done for us in hw.
+                 */
+                pfit_control |= PFIT_ENABLE;
+                if (IS_I965G(dev))
+                        pfit_control |= PFIT_SCALING_AUTO;
+                else
+                        pfit_control |= (VERT_AUTO_SCALE | HORIZ_AUTO_SCALE |
+                                         VERT_INTERP_BILINEAR |
+                                         HORIZ_INTERP_BILINEAR);
+                break;
+        default:
+                break;
+        }
+
+out:
+        lvds_priv->pfit_control = pfit_control;
+        lvds_priv->pfit_pgm_ratios = pfit_pgm_ratios;
         /*
          * XXX: It would be nice to support lower refresh rates on the
          * panels to reduce power consumption, and perhaps match the
@@ -301,8 +572,8 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
 {
         struct drm_device *dev = encoder->dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
-        struct intel_crtc *intel_crtc = to_intel_crtc(encoder->crtc);
-        u32 pfit_control;
+        struct intel_output *intel_output = enc_to_intel_output(encoder);
+        struct intel_lvds_priv *lvds_priv = intel_output->dev_priv;
 
         /*
          * The LVDS pin pair will already have been turned on in the
@@ -319,22 +590,8 @@ static void intel_lvds_mode_set(struct drm_encoder *encoder,
          * screen.  Should be enabled before the pipe is enabled, according to
          * register description and PRM.
          */
-        if (mode->hdisplay != adjusted_mode->hdisplay ||
-            mode->vdisplay != adjusted_mode->vdisplay)
-                pfit_control = (PFIT_ENABLE | VERT_AUTO_SCALE |
-                                HORIZ_AUTO_SCALE | VERT_INTERP_BILINEAR |
-                                HORIZ_INTERP_BILINEAR);
-        else
-                pfit_control = 0;
-
-        if (!IS_I965G(dev)) {
-                if (dev_priv->panel_wants_dither || dev_priv->lvds_dither)
-                        pfit_control |= PANEL_8TO6_DITHER_ENABLE;
-        }
-        else
-                pfit_control |= intel_crtc->pipe << PFIT_PIPE_SHIFT;
-
-        I915_WRITE(PFIT_CONTROL, pfit_control);
+        I915_WRITE(PFIT_PGM_RATIOS, lvds_priv->pfit_pgm_ratios);
+        I915_WRITE(PFIT_CONTROL, lvds_priv->pfit_control);
 }
 
 /**
@@ -406,6 +663,34 @@ static int intel_lvds_set_property(struct drm_connector *connector,
                                    struct drm_property *property,
                                    uint64_t value)
 {
+        struct drm_device *dev = connector->dev;
+        struct intel_output *intel_output =
+                        to_intel_output(connector);
+
+        if (property == dev->mode_config.scaling_mode_property &&
+                                connector->encoder) {
+                struct drm_crtc *crtc = connector->encoder->crtc;
+                struct intel_lvds_priv *lvds_priv = intel_output->dev_priv;
+                if (value == DRM_MODE_SCALE_NON_GPU) {
+                        DRM_DEBUG_KMS(I915_LVDS,
+                                        "non_GPU property is unsupported\n");
+                        return 0;
+                }
+                if (lvds_priv->fitting_mode == value) {
+                        /* the LVDS scaling property is not changed */
+                        return 0;
+                }
+                lvds_priv->fitting_mode = value;
+                if (crtc && crtc->enabled) {
+                        /*
+                         * If the CRTC is enabled, the display will be changed
+                         * according to the new panel fitting mode.
+                         */
+                        drm_crtc_helper_set_mode(crtc, &crtc->mode,
+                                crtc->x, crtc->y, crtc->fb);
+                }
+        }
+
         return 0;
 }
 
@@ -456,7 +741,7 @@ static const struct dmi_system_id intel_no_lvds[] = {
                 .callback = intel_no_lvds_dmi_callback,
                 .ident = "Apple Mac Mini (Core series)",
                 .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Macmini1,1"),
                 },
         },
@@ -464,7 +749,7 @@ static const struct dmi_system_id intel_no_lvds[] = {
                 .callback = intel_no_lvds_dmi_callback,
                 .ident = "Apple Mac Mini (Core 2 series)",
                 .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Apple Inc."),
+                        DMI_MATCH(DMI_SYS_VENDOR, "Apple"),
                         DMI_MATCH(DMI_PRODUCT_NAME, "Macmini2,1"),
                 },
         },
@@ -518,6 +803,7 @@ void intel_lvds_init(struct drm_device *dev)
         struct drm_encoder *encoder;
         struct drm_display_mode *scan; /* *modes, *bios_mode; */
         struct drm_crtc *crtc;
+        struct intel_lvds_priv *lvds_priv;
         u32 lvds;
         int pipe, gpio = GPIOC;
 
@@ -531,7 +817,8 @@ void intel_lvds_init(struct drm_device *dev)
                 gpio = PCH_GPIOC;
         }
 
-        intel_output = kzalloc(sizeof(struct intel_output), GFP_KERNEL);
+        intel_output = kzalloc(sizeof(struct intel_output) +
+                                sizeof(struct intel_lvds_priv), GFP_KERNEL);
         if (!intel_output) {
                 return;
         }
@@ -553,7 +840,18 @@ void intel_lvds_init(struct drm_device *dev)
         connector->interlace_allowed = false;
         connector->doublescan_allowed = false;
 
+        lvds_priv = (struct intel_lvds_priv *)(intel_output + 1);
+        intel_output->dev_priv = lvds_priv;
+        /* create the scaling mode property */
+        drm_mode_create_scaling_mode_property(dev);
+        /*
+         * the initial panel fitting mode will be FULL_SCREEN.
+         */
 
+        drm_connector_attach_property(&intel_output->base,
+                                      dev->mode_config.scaling_mode_property,
+                                      DRM_MODE_SCALE_FULLSCREEN);
+        lvds_priv->fitting_mode = DRM_MODE_SCALE_FULLSCREEN;
         /*
          * LVDS discovery:
          * 1) check for EDID on DDC
@@ -649,5 +947,5 @@ failed:
         if (intel_output->ddc_bus)
                 intel_i2c_destroy(intel_output->ddc_bus);
         drm_connector_cleanup(connector);
-        kfree(connector);
+        kfree(intel_output);
 }
diff --git a/drivers/gpu/drm/i915/intel_modes.c b/drivers/gpu/drm/i915/intel_modes.c
index e0910fefce87..67e2f4632a24 100644
--- a/drivers/gpu/drm/i915/intel_modes.c
+++ b/drivers/gpu/drm/i915/intel_modes.c
@@ -53,10 +53,9 @@ bool intel_ddc_probe(struct intel_output *intel_output)
                 }
         };
 
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, true);
-        ret = i2c_transfer(&intel_output->ddc_bus->adapter, msgs, 2);
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, false);
-
+        intel_i2c_quirk_set(intel_output->base.dev, true);
+        ret = i2c_transfer(intel_output->ddc_bus, msgs, 2);
+        intel_i2c_quirk_set(intel_output->base.dev, false);
         if (ret == 2)
                 return true;
 
@@ -74,10 +73,9 @@ int intel_ddc_get_modes(struct intel_output *intel_output)
         struct edid *edid;
         int ret = 0;
 
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, true);
-        edid = drm_get_edid(&intel_output->base,
-                            &intel_output->ddc_bus->adapter);
-        intel_i2c_quirk_set(intel_output->ddc_bus->drm_dev, false);
+        intel_i2c_quirk_set(intel_output->base.dev, true);
+        edid = drm_get_edid(&intel_output->base, intel_output->ddc_bus);
+        intel_i2c_quirk_set(intel_output->base.dev, false);
         if (edid) {
                 drm_mode_connector_update_edid_property(&intel_output->base,
                                                         edid);
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 9a00adb3a508..f03473779feb 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -38,8 +38,7 @@
 #undef SDVO_DEBUG
 #define I915_SDVO       "i915_sdvo"
 struct intel_sdvo_priv {
-        struct intel_i2c_chan *i2c_bus;
-        int slaveaddr;
+        u8 slave_addr;
 
         /* Register for the SDVO device: SDVOB or SDVOC */
         int output_device;
@@ -146,13 +145,13 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
 
         struct i2c_msg msgs[] = {
                 {
-                        .addr = sdvo_priv->i2c_bus->slave_addr,
+                        .addr = sdvo_priv->slave_addr >> 1,
                         .flags = 0,
                         .len = 1,
                         .buf = out_buf,
                 },
                 {
-                        .addr = sdvo_priv->i2c_bus->slave_addr,
+                        .addr = sdvo_priv->slave_addr >> 1,
                         .flags = I2C_M_RD,
                         .len = 1,
                         .buf = buf,
@@ -162,7 +161,7 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
         out_buf[0] = addr;
         out_buf[1] = 0;
 
-        if ((ret = i2c_transfer(&sdvo_priv->i2c_bus->adapter, msgs, 2)) == 2)
+        if ((ret = i2c_transfer(intel_output->i2c_bus, msgs, 2)) == 2)
         {
                 *ch = buf[0];
                 return true;
@@ -175,10 +174,11 @@ static bool intel_sdvo_read_byte(struct intel_output *intel_output, u8 addr,
 static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr,
                                   u8 ch)
 {
+        struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
         u8 out_buf[2];
         struct i2c_msg msgs[] = {
                 {
-                        .addr = intel_output->i2c_bus->slave_addr,
+                        .addr = sdvo_priv->slave_addr >> 1,
                         .flags = 0,
                         .len = 2,
                         .buf = out_buf,
@@ -188,7 +188,7 @@ static bool intel_sdvo_write_byte(struct intel_output *intel_output, int addr,
         out_buf[0] = addr;
         out_buf[1] = ch;
 
-        if (i2c_transfer(&intel_output->i2c_bus->adapter, msgs, 1) == 1)
+        if (i2c_transfer(intel_output->i2c_bus, msgs, 1) == 1)
         {
                 return true;
         }
@@ -1369,9 +1369,8 @@ intel_sdvo_hdmi_sink_detect(struct drm_connector *connector)
         struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
         struct edid *edid = NULL;
 
-        intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus);
         edid = drm_get_edid(&intel_output->base,
-                            &intel_output->ddc_bus->adapter);
+                            intel_output->ddc_bus);
         if (edid != NULL) {
                 sdvo_priv->is_hdmi = drm_detect_hdmi_monitor(edid);
                 kfree(edid);
@@ -1549,7 +1548,6 @@ static void intel_sdvo_get_tv_modes(struct drm_connector *connector)
 static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
 {
         struct intel_output *intel_output = to_intel_output(connector);
-        struct intel_sdvo_priv *sdvo_priv = intel_output->dev_priv;
         struct drm_i915_private *dev_priv = connector->dev->dev_private;
 
         /*
@@ -1557,8 +1555,6 @@ static void intel_sdvo_get_lvds_modes(struct drm_connector *connector)
          * Assume that the preferred modes are
          * arranged in priority order.
          */
-        /* set the bus switch and get the modes */
-        intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus);
         intel_ddc_get_modes(intel_output);
         if (list_empty(&connector->probed_modes) == false)
                 return;
@@ -1709,7 +1705,7 @@ intel_sdvo_chan_to_intel_output(struct intel_i2c_chan *chan)
 
         list_for_each_entry(connector,
                         &dev->mode_config.connector_list, head) {
-                if (to_intel_output(connector)->ddc_bus == chan) {
+                if (to_intel_output(connector)->ddc_bus == &chan->adapter) {
                         intel_output = to_intel_output(connector);
                         break;
                 }
@@ -1723,7 +1719,7 @@ static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap,
         struct intel_output *intel_output;
         struct intel_sdvo_priv *sdvo_priv;
         struct i2c_algo_bit_data *algo_data;
-        struct i2c_algorithm *algo;
+        const struct i2c_algorithm *algo;
 
         algo_data = (struct i2c_algo_bit_data *)i2c_adap->algo_data;
         intel_output =
@@ -1733,7 +1729,7 @@ static int intel_sdvo_master_xfer(struct i2c_adapter *i2c_adap,
                 return -EINVAL;
 
         sdvo_priv = intel_output->dev_priv;
-        algo = (struct i2c_algorithm *)intel_output->i2c_bus->adapter.algo;
+        algo = intel_output->i2c_bus->algo;
 
         intel_sdvo_set_control_bus_switch(intel_output, sdvo_priv->ddc_bus);
         return algo->master_xfer(i2c_adap, msgs, num);
@@ -1785,13 +1781,11 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
         struct drm_connector *connector;
         struct intel_output *intel_output;
         struct intel_sdvo_priv *sdvo_priv;
-        struct intel_i2c_chan *i2cbus = NULL;
-        struct intel_i2c_chan *ddcbus = NULL;
+
         int connector_type;
         u8 ch[0x40];
         int i;
-        int encoder_type, output_id;
-        u8 slave_addr;
+        int encoder_type;
 
         intel_output = kcalloc(sizeof(struct intel_output)+sizeof(struct intel_sdvo_priv), 1, GFP_KERNEL);
         if (!intel_output) {
@@ -1799,29 +1793,24 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
         }
 
         sdvo_priv = (struct intel_sdvo_priv *)(intel_output + 1);
+        sdvo_priv->output_device = output_device;
+
+        intel_output->dev_priv = sdvo_priv;
         intel_output->type = INTEL_OUTPUT_SDVO;
 
         /* setup the DDC bus. */
         if (output_device == SDVOB)
-                i2cbus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB");
+                intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOB");
         else
-                i2cbus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC");
+                intel_output->i2c_bus = intel_i2c_create(dev, GPIOE, "SDVOCTRL_E for SDVOC");
 
-        if (!i2cbus)
+        if (!intel_output->i2c_bus)
                 goto err_inteloutput;
 
-        slave_addr = intel_sdvo_get_slave_addr(dev, output_device);
-        sdvo_priv->i2c_bus = i2cbus;
+        sdvo_priv->slave_addr = intel_sdvo_get_slave_addr(dev, output_device);
 
-        if (output_device == SDVOB) {
-                output_id = 1;
-        } else {
-                output_id = 2;
-        }
-        sdvo_priv->i2c_bus->slave_addr = slave_addr >> 1;
-        sdvo_priv->output_device = output_device;
-        intel_output->i2c_bus = i2cbus;
-        intel_output->dev_priv = sdvo_priv;
+        /* Save the bit-banging i2c functionality for use by the DDC wrapper */
+        intel_sdvo_i2c_bit_algo.functionality = intel_output->i2c_bus->algo->functionality;
 
         /* Read the regs to test if we can talk to the device */
         for (i = 0; i < 0x40; i++) {
@@ -1835,17 +1824,15 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
 
         /* setup the DDC bus. */
         if (output_device == SDVOB)
-                ddcbus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS");
+                intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOB DDC BUS");
         else
-                ddcbus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS");
+                intel_output->ddc_bus = intel_i2c_create(dev, GPIOE, "SDVOC DDC BUS");
 
-        if (ddcbus == NULL)
+        if (intel_output->ddc_bus == NULL)
                 goto err_i2c;
 
-        intel_sdvo_i2c_bit_algo.functionality =
-                intel_output->i2c_bus->adapter.algo->functionality;
-        ddcbus->adapter.algo = &intel_sdvo_i2c_bit_algo;
-        intel_output->ddc_bus = ddcbus;
+        /* Wrap with our custom algo which switches to DDC mode */
+        intel_output->ddc_bus->algo = &intel_sdvo_i2c_bit_algo;
 
         /* In defaut case sdvo lvds is false */
         sdvo_priv->is_lvds = false;
@@ -1965,9 +1952,10 @@ bool intel_sdvo_init(struct drm_device *dev, int output_device)
         return true;
 
 err_i2c:
-        if (ddcbus != NULL)
+        if (intel_output->ddc_bus != NULL)
                 intel_i2c_destroy(intel_output->ddc_bus);
-        intel_i2c_destroy(intel_output->i2c_bus);
+        if (intel_output->i2c_bus != NULL)
+                intel_i2c_destroy(intel_output->i2c_bus);
 err_inteloutput:
         kfree(intel_output);
 
diff --git a/drivers/gpu/drm/i915/intel_tv.c b/drivers/gpu/drm/i915/intel_tv.c
index ea68992e4416..a43c98e3f077 100644
--- a/drivers/gpu/drm/i915/intel_tv.c
+++ b/drivers/gpu/drm/i915/intel_tv.c
@@ -1383,34 +1383,31 @@ intel_tv_detect_type (struct drm_crtc *crtc, struct intel_output *intel_output)
         /*
          * Detect TV by polling)
          */
-        if (intel_output->load_detect_temp) {
-                /* TV not currently running, prod it with destructive detect */
-                save_tv_dac = tv_dac;
-                tv_ctl = I915_READ(TV_CTL);
-                save_tv_ctl = tv_ctl;
-                tv_ctl &= ~TV_ENC_ENABLE;
-                tv_ctl &= ~TV_TEST_MODE_MASK;
-                tv_ctl |= TV_TEST_MODE_MONITOR_DETECT;
-                tv_dac &= ~TVDAC_SENSE_MASK;
-                tv_dac &= ~DAC_A_MASK;
-                tv_dac &= ~DAC_B_MASK;
-                tv_dac &= ~DAC_C_MASK;
-                tv_dac |= (TVDAC_STATE_CHG_EN |
-                           TVDAC_A_SENSE_CTL |
-                           TVDAC_B_SENSE_CTL |
-                           TVDAC_C_SENSE_CTL |
-                           DAC_CTL_OVERRIDE |
-                           DAC_A_0_7_V |
-                           DAC_B_0_7_V |
-                           DAC_C_0_7_V);
-                I915_WRITE(TV_CTL, tv_ctl);
-                I915_WRITE(TV_DAC, tv_dac);
-                intel_wait_for_vblank(dev);
-                tv_dac = I915_READ(TV_DAC);
-                I915_WRITE(TV_DAC, save_tv_dac);
-                I915_WRITE(TV_CTL, save_tv_ctl);
-                intel_wait_for_vblank(dev);
-        }
+        save_tv_dac = tv_dac;
+        tv_ctl = I915_READ(TV_CTL);
+        save_tv_ctl = tv_ctl;
+        tv_ctl &= ~TV_ENC_ENABLE;
+        tv_ctl &= ~TV_TEST_MODE_MASK;
+        tv_ctl |= TV_TEST_MODE_MONITOR_DETECT;
+        tv_dac &= ~TVDAC_SENSE_MASK;
+        tv_dac &= ~DAC_A_MASK;
+        tv_dac &= ~DAC_B_MASK;
+        tv_dac &= ~DAC_C_MASK;
+        tv_dac |= (TVDAC_STATE_CHG_EN |
+                   TVDAC_A_SENSE_CTL |
+                   TVDAC_B_SENSE_CTL |
+                   TVDAC_C_SENSE_CTL |
+                   DAC_CTL_OVERRIDE |
+                   DAC_A_0_7_V |
+                   DAC_B_0_7_V |
+                   DAC_C_0_7_V);
+        I915_WRITE(TV_CTL, tv_ctl);
+        I915_WRITE(TV_DAC, tv_dac);
+        intel_wait_for_vblank(dev);
+        tv_dac = I915_READ(TV_DAC);
+        I915_WRITE(TV_DAC, save_tv_dac);
+        I915_WRITE(TV_CTL, save_tv_ctl);
+        intel_wait_for_vblank(dev);
         /*
          *  A B C
          *  0 1 1 Composite
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index f30aa7274a54..f97563db4e59 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -35,6 +35,23 @@
 #include "atom.h"
 
 /*
+ * Clear GPU surface registers.
+ */
+static void radeon_surface_init(struct radeon_device *rdev)
+{
+        /* FIXME: check this out */
+        if (rdev->family < CHIP_R600) {
+                int i;
+
+                for (i = 0; i < 8; i++) {
+                        WREG32(RADEON_SURFACE0_INFO +
+                               i * (RADEON_SURFACE1_INFO - RADEON_SURFACE0_INFO),
+                               0);
+                }
+        }
+}
+
+/*
  * GPU scratch registers helpers function.
  */
 static void radeon_scratch_init(struct radeon_device *rdev)
@@ -496,6 +513,8 @@ int radeon_device_init(struct radeon_device *rdev,
         radeon_errata(rdev);
         /* Initialize scratch registers */
         radeon_scratch_init(rdev);
+        /* Initialize surface registers */
+        radeon_surface_init(rdev);
 
         /* TODO: disable VGA need to use VGA request */
         /* BIOS*/
@@ -604,9 +623,6 @@ int radeon_device_init(struct radeon_device *rdev,
         if (r) {
                 return r;
         }
-        if (rdev->fbdev_rfb && rdev->fbdev_rfb->obj) {
-                rdev->fbdev_robj = rdev->fbdev_rfb->obj->driver_private;
-        }
         if (!ret) {
                 DRM_INFO("radeon: kernel modesetting successfully initialized.\n");
         }
diff --git a/drivers/gpu/drm/radeon/radeon_drv.c b/drivers/gpu/drm/radeon/radeon_drv.c
index 09c9fb9f6210..84ba69f48784 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.c
+++ b/drivers/gpu/drm/radeon/radeon_drv.c
@@ -345,7 +345,7 @@ static void __exit radeon_exit(void)
         drm_exit(driver);
 }
 
-late_initcall(radeon_init);
+module_init(radeon_init);
 module_exit(radeon_exit);
 
 MODULE_AUTHOR(DRIVER_AUTHOR);
diff --git a/drivers/gpu/drm/radeon/radeon_fb.c b/drivers/gpu/drm/radeon/radeon_fb.c
index fa86d398945e..9e8f191eb64a 100644
--- a/drivers/gpu/drm/radeon/radeon_fb.c
+++ b/drivers/gpu/drm/radeon/radeon_fb.c
@@ -478,14 +478,16 @@ int radeonfb_create(struct radeon_device *rdev,
 {
         struct fb_info *info;
         struct radeon_fb_device *rfbdev;
-        struct drm_framebuffer *fb;
+        struct drm_framebuffer *fb = NULL;
         struct radeon_framebuffer *rfb;
         struct drm_mode_fb_cmd mode_cmd;
         struct drm_gem_object *gobj = NULL;
         struct radeon_object *robj = NULL;
         struct device *device = &rdev->pdev->dev;
         int size, aligned_size, ret;
+        u64 fb_gpuaddr;
         void *fbptr = NULL;
+        unsigned long tmp;
 
         mode_cmd.width = surface_width;
         mode_cmd.height = surface_height;
@@ -498,11 +500,12 @@ int radeonfb_create(struct radeon_device *rdev,
         aligned_size = ALIGN(size, PAGE_SIZE);
 
         ret = radeon_gem_object_create(rdev, aligned_size, 0,
-                                       RADEON_GEM_DOMAIN_VRAM,
-                                       false, ttm_bo_type_kernel,
-                                       false, &gobj);
+                        RADEON_GEM_DOMAIN_VRAM,
+                        false, ttm_bo_type_kernel,
+                        false, &gobj);
         if (ret) {
-                printk(KERN_ERR "failed to allocate framebuffer\n");
+                printk(KERN_ERR "failed to allocate framebuffer (%d %d)\n",
+                       surface_width, surface_height);
                 ret = -ENOMEM;
                 goto out;
         }
@@ -515,12 +518,19 @@ int radeonfb_create(struct radeon_device *rdev,
                 ret = -ENOMEM;
                 goto out_unref;
         }
+        ret = radeon_object_pin(robj, RADEON_GEM_DOMAIN_VRAM, &fb_gpuaddr);
+        if (ret) {
+                printk(KERN_ERR "failed to pin framebuffer\n");
+                ret = -ENOMEM;
+                goto out_unref;
+        }
 
         list_add(&fb->filp_head, &rdev->ddev->mode_config.fb_kernel_list);
 
         rfb = to_radeon_framebuffer(fb);
         *rfb_p = rfb;
         rdev->fbdev_rfb = rfb;
+        rdev->fbdev_robj = robj;
 
         info = framebuffer_alloc(sizeof(struct radeon_fb_device), device);
         if (info == NULL) {
@@ -541,13 +551,13 @@ int radeonfb_create(struct radeon_device *rdev,
         info->fix.xpanstep = 1; /* doing it in hw */
         info->fix.ypanstep = 1; /* doing it in hw */
         info->fix.ywrapstep = 0;
-        info->fix.accel = FB_ACCEL_I830;
+        info->fix.accel = FB_ACCEL_NONE;
         info->fix.type_aux = 0;
         info->flags = FBINFO_DEFAULT;
         info->fbops = &radeonfb_ops;
         info->fix.line_length = fb->pitch;
-        info->screen_base = fbptr;
-        info->fix.smem_start = (unsigned long)fbptr;
+        tmp = fb_gpuaddr - rdev->mc.vram_location;
+        info->fix.smem_start = rdev->mc.aper_base + tmp;
         info->fix.smem_len = size;
         info->screen_base = fbptr;
         info->screen_size = size;
@@ -562,8 +572,8 @@ int radeonfb_create(struct radeon_device *rdev,
         info->var.width = -1;
         info->var.xres = fb_width;
         info->var.yres = fb_height;
-        info->fix.mmio_start = pci_resource_start(rdev->pdev, 2);
-        info->fix.mmio_len = pci_resource_len(rdev->pdev, 2);
+        info->fix.mmio_start = 0;
+        info->fix.mmio_len = 0;
         info->pixmap.size = 64*1024;
         info->pixmap.buf_align = 8;
         info->pixmap.access_align = 32;
@@ -644,7 +654,7 @@ out_unref:
         if (robj) {
                 radeon_object_kunmap(robj);
         }
-        if (ret) {
+        if (fb && ret) {
                 list_del(&fb->filp_head);
                 drm_gem_object_unreference(gobj);
                 drm_framebuffer_cleanup(fb);
@@ -813,6 +823,7 @@ int radeonfb_remove(struct drm_device *dev, struct drm_framebuffer *fb)
                 robj = rfb->obj->driver_private;
                 unregister_framebuffer(info);
                 radeon_object_kunmap(robj);
+                radeon_object_unpin(robj);
                 framebuffer_release(info);
         }
 
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index 983e8df5e000..bac0d06c52ac 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -223,7 +223,6 @@ int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
 {
         uint32_t flags;
         uint32_t tmp;
-        void *fbptr;
         int r;
 
         flags = radeon_object_flags_from_domain(domain);
@@ -242,10 +241,6 @@ int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
                 DRM_ERROR("radeon: failed to reserve object for pinning it.\n");
                 return r;
         }
-        if (robj->rdev->fbdev_robj == robj) {
-                mutex_lock(&robj->rdev->fbdev_info->lock);
-                radeon_object_kunmap(robj);
-        }
         tmp = robj->tobj.mem.placement;
         ttm_flag_masked(&tmp, flags, TTM_PL_MASK_MEM);
         robj->tobj.proposed_placement = tmp | TTM_PL_FLAG_NO_EVICT | TTM_PL_MASK_CACHING;
@@ -261,23 +256,12 @@ int radeon_object_pin(struct radeon_object *robj, uint32_t domain,
                 DRM_ERROR("radeon: failed to pin object.\n");
         }
         radeon_object_unreserve(robj);
-        if (robj->rdev->fbdev_robj == robj) {
-                if (!r) {
-                        r = radeon_object_kmap(robj, &fbptr);
-                }
-                if (!r) {
-                        robj->rdev->fbdev_info->screen_base = fbptr;
-                        robj->rdev->fbdev_info->fix.smem_start = (unsigned long)fbptr;
-                }
-                mutex_unlock(&robj->rdev->fbdev_info->lock);
-        }
         return r;
 }
 
 void radeon_object_unpin(struct radeon_object *robj)
 {
         uint32_t flags;
-        void *fbptr;
         int r;
 
         spin_lock(&robj->tobj.lock);
@@ -297,10 +281,6 @@ void radeon_object_unpin(struct radeon_object *robj)
                 DRM_ERROR("radeon: failed to reserve object for unpinning it.\n");
                 return;
         }
-        if (robj->rdev->fbdev_robj == robj) {
-                mutex_lock(&robj->rdev->fbdev_info->lock);
-                radeon_object_kunmap(robj);
-        }
         flags = robj->tobj.mem.placement;
         robj->tobj.proposed_placement = flags & ~TTM_PL_FLAG_NO_EVICT;
         r = ttm_buffer_object_validate(&robj->tobj,
@@ -310,16 +290,6 @@ void radeon_object_unpin(struct radeon_object *robj)
                 DRM_ERROR("radeon: failed to unpin buffer.\n");
         }
         radeon_object_unreserve(robj);
-        if (robj->rdev->fbdev_robj == robj) {
-                if (!r) {
-                        r = radeon_object_kmap(robj, &fbptr);
-                }
-                if (!r) {
-                        robj->rdev->fbdev_info->screen_base = fbptr;
-                        robj->rdev->fbdev_info->fix.smem_start = (unsigned long)fbptr;
-                }
-                mutex_unlock(&robj->rdev->fbdev_info->lock);
-        }
 }
 
 int radeon_object_wait(struct radeon_object *robj)
diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 517c84559633..bdec583901eb 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -34,7 +34,6 @@
 #include <linux/highmem.h>
 #include <linux/wait.h>
 #include <linux/vmalloc.h>
-#include <linux/version.h>
 #include <linux/module.h>
 
 void ttm_bo_free_old_node(struct ttm_buffer_object *bo)
diff --git a/drivers/gpu/drm/ttm/ttm_bo_vm.c b/drivers/gpu/drm/ttm/ttm_bo_vm.c
index 27b146c54fbc..40b75032ea47 100644
--- a/drivers/gpu/drm/ttm/ttm_bo_vm.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_vm.c
@@ -32,7 +32,6 @@
 #include <ttm/ttm_bo_driver.h>
 #include <ttm/ttm_placement.h>
 #include <linux/mm.h>
-#include <linux/version.h>
 #include <linux/rbtree.h>
 #include <linux/module.h>
 #include <linux/uaccess.h>
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index 0331fa74cd3f..75dc8bd24592 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -28,7 +28,6 @@
  * Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
  */
 
-#include <linux/version.h>
 #include <linux/vmalloc.h>
 #include <linux/sched.h>
 #include <linux/highmem.h>
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index 3c259ee7ddda..8206442fbabd 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -326,6 +326,16 @@ config I2C_DAVINCI
           devices such as DaVinci NIC.
           For details please see http://www.ti.com/davinci
 
+config I2C_DESIGNWARE
+        tristate "Synopsys DesignWare"
+        depends on HAVE_CLK
+        help
+          If you say yes to this option, support will be included for the
+          Synopsys DesignWare I2C adapter. Only master mode is supported.
+
+          This driver can also be built as a module.  If so, the module
+          will be called i2c-designware.
+
 config I2C_GPIO
         tristate "GPIO-based bitbanging I2C"
         depends on GENERIC_GPIO
diff --git a/drivers/i2c/busses/Makefile b/drivers/i2c/busses/Makefile
index edeabf003106..e654263bfc01 100644
--- a/drivers/i2c/busses/Makefile
+++ b/drivers/i2c/busses/Makefile
@@ -30,6 +30,7 @@ obj-$(CONFIG_I2C_AU1550)	+= i2c-au1550.o
 obj-$(CONFIG_I2C_BLACKFIN_TWI)  += i2c-bfin-twi.o
 obj-$(CONFIG_I2C_CPM)           += i2c-cpm.o
 obj-$(CONFIG_I2C_DAVINCI)       += i2c-davinci.o
+obj-$(CONFIG_I2C_DESIGNWARE)    += i2c-designware.o
 obj-$(CONFIG_I2C_GPIO)          += i2c-gpio.o
 obj-$(CONFIG_I2C_HIGHLANDER)    += i2c-highlander.o
 obj-$(CONFIG_I2C_IBM_IIC)       += i2c-ibm_iic.o
diff --git a/drivers/i2c/busses/i2c-designware.c b/drivers/i2c/busses/i2c-designware.c
new file mode 100644
index 000000000000..b444762e9b9f
--- /dev/null
+++ b/drivers/i2c/busses/i2c-designware.c
@@ -0,0 +1,624 @@
+/*
+ * Synopsys Designware I2C adapter driver (master only).
+ *
+ * Based on the TI DAVINCI I2C adapter driver.
+ *
+ * Copyright (C) 2006 Texas Instruments.
+ * Copyright (C) 2007 MontaVista Software Inc.
+ * Copyright (C) 2009 Provigent Ltd.
+ *
+ * ----------------------------------------------------------------------------
+ *
+ * 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/delay.h>
+#include <linux/i2c.h>
+#include <linux/clk.h>
+#include <linux/errno.h>
+#include <linux/sched.h>
+#include <linux/err.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+/*
+ * Registers offset
+ */
+#define DW_IC_CON               0x0
+#define DW_IC_TAR               0x4
+#define DW_IC_DATA_CMD          0x10
+#define DW_IC_SS_SCL_HCNT       0x14
+#define DW_IC_SS_SCL_LCNT       0x18
+#define DW_IC_FS_SCL_HCNT       0x1c
+#define DW_IC_FS_SCL_LCNT       0x20
+#define DW_IC_INTR_STAT         0x2c
+#define DW_IC_INTR_MASK         0x30
+#define DW_IC_CLR_INTR          0x40
+#define DW_IC_ENABLE            0x6c
+#define DW_IC_STATUS            0x70
+#define DW_IC_TXFLR             0x74
+#define DW_IC_RXFLR             0x78
+#define DW_IC_COMP_PARAM_1      0xf4
+#define DW_IC_TX_ABRT_SOURCE    0x80
+
+#define DW_IC_CON_MASTER                0x1
+#define DW_IC_CON_SPEED_STD             0x2
+#define DW_IC_CON_SPEED_FAST            0x4
+#define DW_IC_CON_10BITADDR_MASTER      0x10
+#define DW_IC_CON_RESTART_EN            0x20
+#define DW_IC_CON_SLAVE_DISABLE         0x40
+
+#define DW_IC_INTR_TX_EMPTY     0x10
+#define DW_IC_INTR_TX_ABRT      0x40
+#define DW_IC_INTR_STOP_DET     0x200
+
+#define DW_IC_STATUS_ACTIVITY   0x1
+
+#define DW_IC_ERR_TX_ABRT       0x1
+
+/*
+ * status codes
+ */
+#define STATUS_IDLE                     0x0
+#define STATUS_WRITE_IN_PROGRESS        0x1
+#define STATUS_READ_IN_PROGRESS         0x2
+
+#define TIMEOUT                 20 /* ms */
+
+/*
+ * hardware abort codes from the DW_IC_TX_ABRT_SOURCE register
+ *
+ * only expected abort codes are listed here
+ * refer to the datasheet for the full list
+ */
+#define ABRT_7B_ADDR_NOACK      0
+#define ABRT_10ADDR1_NOACK      1
+#define ABRT_10ADDR2_NOACK      2
+#define ABRT_TXDATA_NOACK       3
+#define ABRT_GCALL_NOACK        4
+#define ABRT_GCALL_READ         5
+#define ABRT_SBYTE_ACKDET       7
+#define ABRT_SBYTE_NORSTRT      9
+#define ABRT_10B_RD_NORSTRT     10
+#define ARB_MASTER_DIS          11
+#define ARB_LOST                12
+
+static char *abort_sources[] = {
+        [ABRT_7B_ADDR_NOACK]    =
+                "slave address not acknowledged (7bit mode)",
+        [ABRT_10ADDR1_NOACK]    =
+                "first address byte not acknowledged (10bit mode)",
+        [ABRT_10ADDR2_NOACK]    =
+                "second address byte not acknowledged (10bit mode)",
+        [ABRT_TXDATA_NOACK]             =
+                "data not acknowledged",
+        [ABRT_GCALL_NOACK]              =
+                "no acknowledgement for a general call",
+        [ABRT_GCALL_READ]               =
+                "read after general call",
+        [ABRT_SBYTE_ACKDET]             =
+                "start byte acknowledged",
+        [ABRT_SBYTE_NORSTRT]    =
+                "trying to send start byte when restart is disabled",
+        [ABRT_10B_RD_NORSTRT]   =
+                "trying to read when restart is disabled (10bit mode)",
+        [ARB_MASTER_DIS]                =
+                "trying to use disabled adapter",
+        [ARB_LOST]                      =
+                "lost arbitration",
+};
+
+/**
+ * struct dw_i2c_dev - private i2c-designware data
+ * @dev: driver model device node
+ * @base: IO registers pointer
+ * @cmd_complete: tx completion indicator
+ * @pump_msg: continue in progress transfers
+ * @lock: protect this struct and IO registers
+ * @clk: input reference clock
+ * @cmd_err: run time hadware error code
+ * @msgs: points to an array of messages currently being transfered
+ * @msgs_num: the number of elements in msgs
+ * @msg_write_idx: the element index of the current tx message in the msgs
+ *      array
+ * @tx_buf_len: the length of the current tx buffer
+ * @tx_buf: the current tx buffer
+ * @msg_read_idx: the element index of the current rx message in the msgs
+ *      array
+ * @rx_buf_len: the length of the current rx buffer
+ * @rx_buf: the current rx buffer
+ * @msg_err: error status of the current transfer
+ * @status: i2c master status, one of STATUS_*
+ * @abort_source: copy of the TX_ABRT_SOURCE register
+ * @irq: interrupt number for the i2c master
+ * @adapter: i2c subsystem adapter node
+ * @tx_fifo_depth: depth of the hardware tx fifo
+ * @rx_fifo_depth: depth of the hardware rx fifo
+ */
+struct dw_i2c_dev {
+        struct device           *dev;
+        void __iomem            *base;
+        struct completion       cmd_complete;
+        struct tasklet_struct   pump_msg;
+        struct mutex            lock;
+        struct clk              *clk;
+        int                     cmd_err;
+        struct i2c_msg          *msgs;
+        int                     msgs_num;
+        int                     msg_write_idx;
+        u16                     tx_buf_len;
+        u8                      *tx_buf;
+        int                     msg_read_idx;
+        u16                     rx_buf_len;
+        u8                      *rx_buf;
+        int                     msg_err;
+        unsigned int            status;
+        u16                     abort_source;
+        int                     irq;
+        struct i2c_adapter      adapter;
+        unsigned int            tx_fifo_depth;
+        unsigned int            rx_fifo_depth;
+};
+
+/**
+ * i2c_dw_init() - initialize the designware i2c master hardware
+ * @dev: device private data
+ *
+ * This functions configures and enables the I2C master.
+ * This function is called during I2C init function, and in case of timeout at
+ * run time.
+ */
+static void i2c_dw_init(struct dw_i2c_dev *dev)
+{
+        u32 input_clock_khz = clk_get_rate(dev->clk) / 1000;
+        u16 ic_con;
+
+        /* Disable the adapter */
+        writeb(0, dev->base + DW_IC_ENABLE);
+
+        /* set standard and fast speed deviders for high/low periods */
+        writew((input_clock_khz * 40 / 10000)+1, /* std speed high, 4us */
+                        dev->base + DW_IC_SS_SCL_HCNT);
+        writew((input_clock_khz * 47 / 10000)+1, /* std speed low, 4.7us */
+                        dev->base + DW_IC_SS_SCL_LCNT);
+        writew((input_clock_khz *  6 / 10000)+1, /* fast speed high, 0.6us */
+                        dev->base + DW_IC_FS_SCL_HCNT);
+        writew((input_clock_khz * 13 / 10000)+1, /* fast speed low, 1.3us */
+                        dev->base + DW_IC_FS_SCL_LCNT);
+
+        /* configure the i2c master */
+        ic_con = DW_IC_CON_MASTER | DW_IC_CON_SLAVE_DISABLE |
+                DW_IC_CON_RESTART_EN | DW_IC_CON_SPEED_FAST;
+        writew(ic_con, dev->base + DW_IC_CON);
+}
+
+/*
+ * Waiting for bus not busy
+ */
+static int i2c_dw_wait_bus_not_busy(struct dw_i2c_dev *dev)
+{
+        int timeout = TIMEOUT;
+
+        while (readb(dev->base + DW_IC_STATUS) & DW_IC_STATUS_ACTIVITY) {
+                if (timeout <= 0) {
+                        dev_warn(dev->dev, "timeout waiting for bus ready\n");
+                        return -ETIMEDOUT;
+                }
+                timeout--;
+                mdelay(1);
+        }
+
+        return 0;
+}
+
+/*
+ * Initiate low level master read/write transaction.
+ * This function is called from i2c_dw_xfer when starting a transfer.
+ * This function is also called from dw_i2c_pump_msg to continue a transfer
+ * that is longer than the size of the TX FIFO.
+ */
+static void
+i2c_dw_xfer_msg(struct i2c_adapter *adap)
+{
+        struct dw_i2c_dev *dev = i2c_get_adapdata(adap);
+        struct i2c_msg *msgs = dev->msgs;
+        int num = dev->msgs_num;
+        u16 ic_con, intr_mask;
+        int tx_limit = dev->tx_fifo_depth - readb(dev->base + DW_IC_TXFLR);
+        int rx_limit = dev->rx_fifo_depth - readb(dev->base + DW_IC_RXFLR);
+        u16 addr = msgs[dev->msg_write_idx].addr;
+        u16 buf_len = dev->tx_buf_len;
+
+        if (!(dev->status & STATUS_WRITE_IN_PROGRESS)) {
+                /* Disable the adapter */
+                writeb(0, dev->base + DW_IC_ENABLE);
+
+                /* set the slave (target) address */
+                writew(msgs[dev->msg_write_idx].addr, dev->base + DW_IC_TAR);
+
+                /* if the slave address is ten bit address, enable 10BITADDR */
+                ic_con = readw(dev->base + DW_IC_CON);
+                if (msgs[dev->msg_write_idx].flags & I2C_M_TEN)
+                        ic_con |= DW_IC_CON_10BITADDR_MASTER;
+                else
+                        ic_con &= ~DW_IC_CON_10BITADDR_MASTER;
+                writew(ic_con, dev->base + DW_IC_CON);
+
+                /* Enable the adapter */
+                writeb(1, dev->base + DW_IC_ENABLE);
+        }
+
+        for (; dev->msg_write_idx < num; dev->msg_write_idx++) {
+                /* if target address has changed, we need to
+                 * reprogram the target address in the i2c
+                 * adapter when we are done with this transfer
+                 */
+                if (msgs[dev->msg_write_idx].addr != addr)
+                        return;
+
+                if (msgs[dev->msg_write_idx].len == 0) {
+                        dev_err(dev->dev,
+                                "%s: invalid message length\n", __func__);
+                        dev->msg_err = -EINVAL;
+                        return;
+                }
+
+                if (!(dev->status & STATUS_WRITE_IN_PROGRESS)) {
+                        /* new i2c_msg */
+                        dev->tx_buf = msgs[dev->msg_write_idx].buf;
+                        buf_len = msgs[dev->msg_write_idx].len;
+                }
+
+                while (buf_len > 0 && tx_limit > 0 && rx_limit > 0) {
+                        if (msgs[dev->msg_write_idx].flags & I2C_M_RD) {
+                                writew(0x100, dev->base + DW_IC_DATA_CMD);
+                                rx_limit--;
+                        } else
+                                writew(*(dev->tx_buf++),
+                                                dev->base + DW_IC_DATA_CMD);
+                        tx_limit--; buf_len--;
+                }
+        }
+
+        intr_mask = DW_IC_INTR_STOP_DET | DW_IC_INTR_TX_ABRT;
+        if (buf_len > 0) { /* more bytes to be written */
+                intr_mask |= DW_IC_INTR_TX_EMPTY;
+                dev->status |= STATUS_WRITE_IN_PROGRESS;
+        } else
+                dev->status &= ~STATUS_WRITE_IN_PROGRESS;
+        writew(intr_mask, dev->base + DW_IC_INTR_MASK);
+
+        dev->tx_buf_len = buf_len;
+}
+
+static void
+i2c_dw_read(struct i2c_adapter *adap)
+{
+        struct dw_i2c_dev *dev = i2c_get_adapdata(adap);
+        struct i2c_msg *msgs = dev->msgs;
+        int num = dev->msgs_num;
+        u16 addr = msgs[dev->msg_read_idx].addr;
+        int rx_valid = readw(dev->base + DW_IC_RXFLR);
+
+        for (; dev->msg_read_idx < num; dev->msg_read_idx++) {
+                u16 len;
+                u8 *buf;
+
+                if (!(msgs[dev->msg_read_idx].flags & I2C_M_RD))
+                        continue;
+
+                /* different i2c client, reprogram the i2c adapter */
+                if (msgs[dev->msg_read_idx].addr != addr)
+                        return;
+
+                if (!(dev->status & STATUS_READ_IN_PROGRESS)) {
+                        len = msgs[dev->msg_read_idx].len;
+                        buf = msgs[dev->msg_read_idx].buf;
+                } else {
+                        len = dev->rx_buf_len;
+                        buf = dev->rx_buf;
+                }
+
+                for (; len > 0 && rx_valid > 0; len--, rx_valid--)
+                        *buf++ = readb(dev->base + DW_IC_DATA_CMD);
+
+                if (len > 0) {
+                        dev->status |= STATUS_READ_IN_PROGRESS;
+                        dev->rx_buf_len = len;
+                        dev->rx_buf = buf;
+                        return;
+                } else
+                        dev->status &= ~STATUS_READ_IN_PROGRESS;
+        }
+}
+
+/*
+ * Prepare controller for a transaction and call i2c_dw_xfer_msg
+ */
+static int
+i2c_dw_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
+{
+        struct dw_i2c_dev *dev = i2c_get_adapdata(adap);
+        int ret;
+
+        dev_dbg(dev->dev, "%s: msgs: %d\n", __func__, num);
+
+        mutex_lock(&dev->lock);
+
+        INIT_COMPLETION(dev->cmd_complete);
+        dev->msgs = msgs;
+        dev->msgs_num = num;
+        dev->cmd_err = 0;
+        dev->msg_write_idx = 0;
+        dev->msg_read_idx = 0;
+        dev->msg_err = 0;
+        dev->status = STATUS_IDLE;
+
+        ret = i2c_dw_wait_bus_not_busy(dev);
+        if (ret < 0)
+                goto done;
+
+        /* start the transfers */
+        i2c_dw_xfer_msg(adap);
+
+        /* wait for tx to complete */
+        ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete, HZ);
+        if (ret == 0) {
+                dev_err(dev->dev, "controller timed out\n");
+                i2c_dw_init(dev);
+                ret = -ETIMEDOUT;
+                goto done;
+        } else if (ret < 0)
+                goto done;
+
+        if (dev->msg_err) {
+                ret = dev->msg_err;
+                goto done;
+        }
+
+        /* no error */
+        if (likely(!dev->cmd_err)) {
+                /* read rx fifo, and disable the adapter */
+                do {
+                        i2c_dw_read(adap);
+                } while (dev->status & STATUS_READ_IN_PROGRESS);
+                writeb(0, dev->base + DW_IC_ENABLE);
+                ret = num;
+                goto done;
+        }
+
+        /* We have an error */
+        if (dev->cmd_err == DW_IC_ERR_TX_ABRT) {
+                unsigned long abort_source = dev->abort_source;
+                int i;
+
+                for_each_bit(i, &abort_source, ARRAY_SIZE(abort_sources)) {
+                    dev_err(dev->dev, "%s: %s\n", __func__, abort_sources[i]);
+                }
+        }
+        ret = -EIO;
+
+done:
+        mutex_unlock(&dev->lock);
+
+        return ret;
+}
+
+static u32 i2c_dw_func(struct i2c_adapter *adap)
+{
+        return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
+}
+
+static void dw_i2c_pump_msg(unsigned long data)
+{
+        struct dw_i2c_dev *dev = (struct dw_i2c_dev *) data;
+        u16 intr_mask;
+
+        i2c_dw_read(&dev->adapter);
+        i2c_dw_xfer_msg(&dev->adapter);
+
+        intr_mask = DW_IC_INTR_STOP_DET | DW_IC_INTR_TX_ABRT;
+        if (dev->status & STATUS_WRITE_IN_PROGRESS)
+                intr_mask |= DW_IC_INTR_TX_EMPTY;
+        writew(intr_mask, dev->base + DW_IC_INTR_MASK);
+}
+
+/*
+ * Interrupt service routine. This gets called whenever an I2C interrupt
+ * occurs.
+ */
+static irqreturn_t i2c_dw_isr(int this_irq, void *dev_id)
+{
+        struct dw_i2c_dev *dev = dev_id;
+        u16 stat;
+
+        stat = readw(dev->base + DW_IC_INTR_STAT);
+        dev_dbg(dev->dev, "%s: stat=0x%x\n", __func__, stat);
+        if (stat & DW_IC_INTR_TX_ABRT) {
+                dev->abort_source = readw(dev->base + DW_IC_TX_ABRT_SOURCE);
+                dev->cmd_err |= DW_IC_ERR_TX_ABRT;
+                dev->status = STATUS_IDLE;
+        } else if (stat & DW_IC_INTR_TX_EMPTY)
+                tasklet_schedule(&dev->pump_msg);
+
+        readb(dev->base + DW_IC_CLR_INTR);      /* clear interrupts */
+        writew(0, dev->base + DW_IC_INTR_MASK); /* disable interrupts */
+        if (stat & (DW_IC_INTR_TX_ABRT | DW_IC_INTR_STOP_DET))
+                complete(&dev->cmd_complete);
+
+        return IRQ_HANDLED;
+}
+
+static struct i2c_algorithm i2c_dw_algo = {
+        .master_xfer    = i2c_dw_xfer,
+        .functionality  = i2c_dw_func,
+};
+
+static int __devinit dw_i2c_probe(struct platform_device *pdev)
+{
+        struct dw_i2c_dev *dev;
+        struct i2c_adapter *adap;
+        struct resource *mem, *irq, *ioarea;
+        int r;
+
+        /* NOTE: driver uses the static register mapping */
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem) {
+                dev_err(&pdev->dev, "no mem resource?\n");
+                return -EINVAL;
+        }
+
+        irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "no irq resource?\n");
+                return -EINVAL;
+        }
+
+        ioarea = request_mem_region(mem->start, resource_size(mem),
+                        pdev->name);
+        if (!ioarea) {
+                dev_err(&pdev->dev, "I2C region already claimed\n");
+                return -EBUSY;
+        }
+
+        dev = kzalloc(sizeof(struct dw_i2c_dev), GFP_KERNEL);
+        if (!dev) {
+                r = -ENOMEM;
+                goto err_release_region;
+        }
+
+        init_completion(&dev->cmd_complete);
+        tasklet_init(&dev->pump_msg, dw_i2c_pump_msg, (unsigned long) dev);
+        mutex_init(&dev->lock);
+        dev->dev = get_device(&pdev->dev);
+        dev->irq = irq->start;
+        platform_set_drvdata(pdev, dev);
+
+        dev->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(dev->clk)) {
+                r = -ENODEV;
+                goto err_free_mem;
+        }
+        clk_enable(dev->clk);
+
+        dev->base = ioremap(mem->start, resource_size(mem));
+        if (dev->base == NULL) {
+                dev_err(&pdev->dev, "failure mapping io resources\n");
+                r = -EBUSY;
+                goto err_unuse_clocks;
+        }
+        {
+                u32 param1 = readl(dev->base + DW_IC_COMP_PARAM_1);
+
+                dev->tx_fifo_depth = ((param1 >> 16) & 0xff) + 1;
+                dev->rx_fifo_depth = ((param1 >> 8)  & 0xff) + 1;
+        }
+        i2c_dw_init(dev);
+
+        writew(0, dev->base + DW_IC_INTR_MASK); /* disable IRQ */
+        r = request_irq(dev->irq, i2c_dw_isr, 0, pdev->name, dev);
+        if (r) {
+                dev_err(&pdev->dev, "failure requesting irq %i\n", dev->irq);
+                goto err_iounmap;
+        }
+
+        adap = &dev->adapter;
+        i2c_set_adapdata(adap, dev);
+        adap->owner = THIS_MODULE;
+        adap->class = I2C_CLASS_HWMON;
+        strlcpy(adap->name, "Synopsys DesignWare I2C adapter",
+                        sizeof(adap->name));
+        adap->algo = &i2c_dw_algo;
+        adap->dev.parent = &pdev->dev;
+
+        adap->nr = pdev->id;
+        r = i2c_add_numbered_adapter(adap);
+        if (r) {
+                dev_err(&pdev->dev, "failure adding adapter\n");
+                goto err_free_irq;
+        }
+
+        return 0;
+
+err_free_irq:
+        free_irq(dev->irq, dev);
+err_iounmap:
+        iounmap(dev->base);
+err_unuse_clocks:
+        clk_disable(dev->clk);
+        clk_put(dev->clk);
+        dev->clk = NULL;
+err_free_mem:
+        platform_set_drvdata(pdev, NULL);
+        put_device(&pdev->dev);
+        kfree(dev);
+err_release_region:
+        release_mem_region(mem->start, resource_size(mem));
+
+        return r;
+}
+
+static int __devexit dw_i2c_remove(struct platform_device *pdev)
+{
+        struct dw_i2c_dev *dev = platform_get_drvdata(pdev);
+        struct resource *mem;
+
+        platform_set_drvdata(pdev, NULL);
+        i2c_del_adapter(&dev->adapter);
+        put_device(&pdev->dev);
+
+        clk_disable(dev->clk);
+        clk_put(dev->clk);
+        dev->clk = NULL;
+
+        writeb(0, dev->base + DW_IC_ENABLE);
+        free_irq(dev->irq, dev);
+        kfree(dev);
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(mem->start, resource_size(mem));
+        return 0;
+}
+
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:i2c_designware");
+
+static struct platform_driver dw_i2c_driver = {
+        .remove         = __devexit_p(dw_i2c_remove),
+        .driver         = {
+                .name   = "i2c_designware",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init dw_i2c_init_driver(void)
+{
+        return platform_driver_probe(&dw_i2c_driver, dw_i2c_probe);
+}
+module_init(dw_i2c_init_driver);
+
+static void __exit dw_i2c_exit_driver(void)
+{
+        platform_driver_unregister(&dw_i2c_driver);
+}
+module_exit(dw_i2c_exit_driver);
+
+MODULE_AUTHOR("Baruch Siach <baruch@tkos.co.il>");
+MODULE_DESCRIPTION("Synopsys DesignWare I2C bus adapter");
+MODULE_LICENSE("GPL");
diff --git a/drivers/ide/cmd64x.c b/drivers/ide/cmd64x.c
index 03c86209446f..680e5975217f 100644
--- a/drivers/ide/cmd64x.c
+++ b/drivers/ide/cmd64x.c
@@ -389,8 +389,7 @@ static const struct ide_port_info cmd64x_chipsets[] __devinitdata = {
                 .init_chipset   = init_chipset_cmd64x,
                 .enablebits     = {{0x51,0x04,0x04}, {0x51,0x08,0x08}},
                 .port_ops       = &cmd648_port_ops,
-                .host_flags     = IDE_HFLAG_SERIALIZE |
-                                  IDE_HFLAG_ABUSE_PREFETCH,
+                .host_flags     = IDE_HFLAG_ABUSE_PREFETCH,
                 .pio_mask       = ATA_PIO5,
                 .mwdma_mask     = ATA_MWDMA2,
                 .udma_mask      = ATA_UDMA2,
diff --git a/drivers/ide/cs5520.c b/drivers/ide/cs5520.c
index bd066bb9d611..09f98ed0731f 100644
--- a/drivers/ide/cs5520.c
+++ b/drivers/ide/cs5520.c
@@ -135,6 +135,7 @@ static int __devinit cs5520_init_one(struct pci_dev *dev, const struct pci_devic
 
         ide_pci_setup_ports(dev, d, &hw[0], &hws[0]);
         hw[0].irq = 14;
+        hw[1].irq = 15;
 
         return ide_host_add(d, hws, 2, NULL);
 }
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 4a19686fcfe9..f0ede5953af8 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -876,9 +876,12 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
                 return stat;
 
         /*
-         * Sanity check the given block size
+         * Sanity check the given block size, in so far as making
+         * sure the sectors_per_frame we give to the caller won't
+         * end up being bogus.
          */
         blocklen = be32_to_cpu(capbuf.blocklen);
+        blocklen = (blocklen >> SECTOR_BITS) << SECTOR_BITS;
         switch (blocklen) {
         case 512:
         case 1024:
@@ -886,10 +889,9 @@ static int cdrom_read_capacity(ide_drive_t *drive, unsigned long *capacity,
         case 4096:
                 break;
         default:
-                printk(KERN_ERR PFX "%s: weird block size %u\n",
+                printk_once(KERN_ERR PFX "%s: weird block size %u; "
+                                "setting default block size to 2048\n",
                                 drive->name, blocklen);
-                printk(KERN_ERR PFX "%s: default to 2kb block size\n",
-                                drive->name);
                 blocklen = 2048;
                 break;
         }
diff --git a/drivers/ide/ide-dma.c b/drivers/ide/ide-dma.c
index 219e6fb78dc6..ee58c88dee5a 100644
--- a/drivers/ide/ide-dma.c
+++ b/drivers/ide/ide-dma.c
@@ -361,9 +361,6 @@ static int ide_tune_dma(ide_drive_t *drive)
         if (__ide_dma_bad_drive(drive))
                 return 0;
 
-        if (ide_id_dma_bug(drive))
-                return 0;
-
         if (hwif->host_flags & IDE_HFLAG_TRUST_BIOS_FOR_DMA)
                 return config_drive_for_dma(drive);
 
@@ -394,24 +391,6 @@ static int ide_dma_check(ide_drive_t *drive)
         return -1;
 }
 
-int ide_id_dma_bug(ide_drive_t *drive)
-{
-        u16 *id = drive->id;
-
-        if (id[ATA_ID_FIELD_VALID] & 4) {
-                if ((id[ATA_ID_UDMA_MODES] >> 8) &&
-                    (id[ATA_ID_MWDMA_MODES] >> 8))
-                        goto err_out;
-        } else if ((id[ATA_ID_MWDMA_MODES] >> 8) &&
-                   (id[ATA_ID_SWDMA_MODES] >> 8))
-                goto err_out;
-
-        return 0;
-err_out:
-        printk(KERN_ERR "%s: bad DMA info in identify block\n", drive->name);
-        return 1;
-}
-
 int ide_set_dma(ide_drive_t *drive)
 {
         int rc;
diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
index 1059f809b809..93b7886a2d6e 100644
--- a/drivers/ide/ide-io.c
+++ b/drivers/ide/ide-io.c
@@ -476,10 +476,14 @@ void do_ide_request(struct request_queue *q)
 
         if (!ide_lock_port(hwif)) {
                 ide_hwif_t *prev_port;
-
-                WARN_ON_ONCE(hwif->rq);
 repeat:
                 prev_port = hwif->host->cur_port;
+
+                if (drive->dev_flags & IDE_DFLAG_BLOCKED)
+                        rq = hwif->rq;
+                else
+                        WARN_ON_ONCE(hwif->rq);
+
                 if (drive->dev_flags & IDE_DFLAG_SLEEPING &&
                     time_after(drive->sleep, jiffies)) {
                         ide_unlock_port(hwif);
@@ -506,43 +510,29 @@ repeat:
                 hwif->cur_dev = drive;
                 drive->dev_flags &= ~(IDE_DFLAG_SLEEPING | IDE_DFLAG_PARKED);
 
-                spin_unlock_irq(&hwif->lock);
-                spin_lock_irq(q->queue_lock);
-                /*
-                 * we know that the queue isn't empty, but this can happen
-                 * if the q->prep_rq_fn() decides to kill a request
-                 */
-                if (!rq)
+                if (rq == NULL) {
+                        spin_unlock_irq(&hwif->lock);
+                        spin_lock_irq(q->queue_lock);
+                        /*
+                         * we know that the queue isn't empty, but this can
+                         * happen if ->prep_rq_fn() decides to kill a request
+                         */
                         rq = blk_fetch_request(drive->queue);
+                        spin_unlock_irq(q->queue_lock);
+                        spin_lock_irq(&hwif->lock);
 
-                spin_unlock_irq(q->queue_lock);
-                spin_lock_irq(&hwif->lock);
-
-                if (!rq) {
-                        ide_unlock_port(hwif);
-                        goto out;
+                        if (rq == NULL) {
+                                ide_unlock_port(hwif);
+                                goto out;
+                        }
                 }
 
                 /*
                  * Sanity: don't accept a request that isn't a PM request
-                 * if we are currently power managed. This is very important as
-                 * blk_stop_queue() doesn't prevent the blk_fetch_request()
-                 * above to return us whatever is in the queue. Since we call
-                 * ide_do_request() ourselves, we end up taking requests while
-                 * the queue is blocked...
-                 * 
-                 * We let requests forced at head of queue with ide-preempt
-                 * though. I hope that doesn't happen too much, hopefully not
-                 * unless the subdriver triggers such a thing in its own PM
-                 * state machine.
+                 * if we are currently power managed.
                  */
-                if ((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
-                    blk_pm_request(rq) == 0 &&
-                    (rq->cmd_flags & REQ_PREEMPT) == 0) {
-                        /* there should be no pending command at this point */
-                        ide_unlock_port(hwif);
-                        goto plug_device;
-                }
+                BUG_ON((drive->dev_flags & IDE_DFLAG_BLOCKED) &&
+                       blk_pm_request(rq) == 0);
 
                 hwif->rq = rq;
 
diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
index fa047150a1c6..2892b242bbe1 100644
--- a/drivers/ide/ide-iops.c
+++ b/drivers/ide/ide-iops.c
@@ -210,6 +210,7 @@ EXPORT_SYMBOL_GPL(ide_in_drive_list);
  */
 static const struct drive_list_entry ivb_list[] = {
         { "QUANTUM FIREBALLlct10 05"    , "A03.0900"    },
+        { "QUANTUM FIREBALLlct20 30"    , "APL.0900"    },
         { "TSSTcorp CDDVDW SH-S202J"    , "SB00"        },
         { "TSSTcorp CDDVDW SH-S202J"    , "SB01"        },
         { "TSSTcorp CDDVDW SH-S202N"    , "SB00"        },
@@ -329,9 +330,6 @@ int ide_driveid_update(ide_drive_t *drive)
 
         kfree(id);
 
-        if ((drive->dev_flags & IDE_DFLAG_USING_DMA) && ide_id_dma_bug(drive))
-                ide_dma_off(drive);
-
         return 1;
 out_err:
         if (rc == 2)
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 51af4eea0d36..1bb106f6221a 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -818,6 +818,24 @@ static int ide_port_setup_devices(ide_hwif_t *hwif)
         return j;
 }
 
+static void ide_host_enable_irqs(struct ide_host *host)
+{
+        ide_hwif_t *hwif;
+        int i;
+
+        ide_host_for_each_port(i, hwif, host) {
+                if (hwif == NULL)
+                        continue;
+
+                /* clear any pending IRQs */
+                hwif->tp_ops->read_status(hwif);
+
+                /* unmask IRQs */
+                if (hwif->io_ports.ctl_addr)
+                        hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
+        }
+}
+
 /*
  * This routine sets up the IRQ for an IDE interface.
  */
@@ -831,9 +849,6 @@ static int init_irq (ide_hwif_t *hwif)
         if (irq_handler == NULL)
                 irq_handler = ide_intr;
 
-        if (io_ports->ctl_addr)
-                hwif->tp_ops->write_devctl(hwif, ATA_DEVCTL_OBS);
-
         if (request_irq(hwif->irq, irq_handler, sa, hwif->name, hwif))
                 goto out_up;
 
@@ -1404,6 +1419,8 @@ int ide_host_register(struct ide_host *host, const struct ide_port_info *d,
                         ide_port_tune_devices(hwif);
         }
 
+        ide_host_enable_irqs(host);
+
         ide_host_for_each_port(i, hwif, host) {
                 if (hwif == NULL)
                         continue;
diff --git a/drivers/infiniband/core/addr.c b/drivers/infiniband/core/addr.c
index ce511d8748ce..5be1bd4fc7ed 100644
--- a/drivers/infiniband/core/addr.c
+++ b/drivers/infiniband/core/addr.c
@@ -514,7 +514,7 @@ static struct notifier_block nb = {
         .notifier_call = netevent_callback
 };
 
-static int addr_init(void)
+static int __init addr_init(void)
 {
         addr_wq = create_singlethread_workqueue("ib_addr");
         if (!addr_wq)
@@ -524,7 +524,7 @@ static int addr_init(void)
         return 0;
 }
 
-static void addr_cleanup(void)
+static void __exit addr_cleanup(void)
 {
         unregister_netevent_notifier(&nb);
         destroy_workqueue(addr_wq);
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index 851de83ff455..075317884b53 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -2960,7 +2960,7 @@ static void cma_remove_one(struct ib_device *device)
         kfree(cma_dev);
 }
 
-static int cma_init(void)
+static int __init cma_init(void)
 {
         int ret, low, high, remaining;
 
@@ -2990,7 +2990,7 @@ err:
         return ret;
 }
 
-static void cma_cleanup(void)
+static void __exit cma_cleanup(void)
 {
         ib_unregister_client(&cma_client);
         unregister_netdevice_notifier(&cma_nb);
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 9209c5332dfe..8b92f85d4dd0 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -319,7 +319,7 @@ int ehca_query_gid(struct ib_device *ibdev, u8 port,
                                               ib_device);
         struct hipz_query_port *rblock;
 
-        if (index > 255) {
+        if (index < 0 || index > 255) {
                 ehca_err(&shca->ib_device, "Invalid index: %x.", index);
                 return -EINVAL;
         }
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index ce4e6eff4792..fab18a2c74a8 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -52,7 +52,7 @@
 #include "ehca_tools.h"
 #include "hcp_if.h"
 
-#define HCAD_VERSION "0027"
+#define HCAD_VERSION "0028"
 
 MODULE_LICENSE("Dual BSD/GPL");
 MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
@@ -506,6 +506,7 @@ static int ehca_init_device(struct ehca_shca *shca)
         shca->ib_device.detach_mcast        = ehca_detach_mcast;
         shca->ib_device.process_mad         = ehca_process_mad;
         shca->ib_device.mmap                = ehca_mmap;
+        shca->ib_device.dma_ops             = &ehca_dma_mapping_ops;
 
         if (EHCA_BMASK_GET(HCA_CAP_SRQ, shca->hca_cap)) {
                 shca->ib_device.uverbs_cmd_mask |=
@@ -1028,17 +1029,23 @@ static int __init ehca_module_init(void)
                 goto module_init1;
         }
 
+        ret = ehca_create_busmap();
+        if (ret) {
+                ehca_gen_err("Cannot create busmap.");
+                goto module_init2;
+        }
+
         ret = ibmebus_register_driver(&ehca_driver);
         if (ret) {
                 ehca_gen_err("Cannot register eHCA device driver");
                 ret = -EINVAL;
-                goto module_init2;
+                goto module_init3;
         }
 
         ret = register_memory_notifier(&ehca_mem_nb);
         if (ret) {
                 ehca_gen_err("Failed registering memory add/remove notifier");
-                goto module_init3;
+                goto module_init4;
         }
 
         if (ehca_poll_all_eqs != 1) {
@@ -1053,9 +1060,12 @@ static int __init ehca_module_init(void)
 
         return 0;
 
-module_init3:
+module_init4:
         ibmebus_unregister_driver(&ehca_driver);
 
+module_init3:
+        ehca_destroy_busmap();
+
 module_init2:
         ehca_destroy_slab_caches();
 
@@ -1073,6 +1083,8 @@ static void __exit ehca_module_exit(void)
 
         unregister_memory_notifier(&ehca_mem_nb);
 
+        ehca_destroy_busmap();
+
         ehca_destroy_slab_caches();
 
         ehca_destroy_comp_pool();
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index 72f83f7df614..7663a2a9f130 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -53,6 +53,38 @@
 /* max number of rpages (per hcall register_rpages) */
 #define MAX_RPAGES 512
 
+/* DMEM toleration management */
+#define EHCA_SECTSHIFT        SECTION_SIZE_BITS
+#define EHCA_SECTSIZE          (1UL << EHCA_SECTSHIFT)
+#define EHCA_HUGEPAGESHIFT     34
+#define EHCA_HUGEPAGE_SIZE     (1UL << EHCA_HUGEPAGESHIFT)
+#define EHCA_HUGEPAGE_PFN_MASK ((EHCA_HUGEPAGE_SIZE - 1) >> PAGE_SHIFT)
+#define EHCA_INVAL_ADDR        0xFFFFFFFFFFFFFFFFULL
+#define EHCA_DIR_INDEX_SHIFT 13                   /* 8k Entries in 64k block */
+#define EHCA_TOP_INDEX_SHIFT (EHCA_DIR_INDEX_SHIFT * 2)
+#define EHCA_MAP_ENTRIES (1 << EHCA_DIR_INDEX_SHIFT)
+#define EHCA_TOP_MAP_SIZE (0x10000)               /* currently fixed map size */
+#define EHCA_DIR_MAP_SIZE (0x10000)
+#define EHCA_ENT_MAP_SIZE (0x10000)
+#define EHCA_INDEX_MASK (EHCA_MAP_ENTRIES - 1)
+
+static unsigned long ehca_mr_len;
+
+/*
+ * Memory map data structures
+ */
+struct ehca_dir_bmap {
+        u64 ent[EHCA_MAP_ENTRIES];
+};
+struct ehca_top_bmap {
+        struct ehca_dir_bmap *dir[EHCA_MAP_ENTRIES];
+};
+struct ehca_bmap {
+        struct ehca_top_bmap *top[EHCA_MAP_ENTRIES];
+};
+
+static struct ehca_bmap *ehca_bmap;
+
 static struct kmem_cache *mr_cache;
 static struct kmem_cache *mw_cache;
 
@@ -68,6 +100,8 @@ enum ehca_mr_pgsize {
 #define EHCA_MR_PGSHIFT1M  20
 #define EHCA_MR_PGSHIFT16M 24
 
+static u64 ehca_map_vaddr(void *caddr);
+
 static u32 ehca_encode_hwpage_size(u32 pgsize)
 {
         int log = ilog2(pgsize);
@@ -135,7 +169,8 @@ struct ib_mr *ehca_get_dma_mr(struct ib_pd *pd, int mr_access_flags)
                         goto get_dma_mr_exit0;
                 }
 
-                ret = ehca_reg_maxmr(shca, e_maxmr, (u64 *)KERNELBASE,
+                ret = ehca_reg_maxmr(shca, e_maxmr,
+                                     (void *)ehca_map_vaddr((void *)KERNELBASE),
                                      mr_access_flags, e_pd,
                                      &e_maxmr->ib.ib_mr.lkey,
                                      &e_maxmr->ib.ib_mr.rkey);
@@ -251,7 +286,7 @@ struct ib_mr *ehca_reg_phys_mr(struct ib_pd *pd,
 
                 ret = ehca_reg_mr(shca, e_mr, iova_start, size, mr_access_flags,
                                   e_pd, &pginfo, &e_mr->ib.ib_mr.lkey,
-                                  &e_mr->ib.ib_mr.rkey);
+                                  &e_mr->ib.ib_mr.rkey, EHCA_REG_MR);
                 if (ret) {
                         ib_mr = ERR_PTR(ret);
                         goto reg_phys_mr_exit1;
@@ -370,7 +405,7 @@ reg_user_mr_fallback:
 
         ret = ehca_reg_mr(shca, e_mr, (u64 *)virt, length, mr_access_flags,
                           e_pd, &pginfo, &e_mr->ib.ib_mr.lkey,
-                          &e_mr->ib.ib_mr.rkey);
+                          &e_mr->ib.ib_mr.rkey, EHCA_REG_MR);
         if (ret == -EINVAL && pginfo.hwpage_size > PAGE_SIZE) {
                 ehca_warn(pd->device, "failed to register mr "
                           "with hwpage_size=%llx", hwpage_size);
@@ -794,7 +829,7 @@ struct ib_fmr *ehca_alloc_fmr(struct ib_pd *pd,
         ret = ehca_reg_mr(shca, e_fmr, NULL,
                           fmr_attr->max_pages * (1 << fmr_attr->page_shift),
                           mr_access_flags, e_pd, &pginfo,
-                          &tmp_lkey, &tmp_rkey);
+                          &tmp_lkey, &tmp_rkey, EHCA_REG_MR);
         if (ret) {
                 ib_fmr = ERR_PTR(ret);
                 goto alloc_fmr_exit1;
@@ -983,6 +1018,10 @@ free_fmr_exit0:
 
 /*----------------------------------------------------------------------*/
 
+static int ehca_reg_bmap_mr_rpages(struct ehca_shca *shca,
+                                   struct ehca_mr *e_mr,
+                                   struct ehca_mr_pginfo *pginfo);
+
 int ehca_reg_mr(struct ehca_shca *shca,
                 struct ehca_mr *e_mr,
                 u64 *iova_start,
@@ -991,7 +1030,8 @@ int ehca_reg_mr(struct ehca_shca *shca,
                 struct ehca_pd *e_pd,
                 struct ehca_mr_pginfo *pginfo,
                 u32 *lkey, /*OUT*/
-                u32 *rkey) /*OUT*/
+                u32 *rkey, /*OUT*/
+                enum ehca_reg_type reg_type)
 {
         int ret;
         u64 h_ret;
@@ -1015,7 +1055,13 @@ int ehca_reg_mr(struct ehca_shca *shca,
 
         e_mr->ipz_mr_handle = hipzout.handle;
 
-        ret = ehca_reg_mr_rpages(shca, e_mr, pginfo);
+        if (reg_type == EHCA_REG_BUSMAP_MR)
+                ret = ehca_reg_bmap_mr_rpages(shca, e_mr, pginfo);
+        else if (reg_type == EHCA_REG_MR)
+                ret = ehca_reg_mr_rpages(shca, e_mr, pginfo);
+        else
+                ret = -EINVAL;
+
         if (ret)
                 goto ehca_reg_mr_exit1;
 
@@ -1316,7 +1362,7 @@ int ehca_rereg_mr(struct ehca_shca *shca,
                 e_mr->fmr_map_cnt = save_mr.fmr_map_cnt;
 
                 ret = ehca_reg_mr(shca, e_mr, iova_start, size, acl,
-                                  e_pd, pginfo, lkey, rkey);
+                                  e_pd, pginfo, lkey, rkey, EHCA_REG_MR);
                 if (ret) {
                         u32 offset = (u64)(&e_mr->flags) - (u64)e_mr;
                         memcpy(&e_mr->flags, &(save_mr.flags),
@@ -1409,7 +1455,7 @@ int ehca_unmap_one_fmr(struct ehca_shca *shca,
         ret = ehca_reg_mr(shca, e_fmr, NULL,
                           (e_fmr->fmr_max_pages * e_fmr->fmr_page_size),
                           e_fmr->acl, e_pd, &pginfo, &tmp_lkey,
-                          &tmp_rkey);
+                          &tmp_rkey, EHCA_REG_MR);
         if (ret) {
                 u32 offset = (u64)(&e_fmr->flags) - (u64)e_fmr;
                 memcpy(&e_fmr->flags, &(save_mr.flags),
@@ -1478,6 +1524,90 @@ ehca_reg_smr_exit0:
 } /* end ehca_reg_smr() */
 
 /*----------------------------------------------------------------------*/
+static inline void *ehca_calc_sectbase(int top, int dir, int idx)
+{
+        unsigned long ret = idx;
+        ret |= dir << EHCA_DIR_INDEX_SHIFT;
+        ret |= top << EHCA_TOP_INDEX_SHIFT;
+        return abs_to_virt(ret << SECTION_SIZE_BITS);
+}
+
+#define ehca_bmap_valid(entry) \
+        ((u64)entry != (u64)EHCA_INVAL_ADDR)
+
+static u64 ehca_reg_mr_section(int top, int dir, int idx, u64 *kpage,
+                               struct ehca_shca *shca, struct ehca_mr *mr,
+                               struct ehca_mr_pginfo *pginfo)
+{
+        u64 h_ret = 0;
+        unsigned long page = 0;
+        u64 rpage = virt_to_abs(kpage);
+        int page_count;
+
+        void *sectbase = ehca_calc_sectbase(top, dir, idx);
+        if ((unsigned long)sectbase & (pginfo->hwpage_size - 1)) {
+                ehca_err(&shca->ib_device, "reg_mr_section will probably fail:"
+                                           "hwpage_size does not fit to "
+                                           "section start address");
+        }
+        page_count = EHCA_SECTSIZE / pginfo->hwpage_size;
+
+        while (page < page_count) {
+                u64 rnum;
+                for (rnum = 0; (rnum < MAX_RPAGES) && (page < page_count);
+                     rnum++) {
+                        void *pg = sectbase + ((page++) * pginfo->hwpage_size);
+                        kpage[rnum] = virt_to_abs(pg);
+                }
+
+                h_ret = hipz_h_register_rpage_mr(shca->ipz_hca_handle, mr,
+                        ehca_encode_hwpage_size(pginfo->hwpage_size),
+                        0, rpage, rnum);
+
+                if ((h_ret != H_SUCCESS) && (h_ret != H_PAGE_REGISTERED)) {
+                        ehca_err(&shca->ib_device, "register_rpage_mr failed");
+                        return h_ret;
+                }
+        }
+        return h_ret;
+}
+
+static u64 ehca_reg_mr_sections(int top, int dir, u64 *kpage,
+                                struct ehca_shca *shca, struct ehca_mr *mr,
+                                struct ehca_mr_pginfo *pginfo)
+{
+        u64 hret = H_SUCCESS;
+        int idx;
+
+        for (idx = 0; idx < EHCA_MAP_ENTRIES; idx++) {
+                if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir]->ent[idx]))
+                        continue;
+
+                hret = ehca_reg_mr_section(top, dir, idx, kpage, shca, mr,
+                                           pginfo);
+                if ((hret != H_SUCCESS) && (hret != H_PAGE_REGISTERED))
+                                return hret;
+        }
+        return hret;
+}
+
+static u64 ehca_reg_mr_dir_sections(int top, u64 *kpage, struct ehca_shca *shca,
+                                    struct ehca_mr *mr,
+                                    struct ehca_mr_pginfo *pginfo)
+{
+        u64 hret = H_SUCCESS;
+        int dir;
+
+        for (dir = 0; dir < EHCA_MAP_ENTRIES; dir++) {
+                if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir]))
+                        continue;
+
+                hret = ehca_reg_mr_sections(top, dir, kpage, shca, mr, pginfo);
+                if ((hret != H_SUCCESS) && (hret != H_PAGE_REGISTERED))
+                                return hret;
+        }
+        return hret;
+}
 
 /* register internal max-MR to internal SHCA */
 int ehca_reg_internal_maxmr(
@@ -1495,6 +1625,11 @@ int ehca_reg_internal_maxmr(
         u32 num_hwpages;
         u64 hw_pgsize;
 
+        if (!ehca_bmap) {
+                ret = -EFAULT;
+                goto ehca_reg_internal_maxmr_exit0;
+        }
+
         e_mr = ehca_mr_new();
         if (!e_mr) {
                 ehca_err(&shca->ib_device, "out of memory");
@@ -1504,8 +1639,8 @@ int ehca_reg_internal_maxmr(
         e_mr->flags |= EHCA_MR_FLAG_MAXMR;
 
         /* register internal max-MR on HCA */
-        size_maxmr = (u64)high_memory - PAGE_OFFSET;
-        iova_start = (u64 *)KERNELBASE;
+        size_maxmr = ehca_mr_len;
+        iova_start = (u64 *)ehca_map_vaddr((void *)KERNELBASE);
         ib_pbuf.addr = 0;
         ib_pbuf.size = size_maxmr;
         num_kpages = NUM_CHUNKS(((u64)iova_start % PAGE_SIZE) + size_maxmr,
@@ -1524,7 +1659,7 @@ int ehca_reg_internal_maxmr(
 
         ret = ehca_reg_mr(shca, e_mr, iova_start, size_maxmr, 0, e_pd,
                           &pginfo, &e_mr->ib.ib_mr.lkey,
-                          &e_mr->ib.ib_mr.rkey);
+                          &e_mr->ib.ib_mr.rkey, EHCA_REG_BUSMAP_MR);
         if (ret) {
                 ehca_err(&shca->ib_device, "reg of internal max MR failed, "
                          "e_mr=%p iova_start=%p size_maxmr=%llx num_kpages=%x "
@@ -2077,8 +2212,8 @@ int ehca_mr_is_maxmr(u64 size,
                      u64 *iova_start)
 {
         /* a MR is treated as max-MR only if it fits following: */
-        if ((size == ((u64)high_memory - PAGE_OFFSET)) &&
-            (iova_start == (void *)KERNELBASE)) {
+        if ((size == ehca_mr_len) &&
+            (iova_start == (void *)ehca_map_vaddr((void *)KERNELBASE))) {
                 ehca_gen_dbg("this is a max-MR");
                 return 1;
         } else
@@ -2184,3 +2319,350 @@ void ehca_cleanup_mrmw_cache(void)
         if (mw_cache)
                 kmem_cache_destroy(mw_cache);
 }
+
+static inline int ehca_init_top_bmap(struct ehca_top_bmap *ehca_top_bmap,
+                                     int dir)
+{
+        if (!ehca_bmap_valid(ehca_top_bmap->dir[dir])) {
+                ehca_top_bmap->dir[dir] =
+                        kmalloc(sizeof(struct ehca_dir_bmap), GFP_KERNEL);
+                if (!ehca_top_bmap->dir[dir])
+                        return -ENOMEM;
+                /* Set map block to 0xFF according to EHCA_INVAL_ADDR */
+                memset(ehca_top_bmap->dir[dir], 0xFF, EHCA_ENT_MAP_SIZE);
+        }
+        return 0;
+}
+
+static inline int ehca_init_bmap(struct ehca_bmap *ehca_bmap, int top, int dir)
+{
+        if (!ehca_bmap_valid(ehca_bmap->top[top])) {
+                ehca_bmap->top[top] =
+                        kmalloc(sizeof(struct ehca_top_bmap), GFP_KERNEL);
+                if (!ehca_bmap->top[top])
+                        return -ENOMEM;
+                /* Set map block to 0xFF according to EHCA_INVAL_ADDR */
+                memset(ehca_bmap->top[top], 0xFF, EHCA_DIR_MAP_SIZE);
+        }
+        return ehca_init_top_bmap(ehca_bmap->top[top], dir);
+}
+
+static inline int ehca_calc_index(unsigned long i, unsigned long s)
+{
+        return (i >> s) & EHCA_INDEX_MASK;
+}
+
+void ehca_destroy_busmap(void)
+{
+        int top, dir;
+
+        if (!ehca_bmap)
+                return;
+
+        for (top = 0; top < EHCA_MAP_ENTRIES; top++) {
+                if (!ehca_bmap_valid(ehca_bmap->top[top]))
+                        continue;
+                for (dir = 0; dir < EHCA_MAP_ENTRIES; dir++) {
+                        if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir]))
+                                continue;
+
+                        kfree(ehca_bmap->top[top]->dir[dir]);
+                }
+
+                kfree(ehca_bmap->top[top]);
+        }
+
+        kfree(ehca_bmap);
+        ehca_bmap = NULL;
+}
+
+static int ehca_update_busmap(unsigned long pfn, unsigned long nr_pages)
+{
+        unsigned long i, start_section, end_section;
+        int top, dir, idx;
+
+        if (!nr_pages)
+                return 0;
+
+        if (!ehca_bmap) {
+                ehca_bmap = kmalloc(sizeof(struct ehca_bmap), GFP_KERNEL);
+                if (!ehca_bmap)
+                        return -ENOMEM;
+                /* Set map block to 0xFF according to EHCA_INVAL_ADDR */
+                memset(ehca_bmap, 0xFF, EHCA_TOP_MAP_SIZE);
+        }
+
+        start_section = phys_to_abs(pfn * PAGE_SIZE) / EHCA_SECTSIZE;
+        end_section = phys_to_abs((pfn + nr_pages) * PAGE_SIZE) / EHCA_SECTSIZE;
+        for (i = start_section; i < end_section; i++) {
+                int ret;
+                top = ehca_calc_index(i, EHCA_TOP_INDEX_SHIFT);
+                dir = ehca_calc_index(i, EHCA_DIR_INDEX_SHIFT);
+                idx = i & EHCA_INDEX_MASK;
+
+                ret = ehca_init_bmap(ehca_bmap, top, dir);
+                if (ret) {
+                        ehca_destroy_busmap();
+                        return ret;
+                }
+                ehca_bmap->top[top]->dir[dir]->ent[idx] = ehca_mr_len;
+                ehca_mr_len += EHCA_SECTSIZE;
+        }
+        return 0;
+}
+
+static int ehca_is_hugepage(unsigned long pfn)
+{
+        int page_order;
+
+        if (pfn & EHCA_HUGEPAGE_PFN_MASK)
+                return 0;
+
+        page_order = compound_order(pfn_to_page(pfn));
+        if (page_order + PAGE_SHIFT != EHCA_HUGEPAGESHIFT)
+                return 0;
+
+        return 1;
+}
+
+static int ehca_create_busmap_callback(unsigned long initial_pfn,
+                                       unsigned long total_nr_pages, void *arg)
+{
+        int ret;
+        unsigned long pfn, start_pfn, end_pfn, nr_pages;
+
+        if ((total_nr_pages * PAGE_SIZE) < EHCA_HUGEPAGE_SIZE)
+                return ehca_update_busmap(initial_pfn, total_nr_pages);
+
+        /* Given chunk is >= 16GB -> check for hugepages */
+        start_pfn = initial_pfn;
+        end_pfn = initial_pfn + total_nr_pages;
+        pfn = start_pfn;
+
+        while (pfn < end_pfn) {
+                if (ehca_is_hugepage(pfn)) {
+                        /* Add mem found in front of the hugepage */
+                        nr_pages = pfn - start_pfn;
+                        ret = ehca_update_busmap(start_pfn, nr_pages);
+                        if (ret)
+                                return ret;
+                        /* Skip the hugepage */
+                        pfn += (EHCA_HUGEPAGE_SIZE / PAGE_SIZE);
+                        start_pfn = pfn;
+                } else
+                        pfn += (EHCA_SECTSIZE / PAGE_SIZE);
+        }
+
+        /* Add mem found behind the hugepage(s)  */
+        nr_pages = pfn - start_pfn;
+        return ehca_update_busmap(start_pfn, nr_pages);
+}
+
+int ehca_create_busmap(void)
+{
+        int ret;
+
+        ehca_mr_len = 0;
+        ret = walk_memory_resource(0, 1ULL << MAX_PHYSMEM_BITS, NULL,
+                                   ehca_create_busmap_callback);
+        return ret;
+}
+
+static int ehca_reg_bmap_mr_rpages(struct ehca_shca *shca,
+                                   struct ehca_mr *e_mr,
+                                   struct ehca_mr_pginfo *pginfo)
+{
+        int top;
+        u64 hret, *kpage;
+
+        kpage = ehca_alloc_fw_ctrlblock(GFP_KERNEL);
+        if (!kpage) {
+                ehca_err(&shca->ib_device, "kpage alloc failed");
+                return -ENOMEM;
+        }
+        for (top = 0; top < EHCA_MAP_ENTRIES; top++) {
+                if (!ehca_bmap_valid(ehca_bmap->top[top]))
+                        continue;
+                hret = ehca_reg_mr_dir_sections(top, kpage, shca, e_mr, pginfo);
+                if ((hret != H_PAGE_REGISTERED) && (hret != H_SUCCESS))
+                        break;
+        }
+
+        ehca_free_fw_ctrlblock(kpage);
+
+        if (hret == H_SUCCESS)
+                return 0; /* Everything is fine */
+        else {
+                ehca_err(&shca->ib_device, "ehca_reg_bmap_mr_rpages failed, "
+                                 "h_ret=%lli e_mr=%p top=%x lkey=%x "
+                                 "hca_hndl=%llx mr_hndl=%llx", hret, e_mr, top,
+                                 e_mr->ib.ib_mr.lkey,
+                                 shca->ipz_hca_handle.handle,
+                                 e_mr->ipz_mr_handle.handle);
+                return ehca2ib_return_code(hret);
+        }
+}
+
+static u64 ehca_map_vaddr(void *caddr)
+{
+        int top, dir, idx;
+        unsigned long abs_addr, offset;
+        u64 entry;
+
+        if (!ehca_bmap)
+                return EHCA_INVAL_ADDR;
+
+        abs_addr = virt_to_abs(caddr);
+        top = ehca_calc_index(abs_addr, EHCA_TOP_INDEX_SHIFT + EHCA_SECTSHIFT);
+        if (!ehca_bmap_valid(ehca_bmap->top[top]))
+                return EHCA_INVAL_ADDR;
+
+        dir = ehca_calc_index(abs_addr, EHCA_DIR_INDEX_SHIFT + EHCA_SECTSHIFT);
+        if (!ehca_bmap_valid(ehca_bmap->top[top]->dir[dir]))
+                return EHCA_INVAL_ADDR;
+
+        idx = ehca_calc_index(abs_addr, EHCA_SECTSHIFT);
+
+        entry = ehca_bmap->top[top]->dir[dir]->ent[idx];
+        if (ehca_bmap_valid(entry)) {
+                offset = (unsigned long)caddr & (EHCA_SECTSIZE - 1);
+                return entry | offset;
+        } else
+                return EHCA_INVAL_ADDR;
+}
+
+static int ehca_dma_mapping_error(struct ib_device *dev, u64 dma_addr)
+{
+        return dma_addr == EHCA_INVAL_ADDR;
+}
+
+static u64 ehca_dma_map_single(struct ib_device *dev, void *cpu_addr,
+                               size_t size, enum dma_data_direction direction)
+{
+        if (cpu_addr)
+                return ehca_map_vaddr(cpu_addr);
+        else
+                return EHCA_INVAL_ADDR;
+}
+
+static void ehca_dma_unmap_single(struct ib_device *dev, u64 addr, size_t size,
+                                  enum dma_data_direction direction)
+{
+        /* This is only a stub; nothing to be done here */
+}
+
+static u64 ehca_dma_map_page(struct ib_device *dev, struct page *page,
+                             unsigned long offset, size_t size,
+                             enum dma_data_direction direction)
+{
+        u64 addr;
+
+        if (offset + size > PAGE_SIZE)
+                return EHCA_INVAL_ADDR;
+
+        addr = ehca_map_vaddr(page_address(page));
+        if (!ehca_dma_mapping_error(dev, addr))
+                addr += offset;
+
+        return addr;
+}
+
+static void ehca_dma_unmap_page(struct ib_device *dev, u64 addr, size_t size,
+                                enum dma_data_direction direction)
+{
+        /* This is only a stub; nothing to be done here */
+}
+
+static int ehca_dma_map_sg(struct ib_device *dev, struct scatterlist *sgl,
+                           int nents, enum dma_data_direction direction)
+{
+        struct scatterlist *sg;
+        int i;
+
+        for_each_sg(sgl, sg, nents, i) {
+                u64 addr;
+                addr = ehca_map_vaddr(sg_virt(sg));
+                if (ehca_dma_mapping_error(dev, addr))
+                        return 0;
+
+                sg->dma_address = addr;
+                sg->dma_length = sg->length;
+        }
+        return nents;
+}
+
+static void ehca_dma_unmap_sg(struct ib_device *dev, struct scatterlist *sg,
+                              int nents, enum dma_data_direction direction)
+{
+        /* This is only a stub; nothing to be done here */
+}
+
+static u64 ehca_dma_address(struct ib_device *dev, struct scatterlist *sg)
+{
+        return sg->dma_address;
+}
+
+static unsigned int ehca_dma_len(struct ib_device *dev, struct scatterlist *sg)
+{
+        return sg->length;
+}
+
+static void ehca_dma_sync_single_for_cpu(struct ib_device *dev, u64 addr,
+                                         size_t size,
+                                         enum dma_data_direction dir)
+{
+        dma_sync_single_for_cpu(dev->dma_device, addr, size, dir);
+}
+
+static void ehca_dma_sync_single_for_device(struct ib_device *dev, u64 addr,
+                                            size_t size,
+                                            enum dma_data_direction dir)
+{
+        dma_sync_single_for_device(dev->dma_device, addr, size, dir);
+}
+
+static void *ehca_dma_alloc_coherent(struct ib_device *dev, size_t size,
+                                     u64 *dma_handle, gfp_t flag)
+{
+        struct page *p;
+        void *addr = NULL;
+        u64 dma_addr;
+
+        p = alloc_pages(flag, get_order(size));
+        if (p) {
+                addr = page_address(p);
+                dma_addr = ehca_map_vaddr(addr);
+                if (ehca_dma_mapping_error(dev, dma_addr)) {
+                        free_pages((unsigned long)addr, get_order(size));
+                        return NULL;
+                }
+                if (dma_handle)
+                        *dma_handle = dma_addr;
+                return addr;
+        }
+        return NULL;
+}
+
+static void ehca_dma_free_coherent(struct ib_device *dev, size_t size,
+                                   void *cpu_addr, u64 dma_handle)
+{
+        if (cpu_addr && size)
+                free_pages((unsigned long)cpu_addr, get_order(size));
+}
+
+
+struct ib_dma_mapping_ops ehca_dma_mapping_ops = {
+        .mapping_error          = ehca_dma_mapping_error,
+        .map_single             = ehca_dma_map_single,
+        .unmap_single           = ehca_dma_unmap_single,
+        .map_page               = ehca_dma_map_page,
+        .unmap_page             = ehca_dma_unmap_page,
+        .map_sg                 = ehca_dma_map_sg,
+        .unmap_sg               = ehca_dma_unmap_sg,
+        .dma_address            = ehca_dma_address,
+        .dma_len                = ehca_dma_len,
+        .sync_single_for_cpu    = ehca_dma_sync_single_for_cpu,
+        .sync_single_for_device = ehca_dma_sync_single_for_device,
+        .alloc_coherent         = ehca_dma_alloc_coherent,
+        .free_coherent          = ehca_dma_free_coherent,
+};
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.h b/drivers/infiniband/hw/ehca/ehca_mrmw.h
index bc8f4e31c123..50d8b51306dd 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.h
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.h
@@ -42,6 +42,11 @@
 #ifndef _EHCA_MRMW_H_
 #define _EHCA_MRMW_H_
 
+enum ehca_reg_type {
+        EHCA_REG_MR,
+        EHCA_REG_BUSMAP_MR
+};
+
 int ehca_reg_mr(struct ehca_shca *shca,
                 struct ehca_mr *e_mr,
                 u64 *iova_start,
@@ -50,7 +55,8 @@ int ehca_reg_mr(struct ehca_shca *shca,
                 struct ehca_pd *e_pd,
                 struct ehca_mr_pginfo *pginfo,
                 u32 *lkey,
-                u32 *rkey);
+                u32 *rkey,
+                enum ehca_reg_type reg_type);
 
 int ehca_reg_mr_rpages(struct ehca_shca *shca,
                        struct ehca_mr *e_mr,
@@ -118,4 +124,9 @@ void ehca_mrmw_reverse_map_acl(const u32 *hipz_acl,
 
 void ehca_mr_deletenew(struct ehca_mr *mr);
 
+int ehca_create_busmap(void);
+
+void ehca_destroy_busmap(void);
+
+extern struct ib_dma_mapping_ops ehca_dma_mapping_ops;
 #endif  /*_EHCA_MRMW_H_*/
diff --git a/drivers/infiniband/hw/mthca/mthca_mr.c b/drivers/infiniband/hw/mthca/mthca_mr.c
index d606edf10858..065b20899876 100644
--- a/drivers/infiniband/hw/mthca/mthca_mr.c
+++ b/drivers/infiniband/hw/mthca/mthca_mr.c
@@ -352,10 +352,14 @@ static void mthca_arbel_write_mtt_seg(struct mthca_dev *dev,
 
         BUG_ON(!mtts);
 
+        dma_sync_single_for_cpu(&dev->pdev->dev, dma_handle,
+                                list_len * sizeof (u64), DMA_TO_DEVICE);
+
         for (i = 0; i < list_len; ++i)
                 mtts[i] = cpu_to_be64(buffer_list[i] | MTHCA_MTT_FLAG_PRESENT);
 
-        dma_sync_single(&dev->pdev->dev, dma_handle, list_len * sizeof (u64), DMA_TO_DEVICE);
+        dma_sync_single_for_device(&dev->pdev->dev, dma_handle,
+                                   list_len * sizeof (u64), DMA_TO_DEVICE);
 }
 
 int mthca_write_mtt(struct mthca_dev *dev, struct mthca_mtt *mtt,
@@ -803,12 +807,15 @@ int mthca_arbel_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
 
         wmb();
 
+        dma_sync_single_for_cpu(&dev->pdev->dev, fmr->mem.arbel.dma_handle,
+                                list_len * sizeof(u64), DMA_TO_DEVICE);
+
         for (i = 0; i < list_len; ++i)
                 fmr->mem.arbel.mtts[i] = cpu_to_be64(page_list[i] |
                                                      MTHCA_MTT_FLAG_PRESENT);
 
-        dma_sync_single(&dev->pdev->dev, fmr->mem.arbel.dma_handle,
-                        list_len * sizeof(u64), DMA_TO_DEVICE);
+        dma_sync_single_for_device(&dev->pdev->dev, fmr->mem.arbel.dma_handle,
+                                   list_len * sizeof(u64), DMA_TO_DEVICE);
 
         fmr->mem.arbel.mpt->key    = cpu_to_be32(key);
         fmr->mem.arbel.mpt->lkey   = cpu_to_be32(key);
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index 11c7d6642014..114b802771ad 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -472,6 +472,7 @@ int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
 
 static void nes_retrans_expired(struct nes_cm_node *cm_node)
 {
+        struct iw_cm_id *cm_id = cm_node->cm_id;
         switch (cm_node->state) {
         case NES_CM_STATE_SYN_RCVD:
         case NES_CM_STATE_CLOSING:
@@ -479,7 +480,9 @@ static void nes_retrans_expired(struct nes_cm_node *cm_node)
                 break;
         case NES_CM_STATE_LAST_ACK:
         case NES_CM_STATE_FIN_WAIT1:
-        case NES_CM_STATE_MPAREJ_RCVD:
+                if (cm_node->cm_id)
+                        cm_id->rem_ref(cm_id);
+                cm_node->state = NES_CM_STATE_CLOSED;
                 send_reset(cm_node, NULL);
                 break;
         default:
@@ -1406,6 +1409,7 @@ static void handle_rst_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
         case NES_CM_STATE_CLOSED:
                 drop_packet(skb);
                 break;
+        case NES_CM_STATE_FIN_WAIT1:
         case NES_CM_STATE_LAST_ACK:
                 cm_node->cm_id->rem_ref(cm_node->cm_id);
         case NES_CM_STATE_TIME_WAIT:
@@ -1413,8 +1417,6 @@ static void handle_rst_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
                 rem_ref_cm_node(cm_node->cm_core, cm_node);
                 drop_packet(skb);
                 break;
-        case NES_CM_STATE_FIN_WAIT1:
-                nes_debug(NES_DBG_CM, "Bad state %s[%u]\n", __func__, __LINE__);
         default:
                 drop_packet(skb);
                 break;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index 64d5cfd8f380..21e0fd336cf7 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -654,7 +654,7 @@ static int nes_query_device(struct ib_device *ibdev, struct ib_device_attr *prop
                 default:
                         props->max_qp_rd_atom = 0;
         }
-        props->max_qp_init_rd_atom = props->max_qp_wr;
+        props->max_qp_init_rd_atom = props->max_qp_rd_atom;
         props->atomic_cap = IB_ATOMIC_NONE;
         props->max_map_per_fmr = 1;
 
diff --git a/drivers/macintosh/macio_asic.c b/drivers/macintosh/macio_asic.c
index 6e149f4a1fff..a0f68386c12f 100644
--- a/drivers/macintosh/macio_asic.c
+++ b/drivers/macintosh/macio_asic.c
@@ -378,6 +378,17 @@ static struct macio_dev * macio_add_one_device(struct macio_chip *chip,
         dev->ofdev.dev.bus = &macio_bus_type;
         dev->ofdev.dev.release = macio_release_dev;
 
+#ifdef CONFIG_PCI
+        /* Set the DMA ops to the ones from the PCI device, this could be
+         * fishy if we didn't know that on PowerMac it's always direct ops
+         * or iommu ops that will work fine
+         */
+        dev->ofdev.dev.archdata.dma_ops =
+                chip->lbus.pdev->dev.archdata.dma_ops;
+        dev->ofdev.dev.archdata.dma_data =
+                chip->lbus.pdev->dev.archdata.dma_data;
+#endif /* CONFIG_PCI */
+
 #ifdef DEBUG
         printk("preparing mdev @%p, ofdev @%p, dev @%p, kobj @%p\n",
                dev, &dev->ofdev, &dev->ofdev.dev, &dev->ofdev.dev.kobj);
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 36e0675be9f7..020f9573fd82 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -231,6 +231,17 @@ config DM_MIRROR
          Allow volume managers to mirror logical volumes, also
          needed for live data migration tools such as 'pvmove'.
 
+config DM_LOG_USERSPACE
+        tristate "Mirror userspace logging (EXPERIMENTAL)"
+        depends on DM_MIRROR && EXPERIMENTAL && NET
+        select CONNECTOR
+        ---help---
+          The userspace logging module provides a mechanism for
+          relaying the dm-dirty-log API to userspace.  Log designs
+          which are more suited to userspace implementation (e.g.
+          shared storage logs) or experimental logs can be implemented
+          by leveraging this framework.
+
 config DM_ZERO
         tristate "Zero target"
         depends on BLK_DEV_DM
@@ -249,6 +260,25 @@ config DM_MULTIPATH
         ---help---
           Allow volume managers to support multipath hardware.
 
+config DM_MULTIPATH_QL
+        tristate "I/O Path Selector based on the number of in-flight I/Os"
+        depends on DM_MULTIPATH
+        ---help---
+          This path selector is a dynamic load balancer which selects
+          the path with the least number of in-flight I/Os.
+
+          If unsure, say N.
+
+config DM_MULTIPATH_ST
+        tristate "I/O Path Selector based on the service time"
+        depends on DM_MULTIPATH
+        ---help---
+          This path selector is a dynamic load balancer which selects
+          the path expected to complete the incoming I/O in the shortest
+          time.
+
+          If unsure, say N.
+
 config DM_DELAY
         tristate "I/O delaying target (EXPERIMENTAL)"
         depends on BLK_DEV_DM && EXPERIMENTAL
diff --git a/drivers/md/Makefile b/drivers/md/Makefile
index 45cc5951d928..1dc4185bd781 100644
--- a/drivers/md/Makefile
+++ b/drivers/md/Makefile
@@ -8,6 +8,8 @@ dm-multipath-y	+= dm-path-selector.o dm-mpath.o
 dm-snapshot-y   += dm-snap.o dm-exception-store.o dm-snap-transient.o \
                     dm-snap-persistent.o
 dm-mirror-y     += dm-raid1.o
+dm-log-userspace-y \
+                += dm-log-userspace-base.o dm-log-userspace-transfer.o
 md-mod-y        += md.o bitmap.o
 raid456-y       += raid5.o
 raid6_pq-y      += raid6algos.o raid6recov.o raid6tables.o \
@@ -36,8 +38,11 @@ obj-$(CONFIG_BLK_DEV_DM)	+= dm-mod.o
 obj-$(CONFIG_DM_CRYPT)          += dm-crypt.o
 obj-$(CONFIG_DM_DELAY)          += dm-delay.o
 obj-$(CONFIG_DM_MULTIPATH)      += dm-multipath.o dm-round-robin.o
+obj-$(CONFIG_DM_MULTIPATH_QL)   += dm-queue-length.o
+obj-$(CONFIG_DM_MULTIPATH_ST)   += dm-service-time.o
 obj-$(CONFIG_DM_SNAPSHOT)       += dm-snapshot.o
 obj-$(CONFIG_DM_MIRROR)         += dm-mirror.o dm-log.o dm-region-hash.o
+obj-$(CONFIG_DM_LOG_USERSPACE)  += dm-log-userspace.o
 obj-$(CONFIG_DM_ZERO)           += dm-zero.o
 
 quiet_cmd_unroll = UNROLL  $@
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 53394e863c74..9933eb861c71 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -1132,6 +1132,7 @@ static int crypt_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad_crypt_queue;
         }
 
+        ti->num_flush_requests = 1;
         ti->private = cc;
         return 0;
 
@@ -1189,6 +1190,13 @@ static int crypt_map(struct dm_target *ti, struct bio *bio,
                      union map_info *map_context)
 {
         struct dm_crypt_io *io;
+        struct crypt_config *cc;
+
+        if (unlikely(bio_empty_barrier(bio))) {
+                cc = ti->private;
+                bio->bi_bdev = cc->dev->bdev;
+                return DM_MAPIO_REMAPPED;
+        }
 
         io = crypt_io_alloc(ti, bio, bio->bi_sector - ti->begin);
 
@@ -1305,9 +1313,17 @@ static int crypt_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
         return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
 }
 
+static int crypt_iterate_devices(struct dm_target *ti,
+                                 iterate_devices_callout_fn fn, void *data)
+{
+        struct crypt_config *cc = ti->private;
+
+        return fn(ti, cc->dev, cc->start, data);
+}
+
 static struct target_type crypt_target = {
         .name   = "crypt",
-        .version= {1, 6, 0},
+        .version = {1, 7, 0},
         .module = THIS_MODULE,
         .ctr    = crypt_ctr,
         .dtr    = crypt_dtr,
@@ -1318,6 +1334,7 @@ static struct target_type crypt_target = {
         .resume = crypt_resume,
         .message = crypt_message,
         .merge  = crypt_merge,
+        .iterate_devices = crypt_iterate_devices,
 };
 
 static int __init dm_crypt_init(void)
diff --git a/drivers/md/dm-delay.c b/drivers/md/dm-delay.c
index 559dbb52bc85..4e5b843cd4d7 100644
--- a/drivers/md/dm-delay.c
+++ b/drivers/md/dm-delay.c
@@ -197,6 +197,7 @@ out:
         mutex_init(&dc->timer_lock);
         atomic_set(&dc->may_delay, 1);
 
+        ti->num_flush_requests = 1;
         ti->private = dc;
         return 0;
 
@@ -278,8 +279,9 @@ static int delay_map(struct dm_target *ti, struct bio *bio,
 
         if ((bio_data_dir(bio) == WRITE) && (dc->dev_write)) {
                 bio->bi_bdev = dc->dev_write->bdev;
-                bio->bi_sector = dc->start_write +
-                                 (bio->bi_sector - ti->begin);
+                if (bio_sectors(bio))
+                        bio->bi_sector = dc->start_write +
+                                         (bio->bi_sector - ti->begin);
 
                 return delay_bio(dc, dc->write_delay, bio);
         }
@@ -316,9 +318,26 @@ static int delay_status(struct dm_target *ti, status_type_t type,
         return 0;
 }
 
+static int delay_iterate_devices(struct dm_target *ti,
+                                 iterate_devices_callout_fn fn, void *data)
+{
+        struct delay_c *dc = ti->private;
+        int ret = 0;
+
+        ret = fn(ti, dc->dev_read, dc->start_read, data);
+        if (ret)
+                goto out;
+
+        if (dc->dev_write)
+                ret = fn(ti, dc->dev_write, dc->start_write, data);
+
+out:
+        return ret;
+}
+
 static struct target_type delay_target = {
         .name        = "delay",
-        .version     = {1, 0, 2},
+        .version     = {1, 1, 0},
         .module      = THIS_MODULE,
         .ctr         = delay_ctr,
         .dtr         = delay_dtr,
@@ -326,6 +345,7 @@ static struct target_type delay_target = {
         .presuspend  = delay_presuspend,
         .resume      = delay_resume,
         .status      = delay_status,
+        .iterate_devices = delay_iterate_devices,
 };
 
 static int __init dm_delay_init(void)
diff --git a/drivers/md/dm-exception-store.c b/drivers/md/dm-exception-store.c
index 75d8081a9041..c3ae51584b12 100644
--- a/drivers/md/dm-exception-store.c
+++ b/drivers/md/dm-exception-store.c
@@ -216,7 +216,7 @@ int dm_exception_store_create(struct dm_target *ti, int argc, char **argv,
                 return -EINVAL;
         }
 
-        type = get_type(argv[1]);
+        type = get_type(&persistent);
         if (!type) {
                 ti->error = "Exception store type not recognised";
                 r = -EINVAL;
diff --git a/drivers/md/dm-exception-store.h b/drivers/md/dm-exception-store.h
index c92701dc5001..2442c8c07898 100644
--- a/drivers/md/dm-exception-store.h
+++ b/drivers/md/dm-exception-store.h
@@ -156,7 +156,7 @@ static inline void dm_consecutive_chunk_count_inc(struct dm_snap_exception *e)
  */
 static inline sector_t get_dev_size(struct block_device *bdev)
 {
-        return bdev->bd_inode->i_size >> SECTOR_SHIFT;
+        return i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
 }
 
 static inline chunk_t sector_to_chunk(struct dm_exception_store *store,
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index e73aabd61cd7..3a2e6a2f8bdd 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -22,6 +22,7 @@ struct dm_io_client {
 /* FIXME: can we shrink this ? */
 struct io {
         unsigned long error_bits;
+        unsigned long eopnotsupp_bits;
         atomic_t count;
         struct task_struct *sleeper;
         struct dm_io_client *client;
@@ -107,8 +108,11 @@ static inline unsigned bio_get_region(struct bio *bio)
  *---------------------------------------------------------------*/
 static void dec_count(struct io *io, unsigned int region, int error)
 {
-        if (error)
+        if (error) {
                 set_bit(region, &io->error_bits);
+                if (error == -EOPNOTSUPP)
+                        set_bit(region, &io->eopnotsupp_bits);
+        }
 
         if (atomic_dec_and_test(&io->count)) {
                 if (io->sleeper)
@@ -360,7 +364,9 @@ static int sync_io(struct dm_io_client *client, unsigned int num_regions,
                 return -EIO;
         }
 
+retry:
         io.error_bits = 0;
+        io.eopnotsupp_bits = 0;
         atomic_set(&io.count, 1); /* see dispatch_io() */
         io.sleeper = current;
         io.client = client;
@@ -377,6 +383,11 @@ static int sync_io(struct dm_io_client *client, unsigned int num_regions,
         }
         set_current_state(TASK_RUNNING);
 
+        if (io.eopnotsupp_bits && (rw & (1 << BIO_RW_BARRIER))) {
+                rw &= ~(1 << BIO_RW_BARRIER);
+                goto retry;
+        }
+
         if (error_bits)
                 *error_bits = io.error_bits;
 
@@ -397,6 +408,7 @@ static int async_io(struct dm_io_client *client, unsigned int num_regions,
 
         io = mempool_alloc(client->pool, GFP_NOIO);
         io->error_bits = 0;
+        io->eopnotsupp_bits = 0;
         atomic_set(&io->count, 1); /* see dispatch_io() */
         io->sleeper = NULL;
         io->client = client;
diff --git a/drivers/md/dm-ioctl.c b/drivers/md/dm-ioctl.c
index 1128d3fba797..7f77f18fcafa 100644
--- a/drivers/md/dm-ioctl.c
+++ b/drivers/md/dm-ioctl.c
@@ -276,7 +276,7 @@ retry:
         up_write(&_hash_lock);
 }
 
-static int dm_hash_rename(const char *old, const char *new)
+static int dm_hash_rename(uint32_t cookie, const char *old, const char *new)
 {
         char *new_name, *old_name;
         struct hash_cell *hc;
@@ -333,7 +333,7 @@ static int dm_hash_rename(const char *old, const char *new)
                 dm_table_put(table);
         }
 
-        dm_kobject_uevent(hc->md);
+        dm_kobject_uevent(hc->md, KOBJ_CHANGE, cookie);
 
         dm_put(hc->md);
         up_write(&_hash_lock);
@@ -680,6 +680,9 @@ static int dev_remove(struct dm_ioctl *param, size_t param_size)
 
         __hash_remove(hc);
         up_write(&_hash_lock);
+
+        dm_kobject_uevent(md, KOBJ_REMOVE, param->event_nr);
+
         dm_put(md);
         param->data_size = 0;
         return 0;
@@ -715,7 +718,7 @@ static int dev_rename(struct dm_ioctl *param, size_t param_size)
                 return r;
 
         param->data_size = 0;
-        return dm_hash_rename(param->name, new_name);
+        return dm_hash_rename(param->event_nr, param->name, new_name);
 }
 
 static int dev_set_geometry(struct dm_ioctl *param, size_t param_size)
@@ -842,8 +845,11 @@ static int do_resume(struct dm_ioctl *param)
         if (dm_suspended(md))
                 r = dm_resume(md);
 
-        if (!r)
+
+        if (!r) {
+                dm_kobject_uevent(md, KOBJ_CHANGE, param->event_nr);
                 r = __dev_status(md, param);
+        }
 
         dm_put(md);
         return r;
@@ -1044,6 +1050,12 @@ static int populate_table(struct dm_table *table,
                 next = spec->next;
         }
 
+        r = dm_table_set_type(table);
+        if (r) {
+                DMWARN("unable to set table type");
+                return r;
+        }
+
         return dm_table_complete(table);
 }
 
@@ -1089,6 +1101,13 @@ static int table_load(struct dm_ioctl *param, size_t param_size)
                 goto out;
         }
 
+        r = dm_table_alloc_md_mempools(t);
+        if (r) {
+                DMWARN("unable to allocate mempools for this table");
+                dm_table_destroy(t);
+                goto out;
+        }
+
         down_write(&_hash_lock);
         hc = dm_get_mdptr(md);
         if (!hc || hc->md != md) {
diff --git a/drivers/md/dm-linear.c b/drivers/md/dm-linear.c
index 79fb53e51c70..9184b6deb868 100644
--- a/drivers/md/dm-linear.c
+++ b/drivers/md/dm-linear.c
@@ -53,6 +53,7 @@ static int linear_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad;
         }
 
+        ti->num_flush_requests = 1;
         ti->private = lc;
         return 0;
 
@@ -81,7 +82,8 @@ static void linear_map_bio(struct dm_target *ti, struct bio *bio)
         struct linear_c *lc = ti->private;
 
         bio->bi_bdev = lc->dev->bdev;
-        bio->bi_sector = linear_map_sector(ti, bio->bi_sector);
+        if (bio_sectors(bio))
+                bio->bi_sector = linear_map_sector(ti, bio->bi_sector);
 }
 
 static int linear_map(struct dm_target *ti, struct bio *bio,
@@ -132,9 +134,17 @@ static int linear_merge(struct dm_target *ti, struct bvec_merge_data *bvm,
         return min(max_size, q->merge_bvec_fn(q, bvm, biovec));
 }
 
+static int linear_iterate_devices(struct dm_target *ti,
+                                  iterate_devices_callout_fn fn, void *data)
+{
+        struct linear_c *lc = ti->private;
+
+        return fn(ti, lc->dev, lc->start, data);
+}
+
 static struct target_type linear_target = {
         .name   = "linear",
-        .version= {1, 0, 3},
+        .version = {1, 1, 0},
         .module = THIS_MODULE,
         .ctr    = linear_ctr,
         .dtr    = linear_dtr,
@@ -142,6 +152,7 @@ static struct target_type linear_target = {
         .status = linear_status,
         .ioctl  = linear_ioctl,
         .merge  = linear_merge,
+        .iterate_devices = linear_iterate_devices,
 };
 
 int __init dm_linear_init(void)
diff --git a/drivers/md/dm-log-userspace-base.c b/drivers/md/dm-log-userspace-base.c
new file mode 100644
index 000000000000..e69b96560997
--- /dev/null
+++ b/drivers/md/dm-log-userspace-base.c
@@ -0,0 +1,696 @@
+/*
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ *
+ * This file is released under the LGPL.
+ */
+
+#include <linux/bio.h>
+#include <linux/dm-dirty-log.h>
+#include <linux/device-mapper.h>
+#include <linux/dm-log-userspace.h>
+
+#include "dm-log-userspace-transfer.h"
+
+struct flush_entry {
+        int type;
+        region_t region;
+        struct list_head list;
+};
+
+struct log_c {
+        struct dm_target *ti;
+        uint32_t region_size;
+        region_t region_count;
+        char uuid[DM_UUID_LEN];
+
+        char *usr_argv_str;
+        uint32_t usr_argc;
+
+        /*
+         * in_sync_hint gets set when doing is_remote_recovering.  It
+         * represents the first region that needs recovery.  IOW, the
+         * first zero bit of sync_bits.  This can be useful for to limit
+         * traffic for calls like is_remote_recovering and get_resync_work,
+         * but be take care in its use for anything else.
+         */
+        uint64_t in_sync_hint;
+
+        spinlock_t flush_lock;
+        struct list_head flush_list;  /* only for clear and mark requests */
+};
+
+static mempool_t *flush_entry_pool;
+
+static void *flush_entry_alloc(gfp_t gfp_mask, void *pool_data)
+{
+        return kmalloc(sizeof(struct flush_entry), gfp_mask);
+}
+
+static void flush_entry_free(void *element, void *pool_data)
+{
+        kfree(element);
+}
+
+static int userspace_do_request(struct log_c *lc, const char *uuid,
+                                int request_type, char *data, size_t data_size,
+                                char *rdata, size_t *rdata_size)
+{
+        int r;
+
+        /*
+         * If the server isn't there, -ESRCH is returned,
+         * and we must keep trying until the server is
+         * restored.
+         */
+retry:
+        r = dm_consult_userspace(uuid, request_type, data,
+                                 data_size, rdata, rdata_size);
+
+        if (r != -ESRCH)
+                return r;
+
+        DMERR(" Userspace log server not found.");
+        while (1) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule_timeout(2*HZ);
+                DMWARN("Attempting to contact userspace log server...");
+                r = dm_consult_userspace(uuid, DM_ULOG_CTR, lc->usr_argv_str,
+                                         strlen(lc->usr_argv_str) + 1,
+                                         NULL, NULL);
+                if (!r)
+                        break;
+        }
+        DMINFO("Reconnected to userspace log server... DM_ULOG_CTR complete");
+        r = dm_consult_userspace(uuid, DM_ULOG_RESUME, NULL,
+                                 0, NULL, NULL);
+        if (!r)
+                goto retry;
+
+        DMERR("Error trying to resume userspace log: %d", r);
+
+        return -ESRCH;
+}
+
+static int build_constructor_string(struct dm_target *ti,
+                                    unsigned argc, char **argv,
+                                    char **ctr_str)
+{
+        int i, str_size;
+        char *str = NULL;
+
+        *ctr_str = NULL;
+
+        for (i = 0, str_size = 0; i < argc; i++)
+                str_size += strlen(argv[i]) + 1; /* +1 for space between args */
+
+        str_size += 20; /* Max number of chars in a printed u64 number */
+
+        str = kzalloc(str_size, GFP_KERNEL);
+        if (!str) {
+                DMWARN("Unable to allocate memory for constructor string");
+                return -ENOMEM;
+        }
+
+        for (i = 0, str_size = 0; i < argc; i++)
+                str_size += sprintf(str + str_size, "%s ", argv[i]);
+        str_size += sprintf(str + str_size, "%llu",
+                            (unsigned long long)ti->len);
+
+        *ctr_str = str;
+        return str_size;
+}
+
+/*
+ * userspace_ctr
+ *
+ * argv contains:
+ *      <UUID> <other args>
+ * Where 'other args' is the userspace implementation specific log
+ * arguments.  An example might be:
+ *      <UUID> clustered_disk <arg count> <log dev> <region_size> [[no]sync]
+ *
+ * So, this module will strip off the <UUID> for identification purposes
+ * when communicating with userspace about a log; but will pass on everything
+ * else.
+ */
+static int userspace_ctr(struct dm_dirty_log *log, struct dm_target *ti,
+                         unsigned argc, char **argv)
+{
+        int r = 0;
+        int str_size;
+        char *ctr_str = NULL;
+        struct log_c *lc = NULL;
+        uint64_t rdata;
+        size_t rdata_size = sizeof(rdata);
+
+        if (argc < 3) {
+                DMWARN("Too few arguments to userspace dirty log");
+                return -EINVAL;
+        }
+
+        lc = kmalloc(sizeof(*lc), GFP_KERNEL);
+        if (!lc) {
+                DMWARN("Unable to allocate userspace log context.");
+                return -ENOMEM;
+        }
+
+        lc->ti = ti;
+
+        if (strlen(argv[0]) > (DM_UUID_LEN - 1)) {
+                DMWARN("UUID argument too long.");
+                kfree(lc);
+                return -EINVAL;
+        }
+
+        strncpy(lc->uuid, argv[0], DM_UUID_LEN);
+        spin_lock_init(&lc->flush_lock);
+        INIT_LIST_HEAD(&lc->flush_list);
+
+        str_size = build_constructor_string(ti, argc - 1, argv + 1, &ctr_str);
+        if (str_size < 0) {
+                kfree(lc);
+                return str_size;
+        }
+
+        /* Send table string */
+        r = dm_consult_userspace(lc->uuid, DM_ULOG_CTR,
+                                 ctr_str, str_size, NULL, NULL);
+
+        if (r == -ESRCH) {
+                DMERR("Userspace log server not found");
+                goto out;
+        }
+
+        /* Since the region size does not change, get it now */
+        rdata_size = sizeof(rdata);
+        r = dm_consult_userspace(lc->uuid, DM_ULOG_GET_REGION_SIZE,
+                                 NULL, 0, (char *)&rdata, &rdata_size);
+
+        if (r) {
+                DMERR("Failed to get region size of dirty log");
+                goto out;
+        }
+
+        lc->region_size = (uint32_t)rdata;
+        lc->region_count = dm_sector_div_up(ti->len, lc->region_size);
+
+out:
+        if (r) {
+                kfree(lc);
+                kfree(ctr_str);
+        } else {
+                lc->usr_argv_str = ctr_str;
+                lc->usr_argc = argc;
+                log->context = lc;
+        }
+
+        return r;
+}
+
+static void userspace_dtr(struct dm_dirty_log *log)
+{
+        int r;
+        struct log_c *lc = log->context;
+
+        r = dm_consult_userspace(lc->uuid, DM_ULOG_DTR,
+                                 NULL, 0,
+                                 NULL, NULL);
+
+        kfree(lc->usr_argv_str);
+        kfree(lc);
+
+        return;
+}
+
+static int userspace_presuspend(struct dm_dirty_log *log)
+{
+        int r;
+        struct log_c *lc = log->context;
+
+        r = dm_consult_userspace(lc->uuid, DM_ULOG_PRESUSPEND,
+                                 NULL, 0,
+                                 NULL, NULL);
+
+        return r;
+}
+
+static int userspace_postsuspend(struct dm_dirty_log *log)
+{
+        int r;
+        struct log_c *lc = log->context;
+
+        r = dm_consult_userspace(lc->uuid, DM_ULOG_POSTSUSPEND,
+                                 NULL, 0,
+                                 NULL, NULL);
+
+        return r;
+}
+
+static int userspace_resume(struct dm_dirty_log *log)
+{
+        int r;
+        struct log_c *lc = log->context;
+
+        lc->in_sync_hint = 0;
+        r = dm_consult_userspace(lc->uuid, DM_ULOG_RESUME,
+                                 NULL, 0,
+                                 NULL, NULL);
+
+        return r;
+}
+
+static uint32_t userspace_get_region_size(struct dm_dirty_log *log)
+{
+        struct log_c *lc = log->context;
+
+        return lc->region_size;
+}
+
+/*
+ * userspace_is_clean
+ *
+ * Check whether a region is clean.  If there is any sort of
+ * failure when consulting the server, we return not clean.
+ *
+ * Returns: 1 if clean, 0 otherwise
+ */
+static int userspace_is_clean(struct dm_dirty_log *log, region_t region)
+{
+        int r;
+        uint64_t region64 = (uint64_t)region;
+        int64_t is_clean;
+        size_t rdata_size;
+        struct log_c *lc = log->context;
+
+        rdata_size = sizeof(is_clean);
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_CLEAN,
+                                 (char *)&region64, sizeof(region64),
+                                 (char *)&is_clean, &rdata_size);
+
+        return (r) ? 0 : (int)is_clean;
+}
+
+/*
+ * userspace_in_sync
+ *
+ * Check if the region is in-sync.  If there is any sort
+ * of failure when consulting the server, we assume that
+ * the region is not in sync.
+ *
+ * If 'can_block' is set, return immediately
+ *
+ * Returns: 1 if in-sync, 0 if not-in-sync, -EWOULDBLOCK
+ */
+static int userspace_in_sync(struct dm_dirty_log *log, region_t region,
+                             int can_block)
+{
+        int r;
+        uint64_t region64 = region;
+        int64_t in_sync;
+        size_t rdata_size;
+        struct log_c *lc = log->context;
+
+        /*
+         * We can never respond directly - even if in_sync_hint is
+         * set.  This is because another machine could see a device
+         * failure and mark the region out-of-sync.  If we don't go
+         * to userspace to ask, we might think the region is in-sync
+         * and allow a read to pick up data that is stale.  (This is
+         * very unlikely if a device actually fails; but it is very
+         * likely if a connection to one device from one machine fails.)
+         *
+         * There still might be a problem if the mirror caches the region
+         * state as in-sync... but then this call would not be made.  So,
+         * that is a mirror problem.
+         */
+        if (!can_block)
+                return -EWOULDBLOCK;
+
+        rdata_size = sizeof(in_sync);
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_IN_SYNC,
+                                 (char *)&region64, sizeof(region64),
+                                 (char *)&in_sync, &rdata_size);
+        return (r) ? 0 : (int)in_sync;
+}
+
+/*
+ * userspace_flush
+ *
+ * This function is ok to block.
+ * The flush happens in two stages.  First, it sends all
+ * clear/mark requests that are on the list.  Then it
+ * tells the server to commit them.  This gives the
+ * server a chance to optimise the commit, instead of
+ * doing it for every request.
+ *
+ * Additionally, we could implement another thread that
+ * sends the requests up to the server - reducing the
+ * load on flush.  Then the flush would have less in
+ * the list and be responsible for the finishing commit.
+ *
+ * Returns: 0 on success, < 0 on failure
+ */
+static int userspace_flush(struct dm_dirty_log *log)
+{
+        int r = 0;
+        unsigned long flags;
+        struct log_c *lc = log->context;
+        LIST_HEAD(flush_list);
+        struct flush_entry *fe, *tmp_fe;
+
+        spin_lock_irqsave(&lc->flush_lock, flags);
+        list_splice_init(&lc->flush_list, &flush_list);
+        spin_unlock_irqrestore(&lc->flush_lock, flags);
+
+        if (list_empty(&flush_list))
+                return 0;
+
+        /*
+         * FIXME: Count up requests, group request types,
+         * allocate memory to stick all requests in and
+         * send to server in one go.  Failing the allocation,
+         * do it one by one.
+         */
+
+        list_for_each_entry(fe, &flush_list, list) {
+                r = userspace_do_request(lc, lc->uuid, fe->type,
+                                         (char *)&fe->region,
+                                         sizeof(fe->region),
+                                         NULL, NULL);
+                if (r)
+                        goto fail;
+        }
+
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_FLUSH,
+                                 NULL, 0, NULL, NULL);
+
+fail:
+        /*
+         * We can safely remove these entries, even if failure.
+         * Calling code will receive an error and will know that
+         * the log facility has failed.
+         */
+        list_for_each_entry_safe(fe, tmp_fe, &flush_list, list) {
+                list_del(&fe->list);
+                mempool_free(fe, flush_entry_pool);
+        }
+
+        if (r)
+                dm_table_event(lc->ti->table);
+
+        return r;
+}
+
+/*
+ * userspace_mark_region
+ *
+ * This function should avoid blocking unless absolutely required.
+ * (Memory allocation is valid for blocking.)
+ */
+static void userspace_mark_region(struct dm_dirty_log *log, region_t region)
+{
+        unsigned long flags;
+        struct log_c *lc = log->context;
+        struct flush_entry *fe;
+
+        /* Wait for an allocation, but _never_ fail */
+        fe = mempool_alloc(flush_entry_pool, GFP_NOIO);
+        BUG_ON(!fe);
+
+        spin_lock_irqsave(&lc->flush_lock, flags);
+        fe->type = DM_ULOG_MARK_REGION;
+        fe->region = region;
+        list_add(&fe->list, &lc->flush_list);
+        spin_unlock_irqrestore(&lc->flush_lock, flags);
+
+        return;
+}
+
+/*
+ * userspace_clear_region
+ *
+ * This function must not block.
+ * So, the alloc can't block.  In the worst case, it is ok to
+ * fail.  It would simply mean we can't clear the region.
+ * Does nothing to current sync context, but does mean
+ * the region will be re-sync'ed on a reload of the mirror
+ * even though it is in-sync.
+ */
+static void userspace_clear_region(struct dm_dirty_log *log, region_t region)
+{
+        unsigned long flags;
+        struct log_c *lc = log->context;
+        struct flush_entry *fe;
+
+        /*
+         * If we fail to allocate, we skip the clearing of
+         * the region.  This doesn't hurt us in any way, except
+         * to cause the region to be resync'ed when the
+         * device is activated next time.
+         */
+        fe = mempool_alloc(flush_entry_pool, GFP_ATOMIC);
+        if (!fe) {
+                DMERR("Failed to allocate memory to clear region.");
+                return;
+        }
+
+        spin_lock_irqsave(&lc->flush_lock, flags);
+        fe->type = DM_ULOG_CLEAR_REGION;
+        fe->region = region;
+        list_add(&fe->list, &lc->flush_list);
+        spin_unlock_irqrestore(&lc->flush_lock, flags);
+
+        return;
+}
+
+/*
+ * userspace_get_resync_work
+ *
+ * Get a region that needs recovery.  It is valid to return
+ * an error for this function.
+ *
+ * Returns: 1 if region filled, 0 if no work, <0 on error
+ */
+static int userspace_get_resync_work(struct dm_dirty_log *log, region_t *region)
+{
+        int r;
+        size_t rdata_size;
+        struct log_c *lc = log->context;
+        struct {
+                int64_t i; /* 64-bit for mix arch compatibility */
+                region_t r;
+        } pkg;
+
+        if (lc->in_sync_hint >= lc->region_count)
+                return 0;
+
+        rdata_size = sizeof(pkg);
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_RESYNC_WORK,
+                                 NULL, 0,
+                                 (char *)&pkg, &rdata_size);
+
+        *region = pkg.r;
+        return (r) ? r : (int)pkg.i;
+}
+
+/*
+ * userspace_set_region_sync
+ *
+ * Set the sync status of a given region.  This function
+ * must not fail.
+ */
+static void userspace_set_region_sync(struct dm_dirty_log *log,
+                                      region_t region, int in_sync)
+{
+        int r;
+        struct log_c *lc = log->context;
+        struct {
+                region_t r;
+                int64_t i;
+        } pkg;
+
+        pkg.r = region;
+        pkg.i = (int64_t)in_sync;
+
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_SET_REGION_SYNC,
+                                 (char *)&pkg, sizeof(pkg),
+                                 NULL, NULL);
+
+        /*
+         * It would be nice to be able to report failures.
+         * However, it is easy emough to detect and resolve.
+         */
+        return;
+}
+
+/*
+ * userspace_get_sync_count
+ *
+ * If there is any sort of failure when consulting the server,
+ * we assume that the sync count is zero.
+ *
+ * Returns: sync count on success, 0 on failure
+ */
+static region_t userspace_get_sync_count(struct dm_dirty_log *log)
+{
+        int r;
+        size_t rdata_size;
+        uint64_t sync_count;
+        struct log_c *lc = log->context;
+
+        rdata_size = sizeof(sync_count);
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_GET_SYNC_COUNT,
+                                 NULL, 0,
+                                 (char *)&sync_count, &rdata_size);
+
+        if (r)
+                return 0;
+
+        if (sync_count >= lc->region_count)
+                lc->in_sync_hint = lc->region_count;
+
+        return (region_t)sync_count;
+}
+
+/*
+ * userspace_status
+ *
+ * Returns: amount of space consumed
+ */
+static int userspace_status(struct dm_dirty_log *log, status_type_t status_type,
+                            char *result, unsigned maxlen)
+{
+        int r = 0;
+        size_t sz = (size_t)maxlen;
+        struct log_c *lc = log->context;
+
+        switch (status_type) {
+        case STATUSTYPE_INFO:
+                r = userspace_do_request(lc, lc->uuid, DM_ULOG_STATUS_INFO,
+                                         NULL, 0,
+                                         result, &sz);
+
+                if (r) {
+                        sz = 0;
+                        DMEMIT("%s 1 COM_FAILURE", log->type->name);
+                }
+                break;
+        case STATUSTYPE_TABLE:
+                sz = 0;
+                DMEMIT("%s %u %s %s", log->type->name, lc->usr_argc + 1,
+                       lc->uuid, lc->usr_argv_str);
+                break;
+        }
+        return (r) ? 0 : (int)sz;
+}
+
+/*
+ * userspace_is_remote_recovering
+ *
+ * Returns: 1 if region recovering, 0 otherwise
+ */
+static int userspace_is_remote_recovering(struct dm_dirty_log *log,
+                                          region_t region)
+{
+        int r;
+        uint64_t region64 = region;
+        struct log_c *lc = log->context;
+        static unsigned long long limit;
+        struct {
+                int64_t is_recovering;
+                uint64_t in_sync_hint;
+        } pkg;
+        size_t rdata_size = sizeof(pkg);
+
+        /*
+         * Once the mirror has been reported to be in-sync,
+         * it will never again ask for recovery work.  So,
+         * we can safely say there is not a remote machine
+         * recovering if the device is in-sync.  (in_sync_hint
+         * must be reset at resume time.)
+         */
+        if (region < lc->in_sync_hint)
+                return 0;
+        else if (jiffies < limit)
+                return 1;
+
+        limit = jiffies + (HZ / 4);
+        r = userspace_do_request(lc, lc->uuid, DM_ULOG_IS_REMOTE_RECOVERING,
+                                 (char *)&region64, sizeof(region64),
+                                 (char *)&pkg, &rdata_size);
+        if (r)
+                return 1;
+
+        lc->in_sync_hint = pkg.in_sync_hint;
+
+        return (int)pkg.is_recovering;
+}
+
+static struct dm_dirty_log_type _userspace_type = {
+        .name = "userspace",
+        .module = THIS_MODULE,
+        .ctr = userspace_ctr,
+        .dtr = userspace_dtr,
+        .presuspend = userspace_presuspend,
+        .postsuspend = userspace_postsuspend,
+        .resume = userspace_resume,
+        .get_region_size = userspace_get_region_size,
+        .is_clean = userspace_is_clean,
+        .in_sync = userspace_in_sync,
+        .flush = userspace_flush,
+        .mark_region = userspace_mark_region,
+        .clear_region = userspace_clear_region,
+        .get_resync_work = userspace_get_resync_work,
+        .set_region_sync = userspace_set_region_sync,
+        .get_sync_count = userspace_get_sync_count,
+        .status = userspace_status,
+        .is_remote_recovering = userspace_is_remote_recovering,
+};
+
+static int __init userspace_dirty_log_init(void)
+{
+        int r = 0;
+
+        flush_entry_pool = mempool_create(100, flush_entry_alloc,
+                                          flush_entry_free, NULL);
+
+        if (!flush_entry_pool) {
+                DMWARN("Unable to create flush_entry_pool:  No memory.");
+                return -ENOMEM;
+        }
+
+        r = dm_ulog_tfr_init();
+        if (r) {
+                DMWARN("Unable to initialize userspace log communications");
+                mempool_destroy(flush_entry_pool);
+                return r;
+        }
+
+        r = dm_dirty_log_type_register(&_userspace_type);
+        if (r) {
+                DMWARN("Couldn't register userspace dirty log type");
+                dm_ulog_tfr_exit();
+                mempool_destroy(flush_entry_pool);
+                return r;
+        }
+
+        DMINFO("version 1.0.0 loaded");
+        return 0;
+}
+
+static void __exit userspace_dirty_log_exit(void)
+{
+        dm_dirty_log_type_unregister(&_userspace_type);
+        dm_ulog_tfr_exit();
+        mempool_destroy(flush_entry_pool);
+
+        DMINFO("version 1.0.0 unloaded");
+        return;
+}
+
+module_init(userspace_dirty_log_init);
+module_exit(userspace_dirty_log_exit);
+
+MODULE_DESCRIPTION(DM_NAME " userspace dirty log link");
+MODULE_AUTHOR("Jonathan Brassow <dm-devel@redhat.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/md/dm-log-userspace-transfer.c b/drivers/md/dm-log-userspace-transfer.c
new file mode 100644
index 000000000000..0ca1ee768a1f
--- /dev/null
+++ b/drivers/md/dm-log-userspace-transfer.c
@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ *
+ * This file is released under the LGPL.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <net/sock.h>
+#include <linux/workqueue.h>
+#include <linux/connector.h>
+#include <linux/device-mapper.h>
+#include <linux/dm-log-userspace.h>
+
+#include "dm-log-userspace-transfer.h"
+
+static uint32_t dm_ulog_seq;
+
+/*
+ * Netlink/Connector is an unreliable protocol.  How long should
+ * we wait for a response before assuming it was lost and retrying?
+ * (If we do receive a response after this time, it will be discarded
+ * and the response to the resent request will be waited for.
+ */
+#define DM_ULOG_RETRY_TIMEOUT (15 * HZ)
+
+/*
+ * Pre-allocated space for speed
+ */
+#define DM_ULOG_PREALLOCED_SIZE 512
+static struct cn_msg *prealloced_cn_msg;
+static struct dm_ulog_request *prealloced_ulog_tfr;
+
+static struct cb_id ulog_cn_id = {
+        .idx = CN_IDX_DM,
+        .val = CN_VAL_DM_USERSPACE_LOG
+};
+
+static DEFINE_MUTEX(dm_ulog_lock);
+
+struct receiving_pkg {
+        struct list_head list;
+        struct completion complete;
+
+        uint32_t seq;
+
+        int error;
+        size_t *data_size;
+        char *data;
+};
+
+static DEFINE_SPINLOCK(receiving_list_lock);
+static struct list_head receiving_list;
+
+static int dm_ulog_sendto_server(struct dm_ulog_request *tfr)
+{
+        int r;
+        struct cn_msg *msg = prealloced_cn_msg;
+
+        memset(msg, 0, sizeof(struct cn_msg));
+
+        msg->id.idx = ulog_cn_id.idx;
+        msg->id.val = ulog_cn_id.val;
+        msg->ack = 0;
+        msg->seq = tfr->seq;
+        msg->len = sizeof(struct dm_ulog_request) + tfr->data_size;
+
+        r = cn_netlink_send(msg, 0, gfp_any());
+
+        return r;
+}
+
+/*
+ * Parameters for this function can be either msg or tfr, but not
+ * both.  This function fills in the reply for a waiting request.
+ * If just msg is given, then the reply is simply an ACK from userspace
+ * that the request was received.
+ *
+ * Returns: 0 on success, -ENOENT on failure
+ */
+static int fill_pkg(struct cn_msg *msg, struct dm_ulog_request *tfr)
+{
+        uint32_t rtn_seq = (msg) ? msg->seq : (tfr) ? tfr->seq : 0;
+        struct receiving_pkg *pkg;
+
+        /*
+         * The 'receiving_pkg' entries in this list are statically
+         * allocated on the stack in 'dm_consult_userspace'.
+         * Each process that is waiting for a reply from the user
+         * space server will have an entry in this list.
+         *
+         * We are safe to do it this way because the stack space
+         * is unique to each process, but still addressable by
+         * other processes.
+         */
+        list_for_each_entry(pkg, &receiving_list, list) {
+                if (rtn_seq != pkg->seq)
+                        continue;
+
+                if (msg) {
+                        pkg->error = -msg->ack;
+                        /*
+                         * If we are trying again, we will need to know our
+                         * storage capacity.  Otherwise, along with the
+                         * error code, we make explicit that we have no data.
+                         */
+                        if (pkg->error != -EAGAIN)
+                                *(pkg->data_size) = 0;
+                } else if (tfr->data_size > *(pkg->data_size)) {
+                        DMERR("Insufficient space to receive package [%u] "
+                              "(%u vs %lu)", tfr->request_type,
+                              tfr->data_size, *(pkg->data_size));
+
+                        *(pkg->data_size) = 0;
+                        pkg->error = -ENOSPC;
+                } else {
+                        pkg->error = tfr->error;
+                        memcpy(pkg->data, tfr->data, tfr->data_size);
+                        *(pkg->data_size) = tfr->data_size;
+                }
+                complete(&pkg->complete);
+                return 0;
+        }
+
+        return -ENOENT;
+}
+
+/*
+ * This is the connector callback that delivers data
+ * that was sent from userspace.
+ */
+static void cn_ulog_callback(void *data)
+{
+        struct cn_msg *msg = (struct cn_msg *)data;
+        struct dm_ulog_request *tfr = (struct dm_ulog_request *)(msg + 1);
+
+        spin_lock(&receiving_list_lock);
+        if (msg->len == 0)
+                fill_pkg(msg, NULL);
+        else if (msg->len < sizeof(*tfr))
+                DMERR("Incomplete message received (expected %u, got %u): [%u]",
+                      (unsigned)sizeof(*tfr), msg->len, msg->seq);
+        else
+                fill_pkg(NULL, tfr);
+        spin_unlock(&receiving_list_lock);
+}
+
+/**
+ * dm_consult_userspace
+ * @uuid: log's uuid (must be DM_UUID_LEN in size)
+ * @request_type:  found in include/linux/dm-log-userspace.h
+ * @data: data to tx to the server
+ * @data_size: size of data in bytes
+ * @rdata: place to put return data from server
+ * @rdata_size: value-result (amount of space given/amount of space used)
+ *
+ * rdata_size is undefined on failure.
+ *
+ * Memory used to communicate with userspace is zero'ed
+ * before populating to ensure that no unwanted bits leak
+ * from kernel space to user-space.  All userspace log communications
+ * between kernel and user space go through this function.
+ *
+ * Returns: 0 on success, -EXXX on failure
+ **/
+int dm_consult_userspace(const char *uuid, int request_type,
+                         char *data, size_t data_size,
+                         char *rdata, size_t *rdata_size)
+{
+        int r = 0;
+        size_t dummy = 0;
+        int overhead_size =
+                sizeof(struct dm_ulog_request *) + sizeof(struct cn_msg);
+        struct dm_ulog_request *tfr = prealloced_ulog_tfr;
+        struct receiving_pkg pkg;
+
+        if (data_size > (DM_ULOG_PREALLOCED_SIZE - overhead_size)) {
+                DMINFO("Size of tfr exceeds preallocated size");
+                return -EINVAL;
+        }
+
+        if (!rdata_size)
+                rdata_size = &dummy;
+resend:
+        /*
+         * We serialize the sending of requests so we can
+         * use the preallocated space.
+         */
+        mutex_lock(&dm_ulog_lock);
+
+        memset(tfr, 0, DM_ULOG_PREALLOCED_SIZE - overhead_size);
+        memcpy(tfr->uuid, uuid, DM_UUID_LEN);
+        tfr->seq = dm_ulog_seq++;
+
+        /*
+         * Must be valid request type (all other bits set to
+         * zero).  This reserves other bits for possible future
+         * use.
+         */
+        tfr->request_type = request_type & DM_ULOG_REQUEST_MASK;
+
+        tfr->data_size = data_size;
+        if (data && data_size)
+                memcpy(tfr->data, data, data_size);
+
+        memset(&pkg, 0, sizeof(pkg));
+        init_completion(&pkg.complete);
+        pkg.seq = tfr->seq;
+        pkg.data_size = rdata_size;
+        pkg.data = rdata;
+        spin_lock(&receiving_list_lock);
+        list_add(&(pkg.list), &receiving_list);
+        spin_unlock(&receiving_list_lock);
+
+        r = dm_ulog_sendto_server(tfr);
+
+        mutex_unlock(&dm_ulog_lock);
+
+        if (r) {
+                DMERR("Unable to send log request [%u] to userspace: %d",
+                      request_type, r);
+                spin_lock(&receiving_list_lock);
+                list_del_init(&(pkg.list));
+                spin_unlock(&receiving_list_lock);
+
+                goto out;
+        }
+
+        r = wait_for_completion_timeout(&(pkg.complete), DM_ULOG_RETRY_TIMEOUT);
+        spin_lock(&receiving_list_lock);
+        list_del_init(&(pkg.list));
+        spin_unlock(&receiving_list_lock);
+        if (!r) {
+                DMWARN("[%s] Request timed out: [%u/%u] - retrying",
+                       (strlen(uuid) > 8) ?
+                       (uuid + (strlen(uuid) - 8)) : (uuid),
+                       request_type, pkg.seq);
+                goto resend;
+        }
+
+        r = pkg.error;
+        if (r == -EAGAIN)
+                goto resend;
+
+out:
+        return r;
+}
+
+int dm_ulog_tfr_init(void)
+{
+        int r;
+        void *prealloced;
+
+        INIT_LIST_HEAD(&receiving_list);
+
+        prealloced = kmalloc(DM_ULOG_PREALLOCED_SIZE, GFP_KERNEL);
+        if (!prealloced)
+                return -ENOMEM;
+
+        prealloced_cn_msg = prealloced;
+        prealloced_ulog_tfr = prealloced + sizeof(struct cn_msg);
+
+        r = cn_add_callback(&ulog_cn_id, "dmlogusr", cn_ulog_callback);
+        if (r) {
+                cn_del_callback(&ulog_cn_id);
+                return r;
+        }
+
+        return 0;
+}
+
+void dm_ulog_tfr_exit(void)
+{
+        cn_del_callback(&ulog_cn_id);
+        kfree(prealloced_cn_msg);
+}
diff --git a/drivers/md/dm-log-userspace-transfer.h b/drivers/md/dm-log-userspace-transfer.h
new file mode 100644
index 000000000000..c26d8e4e2710
--- /dev/null
+++ b/drivers/md/dm-log-userspace-transfer.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2006-2009 Red Hat, Inc.
+ *
+ * This file is released under the LGPL.
+ */
+
+#ifndef __DM_LOG_USERSPACE_TRANSFER_H__
+#define __DM_LOG_USERSPACE_TRANSFER_H__
+
+#define DM_MSG_PREFIX "dm-log-userspace"
+
+int dm_ulog_tfr_init(void);
+void dm_ulog_tfr_exit(void);
+int dm_consult_userspace(const char *uuid, int request_type,
+                         char *data, size_t data_size,
+                         char *rdata, size_t *rdata_size);
+
+#endif /* __DM_LOG_USERSPACE_TRANSFER_H__ */
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index 6fa8ccf91c70..9443896ede07 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -412,11 +412,12 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
                 /*
                  * Buffer holds both header and bitset.
                  */
-                buf_size = dm_round_up((LOG_OFFSET << SECTOR_SHIFT) +
-                                       bitset_size,
-                                       ti->limits.logical_block_size);
+                buf_size =
+                    dm_round_up((LOG_OFFSET << SECTOR_SHIFT) + bitset_size,
+                                bdev_logical_block_size(lc->header_location.
+                                                            bdev));
 
-                if (buf_size > dev->bdev->bd_inode->i_size) {
+                if (buf_size > i_size_read(dev->bdev->bd_inode)) {
                         DMWARN("log device %s too small: need %llu bytes",
                                 dev->name, (unsigned long long)buf_size);
                         kfree(lc);
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index 6a386ab4f7eb..c70604a20897 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -8,7 +8,6 @@
 #include <linux/device-mapper.h>
 
 #include "dm-path-selector.h"
-#include "dm-bio-record.h"
 #include "dm-uevent.h"
 
 #include <linux/ctype.h>
@@ -35,6 +34,7 @@ struct pgpath {
 
         struct dm_path path;
         struct work_struct deactivate_path;
+        struct work_struct activate_path;
 };
 
 #define path_to_pgpath(__pgp) container_of((__pgp), struct pgpath, path)
@@ -64,8 +64,6 @@ struct multipath {
         spinlock_t lock;
 
         const char *hw_handler_name;
-        struct work_struct activate_path;
-        struct pgpath *pgpath_to_activate;
         unsigned nr_priority_groups;
         struct list_head priority_groups;
         unsigned pg_init_required;      /* pg_init needs calling? */
@@ -84,7 +82,7 @@ struct multipath {
         unsigned pg_init_count;         /* Number of times pg_init called */
 
         struct work_struct process_queued_ios;
-        struct bio_list queued_ios;
+        struct list_head queued_ios;
         unsigned queue_size;
 
         struct work_struct trigger_event;
@@ -101,7 +99,7 @@ struct multipath {
  */
 struct dm_mpath_io {
         struct pgpath *pgpath;
-        struct dm_bio_details details;
+        size_t nr_bytes;
 };
 
 typedef int (*action_fn) (struct pgpath *pgpath);
@@ -128,6 +126,7 @@ static struct pgpath *alloc_pgpath(void)
         if (pgpath) {
                 pgpath->is_active = 1;
                 INIT_WORK(&pgpath->deactivate_path, deactivate_path);
+                INIT_WORK(&pgpath->activate_path, activate_path);
         }
 
         return pgpath;
@@ -160,7 +159,6 @@ static struct priority_group *alloc_priority_group(void)
 
 static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)
 {
-        unsigned long flags;
         struct pgpath *pgpath, *tmp;
         struct multipath *m = ti->private;
 
@@ -169,10 +167,6 @@ static void free_pgpaths(struct list_head *pgpaths, struct dm_target *ti)
                 if (m->hw_handler_name)
                         scsi_dh_detach(bdev_get_queue(pgpath->path.dev->bdev));
                 dm_put_device(ti, pgpath->path.dev);
-                spin_lock_irqsave(&m->lock, flags);
-                if (m->pgpath_to_activate == pgpath)
-                        m->pgpath_to_activate = NULL;
-                spin_unlock_irqrestore(&m->lock, flags);
                 free_pgpath(pgpath);
         }
 }
@@ -198,11 +192,11 @@ static struct multipath *alloc_multipath(struct dm_target *ti)
         m = kzalloc(sizeof(*m), GFP_KERNEL);
         if (m) {
                 INIT_LIST_HEAD(&m->priority_groups);
+                INIT_LIST_HEAD(&m->queued_ios);
                 spin_lock_init(&m->lock);
                 m->queue_io = 1;
                 INIT_WORK(&m->process_queued_ios, process_queued_ios);
                 INIT_WORK(&m->trigger_event, trigger_event);
-                INIT_WORK(&m->activate_path, activate_path);
                 m->mpio_pool = mempool_create_slab_pool(MIN_IOS, _mpio_cache);
                 if (!m->mpio_pool) {
                         kfree(m);
@@ -250,11 +244,12 @@ static void __switch_pg(struct multipath *m, struct pgpath *pgpath)
         m->pg_init_count = 0;
 }
 
-static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg)
+static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg,
+                               size_t nr_bytes)
 {
         struct dm_path *path;
 
-        path = pg->ps.type->select_path(&pg->ps, &m->repeat_count);
+        path = pg->ps.type->select_path(&pg->ps, &m->repeat_count, nr_bytes);
         if (!path)
                 return -ENXIO;
 
@@ -266,7 +261,7 @@ static int __choose_path_in_pg(struct multipath *m, struct priority_group *pg)
         return 0;
 }
 
-static void __choose_pgpath(struct multipath *m)
+static void __choose_pgpath(struct multipath *m, size_t nr_bytes)
 {
         struct priority_group *pg;
         unsigned bypassed = 1;
@@ -278,12 +273,12 @@ static void __choose_pgpath(struct multipath *m)
         if (m->next_pg) {
                 pg = m->next_pg;
                 m->next_pg = NULL;
-                if (!__choose_path_in_pg(m, pg))
+                if (!__choose_path_in_pg(m, pg, nr_bytes))
                         return;
         }
 
         /* Don't change PG until it has no remaining paths */
-        if (m->current_pg && !__choose_path_in_pg(m, m->current_pg))
+        if (m->current_pg && !__choose_path_in_pg(m, m->current_pg, nr_bytes))
                 return;
 
         /*
@@ -295,7 +290,7 @@ static void __choose_pgpath(struct multipath *m)
                 list_for_each_entry(pg, &m->priority_groups, list) {
                         if (pg->bypassed == bypassed)
                                 continue;
-                        if (!__choose_path_in_pg(m, pg))
+                        if (!__choose_path_in_pg(m, pg, nr_bytes))
                                 return;
                 }
         } while (bypassed--);
@@ -322,19 +317,21 @@ static int __must_push_back(struct multipath *m)
                 dm_noflush_suspending(m->ti));
 }
 
-static int map_io(struct multipath *m, struct bio *bio,
+static int map_io(struct multipath *m, struct request *clone,
                   struct dm_mpath_io *mpio, unsigned was_queued)
 {
         int r = DM_MAPIO_REMAPPED;
+        size_t nr_bytes = blk_rq_bytes(clone);
         unsigned long flags;
         struct pgpath *pgpath;
+        struct block_device *bdev;
 
         spin_lock_irqsave(&m->lock, flags);
 
         /* Do we need to select a new pgpath? */
         if (!m->current_pgpath ||
             (!m->queue_io && (m->repeat_count && --m->repeat_count == 0)))
-                __choose_pgpath(m);
+                __choose_pgpath(m, nr_bytes);
 
         pgpath = m->current_pgpath;
 
@@ -344,21 +341,28 @@ static int map_io(struct multipath *m, struct bio *bio,
         if ((pgpath && m->queue_io) ||
             (!pgpath && m->queue_if_no_path)) {
                 /* Queue for the daemon to resubmit */
-                bio_list_add(&m->queued_ios, bio);
+                list_add_tail(&clone->queuelist, &m->queued_ios);
                 m->queue_size++;
                 if ((m->pg_init_required && !m->pg_init_in_progress) ||
                     !m->queue_io)
                         queue_work(kmultipathd, &m->process_queued_ios);
                 pgpath = NULL;
                 r = DM_MAPIO_SUBMITTED;
-        } else if (pgpath)
-                bio->bi_bdev = pgpath->path.dev->bdev;
-        else if (__must_push_back(m))
+        } else if (pgpath) {
+                bdev = pgpath->path.dev->bdev;
+                clone->q = bdev_get_queue(bdev);
+                clone->rq_disk = bdev->bd_disk;
+        } else if (__must_push_back(m))
                 r = DM_MAPIO_REQUEUE;
         else
                 r = -EIO;       /* Failed */
 
         mpio->pgpath = pgpath;
+        mpio->nr_bytes = nr_bytes;
+
+        if (r == DM_MAPIO_REMAPPED && pgpath->pg->ps.type->start_io)
+                pgpath->pg->ps.type->start_io(&pgpath->pg->ps, &pgpath->path,
+                                              nr_bytes);
 
         spin_unlock_irqrestore(&m->lock, flags);
 
@@ -396,30 +400,31 @@ static void dispatch_queued_ios(struct multipath *m)
 {
         int r;
         unsigned long flags;
-        struct bio *bio = NULL, *next;
         struct dm_mpath_io *mpio;
         union map_info *info;
+        struct request *clone, *n;
+        LIST_HEAD(cl);
 
         spin_lock_irqsave(&m->lock, flags);
-        bio = bio_list_get(&m->queued_ios);
+        list_splice_init(&m->queued_ios, &cl);
         spin_unlock_irqrestore(&m->lock, flags);
 
-        while (bio) {
-                next = bio->bi_next;
-                bio->bi_next = NULL;
+        list_for_each_entry_safe(clone, n, &cl, queuelist) {
+                list_del_init(&clone->queuelist);
 
-                info = dm_get_mapinfo(bio);
+                info = dm_get_rq_mapinfo(clone);
                 mpio = info->ptr;
 
-                r = map_io(m, bio, mpio, 1);
-                if (r < 0)
-                        bio_endio(bio, r);
-                else if (r == DM_MAPIO_REMAPPED)
-                        generic_make_request(bio);
-                else if (r == DM_MAPIO_REQUEUE)
-                        bio_endio(bio, -EIO);
-
-                bio = next;
+                r = map_io(m, clone, mpio, 1);
+                if (r < 0) {
+                        mempool_free(mpio, m->mpio_pool);
+                        dm_kill_unmapped_request(clone, r);
+                } else if (r == DM_MAPIO_REMAPPED)
+                        dm_dispatch_request(clone);
+                else if (r == DM_MAPIO_REQUEUE) {
+                        mempool_free(mpio, m->mpio_pool);
+                        dm_requeue_unmapped_request(clone);
+                }
         }
 }
 
@@ -427,8 +432,8 @@ static void process_queued_ios(struct work_struct *work)
 {
         struct multipath *m =
                 container_of(work, struct multipath, process_queued_ios);
-        struct pgpath *pgpath = NULL;
-        unsigned init_required = 0, must_queue = 1;
+        struct pgpath *pgpath = NULL, *tmp;
+        unsigned must_queue = 1;
         unsigned long flags;
 
         spin_lock_irqsave(&m->lock, flags);
@@ -437,7 +442,7 @@ static void process_queued_ios(struct work_struct *work)
                 goto out;
 
         if (!m->current_pgpath)
-                __choose_pgpath(m);
+                __choose_pgpath(m, 0);
 
         pgpath = m->current_pgpath;
 
@@ -446,19 +451,15 @@ static void process_queued_ios(struct work_struct *work)
                 must_queue = 0;
 
         if (m->pg_init_required && !m->pg_init_in_progress && pgpath) {
-                m->pgpath_to_activate = pgpath;
                 m->pg_init_count++;
                 m->pg_init_required = 0;
-                m->pg_init_in_progress = 1;
-                init_required = 1;
+                list_for_each_entry(tmp, &pgpath->pg->pgpaths, list) {
+                        if (queue_work(kmpath_handlerd, &tmp->activate_path))
+                                m->pg_init_in_progress++;
+                }
         }
-
 out:
         spin_unlock_irqrestore(&m->lock, flags);
-
-        if (init_required)
-                queue_work(kmpath_handlerd, &m->activate_path);
-
         if (!must_queue)
                 dispatch_queued_ios(m);
 }
@@ -553,6 +554,12 @@ static int parse_path_selector(struct arg_set *as, struct priority_group *pg,
                 return -EINVAL;
         }
 
+        if (ps_argc > as->argc) {
+                dm_put_path_selector(pst);
+                ti->error = "not enough arguments for path selector";
+                return -EINVAL;
+        }
+
         r = pst->create(&pg->ps, ps_argc, as->argv);
         if (r) {
                 dm_put_path_selector(pst);
@@ -591,9 +598,20 @@ static struct pgpath *parse_path(struct arg_set *as, struct path_selector *ps,
         }
 
         if (m->hw_handler_name) {
-                r = scsi_dh_attach(bdev_get_queue(p->path.dev->bdev),
-                                   m->hw_handler_name);
+                struct request_queue *q = bdev_get_queue(p->path.dev->bdev);
+
+                r = scsi_dh_attach(q, m->hw_handler_name);
+                if (r == -EBUSY) {
+                        /*
+                         * Already attached to different hw_handler,
+                         * try to reattach with correct one.
+                         */
+                        scsi_dh_detach(q);
+                        r = scsi_dh_attach(q, m->hw_handler_name);
+                }
+
                 if (r < 0) {
+                        ti->error = "error attaching hardware handler";
                         dm_put_device(ti, p->path.dev);
                         goto bad;
                 }
@@ -699,6 +717,11 @@ static int parse_hw_handler(struct arg_set *as, struct multipath *m)
         if (!hw_argc)
                 return 0;
 
+        if (hw_argc > as->argc) {
+                ti->error = "not enough arguments for hardware handler";
+                return -EINVAL;
+        }
+
         m->hw_handler_name = kstrdup(shift(as), GFP_KERNEL);
         request_module("scsi_dh_%s", m->hw_handler_name);
         if (scsi_dh_handler_exist(m->hw_handler_name) == 0) {
@@ -823,6 +846,8 @@ static int multipath_ctr(struct dm_target *ti, unsigned int argc,
                 goto bad;
         }
 
+        ti->num_flush_requests = 1;
+
         return 0;
 
  bad:
@@ -836,25 +861,29 @@ static void multipath_dtr(struct dm_target *ti)
 
         flush_workqueue(kmpath_handlerd);
         flush_workqueue(kmultipathd);
+        flush_scheduled_work();
         free_multipath(m);
 }
 
 /*
- * Map bios, recording original fields for later in case we have to resubmit
+ * Map cloned requests
  */
-static int multipath_map(struct dm_target *ti, struct bio *bio,
+static int multipath_map(struct dm_target *ti, struct request *clone,
                          union map_info *map_context)
 {
         int r;
         struct dm_mpath_io *mpio;
         struct multipath *m = (struct multipath *) ti->private;
 
-        mpio = mempool_alloc(m->mpio_pool, GFP_NOIO);
-        dm_bio_record(&mpio->details, bio);
+        mpio = mempool_alloc(m->mpio_pool, GFP_ATOMIC);
+        if (!mpio)
+                /* ENOMEM, requeue */
+                return DM_MAPIO_REQUEUE;
+        memset(mpio, 0, sizeof(*mpio));
 
         map_context->ptr = mpio;
-        bio->bi_rw |= (1 << BIO_RW_FAILFAST_TRANSPORT);
-        r = map_io(m, bio, mpio, 0);
+        clone->cmd_flags |= REQ_FAILFAST_TRANSPORT;
+        r = map_io(m, clone, mpio, 0);
         if (r < 0 || r == DM_MAPIO_REQUEUE)
                 mempool_free(mpio, m->mpio_pool);
 
@@ -924,9 +953,13 @@ static int reinstate_path(struct pgpath *pgpath)
 
         pgpath->is_active = 1;
 
-        m->current_pgpath = NULL;
-        if (!m->nr_valid_paths++ && m->queue_size)
+        if (!m->nr_valid_paths++ && m->queue_size) {
+                m->current_pgpath = NULL;
                 queue_work(kmultipathd, &m->process_queued_ios);
+        } else if (m->hw_handler_name && (m->current_pg == pgpath->pg)) {
+                if (queue_work(kmpath_handlerd, &pgpath->activate_path))
+                        m->pg_init_in_progress++;
+        }
 
         dm_path_uevent(DM_UEVENT_PATH_REINSTATED, m->ti,
                       pgpath->path.dev->name, m->nr_valid_paths);
@@ -1102,87 +1135,70 @@ static void pg_init_done(struct dm_path *path, int errors)
 
         spin_lock_irqsave(&m->lock, flags);
         if (errors) {
-                DMERR("Could not failover device. Error %d.", errors);
-                m->current_pgpath = NULL;
-                m->current_pg = NULL;
+                if (pgpath == m->current_pgpath) {
+                        DMERR("Could not failover device. Error %d.", errors);
+                        m->current_pgpath = NULL;
+                        m->current_pg = NULL;
+                }
         } else if (!m->pg_init_required) {
                 m->queue_io = 0;
                 pg->bypassed = 0;
         }
 
-        m->pg_init_in_progress = 0;
-        queue_work(kmultipathd, &m->process_queued_ios);
+        m->pg_init_in_progress--;
+        if (!m->pg_init_in_progress)
+                queue_work(kmultipathd, &m->process_queued_ios);
         spin_unlock_irqrestore(&m->lock, flags);
 }
 
 static void activate_path(struct work_struct *work)
 {
         int ret;
-        struct multipath *m =
-                container_of(work, struct multipath, activate_path);
-        struct dm_path *path;
-        unsigned long flags;
+        struct pgpath *pgpath =
+                container_of(work, struct pgpath, activate_path);
 
-        spin_lock_irqsave(&m->lock, flags);
-        path = &m->pgpath_to_activate->path;
-        m->pgpath_to_activate = NULL;
-        spin_unlock_irqrestore(&m->lock, flags);
-        if (!path)
-                return;
-        ret = scsi_dh_activate(bdev_get_queue(path->dev->bdev));
-        pg_init_done(path, ret);
+        ret = scsi_dh_activate(bdev_get_queue(pgpath->path.dev->bdev));
+        pg_init_done(&pgpath->path, ret);
 }
 
 /*
  * end_io handling
  */
-static int do_end_io(struct multipath *m, struct bio *bio,
+static int do_end_io(struct multipath *m, struct request *clone,
                      int error, struct dm_mpath_io *mpio)
 {
+        /*
+         * We don't queue any clone request inside the multipath target
+         * during end I/O handling, since those clone requests don't have
+         * bio clones.  If we queue them inside the multipath target,
+         * we need to make bio clones, that requires memory allocation.
+         * (See drivers/md/dm.c:end_clone_bio() about why the clone requests
+         *  don't have bio clones.)
+         * Instead of queueing the clone request here, we queue the original
+         * request into dm core, which will remake a clone request and
+         * clone bios for it and resubmit it later.
+         */
+        int r = DM_ENDIO_REQUEUE;
         unsigned long flags;
 
-        if (!error)
+        if (!error && !clone->errors)
                 return 0;       /* I/O complete */
 
-        if ((error == -EWOULDBLOCK) && bio_rw_ahead(bio))
-                return error;
-
         if (error == -EOPNOTSUPP)
                 return error;
 
-        spin_lock_irqsave(&m->lock, flags);
-        if (!m->nr_valid_paths) {
-                if (__must_push_back(m)) {
-                        spin_unlock_irqrestore(&m->lock, flags);
-                        return DM_ENDIO_REQUEUE;
-                } else if (!m->queue_if_no_path) {
-                        spin_unlock_irqrestore(&m->lock, flags);
-                        return -EIO;
-                } else {
-                        spin_unlock_irqrestore(&m->lock, flags);
-                        goto requeue;
-                }
-        }
-        spin_unlock_irqrestore(&m->lock, flags);
-
         if (mpio->pgpath)
                 fail_path(mpio->pgpath);
 
-      requeue:
-        dm_bio_restore(&mpio->details, bio);
-
-        /* queue for the daemon to resubmit or fail */
         spin_lock_irqsave(&m->lock, flags);
-        bio_list_add(&m->queued_ios, bio);
-        m->queue_size++;
-        if (!m->queue_io)
-                queue_work(kmultipathd, &m->process_queued_ios);
+        if (!m->nr_valid_paths && !m->queue_if_no_path && !__must_push_back(m))
+                r = -EIO;
         spin_unlock_irqrestore(&m->lock, flags);
 
-        return DM_ENDIO_INCOMPLETE;     /* io not complete */
+        return r;
 }
 
-static int multipath_end_io(struct dm_target *ti, struct bio *bio,
+static int multipath_end_io(struct dm_target *ti, struct request *clone,
                             int error, union map_info *map_context)
 {
         struct multipath *m = ti->private;
@@ -1191,14 +1207,13 @@ static int multipath_end_io(struct dm_target *ti, struct bio *bio,
         struct path_selector *ps;
         int r;
 
-        r  = do_end_io(m, bio, error, mpio);
+        r  = do_end_io(m, clone, error, mpio);
         if (pgpath) {
                 ps = &pgpath->pg->ps;
                 if (ps->type->end_io)
-                        ps->type->end_io(ps, &pgpath->path);
+                        ps->type->end_io(ps, &pgpath->path, mpio->nr_bytes);
         }
-        if (r != DM_ENDIO_INCOMPLETE)
-                mempool_free(mpio, m->mpio_pool);
+        mempool_free(mpio, m->mpio_pool);
 
         return r;
 }
@@ -1411,7 +1426,7 @@ static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
         spin_lock_irqsave(&m->lock, flags);
 
         if (!m->current_pgpath)
-                __choose_pgpath(m);
+                __choose_pgpath(m, 0);
 
         if (m->current_pgpath) {
                 bdev = m->current_pgpath->path.dev->bdev;
@@ -1428,22 +1443,113 @@ static int multipath_ioctl(struct dm_target *ti, unsigned int cmd,
         return r ? : __blkdev_driver_ioctl(bdev, mode, cmd, arg);
 }
 
+static int multipath_iterate_devices(struct dm_target *ti,
+                                     iterate_devices_callout_fn fn, void *data)
+{
+        struct multipath *m = ti->private;
+        struct priority_group *pg;
+        struct pgpath *p;
+        int ret = 0;
+
+        list_for_each_entry(pg, &m->priority_groups, list) {
+                list_for_each_entry(p, &pg->pgpaths, list) {
+                        ret = fn(ti, p->path.dev, ti->begin, data);
+                        if (ret)
+                                goto out;
+                }
+        }
+
+out:
+        return ret;
+}
+
+static int __pgpath_busy(struct pgpath *pgpath)
+{
+        struct request_queue *q = bdev_get_queue(pgpath->path.dev->bdev);
+
+        return dm_underlying_device_busy(q);
+}
+
+/*
+ * We return "busy", only when we can map I/Os but underlying devices
+ * are busy (so even if we map I/Os now, the I/Os will wait on
+ * the underlying queue).
+ * In other words, if we want to kill I/Os or queue them inside us
+ * due to map unavailability, we don't return "busy".  Otherwise,
+ * dm core won't give us the I/Os and we can't do what we want.
+ */
+static int multipath_busy(struct dm_target *ti)
+{
+        int busy = 0, has_active = 0;
+        struct multipath *m = ti->private;
+        struct priority_group *pg;
+        struct pgpath *pgpath;
+        unsigned long flags;
+
+        spin_lock_irqsave(&m->lock, flags);
+
+        /* Guess which priority_group will be used at next mapping time */
+        if (unlikely(!m->current_pgpath && m->next_pg))
+                pg = m->next_pg;
+        else if (likely(m->current_pg))
+                pg = m->current_pg;
+        else
+                /*
+                 * We don't know which pg will be used at next mapping time.
+                 * We don't call __choose_pgpath() here to avoid to trigger
+                 * pg_init just by busy checking.
+                 * So we don't know whether underlying devices we will be using
+                 * at next mapping time are busy or not. Just try mapping.
+                 */
+                goto out;
+
+        /*
+         * If there is one non-busy active path at least, the path selector
+         * will be able to select it. So we consider such a pg as not busy.
+         */
+        busy = 1;
+        list_for_each_entry(pgpath, &pg->pgpaths, list)
+                if (pgpath->is_active) {
+                        has_active = 1;
+
+                        if (!__pgpath_busy(pgpath)) {
+                                busy = 0;
+                                break;
+                        }
+                }
+
+        if (!has_active)
+                /*
+                 * No active path in this pg, so this pg won't be used and
+                 * the current_pg will be changed at next mapping time.
+                 * We need to try mapping to determine it.
+                 */
+                busy = 0;
+
+out:
+        spin_unlock_irqrestore(&m->lock, flags);
+
+        return busy;
+}
+
 /*-----------------------------------------------------------------
  * Module setup
  *---------------------------------------------------------------*/
 static struct target_type multipath_target = {
         .name = "multipath",
-        .version = {1, 0, 5},
+        .version = {1, 1, 0},
         .module = THIS_MODULE,
         .ctr = multipath_ctr,
         .dtr = multipath_dtr,
-        .map = multipath_map,
-        .end_io = multipath_end_io,
+        .map_rq = multipath_map,
+        .rq_end_io = multipath_end_io,
         .presuspend = multipath_presuspend,
         .resume = multipath_resume,
         .status = multipath_status,
         .message = multipath_message,
         .ioctl  = multipath_ioctl,
+        .iterate_devices = multipath_iterate_devices,
+        .busy = multipath_busy,
 };
 
 static int __init dm_multipath_init(void)
diff --git a/drivers/md/dm-path-selector.h b/drivers/md/dm-path-selector.h
index 27357b85d73d..e7d1fa8b0459 100644
--- a/drivers/md/dm-path-selector.h
+++ b/drivers/md/dm-path-selector.h
@@ -56,7 +56,8 @@ struct path_selector_type {
          * the path fails.
          */
         struct dm_path *(*select_path) (struct path_selector *ps,
-                                     unsigned *repeat_count);
+                                        unsigned *repeat_count,
+                                        size_t nr_bytes);
 
         /*
          * Notify the selector that a path has failed.
@@ -75,7 +76,10 @@ struct path_selector_type {
         int (*status) (struct path_selector *ps, struct dm_path *path,
                        status_type_t type, char *result, unsigned int maxlen);
 
-        int (*end_io) (struct path_selector *ps, struct dm_path *path);
+        int (*start_io) (struct path_selector *ps, struct dm_path *path,
+                         size_t nr_bytes);
+        int (*end_io) (struct path_selector *ps, struct dm_path *path,
+                       size_t nr_bytes);
 };
 
 /* Register a path selector */
diff --git a/drivers/md/dm-queue-length.c b/drivers/md/dm-queue-length.c
new file mode 100644
index 000000000000..f92b6cea9d9c
--- /dev/null
+++ b/drivers/md/dm-queue-length.c
@@ -0,0 +1,263 @@
+/*
+ * Copyright (C) 2004-2005 IBM Corp.  All Rights Reserved.
+ * Copyright (C) 2006-2009 NEC Corporation.
+ *
+ * dm-queue-length.c
+ *
+ * Module Author: Stefan Bader, IBM
+ * Modified by: Kiyoshi Ueda, NEC
+ *
+ * This file is released under the GPL.
+ *
+ * queue-length path selector - choose a path with the least number of
+ * in-flight I/Os.
+ */
+
+#include "dm.h"
+#include "dm-path-selector.h"
+
+#include <linux/slab.h>
+#include <linux/ctype.h>
+#include <linux/errno.h>
+#include <linux/module.h>
+#include <asm/atomic.h>
+
+#define DM_MSG_PREFIX   "multipath queue-length"
+#define QL_MIN_IO       128
+#define QL_VERSION      "0.1.0"
+
+struct selector {
+        struct list_head        valid_paths;
+        struct list_head        failed_paths;
+};
+
+struct path_info {
+        struct list_head        list;
+        struct dm_path          *path;
+        unsigned                repeat_count;
+        atomic_t                qlen;   /* the number of in-flight I/Os */
+};
+
+static struct selector *alloc_selector(void)
+{
+        struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
+
+        if (s) {
+                INIT_LIST_HEAD(&s->valid_paths);
+                INIT_LIST_HEAD(&s->failed_paths);
+        }
+
+        return s;
+}
+
+static int ql_create(struct path_selector *ps, unsigned argc, char **argv)
+{
+        struct selector *s = alloc_selector();
+
+        if (!s)
+                return -ENOMEM;
+
+        ps->context = s;
+        return 0;
+}
+
+static void ql_free_paths(struct list_head *paths)
+{
+        struct path_info *pi, *next;
+
+        list_for_each_entry_safe(pi, next, paths, list) {
+                list_del(&pi->list);
+                kfree(pi);
+        }
+}
+
+static void ql_destroy(struct path_selector *ps)
+{
+        struct selector *s = ps->context;
+
+        ql_free_paths(&s->valid_paths);
+        ql_free_paths(&s->failed_paths);
+        kfree(s);
+        ps->context = NULL;
+}
+
+static int ql_status(struct path_selector *ps, struct dm_path *path,
+                     status_type_t type, char *result, unsigned maxlen)
+{
+        unsigned sz = 0;
+        struct path_info *pi;
+
+        /* When called with NULL path, return selector status/args. */
+        if (!path)
+                DMEMIT("0 ");
+        else {
+                pi = path->pscontext;
+
+                switch (type) {
+                case STATUSTYPE_INFO:
+                        DMEMIT("%d ", atomic_read(&pi->qlen));
+                        break;
+                case STATUSTYPE_TABLE:
+                        DMEMIT("%u ", pi->repeat_count);
+                        break;
+                }
+        }
+
+        return sz;
+}
+
+static int ql_add_path(struct path_selector *ps, struct dm_path *path,
+                       int argc, char **argv, char **error)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi;
+        unsigned repeat_count = QL_MIN_IO;
+
+        /*
+         * Arguments: [<repeat_count>]
+         *      <repeat_count>: The number of I/Os before switching path.
+         *                      If not given, default (QL_MIN_IO) is used.
+         */
+        if (argc > 1) {
+                *error = "queue-length ps: incorrect number of arguments";
+                return -EINVAL;
+        }
+
+        if ((argc == 1) && (sscanf(argv[0], "%u", &repeat_count) != 1)) {
+                *error = "queue-length ps: invalid repeat count";
+                return -EINVAL;
+        }
+
+        /* Allocate the path information structure */
+        pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+        if (!pi) {
+                *error = "queue-length ps: Error allocating path information";
+                return -ENOMEM;
+        }
+
+        pi->path = path;
+        pi->repeat_count = repeat_count;
+        atomic_set(&pi->qlen, 0);
+
+        path->pscontext = pi;
+
+        list_add_tail(&pi->list, &s->valid_paths);
+
+        return 0;
+}
+
+static void ql_fail_path(struct path_selector *ps, struct dm_path *path)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi = path->pscontext;
+
+        list_move(&pi->list, &s->failed_paths);
+}
+
+static int ql_reinstate_path(struct path_selector *ps, struct dm_path *path)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi = path->pscontext;
+
+        list_move_tail(&pi->list, &s->valid_paths);
+
+        return 0;
+}
+
+/*
+ * Select a path having the minimum number of in-flight I/Os
+ */
+static struct dm_path *ql_select_path(struct path_selector *ps,
+                                      unsigned *repeat_count, size_t nr_bytes)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi = NULL, *best = NULL;
+
+        if (list_empty(&s->valid_paths))
+                return NULL;
+
+        /* Change preferred (first in list) path to evenly balance. */
+        list_move_tail(s->valid_paths.next, &s->valid_paths);
+
+        list_for_each_entry(pi, &s->valid_paths, list) {
+                if (!best ||
+                    (atomic_read(&pi->qlen) < atomic_read(&best->qlen)))
+                        best = pi;
+
+                if (!atomic_read(&best->qlen))
+                        break;
+        }
+
+        if (!best)
+                return NULL;
+
+        *repeat_count = best->repeat_count;
+
+        return best->path;
+}
+
+static int ql_start_io(struct path_selector *ps, struct dm_path *path,
+                       size_t nr_bytes)
+{
+        struct path_info *pi = path->pscontext;
+
+        atomic_inc(&pi->qlen);
+
+        return 0;
+}
+
+static int ql_end_io(struct path_selector *ps, struct dm_path *path,
+                     size_t nr_bytes)
+{
+        struct path_info *pi = path->pscontext;
+
+        atomic_dec(&pi->qlen);
+
+        return 0;
+}
+
+static struct path_selector_type ql_ps = {
+        .name           = "queue-length",
+        .module         = THIS_MODULE,
+        .table_args     = 1,
+        .info_args      = 1,
+        .create         = ql_create,
+        .destroy        = ql_destroy,
+        .status         = ql_status,
+        .add_path       = ql_add_path,
+        .fail_path      = ql_fail_path,
+        .reinstate_path = ql_reinstate_path,
+        .select_path    = ql_select_path,
+        .start_io       = ql_start_io,
+        .end_io         = ql_end_io,
+};
+
+static int __init dm_ql_init(void)
+{
+        int r = dm_register_path_selector(&ql_ps);
+
+        if (r < 0)
+                DMERR("register failed %d", r);
+
+        DMINFO("version " QL_VERSION " loaded");
+
+        return r;
+}
+
+static void __exit dm_ql_exit(void)
+{
+        int r = dm_unregister_path_selector(&ql_ps);
+
+        if (r < 0)
+                DMERR("unregister failed %d", r);
+}
+
+module_init(dm_ql_init);
+module_exit(dm_ql_exit);
+
+MODULE_AUTHOR("Stefan Bader <Stefan.Bader at de.ibm.com>");
+MODULE_DESCRIPTION(
+        "(C) Copyright IBM Corp. 2004,2005   All Rights Reserved.\n"
+        DM_NAME " path selector to balance the number of in-flight I/Os"
+);
+MODULE_LICENSE("GPL");
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 076fbb4e967a..ce8868c768cc 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -1283,9 +1283,23 @@ static int mirror_status(struct dm_target *ti, status_type_t type,
         return 0;
 }
 
+static int mirror_iterate_devices(struct dm_target *ti,
+                                  iterate_devices_callout_fn fn, void *data)
+{
+        struct mirror_set *ms = ti->private;
+        int ret = 0;
+        unsigned i;
+
+        for (i = 0; !ret && i < ms->nr_mirrors; i++)
+                ret = fn(ti, ms->mirror[i].dev,
+                         ms->mirror[i].offset, data);
+
+        return ret;
+}
+
 static struct target_type mirror_target = {
         .name    = "mirror",
-        .version = {1, 0, 20},
+        .version = {1, 12, 0},
         .module  = THIS_MODULE,
         .ctr     = mirror_ctr,
         .dtr     = mirror_dtr,
@@ -1295,6 +1309,7 @@ static struct target_type mirror_target = {
         .postsuspend = mirror_postsuspend,
         .resume  = mirror_resume,
         .status  = mirror_status,
+        .iterate_devices = mirror_iterate_devices,
 };
 
 static int __init dm_mirror_init(void)
diff --git a/drivers/md/dm-region-hash.c b/drivers/md/dm-region-hash.c
index 7b899be0b087..36dbe29f2fd6 100644
--- a/drivers/md/dm-region-hash.c
+++ b/drivers/md/dm-region-hash.c
@@ -283,7 +283,7 @@ static struct dm_region *__rh_alloc(struct dm_region_hash *rh, region_t region)
 
         nreg = mempool_alloc(rh->region_pool, GFP_ATOMIC);
         if (unlikely(!nreg))
-                nreg = kmalloc(sizeof(*nreg), GFP_NOIO);
+                nreg = kmalloc(sizeof(*nreg), GFP_NOIO | __GFP_NOFAIL);
 
         nreg->state = rh->log->type->in_sync(rh->log, region, 1) ?
                       DM_RH_CLEAN : DM_RH_NOSYNC;
diff --git a/drivers/md/dm-round-robin.c b/drivers/md/dm-round-robin.c
index cdfbf65b28cb..24752f449bef 100644
--- a/drivers/md/dm-round-robin.c
+++ b/drivers/md/dm-round-robin.c
@@ -161,7 +161,7 @@ static int rr_reinstate_path(struct path_selector *ps, struct dm_path *p)
 }
 
 static struct dm_path *rr_select_path(struct path_selector *ps,
-                                   unsigned *repeat_count)
+                                      unsigned *repeat_count, size_t nr_bytes)
 {
         struct selector *s = (struct selector *) ps->context;
         struct path_info *pi = NULL;
diff --git a/drivers/md/dm-service-time.c b/drivers/md/dm-service-time.c
new file mode 100644
index 000000000000..cfa668f46c40
--- /dev/null
+++ b/drivers/md/dm-service-time.c
@@ -0,0 +1,339 @@
+/*
+ * Copyright (C) 2007-2009 NEC Corporation.  All Rights Reserved.
+ *
+ * Module Author: Kiyoshi Ueda
+ *
+ * This file is released under the GPL.
+ *
+ * Throughput oriented path selector.
+ */
+
+#include "dm.h"
+#include "dm-path-selector.h"
+
+#define DM_MSG_PREFIX   "multipath service-time"
+#define ST_MIN_IO       1
+#define ST_MAX_RELATIVE_THROUGHPUT      100
+#define ST_MAX_RELATIVE_THROUGHPUT_SHIFT        7
+#define ST_MAX_INFLIGHT_SIZE    ((size_t)-1 >> ST_MAX_RELATIVE_THROUGHPUT_SHIFT)
+#define ST_VERSION      "0.2.0"
+
+struct selector {
+        struct list_head valid_paths;
+        struct list_head failed_paths;
+};
+
+struct path_info {
+        struct list_head list;
+        struct dm_path *path;
+        unsigned repeat_count;
+        unsigned relative_throughput;
+        atomic_t in_flight_size;        /* Total size of in-flight I/Os */
+};
+
+static struct selector *alloc_selector(void)
+{
+        struct selector *s = kmalloc(sizeof(*s), GFP_KERNEL);
+
+        if (s) {
+                INIT_LIST_HEAD(&s->valid_paths);
+                INIT_LIST_HEAD(&s->failed_paths);
+        }
+
+        return s;
+}
+
+static int st_create(struct path_selector *ps, unsigned argc, char **argv)
+{
+        struct selector *s = alloc_selector();
+
+        if (!s)
+                return -ENOMEM;
+
+        ps->context = s;
+        return 0;
+}
+
+static void free_paths(struct list_head *paths)
+{
+        struct path_info *pi, *next;
+
+        list_for_each_entry_safe(pi, next, paths, list) {
+                list_del(&pi->list);
+                kfree(pi);
+        }
+}
+
+static void st_destroy(struct path_selector *ps)
+{
+        struct selector *s = ps->context;
+
+        free_paths(&s->valid_paths);
+        free_paths(&s->failed_paths);
+        kfree(s);
+        ps->context = NULL;
+}
+
+static int st_status(struct path_selector *ps, struct dm_path *path,
+                     status_type_t type, char *result, unsigned maxlen)
+{
+        unsigned sz = 0;
+        struct path_info *pi;
+
+        if (!path)
+                DMEMIT("0 ");
+        else {
+                pi = path->pscontext;
+
+                switch (type) {
+                case STATUSTYPE_INFO:
+                        DMEMIT("%d %u ", atomic_read(&pi->in_flight_size),
+                               pi->relative_throughput);
+                        break;
+                case STATUSTYPE_TABLE:
+                        DMEMIT("%u %u ", pi->repeat_count,
+                               pi->relative_throughput);
+                        break;
+                }
+        }
+
+        return sz;
+}
+
+static int st_add_path(struct path_selector *ps, struct dm_path *path,
+                       int argc, char **argv, char **error)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi;
+        unsigned repeat_count = ST_MIN_IO;
+        unsigned relative_throughput = 1;
+
+        /*
+         * Arguments: [<repeat_count> [<relative_throughput>]]
+         *      <repeat_count>: The number of I/Os before switching path.
+         *                      If not given, default (ST_MIN_IO) is used.
+         *      <relative_throughput>: The relative throughput value of
+         *                      the path among all paths in the path-group.
+         *                      The valid range: 0-<ST_MAX_RELATIVE_THROUGHPUT>
+         *                      If not given, minimum value '1' is used.
+         *                      If '0' is given, the path isn't selected while
+         *                      other paths having a positive value are
+         *                      available.
+         */
+        if (argc > 2) {
+                *error = "service-time ps: incorrect number of arguments";
+                return -EINVAL;
+        }
+
+        if (argc && (sscanf(argv[0], "%u", &repeat_count) != 1)) {
+                *error = "service-time ps: invalid repeat count";
+                return -EINVAL;
+        }
+
+        if ((argc == 2) &&
+            (sscanf(argv[1], "%u", &relative_throughput) != 1 ||
+             relative_throughput > ST_MAX_RELATIVE_THROUGHPUT)) {
+                *error = "service-time ps: invalid relative_throughput value";
+                return -EINVAL;
+        }
+
+        /* allocate the path */
+        pi = kmalloc(sizeof(*pi), GFP_KERNEL);
+        if (!pi) {
+                *error = "service-time ps: Error allocating path context";
+                return -ENOMEM;
+        }
+
+        pi->path = path;
+        pi->repeat_count = repeat_count;
+        pi->relative_throughput = relative_throughput;
+        atomic_set(&pi->in_flight_size, 0);
+
+        path->pscontext = pi;
+
+        list_add_tail(&pi->list, &s->valid_paths);
+
+        return 0;
+}
+
+static void st_fail_path(struct path_selector *ps, struct dm_path *path)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi = path->pscontext;
+
+        list_move(&pi->list, &s->failed_paths);
+}
+
+static int st_reinstate_path(struct path_selector *ps, struct dm_path *path)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi = path->pscontext;
+
+        list_move_tail(&pi->list, &s->valid_paths);
+
+        return 0;
+}
+
+/*
+ * Compare the estimated service time of 2 paths, pi1 and pi2,
+ * for the incoming I/O.
+ *
+ * Returns:
+ * < 0 : pi1 is better
+ * 0   : no difference between pi1 and pi2
+ * > 0 : pi2 is better
+ *
+ * Description:
+ * Basically, the service time is estimated by:
+ *     ('pi->in-flight-size' + 'incoming') / 'pi->relative_throughput'
+ * To reduce the calculation, some optimizations are made.
+ * (See comments inline)
+ */
+static int st_compare_load(struct path_info *pi1, struct path_info *pi2,
+                           size_t incoming)
+{
+        size_t sz1, sz2, st1, st2;
+
+        sz1 = atomic_read(&pi1->in_flight_size);
+        sz2 = atomic_read(&pi2->in_flight_size);
+
+        /*
+         * Case 1: Both have same throughput value. Choose less loaded path.
+         */
+        if (pi1->relative_throughput == pi2->relative_throughput)
+                return sz1 - sz2;
+
+        /*
+         * Case 2a: Both have same load. Choose higher throughput path.
+         * Case 2b: One path has no throughput value. Choose the other one.
+         */
+        if (sz1 == sz2 ||
+            !pi1->relative_throughput || !pi2->relative_throughput)
+                return pi2->relative_throughput - pi1->relative_throughput;
+
+        /*
+         * Case 3: Calculate service time. Choose faster path.
+         *         Service time using pi1:
+         *             st1 = (sz1 + incoming) / pi1->relative_throughput
+         *         Service time using pi2:
+         *             st2 = (sz2 + incoming) / pi2->relative_throughput
+         *
+         *         To avoid the division, transform the expression to use
+         *         multiplication.
+         *         Because ->relative_throughput > 0 here, if st1 < st2,
+         *         the expressions below are the same meaning:
+         *             (sz1 + incoming) / pi1->relative_throughput <
+         *                 (sz2 + incoming) / pi2->relative_throughput
+         *             (sz1 + incoming) * pi2->relative_throughput <
+         *                 (sz2 + incoming) * pi1->relative_throughput
+         *         So use the later one.
+         */
+        sz1 += incoming;
+        sz2 += incoming;
+        if (unlikely(sz1 >= ST_MAX_INFLIGHT_SIZE ||
+                     sz2 >= ST_MAX_INFLIGHT_SIZE)) {
+                /*
+                 * Size may be too big for multiplying pi->relative_throughput
+                 * and overflow.
+                 * To avoid the overflow and mis-selection, shift down both.
+                 */
+                sz1 >>= ST_MAX_RELATIVE_THROUGHPUT_SHIFT;
+                sz2 >>= ST_MAX_RELATIVE_THROUGHPUT_SHIFT;
+        }
+        st1 = sz1 * pi2->relative_throughput;
+        st2 = sz2 * pi1->relative_throughput;
+        if (st1 != st2)
+                return st1 - st2;
+
+        /*
+         * Case 4: Service time is equal. Choose higher throughput path.
+         */
+        return pi2->relative_throughput - pi1->relative_throughput;
+}
+
+static struct dm_path *st_select_path(struct path_selector *ps,
+                                      unsigned *repeat_count, size_t nr_bytes)
+{
+        struct selector *s = ps->context;
+        struct path_info *pi = NULL, *best = NULL;
+
+        if (list_empty(&s->valid_paths))
+                return NULL;
+
+        /* Change preferred (first in list) path to evenly balance. */
+        list_move_tail(s->valid_paths.next, &s->valid_paths);
+
+        list_for_each_entry(pi, &s->valid_paths, list)
+                if (!best || (st_compare_load(pi, best, nr_bytes) < 0))
+                        best = pi;
+
+        if (!best)
+                return NULL;
+
+        *repeat_count = best->repeat_count;
+
+        return best->path;
+}
+
+static int st_start_io(struct path_selector *ps, struct dm_path *path,
+                       size_t nr_bytes)
+{
+        struct path_info *pi = path->pscontext;
+
+        atomic_add(nr_bytes, &pi->in_flight_size);
+
+        return 0;
+}
+
+static int st_end_io(struct path_selector *ps, struct dm_path *path,
+                     size_t nr_bytes)
+{
+        struct path_info *pi = path->pscontext;
+
+        atomic_sub(nr_bytes, &pi->in_flight_size);
+
+        return 0;
+}
+
+static struct path_selector_type st_ps = {
+        .name           = "service-time",
+        .module         = THIS_MODULE,
+        .table_args     = 2,
+        .info_args      = 2,
+        .create         = st_create,
+        .destroy        = st_destroy,
+        .status         = st_status,
+        .add_path       = st_add_path,
+        .fail_path      = st_fail_path,
+        .reinstate_path = st_reinstate_path,
+        .select_path    = st_select_path,
+        .start_io       = st_start_io,
+        .end_io         = st_end_io,
+};
+
+static int __init dm_st_init(void)
+{
+        int r = dm_register_path_selector(&st_ps);
+
+        if (r < 0)
+                DMERR("register failed %d", r);
+
+        DMINFO("version " ST_VERSION " loaded");
+
+        return r;
+}
+
+static void __exit dm_st_exit(void)
+{
+        int r = dm_unregister_path_selector(&st_ps);
+
+        if (r < 0)
+                DMERR("unregister failed %d", r);
+}
+
+module_init(dm_st_init);
+module_exit(dm_st_exit);
+
+MODULE_DESCRIPTION(DM_NAME " throughput oriented path selector");
+MODULE_AUTHOR("Kiyoshi Ueda <k-ueda@ct.jp.nec.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 2662a41337e7..6e3fe4f14934 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -636,7 +636,7 @@ static void persistent_commit_exception(struct dm_exception_store *store,
         /*
          * Commit exceptions to disk.
          */
-        if (ps->valid && area_io(ps, WRITE))
+        if (ps->valid && area_io(ps, WRITE_BARRIER))
                 ps->valid = 0;
 
         /*
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index d73f17fc7778..d573165cd2b7 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -678,6 +678,7 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
 
         ti->private = s;
         ti->split_io = s->store->chunk_size;
+        ti->num_flush_requests = 1;
 
         return 0;
 
@@ -1030,6 +1031,11 @@ static int snapshot_map(struct dm_target *ti, struct bio *bio,
         chunk_t chunk;
         struct dm_snap_pending_exception *pe = NULL;
 
+        if (unlikely(bio_empty_barrier(bio))) {
+                bio->bi_bdev = s->store->cow->bdev;
+                return DM_MAPIO_REMAPPED;
+        }
+
         chunk = sector_to_chunk(s->store, bio->bi_sector);
 
         /* Full snapshots are not usable */
@@ -1338,6 +1344,8 @@ static int origin_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         }
 
         ti->private = dev;
+        ti->num_flush_requests = 1;
+
         return 0;
 }
 
@@ -1353,6 +1361,9 @@ static int origin_map(struct dm_target *ti, struct bio *bio,
         struct dm_dev *dev = ti->private;
         bio->bi_bdev = dev->bdev;
 
+        if (unlikely(bio_empty_barrier(bio)))
+                return DM_MAPIO_REMAPPED;
+
         /* Only tell snapshots if this is a write */
         return (bio_rw(bio) == WRITE) ? do_origin(dev, bio) : DM_MAPIO_REMAPPED;
 }
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index 41569bc60abc..b240e85ae39a 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -167,6 +167,7 @@ static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         sc->stripes = stripes;
         sc->stripe_width = width;
         ti->split_io = chunk_size;
+        ti->num_flush_requests = stripes;
 
         sc->chunk_mask = ((sector_t) chunk_size) - 1;
         for (sc->chunk_shift = 0; chunk_size; sc->chunk_shift++)
@@ -211,10 +212,18 @@ static int stripe_map(struct dm_target *ti, struct bio *bio,
                       union map_info *map_context)
 {
         struct stripe_c *sc = (struct stripe_c *) ti->private;
+        sector_t offset, chunk;
+        uint32_t stripe;
 
-        sector_t offset = bio->bi_sector - ti->begin;
-        sector_t chunk = offset >> sc->chunk_shift;
-        uint32_t stripe = sector_div(chunk, sc->stripes);
+        if (unlikely(bio_empty_barrier(bio))) {
+                BUG_ON(map_context->flush_request >= sc->stripes);
+                bio->bi_bdev = sc->stripe[map_context->flush_request].dev->bdev;
+                return DM_MAPIO_REMAPPED;
+        }
+
+        offset = bio->bi_sector - ti->begin;
+        chunk = offset >> sc->chunk_shift;
+        stripe = sector_div(chunk, sc->stripes);
 
         bio->bi_bdev = sc->stripe[stripe].dev->bdev;
         bio->bi_sector = sc->stripe[stripe].physical_start +
@@ -304,15 +313,31 @@ static int stripe_end_io(struct dm_target *ti, struct bio *bio,
         return error;
 }
 
+static int stripe_iterate_devices(struct dm_target *ti,
+                                  iterate_devices_callout_fn fn, void *data)
+{
+        struct stripe_c *sc = ti->private;
+        int ret = 0;
+        unsigned i = 0;
+
+        do
+                ret = fn(ti, sc->stripe[i].dev,
+                         sc->stripe[i].physical_start, data);
+        while (!ret && ++i < sc->stripes);
+
+        return ret;
+}
+
 static struct target_type stripe_target = {
         .name   = "striped",
-        .version = {1, 1, 0},
+        .version = {1, 2, 0},
         .module = THIS_MODULE,
         .ctr    = stripe_ctr,
         .dtr    = stripe_dtr,
         .map    = stripe_map,
         .end_io = stripe_end_io,
         .status = stripe_status,
+        .iterate_devices = stripe_iterate_devices,
 };
 
 int __init dm_stripe_init(void)
diff --git a/drivers/md/dm-sysfs.c b/drivers/md/dm-sysfs.c
index a2a45e6c7c8b..4b045903a4e2 100644
--- a/drivers/md/dm-sysfs.c
+++ b/drivers/md/dm-sysfs.c
@@ -57,12 +57,21 @@ static ssize_t dm_attr_uuid_show(struct mapped_device *md, char *buf)
         return strlen(buf);
 }
 
+static ssize_t dm_attr_suspended_show(struct mapped_device *md, char *buf)
+{
+        sprintf(buf, "%d\n", dm_suspended(md));
+
+        return strlen(buf);
+}
+
 static DM_ATTR_RO(name);
 static DM_ATTR_RO(uuid);
+static DM_ATTR_RO(suspended);
 
 static struct attribute *dm_attrs[] = {
         &dm_attr_name.attr,
         &dm_attr_uuid.attr,
+        &dm_attr_suspended.attr,
         NULL,
 };
 
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index e9a73bb242b0..4899ebe767c8 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -41,6 +41,7 @@
 struct dm_table {
         struct mapped_device *md;
         atomic_t holders;
+        unsigned type;
 
         /* btree table */
         unsigned int depth;
@@ -62,15 +63,11 @@ struct dm_table {
         /* a list of devices used by this table */
         struct list_head devices;
 
-        /*
-         * These are optimistic limits taken from all the
-         * targets, some targets will need smaller limits.
-         */
-        struct io_restrictions limits;
-
         /* events get handed up using this callback */
         void (*event_fn)(void *);
         void *event_context;
+
+        struct dm_md_mempools *mempools;
 };
 
 /*
@@ -89,43 +86,6 @@ static unsigned int int_log(unsigned int n, unsigned int base)
 }
 
 /*
- * Returns the minimum that is _not_ zero, unless both are zero.
- */
-#define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
-
-/*
- * Combine two io_restrictions, always taking the lower value.
- */
-static void combine_restrictions_low(struct io_restrictions *lhs,
-                                     struct io_restrictions *rhs)
-{
-        lhs->max_sectors =
-                min_not_zero(lhs->max_sectors, rhs->max_sectors);
-
-        lhs->max_phys_segments =
-                min_not_zero(lhs->max_phys_segments, rhs->max_phys_segments);
-
-        lhs->max_hw_segments =
-                min_not_zero(lhs->max_hw_segments, rhs->max_hw_segments);
-
-        lhs->logical_block_size = max(lhs->logical_block_size,
-                                      rhs->logical_block_size);
-
-        lhs->max_segment_size =
-                min_not_zero(lhs->max_segment_size, rhs->max_segment_size);
-
-        lhs->max_hw_sectors =
-                min_not_zero(lhs->max_hw_sectors, rhs->max_hw_sectors);
-
-        lhs->seg_boundary_mask =
-                min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask);
-
-        lhs->bounce_pfn = min_not_zero(lhs->bounce_pfn, rhs->bounce_pfn);
-
-        lhs->no_cluster |= rhs->no_cluster;
-}
-
-/*
  * Calculate the index of the child node of the n'th node k'th key.
  */
 static inline unsigned int get_child(unsigned int n, unsigned int k)
@@ -267,6 +227,8 @@ static void free_devices(struct list_head *devices)
         list_for_each_safe(tmp, next, devices) {
                 struct dm_dev_internal *dd =
                     list_entry(tmp, struct dm_dev_internal, list);
+                DMWARN("dm_table_destroy: dm_put_device call missing for %s",
+                       dd->dm_dev.name);
                 kfree(dd);
         }
 }
@@ -296,12 +258,10 @@ void dm_table_destroy(struct dm_table *t)
         vfree(t->highs);
 
         /* free the device list */
-        if (t->devices.next != &t->devices) {
-                DMWARN("devices still present during destroy: "
-                       "dm_table_remove_device calls missing");
-
+        if (t->devices.next != &t->devices)
                 free_devices(&t->devices);
-        }
+
+        dm_free_md_mempools(t->mempools);
 
         kfree(t);
 }
@@ -385,15 +345,48 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
 /*
  * If possible, this checks an area of a destination device is valid.
  */
-static int check_device_area(struct dm_dev_internal *dd, sector_t start,
-                             sector_t len)
+static int device_area_is_valid(struct dm_target *ti, struct dm_dev *dev,
+                                sector_t start, void *data)
 {
-        sector_t dev_size = dd->dm_dev.bdev->bd_inode->i_size >> SECTOR_SHIFT;
+        struct queue_limits *limits = data;
+        struct block_device *bdev = dev->bdev;
+        sector_t dev_size =
+                i_size_read(bdev->bd_inode) >> SECTOR_SHIFT;
+        unsigned short logical_block_size_sectors =
+                limits->logical_block_size >> SECTOR_SHIFT;
+        char b[BDEVNAME_SIZE];
 
         if (!dev_size)
                 return 1;
 
-        return ((start < dev_size) && (len <= (dev_size - start)));
+        if ((start >= dev_size) || (start + ti->len > dev_size)) {
+                DMWARN("%s: %s too small for target",
+                       dm_device_name(ti->table->md), bdevname(bdev, b));
+                return 0;
+        }
+
+        if (logical_block_size_sectors <= 1)
+                return 1;
+
+        if (start & (logical_block_size_sectors - 1)) {
+                DMWARN("%s: start=%llu not aligned to h/w "
+                       "logical block size %hu of %s",
+                       dm_device_name(ti->table->md),
+                       (unsigned long long)start,
+                       limits->logical_block_size, bdevname(bdev, b));
+                return 0;
+        }
+
+        if (ti->len & (logical_block_size_sectors - 1)) {
+                DMWARN("%s: len=%llu not aligned to h/w "
+                       "logical block size %hu of %s",
+                       dm_device_name(ti->table->md),
+                       (unsigned long long)ti->len,
+                       limits->logical_block_size, bdevname(bdev, b));
+                return 0;
+        }
+
+        return 1;
 }
 
 /*
@@ -479,38 +472,32 @@ static int __table_get_device(struct dm_table *t, struct dm_target *ti,
         }
         atomic_inc(&dd->count);
 
-        if (!check_device_area(dd, start, len)) {
-                DMWARN("device %s too small for target", path);
-                dm_put_device(ti, &dd->dm_dev);
-                return -EINVAL;
-        }
-
         *result = &dd->dm_dev;
-
         return 0;
 }
 
-void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
+/*
+ * Returns the minimum that is _not_ zero, unless both are zero.
+ */
+#define min_not_zero(l, r) (l == 0) ? r : ((r == 0) ? l : min(l, r))
+
+int dm_set_device_limits(struct dm_target *ti, struct dm_dev *dev,
+                         sector_t start, void *data)
 {
+        struct queue_limits *limits = data;
+        struct block_device *bdev = dev->bdev;
         struct request_queue *q = bdev_get_queue(bdev);
-        struct io_restrictions *rs = &ti->limits;
         char b[BDEVNAME_SIZE];
 
         if (unlikely(!q)) {
                 DMWARN("%s: Cannot set limits for nonexistent device %s",
                        dm_device_name(ti->table->md), bdevname(bdev, b));
-                return;
+                return 0;
         }
 
-        /*
-         * Combine the device limits low.
-         *
-         * FIXME: if we move an io_restriction struct
-         *        into q this would just be a call to
-         *        combine_restrictions_low()
-         */
-        rs->max_sectors =
-                min_not_zero(rs->max_sectors, queue_max_sectors(q));
+        if (blk_stack_limits(limits, &q->limits, start) < 0)
+                DMWARN("%s: target device %s is misaligned",
+                       dm_device_name(ti->table->md), bdevname(bdev, b));
 
         /*
          * Check if merge fn is supported.
@@ -519,48 +506,21 @@ void dm_set_device_limits(struct dm_target *ti, struct block_device *bdev)
          */
 
         if (q->merge_bvec_fn && !ti->type->merge)
-                rs->max_sectors =
-                        min_not_zero(rs->max_sectors,
+                limits->max_sectors =
+                        min_not_zero(limits->max_sectors,
                                      (unsigned int) (PAGE_SIZE >> 9));
-
-        rs->max_phys_segments =
-                min_not_zero(rs->max_phys_segments,
-                             queue_max_phys_segments(q));
-
-        rs->max_hw_segments =
-                min_not_zero(rs->max_hw_segments, queue_max_hw_segments(q));
-
-        rs->logical_block_size = max(rs->logical_block_size,
-                                     queue_logical_block_size(q));
-
-        rs->max_segment_size =
-                min_not_zero(rs->max_segment_size, queue_max_segment_size(q));
-
-        rs->max_hw_sectors =
-                min_not_zero(rs->max_hw_sectors, queue_max_hw_sectors(q));
-
-        rs->seg_boundary_mask =
-                min_not_zero(rs->seg_boundary_mask,
-                             queue_segment_boundary(q));
-
-        rs->bounce_pfn = min_not_zero(rs->bounce_pfn, queue_bounce_pfn(q));
-
-        rs->no_cluster |= !test_bit(QUEUE_FLAG_CLUSTER, &q->queue_flags);
+        return 0;
 }
 EXPORT_SYMBOL_GPL(dm_set_device_limits);
 
 int dm_get_device(struct dm_target *ti, const char *path, sector_t start,
                   sector_t len, fmode_t mode, struct dm_dev **result)
 {
-        int r = __table_get_device(ti->table, ti, path,
-                                   start, len, mode, result);
-
-        if (!r)
-                dm_set_device_limits(ti, (*result)->bdev);
-
-        return r;
+        return __table_get_device(ti->table, ti, path,
+                                  start, len, mode, result);
 }
 
+
 /*
  * Decrement a devices use count and remove it if necessary.
  */
@@ -675,24 +635,78 @@ int dm_split_args(int *argc, char ***argvp, char *input)
         return 0;
 }
 
-static void check_for_valid_limits(struct io_restrictions *rs)
+/*
+ * Impose necessary and sufficient conditions on a devices's table such
+ * that any incoming bio which respects its logical_block_size can be
+ * processed successfully.  If it falls across the boundary between
+ * two or more targets, the size of each piece it gets split into must
+ * be compatible with the logical_block_size of the target processing it.
+ */
+static int validate_hardware_logical_block_alignment(struct dm_table *table,
+                                                 struct queue_limits *limits)
 {
-        if (!rs->max_sectors)
-                rs->max_sectors = SAFE_MAX_SECTORS;
-        if (!rs->max_hw_sectors)
-                rs->max_hw_sectors = SAFE_MAX_SECTORS;
-        if (!rs->max_phys_segments)
-                rs->max_phys_segments = MAX_PHYS_SEGMENTS;
-        if (!rs->max_hw_segments)
-                rs->max_hw_segments = MAX_HW_SEGMENTS;
-        if (!rs->logical_block_size)
-                rs->logical_block_size = 1 << SECTOR_SHIFT;
-        if (!rs->max_segment_size)
-                rs->max_segment_size = MAX_SEGMENT_SIZE;
-        if (!rs->seg_boundary_mask)
-                rs->seg_boundary_mask = BLK_SEG_BOUNDARY_MASK;
-        if (!rs->bounce_pfn)
-                rs->bounce_pfn = -1;
+        /*
+         * This function uses arithmetic modulo the logical_block_size
+         * (in units of 512-byte sectors).
+         */
+        unsigned short device_logical_block_size_sects =
+                limits->logical_block_size >> SECTOR_SHIFT;
+
+        /*
+         * Offset of the start of the next table entry, mod logical_block_size.
+         */
+        unsigned short next_target_start = 0;
+
+        /*
+         * Given an aligned bio that extends beyond the end of a
+         * target, how many sectors must the next target handle?
+         */
+        unsigned short remaining = 0;
+
+        struct dm_target *uninitialized_var(ti);
+        struct queue_limits ti_limits;
+        unsigned i = 0;
+
+        /*
+         * Check each entry in the table in turn.
+         */
+        while (i < dm_table_get_num_targets(table)) {
+                ti = dm_table_get_target(table, i++);
+
+                blk_set_default_limits(&ti_limits);
+
+                /* combine all target devices' limits */
+                if (ti->type->iterate_devices)
+                        ti->type->iterate_devices(ti, dm_set_device_limits,
+                                                  &ti_limits);
+
+                /*
+                 * If the remaining sectors fall entirely within this
+                 * table entry are they compatible with its logical_block_size?
+                 */
+                if (remaining < ti->len &&
+                    remaining & ((ti_limits.logical_block_size >>
+                                  SECTOR_SHIFT) - 1))
+                        break;  /* Error */
+
+                next_target_start =
+                    (unsigned short) ((next_target_start + ti->len) &
+                                      (device_logical_block_size_sects - 1));
+                remaining = next_target_start ?
+                    device_logical_block_size_sects - next_target_start : 0;
+        }
+
+        if (remaining) {
+                DMWARN("%s: table line %u (start sect %llu len %llu) "
+                       "not aligned to h/w logical block size %hu",
+                       dm_device_name(table->md), i,
+                       (unsigned long long) ti->begin,
+                       (unsigned long long) ti->len,
+                       limits->logical_block_size);
+                return -EINVAL;
+        }
+
+        return 0;
 }
 
 int dm_table_add_target(struct dm_table *t, const char *type,
@@ -747,9 +761,6 @@ int dm_table_add_target(struct dm_table *t, const char *type,
 
         t->highs[t->num_targets++] = tgt->begin + tgt->len - 1;
 
-        /* FIXME: the plan is to combine high here and then have
-         * the merge fn apply the target level restrictions. */
-        combine_restrictions_low(&t->limits, &tgt->limits);
         return 0;
 
  bad:
@@ -758,6 +769,104 @@ int dm_table_add_target(struct dm_table *t, const char *type,
         return r;
 }
 
+int dm_table_set_type(struct dm_table *t)
+{
+        unsigned i;
+        unsigned bio_based = 0, request_based = 0;
+        struct dm_target *tgt;
+        struct dm_dev_internal *dd;
+        struct list_head *devices;
+
+        for (i = 0; i < t->num_targets; i++) {
+                tgt = t->targets + i;
+                if (dm_target_request_based(tgt))
+                        request_based = 1;
+                else
+                        bio_based = 1;
+
+                if (bio_based && request_based) {
+                        DMWARN("Inconsistent table: different target types"
+                               " can't be mixed up");
+                        return -EINVAL;
+                }
+        }
+
+        if (bio_based) {
+                /* We must use this table as bio-based */
+                t->type = DM_TYPE_BIO_BASED;
+                return 0;
+        }
+
+        BUG_ON(!request_based); /* No targets in this table */
+
+        /* Non-request-stackable devices can't be used for request-based dm */
+        devices = dm_table_get_devices(t);
+        list_for_each_entry(dd, devices, list) {
+                if (!blk_queue_stackable(bdev_get_queue(dd->dm_dev.bdev))) {
+                        DMWARN("table load rejected: including"
+                               " non-request-stackable devices");
+                        return -EINVAL;
+                }
+        }
+
+        /*
+         * Request-based dm supports only tables that have a single target now.
+         * To support multiple targets, request splitting support is needed,
+         * and that needs lots of changes in the block-layer.
+         * (e.g. request completion process for partial completion.)
+         */
+        if (t->num_targets > 1) {
+                DMWARN("Request-based dm doesn't support multiple targets yet");
+                return -EINVAL;
+        }
+
+        t->type = DM_TYPE_REQUEST_BASED;
+
+        return 0;
+}
+
+unsigned dm_table_get_type(struct dm_table *t)
+{
+        return t->type;
+}
+
+bool dm_table_bio_based(struct dm_table *t)
+{
+        return dm_table_get_type(t) == DM_TYPE_BIO_BASED;
+}
+
+bool dm_table_request_based(struct dm_table *t)
+{
+        return dm_table_get_type(t) == DM_TYPE_REQUEST_BASED;
+}
+
+int dm_table_alloc_md_mempools(struct dm_table *t)
+{
+        unsigned type = dm_table_get_type(t);
+
+        if (unlikely(type == DM_TYPE_NONE)) {
+                DMWARN("no table type is set, can't allocate mempools");
+                return -EINVAL;
+        }
+
+        t->mempools = dm_alloc_md_mempools(type);
+        if (!t->mempools)
+                return -ENOMEM;
+
+        return 0;
+}
+
+void dm_table_free_md_mempools(struct dm_table *t)
+{
+        dm_free_md_mempools(t->mempools);
+        t->mempools = NULL;
+}
+
+struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t)
+{
+        return t->mempools;
+}
+
 static int setup_indexes(struct dm_table *t)
 {
         int i;
@@ -792,8 +901,6 @@ int dm_table_complete(struct dm_table *t)
         int r = 0;
         unsigned int leaf_nodes;
 
-        check_for_valid_limits(&t->limits);
-
         /* how many indexes will the btree have ? */
         leaf_nodes = dm_div_up(t->num_targets, KEYS_PER_NODE);
         t->depth = 1 + int_log(leaf_nodes, CHILDREN_PER_NODE);
@@ -869,6 +976,57 @@ struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector)
 }
 
 /*
+ * Establish the new table's queue_limits and validate them.
+ */
+int dm_calculate_queue_limits(struct dm_table *table,
+                              struct queue_limits *limits)
+{
+        struct dm_target *uninitialized_var(ti);
+        struct queue_limits ti_limits;
+        unsigned i = 0;
+
+        blk_set_default_limits(limits);
+
+        while (i < dm_table_get_num_targets(table)) {
+                blk_set_default_limits(&ti_limits);
+
+                ti = dm_table_get_target(table, i++);
+
+                if (!ti->type->iterate_devices)
+                        goto combine_limits;
+
+                /*
+                 * Combine queue limits of all the devices this target uses.
+                 */
+                ti->type->iterate_devices(ti, dm_set_device_limits,
+                                          &ti_limits);
+
+                /*
+                 * Check each device area is consistent with the target's
+                 * overall queue limits.
+                 */
+                if (!ti->type->iterate_devices(ti, device_area_is_valid,
+                                               &ti_limits))
+                        return -EINVAL;
+
+combine_limits:
+                /*
+                 * Merge this target's queue limits into the overall limits
+                 * for the table.
+                 */
+                if (blk_stack_limits(limits, &ti_limits, 0) < 0)
+                        DMWARN("%s: target device "
+                               "(start sect %llu len %llu) "
+                               "is misaligned",
+                               dm_device_name(table->md),
+                               (unsigned long long) ti->begin,
+                               (unsigned long long) ti->len);
+        }
+
+        return validate_hardware_logical_block_alignment(table, limits);
+}
+
+/*
  * Set the integrity profile for this device if all devices used have
  * matching profiles.
  */
@@ -907,27 +1065,42 @@ no_integrity:
         return;
 }
 
-void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q)
+void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
+                               struct queue_limits *limits)
 {
         /*
-         * Make sure we obey the optimistic sub devices
-         * restrictions.
+         * Each target device in the table has a data area that should normally
+         * be aligned such that the DM device's alignment_offset is 0.
+         * FIXME: Propagate alignment_offsets up the stack and warn of
+         *        sub-optimal or inconsistent settings.
+         */
+        limits->alignment_offset = 0;
+        limits->misaligned = 0;
+
+        /*
+         * Copy table's limits to the DM device's request_queue
          */
-        blk_queue_max_sectors(q, t->limits.max_sectors);
-        blk_queue_max_phys_segments(q, t->limits.max_phys_segments);
-        blk_queue_max_hw_segments(q, t->limits.max_hw_segments);
-        blk_queue_logical_block_size(q, t->limits.logical_block_size);
-        blk_queue_max_segment_size(q, t->limits.max_segment_size);
-        blk_queue_max_hw_sectors(q, t->limits.max_hw_sectors);
-        blk_queue_segment_boundary(q, t->limits.seg_boundary_mask);
-        blk_queue_bounce_limit(q, t->limits.bounce_pfn);
-
-        if (t->limits.no_cluster)
+        q->limits = *limits;
+
+        if (limits->no_cluster)
                 queue_flag_clear_unlocked(QUEUE_FLAG_CLUSTER, q);
         else
                 queue_flag_set_unlocked(QUEUE_FLAG_CLUSTER, q);
 
         dm_table_set_integrity(t);
+
+        /*
+         * QUEUE_FLAG_STACKABLE must be set after all queue settings are
+         * visible to other CPUs because, once the flag is set, incoming bios
+         * are processed by request-based dm, which refers to the queue
+         * settings.
+         * Until the flag set, bios are passed to bio-based dm and queued to
+         * md->deferred where queue settings are not needed yet.
+         * Those bios are passed to request-based dm at the resume time.
+         */
+        smp_mb();
+        if (dm_table_request_based(t))
+                queue_flag_set_unlocked(QUEUE_FLAG_STACKABLE, q);
 }
 
 unsigned int dm_table_get_num_targets(struct dm_table *t)
@@ -1023,6 +1196,20 @@ int dm_table_any_congested(struct dm_table *t, int bdi_bits)
         return r;
 }
 
+int dm_table_any_busy_target(struct dm_table *t)
+{
+        unsigned i;
+        struct dm_target *ti;
+
+        for (i = 0; i < t->num_targets; i++) {
+                ti = t->targets + i;
+                if (ti->type->busy && ti->type->busy(ti))
+                        return 1;
+        }
+
+        return 0;
+}
+
 void dm_table_unplug_all(struct dm_table *t)
 {
         struct dm_dev_internal *dd;
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 48db308fae67..3c6d4ee8921d 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -24,6 +24,13 @@
 
 #define DM_MSG_PREFIX "core"
 
+/*
+ * Cookies are numeric values sent with CHANGE and REMOVE
+ * uevents while resuming, removing or renaming the device.
+ */
+#define DM_COOKIE_ENV_VAR_NAME "DM_COOKIE"
+#define DM_COOKIE_LENGTH 24
+
 static const char *_name = DM_NAME;
 
 static unsigned int major = 0;
@@ -71,7 +78,7 @@ struct dm_rq_target_io {
  */
 struct dm_rq_clone_bio_info {
         struct bio *orig;
-        struct request *rq;
+        struct dm_rq_target_io *tio;
 };
 
 union map_info *dm_get_mapinfo(struct bio *bio)
@@ -81,6 +88,14 @@ union map_info *dm_get_mapinfo(struct bio *bio)
         return NULL;
 }
 
+union map_info *dm_get_rq_mapinfo(struct request *rq)
+{
+        if (rq && rq->end_io_data)
+                return &((struct dm_rq_target_io *)rq->end_io_data)->info;
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(dm_get_rq_mapinfo);
+
 #define MINOR_ALLOCED ((void *)-1)
 
 /*
@@ -157,13 +172,31 @@ struct mapped_device {
          * freeze/thaw support require holding onto a super block
          */
         struct super_block *frozen_sb;
-        struct block_device *suspended_bdev;
+        struct block_device *bdev;
 
         /* forced geometry settings */
         struct hd_geometry geometry;
 
+        /* marker of flush suspend for request-based dm */
+        struct request suspend_rq;
+
+        /* For saving the address of __make_request for request based dm */
+        make_request_fn *saved_make_request_fn;
+
         /* sysfs handle */
         struct kobject kobj;
+
+        /* zero-length barrier that will be cloned and submitted to targets */
+        struct bio barrier_bio;
+};
+
+/*
+ * For mempools pre-allocation at the table loading time.
+ */
+struct dm_md_mempools {
+        mempool_t *io_pool;
+        mempool_t *tio_pool;
+        struct bio_set *bs;
 };
 
 #define MIN_IOS 256
@@ -391,14 +424,29 @@ static void free_io(struct mapped_device *md, struct dm_io *io)
         mempool_free(io, md->io_pool);
 }
 
-static struct dm_target_io *alloc_tio(struct mapped_device *md)
+static void free_tio(struct mapped_device *md, struct dm_target_io *tio)
 {
-        return mempool_alloc(md->tio_pool, GFP_NOIO);
+        mempool_free(tio, md->tio_pool);
 }
 
-static void free_tio(struct mapped_device *md, struct dm_target_io *tio)
+static struct dm_rq_target_io *alloc_rq_tio(struct mapped_device *md)
 {
-        mempool_free(tio, md->tio_pool);
+        return mempool_alloc(md->tio_pool, GFP_ATOMIC);
+}
+
+static void free_rq_tio(struct dm_rq_target_io *tio)
+{
+        mempool_free(tio, tio->md->tio_pool);
+}
+
+static struct dm_rq_clone_bio_info *alloc_bio_info(struct mapped_device *md)
+{
+        return mempool_alloc(md->io_pool, GFP_ATOMIC);
+}
+
+static void free_bio_info(struct dm_rq_clone_bio_info *info)
+{
+        mempool_free(info, info->tio->md->io_pool);
 }
 
 static void start_io_acct(struct dm_io *io)
@@ -464,12 +512,13 @@ static void queue_io(struct mapped_device *md, struct bio *bio)
 struct dm_table *dm_get_table(struct mapped_device *md)
 {
         struct dm_table *t;
+        unsigned long flags;
 
-        read_lock(&md->map_lock);
+        read_lock_irqsave(&md->map_lock, flags);
         t = md->map;
         if (t)
                 dm_table_get(t);
-        read_unlock(&md->map_lock);
+        read_unlock_irqrestore(&md->map_lock, flags);
 
         return t;
 }
@@ -536,9 +585,11 @@ static void dec_pending(struct dm_io *io, int error)
                          * Target requested pushing back the I/O.
                          */
                         spin_lock_irqsave(&md->deferred_lock, flags);
-                        if (__noflush_suspending(md))
-                                bio_list_add_head(&md->deferred, io->bio);
-                        else
+                        if (__noflush_suspending(md)) {
+                                if (!bio_barrier(io->bio))
+                                        bio_list_add_head(&md->deferred,
+                                                          io->bio);
+                        } else
                                 /* noflush suspend was interrupted. */
                                 io->error = -EIO;
                         spin_unlock_irqrestore(&md->deferred_lock, flags);
@@ -553,7 +604,8 @@ static void dec_pending(struct dm_io *io, int error)
                          * a per-device variable for error reporting.
                          * Note that you can't touch the bio after end_io_acct
                          */
-                        md->barrier_error = io_error;
+                        if (!md->barrier_error && io_error != -EOPNOTSUPP)
+                                md->barrier_error = io_error;
                         end_io_acct(io);
                 } else {
                         end_io_acct(io);
@@ -607,6 +659,262 @@ static void clone_endio(struct bio *bio, int error)
         dec_pending(io, error);
 }
 
+/*
+ * Partial completion handling for request-based dm
+ */
+static void end_clone_bio(struct bio *clone, int error)
+{
+        struct dm_rq_clone_bio_info *info = clone->bi_private;
+        struct dm_rq_target_io *tio = info->tio;
+        struct bio *bio = info->orig;
+        unsigned int nr_bytes = info->orig->bi_size;
+
+        bio_put(clone);
+
+        if (tio->error)
+                /*
+                 * An error has already been detected on the request.
+                 * Once error occurred, just let clone->end_io() handle
+                 * the remainder.
+                 */
+                return;
+        else if (error) {
+                /*
+                 * Don't notice the error to the upper layer yet.
+                 * The error handling decision is made by the target driver,
+                 * when the request is completed.
+                 */
+                tio->error = error;
+                return;
+        }
+
+        /*
+         * I/O for the bio successfully completed.
+         * Notice the data completion to the upper layer.
+         */
+
+        /*
+         * bios are processed from the head of the list.
+         * So the completing bio should always be rq->bio.
+         * If it's not, something wrong is happening.
+         */
+        if (tio->orig->bio != bio)
+                DMERR("bio completion is going in the middle of the request");
+
+        /*
+         * Update the original request.
+         * Do not use blk_end_request() here, because it may complete
+         * the original request before the clone, and break the ordering.
+         */
+        blk_update_request(tio->orig, 0, nr_bytes);
+}
+
+/*
+ * Don't touch any member of the md after calling this function because
+ * the md may be freed in dm_put() at the end of this function.
+ * Or do dm_get() before calling this function and dm_put() later.
+ */
+static void rq_completed(struct mapped_device *md, int run_queue)
+{
+        int wakeup_waiters = 0;
+        struct request_queue *q = md->queue;
+        unsigned long flags;
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (!queue_in_flight(q))
+                wakeup_waiters = 1;
+        spin_unlock_irqrestore(q->queue_lock, flags);
+
+        /* nudge anyone waiting on suspend queue */
+        if (wakeup_waiters)
+                wake_up(&md->wait);
+
+        if (run_queue)
+                blk_run_queue(q);
+
+        /*
+         * dm_put() must be at the end of this function. See the comment above
+         */
+        dm_put(md);
+}
+
+static void dm_unprep_request(struct request *rq)
+{
+        struct request *clone = rq->special;
+        struct dm_rq_target_io *tio = clone->end_io_data;
+
+        rq->special = NULL;
+        rq->cmd_flags &= ~REQ_DONTPREP;
+
+        blk_rq_unprep_clone(clone);
+        free_rq_tio(tio);
+}
+
+/*
+ * Requeue the original request of a clone.
+ */
+void dm_requeue_unmapped_request(struct request *clone)
+{
+        struct dm_rq_target_io *tio = clone->end_io_data;
+        struct mapped_device *md = tio->md;
+        struct request *rq = tio->orig;
+        struct request_queue *q = rq->q;
+        unsigned long flags;
+
+        dm_unprep_request(rq);
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (elv_queue_empty(q))
+                blk_plug_device(q);
+        blk_requeue_request(q, rq);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+
+        rq_completed(md, 0);
+}
+EXPORT_SYMBOL_GPL(dm_requeue_unmapped_request);
+
+static void __stop_queue(struct request_queue *q)
+{
+        blk_stop_queue(q);
+}
+
+static void stop_queue(struct request_queue *q)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        __stop_queue(q);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+}
+
+static void __start_queue(struct request_queue *q)
+{
+        if (blk_queue_stopped(q))
+                blk_start_queue(q);
+}
+
+static void start_queue(struct request_queue *q)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        __start_queue(q);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+}
+
+/*
+ * Complete the clone and the original request.
+ * Must be called without queue lock.
+ */
+static void dm_end_request(struct request *clone, int error)
+{
+        struct dm_rq_target_io *tio = clone->end_io_data;
+        struct mapped_device *md = tio->md;
+        struct request *rq = tio->orig;
+
+        if (blk_pc_request(rq)) {
+                rq->errors = clone->errors;
+                rq->resid_len = clone->resid_len;
+
+                if (rq->sense)
+                        /*
+                         * We are using the sense buffer of the original
+                         * request.
+                         * So setting the length of the sense data is enough.
+                         */
+                        rq->sense_len = clone->sense_len;
+        }
+
+        BUG_ON(clone->bio);
+        free_rq_tio(tio);
+
+        blk_end_request_all(rq, error);
+
+        rq_completed(md, 1);
+}
+
+/*
+ * Request completion handler for request-based dm
+ */
+static void dm_softirq_done(struct request *rq)
+{
+        struct request *clone = rq->completion_data;
+        struct dm_rq_target_io *tio = clone->end_io_data;
+        dm_request_endio_fn rq_end_io = tio->ti->type->rq_end_io;
+        int error = tio->error;
+
+        if (!(rq->cmd_flags & REQ_FAILED) && rq_end_io)
+                error = rq_end_io(tio->ti, clone, error, &tio->info);
+
+        if (error <= 0)
+                /* The target wants to complete the I/O */
+                dm_end_request(clone, error);
+        else if (error == DM_ENDIO_INCOMPLETE)
+                /* The target will handle the I/O */
+                return;
+        else if (error == DM_ENDIO_REQUEUE)
+                /* The target wants to requeue the I/O */
+                dm_requeue_unmapped_request(clone);
+        else {
+                DMWARN("unimplemented target endio return value: %d", error);
+                BUG();
+        }
+}
+
+/*
+ * Complete the clone and the original request with the error status
+ * through softirq context.
+ */
+static void dm_complete_request(struct request *clone, int error)
+{
+        struct dm_rq_target_io *tio = clone->end_io_data;
+        struct request *rq = tio->orig;
+
+        tio->error = error;
+        rq->completion_data = clone;
+        blk_complete_request(rq);
+}
+
+/*
+ * Complete the not-mapped clone and the original request with the error status
+ * through softirq context.
+ * Target's rq_end_io() function isn't called.
+ * This may be used when the target's map_rq() function fails.
+ */
+void dm_kill_unmapped_request(struct request *clone, int error)
+{
+        struct dm_rq_target_io *tio = clone->end_io_data;
+        struct request *rq = tio->orig;
+
+        rq->cmd_flags |= REQ_FAILED;
+        dm_complete_request(clone, error);
+}
+EXPORT_SYMBOL_GPL(dm_kill_unmapped_request);
+
+/*
+ * Called with the queue lock held
+ */
+static void end_clone_request(struct request *clone, int error)
+{
+        /*
+         * For just cleaning up the information of the queue in which
+         * the clone was dispatched.
+         * The clone is *NOT* freed actually here because it is alloced from
+         * dm own mempool and REQ_ALLOCED isn't set in clone->cmd_flags.
+         */
+        __blk_put_request(clone->q, clone);
+
+        /*
+         * Actual request completion is done in a softirq context which doesn't
+         * hold the queue lock.  Otherwise, deadlock could occur because:
+         *     - another request may be submitted by the upper level driver
+         *       of the stacking during the completion
+         *     - the submission which requires queue lock may be done
+         *       against this queue
+         */
+        dm_complete_request(clone, error);
+}
+
 static sector_t max_io_len(struct mapped_device *md,
                            sector_t sector, struct dm_target *ti)
 {
@@ -634,11 +942,6 @@ static void __map_bio(struct dm_target *ti, struct bio *clone,
         sector_t sector;
         struct mapped_device *md;
 
-        /*
-         * Sanity checks.
-         */
-        BUG_ON(!clone->bi_size);
-
         clone->bi_end_io = clone_endio;
         clone->bi_private = tio;
 
@@ -752,6 +1055,48 @@ static struct bio *clone_bio(struct bio *bio, sector_t sector,
         return clone;
 }
 
+static struct dm_target_io *alloc_tio(struct clone_info *ci,
+                                      struct dm_target *ti)
+{
+        struct dm_target_io *tio = mempool_alloc(ci->md->tio_pool, GFP_NOIO);
+
+        tio->io = ci->io;
+        tio->ti = ti;
+        memset(&tio->info, 0, sizeof(tio->info));
+
+        return tio;
+}
+
+static void __flush_target(struct clone_info *ci, struct dm_target *ti,
+                          unsigned flush_nr)
+{
+        struct dm_target_io *tio = alloc_tio(ci, ti);
+        struct bio *clone;
+
+        tio->info.flush_request = flush_nr;
+
+        clone = bio_alloc_bioset(GFP_NOIO, 0, ci->md->bs);
+        __bio_clone(clone, ci->bio);
+        clone->bi_destructor = dm_bio_destructor;
+
+        __map_bio(ti, clone, tio);
+}
+
+static int __clone_and_map_empty_barrier(struct clone_info *ci)
+{
+        unsigned target_nr = 0, flush_nr;
+        struct dm_target *ti;
+
+        while ((ti = dm_table_get_target(ci->map, target_nr++)))
+                for (flush_nr = 0; flush_nr < ti->num_flush_requests;
+                     flush_nr++)
+                        __flush_target(ci, ti, flush_nr);
+
+        ci->sector_count = 0;
+
+        return 0;
+}
+
 static int __clone_and_map(struct clone_info *ci)
 {
         struct bio *clone, *bio = ci->bio;
@@ -759,6 +1104,9 @@ static int __clone_and_map(struct clone_info *ci)
         sector_t len = 0, max;
         struct dm_target_io *tio;
 
+        if (unlikely(bio_empty_barrier(bio)))
+                return __clone_and_map_empty_barrier(ci);
+
         ti = dm_table_find_target(ci->map, ci->sector);
         if (!dm_target_is_valid(ti))
                 return -EIO;
@@ -768,10 +1116,7 @@ static int __clone_and_map(struct clone_info *ci)
         /*
          * Allocate a target io object.
          */
-        tio = alloc_tio(ci->md);
-        tio->io = ci->io;
-        tio->ti = ti;
-        memset(&tio->info, 0, sizeof(tio->info));
+        tio = alloc_tio(ci, ti);
 
         if (ci->sector_count <= max) {
                 /*
@@ -827,10 +1172,7 @@ static int __clone_and_map(struct clone_info *ci)
 
                                 max = max_io_len(ci->md, ci->sector, ti);
 
-                                tio = alloc_tio(ci->md);
-                                tio->io = ci->io;
-                                tio->ti = ti;
-                                memset(&tio->info, 0, sizeof(tio->info));
+                                tio = alloc_tio(ci, ti);
                         }
 
                         len = min(remaining, max);
@@ -865,7 +1207,8 @@ static void __split_and_process_bio(struct mapped_device *md, struct bio *bio)
                 if (!bio_barrier(bio))
                         bio_io_error(bio);
                 else
-                        md->barrier_error = -EIO;
+                        if (!md->barrier_error)
+                                md->barrier_error = -EIO;
                 return;
         }
 
@@ -878,6 +1221,8 @@ static void __split_and_process_bio(struct mapped_device *md, struct bio *bio)
         ci.io->md = md;
         ci.sector = bio->bi_sector;
         ci.sector_count = bio_sectors(bio);
+        if (unlikely(bio_empty_barrier(bio)))
+                ci.sector_count = 1;
         ci.idx = bio->bi_idx;
 
         start_io_acct(ci.io);
@@ -925,6 +1270,16 @@ static int dm_merge_bvec(struct request_queue *q,
          */
         if (max_size && ti->type->merge)
                 max_size = ti->type->merge(ti, bvm, biovec, max_size);
+        /*
+         * If the target doesn't support merge method and some of the devices
+         * provided their merge_bvec method (we know this by looking at
+         * queue_max_hw_sectors), then we can't allow bios with multiple vector
+         * entries.  So always set max_size to 0, and the code below allows
+         * just one page.
+         */
+        else if (queue_max_hw_sectors(q) <= PAGE_SIZE >> 9)
+
+                max_size = 0;
 
 out_table:
         dm_table_put(map);
@@ -943,7 +1298,7 @@ out:
  * The request function that just remaps the bio built up by
  * dm_merge_bvec.
  */
-static int dm_request(struct request_queue *q, struct bio *bio)
+static int _dm_request(struct request_queue *q, struct bio *bio)
 {
         int rw = bio_data_dir(bio);
         struct mapped_device *md = q->queuedata;
@@ -980,12 +1335,274 @@ static int dm_request(struct request_queue *q, struct bio *bio)
         return 0;
 }
 
+static int dm_make_request(struct request_queue *q, struct bio *bio)
+{
+        struct mapped_device *md = q->queuedata;
+
+        if (unlikely(bio_barrier(bio))) {
+                bio_endio(bio, -EOPNOTSUPP);
+                return 0;
+        }
+
+        return md->saved_make_request_fn(q, bio); /* call __make_request() */
+}
+
+static int dm_request_based(struct mapped_device *md)
+{
+        return blk_queue_stackable(md->queue);
+}
+
+static int dm_request(struct request_queue *q, struct bio *bio)
+{
+        struct mapped_device *md = q->queuedata;
+
+        if (dm_request_based(md))
+                return dm_make_request(q, bio);
+
+        return _dm_request(q, bio);
+}
+
+void dm_dispatch_request(struct request *rq)
+{
+        int r;
+
+        if (blk_queue_io_stat(rq->q))
+                rq->cmd_flags |= REQ_IO_STAT;
+
+        rq->start_time = jiffies;
+        r = blk_insert_cloned_request(rq->q, rq);
+        if (r)
+                dm_complete_request(rq, r);
+}
+EXPORT_SYMBOL_GPL(dm_dispatch_request);
+
+static void dm_rq_bio_destructor(struct bio *bio)
+{
+        struct dm_rq_clone_bio_info *info = bio->bi_private;
+        struct mapped_device *md = info->tio->md;
+
+        free_bio_info(info);
+        bio_free(bio, md->bs);
+}
+
+static int dm_rq_bio_constructor(struct bio *bio, struct bio *bio_orig,
+                                 void *data)
+{
+        struct dm_rq_target_io *tio = data;
+        struct mapped_device *md = tio->md;
+        struct dm_rq_clone_bio_info *info = alloc_bio_info(md);
+
+        if (!info)
+                return -ENOMEM;
+
+        info->orig = bio_orig;
+        info->tio = tio;
+        bio->bi_end_io = end_clone_bio;
+        bio->bi_private = info;
+        bio->bi_destructor = dm_rq_bio_destructor;
+
+        return 0;
+}
+
+static int setup_clone(struct request *clone, struct request *rq,
+                       struct dm_rq_target_io *tio)
+{
+        int r = blk_rq_prep_clone(clone, rq, tio->md->bs, GFP_ATOMIC,
+                                  dm_rq_bio_constructor, tio);
+
+        if (r)
+                return r;
+
+        clone->cmd = rq->cmd;
+        clone->cmd_len = rq->cmd_len;
+        clone->sense = rq->sense;
+        clone->buffer = rq->buffer;
+        clone->end_io = end_clone_request;
+        clone->end_io_data = tio;
+
+        return 0;
+}
+
+static int dm_rq_flush_suspending(struct mapped_device *md)
+{
+        return !md->suspend_rq.special;
+}
+
+/*
+ * Called with the queue lock held.
+ */
+static int dm_prep_fn(struct request_queue *q, struct request *rq)
+{
+        struct mapped_device *md = q->queuedata;
+        struct dm_rq_target_io *tio;
+        struct request *clone;
+
+        if (unlikely(rq == &md->suspend_rq)) {
+                if (dm_rq_flush_suspending(md))
+                        return BLKPREP_OK;
+                else
+                        /* The flush suspend was interrupted */
+                        return BLKPREP_KILL;
+        }
+
+        if (unlikely(rq->special)) {
+                DMWARN("Already has something in rq->special.");
+                return BLKPREP_KILL;
+        }
+
+        tio = alloc_rq_tio(md); /* Only one for each original request */
+        if (!tio)
+                /* -ENOMEM */
+                return BLKPREP_DEFER;
+
+        tio->md = md;
+        tio->ti = NULL;
+        tio->orig = rq;
+        tio->error = 0;
+        memset(&tio->info, 0, sizeof(tio->info));
+
+        clone = &tio->clone;
+        if (setup_clone(clone, rq, tio)) {
+                /* -ENOMEM */
+                free_rq_tio(tio);
+                return BLKPREP_DEFER;
+        }
+
+        rq->special = clone;
+        rq->cmd_flags |= REQ_DONTPREP;
+
+        return BLKPREP_OK;
+}
+
+static void map_request(struct dm_target *ti, struct request *rq,
+                        struct mapped_device *md)
+{
+        int r;
+        struct request *clone = rq->special;
+        struct dm_rq_target_io *tio = clone->end_io_data;
+
+        /*
+         * Hold the md reference here for the in-flight I/O.
+         * We can't rely on the reference count by device opener,
+         * because the device may be closed during the request completion
+         * when all bios are completed.
+         * See the comment in rq_completed() too.
+         */
+        dm_get(md);
+
+        tio->ti = ti;
+        r = ti->type->map_rq(ti, clone, &tio->info);
+        switch (r) {
+        case DM_MAPIO_SUBMITTED:
+                /* The target has taken the I/O to submit by itself later */
+                break;
+        case DM_MAPIO_REMAPPED:
+                /* The target has remapped the I/O so dispatch it */
+                dm_dispatch_request(clone);
+                break;
+        case DM_MAPIO_REQUEUE:
+                /* The target wants to requeue the I/O */
+                dm_requeue_unmapped_request(clone);
+                break;
+        default:
+                if (r > 0) {
+                        DMWARN("unimplemented target map return value: %d", r);
+                        BUG();
+                }
+
+                /* The target wants to complete the I/O */
+                dm_kill_unmapped_request(clone, r);
+                break;
+        }
+}
+
+/*
+ * q->request_fn for request-based dm.
+ * Called with the queue lock held.
+ */
+static void dm_request_fn(struct request_queue *q)
+{
+        struct mapped_device *md = q->queuedata;
+        struct dm_table *map = dm_get_table(md);
+        struct dm_target *ti;
+        struct request *rq;
+
+        /*
+         * For noflush suspend, check blk_queue_stopped() to immediately
+         * quit I/O dispatching.
+         */
+        while (!blk_queue_plugged(q) && !blk_queue_stopped(q)) {
+                rq = blk_peek_request(q);
+                if (!rq)
+                        goto plug_and_out;
+
+                if (unlikely(rq == &md->suspend_rq)) { /* Flush suspend maker */
+                        if (queue_in_flight(q))
+                                /* Not quiet yet.  Wait more */
+                                goto plug_and_out;
+
+                        /* This device should be quiet now */
+                        __stop_queue(q);
+                        blk_start_request(rq);
+                        __blk_end_request_all(rq, 0);
+                        wake_up(&md->wait);
+                        goto out;
+                }
+
+                ti = dm_table_find_target(map, blk_rq_pos(rq));
+                if (ti->type->busy && ti->type->busy(ti))
+                        goto plug_and_out;
+
+                blk_start_request(rq);
+                spin_unlock(q->queue_lock);
+                map_request(ti, rq, md);
+                spin_lock_irq(q->queue_lock);
+        }
+
+        goto out;
+
+plug_and_out:
+        if (!elv_queue_empty(q))
+                /* Some requests still remain, retry later */
+                blk_plug_device(q);
+
+out:
+        dm_table_put(map);
+
+        return;
+}
+
+int dm_underlying_device_busy(struct request_queue *q)
+{
+        return blk_lld_busy(q);
+}
+EXPORT_SYMBOL_GPL(dm_underlying_device_busy);
+
+static int dm_lld_busy(struct request_queue *q)
+{
+        int r;
+        struct mapped_device *md = q->queuedata;
+        struct dm_table *map = dm_get_table(md);
+
+        if (!map || test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))
+                r = 1;
+        else
+                r = dm_table_any_busy_target(map);
+
+        dm_table_put(map);
+
+        return r;
+}
+
 static void dm_unplug_all(struct request_queue *q)
 {
         struct mapped_device *md = q->queuedata;
         struct dm_table *map = dm_get_table(md);
 
         if (map) {
+                if (dm_request_based(md))
+                        generic_unplug_device(q);
+
                 dm_table_unplug_all(map);
                 dm_table_put(map);
         }
@@ -1000,7 +1617,16 @@ static int dm_any_congested(void *congested_data, int bdi_bits)
         if (!test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags)) {
                 map = dm_get_table(md);
                 if (map) {
-                        r = dm_table_any_congested(map, bdi_bits);
+                        /*
+                         * Request-based dm cares about only own queue for
+                         * the query about congestion status of request_queue
+                         */
+                        if (dm_request_based(md))
+                                r = md->queue->backing_dev_info.state &
+                                    bdi_bits;
+                        else
+                                r = dm_table_any_congested(map, bdi_bits);
+
                         dm_table_put(map);
                 }
         }
@@ -1123,30 +1749,32 @@ static struct mapped_device *alloc_dev(int minor)
         INIT_LIST_HEAD(&md->uevent_list);
         spin_lock_init(&md->uevent_lock);
 
-        md->queue = blk_alloc_queue(GFP_KERNEL);
+        md->queue = blk_init_queue(dm_request_fn, NULL);
         if (!md->queue)
                 goto bad_queue;
 
+        /*
+         * Request-based dm devices cannot be stacked on top of bio-based dm
+         * devices.  The type of this dm device has not been decided yet,
+         * although we initialized the queue using blk_init_queue().
+         * The type is decided at the first table loading time.
+         * To prevent problematic device stacking, clear the queue flag
+         * for request stacking support until then.
+         *
+         * This queue is new, so no concurrency on the queue_flags.
+         */
+        queue_flag_clear_unlocked(QUEUE_FLAG_STACKABLE, md->queue);
+        md->saved_make_request_fn = md->queue->make_request_fn;
         md->queue->queuedata = md;
         md->queue->backing_dev_info.congested_fn = dm_any_congested;
         md->queue->backing_dev_info.congested_data = md;
         blk_queue_make_request(md->queue, dm_request);
-        blk_queue_ordered(md->queue, QUEUE_ORDERED_DRAIN, NULL);
         blk_queue_bounce_limit(md->queue, BLK_BOUNCE_ANY);
         md->queue->unplug_fn = dm_unplug_all;
         blk_queue_merge_bvec(md->queue, dm_merge_bvec);
-
-        md->io_pool = mempool_create_slab_pool(MIN_IOS, _io_cache);
-        if (!md->io_pool)
-                goto bad_io_pool;
-
-        md->tio_pool = mempool_create_slab_pool(MIN_IOS, _tio_cache);
-        if (!md->tio_pool)
-                goto bad_tio_pool;
-
-        md->bs = bioset_create(16, 0);
-        if (!md->bs)
-                goto bad_no_bioset;
+        blk_queue_softirq_done(md->queue, dm_softirq_done);
+        blk_queue_prep_rq(md->queue, dm_prep_fn);
+        blk_queue_lld_busy(md->queue, dm_lld_busy);
 
         md->disk = alloc_disk(1);
         if (!md->disk)
@@ -1170,6 +1798,10 @@ static struct mapped_device *alloc_dev(int minor)
         if (!md->wq)
                 goto bad_thread;
 
+        md->bdev = bdget_disk(md->disk, 0);
+        if (!md->bdev)
+                goto bad_bdev;
+
         /* Populate the mapping, nobody knows we exist yet */
         spin_lock(&_minor_lock);
         old_md = idr_replace(&_minor_idr, md, minor);
@@ -1179,15 +1811,11 @@ static struct mapped_device *alloc_dev(int minor)
 
         return md;
 
+bad_bdev:
+        destroy_workqueue(md->wq);
 bad_thread:
         put_disk(md->disk);
 bad_disk:
-        bioset_free(md->bs);
-bad_no_bioset:
-        mempool_destroy(md->tio_pool);
-bad_tio_pool:
-        mempool_destroy(md->io_pool);
-bad_io_pool:
         blk_cleanup_queue(md->queue);
 bad_queue:
         free_minor(minor);
@@ -1204,14 +1832,15 @@ static void free_dev(struct mapped_device *md)
 {
         int minor = MINOR(disk_devt(md->disk));
 
-        if (md->suspended_bdev) {
-                unlock_fs(md);
-                bdput(md->suspended_bdev);
-        }
+        unlock_fs(md);
+        bdput(md->bdev);
         destroy_workqueue(md->wq);
-        mempool_destroy(md->tio_pool);
-        mempool_destroy(md->io_pool);
-        bioset_free(md->bs);
+        if (md->tio_pool)
+                mempool_destroy(md->tio_pool);
+        if (md->io_pool)
+                mempool_destroy(md->io_pool);
+        if (md->bs)
+                bioset_free(md->bs);
         blk_integrity_unregister(md->disk);
         del_gendisk(md->disk);
         free_minor(minor);
@@ -1226,6 +1855,29 @@ static void free_dev(struct mapped_device *md)
         kfree(md);
 }
 
+static void __bind_mempools(struct mapped_device *md, struct dm_table *t)
+{
+        struct dm_md_mempools *p;
+
+        if (md->io_pool && md->tio_pool && md->bs)
+                /* the md already has necessary mempools */
+                goto out;
+
+        p = dm_table_get_md_mempools(t);
+        BUG_ON(!p || md->io_pool || md->tio_pool || md->bs);
+
+        md->io_pool = p->io_pool;
+        p->io_pool = NULL;
+        md->tio_pool = p->tio_pool;
+        p->tio_pool = NULL;
+        md->bs = p->bs;
+        p->bs = NULL;
+
+out:
+        /* mempool bind completed, now no need any mempools in the table */
+        dm_table_free_md_mempools(t);
+}
+
 /*
  * Bind a table to the device.
  */
@@ -1249,15 +1901,17 @@ static void __set_size(struct mapped_device *md, sector_t size)
 {
         set_capacity(md->disk, size);
 
-        mutex_lock(&md->suspended_bdev->bd_inode->i_mutex);
-        i_size_write(md->suspended_bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
-        mutex_unlock(&md->suspended_bdev->bd_inode->i_mutex);
+        mutex_lock(&md->bdev->bd_inode->i_mutex);
+        i_size_write(md->bdev->bd_inode, (loff_t)size << SECTOR_SHIFT);
+        mutex_unlock(&md->bdev->bd_inode->i_mutex);
 }
 
-static int __bind(struct mapped_device *md, struct dm_table *t)
+static int __bind(struct mapped_device *md, struct dm_table *t,
+                  struct queue_limits *limits)
 {
         struct request_queue *q = md->queue;
         sector_t size;
+        unsigned long flags;
 
         size = dm_table_get_size(t);
 
@@ -1267,8 +1921,7 @@ static int __bind(struct mapped_device *md, struct dm_table *t)
         if (size != get_capacity(md->disk))
                 memset(&md->geometry, 0, sizeof(md->geometry));
 
-        if (md->suspended_bdev)
-                __set_size(md, size);
+        __set_size(md, size);
 
         if (!size) {
                 dm_table_destroy(t);
@@ -1277,10 +1930,22 @@ static int __bind(struct mapped_device *md, struct dm_table *t)
 
         dm_table_event_callback(t, event_callback, md);
 
-        write_lock(&md->map_lock);
+        /*
+         * The queue hasn't been stopped yet, if the old table type wasn't
+         * for request-based during suspension.  So stop it to prevent
+         * I/O mapping before resume.
+         * This must be done before setting the queue restrictions,
+         * because request-based dm may be run just after the setting.
+         */
+        if (dm_table_request_based(t) && !blk_queue_stopped(q))
+                stop_queue(q);
+
+        __bind_mempools(md, t);
+
+        write_lock_irqsave(&md->map_lock, flags);
         md->map = t;
-        dm_table_set_restrictions(t, q);
-        write_unlock(&md->map_lock);
+        dm_table_set_restrictions(t, q, limits);
+        write_unlock_irqrestore(&md->map_lock, flags);
 
         return 0;
 }
@@ -1288,14 +1953,15 @@ static int __bind(struct mapped_device *md, struct dm_table *t)
 static void __unbind(struct mapped_device *md)
 {
         struct dm_table *map = md->map;
+        unsigned long flags;
 
         if (!map)
                 return;
 
         dm_table_event_callback(map, NULL, NULL);
-        write_lock(&md->map_lock);
+        write_lock_irqsave(&md->map_lock, flags);
         md->map = NULL;
-        write_unlock(&md->map_lock);
+        write_unlock_irqrestore(&md->map_lock, flags);
         dm_table_destroy(map);
 }
 
@@ -1399,6 +2065,8 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
 {
         int r = 0;
         DECLARE_WAITQUEUE(wait, current);
+        struct request_queue *q = md->queue;
+        unsigned long flags;
 
         dm_unplug_all(md->queue);
 
@@ -1408,7 +2076,14 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
                 set_current_state(interruptible);
 
                 smp_mb();
-                if (!atomic_read(&md->pending))
+                if (dm_request_based(md)) {
+                        spin_lock_irqsave(q->queue_lock, flags);
+                        if (!queue_in_flight(q) && blk_queue_stopped(q)) {
+                                spin_unlock_irqrestore(q->queue_lock, flags);
+                                break;
+                        }
+                        spin_unlock_irqrestore(q->queue_lock, flags);
+                } else if (!atomic_read(&md->pending))
                         break;
 
                 if (interruptible == TASK_INTERRUPTIBLE &&
@@ -1426,34 +2101,36 @@ static int dm_wait_for_completion(struct mapped_device *md, int interruptible)
         return r;
 }
 
-static int dm_flush(struct mapped_device *md)
+static void dm_flush(struct mapped_device *md)
 {
         dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
-        return 0;
+
+        bio_init(&md->barrier_bio);
+        md->barrier_bio.bi_bdev = md->bdev;
+        md->barrier_bio.bi_rw = WRITE_BARRIER;
+        __split_and_process_bio(md, &md->barrier_bio);
+
+        dm_wait_for_completion(md, TASK_UNINTERRUPTIBLE);
 }
 
 static void process_barrier(struct mapped_device *md, struct bio *bio)
 {
-        int error = dm_flush(md);
-
-        if (unlikely(error)) {
-                bio_endio(bio, error);
-                return;
-        }
-        if (bio_empty_barrier(bio)) {
-                bio_endio(bio, 0);
-                return;
-        }
-
-        __split_and_process_bio(md, bio);
+        md->barrier_error = 0;
 
-        error = dm_flush(md);
+        dm_flush(md);
 
-        if (!error && md->barrier_error)
-                error = md->barrier_error;
+        if (!bio_empty_barrier(bio)) {
+                __split_and_process_bio(md, bio);
+                dm_flush(md);
+        }
 
         if (md->barrier_error != DM_ENDIO_REQUEUE)
-                bio_endio(bio, error);
+                bio_endio(bio, md->barrier_error);
+        else {
+                spin_lock_irq(&md->deferred_lock);
+                bio_list_add_head(&md->deferred, bio);
+                spin_unlock_irq(&md->deferred_lock);
+        }
 }
 
 /*
@@ -1479,10 +2156,14 @@ static void dm_wq_work(struct work_struct *work)
 
                 up_write(&md->io_lock);
 
-                if (bio_barrier(c))
-                        process_barrier(md, c);
-                else
-                        __split_and_process_bio(md, c);
+                if (dm_request_based(md))
+                        generic_make_request(c);
+                else {
+                        if (bio_barrier(c))
+                                process_barrier(md, c);
+                        else
+                                __split_and_process_bio(md, c);
+                }
 
                 down_write(&md->io_lock);
         }
@@ -1502,6 +2183,7 @@ static void dm_queue_flush(struct mapped_device *md)
  */
 int dm_swap_table(struct mapped_device *md, struct dm_table *table)
 {
+        struct queue_limits limits;
         int r = -EINVAL;
 
         mutex_lock(&md->suspend_lock);
@@ -1510,19 +2192,96 @@ int dm_swap_table(struct mapped_device *md, struct dm_table *table)
         if (!dm_suspended(md))
                 goto out;
 
-        /* without bdev, the device size cannot be changed */
-        if (!md->suspended_bdev)
-                if (get_capacity(md->disk) != dm_table_get_size(table))
-                        goto out;
+        r = dm_calculate_queue_limits(table, &limits);
+        if (r)
+                goto out;
+
+        /* cannot change the device type, once a table is bound */
+        if (md->map &&
+            (dm_table_get_type(md->map) != dm_table_get_type(table))) {
+                DMWARN("can't change the device type after a table is bound");
+                goto out;
+        }
+
+        /*
+         * It is enought that blk_queue_ordered() is called only once when
+         * the first bio-based table is bound.
+         *
+         * This setting should be moved to alloc_dev() when request-based dm
+         * supports barrier.
+         */
+        if (!md->map && dm_table_bio_based(table))
+                blk_queue_ordered(md->queue, QUEUE_ORDERED_DRAIN, NULL);
 
         __unbind(md);
-        r = __bind(md, table);
+        r = __bind(md, table, &limits);
 
 out:
         mutex_unlock(&md->suspend_lock);
         return r;
 }
 
+static void dm_rq_invalidate_suspend_marker(struct mapped_device *md)
+{
+        md->suspend_rq.special = (void *)0x1;
+}
+
+static void dm_rq_abort_suspend(struct mapped_device *md, int noflush)
+{
+        struct request_queue *q = md->queue;
+        unsigned long flags;
+
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (!noflush)
+                dm_rq_invalidate_suspend_marker(md);
+        __start_queue(q);
+        spin_unlock_irqrestore(q->queue_lock, flags);
+}
+
+static void dm_rq_start_suspend(struct mapped_device *md, int noflush)
+{
+        struct request *rq = &md->suspend_rq;
+        struct request_queue *q = md->queue;
+
+        if (noflush)
+                stop_queue(q);
+        else {
+                blk_rq_init(q, rq);
+                blk_insert_request(q, rq, 0, NULL);
+        }
+}
+
+static int dm_rq_suspend_available(struct mapped_device *md, int noflush)
+{
+        int r = 1;
+        struct request *rq = &md->suspend_rq;
+        struct request_queue *q = md->queue;
+        unsigned long flags;
+
+        if (noflush)
+                return r;
+
+        /* The marker must be protected by queue lock if it is in use */
+        spin_lock_irqsave(q->queue_lock, flags);
+        if (unlikely(rq->ref_count)) {
+                /*
+                 * This can happen, when the previous flush suspend was
+                 * interrupted, the marker is still in the queue and
+                 * this flush suspend has been invoked, because we don't
+                 * remove the marker at the time of suspend interruption.
+                 * We have only one marker per mapped_device, so we can't
+                 * start another flush suspend while it is in use.
+                 */
+                BUG_ON(!rq->special); /* The marker should be invalidated */
+                DMWARN("Invalidating the previous flush suspend is still in"
+                       " progress.  Please retry later.");
+                r = 0;
+        }
+        spin_unlock_irqrestore(q->queue_lock, flags);
+
+        return r;
+}
+
 /*
  * Functions to lock and unlock any filesystem running on the
  * device.
@@ -1533,7 +2292,7 @@ static int lock_fs(struct mapped_device *md)
 
         WARN_ON(md->frozen_sb);
 
-        md->frozen_sb = freeze_bdev(md->suspended_bdev);
+        md->frozen_sb = freeze_bdev(md->bdev);
         if (IS_ERR(md->frozen_sb)) {
                 r = PTR_ERR(md->frozen_sb);
                 md->frozen_sb = NULL;
@@ -1542,9 +2301,6 @@ static int lock_fs(struct mapped_device *md)
 
         set_bit(DMF_FROZEN, &md->flags);
 
-        /* don't bdput right now, we don't want the bdev
-         * to go away while it is locked.
-         */
         return 0;
 }
 
@@ -1553,7 +2309,7 @@ static void unlock_fs(struct mapped_device *md)
         if (!test_bit(DMF_FROZEN, &md->flags))
                 return;
 
-        thaw_bdev(md->suspended_bdev, md->frozen_sb);
+        thaw_bdev(md->bdev, md->frozen_sb);
         md->frozen_sb = NULL;
         clear_bit(DMF_FROZEN, &md->flags);
 }
@@ -1565,6 +2321,53 @@ static void unlock_fs(struct mapped_device *md)
  * dm_bind_table, dm_suspend must be called to flush any in
  * flight bios and ensure that any further io gets deferred.
  */
+/*
+ * Suspend mechanism in request-based dm.
+ *
+ * After the suspend starts, further incoming requests are kept in
+ * the request_queue and deferred.
+ * Remaining requests in the request_queue at the start of suspend are flushed
+ * if it is flush suspend.
+ * The suspend completes when the following conditions have been satisfied,
+ * so wait for it:
+ *    1. q->in_flight is 0 (which means no in_flight request)
+ *    2. queue has been stopped (which means no request dispatching)
+ *
+ *
+ * Noflush suspend
+ * ---------------
+ * Noflush suspend doesn't need to dispatch remaining requests.
+ * So stop the queue immediately.  Then, wait for all in_flight requests
+ * to be completed or requeued.
+ *
+ * To abort noflush suspend, start the queue.
+ *
+ *
+ * Flush suspend
+ * -------------
+ * Flush suspend needs to dispatch remaining requests.  So stop the queue
+ * after the remaining requests are completed. (Requeued request must be also
+ * re-dispatched and completed.  Until then, we can't stop the queue.)
+ *
+ * During flushing the remaining requests, further incoming requests are also
+ * inserted to the same queue.  To distinguish which requests are to be
+ * flushed, we insert a marker request to the queue at the time of starting
+ * flush suspend, like a barrier.
+ * The dispatching is blocked when the marker is found on the top of the queue.
+ * And the queue is stopped when all in_flight requests are completed, since
+ * that means the remaining requests are completely flushed.
+ * Then, the marker is removed from the queue.
+ *
+ * To abort flush suspend, we also need to take care of the marker, not only
+ * starting the queue.
+ * We don't remove the marker forcibly from the queue since it's against
+ * the block-layer manner.  Instead, we put a invalidated mark on the marker.
+ * When the invalidated marker is found on the top of the queue, it is
+ * immediately removed from the queue, so it doesn't block dispatching.
+ * Because we have only one marker per mapped_device, we can't start another
+ * flush suspend until the invalidated marker is removed from the queue.
+ * So fail and return with -EBUSY in such a case.
+ */
 int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
 {
         struct dm_table *map = NULL;
@@ -1579,6 +2382,11 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
                 goto out_unlock;
         }
 
+        if (dm_request_based(md) && !dm_rq_suspend_available(md, noflush)) {
+                r = -EBUSY;
+                goto out_unlock;
+        }
+
         map = dm_get_table(md);
 
         /*
@@ -1591,24 +2399,14 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
         /* This does not get reverted if there's an error later. */
         dm_table_presuspend_targets(map);
 
-        /* bdget() can stall if the pending I/Os are not flushed */
-        if (!noflush) {
-                md->suspended_bdev = bdget_disk(md->disk, 0);
-                if (!md->suspended_bdev) {
-                        DMWARN("bdget failed in dm_suspend");
-                        r = -ENOMEM;
+        /*
+         * Flush I/O to the device. noflush supersedes do_lockfs,
+         * because lock_fs() needs to flush I/Os.
+         */
+        if (!noflush && do_lockfs) {
+                r = lock_fs(md);
+                if (r)
                         goto out;
-                }
-
-                /*
-                 * Flush I/O to the device. noflush supersedes do_lockfs,
-                 * because lock_fs() needs to flush I/Os.
-                 */
-                if (do_lockfs) {
-                        r = lock_fs(md);
-                        if (r)
-                                goto out;
-                }
         }
 
         /*
@@ -1634,6 +2432,9 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
 
         flush_workqueue(md->wq);
 
+        if (dm_request_based(md))
+                dm_rq_start_suspend(md, noflush);
+
         /*
          * At this point no more requests are entering target request routines.
          * We call dm_wait_for_completion to wait for all existing requests
@@ -1650,6 +2451,9 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
         if (r < 0) {
                 dm_queue_flush(md);
 
+                if (dm_request_based(md))
+                        dm_rq_abort_suspend(md, noflush);
+
                 unlock_fs(md);
                 goto out; /* pushback list is already flushed, so skip flush */
         }
@@ -1665,11 +2469,6 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
         set_bit(DMF_SUSPENDED, &md->flags);
 
 out:
-        if (r && md->suspended_bdev) {
-                bdput(md->suspended_bdev);
-                md->suspended_bdev = NULL;
-        }
-
         dm_table_put(map);
 
 out_unlock:
@@ -1696,21 +2495,20 @@ int dm_resume(struct mapped_device *md)
 
         dm_queue_flush(md);
 
-        unlock_fs(md);
+        /*
+         * Flushing deferred I/Os must be done after targets are resumed
+         * so that mapping of targets can work correctly.
+         * Request-based dm is queueing the deferred I/Os in its request_queue.
+         */
+        if (dm_request_based(md))
+                start_queue(md->queue);
 
-        if (md->suspended_bdev) {
-                bdput(md->suspended_bdev);
-                md->suspended_bdev = NULL;
-        }
+        unlock_fs(md);
 
         clear_bit(DMF_SUSPENDED, &md->flags);
 
         dm_table_unplug_all(map);
-
-        dm_kobject_uevent(md);
-
         r = 0;
-
 out:
         dm_table_put(map);
         mutex_unlock(&md->suspend_lock);
@@ -1721,9 +2519,19 @@ out:
 /*-----------------------------------------------------------------
  * Event notification.
  *---------------------------------------------------------------*/
-void dm_kobject_uevent(struct mapped_device *md)
-{
-        kobject_uevent(&disk_to_dev(md->disk)->kobj, KOBJ_CHANGE);
+void dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
+                       unsigned cookie)
+{
+        char udev_cookie[DM_COOKIE_LENGTH];
+        char *envp[] = { udev_cookie, NULL };
+
+        if (!cookie)
+                kobject_uevent(&disk_to_dev(md->disk)->kobj, action);
+        else {
+                snprintf(udev_cookie, DM_COOKIE_LENGTH, "%s=%u",
+                         DM_COOKIE_ENV_VAR_NAME, cookie);
+                kobject_uevent_env(&disk_to_dev(md->disk)->kobj, action, envp);
+        }
 }
 
 uint32_t dm_next_uevent_seq(struct mapped_device *md)
@@ -1777,6 +2585,10 @@ struct mapped_device *dm_get_from_kobject(struct kobject *kobj)
         if (&md->kobj != kobj)
                 return NULL;
 
+        if (test_bit(DMF_FREEING, &md->flags) ||
+            test_bit(DMF_DELETING, &md->flags))
+                return NULL;
+
         dm_get(md);
         return md;
 }
@@ -1797,6 +2609,61 @@ int dm_noflush_suspending(struct dm_target *ti)
 }
 EXPORT_SYMBOL_GPL(dm_noflush_suspending);
 
+struct dm_md_mempools *dm_alloc_md_mempools(unsigned type)
+{
+        struct dm_md_mempools *pools = kmalloc(sizeof(*pools), GFP_KERNEL);
+
+        if (!pools)
+                return NULL;
+
+        pools->io_pool = (type == DM_TYPE_BIO_BASED) ?
+                         mempool_create_slab_pool(MIN_IOS, _io_cache) :
+                         mempool_create_slab_pool(MIN_IOS, _rq_bio_info_cache);
+        if (!pools->io_pool)
+                goto free_pools_and_out;
+
+        pools->tio_pool = (type == DM_TYPE_BIO_BASED) ?
+                          mempool_create_slab_pool(MIN_IOS, _tio_cache) :
+                          mempool_create_slab_pool(MIN_IOS, _rq_tio_cache);
+        if (!pools->tio_pool)
+                goto free_io_pool_and_out;
+
+        pools->bs = (type == DM_TYPE_BIO_BASED) ?
+                    bioset_create(16, 0) : bioset_create(MIN_IOS, 0);
+        if (!pools->bs)
+                goto free_tio_pool_and_out;
+
+        return pools;
+
+free_tio_pool_and_out:
+        mempool_destroy(pools->tio_pool);
+
+free_io_pool_and_out:
+        mempool_destroy(pools->io_pool);
+
+free_pools_and_out:
+        kfree(pools);
+
+        return NULL;
+}
+
+void dm_free_md_mempools(struct dm_md_mempools *pools)
+{
+        if (!pools)
+                return;
+
+        if (pools->io_pool)
+                mempool_destroy(pools->io_pool);
+
+        if (pools->tio_pool)
+                mempool_destroy(pools->tio_pool);
+
+        if (pools->bs)
+                bioset_free(pools->bs);
+
+        kfree(pools);
+}
+
 static struct block_device_operations dm_blk_dops = {
         .open = dm_blk_open,
         .release = dm_blk_close,
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index a31506d93e91..23278ae80f08 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -23,6 +23,13 @@
 #define DM_SUSPEND_NOFLUSH_FLAG         (1 << 1)
 
 /*
+ * Type of table and mapped_device's mempool
+ */
+#define DM_TYPE_NONE            0
+#define DM_TYPE_BIO_BASED       1
+#define DM_TYPE_REQUEST_BASED   2
+
+/*
  * List of devices that a metadevice uses and should open/close.
  */
 struct dm_dev_internal {
@@ -32,6 +39,7 @@ struct dm_dev_internal {
 };
 
 struct dm_table;
+struct dm_md_mempools;
 
 /*-----------------------------------------------------------------
  * Internal table functions.
@@ -41,18 +49,34 @@ void dm_table_event_callback(struct dm_table *t,
                              void (*fn)(void *), void *context);
 struct dm_target *dm_table_get_target(struct dm_table *t, unsigned int index);
 struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector);
-void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q);
+int dm_calculate_queue_limits(struct dm_table *table,
+                              struct queue_limits *limits);
+void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
+                               struct queue_limits *limits);
 struct list_head *dm_table_get_devices(struct dm_table *t);
 void dm_table_presuspend_targets(struct dm_table *t);
 void dm_table_postsuspend_targets(struct dm_table *t);
 int dm_table_resume_targets(struct dm_table *t);
 int dm_table_any_congested(struct dm_table *t, int bdi_bits);
+int dm_table_any_busy_target(struct dm_table *t);
+int dm_table_set_type(struct dm_table *t);
+unsigned dm_table_get_type(struct dm_table *t);
+bool dm_table_bio_based(struct dm_table *t);
+bool dm_table_request_based(struct dm_table *t);
+int dm_table_alloc_md_mempools(struct dm_table *t);
+void dm_table_free_md_mempools(struct dm_table *t);
+struct dm_md_mempools *dm_table_get_md_mempools(struct dm_table *t);
 
 /*
  * To check the return value from dm_table_find_target().
  */
 #define dm_target_is_valid(t) ((t)->table)
 
+/*
+ * To check whether the target type is request-based or not (bio-based).
+ */
+#define dm_target_request_based(t) ((t)->type->map_rq != NULL)
+
 /*-----------------------------------------------------------------
  * A registry of target types.
  *---------------------------------------------------------------*/
@@ -92,9 +116,16 @@ void dm_stripe_exit(void);
 int dm_open_count(struct mapped_device *md);
 int dm_lock_for_deletion(struct mapped_device *md);
 
-void dm_kobject_uevent(struct mapped_device *md);
+void dm_kobject_uevent(struct mapped_device *md, enum kobject_action action,
+                       unsigned cookie);
 
 int dm_kcopyd_init(void);
 void dm_kcopyd_exit(void);
 
+/*
+ * Mempool operations
+ */
+struct dm_md_mempools *dm_alloc_md_mempools(unsigned type);
+void dm_free_md_mempools(struct dm_md_mempools *pools);
+
 #endif
diff --git a/drivers/media/common/ir-keymaps.c b/drivers/media/common/ir-keymaps.c
index 3fe158ac7bbf..4216328552f6 100644
--- a/drivers/media/common/ir-keymaps.c
+++ b/drivers/media/common/ir-keymaps.c
@@ -2750,3 +2750,26 @@ IR_KEYTAB_TYPE ir_codes_dm1105_nec[IR_KEYTAB_SIZE] = {
         [0x1b] = KEY_B,         /*recall*/
 };
 EXPORT_SYMBOL_GPL(ir_codes_dm1105_nec);
+
+/* EVGA inDtube
+   Devin Heitmueller <devin.heitmueller@gmail.com>
+ */
+IR_KEYTAB_TYPE ir_codes_evga_indtube[IR_KEYTAB_SIZE] = {
+        [0x12] = KEY_POWER,
+        [0x02] = KEY_MODE,      /* TV */
+        [0x14] = KEY_MUTE,
+        [0x1a] = KEY_CHANNELUP,
+        [0x16] = KEY_TV2,       /* PIP */
+        [0x1d] = KEY_VOLUMEUP,
+        [0x05] = KEY_CHANNELDOWN,
+        [0x0f] = KEY_PLAYPAUSE,
+        [0x19] = KEY_VOLUMEDOWN,
+        [0x1c] = KEY_REWIND,
+        [0x0d] = KEY_RECORD,
+        [0x18] = KEY_FORWARD,
+        [0x1e] = KEY_PREVIOUS,
+        [0x1b] = KEY_STOP,
+        [0x1f] = KEY_NEXT,
+        [0x13] = KEY_CAMERA,
+};
+EXPORT_SYMBOL_GPL(ir_codes_evga_indtube);
diff --git a/drivers/media/dvb/frontends/stv0900.h b/drivers/media/dvb/frontends/stv0900.h
index 8a1332c2031d..bf4e9b633044 100644
--- a/drivers/media/dvb/frontends/stv0900.h
+++ b/drivers/media/dvb/frontends/stv0900.h
@@ -29,6 +29,11 @@
 #include <linux/dvb/frontend.h>
 #include "dvb_frontend.h"
 
+struct stv0900_reg {
+        u16 addr;
+        u8  val;
+};
+
 struct stv0900_config {
         u8 demod_address;
         u32 xtal;
@@ -38,7 +43,7 @@ struct stv0900_config {
 
         u8 path1_mode;
         u8 path2_mode;
-
+        struct stv0900_reg *ts_config_regs;
         u8 tun1_maddress;/* 0, 1, 2, 3 for 0xc0, 0xc2, 0xc4, 0xc6 */
         u8 tun2_maddress;
         u8 tun1_adc;/* 1 for stv6110, 2 for stb6100 */
diff --git a/drivers/media/dvb/frontends/stv0900_core.c b/drivers/media/dvb/frontends/stv0900_core.c
index 8499bcf7f251..1da045fbb4ef 100644
--- a/drivers/media/dvb/frontends/stv0900_core.c
+++ b/drivers/media/dvb/frontends/stv0900_core.c
@@ -149,31 +149,31 @@ void stv0900_write_reg(struct stv0900_internal *i_params, u16 reg_addr,
                 dprintk(KERN_ERR "%s: i2c error %d\n", __func__, ret);
 }
 
-u8 stv0900_read_reg(struct stv0900_internal *i_params, u16 reg_addr)
+u8 stv0900_read_reg(struct stv0900_internal *i_params, u16 reg)
 {
-        u8 data[2];
         int ret;
-        struct i2c_msg i2cmsg = {
-                .addr  = i_params->i2c_addr,
-                .flags = 0,
-                .len   = 2,
-                .buf   = data,
+        u8 b0[] = { MSB(reg), LSB(reg) };
+        u8 buf = 0;
+        struct i2c_msg msg[] = {
+                {
+                        .addr   = i_params->i2c_addr,
+                        .flags  = 0,
+                        .buf = b0,
+                        .len = 2,
+                }, {
+                        .addr   = i_params->i2c_addr,
+                        .flags  = I2C_M_RD,
+                        .buf = &buf,
+                        .len = 1,
+                },
         };
 
-        data[0] = MSB(reg_addr);
-        data[1] = LSB(reg_addr);
-
-        ret = i2c_transfer(i_params->i2c_adap, &i2cmsg, 1);
-        if (ret != 1)
-                dprintk(KERN_ERR "%s: i2c error %d\n", __func__, ret);
-
-        i2cmsg.flags = I2C_M_RD;
-        i2cmsg.len = 1;
-        ret = i2c_transfer(i_params->i2c_adap, &i2cmsg, 1);
-        if (ret != 1)
-                dprintk(KERN_ERR "%s: i2c error %d\n", __func__, ret);
+        ret = i2c_transfer(i_params->i2c_adap, msg, 2);
+        if (ret != 2)
+                dprintk(KERN_ERR "%s: i2c error %d, reg[0x%02x]\n",
+                                __func__, ret, reg);
 
-        return data[0];
+        return buf;
 }
 
 void extract_mask_pos(u32 label, u8 *mask, u8 *pos)
@@ -712,6 +712,44 @@ static s32 stv0900_carr_get_quality(struct dvb_frontend *fe,
         return c_n;
 }
 
+static int stv0900_read_ucblocks(struct dvb_frontend *fe, u32 * ucblocks)
+{
+        struct stv0900_state *state = fe->demodulator_priv;
+        struct stv0900_internal *i_params = state->internal;
+        enum fe_stv0900_demod_num demod = state->demod;
+        u8 err_val1, err_val0;
+        s32 err_field1, err_field0;
+        u32 header_err_val = 0;
+
+        *ucblocks = 0x0;
+        if (stv0900_get_standard(fe, demod) == STV0900_DVBS2_STANDARD) {
+                /* DVB-S2 delineator errors count */
+
+                /* retreiving number for errnous headers */
+                dmd_reg(err_field0, R0900_P1_BBFCRCKO0,
+                                        R0900_P2_BBFCRCKO0);
+                dmd_reg(err_field1, R0900_P1_BBFCRCKO1,
+                                        R0900_P2_BBFCRCKO1);
+
+                err_val1 = stv0900_read_reg(i_params, err_field1);
+                err_val0 = stv0900_read_reg(i_params, err_field0);
+                header_err_val = (err_val1<<8) | err_val0;
+
+                /* retreiving number for errnous packets */
+                dmd_reg(err_field0, R0900_P1_UPCRCKO0,
+                                        R0900_P2_UPCRCKO0);
+                dmd_reg(err_field1, R0900_P1_UPCRCKO1,
+                                        R0900_P2_UPCRCKO1);
+
+                err_val1 = stv0900_read_reg(i_params, err_field1);
+                err_val0 = stv0900_read_reg(i_params, err_field0);
+                *ucblocks = (err_val1<<8) | err_val0;
+                *ucblocks += header_err_val;
+        }
+
+        return 0;
+}
+
 static int stv0900_read_snr(struct dvb_frontend *fe, u16 *snr)
 {
         *snr = stv0900_carr_get_quality(fe,
@@ -1355,7 +1393,7 @@ static enum fe_stv0900_error stv0900_init_internal(struct dvb_frontend *fe,
         struct stv0900_state *state = fe->demodulator_priv;
         enum fe_stv0900_error error = STV0900_NO_ERROR;
         enum fe_stv0900_error demodError = STV0900_NO_ERROR;
-        int selosci;
+        int selosci, i;
 
         struct stv0900_inode *temp_int = find_inode(state->i2c_adap,
                                                 state->config->demod_address);
@@ -1402,7 +1440,23 @@ static enum fe_stv0900_error stv0900_init_internal(struct dvb_frontend *fe,
                                 stv0900_write_bits(state->internal, F0900_P1_ROLLOFF_CONTROL, p_init->rolloff);
                                 stv0900_write_bits(state->internal, F0900_P2_ROLLOFF_CONTROL, p_init->rolloff);
 
-                                stv0900_set_ts_parallel_serial(state->internal, p_init->path1_ts_clock, p_init->path2_ts_clock);
+                                state->internal->ts_config = p_init->ts_config;
+                                if (state->internal->ts_config == NULL)
+                                        stv0900_set_ts_parallel_serial(state->internal,
+                                                        p_init->path1_ts_clock,
+                                                        p_init->path2_ts_clock);
+                                else {
+                                        for (i = 0; state->internal->ts_config[i].addr != 0xffff; i++)
+                                                stv0900_write_reg(state->internal,
+                                                                state->internal->ts_config[i].addr,
+                                                                state->internal->ts_config[i].val);
+
+                                        stv0900_write_bits(state->internal, F0900_P2_RST_HWARE, 1);
+                                        stv0900_write_bits(state->internal, F0900_P2_RST_HWARE, 0);
+                                        stv0900_write_bits(state->internal, F0900_P1_RST_HWARE, 1);
+                                        stv0900_write_bits(state->internal, F0900_P1_RST_HWARE, 0);
+                                }
+
                                 stv0900_write_bits(state->internal, F0900_P1_TUN_MADDRESS, p_init->tun1_maddress);
                                 switch (p_init->tuner1_adc) {
                                 case 1:
@@ -1882,6 +1936,7 @@ static struct dvb_frontend_ops stv0900_ops = {
         .read_ber                       = stv0900_read_ber,
         .read_signal_strength           = stv0900_read_signal_strength,
         .read_snr                       = stv0900_read_snr,
+        .read_ucblocks                  = stv0900_read_ucblocks,
 };
 
 struct dvb_frontend *stv0900_attach(const struct stv0900_config *config,
@@ -1915,6 +1970,7 @@ struct dvb_frontend *stv0900_attach(const struct stv0900_config *config,
                 init_params.tun1_iq_inversion   = STV0900_IQ_NORMAL;
                 init_params.tuner1_adc          = config->tun1_adc;
                 init_params.path2_ts_clock      = config->path2_mode;
+                init_params.ts_config           = config->ts_config_regs;
                 init_params.tun2_maddress       = config->tun2_maddress;
                 init_params.tuner2_adc          = config->tun2_adc;
                 init_params.tun2_iq_inversion   = STV0900_IQ_SWAPPED;
diff --git a/drivers/media/dvb/frontends/stv0900_priv.h b/drivers/media/dvb/frontends/stv0900_priv.h
index 67dc8ec634e2..5ed7a145c7d3 100644
--- a/drivers/media/dvb/frontends/stv0900_priv.h
+++ b/drivers/media/dvb/frontends/stv0900_priv.h
@@ -271,6 +271,7 @@ struct stv0900_init_params{
 
         /* IQ from the tuner2 to the demod */
         enum stv0900_iq_inversion       tun2_iq_inversion;
+        struct stv0900_reg              *ts_config;
 };
 
 struct stv0900_search_params {
@@ -363,6 +364,7 @@ struct stv0900_internal{
         u8                      i2c_addr;
         u8                      clkmode;/* 0 for CLKI, 2 for XTALI */
         u8                      chip_id;
+        struct stv0900_reg      *ts_config;
         enum fe_stv0900_error   errs;
         int dmds_used;
 };
diff --git a/drivers/media/dvb/frontends/stv090x.c b/drivers/media/dvb/frontends/stv090x.c
index 96ef745a2e4e..488bdfb34fb3 100644
--- a/drivers/media/dvb/frontends/stv090x.c
+++ b/drivers/media/dvb/frontends/stv090x.c
@@ -2674,7 +2674,7 @@ static u8 stv090x_optimize_carloop(struct stv090x_state *state, enum stv090x_mod
 
 static u8 stv090x_optimize_carloop_short(struct stv090x_state *state)
 {
-        struct stv090x_short_frame_crloop *short_crl;
+        struct stv090x_short_frame_crloop *short_crl = NULL;
         s32 index = 0;
         u8 aclc = 0x0b;
 
@@ -2694,10 +2694,13 @@ static u8 stv090x_optimize_carloop_short(struct stv090x_state *state)
                 break;
         }
 
-        if (state->dev_ver >= 0x30)
-                short_crl = stv090x_s2_short_crl_cut20;
-        else if (state->dev_ver >= 0x20)
+        if (state->dev_ver >= 0x30) {
+                /* Cut 3.0 and up */
                 short_crl = stv090x_s2_short_crl_cut30;
+        } else {
+                /* Cut 2.0 and up: we don't support cuts older than 2.0 */
+                short_crl = stv090x_s2_short_crl_cut20;
+        }
 
         if (state->srate <= 3000000)
                 aclc = short_crl[index].crl_2;
diff --git a/drivers/media/dvb/frontends/tda10048.c b/drivers/media/dvb/frontends/tda10048.c
index 4302c563a6b8..cc8862ce4aae 100644
--- a/drivers/media/dvb/frontends/tda10048.c
+++ b/drivers/media/dvb/frontends/tda10048.c
@@ -210,6 +210,7 @@ static struct pll_tab {
         { TDA10048_CLK_4000,  TDA10048_IF_36130, 10, 0, 0 },
         { TDA10048_CLK_16000, TDA10048_IF_3300,  10, 3, 0 },
         { TDA10048_CLK_16000, TDA10048_IF_3500,  10, 3, 0 },
+        { TDA10048_CLK_16000, TDA10048_IF_3800,  10, 3, 0 },
         { TDA10048_CLK_16000, TDA10048_IF_4000,  10, 3, 0 },
         { TDA10048_CLK_16000, TDA10048_IF_4300,  10, 3, 0 },
         { TDA10048_CLK_16000, TDA10048_IF_36130, 10, 3, 0 },
diff --git a/drivers/media/dvb/siano/smscoreapi.c b/drivers/media/dvb/siano/smscoreapi.c
index 32be382f0e97..a246903c3341 100644
--- a/drivers/media/dvb/siano/smscoreapi.c
+++ b/drivers/media/dvb/siano/smscoreapi.c
@@ -1422,8 +1422,8 @@ int smscore_gpio_configure(struct smscore_device_t *coredev, u8 PinNum,
                 struct smscore_gpio_config *pGpioConfig) {
 
         u32 totalLen;
-        u32 TranslatedPinNum;
-        u32 GroupNum;
+        u32 TranslatedPinNum = 0;
+        u32 GroupNum = 0;
         u32 ElectricChar;
         u32 groupCfg;
         void *buffer;
diff --git a/drivers/media/radio/radio-tea5764.c b/drivers/media/radio/radio-tea5764.c
index 393623818ade..3cd76dddb6aa 100644
--- a/drivers/media/radio/radio-tea5764.c
+++ b/drivers/media/radio/radio-tea5764.c
@@ -322,7 +322,9 @@ static int vidioc_g_tuner(struct file *file, void *priv,
         v->rangehigh  = FREQ_MAX * FREQ_MUL;
         v->capability = V4L2_TUNER_CAP_LOW | V4L2_TUNER_CAP_STEREO;
         if (r->tunchk & TEA5764_TUNCHK_STEREO)
-                        v->rxsubchans = V4L2_TUNER_SUB_STEREO;
+                v->rxsubchans = V4L2_TUNER_SUB_STEREO;
+        else
+                v->rxsubchans = V4L2_TUNER_SUB_MONO;
         v->audmode = tea5764_get_audout_mode(radio);
         v->signal = TEA5764_TUNCHK_LEVEL(r->tunchk) * 0xffff / 0xf;
         v->afc = TEA5764_TUNCHK_IFCNT(r->tunchk);
diff --git a/drivers/media/video/Kconfig b/drivers/media/video/Kconfig
index 94f440535c64..061e147f6f26 100644
--- a/drivers/media/video/Kconfig
+++ b/drivers/media/video/Kconfig
@@ -866,9 +866,13 @@ config USB_W9968CF
           module will be called w9968cf.
 
 config USB_OV511
-        tristate "USB OV511 Camera support"
+        tristate "USB OV511 Camera support (DEPRECATED)"
         depends on VIDEO_V4L1
         ---help---
+          This driver is DEPRECATED please use the gspca ov519 module
+          instead. Note that for the ov511 / ov518 support of the gspca module
+          you need atleast version 0.6.0 of libv4l.
+
           Say Y here if you want to connect this type of camera to your
           computer's USB port. See <file:Documentation/video4linux/ov511.txt>
           for more information and for a list of supported cameras.
diff --git a/drivers/media/video/cx18/cx18-controls.c b/drivers/media/video/cx18/cx18-controls.c
index 8e35c3aed544..5136df198338 100644
--- a/drivers/media/video/cx18/cx18-controls.c
+++ b/drivers/media/video/cx18/cx18-controls.c
@@ -61,6 +61,8 @@ int cx18_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *qctrl)
 
         switch (qctrl->id) {
         /* Standard V4L2 controls */
+        case V4L2_CID_USER_CLASS:
+                return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
         case V4L2_CID_BRIGHTNESS:
         case V4L2_CID_HUE:
         case V4L2_CID_SATURATION:
diff --git a/drivers/media/video/cx231xx/cx231xx-avcore.c b/drivers/media/video/cx231xx/cx231xx-avcore.c
index 6a9464079b4c..28f48f41f218 100644
--- a/drivers/media/video/cx231xx/cx231xx-avcore.c
+++ b/drivers/media/video/cx231xx/cx231xx-avcore.c
@@ -1052,22 +1052,13 @@ int cx231xx_set_audio_decoder_input(struct cx231xx *dev,
 /* Set resolution of the video */
 int cx231xx_resolution_set(struct cx231xx *dev)
 {
-        int width, height;
-        u32 hscale, vscale;
-        int status = 0;
-
-        width = dev->width;
-        height = dev->height;
-
-        get_scale(dev, width, height, &hscale, &vscale);
-
         /* set horzontal scale */
-        status = vid_blk_write_word(dev, HSCALE_CTRL, hscale);
+        int status = vid_blk_write_word(dev, HSCALE_CTRL, dev->hscale);
+        if (status)
+                return status;
 
         /* set vertical scale */
-        status = vid_blk_write_word(dev, VSCALE_CTRL, vscale);
-
-        return status;
+        return vid_blk_write_word(dev, VSCALE_CTRL, dev->vscale);
 }
 
 /******************************************************************************
@@ -2055,7 +2046,7 @@ int cx231xx_initialize_stream_xfer(struct cx231xx *dev, u32 media_type)
 
 int cx231xx_capture_start(struct cx231xx *dev, int start, u8 media_type)
 {
-        int rc;
+        int rc = -1;
         u32 ep_mask = -1;
         struct pcb_config *pcb_config;
 
diff --git a/drivers/media/video/cx231xx/cx231xx-video.c b/drivers/media/video/cx231xx/cx231xx-video.c
index a23ae73fe634..609bae6098d3 100644
--- a/drivers/media/video/cx231xx/cx231xx-video.c
+++ b/drivers/media/video/cx231xx/cx231xx-video.c
@@ -893,9 +893,9 @@ static int check_dev(struct cx231xx *dev)
         return 0;
 }
 
-void get_scale(struct cx231xx *dev,
-               unsigned int width, unsigned int height,
-               unsigned int *hscale, unsigned int *vscale)
+static void get_scale(struct cx231xx *dev,
+                      unsigned int width, unsigned int height,
+                      unsigned int *hscale, unsigned int *vscale)
 {
         unsigned int maxw = norm_maxw(dev);
         unsigned int maxh = norm_maxh(dev);
@@ -907,10 +907,6 @@ void get_scale(struct cx231xx *dev,
         *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
         if (*vscale >= 0x4000)
                 *vscale = 0x3fff;
-
-        dev->hscale = *hscale;
-        dev->vscale = *vscale;
-
 }
 
 /* ------------------------------------------------------------------
@@ -955,8 +951,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 {
         struct cx231xx_fh *fh = priv;
         struct cx231xx *dev = fh->dev;
-        int width = f->fmt.pix.width;
-        int height = f->fmt.pix.height;
+        unsigned int width = f->fmt.pix.width;
+        unsigned int height = f->fmt.pix.height;
         unsigned int maxw = norm_maxw(dev);
         unsigned int maxh = norm_maxh(dev);
         unsigned int hscale, vscale;
@@ -971,17 +967,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 
         /* width must even because of the YUYV format
            height must be even because of interlacing */
-        height &= 0xfffe;
-        width &= 0xfffe;
-
-        if (unlikely(height < 32))
-                height = 32;
-        if (unlikely(height > maxh))
-                height = maxh;
-        if (unlikely(width < 48))
-                width = 48;
-        if (unlikely(width > maxw))
-                width = maxw;
+        v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1, 0);
 
         get_scale(dev, width, height, &hscale, &vscale);
 
diff --git a/drivers/media/video/cx231xx/cx231xx.h b/drivers/media/video/cx231xx/cx231xx.h
index e38eb2d425f7..a0f823ac6b8d 100644
--- a/drivers/media/video/cx231xx/cx231xx.h
+++ b/drivers/media/video/cx231xx/cx231xx.h
@@ -722,9 +722,6 @@ int cx231xx_set_video_input_mux(struct cx231xx *dev, u8 input);
 int cx231xx_set_decoder_video_input(struct cx231xx *dev, u8 pin_type, u8 input);
 int cx231xx_do_mode_ctrl_overrides(struct cx231xx *dev);
 int cx231xx_set_audio_input(struct cx231xx *dev, u8 input);
-void get_scale(struct cx231xx *dev,
-               unsigned int width, unsigned int height,
-               unsigned int *hscale, unsigned int *vscale);
 
 /* Provided by cx231xx-video.c */
 int cx231xx_register_extension(struct cx231xx_ops *dev);
diff --git a/drivers/media/video/cx2341x.c b/drivers/media/video/cx2341x.c
index 8ded52946334..4c8e95853fa3 100644
--- a/drivers/media/video/cx2341x.c
+++ b/drivers/media/video/cx2341x.c
@@ -500,6 +500,8 @@ int cx2341x_ctrl_query(const struct cx2341x_mpeg_params *params,
         int err;
 
         switch (qctrl->id) {
+        case V4L2_CID_MPEG_CLASS:
+                return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
         case V4L2_CID_MPEG_STREAM_TYPE:
                 return v4l2_ctrl_query_fill(qctrl,
                                 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index e236df23370e..48a975134ac5 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -45,6 +45,7 @@
 #include "dibx000_common.h"
 #include "zl10353.h"
 #include "stv0900.h"
+#include "stv0900_reg.h"
 #include "stv6110.h"
 #include "lnbh24.h"
 #include "cx24116.h"
@@ -242,12 +243,22 @@ static struct tda18271_std_map hauppauge_tda18271_std_map = {
                       .if_lvl = 6, .rfagc_top = 0x37 },
 };
 
+static struct tda18271_std_map hauppauge_hvr1200_tda18271_std_map = {
+        .dvbt_6   = { .if_freq = 3300, .agc_mode = 3, .std = 4,
+                      .if_lvl = 1, .rfagc_top = 0x37, },
+        .dvbt_7   = { .if_freq = 3800, .agc_mode = 3, .std = 5,
+                      .if_lvl = 1, .rfagc_top = 0x37, },
+        .dvbt_8   = { .if_freq = 4300, .agc_mode = 3, .std = 6,
+                      .if_lvl = 1, .rfagc_top = 0x37, },
+};
+
 static struct tda18271_config hauppauge_tda18271_config = {
         .std_map = &hauppauge_tda18271_std_map,
         .gate    = TDA18271_GATE_ANALOG,
 };
 
 static struct tda18271_config hauppauge_hvr1200_tuner_config = {
+        .std_map = &hauppauge_hvr1200_tda18271_std_map,
         .gate    = TDA18271_GATE_ANALOG,
 };
 
@@ -370,13 +381,25 @@ static struct zl10353_config dvico_fusionhdtv_xc3028 = {
         .disable_i2c_gate_ctrl = 1,
 };
 
+static struct stv0900_reg stv0900_ts_regs[] = {
+        { R0900_TSGENERAL, 0x00 },
+        { R0900_P1_TSSPEED, 0x40 },
+        { R0900_P2_TSSPEED, 0x40 },
+        { R0900_P1_TSCFGM, 0xc0 },
+        { R0900_P2_TSCFGM, 0xc0 },
+        { R0900_P1_TSCFGH, 0xe0 },
+        { R0900_P2_TSCFGH, 0xe0 },
+        { R0900_P1_TSCFGL, 0x20 },
+        { R0900_P2_TSCFGL, 0x20 },
+        { 0xffff, 0xff }, /* terminate */
+};
+
 static struct stv0900_config netup_stv0900_config = {
         .demod_address = 0x68,
         .xtal = 27000000,
         .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
         .diseqc_mode = 2,/* 2/3 PWM */
-        .path1_mode = 2,/*Serial continues clock */
-        .path2_mode = 2,/*Serial continues clock */
+        .ts_config_regs = stv0900_ts_regs,
         .tun1_maddress = 0,/* 0x60 */
         .tun2_maddress = 3,/* 0x63 */
         .tun1_adc = 1,/* 1 Vpp */
@@ -736,7 +759,8 @@ static int dvb_register(struct cx23885_tsport *port)
                                         if (!dvb_attach(lnbh24_attach,
                                                         fe0->dvb.frontend,
                                                         &i2c_bus->i2c_adap,
-                                                        LNBH24_PCL, 0, 0x09))
+                                                        LNBH24_PCL,
+                                                        LNBH24_TTX, 0x09))
                                                 printk(KERN_ERR
                                                         "No LNBH24 found!\n");
 
@@ -756,7 +780,8 @@ static int dvb_register(struct cx23885_tsport *port)
                                         if (!dvb_attach(lnbh24_attach,
                                                         fe0->dvb.frontend,
                                                         &i2c_bus->i2c_adap,
-                                                        LNBH24_PCL, 0, 0x0a))
+                                                        LNBH24_PCL,
+                                                        LNBH24_TTX, 0x0a))
                                                 printk(KERN_ERR
                                                         "No LNBH24 found!\n");
 
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index 66bbd2e71105..70836af3ab48 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -963,15 +963,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         }
 
         f->fmt.pix.field = field;
-        if (f->fmt.pix.height < 32)
-                f->fmt.pix.height = 32;
-        if (f->fmt.pix.height > maxh)
-                f->fmt.pix.height = maxh;
-        if (f->fmt.pix.width < 48)
-                f->fmt.pix.width = 48;
-        if (f->fmt.pix.width > maxw)
-                f->fmt.pix.width = maxw;
-        f->fmt.pix.width &= ~0x03;
+        v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
+                              &f->fmt.pix.height, 32, maxh, 0, 0);
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
diff --git a/drivers/media/video/cx88/cx88-cards.c b/drivers/media/video/cx88/cx88-cards.c
index 94b7a52629d0..a5cc1c1fc2d6 100644
--- a/drivers/media/video/cx88/cx88-cards.c
+++ b/drivers/media/video/cx88/cx88-cards.c
@@ -1524,33 +1524,45 @@ static const struct cx88_board cx88_boards[] = {
                 },
                 .mpeg           = CX88_MPEG_DVB,
         },
+        /* Terry Wu <terrywu2009@gmail.com> */
+        /* TV Audio :      set GPIO 2, 18, 19 value to 0, 1, 0 */
+        /* FM Audio :      set GPIO 2, 18, 19 value to 0, 0, 0 */
+        /* Line-in Audio : set GPIO 2, 18, 19 value to 0, 1, 1 */
+        /* Mute Audio :    set GPIO 2 value to 1               */
         [CX88_BOARD_WINFAST_TV2000_XP_GLOBAL] = {
-                .name           = "Winfast TV2000 XP Global",
+                .name           = "Leadtek TV2000 XP Global",
                 .tuner_type     = TUNER_XC2028,
                 .tuner_addr     = 0x61,
+                .radio_type     = TUNER_XC2028,
+                .radio_addr     = 0x61,
                 .input          = { {
                         .type   = CX88_VMUX_TELEVISION,
                         .vmux   = 0,
-                        .gpio0  = 0x0400, /* pin 2:mute = 0 (off?) */
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
                         .gpio1  = 0x0000,
-                        .gpio2  = 0x0800, /* pin 19:audio = 0 (tv) */
-
+                        .gpio2  = 0x0C04,       /* pin 18 = 1, pin 19 = 0 */
+                        .gpio3  = 0x0000,
                 }, {
                         .type   = CX88_VMUX_COMPOSITE1,
                         .vmux   = 1,
-                        .gpio0  = 0x0400, /* probably?  or 0x0404 to turn mute on */
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
                         .gpio1  = 0x0000,
-                        .gpio2  = 0x0808, /* pin 19:audio = 1 (line) */
-
+                        .gpio2  = 0x0C0C,       /* pin 18 = 1, pin 19 = 1 */
+                        .gpio3  = 0x0000,
                 }, {
                         .type   = CX88_VMUX_SVIDEO,
                         .vmux   = 2,
+                        .gpio0  = 0x0400,       /* pin 2 = 0 */
+                        .gpio1  = 0x0000,
+                        .gpio2  = 0x0C0C,       /* pin 18 = 1, pin 19 = 1 */
+                        .gpio3  = 0x0000,
                 } },
                 .radio = {
                         .type   = CX88_RADIO,
-                        .gpio0  = 0x004ff,
-                        .gpio1  = 0x010ff,
-                        .gpio2  = 0x0ff,
+                        .gpio0  = 0x0400,        /* pin 2 = 0 */
+                        .gpio1  = 0x0000,
+                        .gpio2  = 0x0C00,       /* pin 18 = 0, pin 19 = 0 */
+                        .gpio3  = 0x0000,
                 },
         },
         [CX88_BOARD_POWERCOLOR_REAL_ANGEL] = {
@@ -2438,6 +2450,41 @@ static const struct cx88_subid cx88_subids[] = {
                 .subvendor = 0x107d,
                 .subdevice = 0x6654,
                 .card      = CX88_BOARD_WINFAST_DTV1800H,
+        }, {
+                /* PVR2000 PAL Model [107d:6630] */
+                .subvendor = 0x107d,
+                .subdevice = 0x6630,
+                .card      = CX88_BOARD_LEADTEK_PVR2000,
+        }, {
+                /* PVR2000 PAL Model [107d:6638] */
+                .subvendor = 0x107d,
+                .subdevice = 0x6638,
+                .card      = CX88_BOARD_LEADTEK_PVR2000,
+        }, {
+                /* PVR2000 NTSC Model [107d:6631] */
+                .subvendor = 0x107d,
+                .subdevice = 0x6631,
+                .card      = CX88_BOARD_LEADTEK_PVR2000,
+        }, {
+                /* PVR2000 NTSC Model [107d:6637] */
+                .subvendor = 0x107d,
+                .subdevice = 0x6637,
+                .card      = CX88_BOARD_LEADTEK_PVR2000,
+        }, {
+                /* PVR2000 NTSC Model [107d:663d] */
+                .subvendor = 0x107d,
+                .subdevice = 0x663d,
+                .card      = CX88_BOARD_LEADTEK_PVR2000,
+        }, {
+                /* DV2000 NTSC Model [107d:6621] */
+                .subvendor = 0x107d,
+                .subdevice = 0x6621,
+                .card      = CX88_BOARD_WINFAST_DV2000,
+        }, {
+                /* TV2000 XP Global [107d:6618]  */
+                .subvendor = 0x107d,
+                .subdevice = 0x6618,
+                .card      = CX88_BOARD_WINFAST_TV2000_XP_GLOBAL,
         },
 };
 
@@ -2446,12 +2493,6 @@ static const struct cx88_subid cx88_subids[] = {
 
 static void leadtek_eeprom(struct cx88_core *core, u8 *eeprom_data)
 {
-        /* This is just for the "Winfast 2000XP Expert" board ATM; I don't have data on
-         * any others.
-         *
-         * Byte 0 is 1 on the NTSC board.
-         */
-
         if (eeprom_data[4] != 0x7d ||
             eeprom_data[5] != 0x10 ||
             eeprom_data[7] != 0x66) {
@@ -2459,8 +2500,19 @@ static void leadtek_eeprom(struct cx88_core *core, u8 *eeprom_data)
                 return;
         }
 
-        core->board.tuner_type = (eeprom_data[6] == 0x13) ?
-                TUNER_PHILIPS_FM1236_MK3 : TUNER_PHILIPS_FM1216ME_MK3;
+        /* Terry Wu <terrywu2009@gmail.com> */
+        switch (eeprom_data[6]) {
+        case 0x13: /* SSID 6613 for TV2000 XP Expert NTSC Model */
+        case 0x21: /* SSID 6621 for DV2000 NTSC Model */
+        case 0x31: /* SSID 6631 for PVR2000 NTSC Model */
+        case 0x37: /* SSID 6637 for PVR2000 NTSC Model */
+        case 0x3d: /* SSID 6637 for PVR2000 NTSC Model */
+                core->board.tuner_type = TUNER_PHILIPS_FM1236_MK3;
+                break;
+        default:
+                core->board.tuner_type = TUNER_PHILIPS_FM1216ME_MK3;
+                break;
+        }
 
         info_printk(core, "Leadtek Winfast 2000XP Expert config: "
                     "tuner=%d, eeprom[0]=0x%02x\n",
@@ -2713,7 +2765,6 @@ static int cx88_xc2028_tuner_callback(struct cx88_core *core,
 {
         /* Board-specific callbacks */
         switch (core->boardnr) {
-        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
         case CX88_BOARD_POWERCOLOR_REAL_ANGEL:
         case CX88_BOARD_GENIATECH_X8000_MT:
         case CX88_BOARD_KWORLD_ATSC_120:
@@ -2725,6 +2776,7 @@ static int cx88_xc2028_tuner_callback(struct cx88_core *core,
         case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PRO:
         case CX88_BOARD_DVICO_FUSIONHDTV_5_PCI_NANO:
                 return cx88_dvico_xc2028_callback(core, command, arg);
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
         case CX88_BOARD_WINFAST_DTV1800H:
                 return cx88_xc3028_winfast1800h_callback(core, command, arg);
         }
@@ -2914,6 +2966,7 @@ static void cx88_card_setup_pre_i2c(struct cx88_core *core)
                 udelay(1000);
                 break;
 
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
         case CX88_BOARD_WINFAST_DTV1800H:
                 /* GPIO 12 (xc3028 tuner reset) */
                 cx_set(MO_GP1_IO, 0x1010);
@@ -2950,6 +3003,7 @@ void cx88_setup_xc3028(struct cx88_core *core, struct xc2028_ctrl *ctl)
         case CX88_BOARD_DVICO_FUSIONHDTV_5_PCI_NANO:
                 ctl->demod = XC3028_FE_OREN538;
                 break;
+        case CX88_BOARD_WINFAST_TV2000_XP_GLOBAL:
         case CX88_BOARD_PROLINK_PV_GLOBAL_XTREME:
         case CX88_BOARD_PROLINK_PV_8000GT:
                 /*
@@ -2993,6 +3047,8 @@ static void cx88_card_setup(struct cx88_core *core)
                 if (0 == core->i2c_rc)
                         gdi_eeprom(core, eeprom);
                 break;
+        case CX88_BOARD_LEADTEK_PVR2000:
+        case CX88_BOARD_WINFAST_DV2000:
         case CX88_BOARD_WINFAST2000XP_EXPERT:
                 if (0 == core->i2c_rc)
                         leadtek_eeprom(core, eeprom);
diff --git a/drivers/media/video/cx88/cx88-video.c b/drivers/media/video/cx88/cx88-video.c
index 0ccac702bea4..b12770848c00 100644
--- a/drivers/media/video/cx88/cx88-video.c
+++ b/drivers/media/video/cx88/cx88-video.c
@@ -1111,15 +1111,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         }
 
         f->fmt.pix.field = field;
-        if (f->fmt.pix.height < 32)
-                f->fmt.pix.height = 32;
-        if (f->fmt.pix.height > maxh)
-                f->fmt.pix.height = maxh;
-        if (f->fmt.pix.width < 48)
-                f->fmt.pix.width = 48;
-        if (f->fmt.pix.width > maxw)
-                f->fmt.pix.width = maxw;
-        f->fmt.pix.width &= ~0x03;
+        v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
+                              &f->fmt.pix.height, 32, maxh, 0, 0);
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 00cc791a9e44..c43fdb9bc888 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -139,6 +139,24 @@ static struct em28xx_reg_seq kworld_330u_digital[] = {
         { -1,                   -1,     -1,             -1},
 };
 
+/* Evga inDtube
+   GPIO0 - Enable digital power (s5h1409) - low to enable
+   GPIO1 - Enable analog power (tvp5150/emp202) - low to enable
+   GPIO4 - xc3028 reset
+   GOP3  - s5h1409 reset
+ */
+static struct em28xx_reg_seq evga_indtube_analog[] = {
+        {EM28XX_R08_GPIO,       0x79,   0xff,           60},
+        {       -1,             -1,     -1,             -1},
+};
+
+static struct em28xx_reg_seq evga_indtube_digital[] = {
+        {EM28XX_R08_GPIO,       0x7a,   0xff,            1},
+        {EM2880_R04_GPO,        0x04,   0xff,           10},
+        {EM2880_R04_GPO,        0x0c,   0xff,            1},
+        { -1,                   -1,     -1,             -1},
+};
+
 /* Callback for the most boards */
 static struct em28xx_reg_seq default_tuner_gpio[] = {
         {EM28XX_R08_GPIO,       EM_GPIO_4,      EM_GPIO_4,      10},
@@ -1449,6 +1467,33 @@ struct em28xx_board em28xx_boards[] = {
                         .gpio     = terratec_av350_unmute_gpio,
                 } },
         },
+        [EM2882_BOARD_EVGA_INDTUBE] = {
+                .name         = "Evga inDtube",
+                .tuner_type   = TUNER_XC2028,
+                .tuner_gpio   = default_tuner_gpio,
+                .decoder      = EM28XX_TVP5150,
+                .xclk         = EM28XX_XCLK_FREQUENCY_12MHZ, /* NEC IR */
+                .mts_firmware = 1,
+                .has_dvb      = 1,
+                .dvb_gpio     = evga_indtube_digital,
+                .ir_codes     = ir_codes_evga_indtube,
+                .input        = { {
+                        .type     = EM28XX_VMUX_TELEVISION,
+                        .vmux     = TVP5150_COMPOSITE0,
+                        .amux     = EM28XX_AMUX_VIDEO,
+                        .gpio     = evga_indtube_analog,
+                }, {
+                        .type     = EM28XX_VMUX_COMPOSITE1,
+                        .vmux     = TVP5150_COMPOSITE1,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                        .gpio     = evga_indtube_analog,
+                }, {
+                        .type     = EM28XX_VMUX_SVIDEO,
+                        .vmux     = TVP5150_SVIDEO,
+                        .amux     = EM28XX_AMUX_LINE_IN,
+                        .gpio     = evga_indtube_analog,
+                } },
+        },
 };
 const unsigned int em28xx_bcount = ARRAY_SIZE(em28xx_boards);
 
@@ -1571,6 +1616,7 @@ static struct em28xx_hash_table em28xx_eeprom_hash[] = {
         {0x72cc5a8b, EM2820_BOARD_PROLINK_PLAYTV_BOX4_USB2, TUNER_YMEC_TVF_5533MF},
         {0x966a0441, EM2880_BOARD_KWORLD_DVB_310U, TUNER_XC2028},
         {0x9567eb1a, EM2880_BOARD_EMPIRE_DUAL_TV, TUNER_XC2028},
+        {0xcee44a99, EM2882_BOARD_EVGA_INDTUBE, TUNER_XC2028},
 };
 
 /* I2C devicelist hash table for devices with generic USB IDs */
@@ -1834,6 +1880,10 @@ static void em28xx_setup_xc3028(struct em28xx *dev, struct xc2028_ctrl *ctl)
                 ctl->demod = XC3028_FE_CHINA;
                 ctl->fname = XC2028_DEFAULT_FIRMWARE;
                 break;
+        case EM2882_BOARD_EVGA_INDTUBE:
+                ctl->demod = XC3028_FE_CHINA;
+                ctl->fname = XC3028L_DEFAULT_FIRMWARE;
+                break;
         default:
                 ctl->demod = XC3028_FE_OREN538;
         }
@@ -2101,6 +2151,12 @@ void em28xx_card_setup(struct em28xx *dev)
         case EM2880_BOARD_MSI_DIGIVOX_AD:
                 if (!em28xx_hint_board(dev))
                         em28xx_set_model(dev);
+
+                /* In cases where we had to use a board hint, the call to
+                   em28xx_set_mode() in em28xx_pre_card_setup() was a no-op,
+                   so make the call now so the analog GPIOs are set properly
+                   before probing the i2c bus. */
+                em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
                 break;
         }
 
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
index 563dd2b1c8e9..e7b47c8da8f3 100644
--- a/drivers/media/video/em28xx/em28xx-dvb.c
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -445,6 +445,7 @@ static int dvb_init(struct em28xx *dev)
                 }
                 break;
         case EM2883_BOARD_KWORLD_HYBRID_330U:
+        case EM2882_BOARD_EVGA_INDTUBE:
                 dvb->frontend = dvb_attach(s5h1409_attach,
                                            &em28xx_s5h1409_with_xc3028,
                                            &dev->i2c_adap);
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
index 882796e84dbc..8fe1beecfffa 100644
--- a/drivers/media/video/em28xx/em28xx-video.c
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -687,8 +687,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 {
         struct em28xx_fh      *fh    = priv;
         struct em28xx         *dev   = fh->dev;
-        int                   width  = f->fmt.pix.width;
-        int                   height = f->fmt.pix.height;
+        unsigned int          width  = f->fmt.pix.width;
+        unsigned int          height = f->fmt.pix.height;
         unsigned int          maxw   = norm_maxw(dev);
         unsigned int          maxh   = norm_maxh(dev);
         unsigned int          hscale, vscale;
@@ -701,34 +701,20 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
                 return -EINVAL;
         }
 
-        /* width must even because of the YUYV format
-           height must be even because of interlacing */
-        height &= 0xfffe;
-        width  &= 0xfffe;
-
-        if (unlikely(height < 32))
-                height = 32;
-        if (unlikely(height > maxh))
-                height = maxh;
-        if (unlikely(width < 48))
-                width = 48;
-        if (unlikely(width > maxw))
-                width = maxw;
-
         if (dev->board.is_em2800) {
                 /* the em2800 can only scale down to 50% */
-                if (height % (maxh / 2))
-                        height = maxh;
-                if (width % (maxw / 2))
-                        width = maxw;
-                /* according to empiatech support */
-                /* the MaxPacketSize is to small to support */
-                /* framesizes larger than 640x480 @ 30 fps */
-                /* or 640x576 @ 25 fps. As this would cut */
-                /* of a part of the image we prefer */
-                /* 360x576 or 360x480 for now */
+                height = height > (3 * maxh / 4) ? maxh : maxh / 2;
+                width = width > (3 * maxw / 4) ? maxw : maxw / 2;
+                /* According to empiatech support the MaxPacketSize is too small
+                 * to support framesizes larger than 640x480 @ 30 fps or 640x576
+                 * @ 25 fps.  As this would cut of a part of the image we prefer
+                 * 360x576 or 360x480 for now */
                 if (width == maxw && height == maxh)
                         width /= 2;
+        } else {
+                /* width must even because of the YUYV format
+                   height must be even because of interlacing */
+                v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh, 1, 0);
         }
 
         get_scale(dev, width, height, &hscale, &vscale);
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
index 8bf81be1da61..813ce45c2f99 100644
--- a/drivers/media/video/em28xx/em28xx.h
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -106,6 +106,7 @@
 #define EM2860_BOARD_TERRATEC_GRABBY              67
 #define EM2860_BOARD_TERRATEC_AV350               68
 #define EM2882_BOARD_KWORLD_ATSC_315U             69
+#define EM2882_BOARD_EVGA_INDTUBE                 70
 
 /* Limits minimum and default number of buffers */
 #define EM28XX_MIN_BUF 4
diff --git a/drivers/media/video/gspca/gspca.c b/drivers/media/video/gspca/gspca.c
index f7e0355ad644..1e89600986c8 100644
--- a/drivers/media/video/gspca/gspca.c
+++ b/drivers/media/video/gspca/gspca.c
@@ -1042,13 +1042,11 @@ static int vidioc_queryctrl(struct file *file, void *priv,
                 for (i = 0; i < gspca_dev->sd_desc->nctrls; i++) {
                         if (gspca_dev->ctrl_dis & (1 << i))
                                 continue;
-                        if (ctrls->qctrl.id < id)
+                        if (gspca_dev->sd_desc->ctrls[i].qctrl.id < id)
                                 continue;
-                        if (ctrls != NULL) {
-                                if (gspca_dev->sd_desc->ctrls[i].qctrl.id
+                        if (ctrls && gspca_dev->sd_desc->ctrls[i].qctrl.id
                                             > ctrls->qctrl.id)
-                                        continue;
-                        }
+                                continue;
                         ctrls = &gspca_dev->sd_desc->ctrls[i];
                 }
         } else {
diff --git a/drivers/media/video/gspca/ov519.c b/drivers/media/video/gspca/ov519.c
index 188866ac6cef..2f6e135d94bc 100644
--- a/drivers/media/video/gspca/ov519.c
+++ b/drivers/media/video/gspca/ov519.c
@@ -50,12 +50,18 @@ static int i2c_detect_tries = 10;
 struct sd {
         struct gspca_dev gspca_dev;             /* !! must be the first item */
 
+        __u8 packet_nr;
+
         char bridge;
 #define BRIDGE_OV511            0
 #define BRIDGE_OV511PLUS        1
 #define BRIDGE_OV518            2
 #define BRIDGE_OV518PLUS        3
 #define BRIDGE_OV519            4
+#define BRIDGE_MASK             7
+
+        char invert_led;
+#define BRIDGE_INVERT_LED       8
 
         /* Determined by sensor type */
         __u8 sif;
@@ -65,22 +71,25 @@ struct sd {
         __u8 colors;
         __u8 hflip;
         __u8 vflip;
+        __u8 autobrightness;
+        __u8 freq;
 
         __u8 stopped;           /* Streaming is temporarily paused */
 
-        __u8 frame_rate;        /* current Framerate (OV519 only) */
-        __u8 clockdiv;          /* clockdiv override for OV519 only */
+        __u8 frame_rate;        /* current Framerate */
+        __u8 clockdiv;          /* clockdiv override */
 
         char sensor;            /* Type of image sensor chip (SEN_*) */
 #define SEN_UNKNOWN 0
 #define SEN_OV6620 1
 #define SEN_OV6630 2
-#define SEN_OV7610 3
-#define SEN_OV7620 4
-#define SEN_OV7640 5
-#define SEN_OV7670 6
-#define SEN_OV76BE 7
-#define SEN_OV8610 8
+#define SEN_OV66308AF 3
+#define SEN_OV7610 4
+#define SEN_OV7620 5
+#define SEN_OV7640 6
+#define SEN_OV7670 7
+#define SEN_OV76BE 8
+#define SEN_OV8610 9
 };
 
 /* V4L2 controls supported by the driver */
@@ -94,11 +103,17 @@ static int sd_sethflip(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_gethflip(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setautobrightness(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getautobrightness(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 static void setbrightness(struct gspca_dev *gspca_dev);
 static void setcontrast(struct gspca_dev *gspca_dev);
 static void setcolors(struct gspca_dev *gspca_dev);
+static void setautobrightness(struct sd *sd);
+static void setfreq(struct sd *sd);
 
-static struct ctrl sd_ctrls[] = {
+static const struct ctrl sd_ctrls[] = {
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -141,7 +156,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setcolors,
             .get = sd_getcolors,
         },
-/* next controls work with ov7670 only */
+/* The flip controls work with ov7670 only */
 #define HFLIP_IDX 3
         {
             {
@@ -172,6 +187,51 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setvflip,
             .get = sd_getvflip,
         },
+#define AUTOBRIGHT_IDX 5
+        {
+            {
+                .id      = V4L2_CID_AUTOBRIGHTNESS,
+                .type    = V4L2_CTRL_TYPE_BOOLEAN,
+                .name    = "Auto Brightness",
+                .minimum = 0,
+                .maximum = 1,
+                .step    = 1,
+#define AUTOBRIGHT_DEF 1
+                .default_value = AUTOBRIGHT_DEF,
+            },
+            .set = sd_setautobrightness,
+            .get = sd_getautobrightness,
+        },
+#define FREQ_IDX 6
+        {
+            {
+                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
+                .type    = V4L2_CTRL_TYPE_MENU,
+                .name    = "Light frequency filter",
+                .minimum = 0,
+                .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
+                .step    = 1,
+#define FREQ_DEF 0
+                .default_value = FREQ_DEF,
+            },
+            .set = sd_setfreq,
+            .get = sd_getfreq,
+        },
+#define OV7670_FREQ_IDX 7
+        {
+            {
+                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
+                .type    = V4L2_CTRL_TYPE_MENU,
+                .name    = "Light frequency filter",
+                .minimum = 0,
+                .maximum = 3,   /* 0: 0, 1: 50Hz, 2:60Hz 3: Auto Hz */
+                .step    = 1,
+#define OV7670_FREQ_DEF 3
+                .default_value = OV7670_FREQ_DEF,
+            },
+            .set = sd_setfreq,
+            .get = sd_getfreq,
+        },
 };
 
 static const struct v4l2_pix_format ov519_vga_mode[] = {
@@ -187,11 +247,21 @@ static const struct v4l2_pix_format ov519_vga_mode[] = {
                 .priv = 0},
 };
 static const struct v4l2_pix_format ov519_sif_mode[] = {
+        {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 160 * 120 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 3},
         {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 176,
                 .sizeimage = 176 * 144 * 3 / 8 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 1},
+        {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3 / 8 + 590,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 2},
         {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 352,
                 .sizeimage = 352 * 288 * 3 / 8 + 590,
@@ -199,42 +269,118 @@ static const struct v4l2_pix_format ov519_sif_mode[] = {
                 .priv = 0},
 };
 
+/* Note some of the sizeimage values for the ov511 / ov518 may seem
+   larger then necessary, however they need to be this big as the ov511 /
+   ov518 always fills the entire isoc frame, using 0 padding bytes when
+   it doesn't have any data. So with low framerates the amount of data
+   transfered can become quite large (libv4l will remove all the 0 padding
+   in userspace). */
 static const struct v4l2_pix_format ov518_vga_mode[] = {
         {320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
                 .bytesperline = 320,
-                .sizeimage = 320 * 240 * 3 / 8 + 590,
+                .sizeimage = 320 * 240 * 3,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 1},
         {640, 480, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
                 .bytesperline = 640,
-                .sizeimage = 640 * 480 * 3 / 8 + 590,
+                .sizeimage = 640 * 480 * 2,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 0},
 };
 static const struct v4l2_pix_format ov518_sif_mode[] = {
+        {160, 120, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 70000,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 3},
         {176, 144, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
                 .bytesperline = 176,
-                .sizeimage = 40000,
+                .sizeimage = 70000,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 1},
+        {320, 240, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 2},
         {352, 288, V4L2_PIX_FMT_OV518, V4L2_FIELD_NONE,
                 .bytesperline = 352,
-                .sizeimage = 352 * 288 * 3 / 8 + 590,
+                .sizeimage = 352 * 288 * 3,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 0},
 };
 
+static const struct v4l2_pix_format ov511_vga_mode[] = {
+        {320, 240, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 1},
+        {640, 480, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
+                .bytesperline = 640,
+                .sizeimage = 640 * 480 * 2,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 0},
+};
+static const struct v4l2_pix_format ov511_sif_mode[] = {
+        {160, 120, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
+                .bytesperline = 160,
+                .sizeimage = 70000,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 3},
+        {176, 144, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
+                .bytesperline = 176,
+                .sizeimage = 70000,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 1},
+        {320, 240, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
+                .bytesperline = 320,
+                .sizeimage = 320 * 240 * 3,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 2},
+        {352, 288, V4L2_PIX_FMT_OV511, V4L2_FIELD_NONE,
+                .bytesperline = 352,
+                .sizeimage = 352 * 288 * 3,
+                .colorspace = V4L2_COLORSPACE_JPEG,
+                .priv = 0},
+};
 
 /* Registers common to OV511 / OV518 */
+#define R51x_FIFO_PSIZE                 0x30    /* 2 bytes wide w/ OV518(+) */
 #define R51x_SYS_RESET                  0x50
+        /* Reset type flags */
+        #define OV511_RESET_OMNICE      0x08
 #define R51x_SYS_INIT                   0x53
 #define R51x_SYS_SNAP                   0x52
 #define R51x_SYS_CUST_ID                0x5F
 #define R51x_COMP_LUT_BEGIN             0x80
 
 /* OV511 Camera interface register numbers */
+#define R511_CAM_DELAY                  0x10
+#define R511_CAM_EDGE                   0x11
+#define R511_CAM_PXCNT                  0x12
+#define R511_CAM_LNCNT                  0x13
+#define R511_CAM_PXDIV                  0x14
+#define R511_CAM_LNDIV                  0x15
+#define R511_CAM_UV_EN                  0x16
+#define R511_CAM_LINE_MODE              0x17
+#define R511_CAM_OPTS                   0x18
+
+#define R511_SNAP_FRAME                 0x19
+#define R511_SNAP_PXCNT                 0x1A
+#define R511_SNAP_LNCNT                 0x1B
+#define R511_SNAP_PXDIV                 0x1C
+#define R511_SNAP_LNDIV                 0x1D
+#define R511_SNAP_UV_EN                 0x1E
+#define R511_SNAP_UV_EN                 0x1E
+#define R511_SNAP_OPTS                  0x1F
+
+#define R511_DRAM_FLOW_CTL              0x20
+#define R511_FIFO_OPTS                  0x31
+#define R511_I2C_CTL                    0x40
 #define R511_SYS_LED_CTL                0x55    /* OV511+ only */
-#define OV511_RESET_NOREGS              0x3F    /* All but OV511 & regs */
+#define R511_COMP_EN                    0x78
+#define R511_COMP_LUT_EN                0x79
 
 /* OV518 Camera interface register numbers */
 #define R518_GPIO_OUT                   0x56    /* OV518(+) only */
@@ -383,7 +529,7 @@ static const struct ov_i2c_regvals norm_6x20[] = {
         { 0x28, 0x05 },
         { 0x2a, 0x04 }, /* Disable framerate adjust */
 /*      { 0x2b, 0xac },  * Framerate; Set 2a[7] first */
-        { 0x2d, 0x99 },
+        { 0x2d, 0x85 },
         { 0x33, 0xa0 }, /* Color Processing Parameter */
         { 0x34, 0xd2 }, /* Max A/D range */
         { 0x38, 0x8b },
@@ -416,7 +562,7 @@ static const struct ov_i2c_regvals norm_6x30[] = {
         { 0x07, 0x2d }, /* Sharpness */
         { 0x0c, 0x20 },
         { 0x0d, 0x20 },
-        { 0x0e, 0x20 },
+        { 0x0e, 0xa0 }, /* Was 0x20, bit7 enables a 2x gain which we need */
         { 0x0f, 0x05 },
         { 0x10, 0x9a },
         { 0x11, 0x00 }, /* Pixel clock = fastest */
@@ -558,7 +704,7 @@ static const struct ov_i2c_regvals norm_7620[] = {
         { 0x23, 0x00 },
         { 0x26, 0xa2 },
         { 0x27, 0xea },
-        { 0x28, 0x20 },
+        { 0x28, 0x22 }, /* Was 0x20, bit1 enables a 2x gain which we need */
         { 0x29, 0x00 },
         { 0x2a, 0x10 },
         { 0x2b, 0x00 },
@@ -999,13 +1145,128 @@ static int ov518_reg_w32(struct sd *sd, __u16 index, u32 value, int n)
         return ret;
 }
 
+static int ov511_i2c_w(struct sd *sd, __u8 reg, __u8 value)
+{
+        int rc, retries;
+
+        PDEBUG(D_USBO, "i2c 0x%02x -> [0x%02x]", value, reg);
+
+        /* Three byte write cycle */
+        for (retries = 6; ; ) {
+                /* Select camera register */
+                rc = reg_w(sd, R51x_I2C_SADDR_3, reg);
+                if (rc < 0)
+                        return rc;
+
+                /* Write "value" to I2C data port of OV511 */
+                rc = reg_w(sd, R51x_I2C_DATA, value);
+                if (rc < 0)
+                        return rc;
+
+                /* Initiate 3-byte write cycle */
+                rc = reg_w(sd, R511_I2C_CTL, 0x01);
+                if (rc < 0)
+                        return rc;
+
+                do
+                        rc = reg_r(sd, R511_I2C_CTL);
+                while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
+
+                if (rc < 0)
+                        return rc;
+
+                if ((rc & 2) == 0) /* Ack? */
+                        break;
+                if (--retries < 0) {
+                        PDEBUG(D_USBO, "i2c write retries exhausted");
+                        return -1;
+                }
+        }
+
+        return 0;
+}
+
+static int ov511_i2c_r(struct sd *sd, __u8 reg)
+{
+        int rc, value, retries;
+
+        /* Two byte write cycle */
+        for (retries = 6; ; ) {
+                /* Select camera register */
+                rc = reg_w(sd, R51x_I2C_SADDR_2, reg);
+                if (rc < 0)
+                        return rc;
+
+                /* Initiate 2-byte write cycle */
+                rc = reg_w(sd, R511_I2C_CTL, 0x03);
+                if (rc < 0)
+                        return rc;
+
+                do
+                        rc = reg_r(sd, R511_I2C_CTL);
+                while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
+
+                if (rc < 0)
+                        return rc;
+
+                if ((rc & 2) == 0) /* Ack? */
+                        break;
+
+                /* I2C abort */
+                reg_w(sd, R511_I2C_CTL, 0x10);
+
+                if (--retries < 0) {
+                        PDEBUG(D_USBI, "i2c write retries exhausted");
+                        return -1;
+                }
+        }
+
+        /* Two byte read cycle */
+        for (retries = 6; ; ) {
+                /* Initiate 2-byte read cycle */
+                rc = reg_w(sd, R511_I2C_CTL, 0x05);
+                if (rc < 0)
+                        return rc;
+
+                do
+                        rc = reg_r(sd, R511_I2C_CTL);
+                while (rc > 0 && ((rc & 1) == 0)); /* Retry until idle */
+
+                if (rc < 0)
+                        return rc;
+
+                if ((rc & 2) == 0) /* Ack? */
+                        break;
+
+                /* I2C abort */
+                rc = reg_w(sd, R511_I2C_CTL, 0x10);
+                if (rc < 0)
+                        return rc;
+
+                if (--retries < 0) {
+                        PDEBUG(D_USBI, "i2c read retries exhausted");
+                        return -1;
+                }
+        }
+
+        value = reg_r(sd, R51x_I2C_DATA);
+
+        PDEBUG(D_USBI, "i2c [0x%02X] -> 0x%02X", reg, value);
+
+        /* This is needed to make i2c_w() work */
+        rc = reg_w(sd, R511_I2C_CTL, 0x05);
+        if (rc < 0)
+                return rc;
+
+        return value;
+}
 
 /*
  * The OV518 I2C I/O procedure is different, hence, this function.
  * This is normally only called from i2c_w(). Note that this function
  * always succeeds regardless of whether the sensor is present and working.
  */
-static int i2c_w(struct sd *sd,
+static int ov518_i2c_w(struct sd *sd,
                 __u8 reg,
                 __u8 value)
 {
@@ -1040,7 +1301,7 @@ static int i2c_w(struct sd *sd,
  * This is normally only called from i2c_r(). Note that this function
  * always succeeds regardless of whether the sensor is present and working.
  */
-static int i2c_r(struct sd *sd, __u8 reg)
+static int ov518_i2c_r(struct sd *sd, __u8 reg)
 {
         int rc, value;
 
@@ -1063,6 +1324,34 @@ static int i2c_r(struct sd *sd, __u8 reg)
         return value;
 }
 
+static int i2c_w(struct sd *sd, __u8 reg, __u8 value)
+{
+        switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                return ov511_i2c_w(sd, reg, value);
+        case BRIDGE_OV518:
+        case BRIDGE_OV518PLUS:
+        case BRIDGE_OV519:
+                return ov518_i2c_w(sd, reg, value);
+        }
+        return -1; /* Should never happen */
+}
+
+static int i2c_r(struct sd *sd, __u8 reg)
+{
+        switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                return ov511_i2c_r(sd, reg);
+        case BRIDGE_OV518:
+        case BRIDGE_OV518PLUS:
+        case BRIDGE_OV519:
+                return ov518_i2c_r(sd, reg);
+        }
+        return -1; /* Should never happen */
+}
+
 /* Writes bits at positions specified by mask to an I2C reg. Bits that are in
  * the same position as 1's in "mask" are cleared and set to "value". Bits
  * that are in the same position as 0's in "mask" are preserved, regardless
@@ -1242,7 +1531,6 @@ static int ov8xx0_configure(struct sd *sd)
         }
 
         /* Set sensor-specific vars */
-/*      sd->sif = 0;            already done */
         return 0;
 }
 
@@ -1279,15 +1567,13 @@ static int ov7xx0_configure(struct sd *sd)
                 }
         } else if ((rc & 3) == 1) {
                 /* I don't know what's different about the 76BE yet. */
-                if (i2c_r(sd, 0x15) & 1)
+                if (i2c_r(sd, 0x15) & 1) {
                         PDEBUG(D_PROBE, "Sensor is an OV7620AE");
-                else
+                        sd->sensor = SEN_OV7620;
+                } else {
                         PDEBUG(D_PROBE, "Sensor is an OV76BE");
-
-                /* OV511+ will return all zero isoc data unless we
-                 * configure the sensor as a 7620. Someone needs to
-                 * find the exact reg. setting that causes this. */
-                sd->sensor = SEN_OV76BE;
+                        sd->sensor = SEN_OV76BE;
+                }
         } else if ((rc & 3) == 0) {
                 /* try to read product id registers */
                 high = i2c_r(sd, 0x0a);
@@ -1333,7 +1619,6 @@ static int ov7xx0_configure(struct sd *sd)
         }
 
         /* Set sensor-specific vars */
-/*      sd->sif = 0;            already done */
         return 0;
 }
 
@@ -1362,13 +1647,14 @@ static int ov6xx0_configure(struct sd *sd)
                 break;
         case 0x01:
                 sd->sensor = SEN_OV6620;
+                PDEBUG(D_PROBE, "Sensor is an OV6620");
                 break;
         case 0x02:
                 sd->sensor = SEN_OV6630;
                 PDEBUG(D_PROBE, "Sensor is an OV66308AE");
                 break;
         case 0x03:
-                sd->sensor = SEN_OV6630;
+                sd->sensor = SEN_OV66308AF;
                 PDEBUG(D_PROBE, "Sensor is an OV66308AF");
                 break;
         case 0x90:
@@ -1391,6 +1677,9 @@ static int ov6xx0_configure(struct sd *sd)
 /* Turns on or off the LED. Only has an effect with OV511+/OV518(+)/OV519 */
 static void ov51x_led_control(struct sd *sd, int on)
 {
+        if (sd->invert_led)
+                on = !on;
+
         switch (sd->bridge) {
         /* OV511 has no LED control */
         case BRIDGE_OV511PLUS:
@@ -1406,9 +1695,31 @@ static void ov51x_led_control(struct sd *sd, int on)
         }
 }
 
-/* OV518 quantization tables are 8x4 (instead of 8x8) */
-static int ov518_upload_quan_tables(struct sd *sd)
+static int ov51x_upload_quan_tables(struct sd *sd)
 {
+        const unsigned char yQuanTable511[] = {
+                0, 1, 1, 2, 2, 3, 3, 4,
+                1, 1, 1, 2, 2, 3, 4, 4,
+                1, 1, 2, 2, 3, 4, 4, 4,
+                2, 2, 2, 3, 4, 4, 4, 4,
+                2, 2, 3, 4, 4, 5, 5, 5,
+                3, 3, 4, 4, 5, 5, 5, 5,
+                3, 4, 4, 4, 5, 5, 5, 5,
+                4, 4, 4, 4, 5, 5, 5, 5
+        };
+
+        const unsigned char uvQuanTable511[] = {
+                0, 2, 2, 3, 4, 4, 4, 4,
+                2, 2, 2, 4, 4, 4, 4, 4,
+                2, 2, 3, 4, 4, 4, 4, 4,
+                3, 4, 4, 4, 4, 4, 4, 4,
+                4, 4, 4, 4, 4, 4, 4, 4,
+                4, 4, 4, 4, 4, 4, 4, 4,
+                4, 4, 4, 4, 4, 4, 4, 4,
+                4, 4, 4, 4, 4, 4, 4, 4
+        };
+
+        /* OV518 quantization tables are 8x4 (instead of 8x8) */
         const unsigned char yQuanTable518[] = {
                 5, 4, 5, 6, 6, 7, 7, 7,
                 5, 5, 5, 5, 6, 7, 7, 7,
@@ -1423,14 +1734,23 @@ static int ov518_upload_quan_tables(struct sd *sd)
                 7, 7, 7, 7, 7, 7, 8, 8
         };
 
-        const unsigned char *pYTable = yQuanTable518;
-        const unsigned char *pUVTable = uvQuanTable518;
+        const unsigned char *pYTable, *pUVTable;
         unsigned char val0, val1;
-        int i, rc, reg = R51x_COMP_LUT_BEGIN;
+        int i, size, rc, reg = R51x_COMP_LUT_BEGIN;
 
         PDEBUG(D_PROBE, "Uploading quantization tables");
 
-        for (i = 0; i < 16; i++) {
+        if (sd->bridge == BRIDGE_OV511 || sd->bridge == BRIDGE_OV511PLUS) {
+                pYTable = yQuanTable511;
+                pUVTable = uvQuanTable511;
+                size  = 32;
+        } else {
+                pYTable = yQuanTable518;
+                pUVTable = uvQuanTable518;
+                size  = 16;
+        }
+
+        for (i = 0; i < size; i++) {
                 val0 = *pYTable++;
                 val1 = *pYTable++;
                 val0 &= 0x0f;
@@ -1445,7 +1765,7 @@ static int ov518_upload_quan_tables(struct sd *sd)
                 val0 &= 0x0f;
                 val1 &= 0x0f;
                 val0 |= val1 << 4;
-                rc = reg_w(sd, reg + 16, val0);
+                rc = reg_w(sd, reg + size, val0);
                 if (rc < 0)
                         return rc;
 
@@ -1455,6 +1775,87 @@ static int ov518_upload_quan_tables(struct sd *sd)
         return 0;
 }
 
+/* This initializes the OV511/OV511+ and the sensor */
+static int ov511_configure(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        int rc;
+
+        /* For 511 and 511+ */
+        const struct ov_regvals init_511[] = {
+                { R51x_SYS_RESET,       0x7f },
+                { R51x_SYS_INIT,        0x01 },
+                { R51x_SYS_RESET,       0x7f },
+                { R51x_SYS_INIT,        0x01 },
+                { R51x_SYS_RESET,       0x3f },
+                { R51x_SYS_INIT,        0x01 },
+                { R51x_SYS_RESET,       0x3d },
+        };
+
+        const struct ov_regvals norm_511[] = {
+                { R511_DRAM_FLOW_CTL,   0x01 },
+                { R51x_SYS_SNAP,        0x00 },
+                { R51x_SYS_SNAP,        0x02 },
+                { R51x_SYS_SNAP,        0x00 },
+                { R511_FIFO_OPTS,       0x1f },
+                { R511_COMP_EN,         0x00 },
+                { R511_COMP_LUT_EN,     0x03 },
+        };
+
+        const struct ov_regvals norm_511_p[] = {
+                { R511_DRAM_FLOW_CTL,   0xff },
+                { R51x_SYS_SNAP,        0x00 },
+                { R51x_SYS_SNAP,        0x02 },
+                { R51x_SYS_SNAP,        0x00 },
+                { R511_FIFO_OPTS,       0xff },
+                { R511_COMP_EN,         0x00 },
+                { R511_COMP_LUT_EN,     0x03 },
+        };
+
+        const struct ov_regvals compress_511[] = {
+                { 0x70, 0x1f },
+                { 0x71, 0x05 },
+                { 0x72, 0x06 },
+                { 0x73, 0x06 },
+                { 0x74, 0x14 },
+                { 0x75, 0x03 },
+                { 0x76, 0x04 },
+                { 0x77, 0x04 },
+        };
+
+        PDEBUG(D_PROBE, "Device custom id %x", reg_r(sd, R51x_SYS_CUST_ID));
+
+        rc = write_regvals(sd, init_511, ARRAY_SIZE(init_511));
+        if (rc < 0)
+                return rc;
+
+        switch (sd->bridge) {
+        case BRIDGE_OV511:
+                rc = write_regvals(sd, norm_511, ARRAY_SIZE(norm_511));
+                if (rc < 0)
+                        return rc;
+                break;
+        case BRIDGE_OV511PLUS:
+                rc = write_regvals(sd, norm_511_p, ARRAY_SIZE(norm_511_p));
+                if (rc < 0)
+                        return rc;
+                break;
+        }
+
+        /* Init compression */
+        rc = write_regvals(sd, compress_511, ARRAY_SIZE(compress_511));
+        if (rc < 0)
+                return rc;
+
+        rc = ov51x_upload_quan_tables(sd);
+        if (rc < 0) {
+                PDEBUG(D_ERR, "Error uploading quantization tables");
+                return rc;
+        }
+
+        return 0;
+}
+
 /* This initializes the OV518/OV518+ and the sensor */
 static int ov518_configure(struct gspca_dev *gspca_dev)
 {
@@ -1462,7 +1863,7 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
         int rc;
 
         /* For 518 and 518+ */
-        static struct ov_regvals init_518[] = {
+        const struct ov_regvals init_518[] = {
                 { R51x_SYS_RESET,       0x40 },
                 { R51x_SYS_INIT,        0xe1 },
                 { R51x_SYS_RESET,       0x3e },
@@ -1473,7 +1874,7 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
                 { 0x5d,                 0x03 },
         };
 
-        static struct ov_regvals norm_518[] = {
+        const struct ov_regvals norm_518[] = {
                 { R51x_SYS_SNAP,        0x02 }, /* Reset */
                 { R51x_SYS_SNAP,        0x01 }, /* Enable */
                 { 0x31,                 0x0f },
@@ -1486,7 +1887,7 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
                 { 0x2f,                 0x80 },
         };
 
-        static struct ov_regvals norm_518_p[] = {
+        const struct ov_regvals norm_518_p[] = {
                 { R51x_SYS_SNAP,        0x02 }, /* Reset */
                 { R51x_SYS_SNAP,        0x01 }, /* Enable */
                 { 0x31,                 0x0f },
@@ -1531,7 +1932,7 @@ static int ov518_configure(struct gspca_dev *gspca_dev)
                 break;
         }
 
-        rc = ov518_upload_quan_tables(sd);
+        rc = ov51x_upload_quan_tables(sd);
         if (rc < 0) {
                 PDEBUG(D_ERR, "Error uploading quantization tables");
                 return rc;
@@ -1573,9 +1974,14 @@ static int sd_config(struct gspca_dev *gspca_dev,
         struct cam *cam;
         int ret = 0;
 
-        sd->bridge = id->driver_info;
+        sd->bridge = id->driver_info & BRIDGE_MASK;
+        sd->invert_led = id->driver_info & BRIDGE_INVERT_LED;
 
         switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                ret = ov511_configure(gspca_dev);
+                break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
                 ret = ov518_configure(gspca_dev);
@@ -1634,6 +2040,16 @@ static int sd_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
         switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                if (!sd->sif) {
+                        cam->cam_mode = ov511_vga_mode;
+                        cam->nmodes = ARRAY_SIZE(ov511_vga_mode);
+                } else {
+                        cam->cam_mode = ov511_sif_mode;
+                        cam->nmodes = ARRAY_SIZE(ov511_sif_mode);
+                }
+                break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
                 if (!sd->sif) {
@@ -1655,13 +2071,28 @@ static int sd_config(struct gspca_dev *gspca_dev,
                 break;
         }
         sd->brightness = BRIGHTNESS_DEF;
-        sd->contrast = CONTRAST_DEF;
+        if (sd->sensor == SEN_OV6630 || sd->sensor == SEN_OV66308AF)
+                sd->contrast = 200; /* The default is too low for the ov6630 */
+        else
+                sd->contrast = CONTRAST_DEF;
         sd->colors = COLOR_DEF;
         sd->hflip = HFLIP_DEF;
         sd->vflip = VFLIP_DEF;
-        if (sd->sensor != SEN_OV7670)
-                gspca_dev->ctrl_dis = (1 << HFLIP_IDX)
-                                        | (1 << VFLIP_IDX);
+        sd->autobrightness = AUTOBRIGHT_DEF;
+        if (sd->sensor == SEN_OV7670) {
+                sd->freq = OV7670_FREQ_DEF;
+                gspca_dev->ctrl_dis = 1 << FREQ_IDX;
+        } else {
+                sd->freq = FREQ_DEF;
+                gspca_dev->ctrl_dis = (1 << HFLIP_IDX) | (1 << VFLIP_IDX) |
+                                      (1 << OV7670_FREQ_IDX);
+        }
+        if (sd->sensor == SEN_OV7640 || sd->sensor == SEN_OV7670)
+                gspca_dev->ctrl_dis |= 1 << AUTOBRIGHT_IDX;
+        /* OV8610 Frequency filter control should work but needs testing */
+        if (sd->sensor == SEN_OV8610)
+                gspca_dev->ctrl_dis |= 1 << FREQ_IDX;
+
         return 0;
 error:
         PDEBUG(D_ERR, "OV519 Config failed");
@@ -1680,6 +2111,7 @@ static int sd_init(struct gspca_dev *gspca_dev)
                         return -EIO;
                 break;
         case SEN_OV6630:
+        case SEN_OV66308AF:
                 if (write_i2c_regvals(sd, norm_6x30, ARRAY_SIZE(norm_6x30)))
                         return -EIO;
                 break;
@@ -1688,6 +2120,8 @@ static int sd_init(struct gspca_dev *gspca_dev)
 /*      case SEN_OV76BE: */
                 if (write_i2c_regvals(sd, norm_7610, ARRAY_SIZE(norm_7610)))
                         return -EIO;
+                if (i2c_w_mask(sd, 0x0e, 0x00, 0x40))
+                        return -EIO;
                 break;
         case SEN_OV7620:
                 if (write_i2c_regvals(sd, norm_7620, ARRAY_SIZE(norm_7620)))
@@ -1709,6 +2143,126 @@ static int sd_init(struct gspca_dev *gspca_dev)
         return 0;
 }
 
+/* Set up the OV511/OV511+ with the given image parameters.
+ *
+ * Do not put any sensor-specific code in here (including I2C I/O functions)
+ */
+static int ov511_mode_init_regs(struct sd *sd)
+{
+        int hsegs, vsegs, packet_size, fps, needed;
+        int interlaced = 0;
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
+
+        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
+        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
+        if (!alt) {
+                PDEBUG(D_ERR, "Couldn't get altsetting");
+                return -EIO;
+        }
+
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+        reg_w(sd, R51x_FIFO_PSIZE, packet_size >> 5);
+
+        reg_w(sd, R511_CAM_UV_EN, 0x01);
+        reg_w(sd, R511_SNAP_UV_EN, 0x01);
+        reg_w(sd, R511_SNAP_OPTS, 0x03);
+
+        /* Here I'm assuming that snapshot size == image size.
+         * I hope that's always true. --claudio
+         */
+        hsegs = (sd->gspca_dev.width >> 3) - 1;
+        vsegs = (sd->gspca_dev.height >> 3) - 1;
+
+        reg_w(sd, R511_CAM_PXCNT, hsegs);
+        reg_w(sd, R511_CAM_LNCNT, vsegs);
+        reg_w(sd, R511_CAM_PXDIV, 0x00);
+        reg_w(sd, R511_CAM_LNDIV, 0x00);
+
+        /* YUV420, low pass filter on */
+        reg_w(sd, R511_CAM_OPTS, 0x03);
+
+        /* Snapshot additions */
+        reg_w(sd, R511_SNAP_PXCNT, hsegs);
+        reg_w(sd, R511_SNAP_LNCNT, vsegs);
+        reg_w(sd, R511_SNAP_PXDIV, 0x00);
+        reg_w(sd, R511_SNAP_LNDIV, 0x00);
+
+        /******** Set the framerate ********/
+        if (frame_rate > 0)
+                sd->frame_rate = frame_rate;
+
+        switch (sd->sensor) {
+        case SEN_OV6620:
+                /* No framerate control, doesn't like higher rates yet */
+                sd->clockdiv = 3;
+                break;
+
+        /* Note once the FIXME's in mode_init_ov_sensor_regs() are fixed
+           for more sensors we need to do this for them too */
+        case SEN_OV7620:
+        case SEN_OV7640:
+        case SEN_OV76BE:
+                if (sd->gspca_dev.width == 320)
+                        interlaced = 1;
+                /* Fall through */
+        case SEN_OV6630:
+        case SEN_OV7610:
+        case SEN_OV7670:
+                switch (sd->frame_rate) {
+                case 30:
+                case 25:
+                        /* Not enough bandwidth to do 640x480 @ 30 fps */
+                        if (sd->gspca_dev.width != 640) {
+                                sd->clockdiv = 0;
+                                break;
+                        }
+                        /* Fall through for 640x480 case */
+                default:
+/*              case 20: */
+/*              case 15: */
+                        sd->clockdiv = 1;
+                        break;
+                case 10:
+                        sd->clockdiv = 2;
+                        break;
+                case 5:
+                        sd->clockdiv = 5;
+                        break;
+                }
+                if (interlaced) {
+                        sd->clockdiv = (sd->clockdiv + 1) * 2 - 1;
+                        /* Higher then 10 does not work */
+                        if (sd->clockdiv > 10)
+                                sd->clockdiv = 10;
+                }
+                break;
+
+        case SEN_OV8610:
+                /* No framerate control ?? */
+                sd->clockdiv = 0;
+                break;
+        }
+
+        /* Check if we have enough bandwidth to disable compression */
+        fps = (interlaced ? 60 : 30) / (sd->clockdiv + 1) + 1;
+        needed = fps * sd->gspca_dev.width * sd->gspca_dev.height * 3 / 2;
+        /* 1400 is a conservative estimate of the max nr of isoc packets/sec */
+        if (needed > 1400 * packet_size) {
+                /* Enable Y and UV quantization and compression */
+                reg_w(sd, R511_COMP_EN, 0x07);
+                reg_w(sd, R511_COMP_LUT_EN, 0x03);
+        } else {
+                reg_w(sd, R511_COMP_EN, 0x06);
+                reg_w(sd, R511_COMP_LUT_EN, 0x00);
+        }
+
+        reg_w(sd, R51x_SYS_RESET, OV511_RESET_OMNICE);
+        reg_w(sd, R51x_SYS_RESET, 0);
+
+        return 0;
+}
+
 /* Sets up the OV518/OV518+ with the given image parameters
  *
  * OV518 needs a completely different approach, until we can figure out what
@@ -1718,7 +2272,19 @@ static int sd_init(struct gspca_dev *gspca_dev)
  */
 static int ov518_mode_init_regs(struct sd *sd)
 {
-        int hsegs, vsegs;
+        int hsegs, vsegs, packet_size;
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
+
+        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
+        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
+        if (!alt) {
+                PDEBUG(D_ERR, "Couldn't get altsetting");
+                return -EIO;
+        }
+
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+        ov518_reg_w32(sd, R51x_FIFO_PSIZE, packet_size & ~7, 2);
 
         /******** Set the mode ********/
 
@@ -1755,20 +2321,30 @@ static int ov518_mode_init_regs(struct sd *sd)
         /* Windows driver does this here; who knows why */
         reg_w(sd, 0x2f, 0x80);
 
-        /******** Set the framerate (to 30 FPS) ********/
-        if (sd->bridge == BRIDGE_OV518PLUS)
-                sd->clockdiv = 1;
-        else
-                sd->clockdiv = 0;
+        /******** Set the framerate  ********/
+        sd->clockdiv = 1;
 
         /* Mode independent, but framerate dependent, regs */
-        reg_w(sd, 0x51, 0x04);  /* Clock divider; lower==faster */
+        /* 0x51: Clock divider; Only works on some cams which use 2 crystals */
+        reg_w(sd, 0x51, 0x04);
         reg_w(sd, 0x22, 0x18);
         reg_w(sd, 0x23, 0xff);
 
-        if (sd->bridge == BRIDGE_OV518PLUS)
-                reg_w(sd, 0x21, 0x19);
-        else
+        if (sd->bridge == BRIDGE_OV518PLUS) {
+                switch (sd->sensor) {
+                case SEN_OV7620:
+                        if (sd->gspca_dev.width == 320) {
+                                reg_w(sd, 0x20, 0x00);
+                                reg_w(sd, 0x21, 0x19);
+                        } else {
+                                reg_w(sd, 0x20, 0x60);
+                                reg_w(sd, 0x21, 0x1f);
+                        }
+                        break;
+                default:
+                        reg_w(sd, 0x21, 0x19);
+                }
+        } else
                 reg_w(sd, 0x71, 0x17);  /* Compression-related? */
 
         /* FIXME: Sensor-specific */
@@ -1879,7 +2455,11 @@ static int ov519_mode_init_regs(struct sd *sd)
 
         reg_w(sd, OV519_R10_H_SIZE,     sd->gspca_dev.width >> 4);
         reg_w(sd, OV519_R11_V_SIZE,     sd->gspca_dev.height >> 3);
-        reg_w(sd, OV519_R12_X_OFFSETL,  0x00);
+        if (sd->sensor == SEN_OV7670 &&
+            sd->gspca_dev.cam.cam_mode[sd->gspca_dev.curr_mode].priv)
+                reg_w(sd, OV519_R12_X_OFFSETL, 0x04);
+        else
+                reg_w(sd, OV519_R12_X_OFFSETL, 0x00);
         reg_w(sd, OV519_R13_X_OFFSETH,  0x00);
         reg_w(sd, OV519_R14_Y_OFFSETL,  0x00);
         reg_w(sd, OV519_R15_Y_OFFSETH,  0x00);
@@ -1971,7 +2551,7 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
         int qvga;
 
         gspca_dev = &sd->gspca_dev;
-        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
+        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv & 1;
 
         /******** Mode (VGA/QVGA) and sensor specific regs ********/
         switch (sd->sensor) {
@@ -1983,21 +2563,16 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 break;
         case SEN_OV7620:
-/*              i2c_w(sd, 0x2b, 0x00); */
+        case SEN_OV76BE:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
                 i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a);
                 i2c_w(sd, 0x25, qvga ? 0x30 : 0x60);
                 i2c_w_mask(sd, 0x2d, qvga ? 0x40 : 0x00, 0x40);
-                i2c_w_mask(sd, 0x67, qvga ? 0xf0 : 0x90, 0xf0);
+                i2c_w_mask(sd, 0x67, qvga ? 0xb0 : 0x90, 0xf0);
                 i2c_w_mask(sd, 0x74, qvga ? 0x20 : 0x00, 0x20);
                 break;
-        case SEN_OV76BE:
-/*              i2c_w(sd, 0x2b, 0x00); */
-                i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
-                break;
         case SEN_OV7640:
-/*              i2c_w(sd, 0x2b, 0x00); */
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 i2c_w_mask(sd, 0x28, qvga ? 0x00 : 0x20, 0x20);
 /*              i2c_w(sd, 0x24, qvga ? 0x20 : 0x3a); */
@@ -2016,6 +2591,7 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
                 break;
         case SEN_OV6620:
         case SEN_OV6630:
+        case SEN_OV66308AF:
                 i2c_w_mask(sd, 0x14, qvga ? 0x20 : 0x00, 0x20);
                 break;
         default:
@@ -2023,10 +2599,6 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
         }
 
         /******** Palette-specific regs ********/
-        if (sd->sensor == SEN_OV7610 || sd->sensor == SEN_OV76BE) {
-                /* not valid on the OV6620/OV7620/6630? */
-                i2c_w_mask(sd, 0x0e, 0x00, 0x40);
-        }
 
         /* The OV518 needs special treatment. Although both the OV518
          * and the OV6630 support a 16-bit video bus, only the 8 bit Y
@@ -2036,25 +2608,12 @@ static int mode_init_ov_sensor_regs(struct sd *sd)
 
         /* OV7640 is 8-bit only */
 
-        if (sd->sensor != SEN_OV6630 && sd->sensor != SEN_OV7640)
+        if (sd->sensor != SEN_OV6630 && sd->sensor != SEN_OV66308AF &&
+                                        sd->sensor != SEN_OV7640)
                 i2c_w_mask(sd, 0x13, 0x00, 0x20);
 
         /******** Clock programming ********/
-        /* The OV6620 needs special handling. This prevents the
-         * severe banding that normally occurs */
-        if (sd->sensor == SEN_OV6620) {
-
-                /* Clock down */
-                i2c_w(sd, 0x2a, 0x04);
-                i2c_w(sd, 0x11, sd->clockdiv);
-                i2c_w(sd, 0x2a, 0x84);
-                /* This next setting is critical. It seems to improve
-                 * the gain or the contrast. The "reserved" bits seem
-                 * to have some effect in this case. */
-                i2c_w(sd, 0x2d, 0x85);
-        } else {
-                i2c_w(sd, 0x11, sd->clockdiv);
-        }
+        i2c_w(sd, 0x11, sd->clockdiv);
 
         /******** Special Features ********/
 /* no evidence this is possible with OV7670, either */
@@ -2098,13 +2657,14 @@ static void sethvflip(struct sd *sd)
 static int set_ov_sensor_window(struct sd *sd)
 {
         struct gspca_dev *gspca_dev;
-        int qvga;
+        int qvga, crop;
         int hwsbase, hwebase, vwsbase, vwebase, hwscale, vwscale;
         int ret, hstart, hstop, vstop, vstart;
         __u8 v;
 
         gspca_dev = &sd->gspca_dev;
-        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv;
+        qvga = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv & 1;
+        crop = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode].priv & 2;
 
         /* The different sensor ICs handle setting up of window differently.
          * IF YOU SET IT WRONG, YOU WILL GET ALL ZERO ISOC DATA FROM OV51x!! */
@@ -2123,14 +2683,19 @@ static int set_ov_sensor_window(struct sd *sd)
                 break;
         case SEN_OV6620:
         case SEN_OV6630:
+        case SEN_OV66308AF:
                 hwsbase = 0x38;
                 hwebase = 0x3a;
                 vwsbase = 0x05;
                 vwebase = 0x06;
-                if (qvga) {
+                if (sd->sensor == SEN_OV66308AF && qvga)
                         /* HDG: this fixes U and V getting swapped */
-                        hwsbase--;
-                        vwsbase--;
+                        hwsbase++;
+                if (crop) {
+                        hwsbase += 8;
+                        hwebase += 8;
+                        vwsbase += 11;
+                        vwebase += 11;
                 }
                 break;
         case SEN_OV7620:
@@ -2155,6 +2720,7 @@ static int set_ov_sensor_window(struct sd *sd)
         switch (sd->sensor) {
         case SEN_OV6620:
         case SEN_OV6630:
+        case SEN_OV66308AF:
                 if (qvga) {             /* QCIF */
                         hwscale = 0;
                         vwscale = 0;
@@ -2207,7 +2773,7 @@ static int set_ov_sensor_window(struct sd *sd)
                 if (qvga) {             /* QVGA from ov7670.c by
                                          * Jonathan Corbet */
                         hstart = 164;
-                        hstop = 20;
+                        hstop = 28;
                         vstart = 14;
                         vstop = 494;
                 } else {                /* VGA */
@@ -2233,7 +2799,6 @@ static int set_ov_sensor_window(struct sd *sd)
                 msleep(10);     /* need to sleep between read and write to
                                  * same reg! */
                 i2c_w(sd, OV7670_REG_VREF, v);
-                sethvflip(sd);
         } else {
                 i2c_w(sd, 0x17, hwsbase);
                 i2c_w(sd, 0x18, hwebase + (sd->gspca_dev.width >> hwscale));
@@ -2250,6 +2815,10 @@ static int sd_start(struct gspca_dev *gspca_dev)
         int ret = 0;
 
         switch (sd->bridge) {
+        case BRIDGE_OV511:
+        case BRIDGE_OV511PLUS:
+                ret = ov511_mode_init_regs(sd);
+                break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
                 ret = ov518_mode_init_regs(sd);
@@ -2268,6 +2837,9 @@ static int sd_start(struct gspca_dev *gspca_dev)
         setcontrast(gspca_dev);
         setbrightness(gspca_dev);
         setcolors(gspca_dev);
+        sethvflip(sd);
+        setautobrightness(sd);
+        setfreq(sd);
 
         ret = ov51x_restart(sd);
         if (ret < 0)
@@ -2287,23 +2859,88 @@ static void sd_stopN(struct gspca_dev *gspca_dev)
         ov51x_led_control(sd, 0);
 }
 
-static void ov518_pkt_scan(struct gspca_dev *gspca_dev,
+static void ov511_pkt_scan(struct gspca_dev *gspca_dev,
                         struct gspca_frame *frame,      /* target */
-                        __u8 *data,                     /* isoc packet */
+                        __u8 *in,                       /* isoc packet */
                         int len)                        /* iso packet length */
 {
-        PDEBUG(D_STREAM, "ov518_pkt_scan: %d bytes", len);
+        struct sd *sd = (struct sd *) gspca_dev;
 
-        if (len & 7) {
-                len--;
-                PDEBUG(D_STREAM, "packet number: %d\n", (int)data[len]);
+        /* SOF/EOF packets have 1st to 8th bytes zeroed and the 9th
+         * byte non-zero. The EOF packet has image width/height in the
+         * 10th and 11th bytes. The 9th byte is given as follows:
+         *
+         * bit 7: EOF
+         *     6: compression enabled
+         *     5: 422/420/400 modes
+         *     4: 422/420/400 modes
+         *     3: 1
+         *     2: snapshot button on
+         *     1: snapshot frame
+         *     0: even/odd field
+         */
+        if (!(in[0] | in[1] | in[2] | in[3] | in[4] | in[5] | in[6] | in[7]) &&
+            (in[8] & 0x08)) {
+                if (in[8] & 0x80) {
+                        /* Frame end */
+                        if ((in[9] + 1) * 8 != gspca_dev->width ||
+                            (in[10] + 1) * 8 != gspca_dev->height) {
+                                PDEBUG(D_ERR, "Invalid frame size, got: %dx%d,"
+                                        " requested: %dx%d\n",
+                                        (in[9] + 1) * 8, (in[10] + 1) * 8,
+                                        gspca_dev->width, gspca_dev->height);
+                                gspca_dev->last_packet_type = DISCARD_PACKET;
+                                return;
+                        }
+                        /* Add 11 byte footer to frame, might be usefull */
+                        gspca_frame_add(gspca_dev, LAST_PACKET, frame, in, 11);
+                        return;
+                } else {
+                        /* Frame start */
+                        gspca_frame_add(gspca_dev, FIRST_PACKET, frame, in, 0);
+                        sd->packet_nr = 0;
+                }
         }
 
+        /* Ignore the packet number */
+        len--;
+
+        /* intermediate packet */
+        gspca_frame_add(gspca_dev, INTER_PACKET, frame, in, len);
+}
+
+static void ov518_pkt_scan(struct gspca_dev *gspca_dev,
+                        struct gspca_frame *frame,      /* target */
+                        __u8 *data,                     /* isoc packet */
+                        int len)                        /* iso packet length */
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
         /* A false positive here is likely, until OVT gives me
          * the definitive SOF/EOF format */
         if ((!(data[0] | data[1] | data[2] | data[3] | data[5])) && data[6]) {
                 gspca_frame_add(gspca_dev, LAST_PACKET, frame, data, 0);
                 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, 0);
+                sd->packet_nr = 0;
+        }
+
+        if (gspca_dev->last_packet_type == DISCARD_PACKET)
+                return;
+
+        /* Does this device use packet numbers ? */
+        if (len & 7) {
+                len--;
+                if (sd->packet_nr == data[len])
+                        sd->packet_nr++;
+                /* The last few packets of the frame (which are all 0's
+                   except that they may contain part of the footer), are
+                   numbered 0 */
+                else if (sd->packet_nr == 0 || data[len]) {
+                        PDEBUG(D_ERR, "Invalid packet nr: %d (expect: %d)",
+                                (int)data[len], (int)sd->packet_nr);
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
+                        return;
+                }
         }
 
         /* intermediate packet */
@@ -2364,6 +3001,7 @@ static void sd_pkt_scan(struct gspca_dev *gspca_dev,
         switch (sd->bridge) {
         case BRIDGE_OV511:
         case BRIDGE_OV511PLUS:
+                ov511_pkt_scan(gspca_dev, frame, data, len);
                 break;
         case BRIDGE_OV518:
         case BRIDGE_OV518PLUS:
@@ -2389,13 +3027,13 @@ static void setbrightness(struct gspca_dev *gspca_dev)
         case SEN_OV76BE:
         case SEN_OV6620:
         case SEN_OV6630:
+        case SEN_OV66308AF:
         case SEN_OV7640:
                 i2c_w(sd, OV7610_REG_BRT, val);
                 break;
         case SEN_OV7620:
                 /* 7620 doesn't like manual changes when in auto mode */
-/*fixme
- *              if (!sd->auto_brt) */
+                if (!sd->autobrightness)
                         i2c_w(sd, OV7610_REG_BRT, val);
                 break;
         case SEN_OV7670:
@@ -2418,6 +3056,7 @@ static void setcontrast(struct gspca_dev *gspca_dev)
                 i2c_w(sd, OV7610_REG_CNT, val);
                 break;
         case SEN_OV6630:
+        case SEN_OV66308AF:
                 i2c_w_mask(sd, OV7610_REG_CNT, val >> 4, 0x0f);
                 break;
         case SEN_OV8610: {
@@ -2462,6 +3101,7 @@ static void setcolors(struct gspca_dev *gspca_dev)
         case SEN_OV76BE:
         case SEN_OV6620:
         case SEN_OV6630:
+        case SEN_OV66308AF:
                 i2c_w(sd, OV7610_REG_SAT, val);
                 break;
         case SEN_OV7620:
@@ -2482,6 +3122,72 @@ static void setcolors(struct gspca_dev *gspca_dev)
         }
 }
 
+static void setautobrightness(struct sd *sd)
+{
+        if (sd->sensor == SEN_OV7640 || sd->sensor == SEN_OV7670)
+                return;
+
+        i2c_w_mask(sd, 0x2d, sd->autobrightness ? 0x10 : 0x00, 0x10);
+}
+
+static void setfreq(struct sd *sd)
+{
+        if (sd->sensor == SEN_OV7670) {
+                switch (sd->freq) {
+                case 0: /* Banding filter disabled */
+                        i2c_w_mask(sd, OV7670_REG_COM8, 0, OV7670_COM8_BFILT);
+                        break;
+                case 1: /* 50 hz */
+                        i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_BFILT,
+                                   OV7670_COM8_BFILT);
+                        i2c_w_mask(sd, OV7670_REG_COM11, 0x08, 0x18);
+                        break;
+                case 2: /* 60 hz */
+                        i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_BFILT,
+                                   OV7670_COM8_BFILT);
+                        i2c_w_mask(sd, OV7670_REG_COM11, 0x00, 0x18);
+                        break;
+                case 3: /* Auto hz */
+                        i2c_w_mask(sd, OV7670_REG_COM8, OV7670_COM8_BFILT,
+                                   OV7670_COM8_BFILT);
+                        i2c_w_mask(sd, OV7670_REG_COM11, OV7670_COM11_HZAUTO,
+                                   0x18);
+                        break;
+                }
+        } else {
+                switch (sd->freq) {
+                case 0: /* Banding filter disabled */
+                        i2c_w_mask(sd, 0x2d, 0x00, 0x04);
+                        i2c_w_mask(sd, 0x2a, 0x00, 0x80);
+                        break;
+                case 1: /* 50 hz (filter on and framerate adj) */
+                        i2c_w_mask(sd, 0x2d, 0x04, 0x04);
+                        i2c_w_mask(sd, 0x2a, 0x80, 0x80);
+                        /* 20 fps -> 16.667 fps */
+                        if (sd->sensor == SEN_OV6620 ||
+                            sd->sensor == SEN_OV6630 ||
+                            sd->sensor == SEN_OV66308AF)
+                                i2c_w(sd, 0x2b, 0x5e);
+                        else
+                                i2c_w(sd, 0x2b, 0xac);
+                        break;
+                case 2: /* 60 hz (filter on, ...) */
+                        i2c_w_mask(sd, 0x2d, 0x04, 0x04);
+                        if (sd->sensor == SEN_OV6620 ||
+                            sd->sensor == SEN_OV6630 ||
+                            sd->sensor == SEN_OV66308AF) {
+                                /* 20 fps -> 15 fps */
+                                i2c_w_mask(sd, 0x2a, 0x80, 0x80);
+                                i2c_w(sd, 0x2b, 0xa8);
+                        } else {
+                                /* no framerate adj. */
+                                i2c_w_mask(sd, 0x2a, 0x00, 0x80);
+                        }
+                        break;
+                }
+        }
+}
+
 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -2572,6 +3278,71 @@ static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+static int sd_setautobrightness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->autobrightness = val;
+        if (gspca_dev->streaming)
+                setautobrightness(sd);
+        return 0;
+}
+
+static int sd_getautobrightness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->autobrightness;
+        return 0;
+}
+
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->freq = val;
+        if (gspca_dev->streaming)
+                setfreq(sd);
+        return 0;
+}
+
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->freq;
+        return 0;
+}
+
+static int sd_querymenu(struct gspca_dev *gspca_dev,
+                        struct v4l2_querymenu *menu)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        switch (menu->id) {
+        case V4L2_CID_POWER_LINE_FREQUENCY:
+                switch (menu->index) {
+                case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
+                        strcpy((char *) menu->name, "NoFliker");
+                        return 0;
+                case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
+                        strcpy((char *) menu->name, "50 Hz");
+                        return 0;
+                case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
+                        strcpy((char *) menu->name, "60 Hz");
+                        return 0;
+                case 3:
+                        if (sd->sensor != SEN_OV7670)
+                                return -EINVAL;
+
+                        strcpy((char *) menu->name, "Automatic");
+                        return 0;
+                }
+                break;
+        }
+        return -EINVAL;
+}
+
 /* sub-driver description */
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
@@ -2582,6 +3353,7 @@ static const struct sd_desc sd_desc = {
         .start = sd_start,
         .stopN = sd_stopN,
         .pkt_scan = sd_pkt_scan,
+        .querymenu = sd_querymenu,
 };
 
 /* -- module initialisation -- */
@@ -2590,17 +3362,22 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x041e, 0x405f), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4060), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x041e, 0x4061), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x041e, 0x4064), .driver_info = BRIDGE_OV519 },
-        {USB_DEVICE(0x041e, 0x4068), .driver_info = BRIDGE_OV519 },
+        {USB_DEVICE(0x041e, 0x4064),
+         .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
+        {USB_DEVICE(0x041e, 0x4068),
+         .driver_info = BRIDGE_OV519 | BRIDGE_INVERT_LED },
         {USB_DEVICE(0x045e, 0x028c), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x054c, 0x0154), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x054c, 0x0155), .driver_info = BRIDGE_OV519 },
+        {USB_DEVICE(0x05a9, 0x0511), .driver_info = BRIDGE_OV511 },
         {USB_DEVICE(0x05a9, 0x0518), .driver_info = BRIDGE_OV518 },
         {USB_DEVICE(0x05a9, 0x0519), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x05a9, 0x0530), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x05a9, 0x4519), .driver_info = BRIDGE_OV519 },
         {USB_DEVICE(0x05a9, 0x8519), .driver_info = BRIDGE_OV519 },
+        {USB_DEVICE(0x05a9, 0xa511), .driver_info = BRIDGE_OV511PLUS },
         {USB_DEVICE(0x05a9, 0xa518), .driver_info = BRIDGE_OV518PLUS },
+        {USB_DEVICE(0x0813, 0x0002), .driver_info = BRIDGE_OV511PLUS },
         {}
 };
 
diff --git a/drivers/media/video/gspca/sonixj.c b/drivers/media/video/gspca/sonixj.c
index dc6a6f11354a..0d02f41fa7d0 100644
--- a/drivers/media/video/gspca/sonixj.c
+++ b/drivers/media/video/gspca/sonixj.c
@@ -46,6 +46,7 @@ struct sd {
         u8 gamma;
         u8 vflip;                       /* ov7630/ov7648 only */
         u8 infrared;                    /* mt9v111 only */
+        u8 freq;                        /* ov76xx only */
         u8 quality;                     /* image quality */
 #define QUALITY_MIN 60
 #define QUALITY_MAX 95
@@ -96,8 +97,11 @@ static int sd_setvflip(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getvflip(struct gspca_dev *gspca_dev, __s32 *val);
 static int sd_setinfrared(struct gspca_dev *gspca_dev, __s32 val);
 static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
 
 static struct ctrl sd_ctrls[] = {
+#define BRIGHTNESS_IDX 0
         {
             {
                 .id      = V4L2_CID_BRIGHTNESS,
@@ -113,6 +117,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setbrightness,
             .get = sd_getbrightness,
         },
+#define CONTRAST_IDX 1
         {
             {
                 .id      = V4L2_CID_CONTRAST,
@@ -128,20 +133,22 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setcontrast,
             .get = sd_getcontrast,
         },
+#define COLOR_IDX 2
         {
             {
                 .id      = V4L2_CID_SATURATION,
                 .type    = V4L2_CTRL_TYPE_INTEGER,
-                .name    = "Color",
+                .name    = "Saturation",
                 .minimum = 0,
                 .maximum = 40,
                 .step    = 1,
-#define COLOR_DEF 32
+#define COLOR_DEF 25
                 .default_value = COLOR_DEF,
             },
             .set = sd_setcolors,
             .get = sd_getcolors,
         },
+#define BLUE_BALANCE_IDX 3
         {
             {
                 .id      = V4L2_CID_BLUE_BALANCE,
@@ -156,6 +163,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setblue_balance,
             .get = sd_getblue_balance,
         },
+#define RED_BALANCE_IDX 4
         {
             {
                 .id      = V4L2_CID_RED_BALANCE,
@@ -170,6 +178,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setred_balance,
             .get = sd_getred_balance,
         },
+#define GAMMA_IDX 5
         {
             {
                 .id      = V4L2_CID_GAMMA,
@@ -184,7 +193,7 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setgamma,
             .get = sd_getgamma,
         },
-#define AUTOGAIN_IDX 5
+#define AUTOGAIN_IDX 6
         {
             {
                 .id      = V4L2_CID_AUTOGAIN,
@@ -200,7 +209,7 @@ static struct ctrl sd_ctrls[] = {
             .get = sd_getautogain,
         },
 /* ov7630/ov7648 only */
-#define VFLIP_IDX 6
+#define VFLIP_IDX 7
         {
             {
                 .id      = V4L2_CID_VFLIP,
@@ -209,14 +218,14 @@ static struct ctrl sd_ctrls[] = {
                 .minimum = 0,
                 .maximum = 1,
                 .step    = 1,
-#define VFLIP_DEF 0                     /* vflip def = 1 for ov7630 */
+#define VFLIP_DEF 0
                 .default_value = VFLIP_DEF,
             },
             .set = sd_setvflip,
             .get = sd_getvflip,
         },
 /* mt9v111 only */
-#define INFRARED_IDX 7
+#define INFRARED_IDX 8
         {
             {
                 .id      = V4L2_CID_INFRARED,
@@ -231,28 +240,44 @@ static struct ctrl sd_ctrls[] = {
             .set = sd_setinfrared,
             .get = sd_getinfrared,
         },
+/* ov7630/ov7648/ov7660 only */
+#define FREQ_IDX 9
+        {
+            {
+                .id      = V4L2_CID_POWER_LINE_FREQUENCY,
+                .type    = V4L2_CTRL_TYPE_MENU,
+                .name    = "Light frequency filter",
+                .minimum = 0,
+                .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
+                .step    = 1,
+#define FREQ_DEF 2
+                .default_value = FREQ_DEF,
+            },
+            .set = sd_setfreq,
+            .get = sd_getfreq,
+        },
 };
 
 /* table of the disabled controls */
 static __u32 ctrl_dis[] = {
-        (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
+        (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
                                                 /* SENSOR_HV7131R 0 */
-        (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
+        (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
                                                 /* SENSOR_MI0360 1 */
-        (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
+        (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
                                                 /* SENSOR_MO4000 2 */
-        (1 << VFLIP_IDX),
+        (1 << VFLIP_IDX) | (1 << FREQ_IDX),
                                                 /* SENSOR_MT9V111 3 */
-        (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
+        (1 << INFRARED_IDX) | (1 << VFLIP_IDX) | (1 << FREQ_IDX),
                                                 /* SENSOR_OM6802 4 */
-        (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX),
+        (1 << INFRARED_IDX),
                                                 /* SENSOR_OV7630 5 */
         (1 << INFRARED_IDX),
                                                 /* SENSOR_OV7648 6 */
         (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
                                                 /* SENSOR_OV7660 7 */
-        (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX),
-                                                /* SENSOR_SP80708 8 */
+        (1 << AUTOGAIN_IDX) | (1 << INFRARED_IDX) | (1 << VFLIP_IDX) |
+                              (1 << FREQ_IDX),  /* SENSOR_SP80708 8 */
 };
 
 static const struct v4l2_pix_format vga_mode[] = {
@@ -268,7 +293,8 @@ static const struct v4l2_pix_format vga_mode[] = {
                 .priv = 1},
         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
                 .bytesperline = 640,
-                .sizeimage = 640 * 480 * 3 / 8 + 590,
+                /* Note 3 / 8 is not large enough, not even 5 / 8 is ?! */
+                .sizeimage = 640 * 480 * 3 / 4 + 590,
                 .colorspace = V4L2_COLORSPACE_JPEG,
                 .priv = 0},
 };
@@ -604,7 +630,9 @@ static const u8 ov7630_sensor_init[][8] = {
 /* win: i2c_r from 00 to 80 */
         {0xd1, 0x21, 0x03, 0x80, 0x10, 0x20, 0x80, 0x10},
         {0xb1, 0x21, 0x0c, 0x20, 0x20, 0x00, 0x00, 0x10},
-        {0xd1, 0x21, 0x11, 0x00, 0x48, 0xc0, 0x00, 0x10},
+/* HDG: 0x11 was 0x00 change to 0x01 for better exposure (15 fps instead of 30)
+        0x13 was 0xc0 change to 0xc3 for auto gain and exposure */
+        {0xd1, 0x21, 0x11, 0x01, 0x48, 0xc3, 0x00, 0x10},
         {0xb1, 0x21, 0x15, 0x80, 0x03, 0x00, 0x00, 0x10},
         {0xd1, 0x21, 0x17, 0x1b, 0xbd, 0x05, 0xf6, 0x10},
         {0xa1, 0x21, 0x1b, 0x04, 0x00, 0x00, 0x00, 0x10},
@@ -638,9 +666,8 @@ static const u8 ov7630_sensor_init[][8] = {
         {0xa1, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10},
         {0xb1, 0x21, 0x01, 0x80, 0x80, 0x00, 0x00, 0x10},
 /* */
-        {0xa1, 0x21, 0x11, 0x00, 0x00, 0x00, 0x00, 0x10},
-        {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10},
-        {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10},
+/*      {0xa1, 0x21, 0x2a, 0x88, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
+/*      {0xa1, 0x21, 0x2b, 0x34, 0x00, 0x00, 0x00, 0x10}, * set by setfreq */
 /* */
         {0xa1, 0x21, 0x10, 0x83, 0x00, 0x00, 0x00, 0x10},
 /*      {0xb1, 0x21, 0x01, 0x88, 0x70, 0x00, 0x00, 0x10}, */
@@ -673,7 +700,7 @@ static const u8 ov7648_sensor_init[][8] = {
         {0xd1, 0x21, 0x21, 0x86, 0x00, 0xde, 0xa0, 0x10},
 /*      {0xd1, 0x21, 0x25, 0x80, 0x32, 0xfe, 0xa0, 0x10}, jfm done */
 /*      {0xd1, 0x21, 0x29, 0x00, 0x91, 0x00, 0x88, 0x10}, jfm done */
-        {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10},
+/*      {0xb1, 0x21, 0x2d, 0x85, 0x00, 0x00, 0x00, 0x10}, set by setfreq */
 /*...*/
 /*      {0xa1, 0x21, 0x12, 0x08, 0x00, 0x00, 0x00, 0x10}, jfm done */
 /*      {0xa1, 0x21, 0x75, 0x06, 0x00, 0x00, 0x00, 0x10},   * COMN
@@ -1294,11 +1321,9 @@ static int sd_config(struct gspca_dev *gspca_dev,
         sd->gamma = GAMMA_DEF;
         sd->autogain = AUTOGAIN_DEF;
         sd->ag_cnt = -1;
-        if (sd->sensor != SENSOR_OV7630)
-                sd->vflip = 0;
-        else
-                sd->vflip = 1;
+        sd->vflip = VFLIP_DEF;
         sd->infrared = INFRARED_DEF;
+        sd->freq = FREQ_DEF;
         sd->quality = QUALITY_DEF;
         sd->jpegqual = 80;
 
@@ -1569,7 +1594,7 @@ static void setautogain(struct gspca_dev *gspca_dev)
                 else
                         comb = 0xa0;
                 if (sd->autogain)
-                        comb |= 0x02;
+                        comb |= 0x03;
                 i2c_w1(&sd->gspca_dev, 0x13, comb);
                 return;
             }
@@ -1585,12 +1610,15 @@ static void setvflip(struct sd *sd)
 {
         u8 comn;
 
-        if (sd->sensor == SENSOR_OV7630)
+        if (sd->sensor == SENSOR_OV7630) {
                 comn = 0x02;
-        else
+                if (!sd->vflip)
+                        comn |= 0x80;
+        } else {
                 comn = 0x06;
-        if (sd->vflip)
-                comn |= 0x80;
+                if (sd->vflip)
+                        comn |= 0x80;
+        }
         i2c_w1(&sd->gspca_dev, 0x75, comn);
 }
 
@@ -1602,6 +1630,58 @@ static void setinfrared(struct sd *sd)
                 sd->infrared ? 0x66 : 0x64);
 }
 
+static void setfreq(struct gspca_dev *gspca_dev)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        if (sd->sensor == SENSOR_OV7660) {
+                switch (sd->freq) {
+                case 0: /* Banding filter disabled */
+                        i2c_w1(gspca_dev, 0x13, 0xdf);
+                        break;
+                case 1: /* 50 hz */
+                        i2c_w1(gspca_dev, 0x13, 0xff);
+                        i2c_w1(gspca_dev, 0x3b, 0x0a);
+                        break;
+                case 2: /* 60 hz */
+                        i2c_w1(gspca_dev, 0x13, 0xff);
+                        i2c_w1(gspca_dev, 0x3b, 0x02);
+                        break;
+                }
+        } else {
+                u8 reg2a = 0, reg2b = 0, reg2d = 0;
+
+                /* Get reg2a / reg2d base values */
+                switch (sd->sensor) {
+                case SENSOR_OV7630:
+                        reg2a = 0x08;
+                        reg2d = 0x01;
+                        break;
+                case SENSOR_OV7648:
+                        reg2a = 0x11;
+                        reg2d = 0x81;
+                        break;
+                }
+
+                switch (sd->freq) {
+                case 0: /* Banding filter disabled */
+                        break;
+                case 1: /* 50 hz (filter on and framerate adj) */
+                        reg2a |= 0x80;
+                        reg2b = 0xac;
+                        reg2d |= 0x04;
+                        break;
+                case 2: /* 60 hz (filter on, no framerate adj) */
+                        reg2a |= 0x80;
+                        reg2d |= 0x04;
+                        break;
+                }
+                i2c_w1(gspca_dev, 0x2a, reg2a);
+                i2c_w1(gspca_dev, 0x2b, reg2b);
+                i2c_w1(gspca_dev, 0x2d, reg2d);
+        }
+}
+
 static void setjpegqual(struct gspca_dev *gspca_dev)
 {
         struct sd *sd = (struct sd *) gspca_dev;
@@ -1828,6 +1908,7 @@ static int sd_start(struct gspca_dev *gspca_dev)
         setbrightness(gspca_dev);
         setcontrast(gspca_dev);
         setautogain(gspca_dev);
+        setfreq(gspca_dev);
         return 0;
 }
 
@@ -2131,6 +2212,24 @@ static int sd_getinfrared(struct gspca_dev *gspca_dev, __s32 *val)
         return 0;
 }
 
+static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        sd->freq = val;
+        if (gspca_dev->streaming)
+                setfreq(gspca_dev);
+        return 0;
+}
+
+static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+
+        *val = sd->freq;
+        return 0;
+}
+
 static int sd_set_jcomp(struct gspca_dev *gspca_dev,
                         struct v4l2_jpegcompression *jcomp)
 {
@@ -2159,6 +2258,27 @@ static int sd_get_jcomp(struct gspca_dev *gspca_dev,
         return 0;
 }
 
+static int sd_querymenu(struct gspca_dev *gspca_dev,
+                        struct v4l2_querymenu *menu)
+{
+        switch (menu->id) {
+        case V4L2_CID_POWER_LINE_FREQUENCY:
+                switch (menu->index) {
+                case 0:         /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
+                        strcpy((char *) menu->name, "NoFliker");
+                        return 0;
+                case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
+                        strcpy((char *) menu->name, "50 Hz");
+                        return 0;
+                case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
+                        strcpy((char *) menu->name, "60 Hz");
+                        return 0;
+                }
+                break;
+        }
+        return -EINVAL;
+}
+
 /* sub-driver description */
 static const struct sd_desc sd_desc = {
         .name = MODULE_NAME,
@@ -2173,6 +2293,7 @@ static const struct sd_desc sd_desc = {
         .dq_callback = do_autogain,
         .get_jcomp = sd_get_jcomp,
         .set_jcomp = sd_set_jcomp,
+        .querymenu = sd_querymenu,
 };
 
 /* -- module initialisation -- */
@@ -2233,7 +2354,7 @@ static const __devinitdata struct usb_device_id device_table[] = {
         {USB_DEVICE(0x0c45, 0x613b), BSI(SN9C120, OV7660, 0x21)},
 #endif
         {USB_DEVICE(0x0c45, 0x613c), BSI(SN9C120, HV7131R, 0x11)},
-/*      {USB_DEVICE(0x0c45, 0x613e), BSI(SN9C120, OV7630, 0x??)}, */
+        {USB_DEVICE(0x0c45, 0x613e), BSI(SN9C120, OV7630, 0x21)},
         {USB_DEVICE(0x0c45, 0x6143), BSI(SN9C120, SP80708, 0x18)},
         {}
 };
diff --git a/drivers/media/video/gspca/stv06xx/Makefile b/drivers/media/video/gspca/stv06xx/Makefile
index feeaa94ab588..2f3c3a606ce4 100644
--- a/drivers/media/video/gspca/stv06xx/Makefile
+++ b/drivers/media/video/gspca/stv06xx/Makefile
@@ -3,7 +3,8 @@ obj-$(CONFIG_USB_STV06XX) += gspca_stv06xx.o
 gspca_stv06xx-objs := stv06xx.o \
                       stv06xx_vv6410.o \
                       stv06xx_hdcs.o \
-                      stv06xx_pb0100.o
+                      stv06xx_pb0100.o \
+                      stv06xx_st6422.o
 
 EXTRA_CFLAGS += -Idrivers/media/video/gspca
 
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.c b/drivers/media/video/gspca/stv06xx/stv06xx.c
index e573c3406324..0da8e0de0456 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.c
@@ -92,11 +92,10 @@ static int stv06xx_write_sensor_finish(struct sd *sd)
 {
         int err = 0;
 
-        if (IS_850(sd)) {
+        if (sd->bridge == BRIDGE_STV610) {
                 struct usb_device *udev = sd->gspca_dev.dev;
                 __u8 *buf = sd->gspca_dev.usb_buf;
 
-                /* Quickam Web needs an extra packet */
                 buf[0] = 0;
                 err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                                       0x04, 0x40, 0x1704, 0, buf, 1,
@@ -253,7 +252,7 @@ static int stv06xx_init(struct gspca_dev *gspca_dev)
 
         err = sd->sensor->init(sd);
 
-        if (dump_sensor)
+        if (dump_sensor && sd->sensor->dump)
                 sd->sensor->dump(sd);
 
         return (err < 0) ? err : 0;
@@ -318,6 +317,8 @@ static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
                         __u8 *data,                     /* isoc packet */
                         int len)                        /* iso packet length */
 {
+        struct sd *sd = (struct sd *) gspca_dev;
+
         PDEBUG(D_PACK, "Packet of length %d arrived", len);
 
         /* A packet may contain several frames
@@ -343,14 +344,29 @@ static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
                 if (len < chunk_len) {
                         PDEBUG(D_ERR, "URB packet length is smaller"
                                 " than the specified chunk length");
+                        gspca_dev->last_packet_type = DISCARD_PACKET;
                         return;
                 }
 
+                /* First byte seem to be 02=data 2nd byte is unknown??? */
+                if (sd->bridge == BRIDGE_ST6422 && (id & 0xFF00) == 0x0200)
+                        goto frame_data;
+
                 switch (id) {
                 case 0x0200:
                 case 0x4200:
+frame_data:
                         PDEBUG(D_PACK, "Frame data packet detected");
 
+                        if (sd->to_skip) {
+                                int skip = (sd->to_skip < chunk_len) ?
+                                            sd->to_skip : chunk_len;
+                                data += skip;
+                                len -= skip;
+                                chunk_len -= skip;
+                                sd->to_skip -= skip;
+                        }
+
                         gspca_frame_add(gspca_dev, INTER_PACKET, frame,
                                         data, chunk_len);
                         break;
@@ -365,6 +381,9 @@ static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
                         gspca_frame_add(gspca_dev, FIRST_PACKET,
                                         frame, data, 0);
 
+                        if (sd->bridge == BRIDGE_ST6422)
+                                sd->to_skip = gspca_dev->width * 4;
+
                         if (chunk_len)
                                 PDEBUG(D_ERR, "Chunk length is "
                                               "non-zero on a SOF");
@@ -395,8 +414,12 @@ static void stv06xx_pkt_scan(struct gspca_dev *gspca_dev,
                         /* Unknown chunk with 2 bytes of data,
                            occurs 2-3 times per USB interrupt */
                         break;
+                case 0x42ff:
+                        PDEBUG(D_PACK, "Chunk 0x42ff detected");
+                        /* Special chunk seen sometimes on the ST6422 */
+                        break;
                 default:
-                        PDEBUG(D_PACK, "Unknown chunk %d detected", id);
+                        PDEBUG(D_PACK, "Unknown chunk 0x%04x detected", id);
                         /* Unknown chunk */
                 }
                 data    += chunk_len;
@@ -428,11 +451,16 @@ static int stv06xx_config(struct gspca_dev *gspca_dev,
 
         cam = &gspca_dev->cam;
         sd->desc = sd_desc;
+        sd->bridge = id->driver_info;
         gspca_dev->sd_desc = &sd->desc;
 
         if (dump_bridge)
                 stv06xx_dump_bridge(sd);
 
+        sd->sensor = &stv06xx_sensor_st6422;
+        if (!sd->sensor->probe(sd))
+                return 0;
+
         sd->sensor = &stv06xx_sensor_vv6410;
         if (!sd->sensor->probe(sd))
                 return 0;
@@ -457,9 +485,20 @@ static int stv06xx_config(struct gspca_dev *gspca_dev,
 
 /* -- module initialisation -- */
 static const __devinitdata struct usb_device_id device_table[] = {
-        {USB_DEVICE(0x046d, 0x0840)}, /* QuickCam Express */
-        {USB_DEVICE(0x046d, 0x0850)}, /* LEGO cam / QuickCam Web */
-        {USB_DEVICE(0x046d, 0x0870)}, /* Dexxa WebCam USB */
+        /* QuickCam Express */
+        {USB_DEVICE(0x046d, 0x0840), .driver_info = BRIDGE_STV600 },
+        /* LEGO cam / QuickCam Web */
+        {USB_DEVICE(0x046d, 0x0850), .driver_info = BRIDGE_STV610 },
+        /* Dexxa WebCam USB */
+        {USB_DEVICE(0x046d, 0x0870), .driver_info = BRIDGE_STV602 },
+        /* QuickCam Messenger */
+        {USB_DEVICE(0x046D, 0x08F0), .driver_info = BRIDGE_ST6422 },
+        /* QuickCam Communicate */
+        {USB_DEVICE(0x046D, 0x08F5), .driver_info = BRIDGE_ST6422 },
+        /* QuickCam Messenger (new) */
+        {USB_DEVICE(0x046D, 0x08F6), .driver_info = BRIDGE_ST6422 },
+        /* QuickCam Messenger (new) */
+        {USB_DEVICE(0x046D, 0x08DA), .driver_info = BRIDGE_ST6422 },
         {}
 };
 MODULE_DEVICE_TABLE(usb, device_table);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx.h b/drivers/media/video/gspca/stv06xx/stv06xx.h
index 1207e7d17f14..9df7137fe67e 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx.h
@@ -93,6 +93,17 @@ struct sd {
 
         /* Sensor private data */
         void *sensor_priv;
+
+        /* The first 4 lines produced by the stv6422 are no good, this keeps
+           track of how many bytes we still need to skip during a frame */
+        int to_skip;
+
+        /* Bridge / Camera type */
+        u8 bridge;
+        #define BRIDGE_STV600 0
+        #define BRIDGE_STV602 1
+        #define BRIDGE_STV610 2
+        #define BRIDGE_ST6422 3 /* With integrated sensor */
 };
 
 int stv06xx_write_bridge(struct sd *sd, u16 address, u16 i2c_data);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
index b16903814203..3039ec208f3a 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_hdcs.c
@@ -434,7 +434,7 @@ static int hdcs_probe_1x00(struct sd *sd)
         hdcs->exp.er = 100;
 
         /*
-         * Frame rate on HDCS-1000 0x46D:0x840 depends on PSMP:
+         * Frame rate on HDCS-1000 with STV600 depends on PSMP:
          *  4 = doesn't work at all
          *  5 = 7.8 fps,
          *  6 = 6.9 fps,
@@ -443,7 +443,7 @@ static int hdcs_probe_1x00(struct sd *sd)
          * 15 = 4.4 fps,
          * 31 = 2.8 fps
          *
-         * Frame rate on HDCS-1000 0x46D:0x870 depends on PSMP:
+         * Frame rate on HDCS-1000 with STV602 depends on PSMP:
          * 15 = doesn't work at all
          * 18 = doesn't work at all
          * 19 = 7.3 fps
@@ -453,7 +453,7 @@ static int hdcs_probe_1x00(struct sd *sd)
          * 24 = 6.3 fps
          * 30 = 5.4 fps
          */
-        hdcs->psmp = IS_870(sd) ? 20 : 5;
+        hdcs->psmp = (sd->bridge == BRIDGE_STV602) ? 20 : 5;
 
         sd->sensor_priv = hdcs;
 
@@ -530,7 +530,7 @@ static int hdcs_init(struct sd *sd)
         int i, err = 0;
 
         /* Set the STV0602AA in STV0600 emulation mode */
-        if (IS_870(sd))
+        if (sd->bridge == BRIDGE_STV602)
                 stv06xx_write_bridge(sd, STV_STV0600_EMULATION, 1);
 
         /* Execute the bridge init */
@@ -558,7 +558,7 @@ static int hdcs_init(struct sd *sd)
                 return err;
 
         /* Set PGA sample duration
-        (was 0x7E for IS_870, but caused slow framerate with HDCS-1020) */
+        (was 0x7E for the STV602, but caused slow framerate with HDCS-1020) */
         if (IS_1020(sd))
                 err = stv06xx_write_sensor(sd, HDCS_TCTRL,
                                 (HDCS_ADC_START_SIG_DUR << 6) | hdcs->psmp);
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h b/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h
index e88c42f7d2f8..934b9cebc1ab 100644
--- a/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_sensor.h
@@ -32,14 +32,13 @@
 
 #include "stv06xx.h"
 
-#define IS_850(sd)      ((sd)->gspca_dev.dev->descriptor.idProduct == 0x850)
-#define IS_870(sd)      ((sd)->gspca_dev.dev->descriptor.idProduct == 0x870)
 #define IS_1020(sd)     ((sd)->sensor == &stv06xx_sensor_hdcs1020)
 
 extern const struct stv06xx_sensor stv06xx_sensor_vv6410;
 extern const struct stv06xx_sensor stv06xx_sensor_hdcs1x00;
 extern const struct stv06xx_sensor stv06xx_sensor_hdcs1020;
 extern const struct stv06xx_sensor stv06xx_sensor_pb0100;
+extern const struct stv06xx_sensor stv06xx_sensor_st6422;
 
 struct stv06xx_sensor {
         /* Defines the name of a sensor */
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
new file mode 100644
index 000000000000..87cb5b9ddfa7
--- /dev/null
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.c
@@ -0,0 +1,453 @@
+/*
+ * Support for the sensor part which is integrated (I think) into the
+ * st6422 stv06xx alike bridge, as its integrated there are no i2c writes
+ * but instead direct bridge writes.
+ *
+ * Copyright (c) 2009 Hans de Goede <hdegoede@redhat.com>
+ *
+ * Strongly based on qc-usb-messenger, which is:
+ * Copyright (c) 2001 Jean-Fredric Clere, Nikolas Zimmermann, Georg Acher
+ *                    Mark Cave-Ayland, Carlo E Prelz, Dick Streefland
+ * Copyright (c) 2002, 2003 Tuukka Toivonen
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#include "stv06xx_st6422.h"
+
+static struct v4l2_pix_format st6422_mode[] = {
+        /* Note we actually get 124 lines of data, of which we skip the 4st
+           4 as they are garbage */
+        {
+                162,
+                120,
+                V4L2_PIX_FMT_SGRBG8,
+                V4L2_FIELD_NONE,
+                .sizeimage = 162 * 120,
+                .bytesperline = 162,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 1
+        },
+        /* Note we actually get 248 lines of data, of which we skip the 4st
+           4 as they are garbage, and we tell the app it only gets the
+           first 240 of the 244 lines it actually gets, so that it ignores
+           the last 4. */
+        {
+                324,
+                240,
+                V4L2_PIX_FMT_SGRBG8,
+                V4L2_FIELD_NONE,
+                .sizeimage = 324 * 244,
+                .bytesperline = 324,
+                .colorspace = V4L2_COLORSPACE_SRGB,
+                .priv = 0
+        },
+};
+
+static const struct ctrl st6422_ctrl[] = {
+#define BRIGHTNESS_IDX 0
+        {
+                {
+                        .id             = V4L2_CID_BRIGHTNESS,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "Brightness",
+                        .minimum        = 0,
+                        .maximum        = 31,
+                        .step           = 1,
+                        .default_value  = 3
+                },
+                .set = st6422_set_brightness,
+                .get = st6422_get_brightness
+        },
+#define CONTRAST_IDX 1
+        {
+                {
+                        .id             = V4L2_CID_CONTRAST,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "Contrast",
+                        .minimum        = 0,
+                        .maximum        = 15,
+                        .step           = 1,
+                        .default_value  = 11
+                },
+                .set = st6422_set_contrast,
+                .get = st6422_get_contrast
+        },
+#define GAIN_IDX 2
+        {
+                {
+                        .id             = V4L2_CID_GAIN,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "Gain",
+                        .minimum        = 0,
+                        .maximum        = 255,
+                        .step           = 1,
+                        .default_value  = 64
+                },
+                .set = st6422_set_gain,
+                .get = st6422_get_gain
+        },
+#define EXPOSURE_IDX 3
+        {
+                {
+                        .id             = V4L2_CID_EXPOSURE,
+                        .type           = V4L2_CTRL_TYPE_INTEGER,
+                        .name           = "Exposure",
+                        .minimum        = 0,
+                        .maximum        = 1023,
+                        .step           = 1,
+                        .default_value  = 256
+                },
+                .set = st6422_set_exposure,
+                .get = st6422_get_exposure
+        },
+};
+
+static int st6422_probe(struct sd *sd)
+{
+        int i;
+        s32 *sensor_settings;
+
+        if (sd->bridge != BRIDGE_ST6422)
+                return -ENODEV;
+
+        info("st6422 sensor detected");
+
+        sensor_settings = kmalloc(ARRAY_SIZE(st6422_ctrl) * sizeof(s32),
+                                  GFP_KERNEL);
+        if (!sensor_settings)
+                return -ENOMEM;
+
+        sd->gspca_dev.cam.cam_mode = st6422_mode;
+        sd->gspca_dev.cam.nmodes = ARRAY_SIZE(st6422_mode);
+        sd->desc.ctrls = st6422_ctrl;
+        sd->desc.nctrls = ARRAY_SIZE(st6422_ctrl);
+        sd->sensor_priv = sensor_settings;
+
+        for (i = 0; i < sd->desc.nctrls; i++)
+                sensor_settings[i] = st6422_ctrl[i].qctrl.default_value;
+
+        return 0;
+}
+
+static int st6422_init(struct sd *sd)
+{
+        int err = 0, i;
+
+        const u16 st6422_bridge_init[][2] = {
+                { STV_ISO_ENABLE, 0x00 }, /* disable capture */
+                { 0x1436, 0x00 },
+                { 0x1432, 0x03 },       /* 0x00-0x1F brightness */
+                { 0x143a, 0xF9 },       /* 0x00-0x0F contrast */
+                { 0x0509, 0x38 },       /* R */
+                { 0x050a, 0x38 },       /* G */
+                { 0x050b, 0x38 },       /* B */
+                { 0x050c, 0x2A },
+                { 0x050d, 0x01 },
+
+
+                { 0x1431, 0x00 },       /* 0x00-0x07 ??? */
+                { 0x1433, 0x34 },       /* 160x120, 0x00-0x01 night filter */
+                { 0x1438, 0x18 },       /* 640x480 */
+/* 18 bayes */
+/* 10 compressed? */
+
+                { 0x1439, 0x00 },
+/* antiflimmer??  0xa2 ger perfekt bild mot monitor */
+
+                { 0x143b, 0x05 },
+                { 0x143c, 0x00 },       /* 0x00-0x01 - ??? */
+
+
+/* shutter time 0x0000-0x03FF */
+/* low value  give good picures on moving objects (but requires much light) */
+/* high value gives good picures in darkness (but tends to be overexposed) */
+                { 0x143e, 0x01 },
+                { 0x143d, 0x00 },
+
+                { 0x1442, 0xe2 },
+/* write: 1x1x xxxx */
+/* read:  1x1x xxxx */
+/*        bit 5 == button pressed and hold if 0 */
+/* write 0xe2,0xea */
+
+/* 0x144a */
+/* 0x00 init */
+/* bit 7 == button has been pressed, but not handled */
+
+/* interrupt */
+/* if(urb->iso_frame_desc[i].status == 0x80) { */
+/* if(urb->iso_frame_desc[i].status == 0x88) { */
+
+                { 0x1500, 0xd0 },
+                { 0x1500, 0xd0 },
+                { 0x1500, 0x50 },       /* 0x00 - 0xFF  0x80 == compr ? */
+
+                { 0x1501, 0xaf },
+/* high val-> ljus area blir morkare. */
+/* low val -> ljus area blir ljusare. */
+                { 0x1502, 0xc2 },
+/* high val-> ljus area blir morkare. */
+/* low val -> ljus area blir ljusare. */
+                { 0x1503, 0x45 },
+/* high val-> ljus area blir morkare. */
+/* low val -> ljus area blir ljusare. */
+
+                { 0x1505, 0x02 },
+/* 2  : 324x248  80352 bytes */
+/* 7  : 248x162  40176 bytes */
+/* c+f: 162*124  20088 bytes */
+
+                { 0x150e, 0x8e },
+                { 0x150f, 0x37 },
+                { 0x15c0, 0x00 },
+                { 0x15c1, 1023 }, /* 160x120, ISOC_PACKET_SIZE */
+                { 0x15c3, 0x08 },       /* 0x04/0x14 ... test pictures ??? */
+
+
+                { 0x143f, 0x01 },       /* commit settings */
+
+        };
+
+        for (i = 0; i < ARRAY_SIZE(st6422_bridge_init) && !err; i++) {
+                err = stv06xx_write_bridge(sd, st6422_bridge_init[i][0],
+                                               st6422_bridge_init[i][1]);
+        }
+
+        return err;
+}
+
+static void st6422_disconnect(struct sd *sd)
+{
+        sd->sensor = NULL;
+        kfree(sd->sensor_priv);
+}
+
+static int st6422_start(struct sd *sd)
+{
+        int err, packet_size;
+        struct cam *cam = &sd->gspca_dev.cam;
+        s32 *sensor_settings = sd->sensor_priv;
+        struct usb_host_interface *alt;
+        struct usb_interface *intf;
+
+        intf = usb_ifnum_to_if(sd->gspca_dev.dev, sd->gspca_dev.iface);
+        alt = usb_altnum_to_altsetting(intf, sd->gspca_dev.alt);
+        if (!alt) {
+                PDEBUG(D_ERR, "Couldn't get altsetting");
+                return -EIO;
+        }
+
+        packet_size = le16_to_cpu(alt->endpoint[0].desc.wMaxPacketSize);
+        err = stv06xx_write_bridge(sd, 0x15c1, packet_size);
+        if (err < 0)
+                return err;
+
+        if (cam->cam_mode[sd->gspca_dev.curr_mode].priv)
+                err = stv06xx_write_bridge(sd, 0x1505, 0x0f);
+        else
+                err = stv06xx_write_bridge(sd, 0x1505, 0x02);
+        if (err < 0)
+                return err;
+
+        err = st6422_set_brightness(&sd->gspca_dev,
+                                    sensor_settings[BRIGHTNESS_IDX]);
+        if (err < 0)
+                return err;
+
+        err = st6422_set_contrast(&sd->gspca_dev,
+                                  sensor_settings[CONTRAST_IDX]);
+        if (err < 0)
+                return err;
+
+        err = st6422_set_exposure(&sd->gspca_dev,
+                                  sensor_settings[EXPOSURE_IDX]);
+        if (err < 0)
+                return err;
+
+        err = st6422_set_gain(&sd->gspca_dev,
+                              sensor_settings[GAIN_IDX]);
+        if (err < 0)
+                return err;
+
+        PDEBUG(D_STREAM, "Starting stream");
+
+        return 0;
+}
+
+static int st6422_stop(struct sd *sd)
+{
+        PDEBUG(D_STREAM, "Halting stream");
+
+        return 0;
+}
+
+static int st6422_get_brightness(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[BRIGHTNESS_IDX];
+
+        PDEBUG(D_V4L2, "Read brightness %d", *val);
+
+        return 0;
+}
+
+static int st6422_set_brightness(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        sensor_settings[BRIGHTNESS_IDX] = val;
+
+        if (!gspca_dev->streaming)
+                return 0;
+
+        /* val goes from 0 -> 31 */
+        PDEBUG(D_V4L2, "Set brightness to %d", val);
+        err = stv06xx_write_bridge(sd, 0x1432, val);
+        if (err < 0)
+                return err;
+
+        /* commit settings */
+        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
+        return (err < 0) ? err : 0;
+}
+
+static int st6422_get_contrast(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[CONTRAST_IDX];
+
+        PDEBUG(D_V4L2, "Read contrast %d", *val);
+
+        return 0;
+}
+
+static int st6422_set_contrast(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        sensor_settings[CONTRAST_IDX] = val;
+
+        if (!gspca_dev->streaming)
+                return 0;
+
+        /* Val goes from 0 -> 15 */
+        PDEBUG(D_V4L2, "Set contrast to %d\n", val);
+        err = stv06xx_write_bridge(sd, 0x143a, 0xf0 | val);
+        if (err < 0)
+                return err;
+
+        /* commit settings */
+        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
+        return (err < 0) ? err : 0;
+}
+
+static int st6422_get_gain(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[GAIN_IDX];
+
+        PDEBUG(D_V4L2, "Read gain %d", *val);
+
+        return 0;
+}
+
+static int st6422_set_gain(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        sensor_settings[GAIN_IDX] = val;
+
+        if (!gspca_dev->streaming)
+                return 0;
+
+        PDEBUG(D_V4L2, "Set gain to %d", val);
+
+        /* Set red, green, blue, gain */
+        err = stv06xx_write_bridge(sd, 0x0509, val);
+        if (err < 0)
+                return err;
+
+        err = stv06xx_write_bridge(sd, 0x050a, val);
+        if (err < 0)
+                return err;
+
+        err = stv06xx_write_bridge(sd, 0x050b, val);
+        if (err < 0)
+                return err;
+
+        /* 2 mystery writes */
+        err = stv06xx_write_bridge(sd, 0x050c, 0x2a);
+        if (err < 0)
+                return err;
+
+        err = stv06xx_write_bridge(sd, 0x050d, 0x01);
+        if (err < 0)
+                return err;
+
+        /* commit settings */
+        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
+        return (err < 0) ? err : 0;
+}
+
+static int st6422_get_exposure(struct gspca_dev *gspca_dev, __s32 *val)
+{
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        *val = sensor_settings[EXPOSURE_IDX];
+
+        PDEBUG(D_V4L2, "Read exposure %d", *val);
+
+        return 0;
+}
+
+static int st6422_set_exposure(struct gspca_dev *gspca_dev, __s32 val)
+{
+        int err;
+        struct sd *sd = (struct sd *) gspca_dev;
+        s32 *sensor_settings = sd->sensor_priv;
+
+        sensor_settings[EXPOSURE_IDX] = val;
+
+        if (!gspca_dev->streaming)
+                return 0;
+
+        PDEBUG(D_V4L2, "Set exposure to %d\n", val);
+        err = stv06xx_write_bridge(sd, 0x143d, val & 0xff);
+        if (err < 0)
+                return err;
+
+        err = stv06xx_write_bridge(sd, 0x143e, val >> 8);
+        if (err < 0)
+                return err;
+
+        /* commit settings */
+        err = stv06xx_write_bridge(sd, 0x143f, 0x01);
+        return (err < 0) ? err : 0;
+}
diff --git a/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h
new file mode 100644
index 000000000000..b2d45fe50522
--- /dev/null
+++ b/drivers/media/video/gspca/stv06xx/stv06xx_st6422.h
@@ -0,0 +1,59 @@
+/*
+ * Support for the sensor part which is integrated (I think) into the
+ * st6422 stv06xx alike bridge, as its integrated there are no i2c writes
+ * but instead direct bridge writes.
+ *
+ * Copyright (c) 2009 Hans de Goede <hdegoede@redhat.com>
+ *
+ * Strongly based on qc-usb-messenger, which is:
+ * Copyright (c) 2001 Jean-Fredric Clere, Nikolas Zimmermann, Georg Acher
+ *                    Mark Cave-Ayland, Carlo E Prelz, Dick Streefland
+ * Copyright (c) 2002, 2003 Tuukka Toivonen
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ */
+
+#ifndef STV06XX_ST6422_H_
+#define STV06XX_ST6422_H_
+
+#include "stv06xx_sensor.h"
+
+static int st6422_probe(struct sd *sd);
+static int st6422_start(struct sd *sd);
+static int st6422_init(struct sd *sd);
+static int st6422_stop(struct sd *sd);
+static void st6422_disconnect(struct sd *sd);
+
+/* V4L2 controls supported by the driver */
+static int st6422_get_brightness(struct gspca_dev *gspca_dev, __s32 *val);
+static int st6422_set_brightness(struct gspca_dev *gspca_dev, __s32 val);
+static int st6422_get_contrast(struct gspca_dev *gspca_dev, __s32 *val);
+static int st6422_set_contrast(struct gspca_dev *gspca_dev, __s32 val);
+static int st6422_get_gain(struct gspca_dev *gspca_dev, __s32 *val);
+static int st6422_set_gain(struct gspca_dev *gspca_dev, __s32 val);
+static int st6422_get_exposure(struct gspca_dev *gspca_dev, __s32 *val);
+static int st6422_set_exposure(struct gspca_dev *gspca_dev, __s32 val);
+
+const struct stv06xx_sensor stv06xx_sensor_st6422 = {
+        .name = "ST6422",
+        .init = st6422_init,
+        .probe = st6422_probe,
+        .start = st6422_start,
+        .stop = st6422_stop,
+        .disconnect = st6422_disconnect,
+};
+
+#endif
diff --git a/drivers/media/video/ivtv/ivtv-controls.c b/drivers/media/video/ivtv/ivtv-controls.c
index 84995bcf4a75..a3b77ed3f089 100644
--- a/drivers/media/video/ivtv/ivtv-controls.c
+++ b/drivers/media/video/ivtv/ivtv-controls.c
@@ -60,6 +60,8 @@ int ivtv_queryctrl(struct file *file, void *fh, struct v4l2_queryctrl *qctrl)
 
         switch (qctrl->id) {
         /* Standard V4L2 controls */
+        case V4L2_CID_USER_CLASS:
+                return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
         case V4L2_CID_BRIGHTNESS:
         case V4L2_CID_HUE:
         case V4L2_CID_SATURATION:
diff --git a/drivers/media/video/mt9m001.c b/drivers/media/video/mt9m001.c
index 459c04cbf69d..4d794b42d6cd 100644
--- a/drivers/media/video/mt9m001.c
+++ b/drivers/media/video/mt9m001.c
@@ -280,15 +280,9 @@ static int mt9m001_try_fmt(struct soc_camera_device *icd,
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
-        if (pix->height < 32 + icd->y_skip_top)
-                pix->height = 32 + icd->y_skip_top;
-        if (pix->height > 1024 + icd->y_skip_top)
-                pix->height = 1024 + icd->y_skip_top;
-        if (pix->width < 48)
-                pix->width = 48;
-        if (pix->width > 1280)
-                pix->width = 1280;
-        pix->width &= ~0x01; /* has to be even, unsure why was ~3 */
+        v4l_bound_align_image(&pix->width, 48, 1280, 1,
+                              &pix->height, 32 + icd->y_skip_top,
+                              1024 + icd->y_skip_top, 0, 0);
 
         return 0;
 }
diff --git a/drivers/media/video/mt9t031.c b/drivers/media/video/mt9t031.c
index f72aeb7c4deb..4207fb342670 100644
--- a/drivers/media/video/mt9t031.c
+++ b/drivers/media/video/mt9t031.c
@@ -385,17 +385,9 @@ static int mt9t031_try_fmt(struct soc_camera_device *icd,
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
-        if (pix->height < MT9T031_MIN_HEIGHT)
-                pix->height = MT9T031_MIN_HEIGHT;
-        if (pix->height > MT9T031_MAX_HEIGHT)
-                pix->height = MT9T031_MAX_HEIGHT;
-        if (pix->width < MT9T031_MIN_WIDTH)
-                pix->width = MT9T031_MIN_WIDTH;
-        if (pix->width > MT9T031_MAX_WIDTH)
-                pix->width = MT9T031_MAX_WIDTH;
-
-        pix->width &= ~0x01; /* has to be even */
-        pix->height &= ~0x01; /* has to be even */
+        v4l_bound_align_image(
+                &pix->width, MT9T031_MIN_WIDTH, MT9T031_MAX_WIDTH, 1,
+                &pix->height, MT9T031_MIN_HEIGHT, MT9T031_MAX_HEIGHT, 1, 0);
 
         return 0;
 }
diff --git a/drivers/media/video/mt9v022.c b/drivers/media/video/mt9v022.c
index be20d312b1dc..dbdcc86ae50d 100644
--- a/drivers/media/video/mt9v022.c
+++ b/drivers/media/video/mt9v022.c
@@ -364,15 +364,9 @@ static int mt9v022_try_fmt(struct soc_camera_device *icd,
 {
         struct v4l2_pix_format *pix = &f->fmt.pix;
 
-        if (pix->height < 32 + icd->y_skip_top)
-                pix->height = 32 + icd->y_skip_top;
-        if (pix->height > 480 + icd->y_skip_top)
-                pix->height = 480 + icd->y_skip_top;
-        if (pix->width < 48)
-                pix->width = 48;
-        if (pix->width > 752)
-                pix->width = 752;
-        pix->width &= ~0x03; /* ? */
+        v4l_bound_align_image(&pix->width, 48, 752, 2 /* ? */,
+                              &pix->height, 32 + icd->y_skip_top,
+                              480 + icd->y_skip_top, 0, 0);
 
         return 0;
 }
diff --git a/drivers/media/video/ov511.c b/drivers/media/video/ov511.c
index 08cfd3e4ae8a..0bc2cf573c76 100644
--- a/drivers/media/video/ov511.c
+++ b/drivers/media/video/ov511.c
@@ -211,8 +211,6 @@ static const int i2c_detect_tries = 5;
 static struct usb_device_id device_table [] = {
         { USB_DEVICE(VEND_OMNIVISION, PROD_OV511) },
         { USB_DEVICE(VEND_OMNIVISION, PROD_OV511PLUS) },
-        { USB_DEVICE(VEND_OMNIVISION, PROD_OV518) },
-        { USB_DEVICE(VEND_OMNIVISION, PROD_OV518PLUS) },
         { USB_DEVICE(VEND_MATTEL, PROD_ME2CAM) },
         { }  /* Terminating entry */
 };
diff --git a/drivers/media/video/pvrusb2/pvrusb2-audio.c b/drivers/media/video/pvrusb2/pvrusb2-audio.c
index 10ef1a2c13ea..416933ca607d 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-audio.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-audio.c
@@ -48,11 +48,13 @@ static const int routing_scheme0[] = {
                                                 MSP_DSP_IN_SCART),
 };
 
-static const struct routing_scheme routing_schemes[] = {
-        [PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
-                .def = routing_scheme0,
-                .cnt = ARRAY_SIZE(routing_scheme0),
-        },
+static const struct routing_scheme routing_def0 = {
+        .def = routing_scheme0,
+        .cnt = ARRAY_SIZE(routing_scheme0),
+};
+
+static const struct routing_scheme *routing_schemes[] = {
+        [PVR2_ROUTING_SCHEME_HAUPPAUGE] = &routing_def0,
 };
 
 void pvr2_msp3400_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
@@ -65,7 +67,7 @@ void pvr2_msp3400_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                 pvr2_trace(PVR2_TRACE_CHIPS, "subdev msp3400 v4l2 set_stereo");
 
                 if ((sid < ARRAY_SIZE(routing_schemes)) &&
-                    ((sp = routing_schemes + sid) != NULL) &&
+                    ((sp = routing_schemes[sid]) != NULL) &&
                     (hdw->input_val >= 0) &&
                     (hdw->input_val < sp->cnt)) {
                         input = sp->def[hdw->input_val];
diff --git a/drivers/media/video/pvrusb2/pvrusb2-cs53l32a.c b/drivers/media/video/pvrusb2/pvrusb2-cs53l32a.c
index 9023adf3fdcc..68980e19409f 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-cs53l32a.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-cs53l32a.c
@@ -49,11 +49,13 @@ static const int routing_scheme1[] = {
         [PVR2_CVAL_INPUT_SVIDEO] =  0,
 };
 
-static const struct routing_scheme routing_schemes[] = {
-        [PVR2_ROUTING_SCHEME_ONAIR] = {
-                .def = routing_scheme1,
-                .cnt = ARRAY_SIZE(routing_scheme1),
-        },
+static const struct routing_scheme routing_def1 = {
+        .def = routing_scheme1,
+        .cnt = ARRAY_SIZE(routing_scheme1),
+};
+
+static const struct routing_scheme *routing_schemes[] = {
+        [PVR2_ROUTING_SCHEME_ONAIR] = &routing_def1,
 };
 
 
@@ -65,12 +67,11 @@ void pvr2_cs53l32a_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                 u32 input;
                 pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_input(%d)",
                            hdw->input_val);
-                if ((sid < ARRAY_SIZE(routing_schemes)) &&
-                    ((sp = routing_schemes + sid) != NULL) &&
-                    (hdw->input_val >= 0) &&
-                    (hdw->input_val < sp->cnt)) {
-                        input = sp->def[hdw->input_val];
-                } else {
+                sp = (sid < ARRAY_SIZE(routing_schemes)) ?
+                        routing_schemes[sid] : NULL;
+                if ((sp == NULL) ||
+                    (hdw->input_val < 0) ||
+                    (hdw->input_val >= sp->cnt)) {
                         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
                                    "*** WARNING *** subdev v4l2 set_input:"
                                    " Invalid routing scheme (%u)"
@@ -78,6 +79,7 @@ void pvr2_cs53l32a_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                                    sid, hdw->input_val);
                         return;
                 }
+                input = sp->def[hdw->input_val];
                 sd->ops->audio->s_routing(sd, input, 0, 0);
         }
 }
diff --git a/drivers/media/video/pvrusb2/pvrusb2-cx2584x-v4l.c b/drivers/media/video/pvrusb2/pvrusb2-cx2584x-v4l.c
index 05e52358ae49..82c135835753 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-cx2584x-v4l.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-cx2584x-v4l.c
@@ -68,6 +68,11 @@ static const struct routing_scheme_item routing_scheme0[] = {
         },
 };
 
+static const struct routing_scheme routing_def0 = {
+        .def = routing_scheme0,
+        .cnt = ARRAY_SIZE(routing_scheme0),
+};
+
 /* Specific to gotview device */
 static const struct routing_scheme_item routing_schemegv[] = {
         [PVR2_CVAL_INPUT_TV] = {
@@ -90,15 +95,14 @@ static const struct routing_scheme_item routing_schemegv[] = {
         },
 };
 
-static const struct routing_scheme routing_schemes[] = {
-        [PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
-                .def = routing_scheme0,
-                .cnt = ARRAY_SIZE(routing_scheme0),
-        },
-        [PVR2_ROUTING_SCHEME_GOTVIEW] = {
-                .def = routing_schemegv,
-                .cnt = ARRAY_SIZE(routing_schemegv),
-        },
+static const struct routing_scheme routing_defgv = {
+        .def = routing_schemegv,
+        .cnt = ARRAY_SIZE(routing_schemegv),
+};
+
+static const struct routing_scheme *routing_schemes[] = {
+        [PVR2_ROUTING_SCHEME_HAUPPAUGE] = &routing_def0,
+        [PVR2_ROUTING_SCHEME_GOTVIEW] = &routing_defgv,
 };
 
 void pvr2_cx25840_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
@@ -110,13 +114,11 @@ void pvr2_cx25840_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                 const struct routing_scheme *sp;
                 unsigned int sid = hdw->hdw_desc->signal_routing_scheme;
 
-                if ((sid < ARRAY_SIZE(routing_schemes)) &&
-                    ((sp = routing_schemes + sid) != NULL) &&
-                    (hdw->input_val >= 0) &&
-                    (hdw->input_val < sp->cnt)) {
-                        vid_input = sp->def[hdw->input_val].vid;
-                        aud_input = sp->def[hdw->input_val].aud;
-                } else {
+                sp = (sid < ARRAY_SIZE(routing_schemes)) ?
+                        routing_schemes[sid] : NULL;
+                if ((sp == NULL) ||
+                    (hdw->input_val < 0) ||
+                    (hdw->input_val >= sp->cnt)) {
                         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
                                    "*** WARNING *** subdev cx2584x set_input:"
                                    " Invalid routing scheme (%u)"
@@ -124,7 +126,8 @@ void pvr2_cx25840_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                                    sid, hdw->input_val);
                         return;
                 }
-
+                vid_input = sp->def[hdw->input_val].vid;
+                aud_input = sp->def[hdw->input_val].aud;
                 pvr2_trace(PVR2_TRACE_CHIPS,
                            "subdev cx2584x set_input vid=0x%x aud=0x%x",
                            vid_input, aud_input);
diff --git a/drivers/media/video/pvrusb2/pvrusb2-hdw.c b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
index 0c745b142fb7..cbc388729d77 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-hdw.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-hdw.c
@@ -85,8 +85,8 @@ MODULE_PARM_DESC(video_std,"specify initial video standard");
 module_param_array(tolerance,    int, NULL, 0444);
 MODULE_PARM_DESC(tolerance,"specify stream error tolerance");
 
-/* US Broadcast channel 7 (175.25 MHz) */
-static int default_tv_freq    = 175250000L;
+/* US Broadcast channel 3 (61.25 MHz), to help with testing */
+static int default_tv_freq    = 61250000L;
 /* 104.3 MHz, a usable FM station for my area */
 static int default_radio_freq = 104300000L;
 
@@ -1987,6 +1987,34 @@ static unsigned int pvr2_copy_i2c_addr_list(
 }
 
 
+static void pvr2_hdw_cx25840_vbi_hack(struct pvr2_hdw *hdw)
+{
+        /*
+          Mike Isely <isely@pobox.com> 19-Nov-2006 - This bit of nuttiness
+          for cx25840 causes that module to correctly set up its video
+          scaling.  This is really a problem in the cx25840 module itself,
+          but we work around it here.  The problem has not been seen in
+          ivtv because there VBI is supported and set up.  We don't do VBI
+          here (at least not yet) and thus we never attempted to even set
+          it up.
+        */
+        struct v4l2_format fmt;
+        if (hdw->decoder_client_id != PVR2_CLIENT_ID_CX25840) {
+                /* We're not using a cx25840 so don't enable the hack */
+                return;
+        }
+
+        pvr2_trace(PVR2_TRACE_INIT,
+                   "Module ID %u:"
+                   " Executing cx25840 VBI hack",
+                   hdw->decoder_client_id);
+        memset(&fmt, 0, sizeof(fmt));
+        fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
+        v4l2_device_call_all(&hdw->v4l2_dev, hdw->decoder_client_id,
+                             video, s_fmt, &fmt);
+}
+
+
 static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
                                 const struct pvr2_device_client_desc *cd)
 {
@@ -2078,30 +2106,6 @@ static int pvr2_hdw_load_subdev(struct pvr2_hdw *hdw,
         /* client-specific setup... */
         switch (mid) {
         case PVR2_CLIENT_ID_CX25840:
-                hdw->decoder_client_id = mid;
-                {
-                        /*
-                          Mike Isely <isely@pobox.com> 19-Nov-2006 - This
-                          bit of nuttiness for cx25840 causes that module
-                          to correctly set up its video scaling.  This is
-                          really a problem in the cx25840 module itself,
-                          but we work around it here.  The problem has not
-                          been seen in ivtv because there VBI is supported
-                          and set up.  We don't do VBI here (at least not
-                          yet) and thus we never attempted to even set it
-                          up.
-                        */
-                        struct v4l2_format fmt;
-                        pvr2_trace(PVR2_TRACE_INIT,
-                                   "Module ID %u:"
-                                   " Executing cx25840 VBI hack",
-                                   mid);
-                        memset(&fmt, 0, sizeof(fmt));
-                        fmt.type = V4L2_BUF_TYPE_SLICED_VBI_CAPTURE;
-                        v4l2_device_call_all(&hdw->v4l2_dev, mid,
-                                             video, s_fmt, &fmt);
-                }
-                break;
         case PVR2_CLIENT_ID_SAA7115:
                 hdw->decoder_client_id = mid;
                 break;
@@ -2202,6 +2206,8 @@ static void pvr2_hdw_setup_low(struct pvr2_hdw *hdw)
                 cptr->info->set_value(cptr,~0,cptr->info->default_value);
         }
 
+        pvr2_hdw_cx25840_vbi_hack(hdw);
+
         /* Set up special default values for the television and radio
            frequencies here.  It's not really important what these defaults
            are, but I set them to something usable in the Chicago area just
@@ -2954,6 +2960,7 @@ static void pvr2_subdev_update(struct pvr2_hdw *hdw)
                         vs = hdw->std_mask_cur;
                         v4l2_device_call_all(&hdw->v4l2_dev, 0,
                                              core, s_std, vs);
+                        pvr2_hdw_cx25840_vbi_hack(hdw);
                 }
                 hdw->tuner_signal_stale = !0;
                 hdw->cropcap_stale = !0;
@@ -4076,6 +4083,7 @@ int pvr2_hdw_cmd_decoder_reset(struct pvr2_hdw *hdw)
         if (hdw->decoder_client_id) {
                 v4l2_device_call_all(&hdw->v4l2_dev, hdw->decoder_client_id,
                                      core, reset, 0);
+                pvr2_hdw_cx25840_vbi_hack(hdw);
                 return 0;
         }
         pvr2_trace(PVR2_TRACE_INIT,
diff --git a/drivers/media/video/pvrusb2/pvrusb2-video-v4l.c b/drivers/media/video/pvrusb2/pvrusb2-video-v4l.c
index d2fe7c8f2c3a..4c96cf48c796 100644
--- a/drivers/media/video/pvrusb2/pvrusb2-video-v4l.c
+++ b/drivers/media/video/pvrusb2/pvrusb2-video-v4l.c
@@ -54,6 +54,11 @@ static const int routing_scheme0[] = {
         [PVR2_CVAL_INPUT_SVIDEO] =  SAA7115_SVIDEO2,
 };
 
+static const struct routing_scheme routing_def0 = {
+        .def = routing_scheme0,
+        .cnt = ARRAY_SIZE(routing_scheme0),
+};
+
 static const int routing_scheme1[] = {
         [PVR2_CVAL_INPUT_TV] = SAA7115_COMPOSITE4,
         [PVR2_CVAL_INPUT_RADIO] = SAA7115_COMPOSITE5,
@@ -61,15 +66,14 @@ static const int routing_scheme1[] = {
         [PVR2_CVAL_INPUT_SVIDEO] =  SAA7115_SVIDEO2, /* or SVIDEO0, it seems */
 };
 
-static const struct routing_scheme routing_schemes[] = {
-        [PVR2_ROUTING_SCHEME_HAUPPAUGE] = {
-                .def = routing_scheme0,
-                .cnt = ARRAY_SIZE(routing_scheme0),
-        },
-        [PVR2_ROUTING_SCHEME_ONAIR] = {
-                .def = routing_scheme1,
-                .cnt = ARRAY_SIZE(routing_scheme1),
-        },
+static const struct routing_scheme routing_def1 = {
+        .def = routing_scheme1,
+        .cnt = ARRAY_SIZE(routing_scheme1),
+};
+
+static const struct routing_scheme *routing_schemes[] = {
+        [PVR2_ROUTING_SCHEME_HAUPPAUGE] = &routing_def0,
+        [PVR2_ROUTING_SCHEME_ONAIR] = &routing_def1,
 };
 
 void pvr2_saa7115_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
@@ -81,12 +85,12 @@ void pvr2_saa7115_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
 
                 pvr2_trace(PVR2_TRACE_CHIPS, "subdev v4l2 set_input(%d)",
                            hdw->input_val);
-                if ((sid < ARRAY_SIZE(routing_schemes)) &&
-                    ((sp = routing_schemes + sid) != NULL) &&
-                    (hdw->input_val >= 0) &&
-                    (hdw->input_val < sp->cnt)) {
-                        input = sp->def[hdw->input_val];
-                } else {
+
+                sp = (sid < ARRAY_SIZE(routing_schemes)) ?
+                        routing_schemes[sid] : NULL;
+                if ((sp == NULL) ||
+                    (hdw->input_val < 0) ||
+                    (hdw->input_val >= sp->cnt)) {
                         pvr2_trace(PVR2_TRACE_ERROR_LEGS,
                                    "*** WARNING *** subdev v4l2 set_input:"
                                    " Invalid routing scheme (%u)"
@@ -94,6 +98,7 @@ void pvr2_saa7115_subdev_update(struct pvr2_hdw *hdw, struct v4l2_subdev *sd)
                                    sid, hdw->input_val);
                         return;
                 }
+                input = sp->def[hdw->input_val];
                 sd->ops->video->s_routing(sd, input, 0, 0);
         }
 }
diff --git a/drivers/media/video/pxa_camera.c b/drivers/media/video/pxa_camera.c
index f60de40fd21f..46e0d8ad880f 100644
--- a/drivers/media/video/pxa_camera.c
+++ b/drivers/media/video/pxa_camera.c
@@ -163,13 +163,6 @@
                         CICR0_EOFM | CICR0_FOM)
 
 /*
- * YUV422P picture size should be a multiple of 16, so the heuristic aligns
- * height, width on 4 byte boundaries to reach the 16 multiple for the size.
- */
-#define YUV422P_X_Y_ALIGN 4
-#define YUV422P_SIZE_ALIGN YUV422P_X_Y_ALIGN * YUV422P_X_Y_ALIGN
-
-/*
  * Structures
  */
 enum pxa_camera_active_dma {
@@ -1398,28 +1391,15 @@ static int pxa_camera_try_fmt(struct soc_camera_device *icd,
                 return -EINVAL;
         }
 
-        /* limit to pxa hardware capabilities */
-        if (pix->height < 32)
-                pix->height = 32;
-        if (pix->height > 2048)
-                pix->height = 2048;
-        if (pix->width < 48)
-                pix->width = 48;
-        if (pix->width > 2048)
-                pix->width = 2048;
-        pix->width &= ~0x01;
-
         /*
-         * YUV422P planar format requires images size to be a 16 bytes
-         * multiple. If not, zeros will be inserted between Y and U planes, and
-         * U and V planes, and YUV422P standard would be violated.
+         * Limit to pxa hardware capabilities.  YUV422P planar format requires
+         * images size to be a multiple of 16 bytes.  If not, zeros will be
+         * inserted between Y and U planes, and U and V planes, which violates
+         * the YUV422P standard.
          */
-        if (xlate->host_fmt->fourcc == V4L2_PIX_FMT_YUV422P) {
-                if (!IS_ALIGNED(pix->width * pix->height, YUV422P_SIZE_ALIGN))
-                        pix->height = ALIGN(pix->height, YUV422P_X_Y_ALIGN);
-                if (!IS_ALIGNED(pix->width * pix->height, YUV422P_SIZE_ALIGN))
-                        pix->width = ALIGN(pix->width, YUV422P_X_Y_ALIGN);
-        }
+        v4l_bound_align_image(&pix->width, 48, 2048, 1,
+                              &pix->height, 32, 2048, 0,
+                              xlate->host_fmt->fourcc == V4L2_PIX_FMT_YUV422P ? 4 : 0);
 
         pix->bytesperline = pix->width *
                 DIV_ROUND_UP(xlate->host_fmt->depth, 8);
diff --git a/drivers/media/video/saa7134/saa7134-video.c b/drivers/media/video/saa7134/saa7134-video.c
index e305c1674cee..ba87128542e0 100644
--- a/drivers/media/video/saa7134/saa7134-video.c
+++ b/drivers/media/video/saa7134/saa7134-video.c
@@ -1640,15 +1640,8 @@ static int saa7134_try_fmt_vid_cap(struct file *file, void *priv,
         }
 
         f->fmt.pix.field = field;
-        if (f->fmt.pix.width  < 48)
-                f->fmt.pix.width  = 48;
-        if (f->fmt.pix.height < 32)
-                f->fmt.pix.height = 32;
-        if (f->fmt.pix.width > maxw)
-                f->fmt.pix.width = maxw;
-        if (f->fmt.pix.height > maxh)
-                f->fmt.pix.height = maxh;
-        f->fmt.pix.width &= ~0x03;
+        v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
+                              &f->fmt.pix.height, 32, maxh, 0, 0);
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
diff --git a/drivers/media/video/sh_mobile_ceu_camera.c b/drivers/media/video/sh_mobile_ceu_camera.c
index d369e8409ab8..0db88a53d92c 100644
--- a/drivers/media/video/sh_mobile_ceu_camera.c
+++ b/drivers/media/video/sh_mobile_ceu_camera.c
@@ -689,16 +689,8 @@ static int sh_mobile_ceu_try_fmt(struct soc_camera_device *icd,
 
         /* FIXME: calculate using depth and bus width */
 
-        if (f->fmt.pix.height < 4)
-                f->fmt.pix.height = 4;
-        if (f->fmt.pix.height > 1920)
-                f->fmt.pix.height = 1920;
-        if (f->fmt.pix.width < 2)
-                f->fmt.pix.width = 2;
-        if (f->fmt.pix.width > 2560)
-                f->fmt.pix.width = 2560;
-        f->fmt.pix.width &= ~0x01;
-        f->fmt.pix.height &= ~0x03;
+        v4l_bound_align_image(&f->fmt.pix.width, 2, 2560, 1,
+                              &f->fmt.pix.height, 4, 1920, 2, 0);
 
         f->fmt.pix.bytesperline = f->fmt.pix.width *
                 DIV_ROUND_UP(xlate->host_fmt->depth, 8);
diff --git a/drivers/media/video/tcm825x.c b/drivers/media/video/tcm825x.c
index b30c49248217..b90e9da3167d 100644
--- a/drivers/media/video/tcm825x.c
+++ b/drivers/media/video/tcm825x.c
@@ -878,7 +878,7 @@ static int tcm825x_probe(struct i2c_client *client,
         return rval;
 }
 
-static int __exit tcm825x_remove(struct i2c_client *client)
+static int tcm825x_remove(struct i2c_client *client)
 {
         struct tcm825x_sensor *sensor = i2c_get_clientdata(client);
 
@@ -902,7 +902,7 @@ static struct i2c_driver tcm825x_i2c_driver = {
                 .name = TCM825X_NAME,
         },
         .probe  = tcm825x_probe,
-        .remove = __exit_p(tcm825x_remove),
+        .remove = tcm825x_remove,
         .id_table = tcm825x_id,
 };
 
diff --git a/drivers/media/video/usbvideo/Kconfig b/drivers/media/video/usbvideo/Kconfig
index e4cb99c1f94b..adb1c044ad7d 100644
--- a/drivers/media/video/usbvideo/Kconfig
+++ b/drivers/media/video/usbvideo/Kconfig
@@ -38,10 +38,13 @@ config USB_KONICAWC
           module will be called konicawc.
 
 config USB_QUICKCAM_MESSENGER
-        tristate "USB Logitech Quickcam Messenger"
+        tristate "USB Logitech Quickcam Messenger (DEPRECATED)"
         depends on VIDEO_V4L1
         select VIDEO_USBVIDEO
         ---help---
+          This driver is DEPRECATED please use the gspca stv06xx module
+          instead.
+
           Say Y or M here to enable support for the USB Logitech Quickcam
           Messenger webcam.
 
diff --git a/drivers/media/video/v4l2-common.c b/drivers/media/video/v4l2-common.c
index f96475626da7..b91d66a767d7 100644
--- a/drivers/media/video/v4l2-common.c
+++ b/drivers/media/video/v4l2-common.c
@@ -802,6 +802,17 @@ struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
         /* Decrease the module use count to match the first try_module_get. */
         module_put(client->driver->driver.owner);
 
+        if (sd) {
+                /* We return errors from v4l2_subdev_call only if we have the
+                   callback as the .s_config is not mandatory */
+                int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
+
+                if (err && err != -ENOIOCTLCMD) {
+                        v4l2_device_unregister_subdev(sd);
+                        sd = NULL;
+                }
+        }
+
 error:
         /* If we have a client but no subdev, then something went wrong and
            we must unregister the client. */
@@ -852,6 +863,17 @@ struct v4l2_subdev *v4l2_i2c_new_probed_subdev(struct v4l2_device *v4l2_dev,
         /* Decrease the module use count to match the first try_module_get. */
         module_put(client->driver->driver.owner);
 
+        if (sd) {
+                /* We return errors from v4l2_subdev_call only if we have the
+                   callback as the .s_config is not mandatory */
+                int err = v4l2_subdev_call(sd, core, s_config, 0, NULL);
+
+                if (err && err != -ENOIOCTLCMD) {
+                        v4l2_device_unregister_subdev(sd);
+                        sd = NULL;
+                }
+        }
+
 error:
         /* If we have a client but no subdev, then something went wrong and
            we must unregister the client. */
@@ -872,6 +894,89 @@ struct v4l2_subdev *v4l2_i2c_new_probed_subdev_addr(struct v4l2_device *v4l2_dev
 }
 EXPORT_SYMBOL_GPL(v4l2_i2c_new_probed_subdev_addr);
 
+/* Load an i2c sub-device. */
+struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
+                struct i2c_adapter *adapter, const char *module_name,
+                struct i2c_board_info *info, const unsigned short *probe_addrs)
+{
+        struct v4l2_subdev *sd = NULL;
+        struct i2c_client *client;
+
+        BUG_ON(!v4l2_dev);
+
+        if (module_name)
+                request_module(module_name);
+
+        /* Create the i2c client */
+        if (info->addr == 0 && probe_addrs)
+                client = i2c_new_probed_device(adapter, info, probe_addrs);
+        else
+                client = i2c_new_device(adapter, info);
+
+        /* Note: by loading the module first we are certain that c->driver
+           will be set if the driver was found. If the module was not loaded
+           first, then the i2c core tries to delay-load the module for us,
+           and then c->driver is still NULL until the module is finally
+           loaded. This delay-load mechanism doesn't work if other drivers
+           want to use the i2c device, so explicitly loading the module
+           is the best alternative. */
+        if (client == NULL || client->driver == NULL)
+                goto error;
+
+        /* Lock the module so we can safely get the v4l2_subdev pointer */
+        if (!try_module_get(client->driver->driver.owner))
+                goto error;
+        sd = i2c_get_clientdata(client);
+
+        /* Register with the v4l2_device which increases the module's
+           use count as well. */
+        if (v4l2_device_register_subdev(v4l2_dev, sd))
+                sd = NULL;
+        /* Decrease the module use count to match the first try_module_get. */
+        module_put(client->driver->driver.owner);
+
+        if (sd) {
+                /* We return errors from v4l2_subdev_call only if we have the
+                   callback as the .s_config is not mandatory */
+                int err = v4l2_subdev_call(sd, core, s_config,
+                                info->irq, info->platform_data);
+
+                if (err && err != -ENOIOCTLCMD) {
+                        v4l2_device_unregister_subdev(sd);
+                        sd = NULL;
+                }
+        }
+
+error:
+        /* If we have a client but no subdev, then something went wrong and
+           we must unregister the client. */
+        if (client && sd == NULL)
+                i2c_unregister_device(client);
+        return sd;
+}
+EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
+
+struct v4l2_subdev *v4l2_i2c_new_subdev_cfg(struct v4l2_device *v4l2_dev,
+                struct i2c_adapter *adapter,
+                const char *module_name, const char *client_type,
+                int irq, void *platform_data,
+                u8 addr, const unsigned short *probe_addrs)
+{
+        struct i2c_board_info info;
+
+        /* Setup the i2c board info with the device type and
+           the device address. */
+        memset(&info, 0, sizeof(info));
+        strlcpy(info.type, client_type, sizeof(info.type));
+        info.addr = addr;
+        info.irq = irq;
+        info.platform_data = platform_data;
+
+        return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, module_name,
+                        &info, probe_addrs);
+}
+EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_cfg);
+
 /* Return i2c client address of v4l2_subdev. */
 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
 {
@@ -916,4 +1021,78 @@ const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
 }
 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
 
-#endif
+#endif /* defined(CONFIG_I2C) */
+
+/* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
+ * and max don't have to be aligned, but there must be at least one valid
+ * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
+ * of 16 between 17 and 31.  */
+static unsigned int clamp_align(unsigned int x, unsigned int min,
+                                unsigned int max, unsigned int align)
+{
+        /* Bits that must be zero to be aligned */
+        unsigned int mask = ~((1 << align) - 1);
+
+        /* Round to nearest aligned value */
+        if (align)
+                x = (x + (1 << (align - 1))) & mask;
+
+        /* Clamp to aligned value of min and max */
+        if (x < min)
+                x = (min + ~mask) & mask;
+        else if (x > max)
+                x = max & mask;
+
+        return x;
+}
+
+/* Bound an image to have a width between wmin and wmax, and height between
+ * hmin and hmax, inclusive.  Additionally, the width will be a multiple of
+ * 2^walign, the height will be a multiple of 2^halign, and the overall size
+ * (width*height) will be a multiple of 2^salign.  The image may be shrunk
+ * or enlarged to fit the alignment constraints.
+ *
+ * The width or height maximum must not be smaller than the corresponding
+ * minimum.  The alignments must not be so high there are no possible image
+ * sizes within the allowed bounds.  wmin and hmin must be at least 1
+ * (don't use 0).  If you don't care about a certain alignment, specify 0,
+ * as 2^0 is 1 and one byte alignment is equivalent to no alignment.  If
+ * you only want to adjust downward, specify a maximum that's the same as
+ * the initial value.
+ */
+void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
+                           unsigned int walign,
+                           u32 *h, unsigned int hmin, unsigned int hmax,
+                           unsigned int halign, unsigned int salign)
+{
+        *w = clamp_align(*w, wmin, wmax, walign);
+        *h = clamp_align(*h, hmin, hmax, halign);
+
+        /* Usually we don't need to align the size and are done now. */
+        if (!salign)
+                return;
+
+        /* How much alignment do we have? */
+        walign = __ffs(*w);
+        halign = __ffs(*h);
+        /* Enough to satisfy the image alignment? */
+        if (walign + halign < salign) {
+                /* Max walign where there is still a valid width */
+                unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
+                /* Max halign where there is still a valid height */
+                unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
+
+                /* up the smaller alignment until we have enough */
+                do {
+                        if (halign >= hmaxa ||
+                            (walign <= halign && walign < wmaxa)) {
+                                *w = clamp_align(*w, wmin, wmax, walign + 1);
+                                walign = __ffs(*w);
+                        } else {
+                                *h = clamp_align(*h, hmin, hmax, halign + 1);
+                                halign = __ffs(*h);
+                        }
+                } while (halign + walign < salign);
+        }
+}
+EXPORT_SYMBOL_GPL(v4l_bound_align_image);
diff --git a/drivers/media/video/vivi.c b/drivers/media/video/vivi.c
index fbfefae7886f..cd7266858462 100644
--- a/drivers/media/video/vivi.c
+++ b/drivers/media/video/vivi.c
@@ -883,15 +883,8 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
         maxh  = norm_maxh();
 
         f->fmt.pix.field = field;
-        if (f->fmt.pix.height < 32)
-                f->fmt.pix.height = 32;
-        if (f->fmt.pix.height > maxh)
-                f->fmt.pix.height = maxh;
-        if (f->fmt.pix.width < 48)
-                f->fmt.pix.width = 48;
-        if (f->fmt.pix.width > maxw)
-                f->fmt.pix.width = maxw;
-        f->fmt.pix.width &= ~0x03;
+        v4l_bound_align_image(&f->fmt.pix.width, 48, maxw, 2,
+                              &f->fmt.pix.height, 32, maxh, 0, 0);
         f->fmt.pix.bytesperline =
                 (f->fmt.pix.width * fmt->depth) >> 3;
         f->fmt.pix.sizeimage =
diff --git a/drivers/media/video/w9968cf.c b/drivers/media/video/w9968cf.c
index f59b2bd07e89..6c3f23e31b5c 100644
--- a/drivers/media/video/w9968cf.c
+++ b/drivers/media/video/w9968cf.c
@@ -460,7 +460,7 @@ static int w9968cf_set_picture(struct w9968cf_device*, struct video_picture);
 static int w9968cf_set_window(struct w9968cf_device*, struct video_window);
 static int w9968cf_postprocess_frame(struct w9968cf_device*,
                                      struct w9968cf_frame_t*);
-static int w9968cf_adjust_window_size(struct w9968cf_device*, u16* w, u16* h);
+static int w9968cf_adjust_window_size(struct w9968cf_device*, u32 *w, u32 *h);
 static void w9968cf_init_framelist(struct w9968cf_device*);
 static void w9968cf_push_frame(struct w9968cf_device*, u8 f_num);
 static void w9968cf_pop_frame(struct w9968cf_device*,struct w9968cf_frame_t**);
@@ -1763,8 +1763,7 @@ w9968cf_set_window(struct w9968cf_device* cam, struct video_window win)
         #define UNSC(x) ((x) >> 10)
 
         /* Make sure we are using a supported resolution */
-        if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
-                                              (u16*)&win.height)))
+        if ((err = w9968cf_adjust_window_size(cam, &win.width, &win.height)))
                 goto error;
 
         /* Scaling factors */
@@ -1914,12 +1913,9 @@ error:
   Return 0 on success, -1 otherwise.
   --------------------------------------------------------------------------*/
 static int
-w9968cf_adjust_window_size(struct w9968cf_device* cam, u16* width, u16* height)
+w9968cf_adjust_window_size(struct w9968cf_device *cam, u32 *width, u32 *height)
 {
-        u16 maxw, maxh;
-
-        if ((*width < cam->minwidth) || (*height < cam->minheight))
-                return -ERANGE;
+        unsigned int maxw, maxh, align;
 
         maxw = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
                w9968cf_vpp ? max((u16)W9968CF_MAX_WIDTH, cam->maxwidth)
@@ -1927,16 +1923,10 @@ w9968cf_adjust_window_size(struct w9968cf_device* cam, u16* width, u16* height)
         maxh = cam->upscaling && !(cam->vpp_flag & VPP_DECOMPRESSION) &&
                w9968cf_vpp ? max((u16)W9968CF_MAX_HEIGHT, cam->maxheight)
                            : cam->maxheight;
+        align = (cam->vpp_flag & VPP_DECOMPRESSION) ? 4 : 0;
 
-        if (*width > maxw)
-                *width = maxw;
-        if (*height > maxh)
-                *height = maxh;
-
-        if (cam->vpp_flag & VPP_DECOMPRESSION) {
-                *width  &= ~15L; /* multiple of 16 */
-                *height &= ~15L;
-        }
+        v4l_bound_align_image(width, cam->minwidth, maxw, align,
+                              height, cam->minheight, maxh, align, 0);
 
         PDBGG("Window size adjusted w=%u, h=%u ", *width, *height)
 
@@ -3043,8 +3033,8 @@ static long w9968cf_v4l_ioctl(struct file *filp,
                 if (win.clipcount != 0 || win.flags != 0)
                         return -EINVAL;
 
-                if ((err = w9968cf_adjust_window_size(cam, (u16*)&win.width,
-                                                      (u16*)&win.height))) {
+                if ((err = w9968cf_adjust_window_size(cam, &win.width,
+                                                      &win.height))) {
                         DBG(4, "Resolution not supported (%ux%u). "
                                "VIDIOCSWIN failed", win.width, win.height)
                         return err;
@@ -3116,6 +3106,7 @@ static long w9968cf_v4l_ioctl(struct file *filp,
         {
                 struct video_mmap mmap;
                 struct w9968cf_frame_t* fr;
+                u32 w, h;
                 int err = 0;
 
                 if (copy_from_user(&mmap, arg, sizeof(mmap)))
@@ -3164,8 +3155,10 @@ static long w9968cf_v4l_ioctl(struct file *filp,
                    }
                 }
 
-                if ((err = w9968cf_adjust_window_size(cam, (u16*)&mmap.width,
-                                                      (u16*)&mmap.height))) {
+                w = mmap.width; h = mmap.height;
+                err = w9968cf_adjust_window_size(cam, &w, &h);
+                mmap.width = w; mmap.height = h;
+                if (err) {
                         DBG(4, "Resolution not supported (%dx%d). "
                                "VIDIOCMCAPTURE failed",
                             mmap.width, mmap.height)
diff --git a/drivers/media/video/zoran/zoran_driver.c b/drivers/media/video/zoran/zoran_driver.c
index 643cccaa1aab..3d7df32a3d87 100644
--- a/drivers/media/video/zoran/zoran_driver.c
+++ b/drivers/media/video/zoran/zoran_driver.c
@@ -2088,16 +2088,10 @@ static int zoran_try_fmt_vid_cap(struct file *file, void *__fh,
                 return -EINVAL;
         }
 
-        bpp = (zoran_formats[i].depth + 7) / 8;
-        fmt->fmt.pix.width &= ~((bpp == 2) ? 1 : 3);
-        if (fmt->fmt.pix.width > BUZ_MAX_WIDTH)
-                fmt->fmt.pix.width = BUZ_MAX_WIDTH;
-        if (fmt->fmt.pix.width < BUZ_MIN_WIDTH)
-                fmt->fmt.pix.width = BUZ_MIN_WIDTH;
-        if (fmt->fmt.pix.height > BUZ_MAX_HEIGHT)
-                fmt->fmt.pix.height = BUZ_MAX_HEIGHT;
-        if (fmt->fmt.pix.height < BUZ_MIN_HEIGHT)
-                fmt->fmt.pix.height = BUZ_MIN_HEIGHT;
+        bpp = DIV_ROUND_UP(zoran_formats[i].depth, 8);
+        v4l_bound_align_image(
+                &fmt->fmt.pix.width, BUZ_MIN_WIDTH, BUZ_MAX_WIDTH, bpp == 2 ? 1 : 2,
+                &fmt->fmt.pix.height, BUZ_MIN_HEIGHT, BUZ_MAX_HEIGHT, 0, 0);
         mutex_unlock(&zr->resource_lock);
 
         return 0;
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 20e0b447e8e8..55ff25244af4 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -3518,7 +3518,7 @@ retry_page:
                 } else
                         mptsas_volume_delete(ioc, sas_info->fw.id);
         }
-        mutex_lock(&ioc->sas_device_info_mutex);
+        mutex_unlock(&ioc->sas_device_info_mutex);
 
         /* expanders */
         mutex_lock(&ioc->sas_topology_mutex);
@@ -3549,7 +3549,7 @@ retry_page:
                         goto redo_expander_scan;
                 }
         }
-        mutex_lock(&ioc->sas_topology_mutex);
+        mutex_unlock(&ioc->sas_topology_mutex);
 }
 
 /**
diff --git a/drivers/mfd/twl4030-core.c b/drivers/mfd/twl4030-core.c
index cd1008c19cd7..ca54996ffd0e 100644
--- a/drivers/mfd/twl4030-core.c
+++ b/drivers/mfd/twl4030-core.c
@@ -101,6 +101,12 @@
 #define twl_has_usb()   false
 #endif
 
+#if defined(CONFIG_TWL4030_WATCHDOG) || \
+        defined(CONFIG_TWL4030_WATCHDOG_MODULE)
+#define twl_has_watchdog()        true
+#else
+#define twl_has_watchdog()        false
+#endif
 
 /* Triton Core internal information (BEGIN) */
 
@@ -526,6 +532,12 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
                 usb_transceiver = child;
         }
 
+        if (twl_has_watchdog()) {
+                child = add_child(0, "twl4030_wdt", NULL, 0, false, 0, 0);
+                if (IS_ERR(child))
+                        return PTR_ERR(child);
+        }
+
         if (twl_has_regulator()) {
                 /*
                 child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1);
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 1dc721517e4c..c155bd3ec9f1 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -1725,6 +1725,7 @@ config TLAN
 
 config KS8842
         tristate "Micrel KSZ8842"
+        depends on HAS_IOMEM
         help
           This platform driver is for Micrel KSZ8842 chip.
 
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 38f1c3375d7f..b70cc99962fc 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -6825,6 +6825,14 @@ bnx2_nway_reset(struct net_device *dev)
         return 0;
 }
 
+static u32
+bnx2_get_link(struct net_device *dev)
+{
+        struct bnx2 *bp = netdev_priv(dev);
+
+        return bp->link_up;
+}
+
 static int
 bnx2_get_eeprom_len(struct net_device *dev)
 {
@@ -7392,7 +7400,7 @@ static const struct ethtool_ops bnx2_ethtool_ops = {
         .get_wol                = bnx2_get_wol,
         .set_wol                = bnx2_set_wol,
         .nway_reset             = bnx2_nway_reset,
-        .get_link               = ethtool_op_get_link,
+        .get_link               = bnx2_get_link,
         .get_eeprom_len         = bnx2_get_eeprom_len,
         .get_eeprom             = bnx2_get_eeprom,
         .set_eeprom             = bnx2_set_eeprom,
diff --git a/drivers/net/can/Kconfig b/drivers/net/can/Kconfig
index d5e18812bf49..33821a81cbf8 100644
--- a/drivers/net/can/Kconfig
+++ b/drivers/net/can/Kconfig
@@ -36,7 +36,7 @@ config CAN_CALC_BITTIMING
           If unsure, say Y.
 
 config CAN_SJA1000
-        depends on CAN_DEV
+        depends on CAN_DEV && HAS_IOMEM
         tristate "Philips SJA1000"
         ---help---
           Driver for the SJA1000 CAN controllers from Philips or NXP
diff --git a/drivers/net/cnic.c b/drivers/net/cnic.c
index 44f77eb1180f..4d1515f45ba2 100644
--- a/drivers/net/cnic.c
+++ b/drivers/net/cnic.c
@@ -25,8 +25,6 @@
 #include <linux/delay.h>
 #include <linux/ethtool.h>
 #include <linux/if_vlan.h>
-#include <linux/module.h>
-
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 #define BCM_VLAN 1
 #endif
@@ -2521,9 +2519,9 @@ static struct cnic_dev *init_bnx2_cnic(struct net_device *dev)
         struct cnic_dev *cdev;
         struct cnic_local *cp;
         struct cnic_eth_dev *ethdev = NULL;
-        struct cnic_eth_dev *(*probe)(void *) = NULL;
+        struct cnic_eth_dev *(*probe)(struct net_device *) = NULL;
 
-        probe = __symbol_get("bnx2_cnic_probe");
+        probe = symbol_get(bnx2_cnic_probe);
         if (probe) {
                 ethdev = (*probe)(dev);
                 symbol_put_addr(probe);
diff --git a/drivers/net/cnic_if.h b/drivers/net/cnic_if.h
index 06380963a34e..d1bce27ee99e 100644
--- a/drivers/net/cnic_if.h
+++ b/drivers/net/cnic_if.h
@@ -296,4 +296,6 @@ extern int cnic_register_driver(int ulp_type, struct cnic_ulp_ops *ulp_ops);
 
 extern int cnic_unregister_driver(int ulp_type);
 
+extern struct cnic_eth_dev *bnx2_cnic_probe(struct net_device *dev);
+
 #endif
diff --git a/drivers/net/mlx4/mr.c b/drivers/net/mlx4/mr.c
index 5887e4764d22..f96948be0a44 100644
--- a/drivers/net/mlx4/mr.c
+++ b/drivers/net/mlx4/mr.c
@@ -399,11 +399,14 @@ static int mlx4_write_mtt_chunk(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
         if (!mtts)
                 return -ENOMEM;
 
+        dma_sync_single_for_cpu(&dev->pdev->dev, dma_handle,
+                                npages * sizeof (u64), DMA_TO_DEVICE);
+
         for (i = 0; i < npages; ++i)
                 mtts[i] = cpu_to_be64(page_list[i] | MLX4_MTT_FLAG_PRESENT);
 
-        dma_sync_single_for_cpu(&dev->pdev->dev, dma_handle,
-                                npages * sizeof (u64), DMA_TO_DEVICE);
+        dma_sync_single_for_device(&dev->pdev->dev, dma_handle,
+                                   npages * sizeof (u64), DMA_TO_DEVICE);
 
         return 0;
 }
@@ -547,11 +550,14 @@ int mlx4_map_phys_fmr(struct mlx4_dev *dev, struct mlx4_fmr *fmr, u64 *page_list
         /* Make sure MPT status is visible before writing MTT entries */
         wmb();
 
+        dma_sync_single_for_cpu(&dev->pdev->dev, fmr->dma_handle,
+                                npages * sizeof(u64), DMA_TO_DEVICE);
+
         for (i = 0; i < npages; ++i)
                 fmr->mtts[i] = cpu_to_be64(page_list[i] | MLX4_MTT_FLAG_PRESENT);
 
-        dma_sync_single_for_cpu(&dev->pdev->dev, fmr->dma_handle,
-                                npages * sizeof(u64), DMA_TO_DEVICE);
+        dma_sync_single_for_device(&dev->pdev->dev, fmr->dma_handle,
+                                   npages * sizeof(u64), DMA_TO_DEVICE);
 
         fmr->mpt->key    = cpu_to_be32(key);
         fmr->mpt->lkey   = cpu_to_be32(key);
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index bdb143d2b5c7..055bb61d6e77 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -944,28 +944,31 @@ int netxen_phantom_init(struct netxen_adapter *adapter, int pegtune_val)
         u32 val = 0;
         int retries = 60;
 
-        if (!pegtune_val) {
-                do {
-                        val = NXRD32(adapter, CRB_CMDPEG_STATE);
+        if (pegtune_val)
+                return 0;
 
-                        if (val == PHAN_INITIALIZE_COMPLETE ||
-                                val == PHAN_INITIALIZE_ACK)
-                                return 0;
+        do {
+                val = NXRD32(adapter, CRB_CMDPEG_STATE);
 
-                        msleep(500);
+                switch (val) {
+                case PHAN_INITIALIZE_COMPLETE:
+                case PHAN_INITIALIZE_ACK:
+                        return 0;
+                case PHAN_INITIALIZE_FAILED:
+                        goto out_err;
+                default:
+                        break;
+                }
 
-                } while (--retries);
+                msleep(500);
 
-                if (!retries) {
-                        pegtune_val = NXRD32(adapter,
-                                        NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
-                        printk(KERN_WARNING "netxen_phantom_init: init failed, "
-                                        "pegtune_val=%x\n", pegtune_val);
-                        return -1;
-                }
-        }
+        } while (--retries);
 
-        return 0;
+        NXWR32(adapter, CRB_CMDPEG_STATE, PHAN_INITIALIZE_FAILED);
+
+out_err:
+        dev_warn(&adapter->pdev->dev, "firmware init failed\n");
+        return -EIO;
 }
 
 static int
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index 71daa3d5f114..2919a2d12bf4 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -705,7 +705,7 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
                 first_driver = (adapter->ahw.pci_func == 0);
 
         if (!first_driver)
-                return 0;
+                goto wait_init;
 
         first_boot = NXRD32(adapter, NETXEN_CAM_RAM(0x1fc));
 
@@ -752,6 +752,7 @@ netxen_start_firmware(struct netxen_adapter *adapter, int request_fw)
                 | (_NETXEN_NIC_LINUX_SUBVERSION);
         NXWR32(adapter, CRB_DRIVER_VERSION, val);
 
+wait_init:
         /* Handshake with the card before we register the devices. */
         err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
         if (err) {
@@ -1178,6 +1179,7 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
         free_netdev(netdev);
 }
 
+#ifdef CONFIG_PM
 static int
 netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
 {
@@ -1242,6 +1244,7 @@ netxen_nic_resume(struct pci_dev *pdev)
 
         return 0;
 }
+#endif
 
 static int netxen_nic_open(struct net_device *netdev)
 {
@@ -1771,8 +1774,10 @@ static struct pci_driver netxen_driver = {
         .id_table = netxen_pci_tbl,
         .probe = netxen_nic_probe,
         .remove = __devexit_p(netxen_nic_remove),
+#ifdef CONFIG_PM
         .suspend = netxen_nic_suspend,
         .resume = netxen_nic_resume
+#endif
 };
 
 /* Driver Registration on NetXen card    */
diff --git a/drivers/net/qla3xxx.c b/drivers/net/qla3xxx.c
index bbc6d4d3cc94..3e4b67aaa6ea 100644
--- a/drivers/net/qla3xxx.c
+++ b/drivers/net/qla3xxx.c
@@ -3142,6 +3142,7 @@ static int ql_adapter_initialize(struct ql3_adapter *qdev)
                                                 (void __iomem *)port_regs;
         u32 delay = 10;
         int status = 0;
+        unsigned long hw_flags = 0;
 
         if(ql_mii_setup(qdev))
                 return -1;
@@ -3150,7 +3151,8 @@ static int ql_adapter_initialize(struct ql3_adapter *qdev)
         ql_write_common_reg(qdev, &port_regs->CommonRegs.serialPortInterfaceReg,
                             (ISP_SERIAL_PORT_IF_WE |
                              (ISP_SERIAL_PORT_IF_WE << 16)));
-
+        /* Give the PHY time to come out of reset. */
+        mdelay(100);
         qdev->port_link_state = LS_DOWN;
         netif_carrier_off(qdev->ndev);
 
@@ -3350,7 +3352,9 @@ static int ql_adapter_initialize(struct ql3_adapter *qdev)
                 value = ql_read_page0_reg(qdev, &port_regs->portStatus);
                 if (value & PORT_STATUS_IC)
                         break;
+                spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
                 msleep(500);
+                spin_lock_irqsave(&qdev->hw_lock, hw_flags);
         } while (--delay);
 
         if (delay == 0) {
diff --git a/drivers/pci/hotplug/acpi_pcihp.c b/drivers/pci/hotplug/acpi_pcihp.c
index fbc63d5e459f..eb159587d0bf 100644
--- a/drivers/pci/hotplug/acpi_pcihp.c
+++ b/drivers/pci/hotplug/acpi_pcihp.c
@@ -354,7 +354,7 @@ acpi_status acpi_get_hp_params_from_firmware(struct pci_bus *bus,
                 status = acpi_run_hpp(handle, hpp);
                 if (ACPI_SUCCESS(status))
                         break;
-                if (acpi_root_bridge(handle))
+                if (acpi_is_root_bridge(handle))
                         break;
                 status = acpi_get_parent(handle, &phandle);
                 if (ACPI_FAILURE(status))
@@ -428,7 +428,7 @@ int acpi_get_hp_hw_control_from_firmware(struct pci_dev *pdev, u32 flags)
                 status = acpi_run_oshp(handle);
                 if (ACPI_SUCCESS(status))
                         goto got_one;
-                if (acpi_root_bridge(handle))
+                if (acpi_is_root_bridge(handle))
                         break;
                 chandle = handle;
                 status = acpi_get_parent(chandle, &handle);
@@ -449,42 +449,6 @@ got_one:
 }
 EXPORT_SYMBOL(acpi_get_hp_hw_control_from_firmware);
 
-/* acpi_root_bridge - check to see if this acpi object is a root bridge
- *
- * @handle - the acpi object in question.
- */
-int acpi_root_bridge(acpi_handle handle)
-{
-        acpi_status status;
-        struct acpi_device_info *info;
-        struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL};
-        int i;
-
-        status = acpi_get_object_info(handle, &buffer);
-        if (ACPI_SUCCESS(status)) {
-                info = buffer.pointer;
-                if ((info->valid & ACPI_VALID_HID) &&
-                        !strcmp(PCI_ROOT_HID_STRING,
-                                        info->hardware_id.value)) {
-                        kfree(buffer.pointer);
-                        return 1;
-                }
-                if (info->valid & ACPI_VALID_CID) {
-                        for (i=0; i < info->compatibility_id.count; i++) {
-                                if (!strcmp(PCI_ROOT_HID_STRING,
-                                        info->compatibility_id.id[i].value)) {
-                                        kfree(buffer.pointer);
-                                        return 1;
-                                }
-                        }
-                }
-                kfree(buffer.pointer);
-        }
-        return 0;
-}
-EXPORT_SYMBOL_GPL(acpi_root_bridge);
-
-
 static int is_ejectable(acpi_handle handle)
 {
         acpi_status status;
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 3a6064bce561..0cb0f830a993 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -678,18 +678,9 @@ static void remove_bridge(acpi_handle handle)
 
 static struct pci_dev * get_apic_pci_info(acpi_handle handle)
 {
-        struct acpi_pci_id id;
-        struct pci_bus *bus;
         struct pci_dev *dev;
 
-        if (ACPI_FAILURE(acpi_get_pci_id(handle, &id)))
-                return NULL;
-
-        bus = pci_find_bus(id.segment, id.bus);
-        if (!bus)
-                return NULL;
-
-        dev = pci_get_slot(bus, PCI_DEVFN(id.device, id.function));
+        dev = acpi_get_pci_dev(handle);
         if (!dev)
                 return NULL;
 
@@ -1396,19 +1387,16 @@ static void acpiphp_sanitize_bus(struct pci_bus *bus)
 /* Program resources in newly inserted bridge */
 static int acpiphp_configure_bridge (acpi_handle handle)
 {
-        struct acpi_pci_id pci_id;
+        struct pci_dev *dev;
         struct pci_bus *bus;
 
-        if (ACPI_FAILURE(acpi_get_pci_id(handle, &pci_id))) {
+        dev = acpi_get_pci_dev(handle);
+        if (!dev) {
                 err("cannot get PCI domain and bus number for bridge\n");
                 return -EINVAL;
         }
-        bus = pci_find_bus(pci_id.segment, pci_id.bus);
-        if (!bus) {
-                err("cannot find bus %d:%d\n",
-                                pci_id.segment, pci_id.bus);
-                return -EINVAL;
-        }
+
+        bus = dev->bus;
 
         pci_bus_size_bridges(bus);
         pci_bus_assign_resources(bus);
@@ -1416,6 +1404,7 @@ static int acpiphp_configure_bridge (acpi_handle handle)
         acpiphp_set_hpp_values(handle, bus);
         pci_enable_bridges(bus);
         acpiphp_configure_ioapics(handle);
+        pci_dev_put(dev);
         return 0;
 }
 
@@ -1631,7 +1620,7 @@ find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv)
 {
         int *count = (int *)context;
 
-        if (acpi_root_bridge(handle)) {
+        if (acpi_is_root_bridge(handle)) {
                 acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
                                 handle_hotplug_event_bridge, NULL);
                         (*count)++;
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index 178853a07440..e53eacd75c8d 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -39,6 +39,7 @@
 #include <linux/sysdev.h>
 #include <asm/cacheflush.h>
 #include <asm/iommu.h>
+#include <asm/e820.h>
 #include "pci.h"
 
 #define ROOT_SIZE               VTD_PAGE_SIZE
@@ -217,6 +218,14 @@ static inline bool dma_pte_present(struct dma_pte *pte)
         return (pte->val & 3) != 0;
 }
 
+/*
+ * This domain is a statically identity mapping domain.
+ *      1. This domain creats a static 1:1 mapping to all usable memory.
+ *      2. It maps to each iommu if successful.
+ *      3. Each iommu mapps to this domain if successful.
+ */
+struct dmar_domain *si_domain;
+
 /* devices under the same p2p bridge are owned in one domain */
 #define DOMAIN_FLAG_P2P_MULTIPLE_DEVICES (1 << 0)
 
@@ -225,6 +234,9 @@ static inline bool dma_pte_present(struct dma_pte *pte)
  */
 #define DOMAIN_FLAG_VIRTUAL_MACHINE     (1 << 1)
 
+/* si_domain contains mulitple devices */
+#define DOMAIN_FLAG_STATIC_IDENTITY     (1 << 2)
+
 struct dmar_domain {
         int     id;                     /* domain id */
         unsigned long iommu_bmp;        /* bitmap of iommus this domain uses*/
@@ -435,12 +447,14 @@ int iommu_calculate_agaw(struct intel_iommu *iommu)
         return __iommu_calculate_agaw(iommu, DEFAULT_DOMAIN_ADDRESS_WIDTH);
 }
 
-/* in native case, each domain is related to only one iommu */
+/* This functionin only returns single iommu in a domain */
 static struct intel_iommu *domain_get_iommu(struct dmar_domain *domain)
 {
         int iommu_id;
 
+        /* si_domain and vm domain should not get here. */
         BUG_ON(domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE);
+        BUG_ON(domain->flags & DOMAIN_FLAG_STATIC_IDENTITY);
 
         iommu_id = find_first_bit(&domain->iommu_bmp, g_num_of_iommus);
         if (iommu_id < 0 || iommu_id >= g_num_of_iommus)
@@ -1189,48 +1203,71 @@ void free_dmar_iommu(struct intel_iommu *iommu)
         free_context_table(iommu);
 }
 
-static struct dmar_domain * iommu_alloc_domain(struct intel_iommu *iommu)
+static struct dmar_domain *alloc_domain(void)
 {
-        unsigned long num;
-        unsigned long ndomains;
         struct dmar_domain *domain;
-        unsigned long flags;
 
         domain = alloc_domain_mem();
         if (!domain)
                 return NULL;
 
+        memset(&domain->iommu_bmp, 0, sizeof(unsigned long));
+        domain->flags = 0;
+
+        return domain;
+}
+
+static int iommu_attach_domain(struct dmar_domain *domain,
+                               struct intel_iommu *iommu)
+{
+        int num;
+        unsigned long ndomains;
+        unsigned long flags;
+
         ndomains = cap_ndoms(iommu->cap);
 
         spin_lock_irqsave(&iommu->lock, flags);
+
         num = find_first_zero_bit(iommu->domain_ids, ndomains);
         if (num >= ndomains) {
                 spin_unlock_irqrestore(&iommu->lock, flags);
-                free_domain_mem(domain);
                 printk(KERN_ERR "IOMMU: no free domain ids\n");
-                return NULL;
+                return -ENOMEM;
         }
 
-        set_bit(num, iommu->domain_ids);
         domain->id = num;
-        memset(&domain->iommu_bmp, 0, sizeof(unsigned long));
+        set_bit(num, iommu->domain_ids);
         set_bit(iommu->seq_id, &domain->iommu_bmp);
-        domain->flags = 0;
         iommu->domains[num] = domain;
         spin_unlock_irqrestore(&iommu->lock, flags);
 
-        return domain;
+        return 0;
 }
 
-static void iommu_free_domain(struct dmar_domain *domain)
+static void iommu_detach_domain(struct dmar_domain *domain,
+                                struct intel_iommu *iommu)
 {
         unsigned long flags;
-        struct intel_iommu *iommu;
-
-        iommu = domain_get_iommu(domain);
+        int num, ndomains;
+        int found = 0;
 
         spin_lock_irqsave(&iommu->lock, flags);
-        clear_bit(domain->id, iommu->domain_ids);
+        ndomains = cap_ndoms(iommu->cap);
+        num = find_first_bit(iommu->domain_ids, ndomains);
+        for (; num < ndomains; ) {
+                if (iommu->domains[num] == domain) {
+                        found = 1;
+                        break;
+                }
+                num = find_next_bit(iommu->domain_ids,
+                                    cap_ndoms(iommu->cap), num+1);
+        }
+
+        if (found) {
+                clear_bit(num, iommu->domain_ids);
+                clear_bit(iommu->seq_id, &domain->iommu_bmp);
+                iommu->domains[num] = NULL;
+        }
         spin_unlock_irqrestore(&iommu->lock, flags);
 }
 
@@ -1350,6 +1387,8 @@ static int domain_init(struct dmar_domain *domain, int guest_width)
 
 static void domain_exit(struct dmar_domain *domain)
 {
+        struct dmar_drhd_unit *drhd;
+        struct intel_iommu *iommu;
         u64 end;
 
         /* Domain 0 is reserved, so dont process it */
@@ -1368,7 +1407,10 @@ static void domain_exit(struct dmar_domain *domain)
         /* free page tables */
         dma_pte_free_pagetable(domain, 0, end);
 
-        iommu_free_domain(domain);
+        for_each_active_iommu(iommu, drhd)
+                if (test_bit(iommu->seq_id, &domain->iommu_bmp))
+                        iommu_detach_domain(domain, iommu);
+
         free_domain_mem(domain);
 }
 
@@ -1408,7 +1450,8 @@ static int domain_context_mapping_one(struct dmar_domain *domain, int segment,
         id = domain->id;
         pgd = domain->pgd;
 
-        if (domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE) {
+        if (domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE ||
+            domain->flags & DOMAIN_FLAG_STATIC_IDENTITY) {
                 int found = 0;
 
                 /* find an available domain id for this device in iommu */
@@ -1433,6 +1476,7 @@ static int domain_context_mapping_one(struct dmar_domain *domain, int segment,
                         }
 
                         set_bit(num, iommu->domain_ids);
+                        set_bit(iommu->seq_id, &domain->iommu_bmp);
                         iommu->domains[num] = domain;
                         id = num;
                 }
@@ -1675,6 +1719,7 @@ static struct dmar_domain *get_domain_for_dev(struct pci_dev *pdev, int gaw)
         unsigned long flags;
         int bus = 0, devfn = 0;
         int segment;
+        int ret;
 
         domain = find_domain(pdev);
         if (domain)
@@ -1707,6 +1752,10 @@ static struct dmar_domain *get_domain_for_dev(struct pci_dev *pdev, int gaw)
                 }
         }
 
+        domain = alloc_domain();
+        if (!domain)
+                goto error;
+
         /* Allocate new domain for the device */
         drhd = dmar_find_matched_drhd_unit(pdev);
         if (!drhd) {
@@ -1716,9 +1765,11 @@ static struct dmar_domain *get_domain_for_dev(struct pci_dev *pdev, int gaw)
         }
         iommu = drhd->iommu;
 
-        domain = iommu_alloc_domain(iommu);
-        if (!domain)
+        ret = iommu_attach_domain(domain, iommu);
+        if (ret) {
+                domain_exit(domain);
                 goto error;
+        }
 
         if (domain_init(domain, gaw)) {
                 domain_exit(domain);
@@ -1792,6 +1843,8 @@ error:
         return find_domain(pdev);
 }
 
+static int iommu_identity_mapping;
+
 static int iommu_prepare_identity_map(struct pci_dev *pdev,
                                       unsigned long long start,
                                       unsigned long long end)
@@ -1804,8 +1857,11 @@ static int iommu_prepare_identity_map(struct pci_dev *pdev,
         printk(KERN_INFO
                 "IOMMU: Setting identity map for device %s [0x%Lx - 0x%Lx]\n",
                 pci_name(pdev), start, end);
-        /* page table init */
-        domain = get_domain_for_dev(pdev, DEFAULT_DOMAIN_ADDRESS_WIDTH);
+        if (iommu_identity_mapping)
+                domain = si_domain;
+        else
+                /* page table init */
+                domain = get_domain_for_dev(pdev, DEFAULT_DOMAIN_ADDRESS_WIDTH);
         if (!domain)
                 return -ENOMEM;
 
@@ -1952,7 +2008,110 @@ static int __init init_context_pass_through(void)
         return 0;
 }
 
-static int __init init_dmars(void)
+static int md_domain_init(struct dmar_domain *domain, int guest_width);
+static int si_domain_init(void)
+{
+        struct dmar_drhd_unit *drhd;
+        struct intel_iommu *iommu;
+        int ret = 0;
+
+        si_domain = alloc_domain();
+        if (!si_domain)
+                return -EFAULT;
+
+
+        for_each_active_iommu(iommu, drhd) {
+                ret = iommu_attach_domain(si_domain, iommu);
+                if (ret) {
+                        domain_exit(si_domain);
+                        return -EFAULT;
+                }
+        }
+
+        if (md_domain_init(si_domain, DEFAULT_DOMAIN_ADDRESS_WIDTH)) {
+                domain_exit(si_domain);
+                return -EFAULT;
+        }
+
+        si_domain->flags = DOMAIN_FLAG_STATIC_IDENTITY;
+
+        return 0;
+}
+
+static void domain_remove_one_dev_info(struct dmar_domain *domain,
+                                          struct pci_dev *pdev);
+static int identity_mapping(struct pci_dev *pdev)
+{
+        struct device_domain_info *info;
+
+        if (likely(!iommu_identity_mapping))
+                return 0;
+
+
+        list_for_each_entry(info, &si_domain->devices, link)
+                if (info->dev == pdev)
+                        return 1;
+        return 0;
+}
+
+static int domain_add_dev_info(struct dmar_domain *domain,
+                                  struct pci_dev *pdev)
+{
+        struct device_domain_info *info;
+        unsigned long flags;
+
+        info = alloc_devinfo_mem();
+        if (!info)
+                return -ENOMEM;
+
+        info->segment = pci_domain_nr(pdev->bus);
+        info->bus = pdev->bus->number;
+        info->devfn = pdev->devfn;
+        info->dev = pdev;
+        info->domain = domain;
+
+        spin_lock_irqsave(&device_domain_lock, flags);
+        list_add(&info->link, &domain->devices);
+        list_add(&info->global, &device_domain_list);
+        pdev->dev.archdata.iommu = info;
+        spin_unlock_irqrestore(&device_domain_lock, flags);
+
+        return 0;
+}
+
+static int iommu_prepare_static_identity_mapping(void)
+{
+        int i;
+        struct pci_dev *pdev = NULL;
+        int ret;
+
+        ret = si_domain_init();
+        if (ret)
+                return -EFAULT;
+
+        printk(KERN_INFO "IOMMU: Setting identity map:\n");
+        for_each_pci_dev(pdev) {
+                for (i = 0; i < e820.nr_map; i++) {
+                        struct e820entry *ei = &e820.map[i];
+
+                        if (ei->type == E820_RAM) {
+                                ret = iommu_prepare_identity_map(pdev,
+                                        ei->addr, ei->addr + ei->size);
+                                if (ret)  {
+                                        printk(KERN_INFO "1:1 mapping to one domain failed.\n");
+                                        return -EFAULT;
+                                }
+                        }
+                }
+                ret = domain_add_dev_info(si_domain, pdev);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
+int __init init_dmars(void)
 {
         struct dmar_drhd_unit *drhd;
         struct dmar_rmrr_unit *rmrr;
@@ -1962,6 +2121,13 @@ static int __init init_dmars(void)
         int pass_through = 1;
 
         /*
+         * In case pass through can not be enabled, iommu tries to use identity
+         * mapping.
+         */
+        if (iommu_pass_through)
+                iommu_identity_mapping = 1;
+
+        /*
          * for each drhd
          *    allocate root
          *    initialize and program root entry to not present
@@ -2090,9 +2256,12 @@ static int __init init_dmars(void)
 
         /*
          * If pass through is not set or not enabled, setup context entries for
-         * identity mappings for rmrr, gfx, and isa.
+         * identity mappings for rmrr, gfx, and isa and may fall back to static
+         * identity mapping if iommu_identity_mapping is set.
          */
         if (!iommu_pass_through) {
+                if (iommu_identity_mapping)
+                        iommu_prepare_static_identity_mapping();
                 /*
                  * For each rmrr
                  *   for each dev attached to rmrr
@@ -2107,6 +2276,7 @@ static int __init init_dmars(void)
                  *    endfor
                  * endfor
                  */
+                printk(KERN_INFO "IOMMU: Setting RMRR:\n");
                 for_each_rmrr_units(rmrr) {
                         for (i = 0; i < rmrr->devices_cnt; i++) {
                                 pdev = rmrr->devices[i];
@@ -2248,6 +2418,52 @@ get_valid_domain_for_dev(struct pci_dev *pdev)
         return domain;
 }
 
+static int iommu_dummy(struct pci_dev *pdev)
+{
+        return pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO;
+}
+
+/* Check if the pdev needs to go through non-identity map and unmap process.*/
+static int iommu_no_mapping(struct pci_dev *pdev)
+{
+        int found;
+
+        if (!iommu_identity_mapping)
+                return iommu_dummy(pdev);
+
+        found = identity_mapping(pdev);
+        if (found) {
+                if (pdev->dma_mask > DMA_BIT_MASK(32))
+                        return 1;
+                else {
+                        /*
+                         * 32 bit DMA is removed from si_domain and fall back
+                         * to non-identity mapping.
+                         */
+                        domain_remove_one_dev_info(si_domain, pdev);
+                        printk(KERN_INFO "32bit %s uses non-identity mapping\n",
+                               pci_name(pdev));
+                        return 0;
+                }
+        } else {
+                /*
+                 * In case of a detached 64 bit DMA device from vm, the device
+                 * is put into si_domain for identity mapping.
+                 */
+                if (pdev->dma_mask > DMA_BIT_MASK(32)) {
+                        int ret;
+                        ret = domain_add_dev_info(si_domain, pdev);
+                        if (!ret) {
+                                printk(KERN_INFO "64bit %s uses identity mapping\n",
+                                       pci_name(pdev));
+                                return 1;
+                        }
+                }
+        }
+
+        return iommu_dummy(pdev);
+}
+
 static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
                                      size_t size, int dir, u64 dma_mask)
 {
@@ -2260,7 +2476,8 @@ static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
         struct intel_iommu *iommu;
 
         BUG_ON(dir == DMA_NONE);
-        if (pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO)
+
+        if (iommu_no_mapping(pdev))
                 return paddr;
 
         domain = get_valid_domain_for_dev(pdev);
@@ -2401,8 +2618,9 @@ static void intel_unmap_page(struct device *dev, dma_addr_t dev_addr,
         struct iova *iova;
         struct intel_iommu *iommu;
 
-        if (pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO)
+        if (iommu_no_mapping(pdev))
                 return;
+
         domain = find_domain(pdev);
         BUG_ON(!domain);
 
@@ -2492,7 +2710,7 @@ static void intel_unmap_sg(struct device *hwdev, struct scatterlist *sglist,
         struct scatterlist *sg;
         struct intel_iommu *iommu;
 
-        if (pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO)
+        if (iommu_no_mapping(pdev))
                 return;
 
         domain = find_domain(pdev);
@@ -2553,7 +2771,7 @@ static int intel_map_sg(struct device *hwdev, struct scatterlist *sglist, int ne
         struct intel_iommu *iommu;
 
         BUG_ON(dir == DMA_NONE);
-        if (pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO)
+        if (iommu_no_mapping(pdev))
                 return intel_nontranslate_map_sg(hwdev, sglist, nelems, dir);
 
         domain = get_valid_domain_for_dev(pdev);
@@ -2951,31 +3169,6 @@ int __init intel_iommu_init(void)
         return 0;
 }
 
-static int vm_domain_add_dev_info(struct dmar_domain *domain,
-                                  struct pci_dev *pdev)
-{
-        struct device_domain_info *info;
-        unsigned long flags;
-
-        info = alloc_devinfo_mem();
-        if (!info)
-                return -ENOMEM;
-
-        info->segment = pci_domain_nr(pdev->bus);
-        info->bus = pdev->bus->number;
-        info->devfn = pdev->devfn;
-        info->dev = pdev;
-        info->domain = domain;
-
-        spin_lock_irqsave(&device_domain_lock, flags);
-        list_add(&info->link, &domain->devices);
-        list_add(&info->global, &device_domain_list);
-        pdev->dev.archdata.iommu = info;
-        spin_unlock_irqrestore(&device_domain_lock, flags);
-
-        return 0;
-}
-
 static void iommu_detach_dependent_devices(struct intel_iommu *iommu,
                                            struct pci_dev *pdev)
 {
@@ -3003,7 +3196,7 @@ static void iommu_detach_dependent_devices(struct intel_iommu *iommu,
         }
 }
 
-static void vm_domain_remove_one_dev_info(struct dmar_domain *domain,
+static void domain_remove_one_dev_info(struct dmar_domain *domain,
                                           struct pci_dev *pdev)
 {
         struct device_domain_info *info;
@@ -3136,7 +3329,7 @@ static struct dmar_domain *iommu_alloc_vm_domain(void)
         return domain;
 }
 
-static int vm_domain_init(struct dmar_domain *domain, int guest_width)
+static int md_domain_init(struct dmar_domain *domain, int guest_width)
 {
         int adjust_width;
 
@@ -3227,7 +3420,7 @@ static int intel_iommu_domain_init(struct iommu_domain *domain)
                         "intel_iommu_domain_init: dmar_domain == NULL\n");
                 return -ENOMEM;
         }
-        if (vm_domain_init(dmar_domain, DEFAULT_DOMAIN_ADDRESS_WIDTH)) {
+        if (md_domain_init(dmar_domain, DEFAULT_DOMAIN_ADDRESS_WIDTH)) {
                 printk(KERN_ERR
                         "intel_iommu_domain_init() failed\n");
                 vm_domain_exit(dmar_domain);
@@ -3262,8 +3455,9 @@ static int intel_iommu_attach_device(struct iommu_domain *domain,
 
                 old_domain = find_domain(pdev);
                 if (old_domain) {
-                        if (dmar_domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE)
-                                vm_domain_remove_one_dev_info(old_domain, pdev);
+                        if (dmar_domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE ||
+                            dmar_domain->flags & DOMAIN_FLAG_STATIC_IDENTITY)
+                                domain_remove_one_dev_info(old_domain, pdev);
                         else
                                 domain_remove_dev_info(old_domain);
                 }
@@ -3285,7 +3479,7 @@ static int intel_iommu_attach_device(struct iommu_domain *domain,
                 return -EFAULT;
         }
 
-        ret = vm_domain_add_dev_info(dmar_domain, pdev);
+        ret = domain_add_dev_info(dmar_domain, pdev);
         if (ret)
                 return ret;
 
@@ -3299,7 +3493,7 @@ static void intel_iommu_detach_device(struct iommu_domain *domain,
         struct dmar_domain *dmar_domain = domain->priv;
         struct pci_dev *pdev = to_pci_dev(dev);
 
-        vm_domain_remove_one_dev_info(dmar_domain, pdev);
+        domain_remove_one_dev_info(dmar_domain, pdev);
 }
 
 static int intel_iommu_map_range(struct iommu_domain *domain,
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index 1e83c8c5f985..4f5b8712931f 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -10,6 +10,8 @@
 #include <linux/intel-iommu.h>
 #include "intr_remapping.h"
 #include <acpi/acpi.h>
+#include <asm/pci-direct.h>
+#include "pci.h"
 
 static struct ioapic_scope ir_ioapic[MAX_IO_APICS];
 static int ir_ioapic_num;
@@ -314,7 +316,8 @@ int modify_irte(int irq, struct irte *irte_modified)
         index = irq_iommu->irte_index + irq_iommu->sub_handle;
         irte = &iommu->ir_table->base[index];
 
-        set_64bit((unsigned long *)irte, irte_modified->low);
+        set_64bit((unsigned long *)&irte->low, irte_modified->low);
+        set_64bit((unsigned long *)&irte->high, irte_modified->high);
         __iommu_flush_cache(iommu, irte, sizeof(*irte));
 
         rc = qi_flush_iec(iommu, index, 0);
@@ -369,12 +372,32 @@ struct intel_iommu *map_dev_to_ir(struct pci_dev *dev)
         return drhd->iommu;
 }
 
+static int clear_entries(struct irq_2_iommu *irq_iommu)
+{
+        struct irte *start, *entry, *end;
+        struct intel_iommu *iommu;
+        int index;
+
+        if (irq_iommu->sub_handle)
+                return 0;
+
+        iommu = irq_iommu->iommu;
+        index = irq_iommu->irte_index + irq_iommu->sub_handle;
+
+        start = iommu->ir_table->base + index;
+        end = start + (1 << irq_iommu->irte_mask);
+
+        for (entry = start; entry < end; entry++) {
+                set_64bit((unsigned long *)&entry->low, 0);
+                set_64bit((unsigned long *)&entry->high, 0);
+        }
+
+        return qi_flush_iec(iommu, index, irq_iommu->irte_mask);
+}
+
 int free_irte(int irq)
 {
         int rc = 0;
-        int index, i;
-        struct irte *irte;
-        struct intel_iommu *iommu;
         struct irq_2_iommu *irq_iommu;
         unsigned long flags;
 
@@ -385,16 +408,7 @@ int free_irte(int irq)
                 return -1;
         }
 
-        iommu = irq_iommu->iommu;
-
-        index = irq_iommu->irte_index + irq_iommu->sub_handle;
-        irte = &iommu->ir_table->base[index];
-
-        if (!irq_iommu->sub_handle) {
-                for (i = 0; i < (1 << irq_iommu->irte_mask); i++)
-                        set_64bit((unsigned long *)(irte + i), 0);
-                rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask);
-        }
+        rc = clear_entries(irq_iommu);
 
         irq_iommu->iommu = NULL;
         irq_iommu->irte_index = 0;
@@ -406,6 +420,91 @@ int free_irte(int irq)
         return rc;
 }
 
+/*
+ * source validation type
+ */
+#define SVT_NO_VERIFY           0x0  /* no verification is required */
+#define SVT_VERIFY_SID_SQ       0x1  /* verify using SID and SQ fiels */
+#define SVT_VERIFY_BUS          0x2  /* verify bus of request-id */
+
+/*
+ * source-id qualifier
+ */
+#define SQ_ALL_16       0x0  /* verify all 16 bits of request-id */
+#define SQ_13_IGNORE_1  0x1  /* verify most significant 13 bits, ignore
+                              * the third least significant bit
+                              */
+#define SQ_13_IGNORE_2  0x2  /* verify most significant 13 bits, ignore
+                              * the second and third least significant bits
+                              */
+#define SQ_13_IGNORE_3  0x3  /* verify most significant 13 bits, ignore
+                              * the least three significant bits
+                              */
+
+/*
+ * set SVT, SQ and SID fields of irte to verify
+ * source ids of interrupt requests
+ */
+static void set_irte_sid(struct irte *irte, unsigned int svt,
+                         unsigned int sq, unsigned int sid)
+{
+        irte->svt = svt;
+        irte->sq = sq;
+        irte->sid = sid;
+}
+
+int set_ioapic_sid(struct irte *irte, int apic)
+{
+        int i;
+        u16 sid = 0;
+
+        if (!irte)
+                return -1;
+
+        for (i = 0; i < MAX_IO_APICS; i++) {
+                if (ir_ioapic[i].id == apic) {
+                        sid = (ir_ioapic[i].bus << 8) | ir_ioapic[i].devfn;
+                        break;
+                }
+        }
+
+        if (sid == 0) {
+                pr_warning("Failed to set source-id of IOAPIC (%d)\n", apic);
+                return -1;
+        }
+
+        set_irte_sid(irte, 1, 0, sid);
+
+        return 0;
+}
+
+int set_msi_sid(struct irte *irte, struct pci_dev *dev)
+{
+        struct pci_dev *bridge;
+
+        if (!irte || !dev)
+                return -1;
+
+        /* PCIe device or Root Complex integrated PCI device */
+        if (dev->is_pcie || !dev->bus->parent) {
+                set_irte_sid(irte, SVT_VERIFY_SID_SQ, SQ_ALL_16,
+                             (dev->bus->number << 8) | dev->devfn);
+                return 0;
+        }
+
+        bridge = pci_find_upstream_pcie_bridge(dev);
+        if (bridge) {
+                if (bridge->is_pcie) /* this is a PCIE-to-PCI/PCIX bridge */
+                        set_irte_sid(irte, SVT_VERIFY_BUS, SQ_ALL_16,
+                                (bridge->bus->number << 8) | dev->bus->number);
+                else /* this is a legacy PCI bridge */
+                        set_irte_sid(irte, SVT_VERIFY_SID_SQ, SQ_ALL_16,
+                                (bridge->bus->number << 8) | bridge->devfn);
+        }
+
+        return 0;
+}
+
 static void iommu_set_intr_remapping(struct intel_iommu *iommu, int mode)
 {
         u64 addr;
@@ -612,6 +711,35 @@ error:
         return -1;
 }
 
+static void ir_parse_one_ioapic_scope(struct acpi_dmar_device_scope *scope,
+                                      struct intel_iommu *iommu)
+{
+        struct acpi_dmar_pci_path *path;
+        u8 bus;
+        int count;
+
+        bus = scope->bus;
+        path = (struct acpi_dmar_pci_path *)(scope + 1);
+        count = (scope->length - sizeof(struct acpi_dmar_device_scope))
+                / sizeof(struct acpi_dmar_pci_path);
+
+        while (--count > 0) {
+                /*
+                 * Access PCI directly due to the PCI
+                 * subsystem isn't initialized yet.
+                 */
+                bus = read_pci_config_byte(bus, path->dev, path->fn,
+                                           PCI_SECONDARY_BUS);
+                path++;
+        }
+
+        ir_ioapic[ir_ioapic_num].bus   = bus;
+        ir_ioapic[ir_ioapic_num].devfn = PCI_DEVFN(path->dev, path->fn);
+        ir_ioapic[ir_ioapic_num].iommu = iommu;
+        ir_ioapic[ir_ioapic_num].id    = scope->enumeration_id;
+        ir_ioapic_num++;
+}
+
 static int ir_parse_ioapic_scope(struct acpi_dmar_header *header,
                                  struct intel_iommu *iommu)
 {
@@ -636,9 +764,7 @@ static int ir_parse_ioapic_scope(struct acpi_dmar_header *header,
                                " 0x%Lx\n", scope->enumeration_id,
                                drhd->address);
 
-                        ir_ioapic[ir_ioapic_num].iommu = iommu;
-                        ir_ioapic[ir_ioapic_num].id = scope->enumeration_id;
-                        ir_ioapic_num++;
+                        ir_parse_one_ioapic_scope(scope, iommu);
                 }
                 start += scope->length;
         }
diff --git a/drivers/pci/intr_remapping.h b/drivers/pci/intr_remapping.h
index ca48f0df8ac9..63a263c18415 100644
--- a/drivers/pci/intr_remapping.h
+++ b/drivers/pci/intr_remapping.h
@@ -3,6 +3,8 @@
 struct ioapic_scope {
         struct intel_iommu *iommu;
         unsigned int id;
+        unsigned int bus;       /* PCI bus number */
+        unsigned int devfn;     /* PCI devfn number */
 };
 
 #define IR_X2APIC_MODE(mode) (mode ? (1 << 11) : 0)
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index c682ac536415..fee6a4022bc1 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -34,10 +34,27 @@ config ACER_WMI
           If you have an ACPI-WMI compatible Acer/ Wistron laptop, say Y or M
           here.
 
+config ACERHDF
+        tristate "Acer Aspire One temperature and fan driver"
+        depends on THERMAL && THERMAL_HWMON && ACPI
+        ---help---
+          This is a driver for Acer Aspire One netbooks. It allows to access
+          the temperature sensor and to control the fan.
+
+          After loading this driver the BIOS is still in control of the fan.
+          To let the kernel handle the fan, do:
+          echo -n enabled > /sys/class/thermal/thermal_zone0/mode
+
+          For more information about this driver see
+          <http://piie.net/files/acerhdf_README.txt>
+
+          If you have an Acer Aspire One netbook, say Y or M
+          here.
+
 config ASUS_LAPTOP
-        tristate "Asus Laptop Extras (EXPERIMENTAL)"
+        tristate "Asus Laptop Extras"
         depends on ACPI
-        depends on EXPERIMENTAL && !ACPI_ASUS
+        depends on !ACPI_ASUS
         select LEDS_CLASS
         select NEW_LEDS
         select BACKLIGHT_CLASS_DEVICE
@@ -45,12 +62,12 @@ config ASUS_LAPTOP
         ---help---
           This is the new Linux driver for Asus laptops. It may also support some
           MEDION, JVC or VICTOR laptops. It makes all the extra buttons generate
-          standard ACPI events that go through /proc/acpi/events. It also adds
+          standard ACPI events and input events. It also adds
           support for video output switching, LCD backlight control, Bluetooth and
           Wlan control, and most importantly, allows you to blink those fancy LEDs.
 
           For more information and a userspace daemon for handling the extra
-          buttons see <http://acpi4asus.sf.net/>.
+          buttons see <http://acpi4asus.sf.net>.
 
           If you have an ACPI-compatible ASUS laptop, say Y or M here.
 
@@ -340,9 +357,14 @@ config EEEPC_LAPTOP
         depends on RFKILL || RFKILL = n
         select BACKLIGHT_CLASS_DEVICE
         select HWMON
+        select HOTPLUG
+        select HOTPLUG_PCI if PCI
         ---help---
           This driver supports the Fn-Fx keys on Eee PC laptops.
-          It also adds the ability to switch camera/wlan on/off.
+
+          It  also gives access to some extra laptop functionalities like
+          Bluetooth, backlight and allows powering on/off some other
+          devices.
 
           If you have an Eee PC laptop, say Y or M here.
 
@@ -369,7 +391,7 @@ config ACPI_WMI
           any ACPI-WMI devices.
 
 config ACPI_ASUS
-        tristate "ASUS/Medion Laptop Extras"
+        tristate "ASUS/Medion Laptop Extras (DEPRECATED)"
         depends on ACPI
         select BACKLIGHT_CLASS_DEVICE
         ---help---
@@ -390,7 +412,7 @@ config ACPI_ASUS
           parameters.
 
           More information and a userspace daemon for handling the extra buttons
-          at <http://sourceforge.net/projects/acpi4asus/>.
+          at <http://acpi4asus.sf.net>.
 
           If you have an ACPI-compatible ASUS laptop, say Y or M here. This
           driver is still under development, so if your laptop is unsupported or
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index e40c7bd1b87e..641b8bfa5538 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_COMPAL_LAPTOP)	+= compal-laptop.o
 obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_DELL_WMI)          += dell-wmi.o
 obj-$(CONFIG_ACER_WMI)          += acer-wmi.o
+obj-$(CONFIG_ACERHDF)           += acerhdf.o
 obj-$(CONFIG_HP_WMI)            += hp-wmi.o
 obj-$(CONFIG_TC1100_WMI)        += tc1100-wmi.o
 obj-$(CONFIG_SONY_LAPTOP)       += sony-laptop.o
diff --git a/drivers/platform/x86/acerhdf.c b/drivers/platform/x86/acerhdf.c
new file mode 100644
index 000000000000..bdfee177eefb
--- /dev/null
+++ b/drivers/platform/x86/acerhdf.c
@@ -0,0 +1,602 @@
+/*
+ * acerhdf - A driver which monitors the temperature
+ *           of the aspire one netbook, turns on/off the fan
+ *           as soon as the upper/lower threshold is reached.
+ *
+ * (C) 2009 - Peter Feuerer     peter (a) piie.net
+ *                              http://piie.net
+ *     2009 Borislav Petkov <petkovbb@gmail.com>
+ *
+ * Inspired by and many thanks to:
+ *  o acerfand   - Rachel Greenham
+ *  o acer_ec.pl - Michael Kurz     michi.kurz (at) googlemail.com
+ *               - Petr Tomasek     tomasek (#) etf,cuni,cz
+ *               - Carlos Corbacho  cathectic (at) gmail.com
+ *  o lkml       - Matthew Garrett
+ *               - Borislav Petkov
+ *               - Andreas Mohr
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#define pr_fmt(fmt) "acerhdf: " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/dmi.h>
+#include <acpi/acpi_drivers.h>
+#include <linux/sched.h>
+#include <linux/thermal.h>
+#include <linux/platform_device.h>
+
+/*
+ * The driver is started with "kernel mode off" by default. That means, the BIOS
+ * is still in control of the fan. In this mode the driver allows to read the
+ * temperature of the cpu and a userspace tool may take over control of the fan.
+ * If the driver is switched to "kernel mode" (e.g. via module parameter) the
+ * driver is in full control of the fan. If you want the module to be started in
+ * kernel mode by default, define the following:
+ */
+#undef START_IN_KERNEL_MODE
+
+#define DRV_VER "0.5.13"
+
+/*
+ * According to the Atom N270 datasheet,
+ * (http://download.intel.com/design/processor/datashts/320032.pdf) the
+ * CPU's optimal operating limits denoted in junction temperature as
+ * measured by the on-die thermal monitor are within 0 <= Tj <= 90. So,
+ * assume 89°C is critical temperature.
+ */
+#define ACERHDF_TEMP_CRIT 89
+#define ACERHDF_FAN_OFF 0
+#define ACERHDF_FAN_AUTO 1
+
+/*
+ * No matter what value the user puts into the fanon variable, turn on the fan
+ * at 80 degree Celsius to prevent hardware damage
+ */
+#define ACERHDF_MAX_FANON 80
+
+/*
+ * Maximum interval between two temperature checks is 15 seconds, as the die
+ * can get hot really fast under heavy load (plus we shouldn't forget about
+ * possible impact of _external_ aggressive sources such as heaters, sun etc.)
+ */
+#define ACERHDF_MAX_INTERVAL 15
+
+#ifdef START_IN_KERNEL_MODE
+static int kernelmode = 1;
+#else
+static int kernelmode;
+#endif
+
+static unsigned int interval = 10;
+static unsigned int fanon = 63;
+static unsigned int fanoff = 58;
+static unsigned int verbose;
+static unsigned int fanstate = ACERHDF_FAN_AUTO;
+static char force_bios[16];
+static unsigned int prev_interval;
+struct thermal_zone_device *thz_dev;
+struct thermal_cooling_device *cl_dev;
+struct platform_device *acerhdf_dev;
+
+module_param(kernelmode, uint, 0);
+MODULE_PARM_DESC(kernelmode, "Kernel mode fan control on / off");
+module_param(interval, uint, 0600);
+MODULE_PARM_DESC(interval, "Polling interval of temperature check");
+module_param(fanon, uint, 0600);
+MODULE_PARM_DESC(fanon, "Turn the fan on above this temperature");
+module_param(fanoff, uint, 0600);
+MODULE_PARM_DESC(fanoff, "Turn the fan off below this temperature");
+module_param(verbose, uint, 0600);
+MODULE_PARM_DESC(verbose, "Enable verbose dmesg output");
+module_param_string(force_bios, force_bios, 16, 0);
+MODULE_PARM_DESC(force_bios, "Force BIOS version and omit BIOS check");
+
+/* BIOS settings */
+struct bios_settings_t {
+        const char *vendor;
+        const char *version;
+        unsigned char fanreg;
+        unsigned char tempreg;
+        unsigned char fancmd[2]; /* fan off and auto commands */
+};
+
+/* Register addresses and values for different BIOS versions */
+static const struct bios_settings_t bios_tbl[] = {
+        {"Acer", "v0.3109", 0x55, 0x58, {0x1f, 0x00} },
+        {"Acer", "v0.3114", 0x55, 0x58, {0x1f, 0x00} },
+        {"Acer", "v0.3301", 0x55, 0x58, {0xaf, 0x00} },
+        {"Acer", "v0.3304", 0x55, 0x58, {0xaf, 0x00} },
+        {"Acer", "v0.3305", 0x55, 0x58, {0xaf, 0x00} },
+        {"Acer", "v0.3308", 0x55, 0x58, {0x21, 0x00} },
+        {"Acer", "v0.3309", 0x55, 0x58, {0x21, 0x00} },
+        {"Acer", "v0.3310", 0x55, 0x58, {0x21, 0x00} },
+        {"Gateway", "v0.3103", 0x55, 0x58, {0x21, 0x00} },
+        {"Packard Bell", "v0.3105", 0x55, 0x58, {0x21, 0x00} },
+        {"", "", 0, 0, {0, 0} }
+};
+
+static const struct bios_settings_t *bios_cfg __read_mostly;
+
+
+static int acerhdf_get_temp(int *temp)
+{
+        u8 read_temp;
+
+        if (ec_read(bios_cfg->tempreg, &read_temp))
+                return -EINVAL;
+
+        *temp = read_temp;
+
+        return 0;
+}
+
+static int acerhdf_get_fanstate(int *state)
+{
+        u8 fan;
+        bool tmp;
+
+        if (ec_read(bios_cfg->fanreg, &fan))
+                return -EINVAL;
+
+        tmp = (fan == bios_cfg->fancmd[ACERHDF_FAN_OFF]);
+        *state = tmp ? ACERHDF_FAN_OFF : ACERHDF_FAN_AUTO;
+
+        return 0;
+}
+
+static void acerhdf_change_fanstate(int state)
+{
+        unsigned char cmd;
+
+        if (verbose)
+                pr_notice("fan %s\n", (state == ACERHDF_FAN_OFF) ?
+                                "OFF" : "ON");
+
+        if ((state != ACERHDF_FAN_OFF) && (state != ACERHDF_FAN_AUTO)) {
+                pr_err("invalid fan state %d requested, setting to auto!\n",
+                        state);
+                state = ACERHDF_FAN_AUTO;
+        }
+
+        cmd = bios_cfg->fancmd[state];
+        fanstate = state;
+
+        ec_write(bios_cfg->fanreg, cmd);
+}
+
+static void acerhdf_check_param(struct thermal_zone_device *thermal)
+{
+        if (fanon > ACERHDF_MAX_FANON) {
+                pr_err("fanon temperature too high, set to %d\n",
+                                ACERHDF_MAX_FANON);
+                fanon = ACERHDF_MAX_FANON;
+        }
+
+        if (kernelmode && prev_interval != interval) {
+                if (interval > ACERHDF_MAX_INTERVAL) {
+                        pr_err("interval too high, set to %d\n",
+                                ACERHDF_MAX_INTERVAL);
+                        interval = ACERHDF_MAX_INTERVAL;
+                }
+                if (verbose)
+                        pr_notice("interval changed to: %d\n",
+                                        interval);
+                thermal->polling_delay = interval*1000;
+                prev_interval = interval;
+        }
+}
+
+/*
+ * This is the thermal zone callback which does the delayed polling of the fan
+ * state. We do check /sysfs-originating settings here in acerhdf_check_param()
+ * as late as the polling interval is since we can't do that in the respective
+ * accessors of the module parameters.
+ */
+static int acerhdf_get_ec_temp(struct thermal_zone_device *thermal,
+                               unsigned long *t)
+{
+        int temp, err = 0;
+
+        acerhdf_check_param(thermal);
+
+        err = acerhdf_get_temp(&temp);
+        if (err)
+                return err;
+
+        if (verbose)
+                pr_notice("temp %d\n", temp);
+
+        *t = temp;
+        return 0;
+}
+
+static int acerhdf_bind(struct thermal_zone_device *thermal,
+                        struct thermal_cooling_device *cdev)
+{
+        /* if the cooling device is the one from acerhdf bind it */
+        if (cdev != cl_dev)
+                return 0;
+
+        if (thermal_zone_bind_cooling_device(thermal, 0, cdev)) {
+                pr_err("error binding cooling dev\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int acerhdf_unbind(struct thermal_zone_device *thermal,
+                          struct thermal_cooling_device *cdev)
+{
+        if (cdev != cl_dev)
+                return 0;
+
+        if (thermal_zone_unbind_cooling_device(thermal, 0, cdev)) {
+                pr_err("error unbinding cooling dev\n");
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static inline void acerhdf_revert_to_bios_mode(void)
+{
+        acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
+        kernelmode = 0;
+        if (thz_dev)
+                thz_dev->polling_delay = 0;
+        pr_notice("kernel mode fan control OFF\n");
+}
+static inline void acerhdf_enable_kernelmode(void)
+{
+        kernelmode = 1;
+
+        thz_dev->polling_delay = interval*1000;
+        thermal_zone_device_update(thz_dev);
+        pr_notice("kernel mode fan control ON\n");
+}
+
+static int acerhdf_get_mode(struct thermal_zone_device *thermal,
+                            enum thermal_device_mode *mode)
+{
+        if (verbose)
+                pr_notice("kernel mode fan control %d\n", kernelmode);
+
+        *mode = (kernelmode) ? THERMAL_DEVICE_ENABLED
+                             : THERMAL_DEVICE_DISABLED;
+
+        return 0;
+}
+
+/*
+ * set operation mode;
+ * enabled: the thermal layer of the kernel takes care about
+ *          the temperature and the fan.
+ * disabled: the BIOS takes control of the fan.
+ */
+static int acerhdf_set_mode(struct thermal_zone_device *thermal,
+                            enum thermal_device_mode mode)
+{
+        if (mode == THERMAL_DEVICE_DISABLED && kernelmode)
+                acerhdf_revert_to_bios_mode();
+        else if (mode == THERMAL_DEVICE_ENABLED && !kernelmode)
+                acerhdf_enable_kernelmode();
+
+        return 0;
+}
+
+static int acerhdf_get_trip_type(struct thermal_zone_device *thermal, int trip,
+                                 enum thermal_trip_type *type)
+{
+        if (trip == 0)
+                *type = THERMAL_TRIP_ACTIVE;
+
+        return 0;
+}
+
+static int acerhdf_get_trip_temp(struct thermal_zone_device *thermal, int trip,
+                                 unsigned long *temp)
+{
+        if (trip == 0)
+                *temp = fanon;
+
+        return 0;
+}
+
+static int acerhdf_get_crit_temp(struct thermal_zone_device *thermal,
+                                 unsigned long *temperature)
+{
+        *temperature = ACERHDF_TEMP_CRIT;
+        return 0;
+}
+
+/* bind callback functions to thermalzone */
+struct thermal_zone_device_ops acerhdf_dev_ops = {
+        .bind = acerhdf_bind,
+        .unbind = acerhdf_unbind,
+        .get_temp = acerhdf_get_ec_temp,
+        .get_mode = acerhdf_get_mode,
+        .set_mode = acerhdf_set_mode,
+        .get_trip_type = acerhdf_get_trip_type,
+        .get_trip_temp = acerhdf_get_trip_temp,
+        .get_crit_temp = acerhdf_get_crit_temp,
+};
+
+
+/*
+ * cooling device callback functions
+ * get maximal fan cooling state
+ */
+static int acerhdf_get_max_state(struct thermal_cooling_device *cdev,
+                                 unsigned long *state)
+{
+        *state = 1;
+
+        return 0;
+}
+
+static int acerhdf_get_cur_state(struct thermal_cooling_device *cdev,
+                                 unsigned long *state)
+{
+        int err = 0, tmp;
+
+        err = acerhdf_get_fanstate(&tmp);
+        if (err)
+                return err;
+
+        *state = (tmp == ACERHDF_FAN_AUTO) ? 1 : 0;
+        return 0;
+}
+
+/* change current fan state - is overwritten when running in kernel mode */
+static int acerhdf_set_cur_state(struct thermal_cooling_device *cdev,
+                                 unsigned long state)
+{
+        int cur_temp, cur_state, err = 0;
+
+        if (!kernelmode)
+                return 0;
+
+        err = acerhdf_get_temp(&cur_temp);
+        if (err) {
+                pr_err("error reading temperature, hand off control to BIOS\n");
+                goto err_out;
+        }
+
+        err = acerhdf_get_fanstate(&cur_state);
+        if (err) {
+                pr_err("error reading fan state, hand off control to BIOS\n");
+                goto err_out;
+        }
+
+        if (state == 0) {
+                /* turn fan off only if below fanoff temperature */
+                if ((cur_state == ACERHDF_FAN_AUTO) &&
+                    (cur_temp < fanoff))
+                        acerhdf_change_fanstate(ACERHDF_FAN_OFF);
+        } else {
+                if (cur_state == ACERHDF_FAN_OFF)
+                        acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
+        }
+        return 0;
+
+err_out:
+        acerhdf_revert_to_bios_mode();
+        return -EINVAL;
+}
+
+/* bind fan callbacks to fan device */
+struct thermal_cooling_device_ops acerhdf_cooling_ops = {
+        .get_max_state = acerhdf_get_max_state,
+        .get_cur_state = acerhdf_get_cur_state,
+        .set_cur_state = acerhdf_set_cur_state,
+};
+
+/* suspend / resume functionality */
+static int acerhdf_suspend(struct platform_device *dev, pm_message_t state)
+{
+        if (kernelmode)
+                acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
+
+        if (verbose)
+                pr_notice("going suspend\n");
+
+        return 0;
+}
+
+static int acerhdf_resume(struct platform_device *device)
+{
+        if (verbose)
+                pr_notice("resuming\n");
+
+        return 0;
+}
+
+static int __devinit acerhdf_probe(struct platform_device *device)
+{
+        return 0;
+}
+
+static int acerhdf_remove(struct platform_device *device)
+{
+        return 0;
+}
+
+struct platform_driver acerhdf_drv = {
+        .driver = {
+                .name = "acerhdf",
+                .owner = THIS_MODULE,
+        },
+        .probe = acerhdf_probe,
+        .remove = acerhdf_remove,
+        .suspend = acerhdf_suspend,
+        .resume = acerhdf_resume,
+};
+
+
+/* check hardware */
+static int acerhdf_check_hardware(void)
+{
+        char const *vendor, *version, *product;
+        int i;
+
+        /* get BIOS data */
+        vendor  = dmi_get_system_info(DMI_SYS_VENDOR);
+        version = dmi_get_system_info(DMI_BIOS_VERSION);
+        product = dmi_get_system_info(DMI_PRODUCT_NAME);
+
+        pr_info("Acer Aspire One Fan driver, v.%s\n", DRV_VER);
+
+        if (!force_bios[0]) {
+                if (strncmp(product, "AO", 2)) {
+                        pr_err("no Aspire One hardware found\n");
+                        return -EINVAL;
+                }
+        } else {
+                pr_info("forcing BIOS version: %s\n", version);
+                version = force_bios;
+                kernelmode = 0;
+        }
+
+        if (verbose)
+                pr_info("BIOS info: %s %s, product: %s\n",
+                        vendor, version, product);
+
+        /* search BIOS version and vendor in BIOS settings table */
+        for (i = 0; bios_tbl[i].version[0]; i++) {
+                if (!strcmp(bios_tbl[i].vendor, vendor) &&
+                    !strcmp(bios_tbl[i].version, version)) {
+                        bios_cfg = &bios_tbl[i];
+                        break;
+                }
+        }
+
+        if (!bios_cfg) {
+                pr_err("unknown (unsupported) BIOS version %s/%s, "
+                        "please report, aborting!\n", vendor, version);
+                return -EINVAL;
+        }
+
+        /*
+         * if started with kernel mode off, prevent the kernel from switching
+         * off the fan
+         */
+        if (!kernelmode) {
+                pr_notice("Fan control off, to enable do:\n");
+                pr_notice("echo -n \"enabled\" > "
+                        "/sys/class/thermal/thermal_zone0/mode\n");
+        }
+
+        return 0;
+}
+
+static int acerhdf_register_platform(void)
+{
+        int err = 0;
+
+        err = platform_driver_register(&acerhdf_drv);
+        if (err)
+                return err;
+
+        acerhdf_dev = platform_device_alloc("acerhdf", -1);
+        platform_device_add(acerhdf_dev);
+
+        return 0;
+}
+
+static void acerhdf_unregister_platform(void)
+{
+        if (!acerhdf_dev)
+                return;
+
+        platform_device_del(acerhdf_dev);
+        platform_driver_unregister(&acerhdf_drv);
+}
+
+static int acerhdf_register_thermal(void)
+{
+        cl_dev = thermal_cooling_device_register("acerhdf-fan", NULL,
+                                                 &acerhdf_cooling_ops);
+
+        if (IS_ERR(cl_dev))
+                return -EINVAL;
+
+        thz_dev = thermal_zone_device_register("acerhdf", 1, NULL,
+                                              &acerhdf_dev_ops, 0, 0, 0,
+                                              (kernelmode) ? interval*1000 : 0);
+        if (IS_ERR(thz_dev))
+                return -EINVAL;
+
+        return 0;
+}
+
+static void acerhdf_unregister_thermal(void)
+{
+        if (cl_dev) {
+                thermal_cooling_device_unregister(cl_dev);
+                cl_dev = NULL;
+        }
+
+        if (thz_dev) {
+                thermal_zone_device_unregister(thz_dev);
+                thz_dev = NULL;
+        }
+}
+
+static int __init acerhdf_init(void)
+{
+        int err = 0;
+
+        err = acerhdf_check_hardware();
+        if (err)
+                goto out_err;
+
+        err = acerhdf_register_platform();
+        if (err)
+                goto err_unreg;
+
+        err = acerhdf_register_thermal();
+        if (err)
+                goto err_unreg;
+
+        return 0;
+
+err_unreg:
+        acerhdf_unregister_thermal();
+        acerhdf_unregister_platform();
+
+out_err:
+        return -ENODEV;
+}
+
+static void __exit acerhdf_exit(void)
+{
+        acerhdf_change_fanstate(ACERHDF_FAN_AUTO);
+        acerhdf_unregister_thermal();
+        acerhdf_unregister_platform();
+}
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Peter Feuerer");
+MODULE_DESCRIPTION("Aspire One temperature and fan driver");
+MODULE_ALIAS("dmi:*:*Acer*:*:");
+MODULE_ALIAS("dmi:*:*Gateway*:*:");
+MODULE_ALIAS("dmi:*:*Packard Bell*:*:");
+
+module_init(acerhdf_init);
+module_exit(acerhdf_exit);
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index bfc1a8892a32..db657bbeec90 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -33,6 +33,8 @@
  *  Sam Lin        - GPS support
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -53,9 +55,10 @@
 #define ASUS_HOTK_NAME          "Asus Laptop Support"
 #define ASUS_HOTK_CLASS         "hotkey"
 #define ASUS_HOTK_DEVICE_NAME   "Hotkey"
-#define ASUS_HOTK_FILE          "asus-laptop"
+#define ASUS_HOTK_FILE          KBUILD_MODNAME
 #define ASUS_HOTK_PREFIX        "\\_SB.ATKD."
 
+
 /*
  * Some events we use, same for all Asus
  */
@@ -207,13 +210,17 @@ MODULE_DEVICE_TABLE(acpi, asus_device_ids);
 
 static int asus_hotk_add(struct acpi_device *device);
 static int asus_hotk_remove(struct acpi_device *device, int type);
+static void asus_hotk_notify(struct acpi_device *device, u32 event);
+
 static struct acpi_driver asus_hotk_driver = {
         .name = ASUS_HOTK_NAME,
         .class = ASUS_HOTK_CLASS,
         .ids = asus_device_ids,
+        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = asus_hotk_add,
                 .remove = asus_hotk_remove,
+                .notify = asus_hotk_notify,
                 },
 };
 
@@ -323,7 +330,7 @@ static int read_wireless_status(int mask)
 
         rv = acpi_evaluate_integer(wireless_status_handle, NULL, NULL, &status);
         if (ACPI_FAILURE(rv))
-                printk(ASUS_WARNING "Error reading Wireless status\n");
+                pr_warning("Error reading Wireless status\n");
         else
                 return (status & mask) ? 1 : 0;
 
@@ -337,7 +344,7 @@ static int read_gps_status(void)
 
         rv = acpi_evaluate_integer(gps_status_handle, NULL, NULL, &status);
         if (ACPI_FAILURE(rv))
-                printk(ASUS_WARNING "Error reading GPS status\n");
+                pr_warning("Error reading GPS status\n");
         else
                 return status ? 1 : 0;
 
@@ -377,7 +384,7 @@ static void write_status(acpi_handle handle, int out, int mask)
         }
 
         if (write_acpi_int(handle, NULL, out, NULL))
-                printk(ASUS_WARNING " write failed %x\n", mask);
+                pr_warning(" write failed %x\n", mask);
 }
 
 /* /sys/class/led handlers */
@@ -420,7 +427,7 @@ static int set_lcd_state(int value)
                                               NULL, NULL, NULL);
 
                 if (ACPI_FAILURE(status))
-                        printk(ASUS_WARNING "Error switching LCD\n");
+                        pr_warning("Error switching LCD\n");
         }
 
         write_status(NULL, lcd, LCD_ON);
@@ -444,7 +451,7 @@ static int read_brightness(struct backlight_device *bd)
 
         rv = acpi_evaluate_integer(brightness_get_handle, NULL, NULL, &value);
         if (ACPI_FAILURE(rv))
-                printk(ASUS_WARNING "Error reading brightness\n");
+                pr_warning("Error reading brightness\n");
 
         return value;
 }
@@ -457,7 +464,7 @@ static int set_brightness(struct backlight_device *bd, int value)
         /* 0 <= value <= 15 */
 
         if (write_acpi_int(brightness_set_handle, NULL, value, NULL)) {
-                printk(ASUS_WARNING "Error changing brightness\n");
+                pr_warning("Error changing brightness\n");
                 ret = -EIO;
         }
 
@@ -587,7 +594,7 @@ static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
         rv = parse_arg(buf, count, &value);
         if (rv > 0) {
                 if (write_acpi_int(ledd_set_handle, NULL, value, NULL))
-                        printk(ASUS_WARNING "LED display write failed\n");
+                        pr_warning("LED display write failed\n");
                 else
                         hotk->ledd_status = (u32) value;
         }
@@ -632,7 +639,7 @@ static void set_display(int value)
 {
         /* no sanity check needed for now */
         if (write_acpi_int(display_set_handle, NULL, value, NULL))
-                printk(ASUS_WARNING "Error setting display\n");
+                pr_warning("Error setting display\n");
         return;
 }
 
@@ -647,7 +654,7 @@ static int read_display(void)
                 rv = acpi_evaluate_integer(display_get_handle, NULL,
                                            NULL, &value);
                 if (ACPI_FAILURE(rv))
-                        printk(ASUS_WARNING "Error reading display status\n");
+                        pr_warning("Error reading display status\n");
         }
 
         value &= 0x0F;          /* needed for some models, shouldn't hurt others */
@@ -689,7 +696,7 @@ static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
 static void set_light_sens_switch(int value)
 {
         if (write_acpi_int(ls_switch_handle, NULL, value, NULL))
-                printk(ASUS_WARNING "Error setting light sensor switch\n");
+                pr_warning("Error setting light sensor switch\n");
         hotk->light_switch = value;
 }
 
@@ -714,7 +721,7 @@ static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
 static void set_light_sens_level(int value)
 {
         if (write_acpi_int(ls_level_handle, NULL, value, NULL))
-                printk(ASUS_WARNING "Error setting light sensor level\n");
+                pr_warning("Error setting light sensor level\n");
         hotk->light_level = value;
 }
 
@@ -812,7 +819,7 @@ static int asus_setkeycode(struct input_dev *dev, int scancode, int keycode)
         return -EINVAL;
 }
 
-static void asus_hotk_notify(acpi_handle handle, u32 event, void *data)
+static void asus_hotk_notify(struct acpi_device *device, u32 event)
 {
         static struct key_entry *key;
         u16 count;
@@ -975,11 +982,11 @@ static int asus_hotk_get_info(void)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
         if (ACPI_FAILURE(status))
-                printk(ASUS_WARNING "Couldn't get the DSDT table header\n");
+                pr_warning("Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
-                printk(ASUS_ERR "Hotkey initialization failed\n");
+                pr_err("Hotkey initialization failed\n");
                 return -ENODEV;
         }
 
@@ -987,9 +994,9 @@ static int asus_hotk_get_info(void)
         status =
             acpi_evaluate_integer(hotk->handle, "BSTS", NULL, &bsts_result);
         if (ACPI_FAILURE(status))
-                printk(ASUS_WARNING "Error calling BSTS\n");
+                pr_warning("Error calling BSTS\n");
         else if (bsts_result)
-                printk(ASUS_NOTICE "BSTS called, 0x%02x returned\n",
+                pr_notice("BSTS called, 0x%02x returned\n",
                        (uint) bsts_result);
 
         /* This too ... */
@@ -1020,7 +1027,7 @@ static int asus_hotk_get_info(void)
                 return -ENOMEM;
 
         if (*string)
-                printk(ASUS_NOTICE "  %s model detected\n", string);
+                pr_notice("  %s model detected\n", string);
 
         ASUS_HANDLE_INIT(mled_set);
         ASUS_HANDLE_INIT(tled_set);
@@ -1077,7 +1084,7 @@ static int asus_input_init(void)
 
         hotk->inputdev = input_allocate_device();
         if (!hotk->inputdev) {
-                printk(ASUS_INFO "Unable to allocate input device\n");
+                pr_info("Unable to allocate input device\n");
                 return 0;
         }
         hotk->inputdev->name = "Asus Laptop extra buttons";
@@ -1096,7 +1103,7 @@ static int asus_input_init(void)
         }
         result = input_register_device(hotk->inputdev);
         if (result) {
-                printk(ASUS_INFO "Unable to register input device\n");
+                pr_info("Unable to register input device\n");
                 input_free_device(hotk->inputdev);
         }
         return result;
@@ -1113,7 +1120,7 @@ static int asus_hotk_check(void)
         if (hotk->device->status.present) {
                 result = asus_hotk_get_info();
         } else {
-                printk(ASUS_ERR "Hotkey device not present, aborting\n");
+                pr_err("Hotkey device not present, aborting\n");
                 return -EINVAL;
         }
 
@@ -1124,13 +1131,12 @@ static int asus_hotk_found;
 
 static int asus_hotk_add(struct acpi_device *device)
 {
-        acpi_status status = AE_OK;
         int result;
 
         if (!device)
                 return -EINVAL;
 
-        printk(ASUS_NOTICE "Asus Laptop Support version %s\n",
+        pr_notice("Asus Laptop Support version %s\n",
                ASUS_LAPTOP_VERSION);
 
         hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
@@ -1149,15 +1155,6 @@ static int asus_hotk_add(struct acpi_device *device)
 
         asus_hotk_add_fs();
 
-        /*
-         * We install the handler, it will receive the hotk in parameter, so, we
-         * could add other data to the hotk struct
-         */
-        status = acpi_install_notify_handler(hotk->handle, ACPI_ALL_NOTIFY,
-                                             asus_hotk_notify, hotk);
-        if (ACPI_FAILURE(status))
-                printk(ASUS_ERR "Error installing notify handler\n");
-
         asus_hotk_found = 1;
 
         /* WLED and BLED are on by default */
@@ -1198,16 +1195,9 @@ end:
 
 static int asus_hotk_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = 0;
-
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
 
-        status = acpi_remove_notify_handler(hotk->handle, ACPI_ALL_NOTIFY,
-                                            asus_hotk_notify);
-        if (ACPI_FAILURE(status))
-                printk(ASUS_ERR "Error removing notify handler\n");
-
         kfree(hotk->name);
         kfree(hotk);
 
@@ -1260,8 +1250,7 @@ static int asus_backlight_init(struct device *dev)
                 bd = backlight_device_register(ASUS_HOTK_FILE, dev,
                                                NULL, &asusbl_ops);
                 if (IS_ERR(bd)) {
-                        printk(ASUS_ERR
-                               "Could not register asus backlight device\n");
+                        pr_err("Could not register asus backlight device\n");
                         asus_backlight_device = NULL;
                         return PTR_ERR(bd);
                 }
@@ -1334,7 +1323,6 @@ out:
 
 static int __init asus_laptop_init(void)
 {
-        struct device *dev;
         int result;
 
         if (acpi_disabled)
@@ -1356,24 +1344,10 @@ static int __init asus_laptop_init(void)
                 return -ENODEV;
         }
 
-        dev = acpi_get_physical_device(hotk->device->handle);
-
-        if (!acpi_video_backlight_support()) {
-                result = asus_backlight_init(dev);
-                if (result)
-                        goto fail_backlight;
-        } else
-                printk(ASUS_INFO "Brightness ignored, must be controlled by "
-                       "ACPI video driver\n");
-
         result = asus_input_init();
         if (result)
                 goto fail_input;
 
-        result = asus_led_init(dev);
-        if (result)
-                goto fail_led;
-
         /* Register platform stuff */
         result = platform_driver_register(&asuspf_driver);
         if (result)
@@ -1394,8 +1368,27 @@ static int __init asus_laptop_init(void)
         if (result)
                 goto fail_sysfs;
 
+        result = asus_led_init(&asuspf_device->dev);
+        if (result)
+                goto fail_led;
+
+        if (!acpi_video_backlight_support()) {
+                result = asus_backlight_init(&asuspf_device->dev);
+                if (result)
+                        goto fail_backlight;
+        } else
+                pr_info("Brightness ignored, must be controlled by "
+                       "ACPI video driver\n");
+
         return 0;
 
+fail_backlight:
+       asus_led_exit();
+
+fail_led:
+       sysfs_remove_group(&asuspf_device->dev.kobj,
+                          &asuspf_attribute_group);
+
 fail_sysfs:
         platform_device_del(asuspf_device);
 
@@ -1406,15 +1399,9 @@ fail_platform_device1:
         platform_driver_unregister(&asuspf_driver);
 
 fail_platform_driver:
-        asus_led_exit();
-
-fail_led:
         asus_input_exit();
 
 fail_input:
-        asus_backlight_exit();
-
-fail_backlight:
 
         return result;
 }
diff --git a/drivers/platform/x86/asus_acpi.c b/drivers/platform/x86/asus_acpi.c
index ba1f7497e4b9..ddf5240ade8c 100644
--- a/drivers/platform/x86/asus_acpi.c
+++ b/drivers/platform/x86/asus_acpi.c
@@ -455,6 +455,8 @@ static struct asus_hotk *hotk;
  */
 static int asus_hotk_add(struct acpi_device *device);
 static int asus_hotk_remove(struct acpi_device *device, int type);
+static void asus_hotk_notify(struct acpi_device *device, u32 event);
+
 static const struct acpi_device_id asus_device_ids[] = {
         {"ATK0100", 0},
         {"", 0},
@@ -465,9 +467,11 @@ static struct acpi_driver asus_hotk_driver = {
         .name = "asus_acpi",
         .class = ACPI_HOTK_CLASS,
         .ids = asus_device_ids,
+        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = asus_hotk_add,
                 .remove = asus_hotk_remove,
+                .notify = asus_hotk_notify,
                 },
 };
 
@@ -1101,12 +1105,20 @@ static int asus_hotk_remove_fs(struct acpi_device *device)
         return 0;
 }
 
-static void asus_hotk_notify(acpi_handle handle, u32 event, void *data)
+static void asus_hotk_notify(struct acpi_device *device, u32 event)
 {
         /* TODO Find a better way to handle events count. */
         if (!hotk)
                 return;
 
+        /*
+         * The BIOS *should* be sending us device events, but apparently
+         * Asus uses system events instead, so just ignore any device
+         * events we get.
+         */
+        if (event > ACPI_MAX_SYS_NOTIFY)
+                return;
+
         if ((event & ~((u32) BR_UP)) < 16)
                 hotk->brightness = (event & ~((u32) BR_UP));
         else if ((event & ~((u32) BR_DOWN)) < 16)
@@ -1346,15 +1358,6 @@ static int asus_hotk_add(struct acpi_device *device)
         if (result)
                 goto end;
 
-        /*
-         * We install the handler, it will receive the hotk in parameter, so, we
-         * could add other data to the hotk struct
-         */
-        status = acpi_install_notify_handler(hotk->handle, ACPI_SYSTEM_NOTIFY,
-                                             asus_hotk_notify, hotk);
-        if (ACPI_FAILURE(status))
-                printk(KERN_ERR "  Error installing notify handler\n");
-
         /* For laptops without GPLV: init the hotk->brightness value */
         if ((!hotk->methods->brightness_get)
             && (!hotk->methods->brightness_status)
@@ -1389,16 +1392,9 @@ end:
 
 static int asus_hotk_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = 0;
-
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
 
-        status = acpi_remove_notify_handler(hotk->handle, ACPI_SYSTEM_NOTIFY,
-                                            asus_hotk_notify);
-        if (ACPI_FAILURE(status))
-                printk(KERN_ERR "Asus ACPI: Error removing notify handler\n");
-
         asus_hotk_remove_fs(device);
 
         kfree(hotk);
diff --git a/drivers/platform/x86/dell-wmi.c b/drivers/platform/x86/dell-wmi.c
index 2fab94162147..0f900cc9fa7a 100644
--- a/drivers/platform/x86/dell-wmi.c
+++ b/drivers/platform/x86/dell-wmi.c
@@ -46,10 +46,53 @@ struct key_entry {
         u16 keycode;
 };
 
-enum { KE_KEY, KE_SW, KE_END };
+enum { KE_KEY, KE_SW, KE_IGNORE, KE_END };
+
+/*
+ * Certain keys are flagged as KE_IGNORE. All of these are either
+ * notifications (rather than requests for change) or are also sent
+ * via the keyboard controller so should not be sent again.
+ */
 
 static struct key_entry dell_wmi_keymap[] = {
         {KE_KEY, 0xe045, KEY_PROG1},
+        {KE_KEY, 0xe009, KEY_EJECTCD},
+
+        /* These also contain the brightness level at offset 6 */
+        {KE_KEY, 0xe006, KEY_BRIGHTNESSUP},
+        {KE_KEY, 0xe005, KEY_BRIGHTNESSDOWN},
+
+        /* Battery health status button */
+        {KE_KEY, 0xe007, KEY_BATTERY},
+
+        /* This is actually for all radios. Although physically a
+         * switch, the notification does not provide an indication of
+         * state and so it should be reported as a key */
+        {KE_KEY, 0xe008, KEY_WLAN},
+
+        /* The next device is at offset 6, the active devices are at
+           offset 8 and the attached devices at offset 10 */
+        {KE_KEY, 0xe00b, KEY_DISPLAYTOGGLE},
+
+        {KE_IGNORE, 0xe00c, KEY_KBDILLUMTOGGLE},
+
+        /* BIOS error detected */
+        {KE_IGNORE, 0xe00d, KEY_RESERVED},
+
+        /* Wifi Catcher */
+        {KE_KEY, 0xe011, KEY_PROG2},
+
+        /* Ambient light sensor toggle */
+        {KE_IGNORE, 0xe013, KEY_RESERVED},
+
+        {KE_IGNORE, 0xe020, KEY_MUTE},
+        {KE_IGNORE, 0xe02e, KEY_VOLUMEDOWN},
+        {KE_IGNORE, 0xe030, KEY_VOLUMEUP},
+        {KE_IGNORE, 0xe033, KEY_KBDILLUMUP},
+        {KE_IGNORE, 0xe034, KEY_KBDILLUMDOWN},
+        {KE_IGNORE, 0xe03a, KEY_CAPSLOCK},
+        {KE_IGNORE, 0xe045, KEY_NUMLOCK},
+        {KE_IGNORE, 0xe046, KEY_SCROLLLOCK},
         {KE_END, 0}
 };
 
@@ -122,15 +165,20 @@ static void dell_wmi_notify(u32 value, void *context)
 
         if (obj && obj->type == ACPI_TYPE_BUFFER) {
                 int *buffer = (int *)obj->buffer.pointer;
-                key = dell_wmi_get_entry_by_scancode(buffer[1]);
+                /*
+                 *  The upper bytes of the event may contain
+                 *  additional information, so mask them off for the
+                 *  scancode lookup
+                 */
+                key = dell_wmi_get_entry_by_scancode(buffer[1] & 0xFFFF);
                 if (key) {
                         input_report_key(dell_wmi_input_dev, key->keycode, 1);
                         input_sync(dell_wmi_input_dev);
                         input_report_key(dell_wmi_input_dev, key->keycode, 0);
                         input_sync(dell_wmi_input_dev);
-                } else
+                } else if (buffer[1] & 0xFFFF)
                         printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
-                               buffer[1]);
+                               buffer[1] & 0xFFFF);
         }
 }
 
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 8153b3e59189..ec560f16d720 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -16,6 +16,8 @@
  *  GNU General Public License for more details.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -31,6 +33,7 @@
 #include <linux/input.h>
 #include <linux/rfkill.h>
 #include <linux/pci.h>
+#include <linux/pci_hotplug.h>
 
 #define EEEPC_LAPTOP_VERSION    "0.1"
 
@@ -40,11 +43,6 @@
 #define EEEPC_HOTK_DEVICE_NAME  "Hotkey"
 #define EEEPC_HOTK_HID          "ASUS010"
 
-#define EEEPC_LOG       EEEPC_HOTK_FILE ": "
-#define EEEPC_ERR       KERN_ERR        EEEPC_LOG
-#define EEEPC_WARNING   KERN_WARNING    EEEPC_LOG
-#define EEEPC_NOTICE    KERN_NOTICE     EEEPC_LOG
-#define EEEPC_INFO      KERN_INFO       EEEPC_LOG
 
 /*
  * Definitions for Asus EeePC
@@ -62,7 +60,10 @@ enum {
         DISABLE_ASL_GPS = 0x0020,
         DISABLE_ASL_DISPLAYSWITCH = 0x0040,
         DISABLE_ASL_MODEM = 0x0080,
-        DISABLE_ASL_CARDREADER = 0x0100
+        DISABLE_ASL_CARDREADER = 0x0100,
+        DISABLE_ASL_3G = 0x0200,
+        DISABLE_ASL_WIMAX = 0x0400,
+        DISABLE_ASL_HWCF = 0x0800
 };
 
 enum {
@@ -87,7 +88,13 @@ enum {
         CM_ASL_USBPORT3,
         CM_ASL_MODEM,
         CM_ASL_CARDREADER,
-        CM_ASL_LID
+        CM_ASL_3G,
+        CM_ASL_WIMAX,
+        CM_ASL_HWCF,
+        CM_ASL_LID,
+        CM_ASL_TYPE,
+        CM_ASL_PANELPOWER,      /*P901*/
+        CM_ASL_TPD
 };
 
 static const char *cm_getv[] = {
@@ -96,7 +103,8 @@ static const char *cm_getv[] = {
         NULL, "PBLG", NULL, NULL,
         "CFVG", NULL, NULL, NULL,
         "USBG", NULL, NULL, "MODG",
-        "CRDG", "LIDG"
+        "CRDG", "M3GG", "WIMG", "HWCF",
+        "LIDG", "TYPE", "PBPG", "TPDG"
 };
 
 static const char *cm_setv[] = {
@@ -105,7 +113,8 @@ static const char *cm_setv[] = {
         "SDSP", "PBLS", "HDPS", NULL,
         "CFVS", NULL, NULL, NULL,
         "USBG", NULL, NULL, "MODS",
-        "CRDS", NULL
+        "CRDS", "M3GS", "WIMS", NULL,
+        NULL, NULL, "PBPS", "TPDS"
 };
 
 #define EEEPC_EC        "\\_SB.PCI0.SBRG.EC0."
@@ -130,8 +139,10 @@ struct eeepc_hotk {
         u16 event_count[128];           /* count for each event */
         struct input_dev *inputdev;
         u16 *keycode_map;
-        struct rfkill *eeepc_wlan_rfkill;
-        struct rfkill *eeepc_bluetooth_rfkill;
+        struct rfkill *wlan_rfkill;
+        struct rfkill *bluetooth_rfkill;
+        struct rfkill *wwan3g_rfkill;
+        struct hotplug_slot *hotplug_slot;
 };
 
 /* The actual device the driver binds to */
@@ -181,6 +192,7 @@ static struct key_entry eeepc_keymap[] = {
 static int eeepc_hotk_add(struct acpi_device *device);
 static int eeepc_hotk_remove(struct acpi_device *device, int type);
 static int eeepc_hotk_resume(struct acpi_device *device);
+static void eeepc_hotk_notify(struct acpi_device *device, u32 event);
 
 static const struct acpi_device_id eeepc_device_ids[] = {
         {EEEPC_HOTK_HID, 0},
@@ -192,13 +204,24 @@ static struct acpi_driver eeepc_hotk_driver = {
         .name = EEEPC_HOTK_NAME,
         .class = EEEPC_HOTK_CLASS,
         .ids = eeepc_device_ids,
+        .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
         .ops = {
                 .add = eeepc_hotk_add,
                 .remove = eeepc_hotk_remove,
                 .resume = eeepc_hotk_resume,
+                .notify = eeepc_hotk_notify,
         },
 };
 
+/* PCI hotplug ops */
+static int eeepc_get_adapter_status(struct hotplug_slot *slot, u8 *value);
+
+static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
+        .owner = THIS_MODULE,
+        .get_adapter_status = eeepc_get_adapter_status,
+        .get_power_status = eeepc_get_adapter_status,
+};
+
 /* The backlight device /sys/class/backlight */
 static struct backlight_device *eeepc_backlight_device;
 
@@ -260,20 +283,20 @@ static int set_acpi(int cm, int value)
                 if (method == NULL)
                         return -ENODEV;
                 if (write_acpi_int(ehotk->handle, method, value, NULL))
-                        printk(EEEPC_WARNING "Error writing %s\n", method);
+                        pr_warning("Error writing %s\n", method);
         }
         return 0;
 }
 
 static int get_acpi(int cm)
 {
-        int value = -1;
+        int value = -ENODEV;
         if ((ehotk->cm_supported & (0x1 << cm))) {
                 const char *method = cm_getv[cm];
                 if (method == NULL)
                         return -ENODEV;
                 if (read_acpi_int(ehotk->handle, method, &value))
-                        printk(EEEPC_WARNING "Error reading %s\n", method);
+                        pr_warning("Error reading %s\n", method);
         }
         return value;
 }
@@ -318,6 +341,15 @@ static const struct rfkill_ops eeepc_rfkill_ops = {
         .set_block = eeepc_rfkill_set,
 };
 
+static void __init eeepc_enable_camera(void)
+{
+        /*
+         * If the following call to set_acpi() fails, it's because there's no
+         * camera so we can ignore the error.
+         */
+        set_acpi(CM_ASL_CAMERA, 1);
+}
+
 /*
  * Sys helpers
  */
@@ -336,13 +368,19 @@ static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
 
         rv = parse_arg(buf, count, &value);
         if (rv > 0)
-                set_acpi(cm, value);
+                value = set_acpi(cm, value);
+        if (value < 0)
+                return value;
         return rv;
 }
 
 static ssize_t show_sys_acpi(int cm, char *buf)
 {
-        return sprintf(buf, "%d\n", get_acpi(cm));
+        int value = get_acpi(cm);
+
+        if (value < 0)
+                return value;
+        return sprintf(buf, "%d\n", value);
 }
 
 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm)                            \
@@ -369,13 +407,88 @@ static ssize_t show_sys_acpi(int cm, char *buf)
 EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
 EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
 EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
-EEEPC_CREATE_DEVICE_ATTR(cpufv, CM_ASL_CPUFV);
+
+struct eeepc_cpufv {
+        int num;
+        int cur;
+};
+
+static int get_cpufv(struct eeepc_cpufv *c)
+{
+        c->cur = get_acpi(CM_ASL_CPUFV);
+        c->num = (c->cur >> 8) & 0xff;
+        c->cur &= 0xff;
+        if (c->cur < 0 || c->num <= 0 || c->num > 12)
+                return -ENODEV;
+        return 0;
+}
+
+static ssize_t show_available_cpufv(struct device *dev,
+                                    struct device_attribute *attr,
+                                    char *buf)
+{
+        struct eeepc_cpufv c;
+        int i;
+        ssize_t len = 0;
+
+        if (get_cpufv(&c))
+                return -ENODEV;
+        for (i = 0; i < c.num; i++)
+                len += sprintf(buf + len, "%d ", i);
+        len += sprintf(buf + len, "\n");
+        return len;
+}
+
+static ssize_t show_cpufv(struct device *dev,
+                          struct device_attribute *attr,
+                          char *buf)
+{
+        struct eeepc_cpufv c;
+
+        if (get_cpufv(&c))
+                return -ENODEV;
+        return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
+}
+
+static ssize_t store_cpufv(struct device *dev,
+                           struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct eeepc_cpufv c;
+        int rv, value;
+
+        if (get_cpufv(&c))
+                return -ENODEV;
+        rv = parse_arg(buf, count, &value);
+        if (rv < 0)
+                return rv;
+        if (!rv || value < 0 || value >= c.num)
+                return -EINVAL;
+        set_acpi(CM_ASL_CPUFV, value);
+        return rv;
+}
+
+static struct device_attribute dev_attr_cpufv = {
+        .attr = {
+                .name = "cpufv",
+                .mode = 0644 },
+        .show   = show_cpufv,
+        .store  = store_cpufv
+};
+
+static struct device_attribute dev_attr_available_cpufv = {
+        .attr = {
+                .name = "available_cpufv",
+                .mode = 0444 },
+        .show   = show_available_cpufv
+};
 
 static struct attribute *platform_attributes[] = {
         &dev_attr_camera.attr,
         &dev_attr_cardr.attr,
         &dev_attr_disp.attr,
         &dev_attr_cpufv.attr,
+        &dev_attr_available_cpufv.attr,
         NULL
 };
 
@@ -441,6 +554,28 @@ static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
         return -EINVAL;
 }
 
+static void cmsg_quirk(int cm, const char *name)
+{
+        int dummy;
+
+        /* Some BIOSes do not report cm although it is avaliable.
+           Check if cm_getv[cm] works and, if yes, assume cm should be set. */
+        if (!(ehotk->cm_supported & (1 << cm))
+            && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) {
+                pr_info("%s (%x) not reported by BIOS,"
+                        " enabling anyway\n", name, 1 << cm);
+                ehotk->cm_supported |= 1 << cm;
+        }
+}
+
+static void cmsg_quirks(void)
+{
+        cmsg_quirk(CM_ASL_LID, "LID");
+        cmsg_quirk(CM_ASL_TYPE, "TYPE");
+        cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER");
+        cmsg_quirk(CM_ASL_TPD, "TPD");
+}
+
 static int eeepc_hotk_check(void)
 {
         const struct key_entry *key;
@@ -453,26 +588,24 @@ static int eeepc_hotk_check(void)
         if (ehotk->device->status.present) {
                 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
                                     &buffer)) {
-                        printk(EEEPC_ERR "Hotkey initialization failed\n");
+                        pr_err("Hotkey initialization failed\n");
                         return -ENODEV;
                 } else {
-                        printk(EEEPC_NOTICE "Hotkey init flags 0x%x\n",
-                               ehotk->init_flag);
+                        pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag);
                 }
                 /* get control methods supported */
                 if (read_acpi_int(ehotk->handle, "CMSG"
                                    , &ehotk->cm_supported)) {
-                        printk(EEEPC_ERR
-                               "Get control methods supported failed\n");
+                        pr_err("Get control methods supported failed\n");
                         return -ENODEV;
                 } else {
-                        printk(EEEPC_INFO
-                               "Get control methods supported: 0x%x\n",
-                               ehotk->cm_supported);
+                        cmsg_quirks();
+                        pr_info("Get control methods supported: 0x%x\n",
+                                ehotk->cm_supported);
                 }
                 ehotk->inputdev = input_allocate_device();
                 if (!ehotk->inputdev) {
-                        printk(EEEPC_INFO "Unable to allocate input device\n");
+                        pr_info("Unable to allocate input device\n");
                         return 0;
                 }
                 ehotk->inputdev->name = "Asus EeePC extra buttons";
@@ -491,12 +624,12 @@ static int eeepc_hotk_check(void)
                 }
                 result = input_register_device(ehotk->inputdev);
                 if (result) {
-                        printk(EEEPC_INFO "Unable to register input device\n");
+                        pr_info("Unable to register input device\n");
                         input_free_device(ehotk->inputdev);
                         return 0;
                 }
         } else {
-                printk(EEEPC_ERR "Hotkey device not present, aborting\n");
+                pr_err("Hotkey device not present, aborting\n");
                 return -EINVAL;
         }
         return 0;
@@ -514,6 +647,19 @@ static int notify_brn(void)
         return -1;
 }
 
+static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
+                                    u8 *value)
+{
+        int val = get_acpi(CM_ASL_WLAN);
+
+        if (val == 1 || val == 0)
+                *value = val;
+        else
+                return -EINVAL;
+
+        return 0;
+}
+
 static void eeepc_rfkill_hotplug(void)
 {
         struct pci_dev *dev;
@@ -521,7 +667,7 @@ static void eeepc_rfkill_hotplug(void)
         bool blocked;
 
         if (!bus) {
-                printk(EEEPC_WARNING "Unable to find PCI bus 1?\n");
+                pr_warning("Unable to find PCI bus 1?\n");
                 return;
         }
 
@@ -537,7 +683,7 @@ static void eeepc_rfkill_hotplug(void)
                 if (dev) {
                         pci_bus_assign_resources(bus);
                         if (pci_bus_add_device(dev))
-                                printk(EEEPC_ERR "Unable to hotplug wifi\n");
+                                pr_err("Unable to hotplug wifi\n");
                 }
         } else {
                 dev = pci_get_slot(bus, 0);
@@ -547,7 +693,7 @@ static void eeepc_rfkill_hotplug(void)
                 }
         }
 
-        rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill, blocked);
+        rfkill_set_sw_state(ehotk->wlan_rfkill, blocked);
 }
 
 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
@@ -558,7 +704,7 @@ static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
         eeepc_rfkill_hotplug();
 }
 
-static void eeepc_hotk_notify(acpi_handle handle, u32 event, void *data)
+static void eeepc_hotk_notify(struct acpi_device *device, u32 event)
 {
         static struct key_entry *key;
         u16 count;
@@ -566,6 +712,8 @@ static void eeepc_hotk_notify(acpi_handle handle, u32 event, void *data)
 
         if (!ehotk)
                 return;
+        if (event > ACPI_MAX_SYS_NOTIFY)
+                return;
         if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
                 brn = notify_brn();
         count = ehotk->event_count[event % 128]++;
@@ -618,8 +766,7 @@ static int eeepc_register_rfkill_notifier(char *node)
                                                      eeepc_rfkill_notify,
                                                      NULL);
                 if (ACPI_FAILURE(status))
-                        printk(EEEPC_WARNING
-                               "Failed to register notify on %s\n", node);
+                        pr_warning("Failed to register notify on %s\n", node);
         } else
                 return -ENODEV;
 
@@ -638,20 +785,66 @@ static void eeepc_unregister_rfkill_notifier(char *node)
                                                      ACPI_SYSTEM_NOTIFY,
                                                      eeepc_rfkill_notify);
                 if (ACPI_FAILURE(status))
-                        printk(EEEPC_ERR
-                               "Error removing rfkill notify handler %s\n",
+                        pr_err("Error removing rfkill notify handler %s\n",
                                 node);
         }
 }
 
+static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
+{
+        kfree(hotplug_slot->info);
+        kfree(hotplug_slot);
+}
+
+static int eeepc_setup_pci_hotplug(void)
+{
+        int ret = -ENOMEM;
+        struct pci_bus *bus = pci_find_bus(0, 1);
+
+        if (!bus) {
+                pr_err("Unable to find wifi PCI bus\n");
+                return -ENODEV;
+        }
+
+        ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
+        if (!ehotk->hotplug_slot)
+                goto error_slot;
+
+        ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
+                                            GFP_KERNEL);
+        if (!ehotk->hotplug_slot->info)
+                goto error_info;
+
+        ehotk->hotplug_slot->private = ehotk;
+        ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
+        ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
+        eeepc_get_adapter_status(ehotk->hotplug_slot,
+                                 &ehotk->hotplug_slot->info->adapter_status);
+
+        ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi");
+        if (ret) {
+                pr_err("Unable to register hotplug slot - %d\n", ret);
+                goto error_register;
+        }
+
+        return 0;
+
+error_register:
+        kfree(ehotk->hotplug_slot->info);
+error_info:
+        kfree(ehotk->hotplug_slot);
+        ehotk->hotplug_slot = NULL;
+error_slot:
+        return ret;
+}
+
 static int eeepc_hotk_add(struct acpi_device *device)
 {
-        acpi_status status = AE_OK;
         int result;
 
         if (!device)
                  return -EINVAL;
-        printk(EEEPC_NOTICE EEEPC_HOTK_NAME "\n");
+        pr_notice(EEEPC_HOTK_NAME "\n");
         ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
         if (!ehotk)
                 return -ENOMEM;
@@ -664,58 +857,9 @@ static int eeepc_hotk_add(struct acpi_device *device)
         result = eeepc_hotk_check();
         if (result)
                 goto ehotk_fail;
-        status = acpi_install_notify_handler(ehotk->handle, ACPI_SYSTEM_NOTIFY,
-                                             eeepc_hotk_notify, ehotk);
-        if (ACPI_FAILURE(status))
-                printk(EEEPC_ERR "Error installing notify handler\n");
-
-        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
-        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
-
-        if (get_acpi(CM_ASL_WLAN) != -1) {
-                ehotk->eeepc_wlan_rfkill = rfkill_alloc("eeepc-wlan",
-                                                        &device->dev,
-                                                        RFKILL_TYPE_WLAN,
-                                                        &eeepc_rfkill_ops,
-                                                        (void *)CM_ASL_WLAN);
-
-                if (!ehotk->eeepc_wlan_rfkill)
-                        goto wlan_fail;
-
-                rfkill_init_sw_state(ehotk->eeepc_wlan_rfkill,
-                                     get_acpi(CM_ASL_WLAN) != 1);
-                result = rfkill_register(ehotk->eeepc_wlan_rfkill);
-                if (result)
-                        goto wlan_fail;
-        }
-
-        if (get_acpi(CM_ASL_BLUETOOTH) != -1) {
-                ehotk->eeepc_bluetooth_rfkill =
-                        rfkill_alloc("eeepc-bluetooth",
-                                     &device->dev,
-                                     RFKILL_TYPE_BLUETOOTH,
-                                     &eeepc_rfkill_ops,
-                                     (void *)CM_ASL_BLUETOOTH);
-
-                if (!ehotk->eeepc_bluetooth_rfkill)
-                        goto bluetooth_fail;
-
-                rfkill_init_sw_state(ehotk->eeepc_bluetooth_rfkill,
-                                     get_acpi(CM_ASL_BLUETOOTH) != 1);
-                result = rfkill_register(ehotk->eeepc_bluetooth_rfkill);
-                if (result)
-                        goto bluetooth_fail;
-        }
 
         return 0;
 
- bluetooth_fail:
-        rfkill_destroy(ehotk->eeepc_bluetooth_rfkill);
-        rfkill_unregister(ehotk->eeepc_wlan_rfkill);
- wlan_fail:
-        rfkill_destroy(ehotk->eeepc_wlan_rfkill);
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
  ehotk_fail:
         kfree(ehotk);
         ehotk = NULL;
@@ -725,17 +869,8 @@ static int eeepc_hotk_add(struct acpi_device *device)
 
 static int eeepc_hotk_remove(struct acpi_device *device, int type)
 {
-        acpi_status status = 0;
-
         if (!device || !acpi_driver_data(device))
                  return -EINVAL;
-        status = acpi_remove_notify_handler(ehotk->handle, ACPI_SYSTEM_NOTIFY,
-                                            eeepc_hotk_notify);
-        if (ACPI_FAILURE(status))
-                printk(EEEPC_ERR "Error removing notify handler\n");
-
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
-        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
 
         kfree(ehotk);
         return 0;
@@ -743,7 +878,7 @@ static int eeepc_hotk_remove(struct acpi_device *device, int type)
 
 static int eeepc_hotk_resume(struct acpi_device *device)
 {
-        if (ehotk->eeepc_wlan_rfkill) {
+        if (ehotk->wlan_rfkill) {
                 bool wlan;
 
                 /* Workaround - it seems that _PTS disables the wireless
@@ -755,14 +890,13 @@ static int eeepc_hotk_resume(struct acpi_device *device)
                 wlan = get_acpi(CM_ASL_WLAN);
                 set_acpi(CM_ASL_WLAN, wlan);
 
-                rfkill_set_sw_state(ehotk->eeepc_wlan_rfkill,
-                                    wlan != 1);
+                rfkill_set_sw_state(ehotk->wlan_rfkill, wlan != 1);
 
                 eeepc_rfkill_hotplug();
         }
 
-        if (ehotk->eeepc_bluetooth_rfkill)
-                rfkill_set_sw_state(ehotk->eeepc_bluetooth_rfkill,
+        if (ehotk->bluetooth_rfkill)
+                rfkill_set_sw_state(ehotk->bluetooth_rfkill,
                                     get_acpi(CM_ASL_BLUETOOTH) != 1);
 
         return 0;
@@ -884,10 +1018,16 @@ static void eeepc_backlight_exit(void)
 
 static void eeepc_rfkill_exit(void)
 {
-        if (ehotk->eeepc_wlan_rfkill)
-                rfkill_unregister(ehotk->eeepc_wlan_rfkill);
-        if (ehotk->eeepc_bluetooth_rfkill)
-                rfkill_unregister(ehotk->eeepc_bluetooth_rfkill);
+        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
+        eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
+        if (ehotk->wlan_rfkill)
+                rfkill_unregister(ehotk->wlan_rfkill);
+        if (ehotk->bluetooth_rfkill)
+                rfkill_unregister(ehotk->bluetooth_rfkill);
+        if (ehotk->wwan3g_rfkill)
+                rfkill_unregister(ehotk->wwan3g_rfkill);
+        if (ehotk->hotplug_slot)
+                pci_hp_deregister(ehotk->hotplug_slot);
 }
 
 static void eeepc_input_exit(void)
@@ -922,6 +1062,75 @@ static void __exit eeepc_laptop_exit(void)
         platform_driver_unregister(&platform_driver);
 }
 
+static int eeepc_new_rfkill(struct rfkill **rfkill,
+                            const char *name, struct device *dev,
+                            enum rfkill_type type, int cm)
+{
+        int result;
+
+        result = get_acpi(cm);
+        if (result < 0)
+                return result;
+
+        *rfkill = rfkill_alloc(name, dev, type,
+                               &eeepc_rfkill_ops, (void *)(unsigned long)cm);
+
+        if (!*rfkill)
+                return -EINVAL;
+
+        rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1);
+        result = rfkill_register(*rfkill);
+        if (result) {
+                rfkill_destroy(*rfkill);
+                *rfkill = NULL;
+                return result;
+        }
+        return 0;
+}
+
+
+static int eeepc_rfkill_init(struct device *dev)
+{
+        int result = 0;
+
+        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
+        eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
+
+        result = eeepc_new_rfkill(&ehotk->wlan_rfkill,
+                                  "eeepc-wlan", dev,
+                                  RFKILL_TYPE_WLAN, CM_ASL_WLAN);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill,
+                                  "eeepc-bluetooth", dev,
+                                  RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill,
+                                  "eeepc-wwan3g", dev,
+                                  RFKILL_TYPE_WWAN, CM_ASL_3G);
+
+        if (result && result != -ENODEV)
+                goto exit;
+
+        result = eeepc_setup_pci_hotplug();
+        /*
+         * If we get -EBUSY then something else is handling the PCI hotplug -
+         * don't fail in this case
+         */
+        if (result == -EBUSY)
+                result = 0;
+
+exit:
+        if (result && result != -ENODEV)
+                eeepc_rfkill_exit();
+        return result;
+}
+
 static int eeepc_backlight_init(struct device *dev)
 {
         struct backlight_device *bd;
@@ -929,8 +1138,7 @@ static int eeepc_backlight_init(struct device *dev)
         bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
                                        NULL, &eeepcbl_ops);
         if (IS_ERR(bd)) {
-                printk(EEEPC_ERR
-                       "Could not register eeepc backlight device\n");
+                pr_err("Could not register eeepc backlight device\n");
                 eeepc_backlight_device = NULL;
                 return PTR_ERR(bd);
         }
@@ -949,8 +1157,7 @@ static int eeepc_hwmon_init(struct device *dev)
 
         hwmon = hwmon_device_register(dev);
         if (IS_ERR(hwmon)) {
-                printk(EEEPC_ERR
-                       "Could not register eeepc hwmon device\n");
+                pr_err("Could not register eeepc hwmon device\n");
                 eeepc_hwmon_device = NULL;
                 return PTR_ERR(hwmon);
         }
@@ -976,19 +1183,9 @@ static int __init eeepc_laptop_init(void)
                 acpi_bus_unregister_driver(&eeepc_hotk_driver);
                 return -ENODEV;
         }
-        dev = acpi_get_physical_device(ehotk->device->handle);
 
-        if (!acpi_video_backlight_support()) {
-                result = eeepc_backlight_init(dev);
-                if (result)
-                        goto fail_backlight;
-        } else
-                printk(EEEPC_INFO "Backlight controlled by ACPI video "
-                       "driver\n");
+        eeepc_enable_camera();
 
-        result = eeepc_hwmon_init(dev);
-        if (result)
-                goto fail_hwmon;
         /* Register platform stuff */
         result = platform_driver_register(&platform_driver);
         if (result)
@@ -1005,7 +1202,33 @@ static int __init eeepc_laptop_init(void)
                                     &platform_attribute_group);
         if (result)
                 goto fail_sysfs;
+
+        dev = &platform_device->dev;
+
+        if (!acpi_video_backlight_support()) {
+                result = eeepc_backlight_init(dev);
+                if (result)
+                        goto fail_backlight;
+        } else
+                pr_info("Backlight controlled by ACPI video "
+                        "driver\n");
+
+        result = eeepc_hwmon_init(dev);
+        if (result)
+                goto fail_hwmon;
+
+        result = eeepc_rfkill_init(dev);
+        if (result)
+                goto fail_rfkill;
+
         return 0;
+fail_rfkill:
+        eeepc_hwmon_exit();
+fail_hwmon:
+        eeepc_backlight_exit();
+fail_backlight:
+        sysfs_remove_group(&platform_device->dev.kobj,
+                           &platform_attribute_group);
 fail_sysfs:
         platform_device_del(platform_device);
 fail_platform_device2:
@@ -1013,12 +1236,7 @@ fail_platform_device2:
 fail_platform_device1:
         platform_driver_unregister(&platform_driver);
 fail_platform_driver:
-        eeepc_hwmon_exit();
-fail_hwmon:
-        eeepc_backlight_exit();
-fail_backlight:
         eeepc_input_exit();
-        eeepc_rfkill_exit();
         return result;
 }
 
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 16fffe44e333..4ac2311c00af 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -47,7 +47,7 @@ MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
 #define HPWMI_DISPLAY_QUERY 0x1
 #define HPWMI_HDDTEMP_QUERY 0x2
 #define HPWMI_ALS_QUERY 0x3
-#define HPWMI_DOCK_QUERY 0x4
+#define HPWMI_HARDWARE_QUERY 0x4
 #define HPWMI_WIRELESS_QUERY 0x5
 #define HPWMI_HOTKEY_QUERY 0xc
 
@@ -75,10 +75,9 @@ struct key_entry {
         u16 keycode;
 };
 
-enum { KE_KEY, KE_SW, KE_END };
+enum { KE_KEY, KE_END };
 
 static struct key_entry hp_wmi_keymap[] = {
-        {KE_SW, 0x01, SW_DOCK},
         {KE_KEY, 0x02, KEY_BRIGHTNESSUP},
         {KE_KEY, 0x03, KEY_BRIGHTNESSDOWN},
         {KE_KEY, 0x20e6, KEY_PROG1},
@@ -151,7 +150,22 @@ static int hp_wmi_als_state(void)
 
 static int hp_wmi_dock_state(void)
 {
-        return hp_wmi_perform_query(HPWMI_DOCK_QUERY, 0, 0);
+        int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, 0);
+
+        if (ret < 0)
+                return ret;
+
+        return ret & 0x1;
+}
+
+static int hp_wmi_tablet_state(void)
+{
+        int ret = hp_wmi_perform_query(HPWMI_HARDWARE_QUERY, 0, 0);
+
+        if (ret < 0)
+                return ret;
+
+        return (ret & 0x4) ? 1 : 0;
 }
 
 static int hp_wmi_set_block(void *data, bool blocked)
@@ -232,6 +246,15 @@ static ssize_t show_dock(struct device *dev, struct device_attribute *attr,
         return sprintf(buf, "%d\n", value);
 }
 
+static ssize_t show_tablet(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        int value = hp_wmi_tablet_state();
+        if (value < 0)
+                return -EINVAL;
+        return sprintf(buf, "%d\n", value);
+}
+
 static ssize_t set_als(struct device *dev, struct device_attribute *attr,
                        const char *buf, size_t count)
 {
@@ -244,6 +267,7 @@ static DEVICE_ATTR(display, S_IRUGO, show_display, NULL);
 static DEVICE_ATTR(hddtemp, S_IRUGO, show_hddtemp, NULL);
 static DEVICE_ATTR(als, S_IRUGO | S_IWUSR, show_als, set_als);
 static DEVICE_ATTR(dock, S_IRUGO, show_dock, NULL);
+static DEVICE_ATTR(tablet, S_IRUGO, show_tablet, NULL);
 
 static struct key_entry *hp_wmi_get_entry_by_scancode(int code)
 {
@@ -326,13 +350,13 @@ static void hp_wmi_notify(u32 value, void *context)
                                                  key->keycode, 0);
                                 input_sync(hp_wmi_input_dev);
                                 break;
-                        case KE_SW:
-                                input_report_switch(hp_wmi_input_dev,
-                                                    key->keycode,
-                                                    hp_wmi_dock_state());
-                                input_sync(hp_wmi_input_dev);
-                                break;
                         }
+                } else if (eventcode == 0x1) {
+                        input_report_switch(hp_wmi_input_dev, SW_DOCK,
+                                            hp_wmi_dock_state());
+                        input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
+                                            hp_wmi_tablet_state());
+                        input_sync(hp_wmi_input_dev);
                 } else if (eventcode == 0x5) {
                         if (wifi_rfkill)
                                 rfkill_set_sw_state(wifi_rfkill,
@@ -369,18 +393,19 @@ static int __init hp_wmi_input_setup(void)
                         set_bit(EV_KEY, hp_wmi_input_dev->evbit);
                         set_bit(key->keycode, hp_wmi_input_dev->keybit);
                         break;
-                case KE_SW:
-                        set_bit(EV_SW, hp_wmi_input_dev->evbit);
-                        set_bit(key->keycode, hp_wmi_input_dev->swbit);
-
-                        /* Set initial dock state */
-                        input_report_switch(hp_wmi_input_dev, key->keycode,
-                                            hp_wmi_dock_state());
-                        input_sync(hp_wmi_input_dev);
-                        break;
                 }
         }
 
+        set_bit(EV_SW, hp_wmi_input_dev->evbit);
+        set_bit(SW_DOCK, hp_wmi_input_dev->swbit);
+        set_bit(SW_TABLET_MODE, hp_wmi_input_dev->swbit);
+
+        /* Set initial hardware state */
+        input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_dock_state());
+        input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
+                            hp_wmi_tablet_state());
+        input_sync(hp_wmi_input_dev);
+
         err = input_register_device(hp_wmi_input_dev);
 
         if (err) {
@@ -397,6 +422,7 @@ static void cleanup_sysfs(struct platform_device *device)
         device_remove_file(&device->dev, &dev_attr_hddtemp);
         device_remove_file(&device->dev, &dev_attr_als);
         device_remove_file(&device->dev, &dev_attr_dock);
+        device_remove_file(&device->dev, &dev_attr_tablet);
 }
 
 static int __init hp_wmi_bios_setup(struct platform_device *device)
@@ -416,6 +442,9 @@ static int __init hp_wmi_bios_setup(struct platform_device *device)
         err = device_create_file(&device->dev, &dev_attr_dock);
         if (err)
                 goto add_sysfs_error;
+        err = device_create_file(&device->dev, &dev_attr_tablet);
+        if (err)
+                goto add_sysfs_error;
 
         if (wireless & 0x1) {
                 wifi_rfkill = rfkill_alloc("hp-wifi", &device->dev,
@@ -485,23 +514,17 @@ static int __exit hp_wmi_bios_remove(struct platform_device *device)
 
 static int hp_wmi_resume_handler(struct platform_device *device)
 {
-        struct key_entry *key;
-
         /*
-         * Docking state may have changed while suspended, so trigger
-         * an input event for the current state. As this is a switch,
+         * Hardware state may have changed while suspended, so trigger
+         * input events for the current state. As this is a switch,
          * the input layer will only actually pass it on if the state
          * changed.
          */
-        for (key = hp_wmi_keymap; key->type != KE_END; key++) {
-                switch (key->type) {
-                case KE_SW:
-                        input_report_switch(hp_wmi_input_dev, key->keycode,
-                                            hp_wmi_dock_state());
-                        input_sync(hp_wmi_input_dev);
-                        break;
-                }
-        }
+
+        input_report_switch(hp_wmi_input_dev, SW_DOCK, hp_wmi_dock_state());
+        input_report_switch(hp_wmi_input_dev, SW_TABLET_MODE,
+                            hp_wmi_tablet_state());
+        input_sync(hp_wmi_input_dev);
 
         return 0;
 }
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 40d64c03278c..a463fd72c495 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -22,7 +22,7 @@
  */
 
 #define TPACPI_VERSION "0.23"
-#define TPACPI_SYSFS_VERSION 0x020300
+#define TPACPI_SYSFS_VERSION 0x020400
 
 /*
  *  Changelog:
@@ -257,6 +257,8 @@ static struct {
         u32 wan:1;
         u32 uwb:1;
         u32 fan_ctrl_status_undef:1;
+        u32 second_fan:1;
+        u32 beep_needs_two_args:1;
         u32 input_device_registered:1;
         u32 platform_drv_registered:1;
         u32 platform_drv_attrs_registered:1;
@@ -277,8 +279,10 @@ struct thinkpad_id_data {
         char *bios_version_str; /* Something like 1ZET51WW (1.03z) */
         char *ec_version_str;   /* Something like 1ZHT51WW-1.04a */
 
-        u16 bios_model;         /* Big Endian, TP-1Y = 0x5931, 0 = unknown */
+        u16 bios_model;         /* 1Y = 0x5931, 0 = unknown */
         u16 ec_model;
+        u16 bios_release;       /* 1ZETK1WW = 0x314b, 0 = unknown */
+        u16 ec_release;
 
         char *model_str;        /* ThinkPad T43 */
         char *nummodel_str;     /* 9384A9C for a 9384-A9C model */
@@ -355,6 +359,73 @@ static void tpacpi_log_usertask(const char * const what)
                 } \
         } while (0)
 
+/*
+ * Quirk handling helpers
+ *
+ * ThinkPad IDs and versions seen in the field so far
+ * are two-characters from the set [0-9A-Z], i.e. base 36.
+ *
+ * We use values well outside that range as specials.
+ */
+
+#define TPACPI_MATCH_ANY                0xffffU
+#define TPACPI_MATCH_UNKNOWN            0U
+
+/* TPID('1', 'Y') == 0x5931 */
+#define TPID(__c1, __c2) (((__c2) << 8) | (__c1))
+
+#define TPACPI_Q_IBM(__id1, __id2, __quirk)     \
+        { .vendor = PCI_VENDOR_ID_IBM,          \
+          .bios = TPID(__id1, __id2),           \
+          .ec = TPACPI_MATCH_ANY,               \
+          .quirks = (__quirk) }
+
+#define TPACPI_Q_LNV(__id1, __id2, __quirk)     \
+        { .vendor = PCI_VENDOR_ID_LENOVO,       \
+          .bios = TPID(__id1, __id2),           \
+          .ec = TPACPI_MATCH_ANY,               \
+          .quirks = (__quirk) }
+
+struct tpacpi_quirk {
+        unsigned int vendor;
+        u16 bios;
+        u16 ec;
+        unsigned long quirks;
+};
+
+/**
+ * tpacpi_check_quirks() - search BIOS/EC version on a list
+ * @qlist:              array of &struct tpacpi_quirk
+ * @qlist_size:         number of elements in @qlist
+ *
+ * Iterates over a quirks list until one is found that matches the
+ * ThinkPad's vendor, BIOS and EC model.
+ *
+ * Returns 0 if nothing matches, otherwise returns the quirks field of
+ * the matching &struct tpacpi_quirk entry.
+ *
+ * The match criteria is: vendor, ec and bios much match.
+ */
+static unsigned long __init tpacpi_check_quirks(
+                        const struct tpacpi_quirk *qlist,
+                        unsigned int qlist_size)
+{
+        while (qlist_size) {
+                if ((qlist->vendor == thinkpad_id.vendor ||
+                                qlist->vendor == TPACPI_MATCH_ANY) &&
+                    (qlist->bios == thinkpad_id.bios_model ||
+                                qlist->bios == TPACPI_MATCH_ANY) &&
+                    (qlist->ec == thinkpad_id.ec_model ||
+                                qlist->ec == TPACPI_MATCH_ANY))
+                        return qlist->quirks;
+
+                qlist_size--;
+                qlist++;
+        }
+        return 0;
+}
+
+
 /****************************************************************************
  ****************************************************************************
  *
@@ -2880,7 +2951,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 /* update bright_acpimode... */
                 tpacpi_check_std_acpi_brightness_support();
 
-        if (tp_features.bright_acpimode) {
+        if (tp_features.bright_acpimode && acpi_video_backlight_support()) {
                 printk(TPACPI_INFO
                        "This ThinkPad has standard ACPI backlight "
                        "brightness control, supported by the ACPI "
@@ -4773,7 +4844,7 @@ TPACPI_HANDLE(led, ec, "SLED",	/* 570 */
            "LED",               /* all others */
            );                   /* R30, R31 */
 
-#define TPACPI_LED_NUMLEDS 8
+#define TPACPI_LED_NUMLEDS 16
 static struct tpacpi_led_classdev *tpacpi_leds;
 static enum led_status_t tpacpi_led_state_cache[TPACPI_LED_NUMLEDS];
 static const char * const tpacpi_led_names[TPACPI_LED_NUMLEDS] = {
@@ -4786,15 +4857,20 @@ static const char * const tpacpi_led_names[TPACPI_LED_NUMLEDS] = {
         "tpacpi::dock_batt",
         "tpacpi::unknown_led",
         "tpacpi::standby",
+        "tpacpi::dock_status1",
+        "tpacpi::dock_status2",
+        "tpacpi::unknown_led2",
+        "tpacpi::unknown_led3",
+        "tpacpi::thinkvantage",
 };
-#define TPACPI_SAFE_LEDS        0x0081U
+#define TPACPI_SAFE_LEDS        0x1081U
 
 static inline bool tpacpi_is_led_restricted(const unsigned int led)
 {
 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
         return false;
 #else
-        return (TPACPI_SAFE_LEDS & (1 << led)) == 0;
+        return (1U & (TPACPI_SAFE_LEDS >> led)) == 0;
 #endif
 }
 
@@ -4956,6 +5032,10 @@ static int __init tpacpi_init_led(unsigned int led)
 
         tpacpi_leds[led].led = led;
 
+        /* LEDs with no name don't get registered */
+        if (!tpacpi_led_names[led])
+                return 0;
+
         tpacpi_leds[led].led_classdev.brightness_set = &led_sysfs_set;
         tpacpi_leds[led].led_classdev.blink_set = &led_sysfs_blink_set;
         if (led_supported == TPACPI_LED_570)
@@ -4974,10 +5054,59 @@ static int __init tpacpi_init_led(unsigned int led)
         return rc;
 }
 
+static const struct tpacpi_quirk led_useful_qtable[] __initconst = {
+        TPACPI_Q_IBM('1', 'E', 0x009f), /* A30 */
+        TPACPI_Q_IBM('1', 'N', 0x009f), /* A31 */
+        TPACPI_Q_IBM('1', 'G', 0x009f), /* A31 */
+
+        TPACPI_Q_IBM('1', 'I', 0x0097), /* T30 */
+        TPACPI_Q_IBM('1', 'R', 0x0097), /* T40, T41, T42, R50, R51 */
+        TPACPI_Q_IBM('7', '0', 0x0097), /* T43, R52 */
+        TPACPI_Q_IBM('1', 'Y', 0x0097), /* T43 */
+        TPACPI_Q_IBM('1', 'W', 0x0097), /* R50e */
+        TPACPI_Q_IBM('1', 'V', 0x0097), /* R51 */
+        TPACPI_Q_IBM('7', '8', 0x0097), /* R51e */
+        TPACPI_Q_IBM('7', '6', 0x0097), /* R52 */
+
+        TPACPI_Q_IBM('1', 'K', 0x00bf), /* X30 */
+        TPACPI_Q_IBM('1', 'Q', 0x00bf), /* X31, X32 */
+        TPACPI_Q_IBM('1', 'U', 0x00bf), /* X40 */
+        TPACPI_Q_IBM('7', '4', 0x00bf), /* X41 */
+        TPACPI_Q_IBM('7', '5', 0x00bf), /* X41t */
+
+        TPACPI_Q_IBM('7', '9', 0x1f97), /* T60 (1) */
+        TPACPI_Q_IBM('7', '7', 0x1f97), /* Z60* (1) */
+        TPACPI_Q_IBM('7', 'F', 0x1f97), /* Z61* (1) */
+        TPACPI_Q_IBM('7', 'B', 0x1fb7), /* X60 (1) */
+
+        /* (1) - may have excess leds enabled on MSB */
+
+        /* Defaults (order matters, keep last, don't reorder!) */
+        { /* Lenovo */
+          .vendor = PCI_VENDOR_ID_LENOVO,
+          .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
+          .quirks = 0x1fffU,
+        },
+        { /* IBM ThinkPads with no EC version string */
+          .vendor = PCI_VENDOR_ID_IBM,
+          .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_UNKNOWN,
+          .quirks = 0x00ffU,
+        },
+        { /* IBM ThinkPads with EC version string */
+          .vendor = PCI_VENDOR_ID_IBM,
+          .bios = TPACPI_MATCH_ANY, .ec = TPACPI_MATCH_ANY,
+          .quirks = 0x00bfU,
+        },
+};
+
+#undef TPACPI_LEDQ_IBM
+#undef TPACPI_LEDQ_LNV
+
 static int __init led_init(struct ibm_init_struct *iibm)
 {
         unsigned int i;
         int rc;
+        unsigned long useful_leds;
 
         vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");
 
@@ -4999,6 +5128,9 @@ static int __init led_init(struct ibm_init_struct *iibm)
         vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
                 str_supported(led_supported), led_supported);
 
+        if (led_supported == TPACPI_LED_NONE)
+                return 1;
+
         tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS,
                               GFP_KERNEL);
         if (!tpacpi_leds) {
@@ -5006,8 +5138,12 @@ static int __init led_init(struct ibm_init_struct *iibm)
                 return -ENOMEM;
         }
 
+        useful_leds = tpacpi_check_quirks(led_useful_qtable,
+                                          ARRAY_SIZE(led_useful_qtable));
+
         for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
-                if (!tpacpi_is_led_restricted(i)) {
+                if (!tpacpi_is_led_restricted(i) &&
+                    test_bit(i, &useful_leds)) {
                         rc = tpacpi_init_led(i);
                         if (rc < 0) {
                                 led_exit();
@@ -5017,12 +5153,11 @@ static int __init led_init(struct ibm_init_struct *iibm)
         }
 
 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
-        if (led_supported != TPACPI_LED_NONE)
-                printk(TPACPI_NOTICE
-                        "warning: userspace override of important "
-                        "firmware LEDs is enabled\n");
+        printk(TPACPI_NOTICE
+                "warning: userspace override of important "
+                "firmware LEDs is enabled\n");
 #endif
-        return (led_supported != TPACPI_LED_NONE)? 0 : 1;
+        return 0;
 }
 
 #define str_led_status(s) \
@@ -5052,7 +5187,7 @@ static int led_read(char *p)
         }
 
         len += sprintf(p + len, "commands:\t"
-                       "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
+                       "<led> on, <led> off, <led> blink (<led> is 0-15)\n");
 
         return len;
 }
@@ -5067,7 +5202,7 @@ static int led_write(char *buf)
                 return -ENODEV;
 
         while ((cmd = next_cmd(&buf))) {
-                if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
+                if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 15)
                         return -EINVAL;
 
                 if (strstr(cmd, "off")) {
@@ -5101,8 +5236,17 @@ static struct ibm_struct led_driver_data = {
 
 TPACPI_HANDLE(beep, ec, "BEEP");        /* all except R30, R31 */
 
+#define TPACPI_BEEP_Q1 0x0001
+
+static const struct tpacpi_quirk beep_quirk_table[] __initconst = {
+        TPACPI_Q_IBM('I', 'M', TPACPI_BEEP_Q1), /* 570 */
+        TPACPI_Q_IBM('I', 'U', TPACPI_BEEP_Q1), /* 570E - unverified */
+};
+
 static int __init beep_init(struct ibm_init_struct *iibm)
 {
+        unsigned long quirks;
+
         vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");
 
         TPACPI_ACPIHANDLE_INIT(beep);
@@ -5110,6 +5254,11 @@ static int __init beep_init(struct ibm_init_struct *iibm)
         vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
                 str_supported(beep_handle != NULL));
 
+        quirks = tpacpi_check_quirks(beep_quirk_table,
+                                     ARRAY_SIZE(beep_quirk_table));
+
+        tp_features.beep_needs_two_args = !!(quirks & TPACPI_BEEP_Q1);
+
         return (beep_handle)? 0 : 1;
 }
 
@@ -5141,8 +5290,15 @@ static int beep_write(char *buf)
                         /* beep_cmd set */
                 } else
                         return -EINVAL;
-                if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", beep_cmd, 0))
-                        return -EIO;
+                if (tp_features.beep_needs_two_args) {
+                        if (!acpi_evalf(beep_handle, NULL, NULL, "vdd",
+                                        beep_cmd, 0))
+                                return -EIO;
+                } else {
+                        if (!acpi_evalf(beep_handle, NULL, NULL, "vd",
+                                        beep_cmd))
+                                return -EIO;
+                }
         }
 
         return 0;
@@ -5569,6 +5725,10 @@ static struct ibm_struct ecdump_driver_data = {
  *   Bit 3-0: backlight brightness level
  *
  * brightness_get_raw returns status data in the HBRV layout
+ *
+ * WARNING: The X61 has been verified to use HBRV for something else, so
+ * this should be used _only_ on IBM ThinkPads, and maybe with some careful
+ * testing on the very early *60 Lenovo models...
  */
 
 enum {
@@ -5869,6 +6029,12 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
                            brightness_mode);
         }
 
+        /* Safety */
+        if (thinkpad_id.vendor != PCI_VENDOR_ID_IBM &&
+            (brightness_mode == TPACPI_BRGHT_MODE_ECNVRAM ||
+             brightness_mode == TPACPI_BRGHT_MODE_EC))
+                return -EINVAL;
+
         if (tpacpi_brightness_get_raw(&b) < 0)
                 return 1;
 
@@ -6161,6 +6327,21 @@ static struct ibm_struct volume_driver_data = {
  *      For firmware bugs, refer to:
  *      http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
  *
+ *      ----
+ *
+ *      ThinkPad EC register 0x31 bit 0 (only on select models)
+ *
+ *      When bit 0 of EC register 0x31 is zero, the tachometer registers
+ *      show the speed of the main fan.  When bit 0 of EC register 0x31
+ *      is one, the tachometer registers show the speed of the auxiliary
+ *      fan.
+ *
+ *      Fan control seems to affect both fans, regardless of the state
+ *      of this bit.
+ *
+ *      So far, only the firmware for the X60/X61 non-tablet versions
+ *      seem to support this (firmware TP-7M).
+ *
  * TPACPI_FAN_WR_ACPI_FANS:
  *      ThinkPad X31, X40, X41.  Not available in the X60.
  *
@@ -6187,6 +6368,8 @@ enum {					/* Fan control constants */
         fan_status_offset = 0x2f,       /* EC register 0x2f */
         fan_rpm_offset = 0x84,          /* EC register 0x84: LSB, 0x85 MSB (RPM)
                                          * 0x84 must be read before 0x85 */
+        fan_select_offset = 0x31,       /* EC register 0x31 (Firmware 7M)
+                                           bit 0 selects which fan is active */
 
         TP_EC_FAN_FULLSPEED = 0x40,     /* EC fan mode: full speed */
         TP_EC_FAN_AUTO      = 0x80,     /* EC fan mode: auto fan control */
@@ -6249,30 +6432,18 @@ TPACPI_HANDLE(sfan, ec, "SFAN",	/* 570 */
  * We assume 0x07 really means auto mode while this quirk is active,
  * as this is far more likely than the ThinkPad being in level 7,
  * which is only used by the firmware during thermal emergencies.
+ *
+ * Enable for TP-1Y (T43), TP-78 (R51e), TP-76 (R52),
+ * TP-70 (T43, R52), which are known to be buggy.
  */
 
-static void fan_quirk1_detect(void)
+static void fan_quirk1_setup(void)
 {
-        /* In some ThinkPads, neither the EC nor the ACPI
-         * DSDT initialize the HFSP register, and it ends up
-         * being initially set to 0x07 when it *could* be
-         * either 0x07 or 0x80.
-         *
-         * Enable for TP-1Y (T43), TP-78 (R51e),
-         * TP-76 (R52), TP-70 (T43, R52), which are known
-         * to be buggy. */
         if (fan_control_initial_status == 0x07) {
-                switch (thinkpad_id.ec_model) {
-                case 0x5931: /* TP-1Y */
-                case 0x3837: /* TP-78 */
-                case 0x3637: /* TP-76 */
-                case 0x3037: /* TP-70 */
-                        printk(TPACPI_NOTICE
-                               "fan_init: initial fan status is unknown, "
-                               "assuming it is in auto mode\n");
-                        tp_features.fan_ctrl_status_undef = 1;
-                        ;;
-                }
+                printk(TPACPI_NOTICE
+                       "fan_init: initial fan status is unknown, "
+                       "assuming it is in auto mode\n");
+                tp_features.fan_ctrl_status_undef = 1;
         }
 }
 
@@ -6292,6 +6463,38 @@ static void fan_quirk1_handle(u8 *fan_status)
         }
 }
 
+/* Select main fan on X60/X61, NOOP on others */
+static bool fan_select_fan1(void)
+{
+        if (tp_features.second_fan) {
+                u8 val;
+
+                if (ec_read(fan_select_offset, &val) < 0)
+                        return false;
+                val &= 0xFEU;
+                if (ec_write(fan_select_offset, val) < 0)
+                        return false;
+        }
+        return true;
+}
+
+/* Select secondary fan on X60/X61 */
+static bool fan_select_fan2(void)
+{
+        u8 val;
+
+        if (!tp_features.second_fan)
+                return false;
+
+        if (ec_read(fan_select_offset, &val) < 0)
+                return false;
+        val |= 0x01U;
+        if (ec_write(fan_select_offset, val) < 0)
+                return false;
+
+        return true;
+}
+
 /*
  * Call with fan_mutex held
  */
@@ -6369,6 +6572,8 @@ static int fan_get_speed(unsigned int *speed)
         switch (fan_status_access_mode) {
         case TPACPI_FAN_RD_TPEC:
                 /* all except 570, 600e/x, 770e, 770x */
+                if (unlikely(!fan_select_fan1()))
+                        return -EIO;
                 if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
                              !acpi_ec_read(fan_rpm_offset + 1, &hi)))
                         return -EIO;
@@ -6385,6 +6590,34 @@ static int fan_get_speed(unsigned int *speed)
         return 0;
 }
 
+static int fan2_get_speed(unsigned int *speed)
+{
+        u8 hi, lo;
+        bool rc;
+
+        switch (fan_status_access_mode) {
+        case TPACPI_FAN_RD_TPEC:
+                /* all except 570, 600e/x, 770e, 770x */
+                if (unlikely(!fan_select_fan2()))
+                        return -EIO;
+                rc = !acpi_ec_read(fan_rpm_offset, &lo) ||
+                             !acpi_ec_read(fan_rpm_offset + 1, &hi);
+                fan_select_fan1(); /* play it safe */
+                if (rc)
+                        return -EIO;
+
+                if (likely(speed))
+                        *speed = (hi << 8) | lo;
+
+                break;
+
+        default:
+                return -ENXIO;
+        }
+
+        return 0;
+}
+
 static int fan_set_level(int level)
 {
         if (!fan_control_allowed)
@@ -6790,6 +7023,25 @@ static struct device_attribute dev_attr_fan_fan1_input =
         __ATTR(fan1_input, S_IRUGO,
                 fan_fan1_input_show, NULL);
 
+/* sysfs fan fan2_input ------------------------------------------------ */
+static ssize_t fan_fan2_input_show(struct device *dev,
+                           struct device_attribute *attr,
+                           char *buf)
+{
+        int res;
+        unsigned int speed;
+
+        res = fan2_get_speed(&speed);
+        if (res < 0)
+                return res;
+
+        return snprintf(buf, PAGE_SIZE, "%u\n", speed);
+}
+
+static struct device_attribute dev_attr_fan_fan2_input =
+        __ATTR(fan2_input, S_IRUGO,
+                fan_fan2_input_show, NULL);
+
 /* sysfs fan fan_watchdog (hwmon driver) ------------------------------- */
 static ssize_t fan_fan_watchdog_show(struct device_driver *drv,
                                      char *buf)
@@ -6823,6 +7075,7 @@ static DRIVER_ATTR(fan_watchdog, S_IWUSR | S_IRUGO,
 static struct attribute *fan_attributes[] = {
         &dev_attr_fan_pwm1_enable.attr, &dev_attr_fan_pwm1.attr,
         &dev_attr_fan_fan1_input.attr,
+        NULL, /* for fan2_input */
         NULL
 };
 
@@ -6830,9 +7083,36 @@ static const struct attribute_group fan_attr_group = {
         .attrs = fan_attributes,
 };
 
+#define TPACPI_FAN_Q1   0x0001          /* Unitialized HFSP */
+#define TPACPI_FAN_2FAN 0x0002          /* EC 0x31 bit 0 selects fan2 */
+
+#define TPACPI_FAN_QI(__id1, __id2, __quirks)   \
+        { .vendor = PCI_VENDOR_ID_IBM,          \
+          .bios = TPACPI_MATCH_ANY,             \
+          .ec = TPID(__id1, __id2),             \
+          .quirks = __quirks }
+
+#define TPACPI_FAN_QL(__id1, __id2, __quirks)   \
+        { .vendor = PCI_VENDOR_ID_LENOVO,       \
+          .bios = TPACPI_MATCH_ANY,             \
+          .ec = TPID(__id1, __id2),             \
+          .quirks = __quirks }
+
+static const struct tpacpi_quirk fan_quirk_table[] __initconst = {
+        TPACPI_FAN_QI('1', 'Y', TPACPI_FAN_Q1),
+        TPACPI_FAN_QI('7', '8', TPACPI_FAN_Q1),
+        TPACPI_FAN_QI('7', '6', TPACPI_FAN_Q1),
+        TPACPI_FAN_QI('7', '0', TPACPI_FAN_Q1),
+        TPACPI_FAN_QL('7', 'M', TPACPI_FAN_2FAN),
+};
+
+#undef TPACPI_FAN_QL
+#undef TPACPI_FAN_QI
+
 static int __init fan_init(struct ibm_init_struct *iibm)
 {
         int rc;
+        unsigned long quirks;
 
         vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
                         "initializing fan subdriver\n");
@@ -6843,12 +7123,16 @@ static int __init fan_init(struct ibm_init_struct *iibm)
         fan_control_commands = 0;
         fan_watchdog_maxinterval = 0;
         tp_features.fan_ctrl_status_undef = 0;
+        tp_features.second_fan = 0;
         fan_control_desired_level = 7;
 
         TPACPI_ACPIHANDLE_INIT(fans);
         TPACPI_ACPIHANDLE_INIT(gfan);
         TPACPI_ACPIHANDLE_INIT(sfan);
 
+        quirks = tpacpi_check_quirks(fan_quirk_table,
+                                     ARRAY_SIZE(fan_quirk_table));
+
         if (gfan_handle) {
                 /* 570, 600e/x, 770e, 770x */
                 fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN;
@@ -6858,7 +7142,13 @@ static int __init fan_init(struct ibm_init_struct *iibm)
                 if (likely(acpi_ec_read(fan_status_offset,
                                         &fan_control_initial_status))) {
                         fan_status_access_mode = TPACPI_FAN_RD_TPEC;
-                        fan_quirk1_detect();
+                        if (quirks & TPACPI_FAN_Q1)
+                                fan_quirk1_setup();
+                        if (quirks & TPACPI_FAN_2FAN) {
+                                tp_features.second_fan = 1;
+                                dbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_FAN,
+                                        "secondary fan support enabled\n");
+                        }
                 } else {
                         printk(TPACPI_ERR
                                "ThinkPad ACPI EC access misbehaving, "
@@ -6914,6 +7204,11 @@ static int __init fan_init(struct ibm_init_struct *iibm)
 
         if (fan_status_access_mode != TPACPI_FAN_NONE ||
             fan_control_access_mode != TPACPI_FAN_WR_NONE) {
+                if (tp_features.second_fan) {
+                        /* attach second fan tachometer */
+                        fan_attributes[ARRAY_SIZE(fan_attributes)-2] =
+                                        &dev_attr_fan_fan2_input.attr;
+                }
                 rc = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj,
                                          &fan_attr_group);
                 if (rc < 0)
@@ -7385,6 +7680,24 @@ err_out:
 
 /* Probing */
 
+static bool __pure __init tpacpi_is_fw_digit(const char c)
+{
+        return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z');
+}
+
+/* Most models: xxyTkkWW (#.##c); Ancient 570/600 and -SL lacks (#.##c) */
+static bool __pure __init tpacpi_is_valid_fw_id(const char* const s,
+                                                const char t)
+{
+        return s && strlen(s) >= 8 &&
+                tpacpi_is_fw_digit(s[0]) &&
+                tpacpi_is_fw_digit(s[1]) &&
+                s[2] == t && s[3] == 'T' &&
+                tpacpi_is_fw_digit(s[4]) &&
+                tpacpi_is_fw_digit(s[5]) &&
+                s[6] == 'W' && s[7] == 'W';
+}
+
 /* returns 0 - probe ok, or < 0 - probe error.
  * Probe ok doesn't mean thinkpad found.
  * On error, kfree() cleanup on tp->* is not performed, caller must do it */
@@ -7411,10 +7724,15 @@ static int __must_check __init get_thinkpad_model_data(
         tp->bios_version_str = kstrdup(s, GFP_KERNEL);
         if (s && !tp->bios_version_str)
                 return -ENOMEM;
-        if (!tp->bios_version_str)
+
+        /* Really ancient ThinkPad 240X will fail this, which is fine */
+        if (!tpacpi_is_valid_fw_id(tp->bios_version_str, 'E'))
                 return 0;
+
         tp->bios_model = tp->bios_version_str[0]
                          | (tp->bios_version_str[1] << 8);
+        tp->bios_release = (tp->bios_version_str[4] << 8)
+                         | tp->bios_version_str[5];
 
         /*
          * ThinkPad T23 or newer, A31 or newer, R50e or newer,
@@ -7433,8 +7751,21 @@ static int __must_check __init get_thinkpad_model_data(
                         tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL);
                         if (!tp->ec_version_str)
                                 return -ENOMEM;
-                        tp->ec_model = ec_fw_string[0]
-                                        | (ec_fw_string[1] << 8);
+
+                        if (tpacpi_is_valid_fw_id(ec_fw_string, 'H')) {
+                                tp->ec_model = ec_fw_string[0]
+                                                | (ec_fw_string[1] << 8);
+                                tp->ec_release = (ec_fw_string[4] << 8)
+                                                | ec_fw_string[5];
+                        } else {
+                                printk(TPACPI_NOTICE
+                                        "ThinkPad firmware release %s "
+                                        "doesn't match the known patterns\n",
+                                        ec_fw_string);
+                                printk(TPACPI_NOTICE
+                                        "please report this to %s\n",
+                                        TPACPI_MAIL);
+                        }
                         break;
                 }
         }
diff --git a/drivers/pnp/pnpacpi/rsparser.c b/drivers/pnp/pnpacpi/rsparser.c
index 7f207f335bec..ef3a2cd3a7a0 100644
--- a/drivers/pnp/pnpacpi/rsparser.c
+++ b/drivers/pnp/pnpacpi/rsparser.c
@@ -287,6 +287,25 @@ static void pnpacpi_parse_allocated_address_space(struct pnp_dev *dev,
                                 ACPI_DECODE_16);
 }
 
+static void pnpacpi_parse_allocated_ext_address_space(struct pnp_dev *dev,
+                                                      struct acpi_resource *res)
+{
+        struct acpi_resource_extended_address64 *p = &res->data.ext_address64;
+
+        if (p->producer_consumer == ACPI_PRODUCER)
+                return;
+
+        if (p->resource_type == ACPI_MEMORY_RANGE)
+                pnpacpi_parse_allocated_memresource(dev,
+                        p->minimum, p->address_length,
+                        p->info.mem.write_protect);
+        else if (p->resource_type == ACPI_IO_RANGE)
+                pnpacpi_parse_allocated_ioresource(dev,
+                        p->minimum, p->address_length,
+                        p->granularity == 0xfff ? ACPI_DECODE_10 :
+                                ACPI_DECODE_16);
+}
+
 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
                                               void *data)
 {
@@ -400,8 +419,7 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
                 break;
 
         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
-                if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
-                        return AE_OK;
+                pnpacpi_parse_allocated_ext_address_space(dev, res);
                 break;
 
         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
@@ -630,6 +648,28 @@ static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
                                            IORESOURCE_IO_FIXED);
 }
 
+static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
+                                                    unsigned int option_flags,
+                                                    struct acpi_resource *r)
+{
+        struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
+        unsigned char flags = 0;
+
+        if (p->address_length == 0)
+                return;
+
+        if (p->resource_type == ACPI_MEMORY_RANGE) {
+                if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
+                        flags = IORESOURCE_MEM_WRITEABLE;
+                pnp_register_mem_resource(dev, option_flags, p->minimum,
+                                          p->minimum, 0, p->address_length,
+                                          flags);
+        } else if (p->resource_type == ACPI_IO_RANGE)
+                pnp_register_port_resource(dev, option_flags, p->minimum,
+                                           p->minimum, 0, p->address_length,
+                                           IORESOURCE_IO_FIXED);
+}
+
 struct acpipnp_parse_option_s {
         struct pnp_dev *dev;
         unsigned int option_flags;
@@ -711,6 +751,7 @@ static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
                 break;
 
         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
+                pnpacpi_parse_ext_address_option(dev, option_flags, res);
                 break;
 
         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
@@ -765,6 +806,7 @@ static int pnpacpi_supported_resource(struct acpi_resource *res)
         case ACPI_RESOURCE_TYPE_ADDRESS16:
         case ACPI_RESOURCE_TYPE_ADDRESS32:
         case ACPI_RESOURCE_TYPE_ADDRESS64:
+        case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
                 return 1;
         }
diff --git a/drivers/power/Kconfig b/drivers/power/Kconfig
index 33da1127992a..7eda34838bfe 100644
--- a/drivers/power/Kconfig
+++ b/drivers/power/Kconfig
@@ -82,6 +82,14 @@ config BATTERY_DA9030
           Say Y here to enable support for batteries charger integrated into
           DA9030 PMIC.
 
+config BATTERY_MAX17040
+        tristate "Maxim MAX17040 Fuel Gauge"
+        depends on I2C
+        help
+          MAX17040 is fuel-gauge systems for lithium-ion (Li+) batteries
+          in handheld and portable equipment. The MAX17040 is configured
+          to operate with a single lithium cell
+
 config CHARGER_PCF50633
         tristate "NXP PCF50633 MBC"
         depends on MFD_PCF50633
diff --git a/drivers/power/Makefile b/drivers/power/Makefile
index 2fcf41d13e5c..daf3179689aa 100644
--- a/drivers/power/Makefile
+++ b/drivers/power/Makefile
@@ -25,4 +25,5 @@ obj-$(CONFIG_BATTERY_TOSA)	+= tosa_battery.o
 obj-$(CONFIG_BATTERY_WM97XX)    += wm97xx_battery.o
 obj-$(CONFIG_BATTERY_BQ27x00)   += bq27x00_battery.o
 obj-$(CONFIG_BATTERY_DA9030)    += da9030_battery.o
-obj-$(CONFIG_CHARGER_PCF50633)  += pcf50633-charger.o
\ No newline at end of file
+obj-$(CONFIG_BATTERY_MAX17040)  += max17040_battery.o
+obj-$(CONFIG_CHARGER_PCF50633)  += pcf50633-charger.o
diff --git a/drivers/power/da9030_battery.c b/drivers/power/da9030_battery.c
index 1662bb0f23a5..3364198134a1 100644
--- a/drivers/power/da9030_battery.c
+++ b/drivers/power/da9030_battery.c
@@ -22,8 +22,6 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 
-#define DA9030_STATUS_CHDET     (1 << 3)
-
 #define DA9030_FAULT_LOG                0x0a
 #define DA9030_FAULT_LOG_OVER_TEMP      (1 << 7)
 #define DA9030_FAULT_LOG_VBAT_OVER      (1 << 4)
@@ -244,6 +242,8 @@ static void da9030_set_charge(struct da9030_charger *charger, int on)
         }
 
         da903x_write(charger->master, DA9030_CHARGE_CONTROL, val);
+
+        power_supply_changed(&charger->psy);
 }
 
 static void da9030_charger_check_state(struct da9030_charger *charger)
@@ -258,6 +258,12 @@ static void da9030_charger_check_state(struct da9030_charger *charger)
                         da9030_set_charge(charger, 1);
                 }
         } else {
+                /* Charger has been pulled out */
+                if (!charger->chdet) {
+                        da9030_set_charge(charger, 0);
+                        return;
+                }
+
                 if (charger->adc.vbat_res >=
                     charger->thresholds.vbat_charge_stop) {
                         da9030_set_charge(charger, 0);
@@ -395,13 +401,11 @@ static int da9030_battery_event(struct notifier_block *nb, unsigned long event,
 {
         struct da9030_charger *charger =
                 container_of(nb, struct da9030_charger, nb);
-        int status;
 
         switch (event) {
         case DA9030_EVENT_CHDET:
-                status = da903x_query_status(charger->master,
-                                             DA9030_STATUS_CHDET);
-                da9030_set_charge(charger, status);
+                cancel_delayed_work_sync(&charger->work);
+                schedule_work(&charger->work.work);
                 break;
         case DA9030_EVENT_VBATMON:
                 da9030_battery_vbat_event(charger);
@@ -565,7 +569,8 @@ static int da9030_battery_remove(struct platform_device *dev)
         da903x_unregister_notifier(charger->master, &charger->nb,
                                    DA9030_EVENT_CHDET | DA9030_EVENT_VBATMON |
                                    DA9030_EVENT_CHIOVER | DA9030_EVENT_TBAT);
-        cancel_delayed_work(&charger->work);
+        cancel_delayed_work_sync(&charger->work);
+        da9030_set_charge(charger, 0);
         power_supply_unregister(&charger->psy);
 
         kfree(charger);
diff --git a/drivers/power/ds2760_battery.c b/drivers/power/ds2760_battery.c
index a52d4a11652d..520b5c49ff30 100644
--- a/drivers/power/ds2760_battery.c
+++ b/drivers/power/ds2760_battery.c
@@ -62,6 +62,10 @@ static unsigned int cache_time = 1000;
 module_param(cache_time, uint, 0644);
 MODULE_PARM_DESC(cache_time, "cache time in milliseconds");
 
+static unsigned int pmod_enabled;
+module_param(pmod_enabled, bool, 0644);
+MODULE_PARM_DESC(pmod_enabled, "PMOD enable bit");
+
 /* Some batteries have their rated capacity stored a N * 10 mAh, while
  * others use an index into this table. */
 static int rated_capacities[] = {
@@ -259,6 +263,17 @@ static void ds2760_battery_update_status(struct ds2760_device_info *di)
                 power_supply_changed(&di->bat);
 }
 
+static void ds2760_battery_write_status(struct ds2760_device_info *di,
+                                        char status)
+{
+        if (status == di->raw[DS2760_STATUS_REG])
+                return;
+
+        w1_ds2760_write(di->w1_dev, &status, DS2760_STATUS_WRITE_REG, 1);
+        w1_ds2760_store_eeprom(di->w1_dev, DS2760_EEPROM_BLOCK1);
+        w1_ds2760_recall_eeprom(di->w1_dev, DS2760_EEPROM_BLOCK1);
+}
+
 static void ds2760_battery_work(struct work_struct *work)
 {
         struct ds2760_device_info *di = container_of(work,
@@ -342,9 +357,9 @@ static enum power_supply_property ds2760_battery_props[] = {
 
 static int ds2760_battery_probe(struct platform_device *pdev)
 {
+        char status;
         int retval = 0;
         struct ds2760_device_info *di;
-        struct ds2760_platform_data *pdata;
 
         di = kzalloc(sizeof(*di), GFP_KERNEL);
         if (!di) {
@@ -354,14 +369,13 @@ static int ds2760_battery_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, di);
 
-        pdata = pdev->dev.platform_data;
-        di->dev         = &pdev->dev;
-        di->w1_dev           = pdev->dev.parent;
-        di->bat.name       = dev_name(&pdev->dev);
-        di->bat.type       = POWER_SUPPLY_TYPE_BATTERY;
-        di->bat.properties     = ds2760_battery_props;
-        di->bat.num_properties = ARRAY_SIZE(ds2760_battery_props);
-        di->bat.get_property   = ds2760_battery_get_property;
+        di->dev                 = &pdev->dev;
+        di->w1_dev              = pdev->dev.parent;
+        di->bat.name            = dev_name(&pdev->dev);
+        di->bat.type            = POWER_SUPPLY_TYPE_BATTERY;
+        di->bat.properties      = ds2760_battery_props;
+        di->bat.num_properties  = ARRAY_SIZE(ds2760_battery_props);
+        di->bat.get_property    = ds2760_battery_get_property;
         di->bat.external_power_changed =
                                   ds2760_battery_external_power_changed;
 
@@ -373,6 +387,16 @@ static int ds2760_battery_probe(struct platform_device *pdev)
                 goto batt_failed;
         }
 
+        /* enable sleep mode feature */
+        ds2760_battery_read_status(di);
+        status = di->raw[DS2760_STATUS_REG];
+        if (pmod_enabled)
+                status |= DS2760_STATUS_PMOD;
+        else
+                status &= ~DS2760_STATUS_PMOD;
+
+        ds2760_battery_write_status(di, status);
+
         INIT_DELAYED_WORK(&di->monitor_work, ds2760_battery_work);
         di->monitor_wqueue = create_singlethread_workqueue(dev_name(&pdev->dev));
         if (!di->monitor_wqueue) {
diff --git a/drivers/power/max17040_battery.c b/drivers/power/max17040_battery.c
new file mode 100644
index 000000000000..87b98bf27ae1
--- /dev/null
+++ b/drivers/power/max17040_battery.c
@@ -0,0 +1,309 @@
+/*
+ *  max17040_battery.c
+ *  fuel-gauge systems for lithium-ion (Li+) batteries
+ *
+ *  Copyright (C) 2009 Samsung Electronics
+ *  Minkyu Kang <mk7.kang@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/delay.h>
+#include <linux/power_supply.h>
+#include <linux/max17040_battery.h>
+
+#define MAX17040_VCELL_MSB      0x02
+#define MAX17040_VCELL_LSB      0x03
+#define MAX17040_SOC_MSB        0x04
+#define MAX17040_SOC_LSB        0x05
+#define MAX17040_MODE_MSB       0x06
+#define MAX17040_MODE_LSB       0x07
+#define MAX17040_VER_MSB        0x08
+#define MAX17040_VER_LSB        0x09
+#define MAX17040_RCOMP_MSB      0x0C
+#define MAX17040_RCOMP_LSB      0x0D
+#define MAX17040_CMD_MSB        0xFE
+#define MAX17040_CMD_LSB        0xFF
+
+#define MAX17040_DELAY          1000
+#define MAX17040_BATTERY_FULL   95
+
+struct max17040_chip {
+        struct i2c_client               *client;
+        struct delayed_work             work;
+        struct power_supply             battery;
+        struct max17040_platform_data   *pdata;
+
+        /* State Of Connect */
+        int online;
+        /* battery voltage */
+        int vcell;
+        /* battery capacity */
+        int soc;
+        /* State Of Charge */
+        int status;
+};
+
+static int max17040_get_property(struct power_supply *psy,
+                            enum power_supply_property psp,
+                            union power_supply_propval *val)
+{
+        struct max17040_chip *chip = container_of(psy,
+                                struct max17040_chip, battery);
+
+        switch (psp) {
+        case POWER_SUPPLY_PROP_STATUS:
+                val->intval = chip->status;
+                break;
+        case POWER_SUPPLY_PROP_ONLINE:
+                val->intval = chip->online;
+                break;
+        case POWER_SUPPLY_PROP_VOLTAGE_NOW:
+                val->intval = chip->vcell;
+                break;
+        case POWER_SUPPLY_PROP_CAPACITY:
+                val->intval = chip->soc;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+
+static int max17040_write_reg(struct i2c_client *client, int reg, u8 value)
+{
+        int ret;
+
+        ret = i2c_smbus_write_byte_data(client, reg, value);
+
+        if (ret < 0)
+                dev_err(&client->dev, "%s: err %d\n", __func__, ret);
+
+        return ret;
+}
+
+static int max17040_read_reg(struct i2c_client *client, int reg)
+{
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, reg);
+
+        if (ret < 0)
+                dev_err(&client->dev, "%s: err %d\n", __func__, ret);
+
+        return ret;
+}
+
+static void max17040_reset(struct i2c_client *client)
+{
+        max17040_write_reg(client, MAX17040_CMD_MSB, 0x54);
+        max17040_write_reg(client, MAX17040_CMD_LSB, 0x00);
+}
+
+static void max17040_get_vcell(struct i2c_client *client)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+        u8 msb;
+        u8 lsb;
+
+        msb = max17040_read_reg(client, MAX17040_VCELL_MSB);
+        lsb = max17040_read_reg(client, MAX17040_VCELL_LSB);
+
+        chip->vcell = (msb << 4) + (lsb >> 4);
+}
+
+static void max17040_get_soc(struct i2c_client *client)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+        u8 msb;
+        u8 lsb;
+
+        msb = max17040_read_reg(client, MAX17040_SOC_MSB);
+        lsb = max17040_read_reg(client, MAX17040_SOC_LSB);
+
+        chip->soc = msb;
+}
+
+static void max17040_get_version(struct i2c_client *client)
+{
+        u8 msb;
+        u8 lsb;
+
+        msb = max17040_read_reg(client, MAX17040_VER_MSB);
+        lsb = max17040_read_reg(client, MAX17040_VER_LSB);
+
+        dev_info(&client->dev, "MAX17040 Fuel-Gauge Ver %d%d\n", msb, lsb);
+}
+
+static void max17040_get_online(struct i2c_client *client)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+
+        if (chip->pdata->battery_online)
+                chip->online = chip->pdata->battery_online();
+        else
+                chip->online = 1;
+}
+
+static void max17040_get_status(struct i2c_client *client)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+
+        if (!chip->pdata->charger_online || !chip->pdata->charger_enable) {
+                chip->status = POWER_SUPPLY_STATUS_UNKNOWN;
+                return;
+        }
+
+        if (chip->pdata->charger_online()) {
+                if (chip->pdata->charger_enable())
+                        chip->status = POWER_SUPPLY_STATUS_CHARGING;
+                else
+                        chip->status = POWER_SUPPLY_STATUS_NOT_CHARGING;
+        } else {
+                chip->status = POWER_SUPPLY_STATUS_DISCHARGING;
+        }
+
+        if (chip->soc > MAX17040_BATTERY_FULL)
+                chip->status = POWER_SUPPLY_STATUS_FULL;
+}
+
+static void max17040_work(struct work_struct *work)
+{
+        struct max17040_chip *chip;
+
+        chip = container_of(work, struct max17040_chip, work.work);
+
+        max17040_get_vcell(chip->client);
+        max17040_get_soc(chip->client);
+        max17040_get_online(chip->client);
+        max17040_get_status(chip->client);
+
+        schedule_delayed_work(&chip->work, MAX17040_DELAY);
+}
+
+static enum power_supply_property max17040_battery_props[] = {
+        POWER_SUPPLY_PROP_STATUS,
+        POWER_SUPPLY_PROP_ONLINE,
+        POWER_SUPPLY_PROP_VOLTAGE_NOW,
+        POWER_SUPPLY_PROP_CAPACITY,
+};
+
+static int __devinit max17040_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+        struct max17040_chip *chip;
+        int ret;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
+                return -EIO;
+
+        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+        if (!chip)
+                return -ENOMEM;
+
+        chip->client = client;
+        chip->pdata = client->dev.platform_data;
+
+        i2c_set_clientdata(client, chip);
+
+        chip->battery.name              = "battery";
+        chip->battery.type              = POWER_SUPPLY_TYPE_BATTERY;
+        chip->battery.get_property      = max17040_get_property;
+        chip->battery.properties        = max17040_battery_props;
+        chip->battery.num_properties    = ARRAY_SIZE(max17040_battery_props);
+
+        ret = power_supply_register(&client->dev, &chip->battery);
+        if (ret) {
+                dev_err(&client->dev, "failed: power supply register\n");
+                i2c_set_clientdata(client, NULL);
+                kfree(chip);
+                return ret;
+        }
+
+        max17040_reset(client);
+        max17040_get_version(client);
+
+        INIT_DELAYED_WORK_DEFERRABLE(&chip->work, max17040_work);
+        schedule_delayed_work(&chip->work, MAX17040_DELAY);
+
+        return 0;
+}
+
+static int __devexit max17040_remove(struct i2c_client *client)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+
+        power_supply_unregister(&chip->battery);
+        cancel_delayed_work(&chip->work);
+        i2c_set_clientdata(client, NULL);
+        kfree(chip);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+static int max17040_suspend(struct i2c_client *client,
+                pm_message_t state)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+
+        cancel_delayed_work(&chip->work);
+        return 0;
+}
+
+static int max17040_resume(struct i2c_client *client)
+{
+        struct max17040_chip *chip = i2c_get_clientdata(client);
+
+        schedule_delayed_work(&chip->work, MAX17040_DELAY);
+        return 0;
+}
+
+#else
+
+#define max17040_suspend NULL
+#define max17040_resume NULL
+
+#endif /* CONFIG_PM */
+
+static const struct i2c_device_id max17040_id[] = {
+        { "max17040", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max17040_id);
+
+static struct i2c_driver max17040_i2c_driver = {
+        .driver = {
+                .name   = "max17040",
+        },
+        .probe          = max17040_probe,
+        .remove         = __devexit_p(max17040_remove),
+        .suspend        = max17040_suspend,
+        .resume         = max17040_resume,
+        .id_table       = max17040_id,
+};
+
+static int __init max17040_init(void)
+{
+        return i2c_add_driver(&max17040_i2c_driver);
+}
+module_init(max17040_init);
+
+static void __exit max17040_exit(void)
+{
+        i2c_del_driver(&max17040_i2c_driver);
+}
+module_exit(max17040_exit);
+
+MODULE_AUTHOR("Minkyu Kang <mk7.kang@samsung.com>");
+MODULE_DESCRIPTION("MAX17040 Fuel Gauge");
+MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/Kconfig b/drivers/scsi/Kconfig
index 6a19ed9a1194..9c23122f755f 100644
--- a/drivers/scsi/Kconfig
+++ b/drivers/scsi/Kconfig
@@ -258,10 +258,21 @@ config SCSI_SCAN_ASYNC
           or async on the kernel's command line.
 
 config SCSI_WAIT_SCAN
-        tristate
+        tristate  # No prompt here, this is an invisible symbol.
         default m
         depends on SCSI
         depends on MODULES
+# scsi_wait_scan is a loadable module which waits until all the async scans are
+# complete.  The idea is to use it in initrd/ initramfs scripts.  You modprobe
+# it after all the modprobes of the root SCSI drivers and it will wait until
+# they have all finished scanning their buses before allowing the boot to
+# proceed.  (This method is not applicable if targets boot independently in
+# parallel with the initiator, or with transports with non-deterministic target
+# discovery schemes, or if a transport driver does not support scsi_wait_scan.)
+#
+# This symbol is not exposed as a prompt because little is to be gained by
+# disabling it, whereas people who accidentally switch it off may wonder why
+# their mkinitrd gets into trouble.
 
 menu "SCSI Transports"
         depends on SCSI
diff --git a/drivers/scsi/bnx2i/Kconfig b/drivers/scsi/bnx2i/Kconfig
index b62b482e55e7..1e9f7141102b 100644
--- a/drivers/scsi/bnx2i/Kconfig
+++ b/drivers/scsi/bnx2i/Kconfig
@@ -1,6 +1,8 @@
 config SCSI_BNX2_ISCSI
         tristate "Broadcom NetXtreme II iSCSI support"
         select SCSI_ISCSI_ATTRS
+        select NETDEVICES
+        select NETDEV_1000
         select CNIC
         depends on PCI
         ---help---
diff --git a/drivers/scsi/cxgb3i/cxgb3i_ddp.c b/drivers/scsi/cxgb3i/cxgb3i_ddp.c
index 99c912547902..344fd53b9954 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_ddp.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_ddp.c
@@ -206,6 +206,31 @@ int cxgb3i_ddp_find_page_index(unsigned long pgsz)
         return DDP_PGIDX_MAX;
 }
 
+/**
+ * cxgb3i_ddp_adjust_page_table - adjust page table with PAGE_SIZE
+ * return the ddp page index, if no match is found return DDP_PGIDX_MAX.
+ */
+int cxgb3i_ddp_adjust_page_table(void)
+{
+        int i;
+        unsigned int base_order, order;
+
+        if (PAGE_SIZE < (1UL << ddp_page_shift[0])) {
+                ddp_log_info("PAGE_SIZE 0x%lx too small, min. 0x%lx.\n",
+                                PAGE_SIZE, 1UL << ddp_page_shift[0]);
+                return -EINVAL;
+        }
+
+        base_order = get_order(1UL << ddp_page_shift[0]);
+        order = get_order(1 << PAGE_SHIFT);
+        for (i = 0; i < DDP_PGIDX_MAX; i++) {
+                /* first is the kernel page size, then just doubling the size */
+                ddp_page_order[i] = order - base_order + i;
+                ddp_page_shift[i] = PAGE_SHIFT + i;
+        }
+        return 0;
+}
+
 static inline void ddp_gl_unmap(struct pci_dev *pdev,
                                 struct cxgb3i_gather_list *gl)
 {
@@ -598,30 +623,40 @@ int cxgb3i_adapter_ddp_info(struct t3cdev *tdev,
  * release all the resource held by the ddp pagepod manager for a given
  * adapter if needed
  */
-void cxgb3i_ddp_cleanup(struct t3cdev *tdev)
+
+static void ddp_cleanup(struct kref *kref)
 {
+        struct cxgb3i_ddp_info *ddp = container_of(kref,
+                                                struct cxgb3i_ddp_info,
+                                                refcnt);
         int i = 0;
+
+        ddp_log_info("kref release ddp 0x%p, t3dev 0x%p.\n", ddp, ddp->tdev);
+
+        ddp->tdev->ulp_iscsi = NULL;
+        while (i < ddp->nppods) {
+                struct cxgb3i_gather_list *gl = ddp->gl_map[i];
+                if (gl) {
+                        int npods = (gl->nelem + PPOD_PAGES_MAX - 1)
+                                        >> PPOD_PAGES_SHIFT;
+                        ddp_log_info("t3dev 0x%p, ddp %d + %d.\n",
+                                        ddp->tdev, i, npods);
+                        kfree(gl);
+                        ddp_free_gl_skb(ddp, i, npods);
+                        i += npods;
+                } else
+                        i++;
+        }
+        cxgb3i_free_big_mem(ddp);
+}
+
+void cxgb3i_ddp_cleanup(struct t3cdev *tdev)
+{
         struct cxgb3i_ddp_info *ddp = (struct cxgb3i_ddp_info *)tdev->ulp_iscsi;
 
         ddp_log_info("t3dev 0x%p, release ddp 0x%p.\n", tdev, ddp);
-
-        if (ddp) {
-                tdev->ulp_iscsi = NULL;
-                while (i < ddp->nppods) {
-                        struct cxgb3i_gather_list *gl = ddp->gl_map[i];
-                        if (gl) {
-                                int npods = (gl->nelem + PPOD_PAGES_MAX - 1)
-                                                >> PPOD_PAGES_SHIFT;
-                                ddp_log_info("t3dev 0x%p, ddp %d + %d.\n",
-                                                tdev, i, npods);
-                                kfree(gl);
-                                ddp_free_gl_skb(ddp, i, npods);
-                                i += npods;
-                        } else
-                                i++;
-                }
-                cxgb3i_free_big_mem(ddp);
-        }
+        if (ddp)
+                kref_put(&ddp->refcnt, ddp_cleanup);
 }
 
 /**
@@ -631,12 +666,13 @@ void cxgb3i_ddp_cleanup(struct t3cdev *tdev)
  */
 static void ddp_init(struct t3cdev *tdev)
 {
-        struct cxgb3i_ddp_info *ddp;
+        struct cxgb3i_ddp_info *ddp = tdev->ulp_iscsi;
         struct ulp_iscsi_info uinfo;
         unsigned int ppmax, bits;
         int i, err;
 
-        if (tdev->ulp_iscsi) {
+        if (ddp) {
+                kref_get(&ddp->refcnt);
                 ddp_log_warn("t3dev 0x%p, ddp 0x%p already set up.\n",
                                 tdev, tdev->ulp_iscsi);
                 return;
@@ -670,6 +706,7 @@ static void ddp_init(struct t3cdev *tdev)
                                           ppmax *
                                           sizeof(struct cxgb3i_gather_list *));
         spin_lock_init(&ddp->map_lock);
+        kref_init(&ddp->refcnt);
 
         ddp->tdev = tdev;
         ddp->pdev = uinfo.pdev;
@@ -715,6 +752,17 @@ void cxgb3i_ddp_init(struct t3cdev *tdev)
 {
         if (page_idx == DDP_PGIDX_MAX) {
                 page_idx = cxgb3i_ddp_find_page_index(PAGE_SIZE);
+
+                if (page_idx == DDP_PGIDX_MAX) {
+                        ddp_log_info("system PAGE_SIZE %lu, update hw.\n",
+                                        PAGE_SIZE);
+                        if (cxgb3i_ddp_adjust_page_table() < 0) {
+                                ddp_log_info("PAGE_SIZE %lu, ddp disabled.\n",
+                                                PAGE_SIZE);
+                                return;
+                        }
+                        page_idx = cxgb3i_ddp_find_page_index(PAGE_SIZE);
+                }
                 ddp_log_info("system PAGE_SIZE %lu, ddp idx %u.\n",
                                 PAGE_SIZE, page_idx);
         }
diff --git a/drivers/scsi/cxgb3i/cxgb3i_ddp.h b/drivers/scsi/cxgb3i/cxgb3i_ddp.h
index 0d296de7cf32..87dd56b422bf 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_ddp.h
+++ b/drivers/scsi/cxgb3i/cxgb3i_ddp.h
@@ -54,6 +54,7 @@ struct cxgb3i_gather_list {
  * struct cxgb3i_ddp_info - cxgb3i direct data placement for pdu payload
  *
  * @list:       list head to link elements
+ * @refcnt:     ref. count
  * @tdev:       pointer to t3cdev used by cxgb3 driver
  * @max_txsz:   max tx packet size for ddp
  * @max_rxsz:   max rx packet size for ddp
@@ -70,6 +71,7 @@ struct cxgb3i_gather_list {
  */
 struct cxgb3i_ddp_info {
         struct list_head list;
+        struct kref refcnt;
         struct t3cdev *tdev;
         struct pci_dev *pdev;
         unsigned int max_txsz;
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index c15878e88157..0a5609bb5817 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -45,8 +45,6 @@
 
 #include "fcoe.h"
 
-static int debug_fcoe;
-
 MODULE_AUTHOR("Open-FCoE.org");
 MODULE_DESCRIPTION("FCoE");
 MODULE_LICENSE("GPL v2");
@@ -305,23 +303,22 @@ static int fcoe_netdev_config(struct fc_lport *lp, struct net_device *netdev)
 #ifdef NETIF_F_FCOE_CRC
         if (netdev->features & NETIF_F_FCOE_CRC) {
                 lp->crc_offload = 1;
-                printk(KERN_DEBUG "fcoe:%s supports FCCRC offload\n",
-                       netdev->name);
+                FCOE_NETDEV_DBG(netdev, "Supports FCCRC offload\n");
         }
 #endif
 #ifdef NETIF_F_FSO
         if (netdev->features & NETIF_F_FSO) {
                 lp->seq_offload = 1;
                 lp->lso_max = netdev->gso_max_size;
-                printk(KERN_DEBUG "fcoe:%s supports LSO for max len 0x%x\n",
-                       netdev->name, lp->lso_max);
+                FCOE_NETDEV_DBG(netdev, "Supports LSO for max len 0x%x\n",
+                                lp->lso_max);
         }
 #endif
         if (netdev->fcoe_ddp_xid) {
                 lp->lro_enabled = 1;
                 lp->lro_xid = netdev->fcoe_ddp_xid;
-                printk(KERN_DEBUG "fcoe:%s supports LRO for max xid 0x%x\n",
-                       netdev->name, lp->lro_xid);
+                FCOE_NETDEV_DBG(netdev, "Supports LRO for max xid 0x%x\n",
+                                lp->lro_xid);
         }
         skb_queue_head_init(&fc->fcoe_pending_queue);
         fc->fcoe_pending_queue_active = 0;
@@ -407,7 +404,8 @@ static int fcoe_shost_config(struct fc_lport *lp, struct Scsi_Host *shost,
         /* add the new host to the SCSI-ml */
         rc = scsi_add_host(lp->host, dev);
         if (rc) {
-                FC_DBG("fcoe_shost_config:error on scsi_add_host\n");
+                FCOE_NETDEV_DBG(fcoe_netdev(lp), "fcoe_shost_config: "
+                                "error on scsi_add_host\n");
                 return rc;
         }
         sprintf(fc_host_symbolic_name(lp->host), "%s v%s over %s",
@@ -448,8 +446,7 @@ static int fcoe_if_destroy(struct net_device *netdev)
 
         BUG_ON(!netdev);
 
-        printk(KERN_DEBUG "fcoe_if_destroy:interface on %s\n",
-               netdev->name);
+        FCOE_NETDEV_DBG(netdev, "Destroying interface\n");
 
         lp = fcoe_hostlist_lookup(netdev);
         if (!lp)
@@ -560,8 +557,7 @@ static int fcoe_if_create(struct net_device *netdev)
 
         BUG_ON(!netdev);
 
-        printk(KERN_DEBUG "fcoe_if_create:interface on %s\n",
-               netdev->name);
+        FCOE_NETDEV_DBG(netdev, "Create Interface\n");
 
         lp = fcoe_hostlist_lookup(netdev);
         if (lp)
@@ -570,7 +566,7 @@ static int fcoe_if_create(struct net_device *netdev)
         shost = libfc_host_alloc(&fcoe_shost_template,
                                  sizeof(struct fcoe_softc));
         if (!shost) {
-                FC_DBG("Could not allocate host structure\n");
+                FCOE_NETDEV_DBG(netdev, "Could not allocate host structure\n");
                 return -ENOMEM;
         }
         lp = shost_priv(shost);
@@ -579,7 +575,8 @@ static int fcoe_if_create(struct net_device *netdev)
         /* configure fc_lport, e.g., em */
         rc = fcoe_lport_config(lp);
         if (rc) {
-                FC_DBG("Could not configure lport\n");
+                FCOE_NETDEV_DBG(netdev, "Could not configure lport for the "
+                                "interface\n");
                 goto out_host_put;
         }
 
@@ -593,28 +590,32 @@ static int fcoe_if_create(struct net_device *netdev)
         /* configure lport network properties */
         rc = fcoe_netdev_config(lp, netdev);
         if (rc) {
-                FC_DBG("Could not configure netdev for the interface\n");
+                FCOE_NETDEV_DBG(netdev, "Could not configure netdev for the "
+                                "interface\n");
                 goto out_netdev_cleanup;
         }
 
         /* configure lport scsi host properties */
         rc = fcoe_shost_config(lp, shost, &netdev->dev);
         if (rc) {
-                FC_DBG("Could not configure shost for lport\n");
+                FCOE_NETDEV_DBG(netdev, "Could not configure shost for the "
+                                "interface\n");
                 goto out_netdev_cleanup;
         }
 
         /* lport exch manager allocation */
         rc = fcoe_em_config(lp);
         if (rc) {
-                FC_DBG("Could not configure em for lport\n");
+                FCOE_NETDEV_DBG(netdev, "Could not configure the EM for the "
+                                "interface\n");
                 goto out_netdev_cleanup;
         }
 
         /* Initialize the library */
         rc = fcoe_libfc_config(lp, &fcoe_libfc_fcn_templ);
         if (rc) {
-                FC_DBG("Could not configure libfc for lport!\n");
+                FCOE_NETDEV_DBG(netdev, "Could not configure libfc for the "
+                                "interface\n");
                 goto out_lp_destroy;
         }
 
@@ -653,7 +654,7 @@ static int __init fcoe_if_init(void)
                 fc_attach_transport(&fcoe_transport_function);
 
         if (!scsi_transport_fcoe_sw) {
-                printk(KERN_ERR "fcoe_init:fc_attach_transport() failed\n");
+                printk(KERN_ERR "fcoe: Failed to attach to the FC transport\n");
                 return -ENODEV;
         }
 
@@ -714,7 +715,7 @@ static void fcoe_percpu_thread_destroy(unsigned int cpu)
         unsigned targ_cpu = smp_processor_id();
 #endif /* CONFIG_SMP */
 
-        printk(KERN_DEBUG "fcoe: Destroying receive thread for CPU %d\n", cpu);
+        FCOE_DBG("Destroying receive thread for CPU %d\n", cpu);
 
         /* Prevent any new skbs from being queued for this CPU. */
         p = &per_cpu(fcoe_percpu, cpu);
@@ -736,8 +737,8 @@ static void fcoe_percpu_thread_destroy(unsigned int cpu)
                 p0 = &per_cpu(fcoe_percpu, targ_cpu);
                 spin_lock_bh(&p0->fcoe_rx_list.lock);
                 if (p0->thread) {
-                        FC_DBG("Moving frames from CPU %d to CPU %d\n",
-                               cpu, targ_cpu);
+                        FCOE_DBG("Moving frames from CPU %d to CPU %d\n",
+                                 cpu, targ_cpu);
 
                         while ((skb = __skb_dequeue(&p->fcoe_rx_list)) != NULL)
                                 __skb_queue_tail(&p0->fcoe_rx_list, skb);
@@ -803,12 +804,12 @@ static int fcoe_cpu_callback(struct notifier_block *nfb,
         switch (action) {
         case CPU_ONLINE:
         case CPU_ONLINE_FROZEN:
-                FC_DBG("CPU %x online: Create Rx thread\n", cpu);
+                FCOE_DBG("CPU %x online: Create Rx thread\n", cpu);
                 fcoe_percpu_thread_create(cpu);
                 break;
         case CPU_DEAD:
         case CPU_DEAD_FROZEN:
-                FC_DBG("CPU %x offline: Remove Rx thread\n", cpu);
+                FCOE_DBG("CPU %x offline: Remove Rx thread\n", cpu);
                 fcoe_percpu_thread_destroy(cpu);
                 break;
         default:
@@ -846,24 +847,21 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
         fc = container_of(ptype, struct fcoe_softc, fcoe_packet_type);
         lp = fc->ctlr.lp;
         if (unlikely(lp == NULL)) {
-                FC_DBG("cannot find hba structure");
+                FCOE_NETDEV_DBG(dev, "Cannot find hba structure");
                 goto err2;
         }
         if (!lp->link_up)
                 goto err2;
 
-        if (unlikely(debug_fcoe)) {
-                FC_DBG("skb_info: len:%d data_len:%d head:%p data:%p tail:%p "
-                       "end:%p sum:%d dev:%s", skb->len, skb->data_len,
-                       skb->head, skb->data, skb_tail_pointer(skb),
-                       skb_end_pointer(skb), skb->csum,
-                       skb->dev ? skb->dev->name : "<NULL>");
-
-        }
+        FCOE_NETDEV_DBG(dev, "skb_info: len:%d data_len:%d head:%p "
+                        "data:%p tail:%p end:%p sum:%d dev:%s",
+                        skb->len, skb->data_len, skb->head, skb->data,
+                        skb_tail_pointer(skb), skb_end_pointer(skb),
+                        skb->csum, skb->dev ? skb->dev->name : "<NULL>");
 
         /* check for FCOE packet type */
         if (unlikely(eth_hdr(skb)->h_proto != htons(ETH_P_FCOE))) {
-                FC_DBG("wrong FC type frame");
+                FCOE_NETDEV_DBG(dev, "Wrong FC type frame");
                 goto err;
         }
 
@@ -901,8 +899,9 @@ int fcoe_rcv(struct sk_buff *skb, struct net_device *dev,
                  * the first CPU now. For non-SMP systems this
                  * will check the same CPU twice.
                  */
-                FC_DBG("CPU is online, but no receive thread ready "
-                       "for incoming skb- using first online CPU.\n");
+                FCOE_NETDEV_DBG(dev, "CPU is online, but no receive thread "
+                                "ready for incoming skb- using first online "
+                                "CPU.\n");
 
                 spin_unlock_bh(&fps->fcoe_rx_list.lock);
                 cpu = first_cpu(cpu_online_map);
@@ -1201,19 +1200,17 @@ int fcoe_percpu_receive_thread(void *arg)
                 fr = fcoe_dev_from_skb(skb);
                 lp = fr->fr_dev;
                 if (unlikely(lp == NULL)) {
-                        FC_DBG("invalid HBA Structure");
+                        FCOE_NETDEV_DBG(skb->dev, "Invalid HBA Structure");
                         kfree_skb(skb);
                         continue;
                 }
 
-                if (unlikely(debug_fcoe)) {
-                        FC_DBG("skb_info: len:%d data_len:%d head:%p data:%p "
-                               "tail:%p end:%p sum:%d dev:%s",
-                               skb->len, skb->data_len,
-                               skb->head, skb->data, skb_tail_pointer(skb),
-                               skb_end_pointer(skb), skb->csum,
-                               skb->dev ? skb->dev->name : "<NULL>");
-                }
+                FCOE_NETDEV_DBG(skb->dev, "skb_info: len:%d data_len:%d "
+                                "head:%p data:%p tail:%p end:%p sum:%d dev:%s",
+                                skb->len, skb->data_len,
+                                skb->head, skb->data, skb_tail_pointer(skb),
+                                skb_end_pointer(skb), skb->csum,
+                                skb->dev ? skb->dev->name : "<NULL>");
 
                 /*
                  * Save source MAC address before discarding header.
@@ -1233,7 +1230,7 @@ int fcoe_percpu_receive_thread(void *arg)
                 stats = fc_lport_get_stats(lp);
                 if (unlikely(FC_FCOE_DECAPS_VER(hp) != FC_FCOE_VER)) {
                         if (stats->ErrorFrames < 5)
-                                printk(KERN_WARNING "FCoE version "
+                                printk(KERN_WARNING "fcoe: FCoE version "
                                        "mismatch: The frame has "
                                        "version %x, but the "
                                        "initiator supports version "
@@ -1286,7 +1283,7 @@ int fcoe_percpu_receive_thread(void *arg)
                 if (fr_flags(fp) & FCPHF_CRC_UNCHECKED) {
                         if (le32_to_cpu(fr_crc(fp)) !=
                             ~crc32(~0, skb->data, fr_len)) {
-                                if (debug_fcoe || stats->InvalidCRCCount < 5)
+                                if (stats->InvalidCRCCount < 5)
                                         printk(KERN_WARNING "fcoe: dropping "
                                                "frame with CRC error\n");
                                 stats->InvalidCRCCount++;
@@ -1432,7 +1429,8 @@ static int fcoe_device_notification(struct notifier_block *notifier,
         case NETDEV_REGISTER:
                 break;
         default:
-                FC_DBG("Unknown event %ld from netdev netlink\n", event);
+                FCOE_NETDEV_DBG(real_dev, "Unknown event %ld "
+                                "from netdev netlink\n", event);
         }
         if (link_possible && !fcoe_link_ok(lp))
                 fcoe_ctlr_link_up(&fc->ctlr);
@@ -1505,8 +1503,8 @@ static int fcoe_ethdrv_get(const struct net_device *netdev)
 
         owner = fcoe_netdev_to_module_owner(netdev);
         if (owner) {
-                printk(KERN_DEBUG "fcoe:hold driver module %s for %s\n",
-                       module_name(owner), netdev->name);
+                FCOE_NETDEV_DBG(netdev, "Hold driver module %s\n",
+                                module_name(owner));
                 return  try_module_get(owner);
         }
         return -ENODEV;
@@ -1527,8 +1525,8 @@ static int fcoe_ethdrv_put(const struct net_device *netdev)
 
         owner = fcoe_netdev_to_module_owner(netdev);
         if (owner) {
-                printk(KERN_DEBUG "fcoe:release driver module %s for %s\n",
-                       module_name(owner), netdev->name);
+                FCOE_NETDEV_DBG(netdev, "Release driver module %s\n",
+                                module_name(owner));
                 module_put(owner);
                 return 0;
         }
@@ -1559,7 +1557,7 @@ static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
         }
         rc = fcoe_if_destroy(netdev);
         if (rc) {
-                printk(KERN_ERR "fcoe: fcoe_if_destroy(%s) failed\n",
+                printk(KERN_ERR "fcoe: Failed to destroy interface (%s)\n",
                        netdev->name);
                 rc = -EIO;
                 goto out_putdev;
@@ -1598,7 +1596,7 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
 
         rc = fcoe_if_create(netdev);
         if (rc) {
-                printk(KERN_ERR "fcoe: fcoe_if_create(%s) failed\n",
+                printk(KERN_ERR "fcoe: Failed to create interface (%s)\n",
                        netdev->name);
                 fcoe_ethdrv_put(netdev);
                 rc = -EIO;
diff --git a/drivers/scsi/fcoe/fcoe.h b/drivers/scsi/fcoe/fcoe.h
index a1eb8c1988b0..0d724fa0898f 100644
--- a/drivers/scsi/fcoe/fcoe.h
+++ b/drivers/scsi/fcoe/fcoe.h
@@ -40,6 +40,30 @@
 #define FCOE_MIN_XID            0x0001  /* the min xid supported by fcoe_sw */
 #define FCOE_MAX_XID            0x07ef  /* the max xid supported by fcoe_sw */
 
+unsigned int fcoe_debug_logging;
+module_param_named(debug_logging, fcoe_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
+
+#define FCOE_LOGGING        0x01 /* General logging, not categorized */
+#define FCOE_NETDEV_LOGGING 0x02 /* Netdevice logging */
+
+#define FCOE_CHECK_LOGGING(LEVEL, CMD)                                  \
+do {                                                                    \
+        if (unlikely(fcoe_debug_logging & LEVEL))                       \
+                do {                                                    \
+                        CMD;                                            \
+                } while (0);                                            \
+} while (0);
+
+#define FCOE_DBG(fmt, args...)                                          \
+        FCOE_CHECK_LOGGING(FCOE_LOGGING,                                \
+                           printk(KERN_INFO "fcoe: " fmt, ##args);)
+
+#define FCOE_NETDEV_DBG(netdev, fmt, args...)                   \
+        FCOE_CHECK_LOGGING(FCOE_NETDEV_LOGGING,                 \
+                           printk(KERN_INFO "fcoe: %s" fmt,     \
+                                  netdev->name, ##args);)
+
 /*
  * this percpu struct for fcoe
  */
diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index 2f5bc7fd3fa9..f544340d318b 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -56,15 +56,28 @@ static void fcoe_ctlr_recv_work(struct work_struct *);
 
 static u8 fcoe_all_fcfs[ETH_ALEN] = FIP_ALL_FCF_MACS;
 
-static u32 fcoe_ctlr_debug;     /* 1 for basic, 2 for noisy debug */
+unsigned int libfcoe_debug_logging;
+module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
 
-#define FIP_DBG_LVL(level, fmt, args...)                                \
+#define LIBFCOE_LOGGING     0x01 /* General logging, not categorized */
+#define LIBFCOE_FIP_LOGGING 0x02 /* FIP logging */
+
+#define LIBFCOE_CHECK_LOGGING(LEVEL, CMD)                               \
+do {                                                                    \
+        if (unlikely(libfcoe_debug_logging & LEVEL))                    \
                 do {                                                    \
-                        if (fcoe_ctlr_debug >= (level))                 \
-                                FC_DBG(fmt, ##args);                    \
-                } while (0)
+                        CMD;                                            \
+                } while (0);                                            \
+} while (0);
+
+#define LIBFCOE_DBG(fmt, args...)                                       \
+        LIBFCOE_CHECK_LOGGING(LIBFCOE_LOGGING,                          \
+                              printk(KERN_INFO "libfcoe: " fmt, ##args);)
 
-#define FIP_DBG(fmt, args...)   FIP_DBG_LVL(1, fmt, ##args)
+#define LIBFCOE_FIP_DBG(fmt, args...)                                   \
+        LIBFCOE_CHECK_LOGGING(LIBFCOE_FIP_LOGGING,                      \
+                              printk(KERN_INFO "fip: " fmt, ##args);)
 
 /*
  * Return non-zero if FCF fcoe_size has been validated.
@@ -243,7 +256,7 @@ void fcoe_ctlr_link_up(struct fcoe_ctlr *fip)
                 fip->last_link = 1;
                 fip->link = 1;
                 spin_unlock_bh(&fip->lock);
-                FIP_DBG("%s", "setting AUTO mode.\n");
+                LIBFCOE_FIP_DBG("%s", "setting AUTO mode.\n");
                 fc_linkup(fip->lp);
                 fcoe_ctlr_solicit(fip, NULL);
         } else
@@ -614,7 +627,8 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
                                ((struct fip_mac_desc *)desc)->fd_mac,
                                ETH_ALEN);
                         if (!is_valid_ether_addr(fcf->fcf_mac)) {
-                                FIP_DBG("invalid MAC addr in FIP adv\n");
+                                LIBFCOE_FIP_DBG("Invalid MAC address "
+                                                "in FIP adv\n");
                                 return -EINVAL;
                         }
                         break;
@@ -647,8 +661,8 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
                 case FIP_DT_LOGO:
                 case FIP_DT_ELP:
                 default:
-                        FIP_DBG("unexpected descriptor type %x in FIP adv\n",
-                                desc->fip_dtype);
+                        LIBFCOE_FIP_DBG("unexpected descriptor type %x "
+                                        "in FIP adv\n", desc->fip_dtype);
                         /* standard says ignore unknown descriptors >= 128 */
                         if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
                                 return -EINVAL;
@@ -664,8 +678,8 @@ static int fcoe_ctlr_parse_adv(struct sk_buff *skb, struct fcoe_fcf *fcf)
         return 0;
 
 len_err:
-        FIP_DBG("FIP length error in descriptor type %x len %zu\n",
-                desc->fip_dtype, dlen);
+        LIBFCOE_FIP_DBG("FIP length error in descriptor type %x len %zu\n",
+                        desc->fip_dtype, dlen);
         return -EINVAL;
 }
 
@@ -728,9 +742,10 @@ static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
         }
         mtu_valid = fcoe_ctlr_mtu_valid(fcf);
         fcf->time = jiffies;
-        FIP_DBG_LVL(found ? 2 : 1, "%s FCF for fab %llx map %x val %d\n",
-                    found ? "old" : "new",
-                    fcf->fabric_name, fcf->fc_map, mtu_valid);
+        if (!found) {
+                LIBFCOE_FIP_DBG("New FCF for fab %llx map %x val %d\n",
+                                fcf->fabric_name, fcf->fc_map, mtu_valid);
+        }
 
         /*
          * If this advertisement is not solicited and our max receive size
@@ -807,7 +822,8 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
                                ((struct fip_mac_desc *)desc)->fd_mac,
                                ETH_ALEN);
                         if (!is_valid_ether_addr(granted_mac)) {
-                                FIP_DBG("invalid MAC addrs in FIP ELS\n");
+                                LIBFCOE_FIP_DBG("Invalid MAC address "
+                                                "in FIP ELS\n");
                                 goto drop;
                         }
                         break;
@@ -825,8 +841,8 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
                         els_dtype = desc->fip_dtype;
                         break;
                 default:
-                        FIP_DBG("unexpected descriptor type %x "
-                                "in FIP adv\n", desc->fip_dtype);
+                        LIBFCOE_FIP_DBG("unexpected descriptor type %x "
+                                        "in FIP adv\n", desc->fip_dtype);
                         /* standard says ignore unknown descriptors >= 128 */
                         if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
                                 goto drop;
@@ -867,8 +883,8 @@ static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
         return;
 
 len_err:
-        FIP_DBG("FIP length error in descriptor type %x len %zu\n",
-                desc->fip_dtype, dlen);
+        LIBFCOE_FIP_DBG("FIP length error in descriptor type %x len %zu\n",
+                        desc->fip_dtype, dlen);
 drop:
         kfree_skb(skb);
 }
@@ -894,7 +910,7 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
         struct fc_lport *lp = fip->lp;
         u32     desc_mask;
 
-        FIP_DBG("Clear Virtual Link received\n");
+        LIBFCOE_FIP_DBG("Clear Virtual Link received\n");
         if (!fcf)
                 return;
         if (!fcf || !fc_host_port_id(lp->host))
@@ -952,9 +968,9 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
          * reset only if all required descriptors were present and valid.
          */
         if (desc_mask) {
-                FIP_DBG("missing descriptors mask %x\n", desc_mask);
+                LIBFCOE_FIP_DBG("missing descriptors mask %x\n", desc_mask);
         } else {
-                FIP_DBG("performing Clear Virtual Link\n");
+                LIBFCOE_FIP_DBG("performing Clear Virtual Link\n");
                 fcoe_ctlr_reset(fip, FIP_ST_ENABLED);
         }
 }
@@ -1002,10 +1018,6 @@ static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)
         op = ntohs(fiph->fip_op);
         sub = fiph->fip_subcode;
 
-        FIP_DBG_LVL(2, "ver %x op %x/%x dl %x fl %x\n",
-                    FIP_VER_DECAPS(fiph->fip_ver), op, sub,
-                    ntohs(fiph->fip_dl_len), ntohs(fiph->fip_flags));
-
         if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER)
                 goto drop;
         if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len)
@@ -1017,7 +1029,7 @@ static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)
                 fip->map_dest = 0;
                 fip->state = FIP_ST_ENABLED;
                 state = FIP_ST_ENABLED;
-                FIP_DBG("using FIP mode\n");
+                LIBFCOE_FIP_DBG("Using FIP mode\n");
         }
         spin_unlock_bh(&fip->lock);
         if (state != FIP_ST_ENABLED)
@@ -1052,14 +1064,15 @@ static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
         struct fcoe_fcf *best = NULL;
 
         list_for_each_entry(fcf, &fip->fcfs, list) {
-                FIP_DBG("consider FCF for fab %llx VFID %d map %x val %d\n",
-                        fcf->fabric_name, fcf->vfid,
-                        fcf->fc_map, fcoe_ctlr_mtu_valid(fcf));
+                LIBFCOE_FIP_DBG("consider FCF for fab %llx VFID %d map %x "
+                                "val %d\n", fcf->fabric_name, fcf->vfid,
+                                fcf->fc_map, fcoe_ctlr_mtu_valid(fcf));
                 if (!fcoe_ctlr_fcf_usable(fcf)) {
-                        FIP_DBG("FCF for fab %llx map %x %svalid %savailable\n",
-                                fcf->fabric_name, fcf->fc_map,
-                                (fcf->flags & FIP_FL_SOL) ? "" : "in",
-                                (fcf->flags & FIP_FL_AVAIL) ? "" : "un");
+                        LIBFCOE_FIP_DBG("FCF for fab %llx map %x %svalid "
+                                        "%savailable\n", fcf->fabric_name,
+                                        fcf->fc_map, (fcf->flags & FIP_FL_SOL)
+                                        ? "" : "in", (fcf->flags & FIP_FL_AVAIL)
+                                        ? "" : "un");
                         continue;
                 }
                 if (!best) {
@@ -1069,7 +1082,8 @@ static void fcoe_ctlr_select(struct fcoe_ctlr *fip)
                 if (fcf->fabric_name != best->fabric_name ||
                     fcf->vfid != best->vfid ||
                     fcf->fc_map != best->fc_map) {
-                        FIP_DBG("conflicting fabric, VFID, or FC-MAP\n");
+                        LIBFCOE_FIP_DBG("Conflicting fabric, VFID, "
+                                        "or FC-MAP\n");
                         return;
                 }
                 if (fcf->pri < best->pri)
@@ -1113,7 +1127,7 @@ static void fcoe_ctlr_timeout(unsigned long arg)
         if (sel != fcf) {
                 fcf = sel;              /* the old FCF may have been freed */
                 if (sel) {
-                        printk(KERN_INFO "host%d: FIP selected "
+                        printk(KERN_INFO "libfcoe: host%d: FIP selected "
                                "Fibre-Channel Forwarder MAC %s\n",
                                fip->lp->host->host_no,
                                print_mac(buf, sel->fcf_mac));
@@ -1123,7 +1137,7 @@ static void fcoe_ctlr_timeout(unsigned long arg)
                         fip->ctlr_ka_time = jiffies + sel->fka_period;
                         fip->link = 1;
                 } else {
-                        printk(KERN_NOTICE "host%d: "
+                        printk(KERN_NOTICE "libfcoe: host%d: "
                                "FIP Fibre-Channel Forwarder timed out.  "
                                "Starting FCF discovery.\n",
                                fip->lp->host->host_no);
@@ -1247,7 +1261,7 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
                         return -EINVAL;
                 }
                 fip->state = FIP_ST_NON_FIP;
-                FIP_DBG("received FLOGI LS_ACC using non-FIP mode\n");
+                LIBFCOE_FIP_DBG("received FLOGI LS_ACC using non-FIP mode\n");
 
                 /*
                  * FLOGI accepted.
@@ -1276,7 +1290,7 @@ int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_frame *fp, u8 *sa)
                         memcpy(fip->dest_addr, sa, ETH_ALEN);
                         fip->map_dest = 0;
                         if (fip->state == FIP_ST_NON_FIP)
-                                FIP_DBG("received FLOGI REQ, "
+                                LIBFCOE_FIP_DBG("received FLOGI REQ, "
                                                 "using non-FIP mode\n");
                         fip->state = FIP_ST_NON_FIP;
                 }
diff --git a/drivers/scsi/hosts.c b/drivers/scsi/hosts.c
index 89d41a424b33..5fd2da494d08 100644
--- a/drivers/scsi/hosts.c
+++ b/drivers/scsi/hosts.c
@@ -40,7 +40,7 @@
 #include "scsi_logging.h"
 
 
-static int scsi_host_next_hn;           /* host_no for next new host */
+static atomic_t scsi_host_next_hn;      /* host_no for next new host */
 
 
 static void scsi_host_cls_release(struct device *dev)
@@ -333,7 +333,11 @@ struct Scsi_Host *scsi_host_alloc(struct scsi_host_template *sht, int privsize)
 
         mutex_init(&shost->scan_mutex);
 
-        shost->host_no = scsi_host_next_hn++; /* XXX(hch): still racy */
+        /*
+         * subtract one because we increment first then return, but we need to
+         * know what the next host number was before increment
+         */
+        shost->host_no = atomic_inc_return(&scsi_host_next_hn) - 1;
         shost->dma_channel = 0xff;
 
         /* These three are default values which can be overridden */
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index b4b805e8d7db..166d96450a0e 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -2254,10 +2254,13 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
                                 continue;
                         if (crq->node_name && tgt->ids.node_name != crq->node_name)
                                 continue;
-                        ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
+                        if (tgt->need_login && crq->event == IBMVFC_AE_ELS_LOGO)
+                                tgt->logo_rcvd = 1;
+                        if (!tgt->need_login || crq->event == IBMVFC_AE_ELS_PLOGI) {
+                                ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
+                                ibmvfc_reinit_host(vhost);
+                        }
                 }
-
-                ibmvfc_reinit_host(vhost);
                 break;
         case IBMVFC_AE_LINK_DOWN:
         case IBMVFC_AE_ADAPTER_FAILED:
@@ -2783,27 +2786,27 @@ static void ibmvfc_tasklet(void *data)
 
         spin_lock_irqsave(vhost->host->host_lock, flags);
         while (!done) {
-                /* Pull all the valid messages off the CRQ */
-                while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
-                        ibmvfc_handle_crq(crq, vhost);
-                        crq->valid = 0;
-                }
-
                 /* Pull all the valid messages off the async CRQ */
                 while ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
                         ibmvfc_handle_async(async, vhost);
                         async->valid = 0;
                 }
 
-                vio_enable_interrupts(vdev);
-                if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
-                        vio_disable_interrupts(vdev);
+                /* Pull all the valid messages off the CRQ */
+                while ((crq = ibmvfc_next_crq(vhost)) != NULL) {
                         ibmvfc_handle_crq(crq, vhost);
                         crq->valid = 0;
-                } else if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
+                }
+
+                vio_enable_interrupts(vdev);
+                if ((async = ibmvfc_next_async_crq(vhost)) != NULL) {
                         vio_disable_interrupts(vdev);
                         ibmvfc_handle_async(async, vhost);
                         async->valid = 0;
+                } else if ((crq = ibmvfc_next_crq(vhost)) != NULL) {
+                        vio_disable_interrupts(vdev);
+                        ibmvfc_handle_crq(crq, vhost);
+                        crq->valid = 0;
                 } else
                         done = 1;
         }
@@ -2927,7 +2930,11 @@ static void ibmvfc_tgt_prli_done(struct ibmvfc_event *evt)
                 break;
         case IBMVFC_MAD_FAILED:
         default:
-                if (ibmvfc_retry_cmd(rsp->status, rsp->error))
+                if ((rsp->status & IBMVFC_VIOS_FAILURE) && rsp->error == IBMVFC_PLOGI_REQUIRED)
+                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
+                else if (tgt->logo_rcvd)
+                        level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_plogi);
+                else if (ibmvfc_retry_cmd(rsp->status, rsp->error))
                         level += ibmvfc_retry_tgt_init(tgt, ibmvfc_tgt_send_prli);
                 else
                         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_DEL_RPORT);
@@ -3054,6 +3061,7 @@ static void ibmvfc_tgt_send_plogi(struct ibmvfc_target *tgt)
                 return;
 
         kref_get(&tgt->kref);
+        tgt->logo_rcvd = 0;
         evt = ibmvfc_get_event(vhost);
         vhost->discovery_threads++;
         ibmvfc_set_tgt_action(tgt, IBMVFC_TGT_ACTION_INIT_WAIT);
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index c2668d7d67f5..007fa1c9ef14 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -605,6 +605,7 @@ struct ibmvfc_target {
         int need_login;
         int add_rport;
         int init_retries;
+        int logo_rcvd;
         u32 cancel_key;
         struct ibmvfc_service_parms service_parms;
         struct ibmvfc_service_parms service_parms_change;
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 0f8bc772b112..5f045505a1f4 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -131,13 +131,13 @@ static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
 };
 
 static const struct ipr_chip_t ipr_chip[] = {
-        { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, &ipr_chip_cfg[0] },
-        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, &ipr_chip_cfg[1] },
-        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, &ipr_chip_cfg[1] }
+        { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, IPR_USE_LSI, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, IPR_USE_LSI, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, IPR_USE_LSI, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, IPR_USE_LSI, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, IPR_USE_MSI, &ipr_chip_cfg[0] },
+        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, IPR_USE_LSI, &ipr_chip_cfg[1] },
+        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, IPR_USE_LSI, &ipr_chip_cfg[1] }
 };
 
 static int ipr_max_bus_speeds [] = {
@@ -7367,6 +7367,7 @@ static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
         INIT_LIST_HEAD(&ioa_cfg->used_res_q);
         INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
         init_waitqueue_head(&ioa_cfg->reset_wait_q);
+        init_waitqueue_head(&ioa_cfg->msi_wait_q);
         ioa_cfg->sdt_state = INACTIVE;
         if (ipr_enable_cache)
                 ioa_cfg->cache_state = CACHE_ENABLED;
@@ -7398,25 +7399,108 @@ static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
 }
 
 /**
- * ipr_get_chip_cfg - Find adapter chip configuration
+ * ipr_get_chip_info - Find adapter chip information
  * @dev_id:             PCI device id struct
  *
  * Return value:
- *      ptr to chip config on success / NULL on failure
+ *      ptr to chip information on success / NULL on failure
  **/
-static const struct ipr_chip_cfg_t * __devinit
-ipr_get_chip_cfg(const struct pci_device_id *dev_id)
+static const struct ipr_chip_t * __devinit
+ipr_get_chip_info(const struct pci_device_id *dev_id)
 {
         int i;
 
         for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
                 if (ipr_chip[i].vendor == dev_id->vendor &&
                     ipr_chip[i].device == dev_id->device)
-                        return ipr_chip[i].cfg;
+                        return &ipr_chip[i];
         return NULL;
 }
 
 /**
+ * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
+ * @pdev:               PCI device struct
+ *
+ * Description: Simply set the msi_received flag to 1 indicating that
+ * Message Signaled Interrupts are supported.
+ *
+ * Return value:
+ *      0 on success / non-zero on failure
+ **/
+static irqreturn_t __devinit ipr_test_intr(int irq, void *devp)
+{
+        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
+        unsigned long lock_flags = 0;
+        irqreturn_t rc = IRQ_HANDLED;
+
+        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+
+        ioa_cfg->msi_received = 1;
+        wake_up(&ioa_cfg->msi_wait_q);
+
+        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+        return rc;
+}
+
+/**
+ * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
+ * @pdev:               PCI device struct
+ *
+ * Description: The return value from pci_enable_msi() can not always be
+ * trusted.  This routine sets up and initiates a test interrupt to determine
+ * if the interrupt is received via the ipr_test_intr() service routine.
+ * If the tests fails, the driver will fall back to LSI.
+ *
+ * Return value:
+ *      0 on success / non-zero on failure
+ **/
+static int __devinit ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg,
+                                  struct pci_dev *pdev)
+{
+        int rc;
+        volatile u32 int_reg;
+        unsigned long lock_flags = 0;
+
+        ENTER;
+
+        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        init_waitqueue_head(&ioa_cfg->msi_wait_q);
+        ioa_cfg->msi_received = 0;
+        ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
+        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg);
+        int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
+        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+
+        rc = request_irq(pdev->irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
+        if (rc) {
+                dev_err(&pdev->dev, "Can not assign irq %d\n", pdev->irq);
+                return rc;
+        } else if (ipr_debug)
+                dev_info(&pdev->dev, "IRQ assigned: %d\n", pdev->irq);
+
+        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg);
+        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
+        wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
+        ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
+
+        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
+        if (!ioa_cfg->msi_received) {
+                /* MSI test failed */
+                dev_info(&pdev->dev, "MSI test failed.  Falling back to LSI.\n");
+                rc = -EOPNOTSUPP;
+        } else if (ipr_debug)
+                dev_info(&pdev->dev, "MSI test succeeded.\n");
+
+        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+
+        free_irq(pdev->irq, ioa_cfg);
+
+        LEAVE;
+
+        return rc;
+}
+
+/**
  * ipr_probe_ioa - Allocates memory and does first stage of initialization
  * @pdev:               PCI device struct
  * @dev_id:             PCI device id struct
@@ -7441,11 +7525,6 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
                 goto out;
         }
 
-        if (!(rc = pci_enable_msi(pdev)))
-                dev_info(&pdev->dev, "MSI enabled\n");
-        else if (ipr_debug)
-                dev_info(&pdev->dev, "Cannot enable MSI\n");
-
         dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
 
         host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
@@ -7461,14 +7540,16 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
         ata_host_init(&ioa_cfg->ata_host, &pdev->dev,
                       sata_port_info.flags, &ipr_sata_ops);
 
-        ioa_cfg->chip_cfg = ipr_get_chip_cfg(dev_id);
+        ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id);
 
-        if (!ioa_cfg->chip_cfg) {
+        if (!ioa_cfg->ipr_chip) {
                 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
                         dev_id->vendor, dev_id->device);
                 goto out_scsi_host_put;
         }
 
+        ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
+
         if (ipr_transop_timeout)
                 ioa_cfg->transop_timeout = ipr_transop_timeout;
         else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
@@ -7519,6 +7600,18 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
                 goto cleanup_nomem;
         }
 
+        /* Enable MSI style interrupts if they are supported. */
+        if (ioa_cfg->ipr_chip->intr_type == IPR_USE_MSI && !pci_enable_msi(pdev)) {
+                rc = ipr_test_msi(ioa_cfg, pdev);
+                if (rc == -EOPNOTSUPP)
+                        pci_disable_msi(pdev);
+                else if (rc)
+                        goto out_msi_disable;
+                else
+                        dev_info(&pdev->dev, "MSI enabled with IRQ: %d\n", pdev->irq);
+        } else if (ipr_debug)
+                dev_info(&pdev->dev, "Cannot enable MSI.\n");
+
         /* Save away PCI config space for use following IOA reset */
         rc = pci_save_state(pdev);
 
@@ -7556,7 +7649,9 @@ static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
                 ioa_cfg->ioa_unit_checked = 1;
 
         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
-        rc = request_irq(pdev->irq, ipr_isr, IRQF_SHARED, IPR_NAME, ioa_cfg);
+        rc = request_irq(pdev->irq, ipr_isr,
+                         ioa_cfg->msi_received ? 0 : IRQF_SHARED,
+                         IPR_NAME, ioa_cfg);
 
         if (rc) {
                 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
@@ -7583,12 +7678,13 @@ cleanup_nolog:
         ipr_free_mem(ioa_cfg);
 cleanup_nomem:
         iounmap(ipr_regs);
+out_msi_disable:
+        pci_disable_msi(pdev);
 out_release_regions:
         pci_release_regions(pdev);
 out_scsi_host_put:
         scsi_host_put(host);
 out_disable:
-        pci_disable_msi(pdev);
         pci_disable_device(pdev);
         goto out;
 }
diff --git a/drivers/scsi/ipr.h b/drivers/scsi/ipr.h
index 79a3ae4fb2c7..4b63dd6b1c81 100644
--- a/drivers/scsi/ipr.h
+++ b/drivers/scsi/ipr.h
@@ -37,8 +37,8 @@
 /*
  * Literals
  */
-#define IPR_DRIVER_VERSION "2.4.2"
-#define IPR_DRIVER_DATE "(January 21, 2009)"
+#define IPR_DRIVER_VERSION "2.4.3"
+#define IPR_DRIVER_DATE "(June 10, 2009)"
 
 /*
  * IPR_MAX_CMD_PER_LUN: This defines the maximum number of outstanding
@@ -1025,6 +1025,9 @@ struct ipr_chip_cfg_t {
 struct ipr_chip_t {
         u16 vendor;
         u16 device;
+        u16 intr_type;
+#define IPR_USE_LSI                     0x00
+#define IPR_USE_MSI                     0x01
         const struct ipr_chip_cfg_t *cfg;
 };
 
@@ -1094,6 +1097,7 @@ struct ipr_ioa_cfg {
         u8 needs_hard_reset:1;
         u8 dual_raid:1;
         u8 needs_warm_reset:1;
+        u8 msi_received:1;
 
         u8 revid;
 
@@ -1159,6 +1163,7 @@ struct ipr_ioa_cfg {
 
         unsigned int transop_timeout;
         const struct ipr_chip_cfg_t *chip_cfg;
+        const struct ipr_chip_t *ipr_chip;
 
         void __iomem *hdw_dma_regs;     /* iomapped PCI memory space */
         unsigned long hdw_dma_regs_pci; /* raw PCI memory space */
@@ -1179,6 +1184,7 @@ struct ipr_ioa_cfg {
         struct work_struct work_q;
 
         wait_queue_head_t reset_wait_q;
+        wait_queue_head_t msi_wait_q;
 
         struct ipr_dump *dump;
         enum ipr_sdt_state sdt_state;
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index b7c092d63bbe..518dbd91df85 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -253,8 +253,6 @@ static int iscsi_sw_tcp_xmit_segment(struct iscsi_tcp_conn *tcp_conn,
 
                 if (r < 0) {
                         iscsi_tcp_segment_unmap(segment);
-                        if (copied || r == -EAGAIN)
-                                break;
                         return r;
                 }
                 copied += r;
@@ -275,11 +273,17 @@ static int iscsi_sw_tcp_xmit(struct iscsi_conn *conn)
 
         while (1) {
                 rc = iscsi_sw_tcp_xmit_segment(tcp_conn, segment);
-                if (rc < 0) {
+                /*
+                 * We may not have been able to send data because the conn
+                 * is getting stopped. libiscsi will know so propogate err
+                 * for it to do the right thing.
+                 */
+                if (rc == -EAGAIN)
+                        return rc;
+                else if (rc < 0) {
                         rc = ISCSI_ERR_XMIT_FAILED;
                         goto error;
-                }
-                if (rc == 0)
+                } else if (rc == 0)
                         break;
 
                 consumed += rc;
diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
index 4c880656990b..6fabf66972b9 100644
--- a/drivers/scsi/libfc/fc_disc.c
+++ b/drivers/scsi/libfc/fc_disc.c
@@ -45,14 +45,6 @@
 
 #define FC_DISC_DELAY           3
 
-static int fc_disc_debug;
-
-#define FC_DEBUG_DISC(fmt...)                   \
-        do {                                    \
-                if (fc_disc_debug)              \
-                        FC_DBG(fmt);            \
-        } while (0)
-
 static void fc_disc_gpn_ft_req(struct fc_disc *);
 static void fc_disc_gpn_ft_resp(struct fc_seq *, struct fc_frame *, void *);
 static int fc_disc_new_target(struct fc_disc *, struct fc_rport *,
@@ -137,8 +129,8 @@ static void fc_disc_rport_callback(struct fc_lport *lport,
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
         struct fc_disc *disc = &lport->disc;
 
-        FC_DEBUG_DISC("Received a %d event for port (%6x)\n", event,
-                      rport->port_id);
+        FC_DISC_DBG(disc, "Received a %d event for port (%6x)\n", event,
+                    rport->port_id);
 
         switch (event) {
         case RPORT_EV_CREATED:
@@ -191,8 +183,7 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
 
         lport = disc->lport;
 
-        FC_DEBUG_DISC("Received an RSCN event on port (%6x)\n",
-                      fc_host_port_id(lport->host));
+        FC_DISC_DBG(disc, "Received an RSCN event\n");
 
         /* make sure the frame contains an RSCN message */
         rp = fc_frame_payload_get(fp, sizeof(*rp));
@@ -225,8 +216,8 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
                  */
                 switch (fmt) {
                 case ELS_ADDR_FMT_PORT:
-                        FC_DEBUG_DISC("Port address format for port (%6x)\n",
-                                      ntoh24(pp->rscn_fid));
+                        FC_DISC_DBG(disc, "Port address format for port "
+                                    "(%6x)\n", ntoh24(pp->rscn_fid));
                         dp = kzalloc(sizeof(*dp), GFP_KERNEL);
                         if (!dp) {
                                 redisc = 1;
@@ -243,19 +234,19 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
                 case ELS_ADDR_FMT_DOM:
                 case ELS_ADDR_FMT_FAB:
                 default:
-                        FC_DEBUG_DISC("Address format is (%d)\n", fmt);
+                        FC_DISC_DBG(disc, "Address format is (%d)\n", fmt);
                         redisc = 1;
                         break;
                 }
         }
         lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
         if (redisc) {
-                FC_DEBUG_DISC("RSCN received: rediscovering\n");
+                FC_DISC_DBG(disc, "RSCN received: rediscovering\n");
                 fc_disc_restart(disc);
         } else {
-                FC_DEBUG_DISC("RSCN received: not rediscovering. "
-                              "redisc %d state %d in_prog %d\n",
-                              redisc, lport->state, disc->pending);
+                FC_DISC_DBG(disc, "RSCN received: not rediscovering. "
+                            "redisc %d state %d in_prog %d\n",
+                            redisc, lport->state, disc->pending);
                 list_for_each_entry_safe(dp, next, &disc_ports, peers) {
                         list_del(&dp->peers);
                         rport = lport->tt.rport_lookup(lport, dp->ids.port_id);
@@ -270,7 +261,7 @@ static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp,
         fc_frame_free(fp);
         return;
 reject:
-        FC_DEBUG_DISC("Received a bad RSCN frame\n");
+        FC_DISC_DBG(disc, "Received a bad RSCN frame\n");
         rjt_data.fp = NULL;
         rjt_data.reason = ELS_RJT_LOGIC;
         rjt_data.explan = ELS_EXPL_NONE;
@@ -302,7 +293,8 @@ static void fc_disc_recv_req(struct fc_seq *sp, struct fc_frame *fp,
                 mutex_unlock(&disc->disc_mutex);
                 break;
         default:
-                FC_DBG("Received an unsupported request. opcode (%x)\n", op);
+                FC_DISC_DBG(disc, "Received an unsupported request, "
+                            "the opcode is (%x)\n", op);
                 break;
         }
 }
@@ -320,12 +312,10 @@ static void fc_disc_restart(struct fc_disc *disc)
         struct fc_rport_libfc_priv *rdata, *next;
         struct fc_lport *lport = disc->lport;
 
-        FC_DEBUG_DISC("Restarting discovery for port (%6x)\n",
-                      fc_host_port_id(lport->host));
+        FC_DISC_DBG(disc, "Restarting discovery\n");
 
         list_for_each_entry_safe(rdata, next, &disc->rports, peers) {
                 rport = PRIV_TO_RPORT(rdata);
-                FC_DEBUG_DISC("list_del(%6x)\n", rport->port_id);
                 list_del(&rdata->peers);
                 lport->tt.rport_logoff(rport);
         }
@@ -485,8 +475,7 @@ static void fc_disc_done(struct fc_disc *disc)
         struct fc_lport *lport = disc->lport;
         enum fc_disc_event event;
 
-        FC_DEBUG_DISC("Discovery complete for port (%6x)\n",
-                      fc_host_port_id(lport->host));
+        FC_DISC_DBG(disc, "Discovery complete\n");
 
         event = disc->event;
         disc->event = DISC_EV_NONE;
@@ -510,10 +499,10 @@ static void fc_disc_error(struct fc_disc *disc, struct fc_frame *fp)
 {
         struct fc_lport *lport = disc->lport;
         unsigned long delay = 0;
-        if (fc_disc_debug)
-                FC_DBG("Error %ld, retries %d/%d\n",
-                       PTR_ERR(fp), disc->retry_count,
-                       FC_DISC_RETRY_LIMIT);
+
+        FC_DISC_DBG(disc, "Error %ld, retries %d/%d\n",
+                    PTR_ERR(fp), disc->retry_count,
+                    FC_DISC_RETRY_LIMIT);
 
         if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) {
                 /*
@@ -649,9 +638,9 @@ static int fc_disc_gpn_ft_parse(struct fc_disc *disc, void *buf, size_t len)
                                               &disc->rogue_rports);
                                 lport->tt.rport_login(rport);
                         } else
-                                FC_DBG("Failed to allocate memory for "
-                                       "the newly discovered port (%6x)\n",
-                                       dp.ids.port_id);
+                                printk(KERN_WARNING "libfc: Failed to allocate "
+                                       "memory for the newly discovered port "
+                                       "(%6x)\n", dp.ids.port_id);
                 }
 
                 if (np->fp_flags & FC_NS_FID_LAST) {
@@ -671,9 +660,8 @@ static int fc_disc_gpn_ft_parse(struct fc_disc *disc, void *buf, size_t len)
          */
         if (error == 0 && len > 0 && len < sizeof(*np)) {
                 if (np != &disc->partial_buf) {
-                        FC_DEBUG_DISC("Partial buffer remains "
-                                      "for discovery by (%6x)\n",
-                                      fc_host_port_id(lport->host));
+                        FC_DISC_DBG(disc, "Partial buffer remains "
+                                    "for discovery\n");
                         memcpy(&disc->partial_buf, np, len);
                 }
                 disc->buf_len = (unsigned char) len;
@@ -721,8 +709,7 @@ static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
         int error;
 
         mutex_lock(&disc->disc_mutex);
-        FC_DEBUG_DISC("Received a GPN_FT response on port (%6x)\n",
-                      fc_host_port_id(disc->lport->host));
+        FC_DISC_DBG(disc, "Received a GPN_FT response\n");
 
         if (IS_ERR(fp)) {
                 fc_disc_error(disc, fp);
@@ -738,30 +725,30 @@ static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp,
             disc->seq_count == 0) {
                 cp = fc_frame_payload_get(fp, sizeof(*cp));
                 if (!cp) {
-                        FC_DBG("GPN_FT response too short, len %d\n",
-                               fr_len(fp));
+                        FC_DISC_DBG(disc, "GPN_FT response too short, len %d\n",
+                                    fr_len(fp));
                 } else if (ntohs(cp->ct_cmd) == FC_FS_ACC) {
 
                         /* Accepted, parse the response. */
                         buf = cp + 1;
                         len -= sizeof(*cp);
                 } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) {
-                        FC_DBG("GPN_FT rejected reason %x exp %x "
-                               "(check zoning)\n", cp->ct_reason,
-                               cp->ct_explan);
+                        FC_DISC_DBG(disc, "GPN_FT rejected reason %x exp %x "
+                                    "(check zoning)\n", cp->ct_reason,
+                                    cp->ct_explan);
                         disc->event = DISC_EV_FAILED;
                         fc_disc_done(disc);
                 } else {
-                        FC_DBG("GPN_FT unexpected response code %x\n",
-                               ntohs(cp->ct_cmd));
+                        FC_DISC_DBG(disc, "GPN_FT unexpected response code "
+                                    "%x\n", ntohs(cp->ct_cmd));
                 }
         } else if (fr_sof(fp) == FC_SOF_N3 &&
                    seq_cnt == disc->seq_count) {
                 buf = fh + 1;
         } else {
-                FC_DBG("GPN_FT unexpected frame - out of sequence? "
-                       "seq_cnt %x expected %x sof %x eof %x\n",
-                       seq_cnt, disc->seq_count, fr_sof(fp), fr_eof(fp));
+                FC_DISC_DBG(disc, "GPN_FT unexpected frame - out of sequence? "
+                            "seq_cnt %x expected %x sof %x eof %x\n",
+                            seq_cnt, disc->seq_count, fr_sof(fp), fr_eof(fp));
         }
         if (buf) {
                 error = fc_disc_gpn_ft_parse(disc, buf, len);
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 7af9bceb8aa9..2bc22be5f849 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -32,18 +32,7 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
-/*
- * fc_exch_debug can be set in debugger or at compile time to get more logs.
- */
-static int fc_exch_debug;
-
-#define FC_DEBUG_EXCH(fmt...)                   \
-        do {                                    \
-                if (fc_exch_debug)              \
-                        FC_DBG(fmt);            \
-        } while (0)
-
-static struct kmem_cache *fc_em_cachep; /* cache for exchanges */
+static struct kmem_cache *fc_em_cachep;        /* cache for exchanges */
 
 /*
  * Structure and function definitions for managing Fibre Channel Exchanges
@@ -333,8 +322,8 @@ static inline void fc_exch_timer_set_locked(struct fc_exch *ep,
         if (ep->state & (FC_EX_RST_CLEANUP | FC_EX_DONE))
                 return;
 
-        FC_DEBUG_EXCH("Exchange (%4x) timed out, notifying the upper layer\n",
-                      ep->xid);
+        FC_EXCH_DBG(ep, "Exchange timed out, notifying the upper layer\n");
+
         if (schedule_delayed_work(&ep->timeout_work,
                                   msecs_to_jiffies(timer_msec)))
                 fc_exch_hold(ep);               /* hold for timer */
@@ -545,7 +534,7 @@ struct fc_exch *fc_exch_alloc(struct fc_exch_mgr *mp,
                 /* alloc a new xid */
                 xid = fc_em_alloc_xid(mp, fp);
                 if (!xid) {
-                        printk(KERN_ERR "fc_em_alloc_xid() failed\n");
+                        printk(KERN_WARNING "libfc: Failed to allocate an exhange\n");
                         goto err;
                 }
         }
@@ -820,8 +809,8 @@ static struct fc_seq *fc_seq_start_next_locked(struct fc_seq *sp)
         struct fc_exch *ep = fc_seq_exch(sp);
 
         sp = fc_seq_alloc(ep, ep->seq_id++);
-        FC_DEBUG_EXCH("exch %4x f_ctl %6x seq %2x\n",
-                      ep->xid, ep->f_ctl, sp->id);
+        FC_EXCH_DBG(ep, "f_ctl %6x seq %2x\n",
+                    ep->f_ctl, sp->id);
         return sp;
 }
 /*
@@ -901,7 +890,7 @@ void fc_seq_els_rsp_send(struct fc_seq *sp, enum fc_els_cmd els_cmd,
                 fc_exch_els_rec(sp, els_data->fp);
                 break;
         default:
-                FC_DBG("Invalid ELS CMD:%x\n", els_cmd);
+                FC_EXCH_DBG(fc_seq_exch(sp), "Invalid ELS CMD:%x\n", els_cmd);
         }
 }
 EXPORT_SYMBOL(fc_seq_els_rsp_send);
@@ -1134,7 +1123,7 @@ static void fc_exch_recv_req(struct fc_lport *lp, struct fc_exch_mgr *mp,
                         lp->tt.lport_recv(lp, sp, fp);
                 fc_exch_release(ep);    /* release from lookup */
         } else {
-                FC_DEBUG_EXCH("exch/seq lookup failed: reject %x\n", reject);
+                FC_EM_DBG(mp, "exch/seq lookup failed: reject %x\n", reject);
                 fc_frame_free(fp);
         }
 }
@@ -1242,10 +1231,10 @@ static void fc_exch_recv_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
         sp = fc_seq_lookup_orig(mp, fp);        /* doesn't hold sequence */
         if (!sp) {
                 atomic_inc(&mp->stats.xid_not_found);
-                FC_DEBUG_EXCH("seq lookup failed\n");
+                FC_EM_DBG(mp, "seq lookup failed\n");
         } else {
                 atomic_inc(&mp->stats.non_bls_resp);
-                FC_DEBUG_EXCH("non-BLS response to sequence");
+                FC_EM_DBG(mp, "non-BLS response to sequence");
         }
         fc_frame_free(fp);
 }
@@ -1266,8 +1255,8 @@ static void fc_exch_abts_resp(struct fc_exch *ep, struct fc_frame *fp)
         int rc = 1, has_rec = 0;
 
         fh = fc_frame_header_get(fp);
-        FC_DEBUG_EXCH("exch: BLS rctl %x - %s\n",
-                      fh->fh_r_ctl, fc_exch_rctl_name(fh->fh_r_ctl));
+        FC_EXCH_DBG(ep, "exch: BLS rctl %x - %s\n", fh->fh_r_ctl,
+                    fc_exch_rctl_name(fh->fh_r_ctl));
 
         if (cancel_delayed_work_sync(&ep->timeout_work))
                 fc_exch_release(ep);    /* release from pending timer hold */
@@ -1359,9 +1348,9 @@ static void fc_exch_recv_bls(struct fc_exch_mgr *mp, struct fc_frame *fp)
                 case FC_RCTL_ACK_0:
                         break;
                 default:
-                        FC_DEBUG_EXCH("BLS rctl %x - %s received",
-                                      fh->fh_r_ctl,
-                                      fc_exch_rctl_name(fh->fh_r_ctl));
+                        FC_EXCH_DBG(ep, "BLS rctl %x - %s received",
+                                    fh->fh_r_ctl,
+                                    fc_exch_rctl_name(fh->fh_r_ctl));
                         break;
                 }
                 fc_frame_free(fp);
@@ -1599,7 +1588,8 @@ static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
 
                 if (err == -FC_EX_CLOSED || err == -FC_EX_TIMEOUT)
                         goto cleanup;
-                FC_DBG("Cannot process RRQ, because of frame error %d\n", err);
+                FC_EXCH_DBG(aborted_ep, "Cannot process RRQ, "
+                            "frame error %d\n", err);
                 return;
         }
 
@@ -1608,12 +1598,13 @@ static void fc_exch_rrq_resp(struct fc_seq *sp, struct fc_frame *fp, void *arg)
 
         switch (op) {
         case ELS_LS_RJT:
-                FC_DBG("LS_RJT for RRQ");
+                FC_EXCH_DBG(aborted_ep, "LS_RJT for RRQ");
                 /* fall through */
         case ELS_LS_ACC:
                 goto cleanup;
         default:
-                FC_DBG("unexpected response op %x for RRQ", op);
+                FC_EXCH_DBG(aborted_ep, "unexpected response op %x "
+                            "for RRQ", op);
                 return;
         }
 
@@ -1740,8 +1731,8 @@ struct fc_exch_mgr *fc_exch_mgr_alloc(struct fc_lport *lp,
         size_t len;
 
         if (max_xid <= min_xid || min_xid == 0 || max_xid == FC_XID_UNKNOWN) {
-                FC_DBG("Invalid min_xid 0x:%x and max_xid 0x:%x\n",
-                       min_xid, max_xid);
+                FC_LPORT_DBG(lp, "Invalid min_xid 0x:%x and max_xid 0x:%x\n",
+                             min_xid, max_xid);
                 return NULL;
         }
 
@@ -1878,7 +1869,8 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
 
         /* lport lock ? */
         if (!lp || !mp || (lp->state == LPORT_ST_NONE)) {
-                FC_DBG("fc_lport or EM is not allocated and configured");
+                FC_LPORT_DBG(lp, "Receiving frames for an lport that "
+                             "has not been initialized correctly\n");
                 fc_frame_free(fp);
                 return;
         }
@@ -1904,7 +1896,7 @@ void fc_exch_recv(struct fc_lport *lp, struct fc_exch_mgr *mp,
                         fc_exch_recv_req(lp, mp, fp);
                 break;
         default:
-                FC_DBG("dropping invalid frame (eof %x)", fr_eof(fp));
+                FC_EM_DBG(mp, "dropping invalid frame (eof %x)", fr_eof(fp));
                 fc_frame_free(fp);
                 break;
         }
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index ad8b747837b0..e303e0d12c4b 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -43,13 +43,9 @@ MODULE_AUTHOR("Open-FCoE.org");
 MODULE_DESCRIPTION("libfc");
 MODULE_LICENSE("GPL v2");
 
-static int fc_fcp_debug;
-
-#define FC_DEBUG_FCP(fmt...)                    \
-        do {                                    \
-                if (fc_fcp_debug)               \
-                        FC_DBG(fmt);            \
-        } while (0)
+unsigned int fc_debug_logging;
+module_param_named(debug_logging, fc_debug_logging, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
 
 static struct kmem_cache *scsi_pkt_cachep;
 
@@ -347,8 +343,8 @@ static void fc_fcp_recv_data(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                 if ((fr_flags(fp) & FCPHF_CRC_UNCHECKED) &&
                     fc_frame_crc_check(fp))
                         goto crc_err;
-                FC_DEBUG_FCP("data received past end. len %zx offset %zx "
-                             "data_len %x\n", len, offset, fsp->data_len);
+                FC_FCP_DBG(fsp, "data received past end. len %zx offset %zx "
+                           "data_len %x\n", len, offset, fsp->data_len);
                 fc_fcp_retry_cmd(fsp);
                 return;
         }
@@ -411,7 +407,8 @@ crc_err:
                         stats->ErrorFrames++;
                         /* FIXME - per cpu count, not total count! */
                         if (stats->InvalidCRCCount++ < 5)
-                                printk(KERN_WARNING "CRC error on data frame for port (%6x)\n",
+                                printk(KERN_WARNING "libfc: CRC error on data "
+                                       "frame for port (%6x)\n",
                                        fc_host_port_id(lp->host));
                         /*
                          * Assume the frame is total garbage.
@@ -475,14 +472,14 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         WARN_ON(seq_blen <= 0);
         if (unlikely(offset + seq_blen > fsp->data_len)) {
                 /* this should never happen */
-                FC_DEBUG_FCP("xfer-ready past end. seq_blen %zx offset %zx\n",
-                             seq_blen, offset);
+                FC_FCP_DBG(fsp, "xfer-ready past end. seq_blen %zx "
+                           "offset %zx\n", seq_blen, offset);
                 fc_fcp_send_abort(fsp);
                 return 0;
         } else if (offset != fsp->xfer_len) {
                 /* Out of Order Data Request - no problem, but unexpected. */
-                FC_DEBUG_FCP("xfer-ready non-contiguous. "
-                             "seq_blen %zx offset %zx\n", seq_blen, offset);
+                FC_FCP_DBG(fsp, "xfer-ready non-contiguous. "
+                           "seq_blen %zx offset %zx\n", seq_blen, offset);
         }
 
         /*
@@ -493,7 +490,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
         t_blen = fsp->max_payload;
         if (lp->seq_offload) {
                 t_blen = min(seq_blen, (size_t)lp->lso_max);
-                FC_DEBUG_FCP("fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
+                FC_FCP_DBG(fsp, "fsp=%p:lso:blen=%zx lso_max=0x%x t_blen=%zx\n",
                            fsp, seq_blen, lp->lso_max, t_blen);
         }
 
@@ -694,7 +691,7 @@ static void fc_fcp_reduce_can_queue(struct fc_lport *lp)
         if (!can_queue)
                 can_queue = 1;
         lp->host->can_queue = can_queue;
-        shost_printk(KERN_ERR, lp->host, "Could not allocate frame.\n"
+        shost_printk(KERN_ERR, lp->host, "libfc: Could not allocate frame.\n"
                      "Reducing can_queue to %d.\n", can_queue);
 done:
         spin_unlock_irqrestore(lp->host->host_lock, flags);
@@ -768,7 +765,7 @@ static void fc_fcp_recv(struct fc_seq *seq, struct fc_frame *fp, void *arg)
 
                 fc_fcp_resp(fsp, fp);
         } else {
-                FC_DBG("unexpected frame.  r_ctl %x\n", r_ctl);
+                FC_FCP_DBG(fsp, "unexpected frame.  r_ctl %x\n", r_ctl);
         }
 unlock:
         fc_fcp_unlock_pkt(fsp);
@@ -877,17 +874,17 @@ static void fc_fcp_resp(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                         return;
                 }
                 fsp->status_code = FC_DATA_OVRRUN;
-                FC_DBG("tgt %6x xfer len %zx greater than expected len %x. "
-                       "data len %x\n",
-                       fsp->rport->port_id,
-                       fsp->xfer_len, expected_len, fsp->data_len);
+                FC_FCP_DBG(fsp, "tgt %6x xfer len %zx greater than expected, "
+                           "len %x, data len %x\n",
+                           fsp->rport->port_id,
+                           fsp->xfer_len, expected_len, fsp->data_len);
         }
         fc_fcp_complete_locked(fsp);
         return;
 
 len_err:
-        FC_DBG("short FCP response. flags 0x%x len %u respl %u snsl %u\n",
-               flags, fr_len(fp), respl, snsl);
+        FC_FCP_DBG(fsp, "short FCP response. flags 0x%x len %u respl %u "
+                   "snsl %u\n", flags, fr_len(fp), respl, snsl);
 err:
         fsp->status_code = FC_ERROR;
         fc_fcp_complete_locked(fsp);
@@ -1107,13 +1104,11 @@ static void fc_fcp_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         if (fc_fcp_lock_pkt(fsp))
                 return;
 
-        switch (error) {
-        case -FC_EX_CLOSED:
+        if (error == -FC_EX_CLOSED) {
                 fc_fcp_retry_cmd(fsp);
                 goto unlock;
-        default:
-                FC_DBG("unknown error %ld\n", PTR_ERR(fp));
         }
+
         /*
          * clear abort pending, because the lower layer
          * decided to force completion.
@@ -1145,10 +1140,10 @@ static int fc_fcp_pkt_abort(struct fc_lport *lp, struct fc_fcp_pkt *fsp)
         fsp->wait_for_comp = 0;
 
         if (!rc) {
-                FC_DBG("target abort cmd  failed\n");
+                FC_FCP_DBG(fsp, "target abort cmd  failed\n");
                 rc = FAILED;
         } else if (fsp->state & FC_SRB_ABORTED) {
-                FC_DBG("target abort cmd  passed\n");
+                FC_FCP_DBG(fsp, "target abort cmd  passed\n");
                 rc = SUCCESS;
                 fc_fcp_complete_locked(fsp);
         }
@@ -1213,7 +1208,7 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         spin_unlock_bh(&fsp->scsi_pkt_lock);
 
         if (!rc) {
-                FC_DBG("lun reset failed\n");
+                FC_SCSI_DBG(lp, "lun reset failed\n");
                 return FAILED;
         }
 
@@ -1221,7 +1216,7 @@ static int fc_lun_reset(struct fc_lport *lp, struct fc_fcp_pkt *fsp,
         if (fsp->cdb_status != FCP_TMF_CMPL)
                 return FAILED;
 
-        FC_DBG("lun reset to lun %u completed\n", lun);
+        FC_SCSI_DBG(lp, "lun reset to lun %u completed\n", lun);
         fc_fcp_cleanup_each_cmd(lp, id, lun, FC_CMD_ABORTED);
         return SUCCESS;
 }
@@ -1388,13 +1383,13 @@ static void fc_fcp_rec_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                 rjt = fc_frame_payload_get(fp, sizeof(*rjt));
                 switch (rjt->er_reason) {
                 default:
-                        FC_DEBUG_FCP("device %x unexpected REC reject "
-                                     "reason %d expl %d\n",
-                                     fsp->rport->port_id, rjt->er_reason,
-                                     rjt->er_explan);
+                        FC_FCP_DBG(fsp, "device %x unexpected REC reject "
+                                   "reason %d expl %d\n",
+                                   fsp->rport->port_id, rjt->er_reason,
+                                   rjt->er_explan);
                         /* fall through */
                 case ELS_RJT_UNSUP:
-                        FC_DEBUG_FCP("device does not support REC\n");
+                        FC_FCP_DBG(fsp, "device does not support REC\n");
                         rp = fsp->rport->dd_data;
                         /*
                          * if we do not spport RECs or got some bogus
@@ -1514,8 +1509,8 @@ static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                 break;
 
         default:
-                FC_DBG("REC %p fid %x error unexpected error %d\n",
-                       fsp, fsp->rport->port_id, error);
+                FC_FCP_DBG(fsp, "REC %p fid %x error unexpected error %d\n",
+                           fsp, fsp->rport->port_id, error);
                 fsp->status_code = FC_CMD_PLOGO;
                 /* fall through */
 
@@ -1524,9 +1519,9 @@ static void fc_fcp_rec_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
                  * Assume REC or LS_ACC was lost.
                  * The exchange manager will have aborted REC, so retry.
                  */
-                FC_DBG("REC fid %x error error %d retry %d/%d\n",
-                       fsp->rport->port_id, error, fsp->recov_retry,
-                       FC_MAX_RECOV_RETRY);
+                FC_FCP_DBG(fsp, "REC fid %x error error %d retry %d/%d\n",
+                           fsp->rport->port_id, error, fsp->recov_retry,
+                           FC_MAX_RECOV_RETRY);
                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
                         fc_fcp_rec(fsp);
                 else
@@ -2011,9 +2006,11 @@ int fc_eh_device_reset(struct scsi_cmnd *sc_cmd)
         if (lp->state != LPORT_ST_READY)
                 return rc;
 
+        FC_SCSI_DBG(lp, "Resetting rport (%6x)\n", rport->port_id);
+
         fsp = fc_fcp_pkt_alloc(lp, GFP_NOIO);
         if (fsp == NULL) {
-                FC_DBG("could not allocate scsi_pkt\n");
+                printk(KERN_WARNING "libfc: could not allocate scsi_pkt\n");
                 sc_cmd->result = DID_NO_CONNECT << 16;
                 goto out;
         }
@@ -2048,17 +2045,21 @@ int fc_eh_host_reset(struct scsi_cmnd *sc_cmd)
         struct fc_lport *lp = shost_priv(shost);
         unsigned long wait_tmo;
 
+        FC_SCSI_DBG(lp, "Resetting host\n");
+
         lp->tt.lport_reset(lp);
         wait_tmo = jiffies + FC_HOST_RESET_TIMEOUT;
         while (!fc_fcp_lport_queue_ready(lp) && time_before(jiffies, wait_tmo))
                 msleep(1000);
 
         if (fc_fcp_lport_queue_ready(lp)) {
-                shost_printk(KERN_INFO, shost, "Host reset succeeded.\n");
+                shost_printk(KERN_INFO, shost, "libfc: Host reset succeeded "
+                             "on port (%6x)\n", fc_host_port_id(lp->host));
                 return SUCCESS;
         } else {
-                shost_printk(KERN_INFO, shost, "Host reset failed. "
-                             "lport not ready.\n");
+                shost_printk(KERN_INFO, shost, "libfc: Host reset failed, "
+                             "port (%6x) is not ready.\n",
+                             fc_host_port_id(lp->host));
                 return FAILED;
         }
 }
@@ -2117,7 +2118,8 @@ void fc_fcp_destroy(struct fc_lport *lp)
         struct fc_fcp_internal *si = fc_get_scsi_internal(lp);
 
         if (!list_empty(&si->scsi_pkt_queue))
-                printk(KERN_ERR "Leaked scsi packets.\n");
+                printk(KERN_ERR "libfc: Leaked SCSI packets when destroying "
+                       "port (%6x)\n", fc_host_port_id(lp->host));
 
         mempool_destroy(si->scsi_pkt_pool);
         kfree(si);
@@ -2166,7 +2168,8 @@ static int __init libfc_init(void)
                                             sizeof(struct fc_fcp_pkt),
                                             0, SLAB_HWCACHE_ALIGN, NULL);
         if (scsi_pkt_cachep == NULL) {
-                FC_DBG("Unable to allocate SRB cache...module load failed!");
+                printk(KERN_ERR "libfc: Unable to allocate SRB cache, "
+                       "module load failed!");
                 return -ENOMEM;
         }
 
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index e0c247724d2b..745fa5555d6a 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -101,14 +101,6 @@
 
 #define DNS_DELAY             3 /* Discovery delay after RSCN (in seconds)*/
 
-static int fc_lport_debug;
-
-#define FC_DEBUG_LPORT(fmt...)                  \
-        do {                                    \
-                if (fc_lport_debug)             \
-                        FC_DBG(fmt);            \
-        } while (0)
-
 static void fc_lport_error(struct fc_lport *, struct fc_frame *);
 
 static void fc_lport_enter_reset(struct fc_lport *);
@@ -151,8 +143,8 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
                                     struct fc_rport *rport,
                                     enum fc_rport_event event)
 {
-        FC_DEBUG_LPORT("Received a %d event for port (%6x)\n", event,
-                       rport->port_id);
+        FC_LPORT_DBG(lport, "Received a %d event for port (%6x)\n", event,
+                     rport->port_id);
 
         switch (event) {
         case RPORT_EV_CREATED:
@@ -162,19 +154,19 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
                                 lport->dns_rp = rport;
                                 fc_lport_enter_rpn_id(lport);
                         } else {
-                                FC_DEBUG_LPORT("Received an CREATED event on "
-                                               "port (%6x) for the directory "
-                                               "server, but the lport is not "
-                                               "in the DNS state, it's in the "
-                                               "%d state", rport->port_id,
-                                               lport->state);
+                                FC_LPORT_DBG(lport, "Received an CREATED event "
+                                             "on port (%6x) for the directory "
+                                             "server, but the lport is not "
+                                             "in the DNS state, it's in the "
+                                             "%d state", rport->port_id,
+                                             lport->state);
                                 lport->tt.rport_logoff(rport);
                         }
                         mutex_unlock(&lport->lp_mutex);
                 } else
-                        FC_DEBUG_LPORT("Received an event for port (%6x) "
-                                       "which is not the directory server\n",
-                                       rport->port_id);
+                        FC_LPORT_DBG(lport, "Received an event for port (%6x) "
+                                     "which is not the directory server\n",
+                                     rport->port_id);
                 break;
         case RPORT_EV_LOGO:
         case RPORT_EV_FAILED:
@@ -185,9 +177,9 @@ static void fc_lport_rport_callback(struct fc_lport *lport,
                         mutex_unlock(&lport->lp_mutex);
 
                 } else
-                        FC_DEBUG_LPORT("Received an event for port (%6x) "
-                                       "which is not the directory server\n",
-                                       rport->port_id);
+                        FC_LPORT_DBG(lport, "Received an event for port (%6x) "
+                                     "which is not the directory server\n",
+                                     rport->port_id);
                 break;
         case RPORT_EV_NONE:
                 break;
@@ -363,8 +355,8 @@ static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
                                    struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Received RLIR request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+                     fc_lport_state(lport));
 
         lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
         fc_frame_free(fp);
@@ -389,8 +381,8 @@ static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
         void *dp;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received RLIR request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
+                     fc_lport_state(lport));
 
         len = fr_len(in_fp) - sizeof(struct fc_frame_header);
         pp = fc_frame_payload_get(in_fp, len);
@@ -437,8 +429,8 @@ static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
         size_t len;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received RNID request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received RNID request while in state %s\n",
+                     fc_lport_state(lport));
 
         req = fc_frame_payload_get(in_fp, sizeof(*req));
         if (!req) {
@@ -498,8 +490,8 @@ static void fc_lport_recv_adisc_req(struct fc_seq *sp, struct fc_frame *in_fp,
         size_t len;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received ADISC request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received ADISC request while in state %s\n",
+                     fc_lport_state(lport));
 
         req = fc_frame_payload_get(in_fp, sizeof(*req));
         if (!req) {
@@ -574,8 +566,8 @@ EXPORT_SYMBOL(fc_fabric_login);
  */
 void fc_linkup(struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Link is up for port (%6x)\n",
-                       fc_host_port_id(lport->host));
+        printk(KERN_INFO "libfc: Link up on port (%6x)\n",
+               fc_host_port_id(lport->host));
 
         mutex_lock(&lport->lp_mutex);
         if (!lport->link_up) {
@@ -595,8 +587,8 @@ EXPORT_SYMBOL(fc_linkup);
 void fc_linkdown(struct fc_lport *lport)
 {
         mutex_lock(&lport->lp_mutex);
-        FC_DEBUG_LPORT("Link is down for port (%6x)\n",
-                       fc_host_port_id(lport->host));
+        printk(KERN_INFO "libfc: Link down on port (%6x)\n",
+               fc_host_port_id(lport->host));
 
         if (lport->link_up) {
                 lport->link_up = 0;
@@ -701,12 +693,11 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
 {
         switch (event) {
         case DISC_EV_SUCCESS:
-                FC_DEBUG_LPORT("Got a SUCCESS event for port (%6x)\n",
-                               fc_host_port_id(lport->host));
+                FC_LPORT_DBG(lport, "Discovery succeeded\n");
                 break;
         case DISC_EV_FAILED:
-                FC_DEBUG_LPORT("Got a FAILED event for port (%6x)\n",
-                               fc_host_port_id(lport->host));
+                printk(KERN_ERR "libfc: Discovery failed for port (%6x)\n",
+                       fc_host_port_id(lport->host));
                 mutex_lock(&lport->lp_mutex);
                 fc_lport_enter_reset(lport);
                 mutex_unlock(&lport->lp_mutex);
@@ -726,8 +717,8 @@ void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
  */
 static void fc_lport_enter_ready(struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Port (%6x) entered Ready from state %s\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered READY from state %s\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_READY);
 
@@ -762,8 +753,8 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
         u32 local_fid;
         u32 f_ctl;
 
-        FC_DEBUG_LPORT("Received FLOGI request while in state %s\n",
-                       fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Received FLOGI request while in state %s\n",
+                     fc_lport_state(lport));
 
         fh = fc_frame_header_get(rx_fp);
         remote_fid = ntoh24(fh->fh_s_id);
@@ -772,12 +763,11 @@ static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
                 goto out;
         remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
         if (remote_wwpn == lport->wwpn) {
-                FC_DBG("FLOGI from port with same WWPN %llx "
-                       "possible configuration error\n",
-                       (unsigned long long)remote_wwpn);
+                printk(KERN_WARNING "libfc: Received FLOGI from port "
+                       "with same WWPN %llx\n", remote_wwpn);
                 goto out;
         }
-        FC_DBG("FLOGI from port WWPN %llx\n", (unsigned long long)remote_wwpn);
+        FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn);
 
         /*
          * XXX what is the right thing to do for FIDs?
@@ -909,7 +899,8 @@ static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
                         }
                 }
         } else {
-                FC_DBG("dropping invalid frame (eof %x)\n", fr_eof(fp));
+                FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)\n",
+                             fr_eof(fp));
                 fc_frame_free(fp);
         }
         mutex_unlock(&lport->lp_mutex);
@@ -947,8 +938,8 @@ EXPORT_SYMBOL(fc_lport_reset);
  */
 static void fc_lport_enter_reset(struct fc_lport *lport)
 {
-        FC_DEBUG_LPORT("Port (%6x) entered RESET state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_RESET);
 
@@ -982,9 +973,9 @@ static void fc_lport_enter_reset(struct fc_lport *lport)
 static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
 {
         unsigned long delay = 0;
-        FC_DEBUG_LPORT("Error %ld in state %s, retries %d\n",
-                       PTR_ERR(fp), fc_lport_state(lport),
-                       lport->retry_count);
+        FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d\n",
+                     PTR_ERR(fp), fc_lport_state(lport),
+                     lport->retry_count);
 
         if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) {
                 /*
@@ -1040,11 +1031,11 @@ static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a RFT_ID response\n");
+        FC_LPORT_DBG(lport, "Received a RFT_ID response\n");
 
         if (lport->state != LPORT_ST_RFT_ID) {
-                FC_DBG("Received a RFT_ID response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a RFT_ID response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1094,11 +1085,11 @@ static void fc_lport_rpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a RPN_ID response\n");
+        FC_LPORT_DBG(lport, "Received a RPN_ID response\n");
 
         if (lport->state != LPORT_ST_RPN_ID) {
-                FC_DBG("Received a RPN_ID response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a RPN_ID response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1146,11 +1137,11 @@ static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a SCR response\n");
+        FC_LPORT_DBG(lport, "Received a SCR response\n");
 
         if (lport->state != LPORT_ST_SCR) {
-                FC_DBG("Received a SCR response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a SCR response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1184,8 +1175,8 @@ static void fc_lport_enter_scr(struct fc_lport *lport)
 {
         struct fc_frame *fp;
 
-        FC_DEBUG_LPORT("Port (%6x) entered SCR state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered SCR state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_SCR);
 
@@ -1213,8 +1204,8 @@ static void fc_lport_enter_rft_id(struct fc_lport *lport)
         struct fc_ns_fts *lps;
         int i;
 
-        FC_DEBUG_LPORT("Port (%6x) entered RFT_ID state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered RFT_ID state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
 
@@ -1253,8 +1244,8 @@ static void fc_lport_enter_rpn_id(struct fc_lport *lport)
 {
         struct fc_frame *fp;
 
-        FC_DEBUG_LPORT("Port (%6x) entered RPN_ID state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered RPN_ID state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
 
@@ -1294,8 +1285,8 @@ static void fc_lport_enter_dns(struct fc_lport *lport)
         dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
         dp.lp = lport;
 
-        FC_DEBUG_LPORT("Port (%6x) entered DNS state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered DNS state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_DNS);
 
@@ -1374,11 +1365,11 @@ static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a LOGO response\n");
+        FC_LPORT_DBG(lport, "Received a LOGO response\n");
 
         if (lport->state != LPORT_ST_LOGO) {
-                FC_DBG("Received a LOGO response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a LOGO response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1413,8 +1404,8 @@ static void fc_lport_enter_logo(struct fc_lport *lport)
         struct fc_frame *fp;
         struct fc_els_logo *logo;
 
-        FC_DEBUG_LPORT("Port (%6x) entered LOGO state from %s state\n",
-                       fc_host_port_id(lport->host), fc_lport_state(lport));
+        FC_LPORT_DBG(lport, "Entered LOGO state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_LOGO);
 
@@ -1456,11 +1447,11 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&lport->lp_mutex);
 
-        FC_DEBUG_LPORT("Received a FLOGI response\n");
+        FC_LPORT_DBG(lport, "Received a FLOGI response\n");
 
         if (lport->state != LPORT_ST_FLOGI) {
-                FC_DBG("Received a FLOGI response, but in state %s\n",
-                       fc_lport_state(lport));
+                FC_LPORT_DBG(lport, "Received a FLOGI response, but in state "
+                             "%s\n", fc_lport_state(lport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -1475,7 +1466,8 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
         did = ntoh24(fh->fh_d_id);
         if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
 
-                FC_DEBUG_LPORT("Assigned fid %x\n", did);
+                printk(KERN_INFO "libfc: Assigned FID (%6x) in FLOGI response\n",
+                       did);
                 fc_host_port_id(lport->host) = did;
 
                 flp = fc_frame_payload_get(fp, sizeof(*flp));
@@ -1494,7 +1486,8 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                                 if (e_d_tov > lport->e_d_tov)
                                         lport->e_d_tov = e_d_tov;
                                 lport->r_a_tov = 2 * e_d_tov;
-                                FC_DBG("Point-to-Point mode\n");
+                                printk(KERN_INFO "libfc: Port (%6x) entered "
+                                       "point to point mode\n", did);
                                 fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
                                                    get_unaligned_be64(
                                                            &flp->fl_wwpn),
@@ -1517,7 +1510,7 @@ static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
                         }
                 }
         } else {
-                FC_DBG("bad FLOGI response\n");
+                FC_LPORT_DBG(lport, "Bad FLOGI response\n");
         }
 
 out:
@@ -1537,7 +1530,8 @@ void fc_lport_enter_flogi(struct fc_lport *lport)
 {
         struct fc_frame *fp;
 
-        FC_DEBUG_LPORT("Processing FLOGI state\n");
+        FC_LPORT_DBG(lport, "Entered FLOGI state from %s state\n",
+                     fc_lport_state(lport));
 
         fc_lport_state_enter(lport, LPORT_ST_FLOGI);
 
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 7bfbff7e0efb..7162385f52eb 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -55,14 +55,6 @@
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
-static int fc_rport_debug;
-
-#define FC_DEBUG_RPORT(fmt...)                  \
-        do {                                    \
-                if (fc_rport_debug)             \
-                        FC_DBG(fmt);            \
-        } while (0)
-
 struct workqueue_struct *rport_event_queue;
 
 static void fc_rport_enter_plogi(struct fc_rport *);
@@ -97,7 +89,7 @@ static const char *fc_rport_state_names[] = {
 static void fc_rport_rogue_destroy(struct device *dev)
 {
         struct fc_rport *rport = dev_to_rport(dev);
-        FC_DEBUG_RPORT("Destroying rogue rport (%6x)\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Destroying rogue rport\n");
         kfree(rport);
 }
 
@@ -263,8 +255,8 @@ static void fc_rport_work(struct work_struct *work)
 
                         fc_rport_state_enter(new_rport, RPORT_ST_READY);
                 } else {
-                        FC_DBG("Failed to create the rport for port "
-                               "(%6x).\n", ids.port_id);
+                        printk(KERN_WARNING "libfc: Failed to allocate "
+                               " memory for rport (%6x)\n", ids.port_id);
                         event = RPORT_EV_FAILED;
                 }
                 if (rport->port_id != FC_FID_DIR_SERV)
@@ -309,7 +301,7 @@ int fc_rport_login(struct fc_rport *rport)
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Login to port (%6x)\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Login to port\n");
 
         fc_rport_enter_plogi(rport);
 
@@ -329,16 +321,13 @@ int fc_rport_login(struct fc_rport *rport)
 int fc_rport_logoff(struct fc_rport *rport)
 {
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
-        struct fc_lport *lport = rdata->local_port;
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Remove port (%6x)\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Remove port\n");
 
         if (rdata->rp_state == RPORT_ST_NONE) {
-                FC_DEBUG_RPORT("(%6x): Port (%6x) in NONE state,"
-                               " not removing", fc_host_port_id(lport->host),
-                               rport->port_id);
+                FC_RPORT_DBG(rport, "Port in NONE state, not removing\n");
                 mutex_unlock(&rdata->rp_mutex);
                 goto out;
         }
@@ -379,7 +368,7 @@ static void fc_rport_enter_ready(struct fc_rport *rport)
 
         fc_rport_state_enter(rport, RPORT_ST_READY);
 
-        FC_DEBUG_RPORT("Port (%6x) is Ready\n", rport->port_id);
+        FC_RPORT_DBG(rport, "Port is Ready\n");
 
         rdata->event = RPORT_EV_CREATED;
         queue_work(rport_event_queue, &rdata->event_work);
@@ -436,8 +425,8 @@ static void fc_rport_error(struct fc_rport *rport, struct fc_frame *fp)
 {
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 
-        FC_DEBUG_RPORT("Error %ld in state %s, retries %d\n",
-                       PTR_ERR(fp), fc_rport_state(rport), rdata->retries);
+        FC_RPORT_DBG(rport, "Error %ld in state %s, retries %d\n",
+                     PTR_ERR(fp), fc_rport_state(rport), rdata->retries);
 
         switch (rdata->rp_state) {
         case RPORT_ST_PLOGI:
@@ -479,8 +468,8 @@ static void fc_rport_error_retry(struct fc_rport *rport, struct fc_frame *fp)
                 return fc_rport_error(rport, fp);
 
         if (rdata->retries < rdata->local_port->max_rport_retry_count) {
-                FC_DEBUG_RPORT("Error %ld in state %s, retrying\n",
-                               PTR_ERR(fp), fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Error %ld in state %s, retrying\n",
+                             PTR_ERR(fp), fc_rport_state(rport));
                 rdata->retries++;
                 /* no additional delay on exchange timeouts */
                 if (PTR_ERR(fp) == -FC_EX_TIMEOUT)
@@ -517,12 +506,11 @@ static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a PLOGI response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a PLOGI response\n");
 
         if (rdata->rp_state != RPORT_ST_PLOGI) {
-                FC_DBG("Received a PLOGI response, but in state %s\n",
-                       fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a PLOGI response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -583,8 +571,8 @@ static void fc_rport_enter_plogi(struct fc_rport *rport)
         struct fc_lport *lport = rdata->local_port;
         struct fc_frame *fp;
 
-        FC_DEBUG_RPORT("Port (%6x) entered PLOGI state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered PLOGI state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_PLOGI);
 
@@ -628,12 +616,11 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a PRLI response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a PRLI response\n");
 
         if (rdata->rp_state != RPORT_ST_PRLI) {
-                FC_DBG("Received a PRLI response, but in state %s\n",
-                       fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a PRLI response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -663,7 +650,7 @@ static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
                 fc_rport_enter_rtv(rport);
 
         } else {
-                FC_DBG("Bad ELS response\n");
+                FC_RPORT_DBG(rport, "Bad ELS response for PRLI command\n");
                 rdata->event = RPORT_EV_FAILED;
                 fc_rport_state_enter(rport, RPORT_ST_NONE);
                 queue_work(rport_event_queue, &rdata->event_work);
@@ -695,12 +682,11 @@ static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a LOGO response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a LOGO response\n");
 
         if (rdata->rp_state != RPORT_ST_LOGO) {
-                FC_DEBUG_RPORT("Received a LOGO response, but in state %s\n",
-                               fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a LOGO response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -715,7 +701,7 @@ static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
         if (op == ELS_LS_ACC) {
                 fc_rport_enter_rtv(rport);
         } else {
-                FC_DBG("Bad ELS response\n");
+                FC_RPORT_DBG(rport, "Bad ELS response for LOGO command\n");
                 rdata->event = RPORT_EV_LOGO;
                 fc_rport_state_enter(rport, RPORT_ST_NONE);
                 queue_work(rport_event_queue, &rdata->event_work);
@@ -745,8 +731,8 @@ static void fc_rport_enter_prli(struct fc_rport *rport)
         } *pp;
         struct fc_frame *fp;
 
-        FC_DEBUG_RPORT("Port (%6x) entered PRLI state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered PRLI state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_PRLI);
 
@@ -784,12 +770,11 @@ static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
 
         mutex_lock(&rdata->rp_mutex);
 
-        FC_DEBUG_RPORT("Received a RTV response from port (%6x)\n",
-                       rport->port_id);
+        FC_RPORT_DBG(rport, "Received a RTV response\n");
 
         if (rdata->rp_state != RPORT_ST_RTV) {
-                FC_DBG("Received a RTV response, but in state %s\n",
-                       fc_rport_state(rport));
+                FC_RPORT_DBG(rport, "Received a RTV response, but in state "
+                             "%s\n", fc_rport_state(rport));
                 if (IS_ERR(fp))
                         goto err;
                 goto out;
@@ -844,8 +829,8 @@ static void fc_rport_enter_rtv(struct fc_rport *rport)
         struct fc_rport_libfc_priv *rdata = rport->dd_data;
         struct fc_lport *lport = rdata->local_port;
 
-        FC_DEBUG_RPORT("Port (%6x) entered RTV state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered RTV state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_RTV);
 
@@ -875,8 +860,8 @@ static void fc_rport_enter_logo(struct fc_rport *rport)
         struct fc_lport *lport = rdata->local_port;
         struct fc_frame *fp;
 
-        FC_DEBUG_RPORT("Port (%6x) entered LOGO state from %s state\n",
-                       rport->port_id, fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Port entered LOGO state from %s state\n",
+                     fc_rport_state(rport));
 
         fc_rport_state_enter(rport, RPORT_ST_LOGO);
 
@@ -983,14 +968,13 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
 
         fh = fc_frame_header_get(fp);
 
-        FC_DEBUG_RPORT("Received PLOGI request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received PLOGI request while in state %s\n",
+                     fc_rport_state(rport));
 
         sid = ntoh24(fh->fh_s_id);
         pl = fc_frame_payload_get(fp, sizeof(*pl));
         if (!pl) {
-                FC_DBG("incoming PLOGI from %x too short\n", sid);
+                FC_RPORT_DBG(rport, "Received PLOGI too short\n");
                 WARN_ON(1);
                 /* XXX TBD: send reject? */
                 fc_frame_free(fp);
@@ -1012,26 +996,26 @@ static void fc_rport_recv_plogi_req(struct fc_rport *rport,
          */
         switch (rdata->rp_state) {
         case RPORT_ST_INIT:
-                FC_DEBUG_RPORT("incoming PLOGI from %6x wwpn %llx state INIT "
-                               "- reject\n", sid, (unsigned long long)wwpn);
+                FC_RPORT_DBG(rport, "Received PLOGI, wwpn %llx state INIT "
+                             "- reject\n", (unsigned long long)wwpn);
                 reject = ELS_RJT_UNSUP;
                 break;
         case RPORT_ST_PLOGI:
-                FC_DEBUG_RPORT("incoming PLOGI from %x in PLOGI state %d\n",
-                               sid, rdata->rp_state);
+                FC_RPORT_DBG(rport, "Received PLOGI in PLOGI state %d\n",
+                             rdata->rp_state);
                 if (wwpn < lport->wwpn)
                         reject = ELS_RJT_INPROG;
                 break;
         case RPORT_ST_PRLI:
         case RPORT_ST_READY:
-                FC_DEBUG_RPORT("incoming PLOGI from %x in logged-in state %d "
-                               "- ignored for now\n", sid, rdata->rp_state);
+                FC_RPORT_DBG(rport, "Received PLOGI in logged-in state %d "
+                             "- ignored for now\n", rdata->rp_state);
                 /* XXX TBD - should reset */
                 break;
         case RPORT_ST_NONE:
         default:
-                FC_DEBUG_RPORT("incoming PLOGI from %x in unexpected "
-                               "state %d\n", sid, rdata->rp_state);
+                FC_RPORT_DBG(rport, "Received PLOGI in unexpected "
+                             "state %d\n", rdata->rp_state);
                 fc_frame_free(fp);
                 return;
                 break;
@@ -1115,9 +1099,8 @@ static void fc_rport_recv_prli_req(struct fc_rport *rport,
 
         fh = fc_frame_header_get(rx_fp);
 
-        FC_DEBUG_RPORT("Received PRLI request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received PRLI request while in state %s\n",
+                     fc_rport_state(rport));
 
         switch (rdata->rp_state) {
         case RPORT_ST_PRLI:
@@ -1252,9 +1235,8 @@ static void fc_rport_recv_prlo_req(struct fc_rport *rport, struct fc_seq *sp,
 
         fh = fc_frame_header_get(fp);
 
-        FC_DEBUG_RPORT("Received PRLO request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received PRLO request while in state %s\n",
+                     fc_rport_state(rport));
 
         if (rdata->rp_state == RPORT_ST_NONE) {
                 fc_frame_free(fp);
@@ -1286,9 +1268,8 @@ static void fc_rport_recv_logo_req(struct fc_rport *rport, struct fc_seq *sp,
 
         fh = fc_frame_header_get(fp);
 
-        FC_DEBUG_RPORT("Received LOGO request from port (%6x) "
-                       "while in state %s\n", ntoh24(fh->fh_s_id),
-                       fc_rport_state(rport));
+        FC_RPORT_DBG(rport, "Received LOGO request while in state %s\n",
+                     fc_rport_state(rport));
 
         if (rdata->rp_state == RPORT_ST_NONE) {
                 fc_frame_free(fp);
@@ -1308,7 +1289,6 @@ static void fc_rport_flush_queue(void)
         flush_workqueue(rport_event_queue);
 }
 
-
 int fc_rport_init(struct fc_lport *lport)
 {
         if (!lport->tt.rport_create)
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index 59908aead531..716cc344c5df 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -38,15 +38,30 @@
 #include <scsi/scsi_transport_iscsi.h>
 #include <scsi/libiscsi.h>
 
-static int iscsi_dbg_lib;
-module_param_named(debug_libiscsi, iscsi_dbg_lib, int, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug_libiscsi, "Turn on debugging for libiscsi module. "
-                 "Set to 1 to turn on, and zero to turn off. Default "
-                 "is off.");
+static int iscsi_dbg_lib_conn;
+module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int,
+                   S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug_libiscsi_conn,
+                 "Turn on debugging for connections in libiscsi module. "
+                 "Set to 1 to turn on, and zero to turn off. Default is off.");
+
+static int iscsi_dbg_lib_session;
+module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int,
+                   S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug_libiscsi_session,
+                 "Turn on debugging for sessions in libiscsi module. "
+                 "Set to 1 to turn on, and zero to turn off. Default is off.");
+
+static int iscsi_dbg_lib_eh;
+module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int,
+                   S_IRUGO | S_IWUSR);
+MODULE_PARM_DESC(debug_libiscsi_eh,
+                 "Turn on debugging for error handling in libiscsi module. "
+                 "Set to 1 to turn on, and zero to turn off. Default is off.");
 
 #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...)                  \
         do {                                                    \
-                if (iscsi_dbg_lib)                              \
+                if (iscsi_dbg_lib_conn)                         \
                         iscsi_conn_printk(KERN_INFO, _conn,     \
                                              "%s " dbg_fmt,     \
                                              __func__, ##arg);  \
@@ -54,7 +69,15 @@ MODULE_PARM_DESC(debug_libiscsi, "Turn on debugging for libiscsi module. "
 
 #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...)                    \
         do {                                                            \
-                if (iscsi_dbg_lib)                                      \
+                if (iscsi_dbg_lib_session)                              \
+                        iscsi_session_printk(KERN_INFO, _session,       \
+                                             "%s " dbg_fmt,             \
+                                             __func__, ##arg);          \
+        } while (0);
+
+#define ISCSI_DBG_EH(_session, dbg_fmt, arg...)                         \
+        do {                                                            \
+                if (iscsi_dbg_lib_eh)                                   \
                         iscsi_session_printk(KERN_INFO, _session,       \
                                              "%s " dbg_fmt,             \
                                              __func__, ##arg);          \
@@ -954,6 +977,7 @@ int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
                 task = iscsi_itt_to_ctask(conn, hdr->itt);
                 if (!task)
                         return ISCSI_ERR_BAD_ITT;
+                task->last_xfer = jiffies;
                 break;
         case ISCSI_OP_R2T:
                 /*
@@ -1192,10 +1216,12 @@ static int iscsi_xmit_task(struct iscsi_conn *conn)
         spin_unlock_bh(&conn->session->lock);
         rc = conn->session->tt->xmit_task(task);
         spin_lock_bh(&conn->session->lock);
-        __iscsi_put_task(task);
-        if (!rc)
+        if (!rc) {
                 /* done with this task */
+                task->last_xfer = jiffies;
                 conn->task = NULL;
+        }
+        __iscsi_put_task(task);
         return rc;
 }
 
@@ -1361,6 +1387,9 @@ static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
         task->state = ISCSI_TASK_PENDING;
         task->conn = conn;
         task->sc = sc;
+        task->have_checked_conn = false;
+        task->last_timeout = jiffies;
+        task->last_xfer = jiffies;
         INIT_LIST_HEAD(&task->running);
         return task;
 }
@@ -1555,10 +1584,10 @@ int iscsi_eh_target_reset(struct scsi_cmnd *sc)
         spin_lock_bh(&session->lock);
         if (session->state == ISCSI_STATE_TERMINATE) {
 failed:
-                iscsi_session_printk(KERN_INFO, session,
-                                     "failing target reset: Could not log "
-                                     "back into target [age %d]\n",
-                                     session->age);
+                ISCSI_DBG_EH(session,
+                             "failing target reset: Could not log back into "
+                             "target [age %d]\n",
+                             session->age);
                 spin_unlock_bh(&session->lock);
                 mutex_unlock(&session->eh_mutex);
                 return FAILED;
@@ -1572,7 +1601,7 @@ failed:
          */
         iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
 
-        ISCSI_DBG_SESSION(session, "wait for relogin\n");
+        ISCSI_DBG_EH(session, "wait for relogin\n");
         wait_event_interruptible(conn->ehwait,
                                  session->state == ISCSI_STATE_TERMINATE ||
                                  session->state == ISCSI_STATE_LOGGED_IN ||
@@ -1582,10 +1611,10 @@ failed:
 
         mutex_lock(&session->eh_mutex);
         spin_lock_bh(&session->lock);
-        if (session->state == ISCSI_STATE_LOGGED_IN)
-                iscsi_session_printk(KERN_INFO, session,
-                                     "target reset succeeded\n");
-        else
+        if (session->state == ISCSI_STATE_LOGGED_IN) {
+                ISCSI_DBG_EH(session,
+                             "target reset succeeded\n");
+        } else
                 goto failed;
         spin_unlock_bh(&session->lock);
         mutex_unlock(&session->eh_mutex);
@@ -1601,7 +1630,7 @@ static void iscsi_tmf_timedout(unsigned long data)
         spin_lock(&session->lock);
         if (conn->tmf_state == TMF_QUEUED) {
                 conn->tmf_state = TMF_TIMEDOUT;
-                ISCSI_DBG_SESSION(session, "tmf timedout\n");
+                ISCSI_DBG_EH(session, "tmf timedout\n");
                 /* unblock eh_abort() */
                 wake_up(&conn->ehwait);
         }
@@ -1621,7 +1650,7 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
                 spin_unlock_bh(&session->lock);
                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
                 spin_lock_bh(&session->lock);
-                ISCSI_DBG_SESSION(session, "tmf exec failure\n");
+                ISCSI_DBG_EH(session, "tmf exec failure\n");
                 return -EPERM;
         }
         conn->tmfcmd_pdus_cnt++;
@@ -1629,7 +1658,7 @@ static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
         conn->tmf_timer.function = iscsi_tmf_timedout;
         conn->tmf_timer.data = (unsigned long)conn;
         add_timer(&conn->tmf_timer);
-        ISCSI_DBG_SESSION(session, "tmf set timeout\n");
+        ISCSI_DBG_EH(session, "tmf set timeout\n");
 
         spin_unlock_bh(&session->lock);
         mutex_unlock(&session->eh_mutex);
@@ -1716,17 +1745,18 @@ static int iscsi_has_ping_timed_out(struct iscsi_conn *conn)
                 return 0;
 }
 
-static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
+static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
 {
+        enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
+        struct iscsi_task *task = NULL;
         struct iscsi_cls_session *cls_session;
         struct iscsi_session *session;
         struct iscsi_conn *conn;
-        enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
 
-        cls_session = starget_to_session(scsi_target(scmd->device));
+        cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
 
-        ISCSI_DBG_SESSION(session, "scsi cmd %p timedout\n", scmd);
+        ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc);
 
         spin_lock(&session->lock);
         if (session->state != ISCSI_STATE_LOGGED_IN) {
@@ -1745,6 +1775,26 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
                 goto done;
         }
 
+        task = (struct iscsi_task *)sc->SCp.ptr;
+        if (!task)
+                goto done;
+        /*
+         * If we have sent (at least queued to the network layer) a pdu or
+         * recvd one for the task since the last timeout ask for
+         * more time. If on the next timeout we have not made progress
+         * we can check if it is the task or connection when we send the
+         * nop as a ping.
+         */
+        if (time_after_eq(task->last_xfer, task->last_timeout)) {
+                ISCSI_DBG_EH(session, "Command making progress. Asking "
+                             "scsi-ml for more time to complete. "
+                             "Last data recv at %lu. Last timeout was at "
+                             "%lu\n.", task->last_xfer, task->last_timeout);
+                task->have_checked_conn = false;
+                rc = BLK_EH_RESET_TIMER;
+                goto done;
+        }
+
         if (!conn->recv_timeout && !conn->ping_timeout)
                 goto done;
         /*
@@ -1755,23 +1805,32 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
                 rc = BLK_EH_RESET_TIMER;
                 goto done;
         }
+
+        /* Assumes nop timeout is shorter than scsi cmd timeout */
+        if (task->have_checked_conn)
+                goto done;
+
         /*
-         * if we are about to check the transport then give the command
-         * more time
+         * Checking the transport already or nop from a cmd timeout still
+         * running
          */
-        if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ),
-                           jiffies)) {
+        if (conn->ping_task) {
+                task->have_checked_conn = true;
                 rc = BLK_EH_RESET_TIMER;
                 goto done;
         }
 
-        /* if in the middle of checking the transport then give us more time */
-        if (conn->ping_task)
-                rc = BLK_EH_RESET_TIMER;
+        /* Make sure there is a transport check done */
+        iscsi_send_nopout(conn, NULL);
+        task->have_checked_conn = true;
+        rc = BLK_EH_RESET_TIMER;
+
 done:
+        if (task)
+                task->last_timeout = jiffies;
         spin_unlock(&session->lock);
-        ISCSI_DBG_SESSION(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
-                          "timer reset" : "nh");
+        ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
+                     "timer reset" : "nh");
         return rc;
 }
 
@@ -1841,7 +1900,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
 
-        ISCSI_DBG_SESSION(session, "aborting sc %p\n", sc);
+        ISCSI_DBG_EH(session, "aborting sc %p\n", sc);
 
         mutex_lock(&session->eh_mutex);
         spin_lock_bh(&session->lock);
@@ -1850,8 +1909,8 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
          * got the command.
          */
         if (!sc->SCp.ptr) {
-                ISCSI_DBG_SESSION(session, "sc never reached iscsi layer or "
-                                  "it completed.\n");
+                ISCSI_DBG_EH(session, "sc never reached iscsi layer or "
+                                      "it completed.\n");
                 spin_unlock_bh(&session->lock);
                 mutex_unlock(&session->eh_mutex);
                 return SUCCESS;
@@ -1865,7 +1924,7 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
             sc->SCp.phase != session->age) {
                 spin_unlock_bh(&session->lock);
                 mutex_unlock(&session->eh_mutex);
-                ISCSI_DBG_SESSION(session, "failing abort due to dropped "
+                ISCSI_DBG_EH(session, "failing abort due to dropped "
                                   "session.\n");
                 return FAILED;
         }
@@ -1875,13 +1934,12 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
         age = session->age;
 
         task = (struct iscsi_task *)sc->SCp.ptr;
-        ISCSI_DBG_SESSION(session, "aborting [sc %p itt 0x%x]\n",
-                          sc, task->itt);
+        ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n",
+                     sc, task->itt);
 
         /* task completed before time out */
         if (!task->sc) {
-                ISCSI_DBG_SESSION(session, "sc completed while abort in "
-                                  "progress\n");
+                ISCSI_DBG_EH(session, "sc completed while abort in progress\n");
                 goto success;
         }
 
@@ -1930,8 +1988,8 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
                 if (!sc->SCp.ptr) {
                         conn->tmf_state = TMF_INITIAL;
                         /* task completed before tmf abort response */
-                        ISCSI_DBG_SESSION(session, "sc completed while abort "
-                                          "in progress\n");
+                        ISCSI_DBG_EH(session, "sc completed while abort in "
+                                              "progress\n");
                         goto success;
                 }
                 /* fall through */
@@ -1943,16 +2001,16 @@ int iscsi_eh_abort(struct scsi_cmnd *sc)
 success:
         spin_unlock_bh(&session->lock);
 success_unlocked:
-        ISCSI_DBG_SESSION(session, "abort success [sc %p itt 0x%x]\n",
-                          sc, task->itt);
+        ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n",
+                     sc, task->itt);
         mutex_unlock(&session->eh_mutex);
         return SUCCESS;
 
 failed:
         spin_unlock_bh(&session->lock);
 failed_unlocked:
-        ISCSI_DBG_SESSION(session, "abort failed [sc %p itt 0x%x]\n", sc,
-                          task ? task->itt : 0);
+        ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc,
+                     task ? task->itt : 0);
         mutex_unlock(&session->eh_mutex);
         return FAILED;
 }
@@ -1979,8 +2037,7 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
 
-        ISCSI_DBG_SESSION(session, "LU Reset [sc %p lun %u]\n",
-                          sc, sc->device->lun);
+        ISCSI_DBG_EH(session, "LU Reset [sc %p lun %u]\n", sc, sc->device->lun);
 
         mutex_lock(&session->eh_mutex);
         spin_lock_bh(&session->lock);
@@ -2034,8 +2091,8 @@ int iscsi_eh_device_reset(struct scsi_cmnd *sc)
 unlock:
         spin_unlock_bh(&session->lock);
 done:
-        ISCSI_DBG_SESSION(session, "dev reset result = %s\n",
-                         rc == SUCCESS ? "SUCCESS" : "FAILED");
+        ISCSI_DBG_EH(session, "dev reset result = %s\n",
+                     rc == SUCCESS ? "SUCCESS" : "FAILED");
         mutex_unlock(&session->eh_mutex);
         return rc;
 }
diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index 2bc07090321d..2e0746d70303 100644
--- a/drivers/scsi/libiscsi_tcp.c
+++ b/drivers/scsi/libiscsi_tcp.c
@@ -686,6 +686,7 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
                                      "offset=%d, datalen=%d)\n",
                                       tcp_task->data_offset,
                                       tcp_conn->in.datalen);
+                        task->last_xfer = jiffies;
                         rc = iscsi_segment_seek_sg(&tcp_conn->in.segment,
                                                    sdb->table.sgl,
                                                    sdb->table.nents,
@@ -713,9 +714,10 @@ iscsi_tcp_hdr_dissect(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
                         rc = ISCSI_ERR_BAD_ITT;
                 else if (ahslen)
                         rc = ISCSI_ERR_AHSLEN;
-                else if (task->sc->sc_data_direction == DMA_TO_DEVICE)
+                else if (task->sc->sc_data_direction == DMA_TO_DEVICE) {
+                        task->last_xfer = jiffies;
                         rc = iscsi_tcp_r2t_rsp(conn, task);
-                else
+                } else
                         rc = ISCSI_ERR_PROTO;
                 spin_unlock(&conn->session->lock);
                 break;
diff --git a/drivers/scsi/qla2xxx/qla_dbg.c b/drivers/scsi/qla2xxx/qla_dbg.c
index 4a990f4da4ea..cca8e4ab0372 100644
--- a/drivers/scsi/qla2xxx/qla_dbg.c
+++ b/drivers/scsi/qla2xxx/qla_dbg.c
@@ -216,7 +216,7 @@ qla24xx_soft_reset(struct qla_hw_data *ha)
 
 static int
 qla2xxx_dump_ram(struct qla_hw_data *ha, uint32_t addr, uint16_t *ram,
-    uint16_t ram_words, void **nxt)
+    uint32_t ram_words, void **nxt)
 {
         int rval;
         uint32_t cnt, stat, timer, words, idx;
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 262026129325..f2ce8e3cc91b 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -2301,7 +2301,7 @@ qla2x00_iidma_fcport(scsi_qla_host_t *vha, fc_port_t *fcport)
         static char *link_speeds[] = { "1", "2", "?", "4", "8", "10" };
         char *link_speed;
         int rval;
-        uint16_t mb[6];
+        uint16_t mb[4];
         struct qla_hw_data *ha = vha->hw;
 
         if (!IS_IIDMA_CAPABLE(ha))
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 451ece0760b0..fe69f3057671 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -1267,17 +1267,22 @@ qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
 
         mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
         mcp->out_mb = MBX_0;
-        mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+        if (IS_FWI2_CAPABLE(vha->hw))
+                mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
+        else
+                mcp->in_mb = MBX_1|MBX_0;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
 
         /* Return firmware states. */
         states[0] = mcp->mb[1];
-        states[1] = mcp->mb[2];
-        states[2] = mcp->mb[3];
-        states[3] = mcp->mb[4];
-        states[4] = mcp->mb[5];
+        if (IS_FWI2_CAPABLE(vha->hw)) {
+                states[1] = mcp->mb[2];
+                states[2] = mcp->mb[3];
+                states[3] = mcp->mb[4];
+                states[4] = mcp->mb[5];
+        }
 
         if (rval != QLA_SUCCESS) {
                 /*EMPTY*/
@@ -2697,10 +2702,13 @@ qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
         mcp->mb[0] = MBC_PORT_PARAMS;
         mcp->mb[1] = loop_id;
         mcp->mb[2] = BIT_0;
-        mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
-        mcp->mb[4] = mcp->mb[5] = 0;
-        mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
-        mcp->in_mb = MBX_5|MBX_4|MBX_3|MBX_1|MBX_0;
+        if (IS_QLA81XX(vha->hw))
+                mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
+        else
+                mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
+        mcp->mb[9] = vha->vp_idx;
+        mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
+        mcp->in_mb = MBX_3|MBX_1|MBX_0;
         mcp->tov = MBX_TOV_SECONDS;
         mcp->flags = 0;
         rval = qla2x00_mailbox_command(vha, mcp);
@@ -2710,8 +2718,6 @@ qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
                 mb[0] = mcp->mb[0];
                 mb[1] = mcp->mb[1];
                 mb[3] = mcp->mb[3];
-                mb[4] = mcp->mb[4];
-                mb[5] = mcp->mb[5];
         }
 
         if (rval != QLA_SUCCESS) {
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index dcf011679c8b..f0396e79b6fa 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1663,7 +1663,7 @@ skip_pio:
                 /* queue 0 uses two msix vectors */
                 if (ql2xmultique_tag) {
                         cpus = num_online_cpus();
-                        ha->max_rsp_queues = (ha->msix_count - 1 - cpus) ?
+                        ha->max_rsp_queues = (ha->msix_count - 1 > cpus) ?
                                 (cpus + 1) : (ha->msix_count - 1);
                         ha->max_req_queues = 2;
                 } else if (ql2xmaxqueues > 1) {
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index b63feaf43126..84369705a9ad 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,7 +7,7 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.01-k3"
+#define QLA2XXX_VERSION      "8.03.01-k4"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
diff --git a/drivers/scsi/scsi_debug.c b/drivers/scsi/scsi_debug.c
index 41a21772df12..fb9af207d61d 100644
--- a/drivers/scsi/scsi_debug.c
+++ b/drivers/scsi/scsi_debug.c
@@ -101,6 +101,8 @@ static const char * scsi_debug_version_date = "20070104";
 #define DEF_DIF 0
 #define DEF_GUARD 0
 #define DEF_ATO 1
+#define DEF_PHYSBLK_EXP 0
+#define DEF_LOWEST_ALIGNED 0
 
 /* bit mask values for scsi_debug_opts */
 #define SCSI_DEBUG_OPT_NOISE   1
@@ -156,6 +158,8 @@ static int scsi_debug_dix = DEF_DIX;
 static int scsi_debug_dif = DEF_DIF;
 static int scsi_debug_guard = DEF_GUARD;
 static int scsi_debug_ato = DEF_ATO;
+static int scsi_debug_physblk_exp = DEF_PHYSBLK_EXP;
+static int scsi_debug_lowest_aligned = DEF_LOWEST_ALIGNED;
 
 static int scsi_debug_cmnd_count = 0;
 
@@ -657,7 +661,12 @@ static unsigned char vpdb0_data[] = {
 
 static int inquiry_evpd_b0(unsigned char * arr)
 {
+        unsigned int gran;
+
         memcpy(arr, vpdb0_data, sizeof(vpdb0_data));
+        gran = 1 << scsi_debug_physblk_exp;
+        arr[2] = (gran >> 8) & 0xff;
+        arr[3] = gran & 0xff;
         if (sdebug_store_sectors > 0x400) {
                 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
                 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
@@ -945,6 +954,9 @@ static int resp_readcap16(struct scsi_cmnd * scp,
         arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
         arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
         arr[11] = scsi_debug_sector_size & 0xff;
+        arr[13] = scsi_debug_physblk_exp & 0xf;
+        arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
+        arr[15] = scsi_debug_lowest_aligned & 0xff;
 
         if (scsi_debug_dif) {
                 arr[12] = (scsi_debug_dif - 1) << 1; /* P_TYPE */
@@ -2380,6 +2392,8 @@ module_param_named(dix, scsi_debug_dix, int, S_IRUGO);
 module_param_named(dif, scsi_debug_dif, int, S_IRUGO);
 module_param_named(guard, scsi_debug_guard, int, S_IRUGO);
 module_param_named(ato, scsi_debug_ato, int, S_IRUGO);
+module_param_named(physblk_exp, scsi_debug_physblk_exp, int, S_IRUGO);
+module_param_named(lowest_aligned, scsi_debug_lowest_aligned, int, S_IRUGO);
 
 MODULE_AUTHOR("Eric Youngdale + Douglas Gilbert");
 MODULE_DESCRIPTION("SCSI debug adapter driver");
@@ -2401,7 +2415,9 @@ MODULE_PARM_DESC(ptype, "SCSI peripheral type(def=0[disk])");
 MODULE_PARM_DESC(scsi_level, "SCSI level to simulate(def=5[SPC-3])");
 MODULE_PARM_DESC(virtual_gb, "virtual gigabyte size (def=0 -> use dev_size_mb)");
 MODULE_PARM_DESC(vpd_use_hostno, "0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
-MODULE_PARM_DESC(sector_size, "hardware sector size in bytes (def=512)");
+MODULE_PARM_DESC(sector_size, "logical block size in bytes (def=512)");
+MODULE_PARM_DESC(physblk_exp, "physical block exponent (def=0)");
+MODULE_PARM_DESC(lowest_aligned, "lowest aligned lba (def=0)");
 MODULE_PARM_DESC(dix, "data integrity extensions mask (def=0)");
 MODULE_PARM_DESC(dif, "data integrity field type: 0-3 (def=0)");
 MODULE_PARM_DESC(guard, "protection checksum: 0=crc, 1=ip (def=0)");
@@ -2874,6 +2890,18 @@ static int __init scsi_debug_init(void)
                 return -EINVAL;
         }
 
+        if (scsi_debug_physblk_exp > 15) {
+                printk(KERN_ERR "scsi_debug_init: invalid physblk_exp %u\n",
+                       scsi_debug_physblk_exp);
+                return -EINVAL;
+        }
+
+        if (scsi_debug_lowest_aligned > 0x3fff) {
+                printk(KERN_ERR "scsi_debug_init: lowest_aligned too big: %u\n",
+                       scsi_debug_lowest_aligned);
+                return -EINVAL;
+        }
+
         if (scsi_debug_dev_size_mb < 1)
                 scsi_debug_dev_size_mb = 1;  /* force minimum 1 MB ramdisk */
         sz = (unsigned long)scsi_debug_dev_size_mb * 1048576;
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index 8821df9a277b..93c2622cb969 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -24,6 +24,13 @@ struct scsi_dev_info_list {
         unsigned compatible; /* for use with scsi_static_device_list entries */
 };
 
+struct scsi_dev_info_list_table {
+        struct list_head node;  /* our node for being on the master list */
+        struct list_head scsi_dev_info_list; /* head of dev info list */
+        const char *name;       /* name of list for /proc (NULL for global) */
+        int key;                /* unique numeric identifier */
+};
+
 
 static const char spaces[] = "                "; /* 16 of them */
 static unsigned scsi_default_dev_flags;
@@ -247,6 +254,22 @@ static struct {
         { NULL, NULL, NULL, 0 },
 };
 
+static struct scsi_dev_info_list_table *scsi_devinfo_lookup_by_key(int key)
+{
+        struct scsi_dev_info_list_table *devinfo_table;
+        int found = 0;
+
+        list_for_each_entry(devinfo_table, &scsi_dev_info_list, node)
+                if (devinfo_table->key == key) {
+                        found = 1;
+                        break;
+                }
+        if (!found)
+                return ERR_PTR(-EINVAL);
+
+        return devinfo_table;
+}
+
 /*
  * scsi_strcpy_devinfo: called from scsi_dev_info_list_add to copy into
  * devinfo vendor and model strings.
@@ -296,7 +319,38 @@ static void scsi_strcpy_devinfo(char *name, char *to, size_t to_length,
 static int scsi_dev_info_list_add(int compatible, char *vendor, char *model,
                             char *strflags, int flags)
 {
+        return scsi_dev_info_list_add_keyed(compatible, vendor, model,
+                                            strflags, flags,
+                                            SCSI_DEVINFO_GLOBAL);
+}
+
+/**
+ * scsi_dev_info_list_add_keyed - add one dev_info list entry.
+ * @compatible: if true, null terminate short strings.  Otherwise space pad.
+ * @vendor:     vendor string
+ * @model:      model (product) string
+ * @strflags:   integer string
+ * @flags:      if strflags NULL, use this flag value
+ * @key:        specify list to use
+ *
+ * Description:
+ *      Create and add one dev_info entry for @vendor, @model,
+ *      @strflags or @flag in list specified by @key. If @compatible,
+ *      add to the tail of the list, do not space pad, and set
+ *      devinfo->compatible. The scsi_static_device_list entries are
+ *      added with @compatible 1 and @clfags NULL.
+ *
+ * Returns: 0 OK, -error on failure.
+ **/
+int scsi_dev_info_list_add_keyed(int compatible, char *vendor, char *model,
+                                 char *strflags, int flags, int key)
+{
         struct scsi_dev_info_list *devinfo;
+        struct scsi_dev_info_list_table *devinfo_table =
+                scsi_devinfo_lookup_by_key(key);
+
+        if (IS_ERR(devinfo_table))
+                return PTR_ERR(devinfo_table);
 
         devinfo = kmalloc(sizeof(*devinfo), GFP_KERNEL);
         if (!devinfo) {
@@ -317,12 +371,15 @@ static int scsi_dev_info_list_add(int compatible, char *vendor, char *model,
         devinfo->compatible = compatible;
 
         if (compatible)
-                list_add_tail(&devinfo->dev_info_list, &scsi_dev_info_list);
+                list_add_tail(&devinfo->dev_info_list,
+                              &devinfo_table->scsi_dev_info_list);
         else
-                list_add(&devinfo->dev_info_list, &scsi_dev_info_list);
+                list_add(&devinfo->dev_info_list,
+                         &devinfo_table->scsi_dev_info_list);
 
         return 0;
 }
+EXPORT_SYMBOL(scsi_dev_info_list_add_keyed);
 
 /**
  * scsi_dev_info_list_add_str - parse dev_list and add to the scsi_dev_info_list.
@@ -382,22 +439,48 @@ static int scsi_dev_info_list_add_str(char *dev_list)
  * @model:      model name
  *
  * Description:
- *     Search the scsi_dev_info_list for an entry matching @vendor and
- *     @model, if found, return the matching flags value, else return
- *     the host or global default settings.  Called during scan time.
+ *     Search the global scsi_dev_info_list (specified by list zero)
+ *     for an entry matching @vendor and @model, if found, return the
+ *     matching flags value, else return the host or global default
+ *     settings.  Called during scan time.
  **/
 int scsi_get_device_flags(struct scsi_device *sdev,
                           const unsigned char *vendor,
                           const unsigned char *model)
 {
+        return scsi_get_device_flags_keyed(sdev, vendor, model,
+                                           SCSI_DEVINFO_GLOBAL);
+}
+
+
+/**
+ * get_device_flags_keyed - get device specific flags from the dynamic device list.
+ * @sdev:       &scsi_device to get flags for
+ * @vendor:     vendor name
+ * @model:      model name
+ * @key:        list to look up
+ *
+ * Description:
+ *     Search the scsi_dev_info_list specified by @key for an entry
+ *     matching @vendor and @model, if found, return the matching
+ *     flags value, else return the host or global default settings.
+ *     Called during scan time.
+ **/
+int scsi_get_device_flags_keyed(struct scsi_device *sdev,
+                                const unsigned char *vendor,
+                                const unsigned char *model,
+                                int key)
+{
         struct scsi_dev_info_list *devinfo;
-        unsigned int bflags;
+        struct scsi_dev_info_list_table *devinfo_table;
+
+        devinfo_table = scsi_devinfo_lookup_by_key(key);
 
-        bflags = sdev->sdev_bflags;
-        if (!bflags)
-                bflags = scsi_default_dev_flags;
+        if (IS_ERR(devinfo_table))
+                return PTR_ERR(devinfo_table);
 
-        list_for_each_entry(devinfo, &scsi_dev_info_list, dev_info_list) {
+        list_for_each_entry(devinfo, &devinfo_table->scsi_dev_info_list,
+                            dev_info_list) {
                 if (devinfo->compatible) {
                         /*
                          * Behave like the older version of get_device_flags.
@@ -447,32 +530,89 @@ int scsi_get_device_flags(struct scsi_device *sdev,
                                 return devinfo->flags;
                 }
         }
-        return bflags;
+        /* nothing found, return nothing */
+        if (key != SCSI_DEVINFO_GLOBAL)
+                return 0;
+
+        /* except for the global list, where we have an exception */
+        if (sdev->sdev_bflags)
+                return sdev->sdev_bflags;
+
+        return scsi_default_dev_flags;
 }
+EXPORT_SYMBOL(scsi_get_device_flags_keyed);
 
 #ifdef CONFIG_SCSI_PROC_FS
+struct double_list {
+        struct list_head *top;
+        struct list_head *bottom;
+};
+
 static int devinfo_seq_show(struct seq_file *m, void *v)
 {
+        struct double_list *dl = v;
+        struct scsi_dev_info_list_table *devinfo_table =
+                list_entry(dl->top, struct scsi_dev_info_list_table, node);
         struct scsi_dev_info_list *devinfo =
-                list_entry(v, struct scsi_dev_info_list, dev_info_list);
+                list_entry(dl->bottom, struct scsi_dev_info_list,
+                           dev_info_list);
+
+        if (devinfo_table->scsi_dev_info_list.next == dl->bottom &&
+            devinfo_table->name)
+                seq_printf(m, "[%s]:\n", devinfo_table->name);
 
         seq_printf(m, "'%.8s' '%.16s' 0x%x\n",
-                        devinfo->vendor, devinfo->model, devinfo->flags);
+                   devinfo->vendor, devinfo->model, devinfo->flags);
         return 0;
 }
 
-static void * devinfo_seq_start(struct seq_file *m, loff_t *pos)
+static void *devinfo_seq_start(struct seq_file *m, loff_t *ppos)
 {
-        return seq_list_start(&scsi_dev_info_list, *pos);
+        struct double_list *dl = kmalloc(sizeof(*dl), GFP_KERNEL);
+        loff_t pos = *ppos;
+
+        if (!dl)
+                return NULL;
+
+        list_for_each(dl->top, &scsi_dev_info_list) {
+                struct scsi_dev_info_list_table *devinfo_table =
+                        list_entry(dl->top, struct scsi_dev_info_list_table,
+                                   node);
+                list_for_each(dl->bottom, &devinfo_table->scsi_dev_info_list)
+                        if (pos-- == 0)
+                                return dl;
+        }
+
+        kfree(dl);
+        return NULL;
 }
 
-static void * devinfo_seq_next(struct seq_file *m, void *v, loff_t *pos)
+static void *devinfo_seq_next(struct seq_file *m, void *v, loff_t *ppos)
 {
-        return seq_list_next(v, &scsi_dev_info_list, pos);
+        struct double_list *dl = v;
+        struct scsi_dev_info_list_table *devinfo_table =
+                list_entry(dl->top, struct scsi_dev_info_list_table, node);
+
+        ++*ppos;
+        dl->bottom = dl->bottom->next;
+        while (&devinfo_table->scsi_dev_info_list == dl->bottom) {
+                dl->top = dl->top->next;
+                if (dl->top == &scsi_dev_info_list) {
+                        kfree(dl);
+                        return NULL;
+                }
+                devinfo_table = list_entry(dl->top,
+                                           struct scsi_dev_info_list_table,
+                                           node);
+                dl->bottom = devinfo_table->scsi_dev_info_list.next;
+        }
+
+        return dl;
 }
 
 static void devinfo_seq_stop(struct seq_file *m, void *v)
 {
+        kfree(v);
 }
 
 static const struct seq_operations scsi_devinfo_seq_ops = {
@@ -549,19 +689,78 @@ MODULE_PARM_DESC(default_dev_flags,
  **/
 void scsi_exit_devinfo(void)
 {
-        struct list_head *lh, *lh_next;
-        struct scsi_dev_info_list *devinfo;
-
 #ifdef CONFIG_SCSI_PROC_FS
         remove_proc_entry("scsi/device_info", NULL);
 #endif
 
-        list_for_each_safe(lh, lh_next, &scsi_dev_info_list) {
+        scsi_dev_info_remove_list(SCSI_DEVINFO_GLOBAL);
+}
+
+/**
+ * scsi_dev_info_add_list - add a new devinfo list
+ * @key:        key of the list to add
+ * @name:       Name of the list to add (for /proc/scsi/device_info)
+ *
+ * Adds the requested list, returns zero on success, -EEXIST if the
+ * key is already registered to a list, or other error on failure.
+ */
+int scsi_dev_info_add_list(int key, const char *name)
+{
+        struct scsi_dev_info_list_table *devinfo_table =
+                scsi_devinfo_lookup_by_key(key);
+
+        if (!IS_ERR(devinfo_table))
+                /* list already exists */
+                return -EEXIST;
+
+        devinfo_table = kmalloc(sizeof(*devinfo_table), GFP_KERNEL);
+
+        if (!devinfo_table)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&devinfo_table->node);
+        INIT_LIST_HEAD(&devinfo_table->scsi_dev_info_list);
+        devinfo_table->name = name;
+        devinfo_table->key = key;
+        list_add_tail(&devinfo_table->node, &scsi_dev_info_list);
+
+        return 0;
+}
+EXPORT_SYMBOL(scsi_dev_info_add_list);
+
+/**
+ * scsi_dev_info_remove_list - destroy an added devinfo list
+ * @key: key of the list to destroy
+ *
+ * Iterates over the entire list first, freeing all the values, then
+ * frees the list itself.  Returns 0 on success or -EINVAL if the key
+ * can't be found.
+ */
+int scsi_dev_info_remove_list(int key)
+{
+        struct list_head *lh, *lh_next;
+        struct scsi_dev_info_list_table *devinfo_table =
+                scsi_devinfo_lookup_by_key(key);
+
+        if (IS_ERR(devinfo_table))
+                /* no such list */
+                return -EINVAL;
+
+        /* remove from the master list */
+        list_del(&devinfo_table->node);
+
+        list_for_each_safe(lh, lh_next, &devinfo_table->scsi_dev_info_list) {
+                struct scsi_dev_info_list *devinfo;
+
                 devinfo = list_entry(lh, struct scsi_dev_info_list,
                                      dev_info_list);
                 kfree(devinfo);
         }
+        kfree(devinfo_table);
+
+        return 0;
 }
+EXPORT_SYMBOL(scsi_dev_info_remove_list);
 
 /**
  * scsi_init_devinfo - set up the dynamic device list.
@@ -577,10 +776,14 @@ int __init scsi_init_devinfo(void)
 #endif
         int error, i;
 
-        error = scsi_dev_info_list_add_str(scsi_dev_flags);
+        error = scsi_dev_info_add_list(SCSI_DEVINFO_GLOBAL, NULL);
         if (error)
                 return error;
 
+        error = scsi_dev_info_list_add_str(scsi_dev_flags);
+        if (error)
+                goto out;
+
         for (i = 0; scsi_static_device_list[i].vendor; i++) {
                 error = scsi_dev_info_list_add(1 /* compatibile */,
                                 scsi_static_device_list[i].vendor,
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index 30f3275e119e..f3c40898fc7d 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1207,6 +1207,7 @@ int scsi_prep_fn(struct request_queue *q, struct request *req)
                 ret = scsi_setup_blk_pc_cmnd(sdev, req);
         return scsi_prep_return(q, req, ret);
 }
+EXPORT_SYMBOL(scsi_prep_fn);
 
 /*
  * scsi_dev_queue_ready: if we can send requests to sdev, return 1 else
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index fbc83bebdd8e..021e503c8c44 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -39,9 +39,25 @@ static inline void scsi_log_completion(struct scsi_cmnd *cmd, int disposition)
 #endif
 
 /* scsi_devinfo.c */
+
+/* list of keys for the lists */
+enum {
+        SCSI_DEVINFO_GLOBAL = 0,
+        SCSI_DEVINFO_SPI,
+};
+
 extern int scsi_get_device_flags(struct scsi_device *sdev,
                                  const unsigned char *vendor,
                                  const unsigned char *model);
+extern int scsi_get_device_flags_keyed(struct scsi_device *sdev,
+                                       const unsigned char *vendor,
+                                       const unsigned char *model, int key);
+extern int scsi_dev_info_list_add_keyed(int compatible, char *vendor,
+                                        char *model, char *strflags,
+                                        int flags, int key);
+extern int scsi_dev_info_add_list(int key, const char *name);
+extern int scsi_dev_info_remove_list(int key);
+
 extern int __init scsi_init_devinfo(void);
 extern void scsi_exit_devinfo(void);
 
@@ -71,7 +87,6 @@ extern int scsi_init_queue(void);
 extern void scsi_exit_queue(void);
 struct request_queue;
 struct request;
-extern int scsi_prep_fn(struct request_queue *, struct request *);
 extern struct kmem_cache *scsi_sdb_cache;
 
 /* scsi_proc.c */
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index fa4711d12744..91482f2dcc50 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -420,29 +420,12 @@ static int scsi_bus_resume(struct device * dev)
         return err;
 }
 
-static int scsi_bus_remove(struct device *dev)
-{
-        struct device_driver *drv = dev->driver;
-        struct scsi_device *sdev = to_scsi_device(dev);
-        int err = 0;
-
-        /* reset the prep_fn back to the default since the
-         * driver may have altered it and it's being removed */
-        blk_queue_prep_rq(sdev->request_queue, scsi_prep_fn);
-
-        if (drv && drv->remove)
-                err = drv->remove(dev);
-
-        return 0;
-}
-
 struct bus_type scsi_bus_type = {
         .name           = "scsi",
         .match          = scsi_bus_match,
         .uevent         = scsi_bus_uevent,
         .suspend        = scsi_bus_suspend,
         .resume         = scsi_bus_resume,
-        .remove         = scsi_bus_remove,
 };
 EXPORT_SYMBOL_GPL(scsi_bus_type);
 
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 3f64d93b6c8b..2eee9e6e4fe8 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -3397,7 +3397,6 @@ fc_destroy_bsgjob(struct fc_bsg_job *job)
         kfree(job);
 }
 
-
 /**
  * fc_bsg_jobdone - completion routine for bsg requests that the LLD has
  *                  completed
@@ -3408,15 +3407,10 @@ fc_bsg_jobdone(struct fc_bsg_job *job)
 {
         struct request *req = job->req;
         struct request *rsp = req->next_rq;
-        unsigned long flags;
         int err;
 
-        spin_lock_irqsave(&job->job_lock, flags);
-        job->state_flags |= FC_RQST_STATE_DONE;
-        job->ref_cnt--;
-        spin_unlock_irqrestore(&job->job_lock, flags);
-
         err = job->req->errors = job->reply->result;
+
         if (err < 0)
                 /* we're only returning the result field in the reply */
                 job->req->sense_len = sizeof(uint32_t);
@@ -3433,13 +3427,27 @@ fc_bsg_jobdone(struct fc_bsg_job *job)
                 rsp->resid_len -= min(job->reply->reply_payload_rcv_len,
                                       rsp->resid_len);
         }
+        blk_complete_request(req);
+}
 
-        blk_end_request_all(req, err);
+/**
+ * fc_bsg_softirq_done - softirq done routine for destroying the bsg requests
+ * @req:        BSG request that holds the job to be destroyed
+ */
+static void fc_bsg_softirq_done(struct request *rq)
+{
+        struct fc_bsg_job *job = rq->special;
+        unsigned long flags;
 
+        spin_lock_irqsave(&job->job_lock, flags);
+        job->state_flags |= FC_RQST_STATE_DONE;
+        job->ref_cnt--;
+        spin_unlock_irqrestore(&job->job_lock, flags);
+
+        blk_end_request_all(rq, rq->errors);
         fc_destroy_bsgjob(job);
 }
 
-
 /**
  * fc_bsg_job_timeout - handler for when a bsg request timesout
  * @req:        request that timed out
@@ -3471,19 +3479,13 @@ fc_bsg_job_timeout(struct request *req)
                                 "abort failed with status %d\n", err);
         }
 
-        if (!done) {
-                spin_lock_irqsave(&job->job_lock, flags);
-                job->ref_cnt--;
-                spin_unlock_irqrestore(&job->job_lock, flags);
-                fc_destroy_bsgjob(job);
-        }
-
         /* the blk_end_sync_io() doesn't check the error */
-        return BLK_EH_HANDLED;
+        if (done)
+                return BLK_EH_NOT_HANDLED;
+        else
+                return BLK_EH_HANDLED;
 }
 
-
-
 static int
 fc_bsg_map_buffer(struct fc_bsg_buffer *buf, struct request *req)
 {
@@ -3859,7 +3861,7 @@ fc_bsg_hostadd(struct Scsi_Host *shost, struct fc_host_attrs *fc_host)
         struct fc_internal *i = to_fc_internal(shost->transportt);
         struct request_queue *q;
         int err;
-        char bsg_name[BUS_ID_SIZE]; /*20*/
+        char bsg_name[20];
 
         fc_host->rqst_q = NULL;
 
@@ -3879,6 +3881,7 @@ fc_bsg_hostadd(struct Scsi_Host *shost, struct fc_host_attrs *fc_host)
 
         q->queuedata = shost;
         queue_flag_set_unlocked(QUEUE_FLAG_BIDI, q);
+        blk_queue_softirq_done(q, fc_bsg_softirq_done);
         blk_queue_rq_timed_out(q, fc_bsg_job_timeout);
         blk_queue_rq_timeout(q, FC_DEFAULT_BSG_TIMEOUT);
 
@@ -3924,6 +3927,7 @@ fc_bsg_rportadd(struct Scsi_Host *shost, struct fc_rport *rport)
 
         q->queuedata = rport;
         queue_flag_set_unlocked(QUEUE_FLAG_BIDI, q);
+        blk_queue_softirq_done(q, fc_bsg_softirq_done);
         blk_queue_rq_timed_out(q, fc_bsg_job_timeout);
         blk_queue_rq_timeout(q, BLK_DEFAULT_SG_TIMEOUT);
 
diff --git a/drivers/scsi/scsi_transport_iscsi.c b/drivers/scsi/scsi_transport_iscsi.c
index f3e664628d7a..783e33c65eb7 100644
--- a/drivers/scsi/scsi_transport_iscsi.c
+++ b/drivers/scsi/scsi_transport_iscsi.c
@@ -692,6 +692,7 @@ int iscsi_add_session(struct iscsi_cls_session *session, unsigned int target_id)
                                                  "Too many iscsi targets. Max "
                                                  "number of targets is %d.\n",
                                                  ISCSI_MAX_TARGET - 1);
+                        err = -EOVERFLOW;
                         goto release_host;
                 }
         }
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index d606452297cf..0895d3c71b03 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -173,9 +173,9 @@ static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
                 ret = handler(shost, rphy, req);
                 req->errors = ret;
 
-                spin_lock_irq(q->queue_lock);
+                blk_end_request_all(req, ret);
 
-                req->end_io(req, ret);
+                spin_lock_irq(q->queue_lock);
         }
 }
 
diff --git a/drivers/scsi/scsi_transport_spi.c b/drivers/scsi/scsi_transport_spi.c
index 654a34fb04cb..c25bd9a34e02 100644
--- a/drivers/scsi/scsi_transport_spi.c
+++ b/drivers/scsi/scsi_transport_spi.c
@@ -46,6 +46,22 @@
 #define DV_RETRIES      3       /* should only need at most 
                                  * two cc/ua clears */
 
+/* Our blacklist flags */
+enum {
+        SPI_BLIST_NOIUS = 0x1,
+};
+
+/* blacklist table, modelled on scsi_devinfo.c */
+static struct {
+        char *vendor;
+        char *model;
+        unsigned flags;
+} spi_static_device_list[] __initdata = {
+        {"HP", "Ultrium 3-SCSI", SPI_BLIST_NOIUS },
+        {"IBM", "ULTRIUM-TD3", SPI_BLIST_NOIUS },
+        {NULL, NULL, 0}
+};
+
 /* Private data accessors (keep these out of the header file) */
 #define spi_dv_in_progress(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_in_progress)
 #define spi_dv_mutex(x) (((struct spi_transport_attrs *)&(x)->starget_data)->dv_mutex)
@@ -207,6 +223,9 @@ static int spi_device_configure(struct transport_container *tc,
 {
         struct scsi_device *sdev = to_scsi_device(dev);
         struct scsi_target *starget = sdev->sdev_target;
+        unsigned bflags = scsi_get_device_flags_keyed(sdev, &sdev->inquiry[8],
+                                                      &sdev->inquiry[16],
+                                                      SCSI_DEVINFO_SPI);
 
         /* Populate the target capability fields with the values
          * gleaned from the device inquiry */
@@ -216,6 +235,10 @@ static int spi_device_configure(struct transport_container *tc,
         spi_support_dt(starget) = scsi_device_dt(sdev);
         spi_support_dt_only(starget) = scsi_device_dt_only(sdev);
         spi_support_ius(starget) = scsi_device_ius(sdev);
+        if (bflags & SPI_BLIST_NOIUS) {
+                dev_info(dev, "Information Units disabled by blacklist\n");
+                spi_support_ius(starget) = 0;
+        }
         spi_support_qas(starget) = scsi_device_qas(sdev);
 
         return 0;
@@ -833,7 +856,7 @@ spi_dv_device_internal(struct scsi_device *sdev, u8 *buffer)
                 return;
         }
 
-        if (!scsi_device_wide(sdev)) {
+        if (!spi_support_wide(starget)) {
                 spi_max_width(starget) = 0;
                 max_width = 0;
         }
@@ -860,7 +883,7 @@ spi_dv_device_internal(struct scsi_device *sdev, u8 *buffer)
                 return;
 
         /* device can't handle synchronous */
-        if (!scsi_device_sync(sdev) && !scsi_device_dt(sdev))
+        if (!spi_support_sync(starget) && !spi_support_dt(starget))
                 return;
 
         /* len == -1 is the signal that we need to ascertain the
@@ -876,13 +899,14 @@ spi_dv_device_internal(struct scsi_device *sdev, u8 *buffer)
 
         /* try QAS requests; this should be harmless to set if the
          * target supports it */
-        if (scsi_device_qas(sdev) && spi_max_qas(starget)) {
+        if (spi_support_qas(starget) && spi_max_qas(starget)) {
                 DV_SET(qas, 1);
         } else {
                 DV_SET(qas, 0);
         }
 
-        if (scsi_device_ius(sdev) && spi_max_iu(starget) && min_period < 9) {
+        if (spi_support_ius(starget) && spi_max_iu(starget) &&
+            min_period < 9) {
                 /* This u320 (or u640). Set IU transfers */
                 DV_SET(iu, 1);
                 /* Then set the optional parameters */
@@ -902,7 +926,7 @@ spi_dv_device_internal(struct scsi_device *sdev, u8 *buffer)
                 i->f->get_signalling(shost);
         if (spi_signalling(shost) == SPI_SIGNAL_SE ||
             spi_signalling(shost) == SPI_SIGNAL_HVD ||
-            !scsi_device_dt(sdev)) {
+            !spi_support_dt(starget)) {
                 DV_SET(dt, 0);
         } else {
                 DV_SET(dt, 1);
@@ -1523,7 +1547,21 @@ EXPORT_SYMBOL(spi_release_transport);
 
 static __init int spi_transport_init(void)
 {
-        int error = transport_class_register(&spi_transport_class);
+        int error = scsi_dev_info_add_list(SCSI_DEVINFO_SPI,
+                                           "SCSI Parallel Transport Class");
+        if (!error) {
+                int i;
+
+                for (i = 0; spi_static_device_list[i].vendor; i++)
+                        scsi_dev_info_list_add_keyed(1, /* compatible */
+                                                     spi_static_device_list[i].vendor,
+                                                     spi_static_device_list[i].model,
+                                                     NULL,
+                                                     spi_static_device_list[i].flags,
+                                                     SCSI_DEVINFO_SPI);
+        }
+
+        error = transport_class_register(&spi_transport_class);
         if (error)
                 return error;
         error = anon_transport_class_register(&spi_device_class);
@@ -1535,6 +1573,7 @@ static void __exit spi_transport_exit(void)
         transport_class_unregister(&spi_transport_class);
         anon_transport_class_unregister(&spi_device_class);
         transport_class_unregister(&spi_host_class);
+        scsi_dev_info_remove_list(SCSI_DEVINFO_SPI);
 }
 
 MODULE_AUTHOR("Martin Hicks");
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 878b17a9af30..5616cd780ff3 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1307,6 +1307,7 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
         int sense_valid = 0;
         int the_result;
         int retries = 3;
+        unsigned int alignment;
         unsigned long long lba;
         unsigned sector_size;
 
@@ -1358,6 +1359,16 @@ static int read_capacity_16(struct scsi_disk *sdkp, struct scsi_device *sdp,
                 return -EOVERFLOW;
         }
 
+        /* Logical blocks per physical block exponent */
+        sdkp->hw_sector_size = (1 << (buffer[13] & 0xf)) * sector_size;
+
+        /* Lowest aligned logical block */
+        alignment = ((buffer[14] & 0x3f) << 8 | buffer[15]) * sector_size;
+        blk_queue_alignment_offset(sdp->request_queue, alignment);
+        if (alignment && sdkp->first_scan)
+                sd_printk(KERN_NOTICE, sdkp,
+                          "physical block alignment offset: %u\n", alignment);
+
         sdkp->capacity = lba + 1;
         return sector_size;
 }
@@ -1409,6 +1420,7 @@ static int read_capacity_10(struct scsi_disk *sdkp, struct scsi_device *sdp,
         }
 
         sdkp->capacity = lba + 1;
+        sdkp->hw_sector_size = sector_size;
         return sector_size;
 }
 
@@ -1521,11 +1533,17 @@ got_data:
                 string_get_size(sz, STRING_UNITS_10, cap_str_10,
                                 sizeof(cap_str_10));
 
-                if (sdkp->first_scan || old_capacity != sdkp->capacity)
+                if (sdkp->first_scan || old_capacity != sdkp->capacity) {
                         sd_printk(KERN_NOTICE, sdkp,
-                                  "%llu %d-byte hardware sectors: (%s/%s)\n",
+                                  "%llu %d-byte logical blocks: (%s/%s)\n",
                                   (unsigned long long)sdkp->capacity,
                                   sector_size, cap_str_10, cap_str_2);
+
+                        if (sdkp->hw_sector_size != sector_size)
+                                sd_printk(KERN_NOTICE, sdkp,
+                                          "%u-byte physical blocks\n",
+                                          sdkp->hw_sector_size);
+                }
         }
 
         /* Rescale capacity to 512-byte units */
@@ -1538,6 +1556,7 @@ got_data:
         else if (sector_size == 256)
                 sdkp->capacity >>= 1;
 
+        blk_queue_physical_block_size(sdp->request_queue, sdkp->hw_sector_size);
         sdkp->device->sector_size = sector_size;
 }
 
@@ -1776,6 +1795,52 @@ void sd_read_app_tag_own(struct scsi_disk *sdkp, unsigned char *buffer)
 }
 
 /**
+ * sd_read_block_limits - Query disk device for preferred I/O sizes.
+ * @disk: disk to query
+ */
+static void sd_read_block_limits(struct scsi_disk *sdkp)
+{
+        unsigned int sector_sz = sdkp->device->sector_size;
+        char *buffer;
+
+        /* Block Limits VPD */
+        buffer = scsi_get_vpd_page(sdkp->device, 0xb0);
+
+        if (buffer == NULL)
+                return;
+
+        blk_queue_io_min(sdkp->disk->queue,
+                         get_unaligned_be16(&buffer[6]) * sector_sz);
+        blk_queue_io_opt(sdkp->disk->queue,
+                         get_unaligned_be32(&buffer[12]) * sector_sz);
+
+        kfree(buffer);
+}
+
+/**
+ * sd_read_block_characteristics - Query block dev. characteristics
+ * @disk: disk to query
+ */
+static void sd_read_block_characteristics(struct scsi_disk *sdkp)
+{
+        char *buffer;
+        u16 rot;
+
+        /* Block Device Characteristics VPD */
+        buffer = scsi_get_vpd_page(sdkp->device, 0xb1);
+
+        if (buffer == NULL)
+                return;
+
+        rot = get_unaligned_be16(&buffer[4]);
+
+        if (rot == 1)
+                queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
+
+        kfree(buffer);
+}
+
+/**
  *      sd_revalidate_disk - called the first time a new disk is seen,
  *      performs disk spin up, read_capacity, etc.
  *      @disk: struct gendisk we care about
@@ -1812,6 +1877,8 @@ static int sd_revalidate_disk(struct gendisk *disk)
          */
         if (sdkp->media_present) {
                 sd_read_capacity(sdkp, buffer);
+                sd_read_block_limits(sdkp);
+                sd_read_block_characteristics(sdkp);
                 sd_read_write_protect_flag(sdkp, buffer);
                 sd_read_cache_type(sdkp, buffer);
                 sd_read_app_tag_own(sdkp, buffer);
@@ -1934,6 +2001,8 @@ static void sd_probe_async(void *data, async_cookie_t cookie)
         add_disk(gd);
         sd_dif_config_host(sdkp);
 
+        sd_revalidate_disk(gd);
+
         sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
                   sdp->removable ? "removable " : "");
 }
@@ -2054,6 +2123,7 @@ static int sd_remove(struct device *dev)
 
         async_synchronize_full();
         sdkp = dev_get_drvdata(dev);
+        blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn);
         device_del(&sdkp->dev);
         del_gendisk(sdkp->disk);
         sd_shutdown(dev);
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 708778cf5f06..8474b5bad3fe 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -45,6 +45,7 @@ struct scsi_disk {
         unsigned int    openers;        /* protected by BKL for now, yuck */
         sector_t        capacity;       /* size in 512-byte sectors */
         u32             index;
+        unsigned short  hw_sector_size;
         u8              media_present;
         u8              write_prot;
         u8              protection_type;/* Data Integrity Field */
diff --git a/drivers/scsi/sr.c b/drivers/scsi/sr.c
index cd350dfc1216..cce0fe4c8a3b 100644
--- a/drivers/scsi/sr.c
+++ b/drivers/scsi/sr.c
@@ -881,6 +881,7 @@ static int sr_remove(struct device *dev)
 {
         struct scsi_cd *cd = dev_get_drvdata(dev);
 
+        blk_queue_prep_rq(cd->device->request_queue, scsi_prep_fn);
         del_gendisk(cd->disk);
 
         mutex_lock(&sr_ref_mutex);
diff --git a/drivers/scsi/sym53c8xx_2/sym_hipd.c b/drivers/scsi/sym53c8xx_2/sym_hipd.c
index 69ad4945c936..297deb817a5d 100644
--- a/drivers/scsi/sym53c8xx_2/sym_hipd.c
+++ b/drivers/scsi/sym53c8xx_2/sym_hipd.c
@@ -2321,8 +2321,9 @@ static void sym_int_par (struct sym_hcb *np, u_short sist)
         int phase       = cmd & 7;
         struct sym_ccb *cp      = sym_ccb_from_dsa(np, dsa);
 
-        printf("%s: SCSI parity error detected: SCR1=%d DBC=%x SBCL=%x\n",
-                sym_name(np), hsts, dbc, sbcl);
+        if (printk_ratelimit())
+                printf("%s: SCSI parity error detected: SCR1=%d DBC=%x SBCL=%x\n",
+                        sym_name(np), hsts, dbc, sbcl);
 
         /*
          *  Check that the chip is connected to the SCSI BUS.
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index e371a9c15341..a07015d646dd 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -398,8 +398,7 @@ static int sbs_init(struct pci_dev *dev)
 {
         u8 __iomem *p;
 
-        p = ioremap_nocache(pci_resource_start(dev, 0),
-                                                pci_resource_len(dev, 0));
+        p = pci_ioremap_bar(dev, 0);
 
         if (p == NULL)
                 return -ENOMEM;
@@ -423,8 +422,7 @@ static void __devexit sbs_exit(struct pci_dev *dev)
 {
         u8 __iomem *p;
 
-        p = ioremap_nocache(pci_resource_start(dev, 0),
-                                        pci_resource_len(dev, 0));
+        p = pci_ioremap_bar(dev, 0);
         /* FIXME: What if resource_len < OCT_REG_CR_OFF */
         if (p != NULL)
                 writeb(0, p + OCT_REG_CR_OFF);
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 9f2891c2c4a2..cd1b6a45bb82 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -1548,8 +1548,7 @@ static int __devinit icom_probe(struct pci_dev *dev,
                 goto probe_exit1;
         }
 
-         icom_adapter->base_addr = ioremap(icom_adapter->base_addr_pci,
-                                                pci_resource_len(dev, 0));
+         icom_adapter->base_addr = pci_ioremap_bar(dev, 0);
 
         if (!icom_adapter->base_addr)
                 goto probe_exit1;
diff --git a/drivers/serial/jsm/jsm_tty.c b/drivers/serial/jsm/jsm_tty.c
index 107ce2e187b8..00f4577d2f7f 100644
--- a/drivers/serial/jsm/jsm_tty.c
+++ b/drivers/serial/jsm/jsm_tty.c
@@ -467,7 +467,7 @@ int __devinit jsm_uart_port_init(struct jsm_board *brd)
                         printk(KERN_INFO "jsm: linemap is full, added device failed\n");
                         continue;
                 } else
-                        set_bit((int)line, linemap);
+                        set_bit(line, linemap);
                 brd->channels[i]->uart_port.line = line;
                 if (uart_add_one_port (&jsm_uart_driver, &brd->channels[i]->uart_port))
                         printk(KERN_INFO "jsm: add device failed\n");
@@ -503,7 +503,7 @@ int jsm_remove_uart_port(struct jsm_board *brd)
 
                 ch = brd->channels[i];
 
-                clear_bit((int)(ch->uart_port.line), linemap);
+                clear_bit(ch->uart_port.line, linemap);
                 uart_remove_one_port(&jsm_uart_driver, &brd->channels[i]->uart_port);
         }
 
diff --git a/drivers/serial/serial_txx9.c b/drivers/serial/serial_txx9.c
index 7313c2edcb83..54dd16d66a4b 100644
--- a/drivers/serial/serial_txx9.c
+++ b/drivers/serial/serial_txx9.c
@@ -461,6 +461,94 @@ static void serial_txx9_break_ctl(struct uart_port *port, int break_state)
         spin_unlock_irqrestore(&up->port.lock, flags);
 }
 
+#if defined(CONFIG_SERIAL_TXX9_CONSOLE) || (CONFIG_CONSOLE_POLL)
+/*
+ *      Wait for transmitter & holding register to empty
+ */
+static void wait_for_xmitr(struct uart_txx9_port *up)
+{
+        unsigned int tmout = 10000;
+
+        /* Wait up to 10ms for the character(s) to be sent. */
+        while (--tmout &&
+               !(sio_in(up, TXX9_SICISR) & TXX9_SICISR_TXALS))
+                udelay(1);
+
+        /* Wait up to 1s for flow control if necessary */
+        if (up->port.flags & UPF_CONS_FLOW) {
+                tmout = 1000000;
+                while (--tmout &&
+                       (sio_in(up, TXX9_SICISR) & TXX9_SICISR_CTSS))
+                        udelay(1);
+        }
+}
+#endif
+
+#ifdef CONFIG_CONSOLE_POLL
+/*
+ * Console polling routines for writing and reading from the uart while
+ * in an interrupt or debug context.
+ */
+
+static int serial_txx9_get_poll_char(struct uart_port *port)
+{
+        unsigned int ier;
+        unsigned char c;
+        struct uart_txx9_port *up = (struct uart_txx9_port *)port;
+
+        /*
+         *      First save the IER then disable the interrupts
+         */
+        ier = sio_in(up, TXX9_SIDICR);
+        sio_out(up, TXX9_SIDICR, 0);
+
+        while (sio_in(up, TXX9_SIDISR) & TXX9_SIDISR_UVALID)
+                ;
+
+        c = sio_in(up, TXX9_SIRFIFO);
+
+        /*
+         *      Finally, clear RX interrupt status
+         *      and restore the IER
+         */
+        sio_mask(up, TXX9_SIDISR, TXX9_SIDISR_RDIS);
+        sio_out(up, TXX9_SIDICR, ier);
+        return c;
+}
+
+
+static void serial_txx9_put_poll_char(struct uart_port *port, unsigned char c)
+{
+        unsigned int ier;
+        struct uart_txx9_port *up = (struct uart_txx9_port *)port;
+
+        /*
+         *      First save the IER then disable the interrupts
+         */
+        ier = sio_in(up, TXX9_SIDICR);
+        sio_out(up, TXX9_SIDICR, 0);
+
+        wait_for_xmitr(up);
+        /*
+         *      Send the character out.
+         *      If a LF, also do CR...
+         */
+        sio_out(up, TXX9_SITFIFO, c);
+        if (c == 10) {
+                wait_for_xmitr(up);
+                sio_out(up, TXX9_SITFIFO, 13);
+        }
+
+        /*
+         *      Finally, wait for transmitter to become empty
+         *      and restore the IER
+         */
+        wait_for_xmitr(up);
+        sio_out(up, TXX9_SIDICR, ier);
+}
+
+#endif /* CONFIG_CONSOLE_POLL */
+
 static int serial_txx9_startup(struct uart_port *port)
 {
         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
@@ -781,6 +869,10 @@ static struct uart_ops serial_txx9_pops = {
         .release_port   = serial_txx9_release_port,
         .request_port   = serial_txx9_request_port,
         .config_port    = serial_txx9_config_port,
+#ifdef CONFIG_CONSOLE_POLL
+        .poll_get_char  = serial_txx9_get_poll_char,
+        .poll_put_char  = serial_txx9_put_poll_char,
+#endif
 };
 
 static struct uart_txx9_port serial_txx9_ports[UART_NR];
@@ -803,27 +895,6 @@ static void __init serial_txx9_register_ports(struct uart_driver *drv,
 
 #ifdef CONFIG_SERIAL_TXX9_CONSOLE
 
-/*
- *      Wait for transmitter & holding register to empty
- */
-static inline void wait_for_xmitr(struct uart_txx9_port *up)
-{
-        unsigned int tmout = 10000;
-
-        /* Wait up to 10ms for the character(s) to be sent. */
-        while (--tmout &&
-               !(sio_in(up, TXX9_SICISR) & TXX9_SICISR_TXALS))
-                udelay(1);
-
-        /* Wait up to 1s for flow control if necessary */
-        if (up->port.flags & UPF_CONS_FLOW) {
-                tmout = 1000000;
-                while (--tmout &&
-                       (sio_in(up, TXX9_SICISR) & TXX9_SICISR_CTSS))
-                        udelay(1);
-        }
-}
-
 static void serial_txx9_console_putchar(struct uart_port *port, int ch)
 {
         struct uart_txx9_port *up = (struct uart_txx9_port *)port;
diff --git a/drivers/staging/octeon/Makefile b/drivers/staging/octeon/Makefile
index 3c839e37d37f..c0a583cc2227 100644
--- a/drivers/staging/octeon/Makefile
+++ b/drivers/staging/octeon/Makefile
@@ -12,7 +12,6 @@
 obj-${CONFIG_OCTEON_ETHERNET} :=  octeon-ethernet.o
 
 octeon-ethernet-objs := ethernet.o
-octeon-ethernet-objs += ethernet-common.o
 octeon-ethernet-objs += ethernet-mdio.o
 octeon-ethernet-objs += ethernet-mem.o
 octeon-ethernet-objs += ethernet-proc.o
diff --git a/drivers/staging/octeon/ethernet-common.c b/drivers/staging/octeon/ethernet-common.c
deleted file mode 100644
index 3e6f5b8cc63d..000000000000
--- a/drivers/staging/octeon/ethernet-common.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/**********************************************************************
- * Author: Cavium Networks
- *
- * Contact: support@caviumnetworks.com
- * This file is part of the OCTEON SDK
- *
- * Copyright (c) 2003-2007 Cavium Networks
- *
- * This file is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, Version 2, as
- * published by the Free Software Foundation.
- *
- * This file is distributed in the hope that it will be useful, but
- * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
- * NONINFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this file; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- * or visit http://www.gnu.org/licenses/.
- *
- * This file may also be available under a different license from Cavium.
- * Contact Cavium Networks for more information
-**********************************************************************/
-#include <linux/kernel.h>
-#include <linux/mii.h>
-#include <net/dst.h>
-
-#include <asm/atomic.h>
-#include <asm/octeon/octeon.h>
-
-#include "ethernet-defines.h"
-#include "ethernet-tx.h"
-#include "ethernet-mdio.h"
-#include "ethernet-util.h"
-#include "octeon-ethernet.h"
-#include "ethernet-common.h"
-
-#include "cvmx-pip.h"
-#include "cvmx-pko.h"
-#include "cvmx-fau.h"
-#include "cvmx-helper.h"
-
-#include "cvmx-gmxx-defs.h"
-
-/**
- * Get the low level ethernet statistics
- *
- * @dev:    Device to get the statistics from
- * Returns Pointer to the statistics
- */
-static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev)
-{
-        cvmx_pip_port_status_t rx_status;
-        cvmx_pko_port_status_t tx_status;
-        struct octeon_ethernet *priv = netdev_priv(dev);
-
-        if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) {
-                if (octeon_is_simulation()) {
-                        /* The simulator doesn't support statistics */
-                        memset(&rx_status, 0, sizeof(rx_status));
-                        memset(&tx_status, 0, sizeof(tx_status));
-                } else {
-                        cvmx_pip_get_port_status(priv->port, 1, &rx_status);
-                        cvmx_pko_get_port_status(priv->port, 1, &tx_status);
-                }
-
-                priv->stats.rx_packets += rx_status.inb_packets;
-                priv->stats.tx_packets += tx_status.packets;
-                priv->stats.rx_bytes += rx_status.inb_octets;
-                priv->stats.tx_bytes += tx_status.octets;
-                priv->stats.multicast += rx_status.multicast_packets;
-                priv->stats.rx_crc_errors += rx_status.inb_errors;
-                priv->stats.rx_frame_errors += rx_status.fcs_align_err_packets;
-
-                /*
-                 * The drop counter must be incremented atomically
-                 * since the RX tasklet also increments it.
-                 */
-#ifdef CONFIG_64BIT
-                atomic64_add(rx_status.dropped_packets,
-                             (atomic64_t *)&priv->stats.rx_dropped);
-#else
-                atomic_add(rx_status.dropped_packets,
-                             (atomic_t *)&priv->stats.rx_dropped);
-#endif
-        }
-
-        return &priv->stats;
-}
-
-/**
- * Set the multicast list. Currently unimplemented.
- *
- * @dev:    Device to work on
- */
-static void cvm_oct_common_set_multicast_list(struct net_device *dev)
-{
-        union cvmx_gmxx_prtx_cfg gmx_cfg;
-        struct octeon_ethernet *priv = netdev_priv(dev);
-        int interface = INTERFACE(priv->port);
-        int index = INDEX(priv->port);
-
-        if ((interface < 2)
-            && (cvmx_helper_interface_get_mode(interface) !=
-                CVMX_HELPER_INTERFACE_MODE_SPI)) {
-                union cvmx_gmxx_rxx_adr_ctl control;
-                control.u64 = 0;
-                control.s.bcst = 1;     /* Allow broadcast MAC addresses */
-
-                if (dev->mc_list || (dev->flags & IFF_ALLMULTI) ||
-                    (dev->flags & IFF_PROMISC))
-                        /* Force accept multicast packets */
-                        control.s.mcst = 2;
-                else
-                        /* Force reject multicat packets */
-                        control.s.mcst = 1;
-
-                if (dev->flags & IFF_PROMISC)
-                        /*
-                         * Reject matches if promisc. Since CAM is
-                         * shut off, should accept everything.
-                         */
-                        control.s.cam_mode = 0;
-                else
-                        /* Filter packets based on the CAM */
-                        control.s.cam_mode = 1;
-
-                gmx_cfg.u64 =
-                    cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
-                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
-                               gmx_cfg.u64 & ~1ull);
-
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface),
-                               control.u64);
-                if (dev->flags & IFF_PROMISC)
-                        cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
-                                       (index, interface), 0);
-                else
-                        cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
-                                       (index, interface), 1);
-
-                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
-                               gmx_cfg.u64);
-        }
-}
-
-/**
- * Set the hardware MAC address for a device
- *
- * @dev:    Device to change the MAC address for
- * @addr:   Address structure to change it too. MAC address is addr + 2.
- * Returns Zero on success
- */
-static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr)
-{
-        struct octeon_ethernet *priv = netdev_priv(dev);
-        union cvmx_gmxx_prtx_cfg gmx_cfg;
-        int interface = INTERFACE(priv->port);
-        int index = INDEX(priv->port);
-
-        memcpy(dev->dev_addr, addr + 2, 6);
-
-        if ((interface < 2)
-            && (cvmx_helper_interface_get_mode(interface) !=
-                CVMX_HELPER_INTERFACE_MODE_SPI)) {
-                int i;
-                uint8_t *ptr = addr;
-                uint64_t mac = 0;
-                for (i = 0; i < 6; i++)
-                        mac = (mac << 8) | (uint64_t) (ptr[i + 2]);
-
-                gmx_cfg.u64 =
-                    cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
-                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
-                               gmx_cfg.u64 & ~1ull);
-
-                cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac);
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface),
-                               ptr[2]);
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface),
-                               ptr[3]);
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface),
-                               ptr[4]);
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface),
-                               ptr[5]);
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface),
-                               ptr[6]);
-                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface),
-                               ptr[7]);
-                cvm_oct_common_set_multicast_list(dev);
-                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
-                               gmx_cfg.u64);
-        }
-        return 0;
-}
-
-/**
- * Change the link MTU. Unimplemented
- *
- * @dev:     Device to change
- * @new_mtu: The new MTU
- *
- * Returns Zero on success
- */
-static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu)
-{
-        struct octeon_ethernet *priv = netdev_priv(dev);
-        int interface = INTERFACE(priv->port);
-        int index = INDEX(priv->port);
-#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
-        int vlan_bytes = 4;
-#else
-        int vlan_bytes = 0;
-#endif
-
-        /*
-         * Limit the MTU to make sure the ethernet packets are between
-         * 64 bytes and 65535 bytes.
-         */
-        if ((new_mtu + 14 + 4 + vlan_bytes < 64)
-            || (new_mtu + 14 + 4 + vlan_bytes > 65392)) {
-                pr_err("MTU must be between %d and %d.\n",
-                       64 - 14 - 4 - vlan_bytes, 65392 - 14 - 4 - vlan_bytes);
-                return -EINVAL;
-        }
-        dev->mtu = new_mtu;
-
-        if ((interface < 2)
-            && (cvmx_helper_interface_get_mode(interface) !=
-                CVMX_HELPER_INTERFACE_MODE_SPI)) {
-                /* Add ethernet header and FCS, and VLAN if configured. */
-                int max_packet = new_mtu + 14 + 4 + vlan_bytes;
-
-                if (OCTEON_IS_MODEL(OCTEON_CN3XXX)
-                    || OCTEON_IS_MODEL(OCTEON_CN58XX)) {
-                        /* Signal errors on packets larger than the MTU */
-                        cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface),
-                                       max_packet);
-                } else {
-                        /*
-                         * Set the hardware to truncate packets larger
-                         * than the MTU and smaller the 64 bytes.
-                         */
-                        union cvmx_pip_frm_len_chkx frm_len_chk;
-                        frm_len_chk.u64 = 0;
-                        frm_len_chk.s.minlen = 64;
-                        frm_len_chk.s.maxlen = max_packet;
-                        cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface),
-                                       frm_len_chk.u64);
-                }
-                /*
-                 * Set the hardware to truncate packets larger than
-                 * the MTU. The jabber register must be set to a
-                 * multiple of 8 bytes, so round up.
-                 */
-                cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface),
-                               (max_packet + 7) & ~7u);
-        }
-        return 0;
-}
-
-/**
- * Per network device initialization
- *
- * @dev:    Device to initialize
- * Returns Zero on success
- */
-int cvm_oct_common_init(struct net_device *dev)
-{
-        static int count;
-        char mac[8] = { 0x00, 0x00,
-                octeon_bootinfo->mac_addr_base[0],
-                octeon_bootinfo->mac_addr_base[1],
-                octeon_bootinfo->mac_addr_base[2],
-                octeon_bootinfo->mac_addr_base[3],
-                octeon_bootinfo->mac_addr_base[4],
-                octeon_bootinfo->mac_addr_base[5] + count
-        };
-        struct octeon_ethernet *priv = netdev_priv(dev);
-
-        /*
-         * Force the interface to use the POW send if always_use_pow
-         * was specified or it is in the pow send list.
-         */
-        if ((pow_send_group != -1)
-            && (always_use_pow || strstr(pow_send_list, dev->name)))
-                priv->queue = -1;
-
-        if (priv->queue != -1) {
-                dev->hard_start_xmit = cvm_oct_xmit;
-                if (USE_HW_TCPUDP_CHECKSUM)
-                        dev->features |= NETIF_F_IP_CSUM;
-        } else
-                dev->hard_start_xmit = cvm_oct_xmit_pow;
-        count++;
-
-        dev->get_stats = cvm_oct_common_get_stats;
-        dev->set_mac_address = cvm_oct_common_set_mac_address;
-        dev->set_multicast_list = cvm_oct_common_set_multicast_list;
-        dev->change_mtu = cvm_oct_common_change_mtu;
-        dev->do_ioctl = cvm_oct_ioctl;
-        /* We do our own locking, Linux doesn't need to */
-        dev->features |= NETIF_F_LLTX;
-        SET_ETHTOOL_OPS(dev, &cvm_oct_ethtool_ops);
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = cvm_oct_poll_controller;
-#endif
-
-        cvm_oct_mdio_setup_device(dev);
-        dev->set_mac_address(dev, mac);
-        dev->change_mtu(dev, dev->mtu);
-
-        /*
-         * Zero out stats for port so we won't mistakenly show
-         * counters from the bootloader.
-         */
-        memset(dev->get_stats(dev), 0, sizeof(struct net_device_stats));
-
-        return 0;
-}
-
-void cvm_oct_common_uninit(struct net_device *dev)
-{
-        /* Currently nothing to do */
-}
diff --git a/drivers/staging/octeon/ethernet-common.h b/drivers/staging/octeon/ethernet-common.h
deleted file mode 100644
index 2bd9cd76a398..000000000000
--- a/drivers/staging/octeon/ethernet-common.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*********************************************************************
- * Author: Cavium Networks
- *
- * Contact: support@caviumnetworks.com
- * This file is part of the OCTEON SDK
- *
- * Copyright (c) 2003-2007 Cavium Networks
- *
- * This file is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License, Version 2, as
- * published by the Free Software Foundation.
- *
- * This file is distributed in the hope that it will be useful, but
- * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
- * NONINFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this file; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- * or visit http://www.gnu.org/licenses/.
- *
- * This file may also be available under a different license from Cavium.
- * Contact Cavium Networks for more information
-*********************************************************************/
-
-int cvm_oct_common_init(struct net_device *dev);
-void cvm_oct_common_uninit(struct net_device *dev);
diff --git a/drivers/staging/octeon/ethernet-defines.h b/drivers/staging/octeon/ethernet-defines.h
index 8f7374e7664c..f13131b03c33 100644
--- a/drivers/staging/octeon/ethernet-defines.h
+++ b/drivers/staging/octeon/ethernet-defines.h
@@ -117,6 +117,8 @@
 
 /* Maximum number of packets to process per interrupt. */
 #define MAX_RX_PACKETS 120
+/* Maximum number of SKBs to try to free per xmit packet. */
+#define MAX_SKB_TO_FREE 10
 #define MAX_OUT_QUEUE_DEPTH 1000
 
 #ifndef CONFIG_SMP
diff --git a/drivers/staging/octeon/ethernet-rgmii.c b/drivers/staging/octeon/ethernet-rgmii.c
index 8579f1670d1e..8704133fe127 100644
--- a/drivers/staging/octeon/ethernet-rgmii.c
+++ b/drivers/staging/octeon/ethernet-rgmii.c
@@ -33,7 +33,6 @@
 
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
-#include "ethernet-common.h"
 #include "ethernet-util.h"
 
 #include "cvmx-helper.h"
@@ -265,7 +264,7 @@ static irqreturn_t cvm_oct_rgmii_rml_interrupt(int cpl, void *dev_id)
         return return_status;
 }
 
-static int cvm_oct_rgmii_open(struct net_device *dev)
+int cvm_oct_rgmii_open(struct net_device *dev)
 {
         union cvmx_gmxx_prtx_cfg gmx_cfg;
         struct octeon_ethernet *priv = netdev_priv(dev);
@@ -286,7 +285,7 @@ static int cvm_oct_rgmii_open(struct net_device *dev)
         return 0;
 }
 
-static int cvm_oct_rgmii_stop(struct net_device *dev)
+int cvm_oct_rgmii_stop(struct net_device *dev)
 {
         union cvmx_gmxx_prtx_cfg gmx_cfg;
         struct octeon_ethernet *priv = netdev_priv(dev);
@@ -305,9 +304,7 @@ int cvm_oct_rgmii_init(struct net_device *dev)
         int r;
 
         cvm_oct_common_init(dev);
-        dev->open = cvm_oct_rgmii_open;
-        dev->stop = cvm_oct_rgmii_stop;
-        dev->stop(dev);
+        dev->netdev_ops->ndo_stop(dev);
 
         /*
          * Due to GMX errata in CN3XXX series chips, it is necessary
diff --git a/drivers/staging/octeon/ethernet-sgmii.c b/drivers/staging/octeon/ethernet-sgmii.c
index 58fa39c1d675..2b54996bd85d 100644
--- a/drivers/staging/octeon/ethernet-sgmii.c
+++ b/drivers/staging/octeon/ethernet-sgmii.c
@@ -34,13 +34,12 @@
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
 #include "ethernet-util.h"
-#include "ethernet-common.h"
 
 #include "cvmx-helper.h"
 
 #include "cvmx-gmxx-defs.h"
 
-static int cvm_oct_sgmii_open(struct net_device *dev)
+int cvm_oct_sgmii_open(struct net_device *dev)
 {
         union cvmx_gmxx_prtx_cfg gmx_cfg;
         struct octeon_ethernet *priv = netdev_priv(dev);
@@ -61,7 +60,7 @@ static int cvm_oct_sgmii_open(struct net_device *dev)
         return 0;
 }
 
-static int cvm_oct_sgmii_stop(struct net_device *dev)
+int cvm_oct_sgmii_stop(struct net_device *dev)
 {
         union cvmx_gmxx_prtx_cfg gmx_cfg;
         struct octeon_ethernet *priv = netdev_priv(dev);
@@ -113,9 +112,7 @@ int cvm_oct_sgmii_init(struct net_device *dev)
 {
         struct octeon_ethernet *priv = netdev_priv(dev);
         cvm_oct_common_init(dev);
-        dev->open = cvm_oct_sgmii_open;
-        dev->stop = cvm_oct_sgmii_stop;
-        dev->stop(dev);
+        dev->netdev_ops->ndo_stop(dev);
         if (!octeon_is_simulation())
                 priv->poll = cvm_oct_sgmii_poll;
 
diff --git a/drivers/staging/octeon/ethernet-spi.c b/drivers/staging/octeon/ethernet-spi.c
index e0971bbe4ddc..66190b0cb68f 100644
--- a/drivers/staging/octeon/ethernet-spi.c
+++ b/drivers/staging/octeon/ethernet-spi.c
@@ -33,7 +33,6 @@
 
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
-#include "ethernet-common.h"
 #include "ethernet-util.h"
 
 #include "cvmx-spi.h"
diff --git a/drivers/staging/octeon/ethernet-tx.c b/drivers/staging/octeon/ethernet-tx.c
index 77b7122c8fdb..81a851390f1b 100644
--- a/drivers/staging/octeon/ethernet-tx.c
+++ b/drivers/staging/octeon/ethernet-tx.c
@@ -47,6 +47,7 @@
 
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
+#include "ethernet-tx.h"
 #include "ethernet-util.h"
 
 #include "cvmx-wqe.h"
@@ -82,8 +83,10 @@ int cvm_oct_xmit(struct sk_buff *skb, struct net_device *dev)
         uint64_t old_scratch2;
         int dropped;
         int qos;
+        int queue_it_up;
         struct octeon_ethernet *priv = netdev_priv(dev);
-        int32_t in_use;
+        int32_t skb_to_free;
+        int32_t undo;
         int32_t buffers_to_free;
 #if REUSE_SKBUFFS_WITHOUT_FREE
         unsigned char *fpa_head;
@@ -120,15 +123,15 @@ int cvm_oct_xmit(struct sk_buff *skb, struct net_device *dev)
                 old_scratch2 = cvmx_scratch_read64(CVMX_SCR_SCRATCH + 8);
 
                 /*
-                 * Assume we're going to be able t osend this
-                 * packet. Fetch and increment the number of pending
-                 * packets for output.
+                 * Fetch and increment the number of packets to be
+                 * freed.
                  */
                 cvmx_fau_async_fetch_and_add32(CVMX_SCR_SCRATCH + 8,
                                                FAU_NUM_PACKET_BUFFERS_TO_FREE,
                                                0);
                 cvmx_fau_async_fetch_and_add32(CVMX_SCR_SCRATCH,
-                                               priv->fau + qos * 4, 1);
+                                               priv->fau + qos * 4,
+                                               MAX_SKB_TO_FREE);
         }
 
         /*
@@ -253,10 +256,10 @@ int cvm_oct_xmit(struct sk_buff *skb, struct net_device *dev)
 
         /*
          * The skbuff will be reused without ever being freed. We must
-         * cleanup a bunch of Linux stuff.
+         * cleanup a bunch of core things.
          */
-        dst_release(skb->dst);
-        skb->dst = NULL;
+        dst_release(skb_dst(skb));
+        skb_dst_set(skb, NULL);
 #ifdef CONFIG_XFRM
         secpath_put(skb->sp);
         skb->sp = NULL;
@@ -286,16 +289,30 @@ dont_put_skbuff_in_hw:
         if (USE_ASYNC_IOBDMA) {
                 /* Get the number of skbuffs in use by the hardware */
                 CVMX_SYNCIOBDMA;
-                in_use = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
+                skb_to_free = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
                 buffers_to_free = cvmx_scratch_read64(CVMX_SCR_SCRATCH + 8);
         } else {
                 /* Get the number of skbuffs in use by the hardware */
-                in_use = cvmx_fau_fetch_and_add32(priv->fau + qos * 4, 1);
+                skb_to_free = cvmx_fau_fetch_and_add32(priv->fau + qos * 4,
+                                                       MAX_SKB_TO_FREE);
                 buffers_to_free =
                     cvmx_fau_fetch_and_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
         }
 
         /*
+         * We try to claim MAX_SKB_TO_FREE buffers.  If there were not
+         * that many available, we have to un-claim (undo) any that
+         * were in excess.  If skb_to_free is positive we will free
+         * that many buffers.
+         */
+        undo = skb_to_free > 0 ?
+                MAX_SKB_TO_FREE : skb_to_free + MAX_SKB_TO_FREE;
+        if (undo > 0)
+                cvmx_fau_atomic_add32(priv->fau+qos*4, -undo);
+        skb_to_free = -skb_to_free > MAX_SKB_TO_FREE ?
+                MAX_SKB_TO_FREE : -skb_to_free;
+
+        /*
          * If we're sending faster than the receive can free them then
          * don't do the HW free.
          */
@@ -330,38 +347,31 @@ dont_put_skbuff_in_hw:
                 cvmx_scratch_write64(CVMX_SCR_SCRATCH + 8, old_scratch2);
         }
 
+        queue_it_up = 0;
         if (unlikely(dropped)) {
                 dev_kfree_skb_any(skb);
-                cvmx_fau_atomic_add32(priv->fau + qos * 4, -1);
                 priv->stats.tx_dropped++;
         } else {
                 if (USE_SKBUFFS_IN_HW) {
                         /* Put this packet on the queue to be freed later */
                         if (pko_command.s.dontfree)
-                                skb_queue_tail(&priv->tx_free_list[qos], skb);
-                        else {
+                                queue_it_up = 1;
+                        else
                                 cvmx_fau_atomic_add32
                                     (FAU_NUM_PACKET_BUFFERS_TO_FREE, -1);
-                                cvmx_fau_atomic_add32(priv->fau + qos * 4, -1);
-                        }
                 } else {
                         /* Put this packet on the queue to be freed later */
-                        skb_queue_tail(&priv->tx_free_list[qos], skb);
+                        queue_it_up = 1;
                 }
         }
 
-        /* Free skbuffs not in use by the hardware, possibly two at a time */
-        if (skb_queue_len(&priv->tx_free_list[qos]) > in_use) {
+        if (queue_it_up) {
                 spin_lock(&priv->tx_free_list[qos].lock);
-                /*
-                 * Check again now that we have the lock. It might
-                 * have changed.
-                 */
-                if (skb_queue_len(&priv->tx_free_list[qos]) > in_use)
-                        dev_kfree_skb(__skb_dequeue(&priv->tx_free_list[qos]));
-                if (skb_queue_len(&priv->tx_free_list[qos]) > in_use)
-                        dev_kfree_skb(__skb_dequeue(&priv->tx_free_list[qos]));
+                __skb_queue_tail(&priv->tx_free_list[qos], skb);
+                cvm_oct_free_tx_skbs(priv, skb_to_free, qos, 0);
                 spin_unlock(&priv->tx_free_list[qos].lock);
+        } else {
+                cvm_oct_free_tx_skbs(priv, skb_to_free, qos, 1);
         }
 
         return 0;
diff --git a/drivers/staging/octeon/ethernet-tx.h b/drivers/staging/octeon/ethernet-tx.h
index 5106236fe981..c0bebf750bc0 100644
--- a/drivers/staging/octeon/ethernet-tx.h
+++ b/drivers/staging/octeon/ethernet-tx.h
@@ -30,3 +30,28 @@ int cvm_oct_xmit_pow(struct sk_buff *skb, struct net_device *dev);
 int cvm_oct_transmit_qos(struct net_device *dev, void *work_queue_entry,
                          int do_free, int qos);
 void cvm_oct_tx_shutdown(struct net_device *dev);
+
+/**
+ * Free dead transmit skbs.
+ *
+ * @priv:               The driver data
+ * @skb_to_free:        The number of SKBs to free (free none if negative).
+ * @qos:                The queue to free from.
+ * @take_lock:          If true, acquire the skb list lock.
+ */
+static inline void cvm_oct_free_tx_skbs(struct octeon_ethernet *priv,
+                                        int skb_to_free,
+                                        int qos, int take_lock)
+{
+        /* Free skbuffs not in use by the hardware.  */
+        if (skb_to_free > 0) {
+                if (take_lock)
+                        spin_lock(&priv->tx_free_list[qos].lock);
+                while (skb_to_free > 0) {
+                        dev_kfree_skb(__skb_dequeue(&priv->tx_free_list[qos]));
+                        skb_to_free--;
+                }
+                if (take_lock)
+                        spin_unlock(&priv->tx_free_list[qos].lock);
+        }
+}
diff --git a/drivers/staging/octeon/ethernet-xaui.c b/drivers/staging/octeon/ethernet-xaui.c
index f08eb32e04fc..0c2e7cc40f35 100644
--- a/drivers/staging/octeon/ethernet-xaui.c
+++ b/drivers/staging/octeon/ethernet-xaui.c
@@ -33,14 +33,13 @@
 
 #include "ethernet-defines.h"
 #include "octeon-ethernet.h"
-#include "ethernet-common.h"
 #include "ethernet-util.h"
 
 #include "cvmx-helper.h"
 
 #include "cvmx-gmxx-defs.h"
 
-static int cvm_oct_xaui_open(struct net_device *dev)
+int cvm_oct_xaui_open(struct net_device *dev)
 {
         union cvmx_gmxx_prtx_cfg gmx_cfg;
         struct octeon_ethernet *priv = netdev_priv(dev);
@@ -60,7 +59,7 @@ static int cvm_oct_xaui_open(struct net_device *dev)
         return 0;
 }
 
-static int cvm_oct_xaui_stop(struct net_device *dev)
+int cvm_oct_xaui_stop(struct net_device *dev)
 {
         union cvmx_gmxx_prtx_cfg gmx_cfg;
         struct octeon_ethernet *priv = netdev_priv(dev);
@@ -112,9 +111,7 @@ int cvm_oct_xaui_init(struct net_device *dev)
 {
         struct octeon_ethernet *priv = netdev_priv(dev);
         cvm_oct_common_init(dev);
-        dev->open = cvm_oct_xaui_open;
-        dev->stop = cvm_oct_xaui_stop;
-        dev->stop(dev);
+        dev->netdev_ops->ndo_stop(dev);
         if (!octeon_is_simulation())
                 priv->poll = cvm_oct_xaui_poll;
 
diff --git a/drivers/staging/octeon/ethernet.c b/drivers/staging/octeon/ethernet.c
index e8ef9e0b791f..b8479517dce2 100644
--- a/drivers/staging/octeon/ethernet.c
+++ b/drivers/staging/octeon/ethernet.c
@@ -37,13 +37,14 @@
 #include <asm/octeon/octeon.h>
 
 #include "ethernet-defines.h"
+#include "octeon-ethernet.h"
 #include "ethernet-mem.h"
 #include "ethernet-rx.h"
 #include "ethernet-tx.h"
+#include "ethernet-mdio.h"
 #include "ethernet-util.h"
 #include "ethernet-proc.h"
-#include "ethernet-common.h"
-#include "octeon-ethernet.h"
+
 
 #include "cvmx-pip.h"
 #include "cvmx-pko.h"
@@ -51,6 +52,7 @@
 #include "cvmx-ipd.h"
 #include "cvmx-helper.h"
 
+#include "cvmx-gmxx-defs.h"
 #include "cvmx-smix-defs.h"
 
 #if defined(CONFIG_CAVIUM_OCTEON_NUM_PACKET_BUFFERS) \
@@ -129,53 +131,55 @@ extern struct semaphore mdio_sem;
  */
 static void cvm_do_timer(unsigned long arg)
 {
+        int32_t skb_to_free, undo;
+        int queues_per_port;
+        int qos;
+        struct octeon_ethernet *priv;
         static int port;
-        if (port < CVMX_PIP_NUM_INPUT_PORTS) {
-                if (cvm_oct_device[port]) {
-                        int queues_per_port;
-                        int qos;
-                        struct octeon_ethernet *priv =
-                                netdev_priv(cvm_oct_device[port]);
-                        if (priv->poll) {
-                                /* skip polling if we don't get the lock */
-                                if (!down_trylock(&mdio_sem)) {
-                                        priv->poll(cvm_oct_device[port]);
-                                        up(&mdio_sem);
-                                }
-                        }
 
-                        queues_per_port = cvmx_pko_get_num_queues(port);
-                        /* Drain any pending packets in the free list */
-                        for (qos = 0; qos < queues_per_port; qos++) {
-                                if (skb_queue_len(&priv->tx_free_list[qos])) {
-                                        spin_lock(&priv->tx_free_list[qos].
-                                                  lock);
-                                        while (skb_queue_len
-                                               (&priv->tx_free_list[qos]) >
-                                               cvmx_fau_fetch_and_add32(priv->
-                                                                        fau +
-                                                                        qos * 4,
-                                                                        0))
-                                                dev_kfree_skb(__skb_dequeue
-                                                              (&priv->
-                                                               tx_free_list
-                                                               [qos]));
-                                        spin_unlock(&priv->tx_free_list[qos].
-                                                    lock);
-                                }
-                        }
-                        cvm_oct_device[port]->get_stats(cvm_oct_device[port]);
-                }
-                port++;
-                /* Poll the next port in a 50th of a second.
-                   This spreads the polling of ports out a little bit */
-                mod_timer(&cvm_oct_poll_timer, jiffies + HZ / 50);
-        } else {
+        if (port >= CVMX_PIP_NUM_INPUT_PORTS) {
+                /*
+                 * All ports have been polled. Start the next
+                 * iteration through the ports in one second.
+                 */
                 port = 0;
-                /* All ports have been polled. Start the next iteration through
-                   the ports in one second */
                 mod_timer(&cvm_oct_poll_timer, jiffies + HZ);
+                return;
+        }
+        if (!cvm_oct_device[port])
+                goto out;
+
+        priv = netdev_priv(cvm_oct_device[port]);
+        if (priv->poll) {
+                /* skip polling if we don't get the lock */
+                if (!down_trylock(&mdio_sem)) {
+                        priv->poll(cvm_oct_device[port]);
+                        up(&mdio_sem);
+                }
         }
+
+        queues_per_port = cvmx_pko_get_num_queues(port);
+        /* Drain any pending packets in the free list */
+        for (qos = 0; qos < queues_per_port; qos++) {
+                if (skb_queue_len(&priv->tx_free_list[qos]) == 0)
+                        continue;
+                skb_to_free = cvmx_fau_fetch_and_add32(priv->fau + qos * 4,
+                                                       MAX_SKB_TO_FREE);
+                undo = skb_to_free > 0 ?
+                        MAX_SKB_TO_FREE : skb_to_free + MAX_SKB_TO_FREE;
+                if (undo > 0)
+                        cvmx_fau_atomic_add32(priv->fau+qos*4, -undo);
+                skb_to_free = -skb_to_free > MAX_SKB_TO_FREE ?
+                        MAX_SKB_TO_FREE : -skb_to_free;
+                cvm_oct_free_tx_skbs(priv, skb_to_free, qos, 1);
+        }
+        cvm_oct_device[port]->netdev_ops->ndo_get_stats(cvm_oct_device[port]);
+
+out:
+        port++;
+        /* Poll the next port in a 50th of a second.
+           This spreads the polling of ports out a little bit */
+        mod_timer(&cvm_oct_poll_timer, jiffies + HZ / 50);
 }
 
 /**
@@ -246,6 +250,362 @@ int cvm_oct_free_work(void *work_queue_entry)
 EXPORT_SYMBOL(cvm_oct_free_work);
 
 /**
+ * Get the low level ethernet statistics
+ *
+ * @dev:    Device to get the statistics from
+ * Returns Pointer to the statistics
+ */
+static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev)
+{
+        cvmx_pip_port_status_t rx_status;
+        cvmx_pko_port_status_t tx_status;
+        struct octeon_ethernet *priv = netdev_priv(dev);
+
+        if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) {
+                if (octeon_is_simulation()) {
+                        /* The simulator doesn't support statistics */
+                        memset(&rx_status, 0, sizeof(rx_status));
+                        memset(&tx_status, 0, sizeof(tx_status));
+                } else {
+                        cvmx_pip_get_port_status(priv->port, 1, &rx_status);
+                        cvmx_pko_get_port_status(priv->port, 1, &tx_status);
+                }
+
+                priv->stats.rx_packets += rx_status.inb_packets;
+                priv->stats.tx_packets += tx_status.packets;
+                priv->stats.rx_bytes += rx_status.inb_octets;
+                priv->stats.tx_bytes += tx_status.octets;
+                priv->stats.multicast += rx_status.multicast_packets;
+                priv->stats.rx_crc_errors += rx_status.inb_errors;
+                priv->stats.rx_frame_errors += rx_status.fcs_align_err_packets;
+
+                /*
+                 * The drop counter must be incremented atomically
+                 * since the RX tasklet also increments it.
+                 */
+#ifdef CONFIG_64BIT
+                atomic64_add(rx_status.dropped_packets,
+                             (atomic64_t *)&priv->stats.rx_dropped);
+#else
+                atomic_add(rx_status.dropped_packets,
+                             (atomic_t *)&priv->stats.rx_dropped);
+#endif
+        }
+
+        return &priv->stats;
+}
+
+/**
+ * Change the link MTU. Unimplemented
+ *
+ * @dev:     Device to change
+ * @new_mtu: The new MTU
+ *
+ * Returns Zero on success
+ */
+static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu)
+{
+        struct octeon_ethernet *priv = netdev_priv(dev);
+        int interface = INTERFACE(priv->port);
+        int index = INDEX(priv->port);
+#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
+        int vlan_bytes = 4;
+#else
+        int vlan_bytes = 0;
+#endif
+
+        /*
+         * Limit the MTU to make sure the ethernet packets are between
+         * 64 bytes and 65535 bytes.
+         */
+        if ((new_mtu + 14 + 4 + vlan_bytes < 64)
+            || (new_mtu + 14 + 4 + vlan_bytes > 65392)) {
+                pr_err("MTU must be between %d and %d.\n",
+                       64 - 14 - 4 - vlan_bytes, 65392 - 14 - 4 - vlan_bytes);
+                return -EINVAL;
+        }
+        dev->mtu = new_mtu;
+
+        if ((interface < 2)
+            && (cvmx_helper_interface_get_mode(interface) !=
+                CVMX_HELPER_INTERFACE_MODE_SPI)) {
+                /* Add ethernet header and FCS, and VLAN if configured. */
+                int max_packet = new_mtu + 14 + 4 + vlan_bytes;
+
+                if (OCTEON_IS_MODEL(OCTEON_CN3XXX)
+                    || OCTEON_IS_MODEL(OCTEON_CN58XX)) {
+                        /* Signal errors on packets larger than the MTU */
+                        cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface),
+                                       max_packet);
+                } else {
+                        /*
+                         * Set the hardware to truncate packets larger
+                         * than the MTU and smaller the 64 bytes.
+                         */
+                        union cvmx_pip_frm_len_chkx frm_len_chk;
+                        frm_len_chk.u64 = 0;
+                        frm_len_chk.s.minlen = 64;
+                        frm_len_chk.s.maxlen = max_packet;
+                        cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface),
+                                       frm_len_chk.u64);
+                }
+                /*
+                 * Set the hardware to truncate packets larger than
+                 * the MTU. The jabber register must be set to a
+                 * multiple of 8 bytes, so round up.
+                 */
+                cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface),
+                               (max_packet + 7) & ~7u);
+        }
+        return 0;
+}
+
+/**
+ * Set the multicast list. Currently unimplemented.
+ *
+ * @dev:    Device to work on
+ */
+static void cvm_oct_common_set_multicast_list(struct net_device *dev)
+{
+        union cvmx_gmxx_prtx_cfg gmx_cfg;
+        struct octeon_ethernet *priv = netdev_priv(dev);
+        int interface = INTERFACE(priv->port);
+        int index = INDEX(priv->port);
+
+        if ((interface < 2)
+            && (cvmx_helper_interface_get_mode(interface) !=
+                CVMX_HELPER_INTERFACE_MODE_SPI)) {
+                union cvmx_gmxx_rxx_adr_ctl control;
+                control.u64 = 0;
+                control.s.bcst = 1;     /* Allow broadcast MAC addresses */
+
+                if (dev->mc_list || (dev->flags & IFF_ALLMULTI) ||
+                    (dev->flags & IFF_PROMISC))
+                        /* Force accept multicast packets */
+                        control.s.mcst = 2;
+                else
+                        /* Force reject multicat packets */
+                        control.s.mcst = 1;
+
+                if (dev->flags & IFF_PROMISC)
+                        /*
+                         * Reject matches if promisc. Since CAM is
+                         * shut off, should accept everything.
+                         */
+                        control.s.cam_mode = 0;
+                else
+                        /* Filter packets based on the CAM */
+                        control.s.cam_mode = 1;
+
+                gmx_cfg.u64 =
+                    cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
+                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
+                               gmx_cfg.u64 & ~1ull);
+
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface),
+                               control.u64);
+                if (dev->flags & IFF_PROMISC)
+                        cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
+                                       (index, interface), 0);
+                else
+                        cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
+                                       (index, interface), 1);
+
+                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
+                               gmx_cfg.u64);
+        }
+}
+
+/**
+ * Set the hardware MAC address for a device
+ *
+ * @dev:    Device to change the MAC address for
+ * @addr:   Address structure to change it too. MAC address is addr + 2.
+ * Returns Zero on success
+ */
+static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr)
+{
+        struct octeon_ethernet *priv = netdev_priv(dev);
+        union cvmx_gmxx_prtx_cfg gmx_cfg;
+        int interface = INTERFACE(priv->port);
+        int index = INDEX(priv->port);
+
+        memcpy(dev->dev_addr, addr + 2, 6);
+
+        if ((interface < 2)
+            && (cvmx_helper_interface_get_mode(interface) !=
+                CVMX_HELPER_INTERFACE_MODE_SPI)) {
+                int i;
+                uint8_t *ptr = addr;
+                uint64_t mac = 0;
+                for (i = 0; i < 6; i++)
+                        mac = (mac << 8) | (uint64_t) (ptr[i + 2]);
+
+                gmx_cfg.u64 =
+                    cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
+                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
+                               gmx_cfg.u64 & ~1ull);
+
+                cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac);
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface),
+                               ptr[2]);
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface),
+                               ptr[3]);
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface),
+                               ptr[4]);
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface),
+                               ptr[5]);
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface),
+                               ptr[6]);
+                cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface),
+                               ptr[7]);
+                cvm_oct_common_set_multicast_list(dev);
+                cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
+                               gmx_cfg.u64);
+        }
+        return 0;
+}
+
+/**
+ * Per network device initialization
+ *
+ * @dev:    Device to initialize
+ * Returns Zero on success
+ */
+int cvm_oct_common_init(struct net_device *dev)
+{
+        static int count;
+        char mac[8] = { 0x00, 0x00,
+                octeon_bootinfo->mac_addr_base[0],
+                octeon_bootinfo->mac_addr_base[1],
+                octeon_bootinfo->mac_addr_base[2],
+                octeon_bootinfo->mac_addr_base[3],
+                octeon_bootinfo->mac_addr_base[4],
+                octeon_bootinfo->mac_addr_base[5] + count
+        };
+        struct octeon_ethernet *priv = netdev_priv(dev);
+
+        /*
+         * Force the interface to use the POW send if always_use_pow
+         * was specified or it is in the pow send list.
+         */
+        if ((pow_send_group != -1)
+            && (always_use_pow || strstr(pow_send_list, dev->name)))
+                priv->queue = -1;
+
+        if (priv->queue != -1 && USE_HW_TCPUDP_CHECKSUM)
+                dev->features |= NETIF_F_IP_CSUM;
+
+        count++;
+
+        /* We do our own locking, Linux doesn't need to */
+        dev->features |= NETIF_F_LLTX;
+        SET_ETHTOOL_OPS(dev, &cvm_oct_ethtool_ops);
+
+        cvm_oct_mdio_setup_device(dev);
+        dev->netdev_ops->ndo_set_mac_address(dev, mac);
+        dev->netdev_ops->ndo_change_mtu(dev, dev->mtu);
+
+        /*
+         * Zero out stats for port so we won't mistakenly show
+         * counters from the bootloader.
+         */
+        memset(dev->netdev_ops->ndo_get_stats(dev), 0,
+               sizeof(struct net_device_stats));
+
+        return 0;
+}
+
+void cvm_oct_common_uninit(struct net_device *dev)
+{
+        /* Currently nothing to do */
+}
+
+static const struct net_device_ops cvm_oct_npi_netdev_ops = {
+        .ndo_init               = cvm_oct_common_init,
+        .ndo_uninit             = cvm_oct_common_uninit,
+        .ndo_start_xmit         = cvm_oct_xmit,
+        .ndo_set_multicast_list = cvm_oct_common_set_multicast_list,
+        .ndo_set_mac_address    = cvm_oct_common_set_mac_address,
+        .ndo_do_ioctl           = cvm_oct_ioctl,
+        .ndo_change_mtu         = cvm_oct_common_change_mtu,
+        .ndo_get_stats          = cvm_oct_common_get_stats,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = cvm_oct_poll_controller,
+#endif
+};
+static const struct net_device_ops cvm_oct_xaui_netdev_ops = {
+        .ndo_init               = cvm_oct_xaui_init,
+        .ndo_uninit             = cvm_oct_xaui_uninit,
+        .ndo_open               = cvm_oct_xaui_open,
+        .ndo_stop               = cvm_oct_xaui_stop,
+        .ndo_start_xmit         = cvm_oct_xmit,
+        .ndo_set_multicast_list = cvm_oct_common_set_multicast_list,
+        .ndo_set_mac_address    = cvm_oct_common_set_mac_address,
+        .ndo_do_ioctl           = cvm_oct_ioctl,
+        .ndo_change_mtu         = cvm_oct_common_change_mtu,
+        .ndo_get_stats          = cvm_oct_common_get_stats,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = cvm_oct_poll_controller,
+#endif
+};
+static const struct net_device_ops cvm_oct_sgmii_netdev_ops = {
+        .ndo_init               = cvm_oct_sgmii_init,
+        .ndo_uninit             = cvm_oct_sgmii_uninit,
+        .ndo_open               = cvm_oct_sgmii_open,
+        .ndo_stop               = cvm_oct_sgmii_stop,
+        .ndo_start_xmit         = cvm_oct_xmit,
+        .ndo_set_multicast_list = cvm_oct_common_set_multicast_list,
+        .ndo_set_mac_address    = cvm_oct_common_set_mac_address,
+        .ndo_do_ioctl           = cvm_oct_ioctl,
+        .ndo_change_mtu         = cvm_oct_common_change_mtu,
+        .ndo_get_stats          = cvm_oct_common_get_stats,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = cvm_oct_poll_controller,
+#endif
+};
+static const struct net_device_ops cvm_oct_spi_netdev_ops = {
+        .ndo_init               = cvm_oct_spi_init,
+        .ndo_uninit             = cvm_oct_spi_uninit,
+        .ndo_start_xmit         = cvm_oct_xmit,
+        .ndo_set_multicast_list = cvm_oct_common_set_multicast_list,
+        .ndo_set_mac_address    = cvm_oct_common_set_mac_address,
+        .ndo_do_ioctl           = cvm_oct_ioctl,
+        .ndo_change_mtu         = cvm_oct_common_change_mtu,
+        .ndo_get_stats          = cvm_oct_common_get_stats,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = cvm_oct_poll_controller,
+#endif
+};
+static const struct net_device_ops cvm_oct_rgmii_netdev_ops = {
+        .ndo_init               = cvm_oct_rgmii_init,
+        .ndo_uninit             = cvm_oct_rgmii_uninit,
+        .ndo_open               = cvm_oct_rgmii_open,
+        .ndo_stop               = cvm_oct_rgmii_stop,
+        .ndo_start_xmit         = cvm_oct_xmit,
+        .ndo_set_multicast_list = cvm_oct_common_set_multicast_list,
+        .ndo_set_mac_address    = cvm_oct_common_set_mac_address,
+        .ndo_do_ioctl           = cvm_oct_ioctl,
+        .ndo_change_mtu         = cvm_oct_common_change_mtu,
+        .ndo_get_stats          = cvm_oct_common_get_stats,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = cvm_oct_poll_controller,
+#endif
+};
+static const struct net_device_ops cvm_oct_pow_netdev_ops = {
+        .ndo_init               = cvm_oct_common_init,
+        .ndo_start_xmit         = cvm_oct_xmit_pow,
+        .ndo_set_multicast_list = cvm_oct_common_set_multicast_list,
+        .ndo_set_mac_address    = cvm_oct_common_set_mac_address,
+        .ndo_do_ioctl           = cvm_oct_ioctl,
+        .ndo_change_mtu         = cvm_oct_common_change_mtu,
+        .ndo_get_stats          = cvm_oct_common_get_stats,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = cvm_oct_poll_controller,
+#endif
+};
+
+/**
  * Module/ driver initialization. Creates the linux network
  * devices.
  *
@@ -303,7 +663,7 @@ static int __init cvm_oct_init_module(void)
                         struct octeon_ethernet *priv = netdev_priv(dev);
                         memset(priv, 0, sizeof(struct octeon_ethernet));
 
-                        dev->init = cvm_oct_common_init;
+                        dev->netdev_ops = &cvm_oct_pow_netdev_ops;
                         priv->imode = CVMX_HELPER_INTERFACE_MODE_DISABLED;
                         priv->port = CVMX_PIP_NUM_INPUT_PORTS;
                         priv->queue = -1;
@@ -372,44 +732,38 @@ static int __init cvm_oct_init_module(void)
                                 break;
 
                         case CVMX_HELPER_INTERFACE_MODE_NPI:
-                                dev->init = cvm_oct_common_init;
-                                dev->uninit = cvm_oct_common_uninit;
+                                dev->netdev_ops = &cvm_oct_npi_netdev_ops;
                                 strcpy(dev->name, "npi%d");
                                 break;
 
                         case CVMX_HELPER_INTERFACE_MODE_XAUI:
-                                dev->init = cvm_oct_xaui_init;
-                                dev->uninit = cvm_oct_xaui_uninit;
+                                dev->netdev_ops = &cvm_oct_xaui_netdev_ops;
                                 strcpy(dev->name, "xaui%d");
                                 break;
 
                         case CVMX_HELPER_INTERFACE_MODE_LOOP:
-                                dev->init = cvm_oct_common_init;
-                                dev->uninit = cvm_oct_common_uninit;
+                                dev->netdev_ops = &cvm_oct_npi_netdev_ops;
                                 strcpy(dev->name, "loop%d");
                                 break;
 
                         case CVMX_HELPER_INTERFACE_MODE_SGMII:
-                                dev->init = cvm_oct_sgmii_init;
-                                dev->uninit = cvm_oct_sgmii_uninit;
+                                dev->netdev_ops = &cvm_oct_sgmii_netdev_ops;
                                 strcpy(dev->name, "eth%d");
                                 break;
 
                         case CVMX_HELPER_INTERFACE_MODE_SPI:
-                                dev->init = cvm_oct_spi_init;
-                                dev->uninit = cvm_oct_spi_uninit;
+                                dev->netdev_ops = &cvm_oct_spi_netdev_ops;
                                 strcpy(dev->name, "spi%d");
                                 break;
 
                         case CVMX_HELPER_INTERFACE_MODE_RGMII:
                         case CVMX_HELPER_INTERFACE_MODE_GMII:
-                                dev->init = cvm_oct_rgmii_init;
-                                dev->uninit = cvm_oct_rgmii_uninit;
+                                dev->netdev_ops = &cvm_oct_rgmii_netdev_ops;
                                 strcpy(dev->name, "eth%d");
                                 break;
                         }
 
-                        if (!dev->init) {
+                        if (!dev->netdev_ops) {
                                 kfree(dev);
                         } else if (register_netdev(dev) < 0) {
                                 pr_err("Failed to register ethernet device "
diff --git a/drivers/staging/octeon/octeon-ethernet.h b/drivers/staging/octeon/octeon-ethernet.h
index b3199076ef5e..3aef9878fc0a 100644
--- a/drivers/staging/octeon/octeon-ethernet.h
+++ b/drivers/staging/octeon/octeon-ethernet.h
@@ -111,12 +111,23 @@ static inline int cvm_oct_transmit(struct net_device *dev,
 
 extern int cvm_oct_rgmii_init(struct net_device *dev);
 extern void cvm_oct_rgmii_uninit(struct net_device *dev);
+extern int cvm_oct_rgmii_open(struct net_device *dev);
+extern int cvm_oct_rgmii_stop(struct net_device *dev);
+
 extern int cvm_oct_sgmii_init(struct net_device *dev);
 extern void cvm_oct_sgmii_uninit(struct net_device *dev);
+extern int cvm_oct_sgmii_open(struct net_device *dev);
+extern int cvm_oct_sgmii_stop(struct net_device *dev);
+
 extern int cvm_oct_spi_init(struct net_device *dev);
 extern void cvm_oct_spi_uninit(struct net_device *dev);
 extern int cvm_oct_xaui_init(struct net_device *dev);
 extern void cvm_oct_xaui_uninit(struct net_device *dev);
+extern int cvm_oct_xaui_open(struct net_device *dev);
+extern int cvm_oct_xaui_stop(struct net_device *dev);
+
+extern int cvm_oct_common_init(struct net_device *dev);
+extern void cvm_oct_common_uninit(struct net_device *dev);
 
 extern int always_use_pow;
 extern int pow_send_group;
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 38bfdb0f6660..3f1045993474 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -550,7 +550,7 @@ static void acm_waker(struct work_struct *waker)
 static int acm_tty_open(struct tty_struct *tty, struct file *filp)
 {
         struct acm *acm;
-        int rv = -EINVAL;
+        int rv = -ENODEV;
         int i;
         dbg("Entering acm_tty_open.");
 
@@ -677,7 +677,7 @@ static void acm_tty_close(struct tty_struct *tty, struct file *filp)
 
         /* Perform the closing process and see if we need to do the hardware
            shutdown */
-        if (tty_port_close_start(&acm->port, tty, filp) == 0)
+        if (!acm || tty_port_close_start(&acm->port, tty, filp) == 0)
                 return;
         acm_port_down(acm, 0);
         tty_port_close_end(&acm->port, tty);
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index d595aa5586a7..a84216464ca0 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -333,6 +333,9 @@ static void serial_close(struct tty_struct *tty, struct file *filp)
 {
         struct usb_serial_port *port = tty->driver_data;
 
+        if (!port)
+                return;
+
         dbg("%s - port %d", __func__, port->number);
 
 
diff --git a/drivers/uwb/hwa-rc.c b/drivers/uwb/hwa-rc.c
index 559f8784acf3..9052bcb4f528 100644
--- a/drivers/uwb/hwa-rc.c
+++ b/drivers/uwb/hwa-rc.c
@@ -501,7 +501,7 @@ int hwarc_filter_event_WUSB_0100(struct uwb_rc *rc, struct uwb_rceb **header,
         int result = -ENOANO;
         struct uwb_rceb *rceb = *header;
         int event = le16_to_cpu(rceb->wEvent);
-        size_t event_size;
+        ssize_t event_size;
         size_t core_size, offset;
 
         if (rceb->bEventType != UWB_RC_CET_GENERAL)
diff --git a/drivers/uwb/wlp/txrx.c b/drivers/uwb/wlp/txrx.c
index cd2035768b47..86a853b84119 100644
--- a/drivers/uwb/wlp/txrx.c
+++ b/drivers/uwb/wlp/txrx.c
@@ -326,7 +326,7 @@ int wlp_prepare_tx_frame(struct device *dev, struct wlp *wlp,
         int result = -EINVAL;
         struct ethhdr *eth_hdr = (void *) skb->data;
 
-        if (is_broadcast_ether_addr(eth_hdr->h_dest)) {
+        if (is_multicast_ether_addr(eth_hdr->h_dest)) {
                 result = wlp_eda_for_each(&wlp->eda, wlp_wss_send_copy, skb);
                 if (result < 0) {
                         if (printk_ratelimit())
diff --git a/drivers/video/nvidia/nv_setup.c b/drivers/video/nvidia/nv_setup.c
index 135ae18bfce8..eef2bb298d9f 100644
--- a/drivers/video/nvidia/nv_setup.c
+++ b/drivers/video/nvidia/nv_setup.c
@@ -543,8 +543,7 @@ int NVCommonSetup(struct fb_info *info)
                 } else if (analog_on_B) {
                         CRTCnumber = outputBfromCRTC;
                         FlatPanel = 0;
-                        printk("nvidiafb: CRTC %i"
-                               "appears to have a "
+                        printk("nvidiafb: CRTC %i appears to have a "
                                "CRT attached\n", CRTCnumber);
                 } else if (slaved_on_A) {
                         CRTCnumber = 0;
diff --git a/drivers/w1/slaves/w1_ds2760.c b/drivers/w1/slaves/w1_ds2760.c
index 1f09d4e4144c..59f708efe25f 100644
--- a/drivers/w1/slaves/w1_ds2760.c
+++ b/drivers/w1/slaves/w1_ds2760.c
@@ -68,6 +68,34 @@ int w1_ds2760_write(struct device *dev, char *buf, int addr, size_t count)
         return w1_ds2760_io(dev, buf, addr, count, 1);
 }
 
+static int w1_ds2760_eeprom_cmd(struct device *dev, int addr, int cmd)
+{
+        struct w1_slave *sl = container_of(dev, struct w1_slave, dev);
+
+        if (!dev)
+                return -EINVAL;
+
+        mutex_lock(&sl->master->mutex);
+
+        if (w1_reset_select_slave(sl) == 0) {
+                w1_write_8(sl->master, cmd);
+                w1_write_8(sl->master, addr);
+        }
+
+        mutex_unlock(&sl->master->mutex);
+        return 0;
+}
+
+int w1_ds2760_store_eeprom(struct device *dev, int addr)
+{
+        return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_COPY_DATA);
+}
+
+int w1_ds2760_recall_eeprom(struct device *dev, int addr)
+{
+        return w1_ds2760_eeprom_cmd(dev, addr, W1_DS2760_RECALL_DATA);
+}
+
 static ssize_t w1_ds2760_read_bin(struct kobject *kobj,
                                   struct bin_attribute *bin_attr,
                                   char *buf, loff_t off, size_t count)
@@ -200,6 +228,8 @@ static void __exit w1_ds2760_exit(void)
 
 EXPORT_SYMBOL(w1_ds2760_read);
 EXPORT_SYMBOL(w1_ds2760_write);
+EXPORT_SYMBOL(w1_ds2760_store_eeprom);
+EXPORT_SYMBOL(w1_ds2760_recall_eeprom);
 
 module_init(w1_ds2760_init);
 module_exit(w1_ds2760_exit);
diff --git a/drivers/w1/slaves/w1_ds2760.h b/drivers/w1/slaves/w1_ds2760.h
index f1302429cb02..58e774141568 100644
--- a/drivers/w1/slaves/w1_ds2760.h
+++ b/drivers/w1/slaves/w1_ds2760.h
@@ -25,6 +25,10 @@
 
 #define DS2760_PROTECTION_REG           0x00
 #define DS2760_STATUS_REG               0x01
+        #define DS2760_STATUS_IE        (1 << 2)
+        #define DS2760_STATUS_SWEN      (1 << 3)
+        #define DS2760_STATUS_RNAOP     (1 << 4)
+        #define DS2760_STATUS_PMOD      (1 << 5)
 #define DS2760_EEPROM_REG               0x07
 #define DS2760_SPECIAL_FEATURE_REG      0x08
 #define DS2760_VOLTAGE_MSB              0x0c
@@ -38,6 +42,7 @@
 #define DS2760_EEPROM_BLOCK0            0x20
 #define DS2760_ACTIVE_FULL              0x20
 #define DS2760_EEPROM_BLOCK1            0x30
+#define DS2760_STATUS_WRITE_REG         0x31
 #define DS2760_RATED_CAPACITY           0x32
 #define DS2760_CURRENT_OFFSET_BIAS      0x33
 #define DS2760_ACTIVE_EMPTY             0x3b
@@ -46,5 +51,7 @@ extern int w1_ds2760_read(struct device *dev, char *buf, int addr,
                           size_t count);
 extern int w1_ds2760_write(struct device *dev, char *buf, int addr,
                            size_t count);
+extern int w1_ds2760_store_eeprom(struct device *dev, int addr);
+extern int w1_ds2760_recall_eeprom(struct device *dev, int addr);
 
 #endif /* !__w1_ds2760_h__ */
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig
index b166f2852a64..b1ccc04f3c9a 100644
--- a/drivers/watchdog/Kconfig
+++ b/drivers/watchdog/Kconfig
@@ -240,6 +240,32 @@ config ORION_WATCHDOG
           To compile this driver as a module, choose M here: the
           module will be called orion_wdt.
 
+config COH901327_WATCHDOG
+        bool "ST-Ericsson COH 901 327 watchdog"
+        depends on ARCH_U300
+        default y if MACH_U300
+        help
+          Say Y here to include Watchdog timer support for the
+          watchdog embedded into the ST-Ericsson U300 series platforms.
+          This watchdog is used to reset the system and thus cannot be
+          compiled as a module.
+
+config TWL4030_WATCHDOG
+        tristate "TWL4030 Watchdog"
+        depends on TWL4030_CORE
+        help
+          Support for TI TWL4030 watchdog.  Say 'Y' here to enable the
+          watchdog timer support for TWL4030 chips.
+
+config STMP3XXX_WATCHDOG
+        tristate "Freescale STMP3XXX watchdog"
+        depends on ARCH_STMP3XXX
+        help
+          Say Y here if to include support for the watchdog timer
+          for the Sigmatel STMP37XX/378X SoC.
+          To compile this driver as a module, choose M here: the
+          module will be called stmp3xxx_wdt.
+
 # AVR32 Architecture
 
 config AT32AP700X_WDT
@@ -703,6 +729,12 @@ config SBC_EPX_C3_WATCHDOG
 
 # MIPS Architecture
 
+config BCM47XX_WDT
+        tristate "Broadcom BCM47xx Watchdog Timer"
+        depends on BCM47XX
+        help
+          Hardware driver for the Broadcom BCM47xx Watchog Timer.
+
 config RC32434_WDT
         tristate "IDT RC32434 SoC Watchdog Timer"
         depends on MIKROTIK_RB532
@@ -729,6 +761,15 @@ config WDT_MTX1
           Hardware driver for the MTX-1 boards. This is a watchdog timer that
           will reboot the machine after a 100 seconds timer expired.
 
+config PNX833X_WDT
+        tristate "PNX833x Hardware Watchdog"
+        depends on SOC_PNX8335
+        help
+          Hardware driver for the PNX833x's watchdog. This is a
+          watchdog timer that will reboot the machine after a programable
+          timer has expired and no process has written to /dev/watchdog during
+          that time.
+
 config WDT_RM9K_GPI
         tristate "RM9000/GPI hardware watchdog"
         depends on CPU_RM9000
@@ -966,24 +1007,16 @@ config WDTPCI
         ---help---
           If you have a PCI-WDT500/501 watchdog board, say Y here, otherwise N.
 
-          To compile this driver as a module, choose M here: the
-          module will be called wdt_pci.
-
-config WDT_501_PCI
-        bool "PCI-WDT501 features"
-        depends on WDTPCI
-        help
-          Saying Y here and creating a character special file /dev/temperature
-          with major number 10 and minor number 131 ("man mknod") will give
-          you a thermometer inside your computer: reading from
-          /dev/temperature yields one byte, the temperature in degrees
-          Fahrenheit. This works only if you have a PCI-WDT501 watchdog board
-          installed.
+          If you have a PCI-WDT501 watchdog board then you can enable the
+          temperature sensor by setting the type parameter to 501.
 
           If you want to enable the Fan Tachometer on the PCI-WDT501, then you
           can do this via the tachometer parameter. Only do this if you have a
           fan tachometer actually set up.
 
+          To compile this driver as a module, choose M here: the
+          module will be called wdt_pci.
+
 #
 # USB-based Watchdog Cards
 #
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile
index c3afa14d5be1..3d774294a2b7 100644
--- a/drivers/watchdog/Makefile
+++ b/drivers/watchdog/Makefile
@@ -28,6 +28,7 @@ obj-$(CONFIG_USBPCWATCHDOG) += pcwd_usb.o
 obj-$(CONFIG_AT91RM9200_WATCHDOG) += at91rm9200_wdt.o
 obj-$(CONFIG_AT91SAM9X_WATCHDOG) += at91sam9_wdt.o
 obj-$(CONFIG_OMAP_WATCHDOG) += omap_wdt.o
+obj-$(CONFIG_TWL4030_WATCHDOG) += twl4030_wdt.o
 obj-$(CONFIG_21285_WATCHDOG) += wdt285.o
 obj-$(CONFIG_977_WATCHDOG) += wdt977.o
 obj-$(CONFIG_IXP2000_WATCHDOG) += ixp2000_wdt.o
@@ -41,6 +42,8 @@ obj-$(CONFIG_PNX4008_WATCHDOG) += pnx4008_wdt.o
 obj-$(CONFIG_IOP_WATCHDOG) += iop_wdt.o
 obj-$(CONFIG_DAVINCI_WATCHDOG) += davinci_wdt.o
 obj-$(CONFIG_ORION_WATCHDOG) += orion_wdt.o
+obj-$(CONFIG_COH901327_WATCHDOG) += coh901327_wdt.o
+obj-$(CONFIG_STMP3XXX_WATCHDOG) += stmp3xxx_wdt.o
 
 # AVR32 Architecture
 obj-$(CONFIG_AT32AP700X_WDT) += at32ap700x_wdt.o
@@ -98,9 +101,11 @@ obj-$(CONFIG_SBC_EPX_C3_WATCHDOG) += sbc_epx_c3.o
 # M68KNOMMU Architecture
 
 # MIPS Architecture
+obj-$(CONFIG_BCM47XX_WDT) += bcm47xx_wdt.o
 obj-$(CONFIG_RC32434_WDT) += rc32434_wdt.o
 obj-$(CONFIG_INDYDOG) += indydog.o
 obj-$(CONFIG_WDT_MTX1) += mtx-1_wdt.o
+obj-$(CONFIG_PNX833X_WDT) += pnx833x_wdt.o
 obj-$(CONFIG_WDT_RM9K_GPI) += rm9k_wdt.o
 obj-$(CONFIG_SIBYTE_WDOG) += sb_wdog.o
 obj-$(CONFIG_AR7_WDT) += ar7_wdt.o
diff --git a/drivers/watchdog/bcm47xx_wdt.c b/drivers/watchdog/bcm47xx_wdt.c
new file mode 100644
index 000000000000..5c7011cda6a6
--- /dev/null
+++ b/drivers/watchdog/bcm47xx_wdt.c
@@ -0,0 +1,286 @@
+/*
+ *  Watchdog driver for Broadcom BCM47XX
+ *
+ *  Copyright (C) 2008 Aleksandar Radovanovic <biblbroks@sezampro.rs>
+ *  Copyright (C) 2009 Matthieu CASTET <castet.matthieu@free.fr>
+ *
+ *  This program is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU General Public License
+ *  as published by the Free Software Foundation; either version
+ *  2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/bitops.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/reboot.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+#include <linux/watchdog.h>
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+#include <linux/ssb/ssb_embedded.h>
+#include <asm/mach-bcm47xx/bcm47xx.h>
+
+#define DRV_NAME                "bcm47xx_wdt"
+
+#define WDT_DEFAULT_TIME        30      /* seconds */
+#define WDT_MAX_TIME            255     /* seconds */
+
+static int wdt_time = WDT_DEFAULT_TIME;
+static int nowayout = WATCHDOG_NOWAYOUT;
+
+module_param(wdt_time, int, 0);
+MODULE_PARM_DESC(wdt_time, "Watchdog time in seconds. (default="
+                                __MODULE_STRING(WDT_DEFAULT_TIME) ")");
+
+#ifdef CONFIG_WATCHDOG_NOWAYOUT
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout,
+                "Watchdog cannot be stopped once started (default="
+                                __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+#endif
+
+static unsigned long bcm47xx_wdt_busy;
+static char expect_release;
+static struct timer_list wdt_timer;
+static atomic_t ticks;
+
+static inline void bcm47xx_wdt_hw_start(void)
+{
+        /* this is 2,5s on 100Mhz clock  and 2s on 133 Mhz */
+        ssb_watchdog_timer_set(&ssb_bcm47xx, 0xfffffff);
+}
+
+static inline int bcm47xx_wdt_hw_stop(void)
+{
+        return ssb_watchdog_timer_set(&ssb_bcm47xx, 0);
+}
+
+static void bcm47xx_timer_tick(unsigned long unused)
+{
+        if (!atomic_dec_and_test(&ticks)) {
+                bcm47xx_wdt_hw_start();
+                mod_timer(&wdt_timer, jiffies + HZ);
+        } else {
+                printk(KERN_CRIT DRV_NAME "Watchdog will fire soon!!!\n");
+        }
+}
+
+static inline void bcm47xx_wdt_pet(void)
+{
+        atomic_set(&ticks, wdt_time);
+}
+
+static void bcm47xx_wdt_start(void)
+{
+        bcm47xx_wdt_pet();
+        bcm47xx_timer_tick(0);
+}
+
+static void bcm47xx_wdt_pause(void)
+{
+        del_timer_sync(&wdt_timer);
+        bcm47xx_wdt_hw_stop();
+}
+
+static void bcm47xx_wdt_stop(void)
+{
+        bcm47xx_wdt_pause();
+}
+
+static int bcm47xx_wdt_settimeout(int new_time)
+{
+        if ((new_time <= 0) || (new_time > WDT_MAX_TIME))
+                return -EINVAL;
+
+        wdt_time = new_time;
+        return 0;
+}
+
+static int bcm47xx_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(0, &bcm47xx_wdt_busy))
+                return -EBUSY;
+
+        bcm47xx_wdt_start();
+        return nonseekable_open(inode, file);
+}
+
+static int bcm47xx_wdt_release(struct inode *inode, struct file *file)
+{
+        if (expect_release == 42) {
+                bcm47xx_wdt_stop();
+        } else {
+                printk(KERN_CRIT DRV_NAME
+                        ": Unexpected close, not stopping watchdog!\n");
+                bcm47xx_wdt_start();
+        }
+
+        clear_bit(0, &bcm47xx_wdt_busy);
+        expect_release = 0;
+        return 0;
+}
+
+static ssize_t bcm47xx_wdt_write(struct file *file, const char __user *data,
+                                size_t len, loff_t *ppos)
+{
+        if (len) {
+                if (!nowayout) {
+                        size_t i;
+
+                        expect_release = 0;
+
+                        for (i = 0; i != len; i++) {
+                                char c;
+                                if (get_user(c, data + i))
+                                        return -EFAULT;
+                                if (c == 'V')
+                                        expect_release = 42;
+                        }
+                }
+                bcm47xx_wdt_pet();
+        }
+        return len;
+}
+
+static struct watchdog_info bcm47xx_wdt_info = {
+        .identity       = DRV_NAME,
+        .options        = WDIOF_SETTIMEOUT |
+                                WDIOF_KEEPALIVEPING |
+                                WDIOF_MAGICCLOSE,
+};
+
+static long bcm47xx_wdt_ioctl(struct file *file,
+                                        unsigned int cmd, unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        int new_value, retval = -EINVAL;;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &bcm47xx_wdt_info,
+                                sizeof(bcm47xx_wdt_info)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_SETOPTIONS:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+
+                if (new_value & WDIOS_DISABLECARD) {
+                        bcm47xx_wdt_stop();
+                        retval = 0;
+                }
+
+                if (new_value & WDIOS_ENABLECARD) {
+                        bcm47xx_wdt_start();
+                        retval = 0;
+                }
+
+                return retval;
+
+        case WDIOC_KEEPALIVE:
+                bcm47xx_wdt_pet();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_value, p))
+                        return -EFAULT;
+
+                if (bcm47xx_wdt_settimeout(new_value))
+                        return -EINVAL;
+
+                bcm47xx_wdt_pet();
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(wdt_time, p);
+
+        default:
+                return -ENOTTY;
+        }
+}
+
+static int bcm47xx_wdt_notify_sys(struct notifier_block *this,
+        unsigned long code, void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+                bcm47xx_wdt_stop();
+        return NOTIFY_DONE;
+}
+
+static const struct file_operations bcm47xx_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .unlocked_ioctl = bcm47xx_wdt_ioctl,
+        .open           = bcm47xx_wdt_open,
+        .release        = bcm47xx_wdt_release,
+        .write          = bcm47xx_wdt_write,
+};
+
+static struct miscdevice bcm47xx_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &bcm47xx_wdt_fops,
+};
+
+static struct notifier_block bcm47xx_wdt_notifier = {
+        .notifier_call = bcm47xx_wdt_notify_sys,
+};
+
+static int __init bcm47xx_wdt_init(void)
+{
+        int ret;
+
+        if (bcm47xx_wdt_hw_stop() < 0)
+                return -ENODEV;
+
+        setup_timer(&wdt_timer, bcm47xx_timer_tick, 0L);
+
+        if (bcm47xx_wdt_settimeout(wdt_time)) {
+                bcm47xx_wdt_settimeout(WDT_DEFAULT_TIME);
+                printk(KERN_INFO DRV_NAME ": "
+                        "wdt_time value must be 0 < wdt_time < %d, using %d\n",
+                        (WDT_MAX_TIME + 1), wdt_time);
+        }
+
+        ret = register_reboot_notifier(&bcm47xx_wdt_notifier);
+        if (ret)
+                return ret;
+
+        ret = misc_register(&bcm47xx_wdt_miscdev);
+        if (ret) {
+                unregister_reboot_notifier(&bcm47xx_wdt_notifier);
+                return ret;
+        }
+
+        printk(KERN_INFO "BCM47xx Watchdog Timer enabled (%d seconds%s)\n",
+                                wdt_time, nowayout ? ", nowayout" : "");
+        return 0;
+}
+
+static void __exit bcm47xx_wdt_exit(void)
+{
+        if (!nowayout)
+                bcm47xx_wdt_stop();
+
+        misc_deregister(&bcm47xx_wdt_miscdev);
+
+        unregister_reboot_notifier(&bcm47xx_wdt_notifier);
+}
+
+module_init(bcm47xx_wdt_init);
+module_exit(bcm47xx_wdt_exit);
+
+MODULE_AUTHOR("Aleksandar Radovanovic");
+MODULE_DESCRIPTION("Watchdog driver for Broadcom BCM47xx");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/coh901327_wdt.c b/drivers/watchdog/coh901327_wdt.c
new file mode 100644
index 000000000000..fecb307d28e9
--- /dev/null
+++ b/drivers/watchdog/coh901327_wdt.c
@@ -0,0 +1,537 @@
+/*
+ * coh901327_wdt.c
+ *
+ * Copyright (C) 2008-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * Watchdog driver for the ST-Ericsson AB COH 901 327 IP core
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ */
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/interrupt.h>
+#include <linux/pm.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/bitops.h>
+#include <linux/uaccess.h>
+#include <linux/clk.h>
+
+#define DRV_NAME "WDOG COH 901 327"
+
+/*
+ * COH 901 327 register definitions
+ */
+
+/* WDOG_FEED Register 32bit (-/W) */
+#define U300_WDOG_FR                                                    0x00
+#define U300_WDOG_FR_FEED_RESTART_TIMER                                 0xFEEDU
+/* WDOG_TIMEOUT Register 32bit (R/W) */
+#define U300_WDOG_TR                                                    0x04
+#define U300_WDOG_TR_TIMEOUT_MASK                                       0x7FFFU
+/* WDOG_DISABLE1 Register 32bit (-/W) */
+#define U300_WDOG_D1R                                                   0x08
+#define U300_WDOG_D1R_DISABLE1_DISABLE_TIMER                            0x2BADU
+/* WDOG_DISABLE2 Register 32bit (R/W) */
+#define U300_WDOG_D2R                                                   0x0C
+#define U300_WDOG_D2R_DISABLE2_DISABLE_TIMER                            0xCAFEU
+#define U300_WDOG_D2R_DISABLE_STATUS_DISABLED                           0xDABEU
+#define U300_WDOG_D2R_DISABLE_STATUS_ENABLED                            0x0000U
+/* WDOG_STATUS Register 32bit (R/W) */
+#define U300_WDOG_SR                                                    0x10
+#define U300_WDOG_SR_STATUS_TIMED_OUT                                   0xCFE8U
+#define U300_WDOG_SR_STATUS_NORMAL                                      0x0000U
+#define U300_WDOG_SR_RESET_STATUS_RESET                                 0xE8B4U
+/* WDOG_COUNT Register 32bit (R/-) */
+#define U300_WDOG_CR                                                    0x14
+#define U300_WDOG_CR_VALID_IND                                          0x8000U
+#define U300_WDOG_CR_VALID_STABLE                                       0x0000U
+#define U300_WDOG_CR_COUNT_VALUE_MASK                                   0x7FFFU
+/* WDOG_JTAGOVR Register 32bit (R/W) */
+#define U300_WDOG_JOR                                                   0x18
+#define U300_WDOG_JOR_JTAG_MODE_IND                                     0x0002U
+#define U300_WDOG_JOR_JTAG_WATCHDOG_ENABLE                              0x0001U
+/* WDOG_RESTART Register 32bit (-/W) */
+#define U300_WDOG_RR                                                    0x1C
+#define U300_WDOG_RR_RESTART_VALUE_RESUME                               0xACEDU
+/* WDOG_IRQ_EVENT Register 32bit (R/W) */
+#define U300_WDOG_IER                                                   0x20
+#define U300_WDOG_IER_WILL_BARK_IRQ_EVENT_IND                           0x0001U
+#define U300_WDOG_IER_WILL_BARK_IRQ_ACK_ENABLE                          0x0001U
+/* WDOG_IRQ_MASK Register 32bit (R/W) */
+#define U300_WDOG_IMR                                                   0x24
+#define U300_WDOG_IMR_WILL_BARK_IRQ_ENABLE                              0x0001U
+/* WDOG_IRQ_FORCE Register 32bit (R/W) */
+#define U300_WDOG_IFR                                                   0x28
+#define U300_WDOG_IFR_WILL_BARK_IRQ_FORCE_ENABLE                        0x0001U
+
+/* Default timeout in seconds = 1 minute */
+static int margin = 60;
+static resource_size_t phybase;
+static resource_size_t physize;
+static int irq;
+static void __iomem *virtbase;
+static unsigned long coh901327_users;
+static unsigned long boot_status;
+static u16 wdogenablestore;
+static u16 irqmaskstore;
+static struct device *parent;
+
+/*
+ * The watchdog block is of course always clocked, the
+ * clk_enable()/clk_disable() calls are mainly for performing reference
+ * counting higher up in the clock hierarchy.
+ */
+static struct clk *clk;
+
+/*
+ * Enabling and disabling functions.
+ */
+static void coh901327_enable(u16 timeout)
+{
+        u16 val;
+
+        clk_enable(clk);
+        /* Restart timer if it is disabled */
+        val = readw(virtbase + U300_WDOG_D2R);
+        if (val == U300_WDOG_D2R_DISABLE_STATUS_DISABLED)
+                writew(U300_WDOG_RR_RESTART_VALUE_RESUME,
+                       virtbase + U300_WDOG_RR);
+        /* Acknowledge any pending interrupt so it doesn't just fire off */
+        writew(U300_WDOG_IER_WILL_BARK_IRQ_ACK_ENABLE,
+               virtbase + U300_WDOG_IER);
+        /* Enable the watchdog interrupt */
+        writew(U300_WDOG_IMR_WILL_BARK_IRQ_ENABLE, virtbase + U300_WDOG_IMR);
+        /* Activate the watchdog timer */
+        writew(timeout, virtbase + U300_WDOG_TR);
+        /* Start the watchdog timer */
+        writew(U300_WDOG_FR_FEED_RESTART_TIMER, virtbase + U300_WDOG_FR);
+        /*
+         * Extra read so that this change propagate in the watchdog.
+         */
+        (void) readw(virtbase + U300_WDOG_CR);
+        val = readw(virtbase + U300_WDOG_D2R);
+        clk_disable(clk);
+        if (val != U300_WDOG_D2R_DISABLE_STATUS_ENABLED)
+                dev_err(parent,
+                        "%s(): watchdog not enabled! D2R value %04x\n",
+                        __func__, val);
+}
+
+static void coh901327_disable(void)
+{
+        u16 val;
+
+        clk_enable(clk);
+        /* Disable the watchdog interrupt if it is active */
+        writew(0x0000U, virtbase + U300_WDOG_IMR);
+        /* If the watchdog is currently enabled, attempt to disable it */
+        val = readw(virtbase + U300_WDOG_D2R);
+        if (val != U300_WDOG_D2R_DISABLE_STATUS_DISABLED) {
+                writew(U300_WDOG_D1R_DISABLE1_DISABLE_TIMER,
+                       virtbase + U300_WDOG_D1R);
+                writew(U300_WDOG_D2R_DISABLE2_DISABLE_TIMER,
+                       virtbase + U300_WDOG_D2R);
+                /* Write this twice (else problems occur) */
+                writew(U300_WDOG_D2R_DISABLE2_DISABLE_TIMER,
+                       virtbase + U300_WDOG_D2R);
+        }
+        val = readw(virtbase + U300_WDOG_D2R);
+        clk_disable(clk);
+        if (val != U300_WDOG_D2R_DISABLE_STATUS_DISABLED)
+                dev_err(parent,
+                        "%s(): watchdog not disabled! D2R value %04x\n",
+                        __func__, val);
+}
+
+static void coh901327_start(void)
+{
+        coh901327_enable(margin * 100);
+}
+
+static void coh901327_keepalive(void)
+{
+        clk_enable(clk);
+        /* Feed the watchdog */
+        writew(U300_WDOG_FR_FEED_RESTART_TIMER,
+               virtbase + U300_WDOG_FR);
+        clk_disable(clk);
+}
+
+static int coh901327_settimeout(int time)
+{
+        /*
+         * Max margin is 327 since the 10ms
+         * timeout register is max
+         * 0x7FFF = 327670ms ~= 327s.
+         */
+        if (time <= 0 || time > 327)
+                return -EINVAL;
+
+        margin = time;
+        clk_enable(clk);
+        /* Set new timeout value */
+        writew(margin * 100, virtbase + U300_WDOG_TR);
+        /* Feed the dog */
+        writew(U300_WDOG_FR_FEED_RESTART_TIMER,
+               virtbase + U300_WDOG_FR);
+        clk_disable(clk);
+        return 0;
+}
+
+/*
+ * This interrupt occurs 10 ms before the watchdog WILL bark.
+ */
+static irqreturn_t coh901327_interrupt(int irq, void *data)
+{
+        u16 val;
+
+        /*
+         * Ack IRQ? If this occurs we're FUBAR anyway, so
+         * just acknowledge, disable the interrupt and await the imminent end.
+         * If you at some point need a host of callbacks to be called
+         * when the system is about to watchdog-reset, add them here!
+         *
+         * NOTE: on future versions of this IP-block, it will be possible
+         * to prevent a watchdog reset by feeding the watchdog at this
+         * point.
+         */
+        clk_enable(clk);
+        val = readw(virtbase + U300_WDOG_IER);
+        if (val == U300_WDOG_IER_WILL_BARK_IRQ_EVENT_IND)
+                writew(U300_WDOG_IER_WILL_BARK_IRQ_ACK_ENABLE,
+                       virtbase + U300_WDOG_IER);
+        writew(0x0000U, virtbase + U300_WDOG_IMR);
+        clk_disable(clk);
+        dev_crit(parent, "watchdog is barking!\n");
+        return IRQ_HANDLED;
+}
+
+/*
+ * Allow only one user (daemon) to open the watchdog
+ */
+static int coh901327_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(1, &coh901327_users))
+                return -EBUSY;
+        coh901327_start();
+        return nonseekable_open(inode, file);
+}
+
+static int coh901327_release(struct inode *inode, struct file *file)
+{
+        clear_bit(1, &coh901327_users);
+        coh901327_disable();
+        return 0;
+}
+
+static ssize_t coh901327_write(struct file *file, const char __user *data,
+                               size_t len, loff_t *ppos)
+{
+        if (len)
+                coh901327_keepalive();
+        return len;
+}
+
+static long coh901327_ioctl(struct file *file, unsigned int cmd,
+                            unsigned long arg)
+{
+        int ret = -ENOTTY;
+        u16 val;
+        int time;
+        int new_options;
+        union {
+                struct watchdog_info __user *ident;
+                int __user *i;
+        } uarg;
+        static struct watchdog_info ident = {
+                .options                = WDIOF_CARDRESET |
+                                          WDIOF_SETTIMEOUT |
+                                          WDIOF_KEEPALIVEPING,
+                .identity               = "COH 901 327 Watchdog",
+                .firmware_version       = 1,
+        };
+        uarg.i = (int __user *)arg;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user(uarg.ident, &ident,
+                                   sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+                ret = put_user(0, uarg.i);
+                break;
+
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(boot_status, uarg.i);
+                break;
+
+        case WDIOC_SETOPTIONS:
+                ret = get_user(new_options, uarg.i);
+                if (ret)
+                        break;
+                if (new_options & WDIOS_DISABLECARD)
+                        coh901327_disable();
+                if (new_options & WDIOS_ENABLECARD)
+                        coh901327_start();
+                ret = 0;
+                break;
+
+        case WDIOC_KEEPALIVE:
+                coh901327_keepalive();
+                ret = 0;
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                ret = get_user(time, uarg.i);
+                if (ret)
+                        break;
+
+                ret = coh901327_settimeout(time);
+                if (ret)
+                        break;
+                /* Then fall through to return set value */
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(margin, uarg.i);
+                break;
+
+        case WDIOC_GETTIMELEFT:
+                clk_enable(clk);
+                /* Read repeatedly until the value is stable! */
+                val = readw(virtbase + U300_WDOG_CR);
+                while (val & U300_WDOG_CR_VALID_IND)
+                        val = readw(virtbase + U300_WDOG_CR);
+                val &= U300_WDOG_CR_COUNT_VALUE_MASK;
+                clk_disable(clk);
+                if (val != 0)
+                        val /= 100;
+                ret = put_user(val, uarg.i);
+                break;
+        }
+        return ret;
+}
+
+static const struct file_operations coh901327_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = coh901327_write,
+        .unlocked_ioctl = coh901327_ioctl,
+        .open           = coh901327_open,
+        .release        = coh901327_release,
+};
+
+static struct miscdevice coh901327_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &coh901327_fops,
+};
+
+static int __exit coh901327_remove(struct platform_device *pdev)
+{
+        misc_deregister(&coh901327_miscdev);
+        coh901327_disable();
+        free_irq(irq, pdev);
+        clk_put(clk);
+        iounmap(virtbase);
+        release_mem_region(phybase, physize);
+        return 0;
+}
+
+
+static int __init coh901327_probe(struct platform_device *pdev)
+{
+        int ret;
+        u16 val;
+        struct resource *res;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENOENT;
+
+        parent = &pdev->dev;
+        physize = resource_size(res);
+        phybase = res->start;
+
+        if (request_mem_region(phybase, physize, DRV_NAME) == NULL) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        virtbase = ioremap(phybase, physize);
+        if (!virtbase) {
+                ret = -ENOMEM;
+                goto out_no_remap;
+        }
+
+        clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(clk)) {
+                ret = PTR_ERR(clk);
+                dev_err(&pdev->dev, "could not get clock\n");
+                goto out_no_clk;
+        }
+        ret = clk_enable(clk);
+        if (ret) {
+                dev_err(&pdev->dev, "could not enable clock\n");
+                goto out_no_clk_enable;
+        }
+
+        val = readw(virtbase + U300_WDOG_SR);
+        switch (val) {
+        case U300_WDOG_SR_STATUS_TIMED_OUT:
+                dev_info(&pdev->dev,
+                        "watchdog timed out since last chip reset!\n");
+                boot_status = WDIOF_CARDRESET;
+                /* Status will be cleared below */
+                break;
+        case U300_WDOG_SR_STATUS_NORMAL:
+                dev_info(&pdev->dev,
+                        "in normal status, no timeouts have occurred.\n");
+                break;
+        default:
+                dev_info(&pdev->dev,
+                        "contains an illegal status code (%08x)\n", val);
+                break;
+        }
+
+        val = readw(virtbase + U300_WDOG_D2R);
+        switch (val) {
+        case U300_WDOG_D2R_DISABLE_STATUS_DISABLED:
+                dev_info(&pdev->dev, "currently disabled.\n");
+                break;
+        case U300_WDOG_D2R_DISABLE_STATUS_ENABLED:
+                dev_info(&pdev->dev,
+                         "currently enabled! (disabling it now)\n");
+                coh901327_disable();
+                break;
+        default:
+                dev_err(&pdev->dev,
+                        "contains an illegal enable/disable code (%08x)\n",
+                        val);
+                break;
+        }
+
+        /* Reset the watchdog */
+        writew(U300_WDOG_SR_RESET_STATUS_RESET, virtbase + U300_WDOG_SR);
+
+        irq = platform_get_irq(pdev, 0);
+        if (request_irq(irq, coh901327_interrupt, IRQF_DISABLED,
+                        DRV_NAME " Bark", pdev)) {
+                ret = -EIO;
+                goto out_no_irq;
+        }
+
+        clk_disable(clk);
+
+        ret = misc_register(&coh901327_miscdev);
+        if (ret == 0)
+                dev_info(&pdev->dev,
+                         "initialized. timer margin=%d sec\n", margin);
+        else
+                goto out_no_wdog;
+
+        return 0;
+
+out_no_wdog:
+        free_irq(irq, pdev);
+out_no_irq:
+        clk_disable(clk);
+out_no_clk_enable:
+        clk_put(clk);
+out_no_clk:
+        iounmap(virtbase);
+out_no_remap:
+        release_mem_region(phybase, SZ_4K);
+out:
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int coh901327_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        irqmaskstore = readw(virtbase + U300_WDOG_IMR) & 0x0001U;
+        wdogenablestore = readw(virtbase + U300_WDOG_D2R);
+        /* If watchdog is on, disable it here and now */
+        if (wdogenablestore == U300_WDOG_D2R_DISABLE_STATUS_ENABLED)
+                coh901327_disable();
+        return 0;
+}
+
+static int coh901327_resume(struct platform_device *pdev)
+{
+        /* Restore the watchdog interrupt */
+        writew(irqmaskstore, virtbase + U300_WDOG_IMR);
+        if (wdogenablestore == U300_WDOG_D2R_DISABLE_STATUS_ENABLED) {
+                /* Restart the watchdog timer */
+                writew(U300_WDOG_RR_RESTART_VALUE_RESUME,
+                       virtbase + U300_WDOG_RR);
+                writew(U300_WDOG_FR_FEED_RESTART_TIMER,
+                       virtbase + U300_WDOG_FR);
+        }
+        return 0;
+}
+#else
+#define coh901327_suspend NULL
+#define coh901327_resume  NULL
+#endif
+
+/*
+ * Mistreating the watchdog is the only way to perform a software reset of the
+ * system on EMP platforms. So we implement this and export a symbol for it.
+ */
+void coh901327_watchdog_reset(void)
+{
+        /* Enable even if on JTAG too */
+        writew(U300_WDOG_JOR_JTAG_WATCHDOG_ENABLE,
+               virtbase + U300_WDOG_JOR);
+        /*
+         * Timeout = 5s, we have to wait for the watchdog reset to
+         * actually take place: the watchdog will be reloaded with the
+         * default value immediately, so we HAVE to reboot and get back
+         * into the kernel in 30s, or the device will reboot again!
+         * The boot loader will typically deactivate the watchdog, so we
+         * need time enough for the boot loader to get to the point of
+         * deactivating the watchdog before it is shut down by it.
+         *
+         * NOTE: on future versions of the watchdog, this restriction is
+         * gone: the watchdog will be reloaded with a defaul value (1 min)
+         * instead of last value, and you can conveniently set the watchdog
+         * timeout to 10ms (value = 1) without any problems.
+         */
+        coh901327_enable(500);
+        /* Return and await doom */
+}
+
+static struct platform_driver coh901327_driver = {
+        .driver = {
+                .owner  = THIS_MODULE,
+                .name   = "coh901327_wdog",
+        },
+        .remove         = __exit_p(coh901327_remove),
+        .suspend        = coh901327_suspend,
+        .resume         = coh901327_resume,
+};
+
+static int __init coh901327_init(void)
+{
+        return platform_driver_probe(&coh901327_driver, coh901327_probe);
+}
+module_init(coh901327_init);
+
+static void __exit coh901327_exit(void)
+{
+        platform_driver_unregister(&coh901327_driver);
+}
+module_exit(coh901327_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+MODULE_DESCRIPTION("COH 901 327 Watchdog");
+
+module_param(margin, int, 0);
+MODULE_PARM_DESC(margin, "Watchdog margin in seconds (default 60s)");
+
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/hpwdt.c b/drivers/watchdog/hpwdt.c
index c0b9169ba5d5..a6c5674c78e6 100644
--- a/drivers/watchdog/hpwdt.c
+++ b/drivers/watchdog/hpwdt.c
@@ -120,7 +120,8 @@ static int nowayout = WATCHDOG_NOWAYOUT;
 static char expect_release;
 static unsigned long hpwdt_is_open;
 static unsigned int allow_kdump;
-static int hpwdt_nmi_sourcing;
+static unsigned int hpwdt_nmi_sourcing;
+static unsigned int priority;           /* hpwdt at end of die_notify list */
 
 static void __iomem *pci_mem_addr;              /* the PCI-memory address */
 static unsigned long __iomem *hpwdt_timer_reg;
@@ -623,7 +624,7 @@ static struct miscdevice hpwdt_miscdev = {
 
 static struct notifier_block die_notifier = {
         .notifier_call = hpwdt_pretimeout,
-        .priority = 0x7FFFFFFF,
+        .priority = 0,
 };
 
 /*
@@ -641,7 +642,8 @@ static void __devinit hpwdt_check_nmi_sourcing(struct pci_dev *dev)
                 hpwdt_nmi_sourcing = 1;
         else
                 dev_warn(&dev->dev, "NMI sourcing is disabled. To enable this "
-                        "functionality you must reboot with nmi_watchdog=0.\n");
+                        "functionality you must reboot with nmi_watchdog=0 "
+                        "and load the hpwdt driver with priority=1.\n");
 }
 #else
 static void __devinit hpwdt_check_nmi_sourcing(struct pci_dev *dev)
@@ -714,6 +716,14 @@ static int __devinit hpwdt_init_one(struct pci_dev *dev,
         cmn_regs.u1.rah = 0x0D;
         cmn_regs.u1.ral = 0x02;
 
+        /*
+         * If the priority is set to 1, then we will be put first on the
+         * die notify list to handle a critical NMI. The default is to
+         * be last so other users of the NMI signal can function.
+         */
+        if (priority)
+                die_notifier.priority = 0x7FFFFFFF;
+
         retval = register_die_notifier(&die_notifier);
         if (retval != 0) {
                 dev_warn(&dev->dev,
@@ -733,9 +743,11 @@ static int __devinit hpwdt_init_one(struct pci_dev *dev,
         printk(KERN_INFO
                 "hp Watchdog Timer Driver: %s"
                 ", timer margin: %d seconds (nowayout=%d)"
-                ", allow kernel dump: %s (default = 0/OFF).\n",
+                ", allow kernel dump: %s (default = 0/OFF)"
+                ", priority: %s (default = 0/LAST).\n",
                 HPWDT_VERSION, soft_margin, nowayout,
-                (allow_kdump == 0) ? "OFF" : "ON");
+                (allow_kdump == 0) ? "OFF" : "ON",
+                (priority == 0) ? "LAST" : "FIRST");
 
         return 0;
 
@@ -798,5 +810,9 @@ module_param(nowayout, int, 0);
 MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
+module_param(priority, int, 0);
+MODULE_PARM_DESC(priority, "The hpwdt driver handles NMIs first or last"
+                " (default = 0/Last)\n");
+
 module_init(hpwdt_init);
 module_exit(hpwdt_cleanup);
diff --git a/drivers/watchdog/omap_wdt.c b/drivers/watchdog/omap_wdt.c
index f2713851aaab..3ed571a2ab18 100644
--- a/drivers/watchdog/omap_wdt.c
+++ b/drivers/watchdog/omap_wdt.c
@@ -159,6 +159,7 @@ static int omap_wdt_open(struct inode *inode, struct file *file)
         file->private_data = (void *) wdev;
 
         omap_wdt_set_timeout(wdev);
+        omap_wdt_ping(wdev); /* trigger loading of new timeout value */
         omap_wdt_enable(wdev);
 
         return nonseekable_open(inode, file);
@@ -313,6 +314,9 @@ static int __devinit omap_wdt_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, wdev);
 
+        clk_enable(wdev->ick);
+        clk_enable(wdev->fck);
+
         omap_wdt_disable(wdev);
         omap_wdt_adjust_timeout(timer_margin);
 
@@ -332,6 +336,9 @@ static int __devinit omap_wdt_probe(struct platform_device *pdev)
         /* autogate OCP interface clock */
         __raw_writel(0x01, wdev->base + OMAP_WATCHDOG_SYS_CONFIG);
 
+        clk_disable(wdev->ick);
+        clk_disable(wdev->fck);
+
         omap_wdt_dev = pdev;
 
         return 0;
diff --git a/drivers/watchdog/pnx833x_wdt.c b/drivers/watchdog/pnx833x_wdt.c
new file mode 100644
index 000000000000..538ec2c05197
--- /dev/null
+++ b/drivers/watchdog/pnx833x_wdt.c
@@ -0,0 +1,282 @@
+/*
+ *  PNX833x Hardware Watchdog Driver
+ *  Copyright 2008 NXP Semiconductors
+ *  Daniel Laird <daniel.j.laird@nxp.com>
+ *  Andre McCurdy <andre.mccurdy@nxp.com>
+ *
+ *  Heavily based upon - IndyDog        0.3
+ *  A Hardware Watchdog Device for SGI IP22
+ *
+ * (c) Copyright 2002 Guido Guenther <agx@sigxcpu.org>, All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ *
+ * based on softdog.c by Alan Cox <alan@redhat.com>
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/notifier.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <asm/mach-pnx833x/pnx833x.h>
+
+#define PFX "pnx833x: "
+#define WATCHDOG_TIMEOUT 30             /* 30 sec Maximum timeout */
+#define WATCHDOG_COUNT_FREQUENCY 68000000U /* Watchdog counts at 68MHZ. */
+
+/** CONFIG block */
+#define PNX833X_CONFIG                      (0x07000U)
+#define PNX833X_CONFIG_CPU_WATCHDOG         (0x54)
+#define PNX833X_CONFIG_CPU_WATCHDOG_COMPARE (0x58)
+#define PNX833X_CONFIG_CPU_COUNTERS_CONTROL (0x1c)
+
+/** RESET block */
+#define PNX833X_RESET                       (0x08000U)
+#define PNX833X_RESET_CONFIG                (0x08)
+
+static int pnx833x_wdt_alive;
+
+/* Set default timeout in MHZ.*/
+static int pnx833x_wdt_timeout = (WATCHDOG_TIMEOUT * WATCHDOG_COUNT_FREQUENCY);
+module_param(pnx833x_wdt_timeout, int, 0);
+MODULE_PARM_DESC(timeout, "Watchdog timeout in Mhz. (68Mhz clock), default="
+                        __MODULE_STRING(pnx833x_wdt_timeout) "(30 seconds).");
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started (default="
+                                        __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static int start_enabled = 1;
+module_param(start_enabled, int, 0);
+MODULE_PARM_DESC(start_enabled, "Watchdog is started on module insertion "
+                                "(default=" __MODULE_STRING(start_enabled) ")");
+
+static void pnx833x_wdt_start(void)
+{
+        /* Enable watchdog causing reset. */
+        PNX833X_REG(PNX833X_RESET + PNX833X_RESET_CONFIG) |= 0x1;
+        /* Set timeout.*/
+        PNX833X_REG(PNX833X_CONFIG +
+                PNX833X_CONFIG_CPU_WATCHDOG_COMPARE) = pnx833x_wdt_timeout;
+        /* Enable watchdog. */
+        PNX833X_REG(PNX833X_CONFIG +
+                                PNX833X_CONFIG_CPU_COUNTERS_CONTROL) |= 0x1;
+
+        printk(KERN_INFO PFX "Started watchdog timer.\n");
+}
+
+static void pnx833x_wdt_stop(void)
+{
+        /* Disable watchdog causing reset. */
+        PNX833X_REG(PNX833X_RESET + PNX833X_CONFIG) &= 0xFFFFFFFE;
+        /* Disable watchdog.*/
+        PNX833X_REG(PNX833X_CONFIG +
+                        PNX833X_CONFIG_CPU_COUNTERS_CONTROL) &= 0xFFFFFFFE;
+
+        printk(KERN_INFO PFX "Stopped watchdog timer.\n");
+}
+
+static void pnx833x_wdt_ping(void)
+{
+        PNX833X_REG(PNX833X_CONFIG +
+                PNX833X_CONFIG_CPU_WATCHDOG_COMPARE) = pnx833x_wdt_timeout;
+}
+
+/*
+ *      Allow only one person to hold it open
+ */
+static int pnx833x_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(0, &pnx833x_wdt_alive))
+                return -EBUSY;
+
+        if (nowayout)
+                __module_get(THIS_MODULE);
+
+        /* Activate timer */
+        if (!start_enabled)
+                pnx833x_wdt_start();
+
+        pnx833x_wdt_ping();
+
+        printk(KERN_INFO "Started watchdog timer.\n");
+
+        return nonseekable_open(inode, file);
+}
+
+static int pnx833x_wdt_release(struct inode *inode, struct file *file)
+{
+        /* Shut off the timer.
+         * Lock it in if it's a module and we defined ...NOWAYOUT */
+        if (!nowayout)
+                pnx833x_wdt_stop(); /* Turn the WDT off */
+
+        clear_bit(0, &pnx833x_wdt_alive);
+        return 0;
+}
+
+static ssize_t pnx833x_wdt_write(struct file *file, const char *data, size_t len, loff_t *ppos)
+{
+        /* Refresh the timer. */
+        if (len)
+                pnx833x_wdt_ping();
+
+        return len;
+}
+
+static long pnx833x_wdt_ioctl(struct file *file, unsigned int cmd,
+                                                        unsigned long arg)
+{
+        int options, new_timeout = 0;
+        uint32_t timeout, timeout_left = 0;
+
+        static struct watchdog_info ident = {
+                .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT,
+                .firmware_version = 0,
+                .identity = "Hardware Watchdog for PNX833x",
+        };
+
+        switch (cmd) {
+        default:
+                return -ENOTTY;
+
+        case WDIOC_GETSUPPORT:
+                if (copy_to_user((struct watchdog_info *)arg,
+                                 &ident, sizeof(ident)))
+                        return -EFAULT;
+                return 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, (int *)arg);
+
+        case WDIOC_SETOPTIONS:
+                if (get_user(options, (int *)arg))
+                        return -EFAULT;
+
+                if (options & WDIOS_DISABLECARD)
+                        pnx833x_wdt_stop();
+
+                if (options & WDIOS_ENABLECARD)
+                        pnx833x_wdt_start();
+
+                return 0;
+
+        case WDIOC_KEEPALIVE:
+                pnx833x_wdt_ping();
+                return 0;
+
+        case WDIOC_SETTIMEOUT:
+        {
+                if (get_user(new_timeout, (int *)arg))
+                        return -EFAULT;
+
+                pnx833x_wdt_timeout = new_timeout;
+                PNX833X_REG(PNX833X_CONFIG +
+                        PNX833X_CONFIG_CPU_WATCHDOG_COMPARE) = new_timeout;
+                return put_user(new_timeout, (int *)arg);
+        }
+
+        case WDIOC_GETTIMEOUT:
+                timeout = PNX833X_REG(PNX833X_CONFIG +
+                                        PNX833X_CONFIG_CPU_WATCHDOG_COMPARE);
+                return put_user(timeout, (int *)arg);
+
+        case WDIOC_GETTIMELEFT:
+                timeout_left = PNX833X_REG(PNX833X_CONFIG +
+                                                PNX833X_CONFIG_CPU_WATCHDOG);
+                return put_user(timeout_left, (int *)arg);
+
+        }
+}
+
+static int pnx833x_wdt_notify_sys(struct notifier_block *this,
+                                        unsigned long code, void *unused)
+{
+        if (code == SYS_DOWN || code == SYS_HALT)
+                pnx833x_wdt_stop(); /* Turn the WDT off */
+
+        return NOTIFY_DONE;
+}
+
+static const struct file_operations pnx833x_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .write          = pnx833x_wdt_write,
+        .unlocked_ioctl = pnx833x_wdt_ioctl,
+        .open           = pnx833x_wdt_open,
+        .release        = pnx833x_wdt_release,
+};
+
+static struct miscdevice pnx833x_wdt_miscdev = {
+        .minor          = WATCHDOG_MINOR,
+        .name           = "watchdog",
+        .fops           = &pnx833x_wdt_fops,
+};
+
+static struct notifier_block pnx833x_wdt_notifier = {
+        .notifier_call = pnx833x_wdt_notify_sys,
+};
+
+static char banner[] __initdata =
+        KERN_INFO PFX "Hardware Watchdog Timer for PNX833x: Version 0.1\n";
+
+static int __init watchdog_init(void)
+{
+        int ret, cause;
+
+        /* Lets check the reason for the reset.*/
+        cause = PNX833X_REG(PNX833X_RESET);
+        /*If bit 31 is set then watchdog was cause of reset.*/
+        if (cause & 0x80000000) {
+                printk(KERN_INFO PFX "The system was previously reset due to "
+                        "the watchdog firing - please investigate...\n");
+        }
+
+        ret = register_reboot_notifier(&pnx833x_wdt_notifier);
+        if (ret) {
+                printk(KERN_ERR PFX
+                        "cannot register reboot notifier (err=%d)\n", ret);
+                return ret;
+        }
+
+        ret = misc_register(&pnx833x_wdt_miscdev);
+        if (ret) {
+                printk(KERN_ERR PFX
+                        "cannot register miscdev on minor=%d (err=%d)\n",
+                        WATCHDOG_MINOR, ret);
+                unregister_reboot_notifier(&pnx833x_wdt_notifier);
+                return ret;
+        }
+
+        printk(banner);
+        if (start_enabled)
+                pnx833x_wdt_start();
+
+        return 0;
+}
+
+static void __exit watchdog_exit(void)
+{
+        misc_deregister(&pnx833x_wdt_miscdev);
+        unregister_reboot_notifier(&pnx833x_wdt_notifier);
+}
+
+module_init(watchdog_init);
+module_exit(watchdog_exit);
+
+MODULE_AUTHOR("Daniel Laird/Andre McCurdy");
+MODULE_DESCRIPTION("Hardware Watchdog Device for PNX833x");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/stmp3xxx_wdt.c b/drivers/watchdog/stmp3xxx_wdt.c
new file mode 100644
index 000000000000..5dd952681f32
--- /dev/null
+++ b/drivers/watchdog/stmp3xxx_wdt.c
@@ -0,0 +1,296 @@
+/*
+ * Watchdog driver for Freescale STMP37XX/STMP378X
+ *
+ * Author: Vitaly Wool <vital@embeddedalley.com>
+ *
+ * Copyright 2008 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
+ */
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/watchdog.h>
+#include <linux/platform_device.h>
+#include <linux/spinlock.h>
+#include <linux/uaccess.h>
+
+#include <mach/platform.h>
+#include <mach/regs-rtc.h>
+
+#define DEFAULT_HEARTBEAT       19
+#define MAX_HEARTBEAT           (0x10000000 >> 6)
+
+/* missing bitmask in headers */
+#define BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER     0x80000000
+
+#define WDT_IN_USE              0
+#define WDT_OK_TO_CLOSE         1
+
+#define WDOG_COUNTER_RATE       1000 /* 1 kHz clock */
+
+static DEFINE_SPINLOCK(stmp3xxx_wdt_io_lock);
+static unsigned long wdt_status;
+static const int nowayout = WATCHDOG_NOWAYOUT;
+static int heartbeat = DEFAULT_HEARTBEAT;
+static unsigned long boot_status;
+
+static void wdt_enable(u32 value)
+{
+        spin_lock(&stmp3xxx_wdt_io_lock);
+        __raw_writel(value, REGS_RTC_BASE + HW_RTC_WATCHDOG);
+        stmp3xxx_setl(BM_RTC_CTRL_WATCHDOGEN, REGS_RTC_BASE + HW_RTC_CTRL);
+        stmp3xxx_setl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
+                        REGS_RTC_BASE + HW_RTC_PERSISTENT1);
+        spin_unlock(&stmp3xxx_wdt_io_lock);
+}
+
+static void wdt_disable(void)
+{
+        spin_lock(&stmp3xxx_wdt_io_lock);
+        stmp3xxx_clearl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
+                        REGS_RTC_BASE + HW_RTC_PERSISTENT1);
+        stmp3xxx_clearl(BM_RTC_CTRL_WATCHDOGEN, REGS_RTC_BASE + HW_RTC_CTRL);
+        spin_unlock(&stmp3xxx_wdt_io_lock);
+}
+
+static void wdt_ping(void)
+{
+        wdt_enable(heartbeat * WDOG_COUNTER_RATE);
+}
+
+static int stmp3xxx_wdt_open(struct inode *inode, struct file *file)
+{
+        if (test_and_set_bit(WDT_IN_USE, &wdt_status))
+                return -EBUSY;
+
+        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+        wdt_ping();
+
+        return nonseekable_open(inode, file);
+}
+
+static ssize_t stmp3xxx_wdt_write(struct file *file, const char __user *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);
+                        }
+                }
+                wdt_ping();
+        }
+
+        return len;
+}
+
+static struct watchdog_info ident = {
+        .options        = WDIOF_CARDRESET |
+                          WDIOF_MAGICCLOSE |
+                          WDIOF_SETTIMEOUT |
+                          WDIOF_KEEPALIVEPING,
+        .identity       = "STMP3XXX Watchdog",
+};
+
+static long stmp3xxx_wdt_ioctl(struct file *file, unsigned int cmd,
+        unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        int new_heartbeat, opts;
+        int ret = -ENOTTY;
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                ret = copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0;
+                break;
+
+        case WDIOC_GETSTATUS:
+                ret = put_user(0, p);
+                break;
+
+        case WDIOC_GETBOOTSTATUS:
+                ret = put_user(boot_status, p);
+                break;
+
+        case WDIOC_SETOPTIONS:
+                if (get_user(opts, p)) {
+                        ret = -EFAULT;
+                        break;
+                }
+                if (opts & WDIOS_DISABLECARD)
+                        wdt_disable();
+                else if (opts & WDIOS_ENABLECARD)
+                        wdt_ping();
+                else {
+                        pr_debug("%s: unknown option 0x%x\n", __func__, opts);
+                        ret = -EINVAL;
+                        break;
+                }
+                ret = 0;
+                break;
+
+        case WDIOC_KEEPALIVE:
+                wdt_ping();
+                ret = 0;
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_heartbeat, p)) {
+                        ret = -EFAULT;
+                        break;
+                }
+                if (new_heartbeat <= 0 || new_heartbeat > MAX_HEARTBEAT) {
+                        ret = -EINVAL;
+                        break;
+                }
+
+                heartbeat = new_heartbeat;
+                wdt_ping();
+                /* Fall through */
+
+        case WDIOC_GETTIMEOUT:
+                ret = put_user(heartbeat, p);
+                break;
+        }
+        return ret;
+}
+
+static int stmp3xxx_wdt_release(struct inode *inode, struct file *file)
+{
+        int ret = 0;
+
+        if (!nowayout) {
+                if (!test_bit(WDT_OK_TO_CLOSE, &wdt_status)) {
+                        wdt_ping();
+                        pr_debug("%s: Device closed unexpectdly\n", __func__);
+                        ret = -EINVAL;
+                } else {
+                        wdt_disable();
+                        clear_bit(WDT_OK_TO_CLOSE, &wdt_status);
+                }
+        }
+        clear_bit(WDT_IN_USE, &wdt_status);
+
+        return ret;
+}
+
+static const struct file_operations stmp3xxx_wdt_fops = {
+        .owner = THIS_MODULE,
+        .llseek = no_llseek,
+        .write = stmp3xxx_wdt_write,
+        .unlocked_ioctl = stmp3xxx_wdt_ioctl,
+        .open = stmp3xxx_wdt_open,
+        .release = stmp3xxx_wdt_release,
+};
+
+static struct miscdevice stmp3xxx_wdt_miscdev = {
+        .minor = WATCHDOG_MINOR,
+        .name = "watchdog",
+        .fops = &stmp3xxx_wdt_fops,
+};
+
+static int __devinit stmp3xxx_wdt_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+
+        if (heartbeat < 1 || heartbeat > MAX_HEARTBEAT)
+                heartbeat = DEFAULT_HEARTBEAT;
+
+        boot_status = __raw_readl(REGS_RTC_BASE + HW_RTC_PERSISTENT1) &
+                        BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER;
+        boot_status = !!boot_status;
+        stmp3xxx_clearl(BV_RTC_PERSISTENT1_GENERAL__RTC_FORCE_UPDATER,
+                        REGS_RTC_BASE + HW_RTC_PERSISTENT1);
+        wdt_disable();          /* disable for now */
+
+        ret = misc_register(&stmp3xxx_wdt_miscdev);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "cannot register misc device\n");
+                return ret;
+        }
+
+        printk(KERN_INFO "stmp3xxx watchdog: initialized, heartbeat %d sec\n",
+                heartbeat);
+
+        return ret;
+}
+
+static int __devexit stmp3xxx_wdt_remove(struct platform_device *pdev)
+{
+        misc_deregister(&stmp3xxx_wdt_miscdev);
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int wdt_suspended;
+static u32 wdt_saved_time;
+
+static int stmp3xxx_wdt_suspend(struct platform_device *pdev,
+                                pm_message_t state)
+{
+        if (__raw_readl(REGS_RTC_BASE + HW_RTC_CTRL) &
+                BM_RTC_CTRL_WATCHDOGEN) {
+                wdt_suspended = 1;
+                wdt_saved_time = __raw_readl(REGS_RTC_BASE + HW_RTC_WATCHDOG);
+                wdt_disable();
+        }
+        return 0;
+}
+
+static int stmp3xxx_wdt_resume(struct platform_device *pdev)
+{
+        if (wdt_suspended) {
+                wdt_enable(wdt_saved_time);
+                wdt_suspended = 0;
+        }
+        return 0;
+}
+#else
+#define stmp3xxx_wdt_suspend    NULL
+#define stmp3xxx_wdt_resume     NULL
+#endif
+
+static struct platform_driver platform_wdt_driver = {
+        .driver = {
+                .name = "stmp3xxx_wdt",
+        },
+        .probe = stmp3xxx_wdt_probe,
+        .remove = __devexit_p(stmp3xxx_wdt_remove),
+        .suspend = stmp3xxx_wdt_suspend,
+        .resume = stmp3xxx_wdt_resume,
+};
+
+static int __init stmp3xxx_wdt_init(void)
+{
+        return platform_driver_register(&platform_wdt_driver);
+}
+
+static void __exit stmp3xxx_wdt_exit(void)
+{
+        return platform_driver_unregister(&platform_wdt_driver);
+}
+
+module_init(stmp3xxx_wdt_init);
+module_exit(stmp3xxx_wdt_exit);
+
+MODULE_DESCRIPTION("STMP3XXX Watchdog Driver");
+MODULE_LICENSE("GPL");
+
+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_ALIAS_MISCDEV(WATCHDOG_MINOR);
diff --git a/drivers/watchdog/twl4030_wdt.c b/drivers/watchdog/twl4030_wdt.c
new file mode 100644
index 000000000000..cb46556f2973
--- /dev/null
+++ b/drivers/watchdog/twl4030_wdt.c
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) Nokia Corporation
+ *
+ * Written by Timo Kokkonen <timo.t.kokkonen at nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/fs.h>
+#include <linux/watchdog.h>
+#include <linux/platform_device.h>
+#include <linux/miscdevice.h>
+#include <linux/uaccess.h>
+#include <linux/i2c/twl4030.h>
+
+#define TWL4030_WATCHDOG_CFG_REG_OFFS   0x3
+
+#define TWL4030_WDT_STATE_OPEN          0x1
+#define TWL4030_WDT_STATE_ACTIVE        0x8
+
+static struct platform_device *twl4030_wdt_dev;
+
+struct twl4030_wdt {
+        struct miscdevice       miscdev;
+        int                     timer_margin;
+        unsigned long           state;
+};
+
+static int nowayout = WATCHDOG_NOWAYOUT;
+module_param(nowayout, int, 0);
+MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
+        "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
+
+static int twl4030_wdt_write(unsigned char val)
+{
+        return twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, val,
+                                        TWL4030_WATCHDOG_CFG_REG_OFFS);
+}
+
+static int twl4030_wdt_enable(struct twl4030_wdt *wdt)
+{
+        return twl4030_wdt_write(wdt->timer_margin + 1);
+}
+
+static int twl4030_wdt_disable(struct twl4030_wdt *wdt)
+{
+        return twl4030_wdt_write(0);
+}
+
+static int twl4030_wdt_set_timeout(struct twl4030_wdt *wdt, int timeout)
+{
+        if (timeout < 0 || timeout > 30) {
+                dev_warn(wdt->miscdev.parent,
+                        "Timeout can only be in the range [0-30] seconds");
+                return -EINVAL;
+        }
+        wdt->timer_margin = timeout;
+        return twl4030_wdt_enable(wdt);
+}
+
+static ssize_t twl4030_wdt_write_fop(struct file *file,
+                const char __user *data, size_t len, loff_t *ppos)
+{
+        struct twl4030_wdt *wdt = file->private_data;
+
+        if (len)
+                twl4030_wdt_enable(wdt);
+
+        return len;
+}
+
+static long twl4030_wdt_ioctl(struct file *file,
+                unsigned int cmd, unsigned long arg)
+{
+        void __user *argp = (void __user *)arg;
+        int __user *p = argp;
+        int new_margin;
+        struct twl4030_wdt *wdt = file->private_data;
+
+        static const struct watchdog_info twl4030_wd_ident = {
+                .identity = "TWL4030 Watchdog",
+                .options = WDIOF_SETTIMEOUT,
+                .firmware_version = 0,
+        };
+
+        switch (cmd) {
+        case WDIOC_GETSUPPORT:
+                return copy_to_user(argp, &twl4030_wd_ident,
+                                sizeof(twl4030_wd_ident)) ? -EFAULT : 0;
+
+        case WDIOC_GETSTATUS:
+        case WDIOC_GETBOOTSTATUS:
+                return put_user(0, p);
+
+        case WDIOC_KEEPALIVE:
+                twl4030_wdt_enable(wdt);
+                break;
+
+        case WDIOC_SETTIMEOUT:
+                if (get_user(new_margin, p))
+                        return -EFAULT;
+                if (twl4030_wdt_set_timeout(wdt, new_margin))
+                        return -EINVAL;
+                return put_user(wdt->timer_margin, p);
+
+        case WDIOC_GETTIMEOUT:
+                return put_user(wdt->timer_margin, p);
+
+        default:
+                return -ENOTTY;
+        }
+
+        return 0;
+}
+
+static int twl4030_wdt_open(struct inode *inode, struct file *file)
+{
+        struct twl4030_wdt *wdt = platform_get_drvdata(twl4030_wdt_dev);
+
+        /* /dev/watchdog can only be opened once */
+        if (test_and_set_bit(0, &wdt->state))
+                return -EBUSY;
+
+        wdt->state |= TWL4030_WDT_STATE_ACTIVE;
+        file->private_data = (void *) wdt;
+
+        twl4030_wdt_enable(wdt);
+        return nonseekable_open(inode, file);
+}
+
+static int twl4030_wdt_release(struct inode *inode, struct file *file)
+{
+        struct twl4030_wdt *wdt = file->private_data;
+        if (nowayout) {
+                dev_alert(wdt->miscdev.parent,
+                       "Unexpected close, watchdog still running!\n");
+                twl4030_wdt_enable(wdt);
+        } else {
+                if (twl4030_wdt_disable(wdt))
+                        return -EFAULT;
+                wdt->state &= ~TWL4030_WDT_STATE_ACTIVE;
+        }
+
+        clear_bit(0, &wdt->state);
+        return 0;
+}
+
+static const struct file_operations twl4030_wdt_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .open           = twl4030_wdt_open,
+        .release        = twl4030_wdt_release,
+        .unlocked_ioctl = twl4030_wdt_ioctl,
+        .write          = twl4030_wdt_write_fop,
+};
+
+static int __devinit twl4030_wdt_probe(struct platform_device *pdev)
+{
+        int ret = 0;
+        struct twl4030_wdt *wdt;
+
+        wdt = kzalloc(sizeof(struct twl4030_wdt), GFP_KERNEL);
+        if (!wdt)
+                return -ENOMEM;
+
+        wdt->state              = 0;
+        wdt->timer_margin       = 30;
+        wdt->miscdev.parent     = &pdev->dev;
+        wdt->miscdev.fops       = &twl4030_wdt_fops;
+        wdt->miscdev.minor      = WATCHDOG_MINOR;
+        wdt->miscdev.name       = "watchdog";
+
+        platform_set_drvdata(pdev, wdt);
+
+        twl4030_wdt_dev = pdev;
+
+        ret = misc_register(&wdt->miscdev);
+        if (ret) {
+                dev_err(wdt->miscdev.parent,
+                        "Failed to register misc device\n");
+                platform_set_drvdata(pdev, NULL);
+                kfree(wdt);
+                twl4030_wdt_dev = NULL;
+                return ret;
+        }
+        return 0;
+}
+
+static int __devexit twl4030_wdt_remove(struct platform_device *pdev)
+{
+        struct twl4030_wdt *wdt = platform_get_drvdata(pdev);
+
+        if (wdt->state & TWL4030_WDT_STATE_ACTIVE)
+                if (twl4030_wdt_disable(wdt))
+                        return -EFAULT;
+
+        wdt->state &= ~TWL4030_WDT_STATE_ACTIVE;
+        misc_deregister(&wdt->miscdev);
+
+        platform_set_drvdata(pdev, NULL);
+        kfree(wdt);
+        twl4030_wdt_dev = NULL;
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int twl4030_wdt_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct twl4030_wdt *wdt = platform_get_drvdata(pdev);
+        if (wdt->state & TWL4030_WDT_STATE_ACTIVE)
+                return twl4030_wdt_disable(wdt);
+
+        return 0;
+}
+
+static int twl4030_wdt_resume(struct platform_device *pdev)
+{
+        struct twl4030_wdt *wdt = platform_get_drvdata(pdev);
+        if (wdt->state & TWL4030_WDT_STATE_ACTIVE)
+                return twl4030_wdt_enable(wdt);
+
+        return 0;
+}
+#else
+#define twl4030_wdt_suspend        NULL
+#define twl4030_wdt_resume         NULL
+#endif
+
+static struct platform_driver twl4030_wdt_driver = {
+        .probe          = twl4030_wdt_probe,
+        .remove         = __devexit_p(twl4030_wdt_remove),
+        .suspend        = twl4030_wdt_suspend,
+        .resume         = twl4030_wdt_resume,
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "twl4030_wdt",
+        },
+};
+
+static int __devinit twl4030_wdt_init(void)
+{
+        return platform_driver_register(&twl4030_wdt_driver);
+}
+module_init(twl4030_wdt_init);
+
+static void __devexit twl4030_wdt_exit(void)
+{
+        platform_driver_unregister(&twl4030_wdt_driver);
+}
+module_exit(twl4030_wdt_exit);
+
+MODULE_AUTHOR("Nokia Corporation");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR);
+MODULE_ALIAS("platform:twl4030_wdt");
+
diff --git a/drivers/watchdog/wdrtas.c b/drivers/watchdog/wdrtas.c
index a4fe7a38d9b0..3bde56bce63a 100644
--- a/drivers/watchdog/wdrtas.c
+++ b/drivers/watchdog/wdrtas.c
@@ -218,16 +218,14 @@ static void wdrtas_timer_keepalive(void)
  */
 static int wdrtas_get_temperature(void)
 {
-        long result;
+        int result;
         int temperature = 0;
 
-        result = rtas_call(wdrtas_token_get_sensor_state, 2, 2,
-                           (void *)__pa(&temperature),
-                           WDRTAS_THERMAL_SENSOR, 0);
+        result = rtas_get_sensor(WDRTAS_THERMAL_SENSOR, 0, &temperature);
 
         if (result < 0)
                 printk(KERN_WARNING "wdrtas: reading the thermal sensor "
-                       "faild: %li\n", result);
+                       "failed: %i\n", result);
         else
                 temperature = ((temperature * 9) / 5) + 32; /* fahrenheit */
 
diff --git a/drivers/watchdog/wdt_pci.c b/drivers/watchdog/wdt_pci.c
index c45839a4a34d..7a1bdc7c95a9 100644
--- a/drivers/watchdog/wdt_pci.c
+++ b/drivers/watchdog/wdt_pci.c
@@ -2,7 +2,7 @@
  *      Industrial Computer Source PCI-WDT500/501 driver
  *
  *      (c) Copyright 1996-1997 Alan Cox <alan@lxorguk.ukuu.org.uk>,
- *                                               All Rights Reserved.
+ *                                              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
@@ -99,14 +99,16 @@ MODULE_PARM_DESC(nowayout,
                 "Watchdog cannot be stopped once started (default="
                                 __MODULE_STRING(WATCHDOG_NOWAYOUT) ")");
 
-#ifdef CONFIG_WDT_501_PCI
 /* Support for the Fan Tachometer on the PCI-WDT501 */
 static int tachometer;
-
 module_param(tachometer, int, 0);
 MODULE_PARM_DESC(tachometer,
-        "PCI-WDT501 Fan Tachometer support (0=disable, default=0)");
-#endif /* CONFIG_WDT_501_PCI */
+                "PCI-WDT501 Fan Tachometer support (0=disable, default=0)");
+
+static int type = 500;
+module_param(type, int, 0);
+MODULE_PARM_DESC(type,
+                "PCI-WDT501 Card type (500 or 501 , default=500)");
 
 /*
  *      Programming support
@@ -266,22 +268,21 @@ static int wdtpci_get_status(int *status)
                 *status |= WDIOF_EXTERN1;
         if (new_status & WDC_SR_ISII1)
                 *status |= WDIOF_EXTERN2;
-#ifdef CONFIG_WDT_501_PCI
-        if (!(new_status & WDC_SR_TGOOD))
-                *status |= WDIOF_OVERHEAT;
-        if (!(new_status & WDC_SR_PSUOVER))
-                *status |= WDIOF_POWEROVER;
-        if (!(new_status & WDC_SR_PSUUNDR))
-                *status |= WDIOF_POWERUNDER;
-        if (tachometer) {
-                if (!(new_status & WDC_SR_FANGOOD))
-                        *status |= WDIOF_FANFAULT;
+        if (type == 501) {
+                if (!(new_status & WDC_SR_TGOOD))
+                        *status |= WDIOF_OVERHEAT;
+                if (!(new_status & WDC_SR_PSUOVER))
+                        *status |= WDIOF_POWEROVER;
+                if (!(new_status & WDC_SR_PSUUNDR))
+                        *status |= WDIOF_POWERUNDER;
+                if (tachometer) {
+                        if (!(new_status & WDC_SR_FANGOOD))
+                                *status |= WDIOF_FANFAULT;
+                }
         }
-#endif /* CONFIG_WDT_501_PCI */
         return 0;
 }
 
-#ifdef CONFIG_WDT_501_PCI
 /**
  *      wdtpci_get_temperature:
  *
@@ -300,7 +301,6 @@ static int wdtpci_get_temperature(int *temperature)
         *temperature = (c * 11 / 15) + 7;
         return 0;
 }
-#endif /* CONFIG_WDT_501_PCI */
 
 /**
  *      wdtpci_interrupt:
@@ -327,22 +327,22 @@ static irqreturn_t wdtpci_interrupt(int irq, void *dev_id)
 
         printk(KERN_CRIT PFX "status %d\n", status);
 
-#ifdef CONFIG_WDT_501_PCI
-        if (!(status & WDC_SR_TGOOD)) {
-                u8 alarm = inb(WDT_RT);
-                printk(KERN_CRIT PFX "Overheat alarm.(%d)\n", alarm);
-                udelay(8);
-        }
-        if (!(status & WDC_SR_PSUOVER))
-                printk(KERN_CRIT PFX "PSU over voltage.\n");
-        if (!(status & WDC_SR_PSUUNDR))
-                printk(KERN_CRIT PFX "PSU under voltage.\n");
-        if (tachometer) {
-                if (!(status & WDC_SR_FANGOOD))
-                        printk(KERN_CRIT PFX "Possible fan fault.\n");
+        if (type == 501) {
+                if (!(status & WDC_SR_TGOOD)) {
+                        printk(KERN_CRIT PFX "Overheat alarm.(%d)\n",
+                                                                inb(WDT_RT));
+                        udelay(8);
+                }
+                if (!(status & WDC_SR_PSUOVER))
+                        printk(KERN_CRIT PFX "PSU over voltage.\n");
+                if (!(status & WDC_SR_PSUUNDR))
+                        printk(KERN_CRIT PFX "PSU under voltage.\n");
+                if (tachometer) {
+                        if (!(status & WDC_SR_FANGOOD))
+                                printk(KERN_CRIT PFX "Possible fan fault.\n");
+                }
         }
-#endif /* CONFIG_WDT_501_PCI */
-        if (!(status&WDC_SR_WCCR)) {
+        if (!(status & WDC_SR_WCCR)) {
 #ifdef SOFTWARE_REBOOT
 #ifdef ONLY_TESTING
                 printk(KERN_CRIT PFX "Would Reboot.\n");
@@ -371,12 +371,13 @@ static irqreturn_t wdtpci_interrupt(int irq, void *dev_id)
  */
 
 static ssize_t wdtpci_write(struct file *file, const char __user *buf,
-                                        size_t count, loff_t *ppos)
+                                                size_t count, loff_t *ppos)
 {
         if (count) {
                 if (!nowayout) {
                         size_t i;
 
+                        /* In case it was set long ago */
                         expect_close = 0;
 
                         for (i = 0; i != count; i++) {
@@ -406,10 +407,10 @@ static ssize_t wdtpci_write(struct file *file, const char __user *buf,
 static long wdtpci_ioctl(struct file *file, unsigned int cmd,
                                                         unsigned long arg)
 {
-        int new_heartbeat;
-        int status;
         void __user *argp = (void __user *)arg;
         int __user *p = argp;
+        int new_heartbeat;
+        int status;
 
         static struct watchdog_info ident = {
                 .options =              WDIOF_SETTIMEOUT|
@@ -421,11 +422,12 @@ static long wdtpci_ioctl(struct file *file, unsigned int cmd,
 
         /* Add options according to the card we have */
         ident.options |= (WDIOF_EXTERN1|WDIOF_EXTERN2);
-#ifdef CONFIG_WDT_501_PCI
-        ident.options |= (WDIOF_OVERHEAT|WDIOF_POWERUNDER|WDIOF_POWEROVER);
-        if (tachometer)
-                ident.options |= WDIOF_FANFAULT;
-#endif /* CONFIG_WDT_501_PCI */
+        if (type == 501) {
+                ident.options |= (WDIOF_OVERHEAT|WDIOF_POWERUNDER|
+                                                        WDIOF_POWEROVER);
+                if (tachometer)
+                        ident.options |= WDIOF_FANFAULT;
+        }
 
         switch (cmd) {
         case WDIOC_GETSUPPORT:
@@ -503,7 +505,6 @@ static int wdtpci_release(struct inode *inode, struct file *file)
         return 0;
 }
 
-#ifdef CONFIG_WDT_501_PCI
 /**
  *      wdtpci_temp_read:
  *      @file: file handle to the watchdog board
@@ -554,7 +555,6 @@ static int wdtpci_temp_release(struct inode *inode, struct file *file)
 {
         return 0;
 }
-#endif /* CONFIG_WDT_501_PCI */
 
 /**
  *      notify_sys:
@@ -596,7 +596,6 @@ static struct miscdevice wdtpci_miscdev = {
         .fops   = &wdtpci_fops,
 };
 
-#ifdef CONFIG_WDT_501_PCI
 static const struct file_operations wdtpci_temp_fops = {
         .owner          = THIS_MODULE,
         .llseek         = no_llseek,
@@ -610,7 +609,6 @@ static struct miscdevice temp_miscdev = {
         .name   = "temperature",
         .fops   = &wdtpci_temp_fops,
 };
-#endif /* CONFIG_WDT_501_PCI */
 
 /*
  *      The WDT card needs to learn about soft shutdowns in order to
@@ -633,6 +631,11 @@ static int __devinit wdtpci_init_one(struct pci_dev *dev,
                 return -ENODEV;
         }
 
+        if (type != 500 && type != 501) {
+                printk(KERN_ERR PFX "unknown card type '%d'.\n", type);
+                return -ENODEV;
+        }
+
         if (pci_enable_device(dev)) {
                 printk(KERN_ERR PFX "Not possible to enable PCI Device\n");
                 return -ENODEV;
@@ -678,15 +681,15 @@ static int __devinit wdtpci_init_one(struct pci_dev *dev,
                 goto out_irq;
         }
 
-#ifdef CONFIG_WDT_501_PCI
-        ret = misc_register(&temp_miscdev);
-        if (ret) {
-                printk(KERN_ERR PFX
+        if (type == 501) {
+                ret = misc_register(&temp_miscdev);
+                if (ret) {
+                        printk(KERN_ERR PFX
                         "cannot register miscdev on minor=%d (err=%d)\n",
-                                        TEMP_MINOR, ret);
-                goto out_rbt;
+                                                        TEMP_MINOR, ret);
+                        goto out_rbt;
+                }
         }
-#endif /* CONFIG_WDT_501_PCI */
 
         ret = misc_register(&wdtpci_miscdev);
         if (ret) {
@@ -698,20 +701,18 @@ static int __devinit wdtpci_init_one(struct pci_dev *dev,
 
         printk(KERN_INFO PFX "initialized. heartbeat=%d sec (nowayout=%d)\n",
                 heartbeat, nowayout);
-#ifdef CONFIG_WDT_501_PCI
-        printk(KERN_INFO "wdt: Fan Tachometer is %s\n",
+        if (type == 501)
+                printk(KERN_INFO "wdt: Fan Tachometer is %s\n",
                                 (tachometer ? "Enabled" : "Disabled"));
-#endif /* CONFIG_WDT_501_PCI */
 
         ret = 0;
 out:
         return ret;
 
 out_misc:
-#ifdef CONFIG_WDT_501_PCI
-        misc_deregister(&temp_miscdev);
+        if (type == 501)
+                misc_deregister(&temp_miscdev);
 out_rbt:
-#endif /* CONFIG_WDT_501_PCI */
         unregister_reboot_notifier(&wdtpci_notifier);
 out_irq:
         free_irq(irq, &wdtpci_miscdev);
@@ -728,9 +729,8 @@ static void __devexit wdtpci_remove_one(struct pci_dev *pdev)
         /* here we assume only one device will ever have
          * been picked up and registered by probe function */
         misc_deregister(&wdtpci_miscdev);
-#ifdef CONFIG_WDT_501_PCI
-        misc_deregister(&temp_miscdev);
-#endif /* CONFIG_WDT_501_PCI */
+        if (type == 501)
+                misc_deregister(&temp_miscdev);
         unregister_reboot_notifier(&wdtpci_notifier);
         free_irq(irq, &wdtpci_miscdev);
         release_region(io, 16);