276 files changed, 10747 insertions, 2083 deletions

diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index 0bba148a2c61..4ced54f7a5d9 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -76,12 +76,9 @@ acpi_ev_queue_notify_request(struct acpi_namespace_node *node,
  * evgpe - GPE handling and dispatch
  */
 acpi_status
-acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
-                                u8 type);
+acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info);
 
-acpi_status
-acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
-                   u8 write_to_hardware);
+acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
 acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
@@ -122,9 +119,6 @@ acpi_ev_gpe_dispatch(struct acpi_gpe_event_info *gpe_event_info,
 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list);
 
 acpi_status
-acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type);
-
-acpi_status
 acpi_ev_check_for_wake_only_gpe(struct acpi_gpe_event_info *gpe_event_info);
 
 acpi_status acpi_ev_gpe_initialize(void);
diff --git a/drivers/acpi/acpica/aclocal.h b/drivers/acpi/acpica/aclocal.h
index 81e64f478679..13cb80caacde 100644
--- a/drivers/acpi/acpica/aclocal.h
+++ b/drivers/acpi/acpica/aclocal.h
@@ -426,6 +426,8 @@ struct acpi_gpe_event_info {
         struct acpi_gpe_register_info *register_info;   /* Backpointer to register info */
         u8 flags;               /* Misc info about this GPE */
         u8 gpe_number;          /* This GPE */
+        u8 runtime_count;
+        u8 wakeup_count;
 };
 
 /* Information about a GPE register pair, one per each status/enable pair in an array */
diff --git a/drivers/acpi/acpica/acobject.h b/drivers/acpi/acpica/acobject.h
index 64062b1be3ee..07f6e2ea2ee5 100644
--- a/drivers/acpi/acpica/acobject.h
+++ b/drivers/acpi/acpica/acobject.h
@@ -287,8 +287,10 @@ struct acpi_object_buffer_field {
 
 struct acpi_object_notify_handler {
         ACPI_OBJECT_COMMON_HEADER struct acpi_namespace_node *node;     /* Parent device */
+        u32 handler_type;
         acpi_notify_handler handler;
         void *context;
+        struct acpi_object_notify_handler *next;
 };
 
 struct acpi_object_addr_handler {
diff --git a/drivers/acpi/acpica/evgpe.c b/drivers/acpi/acpica/evgpe.c
index afacf4416c73..0b453467a5a0 100644
--- a/drivers/acpi/acpica/evgpe.c
+++ b/drivers/acpi/acpica/evgpe.c
@@ -54,54 +54,9 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context);
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_ev_set_gpe_type
- *
- * PARAMETERS:  gpe_event_info          - GPE to set
- *              Type                    - New type
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Sets the new type for the GPE (wake, run, or wake/run)
- *
- ******************************************************************************/
-
-acpi_status
-acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_set_gpe_type);
-
-        /* Validate type and update register enable masks */
-
-        switch (type) {
-        case ACPI_GPE_TYPE_WAKE:
-        case ACPI_GPE_TYPE_RUNTIME:
-        case ACPI_GPE_TYPE_WAKE_RUN:
-                break;
-
-        default:
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
-
-        /* Disable the GPE if currently enabled */
-
-        status = acpi_ev_disable_gpe(gpe_event_info);
-
-        /* Clear the type bits and insert the new Type */
-
-        gpe_event_info->flags &= ~ACPI_GPE_TYPE_MASK;
-        gpe_event_info->flags |= type;
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
  * FUNCTION:    acpi_ev_update_gpe_enable_masks
  *
  * PARAMETERS:  gpe_event_info          - GPE to update
- *              Type                    - What to do: ACPI_GPE_DISABLE or
- *                                        ACPI_GPE_ENABLE
  *
  * RETURN:      Status
  *
@@ -110,8 +65,7 @@ acpi_ev_set_gpe_type(struct acpi_gpe_event_info *gpe_event_info, u8 type)
  ******************************************************************************/
 
 acpi_status
-acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
-                                u8 type)
+acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info)
 {
         struct acpi_gpe_register_info *gpe_register_info;
         u8 register_bit;
@@ -127,37 +81,14 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
             (1 <<
              (gpe_event_info->gpe_number - gpe_register_info->base_gpe_number));
 
-        /* 1) Disable case. Simply clear all enable bits */
-
-        if (type == ACPI_GPE_DISABLE) {
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
-                               register_bit);
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
-                return_ACPI_STATUS(AE_OK);
-        }
-
-        /* 2) Enable case. Set/Clear the appropriate enable bits */
+        ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake, register_bit);
+        ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
 
-        switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
-        case ACPI_GPE_TYPE_WAKE:
-                ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_run, register_bit);
-                break;
-
-        case ACPI_GPE_TYPE_RUNTIME:
-                ACPI_CLEAR_BIT(gpe_register_info->enable_for_wake,
-                               register_bit);
+        if (gpe_event_info->runtime_count)
                 ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
-                break;
 
-        case ACPI_GPE_TYPE_WAKE_RUN:
+        if (gpe_event_info->wakeup_count)
                 ACPI_SET_BIT(gpe_register_info->enable_for_wake, register_bit);
-                ACPI_SET_BIT(gpe_register_info->enable_for_run, register_bit);
-                break;
-
-        default:
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
-        }
 
         return_ACPI_STATUS(AE_OK);
 }
@@ -167,8 +98,6 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
  * FUNCTION:    acpi_ev_enable_gpe
  *
  * PARAMETERS:  gpe_event_info          - GPE to enable
- *              write_to_hardware       - Enable now, or just mark data structs
- *                                        (WAKE GPEs should be deferred)
  *
  * RETURN:      Status
  *
@@ -176,9 +105,7 @@ acpi_ev_update_gpe_enable_masks(struct acpi_gpe_event_info *gpe_event_info,
  *
  ******************************************************************************/
 
-acpi_status
-acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
-                   u8 write_to_hardware)
+acpi_status acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 {
         acpi_status status;
 
@@ -186,47 +113,20 @@ acpi_ev_enable_gpe(struct acpi_gpe_event_info *gpe_event_info,
 
         /* Make sure HW enable masks are updated */
 
-        status =
-            acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_ENABLE);
-        if (ACPI_FAILURE(status)) {
+        status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        if (ACPI_FAILURE(status))
                 return_ACPI_STATUS(status);
-        }
 
         /* Mark wake-enabled or HW enable, or both */
 
-        switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
-        case ACPI_GPE_TYPE_WAKE:
-
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-                break;
-
-        case ACPI_GPE_TYPE_WAKE_RUN:
-
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-
-                /*lint -fallthrough */
-
-        case ACPI_GPE_TYPE_RUNTIME:
-
-                ACPI_SET_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED);
-
-                if (write_to_hardware) {
-
-                        /* Clear the GPE (of stale events), then enable it */
-
-                        status = acpi_hw_clear_gpe(gpe_event_info);
-                        if (ACPI_FAILURE(status)) {
-                                return_ACPI_STATUS(status);
-                        }
-
-                        /* Enable the requested runtime GPE */
-
-                        status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
-                }
-                break;
+        if (gpe_event_info->runtime_count) {
+                /* Clear the GPE (of stale events), then enable it */
+                status = acpi_hw_clear_gpe(gpe_event_info);
+                if (ACPI_FAILURE(status))
+                        return_ACPI_STATUS(status);
 
-        default:
-                return_ACPI_STATUS(AE_BAD_PARAMETER);
+                /* Enable the requested runtime GPE */
+                status = acpi_hw_write_gpe_enable_reg(gpe_event_info);
         }
 
         return_ACPI_STATUS(AE_OK);
@@ -252,34 +152,9 @@ acpi_status acpi_ev_disable_gpe(struct acpi_gpe_event_info *gpe_event_info)
 
         /* Make sure HW enable masks are updated */
 
-        status =
-            acpi_ev_update_gpe_enable_masks(gpe_event_info, ACPI_GPE_DISABLE);
-        if (ACPI_FAILURE(status)) {
+        status = acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        if (ACPI_FAILURE(status))
                 return_ACPI_STATUS(status);
-        }
-
-        /* Clear the appropriate enabled flags for this GPE */
-
-        switch (gpe_event_info->flags & ACPI_GPE_TYPE_MASK) {
-        case ACPI_GPE_TYPE_WAKE:
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-                break;
-
-        case ACPI_GPE_TYPE_WAKE_RUN:
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_WAKE_ENABLED);
-
-                /* fallthrough */
-
-        case ACPI_GPE_TYPE_RUNTIME:
-
-                /* Disable the requested runtime GPE */
-
-                ACPI_CLEAR_BIT(gpe_event_info->flags, ACPI_GPE_RUN_ENABLED);
-                break;
-
-        default:
-                break;
-        }
 
         /*
          * Even if we don't know the GPE type, make sure that we always
@@ -521,7 +396,7 @@ static void ACPI_SYSTEM_XFACE acpi_ev_asynch_execute_gpe_method(void *context)
 
         /* Set the GPE flags for return to enabled state */
 
-        (void)acpi_ev_enable_gpe(gpe_event_info, FALSE);
+        (void)acpi_ev_update_gpe_enable_masks(gpe_event_info);
 
         /*
          * Take a snapshot of the GPE info for this level - we copy the info to
diff --git a/drivers/acpi/acpica/evgpeblk.c b/drivers/acpi/acpica/evgpeblk.c
index 247920900187..3d4c4aca11cd 100644
--- a/drivers/acpi/acpica/evgpeblk.c
+++ b/drivers/acpi/acpica/evgpeblk.c
@@ -258,7 +258,6 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
         u32 gpe_number;
         char name[ACPI_NAME_SIZE + 1];
         u8 type;
-        acpi_status status;
 
         ACPI_FUNCTION_TRACE(ev_save_method_info);
 
@@ -325,26 +324,20 @@ acpi_ev_save_method_info(acpi_handle obj_handle,
 
         /*
          * Now we can add this information to the gpe_event_info block for use
-         * during dispatch of this GPE. Default type is RUNTIME, although this may
-         * change when the _PRW methods are executed later.
+         * during dispatch of this GPE.
          */
         gpe_event_info =
             &gpe_block->event_info[gpe_number - gpe_block->block_base_number];
 
-        gpe_event_info->flags = (u8)
-            (type | ACPI_GPE_DISPATCH_METHOD | ACPI_GPE_TYPE_RUNTIME);
+        gpe_event_info->flags = (u8) (type | ACPI_GPE_DISPATCH_METHOD);
 
         gpe_event_info->dispatch.method_node =
             (struct acpi_namespace_node *)obj_handle;
 
-        /* Update enable mask, but don't enable the HW GPE as of yet */
-
-        status = acpi_ev_enable_gpe(gpe_event_info, FALSE);
-
         ACPI_DEBUG_PRINT((ACPI_DB_LOAD,
                           "Registered GPE method %s as GPE number 0x%.2X\n",
                           name, gpe_number));
-        return_ACPI_STATUS(status);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
@@ -454,20 +447,7 @@ acpi_ev_match_prw_and_gpe(acpi_handle obj_handle,
                                                         gpe_block->
                                                         block_base_number];
 
-                /* Mark GPE for WAKE-ONLY but WAKE_DISABLED */
-
-                gpe_event_info->flags &=
-                    ~(ACPI_GPE_WAKE_ENABLED | ACPI_GPE_RUN_ENABLED);
-
-                status =
-                    acpi_ev_set_gpe_type(gpe_event_info, ACPI_GPE_TYPE_WAKE);
-                if (ACPI_FAILURE(status)) {
-                        goto cleanup;
-                }
-
-                status =
-                    acpi_ev_update_gpe_enable_masks(gpe_event_info,
-                                                    ACPI_GPE_DISABLE);
+                gpe_event_info->flags |= ACPI_GPE_CAN_WAKE;
         }
 
       cleanup:
@@ -989,7 +969,6 @@ acpi_status
 acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
                              struct acpi_gpe_block_info *gpe_block)
 {
-        acpi_status status;
         struct acpi_gpe_event_info *gpe_event_info;
         struct acpi_gpe_walk_info gpe_info;
         u32 wake_gpe_count;
@@ -1019,42 +998,50 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
                 gpe_info.gpe_block = gpe_block;
                 gpe_info.gpe_device = gpe_device;
 
-                status =
-                    acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+                acpi_ns_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
                                            ACPI_UINT32_MAX, ACPI_NS_WALK_UNLOCK,
                                            acpi_ev_match_prw_and_gpe, NULL,
                                            &gpe_info, NULL);
         }
 
         /*
-         * Enable all GPEs in this block that have these attributes:
-         * 1) are "runtime" or "run/wake" GPEs, and
-         * 2) have a corresponding _Lxx or _Exx method
-         *
-         * Any other GPEs within this block must be enabled via the
-         * acpi_enable_gpe() external interface.
+         * Enable all GPEs that have a corresponding method and aren't
+         * capable of generating wakeups. Any other GPEs within this block
+         * must be enabled via the acpi_enable_gpe() interface.
          */
         wake_gpe_count = 0;
         gpe_enabled_count = 0;
+        if (gpe_device == acpi_gbl_fadt_gpe_device)
+                gpe_device = NULL;
 
         for (i = 0; i < gpe_block->register_count; i++) {
-                for (j = 0; j < 8; j++) {
+                for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++) {
+                        acpi_status status;
+                        acpi_size gpe_index;
+                        int gpe_number;
 
                         /* Get the info block for this particular GPE */
+                        gpe_index = (acpi_size)i * ACPI_GPE_REGISTER_WIDTH + j;
+                        gpe_event_info = &gpe_block->event_info[gpe_index];
 
-                        gpe_event_info = &gpe_block->event_info[((acpi_size) i *
-                                                                 ACPI_GPE_REGISTER_WIDTH)
-                                                                + j];
-
-                        if (((gpe_event_info->flags & ACPI_GPE_DISPATCH_MASK) ==
-                             ACPI_GPE_DISPATCH_METHOD) &&
-                            (gpe_event_info->flags & ACPI_GPE_TYPE_RUNTIME)) {
-                                gpe_enabled_count++;
-                        }
-
-                        if (gpe_event_info->flags & ACPI_GPE_TYPE_WAKE) {
+                        if (gpe_event_info->flags & ACPI_GPE_CAN_WAKE) {
                                 wake_gpe_count++;
+                                if (acpi_gbl_leave_wake_gpes_disabled)
+                                        continue;
                         }
+
+                        if (!(gpe_event_info->flags & ACPI_GPE_DISPATCH_METHOD))
+                                continue;
+
+                        gpe_number = gpe_index + gpe_block->block_base_number;
+                        status = acpi_enable_gpe(gpe_device, gpe_number,
+                                                ACPI_GPE_TYPE_RUNTIME);
+                        if (ACPI_FAILURE(status))
+                                ACPI_ERROR((AE_INFO,
+                                                "Failed to enable GPE %02X\n",
+                                                gpe_number));
+                        else
+                                gpe_enabled_count++;
                 }
         }
 
@@ -1062,15 +1049,7 @@ acpi_ev_initialize_gpe_block(struct acpi_namespace_node *gpe_device,
                           "Found %u Wake, Enabled %u Runtime GPEs in this block\n",
                           wake_gpe_count, gpe_enabled_count));
 
-        /* Enable all valid runtime GPEs found above */
-
-        status = acpi_hw_enable_runtime_gpe_block(NULL, gpe_block, NULL);
-        if (ACPI_FAILURE(status)) {
-                ACPI_ERROR((AE_INFO, "Could not enable GPEs in GpeBlock %p",
-                            gpe_block));
-        }
-
-        return_ACPI_STATUS(status);
+        return_ACPI_STATUS(AE_OK);
 }
 
 /*******************************************************************************
diff --git a/drivers/acpi/acpica/evmisc.c b/drivers/acpi/acpica/evmisc.c
index ce224e1eaa89..8f0fac6c4366 100644
--- a/drivers/acpi/acpica/evmisc.c
+++ b/drivers/acpi/acpica/evmisc.c
@@ -259,9 +259,15 @@ static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
 
         handler_obj = notify_info->notify.handler_obj;
         if (handler_obj) {
-                handler_obj->notify.handler(notify_info->notify.node,
-                                            notify_info->notify.value,
-                                            handler_obj->notify.context);
+                struct acpi_object_notify_handler *notifier;
+
+                notifier = &handler_obj->notify;
+                while (notifier) {
+                        notifier->handler(notify_info->notify.node,
+                                          notify_info->notify.value,
+                                          notifier->context);
+                        notifier = notifier->next;
+                }
         }
 
         /* All done with the info object */
diff --git a/drivers/acpi/acpica/evxface.c b/drivers/acpi/acpica/evxface.c
index 2fe0809d4eb2..474e2cab603d 100644
--- a/drivers/acpi/acpica/evxface.c
+++ b/drivers/acpi/acpica/evxface.c
@@ -218,6 +218,72 @@ ACPI_EXPORT_SYMBOL(acpi_remove_fixed_event_handler)
 
 /*******************************************************************************
  *
+ * FUNCTION:    acpi_populate_handler_object
+ *
+ * PARAMETERS:  handler_obj        - Handler object to populate
+ *              handler_type       - The type of handler:
+ *                                  ACPI_SYSTEM_NOTIFY: system_handler (00-7f)
+ *                                  ACPI_DEVICE_NOTIFY: driver_handler (80-ff)
+ *                                  ACPI_ALL_NOTIFY:  both system and device
+ *              handler            - Address of the handler
+ *              context            - Value passed to the handler on each GPE
+ *              next               - Address of a handler object to link to
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Populate a handler object.
+ *
+ ******************************************************************************/
+static void
+acpi_populate_handler_object(struct acpi_object_notify_handler *handler_obj,
+                             u32 handler_type,
+                             acpi_notify_handler handler, void *context,
+                             struct acpi_object_notify_handler *next)
+{
+        handler_obj->handler_type = handler_type;
+        handler_obj->handler = handler;
+        handler_obj->context = context;
+        handler_obj->next = next;
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_add_handler_object
+ *
+ * PARAMETERS:  parent_obj         - Parent of the new object
+ *              handler            - Address of the handler
+ *              context            - Value passed to the handler on each GPE
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Create a new handler object and populate it.
+ *
+ ******************************************************************************/
+static acpi_status
+acpi_add_handler_object(struct acpi_object_notify_handler *parent_obj,
+                        acpi_notify_handler handler, void *context)
+{
+        struct acpi_object_notify_handler *handler_obj;
+
+        /* The parent must not be a defice notify handler object. */
+        if (parent_obj->handler_type & ACPI_DEVICE_NOTIFY)
+                return AE_BAD_PARAMETER;
+
+        handler_obj = ACPI_ALLOCATE_ZEROED(sizeof(*handler_obj));
+        if (!handler_obj)
+                return AE_NO_MEMORY;
+
+        acpi_populate_handler_object(handler_obj,
+                                        ACPI_SYSTEM_NOTIFY,
+                                        handler, context,
+                                        parent_obj->next);
+        parent_obj->next = handler_obj;
+
+        return AE_OK;
+}
+
+/*******************************************************************************
+ *
  * FUNCTION:    acpi_install_notify_handler
  *
  * PARAMETERS:  Device          - The device for which notifies will be handled
@@ -316,15 +382,32 @@ acpi_install_notify_handler(acpi_handle device,
                 obj_desc = acpi_ns_get_attached_object(node);
                 if (obj_desc) {
 
-                        /* Object exists - make sure there's no handler */
+                        /* Object exists. */
 
-                        if (((handler_type & ACPI_SYSTEM_NOTIFY) &&
-                             obj_desc->common_notify.system_notify) ||
-                            ((handler_type & ACPI_DEVICE_NOTIFY) &&
-                             obj_desc->common_notify.device_notify)) {
+                        /* For a device notify, make sure there's no handler. */
+                        if ((handler_type & ACPI_DEVICE_NOTIFY) &&
+                             obj_desc->common_notify.device_notify) {
                                 status = AE_ALREADY_EXISTS;
                                 goto unlock_and_exit;
                         }
+
+                        /* System notifies may have more handlers installed. */
+                        notify_obj = obj_desc->common_notify.system_notify;
+
+                        if ((handler_type & ACPI_SYSTEM_NOTIFY) && notify_obj) {
+                                struct acpi_object_notify_handler *parent_obj;
+
+                                if (handler_type & ACPI_DEVICE_NOTIFY) {
+                                        status = AE_ALREADY_EXISTS;
+                                        goto unlock_and_exit;
+                                }
+
+                                parent_obj = &notify_obj->notify;
+                                status = acpi_add_handler_object(parent_obj,
+                                                                 handler,
+                                                                 context);
+                                goto unlock_and_exit;
+                        }
                 } else {
                         /* Create a new object */
 
@@ -356,9 +439,10 @@ acpi_install_notify_handler(acpi_handle device,
                         goto unlock_and_exit;
                 }
 
-                notify_obj->notify.node = node;
-                notify_obj->notify.handler = handler;
-                notify_obj->notify.context = context;
+                acpi_populate_handler_object(&notify_obj->notify,
+                                                handler_type,
+                                                handler, context,
+                                                NULL);
 
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
                         obj_desc->common_notify.system_notify = notify_obj;
@@ -418,6 +502,10 @@ acpi_remove_notify_handler(acpi_handle device,
                 goto exit;
         }
 
+
+        /* Make sure all deferred tasks are completed */
+        acpi_os_wait_events_complete(NULL);
+
         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
         if (ACPI_FAILURE(status)) {
                 goto exit;
@@ -445,15 +533,6 @@ acpi_remove_notify_handler(acpi_handle device,
                         goto unlock_and_exit;
                 }
 
-                /* Make sure all deferred tasks are completed */
-
-                (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-                acpi_os_wait_events_complete(NULL);
-                status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                if (ACPI_FAILURE(status)) {
-                        goto exit;
-                }
-
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
                         acpi_gbl_system_notify.node = NULL;
                         acpi_gbl_system_notify.handler = NULL;
@@ -488,28 +567,60 @@ acpi_remove_notify_handler(acpi_handle device,
                 /* Object exists - make sure there's an existing handler */
 
                 if (handler_type & ACPI_SYSTEM_NOTIFY) {
+                        struct acpi_object_notify_handler *handler_obj;
+                        struct acpi_object_notify_handler *parent_obj;
+
                         notify_obj = obj_desc->common_notify.system_notify;
                         if (!notify_obj) {
                                 status = AE_NOT_EXIST;
                                 goto unlock_and_exit;
                         }
 
-                        if (notify_obj->notify.handler != handler) {
+                        handler_obj = &notify_obj->notify;
+                        parent_obj = NULL;
+                        while (handler_obj->handler != handler) {
+                                if (handler_obj->next) {
+                                        parent_obj = handler_obj;
+                                        handler_obj = handler_obj->next;
+                                } else {
+                                        break;
+                                }
+                        }
+
+                        if (handler_obj->handler != handler) {
                                 status = AE_BAD_PARAMETER;
                                 goto unlock_and_exit;
                         }
-                        /* Make sure all deferred tasks are completed */
 
-                        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-                        acpi_os_wait_events_complete(NULL);
-                        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                        if (ACPI_FAILURE(status)) {
-                                goto exit;
+                        /*
+                         * Remove the handler.  There are three possible cases.
+                         * First, we may need to remove a non-embedded object.
+                         * Second, we may need to remove the embedded object's
+                         * handler data, while non-embedded objects exist.
+                         * Finally, we may need to remove the embedded object
+                         * entirely along with its container.
+                         */
+                        if (parent_obj) {
+                                /* Non-embedded object is being removed. */
+                                parent_obj->next = handler_obj->next;
+                                ACPI_FREE(handler_obj);
+                        } else if (notify_obj->notify.next) {
+                                /*
+                                 * The handler matches the embedded object, but
+                                 * there are more handler objects in the list.
+                                 * Replace the embedded object's data with the
+                                 * first next object's data and remove that
+                                 * object.
+                                 */
+                                parent_obj = &notify_obj->notify;
+                                handler_obj = notify_obj->notify.next;
+                                *parent_obj = *handler_obj;
+                                ACPI_FREE(handler_obj);
+                        } else {
+                                /* No more handler objects in the list. */
+                                obj_desc->common_notify.system_notify = NULL;
+                                acpi_ut_remove_reference(notify_obj);
                         }
-
-                        /* Remove the handler */
-                        obj_desc->common_notify.system_notify = NULL;
-                        acpi_ut_remove_reference(notify_obj);
                 }
 
                 if (handler_type & ACPI_DEVICE_NOTIFY) {
@@ -523,14 +634,6 @@ acpi_remove_notify_handler(acpi_handle device,
                                 status = AE_BAD_PARAMETER;
                                 goto unlock_and_exit;
                         }
-                        /* Make sure all deferred tasks are completed */
-
-                        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
-                        acpi_os_wait_events_complete(NULL);
-                        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
-                        if (ACPI_FAILURE(status)) {
-                                goto exit;
-                        }
 
                         /* Remove the handler */
                         obj_desc->common_notify.device_notify = NULL;
@@ -617,13 +720,6 @@ acpi_install_gpe_handler(acpi_handle gpe_device,
         handler->context = context;
         handler->method_node = gpe_event_info->dispatch.method_node;
 
-        /* Disable the GPE before installing the handler */
-
-        status = acpi_ev_disable_gpe(gpe_event_info);
-        if (ACPI_FAILURE(status)) {
-                goto unlock_and_exit;
-        }
-
         /* Install the handler */
 
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
@@ -707,13 +803,6 @@ acpi_remove_gpe_handler(acpi_handle gpe_device,
                 goto unlock_and_exit;
         }
 
-        /* Disable the GPE before removing the handler */
-
-        status = acpi_ev_disable_gpe(gpe_event_info);
-        if (ACPI_FAILURE(status)) {
-                goto unlock_and_exit;
-        }
-
         /* Make sure all deferred tasks are completed */
 
         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
diff --git a/drivers/acpi/acpica/evxfevnt.c b/drivers/acpi/acpica/evxfevnt.c
index eed7a38d25f2..124c157215bf 100644
--- a/drivers/acpi/acpica/evxfevnt.c
+++ b/drivers/acpi/acpica/evxfevnt.c
@@ -201,23 +201,27 @@ ACPI_EXPORT_SYMBOL(acpi_enable_event)
 
 /*******************************************************************************
  *
- * FUNCTION:    acpi_set_gpe_type
+ * FUNCTION:    acpi_set_gpe
  *
  * PARAMETERS:  gpe_device      - Parent GPE Device
  *              gpe_number      - GPE level within the GPE block
- *              Type            - New GPE type
+ *              action          - Enable or disable
+ *                                Called from ISR or not
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Set the type of an individual GPE
+ * DESCRIPTION: Enable or disable an ACPI event (general purpose)
  *
  ******************************************************************************/
-acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
+acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action)
 {
         acpi_status status = AE_OK;
+        acpi_cpu_flags flags;
         struct acpi_gpe_event_info *gpe_event_info;
 
-        ACPI_FUNCTION_TRACE(acpi_set_gpe_type);
+        ACPI_FUNCTION_TRACE(acpi_set_gpe);
+
+        flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
         /* Ensure that we have a valid GPE number */
 
@@ -227,19 +231,29 @@ acpi_status acpi_set_gpe_type(acpi_handle gpe_device, u32 gpe_number, u8 type)
                 goto unlock_and_exit;
         }
 
-        if ((gpe_event_info->flags & ACPI_GPE_TYPE_MASK) == type) {
-                return_ACPI_STATUS(AE_OK);
-        }
+        /* Perform the action */
+
+        switch (action) {
+        case ACPI_GPE_ENABLE:
+                status = acpi_ev_enable_gpe(gpe_event_info);
+                break;
 
-        /* Set the new type (will disable GPE if currently enabled) */
+        case ACPI_GPE_DISABLE:
+                status = acpi_ev_disable_gpe(gpe_event_info);
+                break;
 
-        status = acpi_ev_set_gpe_type(gpe_event_info, type);
+        default:
+                ACPI_ERROR((AE_INFO, "Invalid action\n"));
+                status = AE_BAD_PARAMETER;
+                break;
+        }
 
       unlock_and_exit:
+        acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
 
-ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
+ACPI_EXPORT_SYMBOL(acpi_set_gpe)
 
 /*******************************************************************************
  *
@@ -247,15 +261,14 @@ ACPI_EXPORT_SYMBOL(acpi_set_gpe_type)
  *
  * PARAMETERS:  gpe_device      - Parent GPE Device
  *              gpe_number      - GPE level within the GPE block
- *              Flags           - Just enable, or also wake enable?
- *                                Called from ISR or not
+ *              type            - Purpose the GPE will be used for
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Enable an ACPI event (general purpose)
+ * DESCRIPTION: Take a reference to a GPE and enable it if necessary
  *
  ******************************************************************************/
-acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
+acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
 {
         acpi_status status = AE_OK;
         acpi_cpu_flags flags;
@@ -263,6 +276,9 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
 
         ACPI_FUNCTION_TRACE(acpi_enable_gpe);
 
+        if (type & ~ACPI_GPE_TYPE_WAKE_RUN)
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
 
         /* Ensure that we have a valid GPE number */
@@ -273,15 +289,32 @@ acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number)
                 goto unlock_and_exit;
         }
 
-        /* Perform the enable */
+        if (type & ACPI_GPE_TYPE_RUNTIME) {
+                if (++gpe_event_info->runtime_count == 1) {
+                        status = acpi_ev_enable_gpe(gpe_event_info);
+                        if (ACPI_FAILURE(status))
+                                gpe_event_info->runtime_count--;
+                }
+        }
+
+        if (type & ACPI_GPE_TYPE_WAKE) {
+                if (!(gpe_event_info->flags & ACPI_GPE_CAN_WAKE)) {
+                        status = AE_BAD_PARAMETER;
+                        goto unlock_and_exit;
+                }
 
-        status = acpi_ev_enable_gpe(gpe_event_info, TRUE);
+                /*
+                 * Wake-up GPEs are only enabled right prior to putting the
+                 * system into a sleep state.
+                 */
+                if (++gpe_event_info->wakeup_count == 1)
+                        acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        }
 
-      unlock_and_exit:
+unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
-
 ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
 
 /*******************************************************************************
@@ -290,15 +323,14 @@ ACPI_EXPORT_SYMBOL(acpi_enable_gpe)
  *
  * PARAMETERS:  gpe_device      - Parent GPE Device
  *              gpe_number      - GPE level within the GPE block
- *              Flags           - Just disable, or also wake disable?
- *                                Called from ISR or not
+ *              type            - Purpose the GPE won't be used for any more
  *
  * RETURN:      Status
  *
- * DESCRIPTION: Disable an ACPI event (general purpose)
+ * DESCRIPTION: Release a reference to a GPE and disable it if necessary
  *
  ******************************************************************************/
-acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
+acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number, u8 type)
 {
         acpi_status status = AE_OK;
         acpi_cpu_flags flags;
@@ -306,6 +338,9 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
 
         ACPI_FUNCTION_TRACE(acpi_disable_gpe);
 
+        if (type & ~ACPI_GPE_TYPE_WAKE_RUN)
+                return_ACPI_STATUS(AE_BAD_PARAMETER);
+
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
         /* Ensure that we have a valid GPE number */
 
@@ -315,13 +350,24 @@ acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number)
                 goto unlock_and_exit;
         }
 
-        status = acpi_ev_disable_gpe(gpe_event_info);
+        if ((type & ACPI_GPE_TYPE_RUNTIME) && gpe_event_info->runtime_count) {
+                if (--gpe_event_info->runtime_count == 0)
+                        status = acpi_ev_disable_gpe(gpe_event_info);
+        }
+
+        if ((type & ACPI_GPE_TYPE_WAKE) && gpe_event_info->wakeup_count) {
+                /*
+                 * Wake-up GPEs are not enabled after leaving system sleep
+                 * states, so we don't need to disable them here.
+                 */
+                if (--gpe_event_info->wakeup_count == 0)
+                        acpi_ev_update_gpe_enable_masks(gpe_event_info);
+        }
 
 unlock_and_exit:
         acpi_os_release_lock(acpi_gbl_gpe_lock, flags);
         return_ACPI_STATUS(status);
 }
-
 ACPI_EXPORT_SYMBOL(acpi_disable_gpe)
 
 /*******************************************************************************
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 8a95e8329df7..f53fbe307c9d 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -422,11 +422,10 @@ static int acpi_button_add(struct acpi_device *device)
 
         if (device->wakeup.flags.valid) {
                 /* Button's GPE is run-wake GPE */
-                acpi_set_gpe_type(device->wakeup.gpe_device,
-                                  device->wakeup.gpe_number,
-                                  ACPI_GPE_TYPE_WAKE_RUN);
                 acpi_enable_gpe(device->wakeup.gpe_device,
-                                device->wakeup.gpe_number);
+                                device->wakeup.gpe_number,
+                                ACPI_GPE_TYPE_WAKE_RUN);
+                device->wakeup.run_wake_count++;
                 device->wakeup.state.enabled = 1;
         }
 
@@ -446,6 +445,14 @@ static int acpi_button_remove(struct acpi_device *device, int type)
 {
         struct acpi_button *button = acpi_driver_data(device);
 
+        if (device->wakeup.flags.valid) {
+                acpi_disable_gpe(device->wakeup.gpe_device,
+                                device->wakeup.gpe_number,
+                                ACPI_GPE_TYPE_WAKE_RUN);
+                device->wakeup.run_wake_count--;
+                device->wakeup.state.enabled = 0;
+        }
+
         acpi_button_remove_fs(device);
         input_unregister_device(button->input);
         kfree(button);
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index bbc2c1315c47..b2586f57e1f5 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -935,6 +935,7 @@ static int dock_add(acpi_handle handle)
         struct platform_device *dd;
 
         id = dock_station_count;
+        memset(&ds, 0, sizeof(ds));
         dd = platform_device_register_data(NULL, "dock", id, &ds, sizeof(ds));
         if (IS_ERR(dd))
                 return PTR_ERR(dd);
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index d6471bb6852f..27e0b92b2e39 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -307,7 +307,11 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
         pr_debug(PREFIX "transaction start\n");
         /* disable GPE during transaction if storm is detected */
         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
-                acpi_disable_gpe(NULL, ec->gpe);
+                /*
+                 * It has to be disabled at the hardware level regardless of the
+                 * GPE reference counting, so that it doesn't trigger.
+                 */
+                acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
         }
 
         status = acpi_ec_transaction_unlocked(ec, t);
@@ -316,8 +320,12 @@ static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
         ec_check_sci_sync(ec, acpi_ec_read_status(ec));
         if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
                 msleep(1);
-                /* it is safe to enable GPE outside of transaction */
-                acpi_enable_gpe(NULL, ec->gpe);
+                /*
+                 * It is safe to enable the GPE outside of the transaction.  Use
+                 * acpi_set_gpe() for that, since we used it to disable the GPE
+                 * above.
+                 */
+                acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
         } else if (t->irq_count > ACPI_EC_STORM_THRESHOLD) {
                 pr_info(PREFIX "GPE storm detected, "
                         "transactions will use polling mode\n");
@@ -788,8 +796,8 @@ static int ec_install_handlers(struct acpi_ec *ec)
                                   &acpi_ec_gpe_handler, ec);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
-        acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
-        acpi_enable_gpe(NULL, ec->gpe);
+
+        acpi_enable_gpe(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
         status = acpi_install_address_space_handler(ec->handle,
                                                     ACPI_ADR_SPACE_EC,
                                                     &acpi_ec_space_handler,
@@ -806,6 +814,7 @@ static int ec_install_handlers(struct acpi_ec *ec)
                 } else {
                         acpi_remove_gpe_handler(NULL, ec->gpe,
                                 &acpi_ec_gpe_handler);
+                        acpi_disable_gpe(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
                         return -ENODEV;
                 }
         }
@@ -816,6 +825,7 @@ static int ec_install_handlers(struct acpi_ec *ec)
 
 static void ec_remove_handlers(struct acpi_ec *ec)
 {
+        acpi_disable_gpe(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
         if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
                                 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
                 pr_err(PREFIX "failed to remove space handler\n");
@@ -1057,16 +1067,16 @@ error:
 static int acpi_ec_suspend(struct acpi_device *device, pm_message_t state)
 {
         struct acpi_ec *ec = acpi_driver_data(device);
-        /* Stop using GPE */
-        acpi_disable_gpe(NULL, ec->gpe);
+        /* Stop using the GPE, but keep it reference counted. */
+        acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
         return 0;
 }
 
 static int acpi_ec_resume(struct acpi_device *device)
 {
         struct acpi_ec *ec = acpi_driver_data(device);
-        /* Enable use of GPE back */
-        acpi_enable_gpe(NULL, ec->gpe);
+        /* Enable the GPE again, but don't reference count it once more. */
+        acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
         return 0;
 }
 
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index cb28e0502acc..9c4c962e46e3 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -36,8 +36,6 @@ static inline int acpi_debug_init(void) { return 0; }
 int acpi_power_init(void);
 int acpi_device_sleep_wake(struct acpi_device *dev,
                            int enable, int sleep_state, int dev_state);
-int acpi_enable_wakeup_device_power(struct acpi_device *dev, int sleep_state);
-int acpi_disable_wakeup_device_power(struct acpi_device *dev);
 int acpi_power_get_inferred_state(struct acpi_device *device);
 int acpi_power_transition(struct acpi_device *device, int state);
 extern int acpi_power_nocheck;
diff --git a/drivers/acpi/pci_bind.c b/drivers/acpi/pci_bind.c
index a5a77b78a723..2ef04098cc1d 100644
--- a/drivers/acpi/pci_bind.c
+++ b/drivers/acpi/pci_bind.c
@@ -26,7 +26,9 @@
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/pci.h>
+#include <linux/pci-acpi.h>
 #include <linux/acpi.h>
+#include <linux/pm_runtime.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 
@@ -38,7 +40,13 @@ static int acpi_pci_unbind(struct acpi_device *device)
         struct pci_dev *dev;
 
         dev = acpi_get_pci_dev(device->handle);
-        if (!dev || !dev->subordinate)
+        if (!dev)
+                goto out;
+
+        device_set_run_wake(&dev->dev, false);
+        pci_acpi_remove_pm_notifier(device);
+
+        if (!dev->subordinate)
                 goto out;
 
         acpi_pci_irq_del_prt(dev->subordinate);
@@ -62,6 +70,10 @@ static int acpi_pci_bind(struct acpi_device *device)
         if (!dev)
                 return 0;
 
+        pci_acpi_add_pm_notifier(device, dev);
+        if (device->wakeup.flags.run_wake)
+                device_set_run_wake(&dev->dev, true);
+
         /*
          * Install the 'bind' function to facilitate callbacks for
          * children of the P2P bridge.
diff --git a/drivers/acpi/pci_root.c b/drivers/acpi/pci_root.c
index 64f55b6db73c..d724736d56c8 100644
--- a/drivers/acpi/pci_root.c
+++ b/drivers/acpi/pci_root.c
@@ -30,6 +30,7 @@
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
 #include <linux/pm.h>
+#include <linux/pm_runtime.h>
 #include <linux/pci.h>
 #include <linux/pci-acpi.h>
 #include <linux/acpi.h>
@@ -528,6 +529,10 @@ static int __devinit acpi_pci_root_add(struct acpi_device *device)
         if (flags != base_flags)
                 acpi_pci_osc_support(root, flags);
 
+        pci_acpi_add_bus_pm_notifier(device, root->bus);
+        if (device->wakeup.flags.run_wake)
+                device_set_run_wake(root->bus->bridge, true);
+
         return 0;
 
 end:
@@ -549,6 +554,9 @@ static int acpi_pci_root_remove(struct acpi_device *device, int type)
 {
         struct acpi_pci_root *root = acpi_driver_data(device);
 
+        device_set_run_wake(root->bus->bridge, false);
+        pci_acpi_remove_bus_pm_notifier(device);
+
         kfree(root);
         return 0;
 }
@@ -558,6 +566,7 @@ static int __init acpi_pci_root_init(void)
         if (acpi_pci_disabled)
                 return 0;
 
+        pci_acpi_crs_quirks();
         if (acpi_bus_register_driver(&acpi_pci_root_driver) < 0)
                 return -ENODEV;
 
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 7c0441f63b39..cc978a8c00b7 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -110,6 +110,14 @@ static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
           DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
           DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
          (void *)2},
+        { set_max_cstate, "Pavilion zv5000", {
+          DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
+          DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")},
+         (void *)1},
+        { set_max_cstate, "Asus L8400B", {
+          DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
+          DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
+         (void *)1},
         {},
 };
 
@@ -872,12 +880,14 @@ static int acpi_idle_enter_simple(struct cpuidle_device *dev,
                 return(acpi_idle_enter_c1(dev, state));
 
         local_irq_disable();
-        current_thread_info()->status &= ~TS_POLLING;
-        /*
-         * TS_POLLING-cleared state must be visible before we test
-         * NEED_RESCHED:
-         */
-        smp_mb();
+        if (cx->entry_method != ACPI_CSTATE_FFH) {
+                current_thread_info()->status &= ~TS_POLLING;
+                /*
+                 * TS_POLLING-cleared state must be visible before we test
+                 * NEED_RESCHED:
+                 */
+                smp_mb();
+        }
 
         if (unlikely(need_resched())) {
                 current_thread_info()->status |= TS_POLLING;
@@ -957,12 +967,14 @@ static int acpi_idle_enter_bm(struct cpuidle_device *dev,
         }
 
         local_irq_disable();
-        current_thread_info()->status &= ~TS_POLLING;
-        /*
-         * TS_POLLING-cleared state must be visible before we test
-         * NEED_RESCHED:
-         */
-        smp_mb();
+        if (cx->entry_method != ACPI_CSTATE_FFH) {
+                current_thread_info()->status &= ~TS_POLLING;
+                /*
+                 * TS_POLLING-cleared state must be visible before we test
+                 * NEED_RESCHED:
+                 */
+                smp_mb();
+        }
 
         if (unlikely(need_resched())) {
                 current_thread_info()->status |= TS_POLLING;
diff --git a/drivers/acpi/processor_pdc.c b/drivers/acpi/processor_pdc.c
index 7247819dbd80..e306ba9aa34e 100644
--- a/drivers/acpi/processor_pdc.c
+++ b/drivers/acpi/processor_pdc.c
@@ -125,6 +125,8 @@ acpi_processor_eval_pdc(acpi_handle handle, struct acpi_object_list *pdc_in)
         return status;
 }
 
+static int early_pdc_done;
+
 void acpi_processor_set_pdc(acpi_handle handle)
 {
         struct acpi_object_list *obj_list;
@@ -132,6 +134,9 @@ void acpi_processor_set_pdc(acpi_handle handle)
         if (arch_has_acpi_pdc() == false)
                 return;
 
+        if (early_pdc_done)
+                return;
+
         obj_list = acpi_processor_alloc_pdc();
         if (!obj_list)
                 return;
@@ -151,6 +156,13 @@ static int set_early_pdc_optin(const struct dmi_system_id *id)
         return 0;
 }
 
+static int param_early_pdc_optin(char *s)
+{
+        early_pdc_optin = 1;
+        return 1;
+}
+__setup("acpi_early_pdc_eval", param_early_pdc_optin);
+
 static struct dmi_system_id __cpuinitdata early_pdc_optin_table[] = {
         {
         set_early_pdc_optin, "HP Envy", {
@@ -192,4 +204,6 @@ void __init acpi_early_processor_set_pdc(void)
         acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
                             ACPI_UINT32_MAX,
                             early_init_pdc, NULL, NULL, NULL);
+
+        early_pdc_done = 1;
 }
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index 2cabadcc4d8c..a959f6a07508 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -413,7 +413,11 @@ static int acpi_processor_get_performance_info(struct acpi_processor *pr)
         if (result)
                 goto update_bios;
 
-        return 0;
+        /* We need to call _PPC once when cpufreq starts */
+        if (ignore_ppc != 1)
+                result = acpi_processor_get_platform_limit(pr);
+
+        return result;
 
         /*
          * Having _PPC but missing frequencies (_PSS, _PCT) is a very good hint that
diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c
index ff9f6226085d..fb7fc24fe727 100644
--- a/drivers/acpi/scan.c
+++ b/drivers/acpi/scan.c
@@ -741,19 +741,40 @@ acpi_bus_extract_wakeup_device_power_package(struct acpi_device *device,
         return AE_OK;
 }
 
-static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
+static void acpi_bus_set_run_wake_flags(struct acpi_device *device)
 {
-        acpi_status status = 0;
-        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *package = NULL;
-        int psw_error;
-
         struct acpi_device_id button_device_ids[] = {
                 {"PNP0C0D", 0},
                 {"PNP0C0C", 0},
                 {"PNP0C0E", 0},
                 {"", 0},
         };
+        acpi_status status;
+        acpi_event_status event_status;
+
+        device->wakeup.run_wake_count = 0;
+        device->wakeup.flags.notifier_present = 0;
+
+        /* Power button, Lid switch always enable wakeup */
+        if (!acpi_match_device_ids(device, button_device_ids)) {
+                device->wakeup.flags.run_wake = 1;
+                device->wakeup.flags.always_enabled = 1;
+                return;
+        }
+
+        status = acpi_get_gpe_status(NULL, device->wakeup.gpe_number,
+                                        ACPI_NOT_ISR, &event_status);
+        if (status == AE_OK)
+                device->wakeup.flags.run_wake =
+                                !!(event_status & ACPI_EVENT_FLAG_HANDLE);
+}
+
+static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
+{
+        acpi_status status = 0;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *package = NULL;
+        int psw_error;
 
         /* _PRW */
         status = acpi_evaluate_object(device->handle, "_PRW", NULL, &buffer);
@@ -773,6 +794,7 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
 
         device->wakeup.flags.valid = 1;
         device->wakeup.prepare_count = 0;
+        acpi_bus_set_run_wake_flags(device);
         /* Call _PSW/_DSW object to disable its ability to wake the sleeping
          * system for the ACPI device with the _PRW object.
          * The _PSW object is depreciated in ACPI 3.0 and is replaced by _DSW.
@@ -784,10 +806,6 @@ static int acpi_bus_get_wakeup_device_flags(struct acpi_device *device)
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                 "error in _DSW or _PSW evaluation\n"));
 
-        /* Power button, Lid switch always enable wakeup */
-        if (!acpi_match_device_ids(device, button_device_ids))
-                device->wakeup.flags.run_wake = 1;
-
 end:
         if (ACPI_FAILURE(status))
                 device->flags.wake_capable = 0;
@@ -1336,9 +1354,25 @@ static int acpi_bus_scan(acpi_handle handle, struct acpi_bus_ops *ops,
 
         if (child)
                 *child = device;
-        return 0;
+
+        if (device)
+                return 0;
+        else
+                return -ENODEV;
 }
 
+/*
+ * acpi_bus_add and acpi_bus_start
+ *
+ * scan a given ACPI tree and (probably recently hot-plugged)
+ * create and add or starts found devices.
+ *
+ * If no devices were found -ENODEV is returned which does not
+ * mean that this is a real error, there just have been no suitable
+ * ACPI objects in the table trunk from which the kernel could create
+ * a device and add/start an appropriate driver.
+ */
+
 int
 acpi_bus_add(struct acpi_device **child,
              struct acpi_device *parent, acpi_handle handle, int type)
@@ -1348,8 +1382,7 @@ acpi_bus_add(struct acpi_device **child,
         memset(&ops, 0, sizeof(ops));
         ops.acpi_op_add = 1;
 
-        acpi_bus_scan(handle, &ops, child);
-        return 0;
+        return acpi_bus_scan(handle, &ops, child);
 }
 EXPORT_SYMBOL(acpi_bus_add);
 
@@ -1357,11 +1390,13 @@ int acpi_bus_start(struct acpi_device *device)
 {
         struct acpi_bus_ops ops;
 
+        if (!device)
+                return -EINVAL;
+
         memset(&ops, 0, sizeof(ops));
         ops.acpi_op_start = 1;
 
-        acpi_bus_scan(device->handle, &ops, NULL);
-        return 0;
+        return acpi_bus_scan(device->handle, &ops, NULL);
 }
 EXPORT_SYMBOL(acpi_bus_start);
 
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index 79d33d908b5a..3bde594a9979 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -745,9 +745,18 @@ int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
                 return -ENODEV;
         }
 
-        error = enable ?
-                acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
-                acpi_disable_wakeup_device_power(adev);
+        if (enable) {
+                error = acpi_enable_wakeup_device_power(adev,
+                                                acpi_target_sleep_state);
+                if (!error)
+                        acpi_enable_gpe(adev->wakeup.gpe_device,
+                                        adev->wakeup.gpe_number,
+                                        ACPI_GPE_TYPE_WAKE);
+        } else {
+                acpi_disable_gpe(adev->wakeup.gpe_device, adev->wakeup.gpe_number,
+                                ACPI_GPE_TYPE_WAKE);
+                error = acpi_disable_wakeup_device_power(adev);
+        }
         if (!error)
                 dev_info(dev, "wake-up capability %s by ACPI\n",
                                 enable ? "enabled" : "disabled");
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index d11282975f35..a206a12da78a 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -387,10 +387,10 @@ static ssize_t counter_set(struct kobject *kobj,
         if (index < num_gpes) {
                 if (!strcmp(buf, "disable\n") &&
                                 (status & ACPI_EVENT_FLAG_ENABLED))
-                        result = acpi_disable_gpe(handle, index);
+                        result = acpi_set_gpe(handle, index, ACPI_GPE_DISABLE);
                 else if (!strcmp(buf, "enable\n") &&
                                 !(status & ACPI_EVENT_FLAG_ENABLED))
-                        result = acpi_enable_gpe(handle, index);
+                        result = acpi_set_gpe(handle, index, ACPI_GPE_ENABLE);
                 else if (!strcmp(buf, "clear\n") &&
                                 (status & ACPI_EVENT_FLAG_SET))
                         result = acpi_clear_gpe(handle, index, ACPI_NOT_ISR);
diff --git a/drivers/acpi/tables.c b/drivers/acpi/tables.c
index f336bca7c450..8a0ed2800e63 100644
--- a/drivers/acpi/tables.c
+++ b/drivers/acpi/tables.c
@@ -213,7 +213,7 @@ acpi_table_parse_entries(char *id,
         unsigned long table_end;
         acpi_size tbl_size;
 
-        if (acpi_disabled)
+        if (acpi_disabled && !acpi_ht)
                 return -ENODEV;
 
         if (!handler)
@@ -280,7 +280,7 @@ int __init acpi_table_parse(char *id, acpi_table_handler handler)
         struct acpi_table_header *table = NULL;
         acpi_size tbl_size;
 
-        if (acpi_disabled)
+        if (acpi_disabled && !acpi_ht)
                 return -ENODEV;
 
         if (!handler)
diff --git a/drivers/acpi/wakeup.c b/drivers/acpi/wakeup.c
index e0ee0c036f5a..4b9d339a6e28 100644
--- a/drivers/acpi/wakeup.c
+++ b/drivers/acpi/wakeup.c
@@ -21,12 +21,12 @@
 ACPI_MODULE_NAME("wakeup_devices")
 
 /**
- * acpi_enable_wakeup_device_prep - prepare wakeup devices
- *      @sleep_state:   ACPI state
- * Enable all wakup devices power if the devices' wakeup level
- * is higher than requested sleep level
+ * acpi_enable_wakeup_device_prep - Prepare wake-up devices.
+ * @sleep_state: ACPI system sleep state.
+ *
+ * Enable all wake-up devices' power, unless the requested system sleep state is
+ * too deep.
  */
-
 void acpi_enable_wakeup_device_prep(u8 sleep_state)
 {
         struct list_head *node, *next;
@@ -36,9 +36,8 @@ void acpi_enable_wakeup_device_prep(u8 sleep_state)
                                                        struct acpi_device,
                                                        wakeup_list);
 
-                if (!dev->wakeup.flags.valid ||
-                    !dev->wakeup.state.enabled ||
-                    (sleep_state > (u32) dev->wakeup.sleep_state))
+                if (!dev->wakeup.flags.valid || !dev->wakeup.state.enabled
+                    || (sleep_state > (u32) dev->wakeup.sleep_state))
                         continue;
 
                 acpi_enable_wakeup_device_power(dev, sleep_state);
@@ -46,9 +45,12 @@ void acpi_enable_wakeup_device_prep(u8 sleep_state)
 }
 
 /**
- * acpi_enable_wakeup_device - enable wakeup devices
- *      @sleep_state:   ACPI state
- * Enable all wakup devices's GPE
+ * acpi_enable_wakeup_device - Enable wake-up device GPEs.
+ * @sleep_state: ACPI system sleep state.
+ *
+ * Enable all wake-up devices' GPEs, with the assumption that
+ * acpi_disable_all_gpes() was executed before, so we don't need to disable any
+ * GPEs here.
  */
 void acpi_enable_wakeup_device(u8 sleep_state)
 {
@@ -65,29 +67,22 @@ void acpi_enable_wakeup_device(u8 sleep_state)
                 if (!dev->wakeup.flags.valid)
                         continue;
 
-                /* If users want to disable run-wake GPE,
-                 * we only disable it for wake and leave it for runtime
-                 */
                 if ((!dev->wakeup.state.enabled && !dev->wakeup.prepare_count)
-                    || sleep_state > (u32) dev->wakeup.sleep_state) {
-                        if (dev->wakeup.flags.run_wake) {
-                                /* set_gpe_type will disable GPE, leave it like that */
-                                acpi_set_gpe_type(dev->wakeup.gpe_device,
-                                                  dev->wakeup.gpe_number,
-                                                  ACPI_GPE_TYPE_RUNTIME);
-                        }
+                    || sleep_state > (u32) dev->wakeup.sleep_state)
                         continue;
-                }
-                if (!dev->wakeup.flags.run_wake)
-                        acpi_enable_gpe(dev->wakeup.gpe_device,
-                                        dev->wakeup.gpe_number);
+
+                /* The wake-up power should have been enabled already. */
+                acpi_set_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
+                                ACPI_GPE_ENABLE);
         }
 }
 
 /**
- * acpi_disable_wakeup_device - disable devices' wakeup capability
- *      @sleep_state:   ACPI state
- * Disable all wakup devices's GPE and wakeup capability
+ * acpi_disable_wakeup_device - Disable devices' wakeup capability.
+ * @sleep_state: ACPI system sleep state.
+ *
+ * This function only affects devices with wakeup.state.enabled set, which means
+ * that it reverses the changes made by acpi_enable_wakeup_device_prep().
  */
 void acpi_disable_wakeup_device(u8 sleep_state)
 {
@@ -97,30 +92,11 @@ void acpi_disable_wakeup_device(u8 sleep_state)
                 struct acpi_device *dev =
                         container_of(node, struct acpi_device, wakeup_list);
 
-                if (!dev->wakeup.flags.valid)
-                        continue;
-
-                if ((!dev->wakeup.state.enabled && !dev->wakeup.prepare_count)
-                    || sleep_state > (u32) dev->wakeup.sleep_state) {
-                        if (dev->wakeup.flags.run_wake) {
-                                acpi_set_gpe_type(dev->wakeup.gpe_device,
-                                                  dev->wakeup.gpe_number,
-                                                  ACPI_GPE_TYPE_WAKE_RUN);
-                                /* Re-enable it, since set_gpe_type will disable it */
-                                acpi_enable_gpe(dev->wakeup.gpe_device,
-                                                dev->wakeup.gpe_number);
-                        }
+                if (!dev->wakeup.flags.valid || !dev->wakeup.state.enabled
+                    || (sleep_state > (u32) dev->wakeup.sleep_state))
                         continue;
-                }
 
                 acpi_disable_wakeup_device_power(dev);
-                /* Never disable run-wake GPE */
-                if (!dev->wakeup.flags.run_wake) {
-                        acpi_disable_gpe(dev->wakeup.gpe_device,
-                                         dev->wakeup.gpe_number);
-                        acpi_clear_gpe(dev->wakeup.gpe_device,
-                                       dev->wakeup.gpe_number, ACPI_NOT_ISR);
-                }
         }
 }
 
@@ -134,13 +110,11 @@ int __init acpi_wakeup_device_init(void)
                                                        struct acpi_device,
                                                        wakeup_list);
                 /* In case user doesn't load button driver */
-                if (!dev->wakeup.flags.run_wake || dev->wakeup.state.enabled)
+                if (!dev->wakeup.flags.always_enabled ||
+                    dev->wakeup.state.enabled)
                         continue;
-                acpi_set_gpe_type(dev->wakeup.gpe_device,
-                                  dev->wakeup.gpe_number,
-                                  ACPI_GPE_TYPE_WAKE_RUN);
-                acpi_enable_gpe(dev->wakeup.gpe_device,
-                                dev->wakeup.gpe_number);
+                acpi_enable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number,
+                                ACPI_GPE_TYPE_WAKE);
                 dev->wakeup.state.enabled = 1;
         }
         mutex_unlock(&acpi_device_lock);
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index b34390347c16..a6a736a7dbf2 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -3082,8 +3082,16 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
         ahci_save_initial_config(pdev, hpriv);
 
         /* prepare host */
-        if (hpriv->cap & HOST_CAP_NCQ)
-                pi.flags |= ATA_FLAG_NCQ | ATA_FLAG_FPDMA_AA;
+        if (hpriv->cap & HOST_CAP_NCQ) {
+                pi.flags |= ATA_FLAG_NCQ;
+                /* Auto-activate optimization is supposed to be supported on
+                   all AHCI controllers indicating NCQ support, but it seems
+                   to be broken at least on some NVIDIA MCP79 chipsets.
+                   Until we get info on which NVIDIA chipsets don't have this
+                   issue, if any, disable AA on all NVIDIA AHCIs. */
+                if (pdev->vendor != PCI_VENDOR_ID_NVIDIA)
+                        pi.flags |= ATA_FLAG_FPDMA_AA;
+        }
 
         if (hpriv->cap & HOST_CAP_PMP)
                 pi.flags |= ATA_FLAG_PMP;
diff --git a/drivers/base/class.c b/drivers/base/class.c
index 161746deab4b..6e2c3b064f53 100644
--- a/drivers/base/class.c
+++ b/drivers/base/class.c
@@ -59,6 +59,8 @@ static void class_release(struct kobject *kobj)
         else
                 pr_debug("class '%s' does not have a release() function, "
                          "be careful\n", class->name);
+
+        kfree(cp);
 }
 
 static struct sysfs_ops class_sysfs_ops = {
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 51042f0ba7e1..7eff828b2117 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -243,10 +243,12 @@ static int index_to_minor(int index)
 static int __devinit virtblk_probe(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk;
+        struct request_queue *q;
         int err;
         u64 cap;
-        u32 v;
-        u32 blk_size, sg_elems;
+        u32 v, blk_size, sg_elems, opt_io_size;
+        u16 min_io_size;
+        u8 physical_block_exp, alignment_offset;
 
         if (index_to_minor(index) >= 1 << MINORBITS)
                 return -ENOSPC;
@@ -293,13 +295,13 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
                 goto out_mempool;
         }
 
-        vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
-        if (!vblk->disk->queue) {
+        q = vblk->disk->queue = blk_init_queue(do_virtblk_request, &vblk->lock);
+        if (!q) {
                 err = -ENOMEM;
                 goto out_put_disk;
         }
 
-        vblk->disk->queue->queuedata = vblk;
+        q->queuedata = vblk;
 
         if (index < 26) {
                 sprintf(vblk->disk->disk_name, "vd%c", 'a' + index % 26);
@@ -323,10 +325,10 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
 
         /* If barriers are supported, tell block layer that queue is ordered */
         if (virtio_has_feature(vdev, VIRTIO_BLK_F_FLUSH))
-                blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_DRAIN_FLUSH,
+                blk_queue_ordered(q, QUEUE_ORDERED_DRAIN_FLUSH,
                                   virtblk_prepare_flush);
         else if (virtio_has_feature(vdev, VIRTIO_BLK_F_BARRIER))
-                blk_queue_ordered(vblk->disk->queue, QUEUE_ORDERED_TAG, NULL);
+                blk_queue_ordered(q, QUEUE_ORDERED_TAG, NULL);
 
         /* If disk is read-only in the host, the guest should obey */
         if (virtio_has_feature(vdev, VIRTIO_BLK_F_RO))
@@ -345,14 +347,14 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
         set_capacity(vblk->disk, cap);
 
         /* We can handle whatever the host told us to handle. */
-        blk_queue_max_phys_segments(vblk->disk->queue, vblk->sg_elems-2);
-        blk_queue_max_hw_segments(vblk->disk->queue, vblk->sg_elems-2);
+        blk_queue_max_phys_segments(q, vblk->sg_elems-2);
+        blk_queue_max_hw_segments(q, vblk->sg_elems-2);
 
         /* No need to bounce any requests */
-        blk_queue_bounce_limit(vblk->disk->queue, BLK_BOUNCE_ANY);
+        blk_queue_bounce_limit(q, BLK_BOUNCE_ANY);
 
         /* No real sector limit. */
-        blk_queue_max_sectors(vblk->disk->queue, -1U);
+        blk_queue_max_sectors(q, -1U);
 
         /* Host can optionally specify maximum segment size and number of
          * segments. */
@@ -360,16 +362,45 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
                                 offsetof(struct virtio_blk_config, size_max),
                                 &v);
         if (!err)
-                blk_queue_max_segment_size(vblk->disk->queue, v);
+                blk_queue_max_segment_size(q, v);
         else
-                blk_queue_max_segment_size(vblk->disk->queue, -1U);
+                blk_queue_max_segment_size(q, -1U);
 
         /* Host can optionally specify the block size of the device */
         err = virtio_config_val(vdev, VIRTIO_BLK_F_BLK_SIZE,
                                 offsetof(struct virtio_blk_config, blk_size),
                                 &blk_size);
         if (!err)
-                blk_queue_logical_block_size(vblk->disk->queue, blk_size);
+                blk_queue_logical_block_size(q, blk_size);
+        else
+                blk_size = queue_logical_block_size(q);
+
+        /* Use topology information if available */
+        err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
+                        offsetof(struct virtio_blk_config, physical_block_exp),
+                        &physical_block_exp);
+        if (!err && physical_block_exp)
+                blk_queue_physical_block_size(q,
+                                blk_size * (1 << physical_block_exp));
+
+        err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
+                        offsetof(struct virtio_blk_config, alignment_offset),
+                        &alignment_offset);
+        if (!err && alignment_offset)
+                blk_queue_alignment_offset(q, blk_size * alignment_offset);
+
+        err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
+                        offsetof(struct virtio_blk_config, min_io_size),
+                        &min_io_size);
+        if (!err && min_io_size)
+                blk_queue_io_min(q, blk_size * min_io_size);
+
+        err = virtio_config_val(vdev, VIRTIO_BLK_F_TOPOLOGY,
+                        offsetof(struct virtio_blk_config, opt_io_size),
+                        &opt_io_size);
+        if (!err && opt_io_size)
+                blk_queue_io_opt(q, blk_size * opt_io_size);
+
 
         add_disk(vblk->disk);
         return 0;
@@ -412,7 +443,7 @@ static struct virtio_device_id id_table[] = {
 static unsigned int features[] = {
         VIRTIO_BLK_F_BARRIER, VIRTIO_BLK_F_SEG_MAX, VIRTIO_BLK_F_SIZE_MAX,
         VIRTIO_BLK_F_GEOMETRY, VIRTIO_BLK_F_RO, VIRTIO_BLK_F_BLK_SIZE,
-        VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_FLUSH
+        VIRTIO_BLK_F_SCSI, VIRTIO_BLK_F_FLUSH, VIRTIO_BLK_F_TOPOLOGY
 };
 
 /*
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index e023682be2c4..3141dd3b6e53 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -666,6 +666,14 @@ config VIRTIO_CONSOLE
         help
           Virtio console for use with lguest and other hypervisors.
 
+          Also serves as a general-purpose serial device for data
+          transfer between the guest and host.  Character devices at
+          /dev/vportNpn will be created when corresponding ports are
+          found, where N is the device number and n is the port number
+          within that device.  If specified by the host, a sysfs
+          attribute called 'name' will be populated with a name for
+          the port which can be used by udev scripts to create a
+          symlink to the device.
 
 config HVCS
         tristate "IBM Hypervisor Virtual Console Server support"
diff --git a/drivers/char/hvc_beat.c b/drivers/char/hvc_beat.c
index 0afc8b82212e..5fe4631e2a61 100644
--- a/drivers/char/hvc_beat.c
+++ b/drivers/char/hvc_beat.c
@@ -84,7 +84,7 @@ static int hvc_beat_put_chars(uint32_t vtermno, const char *buf, int cnt)
         return cnt;
 }
 
-static struct hv_ops hvc_beat_get_put_ops = {
+static const struct hv_ops hvc_beat_get_put_ops = {
         .get_chars = hvc_beat_get_chars,
         .put_chars = hvc_beat_put_chars,
 };
@@ -99,7 +99,7 @@ static int hvc_beat_config(char *p)
 
 static int __init hvc_beat_console_init(void)
 {
-        if (hvc_beat_useit && machine_is_compatible("Beat")) {
+        if (hvc_beat_useit && of_machine_is_compatible("Beat")) {
                 hvc_instantiate(0, 0, &hvc_beat_get_put_ops);
         }
         return 0;
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 416d3423150d..d8dac5820f0e 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -125,7 +125,7 @@ static struct hvc_struct *hvc_get_by_index(int index)
  * console interfaces but can still be used as a tty device.  This has to be
  * static because kmalloc will not work during early console init.
  */
-static struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
+static const struct hv_ops *cons_ops[MAX_NR_HVC_CONSOLES];
 static uint32_t vtermnos[MAX_NR_HVC_CONSOLES] =
         {[0 ... MAX_NR_HVC_CONSOLES - 1] = -1};
 
@@ -247,7 +247,7 @@ static void destroy_hvc_struct(struct kref *kref)
  * vty adapters do NOT get an hvc_instantiate() callback since they
  * appear after early console init.
  */
-int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops)
+int hvc_instantiate(uint32_t vtermno, int index, const struct hv_ops *ops)
 {
         struct hvc_struct *hp;
 
@@ -749,7 +749,8 @@ static const struct tty_operations hvc_ops = {
 };
 
 struct hvc_struct __devinit *hvc_alloc(uint32_t vtermno, int data,
-                                        struct hv_ops *ops, int outbuf_size)
+                                       const struct hv_ops *ops,
+                                       int outbuf_size)
 {
         struct hvc_struct *hp;
         int i;
diff --git a/drivers/char/hvc_console.h b/drivers/char/hvc_console.h
index 10950ca706d8..52ddf4d3716c 100644
--- a/drivers/char/hvc_console.h
+++ b/drivers/char/hvc_console.h
@@ -55,7 +55,7 @@ struct hvc_struct {
         int outbuf_size;
         int n_outbuf;
         uint32_t vtermno;
-        struct hv_ops *ops;
+        const struct hv_ops *ops;
         int irq_requested;
         int data;
         struct winsize ws;
@@ -76,11 +76,12 @@ struct hv_ops {
 };
 
 /* Register a vterm and a slot index for use as a console (console_init) */
-extern int hvc_instantiate(uint32_t vtermno, int index, struct hv_ops *ops);
+extern int hvc_instantiate(uint32_t vtermno, int index,
+                           const struct hv_ops *ops);
 
 /* register a vterm for hvc tty operation (module_init or hotplug add) */
 extern struct hvc_struct * __devinit hvc_alloc(uint32_t vtermno, int data,
-                                struct hv_ops *ops, int outbuf_size);
+                                const struct hv_ops *ops, int outbuf_size);
 /* remove a vterm from hvc tty operation (module_exit or hotplug remove) */
 extern int hvc_remove(struct hvc_struct *hp);
 
diff --git a/drivers/char/hvc_iseries.c b/drivers/char/hvc_iseries.c
index 936d05bf37fa..fd0242676a2a 100644
--- a/drivers/char/hvc_iseries.c
+++ b/drivers/char/hvc_iseries.c
@@ -197,7 +197,7 @@ done:
         return sent;
 }
 
-static struct hv_ops hvc_get_put_ops = {
+static const struct hv_ops hvc_get_put_ops = {
         .get_chars = get_chars,
         .put_chars = put_chars,
         .notifier_add = notifier_add_irq,
diff --git a/drivers/char/hvc_iucv.c b/drivers/char/hvc_iucv.c
index fe62bd0e17b7..21681a81cc35 100644
--- a/drivers/char/hvc_iucv.c
+++ b/drivers/char/hvc_iucv.c
@@ -922,7 +922,7 @@ static int hvc_iucv_pm_restore_thaw(struct device *dev)
 
 
 /* HVC operations */
-static struct hv_ops hvc_iucv_ops = {
+static const struct hv_ops hvc_iucv_ops = {
         .get_chars = hvc_iucv_get_chars,
         .put_chars = hvc_iucv_put_chars,
         .notifier_add = hvc_iucv_notifier_add,
diff --git a/drivers/char/hvc_rtas.c b/drivers/char/hvc_rtas.c
index 88590d040046..61c4a61558d9 100644
--- a/drivers/char/hvc_rtas.c
+++ b/drivers/char/hvc_rtas.c
@@ -71,7 +71,7 @@ static int hvc_rtas_read_console(uint32_t vtermno, char *buf, int count)
         return i;
 }
 
-static struct hv_ops hvc_rtas_get_put_ops = {
+static const struct hv_ops hvc_rtas_get_put_ops = {
         .get_chars = hvc_rtas_read_console,
         .put_chars = hvc_rtas_write_console,
 };
diff --git a/drivers/char/hvc_udbg.c b/drivers/char/hvc_udbg.c
index bd63ba878a56..b0957e61a7be 100644
--- a/drivers/char/hvc_udbg.c
+++ b/drivers/char/hvc_udbg.c
@@ -58,7 +58,7 @@ static int hvc_udbg_get(uint32_t vtermno, char *buf, int count)
         return i;
 }
 
-static struct hv_ops hvc_udbg_ops = {
+static const struct hv_ops hvc_udbg_ops = {
         .get_chars = hvc_udbg_get,
         .put_chars = hvc_udbg_put,
 };
diff --git a/drivers/char/hvc_vio.c b/drivers/char/hvc_vio.c
index 10be343d6ae7..27370e99c66f 100644
--- a/drivers/char/hvc_vio.c
+++ b/drivers/char/hvc_vio.c
@@ -77,7 +77,7 @@ static int filtered_get_chars(uint32_t vtermno, char *buf, int count)
         return got;
 }
 
-static struct hv_ops hvc_get_put_ops = {
+static const struct hv_ops hvc_get_put_ops = {
         .get_chars = filtered_get_chars,
         .put_chars = hvc_put_chars,
         .notifier_add = notifier_add_irq,
diff --git a/drivers/char/hvc_xen.c b/drivers/char/hvc_xen.c
index b1a71638c772..60446f82a3fc 100644
--- a/drivers/char/hvc_xen.c
+++ b/drivers/char/hvc_xen.c
@@ -122,7 +122,7 @@ static int read_console(uint32_t vtermno, char *buf, int len)
         return recv;
 }
 
-static struct hv_ops hvc_ops = {
+static const struct hv_ops hvc_ops = {
         .get_chars = read_console,
         .put_chars = write_console,
         .notifier_add = notifier_add_irq,
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 87060266ef91..6ea1014697d1 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -186,3 +186,15 @@ config HW_RANDOM_MXC_RNGA
           module will be called mxc-rnga.
 
           If unsure, say Y.
+
+config HW_RANDOM_NOMADIK
+        tristate "ST-Ericsson Nomadik Random Number Generator support"
+        depends on HW_RANDOM && PLAT_NOMADIK
+        ---help---
+          This driver provides kernel-side support for the Random Number
+          Generator hardware found on ST-Ericsson SoCs (8815 and 8500).
+
+          To compile this driver as a module, choose M here: the
+          module will be called nomadik-rng.
+
+          If unsure, say Y.
diff --git a/drivers/char/hw_random/Makefile b/drivers/char/hw_random/Makefile
index 5eeb1303f0d0..4273308aa1e3 100644
--- a/drivers/char/hw_random/Makefile
+++ b/drivers/char/hw_random/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_HW_RANDOM_VIRTIO) += virtio-rng.o
 obj-$(CONFIG_HW_RANDOM_TX4939) += tx4939-rng.o
 obj-$(CONFIG_HW_RANDOM_MXC_RNGA) += mxc-rnga.o
 obj-$(CONFIG_HW_RANDOM_OCTEON) += octeon-rng.o
+obj-$(CONFIG_HW_RANDOM_NOMADIK) += nomadik-rng.o
diff --git a/drivers/char/hw_random/nomadik-rng.c b/drivers/char/hw_random/nomadik-rng.c
new file mode 100644
index 000000000000..a8b4c4010144
--- /dev/null
+++ b/drivers/char/hw_random/nomadik-rng.c
@@ -0,0 +1,103 @@
+/*
+ * Nomadik RNG support
+ *  Copyright 2009 Alessandro Rubini
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/amba/bus.h>
+#include <linux/hw_random.h>
+#include <linux/io.h>
+
+static int nmk_rng_read(struct hwrng *rng, void *data, size_t max, bool wait)
+{
+        void __iomem *base = (void __iomem *)rng->priv;
+
+        /*
+         * The register is 32 bits and gives 16 random bits (low half).
+         * A subsequent read will delay the core for 400ns, so we just read
+         * once and accept the very unlikely very small delay, even if wait==0.
+         */
+        *(u16 *)data = __raw_readl(base + 8) & 0xffff;
+        return 2;
+}
+
+/* we have at most one RNG per machine, granted */
+static struct hwrng nmk_rng = {
+        .name           = "nomadik",
+        .read           = nmk_rng_read,
+};
+
+static int nmk_rng_probe(struct amba_device *dev, struct amba_id *id)
+{
+        void __iomem *base;
+        int ret;
+
+        ret = amba_request_regions(dev, dev->dev.init_name);
+        if (ret)
+                return ret;
+        ret = -ENOMEM;
+        base = ioremap(dev->res.start, resource_size(&dev->res));
+        if (!base)
+                goto out_release;
+        nmk_rng.priv = (unsigned long)base;
+        ret = hwrng_register(&nmk_rng);
+        if (ret)
+                goto out_unmap;
+        return 0;
+
+out_unmap:
+        iounmap(base);
+out_release:
+        amba_release_regions(dev);
+        return ret;
+}
+
+static int nmk_rng_remove(struct amba_device *dev)
+{
+        void __iomem *base = (void __iomem *)nmk_rng.priv;
+        hwrng_unregister(&nmk_rng);
+        iounmap(base);
+        amba_release_regions(dev);
+        return 0;
+}
+
+static struct amba_id nmk_rng_ids[] = {
+        {
+                .id     = 0x000805e1,
+                .mask   = 0x000fffff, /* top bits are rev and cfg: accept all */
+        },
+        {0, 0},
+};
+
+static struct amba_driver nmk_rng_driver = {
+        .drv = {
+                .owner = THIS_MODULE,
+                .name = "rng",
+                },
+        .probe = nmk_rng_probe,
+        .remove = nmk_rng_remove,
+        .id_table = nmk_rng_ids,
+};
+
+static int __init nmk_rng_init(void)
+{
+        return amba_driver_register(&nmk_rng_driver);
+}
+
+static void __devexit nmk_rng_exit(void)
+{
+        amba_driver_unregister(&nmk_rng_driver);
+}
+
+module_init(nmk_rng_init);
+module_exit(nmk_rng_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index a035ae39a359..213373b5f17f 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -1,18 +1,6 @@
-/*D:300
- * The Guest console driver
- *
- * Writing console drivers is one of the few remaining Dark Arts in Linux.
- * Fortunately for us, the path of virtual consoles has been well-trodden by
- * the PowerPC folks, who wrote "hvc_console.c" to generically support any
- * virtual console.  We use that infrastructure which only requires us to write
- * the basic put_chars and get_chars functions and call the right register
- * functions.
- :*/
-
-/*M:002 The console can be flooded: while the Guest is processing input the
- * Host can send more.  Buffering in the Host could alleviate this, but it is a
- * difficult problem in general. :*/
-/* Copyright (C) 2006, 2007 Rusty Russell, IBM Corporation
+/*
+ * Copyright (C) 2006, 2007, 2009 Rusty Russell, IBM Corporation
+ * Copyright (C) 2009, 2010 Red Hat, Inc.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -28,142 +16,694 @@
  * 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/cdev.h>
+#include <linux/debugfs.h>
+#include <linux/device.h>
 #include <linux/err.h>
+#include <linux/fs.h>
 #include <linux/init.h>
+#include <linux/list.h>
+#include <linux/poll.h>
+#include <linux/sched.h>
+#include <linux/spinlock.h>
 #include <linux/virtio.h>
 #include <linux/virtio_console.h>
+#include <linux/wait.h>
+#include <linux/workqueue.h>
 #include "hvc_console.h"
 
-/*D:340 These represent our input and output console queues, and the virtio
- * operations for them. */
-static struct virtqueue *in_vq, *out_vq;
-static struct virtio_device *vdev;
+/*
+ * This is a global struct for storing common data for all the devices
+ * this driver handles.
+ *
+ * Mainly, it has a linked list for all the consoles in one place so
+ * that callbacks from hvc for get_chars(), put_chars() work properly
+ * across multiple devices and multiple ports per device.
+ */
+struct ports_driver_data {
+        /* Used for registering chardevs */
+        struct class *class;
+
+        /* Used for exporting per-port information to debugfs */
+        struct dentry *debugfs_dir;
+
+        /* Number of devices this driver is handling */
+        unsigned int index;
+
+        /*
+         * This is used to keep track of the number of hvc consoles
+         * spawned by this driver.  This number is given as the first
+         * argument to hvc_alloc().  To correctly map an initial
+         * console spawned via hvc_instantiate to the console being
+         * hooked up via hvc_alloc, we need to pass the same vtermno.
+         *
+         * We also just assume the first console being initialised was
+         * the first one that got used as the initial console.
+         */
+        unsigned int next_vtermno;
+
+        /* All the console devices handled by this driver */
+        struct list_head consoles;
+};
+static struct ports_driver_data pdrvdata;
+
+DEFINE_SPINLOCK(pdrvdata_lock);
+
+/* This struct holds information that's relevant only for console ports */
+struct console {
+        /* We'll place all consoles in a list in the pdrvdata struct */
+        struct list_head list;
+
+        /* The hvc device associated with this console port */
+        struct hvc_struct *hvc;
+
+        /*
+         * This number identifies the number that we used to register
+         * with hvc in hvc_instantiate() and hvc_alloc(); this is the
+         * number passed on by the hvc callbacks to us to
+         * differentiate between the other console ports handled by
+         * this driver
+         */
+        u32 vtermno;
+};
+
+struct port_buffer {
+        char *buf;
+
+        /* size of the buffer in *buf above */
+        size_t size;
+
+        /* used length of the buffer */
+        size_t len;
+        /* offset in the buf from which to consume data */
+        size_t offset;
+};
+
+/*
+ * This is a per-device struct that stores data common to all the
+ * ports for that device (vdev->priv).
+ */
+struct ports_device {
+        /*
+         * Workqueue handlers where we process deferred work after
+         * notification
+         */
+        struct work_struct control_work;
+        struct work_struct config_work;
+
+        struct list_head ports;
+
+        /* To protect the list of ports */
+        spinlock_t ports_lock;
+
+        /* To protect the vq operations for the control channel */
+        spinlock_t cvq_lock;
+
+        /* The current config space is stored here */
+        struct virtio_console_config config;
+
+        /* The virtio device we're associated with */
+        struct virtio_device *vdev;
+
+        /*
+         * A couple of virtqueues for the control channel: one for
+         * guest->host transfers, one for host->guest transfers
+         */
+        struct virtqueue *c_ivq, *c_ovq;
+
+        /* Array of per-port IO virtqueues */
+        struct virtqueue **in_vqs, **out_vqs;
+
+        /* Used for numbering devices for sysfs and debugfs */
+        unsigned int drv_index;
+
+        /* Major number for this device.  Ports will be created as minors. */
+        int chr_major;
+};
+
+/* This struct holds the per-port data */
+struct port {
+        /* Next port in the list, head is in the ports_device */
+        struct list_head list;
+
+        /* Pointer to the parent virtio_console device */
+        struct ports_device *portdev;
+
+        /* The current buffer from which data has to be fed to readers */
+        struct port_buffer *inbuf;
+
+        /*
+         * To protect the operations on the in_vq associated with this
+         * port.  Has to be a spinlock because it can be called from
+         * interrupt context (get_char()).
+         */
+        spinlock_t inbuf_lock;
+
+        /* The IO vqs for this port */
+        struct virtqueue *in_vq, *out_vq;
+
+        /* File in the debugfs directory that exposes this port's information */
+        struct dentry *debugfs_file;
+
+        /*
+         * The entries in this struct will be valid if this port is
+         * hooked up to an hvc console
+         */
+        struct console cons;
+
+        /* Each port associates with a separate char device */
+        struct cdev cdev;
+        struct device *dev;
+
+        /* A waitqueue for poll() or blocking read operations */
+        wait_queue_head_t waitqueue;
+
+        /* The 'name' of the port that we expose via sysfs properties */
+        char *name;
+
+        /* The 'id' to identify the port with the Host */
+        u32 id;
+
+        /* Is the host device open */
+        bool host_connected;
+
+        /* We should allow only one process to open a port */
+        bool guest_connected;
+};
+
+/* This is the very early arch-specified put chars function. */
+static int (*early_put_chars)(u32, const char *, int);
+
+static struct port *find_port_by_vtermno(u32 vtermno)
+{
+        struct port *port;
+        struct console *cons;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pdrvdata_lock, flags);
+        list_for_each_entry(cons, &pdrvdata.consoles, list) {
+                if (cons->vtermno == vtermno) {
+                        port = container_of(cons, struct port, cons);
+                        goto out;
+                }
+        }
+        port = NULL;
+out:
+        spin_unlock_irqrestore(&pdrvdata_lock, flags);
+        return port;
+}
+
+static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
+{
+        struct port *port;
+        unsigned long flags;
+
+        spin_lock_irqsave(&portdev->ports_lock, flags);
+        list_for_each_entry(port, &portdev->ports, list)
+                if (port->id == id)
+                        goto out;
+        port = NULL;
+out:
+        spin_unlock_irqrestore(&portdev->ports_lock, flags);
+
+        return port;
+}
+
+static struct port *find_port_by_vq(struct ports_device *portdev,
+                                    struct virtqueue *vq)
+{
+        struct port *port;
+        unsigned long flags;
+
+        spin_lock_irqsave(&portdev->ports_lock, flags);
+        list_for_each_entry(port, &portdev->ports, list)
+                if (port->in_vq == vq || port->out_vq == vq)
+                        goto out;
+        port = NULL;
+out:
+        spin_unlock_irqrestore(&portdev->ports_lock, flags);
+        return port;
+}
+
+static bool is_console_port(struct port *port)
+{
+        if (port->cons.hvc)
+                return true;
+        return false;
+}
+
+static inline bool use_multiport(struct ports_device *portdev)
+{
+        /*
+         * This condition can be true when put_chars is called from
+         * early_init
+         */
+        if (!portdev->vdev)
+                return 0;
+        return portdev->vdev->features[0] & (1 << VIRTIO_CONSOLE_F_MULTIPORT);
+}
 
-/* This is our input buffer, and how much data is left in it. */
-static unsigned int in_len;
-static char *in, *inbuf;
+static void free_buf(struct port_buffer *buf)
+{
+        kfree(buf->buf);
+        kfree(buf);
+}
+
+static struct port_buffer *alloc_buf(size_t buf_size)
+{
+        struct port_buffer *buf;
 
-/* The operations for our console. */
-static struct hv_ops virtio_cons;
+        buf = kmalloc(sizeof(*buf), GFP_KERNEL);
+        if (!buf)
+                goto fail;
+        buf->buf = kzalloc(buf_size, GFP_KERNEL);
+        if (!buf->buf)
+                goto free_buf;
+        buf->len = 0;
+        buf->offset = 0;
+        buf->size = buf_size;
+        return buf;
+
+free_buf:
+        kfree(buf);
+fail:
+        return NULL;
+}
+
+/* Callers should take appropriate locks */
+static void *get_inbuf(struct port *port)
+{
+        struct port_buffer *buf;
+        struct virtqueue *vq;
+        unsigned int len;
 
-/* The hvc device */
-static struct hvc_struct *hvc;
+        vq = port->in_vq;
+        buf = vq->vq_ops->get_buf(vq, &len);
+        if (buf) {
+                buf->len = len;
+                buf->offset = 0;
+        }
+        return buf;
+}
 
-/*D:310 The put_chars() callback is pretty straightforward.
+/*
+ * Create a scatter-gather list representing our input buffer and put
+ * it in the queue.
  *
- * We turn the characters into a scatter-gather list, add it to the output
- * queue and then kick the Host.  Then we sit here waiting for it to finish:
- * inefficient in theory, but in practice implementations will do it
- * immediately (lguest's Launcher does). */
-static int put_chars(u32 vtermno, const char *buf, int count)
+ * Callers should take appropriate locks.
+ */
+static int add_inbuf(struct virtqueue *vq, struct port_buffer *buf)
 {
         struct scatterlist sg[1];
+        int ret;
+
+        sg_init_one(sg, buf->buf, buf->size);
+
+        ret = vq->vq_ops->add_buf(vq, sg, 0, 1, buf);
+        vq->vq_ops->kick(vq);
+        return ret;
+}
+
+/* Discard any unread data this port has. Callers lockers. */
+static void discard_port_data(struct port *port)
+{
+        struct port_buffer *buf;
+        struct virtqueue *vq;
         unsigned int len;
+        int ret;
 
-        /* This is a convenient routine to initialize a single-elem sg list */
-        sg_init_one(sg, buf, count);
+        vq = port->in_vq;
+        if (port->inbuf)
+                buf = port->inbuf;
+        else
+                buf = vq->vq_ops->get_buf(vq, &len);
 
-        /* add_buf wants a token to identify this buffer: we hand it any
-         * non-NULL pointer, since there's only ever one buffer. */
-        if (out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, (void *)1) >= 0) {
-                /* Tell Host to go! */
-                out_vq->vq_ops->kick(out_vq);
-                /* Chill out until it's done with the buffer. */
-                while (!out_vq->vq_ops->get_buf(out_vq, &len))
-                        cpu_relax();
+        ret = 0;
+        while (buf) {
+                if (add_inbuf(vq, buf) < 0) {
+                        ret++;
+                        free_buf(buf);
+                }
+                buf = vq->vq_ops->get_buf(vq, &len);
         }
+        port->inbuf = NULL;
+        if (ret)
+                dev_warn(port->dev, "Errors adding %d buffers back to vq\n",
+                         ret);
+}
 
-        /* We're expected to return the amount of data we wrote: all of it. */
-        return count;
+static bool port_has_data(struct port *port)
+{
+        unsigned long flags;
+        bool ret;
+
+        spin_lock_irqsave(&port->inbuf_lock, flags);
+        if (port->inbuf) {
+                ret = true;
+                goto out;
+        }
+        port->inbuf = get_inbuf(port);
+        if (port->inbuf) {
+                ret = true;
+                goto out;
+        }
+        ret = false;
+out:
+        spin_unlock_irqrestore(&port->inbuf_lock, flags);
+        return ret;
 }
 
-/* Create a scatter-gather list representing our input buffer and put it in the
- * queue. */
-static void add_inbuf(void)
+static ssize_t send_control_msg(struct port *port, unsigned int event,
+                                unsigned int value)
 {
         struct scatterlist sg[1];
-        sg_init_one(sg, inbuf, PAGE_SIZE);
+        struct virtio_console_control cpkt;
+        struct virtqueue *vq;
+        int len;
+
+        if (!use_multiport(port->portdev))
+                return 0;
+
+        cpkt.id = port->id;
+        cpkt.event = event;
+        cpkt.value = value;
+
+        vq = port->portdev->c_ovq;
 
-        /* We should always be able to add one buffer to an empty queue. */
-        if (in_vq->vq_ops->add_buf(in_vq, sg, 0, 1, inbuf) < 0)
-                BUG();
-        in_vq->vq_ops->kick(in_vq);
+        sg_init_one(sg, &cpkt, sizeof(cpkt));
+        if (vq->vq_ops->add_buf(vq, sg, 1, 0, &cpkt) >= 0) {
+                vq->vq_ops->kick(vq);
+                while (!vq->vq_ops->get_buf(vq, &len))
+                        cpu_relax();
+        }
+        return 0;
 }
 
-/*D:350 get_chars() is the callback from the hvc_console infrastructure when
- * an interrupt is received.
- *
- * Most of the code deals with the fact that the hvc_console() infrastructure
- * only asks us for 16 bytes at a time.  We keep in_offset and in_used fields
- * for partially-filled buffers. */
-static int get_chars(u32 vtermno, char *buf, int count)
+static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count)
 {
-        /* If we don't have an input queue yet, we can't get input. */
-        BUG_ON(!in_vq);
+        struct scatterlist sg[1];
+        struct virtqueue *out_vq;
+        ssize_t ret;
+        unsigned int len;
+
+        out_vq = port->out_vq;
+
+        sg_init_one(sg, in_buf, in_count);
+        ret = out_vq->vq_ops->add_buf(out_vq, sg, 1, 0, in_buf);
+
+        /* Tell Host to go! */
+        out_vq->vq_ops->kick(out_vq);
+
+        if (ret < 0) {
+                len = 0;
+                goto fail;
+        }
+
+        /*
+         * Wait till the host acknowledges it pushed out the data we
+         * sent. Also ensure we return to userspace the number of
+         * bytes that were successfully consumed by the host.
+         */
+        while (!out_vq->vq_ops->get_buf(out_vq, &len))
+                cpu_relax();
+fail:
+        /* We're expected to return the amount of data we wrote */
+        return len;
+}
+
+/*
+ * Give out the data that's requested from the buffer that we have
+ * queued up.
+ */
+static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
+                            bool to_user)
+{
+        struct port_buffer *buf;
+        unsigned long flags;
+
+        if (!out_count || !port_has_data(port))
+                return 0;
+
+        buf = port->inbuf;
+        out_count = min(out_count, buf->len - buf->offset);
+
+        if (to_user) {
+                ssize_t ret;
+
+                ret = copy_to_user(out_buf, buf->buf + buf->offset, out_count);
+                if (ret)
+                        return -EFAULT;
+        } else {
+                memcpy(out_buf, buf->buf + buf->offset, out_count);
+        }
+
+        buf->offset += out_count;
+
+        if (buf->offset == buf->len) {
+                /*
+                 * We're done using all the data in this buffer.
+                 * Re-queue so that the Host can send us more data.
+                 */
+                spin_lock_irqsave(&port->inbuf_lock, flags);
+                port->inbuf = NULL;
+
+                if (add_inbuf(port->in_vq, buf) < 0)
+                        dev_warn(port->dev, "failed add_buf\n");
+
+                spin_unlock_irqrestore(&port->inbuf_lock, flags);
+        }
+        /* Return the number of bytes actually copied */
+        return out_count;
+}
 
-        /* No buffer?  Try to get one. */
-        if (!in_len) {
-                in = in_vq->vq_ops->get_buf(in_vq, &in_len);
-                if (!in)
+/* The condition that must be true for polling to end */
+static bool wait_is_over(struct port *port)
+{
+        return port_has_data(port) || !port->host_connected;
+}
+
+static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
+                              size_t count, loff_t *offp)
+{
+        struct port *port;
+        ssize_t ret;
+
+        port = filp->private_data;
+
+        if (!port_has_data(port)) {
+                /*
+                 * If nothing's connected on the host just return 0 in
+                 * case of list_empty; this tells the userspace app
+                 * that there's no connection
+                 */
+                if (!port->host_connected)
                         return 0;
+                if (filp->f_flags & O_NONBLOCK)
+                        return -EAGAIN;
+
+                ret = wait_event_interruptible(port->waitqueue,
+                                               wait_is_over(port));
+                if (ret < 0)
+                        return ret;
+        }
+        /*
+         * We could've received a disconnection message while we were
+         * waiting for more data.
+         *
+         * This check is not clubbed in the if() statement above as we
+         * might receive some data as well as the host could get
+         * disconnected after we got woken up from our wait.  So we
+         * really want to give off whatever data we have and only then
+         * check for host_connected.
+         */
+        if (!port_has_data(port) && !port->host_connected)
+                return 0;
+
+        return fill_readbuf(port, ubuf, count, true);
+}
+
+static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
+                               size_t count, loff_t *offp)
+{
+        struct port *port;
+        char *buf;
+        ssize_t ret;
+
+        port = filp->private_data;
+
+        count = min((size_t)(32 * 1024), count);
+
+        buf = kmalloc(count, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        ret = copy_from_user(buf, ubuf, count);
+        if (ret) {
+                ret = -EFAULT;
+                goto free_buf;
         }
 
-        /* You want more than we have to give?  Well, try wanting less! */
-        if (in_len < count)
-                count = in_len;
+        ret = send_buf(port, buf, count);
+free_buf:
+        kfree(buf);
+        return ret;
+}
+
+static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
+{
+        struct port *port;
+        unsigned int ret;
+
+        port = filp->private_data;
+        poll_wait(filp, &port->waitqueue, wait);
+
+        ret = 0;
+        if (port->inbuf)
+                ret |= POLLIN | POLLRDNORM;
+        if (port->host_connected)
+                ret |= POLLOUT;
+        if (!port->host_connected)
+                ret |= POLLHUP;
+
+        return ret;
+}
+
+static int port_fops_release(struct inode *inode, struct file *filp)
+{
+        struct port *port;
+
+        port = filp->private_data;
+
+        /* Notify host of port being closed */
+        send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
+
+        spin_lock_irq(&port->inbuf_lock);
+        port->guest_connected = false;
+
+        discard_port_data(port);
+
+        spin_unlock_irq(&port->inbuf_lock);
+
+        return 0;
+}
+
+static int port_fops_open(struct inode *inode, struct file *filp)
+{
+        struct cdev *cdev = inode->i_cdev;
+        struct port *port;
+
+        port = container_of(cdev, struct port, cdev);
+        filp->private_data = port;
+
+        /*
+         * Don't allow opening of console port devices -- that's done
+         * via /dev/hvc
+         */
+        if (is_console_port(port))
+                return -ENXIO;
+
+        /* Allow only one process to open a particular port at a time */
+        spin_lock_irq(&port->inbuf_lock);
+        if (port->guest_connected) {
+                spin_unlock_irq(&port->inbuf_lock);
+                return -EMFILE;
+        }
 
-        /* Copy across to their buffer and increment offset. */
-        memcpy(buf, in, count);
-        in += count;
-        in_len -= count;
+        port->guest_connected = true;
+        spin_unlock_irq(&port->inbuf_lock);
 
-        /* Finished?  Re-register buffer so Host will use it again. */
-        if (in_len == 0)
-                add_inbuf();
+        /* Notify host of port being opened */
+        send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
 
-        return count;
+        return 0;
 }
-/*:*/
 
-/*D:320 Console drivers are initialized very early so boot messages can go out,
- * so we do things slightly differently from the generic virtio initialization
- * of the net and block drivers.
+/*
+ * The file operations that we support: programs in the guest can open
+ * a console device, read from it, write to it, poll for data and
+ * close it.  The devices are at
+ *   /dev/vport<device number>p<port number>
+ */
+static const struct file_operations port_fops = {
+        .owner = THIS_MODULE,
+        .open  = port_fops_open,
+        .read  = port_fops_read,
+        .write = port_fops_write,
+        .poll  = port_fops_poll,
+        .release = port_fops_release,
+};
+
+/*
+ * The put_chars() callback is pretty straightforward.
  *
- * At this stage, the console is output-only.  It's too early to set up a
- * virtqueue, so we let the drivers do some boutique early-output thing. */
-int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
+ * We turn the characters into a scatter-gather list, add it to the
+ * output queue and then kick the Host.  Then we sit here waiting for
+ * it to finish: inefficient in theory, but in practice
+ * implementations will do it immediately (lguest's Launcher does).
+ */
+static int put_chars(u32 vtermno, const char *buf, int count)
 {
-        virtio_cons.put_chars = put_chars;
-        return hvc_instantiate(0, 0, &virtio_cons);
+        struct port *port;
+
+        port = find_port_by_vtermno(vtermno);
+        if (!port)
+                return 0;
+
+        if (unlikely(early_put_chars))
+                return early_put_chars(vtermno, buf, count);
+
+        return send_buf(port, (void *)buf, count);
 }
 
 /*
- * virtio console configuration. This supports:
- * - console resize
+ * get_chars() is the callback from the hvc_console infrastructure
+ * when an interrupt is received.
+ *
+ * We call out to fill_readbuf that gets us the required data from the
+ * buffers that are queued up.
  */
-static void virtcons_apply_config(struct virtio_device *dev)
+static int get_chars(u32 vtermno, char *buf, int count)
 {
+        struct port *port;
+
+        port = find_port_by_vtermno(vtermno);
+        if (!port)
+                return 0;
+
+        /* If we don't have an input queue yet, we can't get input. */
+        BUG_ON(!port->in_vq);
+
+        return fill_readbuf(port, buf, count, false);
+}
+
+static void resize_console(struct port *port)
+{
+        struct virtio_device *vdev;
         struct winsize ws;
 
-        if (virtio_has_feature(dev, VIRTIO_CONSOLE_F_SIZE)) {
-                dev->config->get(dev,
-                                 offsetof(struct virtio_console_config, cols),
-                                 &ws.ws_col, sizeof(u16));
-                dev->config->get(dev,
-                                 offsetof(struct virtio_console_config, rows),
-                                 &ws.ws_row, sizeof(u16));
-                hvc_resize(hvc, ws);
+        vdev = port->portdev->vdev;
+        if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_SIZE)) {
+                vdev->config->get(vdev,
+                                  offsetof(struct virtio_console_config, cols),
+                                  &ws.ws_col, sizeof(u16));
+                vdev->config->get(vdev,
+                                  offsetof(struct virtio_console_config, rows),
+                                  &ws.ws_row, sizeof(u16));
+                hvc_resize(port->cons.hvc, ws);
         }
 }
 
-/*
- * we support only one console, the hvc struct is a global var
- * We set the configuration at this point, since we now have a tty
- */
+/* We set the configuration at this point, since we now have a tty */
 static int notifier_add_vio(struct hvc_struct *hp, int data)
 {
+        struct port *port;
+
+        port = find_port_by_vtermno(hp->vtermno);
+        if (!port)
+                return -EINVAL;
+
         hp->irq_requested = 1;
-        virtcons_apply_config(vdev);
+        resize_console(port);
 
         return 0;
 }
@@ -173,79 +713,797 @@ static void notifier_del_vio(struct hvc_struct *hp, int data)
         hp->irq_requested = 0;
 }
 
-static void hvc_handle_input(struct virtqueue *vq)
+/* The operations for console ports. */
+static const struct hv_ops hv_ops = {
+        .get_chars = get_chars,
+        .put_chars = put_chars,
+        .notifier_add = notifier_add_vio,
+        .notifier_del = notifier_del_vio,
+        .notifier_hangup = notifier_del_vio,
+};
+
+/*
+ * Console drivers are initialized very early so boot messages can go
+ * out, so we do things slightly differently from the generic virtio
+ * initialization of the net and block drivers.
+ *
+ * At this stage, the console is output-only.  It's too early to set
+ * up a virtqueue, so we let the drivers do some boutique early-output
+ * thing.
+ */
+int __init virtio_cons_early_init(int (*put_chars)(u32, const char *, int))
 {
-        if (hvc_poll(hvc))
+        early_put_chars = put_chars;
+        return hvc_instantiate(0, 0, &hv_ops);
+}
+
+int init_port_console(struct port *port)
+{
+        int ret;
+
+        /*
+         * The Host's telling us this port is a console port.  Hook it
+         * up with an hvc console.
+         *
+         * To set up and manage our virtual console, we call
+         * hvc_alloc().
+         *
+         * The first argument of hvc_alloc() is the virtual console
+         * number.  The second argument is the parameter for the
+         * notification mechanism (like irq number).  We currently
+         * leave this as zero, virtqueues have implicit notifications.
+         *
+         * The third argument is a "struct hv_ops" containing the
+         * put_chars() get_chars(), notifier_add() and notifier_del()
+         * pointers.  The final argument is the output buffer size: we
+         * can do any size, so we put PAGE_SIZE here.
+         */
+        port->cons.vtermno = pdrvdata.next_vtermno;
+
+        port->cons.hvc = hvc_alloc(port->cons.vtermno, 0, &hv_ops, PAGE_SIZE);
+        if (IS_ERR(port->cons.hvc)) {
+                ret = PTR_ERR(port->cons.hvc);
+                dev_err(port->dev,
+                        "error %d allocating hvc for port\n", ret);
+                port->cons.hvc = NULL;
+                return ret;
+        }
+        spin_lock_irq(&pdrvdata_lock);
+        pdrvdata.next_vtermno++;
+        list_add_tail(&port->cons.list, &pdrvdata.consoles);
+        spin_unlock_irq(&pdrvdata_lock);
+        port->guest_connected = true;
+
+        /* Notify host of port being opened */
+        send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 1);
+
+        return 0;
+}
+
+static ssize_t show_port_name(struct device *dev,
+                              struct device_attribute *attr, char *buffer)
+{
+        struct port *port;
+
+        port = dev_get_drvdata(dev);
+
+        return sprintf(buffer, "%s\n", port->name);
+}
+
+static DEVICE_ATTR(name, S_IRUGO, show_port_name, NULL);
+
+static struct attribute *port_sysfs_entries[] = {
+        &dev_attr_name.attr,
+        NULL
+};
+
+static struct attribute_group port_attribute_group = {
+        .name = NULL,           /* put in device directory */
+        .attrs = port_sysfs_entries,
+};
+
+static int debugfs_open(struct inode *inode, struct file *filp)
+{
+        filp->private_data = inode->i_private;
+        return 0;
+}
+
+static ssize_t debugfs_read(struct file *filp, char __user *ubuf,
+                            size_t count, loff_t *offp)
+{
+        struct port *port;
+        char *buf;
+        ssize_t ret, out_offset, out_count;
+
+        out_count = 1024;
+        buf = kmalloc(out_count, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        port = filp->private_data;
+        out_offset = 0;
+        out_offset += snprintf(buf + out_offset, out_count,
+                               "name: %s\n", port->name ? port->name : "");
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "guest_connected: %d\n", port->guest_connected);
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "host_connected: %d\n", port->host_connected);
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "is_console: %s\n",
+                               is_console_port(port) ? "yes" : "no");
+        out_offset += snprintf(buf + out_offset, out_count - out_offset,
+                               "console_vtermno: %u\n", port->cons.vtermno);
+
+        ret = simple_read_from_buffer(ubuf, count, offp, buf, out_offset);
+        kfree(buf);
+        return ret;
+}
+
+static const struct file_operations port_debugfs_ops = {
+        .owner = THIS_MODULE,
+        .open  = debugfs_open,
+        .read  = debugfs_read,
+};
+
+/* Remove all port-specific data. */
+static int remove_port(struct port *port)
+{
+        struct port_buffer *buf;
+
+        spin_lock_irq(&port->portdev->ports_lock);
+        list_del(&port->list);
+        spin_unlock_irq(&port->portdev->ports_lock);
+
+        if (is_console_port(port)) {
+                spin_lock_irq(&pdrvdata_lock);
+                list_del(&port->cons.list);
+                spin_unlock_irq(&pdrvdata_lock);
+                hvc_remove(port->cons.hvc);
+        }
+        if (port->guest_connected)
+                send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
+
+        sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
+        device_destroy(pdrvdata.class, port->dev->devt);
+        cdev_del(&port->cdev);
+
+        /* Remove unused data this port might have received. */
+        discard_port_data(port);
+
+        /* Remove buffers we queued up for the Host to send us data in. */
+        while ((buf = port->in_vq->vq_ops->detach_unused_buf(port->in_vq)))
+                free_buf(buf);
+
+        kfree(port->name);
+
+        debugfs_remove(port->debugfs_file);
+
+        kfree(port);
+        return 0;
+}
+
+/* Any private messages that the Host and Guest want to share */
+static void handle_control_message(struct ports_device *portdev,
+                                   struct port_buffer *buf)
+{
+        struct virtio_console_control *cpkt;
+        struct port *port;
+        size_t name_size;
+        int err;
+
+        cpkt = (struct virtio_console_control *)(buf->buf + buf->offset);
+
+        port = find_port_by_id(portdev, cpkt->id);
+        if (!port) {
+                /* No valid header at start of buffer.  Drop it. */
+                dev_dbg(&portdev->vdev->dev,
+                        "Invalid index %u in control packet\n", cpkt->id);
+                return;
+        }
+
+        switch (cpkt->event) {
+        case VIRTIO_CONSOLE_CONSOLE_PORT:
+                if (!cpkt->value)
+                        break;
+                if (is_console_port(port))
+                        break;
+
+                init_port_console(port);
+                /*
+                 * Could remove the port here in case init fails - but
+                 * have to notify the host first.
+                 */
+                break;
+        case VIRTIO_CONSOLE_RESIZE:
+                if (!is_console_port(port))
+                        break;
+                port->cons.hvc->irq_requested = 1;
+                resize_console(port);
+                break;
+        case VIRTIO_CONSOLE_PORT_OPEN:
+                port->host_connected = cpkt->value;
+                wake_up_interruptible(&port->waitqueue);
+                break;
+        case VIRTIO_CONSOLE_PORT_NAME:
+                /*
+                 * Skip the size of the header and the cpkt to get the size
+                 * of the name that was sent
+                 */
+                name_size = buf->len - buf->offset - sizeof(*cpkt) + 1;
+
+                port->name = kmalloc(name_size, GFP_KERNEL);
+                if (!port->name) {
+                        dev_err(port->dev,
+                                "Not enough space to store port name\n");
+                        break;
+                }
+                strncpy(port->name, buf->buf + buf->offset + sizeof(*cpkt),
+                        name_size - 1);
+                port->name[name_size - 1] = 0;
+
+                /*
+                 * Since we only have one sysfs attribute, 'name',
+                 * create it only if we have a name for the port.
+                 */
+                err = sysfs_create_group(&port->dev->kobj,
+                                         &port_attribute_group);
+                if (err)
+                        dev_err(port->dev,
+                                "Error %d creating sysfs device attributes\n",
+                                err);
+
+                break;
+        case VIRTIO_CONSOLE_PORT_REMOVE:
+                /*
+                 * Hot unplug the port.  We don't decrement nr_ports
+                 * since we don't want to deal with extra complexities
+                 * of using the lowest-available port id: We can just
+                 * pick up the nr_ports number as the id and not have
+                 * userspace send it to us.  This helps us in two
+                 * ways:
+                 *
+                 * - We don't need to have a 'port_id' field in the
+                 *   config space when a port is hot-added.  This is a
+                 *   good thing as we might queue up multiple hotplug
+                 *   requests issued in our workqueue.
+                 *
+                 * - Another way to deal with this would have been to
+                 *   use a bitmap of the active ports and select the
+                 *   lowest non-active port from that map.  That
+                 *   bloats the already tight config space and we
+                 *   would end up artificially limiting the
+                 *   max. number of ports to sizeof(bitmap).  Right
+                 *   now we can support 2^32 ports (as the port id is
+                 *   stored in a u32 type).
+                 *
+                 */
+                remove_port(port);
+                break;
+        }
+}
+
+static void control_work_handler(struct work_struct *work)
+{
+        struct ports_device *portdev;
+        struct virtqueue *vq;
+        struct port_buffer *buf;
+        unsigned int len;
+
+        portdev = container_of(work, struct ports_device, control_work);
+        vq = portdev->c_ivq;
+
+        spin_lock(&portdev->cvq_lock);
+        while ((buf = vq->vq_ops->get_buf(vq, &len))) {
+                spin_unlock(&portdev->cvq_lock);
+
+                buf->len = len;
+                buf->offset = 0;
+
+                handle_control_message(portdev, buf);
+
+                spin_lock(&portdev->cvq_lock);
+                if (add_inbuf(portdev->c_ivq, buf) < 0) {
+                        dev_warn(&portdev->vdev->dev,
+                                 "Error adding buffer to queue\n");
+                        free_buf(buf);
+                }
+        }
+        spin_unlock(&portdev->cvq_lock);
+}
+
+static void in_intr(struct virtqueue *vq)
+{
+        struct port *port;
+        unsigned long flags;
+
+        port = find_port_by_vq(vq->vdev->priv, vq);
+        if (!port)
+                return;
+
+        spin_lock_irqsave(&port->inbuf_lock, flags);
+        if (!port->inbuf)
+                port->inbuf = get_inbuf(port);
+
+        /*
+         * Don't queue up data when port is closed.  This condition
+         * can be reached when a console port is not yet connected (no
+         * tty is spawned) and the host sends out data to console
+         * ports.  For generic serial ports, the host won't
+         * (shouldn't) send data till the guest is connected.
+         */
+        if (!port->guest_connected)
+                discard_port_data(port);
+
+        spin_unlock_irqrestore(&port->inbuf_lock, flags);
+
+        wake_up_interruptible(&port->waitqueue);
+
+        if (is_console_port(port) && hvc_poll(port->cons.hvc))
                 hvc_kick();
 }
 
-/*D:370 Once we're further in boot, we get probed like any other virtio device.
- * At this stage we set up the output virtqueue.
- *
- * To set up and manage our virtual console, we call hvc_alloc().  Since we
- * never remove the console device we never need this pointer again.
+static void control_intr(struct virtqueue *vq)
+{
+        struct ports_device *portdev;
+
+        portdev = vq->vdev->priv;
+        schedule_work(&portdev->control_work);
+}
+
+static void config_intr(struct virtio_device *vdev)
+{
+        struct ports_device *portdev;
+
+        portdev = vdev->priv;
+        if (use_multiport(portdev)) {
+                /* Handle port hot-add */
+                schedule_work(&portdev->config_work);
+        }
+        /*
+         * We'll use this way of resizing only for legacy support.
+         * For newer userspace (VIRTIO_CONSOLE_F_MULTPORT+), use
+         * control messages to indicate console size changes so that
+         * it can be done per-port
+         */
+        resize_console(find_port_by_id(portdev, 0));
+}
+
+static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
+{
+        struct port_buffer *buf;
+        unsigned int ret;
+        int err;
+
+        ret = 0;
+        do {
+                buf = alloc_buf(PAGE_SIZE);
+                if (!buf)
+                        break;
+
+                spin_lock_irq(lock);
+                err = add_inbuf(vq, buf);
+                if (err < 0) {
+                        spin_unlock_irq(lock);
+                        free_buf(buf);
+                        break;
+                }
+                ret++;
+                spin_unlock_irq(lock);
+        } while (err > 0);
+
+        return ret;
+}
+
+static int add_port(struct ports_device *portdev, u32 id)
+{
+        char debugfs_name[16];
+        struct port *port;
+        struct port_buffer *buf;
+        dev_t devt;
+        int err;
+
+        port = kmalloc(sizeof(*port), GFP_KERNEL);
+        if (!port) {
+                err = -ENOMEM;
+                goto fail;
+        }
+
+        port->portdev = portdev;
+        port->id = id;
+
+        port->name = NULL;
+        port->inbuf = NULL;
+        port->cons.hvc = NULL;
+
+        port->host_connected = port->guest_connected = false;
+
+        port->in_vq = portdev->in_vqs[port->id];
+        port->out_vq = portdev->out_vqs[port->id];
+
+        cdev_init(&port->cdev, &port_fops);
+
+        devt = MKDEV(portdev->chr_major, id);
+        err = cdev_add(&port->cdev, devt, 1);
+        if (err < 0) {
+                dev_err(&port->portdev->vdev->dev,
+                        "Error %d adding cdev for port %u\n", err, id);
+                goto free_port;
+        }
+        port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
+                                  devt, port, "vport%up%u",
+                                  port->portdev->drv_index, id);
+        if (IS_ERR(port->dev)) {
+                err = PTR_ERR(port->dev);
+                dev_err(&port->portdev->vdev->dev,
+                        "Error %d creating device for port %u\n",
+                        err, id);
+                goto free_cdev;
+        }
+
+        spin_lock_init(&port->inbuf_lock);
+        init_waitqueue_head(&port->waitqueue);
+
+        /* Fill the in_vq with buffers so the host can send us data. */
+        err = fill_queue(port->in_vq, &port->inbuf_lock);
+        if (!err) {
+                dev_err(port->dev, "Error allocating inbufs\n");
+                err = -ENOMEM;
+                goto free_device;
+        }
+
+        /*
+         * If we're not using multiport support, this has to be a console port
+         */
+        if (!use_multiport(port->portdev)) {
+                err = init_port_console(port);
+                if (err)
+                        goto free_inbufs;
+        }
+
+        spin_lock_irq(&portdev->ports_lock);
+        list_add_tail(&port->list, &port->portdev->ports);
+        spin_unlock_irq(&portdev->ports_lock);
+
+        /*
+         * Tell the Host we're set so that it can send us various
+         * configuration parameters for this port (eg, port name,
+         * caching, whether this is a console port, etc.)
+         */
+        send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
+
+        if (pdrvdata.debugfs_dir) {
+                /*
+                 * Finally, create the debugfs file that we can use to
+                 * inspect a port's state at any time
+                 */
+                sprintf(debugfs_name, "vport%up%u",
+                        port->portdev->drv_index, id);
+                port->debugfs_file = debugfs_create_file(debugfs_name, 0444,
+                                                         pdrvdata.debugfs_dir,
+                                                         port,
+                                                         &port_debugfs_ops);
+        }
+        return 0;
+
+free_inbufs:
+        while ((buf = port->in_vq->vq_ops->detach_unused_buf(port->in_vq)))
+                free_buf(buf);
+free_device:
+        device_destroy(pdrvdata.class, port->dev->devt);
+free_cdev:
+        cdev_del(&port->cdev);
+free_port:
+        kfree(port);
+fail:
+        return err;
+}
+
+/*
+ * The workhandler for config-space updates.
  *
- * Finally we put our input buffer in the input queue, ready to receive. */
-static int __devinit virtcons_probe(struct virtio_device *dev)
+ * This is called when ports are hot-added.
+ */
+static void config_work_handler(struct work_struct *work)
+{
+        struct virtio_console_config virtconconf;
+        struct ports_device *portdev;
+        struct virtio_device *vdev;
+        int err;
+
+        portdev = container_of(work, struct ports_device, config_work);
+
+        vdev = portdev->vdev;
+        vdev->config->get(vdev,
+                          offsetof(struct virtio_console_config, nr_ports),
+                          &virtconconf.nr_ports,
+                          sizeof(virtconconf.nr_ports));
+
+        if (portdev->config.nr_ports == virtconconf.nr_ports) {
+                /*
+                 * Port 0 got hot-added.  Since we already did all the
+                 * other initialisation for it, just tell the Host
+                 * that the port is ready if we find the port.  In
+                 * case the port was hot-removed earlier, we call
+                 * add_port to add the port.
+                 */
+                struct port *port;
+
+                port = find_port_by_id(portdev, 0);
+                if (!port)
+                        add_port(portdev, 0);
+                else
+                        send_control_msg(port, VIRTIO_CONSOLE_PORT_READY, 1);
+                return;
+        }
+        if (virtconconf.nr_ports > portdev->config.max_nr_ports) {
+                dev_warn(&vdev->dev,
+                         "More ports specified (%u) than allowed (%u)",
+                         portdev->config.nr_ports + 1,
+                         portdev->config.max_nr_ports);
+                return;
+        }
+        if (virtconconf.nr_ports < portdev->config.nr_ports)
+                return;
+
+        /* Hot-add ports */
+        while (virtconconf.nr_ports - portdev->config.nr_ports) {
+                err = add_port(portdev, portdev->config.nr_ports);
+                if (err)
+                        break;
+                portdev->config.nr_ports++;
+        }
+}
+
+static int init_vqs(struct ports_device *portdev)
 {
-        vq_callback_t *callbacks[] = { hvc_handle_input, NULL};
-        const char *names[] = { "input", "output" };
-        struct virtqueue *vqs[2];
+        vq_callback_t **io_callbacks;
+        char **io_names;
+        struct virtqueue **vqs;
+        u32 i, j, nr_ports, nr_queues;
         int err;
 
-        vdev = dev;
+        nr_ports = portdev->config.max_nr_ports;
+        nr_queues = use_multiport(portdev) ? (nr_ports + 1) * 2 : 2;
 
-        /* This is the scratch page we use to receive console input */
-        inbuf = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!inbuf) {
+        vqs = kmalloc(nr_queues * sizeof(struct virtqueue *), GFP_KERNEL);
+        if (!vqs) {
                 err = -ENOMEM;
                 goto fail;
         }
+        io_callbacks = kmalloc(nr_queues * sizeof(vq_callback_t *), GFP_KERNEL);
+        if (!io_callbacks) {
+                err = -ENOMEM;
+                goto free_vqs;
+        }
+        io_names = kmalloc(nr_queues * sizeof(char *), GFP_KERNEL);
+        if (!io_names) {
+                err = -ENOMEM;
+                goto free_callbacks;
+        }
+        portdev->in_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
+                                  GFP_KERNEL);
+        if (!portdev->in_vqs) {
+                err = -ENOMEM;
+                goto free_names;
+        }
+        portdev->out_vqs = kmalloc(nr_ports * sizeof(struct virtqueue *),
+                                   GFP_KERNEL);
+        if (!portdev->out_vqs) {
+                err = -ENOMEM;
+                goto free_invqs;
+        }
+
+        /*
+         * For backward compat (newer host but older guest), the host
+         * spawns a console port first and also inits the vqs for port
+         * 0 before others.
+         */
+        j = 0;
+        io_callbacks[j] = in_intr;
+        io_callbacks[j + 1] = NULL;
+        io_names[j] = "input";
+        io_names[j + 1] = "output";
+        j += 2;
 
+        if (use_multiport(portdev)) {
+                io_callbacks[j] = control_intr;
+                io_callbacks[j + 1] = NULL;
+                io_names[j] = "control-i";
+                io_names[j + 1] = "control-o";
+
+                for (i = 1; i < nr_ports; i++) {
+                        j += 2;
+                        io_callbacks[j] = in_intr;
+                        io_callbacks[j + 1] = NULL;
+                        io_names[j] = "input";
+                        io_names[j + 1] = "output";
+                }
+        }
         /* Find the queues. */
-        /* FIXME: This is why we want to wean off hvc: we do nothing
-         * when input comes in. */
-        err = vdev->config->find_vqs(vdev, 2, vqs, callbacks, names);
+        err = portdev->vdev->config->find_vqs(portdev->vdev, nr_queues, vqs,
+                                              io_callbacks,
+                                              (const char **)io_names);
         if (err)
+                goto free_outvqs;
+
+        j = 0;
+        portdev->in_vqs[0] = vqs[0];
+        portdev->out_vqs[0] = vqs[1];
+        j += 2;
+        if (use_multiport(portdev)) {
+                portdev->c_ivq = vqs[j];
+                portdev->c_ovq = vqs[j + 1];
+
+                for (i = 1; i < nr_ports; i++) {
+                        j += 2;
+                        portdev->in_vqs[i] = vqs[j];
+                        portdev->out_vqs[i] = vqs[j + 1];
+                }
+        }
+        kfree(io_callbacks);
+        kfree(io_names);
+        kfree(vqs);
+
+        return 0;
+
+free_names:
+        kfree(io_names);
+free_callbacks:
+        kfree(io_callbacks);
+free_outvqs:
+        kfree(portdev->out_vqs);
+free_invqs:
+        kfree(portdev->in_vqs);
+free_vqs:
+        kfree(vqs);
+fail:
+        return err;
+}
+
+static const struct file_operations portdev_fops = {
+        .owner = THIS_MODULE,
+};
+
+/*
+ * Once we're further in boot, we get probed like any other virtio
+ * device.
+ *
+ * If the host also supports multiple console ports, we check the
+ * config space to see how many ports the host has spawned.  We
+ * initialize each port found.
+ */
+static int __devinit virtcons_probe(struct virtio_device *vdev)
+{
+        struct ports_device *portdev;
+        u32 i;
+        int err;
+        bool multiport;
+
+        portdev = kmalloc(sizeof(*portdev), GFP_KERNEL);
+        if (!portdev) {
+                err = -ENOMEM;
+                goto fail;
+        }
+
+        /* Attach this portdev to this virtio_device, and vice-versa. */
+        portdev->vdev = vdev;
+        vdev->priv = portdev;
+
+        spin_lock_irq(&pdrvdata_lock);
+        portdev->drv_index = pdrvdata.index++;
+        spin_unlock_irq(&pdrvdata_lock);
+
+        portdev->chr_major = register_chrdev(0, "virtio-portsdev",
+                                             &portdev_fops);
+        if (portdev->chr_major < 0) {
+                dev_err(&vdev->dev,
+                        "Error %d registering chrdev for device %u\n",
+                        portdev->chr_major, portdev->drv_index);
+                err = portdev->chr_major;
                 goto free;
+        }
 
-        in_vq = vqs[0];
-        out_vq = vqs[1];
+        multiport = false;
+        portdev->config.nr_ports = 1;
+        portdev->config.max_nr_ports = 1;
+        if (virtio_has_feature(vdev, VIRTIO_CONSOLE_F_MULTIPORT)) {
+                multiport = true;
+                vdev->features[0] |= 1 << VIRTIO_CONSOLE_F_MULTIPORT;
 
-        /* Start using the new console output. */
-        virtio_cons.get_chars = get_chars;
-        virtio_cons.put_chars = put_chars;
-        virtio_cons.notifier_add = notifier_add_vio;
-        virtio_cons.notifier_del = notifier_del_vio;
-        virtio_cons.notifier_hangup = notifier_del_vio;
-
-        /* The first argument of hvc_alloc() is the virtual console number, so
-         * we use zero.  The second argument is the parameter for the
-         * notification mechanism (like irq number). We currently leave this
-         * as zero, virtqueues have implicit notifications.
-         *
-         * The third argument is a "struct hv_ops" containing the put_chars()
-         * get_chars(), notifier_add() and notifier_del() pointers.
-         * The final argument is the output buffer size: we can do any size,
-         * so we put PAGE_SIZE here. */
-        hvc = hvc_alloc(0, 0, &virtio_cons, PAGE_SIZE);
-        if (IS_ERR(hvc)) {
-                err = PTR_ERR(hvc);
-                goto free_vqs;
+                vdev->config->get(vdev, offsetof(struct virtio_console_config,
+                                                 nr_ports),
+                                  &portdev->config.nr_ports,
+                                  sizeof(portdev->config.nr_ports));
+                vdev->config->get(vdev, offsetof(struct virtio_console_config,
+                                                 max_nr_ports),
+                                  &portdev->config.max_nr_ports,
+                                  sizeof(portdev->config.max_nr_ports));
+                if (portdev->config.nr_ports > portdev->config.max_nr_ports) {
+                        dev_warn(&vdev->dev,
+                                 "More ports (%u) specified than allowed (%u). Will init %u ports.",
+                                 portdev->config.nr_ports,
+                                 portdev->config.max_nr_ports,
+                                 portdev->config.max_nr_ports);
+
+                        portdev->config.nr_ports = portdev->config.max_nr_ports;
+                }
+        }
+
+        /* Let the Host know we support multiple ports.*/
+        vdev->config->finalize_features(vdev);
+
+        err = init_vqs(portdev);
+        if (err < 0) {
+                dev_err(&vdev->dev, "Error %d initializing vqs\n", err);
+                goto free_chrdev;
+        }
+
+        spin_lock_init(&portdev->ports_lock);
+        INIT_LIST_HEAD(&portdev->ports);
+
+        if (multiport) {
+                spin_lock_init(&portdev->cvq_lock);
+                INIT_WORK(&portdev->control_work, &control_work_handler);
+                INIT_WORK(&portdev->config_work, &config_work_handler);
+
+                err = fill_queue(portdev->c_ivq, &portdev->cvq_lock);
+                if (!err) {
+                        dev_err(&vdev->dev,
+                                "Error allocating buffers for control queue\n");
+                        err = -ENOMEM;
+                        goto free_vqs;
+                }
         }
 
-        /* Register the input buffer the first time. */
-        add_inbuf();
+        for (i = 0; i < portdev->config.nr_ports; i++)
+                add_port(portdev, i);
+
+        /* Start using the new console output. */
+        early_put_chars = NULL;
         return 0;
 
 free_vqs:
         vdev->config->del_vqs(vdev);
+        kfree(portdev->in_vqs);
+        kfree(portdev->out_vqs);
+free_chrdev:
+        unregister_chrdev(portdev->chr_major, "virtio-portsdev");
 free:
-        kfree(inbuf);
+        kfree(portdev);
 fail:
         return err;
 }
 
+static void virtcons_remove(struct virtio_device *vdev)
+{
+        struct ports_device *portdev;
+        struct port *port, *port2;
+        struct port_buffer *buf;
+        unsigned int len;
+
+        portdev = vdev->priv;
+
+        cancel_work_sync(&portdev->control_work);
+        cancel_work_sync(&portdev->config_work);
+
+        list_for_each_entry_safe(port, port2, &portdev->ports, list)
+                remove_port(port);
+
+        unregister_chrdev(portdev->chr_major, "virtio-portsdev");
+
+        while ((buf = portdev->c_ivq->vq_ops->get_buf(portdev->c_ivq, &len)))
+                free_buf(buf);
+
+        while ((buf = portdev->c_ivq->vq_ops->detach_unused_buf(portdev->c_ivq)))
+                free_buf(buf);
+
+        vdev->config->del_vqs(vdev);
+        kfree(portdev->in_vqs);
+        kfree(portdev->out_vqs);
+
+        kfree(portdev);
+}
+
 static struct virtio_device_id id_table[] = {
         { VIRTIO_ID_CONSOLE, VIRTIO_DEV_ANY_ID },
         { 0 },
@@ -253,6 +1511,7 @@ static struct virtio_device_id id_table[] = {
 
 static unsigned int features[] = {
         VIRTIO_CONSOLE_F_SIZE,
+        VIRTIO_CONSOLE_F_MULTIPORT,
 };
 
 static struct virtio_driver virtio_console = {
@@ -262,14 +1521,41 @@ static struct virtio_driver virtio_console = {
         .driver.owner = THIS_MODULE,
         .id_table =     id_table,
         .probe =        virtcons_probe,
-        .config_changed = virtcons_apply_config,
+        .remove =       virtcons_remove,
+        .config_changed = config_intr,
 };
 
 static int __init init(void)
 {
+        int err;
+
+        pdrvdata.class = class_create(THIS_MODULE, "virtio-ports");
+        if (IS_ERR(pdrvdata.class)) {
+                err = PTR_ERR(pdrvdata.class);
+                pr_err("Error %d creating virtio-ports class\n", err);
+                return err;
+        }
+
+        pdrvdata.debugfs_dir = debugfs_create_dir("virtio-ports", NULL);
+        if (!pdrvdata.debugfs_dir) {
+                pr_warning("Error %ld creating debugfs dir for virtio-ports\n",
+                           PTR_ERR(pdrvdata.debugfs_dir));
+        }
+        INIT_LIST_HEAD(&pdrvdata.consoles);
+
         return register_virtio_driver(&virtio_console);
 }
+
+static void __exit fini(void)
+{
+        unregister_virtio_driver(&virtio_console);
+
+        class_destroy(pdrvdata.class);
+        if (pdrvdata.debugfs_dir)
+                debugfs_remove_recursive(pdrvdata.debugfs_dir);
+}
 module_init(init);
+module_exit(fini);
 
 MODULE_DEVICE_TABLE(virtio, id_table);
 MODULE_DESCRIPTION("Virtio console driver");
diff --git a/drivers/clocksource/cs5535-clockevt.c b/drivers/clocksource/cs5535-clockevt.c
index 27d20fac19d1..b314a999aabe 100644
--- a/drivers/clocksource/cs5535-clockevt.c
+++ b/drivers/clocksource/cs5535-clockevt.c
@@ -21,7 +21,7 @@
 
 #define DRV_NAME "cs5535-clockevt"
 
-static int timer_irq = CONFIG_CS5535_MFGPT_DEFAULT_IRQ;
+static int timer_irq;
 module_param_named(irq, timer_irq, int, 0644);
 MODULE_PARM_DESC(irq, "Which IRQ to use for the clock source MFGPT ticks.");
 
diff --git a/drivers/crypto/amcc/crypto4xx_core.c b/drivers/crypto/amcc/crypto4xx_core.c
index 46e899ac924e..1c3849f6b7a2 100644
--- a/drivers/crypto/amcc/crypto4xx_core.c
+++ b/drivers/crypto/amcc/crypto4xx_core.c
@@ -1274,7 +1274,7 @@ static int __exit crypto4xx_remove(struct of_device *ofdev)
         return 0;
 }
 
-static struct of_device_id crypto4xx_match[] = {
+static const struct of_device_id crypto4xx_match[] = {
         { .compatible      = "amcc,ppc4xx-crypto",},
         { },
 };
diff --git a/drivers/crypto/geode-aes.c b/drivers/crypto/geode-aes.c
index 4801162919d9..c7a5a43ba691 100644
--- a/drivers/crypto/geode-aes.c
+++ b/drivers/crypto/geode-aes.c
@@ -135,13 +135,13 @@ static int geode_setkey_cip(struct crypto_tfm *tfm, const u8 *key,
         /*
          * The requested key size is not supported by HW, do a fallback
          */
-        op->fallback.blk->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
-        op->fallback.blk->base.crt_flags |= (tfm->crt_flags & CRYPTO_TFM_REQ_MASK);
+        op->fallback.cip->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
+        op->fallback.cip->base.crt_flags |= (tfm->crt_flags & CRYPTO_TFM_REQ_MASK);
 
         ret = crypto_cipher_setkey(op->fallback.cip, key, len);
         if (ret) {
                 tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
-                tfm->crt_flags |= (op->fallback.blk->base.crt_flags & CRYPTO_TFM_RES_MASK);
+                tfm->crt_flags |= (op->fallback.cip->base.crt_flags & CRYPTO_TFM_RES_MASK);
         }
         return ret;
 }
@@ -263,7 +263,7 @@ static int fallback_init_cip(struct crypto_tfm *tfm)
 
         if (IS_ERR(op->fallback.cip)) {
                 printk(KERN_ERR "Error allocating fallback algo %s\n", name);
-                return PTR_ERR(op->fallback.blk);
+                return PTR_ERR(op->fallback.cip);
         }
 
         return 0;
diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index c47ffe8a73ef..fd529d68c5ba 100644
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -1958,7 +1958,7 @@ err_out:
         return err;
 }
 
-static struct of_device_id talitos_match[] = {
+static const struct of_device_id talitos_match[] = {
         {
                 .compatible = "fsl,sec2.0",
         },
diff --git a/drivers/firewire/net.c b/drivers/firewire/net.c
index cbaf420c36c5..2d3dc7ded0a9 100644
--- a/drivers/firewire/net.c
+++ b/drivers/firewire/net.c
@@ -893,20 +893,31 @@ static void fwnet_receive_broadcast(struct fw_iso_context *context,
 
 static struct kmem_cache *fwnet_packet_task_cache;
 
+static void fwnet_free_ptask(struct fwnet_packet_task *ptask)
+{
+        dev_kfree_skb_any(ptask->skb);
+        kmem_cache_free(fwnet_packet_task_cache, ptask);
+}
+
 static int fwnet_send_packet(struct fwnet_packet_task *ptask);
 
 static void fwnet_transmit_packet_done(struct fwnet_packet_task *ptask)
 {
-        struct fwnet_device *dev;
+        struct fwnet_device *dev = ptask->dev;
         unsigned long flags;
-
-        dev = ptask->dev;
+        bool free;
 
         spin_lock_irqsave(&dev->lock, flags);
-        list_del(&ptask->pt_link);
-        spin_unlock_irqrestore(&dev->lock, flags);
 
-        ptask->outstanding_pkts--; /* FIXME access inside lock */
+        ptask->outstanding_pkts--;
+
+        /* Check whether we or the networking TX soft-IRQ is last user. */
+        free = (ptask->outstanding_pkts == 0 && !list_empty(&ptask->pt_link));
+
+        if (ptask->outstanding_pkts == 0)
+                list_del(&ptask->pt_link);
+
+        spin_unlock_irqrestore(&dev->lock, flags);
 
         if (ptask->outstanding_pkts > 0) {
                 u16 dg_size;
@@ -951,10 +962,10 @@ static void fwnet_transmit_packet_done(struct fwnet_packet_task *ptask)
                         ptask->max_payload = skb->len + RFC2374_FRAG_HDR_SIZE;
                 }
                 fwnet_send_packet(ptask);
-        } else {
-                dev_kfree_skb_any(ptask->skb);
-                kmem_cache_free(fwnet_packet_task_cache, ptask);
         }
+
+        if (free)
+                fwnet_free_ptask(ptask);
 }
 
 static void fwnet_write_complete(struct fw_card *card, int rcode,
@@ -977,6 +988,7 @@ static int fwnet_send_packet(struct fwnet_packet_task *ptask)
         unsigned tx_len;
         struct rfc2734_header *bufhdr;
         unsigned long flags;
+        bool free;
 
         dev = ptask->dev;
         tx_len = ptask->max_payload;
@@ -1022,12 +1034,16 @@ static int fwnet_send_packet(struct fwnet_packet_task *ptask)
                                 generation, SCODE_100, 0ULL, ptask->skb->data,
                                 tx_len + 8, fwnet_write_complete, ptask);
 
-                /* FIXME race? */
                 spin_lock_irqsave(&dev->lock, flags);
-                list_add_tail(&ptask->pt_link, &dev->broadcasted_list);
+
+                /* If the AT tasklet already ran, we may be last user. */
+                free = (ptask->outstanding_pkts == 0 && list_empty(&ptask->pt_link));
+                if (!free)
+                        list_add_tail(&ptask->pt_link, &dev->broadcasted_list);
+
                 spin_unlock_irqrestore(&dev->lock, flags);
 
-                return 0;
+                goto out;
         }
 
         fw_send_request(dev->card, &ptask->transaction,
@@ -1035,12 +1051,19 @@ static int fwnet_send_packet(struct fwnet_packet_task *ptask)
                         ptask->generation, ptask->speed, ptask->fifo_addr,
                         ptask->skb->data, tx_len, fwnet_write_complete, ptask);
 
-        /* FIXME race? */
         spin_lock_irqsave(&dev->lock, flags);
-        list_add_tail(&ptask->pt_link, &dev->sent_list);
+
+        /* If the AT tasklet already ran, we may be last user. */
+        free = (ptask->outstanding_pkts == 0 && list_empty(&ptask->pt_link));
+        if (!free)
+                list_add_tail(&ptask->pt_link, &dev->sent_list);
+
         spin_unlock_irqrestore(&dev->lock, flags);
 
         dev->netdev->trans_start = jiffies;
+ out:
+        if (free)
+                fwnet_free_ptask(ptask);
 
         return 0;
 }
@@ -1298,6 +1321,8 @@ static netdev_tx_t fwnet_tx(struct sk_buff *skb, struct net_device *net)
         spin_unlock_irqrestore(&dev->lock, flags);
 
         ptask->max_payload = max_payload;
+        INIT_LIST_HEAD(&ptask->pt_link);
+
         fwnet_send_packet(ptask);
 
         return NETDEV_TX_OK;
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index 2345d4103fe6..43ebf337b131 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -2101,11 +2101,6 @@ static int ohci_queue_iso_transmit(struct fw_iso_context *base,
         u32 payload_index, payload_end_index, next_page_index;
         int page, end_page, i, length, offset;
 
-        /*
-         * FIXME: Cycle lost behavior should be configurable: lose
-         * packet, retransmit or terminate..
-         */
-
         p = packet;
         payload_index = payload;
 
@@ -2135,6 +2130,14 @@ static int ohci_queue_iso_transmit(struct fw_iso_context *base,
         if (!p->skip) {
                 d[0].control   = cpu_to_le16(DESCRIPTOR_KEY_IMMEDIATE);
                 d[0].req_count = cpu_to_le16(8);
+                /*
+                 * Link the skip address to this descriptor itself.  This causes
+                 * a context to skip a cycle whenever lost cycles or FIFO
+                 * overruns occur, without dropping the data.  The application
+                 * should then decide whether this is an error condition or not.
+                 * FIXME:  Make the context's cycle-lost behaviour configurable?
+                 */
+                d[0].branch_address = cpu_to_le32(d_bus | z);
 
                 header = (__le32 *) &d[1];
                 header[0] = cpu_to_le32(IT_HEADER_SY(p->sy) |
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index f665b05592f3..ab6c97330412 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -598,6 +598,50 @@ struct drm_display_mode *drm_mode_std(struct drm_device *dev,
         return mode;
 }
 
+/*
+ * EDID is delightfully ambiguous about how interlaced modes are to be
+ * encoded.  Our internal representation is of frame height, but some
+ * HDTV detailed timings are encoded as field height.
+ *
+ * The format list here is from CEA, in frame size.  Technically we
+ * should be checking refresh rate too.  Whatever.
+ */
+static void
+drm_mode_do_interlace_quirk(struct drm_display_mode *mode,
+                            struct detailed_pixel_timing *pt)
+{
+        int i;
+        static const struct {
+                int w, h;
+        } cea_interlaced[] = {
+                { 1920, 1080 },
+                {  720,  480 },
+                { 1440,  480 },
+                { 2880,  480 },
+                {  720,  576 },
+                { 1440,  576 },
+                { 2880,  576 },
+        };
+        static const int n_sizes =
+                sizeof(cea_interlaced)/sizeof(cea_interlaced[0]);
+
+        if (!(pt->misc & DRM_EDID_PT_INTERLACED))
+                return;
+
+        for (i = 0; i < n_sizes; i++) {
+                if ((mode->hdisplay == cea_interlaced[i].w) &&
+                    (mode->vdisplay == cea_interlaced[i].h / 2)) {
+                        mode->vdisplay *= 2;
+                        mode->vsync_start *= 2;
+                        mode->vsync_end *= 2;
+                        mode->vtotal *= 2;
+                        mode->vtotal |= 1;
+                }
+        }
+
+        mode->flags |= DRM_MODE_FLAG_INTERLACE;
+}
+
 /**
  * drm_mode_detailed - create a new mode from an EDID detailed timing section
  * @dev: DRM device (needed to create new mode)
@@ -680,8 +724,7 @@ static struct drm_display_mode *drm_mode_detailed(struct drm_device *dev,
 
         drm_mode_set_name(mode);
 
-        if (pt->misc & DRM_EDID_PT_INTERLACED)
-                mode->flags |= DRM_MODE_FLAG_INTERLACE;
+        drm_mode_do_interlace_quirk(mode, pt);
 
         if (quirks & EDID_QUIRK_DETAILED_SYNC_PP) {
                 pt->misc |= DRM_EDID_PT_HSYNC_POSITIVE | DRM_EDID_PT_VSYNC_POSITIVE;
diff --git a/drivers/gpu/drm/drm_mm.c b/drivers/gpu/drm/drm_mm.c
index cdec32977129..2ac074c8f5d2 100644
--- a/drivers/gpu/drm/drm_mm.c
+++ b/drivers/gpu/drm/drm_mm.c
@@ -405,7 +405,8 @@ struct drm_mm_node *drm_mm_search_free_in_range(const struct drm_mm *mm,
                                 wasted += alignment - tmp;
                 }
 
-                if (entry->size >= size + wasted) {
+                if (entry->size >= size + wasted &&
+                    (entry->start + wasted + size) <= end) {
                         if (!best_match)
                                 return entry;
                         if (entry->size < best_size) {
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 79beffcf5936..cf4cb3e9a0c2 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -176,6 +176,8 @@ MODULE_DEVICE_TABLE(pci, pciidlist);
 
 static int i915_drm_freeze(struct drm_device *dev)
 {
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
         pci_save_state(dev->pdev);
 
         /* If KMS is active, we do the leavevt stuff here */
@@ -191,17 +193,12 @@ static int i915_drm_freeze(struct drm_device *dev)
 
         i915_save_state(dev);
 
-        return 0;
-}
-
-static void i915_drm_suspend(struct drm_device *dev)
-{
-        struct drm_i915_private *dev_priv = dev->dev_private;
-
         intel_opregion_free(dev, 1);
 
         /* Modeset on resume, not lid events */
         dev_priv->modeset_on_lid = 0;
+
+        return 0;
 }
 
 static int i915_suspend(struct drm_device *dev, pm_message_t state)
@@ -221,8 +218,6 @@ static int i915_suspend(struct drm_device *dev, pm_message_t state)
         if (error)
                 return error;
 
-        i915_drm_suspend(dev);
-
         if (state.event == PM_EVENT_SUSPEND) {
                 /* Shut down the device */
                 pci_disable_device(dev->pdev);
@@ -237,6 +232,10 @@ static int i915_drm_thaw(struct drm_device *dev)
         struct drm_i915_private *dev_priv = dev->dev_private;
         int error = 0;
 
+        i915_restore_state(dev);
+
+        intel_opregion_init(dev, 1);
+
         /* KMS EnterVT equivalent */
         if (drm_core_check_feature(dev, DRIVER_MODESET)) {
                 mutex_lock(&dev->struct_mutex);
@@ -263,10 +262,6 @@ static int i915_resume(struct drm_device *dev)
 
         pci_set_master(dev->pdev);
 
-        i915_restore_state(dev);
-
-        intel_opregion_init(dev, 1);
-
         return i915_drm_thaw(dev);
 }
 
@@ -423,8 +418,6 @@ static int i915_pm_suspend(struct device *dev)
         if (error)
                 return error;
 
-        i915_drm_suspend(drm_dev);
-
         pci_disable_device(pdev);
         pci_set_power_state(pdev, PCI_D3hot);
 
@@ -464,13 +457,8 @@ static int i915_pm_poweroff(struct device *dev)
 {
         struct pci_dev *pdev = to_pci_dev(dev);
         struct drm_device *drm_dev = pci_get_drvdata(pdev);
-        int error;
-
-        error = i915_drm_freeze(drm_dev);
-        if (!error)
-                i915_drm_suspend(drm_dev);
 
-        return error;
+        return i915_drm_freeze(drm_dev);
 }
 
 const struct dev_pm_ops i915_pm_ops = {
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index b1d0acbae4e4..c2e8a45780d5 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -636,6 +636,13 @@ static const struct dmi_system_id bad_lid_status[] = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "PC-81005"),
                 },
         },
+        {
+                .ident = "Clevo M5x0N",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
+                        DMI_MATCH(DMI_BOARD_NAME, "M5x0N"),
+                },
+        },
         { }
 };
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.c b/drivers/gpu/drm/nouveau/nouveau_bios.c
index 2cd0fad17dac..0e9cd1d49130 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.c
@@ -5861,13 +5861,12 @@ nouveau_bios_run_init_table(struct drm_device *dev, uint16_t table,
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nvbios *bios = &dev_priv->VBIOS;
         struct init_exec iexec = { true, false };
-        unsigned long flags;
 
-        spin_lock_irqsave(&bios->lock, flags);
+        mutex_lock(&bios->lock);
         bios->display.output = dcbent;
         parse_init_table(bios, table, &iexec);
         bios->display.output = NULL;
-        spin_unlock_irqrestore(&bios->lock, flags);
+        mutex_unlock(&bios->lock);
 }
 
 static bool NVInitVBIOS(struct drm_device *dev)
@@ -5876,7 +5875,7 @@ static bool NVInitVBIOS(struct drm_device *dev)
         struct nvbios *bios = &dev_priv->VBIOS;
 
         memset(bios, 0, sizeof(struct nvbios));
-        spin_lock_init(&bios->lock);
+        mutex_init(&bios->lock);
         bios->dev = dev;
 
         if (!NVShadowVBIOS(dev, bios->data))
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.h b/drivers/gpu/drm/nouveau/nouveau_bios.h
index 68446fd4146b..fd94bd6dc264 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.h
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.h
@@ -205,7 +205,7 @@ struct nvbios {
         struct drm_device *dev;
         struct nouveau_bios_info pub;
 
-        spinlock_t lock;
+        struct mutex lock;
 
         uint8_t data[NV_PROM_SIZE];
         unsigned int length;
diff --git a/drivers/gpu/drm/nouveau/nouveau_drv.h b/drivers/gpu/drm/nouveau/nouveau_drv.h
index 5445cefdd03e..1c15ef37b71c 100644
--- a/drivers/gpu/drm/nouveau/nouveau_drv.h
+++ b/drivers/gpu/drm/nouveau/nouveau_drv.h
@@ -583,6 +583,7 @@ struct drm_nouveau_private {
         uint64_t vm_end;
         struct nouveau_gpuobj *vm_vram_pt[NV50_VM_VRAM_NR];
         int vm_vram_pt_nr;
+        uint64_t vram_sys_base;
 
         /* the mtrr covering the FB */
         int fb_mtrr;
diff --git a/drivers/gpu/drm/nouveau/nouveau_mem.c b/drivers/gpu/drm/nouveau/nouveau_mem.c
index 8f3a12f614ed..2dc09dbd817d 100644
--- a/drivers/gpu/drm/nouveau/nouveau_mem.c
+++ b/drivers/gpu/drm/nouveau/nouveau_mem.c
@@ -285,53 +285,50 @@ nv50_mem_vm_bind_linear(struct drm_device *dev, uint64_t virt, uint32_t size,
                         uint32_t flags, uint64_t phys)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
-        struct nouveau_gpuobj **pgt;
-        unsigned psz, pfl, pages;
-
-        if (virt >= dev_priv->vm_gart_base &&
-            (virt + size) < (dev_priv->vm_gart_base + dev_priv->vm_gart_size)) {
-                psz = 12;
-                pgt = &dev_priv->gart_info.sg_ctxdma;
-                pfl = 0x21;
-                virt -= dev_priv->vm_gart_base;
-        } else
-        if (virt >= dev_priv->vm_vram_base &&
-            (virt + size) < (dev_priv->vm_vram_base + dev_priv->vm_vram_size)) {
-                psz = 16;
-                pgt = dev_priv->vm_vram_pt;
-                pfl = 0x01;
-                virt -= dev_priv->vm_vram_base;
-        } else {
-                NV_ERROR(dev, "Invalid address: 0x%16llx-0x%16llx\n",
-                         virt, virt + size - 1);
-                return -EINVAL;
-        }
+        struct nouveau_gpuobj *pgt;
+        unsigned block;
+        int i;
 
-        pages = size >> psz;
+        virt = ((virt - dev_priv->vm_vram_base) >> 16) << 1;
+        size = (size >> 16) << 1;
+
+        phys |= ((uint64_t)flags << 32);
+        phys |= 1;
+        if (dev_priv->vram_sys_base) {
+                phys += dev_priv->vram_sys_base;
+                phys |= 0x30;
+        }
 
         dev_priv->engine.instmem.prepare_access(dev, true);
-        if (flags & 0x80000000) {
-                while (pages--) {
-                        struct nouveau_gpuobj *pt = pgt[virt >> 29];
-                        unsigned pte = ((virt & 0x1fffffffULL) >> psz) << 1;
+        while (size) {
+                unsigned offset_h = upper_32_bits(phys);
+                unsigned offset_l = lower_32_bits(phys);
+                unsigned pte, end;
+
+                for (i = 7; i >= 0; i--) {
+                        block = 1 << (i + 1);
+                        if (size >= block && !(virt & (block - 1)))
+                                break;
+                }
+                offset_l |= (i << 7);
 
-                        nv_wo32(dev, pt, pte++, 0x00000000);
-                        nv_wo32(dev, pt, pte++, 0x00000000);
+                phys += block << 15;
+                size -= block;
 
-                        virt += (1 << psz);
-                }
-        } else {
-                while (pages--) {
-                        struct nouveau_gpuobj *pt = pgt[virt >> 29];
-                        unsigned pte = ((virt & 0x1fffffffULL) >> psz) << 1;
-                        unsigned offset_h = upper_32_bits(phys) & 0xff;
-                        unsigned offset_l = lower_32_bits(phys);
+                while (block) {
+                        pgt = dev_priv->vm_vram_pt[virt >> 14];
+                        pte = virt & 0x3ffe;
 
-                        nv_wo32(dev, pt, pte++, offset_l | pfl);
-                        nv_wo32(dev, pt, pte++, offset_h | flags);
+                        end = pte + block;
+                        if (end > 16384)
+                                end = 16384;
+                        block -= (end - pte);
+                        virt  += (end - pte);
 
-                        phys += (1 << psz);
-                        virt += (1 << psz);
+                        while (pte < end) {
+                                nv_wo32(dev, pgt, pte++, offset_l);
+                                nv_wo32(dev, pgt, pte++, offset_h);
+                        }
                 }
         }
         dev_priv->engine.instmem.finish_access(dev);
@@ -356,7 +353,41 @@ nv50_mem_vm_bind_linear(struct drm_device *dev, uint64_t virt, uint32_t size,
 void
 nv50_mem_vm_unbind(struct drm_device *dev, uint64_t virt, uint32_t size)
 {
-        nv50_mem_vm_bind_linear(dev, virt, size, 0x80000000, 0);
+        struct drm_nouveau_private *dev_priv = dev->dev_private;
+        struct nouveau_gpuobj *pgt;
+        unsigned pages, pte, end;
+
+        virt -= dev_priv->vm_vram_base;
+        pages = (size >> 16) << 1;
+
+        dev_priv->engine.instmem.prepare_access(dev, true);
+        while (pages) {
+                pgt = dev_priv->vm_vram_pt[virt >> 29];
+                pte = (virt & 0x1ffe0000ULL) >> 15;
+
+                end = pte + pages;
+                if (end > 16384)
+                        end = 16384;
+                pages -= (end - pte);
+                virt  += (end - pte) << 15;
+
+                while (pte < end)
+                        nv_wo32(dev, pgt, pte++, 0);
+        }
+        dev_priv->engine.instmem.finish_access(dev);
+
+        nv_wr32(dev, 0x100c80, 0x00050001);
+        if (!nv_wait(0x100c80, 0x00000001, 0x00000000)) {
+                NV_ERROR(dev, "timeout: (0x100c80 & 1) == 0 (2)\n");
+                NV_ERROR(dev, "0x100c80 = 0x%08x\n", nv_rd32(dev, 0x100c80));
+                return;
+        }
+
+        nv_wr32(dev, 0x100c80, 0x00000001);
+        if (!nv_wait(0x100c80, 0x00000001, 0x00000000)) {
+                NV_ERROR(dev, "timeout: (0x100c80 & 1) == 0 (2)\n");
+                NV_ERROR(dev, "0x100c80 = 0x%08x\n", nv_rd32(dev, 0x100c80));
+        }
 }
 
 /*
diff --git a/drivers/gpu/drm/nouveau/nv04_dac.c b/drivers/gpu/drm/nouveau/nv04_dac.c
index d0e038d28948..1d73b15d70da 100644
--- a/drivers/gpu/drm/nouveau/nv04_dac.c
+++ b/drivers/gpu/drm/nouveau/nv04_dac.c
@@ -119,7 +119,7 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
                                                  struct drm_connector *connector)
 {
         struct drm_device *dev = encoder->dev;
-        uint8_t saved_seq1, saved_pi, saved_rpc1;
+        uint8_t saved_seq1, saved_pi, saved_rpc1, saved_cr_mode;
         uint8_t saved_palette0[3], saved_palette_mask;
         uint32_t saved_rtest_ctrl, saved_rgen_ctrl;
         int i;
@@ -135,6 +135,9 @@ static enum drm_connector_status nv04_dac_detect(struct drm_encoder *encoder,
                 /* only implemented for head A for now */
                 NVSetOwner(dev, 0);
 
+        saved_cr_mode = NVReadVgaCrtc(dev, 0, NV_CIO_CR_MODE_INDEX);
+        NVWriteVgaCrtc(dev, 0, NV_CIO_CR_MODE_INDEX, saved_cr_mode | 0x80);
+
         saved_seq1 = NVReadVgaSeq(dev, 0, NV_VIO_SR_CLOCK_INDEX);
         NVWriteVgaSeq(dev, 0, NV_VIO_SR_CLOCK_INDEX, saved_seq1 & ~0x20);
 
@@ -203,6 +206,7 @@ out:
         NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_PIXEL_INDEX, saved_pi);
         NVWriteVgaCrtc(dev, 0, NV_CIO_CRE_RPC1_INDEX, saved_rpc1);
         NVWriteVgaSeq(dev, 0, NV_VIO_SR_CLOCK_INDEX, saved_seq1);
+        NVWriteVgaCrtc(dev, 0, NV_CIO_CR_MODE_INDEX, saved_cr_mode);
 
         if (blue == 0x18) {
                 NV_INFO(dev, "Load detected on head A\n");
diff --git a/drivers/gpu/drm/nouveau/nv17_tv.c b/drivers/gpu/drm/nouveau/nv17_tv.c
index 58b917c3341b..21ac6e49b6ee 100644
--- a/drivers/gpu/drm/nouveau/nv17_tv.c
+++ b/drivers/gpu/drm/nouveau/nv17_tv.c
@@ -579,6 +579,8 @@ static void nv17_tv_restore(struct drm_encoder *encoder)
                                 nouveau_encoder(encoder)->restore.output);
 
         nv17_tv_state_load(dev, &to_tv_enc(encoder)->saved_state);
+
+        nouveau_encoder(encoder)->last_dpms = NV_DPMS_CLEARED;
 }
 
 static int nv17_tv_create_resources(struct drm_encoder *encoder,
diff --git a/drivers/gpu/drm/nouveau/nv50_instmem.c b/drivers/gpu/drm/nouveau/nv50_instmem.c
index 94400f777e7f..f0dc4e36ef05 100644
--- a/drivers/gpu/drm/nouveau/nv50_instmem.c
+++ b/drivers/gpu/drm/nouveau/nv50_instmem.c
@@ -76,6 +76,11 @@ nv50_instmem_init(struct drm_device *dev)
         for (i = 0x1700; i <= 0x1710; i += 4)
                 priv->save1700[(i-0x1700)/4] = nv_rd32(dev, i);
 
+        if (dev_priv->chipset == 0xaa || dev_priv->chipset == 0xac)
+                dev_priv->vram_sys_base = nv_rd32(dev, 0x100e10) << 12;
+        else
+                dev_priv->vram_sys_base = 0;
+
         /* Reserve the last MiB of VRAM, we should probably try to avoid
          * setting up the below tables over the top of the VBIOS image at
          * some point.
@@ -172,16 +177,28 @@ nv50_instmem_init(struct drm_device *dev)
          * We map the entire fake channel into the start of the PRAMIN BAR
          */
         ret = nouveau_gpuobj_new_ref(dev, chan, NULL, 0, pt_size, 0x1000,
-                                                        0, &priv->pramin_pt);
+                                     0, &priv->pramin_pt);
         if (ret)
                 return ret;
 
-        for (i = 0, v = c_offset; i < pt_size; i += 8, v += 0x1000) {
-                if (v < (c_offset + c_size))
-                        BAR0_WI32(priv->pramin_pt->gpuobj, i + 0, v | 1);
-                else
-                        BAR0_WI32(priv->pramin_pt->gpuobj, i + 0, 0x00000009);
+        v = c_offset | 1;
+        if (dev_priv->vram_sys_base) {
+                v += dev_priv->vram_sys_base;
+                v |= 0x30;
+        }
+
+        i = 0;
+        while (v < dev_priv->vram_sys_base + c_offset + c_size) {
+                BAR0_WI32(priv->pramin_pt->gpuobj, i + 0, v);
+                BAR0_WI32(priv->pramin_pt->gpuobj, i + 4, 0x00000000);
+                v += 0x1000;
+                i += 8;
+        }
+
+        while (i < pt_size) {
+                BAR0_WI32(priv->pramin_pt->gpuobj, i + 0, 0x00000000);
                 BAR0_WI32(priv->pramin_pt->gpuobj, i + 4, 0x00000000);
+                i += 8;
         }
 
         BAR0_WI32(chan->vm_pd, 0x00, priv->pramin_pt->instance | 0x63);
@@ -416,7 +433,9 @@ nv50_instmem_bind(struct drm_device *dev, struct nouveau_gpuobj *gpuobj)
 {
         struct drm_nouveau_private *dev_priv = dev->dev_private;
         struct nv50_instmem_priv *priv = dev_priv->engine.instmem.priv;
-        uint32_t pte, pte_end, vram;
+        struct nouveau_gpuobj *pramin_pt = priv->pramin_pt->gpuobj;
+        uint32_t pte, pte_end;
+        uint64_t vram;
 
         if (!gpuobj->im_backing || !gpuobj->im_pramin || gpuobj->im_bound)
                 return -EINVAL;
@@ -424,20 +443,24 @@ nv50_instmem_bind(struct drm_device *dev, struct nouveau_gpuobj *gpuobj)
         NV_DEBUG(dev, "st=0x%0llx sz=0x%0llx\n",
                  gpuobj->im_pramin->start, gpuobj->im_pramin->size);
 
-        pte     = (gpuobj->im_pramin->start >> 12) << 3;
-        pte_end = ((gpuobj->im_pramin->size >> 12) << 3) + pte;
+        pte     = (gpuobj->im_pramin->start >> 12) << 1;
+        pte_end = ((gpuobj->im_pramin->size >> 12) << 1) + pte;
         vram    = gpuobj->im_backing_start;
 
         NV_DEBUG(dev, "pramin=0x%llx, pte=%d, pte_end=%d\n",
                  gpuobj->im_pramin->start, pte, pte_end);
         NV_DEBUG(dev, "first vram page: 0x%08x\n", gpuobj->im_backing_start);
 
+        vram |= 1;
+        if (dev_priv->vram_sys_base) {
+                vram += dev_priv->vram_sys_base;
+                vram |= 0x30;
+        }
+
         dev_priv->engine.instmem.prepare_access(dev, true);
         while (pte < pte_end) {
-                nv_wo32(dev, priv->pramin_pt->gpuobj, (pte + 0)/4, vram | 1);
-                nv_wo32(dev, priv->pramin_pt->gpuobj, (pte + 4)/4, 0x00000000);
-
-                pte += 8;
+                nv_wo32(dev, pramin_pt, pte++, lower_32_bits(vram));
+                nv_wo32(dev, pramin_pt, pte++, upper_32_bits(vram));
                 vram += NV50_INSTMEM_PAGE_SIZE;
         }
         dev_priv->engine.instmem.finish_access(dev);
@@ -470,14 +493,13 @@ nv50_instmem_unbind(struct drm_device *dev, struct nouveau_gpuobj *gpuobj)
         if (gpuobj->im_bound == 0)
                 return -EINVAL;
 
-        pte     = (gpuobj->im_pramin->start >> 12) << 3;
-        pte_end = ((gpuobj->im_pramin->size >> 12) << 3) + pte;
+        pte     = (gpuobj->im_pramin->start >> 12) << 1;
+        pte_end = ((gpuobj->im_pramin->size >> 12) << 1) + pte;
 
         dev_priv->engine.instmem.prepare_access(dev, true);
         while (pte < pte_end) {
-                nv_wo32(dev, priv->pramin_pt->gpuobj, (pte + 0)/4, 0x00000009);
-                nv_wo32(dev, priv->pramin_pt->gpuobj, (pte + 4)/4, 0x00000000);
-                pte += 8;
+                nv_wo32(dev, priv->pramin_pt->gpuobj, pte++, 0x00000000);
+                nv_wo32(dev, priv->pramin_pt->gpuobj, pte++, 0x00000000);
         }
         dev_priv->engine.instmem.finish_access(dev);
 
diff --git a/drivers/gpu/drm/radeon/atom.c b/drivers/gpu/drm/radeon/atom.c
index e3b44562d265..7f152f66f196 100644
--- a/drivers/gpu/drm/radeon/atom.c
+++ b/drivers/gpu/drm/radeon/atom.c
@@ -24,6 +24,7 @@
 
 #include <linux/module.h>
 #include <linux/sched.h>
+#include <asm/unaligned.h>
 
 #define ATOM_DEBUG
 
@@ -212,7 +213,9 @@ static uint32_t atom_get_src_int(atom_exec_context *ctx, uint8_t attr,
         case ATOM_ARG_PS:
                 idx = U8(*ptr);
                 (*ptr)++;
-                val = le32_to_cpu(ctx->ps[idx]);
+                /* get_unaligned_le32 avoids unaligned accesses from atombios
+                 * tables, noticed on a DEC Alpha. */
+                val = get_unaligned_le32((u32 *)&ctx->ps[idx]);
                 if (print)
                         DEBUG("PS[0x%02X,0x%04X]", idx, val);
                 break;
@@ -640,7 +643,7 @@ static void atom_op_delay(atom_exec_context *ctx, int *ptr, int arg)
         uint8_t count = U8((*ptr)++);
         SDEBUG("   count: %d\n", count);
         if (arg == ATOM_UNIT_MICROSEC)
-                schedule_timeout_uninterruptible(usecs_to_jiffies(count));
+                udelay(count);
         else
                 schedule_timeout_uninterruptible(msecs_to_jiffies(count));
 }
diff --git a/drivers/gpu/drm/radeon/atombios_dp.c b/drivers/gpu/drm/radeon/atombios_dp.c
index b32eeea5bb8b..99915a682d59 100644
--- a/drivers/gpu/drm/radeon/atombios_dp.c
+++ b/drivers/gpu/drm/radeon/atombios_dp.c
@@ -350,7 +350,7 @@ retry:
         atom_execute_table(rdev->mode_info.atom_context, index, (uint32_t *)&args);
 
         if (args.ucReplyStatus && !args.ucDataOutLen) {
-                if (args.ucReplyStatus == 0x20 && retry_count < 10)
+                if (args.ucReplyStatus == 0x20 && retry_count++ < 10)
                         goto retry;
                 DRM_DEBUG("failed to get auxch %02x%02x %02x %02x 0x%02x %02x after %d retries\n",
                           req_bytes[1], req_bytes[0], req_bytes[2], req_bytes[3],
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c
index af1c3ca8a4cb..446b765ac72a 100644
--- a/drivers/gpu/drm/radeon/r600_blit_kms.c
+++ b/drivers/gpu/drm/radeon/r600_blit_kms.c
@@ -543,9 +543,6 @@ int r600_vb_ib_get(struct radeon_device *rdev)
 void r600_vb_ib_put(struct radeon_device *rdev)
 {
         radeon_fence_emit(rdev, rdev->r600_blit.vb_ib->fence);
-        mutex_lock(&rdev->ib_pool.mutex);
-        list_add_tail(&rdev->r600_blit.vb_ib->list, &rdev->ib_pool.scheduled_ibs);
-        mutex_unlock(&rdev->ib_pool.mutex);
         radeon_ib_free(rdev, &rdev->r600_blit.vb_ib);
 }
 
diff --git a/drivers/gpu/drm/radeon/r600_cp.c b/drivers/gpu/drm/radeon/r600_cp.c
index 6d5a711c2e91..75bcf35a0931 100644
--- a/drivers/gpu/drm/radeon/r600_cp.c
+++ b/drivers/gpu/drm/radeon/r600_cp.c
@@ -1428,9 +1428,12 @@ static void r700_gfx_init(struct drm_device *dev,
 
         gb_tiling_config |= R600_BANK_SWAPS(1);
 
-        backend_map = r700_get_tile_pipe_to_backend_map(dev_priv->r600_max_tile_pipes,
-                                                        dev_priv->r600_max_backends,
-                                                        (0xff << dev_priv->r600_max_backends) & 0xff);
+        if ((dev_priv->flags & RADEON_FAMILY_MASK) == CHIP_RV740)
+                backend_map = 0x28;
+        else
+                backend_map = r700_get_tile_pipe_to_backend_map(dev_priv->r600_max_tile_pipes,
+                                                                dev_priv->r600_max_backends,
+                                                                (0xff << dev_priv->r600_max_backends) & 0xff);
         gb_tiling_config |= R600_BACKEND_MAP(backend_map);
 
         cc_gc_shader_pipe_config =
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index f57480ba1355..c0356bb193e5 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -96,6 +96,7 @@ extern int radeon_audio;
  * symbol;
  */
 #define RADEON_MAX_USEC_TIMEOUT         100000  /* 100 ms */
+/* RADEON_IB_POOL_SIZE must be a power of 2 */
 #define RADEON_IB_POOL_SIZE             16
 #define RADEON_DEBUGFS_MAX_NUM_FILES    32
 #define RADEONFB_CONN_LIMIT             4
@@ -363,11 +364,12 @@ void radeon_irq_kms_sw_irq_put(struct radeon_device *rdev);
  */
 struct radeon_ib {
         struct list_head        list;
-        unsigned long           idx;
+        unsigned                idx;
         uint64_t                gpu_addr;
         struct radeon_fence     *fence;
-        uint32_t        *ptr;
+        uint32_t                *ptr;
         uint32_t                length_dw;
+        bool                    free;
 };
 
 /*
@@ -377,10 +379,9 @@ struct radeon_ib {
 struct radeon_ib_pool {
         struct mutex            mutex;
         struct radeon_bo        *robj;
-        struct list_head        scheduled_ibs;
         struct radeon_ib        ibs[RADEON_IB_POOL_SIZE];
         bool                    ready;
-        DECLARE_BITMAP(alloc_bm, RADEON_IB_POOL_SIZE);
+        unsigned                head_id;
 };
 
 struct radeon_cp {
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 2dcda6115874..4d8831548a5f 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -206,6 +206,15 @@ static bool radeon_atom_apply_quirks(struct drm_device *dev,
                         *connector_type = DRM_MODE_CONNECTOR_DVID;
         }
 
+        /* Asrock RS600 board lists the DVI port as HDMI */
+        if ((dev->pdev->device == 0x7941) &&
+            (dev->pdev->subsystem_vendor == 0x1849) &&
+            (dev->pdev->subsystem_device == 0x7941)) {
+                if ((*connector_type == DRM_MODE_CONNECTOR_HDMIA) &&
+                    (supported_device == ATOM_DEVICE_DFP3_SUPPORT))
+                        *connector_type = DRM_MODE_CONNECTOR_DVID;
+        }
+
         /* a-bit f-i90hd - ciaranm on #radeonhd - this board has no DVI */
         if ((dev->pdev->device == 0x7941) &&
             (dev->pdev->subsystem_vendor == 0x147b) &&
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index e7b19440102e..22d476160d52 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -1279,47 +1279,47 @@ bool radeon_get_legacy_connector_info_from_table(struct drm_device *dev)
         rdev->mode_info.connector_table = radeon_connector_table;
         if (rdev->mode_info.connector_table == CT_NONE) {
 #ifdef CONFIG_PPC_PMAC
-                if (machine_is_compatible("PowerBook3,3")) {
+                if (of_machine_is_compatible("PowerBook3,3")) {
                         /* powerbook with VGA */
                         rdev->mode_info.connector_table = CT_POWERBOOK_VGA;
-                } else if (machine_is_compatible("PowerBook3,4") ||
-                           machine_is_compatible("PowerBook3,5")) {
+                } else if (of_machine_is_compatible("PowerBook3,4") ||
+                           of_machine_is_compatible("PowerBook3,5")) {
                         /* powerbook with internal tmds */
                         rdev->mode_info.connector_table = CT_POWERBOOK_INTERNAL;
-                } else if (machine_is_compatible("PowerBook5,1") ||
-                           machine_is_compatible("PowerBook5,2") ||
-                           machine_is_compatible("PowerBook5,3") ||
-                           machine_is_compatible("PowerBook5,4") ||
-                           machine_is_compatible("PowerBook5,5")) {
+                } else if (of_machine_is_compatible("PowerBook5,1") ||
+                           of_machine_is_compatible("PowerBook5,2") ||
+                           of_machine_is_compatible("PowerBook5,3") ||
+                           of_machine_is_compatible("PowerBook5,4") ||
+                           of_machine_is_compatible("PowerBook5,5")) {
                         /* powerbook with external single link tmds (sil164) */
                         rdev->mode_info.connector_table = CT_POWERBOOK_EXTERNAL;
-                } else if (machine_is_compatible("PowerBook5,6")) {
+                } else if (of_machine_is_compatible("PowerBook5,6")) {
                         /* powerbook with external dual or single link tmds */
                         rdev->mode_info.connector_table = CT_POWERBOOK_EXTERNAL;
-                } else if (machine_is_compatible("PowerBook5,7") ||
-                           machine_is_compatible("PowerBook5,8") ||
-                           machine_is_compatible("PowerBook5,9")) {
+                } else if (of_machine_is_compatible("PowerBook5,7") ||
+                           of_machine_is_compatible("PowerBook5,8") ||
+                           of_machine_is_compatible("PowerBook5,9")) {
                         /* PowerBook6,2 ? */
                         /* powerbook with external dual link tmds (sil1178?) */
                         rdev->mode_info.connector_table = CT_POWERBOOK_EXTERNAL;
-                } else if (machine_is_compatible("PowerBook4,1") ||
-                           machine_is_compatible("PowerBook4,2") ||
-                           machine_is_compatible("PowerBook4,3") ||
-                           machine_is_compatible("PowerBook6,3") ||
-                           machine_is_compatible("PowerBook6,5") ||
-                           machine_is_compatible("PowerBook6,7")) {
+                } else if (of_machine_is_compatible("PowerBook4,1") ||
+                           of_machine_is_compatible("PowerBook4,2") ||
+                           of_machine_is_compatible("PowerBook4,3") ||
+                           of_machine_is_compatible("PowerBook6,3") ||
+                           of_machine_is_compatible("PowerBook6,5") ||
+                           of_machine_is_compatible("PowerBook6,7")) {
                         /* ibook */
                         rdev->mode_info.connector_table = CT_IBOOK;
-                } else if (machine_is_compatible("PowerMac4,4")) {
+                } else if (of_machine_is_compatible("PowerMac4,4")) {
                         /* emac */
                         rdev->mode_info.connector_table = CT_EMAC;
-                } else if (machine_is_compatible("PowerMac10,1")) {
+                } else if (of_machine_is_compatible("PowerMac10,1")) {
                         /* mini with internal tmds */
                         rdev->mode_info.connector_table = CT_MINI_INTERNAL;
-                } else if (machine_is_compatible("PowerMac10,2")) {
+                } else if (of_machine_is_compatible("PowerMac10,2")) {
                         /* mini with external tmds */
                         rdev->mode_info.connector_table = CT_MINI_EXTERNAL;
-                } else if (machine_is_compatible("PowerMac12,1")) {
+                } else if (of_machine_is_compatible("PowerMac12,1")) {
                         /* PowerMac8,1 ? */
                         /* imac g5 isight */
                         rdev->mode_info.connector_table = CT_IMAC_G5_ISIGHT;
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index 238188540017..65f81942f399 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -780,7 +780,7 @@ static enum drm_connector_status radeon_dvi_detect(struct drm_connector *connect
                          * connected and the DVI port disconnected.  If the edid doesn't
                          * say HDMI, vice versa.
                          */
-                        if (radeon_connector->shared_ddc && connector_status_connected) {
+                        if (radeon_connector->shared_ddc && (ret == connector_status_connected)) {
                                 struct drm_device *dev = connector->dev;
                                 struct drm_connector *list_connector;
                                 struct radeon_connector *list_radeon_connector;
@@ -1060,8 +1060,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                         return;
                 }
                 if (radeon_connector->ddc_bus && i2c_bus->valid) {
-                        if (memcmp(&radeon_connector->ddc_bus->rec, i2c_bus,
-                                    sizeof(struct radeon_i2c_bus_rec)) == 0) {
+                        if (radeon_connector->ddc_bus->rec.i2c_id == i2c_bus->i2c_id) {
                                 radeon_connector->shared_ddc = true;
                                 shared_ddc = true;
                         }
diff --git a/drivers/gpu/drm/radeon/radeon_cs.c b/drivers/gpu/drm/radeon/radeon_cs.c
index 1190148cf5e6..e9d085021c1f 100644
--- a/drivers/gpu/drm/radeon/radeon_cs.c
+++ b/drivers/gpu/drm/radeon/radeon_cs.c
@@ -86,7 +86,7 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p)
                                                 &p->validated);
                 }
         }
-        return radeon_bo_list_validate(&p->validated, p->ib->fence);
+        return radeon_bo_list_validate(&p->validated);
 }
 
 int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)
@@ -189,12 +189,10 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error)
 {
         unsigned i;
 
-        if (error && parser->ib) {
-                radeon_bo_list_unvalidate(&parser->validated,
-                                                parser->ib->fence);
-        } else {
-                radeon_bo_list_unreserve(&parser->validated);
+        if (!error && parser->ib) {
+                radeon_bo_list_fence(&parser->validated, parser->ib->fence);
         }
+        radeon_bo_list_unreserve(&parser->validated);
         for (i = 0; i < parser->nrelocs; i++) {
                 if (parser->relocs[i].gobj) {
                         mutex_lock(&parser->rdev->ddev->struct_mutex);
diff --git a/drivers/gpu/drm/radeon/radeon_drv.h b/drivers/gpu/drm/radeon/radeon_drv.h
index e13785282a82..c57ad606504d 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.h
+++ b/drivers/gpu/drm/radeon/radeon_drv.h
@@ -106,9 +106,10 @@
  * 1.29- R500 3D cmd buffer support
  * 1.30- Add support for occlusion queries
  * 1.31- Add support for num Z pipes from GET_PARAM
+ * 1.32- fixes for rv740 setup
  */
 #define DRIVER_MAJOR            1
-#define DRIVER_MINOR            31
+#define DRIVER_MINOR            32
 #define DRIVER_PATCHLEVEL       0
 
 enum radeon_cp_microcode_version {
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index d72a71bff218..f1da370928eb 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -306,11 +306,10 @@ void radeon_bo_list_unreserve(struct list_head *head)
         }
 }
 
-int radeon_bo_list_validate(struct list_head *head, void *fence)
+int radeon_bo_list_validate(struct list_head *head)
 {
         struct radeon_bo_list *lobj;
         struct radeon_bo *bo;
-        struct radeon_fence *old_fence = NULL;
         int r;
 
         r = radeon_bo_list_reserve(head);
@@ -334,32 +333,27 @@ int radeon_bo_list_validate(struct list_head *head, void *fence)
                 }
                 lobj->gpu_offset = radeon_bo_gpu_offset(bo);
                 lobj->tiling_flags = bo->tiling_flags;
-                if (fence) {
-                        old_fence = (struct radeon_fence *)bo->tbo.sync_obj;
-                        bo->tbo.sync_obj = radeon_fence_ref(fence);
-                        bo->tbo.sync_obj_arg = NULL;
-                }
-                if (old_fence) {
-                        radeon_fence_unref(&old_fence);
-                }
         }
         return 0;
 }
 
-void radeon_bo_list_unvalidate(struct list_head *head, void *fence)
+void radeon_bo_list_fence(struct list_head *head, void *fence)
 {
         struct radeon_bo_list *lobj;
-        struct radeon_fence *old_fence;
-
-        if (fence)
-                list_for_each_entry(lobj, head, list) {
-                        old_fence = to_radeon_fence(lobj->bo->tbo.sync_obj);
-                        if (old_fence == fence) {
-                                lobj->bo->tbo.sync_obj = NULL;
-                                radeon_fence_unref(&old_fence);
-                        }
+        struct radeon_bo *bo;
+        struct radeon_fence *old_fence = NULL;
+
+        list_for_each_entry(lobj, head, list) {
+                bo = lobj->bo;
+                spin_lock(&bo->tbo.lock);
+                old_fence = (struct radeon_fence *)bo->tbo.sync_obj;
+                bo->tbo.sync_obj = radeon_fence_ref(fence);
+                bo->tbo.sync_obj_arg = NULL;
+                spin_unlock(&bo->tbo.lock);
+                if (old_fence) {
+                        radeon_fence_unref(&old_fence);
                 }
-        radeon_bo_list_unreserve(head);
+        }
 }
 
 int radeon_bo_fbdev_mmap(struct radeon_bo *bo,
diff --git a/drivers/gpu/drm/radeon/radeon_object.h b/drivers/gpu/drm/radeon/radeon_object.h
index a02f18011ad1..7ab43de1e244 100644
--- a/drivers/gpu/drm/radeon/radeon_object.h
+++ b/drivers/gpu/drm/radeon/radeon_object.h
@@ -156,8 +156,8 @@ extern void radeon_bo_list_add_object(struct radeon_bo_list *lobj,
                                 struct list_head *head);
 extern int radeon_bo_list_reserve(struct list_head *head);
 extern void radeon_bo_list_unreserve(struct list_head *head);
-extern int radeon_bo_list_validate(struct list_head *head, void *fence);
-extern void radeon_bo_list_unvalidate(struct list_head *head, void *fence);
+extern int radeon_bo_list_validate(struct list_head *head);
+extern void radeon_bo_list_fence(struct list_head *head, void *fence);
 extern int radeon_bo_fbdev_mmap(struct radeon_bo *bo,
                                 struct vm_area_struct *vma);
 extern int radeon_bo_set_tiling_flags(struct radeon_bo *bo,
diff --git a/drivers/gpu/drm/radeon/radeon_ring.c b/drivers/gpu/drm/radeon/radeon_ring.c
index 4d12b2d17b4d..6579eb4c1f28 100644
--- a/drivers/gpu/drm/radeon/radeon_ring.c
+++ b/drivers/gpu/drm/radeon/radeon_ring.c
@@ -41,68 +41,55 @@ int radeon_ib_get(struct radeon_device *rdev, struct radeon_ib **ib)
 {
         struct radeon_fence *fence;
         struct radeon_ib *nib;
-        unsigned long i;
-        int r = 0;
+        int r = 0, i, c;
 
         *ib = NULL;
         r = radeon_fence_create(rdev, &fence);
         if (r) {
-                DRM_ERROR("failed to create fence for new IB\n");
+                dev_err(rdev->dev, "failed to create fence for new IB\n");
                 return r;
         }
         mutex_lock(&rdev->ib_pool.mutex);
-        i = find_first_zero_bit(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
-        if (i < RADEON_IB_POOL_SIZE) {
-                set_bit(i, rdev->ib_pool.alloc_bm);
-                rdev->ib_pool.ibs[i].length_dw = 0;
-                *ib = &rdev->ib_pool.ibs[i];
-                mutex_unlock(&rdev->ib_pool.mutex);
-                goto out;
+        for (i = rdev->ib_pool.head_id, c = 0, nib = NULL; c < RADEON_IB_POOL_SIZE; c++, i++) {
+                i &= (RADEON_IB_POOL_SIZE - 1);
+                if (rdev->ib_pool.ibs[i].free) {
+                        nib = &rdev->ib_pool.ibs[i];
+                        break;
+                }
         }
-        if (list_empty(&rdev->ib_pool.scheduled_ibs)) {
-                /* we go do nothings here */
+        if (nib == NULL) {
+                /* This should never happen, it means we allocated all
+                 * IB and haven't scheduled one yet, return EBUSY to
+                 * userspace hoping that on ioctl recall we get better
+                 * luck
+                 */
+                dev_err(rdev->dev, "no free indirect buffer !\n");
                 mutex_unlock(&rdev->ib_pool.mutex);
-                DRM_ERROR("all IB allocated none scheduled.\n");
-                r = -EINVAL;
-                goto out;
+                radeon_fence_unref(&fence);
+                return -EBUSY;
         }
-        /* get the first ib on the scheduled list */
-        nib = list_entry(rdev->ib_pool.scheduled_ibs.next,
-                         struct radeon_ib, list);
-        if (nib->fence == NULL) {
-                /* we go do nothings here */
+        rdev->ib_pool.head_id = (nib->idx + 1) & (RADEON_IB_POOL_SIZE - 1);
+        nib->free = false;
+        if (nib->fence) {
                 mutex_unlock(&rdev->ib_pool.mutex);
-                DRM_ERROR("IB %lu scheduled without a fence.\n", nib->idx);
-                r = -EINVAL;
-                goto out;
-        }
-        mutex_unlock(&rdev->ib_pool.mutex);
-
-        r = radeon_fence_wait(nib->fence, false);
-        if (r) {
-                DRM_ERROR("radeon: IB(%lu:0x%016lX:%u)\n", nib->idx,
-                          (unsigned long)nib->gpu_addr, nib->length_dw);
-                DRM_ERROR("radeon: GPU lockup detected, fail to get a IB\n");
-                goto out;
+                r = radeon_fence_wait(nib->fence, false);
+                if (r) {
+                        dev_err(rdev->dev, "error waiting fence of IB(%u:0x%016lX:%u)\n",
+                                nib->idx, (unsigned long)nib->gpu_addr, nib->length_dw);
+                        mutex_lock(&rdev->ib_pool.mutex);
+                        nib->free = true;
+                        mutex_unlock(&rdev->ib_pool.mutex);
+                        radeon_fence_unref(&fence);
+                        return r;
+                }
+                mutex_lock(&rdev->ib_pool.mutex);
         }
         radeon_fence_unref(&nib->fence);
-
+        nib->fence = fence;
         nib->length_dw = 0;
-
-        /* scheduled list is accessed here */
-        mutex_lock(&rdev->ib_pool.mutex);
-        list_del(&nib->list);
-        INIT_LIST_HEAD(&nib->list);
         mutex_unlock(&rdev->ib_pool.mutex);
-
         *ib = nib;
-out:
-        if (r) {
-                radeon_fence_unref(&fence);
-        } else {
-                (*ib)->fence = fence;
-        }
-        return r;
+        return 0;
 }
 
 void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib **ib)
@@ -113,19 +100,10 @@ void radeon_ib_free(struct radeon_device *rdev, struct radeon_ib **ib)
         if (tmp == NULL) {
                 return;
         }
-        mutex_lock(&rdev->ib_pool.mutex);
-        if (!list_empty(&tmp->list) && !radeon_fence_signaled(tmp->fence)) {
-                /* IB is scheduled & not signaled don't do anythings */
-                mutex_unlock(&rdev->ib_pool.mutex);
-                return;
-        }
-        list_del(&tmp->list);
-        INIT_LIST_HEAD(&tmp->list);
-        if (tmp->fence)
+        if (!tmp->fence->emited)
                 radeon_fence_unref(&tmp->fence);
-
-        tmp->length_dw = 0;
-        clear_bit(tmp->idx, rdev->ib_pool.alloc_bm);
+        mutex_lock(&rdev->ib_pool.mutex);
+        tmp->free = true;
         mutex_unlock(&rdev->ib_pool.mutex);
 }
 
@@ -135,7 +113,7 @@ int radeon_ib_schedule(struct radeon_device *rdev, struct radeon_ib *ib)
 
         if (!ib->length_dw || !rdev->cp.ready) {
                 /* TODO: Nothings in the ib we should report. */
-                DRM_ERROR("radeon: couldn't schedule IB(%lu).\n", ib->idx);
+                DRM_ERROR("radeon: couldn't schedule IB(%u).\n", ib->idx);
                 return -EINVAL;
         }
 
@@ -148,7 +126,8 @@ int radeon_ib_schedule(struct radeon_device *rdev, struct radeon_ib *ib)
         radeon_ring_ib_execute(rdev, ib);
         radeon_fence_emit(rdev, ib->fence);
         mutex_lock(&rdev->ib_pool.mutex);
-        list_add_tail(&ib->list, &rdev->ib_pool.scheduled_ibs);
+        /* once scheduled IB is considered free and protected by the fence */
+        ib->free = true;
         mutex_unlock(&rdev->ib_pool.mutex);
         radeon_ring_unlock_commit(rdev);
         return 0;
@@ -164,7 +143,6 @@ int radeon_ib_pool_init(struct radeon_device *rdev)
         if (rdev->ib_pool.robj)
                 return 0;
         /* Allocate 1M object buffer */
-        INIT_LIST_HEAD(&rdev->ib_pool.scheduled_ibs);
         r = radeon_bo_create(rdev, NULL,  RADEON_IB_POOL_SIZE*64*1024,
                                 true, RADEON_GEM_DOMAIN_GTT,
                                 &rdev->ib_pool.robj);
@@ -195,9 +173,9 @@ int radeon_ib_pool_init(struct radeon_device *rdev)
                 rdev->ib_pool.ibs[i].ptr = ptr + offset;
                 rdev->ib_pool.ibs[i].idx = i;
                 rdev->ib_pool.ibs[i].length_dw = 0;
-                INIT_LIST_HEAD(&rdev->ib_pool.ibs[i].list);
+                rdev->ib_pool.ibs[i].free = true;
         }
-        bitmap_zero(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
+        rdev->ib_pool.head_id = 0;
         rdev->ib_pool.ready = true;
         DRM_INFO("radeon: ib pool ready.\n");
         if (radeon_debugfs_ib_init(rdev)) {
@@ -214,7 +192,6 @@ void radeon_ib_pool_fini(struct radeon_device *rdev)
                 return;
         }
         mutex_lock(&rdev->ib_pool.mutex);
-        bitmap_zero(rdev->ib_pool.alloc_bm, RADEON_IB_POOL_SIZE);
         if (rdev->ib_pool.robj) {
                 r = radeon_bo_reserve(rdev->ib_pool.robj, false);
                 if (likely(r == 0)) {
@@ -363,7 +340,7 @@ static int radeon_debugfs_ib_info(struct seq_file *m, void *data)
         if (ib == NULL) {
                 return 0;
         }
-        seq_printf(m, "IB %04lu\n", ib->idx);
+        seq_printf(m, "IB %04u\n", ib->idx);
         seq_printf(m, "IB fence %p\n", ib->fence);
         seq_printf(m, "IB size %05u dwords\n", ib->length_dw);
         for (i = 0; i < ib->length_dw; i++) {
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index 5943d561fd1e..03021674d097 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -549,9 +549,12 @@ static void rv770_gpu_init(struct radeon_device *rdev)
 
         gb_tiling_config |= BANK_SWAPS(1);
 
-        backend_map = r700_get_tile_pipe_to_backend_map(rdev->config.rv770.max_tile_pipes,
-                                                        rdev->config.rv770.max_backends,
-                                                        (0xff << rdev->config.rv770.max_backends) & 0xff);
+        if (rdev->family == CHIP_RV740)
+                backend_map = 0x28;
+        else
+                backend_map = r700_get_tile_pipe_to_backend_map(rdev->config.rv770.max_tile_pipes,
+                                                                rdev->config.rv770.max_backends,
+                                                                (0xff << rdev->config.rv770.max_backends) & 0xff);
         gb_tiling_config |= BACKEND_MAP(backend_map);
 
         cc_gc_shader_pipe_config =
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 1a3e909b7bba..c7320ce4567d 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -1020,6 +1020,12 @@ static int ttm_bo_mem_compat(struct ttm_placement *placement,
                              struct ttm_mem_reg *mem)
 {
         int i;
+        struct drm_mm_node *node = mem->mm_node;
+
+        if (node && placement->lpfn != 0 &&
+            (node->start < placement->fpfn ||
+             node->start + node->size > placement->lpfn))
+                return -1;
 
         for (i = 0; i < placement->num_placement; i++) {
                 if ((placement->placement[i] & mem->placement &
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index e2123af7775a..3d47a2c12322 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -196,14 +196,15 @@ EXPORT_SYMBOL(ttm_tt_populate);
 
 #ifdef CONFIG_X86
 static inline int ttm_tt_set_page_caching(struct page *p,
-                                          enum ttm_caching_state c_state)
+                                          enum ttm_caching_state c_old,
+                                          enum ttm_caching_state c_new)
 {
         int ret = 0;
 
         if (PageHighMem(p))
                 return 0;
 
-        if (get_page_memtype(p) != -1) {
+        if (c_old != tt_cached) {
                 /* p isn't in the default caching state, set it to
                  * writeback first to free its current memtype. */
 
@@ -212,16 +213,17 @@ static inline int ttm_tt_set_page_caching(struct page *p,
                         return ret;
         }
 
-        if (c_state == tt_wc)
+        if (c_new == tt_wc)
                 ret = set_memory_wc((unsigned long) page_address(p), 1);
-        else if (c_state == tt_uncached)
+        else if (c_new == tt_uncached)
                 ret = set_pages_uc(p, 1);
 
         return ret;
 }
 #else /* CONFIG_X86 */
 static inline int ttm_tt_set_page_caching(struct page *p,
-                                          enum ttm_caching_state c_state)
+                                          enum ttm_caching_state c_old,
+                                          enum ttm_caching_state c_new)
 {
         return 0;
 }
@@ -254,7 +256,9 @@ static int ttm_tt_set_caching(struct ttm_tt *ttm,
         for (i = 0; i < ttm->num_pages; ++i) {
                 cur_page = ttm->pages[i];
                 if (likely(cur_page != NULL)) {
-                        ret = ttm_tt_set_page_caching(cur_page, c_state);
+                        ret = ttm_tt_set_page_caching(cur_page,
+                                                      ttm->caching_state,
+                                                      c_state);
                         if (unlikely(ret != 0))
                                 goto out_err;
                 }
@@ -268,7 +272,7 @@ out_err:
         for (j = 0; j < i; ++j) {
                 cur_page = ttm->pages[j];
                 if (likely(cur_page != NULL)) {
-                        (void)ttm_tt_set_page_caching(cur_page,
+                        (void)ttm_tt_set_page_caching(cur_page, c_state,
                                                       ttm->caching_state);
                 }
         }
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
index a6e8f687fa64..0c9c0811f42d 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_drv.c
@@ -348,22 +348,19 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
                  */
 
                 DRM_INFO("It appears like vesafb is loaded. "
-                         "Ignore above error if any. Entering stealth mode.\n");
+                         "Ignore above error if any.\n");
                 ret = pci_request_region(dev->pdev, 2, "vmwgfx stealth probe");
                 if (unlikely(ret != 0)) {
                         DRM_ERROR("Failed reserving the SVGA MMIO resource.\n");
                         goto out_no_device;
                 }
-                vmw_kms_init(dev_priv);
-                vmw_overlay_init(dev_priv);
-        } else {
-                ret = vmw_request_device(dev_priv);
-                if (unlikely(ret != 0))
-                        goto out_no_device;
-                vmw_kms_init(dev_priv);
-                vmw_overlay_init(dev_priv);
-                vmw_fb_init(dev_priv);
         }
+        ret = vmw_request_device(dev_priv);
+        if (unlikely(ret != 0))
+                goto out_no_device;
+        vmw_kms_init(dev_priv);
+        vmw_overlay_init(dev_priv);
+        vmw_fb_init(dev_priv);
 
         dev_priv->pm_nb.notifier_call = vmwgfx_pm_notifier;
         register_pm_notifier(&dev_priv->pm_nb);
@@ -406,17 +403,15 @@ static int vmw_driver_unload(struct drm_device *dev)
 
         unregister_pm_notifier(&dev_priv->pm_nb);
 
-        if (!dev_priv->stealth) {
-                vmw_fb_close(dev_priv);
-                vmw_kms_close(dev_priv);
-                vmw_overlay_close(dev_priv);
-                vmw_release_device(dev_priv);
-                pci_release_regions(dev->pdev);
-        } else {
-                vmw_kms_close(dev_priv);
-                vmw_overlay_close(dev_priv);
+        vmw_fb_close(dev_priv);
+        vmw_kms_close(dev_priv);
+        vmw_overlay_close(dev_priv);
+        vmw_release_device(dev_priv);
+        if (dev_priv->stealth)
                 pci_release_region(dev->pdev, 2);
-        }
+        else
+                pci_release_regions(dev->pdev);
+
         if (dev_priv->capabilities & SVGA_CAP_IRQMASK)
                 drm_irq_uninstall(dev_priv->dev);
         if (dev->devname == vmw_devname)
@@ -585,11 +580,6 @@ static int vmw_master_set(struct drm_device *dev,
         int ret = 0;
 
         DRM_INFO("Master set.\n");
-        if (dev_priv->stealth) {
-                ret = vmw_request_device(dev_priv);
-                if (unlikely(ret != 0))
-                        return ret;
-        }
 
         if (active) {
                 BUG_ON(active != &dev_priv->fbdev_master);
@@ -649,18 +639,11 @@ static void vmw_master_drop(struct drm_device *dev,
 
         ttm_lock_set_kill(&vmaster->lock, true, SIGTERM);
 
-        if (dev_priv->stealth) {
-                ret = ttm_bo_evict_mm(&dev_priv->bdev, TTM_PL_VRAM);
-                if (unlikely(ret != 0))
-                        DRM_ERROR("Unable to clean VRAM on master drop.\n");
-                vmw_release_device(dev_priv);
-        }
         dev_priv->active_master = &dev_priv->fbdev_master;
         ttm_lock_set_kill(&dev_priv->fbdev_master.lock, false, SIGTERM);
         ttm_vt_unlock(&dev_priv->fbdev_master.lock);
 
-        if (!dev_priv->stealth)
-                vmw_fb_on(dev_priv);
+        vmw_fb_on(dev_priv);
 }
 
 
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
index d69caf92ffe7..0897359b3e4e 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
@@ -182,25 +182,19 @@ static int vmw_cmd_present_check(struct vmw_private *dev_priv,
         return vmw_cmd_sid_check(dev_priv, sw_context, &cmd->body.sid);
 }
 
-static int vmw_cmd_dma(struct vmw_private *dev_priv,
-                       struct vmw_sw_context *sw_context,
-                       SVGA3dCmdHeader *header)
+static int vmw_translate_guest_ptr(struct vmw_private *dev_priv,
+                                   struct vmw_sw_context *sw_context,
+                                   SVGAGuestPtr *ptr,
+                                   struct vmw_dma_buffer **vmw_bo_p)
 {
-        uint32_t handle;
         struct vmw_dma_buffer *vmw_bo = NULL;
         struct ttm_buffer_object *bo;
-        struct vmw_surface *srf = NULL;
-        struct vmw_dma_cmd {
-                SVGA3dCmdHeader header;
-                SVGA3dCmdSurfaceDMA dma;
-        } *cmd;
+        uint32_t handle = ptr->gmrId;
         struct vmw_relocation *reloc;
-        int ret;
         uint32_t cur_validate_node;
         struct ttm_validate_buffer *val_buf;
+        int ret;
 
-        cmd = container_of(header, struct vmw_dma_cmd, header);
-        handle = cmd->dma.guest.ptr.gmrId;
         ret = vmw_user_dmabuf_lookup(sw_context->tfile, handle, &vmw_bo);
         if (unlikely(ret != 0)) {
                 DRM_ERROR("Could not find or use GMR region.\n");
@@ -209,14 +203,14 @@ static int vmw_cmd_dma(struct vmw_private *dev_priv,
         bo = &vmw_bo->base;
 
         if (unlikely(sw_context->cur_reloc >= VMWGFX_MAX_RELOCATIONS)) {
-                DRM_ERROR("Max number of DMA commands per submission"
+                DRM_ERROR("Max number relocations per submission"
                           " exceeded\n");
                 ret = -EINVAL;
                 goto out_no_reloc;
         }
 
         reloc = &sw_context->relocs[sw_context->cur_reloc++];
-        reloc->location = &cmd->dma.guest.ptr;
+        reloc->location = ptr;
 
         cur_validate_node = vmw_dmabuf_validate_node(bo, sw_context->cur_val_buf);
         if (unlikely(cur_validate_node >= VMWGFX_MAX_GMRS)) {
@@ -234,7 +228,89 @@ static int vmw_cmd_dma(struct vmw_private *dev_priv,
                 list_add_tail(&val_buf->head, &sw_context->validate_nodes);
                 ++sw_context->cur_val_buf;
         }
+        *vmw_bo_p = vmw_bo;
+        return 0;
+
+out_no_reloc:
+        vmw_dmabuf_unreference(&vmw_bo);
+        vmw_bo_p = NULL;
+        return ret;
+}
+
+static int vmw_cmd_end_query(struct vmw_private *dev_priv,
+                             struct vmw_sw_context *sw_context,
+                             SVGA3dCmdHeader *header)
+{
+        struct vmw_dma_buffer *vmw_bo;
+        struct vmw_query_cmd {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdEndQuery q;
+        } *cmd;
+        int ret;
+
+        cmd = container_of(header, struct vmw_query_cmd, header);
+        ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
+        if (unlikely(ret != 0))
+                return ret;
+
+        ret = vmw_translate_guest_ptr(dev_priv, sw_context,
+                                      &cmd->q.guestResult,
+                                      &vmw_bo);
+        if (unlikely(ret != 0))
+                return ret;
+
+        vmw_dmabuf_unreference(&vmw_bo);
+        return 0;
+}
 
+static int vmw_cmd_wait_query(struct vmw_private *dev_priv,
+                              struct vmw_sw_context *sw_context,
+                              SVGA3dCmdHeader *header)
+{
+        struct vmw_dma_buffer *vmw_bo;
+        struct vmw_query_cmd {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdWaitForQuery q;
+        } *cmd;
+        int ret;
+
+        cmd = container_of(header, struct vmw_query_cmd, header);
+        ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
+        if (unlikely(ret != 0))
+                return ret;
+
+        ret = vmw_translate_guest_ptr(dev_priv, sw_context,
+                                      &cmd->q.guestResult,
+                                      &vmw_bo);
+        if (unlikely(ret != 0))
+                return ret;
+
+        vmw_dmabuf_unreference(&vmw_bo);
+        return 0;
+}
+
+
+static int vmw_cmd_dma(struct vmw_private *dev_priv,
+                       struct vmw_sw_context *sw_context,
+                       SVGA3dCmdHeader *header)
+{
+        struct vmw_dma_buffer *vmw_bo = NULL;
+        struct ttm_buffer_object *bo;
+        struct vmw_surface *srf = NULL;
+        struct vmw_dma_cmd {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdSurfaceDMA dma;
+        } *cmd;
+        int ret;
+
+        cmd = container_of(header, struct vmw_dma_cmd, header);
+        ret = vmw_translate_guest_ptr(dev_priv, sw_context,
+                                      &cmd->dma.guest.ptr,
+                                      &vmw_bo);
+        if (unlikely(ret != 0))
+                return ret;
+
+        bo = &vmw_bo->base;
         ret = vmw_user_surface_lookup_handle(dev_priv, sw_context->tfile,
                                              cmd->dma.host.sid, &srf);
         if (ret) {
@@ -379,8 +455,8 @@ static vmw_cmd_func vmw_cmd_funcs[SVGA_3D_CMD_MAX] = {
         VMW_CMD_DEF(SVGA_3D_CMD_DRAW_PRIMITIVES, &vmw_cmd_draw),
         VMW_CMD_DEF(SVGA_3D_CMD_SETSCISSORRECT, &vmw_cmd_cid_check),
         VMW_CMD_DEF(SVGA_3D_CMD_BEGIN_QUERY, &vmw_cmd_cid_check),
-        VMW_CMD_DEF(SVGA_3D_CMD_END_QUERY, &vmw_cmd_cid_check),
-        VMW_CMD_DEF(SVGA_3D_CMD_WAIT_FOR_QUERY, &vmw_cmd_cid_check),
+        VMW_CMD_DEF(SVGA_3D_CMD_END_QUERY, &vmw_cmd_end_query),
+        VMW_CMD_DEF(SVGA_3D_CMD_WAIT_FOR_QUERY, &vmw_cmd_wait_query),
         VMW_CMD_DEF(SVGA_3D_CMD_PRESENT_READBACK, &vmw_cmd_ok),
         VMW_CMD_DEF(SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN,
                     &vmw_cmd_blt_surf_screen_check)
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
index 4f4f6432be8b..a93367041cdc 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
@@ -559,6 +559,9 @@ int vmw_fb_init(struct vmw_private *vmw_priv)
         info->pixmap.scan_align = 1;
 #endif
 
+        info->aperture_base = vmw_priv->vram_start;
+        info->aperture_size = vmw_priv->vram_size;
+
         /*
          * Dirty & Deferred IO
          */
diff --git a/drivers/gpu/vga/vgaarb.c b/drivers/gpu/vga/vgaarb.c
index 24b56dc54597..2f6cf69ecb39 100644
--- a/drivers/gpu/vga/vgaarb.c
+++ b/drivers/gpu/vga/vgaarb.c
@@ -961,7 +961,7 @@ static ssize_t vga_arb_write(struct file *file, const char __user * buf,
                 remaining -= 7;
                 pr_devel("client 0x%p called 'target'\n", priv);
                 /* if target is default */
-                if (!strncmp(kbuf, "default", 7))
+                if (!strncmp(curr_pos, "default", 7))
                         pdev = pci_dev_get(vga_default_device());
                 else {
                         if (!vga_pci_str_to_vars(curr_pos, remaining,
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index 24d90ea246ce..71d4c0703629 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -55,6 +55,12 @@ source "drivers/hid/usbhid/Kconfig"
 menu "Special HID drivers"
         depends on HID
 
+config HID_3M_PCT
+        tristate "3M PCT"
+        depends on USB_HID
+        ---help---
+        Support for 3M PCT touch screens.
+
 config HID_A4TECH
         tristate "A4 tech" if EMBEDDED
         depends on USB_HID
@@ -183,6 +189,23 @@ config LOGIRUMBLEPAD2_FF
           Say Y here if you want to enable force feedback support for Logitech
           Rumblepad 2 devices.
 
+config LOGIG940_FF
+        bool "Logitech Flight System G940 force feedback support"
+        depends on HID_LOGITECH
+        select INPUT_FF_MEMLESS
+        help
+          Say Y here if you want to enable force feedback support for Logitech
+          Flight System G940 devices.
+
+config HID_MAGICMOUSE
+        tristate "Apple MagicMouse multi-touch support"
+        depends on BT_HIDP
+        ---help---
+        Support for the Apple Magic Mouse multi-touch.
+
+        Say Y here if you want support for the multi-touch features of the
+        Apple Wireless "Magic" Mouse.
+
 config HID_MICROSOFT
         tristate "Microsoft" if EMBEDDED
         depends on USB_HID
@@ -190,6 +213,12 @@ config HID_MICROSOFT
         ---help---
         Support for Microsoft devices that are not fully compliant with HID standard.
 
+config HID_MOSART
+        tristate "MosArt"
+        depends on USB_HID
+        ---help---
+        Support for MosArt dual-touch panels.
+
 config HID_MONTEREY
         tristate "Monterey" if EMBEDDED
         depends on USB_HID
@@ -198,12 +227,18 @@ config HID_MONTEREY
         Support for Monterey Genius KB29E.
 
 config HID_NTRIG
-        tristate "NTrig" if EMBEDDED
+        tristate "NTrig"
         depends on USB_HID
-        default !EMBEDDED
         ---help---
         Support for N-Trig touch screen.
 
+config HID_ORTEK
+        tristate "Ortek" if EMBEDDED
+        depends on USB_HID
+        default !EMBEDDED
+        ---help---
+        Support for Ortek WKB-2000 wireless keyboard + mouse trackpad.
+
 config HID_PANTHERLORD
         tristate "Pantherlord support" if EMBEDDED
         depends on USB_HID
@@ -227,6 +262,12 @@ config HID_PETALYNX
         ---help---
         Support for Petalynx Maxter remote control.
 
+config HID_QUANTA
+        tristate "Quanta Optical Touch"
+        depends on USB_HID
+        ---help---
+        Support for Quanta Optical Touch dual-touch panels.
+
 config HID_SAMSUNG
         tristate "Samsung" if EMBEDDED
         depends on USB_HID
@@ -241,6 +282,12 @@ config HID_SONY
         ---help---
         Support for Sony PS3 controller.
 
+config HID_STANTUM
+        tristate "Stantum"
+        depends on USB_HID
+        ---help---
+        Support for Stantum multitouch panel.
+
 config HID_SUNPLUS
         tristate "Sunplus" if EMBEDDED
         depends on USB_HID
@@ -305,9 +352,8 @@ config THRUSTMASTER_FF
           Rumble Force or Force Feedback Wheel.
 
 config HID_WACOM
-        tristate "Wacom Bluetooth devices support" if EMBEDDED
+        tristate "Wacom Bluetooth devices support"
         depends on BT_HIDP
-        default !EMBEDDED
         ---help---
         Support for Wacom Graphire Bluetooth tablet.
 
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 0de2dff5542c..0b2618f092ca 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -18,7 +18,11 @@ endif
 ifdef CONFIG_LOGIRUMBLEPAD2_FF
         hid-logitech-objs       += hid-lg2ff.o
 endif
+ifdef CONFIG_LOGIG940_FF
+        hid-logitech-objs       += hid-lg3ff.o
+endif
 
+obj-$(CONFIG_HID_3M_PCT)        += hid-3m-pct.o
 obj-$(CONFIG_HID_A4TECH)        += hid-a4tech.o
 obj-$(CONFIG_HID_APPLE)         += hid-apple.o
 obj-$(CONFIG_HID_BELKIN)        += hid-belkin.o
@@ -31,14 +35,19 @@ obj-$(CONFIG_HID_GYRATION)	+= hid-gyration.o
 obj-$(CONFIG_HID_KENSINGTON)    += hid-kensington.o
 obj-$(CONFIG_HID_KYE)           += hid-kye.o
 obj-$(CONFIG_HID_LOGITECH)      += hid-logitech.o
+obj-$(CONFIG_HID_MAGICMOUSE)    += hid-magicmouse.o
 obj-$(CONFIG_HID_MICROSOFT)     += hid-microsoft.o
 obj-$(CONFIG_HID_MONTEREY)      += hid-monterey.o
+obj-$(CONFIG_HID_MOSART)        += hid-mosart.o
 obj-$(CONFIG_HID_NTRIG)         += hid-ntrig.o
+obj-$(CONFIG_HID_ORTEK)         += hid-ortek.o
+obj-$(CONFIG_HID_QUANTA)        += hid-quanta.o
 obj-$(CONFIG_HID_PANTHERLORD)   += hid-pl.o
 obj-$(CONFIG_HID_PETALYNX)      += hid-petalynx.o
 obj-$(CONFIG_HID_SAMSUNG)       += hid-samsung.o
 obj-$(CONFIG_HID_SMARTJOYPLUS)  += hid-sjoy.o
 obj-$(CONFIG_HID_SONY)          += hid-sony.o
+obj-$(CONFIG_HID_STANTUM)       += hid-stantum.o
 obj-$(CONFIG_HID_SUNPLUS)       += hid-sunplus.o
 obj-$(CONFIG_HID_GREENASIA)     += hid-gaff.o
 obj-$(CONFIG_HID_THRUSTMASTER)  += hid-tmff.o
diff --git a/drivers/hid/hid-3m-pct.c b/drivers/hid/hid-3m-pct.c
new file mode 100644
index 000000000000..2370aefc86b2
--- /dev/null
+++ b/drivers/hid/hid-3m-pct.c
@@ -0,0 +1,290 @@
+/*
+ *  HID driver for 3M PCT multitouch panels
+ *
+ *  Copyright (c) 2009 Stephane Chatty <chatty@enac.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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
+MODULE_DESCRIPTION("3M PCT multitouch panels");
+MODULE_LICENSE("GPL");
+
+#include "hid-ids.h"
+
+struct mmm_finger {
+        __s32 x, y;
+        __u8 rank;
+        bool touch, valid;
+};
+
+struct mmm_data {
+        struct mmm_finger f[10];
+        __u8 curid, num;
+        bool touch, valid;
+};
+
+static int mmm_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        switch (usage->hid & HID_USAGE_PAGE) {
+
+        case HID_UP_BUTTON:
+                return -1;
+
+        case HID_UP_GENDESK:
+                switch (usage->hid) {
+                case HID_GD_X:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_X);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_X,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                case HID_GD_Y:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_Y);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_Y,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                }
+                return 0;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                /* we do not want to map these: no input-oriented meaning */
+                case 0x14:
+                case 0x23:
+                case HID_DG_INPUTMODE:
+                case HID_DG_DEVICEINDEX:
+                case HID_DG_CONTACTCOUNT:
+                case HID_DG_CONTACTMAX:
+                case HID_DG_INRANGE:
+                case HID_DG_CONFIDENCE:
+                        return -1;
+                case HID_DG_TIPSWITCH:
+                        /* touchscreen emulation */
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
+                        return 1;
+                case HID_DG_CONTACTID:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TRACKING_ID);
+                        return 1;
+                }
+                /* let hid-input decide for the others */
+                return 0;
+
+        case 0xff000000:
+                /* we do not want to map these: no input-oriented meaning */
+                return -1;
+        }
+
+        return 0;
+}
+
+static int mmm_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->type == EV_KEY || usage->type == EV_ABS)
+                clear_bit(usage->code, *bit);
+
+        return 0;
+}
+
+/*
+ * this function is called when a whole packet has been received and processed,
+ * so that it can decide what to send to the input layer.
+ */
+static void mmm_filter_event(struct mmm_data *md, struct input_dev *input)
+{
+        struct mmm_finger *oldest = 0;
+        bool pressed = false, released = false;
+        int i;
+
+        /*
+         * we need to iterate on all fingers to decide if we have a press
+         * or a release event in our touchscreen emulation.
+         */
+        for (i = 0; i < 10; ++i) {
+                struct mmm_finger *f = &md->f[i];
+                if (!f->valid) {
+                        /* this finger is just placeholder data, ignore */
+                } else if (f->touch) {
+                        /* this finger is on the screen */
+                        input_event(input, EV_ABS, ABS_MT_TRACKING_ID, i);
+                        input_event(input, EV_ABS, ABS_MT_POSITION_X, f->x);
+                        input_event(input, EV_ABS, ABS_MT_POSITION_Y, f->y);
+                        input_mt_sync(input);
+                        /*
+                         * touchscreen emulation: maintain the age rank
+                         * of this finger, decide if we have a press
+                         */
+                        if (f->rank == 0) {
+                                f->rank = ++(md->num);
+                                if (f->rank == 1)
+                                        pressed = true;
+                        }
+                        if (f->rank == 1)
+                                oldest = f;
+                } else {
+                        /* this finger took off the screen */
+                        /* touchscreen emulation: maintain age rank of others */
+                        int j;
+
+                        for (j = 0; j < 10; ++j) {
+                                struct mmm_finger *g = &md->f[j];
+                                if (g->rank > f->rank) {
+                                        g->rank--;
+                                        if (g->rank == 1)
+                                                oldest = g;
+                                }
+                        }
+                        f->rank = 0;
+                        --(md->num);
+                        if (md->num == 0)
+                                released = true;
+                }
+                f->valid = 0;
+        }
+
+        /* touchscreen emulation */
+        if (oldest) {
+                if (pressed)
+                        input_event(input, EV_KEY, BTN_TOUCH, 1);
+                input_event(input, EV_ABS, ABS_X, oldest->x);
+                input_event(input, EV_ABS, ABS_Y, oldest->y);
+        } else if (released) {
+                input_event(input, EV_KEY, BTN_TOUCH, 0);
+        }
+}
+
+/*
+ * this function is called upon all reports
+ * so that we can accumulate contact point information,
+ * and call input_mt_sync after each point.
+ */
+static int mmm_event(struct hid_device *hid, struct hid_field *field,
+                                struct hid_usage *usage, __s32 value)
+{
+        struct mmm_data *md = hid_get_drvdata(hid);
+        /*
+         * strangely, this function can be called before
+         * field->hidinput is initialized!
+         */
+        if (hid->claimed & HID_CLAIMED_INPUT) {
+                struct input_dev *input = field->hidinput->input;
+                switch (usage->hid) {
+                case HID_DG_TIPSWITCH:
+                        md->touch = value;
+                        break;
+                case HID_DG_CONFIDENCE:
+                        md->valid = value;
+                        break;
+                case HID_DG_CONTACTID:
+                        if (md->valid) {
+                                md->curid = value;
+                                md->f[value].touch = md->touch;
+                                md->f[value].valid = 1;
+                        }
+                        break;
+                case HID_GD_X:
+                        if (md->valid)
+                                md->f[md->curid].x = value;
+                        break;
+                case HID_GD_Y:
+                        if (md->valid)
+                                md->f[md->curid].y = value;
+                        break;
+                case HID_DG_CONTACTCOUNT:
+                        mmm_filter_event(md, input);
+                        break;
+                }
+        }
+
+        /* we have handled the hidinput part, now remains hiddev */
+        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
+
+        return 1;
+}
+
+static int mmm_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        struct mmm_data *md;
+
+        md = kzalloc(sizeof(struct mmm_data), GFP_KERNEL);
+        if (!md) {
+                dev_err(&hdev->dev, "cannot allocate 3M data\n");
+                return -ENOMEM;
+        }
+        hid_set_drvdata(hdev, md);
+
+        ret = hid_parse(hdev);
+        if (!ret)
+                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+
+        if (ret)
+                kfree(md);
+        return ret;
+}
+
+static void mmm_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+        hid_set_drvdata(hdev, NULL);
+}
+
+static const struct hid_device_id mmm_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, mmm_devices);
+
+static const struct hid_usage_id mmm_grabbed_usages[] = {
+        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+};
+
+static struct hid_driver mmm_driver = {
+        .name = "3m-pct",
+        .id_table = mmm_devices,
+        .probe = mmm_probe,
+        .remove = mmm_remove,
+        .input_mapping = mmm_input_mapping,
+        .input_mapped = mmm_input_mapped,
+        .usage_table = mmm_grabbed_usages,
+        .event = mmm_event,
+};
+
+static int __init mmm_init(void)
+{
+        return hid_register_driver(&mmm_driver);
+}
+
+static void __exit mmm_exit(void)
+{
+        hid_unregister_driver(&mmm_driver);
+}
+
+module_init(mmm_init);
+module_exit(mmm_exit);
+MODULE_LICENSE("GPL");
+
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index 5b4d66dc1a05..78286b184ace 100644
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -40,6 +40,11 @@ module_param(fnmode, uint, 0644);
 MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
                 "[1] = fkeyslast, 2 = fkeysfirst)");
 
+static unsigned int iso_layout = 1;
+module_param(iso_layout, uint, 0644);
+MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. "
+                "(0 = disabled, [1] = enabled)");
+
 struct apple_sc {
         unsigned long quirks;
         unsigned int fn_on;
@@ -199,11 +204,13 @@ static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
                 }
         }
 
-        if (asc->quirks & APPLE_ISO_KEYBOARD) {
-                trans = apple_find_translation(apple_iso_keyboard, usage->code);
-                if (trans) {
-                        input_event(input, usage->type, trans->to, value);
-                        return 1;
+        if (iso_layout) {
+                if (asc->quirks & APPLE_ISO_KEYBOARD) {
+                        trans = apple_find_translation(apple_iso_keyboard, usage->code);
+                        if (trans) {
+                                input_event(input, usage->type, trans->to, value);
+                                return 1;
+                        }
                 }
         }
 
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index eabe5f87c6c1..368fbb0c4ca6 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -4,7 +4,7 @@
  *  Copyright (c) 1999 Andreas Gal
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
- *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2006-2010 Jiri Kosina
  */
 
 /*
@@ -51,7 +51,7 @@ EXPORT_SYMBOL_GPL(hid_debug);
  * Register a new report for a device.
  */
 
-static struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
+struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
 {
         struct hid_report_enum *report_enum = device->report_enum + type;
         struct hid_report *report;
@@ -75,6 +75,7 @@ static struct hid_report *hid_register_report(struct hid_device *device, unsigne
 
         return report;
 }
+EXPORT_SYMBOL_GPL(hid_register_report);
 
 /*
  * Register a new field for this report.
@@ -387,7 +388,8 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
         __u32 data;
         unsigned n;
 
-        if (item->size == 0) {
+        /* Local delimiter could have value 0, which allows size to be 0 */
+        if (item->size == 0 && item->tag != HID_LOCAL_ITEM_TAG_DELIMITER) {
                 dbg_hid("item data expected for local item\n");
                 return -1;
         }
@@ -1248,11 +1250,13 @@ EXPORT_SYMBOL_GPL(hid_disconnect);
 
 /* a list of devices for which there is a specialized driver on HID bus */
 static const struct hid_device_id hid_blacklist[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_3M, USB_DEVICE_ID_3M1968) },
         { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_WCP32PU) },
         { HID_USB_DEVICE(USB_VENDOR_ID_A4TECH, USB_DEVICE_ID_A4TECH_X5_005D) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI) },
@@ -1324,6 +1328,7 @@ static const struct hid_device_id hid_blacklist[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
@@ -1337,10 +1342,15 @@ static const struct hid_device_id hid_blacklist[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
         { HID_USB_DEVICE(USB_VENDOR_ID_NTRIG, USB_DEVICE_ID_NTRIG_TOUCH_SCREEN) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
         { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SAMSUNG, USB_DEVICE_ID_SAMSUNG_IR_REMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SUNPLUS, USB_DEVICE_ID_SUNPLUS_WDESKTOP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
         { HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
@@ -1543,8 +1553,9 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_AIPTEK, USB_DEVICE_ID_AIPTEK_24) },
         { HID_USB_DEVICE(USB_VENDOR_ID_AIRCABLE, USB_DEVICE_ID_AIRCABLE1) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ALCOR, USB_DEVICE_ID_ALCOR_USBRS232) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM)},
-        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_LCM2)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM)},
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_LCM2)},
         { HID_USB_DEVICE(USB_VENDOR_ID_AVERMEDIA, USB_DEVICE_ID_AVER_FM_MR800) },
         { HID_USB_DEVICE(USB_VENDOR_ID_BERKSHIRE, USB_DEVICE_ID_BERKSHIRE_PCWD) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CIDC, 0x0103) },
@@ -1661,8 +1672,6 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_PANJIT, 0x0004) },
         { HID_USB_DEVICE(USB_VENDOR_ID_PHILIPS, USB_DEVICE_ID_PHILIPS_IEEE802154_DONGLE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_POWERCOM, USB_DEVICE_ID_POWERCOM_UPS) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY1) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },
diff --git a/drivers/hid/hid-debug.c b/drivers/hid/hid-debug.c
index 6abd0369aedb..cd4ece6fdfb9 100644
--- a/drivers/hid/hid-debug.c
+++ b/drivers/hid/hid-debug.c
@@ -864,13 +864,13 @@ static const char **names[EV_MAX + 1] = {
         [EV_SND] = sounds,                      [EV_REP] = repeats,
 };
 
-void hid_resolv_event(__u8 type, __u16 code, struct seq_file *f) {
-
+static void hid_resolv_event(__u8 type, __u16 code, struct seq_file *f)
+{
         seq_printf(f, "%s.%s", events[type] ? events[type] : "?",
                 names[type] ? (names[type][code] ? names[type][code] : "?") : "?");
 }
 
-void hid_dump_input_mapping(struct hid_device *hid, struct seq_file *f)
+static void hid_dump_input_mapping(struct hid_device *hid, struct seq_file *f)
 {
         int i, j, k;
         struct hid_report *report;
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 010368e649ed..72c05f90553c 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -18,6 +18,9 @@
 #ifndef HID_IDS_H_FILE
 #define HID_IDS_H_FILE
 
+#define USB_VENDOR_ID_3M                0x0596
+#define USB_DEVICE_ID_3M1968            0x0500
+
 #define USB_VENDOR_ID_A4TECH            0x09da
 #define USB_DEVICE_ID_A4TECH_WCP32PU    0x0006
 #define USB_DEVICE_ID_A4TECH_X5_005D    0x000a
@@ -56,6 +59,7 @@
 
 #define USB_VENDOR_ID_APPLE             0x05ac
 #define USB_DEVICE_ID_APPLE_MIGHTYMOUSE 0x0304
+#define USB_DEVICE_ID_APPLE_MAGICMOUSE  0x030d
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI       0x020e
 #define USB_DEVICE_ID_APPLE_FOUNTAIN_ISO        0x020f
 #define USB_DEVICE_ID_APPLE_GEYSER_ANSI 0x0214
@@ -96,9 +100,12 @@
 #define USB_DEVICE_ID_APPLE_ATV_IRCONTROL       0x8241
 #define USB_DEVICE_ID_APPLE_IRCONTROL4  0x8242
 
-#define USB_VENDOR_ID_ASUS              0x0b05
-#define USB_DEVICE_ID_ASUS_LCM          0x1726
-#define USB_DEVICE_ID_ASUS_LCM2         0x175b
+#define USB_VENDOR_ID_ASUS              0x0486
+#define USB_DEVICE_ID_ASUS_T91MT        0x0185
+
+#define USB_VENDOR_ID_ASUSTEK           0x0b05
+#define USB_DEVICE_ID_ASUSTEK_LCM       0x1726
+#define USB_DEVICE_ID_ASUSTEK_LCM2      0x175b
 
 #define USB_VENDOR_ID_ATEN              0x0557
 #define USB_DEVICE_ID_ATEN_UC100KM      0x2004
@@ -169,6 +176,9 @@
 #define USB_VENDOR_ID_ESSENTIAL_REALITY 0x0d7f
 #define USB_DEVICE_ID_ESSENTIAL_REALITY_P5 0x0100
 
+#define USB_VENDOR_ID_ETURBOTOUCH       0x22b9
+#define USB_DEVICE_ID_ETURBOTOUCH       0x0006
+
 #define USB_VENDOR_ID_ETT               0x0664
 #define USB_DEVICE_ID_TC5UH             0x0309
 
@@ -303,6 +313,7 @@
 #define USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2     0xc219
 #define USB_DEVICE_ID_LOGITECH_WINGMAN_F3D      0xc283
 #define USB_DEVICE_ID_LOGITECH_FORCE3D_PRO      0xc286
+#define USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940       0xc287
 #define USB_DEVICE_ID_LOGITECH_WHEEL    0xc294
 #define USB_DEVICE_ID_LOGITECH_WINGMAN_FFG      0xc293
 #define USB_DEVICE_ID_LOGITECH_MOMO_WHEEL       0xc295
@@ -365,6 +376,9 @@
 #define USB_VENDOR_ID_ONTRAK            0x0a07
 #define USB_DEVICE_ID_ONTRAK_ADU100     0x0064
 
+#define USB_VENDOR_ID_ORTEK             0x05a4
+#define USB_DEVICE_ID_ORTEK_WKB2000     0x2000
+
 #define USB_VENDOR_ID_PANJIT            0x134c
 
 #define USB_VENDOR_ID_PANTHERLORD       0x0810
@@ -382,9 +396,16 @@
 #define USB_VENDOR_ID_POWERCOM          0x0d9f
 #define USB_DEVICE_ID_POWERCOM_UPS      0x0002
 
+#define USB_VENDOR_ID_PRODIGE           0x05af
+#define USB_DEVICE_ID_PRODIGE_CORDLESS  0x3062
+
 #define USB_VENDOR_ID_SAITEK            0x06a3
 #define USB_DEVICE_ID_SAITEK_RUMBLEPAD  0xff17
 
+#define USB_VENDOR_ID_QUANTA            0x0408
+#define USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH      0x3000
+#define USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN   0x3001
+
 #define USB_VENDOR_ID_SAMSUNG           0x0419
 #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE 0x0001
 
@@ -396,18 +417,20 @@
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_FIRST     0x0034
 #define USB_DEVICE_ID_SOUNDGRAPH_IMON_LAST      0x0046
 
+#define USB_VENDOR_ID_STANTUM           0x1f87
+#define USB_DEVICE_ID_MTP               0x0002
+
 #define USB_VENDOR_ID_SUN               0x0430
 #define USB_DEVICE_ID_RARITAN_KVM_DONGLE        0xcdab
 
 #define USB_VENDOR_ID_SUNPLUS           0x04fc
 #define USB_DEVICE_ID_SUNPLUS_WDESKTOP  0x05d8
 
-#define USB_VENDOR_ID_TENX              0x1130
-#define USB_DEVICE_ID_TENX_IBUDDY1      0x0001
-#define USB_DEVICE_ID_TENX_IBUDDY2      0x0002
-
 #define USB_VENDOR_ID_THRUSTMASTER      0x044f
 
+#define USB_VENDOR_ID_TOUCHPACK         0x1bfd
+#define USB_DEVICE_ID_TOUCHPACK_RTS     0x1688
+
 #define USB_VENDOR_ID_TOPMAX            0x0663
 #define USB_DEVICE_ID_TOPMAX_COBRAPAD   0x0103
 
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index 5862b0f3b55d..79d9edd0bdfa 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -1,6 +1,6 @@
 /*
  *  Copyright (c) 2000-2001 Vojtech Pavlik
- *  Copyright (c) 2006-2007 Jiri Kosina
+ *  Copyright (c) 2006-2010 Jiri Kosina
  *
  *  HID to Linux Input mapping
  */
@@ -193,12 +193,17 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 break;
 
         case HID_UP_BUTTON:
-                code = ((usage->hid - 1) & 0xf);
+                code = ((usage->hid - 1) & HID_USAGE);
 
                 switch (field->application) {
                 case HID_GD_MOUSE:
                 case HID_GD_POINTER:  code += 0x110; break;
-                case HID_GD_JOYSTICK: code += 0x120; break;
+                case HID_GD_JOYSTICK:
+                                      if (code <= 0xf)
+                                              code += BTN_JOYSTICK;
+                                      else
+                                              code += BTN_TRIGGER_HAPPY;
+                                      break;
                 case HID_GD_GAMEPAD:  code += 0x130; break;
                 default:
                         switch (field->physical) {
@@ -400,6 +405,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 case 0x192: map_key_clear(KEY_CALC);            break;
                 case 0x194: map_key_clear(KEY_FILE);            break;
                 case 0x196: map_key_clear(KEY_WWW);             break;
+                case 0x199: map_key_clear(KEY_CHAT);            break;
                 case 0x19c: map_key_clear(KEY_LOGOFF);          break;
                 case 0x19e: map_key_clear(KEY_COFFEE);          break;
                 case 0x1a6: map_key_clear(KEY_HELP);            break;
diff --git a/drivers/hid/hid-lg.c b/drivers/hid/hid-lg.c
index 9fcd3d017ab3..3677c9037a11 100644
--- a/drivers/hid/hid-lg.c
+++ b/drivers/hid/hid-lg.c
@@ -34,6 +34,7 @@
 #define LG_FF                   0x200
 #define LG_FF2                  0x400
 #define LG_RDESC_REL_ABS        0x800
+#define LG_FF3                  0x1000
 
 /*
  * Certain Logitech keyboards send in report #3 keys which are far
@@ -266,7 +267,7 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
                 goto err_free;
         }
 
-        if (quirks & (LG_FF | LG_FF2))
+        if (quirks & (LG_FF | LG_FF2 | LG_FF3))
                 connect_mask &= ~HID_CONNECT_FF;
 
         ret = hid_hw_start(hdev, connect_mask);
@@ -279,6 +280,8 @@ static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
                 lgff_init(hdev);
         if (quirks & LG_FF2)
                 lg2ff_init(hdev);
+        if (quirks & LG_FF3)
+                lg3ff_init(hdev);
 
         return 0;
 err_free:
@@ -331,6 +334,8 @@ static const struct hid_device_id lg_devices[] = {
                 .driver_data = LG_FF },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
                 .driver_data = LG_FF2 },
+        { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
+                .driver_data = LG_FF3 },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),
                 .driver_data = LG_RDESC_REL_ABS },
         { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER),
diff --git a/drivers/hid/hid-lg.h b/drivers/hid/hid-lg.h
index bf31592eaf79..ce2ac8672624 100644
--- a/drivers/hid/hid-lg.h
+++ b/drivers/hid/hid-lg.h
@@ -13,4 +13,10 @@ int lg2ff_init(struct hid_device *hdev);
 static inline int lg2ff_init(struct hid_device *hdev) { return -1; }
 #endif
 
+#ifdef CONFIG_LOGIG940_FF
+int lg3ff_init(struct hid_device *hdev);
+#else
+static inline int lg3ff_init(struct hid_device *hdev) { return -1; }
+#endif
+
 #endif
diff --git a/drivers/hid/hid-lg3ff.c b/drivers/hid/hid-lg3ff.c
new file mode 100644
index 000000000000..4002832ee4af
--- /dev/null
+++ b/drivers/hid/hid-lg3ff.c
@@ -0,0 +1,176 @@
+/*
+ *  Force feedback support for Logitech Flight System G940
+ *
+ *  Copyright (c) 2009 Gary Stein <LordCnidarian@gmail.com>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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/input.h>
+#include <linux/usb.h>
+#include <linux/hid.h>
+
+#include "usbhid/usbhid.h"
+#include "hid-lg.h"
+
+/*
+ * G940 Theory of Operation (from experimentation)
+ *
+ * There are 63 fields (only 3 of them currently used)
+ * 0 - seems to be command field
+ * 1 - 30 deal with the x axis
+ * 31 -60 deal with the y axis
+ *
+ * Field 1 is x axis constant force
+ * Field 31 is y axis constant force
+ *
+ * other interesting fields 1,2,3,4 on x axis
+ * (same for 31,32,33,34 on y axis)
+ *
+ * 0 0 127 127 makes the joystick autocenter hard
+ *
+ * 127 0 127 127 makes the joystick loose on the right,
+ * but stops all movemnt left
+ *
+ * -127 0 -127 -127 makes the joystick loose on the left,
+ * but stops all movement right
+ *
+ * 0 0 -127 -127 makes the joystick rattle very hard
+ *
+ * I'm sure these are effects that I don't know enough about them
+ */
+
+struct lg3ff_device {
+        struct hid_report *report;
+};
+
+static int hid_lg3ff_play(struct input_dev *dev, void *data,
+                         struct ff_effect *effect)
+{
+        struct hid_device *hid = input_get_drvdata(dev);
+        struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
+        int x, y;
+
+/*
+ * Maxusage should always be 63 (maximum fields)
+ * likely a better way to ensure this data is clean
+ */
+        memset(report->field[0]->value, 0, sizeof(__s32)*report->field[0]->maxusage);
+
+        switch (effect->type) {
+        case FF_CONSTANT:
+/*
+ * Already clamped in ff_memless
+ * 0 is center (different then other logitech)
+ */
+                x = effect->u.ramp.start_level;
+                y = effect->u.ramp.end_level;
+
+                /* send command byte */
+                report->field[0]->value[0] = 0x51;
+
+/*
+ * Sign backwards from other Force3d pro
+ * which get recast here in two's complement 8 bits
+ */
+                report->field[0]->value[1] = (unsigned char)(-x);
+                report->field[0]->value[31] = (unsigned char)(-y);
+
+                usbhid_submit_report(hid, report, USB_DIR_OUT);
+                break;
+        }
+        return 0;
+}
+static void hid_lg3ff_set_autocenter(struct input_dev *dev, u16 magnitude)
+{
+        struct hid_device *hid = input_get_drvdata(dev);
+        struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
+
+/*
+ * Auto Centering probed from device
+ * NOTE: deadman's switch on G940 must be covered
+ * for effects to work
+ */
+        report->field[0]->value[0] = 0x51;
+        report->field[0]->value[1] = 0x00;
+        report->field[0]->value[2] = 0x00;
+        report->field[0]->value[3] = 0x7F;
+        report->field[0]->value[4] = 0x7F;
+        report->field[0]->value[31] = 0x00;
+        report->field[0]->value[32] = 0x00;
+        report->field[0]->value[33] = 0x7F;
+        report->field[0]->value[34] = 0x7F;
+
+        usbhid_submit_report(hid, report, USB_DIR_OUT);
+}
+
+
+static const signed short ff3_joystick_ac[] = {
+        FF_CONSTANT,
+        FF_AUTOCENTER,
+        -1
+};
+
+int lg3ff_init(struct hid_device *hid)
+{
+        struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
+        struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
+        struct input_dev *dev = hidinput->input;
+        struct hid_report *report;
+        struct hid_field *field;
+        const signed short *ff_bits = ff3_joystick_ac;
+        int error;
+        int i;
+
+        /* Find the report to use */
+        if (list_empty(report_list)) {
+                err_hid("No output report found");
+                return -1;
+        }
+
+        /* Check that the report looks ok */
+        report = list_entry(report_list->next, struct hid_report, list);
+        if (!report) {
+                err_hid("NULL output report");
+                return -1;
+        }
+
+        field = report->field[0];
+        if (!field) {
+                err_hid("NULL field");
+                return -1;
+        }
+
+        /* Assume single fixed device G940 */
+        for (i = 0; ff_bits[i] >= 0; i++)
+                set_bit(ff_bits[i], dev->ffbit);
+
+        error = input_ff_create_memless(dev, NULL, hid_lg3ff_play);
+        if (error)
+                return error;
+
+        if (test_bit(FF_AUTOCENTER, dev->ffbit))
+                dev->ff->set_autocenter = hid_lg3ff_set_autocenter;
+
+        dev_info(&hid->dev, "Force feedback for Logitech Flight System G940 by "
+                        "Gary Stein <LordCnidarian@gmail.com>\n");
+        return 0;
+}
+
diff --git a/drivers/hid/hid-lgff.c b/drivers/hid/hid-lgff.c
index 987abebe0829..61142b76a9b1 100644
--- a/drivers/hid/hid-lgff.c
+++ b/drivers/hid/hid-lgff.c
@@ -67,6 +67,7 @@ static const struct dev_type devices[] = {
         { 0x046d, 0xc219, ff_rumble },
         { 0x046d, 0xc283, ff_joystick },
         { 0x046d, 0xc286, ff_joystick_ac },
+        { 0x046d, 0xc287, ff_joystick_ac },
         { 0x046d, 0xc293, ff_joystick },
         { 0x046d, 0xc294, ff_wheel },
         { 0x046d, 0xc295, ff_joystick },
diff --git a/drivers/hid/hid-magicmouse.c b/drivers/hid/hid-magicmouse.c
new file mode 100644
index 000000000000..4a3a94f2b10c
--- /dev/null
+++ b/drivers/hid/hid-magicmouse.c
@@ -0,0 +1,449 @@
+/*
+ *   Apple "Magic" Wireless Mouse driver
+ *
+ *   Copyright (c) 2010 Michael Poole <mdpoole@troilus.org>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+
+#include "hid-ids.h"
+
+static bool emulate_3button = true;
+module_param(emulate_3button, bool, 0644);
+MODULE_PARM_DESC(emulate_3button, "Emulate a middle button");
+
+static int middle_button_start = -350;
+static int middle_button_stop = +350;
+
+static bool emulate_scroll_wheel = true;
+module_param(emulate_scroll_wheel, bool, 0644);
+MODULE_PARM_DESC(emulate_scroll_wheel, "Emulate a scroll wheel");
+
+static bool report_touches = true;
+module_param(report_touches, bool, 0644);
+MODULE_PARM_DESC(report_touches, "Emit touch records (otherwise, only use them for emulation)");
+
+static bool report_undeciphered;
+module_param(report_undeciphered, bool, 0644);
+MODULE_PARM_DESC(report_undeciphered, "Report undeciphered multi-touch state field using a MSC_RAW event");
+
+#define TOUCH_REPORT_ID   0x29
+/* These definitions are not precise, but they're close enough.  (Bits
+ * 0x03 seem to indicate the aspect ratio of the touch, bits 0x70 seem
+ * to be some kind of bit mask -- 0x20 may be a near-field reading,
+ * and 0x40 is actual contact, and 0x10 may be a start/stop or change
+ * indication.)
+ */
+#define TOUCH_STATE_MASK  0xf0
+#define TOUCH_STATE_NONE  0x00
+#define TOUCH_STATE_START 0x30
+#define TOUCH_STATE_DRAG  0x40
+
+/**
+ * struct magicmouse_sc - Tracks Magic Mouse-specific data.
+ * @input: Input device through which we report events.
+ * @quirks: Currently unused.
+ * @last_timestamp: Timestamp from most recent (18-bit) touch report
+ *     (units of milliseconds over short windows, but seems to
+ *     increase faster when there are no touches).
+ * @delta_time: 18-bit difference between the two most recent touch
+ *     reports from the mouse.
+ * @ntouches: Number of touches in most recent touch report.
+ * @scroll_accel: Number of consecutive scroll motions.
+ * @scroll_jiffies: Time of last scroll motion.
+ * @touches: Most recent data for a touch, indexed by tracking ID.
+ * @tracking_ids: Mapping of current touch input data to @touches.
+ */
+struct magicmouse_sc {
+        struct input_dev *input;
+        unsigned long quirks;
+
+        int last_timestamp;
+        int delta_time;
+        int ntouches;
+        int scroll_accel;
+        unsigned long scroll_jiffies;
+
+        struct {
+                short x;
+                short y;
+                short scroll_y;
+                u8 size;
+        } touches[16];
+        int tracking_ids[16];
+};
+
+static int magicmouse_firm_touch(struct magicmouse_sc *msc)
+{
+        int touch = -1;
+        int ii;
+
+        /* If there is only one "firm" touch, set touch to its
+         * tracking ID.
+         */
+        for (ii = 0; ii < msc->ntouches; ii++) {
+                int idx = msc->tracking_ids[ii];
+                if (msc->touches[idx].size < 8) {
+                        /* Ignore this touch. */
+                } else if (touch >= 0) {
+                        touch = -1;
+                        break;
+                } else {
+                        touch = idx;
+                }
+        }
+
+        return touch;
+}
+
+static void magicmouse_emit_buttons(struct magicmouse_sc *msc, int state)
+{
+        int last_state = test_bit(BTN_LEFT, msc->input->key) << 0 |
+                test_bit(BTN_RIGHT, msc->input->key) << 1 |
+                test_bit(BTN_MIDDLE, msc->input->key) << 2;
+
+        if (emulate_3button) {
+                int id;
+
+                /* If some button was pressed before, keep it held
+                 * down.  Otherwise, if there's exactly one firm
+                 * touch, use that to override the mouse's guess.
+                 */
+                if (state == 0) {
+                        /* The button was released. */
+                } else if (last_state != 0) {
+                        state = last_state;
+                } else if ((id = magicmouse_firm_touch(msc)) >= 0) {
+                        int x = msc->touches[id].x;
+                        if (x < middle_button_start)
+                                state = 1;
+                        else if (x > middle_button_stop)
+                                state = 2;
+                        else
+                                state = 4;
+                } /* else: we keep the mouse's guess */
+
+                input_report_key(msc->input, BTN_MIDDLE, state & 4);
+        }
+
+        input_report_key(msc->input, BTN_LEFT, state & 1);
+        input_report_key(msc->input, BTN_RIGHT, state & 2);
+
+        if (state != last_state)
+                msc->scroll_accel = 0;
+}
+
+static void magicmouse_emit_touch(struct magicmouse_sc *msc, int raw_id, u8 *tdata)
+{
+        struct input_dev *input = msc->input;
+        __s32 x_y = tdata[0] << 8 | tdata[1] << 16 | tdata[2] << 24;
+        int misc = tdata[5] | tdata[6] << 8;
+        int id = (misc >> 6) & 15;
+        int x = x_y << 12 >> 20;
+        int y = -(x_y >> 20);
+
+        /* Store tracking ID and other fields. */
+        msc->tracking_ids[raw_id] = id;
+        msc->touches[id].x = x;
+        msc->touches[id].y = y;
+        msc->touches[id].size = misc & 63;
+
+        /* If requested, emulate a scroll wheel by detecting small
+         * vertical touch motions along the middle of the mouse.
+         */
+        if (emulate_scroll_wheel &&
+            middle_button_start < x && x < middle_button_stop) {
+                static const int accel_profile[] = {
+                        256, 228, 192, 160, 128, 96, 64, 32,
+                };
+                unsigned long now = jiffies;
+                int step = msc->touches[id].scroll_y - y;
+
+                /* Reset acceleration after half a second. */
+                if (time_after(now, msc->scroll_jiffies + HZ / 2))
+                        msc->scroll_accel = 0;
+
+                /* Calculate and apply the scroll motion. */
+                switch (tdata[7] & TOUCH_STATE_MASK) {
+                case TOUCH_STATE_START:
+                        msc->touches[id].scroll_y = y;
+                        msc->scroll_accel = min_t(int, msc->scroll_accel + 1,
+                                                ARRAY_SIZE(accel_profile) - 1);
+                        break;
+                case TOUCH_STATE_DRAG:
+                        step = step / accel_profile[msc->scroll_accel];
+                        if (step != 0) {
+                                msc->touches[id].scroll_y = y;
+                                msc->scroll_jiffies = now;
+                                input_report_rel(input, REL_WHEEL, step);
+                        }
+                        break;
+                }
+        }
+
+        /* Generate the input events for this touch. */
+        if (report_touches) {
+                int orientation = (misc >> 10) - 32;
+
+                input_report_abs(input, ABS_MT_TRACKING_ID, id);
+                input_report_abs(input, ABS_MT_TOUCH_MAJOR, tdata[3]);
+                input_report_abs(input, ABS_MT_TOUCH_MINOR, tdata[4]);
+                input_report_abs(input, ABS_MT_ORIENTATION, orientation);
+                input_report_abs(input, ABS_MT_POSITION_X, x);
+                input_report_abs(input, ABS_MT_POSITION_Y, y);
+
+                if (report_undeciphered)
+                        input_event(input, EV_MSC, MSC_RAW, tdata[7]);
+
+                input_mt_sync(input);
+        }
+}
+
+static int magicmouse_raw_event(struct hid_device *hdev,
+                struct hid_report *report, u8 *data, int size)
+{
+        struct magicmouse_sc *msc = hid_get_drvdata(hdev);
+        struct input_dev *input = msc->input;
+        int x, y, ts, ii, clicks;
+
+        switch (data[0]) {
+        case 0x10:
+                if (size != 6)
+                        return 0;
+                x = (__s16)(data[2] | data[3] << 8);
+                y = (__s16)(data[4] | data[5] << 8);
+                clicks = data[1];
+                break;
+        case TOUCH_REPORT_ID:
+                /* Expect six bytes of prefix, and N*8 bytes of touch data. */
+                if (size < 6 || ((size - 6) % 8) != 0)
+                        return 0;
+                ts = data[3] >> 6 | data[4] << 2 | data[5] << 10;
+                msc->delta_time = (ts - msc->last_timestamp) & 0x3ffff;
+                msc->last_timestamp = ts;
+                msc->ntouches = (size - 6) / 8;
+                for (ii = 0; ii < msc->ntouches; ii++)
+                        magicmouse_emit_touch(msc, ii, data + ii * 8 + 6);
+                /* When emulating three-button mode, it is important
+                 * to have the current touch information before
+                 * generating a click event.
+                 */
+                x = (signed char)data[1];
+                y = (signed char)data[2];
+                clicks = data[3];
+                break;
+        case 0x20: /* Theoretically battery status (0-100), but I have
+                    * never seen it -- maybe it is only upon request.
+                    */
+        case 0x60: /* Unknown, maybe laser on/off. */
+        case 0x61: /* Laser reflection status change.
+                    * data[1]: 0 = spotted, 1 = lost
+                    */
+        default:
+                return 0;
+        }
+
+        magicmouse_emit_buttons(msc, clicks & 3);
+        input_report_rel(input, REL_X, x);
+        input_report_rel(input, REL_Y, y);
+        input_sync(input);
+        return 1;
+}
+
+static int magicmouse_input_open(struct input_dev *dev)
+{
+        struct hid_device *hid = input_get_drvdata(dev);
+
+        return hid->ll_driver->open(hid);
+}
+
+static void magicmouse_input_close(struct input_dev *dev)
+{
+        struct hid_device *hid = input_get_drvdata(dev);
+
+        hid->ll_driver->close(hid);
+}
+
+static void magicmouse_setup_input(struct input_dev *input, struct hid_device *hdev)
+{
+        input_set_drvdata(input, hdev);
+        input->event = hdev->ll_driver->hidinput_input_event;
+        input->open = magicmouse_input_open;
+        input->close = magicmouse_input_close;
+
+        input->name = hdev->name;
+        input->phys = hdev->phys;
+        input->uniq = hdev->uniq;
+        input->id.bustype = hdev->bus;
+        input->id.vendor = hdev->vendor;
+        input->id.product = hdev->product;
+        input->id.version = hdev->version;
+        input->dev.parent = hdev->dev.parent;
+
+        __set_bit(EV_KEY, input->evbit);
+        __set_bit(BTN_LEFT, input->keybit);
+        __set_bit(BTN_RIGHT, input->keybit);
+        if (emulate_3button)
+                __set_bit(BTN_MIDDLE, input->keybit);
+        __set_bit(BTN_TOOL_FINGER, input->keybit);
+
+        __set_bit(EV_REL, input->evbit);
+        __set_bit(REL_X, input->relbit);
+        __set_bit(REL_Y, input->relbit);
+        if (emulate_scroll_wheel)
+                __set_bit(REL_WHEEL, input->relbit);
+
+        if (report_touches) {
+                __set_bit(EV_ABS, input->evbit);
+
+                input_set_abs_params(input, ABS_MT_TRACKING_ID, 0, 15, 0, 0);
+                input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 255, 4, 0);
+                input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 255, 4, 0);
+                input_set_abs_params(input, ABS_MT_ORIENTATION, -32, 31, 1, 0);
+                input_set_abs_params(input, ABS_MT_POSITION_X, -1100, 1358,
+                                4, 0);
+                /* Note: Touch Y position from the device is inverted relative
+                 * to how pointer motion is reported (and relative to how USB
+                 * HID recommends the coordinates work).  This driver keeps
+                 * the origin at the same position, and just uses the additive
+                 * inverse of the reported Y.
+                 */
+                input_set_abs_params(input, ABS_MT_POSITION_Y, -1589, 2047,
+                                4, 0);
+        }
+
+        if (report_undeciphered) {
+                __set_bit(EV_MSC, input->evbit);
+                __set_bit(MSC_RAW, input->mscbit);
+        }
+}
+
+static int magicmouse_probe(struct hid_device *hdev,
+        const struct hid_device_id *id)
+{
+        __u8 feature_1[] = { 0xd7, 0x01 };
+        __u8 feature_2[] = { 0xf8, 0x01, 0x32 };
+        struct input_dev *input;
+        struct magicmouse_sc *msc;
+        struct hid_report *report;
+        int ret;
+
+        msc = kzalloc(sizeof(*msc), GFP_KERNEL);
+        if (msc == NULL) {
+                dev_err(&hdev->dev, "can't alloc magicmouse descriptor\n");
+                return -ENOMEM;
+        }
+
+        msc->quirks = id->driver_data;
+        hid_set_drvdata(hdev, msc);
+
+        ret = hid_parse(hdev);
+        if (ret) {
+                dev_err(&hdev->dev, "magicmouse hid parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "magicmouse hw start failed\n");
+                goto err_free;
+        }
+
+        report = hid_register_report(hdev, HID_INPUT_REPORT, TOUCH_REPORT_ID);
+        if (!report) {
+                dev_err(&hdev->dev, "unable to register touch report\n");
+                ret = -ENOMEM;
+                goto err_stop_hw;
+        }
+        report->size = 6;
+
+        ret = hdev->hid_output_raw_report(hdev, feature_1, sizeof(feature_1),
+                        HID_FEATURE_REPORT);
+        if (ret != sizeof(feature_1)) {
+                dev_err(&hdev->dev, "unable to request touch data (1:%d)\n",
+                                ret);
+                goto err_stop_hw;
+        }
+        ret = hdev->hid_output_raw_report(hdev, feature_2,
+                        sizeof(feature_2), HID_FEATURE_REPORT);
+        if (ret != sizeof(feature_2)) {
+                dev_err(&hdev->dev, "unable to request touch data (2:%d)\n",
+                                ret);
+                goto err_stop_hw;
+        }
+
+        input = input_allocate_device();
+        if (!input) {
+                dev_err(&hdev->dev, "can't alloc input device\n");
+                ret = -ENOMEM;
+                goto err_stop_hw;
+        }
+        magicmouse_setup_input(input, hdev);
+
+        ret = input_register_device(input);
+        if (ret) {
+                dev_err(&hdev->dev, "input device registration failed\n");
+                goto err_input;
+        }
+        msc->input = input;
+
+        return 0;
+err_input:
+        input_free_device(input);
+err_stop_hw:
+        hid_hw_stop(hdev);
+err_free:
+        kfree(msc);
+        return ret;
+}
+
+static void magicmouse_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+}
+
+static const struct hid_device_id magic_mice[] = {
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE),
+                .driver_data = 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, magic_mice);
+
+static struct hid_driver magicmouse_driver = {
+        .name = "magicmouse",
+        .id_table = magic_mice,
+        .probe = magicmouse_probe,
+        .remove = magicmouse_remove,
+        .raw_event = magicmouse_raw_event,
+};
+
+static int __init magicmouse_init(void)
+{
+        int ret;
+
+        ret = hid_register_driver(&magicmouse_driver);
+        if (ret)
+                printk(KERN_ERR "can't register magicmouse driver\n");
+
+        return ret;
+}
+
+static void __exit magicmouse_exit(void)
+{
+        hid_unregister_driver(&magicmouse_driver);
+}
+
+module_init(magicmouse_init);
+module_exit(magicmouse_exit);
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-mosart.c b/drivers/hid/hid-mosart.c
new file mode 100644
index 000000000000..c8718168fe42
--- /dev/null
+++ b/drivers/hid/hid-mosart.c
@@ -0,0 +1,273 @@
+/*
+ *  HID driver for the multitouch panel on the ASUS EeePC T91MT
+ *
+ *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
+ *  Copyright (c) 2010 Teemu Tuominen <teemu.tuominen@cybercom.com>
+ *
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include "usbhid/usbhid.h"
+
+MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
+MODULE_DESCRIPTION("MosArt dual-touch panel");
+MODULE_LICENSE("GPL");
+
+#include "hid-ids.h"
+
+struct mosart_data {
+        __u16 x, y;
+        __u8 id;
+        bool valid;             /* valid finger data, or just placeholder? */
+        bool first;             /* is this the first finger in this frame? */
+        bool activity_now;      /* at least one active finger in this frame? */
+        bool activity;          /* at least one active finger previously? */
+};
+
+static int mosart_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        switch (usage->hid & HID_USAGE_PAGE) {
+
+        case HID_UP_GENDESK:
+                switch (usage->hid) {
+                case HID_GD_X:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_X);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_X,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                case HID_GD_Y:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_Y);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_Y,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                }
+                return 0;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                case HID_DG_CONFIDENCE:
+                case HID_DG_TIPSWITCH:
+                case HID_DG_INPUTMODE:
+                case HID_DG_DEVICEINDEX:
+                case HID_DG_CONTACTCOUNT:
+                case HID_DG_CONTACTMAX:
+                case HID_DG_TIPPRESSURE:
+                case HID_DG_WIDTH:
+                case HID_DG_HEIGHT:
+                        return -1;
+                case HID_DG_INRANGE:
+                        /* touchscreen emulation */
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
+                        return 1;
+
+                case HID_DG_CONTACTID:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TRACKING_ID);
+                        return 1;
+
+                }
+                return 0;
+
+        case 0xff000000:
+                /* ignore HID features */
+                return -1;
+        }
+
+        return 0;
+}
+
+static int mosart_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->type == EV_KEY || usage->type == EV_ABS)
+                clear_bit(usage->code, *bit);
+
+        return 0;
+}
+
+/*
+ * this function is called when a whole finger has been parsed,
+ * so that it can decide what to send to the input layer.
+ */
+static void mosart_filter_event(struct mosart_data *td, struct input_dev *input)
+{
+        td->first = !td->first; /* touchscreen emulation */
+
+        if (!td->valid) {
+                /*
+                 * touchscreen emulation: if no finger in this frame is valid
+                 * and there previously was finger activity, this is a release
+                 */ 
+                if (!td->first && !td->activity_now && td->activity) {
+                        input_event(input, EV_KEY, BTN_TOUCH, 0);
+                        td->activity = false;
+                }
+                return;
+        }
+
+        input_event(input, EV_ABS, ABS_MT_TRACKING_ID, td->id);
+        input_event(input, EV_ABS, ABS_MT_POSITION_X, td->x);
+        input_event(input, EV_ABS, ABS_MT_POSITION_Y, td->y);
+
+        input_mt_sync(input);
+        td->valid = false;
+
+        /* touchscreen emulation: if first active finger in this frame... */
+        if (!td->activity_now) {
+                /* if there was no previous activity, emit touch event */
+                if (!td->activity) {
+                        input_event(input, EV_KEY, BTN_TOUCH, 1);
+                        td->activity = true;
+                }
+                td->activity_now = true;
+                /* and in any case this is our preferred finger */
+                input_event(input, EV_ABS, ABS_X, td->x);
+                input_event(input, EV_ABS, ABS_Y, td->y);
+        }
+}
+
+
+static int mosart_event(struct hid_device *hid, struct hid_field *field,
+                                struct hid_usage *usage, __s32 value)
+{
+        struct mosart_data *td = hid_get_drvdata(hid);
+
+        if (hid->claimed & HID_CLAIMED_INPUT) {
+                struct input_dev *input = field->hidinput->input;
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        td->valid = !!value;
+                        break;
+                case HID_GD_X:
+                        td->x = value;
+                        break;
+                case HID_GD_Y:
+                        td->y = value;
+                        mosart_filter_event(td, input);
+                        break;
+                case HID_DG_CONTACTID:
+                        td->id = value;
+                        break;
+                case HID_DG_CONTACTCOUNT:
+                        /* touch emulation: this is the last field in a frame */
+                        td->first = false;
+                        td->activity_now = false;
+                        break;
+                case HID_DG_CONFIDENCE:
+                case HID_DG_TIPSWITCH:
+                        /* avoid interference from generic hidinput handling */
+                        break;
+
+                default:
+                        /* fallback to the generic hidinput handling */
+                        return 0;
+                }
+        }
+
+        /* we have handled the hidinput part, now remains hiddev */
+        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
+
+        return 1;
+}
+
+static int mosart_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        struct mosart_data *td;
+
+
+        td = kmalloc(sizeof(struct mosart_data), GFP_KERNEL);
+        if (!td) {
+                dev_err(&hdev->dev, "cannot allocate MosArt data\n");
+                return -ENOMEM;
+        }
+        td->valid = false;
+        td->activity = false;
+        td->activity_now = false;
+        td->first = false;
+        hid_set_drvdata(hdev, td);
+
+        /* currently, it's better to have one evdev device only */
+#if 0
+        hdev->quirks |= HID_QUIRK_MULTI_INPUT;
+#endif
+
+        ret = hid_parse(hdev);
+        if (ret == 0)
+                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+
+        if (ret == 0) {
+                struct hid_report_enum *re = hdev->report_enum
+                                                + HID_FEATURE_REPORT;
+                struct hid_report *r = re->report_id_hash[7];
+
+                r->field[0]->value[0] = 0x02;
+                usbhid_submit_report(hdev, r, USB_DIR_OUT);
+        } else 
+                kfree(td);
+
+        return ret;
+}
+
+static void mosart_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+        hid_set_drvdata(hdev, NULL);
+}
+
+static const struct hid_device_id mosart_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, mosart_devices);
+
+static const struct hid_usage_id mosart_grabbed_usages[] = {
+        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+};
+
+static struct hid_driver mosart_driver = {
+        .name = "mosart",
+        .id_table = mosart_devices,
+        .probe = mosart_probe,
+        .remove = mosart_remove,
+        .input_mapping = mosart_input_mapping,
+        .input_mapped = mosart_input_mapped,
+        .usage_table = mosart_grabbed_usages,
+        .event = mosart_event,
+};
+
+static int __init mosart_init(void)
+{
+        return hid_register_driver(&mosart_driver);
+}
+
+static void __exit mosart_exit(void)
+{
+        hid_unregister_driver(&mosart_driver);
+}
+
+module_init(mosart_init);
+module_exit(mosart_exit);
+
diff --git a/drivers/hid/hid-ntrig.c b/drivers/hid/hid-ntrig.c
index 49ce69d7bba7..3234c729a895 100644
--- a/drivers/hid/hid-ntrig.c
+++ b/drivers/hid/hid-ntrig.c
@@ -25,11 +25,16 @@
                                         EV_KEY, (c))
 
 struct ntrig_data {
-        __s32 x, y, id, w, h;
-        char reading_a_point, found_contact_id;
-        char pen_active;
-        char finger_active;
-        char inverted;
+        /* Incoming raw values for a single contact */
+        __u16 x, y, w, h;
+        __u16 id;
+        __u8 confidence;
+
+        bool reading_mt;
+        __u8 first_contact_confidence;
+
+        __u8 mt_footer[4];
+        __u8 mt_foot_count;
 };
 
 /*
@@ -42,8 +47,11 @@ static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
                 struct hid_field *field, struct hid_usage *usage,
                 unsigned long **bit, int *max)
 {
-        switch (usage->hid & HID_USAGE_PAGE) {
+        /* No special mappings needed for the pen and single touch */
+        if (field->physical)
+                return 0;
 
+        switch (usage->hid & HID_USAGE_PAGE) {
         case HID_UP_GENDESK:
                 switch (usage->hid) {
                 case HID_GD_X:
@@ -66,18 +74,12 @@ static int ntrig_input_mapping(struct hid_device *hdev, struct hid_input *hi,
         case HID_UP_DIGITIZER:
                 switch (usage->hid) {
                 /* we do not want to map these for now */
-                case HID_DG_CONTACTID: /* value is useless */
+                case HID_DG_CONTACTID: /* Not trustworthy, squelch for now */
                 case HID_DG_INPUTMODE:
                 case HID_DG_DEVICEINDEX:
-                case HID_DG_CONTACTCOUNT:
                 case HID_DG_CONTACTMAX:
                         return -1;
 
-                /* original mapping by Rafi Rubin */
-                case HID_DG_CONFIDENCE:
-                        nt_map_key_clear(BTN_TOOL_DOUBLETAP);
-                        return 1;
-
                 /* width/height mapped on TouchMajor/TouchMinor/Orientation */
                 case HID_DG_WIDTH:
                         hid_map_usage(hi, usage, bit, max,
@@ -104,6 +106,10 @@ static int ntrig_input_mapped(struct hid_device *hdev, struct hid_input *hi,
                 struct hid_field *field, struct hid_usage *usage,
                 unsigned long **bit, int *max)
 {
+        /* No special mappings needed for the pen and single touch */
+        if (field->physical)
+                return 0;
+
         if (usage->type == EV_KEY || usage->type == EV_REL
                         || usage->type == EV_ABS)
                 clear_bit(usage->code, *bit);
@@ -123,31 +129,30 @@ static int ntrig_event (struct hid_device *hid, struct hid_field *field,
         struct input_dev *input = field->hidinput->input;
         struct ntrig_data *nd = hid_get_drvdata(hid);
 
+        /* No special handling needed for the pen */
+        if (field->application == HID_DG_PEN)
+                return 0;
+
         if (hid->claimed & HID_CLAIMED_INPUT) {
                 switch (usage->hid) {
-
-                case HID_DG_INRANGE:
-                        if (field->application & 0x3)
-                                nd->pen_active = (value != 0);
-                        else
-                                nd->finger_active = (value != 0);
-                        return 0;
-
-                case HID_DG_INVERT:
-                        nd->inverted = value;
-                        return 0;
-
+                case 0xff000001:
+                        /* Tag indicating the start of a multitouch group */
+                        nd->reading_mt = 1;
+                        nd->first_contact_confidence = 0;
+                        break;
+                case HID_DG_CONFIDENCE:
+                        nd->confidence = value;
+                        break;
                 case HID_GD_X:
                         nd->x = value;
-                        nd->reading_a_point = 1;
+                        /* Clear the contact footer */
+                        nd->mt_foot_count = 0;
                         break;
                 case HID_GD_Y:
                         nd->y = value;
                         break;
                 case HID_DG_CONTACTID:
                         nd->id = value;
-                        /* we receive this only when in multitouch mode */
-                        nd->found_contact_id = 1;
                         break;
                 case HID_DG_WIDTH:
                         nd->w = value;
@@ -159,35 +164,13 @@ static int ntrig_event (struct hid_device *hid, struct hid_field *field,
                          * report received in a finger event. We want
                          * to emit a normal (X, Y) position
                          */
-                        if (!nd->found_contact_id) {
-                                if (nd->pen_active && nd->finger_active) {
-                                        input_report_key(input, BTN_TOOL_DOUBLETAP, 0);
-                                        input_report_key(input, BTN_TOOL_DOUBLETAP, 1);
-                                }
+                        if (!nd->reading_mt) {
+                                input_report_key(input, BTN_TOOL_DOUBLETAP,
+                                                 (nd->confidence != 0));
                                 input_event(input, EV_ABS, ABS_X, nd->x);
                                 input_event(input, EV_ABS, ABS_Y, nd->y);
                         }
                         break;
-                case HID_DG_TIPPRESSURE:
-                        /*
-                         * when in single touch mode, this is the last
-                         * report received in a pen event. We want
-                         * to emit a normal (X, Y) position
-                         */
-                        if (! nd->found_contact_id) {
-                                if (nd->pen_active && nd->finger_active) {
-                                        input_report_key(input,
-                                                        nd->inverted ? BTN_TOOL_RUBBER : BTN_TOOL_PEN
-                                                        , 0);
-                                        input_report_key(input,
-                                                        nd->inverted ? BTN_TOOL_RUBBER : BTN_TOOL_PEN
-                                                        , 1);
-                                }
-                                input_event(input, EV_ABS, ABS_X, nd->x);
-                                input_event(input, EV_ABS, ABS_Y, nd->y);
-                                input_event(input, EV_ABS, ABS_PRESSURE, value);
-                        }
-                        break;
                 case 0xff000002:
                         /*
                          * we receive this when the device is in multitouch
@@ -195,10 +178,34 @@ static int ntrig_event (struct hid_device *hid, struct hid_field *field,
                          * this usage tells if the contact point is real
                          * or a placeholder
                          */
-                        if (!nd->reading_a_point || value != 1)
+
+                        /* Shouldn't get more than 4 footer packets, so skip */
+                        if (nd->mt_foot_count >= 4)
                                 break;
+
+                        nd->mt_footer[nd->mt_foot_count++] = value;
+
+                        /* if the footer isn't complete break */
+                        if (nd->mt_foot_count != 4)
+                                break;
+
+                        /* Pen activity signal, trigger end of touch. */
+                        if (nd->mt_footer[2]) {
+                                nd->confidence = 0;
+                                break;
+                        }
+
+                        /* If the contact was invalid */
+                        if (!(nd->confidence && nd->mt_footer[0])
+                                        || nd->w <= 250
+                                        || nd->h <= 190) {
+                                nd->confidence = 0;
+                                break;
+                        }
+
                         /* emit a normal (X, Y) for the first point only */
                         if (nd->id == 0) {
+                                nd->first_contact_confidence = nd->confidence;
                                 input_event(input, EV_ABS, ABS_X, nd->x);
                                 input_event(input, EV_ABS, ABS_Y, nd->y);
                         }
@@ -220,8 +227,39 @@ static int ntrig_event (struct hid_device *hid, struct hid_field *field,
                                                 ABS_MT_TOUCH_MINOR, nd->w);
                         }
                         input_mt_sync(field->hidinput->input);
-                        nd->reading_a_point = 0;
-                        nd->found_contact_id = 0;
+                        break;
+
+                case HID_DG_CONTACTCOUNT: /* End of a multitouch group */
+                        if (!nd->reading_mt)
+                                break;
+
+                        nd->reading_mt = 0;
+
+                        if (nd->first_contact_confidence) {
+                                switch (value) {
+                                case 0: /* for single touch devices */
+                                case 1:
+                                        input_report_key(input,
+                                                        BTN_TOOL_DOUBLETAP, 1);
+                                        break;
+                                case 2:
+                                        input_report_key(input,
+                                                        BTN_TOOL_TRIPLETAP, 1);
+                                        break;
+                                case 3:
+                                default:
+                                        input_report_key(input,
+                                                        BTN_TOOL_QUADTAP, 1);
+                                }
+                                input_report_key(input, BTN_TOUCH, 1);
+                        } else {
+                                input_report_key(input,
+                                                BTN_TOOL_DOUBLETAP, 0);
+                                input_report_key(input,
+                                                BTN_TOOL_TRIPLETAP, 0);
+                                input_report_key(input,
+                                                BTN_TOOL_QUADTAP, 0);
+                        }
                         break;
 
                 default:
@@ -231,8 +269,8 @@ static int ntrig_event (struct hid_device *hid, struct hid_field *field,
         }
 
         /* we have handled the hidinput part, now remains hiddev */
-        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
-                hid->hiddev_hid_event(hid, field, usage, value);
+        if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
 
         return 1;
 }
@@ -241,23 +279,67 @@ static int ntrig_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
         int ret;
         struct ntrig_data *nd;
+        struct hid_input *hidinput;
+        struct input_dev *input;
+
+        if (id->driver_data)
+                hdev->quirks |= HID_QUIRK_MULTI_INPUT;
 
         nd = kmalloc(sizeof(struct ntrig_data), GFP_KERNEL);
         if (!nd) {
                 dev_err(&hdev->dev, "cannot allocate N-Trig data\n");
                 return -ENOMEM;
         }
-        nd->reading_a_point = 0;
-        nd->found_contact_id = 0;
+
+        nd->reading_mt = 0;
         hid_set_drvdata(hdev, nd);
 
         ret = hid_parse(hdev);
-        if (!ret)
-                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret) {
+                dev_err(&hdev->dev, "parse failed\n");
+                goto err_free;
+        }
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
+        if (ret) {
+                dev_err(&hdev->dev, "hw start failed\n");
+                goto err_free;
+        }
 
-        if (ret)
-                kfree (nd);
 
+        list_for_each_entry(hidinput, &hdev->inputs, list) {
+                input = hidinput->input;
+                switch (hidinput->report->field[0]->application) {
+                case HID_DG_PEN:
+                        input->name = "N-Trig Pen";
+                        break;
+                case HID_DG_TOUCHSCREEN:
+                        __clear_bit(BTN_TOOL_PEN, input->keybit);
+                        /*
+                         * A little something special to enable
+                         * two and three finger taps.
+                         */
+                        __set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
+                        __set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
+                        __set_bit(BTN_TOOL_QUADTAP, input->keybit);
+                        /*
+                         * The physical touchscreen (single touch)
+                         * input has a value for physical, whereas
+                         * the multitouch only has logical input
+                         * fields.
+                         */
+                        input->name =
+                                (hidinput->report->field[0]
+                                 ->physical) ?
+                                "N-Trig Touchscreen" :
+                                "N-Trig MultiTouch";
+                        break;
+                }
+        }
+
+        return 0;
+err_free:
+        kfree(nd);
         return ret;
 }
 
@@ -276,7 +358,7 @@ MODULE_DEVICE_TABLE(hid, ntrig_devices);
 
 static const struct hid_usage_id ntrig_grabbed_usages[] = {
         { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
-        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1 }
 };
 
 static struct hid_driver ntrig_driver = {
diff --git a/drivers/hid/hid-ortek.c b/drivers/hid/hid-ortek.c
new file mode 100644
index 000000000000..aa9a960f73a4
--- /dev/null
+++ b/drivers/hid/hid-ortek.c
@@ -0,0 +1,56 @@
+/*
+ *  HID driver for Ortek WKB-2000 (wireless keyboard + mouse trackpad).
+ *  Fixes LogicalMaximum error in USB report description, see
+ *  http://bugzilla.kernel.org/show_bug.cgi?id=14787
+ *
+ *  Copyright (c) 2010 Johnathon Harris <jmharris@gmail.com>
+ */
+
+/*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 2 of the License, or (at your option)
+ * any later version.
+ */
+
+#include <linux/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+#include "hid-ids.h"
+
+static void ortek_report_fixup(struct hid_device *hdev, __u8 *rdesc,
+                unsigned int rsize)
+{
+        if (rsize >= 56 && rdesc[54] == 0x25 && rdesc[55] == 0x01) {
+                dev_info(&hdev->dev, "Fixing up Ortek WKB-2000 "
+                                "report descriptor.\n");
+                rdesc[55] = 0x92;
+        }
+}
+
+static const struct hid_device_id ortek_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_ORTEK, USB_DEVICE_ID_ORTEK_WKB2000) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, ortek_devices);
+
+static struct hid_driver ortek_driver = {
+        .name = "ortek",
+        .id_table = ortek_devices,
+        .report_fixup = ortek_report_fixup
+};
+
+static int __init ortek_init(void)
+{
+        return hid_register_driver(&ortek_driver);
+}
+
+static void __exit ortek_exit(void)
+{
+        hid_unregister_driver(&ortek_driver);
+}
+
+module_init(ortek_init);
+module_exit(ortek_exit);
+MODULE_LICENSE("GPL");
diff --git a/drivers/hid/hid-quanta.c b/drivers/hid/hid-quanta.c
new file mode 100644
index 000000000000..01dd51c4986c
--- /dev/null
+++ b/drivers/hid/hid-quanta.c
@@ -0,0 +1,260 @@
+/*
+ *  HID driver for Quanta Optical Touch dual-touch panels
+ *
+ *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
+MODULE_DESCRIPTION("Quanta dual-touch panel");
+MODULE_LICENSE("GPL");
+
+#include "hid-ids.h"
+
+struct quanta_data {
+        __u16 x, y;
+        __u8 id;
+        bool valid;             /* valid finger data, or just placeholder? */
+        bool first;             /* is this the first finger in this frame? */
+        bool activity_now;      /* at least one active finger in this frame? */
+        bool activity;          /* at least one active finger previously? */
+};
+
+static int quanta_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        switch (usage->hid & HID_USAGE_PAGE) {
+
+        case HID_UP_GENDESK:
+                switch (usage->hid) {
+                case HID_GD_X:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_X);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_X,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                case HID_GD_Y:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_Y);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_Y,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                }
+                return 0;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                case HID_DG_CONFIDENCE:
+                case HID_DG_TIPSWITCH:
+                case HID_DG_INPUTMODE:
+                case HID_DG_DEVICEINDEX:
+                case HID_DG_CONTACTCOUNT:
+                case HID_DG_CONTACTMAX:
+                case HID_DG_TIPPRESSURE:
+                case HID_DG_WIDTH:
+                case HID_DG_HEIGHT:
+                        return -1;
+                case HID_DG_INRANGE:
+                        /* touchscreen emulation */
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
+                        return 1;
+                case HID_DG_CONTACTID:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TRACKING_ID);
+                        return 1;
+                }
+                return 0;
+
+        case 0xff000000:
+                /* ignore vendor-specific features */
+                return -1;
+        }
+
+        return 0;
+}
+
+static int quanta_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->type == EV_KEY || usage->type == EV_ABS)
+                clear_bit(usage->code, *bit);
+
+        return 0;
+}
+
+/*
+ * this function is called when a whole finger has been parsed,
+ * so that it can decide what to send to the input layer.
+ */
+static void quanta_filter_event(struct quanta_data *td, struct input_dev *input)
+{
+        
+        td->first = !td->first; /* touchscreen emulation */
+
+        if (!td->valid) {
+                /*
+                 * touchscreen emulation: if no finger in this frame is valid
+                 * and there previously was finger activity, this is a release
+                 */ 
+                if (!td->first && !td->activity_now && td->activity) {
+                        input_event(input, EV_KEY, BTN_TOUCH, 0);
+                        td->activity = false;
+                }
+                return;
+        }
+
+        input_event(input, EV_ABS, ABS_MT_TRACKING_ID, td->id);
+        input_event(input, EV_ABS, ABS_MT_POSITION_X, td->x);
+        input_event(input, EV_ABS, ABS_MT_POSITION_Y, td->y);
+
+        input_mt_sync(input);
+        td->valid = false;
+
+        /* touchscreen emulation: if first active finger in this frame... */
+        if (!td->activity_now) {
+                /* if there was no previous activity, emit touch event */
+                if (!td->activity) {
+                        input_event(input, EV_KEY, BTN_TOUCH, 1);
+                        td->activity = true;
+                }
+                td->activity_now = true;
+                /* and in any case this is our preferred finger */
+                input_event(input, EV_ABS, ABS_X, td->x);
+                input_event(input, EV_ABS, ABS_Y, td->y);
+        }
+}
+
+
+static int quanta_event(struct hid_device *hid, struct hid_field *field,
+                                struct hid_usage *usage, __s32 value)
+{
+        struct quanta_data *td = hid_get_drvdata(hid);
+
+        if (hid->claimed & HID_CLAIMED_INPUT) {
+                struct input_dev *input = field->hidinput->input;
+
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        td->valid = !!value;
+                        break;
+                case HID_GD_X:
+                        td->x = value;
+                        break;
+                case HID_GD_Y:
+                        td->y = value;
+                        quanta_filter_event(td, input);
+                        break;
+                case HID_DG_CONTACTID:
+                        td->id = value;
+                        break;
+                case HID_DG_CONTACTCOUNT:
+                        /* touch emulation: this is the last field in a frame */
+                        td->first = false;
+                        td->activity_now = false;
+                        break;
+                case HID_DG_CONFIDENCE:
+                case HID_DG_TIPSWITCH:
+                        /* avoid interference from generic hidinput handling */
+                        break;
+
+                default:
+                        /* fallback to the generic hidinput handling */
+                        return 0;
+                }
+        }
+
+        /* we have handled the hidinput part, now remains hiddev */
+        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
+
+        return 1;
+}
+
+static int quanta_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret;
+        struct quanta_data *td;
+
+        td = kmalloc(sizeof(struct quanta_data), GFP_KERNEL);
+        if (!td) {
+                dev_err(&hdev->dev, "cannot allocate Quanta Touch data\n");
+                return -ENOMEM;
+        }
+        td->valid = false;
+        td->activity = false;
+        td->activity_now = false;
+        td->first = false;
+        hid_set_drvdata(hdev, td);
+
+        ret = hid_parse(hdev);
+        if (!ret)
+                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+
+        if (ret)
+                kfree(td);
+
+        return ret;
+}
+
+static void quanta_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+        hid_set_drvdata(hdev, NULL);
+}
+
+static const struct hid_device_id quanta_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
+                        USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA,
+                        USB_DEVICE_ID_PIXART_IMAGING_INC_OPTICAL_TOUCH_SCREEN) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, quanta_devices);
+
+static const struct hid_usage_id quanta_grabbed_usages[] = {
+        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+};
+
+static struct hid_driver quanta_driver = {
+        .name = "quanta-touch",
+        .id_table = quanta_devices,
+        .probe = quanta_probe,
+        .remove = quanta_remove,
+        .input_mapping = quanta_input_mapping,
+        .input_mapped = quanta_input_mapped,
+        .usage_table = quanta_grabbed_usages,
+        .event = quanta_event,
+};
+
+static int __init quanta_init(void)
+{
+        return hid_register_driver(&quanta_driver);
+}
+
+static void __exit quanta_exit(void)
+{
+        hid_unregister_driver(&quanta_driver);
+}
+
+module_init(quanta_init);
+module_exit(quanta_exit);
+
diff --git a/drivers/hid/hid-sony.c b/drivers/hid/hid-sony.c
index 4e8450228a24..9bf00d77d92b 100644
--- a/drivers/hid/hid-sony.c
+++ b/drivers/hid/hid-sony.c
@@ -48,7 +48,7 @@ static void sony_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  * to "operational".  Without this, the ps3 controller will not report any
  * events.
  */
-static int sony_set_operational(struct hid_device *hdev)
+static int sony_set_operational_usb(struct hid_device *hdev)
 {
         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
         struct usb_device *dev = interface_to_usbdev(intf);
@@ -73,6 +73,12 @@ static int sony_set_operational(struct hid_device *hdev)
         return ret;
 }
 
+static int sony_set_operational_bt(struct hid_device *hdev)
+{
+        unsigned char buf[] = { 0x53, 0xf4,  0x42, 0x03, 0x00, 0x00 };
+        return hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
+}
+
 static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
         int ret;
@@ -81,7 +87,7 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
 
         sc = kzalloc(sizeof(*sc), GFP_KERNEL);
         if (sc == NULL) {
-                dev_err(&hdev->dev, "can't alloc apple descriptor\n");
+                dev_err(&hdev->dev, "can't alloc sony descriptor\n");
                 return -ENOMEM;
         }
 
@@ -101,7 +107,17 @@ static int sony_probe(struct hid_device *hdev, const struct hid_device_id *id)
                 goto err_free;
         }
 
-        ret = sony_set_operational(hdev);
+        switch (hdev->bus) {
+        case BUS_USB:
+                ret = sony_set_operational_usb(hdev);
+                break;
+        case BUS_BLUETOOTH:
+                ret = sony_set_operational_bt(hdev);
+                break;
+        default:
+                ret = 0;
+        }
+
         if (ret < 0)
                 goto err_stop;
 
@@ -121,6 +137,7 @@ static void sony_remove(struct hid_device *hdev)
 
 static const struct hid_device_id sony_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
+        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_VAIO_VGX_MOUSE),
                 .driver_data = VAIO_RDESC_CONSTANT },
         { }
diff --git a/drivers/hid/hid-stantum.c b/drivers/hid/hid-stantum.c
new file mode 100644
index 000000000000..2e592a06654e
--- /dev/null
+++ b/drivers/hid/hid-stantum.c
@@ -0,0 +1,283 @@
+/*
+ *  HID driver for Stantum multitouch panels
+ *
+ *  Copyright (c) 2009 Stephane Chatty <chatty@enac.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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+
+MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
+MODULE_DESCRIPTION("Stantum HID multitouch panels");
+MODULE_LICENSE("GPL");
+
+#include "hid-ids.h"
+
+struct stantum_data {
+        __s32 x, y, z, w, h;    /* x, y, pressure, width, height */
+        __u16 id;               /* touch id */
+        bool valid;             /* valid finger data, or just placeholder? */
+        bool first;             /* first finger in the HID packet? */
+        bool activity;          /* at least one active finger so far? */
+};
+
+static int stantum_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        switch (usage->hid & HID_USAGE_PAGE) {
+
+        case HID_UP_GENDESK:
+                switch (usage->hid) {
+                case HID_GD_X:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_X);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_X,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                case HID_GD_Y:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_Y);
+                        /* touchscreen emulation */
+                        input_set_abs_params(hi->input, ABS_Y,
+                                                field->logical_minimum,
+                                                field->logical_maximum, 0, 0);
+                        return 1;
+                }
+                return 0;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                case HID_DG_CONFIDENCE:
+                case HID_DG_INPUTMODE:
+                case HID_DG_DEVICEINDEX:
+                case HID_DG_CONTACTCOUNT:
+                case HID_DG_CONTACTMAX:
+                        return -1;
+
+                case HID_DG_TIPSWITCH:
+                        /* touchscreen emulation */
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
+                        return 1;
+
+                case HID_DG_WIDTH:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TOUCH_MAJOR);
+                        return 1;
+                case HID_DG_HEIGHT:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TOUCH_MINOR);
+                        input_set_abs_params(hi->input, ABS_MT_ORIENTATION,
+                                        1, 1, 0, 0);
+                        return 1;
+                case HID_DG_TIPPRESSURE:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_PRESSURE);
+                        return 1;
+
+                case HID_DG_CONTACTID:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TRACKING_ID);
+                        return 1;
+
+                }
+                return 0;
+
+        case 0xff000000:
+                /* no input-oriented meaning */
+                return -1;
+        }
+
+        return 0;
+}
+
+static int stantum_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->type == EV_KEY || usage->type == EV_ABS)
+                clear_bit(usage->code, *bit);
+
+        return 0;
+}
+
+/*
+ * this function is called when a whole finger has been parsed,
+ * so that it can decide what to send to the input layer.
+ */
+static void stantum_filter_event(struct stantum_data *sd,
+                                        struct input_dev *input)
+{
+        bool wide;
+
+        if (!sd->valid) {
+                /*
+                 * touchscreen emulation: if the first finger is not valid and
+                 * there previously was finger activity, this is a release
+                 */
+                if (sd->first && sd->activity) {
+                        input_event(input, EV_KEY, BTN_TOUCH, 0);
+                        sd->activity = false;
+                }
+                return;
+        }
+
+        input_event(input, EV_ABS, ABS_MT_TRACKING_ID, sd->id);
+        input_event(input, EV_ABS, ABS_MT_POSITION_X, sd->x);
+        input_event(input, EV_ABS, ABS_MT_POSITION_Y, sd->y);
+
+        wide = (sd->w > sd->h);
+        input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
+        input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, wide ? sd->w : sd->h);
+        input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, wide ? sd->h : sd->w);
+
+        input_event(input, EV_ABS, ABS_MT_PRESSURE, sd->z);
+
+        input_mt_sync(input);
+        sd->valid = false;
+
+        /* touchscreen emulation */
+        if (sd->first) {
+                if (!sd->activity) {
+                        input_event(input, EV_KEY, BTN_TOUCH, 1);
+                        sd->activity = true;
+                }
+                input_event(input, EV_ABS, ABS_X, sd->x);
+                input_event(input, EV_ABS, ABS_Y, sd->y);
+        }
+        sd->first = false;
+}
+
+
+static int stantum_event(struct hid_device *hid, struct hid_field *field,
+                                struct hid_usage *usage, __s32 value)
+{
+        struct stantum_data *sd = hid_get_drvdata(hid);
+
+        if (hid->claimed & HID_CLAIMED_INPUT) {
+                struct input_dev *input = field->hidinput->input;
+
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        /* this is the last field in a finger */
+                        stantum_filter_event(sd, input);
+                        break;
+                case HID_DG_WIDTH:
+                        sd->w = value;
+                        break;
+                case HID_DG_HEIGHT:
+                        sd->h = value;
+                        break;
+                case HID_GD_X:
+                        sd->x = value;
+                        break;
+                case HID_GD_Y:
+                        sd->y = value;
+                        break;
+                case HID_DG_TIPPRESSURE:
+                        sd->z = value;
+                        break;
+                case HID_DG_CONTACTID:
+                        sd->id = value;
+                        break;
+                case HID_DG_CONFIDENCE:
+                        sd->valid = !!value;
+                        break;
+                case 0xff000002:
+                        /* this comes only before the first finger */
+                        sd->first = true;
+                        break;
+
+                default:
+                        /* ignore the others */
+                        return 1;
+                }
+        }
+
+        /* we have handled the hidinput part, now remains hiddev */
+        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
+
+        return 1;
+}
+
+static int stantum_probe(struct hid_device *hdev,
+                                const struct hid_device_id *id)
+{
+        int ret;
+        struct stantum_data *sd;
+
+        sd = kmalloc(sizeof(struct stantum_data), GFP_KERNEL);
+        if (!sd) {
+                dev_err(&hdev->dev, "cannot allocate Stantum data\n");
+                return -ENOMEM;
+        }
+        sd->valid = false;
+        sd->first = false;
+        sd->activity = false;
+        hid_set_drvdata(hdev, sd);
+
+        ret = hid_parse(hdev);
+        if (!ret)
+                ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+
+        if (ret)
+                kfree(sd);
+
+        return ret;
+}
+
+static void stantum_remove(struct hid_device *hdev)
+{
+        hid_hw_stop(hdev);
+        kfree(hid_get_drvdata(hdev));
+        hid_set_drvdata(hdev, NULL);
+}
+
+static const struct hid_device_id stantum_devices[] = {
+        { HID_USB_DEVICE(USB_VENDOR_ID_STANTUM, USB_DEVICE_ID_MTP) },
+        { }
+};
+MODULE_DEVICE_TABLE(hid, stantum_devices);
+
+static const struct hid_usage_id stantum_grabbed_usages[] = {
+        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+};
+
+static struct hid_driver stantum_driver = {
+        .name = "stantum",
+        .id_table = stantum_devices,
+        .probe = stantum_probe,
+        .remove = stantum_remove,
+        .input_mapping = stantum_input_mapping,
+        .input_mapped = stantum_input_mapped,
+        .usage_table = stantum_grabbed_usages,
+        .event = stantum_event,
+};
+
+static int __init stantum_init(void)
+{
+        return hid_register_driver(&stantum_driver);
+}
+
+static void __exit stantum_exit(void)
+{
+        hid_unregister_driver(&stantum_driver);
+}
+
+module_init(stantum_init);
+module_exit(stantum_exit);
+
diff --git a/drivers/hid/hid-wacom.c b/drivers/hid/hid-wacom.c
index 12dcda529201..8d3b46f5d149 100644
--- a/drivers/hid/hid-wacom.c
+++ b/drivers/hid/hid-wacom.c
@@ -156,7 +156,9 @@ static int wacom_probe(struct hid_device *hdev,
         struct hid_input *hidinput;
         struct input_dev *input;
         struct wacom_data *wdata;
+        char rep_data[2];
         int ret;
+        int limit;
 
         wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
         if (wdata == NULL) {
@@ -166,6 +168,7 @@ static int wacom_probe(struct hid_device *hdev,
 
         hid_set_drvdata(hdev, wdata);
 
+        /* Parse the HID report now */
         ret = hid_parse(hdev);
         if (ret) {
                 dev_err(&hdev->dev, "parse failed\n");
@@ -178,6 +181,31 @@ static int wacom_probe(struct hid_device *hdev,
                 goto err_free;
         }
 
+        /*
+         * Note that if the raw queries fail, it's not a hard failure and it
+         * is safe to continue
+         */
+
+        /* Set Wacom mode2 */
+        rep_data[0] = 0x03; rep_data[1] = 0x00;
+        limit = 3;
+        do {
+                ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
+                                HID_FEATURE_REPORT);
+        } while (ret < 0 && limit-- > 0);
+        if (ret < 0)
+                dev_warn(&hdev->dev, "failed to poke device #1, %d\n", ret);
+
+        /* 0x06 - high reporting speed, 0x05 - low speed */
+        rep_data[0] = 0x06; rep_data[1] = 0x00;
+        limit = 3;
+        do {
+                ret = hdev->hid_output_raw_report(hdev, rep_data, 2,
+                                HID_FEATURE_REPORT);
+        } while (ret < 0 && limit-- > 0);
+        if (ret < 0)
+                dev_warn(&hdev->dev, "failed to poke device #2, %d\n", ret);
+
         hidinput = list_entry(hdev->inputs.next, struct hid_input, list);
         input = hidinput->input;
 
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index cdd136942bca..d04476700b7b 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -134,7 +134,7 @@ static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t
                 goto out;
         }
 
-        ret = dev->hid_output_raw_report(dev, buf, count);
+        ret = dev->hid_output_raw_report(dev, buf, count, HID_OUTPUT_REPORT);
 out:
         kfree(buf);
         return ret;
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index e2997a8d5e1b..56d06cd8075b 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -5,7 +5,7 @@
  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  *  Copyright (c) 2007-2008 Oliver Neukum
- *  Copyright (c) 2006-2009 Jiri Kosina
+ *  Copyright (c) 2006-2010 Jiri Kosina
  */
 
 /*
@@ -316,6 +316,7 @@ static int hid_submit_out(struct hid_device *hid)
                         err_hid("usb_submit_urb(out) failed");
                         return -1;
                 }
+                usbhid->last_out = jiffies;
         } else {
                 /*
                  * queue work to wake up the device.
@@ -377,6 +378,7 @@ static int hid_submit_ctrl(struct hid_device *hid)
                         err_hid("usb_submit_urb(ctrl) failed");
                         return -1;
                 }
+                usbhid->last_ctrl = jiffies;
         } else {
                 /*
                  * queue work to wake up the device.
@@ -512,9 +514,20 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
                 usbhid->out[usbhid->outhead].report = report;
                 usbhid->outhead = head;
 
-                if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl))
+                if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl)) {
                         if (hid_submit_out(hid))
                                 clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
+                } else {
+                        /*
+                         * the queue is known to run
+                         * but an earlier request may be stuck
+                         * we may need to time out
+                         * no race because this is called under
+                         * spinlock
+                         */
+                        if (time_after(jiffies, usbhid->last_out + HZ * 5))
+                                usb_unlink_urb(usbhid->urbout);
+                }
                 return;
         }
 
@@ -535,9 +548,20 @@ static void __usbhid_submit_report(struct hid_device *hid, struct hid_report *re
         usbhid->ctrl[usbhid->ctrlhead].dir = dir;
         usbhid->ctrlhead = head;
 
-        if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl))
+        if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl)) {
                 if (hid_submit_ctrl(hid))
                         clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
+        } else {
+                /*
+                 * the queue is known to run
+                 * but an earlier request may be stuck
+                 * we may need to time out
+                 * no race because this is called under
+                 * spinlock
+                 */
+                if (time_after(jiffies, usbhid->last_ctrl + HZ * 5))
+                        usb_unlink_urb(usbhid->urbctrl);
+        }
 }
 
 void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
@@ -774,7 +798,8 @@ static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
         return 0;
 }
 
-static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t count)
+static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t count,
+                unsigned char report_type)
 {
         struct usbhid_device *usbhid = hid->driver_data;
         struct usb_device *dev = hid_to_usb_dev(hid);
@@ -785,7 +810,7 @@ static int usbhid_output_raw_report(struct hid_device *hid, __u8 *buf, size_t co
         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
                 HID_REQ_SET_REPORT,
                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
-                ((HID_OUTPUT_REPORT + 1) << 8) | *buf,
+                ((report_type + 1) << 8) | *buf,
                 interface->desc.bInterfaceNumber, buf + 1, count - 1,
                 USB_CTRL_SET_TIMEOUT);
 
@@ -981,9 +1006,6 @@ static int usbhid_start(struct hid_device *hid)
 
         spin_lock_init(&usbhid->lock);
 
-        usbhid->intf = intf;
-        usbhid->ifnum = interface->desc.bInterfaceNumber;
-
         usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
         if (!usbhid->urbctrl) {
                 ret = -ENOMEM;
@@ -1154,6 +1176,8 @@ static int usbhid_probe(struct usb_interface *intf, const struct usb_device_id *
 
         hid->driver_data = usbhid;
         usbhid->hid = hid;
+        usbhid->intf = intf;
+        usbhid->ifnum = interface->desc.bInterfaceNumber;
 
         ret = hid_add_device(hid);
         if (ret) {
@@ -1342,7 +1366,7 @@ static int hid_reset_resume(struct usb_interface *intf)
 
 #endif /* CONFIG_PM */
 
-static struct usb_device_id hid_usb_ids [] = {
+static const struct usb_device_id hid_usb_ids[] = {
         { .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS,
                 .bInterfaceClass = USB_INTERFACE_CLASS_HID },
         { }                                             /* Terminating entry */
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 38773dc2821b..7844280897d1 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -43,8 +43,10 @@ static const struct hid_blacklist {
 
         { USB_VENDOR_ID_AFATECH, USB_DEVICE_ID_AFATECH_AF9016, HID_QUIRK_FULLSPEED_INTERVAL },
 
+        { USB_VENDOR_ID_ETURBOTOUCH, USB_DEVICE_ID_ETURBOTOUCH, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
         { USB_VENDOR_ID_PLAYDOTCOM, USB_DEVICE_ID_PLAYDOTCOM_EMS_USBII, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_TOUCHPACK, USB_DEVICE_ID_TOUCHPACK_RTS, HID_QUIRK_MULTI_INPUT },
 
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_UC100KM, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ATEN, USB_DEVICE_ID_ATEN_CS124U, HID_QUIRK_NOGET },
@@ -57,6 +59,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET },
+        { USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_SUN, USB_DEVICE_ID_RARITAN_KVM_DONGLE, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_KEYBOARD, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209, HID_QUIRK_MULTI_INPUT },
diff --git a/drivers/hid/usbhid/usbhid.h b/drivers/hid/usbhid/usbhid.h
index 08f505ca2e3d..ec20400c7f29 100644
--- a/drivers/hid/usbhid/usbhid.h
+++ b/drivers/hid/usbhid/usbhid.h
@@ -80,12 +80,14 @@ struct usbhid_device {
         unsigned char ctrlhead, ctrltail;                               /* Control fifo head & tail */
         char *ctrlbuf;                                                  /* Control buffer */
         dma_addr_t ctrlbuf_dma;                                         /* Control buffer dma */
+        unsigned long last_ctrl;                                                /* record of last output for timeouts */
 
         struct urb *urbout;                                             /* Output URB */
         struct hid_output_fifo out[HID_CONTROL_FIFO_SIZE];              /* Output pipe fifo */
         unsigned char outhead, outtail;                                 /* Output pipe fifo head & tail */
         char *outbuf;                                                   /* Output buffer */
         dma_addr_t outbuf_dma;                                          /* Output buffer dma */
+        unsigned long last_out;                                                 /* record of last output for timeouts */
 
         spinlock_t lock;                                                /* fifo spinlock */
         unsigned long iofl;                                             /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
diff --git a/drivers/input/input-polldev.c b/drivers/input/input-polldev.c
index aa6713b4a988..291d9393d359 100644
--- a/drivers/input/input-polldev.c
+++ b/drivers/input/input-polldev.c
@@ -100,6 +100,12 @@ static void input_close_polled_device(struct input_dev *input)
         struct input_polled_dev *dev = input_get_drvdata(input);
 
         cancel_delayed_work_sync(&dev->work);
+        /*
+         * Clean up work struct to remove references to the workqueue.
+         * It may be destroyed by the next call. This causes problems
+         * at next device open-close in case of poll_interval == 0.
+         */
+        INIT_DELAYED_WORK(&dev->work, dev->work.work.func);
         input_polldev_stop_workqueue();
 
         if (dev->close)
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index d84a36e545f6..b54aee7cd9e3 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -1161,9 +1161,17 @@ static int i8042_pm_restore(struct device *dev)
         return 0;
 }
 
+static int i8042_pm_thaw(struct device *dev)
+{
+        i8042_interrupt(0, NULL);
+
+        return 0;
+}
+
 static const struct dev_pm_ops i8042_pm_ops = {
         .suspend        = i8042_pm_reset,
         .resume         = i8042_pm_restore,
+        .thaw           = i8042_pm_thaw,
         .poweroff       = i8042_pm_reset,
         .restore        = i8042_pm_restore,
 };
diff --git a/drivers/input/touchscreen/usbtouchscreen.c b/drivers/input/touchscreen/usbtouchscreen.c
index 09a5e7341bd5..5256123a5228 100644
--- a/drivers/input/touchscreen/usbtouchscreen.c
+++ b/drivers/input/touchscreen/usbtouchscreen.c
@@ -618,8 +618,8 @@ static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 {
-        dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ;
-        dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ;
+        dev->x = (pkt[2] << 8) | pkt[1];
+        dev->y = (pkt[4] << 8) | pkt[3];
         dev->press = pkt[5] & 0xff;
         dev->touch = pkt[0] & 0x01;
 
@@ -809,9 +809,9 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
 #ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
         [DEVTYPE_GENERAL_TOUCH] = {
                 .min_xc         = 0x0,
-                .max_xc         = 0x0500,
+                .max_xc         = 0x7fff,
                 .min_yc         = 0x0,
-                .max_yc         = 0x0500,
+                .max_yc         = 0x7fff,
                 .rept_size      = 7,
                 .read_data      = general_touch_read_data,
         },
diff --git a/drivers/isdn/hisax/Kconfig b/drivers/isdn/hisax/Kconfig
index 3464ebc4cdbc..452fde9edf86 100644
--- a/drivers/isdn/hisax/Kconfig
+++ b/drivers/isdn/hisax/Kconfig
@@ -109,7 +109,7 @@ config HISAX_16_3
 
 config HISAX_TELESPCI
         bool "Teles PCI"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the Teles PCI.
           See <file:Documentation/isdn/README.HiSax> on how to configure it.
@@ -237,7 +237,7 @@ config HISAX_MIC
 
 config HISAX_NETJET
         bool "NETjet card"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the NetJet from Traverse
           Technologies.
@@ -248,7 +248,7 @@ config HISAX_NETJET
 
 config HISAX_NETJET_U
         bool "NETspider U card"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the Netspider U interface ISDN card
           from Traverse Technologies.
@@ -287,7 +287,7 @@ config HISAX_HSTSAPHIR
 
 config HISAX_BKM_A4T
         bool "Telekom A4T card"
-        depends on PCI && PCI_LEGACY
+        depends on PCI
         help
           This enables HiSax support for the Telekom A4T card.
 
@@ -297,7 +297,7 @@ config HISAX_BKM_A4T
 
 config HISAX_SCT_QUADRO
         bool "Scitel Quadro card"
-        depends on PCI && PCI_LEGACY
+        depends on PCI
         help
           This enables HiSax support for the Scitel Quadro card.
 
@@ -316,7 +316,7 @@ config HISAX_GAZEL
 
 config HISAX_HFC_PCI
         bool "HFC PCI-Bus cards"
-        depends on PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the HFC-S PCI 2BDS0 based cards.
 
@@ -325,7 +325,7 @@ config HISAX_HFC_PCI
 
 config HISAX_W6692
         bool "Winbond W6692 based cards"
-        depends on PCI && PCI_LEGACY
+        depends on PCI
         help
           This enables HiSax support for Winbond W6692 based PCI ISDN cards.
 
@@ -341,7 +341,7 @@ config HISAX_HFC_SX
 
 config HISAX_ENTERNOW_PCI
         bool "Formula-n enter:now PCI card"
-        depends on HISAX_NETJET && PCI && PCI_LEGACY && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
+        depends on HISAX_NETJET && PCI && (BROKEN || !(SPARC || PPC || PARISC || M68K || (MIPS && !CPU_LITTLE_ENDIAN) || FRV))
         help
           This enables HiSax support for the Formula-n enter:now PCI
           ISDN card.
@@ -412,7 +412,7 @@ config HISAX_HFC4S8S
 
 config HISAX_FRITZ_PCIPNP
         tristate "AVM Fritz!Card PCI/PCIv2/PnP support (EXPERIMENTAL)"
-        depends on PCI && PCI_LEGACY && EXPERIMENTAL
+        depends on PCI && EXPERIMENTAL
         help
           This enables the driver for the AVM Fritz!Card PCI,
           Fritz!Card PCI v2 and Fritz!Card PnP.
diff --git a/drivers/isdn/hisax/avm_pci.c b/drivers/isdn/hisax/avm_pci.c
index 7cabc5a19492..14295a155e71 100644
--- a/drivers/isdn/hisax/avm_pci.c
+++ b/drivers/isdn/hisax/avm_pci.c
@@ -822,7 +822,7 @@ static int __devinit avm_pnp_setup(struct IsdnCardState *cs)
 
 #endif /* __ISAPNP__ */
 
-#ifndef CONFIG_PCI_LEGACY
+#ifndef CONFIG_PCI
 
 static int __devinit avm_pci_setup(struct IsdnCardState *cs)
 {
@@ -835,7 +835,7 @@ static struct pci_dev *dev_avm __devinitdata = NULL;
 
 static int __devinit avm_pci_setup(struct IsdnCardState *cs)
 {
-        if ((dev_avm = pci_find_device(PCI_VENDOR_ID_AVM,
+        if ((dev_avm = hisax_find_pci_device(PCI_VENDOR_ID_AVM,
                 PCI_DEVICE_ID_AVM_A1, dev_avm))) {
 
                 if (pci_enable_device(dev_avm))
@@ -864,7 +864,7 @@ static int __devinit avm_pci_setup(struct IsdnCardState *cs)
         return (1);
 }
 
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_avm_pcipnp(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/bkm_a4t.c b/drivers/isdn/hisax/bkm_a4t.c
index 9ca2ee54cc94..9f2009c0b69c 100644
--- a/drivers/isdn/hisax/bkm_a4t.c
+++ b/drivers/isdn/hisax/bkm_a4t.c
@@ -340,7 +340,7 @@ setup_bkm_a4t(struct IsdnCard *card)
         } else
                 return (0);
 
-        while ((dev_a4t = pci_find_device(PCI_VENDOR_ID_ZORAN,
+        while ((dev_a4t = hisax_find_pci_device(PCI_VENDOR_ID_ZORAN,
                 PCI_DEVICE_ID_ZORAN_36120, dev_a4t))) {
                 ret = a4t_pci_probe(dev_a4t, cs, &found, &pci_memaddr);
                 if (!ret)
diff --git a/drivers/isdn/hisax/bkm_a8.c b/drivers/isdn/hisax/bkm_a8.c
index e1ff4717a8a6..e775706c60e3 100644
--- a/drivers/isdn/hisax/bkm_a8.c
+++ b/drivers/isdn/hisax/bkm_a8.c
@@ -301,7 +301,7 @@ setup_sct_quadro(struct IsdnCard *card)
                 (sub_vendor_id != PCI_VENDOR_ID_BERKOM)))
                 return (0);
         if (cs->subtyp == SCT_1) {
-                while ((dev_a8 = pci_find_device(PCI_VENDOR_ID_PLX,
+                while ((dev_a8 = hisax_find_pci_device(PCI_VENDOR_ID_PLX,
                         PCI_DEVICE_ID_PLX_9050, dev_a8))) {
                         
                         sub_vendor_id = dev_a8->subsystem_vendor;
diff --git a/drivers/isdn/hisax/diva.c b/drivers/isdn/hisax/diva.c
index 0b0c2e5d806b..780da9bda915 100644
--- a/drivers/isdn/hisax/diva.c
+++ b/drivers/isdn/hisax/diva.c
@@ -1148,7 +1148,7 @@ static int __devinit setup_diva_isapnp(struct IsdnCard *card)
 
 #endif  /* ISAPNP */
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static struct pci_dev *dev_diva __devinitdata = NULL;
 static struct pci_dev *dev_diva_u __devinitdata = NULL;
 static struct pci_dev *dev_diva201 __devinitdata = NULL;
@@ -1159,21 +1159,21 @@ static int __devinit setup_diva_pci(struct IsdnCard *card)
         struct IsdnCardState *cs = card->cs;
 
         cs->subtyp = 0;
-        if ((dev_diva = pci_find_device(PCI_VENDOR_ID_EICON,
+        if ((dev_diva = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA20, dev_diva))) {
                 if (pci_enable_device(dev_diva))
                         return(0);
                 cs->subtyp = DIVA_PCI;
                 cs->irq = dev_diva->irq;
                 cs->hw.diva.cfg_reg = pci_resource_start(dev_diva, 2);
-        } else if ((dev_diva_u = pci_find_device(PCI_VENDOR_ID_EICON,
+        } else if ((dev_diva_u = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA20_U, dev_diva_u))) {
                 if (pci_enable_device(dev_diva_u))
                         return(0);
                 cs->subtyp = DIVA_PCI;
                 cs->irq = dev_diva_u->irq;
                 cs->hw.diva.cfg_reg = pci_resource_start(dev_diva_u, 2);
-        } else if ((dev_diva201 = pci_find_device(PCI_VENDOR_ID_EICON,
+        } else if ((dev_diva201 = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA201, dev_diva201))) {
                 if (pci_enable_device(dev_diva201))
                         return(0);
@@ -1183,7 +1183,7 @@ static int __devinit setup_diva_pci(struct IsdnCard *card)
                         (ulong) ioremap(pci_resource_start(dev_diva201, 0), 4096);
                 cs->hw.diva.cfg_reg =
                         (ulong) ioremap(pci_resource_start(dev_diva201, 1), 4096);
-        } else if ((dev_diva202 = pci_find_device(PCI_VENDOR_ID_EICON,
+        } else if ((dev_diva202 = hisax_find_pci_device(PCI_VENDOR_ID_EICON,
                 PCI_DEVICE_ID_EICON_DIVA202, dev_diva202))) {
                 if (pci_enable_device(dev_diva202))
                         return(0);
@@ -1229,14 +1229,14 @@ static int __devinit setup_diva_pci(struct IsdnCard *card)
         return (1);             /* card found */
 }
 
-#else   /* if !CONFIG_PCI_LEGACY */
+#else   /* if !CONFIG_PCI */
 
 static int __devinit setup_diva_pci(struct IsdnCard *card)
 {
         return (-1);    /* card not found; continue search */
 }
 
-#endif  /* CONFIG_PCI_LEGACY */
+#endif  /* CONFIG_PCI */
 
 int __devinit
 setup_diva(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/elsa.c b/drivers/isdn/hisax/elsa.c
index aa29d1cf16af..23c41fcd864e 100644
--- a/drivers/isdn/hisax/elsa.c
+++ b/drivers/isdn/hisax/elsa.c
@@ -1025,7 +1025,7 @@ setup_elsa_pcmcia(struct IsdnCard *card)
                cs->irq);
 }
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static  struct pci_dev *dev_qs1000 __devinitdata = NULL;
 static  struct pci_dev *dev_qs3000 __devinitdata = NULL;
 
@@ -1035,7 +1035,7 @@ setup_elsa_pci(struct IsdnCard *card)
         struct IsdnCardState *cs = card->cs;
 
         cs->subtyp = 0;
-        if ((dev_qs1000 = pci_find_device(PCI_VENDOR_ID_ELSA,
+        if ((dev_qs1000 = hisax_find_pci_device(PCI_VENDOR_ID_ELSA,
                 PCI_DEVICE_ID_ELSA_MICROLINK, dev_qs1000))) {
                 if (pci_enable_device(dev_qs1000))
                         return(0);
@@ -1043,7 +1043,7 @@ setup_elsa_pci(struct IsdnCard *card)
                 cs->irq = dev_qs1000->irq;
                 cs->hw.elsa.cfg = pci_resource_start(dev_qs1000, 1);
                 cs->hw.elsa.base = pci_resource_start(dev_qs1000, 3);
-        } else if ((dev_qs3000 = pci_find_device(PCI_VENDOR_ID_ELSA,
+        } else if ((dev_qs3000 = hisax_find_pci_device(PCI_VENDOR_ID_ELSA,
                 PCI_DEVICE_ID_ELSA_QS3000, dev_qs3000))) {
                 if (pci_enable_device(dev_qs3000))
                         return(0);
@@ -1093,7 +1093,7 @@ setup_elsa_pci(struct IsdnCard *card)
 {
         return (1);
 }
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 static int __devinit
 setup_elsa_common(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/enternow_pci.c b/drivers/isdn/hisax/enternow_pci.c
index 39f421ed8de8..26264abf1f58 100644
--- a/drivers/isdn/hisax/enternow_pci.c
+++ b/drivers/isdn/hisax/enternow_pci.c
@@ -406,7 +406,7 @@ setup_enternow_pci(struct IsdnCard *card)
 
         for ( ;; )
         {
-                if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                if ((dev_netjet = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {
                         ret = en_pci_probe(dev_netjet, cs);
                         if (!ret)
diff --git a/drivers/isdn/hisax/gazel.c b/drivers/isdn/hisax/gazel.c
index 0ea3b4607680..353982fc1436 100644
--- a/drivers/isdn/hisax/gazel.c
+++ b/drivers/isdn/hisax/gazel.c
@@ -531,7 +531,7 @@ setup_gazelisa(struct IsdnCard *card, struct IsdnCardState *cs)
         return (0);
 }
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static struct pci_dev *dev_tel __devinitdata = NULL;
 
 static int __devinit
@@ -546,7 +546,7 @@ setup_gazelpci(struct IsdnCardState *cs)
         found = 0;
         seekcard = PCI_DEVICE_ID_PLX_R685;
         for (nbseek = 0; nbseek < 4; nbseek++) {
-                if ((dev_tel = pci_find_device(PCI_VENDOR_ID_PLX,
+                if ((dev_tel = hisax_find_pci_device(PCI_VENDOR_ID_PLX,
                                         seekcard, dev_tel))) {
                         if (pci_enable_device(dev_tel))
                                 return 1;
@@ -620,7 +620,7 @@ setup_gazelpci(struct IsdnCardState *cs)
 
         return (0);
 }
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_gazel(struct IsdnCard *card)
@@ -640,7 +640,7 @@ setup_gazel(struct IsdnCard *card)
                         return (0);
         } else {
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
                 if (setup_gazelpci(cs))
                         return (0);
 #else
diff --git a/drivers/isdn/hisax/hfc_pci.c b/drivers/isdn/hisax/hfc_pci.c
index 10914731b304..917cc84065bd 100644
--- a/drivers/isdn/hisax/hfc_pci.c
+++ b/drivers/isdn/hisax/hfc_pci.c
@@ -1658,7 +1658,7 @@ setup_hfcpci(struct IsdnCard *card)
 
         i = 0;
         while (id_list[i].vendor_id) {
-                tmp_hfcpci = pci_find_device(id_list[i].vendor_id,
+                tmp_hfcpci = hisax_find_pci_device(id_list[i].vendor_id,
                                              id_list[i].device_id,
                                              dev_hfcpci);
                 i++;
diff --git a/drivers/isdn/hisax/hisax.h b/drivers/isdn/hisax/hisax.h
index 0685c1946969..832a87855ffb 100644
--- a/drivers/isdn/hisax/hisax.h
+++ b/drivers/isdn/hisax/hisax.h
@@ -1323,3 +1323,26 @@ void release_tei(struct IsdnCardState *cs);
 char *HiSax_getrev(const char *revision);
 int TeiNew(void);
 void TeiFree(void);
+
+#ifdef CONFIG_PCI
+
+#include <linux/pci.h>
+
+/* adaptation wrapper for old usage
+ * WARNING! This is unfit for use in a PCI hotplug environment,
+ * as the returned PCI device can disappear at any moment in time.
+ * Callers should be converted to use pci_get_device() instead.
+ */
+static inline struct pci_dev *hisax_find_pci_device(unsigned int vendor,
+                                                    unsigned int device,
+                                                    struct pci_dev *from)
+{
+        struct pci_dev *pdev;
+
+        pci_dev_get(from);
+        pdev = pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
+        pci_dev_put(pdev);
+        return pdev;
+}
+
+#endif
diff --git a/drivers/isdn/hisax/niccy.c b/drivers/isdn/hisax/niccy.c
index ef00633e1d2a..ccaa6e13310f 100644
--- a/drivers/isdn/hisax/niccy.c
+++ b/drivers/isdn/hisax/niccy.c
@@ -297,12 +297,12 @@ int __devinit setup_niccy(struct IsdnCard *card)
                         return 0;
                 }
         } else {
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
                 static struct pci_dev *niccy_dev __devinitdata;
 
                 u_int pci_ioaddr;
                 cs->subtyp = 0;
-                if ((niccy_dev = pci_find_device(PCI_VENDOR_ID_SATSAGEM,
+                if ((niccy_dev = hisax_find_pci_device(PCI_VENDOR_ID_SATSAGEM,
                                                  PCI_DEVICE_ID_SATSAGEM_NICCY,
                                                  niccy_dev))) {
                         if (pci_enable_device(niccy_dev))
@@ -354,7 +354,7 @@ int __devinit setup_niccy(struct IsdnCard *card)
                 printk(KERN_WARNING "Niccy: io0 0 and NO_PCI_BIOS\n");
                 printk(KERN_WARNING "Niccy: unable to config NICCY PCI\n");
                 return 0;
-#endif                          /* CONFIG_PCI_LEGACY */
+#endif                          /* CONFIG_PCI */
         }
         printk(KERN_INFO "HiSax: NICCY %s config irq:%d data:0x%X ale:0x%X\n",
                 (cs->subtyp == 1) ? "PnP" : "PCI",
diff --git a/drivers/isdn/hisax/nj_s.c b/drivers/isdn/hisax/nj_s.c
index 8d36ccc87d81..2344e7b33448 100644
--- a/drivers/isdn/hisax/nj_s.c
+++ b/drivers/isdn/hisax/nj_s.c
@@ -276,7 +276,7 @@ setup_netjet_s(struct IsdnCard *card)
 
         for ( ;; )
         {
-                if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                if ((dev_netjet = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {
                         ret = njs_pci_probe(dev_netjet, cs);
                         if (!ret)
diff --git a/drivers/isdn/hisax/nj_u.c b/drivers/isdn/hisax/nj_u.c
index d306c946ffba..095e974aed80 100644
--- a/drivers/isdn/hisax/nj_u.c
+++ b/drivers/isdn/hisax/nj_u.c
@@ -240,7 +240,7 @@ setup_netjet_u(struct IsdnCard *card)
 
         for ( ;; )
         {
-                if ((dev_netjet = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+                if ((dev_netjet = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_300,  dev_netjet))) {
                         ret = nju_pci_probe(dev_netjet, cs);
                         if (!ret)
diff --git a/drivers/isdn/hisax/sedlbauer.c b/drivers/isdn/hisax/sedlbauer.c
index 5569a522e2a1..69dfc8d29017 100644
--- a/drivers/isdn/hisax/sedlbauer.c
+++ b/drivers/isdn/hisax/sedlbauer.c
@@ -598,7 +598,7 @@ setup_sedlbauer_isapnp(struct IsdnCard *card, int *bytecnt)
 }
 #endif /* __ISAPNP__ */
 
-#ifdef CONFIG_PCI_LEGACY
+#ifdef CONFIG_PCI
 static struct pci_dev *dev_sedl __devinitdata = NULL;
 
 static int __devinit
@@ -607,7 +607,7 @@ setup_sedlbauer_pci(struct IsdnCard *card)
         struct IsdnCardState *cs = card->cs;
         u16 sub_vendor_id, sub_id;
 
-        if ((dev_sedl = pci_find_device(PCI_VENDOR_ID_TIGERJET,
+        if ((dev_sedl = hisax_find_pci_device(PCI_VENDOR_ID_TIGERJET,
                         PCI_DEVICE_ID_TIGERJET_100, dev_sedl))) {
                 if (pci_enable_device(dev_sedl))
                         return(0);
@@ -673,7 +673,7 @@ setup_sedlbauer_pci(struct IsdnCard *card)
         return (1);
 }
 
-#endif /* CONFIG_PCI_LEGACY */
+#endif /* CONFIG_PCI */
 
 int __devinit
 setup_sedlbauer(struct IsdnCard *card)
diff --git a/drivers/isdn/hisax/telespci.c b/drivers/isdn/hisax/telespci.c
index 28b08de4673d..b85ceb3746ce 100644
--- a/drivers/isdn/hisax/telespci.c
+++ b/drivers/isdn/hisax/telespci.c
@@ -300,7 +300,7 @@ setup_telespci(struct IsdnCard *card)
         if (cs->typ != ISDN_CTYPE_TELESPCI)
                 return (0);
 
-        if ((dev_tel = pci_find_device (PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36120, dev_tel))) {
+        if ((dev_tel = hisax_find_pci_device (PCI_VENDOR_ID_ZORAN, PCI_DEVICE_ID_ZORAN_36120, dev_tel))) {
                 if (pci_enable_device(dev_tel))
                         return(0);
                 cs->irq = dev_tel->irq;
diff --git a/drivers/isdn/hisax/w6692.c b/drivers/isdn/hisax/w6692.c
index c4d862c11a60..9d6e864023fe 100644
--- a/drivers/isdn/hisax/w6692.c
+++ b/drivers/isdn/hisax/w6692.c
@@ -1007,7 +1007,7 @@ setup_w6692(struct IsdnCard *card)
                 return (0);
 
         while (id_list[id_idx].vendor_id) {
-                dev_w6692 = pci_find_device(id_list[id_idx].vendor_id,
+                dev_w6692 = hisax_find_pci_device(id_list[id_idx].vendor_id,
                                             id_list[id_idx].device_id,
                                             dev_w6692);
                 if (dev_w6692) {
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 23741cec45e3..d840a109f833 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -322,8 +322,8 @@ static int __init adb_init(void)
                 adb_controller = NULL;
         } else {
 #ifdef CONFIG_PPC
-                if (machine_is_compatible("AAPL,PowerBook1998") ||
-                        machine_is_compatible("PowerBook1,1"))
+                if (of_machine_is_compatible("AAPL,PowerBook1998") ||
+                        of_machine_is_compatible("PowerBook1,1"))
                         sleepy_trackpad = 1;
 #endif /* CONFIG_PPC */
 
diff --git a/drivers/macintosh/therm_pm72.c b/drivers/macintosh/therm_pm72.c
index 454bc501df3c..5738d8bf2d97 100644
--- a/drivers/macintosh/therm_pm72.c
+++ b/drivers/macintosh/therm_pm72.c
@@ -1899,7 +1899,7 @@ static int create_control_loops(void)
          */
         if (rackmac)
                 cpu_pid_type = CPU_PID_TYPE_RACKMAC;
-        else if (machine_is_compatible("PowerMac7,3")
+        else if (of_machine_is_compatible("PowerMac7,3")
             && (cpu_count > 1)
             && fcu_fans[CPUA_PUMP_RPM_INDEX].id != FCU_FAN_ABSENT_ID
             && fcu_fans[CPUB_PUMP_RPM_INDEX].id != FCU_FAN_ABSENT_ID) {
@@ -2234,10 +2234,10 @@ static int __init therm_pm72_init(void)
 {
         struct device_node *np;
 
-        rackmac = machine_is_compatible("RackMac3,1");
+        rackmac = of_machine_is_compatible("RackMac3,1");
 
-        if (!machine_is_compatible("PowerMac7,2") &&
-            !machine_is_compatible("PowerMac7,3") &&
+        if (!of_machine_is_compatible("PowerMac7,2") &&
+            !of_machine_is_compatible("PowerMac7,3") &&
             !rackmac)
                 return -ENODEV;
 
diff --git a/drivers/macintosh/therm_windtunnel.c b/drivers/macintosh/therm_windtunnel.c
index ba48fd76396e..7fb8b4da35a7 100644
--- a/drivers/macintosh/therm_windtunnel.c
+++ b/drivers/macintosh/therm_windtunnel.c
@@ -490,7 +490,7 @@ g4fan_init( void )
         info = of_get_property(np, "thermal-info", NULL);
         of_node_put(np);
 
-        if( !info || !machine_is_compatible("PowerMac3,6") )
+        if( !info || !of_machine_is_compatible("PowerMac3,6") )
                 return -ENODEV;
 
         if( info->id != 3 ) {
diff --git a/drivers/macintosh/via-pmu-backlight.c b/drivers/macintosh/via-pmu-backlight.c
index a348bb0791d3..4f3c4479c16a 100644
--- a/drivers/macintosh/via-pmu-backlight.c
+++ b/drivers/macintosh/via-pmu-backlight.c
@@ -150,13 +150,13 @@ void __init pmu_backlight_init()
 
         /* Special case for the old PowerBook since I can't test on it */
         autosave =
-                machine_is_compatible("AAPL,3400/2400") ||
-                machine_is_compatible("AAPL,3500");
+                of_machine_is_compatible("AAPL,3400/2400") ||
+                of_machine_is_compatible("AAPL,3500");
 
         if (!autosave &&
             !pmac_has_backlight_type("pmu") &&
-            !machine_is_compatible("AAPL,PowerBook1998") &&
-            !machine_is_compatible("PowerBook1,1"))
+            !of_machine_is_compatible("AAPL,PowerBook1998") &&
+            !of_machine_is_compatible("PowerBook1,1"))
                 return;
 
         snprintf(name, sizeof(name), "pmubl");
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index db379c381432..42764849eb78 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -463,8 +463,8 @@ static int __init via_pmu_dev_init(void)
 #endif
 
 #ifdef CONFIG_PPC32
-        if (machine_is_compatible("AAPL,3400/2400") ||
-                machine_is_compatible("AAPL,3500")) {
+        if (of_machine_is_compatible("AAPL,3400/2400") ||
+                of_machine_is_compatible("AAPL,3500")) {
                 int mb = pmac_call_feature(PMAC_FTR_GET_MB_INFO,
                         NULL, PMAC_MB_INFO_MODEL, 0);
                 pmu_battery_count = 1;
@@ -472,8 +472,8 @@ static int __init via_pmu_dev_init(void)
                         pmu_batteries[0].flags |= PMU_BATT_TYPE_COMET;
                 else
                         pmu_batteries[0].flags |= PMU_BATT_TYPE_HOOPER;
-        } else if (machine_is_compatible("AAPL,PowerBook1998") ||
-                machine_is_compatible("PowerBook1,1")) {
+        } else if (of_machine_is_compatible("AAPL,PowerBook1998") ||
+                of_machine_is_compatible("PowerBook1,1")) {
                 pmu_battery_count = 2;
                 pmu_batteries[0].flags |= PMU_BATT_TYPE_SMART;
                 pmu_batteries[1].flags |= PMU_BATT_TYPE_SMART;
diff --git a/drivers/macintosh/windfarm_core.c b/drivers/macintosh/windfarm_core.c
index 075b4d99e354..437f55c5d18d 100644
--- a/drivers/macintosh/windfarm_core.c
+++ b/drivers/macintosh/windfarm_core.c
@@ -468,9 +468,9 @@ static int __init windfarm_core_init(void)
         DBG("wf: core loaded\n");
 
         /* Don't register on old machines that use therm_pm72 for now */
-        if (machine_is_compatible("PowerMac7,2") ||
-            machine_is_compatible("PowerMac7,3") ||
-            machine_is_compatible("RackMac3,1"))
+        if (of_machine_is_compatible("PowerMac7,2") ||
+            of_machine_is_compatible("PowerMac7,3") ||
+            of_machine_is_compatible("RackMac3,1"))
                 return -ENODEV;
         platform_device_register(&wf_platform_device);
         return 0;
diff --git a/drivers/macintosh/windfarm_cpufreq_clamp.c b/drivers/macintosh/windfarm_cpufreq_clamp.c
index 900aade06198..1a77a7c97d0e 100644
--- a/drivers/macintosh/windfarm_cpufreq_clamp.c
+++ b/drivers/macintosh/windfarm_cpufreq_clamp.c
@@ -76,9 +76,9 @@ static int __init wf_cpufreq_clamp_init(void)
         struct wf_control *clamp;
 
         /* Don't register on old machines that use therm_pm72 for now */
-        if (machine_is_compatible("PowerMac7,2") ||
-            machine_is_compatible("PowerMac7,3") ||
-            machine_is_compatible("RackMac3,1"))
+        if (of_machine_is_compatible("PowerMac7,2") ||
+            of_machine_is_compatible("PowerMac7,3") ||
+            of_machine_is_compatible("RackMac3,1"))
                 return -ENODEV;
 
         clamp = kmalloc(sizeof(struct wf_control), GFP_KERNEL);
diff --git a/drivers/macintosh/windfarm_lm75_sensor.c b/drivers/macintosh/windfarm_lm75_sensor.c
index ed6426a10773..d8257d35afde 100644
--- a/drivers/macintosh/windfarm_lm75_sensor.c
+++ b/drivers/macintosh/windfarm_lm75_sensor.c
@@ -239,9 +239,9 @@ static struct i2c_driver wf_lm75_driver = {
 static int __init wf_lm75_sensor_init(void)
 {
         /* Don't register on old machines that use therm_pm72 for now */
-        if (machine_is_compatible("PowerMac7,2") ||
-            machine_is_compatible("PowerMac7,3") ||
-            machine_is_compatible("RackMac3,1"))
+        if (of_machine_is_compatible("PowerMac7,2") ||
+            of_machine_is_compatible("PowerMac7,3") ||
+            of_machine_is_compatible("RackMac3,1"))
                 return -ENODEV;
         return i2c_add_driver(&wf_lm75_driver);
 }
diff --git a/drivers/macintosh/windfarm_max6690_sensor.c b/drivers/macintosh/windfarm_max6690_sensor.c
index a67b349319e9..b486eb929fde 100644
--- a/drivers/macintosh/windfarm_max6690_sensor.c
+++ b/drivers/macintosh/windfarm_max6690_sensor.c
@@ -188,9 +188,9 @@ static struct i2c_driver wf_max6690_driver = {
 static int __init wf_max6690_sensor_init(void)
 {
         /* Don't register on old machines that use therm_pm72 for now */
-        if (machine_is_compatible("PowerMac7,2") ||
-            machine_is_compatible("PowerMac7,3") ||
-            machine_is_compatible("RackMac3,1"))
+        if (of_machine_is_compatible("PowerMac7,2") ||
+            of_machine_is_compatible("PowerMac7,3") ||
+            of_machine_is_compatible("RackMac3,1"))
                 return -ENODEV;
         return i2c_add_driver(&wf_max6690_driver);
 }
diff --git a/drivers/macintosh/windfarm_pm112.c b/drivers/macintosh/windfarm_pm112.c
index 73d695dc9e50..e0ee80700cde 100644
--- a/drivers/macintosh/windfarm_pm112.c
+++ b/drivers/macintosh/windfarm_pm112.c
@@ -676,7 +676,7 @@ static int __init wf_pm112_init(void)
 {
         struct device_node *cpu;
 
-        if (!machine_is_compatible("PowerMac11,2"))
+        if (!of_machine_is_compatible("PowerMac11,2"))
                 return -ENODEV;
 
         /* Count the number of CPU cores */
diff --git a/drivers/macintosh/windfarm_pm121.c b/drivers/macintosh/windfarm_pm121.c
index 66ec4fb115bb..947d4afa25ca 100644
--- a/drivers/macintosh/windfarm_pm121.c
+++ b/drivers/macintosh/windfarm_pm121.c
@@ -1008,7 +1008,7 @@ static int __init pm121_init(void)
 {
         int rc = -ENODEV;
 
-        if (machine_is_compatible("PowerMac12,1"))
+        if (of_machine_is_compatible("PowerMac12,1"))
                 rc = pm121_init_pm();
 
         if (rc == 0) {
diff --git a/drivers/macintosh/windfarm_pm81.c b/drivers/macintosh/windfarm_pm81.c
index abbe206474f5..565d5b2adc95 100644
--- a/drivers/macintosh/windfarm_pm81.c
+++ b/drivers/macintosh/windfarm_pm81.c
@@ -779,8 +779,8 @@ static int __init wf_smu_init(void)
 {
         int rc = -ENODEV;
 
-        if (machine_is_compatible("PowerMac8,1") ||
-            machine_is_compatible("PowerMac8,2"))
+        if (of_machine_is_compatible("PowerMac8,1") ||
+            of_machine_is_compatible("PowerMac8,2"))
                 rc = wf_init_pm();
 
         if (rc == 0) {
diff --git a/drivers/macintosh/windfarm_pm91.c b/drivers/macintosh/windfarm_pm91.c
index 764c525b2117..bea99168ff35 100644
--- a/drivers/macintosh/windfarm_pm91.c
+++ b/drivers/macintosh/windfarm_pm91.c
@@ -711,7 +711,7 @@ static int __init wf_smu_init(void)
 {
         int rc = -ENODEV;
 
-        if (machine_is_compatible("PowerMac9,1"))
+        if (of_machine_is_compatible("PowerMac9,1"))
                 rc = wf_init_pm();
 
         if (rc == 0) {
diff --git a/drivers/macintosh/windfarm_smu_sensors.c b/drivers/macintosh/windfarm_smu_sensors.c
index 9c567b93f417..3c193504bb80 100644
--- a/drivers/macintosh/windfarm_smu_sensors.c
+++ b/drivers/macintosh/windfarm_smu_sensors.c
@@ -363,9 +363,9 @@ smu_cpu_power_create(struct wf_sensor *volts, struct wf_sensor *amps)
          * I yet have to figure out what's up with 8,2 and will have to
          * adjust for later, unless we can 100% trust the SDB partition...
          */
-        if ((machine_is_compatible("PowerMac8,1") ||
-             machine_is_compatible("PowerMac8,2") ||
-             machine_is_compatible("PowerMac9,1")) &&
+        if ((of_machine_is_compatible("PowerMac8,1") ||
+             of_machine_is_compatible("PowerMac8,2") ||
+             of_machine_is_compatible("PowerMac9,1")) &&
             cpuvcp_version >= 2) {
                 pow->quadratic = 1;
                 DBG("windfarm: CPU Power using quadratic transform\n");
diff --git a/drivers/md/dm-log-userspace-transfer.c b/drivers/md/dm-log-userspace-transfer.c
index 54abf9e303b7..f1c8cae70b4b 100644
--- a/drivers/md/dm-log-userspace-transfer.c
+++ b/drivers/md/dm-log-userspace-transfer.c
@@ -172,11 +172,15 @@ int dm_consult_userspace(const char *uuid, uint64_t luid, int request_type,
 {
         int r = 0;
         size_t dummy = 0;
-        int overhead_size =
-                sizeof(struct dm_ulog_request *) + sizeof(struct cn_msg);
+        int overhead_size = sizeof(struct dm_ulog_request) + sizeof(struct cn_msg);
         struct dm_ulog_request *tfr = prealloced_ulog_tfr;
         struct receiving_pkg pkg;
 
+        /*
+         * Given the space needed to hold the 'struct cn_msg' and
+         * 'struct dm_ulog_request' - do we have enough payload
+         * space remaining?
+         */
         if (data_size > (DM_ULOG_PREALLOCED_SIZE - overhead_size)) {
                 DMINFO("Size of tfr exceeds preallocated size");
                 return -EINVAL;
@@ -191,7 +195,7 @@ resend:
          */
         mutex_lock(&dm_ulog_lock);
 
-        memset(tfr, 0, DM_ULOG_PREALLOCED_SIZE - overhead_size);
+        memset(tfr, 0, DM_ULOG_PREALLOCED_SIZE - sizeof(struct cn_msg));
         memcpy(tfr->uuid, uuid, DM_UUID_LEN);
         tfr->luid = luid;
         tfr->seq = dm_ulog_seq++;
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index ad779bd13aec..6c1046df81f6 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -724,7 +724,7 @@ static void do_writes(struct mirror_set *ms, struct bio_list *writes)
         /*
          * Dispatch io.
          */
-        if (unlikely(ms->log_failure)) {
+        if (unlikely(ms->log_failure) && errors_handled(ms)) {
                 spin_lock_irq(&ms->lock);
                 bio_list_merge(&ms->failures, &sync);
                 spin_unlock_irq(&ms->lock);
diff --git a/drivers/md/dm-region-hash.c b/drivers/md/dm-region-hash.c
index 5f19ceb6fe91..168bd38f5006 100644
--- a/drivers/md/dm-region-hash.c
+++ b/drivers/md/dm-region-hash.c
@@ -660,10 +660,9 @@ void dm_rh_recovery_end(struct dm_region *reg, int success)
         spin_lock_irq(&rh->region_lock);
         if (success)
                 list_add(&reg->list, &reg->rh->recovered_regions);
-        else {
-                reg->state = DM_RH_NOSYNC;
+        else
                 list_add(&reg->list, &reg->rh->failed_recovered_regions);
-        }
+
         spin_unlock_irq(&rh->region_lock);
 
         rh->wakeup_workers(rh->context);
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 7d08879689ac..c097d8a4823d 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -254,7 +254,7 @@ static int chunk_io(struct pstore *ps, void *area, chunk_t chunk, int rw,
          * Issue the synchronous I/O from a different thread
          * to avoid generic_make_request recursion.
          */
-        INIT_WORK(&req.work, do_metadata);
+        INIT_WORK_ON_STACK(&req.work, do_metadata);
         queue_work(ps->metadata_wq, &req.work);
         flush_workqueue(ps->metadata_wq);
 
diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
index e0efc1adcaff..bd58703ee8f6 100644
--- a/drivers/md/dm-stripe.c
+++ b/drivers/md/dm-stripe.c
@@ -110,7 +110,7 @@ static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
         }
 
         stripes = simple_strtoul(argv[0], &end, 10);
-        if (*end) {
+        if (!stripes || *end) {
                 ti->error = "Invalid stripe count";
                 return -EINVAL;
         }
diff --git a/drivers/md/dm-sysfs.c b/drivers/md/dm-sysfs.c
index f53392df7b97..f91b40942e07 100644
--- a/drivers/md/dm-sysfs.c
+++ b/drivers/md/dm-sysfs.c
@@ -80,20 +80,12 @@ static struct sysfs_ops dm_sysfs_ops = {
 };
 
 /*
- * The sysfs structure is embedded in md struct, nothing to do here
- */
-static void dm_sysfs_release(struct kobject *kobj)
-{
-}
-
-/*
  * dm kobject is embedded in mapped_device structure
  * no need to define release function here
  */
 static struct kobj_type dm_ktype = {
         .sysfs_ops      = &dm_sysfs_ops,
         .default_attrs  = dm_attrs,
-        .release        = dm_sysfs_release
 };
 
 /*
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 3167480b532c..aa4e2aa86d49 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1595,10 +1595,15 @@ static int dm_prep_fn(struct request_queue *q, struct request *rq)
         return BLKPREP_OK;
 }
 
-static void map_request(struct dm_target *ti, struct request *clone,
-                        struct mapped_device *md)
+/*
+ * Returns:
+ * 0  : the request has been processed (not requeued)
+ * !0 : the request has been requeued
+ */
+static int map_request(struct dm_target *ti, struct request *clone,
+                       struct mapped_device *md)
 {
-        int r;
+        int r, requeued = 0;
         struct dm_rq_target_io *tio = clone->end_io_data;
 
         /*
@@ -1625,6 +1630,7 @@ static void map_request(struct dm_target *ti, struct request *clone,
         case DM_MAPIO_REQUEUE:
                 /* The target wants to requeue the I/O */
                 dm_requeue_unmapped_request(clone);
+                requeued = 1;
                 break;
         default:
                 if (r > 0) {
@@ -1636,6 +1642,8 @@ static void map_request(struct dm_target *ti, struct request *clone,
                 dm_kill_unmapped_request(clone, r);
                 break;
         }
+
+        return requeued;
 }
 
 /*
@@ -1677,12 +1685,17 @@ static void dm_request_fn(struct request_queue *q)
                 atomic_inc(&md->pending[rq_data_dir(clone)]);
 
                 spin_unlock(q->queue_lock);
-                map_request(ti, clone, md);
+                if (map_request(ti, clone, md))
+                        goto requeued;
+
                 spin_lock_irq(q->queue_lock);
         }
 
         goto out;
 
+requeued:
+        spin_lock_irq(q->queue_lock);
+
 plug_and_out:
         if (!elv_queue_empty(q))
                 /* Some requests still remain, retry later */
diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
index 1b249897c9fb..465295b1d14b 100644
--- a/drivers/media/dvb/dvb-usb/Kconfig
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -112,11 +112,13 @@ config DVB_USB_CXUSB
         select DVB_MT352 if !DVB_FE_CUSTOMISE
         select DVB_ZL10353 if !DVB_FE_CUSTOMISE
         select DVB_DIB7000P if !DVB_FE_CUSTOMISE
-        select DVB_LGS8GL5 if !DVB_FE_CUSTOMISE
         select DVB_TUNER_DIB0070 if !DVB_FE_CUSTOMISE
+        select DVB_ATBM8830 if !DVB_FE_CUSTOMISE
+        select DVB_LGS8GXX if !DVB_FE_CUSTOMISE
         select MEDIA_TUNER_SIMPLE if !MEDIA_TUNER_CUSTOMISE
         select MEDIA_TUNER_XC2028 if !MEDIA_TUNER_CUSTOMISE
         select MEDIA_TUNER_MXL5005S if !MEDIA_TUNER_CUSTOMISE
+        select MEDIA_TUNER_MAX2165 if !MEDIA_TUNER_CUSTOMISE
         help
           Say Y here to support the Conexant USB2.0 hybrid reference design.
           Currently, only DVB and ATSC modes are supported, analog mode
diff --git a/drivers/media/dvb/frontends/l64781.c b/drivers/media/dvb/frontends/l64781.c
index 3051b64aa17c..445fa1068064 100644
--- a/drivers/media/dvb/frontends/l64781.c
+++ b/drivers/media/dvb/frontends/l64781.c
@@ -192,8 +192,8 @@ static int apply_frontend_param (struct dvb_frontend* fe, struct dvb_frontend_pa
         spi_bias *= qam_tab[p->constellation];
         spi_bias /= p->code_rate_HP + 1;
         spi_bias /= (guard_tab[p->guard_interval] + 32);
-        spi_bias *= 1000ULL;
-        spi_bias /= 1000ULL + ppm/1000;
+        spi_bias *= 1000;
+        spi_bias /= 1000 + ppm/1000;
         spi_bias *= p->code_rate_HP;
 
         val0x04 = (p->transmission_mode << 2) | p->guard_interval;
diff --git a/drivers/media/video/bt8xx/bttv-driver.c b/drivers/media/video/bt8xx/bttv-driver.c
index 3182a406bdd1..ae08b077fd04 100644
--- a/drivers/media/video/bt8xx/bttv-driver.c
+++ b/drivers/media/video/bt8xx/bttv-driver.c
@@ -4461,6 +4461,7 @@ static int __devinit bttv_probe(struct pci_dev *dev,
                 request_modules(btv);
         }
 
+        init_bttv_i2c_ir(btv);
         bttv_input_init(btv);
 
         /* everything is fine */
diff --git a/drivers/media/video/bt8xx/bttv-i2c.c b/drivers/media/video/bt8xx/bttv-i2c.c
index 63aa31a041e8..407fa61e4cda 100644
--- a/drivers/media/video/bt8xx/bttv-i2c.c
+++ b/drivers/media/video/bt8xx/bttv-i2c.c
@@ -388,7 +388,12 @@ int __devinit init_bttv_i2c(struct bttv *btv)
         if (0 == btv->i2c_rc && i2c_scan)
                 do_i2c_scan(btv->c.v4l2_dev.name, &btv->i2c_client);
 
-        /* Instantiate the IR receiver device, if present */
+        return btv->i2c_rc;
+}
+
+/* Instantiate the I2C IR receiver device, if present */
+void __devinit init_bttv_i2c_ir(struct bttv *btv)
+{
         if (0 == btv->i2c_rc) {
                 struct i2c_board_info info;
                 /* The external IR receiver is at i2c address 0x34 (0x35 for
@@ -408,7 +413,6 @@ int __devinit init_bttv_i2c(struct bttv *btv)
                 strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
                 i2c_new_probed_device(&btv->c.i2c_adap, &info, addr_list);
         }
-        return btv->i2c_rc;
 }
 
 int __devexit fini_bttv_i2c(struct bttv *btv)
diff --git a/drivers/media/video/bt8xx/bttvp.h b/drivers/media/video/bt8xx/bttvp.h
index a1d0e9c9f286..6cccc2a17eee 100644
--- a/drivers/media/video/bt8xx/bttvp.h
+++ b/drivers/media/video/bt8xx/bttvp.h
@@ -279,6 +279,7 @@ extern unsigned int bttv_debug;
 extern unsigned int bttv_gpio;
 extern void bttv_gpio_tracking(struct bttv *btv, char *comment);
 extern int init_bttv_i2c(struct bttv *btv);
+extern void init_bttv_i2c_ir(struct bttv *btv);
 extern int fini_bttv_i2c(struct bttv *btv);
 
 #define bttv_printk if (bttv_verbose) printk
diff --git a/drivers/media/video/mt9t112.c b/drivers/media/video/mt9t112.c
index fc4dd6045720..7438f8d775ba 100644
--- a/drivers/media/video/mt9t112.c
+++ b/drivers/media/video/mt9t112.c
@@ -514,7 +514,7 @@ static int mt9t112_init_pll(const struct i2c_client *client)
         /* poll to verify out of standby. Must Poll this bit */
         for (i = 0; i < 100; i++) {
                 mt9t112_reg_read(data, client, 0x0018);
-                if (0x4000 & data)
+                if (!(0x4000 & data))
                         break;
 
                 mdelay(10);
diff --git a/drivers/media/video/pwc/pwc-ctrl.c b/drivers/media/video/pwc/pwc-ctrl.c
index 50b415e07eda..f7f7e04cf485 100644
--- a/drivers/media/video/pwc/pwc-ctrl.c
+++ b/drivers/media/video/pwc/pwc-ctrl.c
@@ -753,7 +753,7 @@ int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
                 buf[0] = 0xff; /* fixed */
 
         ret = send_control_msg(pdev,
-                SET_LUM_CTL, SHUTTER_MODE_FORMATTER, &buf, sizeof(buf));
+                SET_LUM_CTL, SHUTTER_MODE_FORMATTER, &buf, 1);
 
         if (!mode && ret >= 0) {
                 if (value < 0)
diff --git a/drivers/net/benet/be_cmds.c b/drivers/net/benet/be_cmds.c
index fee6eee7ae5b..006cb2efcd22 100644
--- a/drivers/net/benet/be_cmds.c
+++ b/drivers/net/benet/be_cmds.c
@@ -296,6 +296,7 @@ static void be_cmd_hdr_prepare(struct be_cmd_req_hdr *req_hdr,
         req_hdr->opcode = opcode;
         req_hdr->subsystem = subsystem;
         req_hdr->request_length = cpu_to_le32(cmd_len - sizeof(*req_hdr));
+        req_hdr->version = 0;
 }
 
 static void be_cmd_page_addrs_prepare(struct phys_addr *pages, u32 max_pages,
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index d29bb532eccf..765543663a4f 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -4006,11 +4006,21 @@ check_page:
                         }
                 }
 
-                if (!buffer_info->dma)
+                if (!buffer_info->dma) {
                         buffer_info->dma = pci_map_page(pdev,
                                                         buffer_info->page, 0,
                                                         buffer_info->length,
                                                         PCI_DMA_FROMDEVICE);
+                        if (pci_dma_mapping_error(pdev, buffer_info->dma)) {
+                                put_page(buffer_info->page);
+                                dev_kfree_skb(skb);
+                                buffer_info->page = NULL;
+                                buffer_info->skb = NULL;
+                                buffer_info->dma = 0;
+                                adapter->alloc_rx_buff_failed++;
+                                break; /* while !buffer_info->skb */
+                        }
+                }
 
                 rx_desc = E1000_RX_DESC(*rx_ring, i);
                 rx_desc->buffer_addr = cpu_to_le64(buffer_info->dma);
@@ -4101,6 +4111,13 @@ map_skb:
                                                   skb->data,
                                                   buffer_info->length,
                                                   PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(pdev, buffer_info->dma)) {
+                        dev_kfree_skb(skb);
+                        buffer_info->skb = NULL;
+                        buffer_info->dma = 0;
+                        adapter->alloc_rx_buff_failed++;
+                        break; /* while !buffer_info->skb */
+                }
 
                 /*
                  * XXX if it was allocated cleanly it will never map to a
diff --git a/drivers/net/ixgbe/ixgbe_82598.c b/drivers/net/ixgbe/ixgbe_82598.c
index 3103f4165311..35a06b47587b 100644
--- a/drivers/net/ixgbe/ixgbe_82598.c
+++ b/drivers/net/ixgbe/ixgbe_82598.c
@@ -357,12 +357,34 @@ static s32 ixgbe_fc_enable_82598(struct ixgbe_hw *hw, s32 packetbuf_num)
         u32 fctrl_reg;
         u32 rmcs_reg;
         u32 reg;
+        u32 link_speed = 0;
+        bool link_up;
 
 #ifdef CONFIG_DCB
         if (hw->fc.requested_mode == ixgbe_fc_pfc)
                 goto out;
 
 #endif /* CONFIG_DCB */
+        /*
+         * On 82598 having Rx FC on causes resets while doing 1G
+         * so if it's on turn it off once we know link_speed. For
+         * more details see 82598 Specification update.
+         */
+        hw->mac.ops.check_link(hw, &link_speed, &link_up, false);
+        if (link_up && link_speed == IXGBE_LINK_SPEED_1GB_FULL) {
+                switch (hw->fc.requested_mode) {
+                case ixgbe_fc_full:
+                        hw->fc.requested_mode = ixgbe_fc_tx_pause;
+                        break;
+                case ixgbe_fc_rx_pause:
+                        hw->fc.requested_mode = ixgbe_fc_none;
+                        break;
+                default:
+                        /* no change */
+                        break;
+                }
+        }
+
         /* Negotiate the fc mode to use */
         ret_val = ixgbe_fc_autoneg(hw);
         if (ret_val)
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index 7b7c8486c0bf..951b73cf5ca2 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -5763,6 +5763,10 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         if (err)
                 goto err_sw_init;
 
+        /* Make it possible the adapter to be woken up via WOL */
+        if (adapter->hw.mac.type == ixgbe_mac_82599EB)
+                IXGBE_WRITE_REG(&adapter->hw, IXGBE_WUS, ~0);
+
         /*
          * If there is a fan on this device and it has failed log the
          * failure.
diff --git a/drivers/net/mace.c b/drivers/net/mace.c
index d9fbad386389..43aea91e3369 100644
--- a/drivers/net/mace.c
+++ b/drivers/net/mace.c
@@ -206,7 +206,7 @@ static int __devinit mace_probe(struct macio_dev *mdev, const struct of_device_i
                 mp->port_aaui = port_aaui;
         else {
                 /* Apple Network Server uses the AAUI port */
-                if (machine_is_compatible("AAPL,ShinerESB"))
+                if (of_machine_is_compatible("AAPL,ShinerESB"))
                         mp->port_aaui = 1;
                 else {
 #ifdef CONFIG_MACE_AAUI_PORT
diff --git a/drivers/net/sfc/efx.c b/drivers/net/sfc/efx.c
index 103e8b0e2a0d..46997e177ee3 100644
--- a/drivers/net/sfc/efx.c
+++ b/drivers/net/sfc/efx.c
@@ -2284,6 +2284,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev,
  fail2:
         efx_fini_struct(efx);
  fail1:
+        WARN_ON(rc > 0);
         EFX_LOG(efx, "initialisation failed. rc=%d\n", rc);
         free_netdev(net_dev);
         return rc;
diff --git a/drivers/net/sfc/falcon_boards.c b/drivers/net/sfc/falcon_boards.c
index bf0b96af5334..5712fddd72f2 100644
--- a/drivers/net/sfc/falcon_boards.c
+++ b/drivers/net/sfc/falcon_boards.c
@@ -29,6 +29,15 @@
 #define FALCON_BOARD_SFN4111T 0x51
 #define FALCON_BOARD_SFN4112F 0x52
 
+/* Board temperature is about 15°C above ambient when air flow is
+ * limited. */
+#define FALCON_BOARD_TEMP_BIAS  15
+
+/* SFC4000 datasheet says: 'The maximum permitted junction temperature
+ * is 125°C; the thermal design of the environment for the SFC4000
+ * should aim to keep this well below 100°C.' */
+#define FALCON_JUNC_TEMP_MAX    90
+
 /*****************************************************************************
  * Support for LM87 sensor chip used on several boards
  */
@@ -548,16 +557,16 @@ fail_hwmon:
 static u8 sfe4002_lm87_channel = 0x03; /* use AIN not FAN inputs */
 
 static const u8 sfe4002_lm87_regs[] = {
-        LM87_IN_LIMITS(0, 0x83, 0x91),          /* 2.5V:  1.8V +/- 5% */
-        LM87_IN_LIMITS(1, 0x51, 0x5a),          /* Vccp1: 1.2V +/- 5% */
-        LM87_IN_LIMITS(2, 0xb6, 0xca),          /* 3.3V:  3.3V +/- 5% */
-        LM87_IN_LIMITS(3, 0xb0, 0xc9),          /* 5V:    4.6-5.2V */
-        LM87_IN_LIMITS(4, 0xb0, 0xe0),          /* 12V:   11-14V */
-        LM87_IN_LIMITS(5, 0x44, 0x4b),          /* Vccp2: 1.0V +/- 5% */
-        LM87_AIN_LIMITS(0, 0xa0, 0xb2),         /* AIN1:  1.66V +/- 5% */
-        LM87_AIN_LIMITS(1, 0x91, 0xa1),         /* AIN2:  1.5V +/- 5% */
-        LM87_TEMP_INT_LIMITS(10, 60),           /* board */
-        LM87_TEMP_EXT1_LIMITS(10, 70),          /* Falcon */
+        LM87_IN_LIMITS(0, 0x7c, 0x99),          /* 2.5V:  1.8V +/- 10% */
+        LM87_IN_LIMITS(1, 0x4c, 0x5e),          /* Vccp1: 1.2V +/- 10% */
+        LM87_IN_LIMITS(2, 0xac, 0xd4),          /* 3.3V:  3.3V +/- 10% */
+        LM87_IN_LIMITS(3, 0xac, 0xd4),          /* 5V:    5.0V +/- 10% */
+        LM87_IN_LIMITS(4, 0xac, 0xe0),          /* 12V:   10.8-14V */
+        LM87_IN_LIMITS(5, 0x3f, 0x4f),          /* Vccp2: 1.0V +/- 10% */
+        LM87_AIN_LIMITS(0, 0x98, 0xbb),         /* AIN1:  1.66V +/- 10% */
+        LM87_AIN_LIMITS(1, 0x8a, 0xa9),         /* AIN2:  1.5V +/- 10% */
+        LM87_TEMP_INT_LIMITS(0, 80 + FALCON_BOARD_TEMP_BIAS),
+        LM87_TEMP_EXT1_LIMITS(0, FALCON_JUNC_TEMP_MAX),
         0
 };
 
@@ -619,14 +628,14 @@ static int sfe4002_init(struct efx_nic *efx)
 static u8 sfn4112f_lm87_channel = 0x03; /* use AIN not FAN inputs */
 
 static const u8 sfn4112f_lm87_regs[] = {
-        LM87_IN_LIMITS(0, 0x83, 0x91),          /* 2.5V:  1.8V +/- 5% */
-        LM87_IN_LIMITS(1, 0x51, 0x5a),          /* Vccp1: 1.2V +/- 5% */
-        LM87_IN_LIMITS(2, 0xb6, 0xca),          /* 3.3V:  3.3V +/- 5% */
-        LM87_IN_LIMITS(4, 0xb0, 0xe0),          /* 12V:   11-14V */
-        LM87_IN_LIMITS(5, 0x44, 0x4b),          /* Vccp2: 1.0V +/- 5% */
-        LM87_AIN_LIMITS(1, 0x91, 0xa1),         /* AIN2:  1.5V +/- 5% */
-        LM87_TEMP_INT_LIMITS(10, 60),           /* board */
-        LM87_TEMP_EXT1_LIMITS(10, 70),          /* Falcon */
+        LM87_IN_LIMITS(0, 0x7c, 0x99),          /* 2.5V:  1.8V +/- 10% */
+        LM87_IN_LIMITS(1, 0x4c, 0x5e),          /* Vccp1: 1.2V +/- 10% */
+        LM87_IN_LIMITS(2, 0xac, 0xd4),          /* 3.3V:  3.3V +/- 10% */
+        LM87_IN_LIMITS(4, 0xac, 0xe0),          /* 12V:   10.8-14V */
+        LM87_IN_LIMITS(5, 0x3f, 0x4f),          /* Vccp2: 1.0V +/- 10% */
+        LM87_AIN_LIMITS(1, 0x8a, 0xa9),         /* AIN2:  1.5V +/- 10% */
+        LM87_TEMP_INT_LIMITS(0, 60 + FALCON_BOARD_TEMP_BIAS),
+        LM87_TEMP_EXT1_LIMITS(0, FALCON_JUNC_TEMP_MAX),
         0
 };
 
diff --git a/drivers/net/sfc/mcdi.c b/drivers/net/sfc/mcdi.c
index 9f035b9f0350..f66b3da6ddff 100644
--- a/drivers/net/sfc/mcdi.c
+++ b/drivers/net/sfc/mcdi.c
@@ -127,7 +127,7 @@ static int efx_mcdi_poll(struct efx_nic *efx)
         efx_dword_t reg;
 
         /* Check for a reboot atomically with respect to efx_mcdi_copyout() */
-        rc = efx_mcdi_poll_reboot(efx);
+        rc = -efx_mcdi_poll_reboot(efx);
         if (rc)
                 goto out;
 
diff --git a/drivers/net/sfc/qt202x_phy.c b/drivers/net/sfc/qt202x_phy.c
index e0d13a451019..67eec7a6e487 100644
--- a/drivers/net/sfc/qt202x_phy.c
+++ b/drivers/net/sfc/qt202x_phy.c
@@ -320,7 +320,7 @@ static int qt202x_reset_phy(struct efx_nic *efx)
 
         falcon_board(efx)->type->init_phy(efx);
 
-        return rc;
+        return 0;
 
  fail:
         EFX_ERR(efx, "PHY reset timed out\n");
diff --git a/drivers/net/tc35815.c b/drivers/net/tc35815.c
index 75a669d48e5e..d71c1976072e 100644
--- a/drivers/net/tc35815.c
+++ b/drivers/net/tc35815.c
@@ -1437,7 +1437,6 @@ static int tc35815_do_interrupt(struct net_device *dev, u32 status, int limit)
                 /* Transmit complete. */
                 lp->lstats.tx_ints++;
                 tc35815_txdone(dev);
-                netif_wake_queue(dev);
                 if (ret < 0)
                         ret = 0;
         }
diff --git a/drivers/net/usb/cdc_ether.c b/drivers/net/usb/cdc_ether.c
index 4f27f022fbf7..5f3b9eaeb04f 100644
--- a/drivers/net/usb/cdc_ether.c
+++ b/drivers/net/usb/cdc_ether.c
@@ -584,6 +584,11 @@ static const struct usb_device_id	products [] = {
                         USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
         .driver_info = (unsigned long) &mbm_info,
 }, {
+        /* Ericsson C3607w ver 2 */
+        USB_DEVICE_AND_INTERFACE_INFO(0x0bdb, 0x190b, USB_CLASS_COMM,
+                        USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
+        .driver_info = (unsigned long) &mbm_info,
+}, {
         /* Toshiba F3507g */
         USB_DEVICE_AND_INTERFACE_INFO(0x0930, 0x130b, USB_CLASS_COMM,
                         USB_CDC_SUBCLASS_MDLM, USB_CDC_PROTO_NONE),
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index c93f58f5c6f2..317aa34b21cf 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -1877,13 +1877,12 @@ static void velocity_error(struct velocity_info *vptr, int status)
 /**
  *      tx_srv          -       transmit interrupt service
  *      @vptr; Velocity
- *      @status:
  *
  *      Scan the queues looking for transmitted packets that
  *      we can complete and clean up. Update any statistics as
  *      necessary/
  */
-static int velocity_tx_srv(struct velocity_info *vptr, u32 status)
+static int velocity_tx_srv(struct velocity_info *vptr)
 {
         struct tx_desc *td;
         int qnum;
@@ -2090,14 +2089,12 @@ static int velocity_receive_frame(struct velocity_info *vptr, int idx)
 /**
  *      velocity_rx_srv         -       service RX interrupt
  *      @vptr: velocity
- *      @status: adapter status (unused)
  *
  *      Walk the receive ring of the velocity adapter and remove
  *      any received packets from the receive queue. Hand the ring
  *      slots back to the adapter for reuse.
  */
-static int velocity_rx_srv(struct velocity_info *vptr, int status,
-                int budget_left)
+static int velocity_rx_srv(struct velocity_info *vptr, int budget_left)
 {
         struct net_device_stats *stats = &vptr->dev->stats;
         int rd_curr = vptr->rx.curr;
@@ -2151,32 +2148,24 @@ static int velocity_poll(struct napi_struct *napi, int budget)
         struct velocity_info *vptr = container_of(napi,
                         struct velocity_info, napi);
         unsigned int rx_done;
-        u32 isr_status;
-
-        spin_lock(&vptr->lock);
-        isr_status = mac_read_isr(vptr->mac_regs);
-
-        /* Ack the interrupt */
-        mac_write_isr(vptr->mac_regs, isr_status);
-        if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
-                velocity_error(vptr, isr_status);
+        unsigned long flags;
 
+        spin_lock_irqsave(&vptr->lock, flags);
         /*
          * Do rx and tx twice for performance (taken from the VIA
          * out-of-tree driver).
          */
-        rx_done = velocity_rx_srv(vptr, isr_status, budget / 2);
-        velocity_tx_srv(vptr, isr_status);
-        rx_done += velocity_rx_srv(vptr, isr_status, budget - rx_done);
-        velocity_tx_srv(vptr, isr_status);
-
-        spin_unlock(&vptr->lock);
+        rx_done = velocity_rx_srv(vptr, budget / 2);
+        velocity_tx_srv(vptr);
+        rx_done += velocity_rx_srv(vptr, budget - rx_done);
+        velocity_tx_srv(vptr);
 
         /* If budget not fully consumed, exit the polling mode */
         if (rx_done < budget) {
                 napi_complete(napi);
                 mac_enable_int(vptr->mac_regs);
         }
+        spin_unlock_irqrestore(&vptr->lock, flags);
 
         return rx_done;
 }
@@ -2206,10 +2195,17 @@ static irqreturn_t velocity_intr(int irq, void *dev_instance)
                 return IRQ_NONE;
         }
 
+        /* Ack the interrupt */
+        mac_write_isr(vptr->mac_regs, isr_status);
+
         if (likely(napi_schedule_prep(&vptr->napi))) {
                 mac_disable_int(vptr->mac_regs);
                 __napi_schedule(&vptr->napi);
         }
+
+        if (isr_status & (~(ISR_PRXI | ISR_PPRXI | ISR_PTXI | ISR_PPTXI)))
+                velocity_error(vptr, isr_status);
+
         spin_unlock(&vptr->lock);
 
         return IRQ_HANDLED;
@@ -3100,7 +3096,7 @@ static int velocity_resume(struct pci_dev *pdev)
         velocity_init_registers(vptr, VELOCITY_INIT_WOL);
         mac_disable_int(vptr->mac_regs);
 
-        velocity_tx_srv(vptr, 0);
+        velocity_tx_srv(vptr);
 
         for (i = 0; i < vptr->tx.numq; i++) {
                 if (vptr->tx.used[i])
@@ -3344,6 +3340,7 @@ static int velocity_set_coalesce(struct net_device *dev,
 {
         struct velocity_info *vptr = netdev_priv(dev);
         int max_us = 0x3f * 64;
+        unsigned long flags;
 
         /* 6 bits of  */
         if (ecmd->tx_coalesce_usecs > max_us)
@@ -3365,6 +3362,7 @@ static int velocity_set_coalesce(struct net_device *dev,
                         ecmd->tx_coalesce_usecs);
 
         /* Setup the interrupt suppression and queue timers */
+        spin_lock_irqsave(&vptr->lock, flags);
         mac_disable_int(vptr->mac_regs);
         setup_adaptive_interrupts(vptr);
         setup_queue_timers(vptr);
@@ -3372,6 +3370,7 @@ static int velocity_set_coalesce(struct net_device *dev,
         mac_write_int_mask(vptr->int_mask, vptr->mac_regs);
         mac_clear_isr(vptr->mac_regs);
         mac_enable_int(vptr->mac_regs);
+        spin_unlock_irqrestore(&vptr->lock, flags);
 
         return 0;
 }
diff --git a/drivers/net/wireless/ath/ath9k/xmit.c b/drivers/net/wireless/ath/ath9k/xmit.c
index fa12b9060b0b..29bf33692f71 100644
--- a/drivers/net/wireless/ath/ath9k/xmit.c
+++ b/drivers/net/wireless/ath/ath9k/xmit.c
@@ -1615,7 +1615,7 @@ static int ath_tx_setup_buffer(struct ieee80211_hw *hw, struct ath_buf *bf,
                 bf->bf_frmlen -= padsize;
         }
 
-        if (conf_is_ht(&hw->conf) && !is_pae(skb))
+        if (conf_is_ht(&hw->conf))
                 bf->bf_state.bf_type |= BUF_HT;
 
         bf->bf_flags = setup_tx_flags(sc, skb, txctl->txq);
@@ -1701,7 +1701,7 @@ static void ath_tx_start_dma(struct ath_softc *sc, struct ath_buf *bf,
                         goto tx_done;
                 }
 
-                if (tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
+                if ((tx_info->flags & IEEE80211_TX_CTL_AMPDU) && !is_pae(skb)) {
                         /*
                          * Try aggregation if it's a unicast data frame
                          * and the destination is HT capable.
diff --git a/drivers/net/wireless/b43/b43.h b/drivers/net/wireless/b43/b43.h
index fe3bf9491997..c484cc253892 100644
--- a/drivers/net/wireless/b43/b43.h
+++ b/drivers/net/wireless/b43/b43.h
@@ -115,6 +115,7 @@
 #define B43_MMIO_TSF_2                  0x636   /* core rev < 3 only */
 #define B43_MMIO_TSF_3                  0x638   /* core rev < 3 only */
 #define B43_MMIO_RNG                    0x65A
+#define B43_MMIO_IFSSLOT                0x684   /* Interframe slot time */
 #define B43_MMIO_IFSCTL                 0x688 /* Interframe space control */
 #define  B43_MMIO_IFSCTL_USE_EDCF       0x0004
 #define B43_MMIO_POWERUP_DELAY          0x6A8
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 4c41cfe44f26..490fb45d1d05 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -628,10 +628,17 @@ static void b43_upload_card_macaddress(struct b43_wldev *dev)
 static void b43_set_slot_time(struct b43_wldev *dev, u16 slot_time)
 {
         /* slot_time is in usec. */
-        if (dev->phy.type != B43_PHYTYPE_G)
+        /* This test used to exit for all but a G PHY. */
+        if (b43_current_band(dev->wl) == IEEE80211_BAND_5GHZ)
                 return;
-        b43_write16(dev, 0x684, 510 + slot_time);
-        b43_shm_write16(dev, B43_SHM_SHARED, 0x0010, slot_time);
+        b43_write16(dev, B43_MMIO_IFSSLOT, 510 + slot_time);
+        /* Shared memory location 0x0010 is the slot time and should be
+         * set to slot_time; however, this register is initially 0 and changing
+         * the value adversely affects the transmit rate for BCM4311
+         * devices. Until this behavior is unterstood, delete this step
+         *
+         * b43_shm_write16(dev, B43_SHM_SHARED, 0x0010, slot_time);
+         */
 }
 
 static void b43_short_slot_timing_enable(struct b43_wldev *dev)
diff --git a/drivers/net/wireless/iwlwifi/iwl-4965.c b/drivers/net/wireless/iwlwifi/iwl-4965.c
index 9b4b8b5c7574..31462813bac0 100644
--- a/drivers/net/wireless/iwlwifi/iwl-4965.c
+++ b/drivers/net/wireless/iwlwifi/iwl-4965.c
@@ -2008,7 +2008,7 @@ static void iwl4965_rx_reply_tx(struct iwl_priv *priv,
                         IWL_DEBUG_TX_REPLY(priv, "Retry scheduler reclaim scd_ssn "
                                            "%d index %d\n", scd_ssn , index);
                         freed = iwl_tx_queue_reclaim(priv, txq_id, index);
-                        priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
+                        iwl_free_tfds_in_queue(priv, sta_id, tid, freed);
 
                         if (priv->mac80211_registered &&
                             (iwl_queue_space(&txq->q) > txq->q.low_mark) &&
diff --git a/drivers/net/wireless/iwlwifi/iwl-5000.c b/drivers/net/wireless/iwlwifi/iwl-5000.c
index de45f308b744..cffaae772d51 100644
--- a/drivers/net/wireless/iwlwifi/iwl-5000.c
+++ b/drivers/net/wireless/iwlwifi/iwl-5000.c
@@ -1125,7 +1125,7 @@ static void iwl5000_rx_reply_tx(struct iwl_priv *priv,
                                         scd_ssn , index, txq_id, txq->swq_id);
 
                         freed = iwl_tx_queue_reclaim(priv, txq_id, index);
-                        priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
+                        iwl_free_tfds_in_queue(priv, sta_id, tid, freed);
 
                         if (priv->mac80211_registered &&
                             (iwl_queue_space(&txq->q) > txq->q.low_mark) &&
@@ -1153,16 +1153,14 @@ static void iwl5000_rx_reply_tx(struct iwl_priv *priv,
                                    tx_resp->failure_frame);
 
                 freed = iwl_tx_queue_reclaim(priv, txq_id, index);
-                if (ieee80211_is_data_qos(tx_resp->frame_ctrl))
-                        priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
+                iwl_free_tfds_in_queue(priv, sta_id, tid, freed);
 
                 if (priv->mac80211_registered &&
                     (iwl_queue_space(&txq->q) > txq->q.low_mark))
                         iwl_wake_queue(priv, txq_id);
         }
 
-        if (ieee80211_is_data_qos(tx_resp->frame_ctrl))
-                iwl_txq_check_empty(priv, sta_id, tid, txq_id);
+        iwl_txq_check_empty(priv, sta_id, tid, txq_id);
 
         if (iwl_check_bits(status, TX_ABORT_REQUIRED_MSK))
                 IWL_ERR(priv, "TODO:  Implement Tx ABORT REQUIRED!!!\n");
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.c b/drivers/net/wireless/iwlwifi/iwl-core.c
index 5461f105bd2d..f36f804804fc 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.c
+++ b/drivers/net/wireless/iwlwifi/iwl-core.c
@@ -2745,6 +2745,7 @@ int iwl_mac_config(struct ieee80211_hw *hw, u32 changed)
                         priv->staging_rxon.flags = 0;
 
                 iwl_set_rxon_channel(priv, conf->channel);
+                iwl_set_rxon_ht(priv, ht_conf);
 
                 iwl_set_flags_for_band(priv, conf->channel->band);
                 spin_unlock_irqrestore(&priv->lock, flags);
diff --git a/drivers/net/wireless/iwlwifi/iwl-core.h b/drivers/net/wireless/iwlwifi/iwl-core.h
index 27ca859e7453..b69e972671b2 100644
--- a/drivers/net/wireless/iwlwifi/iwl-core.h
+++ b/drivers/net/wireless/iwlwifi/iwl-core.h
@@ -446,6 +446,8 @@ void iwl_hw_txq_ctx_free(struct iwl_priv *priv);
 int iwl_hw_tx_queue_init(struct iwl_priv *priv,
                          struct iwl_tx_queue *txq);
 int iwl_txq_update_write_ptr(struct iwl_priv *priv, struct iwl_tx_queue *txq);
+void iwl_free_tfds_in_queue(struct iwl_priv *priv,
+                            int sta_id, int tid, int freed);
 int iwl_tx_queue_init(struct iwl_priv *priv, struct iwl_tx_queue *txq,
                       int slots_num, u32 txq_id);
 void iwl_tx_queue_free(struct iwl_priv *priv, int txq_id);
diff --git a/drivers/net/wireless/iwlwifi/iwl-rx.c b/drivers/net/wireless/iwlwifi/iwl-rx.c
index 6f36b6e79f5e..2dbce85404aa 100644
--- a/drivers/net/wireless/iwlwifi/iwl-rx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-rx.c
@@ -928,7 +928,10 @@ static void iwl_pass_packet_to_mac80211(struct iwl_priv *priv,
         if (ieee80211_is_mgmt(fc) ||
             ieee80211_has_protected(fc) ||
             ieee80211_has_morefrags(fc) ||
-            le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG)
+            le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_FRAG ||
+            (ieee80211_is_data_qos(fc) &&
+             *ieee80211_get_qos_ctl(hdr) &
+             IEEE80211_QOS_CONTROL_A_MSDU_PRESENT))
                 ret = skb_linearize(skb);
         else
                 ret = __pskb_pull_tail(skb, min_t(u16, IWL_LINK_HDR_MAX, len)) ?
diff --git a/drivers/net/wireless/iwlwifi/iwl-tx.c b/drivers/net/wireless/iwlwifi/iwl-tx.c
index 87ce2bd292c7..8f4071562857 100644
--- a/drivers/net/wireless/iwlwifi/iwl-tx.c
+++ b/drivers/net/wireless/iwlwifi/iwl-tx.c
@@ -120,6 +120,20 @@ int iwl_txq_update_write_ptr(struct iwl_priv *priv, struct iwl_tx_queue *txq)
 EXPORT_SYMBOL(iwl_txq_update_write_ptr);
 
 
+void iwl_free_tfds_in_queue(struct iwl_priv *priv,
+                            int sta_id, int tid, int freed)
+{
+        if (priv->stations[sta_id].tid[tid].tfds_in_queue >= freed)
+                priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
+        else {
+                IWL_ERR(priv, "free more than tfds_in_queue (%u:%d)\n",
+                        priv->stations[sta_id].tid[tid].tfds_in_queue,
+                        freed);
+                priv->stations[sta_id].tid[tid].tfds_in_queue = 0;
+        }
+}
+EXPORT_SYMBOL(iwl_free_tfds_in_queue);
+
 /**
  * iwl_tx_queue_free - Deallocate DMA queue.
  * @txq: Transmit queue to deallocate.
@@ -1131,6 +1145,7 @@ int iwl_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index)
         struct iwl_queue *q = &txq->q;
         struct iwl_tx_info *tx_info;
         int nfreed = 0;
+        struct ieee80211_hdr *hdr;
 
         if ((index >= q->n_bd) || (iwl_queue_used(q, index) == 0)) {
                 IWL_ERR(priv, "Read index for DMA queue txq id (%d), index %d, "
@@ -1145,13 +1160,16 @@ int iwl_tx_queue_reclaim(struct iwl_priv *priv, int txq_id, int index)
 
                 tx_info = &txq->txb[txq->q.read_ptr];
                 iwl_tx_status(priv, tx_info->skb[0]);
+
+                hdr = (struct ieee80211_hdr *)tx_info->skb[0]->data;
+                if (hdr && ieee80211_is_data_qos(hdr->frame_control))
+                        nfreed++;
                 tx_info->skb[0] = NULL;
 
                 if (priv->cfg->ops->lib->txq_inval_byte_cnt_tbl)
                         priv->cfg->ops->lib->txq_inval_byte_cnt_tbl(priv, txq);
 
                 priv->cfg->ops->lib->txq_free_tfd(priv, txq);
-                nfreed++;
         }
         return nfreed;
 }
@@ -1559,7 +1577,7 @@ void iwl_rx_reply_compressed_ba(struct iwl_priv *priv,
         if (txq->q.read_ptr != (ba_resp_scd_ssn & 0xff)) {
                 /* calculate mac80211 ampdu sw queue to wake */
                 int freed = iwl_tx_queue_reclaim(priv, scd_flow, index);
-                priv->stations[sta_id].tid[tid].tfds_in_queue -= freed;
+                iwl_free_tfds_in_queue(priv, sta_id, tid, freed);
 
                 if ((iwl_queue_space(&txq->q) > txq->q.low_mark) &&
                     priv->mac80211_registered &&
diff --git a/drivers/net/wireless/iwmc3200wifi/rx.c b/drivers/net/wireless/iwmc3200wifi/rx.c
index 6d6ed7485175..f727b4a83196 100644
--- a/drivers/net/wireless/iwmc3200wifi/rx.c
+++ b/drivers/net/wireless/iwmc3200wifi/rx.c
@@ -794,7 +794,7 @@ static int iwm_mlme_update_bss_table(struct iwm_priv *iwm, u8 *buf,
         }
 
         bss->bss = kzalloc(bss_len, GFP_KERNEL);
-        if (!bss) {
+        if (!bss->bss) {
                 kfree(bss);
                 IWM_ERR(iwm, "Couldn't allocate bss\n");
                 return -ENOMEM;
diff --git a/drivers/net/wireless/rtl818x/rtl8187_dev.c b/drivers/net/wireless/rtl818x/rtl8187_dev.c
index bc5726dd5fe4..7ba3052b0708 100644
--- a/drivers/net/wireless/rtl818x/rtl8187_dev.c
+++ b/drivers/net/wireless/rtl818x/rtl8187_dev.c
@@ -65,6 +65,7 @@ static struct usb_device_id rtl8187_table[] __devinitdata = {
         /* Sitecom */
         {USB_DEVICE(0x0df6, 0x000d), .driver_info = DEVICE_RTL8187},
         {USB_DEVICE(0x0df6, 0x0028), .driver_info = DEVICE_RTL8187B},
+        {USB_DEVICE(0x0df6, 0x0029), .driver_info = DEVICE_RTL8187B},
         /* Sphairon Access Systems GmbH */
         {USB_DEVICE(0x114B, 0x0150), .driver_info = DEVICE_RTL8187},
         /* Dick Smith Electronics */
diff --git a/drivers/of/Kconfig b/drivers/of/Kconfig
index d2fa27c5c1b2..7cecc8fea9bd 100644
--- a/drivers/of/Kconfig
+++ b/drivers/of/Kconfig
@@ -1,3 +1,11 @@
+config OF_FLATTREE
+        bool
+        depends on OF
+
+config OF_DYNAMIC
+        def_bool y
+        depends on OF && PPC_OF
+
 config OF_DEVICE
         def_bool y
         depends on OF && (SPARC || PPC_OF || MICROBLAZE)
diff --git a/drivers/of/Makefile b/drivers/of/Makefile
index bdfb5f5d4b06..f232cc98ce00 100644
--- a/drivers/of/Makefile
+++ b/drivers/of/Makefile
@@ -1,4 +1,5 @@
 obj-y = base.o
+obj-$(CONFIG_OF_FLATTREE) += fdt.o
 obj-$(CONFIG_OF_DEVICE) += device.o platform.o
 obj-$(CONFIG_OF_GPIO)   += gpio.o
 obj-$(CONFIG_OF_I2C)    += of_i2c.o
diff --git a/drivers/of/base.c b/drivers/of/base.c
index e6627b2320f1..cb96888d1427 100644
--- a/drivers/of/base.c
+++ b/drivers/of/base.c
@@ -20,8 +20,10 @@
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/spinlock.h>
+#include <linux/proc_fs.h>
 
 struct device_node *allnodes;
+struct device_node *of_chosen;
 
 /* use when traversing tree through the allnext, child, sibling,
  * or parent members of struct device_node.
@@ -37,7 +39,7 @@ int of_n_addr_cells(struct device_node *np)
                         np = np->parent;
                 ip = of_get_property(np, "#address-cells", NULL);
                 if (ip)
-                        return *ip;
+                        return be32_to_cpup(ip);
         } while (np->parent);
         /* No #address-cells property for the root node */
         return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
@@ -53,13 +55,88 @@ int of_n_size_cells(struct device_node *np)
                         np = np->parent;
                 ip = of_get_property(np, "#size-cells", NULL);
                 if (ip)
-                        return *ip;
+                        return be32_to_cpup(ip);
         } while (np->parent);
         /* No #size-cells property for the root node */
         return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
 }
 EXPORT_SYMBOL(of_n_size_cells);
 
+#if !defined(CONFIG_SPARC)   /* SPARC doesn't do ref counting (yet) */
+/**
+ *      of_node_get - Increment refcount of a node
+ *      @node:  Node to inc refcount, NULL is supported to
+ *              simplify writing of callers
+ *
+ *      Returns node.
+ */
+struct device_node *of_node_get(struct device_node *node)
+{
+        if (node)
+                kref_get(&node->kref);
+        return node;
+}
+EXPORT_SYMBOL(of_node_get);
+
+static inline struct device_node *kref_to_device_node(struct kref *kref)
+{
+        return container_of(kref, struct device_node, kref);
+}
+
+/**
+ *      of_node_release - release a dynamically allocated node
+ *      @kref:  kref element of the node to be released
+ *
+ *      In of_node_put() this function is passed to kref_put()
+ *      as the destructor.
+ */
+static void of_node_release(struct kref *kref)
+{
+        struct device_node *node = kref_to_device_node(kref);
+        struct property *prop = node->properties;
+
+        /* We should never be releasing nodes that haven't been detached. */
+        if (!of_node_check_flag(node, OF_DETACHED)) {
+                pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name);
+                dump_stack();
+                kref_init(&node->kref);
+                return;
+        }
+
+        if (!of_node_check_flag(node, OF_DYNAMIC))
+                return;
+
+        while (prop) {
+                struct property *next = prop->next;
+                kfree(prop->name);
+                kfree(prop->value);
+                kfree(prop);
+                prop = next;
+
+                if (!prop) {
+                        prop = node->deadprops;
+                        node->deadprops = NULL;
+                }
+        }
+        kfree(node->full_name);
+        kfree(node->data);
+        kfree(node);
+}
+
+/**
+ *      of_node_put - Decrement refcount of a node
+ *      @node:  Node to dec refcount, NULL is supported to
+ *              simplify writing of callers
+ *
+ */
+void of_node_put(struct device_node *node)
+{
+        if (node)
+                kref_put(&node->kref, of_node_release);
+}
+EXPORT_SYMBOL(of_node_put);
+#endif /* !CONFIG_SPARC */
+
 struct property *of_find_property(const struct device_node *np,
                                   const char *name,
                                   int *lenp)
@@ -144,6 +221,27 @@ int of_device_is_compatible(const struct device_node *device,
 EXPORT_SYMBOL(of_device_is_compatible);
 
 /**
+ * of_machine_is_compatible - Test root of device tree for a given compatible value
+ * @compat: compatible string to look for in root node's compatible property.
+ *
+ * Returns true if the root node has the given value in its
+ * compatible property.
+ */
+int of_machine_is_compatible(const char *compat)
+{
+        struct device_node *root;
+        int rc = 0;
+
+        root = of_find_node_by_path("/");
+        if (root) {
+                rc = of_device_is_compatible(root, compat);
+                of_node_put(root);
+        }
+        return rc;
+}
+EXPORT_SYMBOL(of_machine_is_compatible);
+
+/**
  *  of_device_is_available - check if a device is available for use
  *
  *  @device: Node to check for availability
@@ -519,6 +617,27 @@ int of_modalias_node(struct device_node *node, char *modalias, int len)
 EXPORT_SYMBOL_GPL(of_modalias_node);
 
 /**
+ * of_find_node_by_phandle - Find a node given a phandle
+ * @handle:     phandle of the node to find
+ *
+ * Returns a node pointer with refcount incremented, use
+ * of_node_put() on it when done.
+ */
+struct device_node *of_find_node_by_phandle(phandle handle)
+{
+        struct device_node *np;
+
+        read_lock(&devtree_lock);
+        for (np = allnodes; np; np = np->allnext)
+                if (np->phandle == handle)
+                        break;
+        of_node_get(np);
+        read_unlock(&devtree_lock);
+        return np;
+}
+EXPORT_SYMBOL(of_find_node_by_phandle);
+
+/**
  * of_parse_phandle - Resolve a phandle property to a device_node pointer
  * @np: Pointer to device node holding phandle property
  * @phandle_name: Name of property holding a phandle value
@@ -578,8 +697,8 @@ int of_parse_phandles_with_args(struct device_node *np, const char *list_name,
                                 const void **out_args)
 {
         int ret = -EINVAL;
-        const u32 *list;
-        const u32 *list_end;
+        const __be32 *list;
+        const __be32 *list_end;
         int size;
         int cur_index = 0;
         struct device_node *node = NULL;
@@ -593,7 +712,7 @@ int of_parse_phandles_with_args(struct device_node *np, const char *list_name,
         list_end = list + size / sizeof(*list);
 
         while (list < list_end) {
-                const u32 *cells;
+                const __be32 *cells;
                 const phandle *phandle;
 
                 phandle = list++;
@@ -617,7 +736,7 @@ int of_parse_phandles_with_args(struct device_node *np, const char *list_name,
                         goto err1;
                 }
 
-                list += *cells;
+                list += be32_to_cpup(cells);
                 if (list > list_end) {
                         pr_debug("%s: insufficient arguments length\n",
                                  np->full_name);
@@ -658,3 +777,190 @@ err0:
         return ret;
 }
 EXPORT_SYMBOL(of_parse_phandles_with_args);
+
+/**
+ * prom_add_property - Add a property to a node
+ */
+int prom_add_property(struct device_node *np, struct property *prop)
+{
+        struct property **next;
+        unsigned long flags;
+
+        prop->next = NULL;
+        write_lock_irqsave(&devtree_lock, flags);
+        next = &np->properties;
+        while (*next) {
+                if (strcmp(prop->name, (*next)->name) == 0) {
+                        /* duplicate ! don't insert it */
+                        write_unlock_irqrestore(&devtree_lock, flags);
+                        return -1;
+                }
+                next = &(*next)->next;
+        }
+        *next = prop;
+        write_unlock_irqrestore(&devtree_lock, flags);
+
+#ifdef CONFIG_PROC_DEVICETREE
+        /* try to add to proc as well if it was initialized */
+        if (np->pde)
+                proc_device_tree_add_prop(np->pde, prop);
+#endif /* CONFIG_PROC_DEVICETREE */
+
+        return 0;
+}
+
+/**
+ * prom_remove_property - Remove a property from a node.
+ *
+ * Note that we don't actually remove it, since we have given out
+ * who-knows-how-many pointers to the data using get-property.
+ * Instead we just move the property to the "dead properties"
+ * list, so it won't be found any more.
+ */
+int prom_remove_property(struct device_node *np, struct property *prop)
+{
+        struct property **next;
+        unsigned long flags;
+        int found = 0;
+
+        write_lock_irqsave(&devtree_lock, flags);
+        next = &np->properties;
+        while (*next) {
+                if (*next == prop) {
+                        /* found the node */
+                        *next = prop->next;
+                        prop->next = np->deadprops;
+                        np->deadprops = prop;
+                        found = 1;
+                        break;
+                }
+                next = &(*next)->next;
+        }
+        write_unlock_irqrestore(&devtree_lock, flags);
+
+        if (!found)
+                return -ENODEV;
+
+#ifdef CONFIG_PROC_DEVICETREE
+        /* try to remove the proc node as well */
+        if (np->pde)
+                proc_device_tree_remove_prop(np->pde, prop);
+#endif /* CONFIG_PROC_DEVICETREE */
+
+        return 0;
+}
+
+/*
+ * prom_update_property - Update a property in a node.
+ *
+ * Note that we don't actually remove it, since we have given out
+ * who-knows-how-many pointers to the data using get-property.
+ * Instead we just move the property to the "dead properties" list,
+ * and add the new property to the property list
+ */
+int prom_update_property(struct device_node *np,
+                         struct property *newprop,
+                         struct property *oldprop)
+{
+        struct property **next;
+        unsigned long flags;
+        int found = 0;
+
+        write_lock_irqsave(&devtree_lock, flags);
+        next = &np->properties;
+        while (*next) {
+                if (*next == oldprop) {
+                        /* found the node */
+                        newprop->next = oldprop->next;
+                        *next = newprop;
+                        oldprop->next = np->deadprops;
+                        np->deadprops = oldprop;
+                        found = 1;
+                        break;
+                }
+                next = &(*next)->next;
+        }
+        write_unlock_irqrestore(&devtree_lock, flags);
+
+        if (!found)
+                return -ENODEV;
+
+#ifdef CONFIG_PROC_DEVICETREE
+        /* try to add to proc as well if it was initialized */
+        if (np->pde)
+                proc_device_tree_update_prop(np->pde, newprop, oldprop);
+#endif /* CONFIG_PROC_DEVICETREE */
+
+        return 0;
+}
+
+#if defined(CONFIG_OF_DYNAMIC)
+/*
+ * Support for dynamic device trees.
+ *
+ * On some platforms, the device tree can be manipulated at runtime.
+ * The routines in this section support adding, removing and changing
+ * device tree nodes.
+ */
+
+/**
+ * of_attach_node - Plug a device node into the tree and global list.
+ */
+void of_attach_node(struct device_node *np)
+{
+        unsigned long flags;
+
+        write_lock_irqsave(&devtree_lock, flags);
+        np->sibling = np->parent->child;
+        np->allnext = allnodes;
+        np->parent->child = np;
+        allnodes = np;
+        write_unlock_irqrestore(&devtree_lock, flags);
+}
+
+/**
+ * of_detach_node - "Unplug" a node from the device tree.
+ *
+ * The caller must hold a reference to the node.  The memory associated with
+ * the node is not freed until its refcount goes to zero.
+ */
+void of_detach_node(struct device_node *np)
+{
+        struct device_node *parent;
+        unsigned long flags;
+
+        write_lock_irqsave(&devtree_lock, flags);
+
+        parent = np->parent;
+        if (!parent)
+                goto out_unlock;
+
+        if (allnodes == np)
+                allnodes = np->allnext;
+        else {
+                struct device_node *prev;
+                for (prev = allnodes;
+                     prev->allnext != np;
+                     prev = prev->allnext)
+                        ;
+                prev->allnext = np->allnext;
+        }
+
+        if (parent->child == np)
+                parent->child = np->sibling;
+        else {
+                struct device_node *prevsib;
+                for (prevsib = np->parent->child;
+                     prevsib->sibling != np;
+                     prevsib = prevsib->sibling)
+                        ;
+                prevsib->sibling = np->sibling;
+        }
+
+        of_node_set_flag(np, OF_DETACHED);
+
+out_unlock:
+        write_unlock_irqrestore(&devtree_lock, flags);
+}
+#endif /* defined(CONFIG_OF_DYNAMIC) */
+
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
new file mode 100644
index 000000000000..406757a9d7ea
--- /dev/null
+++ b/drivers/of/fdt.c
@@ -0,0 +1,590 @@
+/*
+ * Functions for working with the Flattened Device Tree data format
+ *
+ * Copyright 2009 Benjamin Herrenschmidt, IBM Corp
+ * benh@kernel.crashing.org
+ *
+ * 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/initrd.h>
+#include <linux/of.h>
+#include <linux/of_fdt.h>
+#include <linux/string.h>
+#include <linux/errno.h>
+
+#ifdef CONFIG_PPC
+#include <asm/machdep.h>
+#endif /* CONFIG_PPC */
+
+#include <asm/page.h>
+
+int __initdata dt_root_addr_cells;
+int __initdata dt_root_size_cells;
+
+struct boot_param_header *initial_boot_params;
+
+char *find_flat_dt_string(u32 offset)
+{
+        return ((char *)initial_boot_params) +
+                be32_to_cpu(initial_boot_params->off_dt_strings) + offset;
+}
+
+/**
+ * of_scan_flat_dt - scan flattened tree blob and call callback on each.
+ * @it: callback function
+ * @data: context data pointer
+ *
+ * This function is used to scan the flattened device-tree, it is
+ * used to extract the memory information at boot before we can
+ * unflatten the tree
+ */
+int __init of_scan_flat_dt(int (*it)(unsigned long node,
+                                     const char *uname, int depth,
+                                     void *data),
+                           void *data)
+{
+        unsigned long p = ((unsigned long)initial_boot_params) +
+                be32_to_cpu(initial_boot_params->off_dt_struct);
+        int rc = 0;
+        int depth = -1;
+
+        do {
+                u32 tag = be32_to_cpup((__be32 *)p);
+                char *pathp;
+
+                p += 4;
+                if (tag == OF_DT_END_NODE) {
+                        depth--;
+                        continue;
+                }
+                if (tag == OF_DT_NOP)
+                        continue;
+                if (tag == OF_DT_END)
+                        break;
+                if (tag == OF_DT_PROP) {
+                        u32 sz = be32_to_cpup((__be32 *)p);
+                        p += 8;
+                        if (be32_to_cpu(initial_boot_params->version) < 0x10)
+                                p = _ALIGN(p, sz >= 8 ? 8 : 4);
+                        p += sz;
+                        p = _ALIGN(p, 4);
+                        continue;
+                }
+                if (tag != OF_DT_BEGIN_NODE) {
+                        pr_err("Invalid tag %x in flat device tree!\n", tag);
+                        return -EINVAL;
+                }
+                depth++;
+                pathp = (char *)p;
+                p = _ALIGN(p + strlen(pathp) + 1, 4);
+                if ((*pathp) == '/') {
+                        char *lp, *np;
+                        for (lp = NULL, np = pathp; *np; np++)
+                                if ((*np) == '/')
+                                        lp = np+1;
+                        if (lp != NULL)
+                                pathp = lp;
+                }
+                rc = it(p, pathp, depth, data);
+                if (rc != 0)
+                        break;
+        } while (1);
+
+        return rc;
+}
+
+/**
+ * of_get_flat_dt_root - find the root node in the flat blob
+ */
+unsigned long __init of_get_flat_dt_root(void)
+{
+        unsigned long p = ((unsigned long)initial_boot_params) +
+                be32_to_cpu(initial_boot_params->off_dt_struct);
+
+        while (be32_to_cpup((__be32 *)p) == OF_DT_NOP)
+                p += 4;
+        BUG_ON(be32_to_cpup((__be32 *)p) != OF_DT_BEGIN_NODE);
+        p += 4;
+        return _ALIGN(p + strlen((char *)p) + 1, 4);
+}
+
+/**
+ * of_get_flat_dt_prop - Given a node in the flat blob, return the property ptr
+ *
+ * This function can be used within scan_flattened_dt callback to get
+ * access to properties
+ */
+void *__init of_get_flat_dt_prop(unsigned long node, const char *name,
+                                 unsigned long *size)
+{
+        unsigned long p = node;
+
+        do {
+                u32 tag = be32_to_cpup((__be32 *)p);
+                u32 sz, noff;
+                const char *nstr;
+
+                p += 4;
+                if (tag == OF_DT_NOP)
+                        continue;
+                if (tag != OF_DT_PROP)
+                        return NULL;
+
+                sz = be32_to_cpup((__be32 *)p);
+                noff = be32_to_cpup((__be32 *)(p + 4));
+                p += 8;
+                if (be32_to_cpu(initial_boot_params->version) < 0x10)
+                        p = _ALIGN(p, sz >= 8 ? 8 : 4);
+
+                nstr = find_flat_dt_string(noff);
+                if (nstr == NULL) {
+                        pr_warning("Can't find property index name !\n");
+                        return NULL;
+                }
+                if (strcmp(name, nstr) == 0) {
+                        if (size)
+                                *size = sz;
+                        return (void *)p;
+                }
+                p += sz;
+                p = _ALIGN(p, 4);
+        } while (1);
+}
+
+/**
+ * of_flat_dt_is_compatible - Return true if given node has compat in compatible list
+ * @node: node to test
+ * @compat: compatible string to compare with compatible list.
+ */
+int __init of_flat_dt_is_compatible(unsigned long node, const char *compat)
+{
+        const char *cp;
+        unsigned long cplen, l;
+
+        cp = of_get_flat_dt_prop(node, "compatible", &cplen);
+        if (cp == NULL)
+                return 0;
+        while (cplen > 0) {
+                if (strncasecmp(cp, compat, strlen(compat)) == 0)
+                        return 1;
+                l = strlen(cp) + 1;
+                cp += l;
+                cplen -= l;
+        }
+
+        return 0;
+}
+
+static void *__init unflatten_dt_alloc(unsigned long *mem, unsigned long size,
+                                       unsigned long align)
+{
+        void *res;
+
+        *mem = _ALIGN(*mem, align);
+        res = (void *)*mem;
+        *mem += size;
+
+        return res;
+}
+
+/**
+ * unflatten_dt_node - Alloc and populate a device_node from the flat tree
+ * @p: pointer to node in flat tree
+ * @dad: Parent struct device_node
+ * @allnextpp: pointer to ->allnext from last allocated device_node
+ * @fpsize: Size of the node path up at the current depth.
+ */
+unsigned long __init unflatten_dt_node(unsigned long mem,
+                                        unsigned long *p,
+                                        struct device_node *dad,
+                                        struct device_node ***allnextpp,
+                                        unsigned long fpsize)
+{
+        struct device_node *np;
+        struct property *pp, **prev_pp = NULL;
+        char *pathp;
+        u32 tag;
+        unsigned int l, allocl;
+        int has_name = 0;
+        int new_format = 0;
+
+        tag = be32_to_cpup((__be32 *)(*p));
+        if (tag != OF_DT_BEGIN_NODE) {
+                pr_err("Weird tag at start of node: %x\n", tag);
+                return mem;
+        }
+        *p += 4;
+        pathp = (char *)*p;
+        l = allocl = strlen(pathp) + 1;
+        *p = _ALIGN(*p + l, 4);
+
+        /* version 0x10 has a more compact unit name here instead of the full
+         * path. we accumulate the full path size using "fpsize", we'll rebuild
+         * it later. We detect this because the first character of the name is
+         * not '/'.
+         */
+        if ((*pathp) != '/') {
+                new_format = 1;
+                if (fpsize == 0) {
+                        /* root node: special case. fpsize accounts for path
+                         * plus terminating zero. root node only has '/', so
+                         * fpsize should be 2, but we want to avoid the first
+                         * level nodes to have two '/' so we use fpsize 1 here
+                         */
+                        fpsize = 1;
+                        allocl = 2;
+                } else {
+                        /* account for '/' and path size minus terminal 0
+                         * already in 'l'
+                         */
+                        fpsize += l;
+                        allocl = fpsize;
+                }
+        }
+
+        np = unflatten_dt_alloc(&mem, sizeof(struct device_node) + allocl,
+                                __alignof__(struct device_node));
+        if (allnextpp) {
+                memset(np, 0, sizeof(*np));
+                np->full_name = ((char *)np) + sizeof(struct device_node);
+                if (new_format) {
+                        char *fn = np->full_name;
+                        /* rebuild full path for new format */
+                        if (dad && dad->parent) {
+                                strcpy(fn, dad->full_name);
+#ifdef DEBUG
+                                if ((strlen(fn) + l + 1) != allocl) {
+                                        pr_debug("%s: p: %d, l: %d, a: %d\n",
+                                                pathp, (int)strlen(fn),
+                                                l, allocl);
+                                }
+#endif
+                                fn += strlen(fn);
+                        }
+                        *(fn++) = '/';
+                        memcpy(fn, pathp, l);
+                } else
+                        memcpy(np->full_name, pathp, l);
+                prev_pp = &np->properties;
+                **allnextpp = np;
+                *allnextpp = &np->allnext;
+                if (dad != NULL) {
+                        np->parent = dad;
+                        /* we temporarily use the next field as `last_child'*/
+                        if (dad->next == NULL)
+                                dad->child = np;
+                        else
+                                dad->next->sibling = np;
+                        dad->next = np;
+                }
+                kref_init(&np->kref);
+        }
+        while (1) {
+                u32 sz, noff;
+                char *pname;
+
+                tag = be32_to_cpup((__be32 *)(*p));
+                if (tag == OF_DT_NOP) {
+                        *p += 4;
+                        continue;
+                }
+                if (tag != OF_DT_PROP)
+                        break;
+                *p += 4;
+                sz = be32_to_cpup((__be32 *)(*p));
+                noff = be32_to_cpup((__be32 *)((*p) + 4));
+                *p += 8;
+                if (be32_to_cpu(initial_boot_params->version) < 0x10)
+                        *p = _ALIGN(*p, sz >= 8 ? 8 : 4);
+
+                pname = find_flat_dt_string(noff);
+                if (pname == NULL) {
+                        pr_info("Can't find property name in list !\n");
+                        break;
+                }
+                if (strcmp(pname, "name") == 0)
+                        has_name = 1;
+                l = strlen(pname) + 1;
+                pp = unflatten_dt_alloc(&mem, sizeof(struct property),
+                                        __alignof__(struct property));
+                if (allnextpp) {
+                        /* We accept flattened tree phandles either in
+                         * ePAPR-style "phandle" properties, or the
+                         * legacy "linux,phandle" properties.  If both
+                         * appear and have different values, things
+                         * will get weird.  Don't do that. */
+                        if ((strcmp(pname, "phandle") == 0) ||
+                            (strcmp(pname, "linux,phandle") == 0)) {
+                                if (np->phandle == 0)
+                                        np->phandle = *((u32 *)*p);
+                        }
+                        /* And we process the "ibm,phandle" property
+                         * used in pSeries dynamic device tree
+                         * stuff */
+                        if (strcmp(pname, "ibm,phandle") == 0)
+                                np->phandle = *((u32 *)*p);
+                        pp->name = pname;
+                        pp->length = sz;
+                        pp->value = (void *)*p;
+                        *prev_pp = pp;
+                        prev_pp = &pp->next;
+                }
+                *p = _ALIGN((*p) + sz, 4);
+        }
+        /* with version 0x10 we may not have the name property, recreate
+         * it here from the unit name if absent
+         */
+        if (!has_name) {
+                char *p1 = pathp, *ps = pathp, *pa = NULL;
+                int sz;
+
+                while (*p1) {
+                        if ((*p1) == '@')
+                                pa = p1;
+                        if ((*p1) == '/')
+                                ps = p1 + 1;
+                        p1++;
+                }
+                if (pa < ps)
+                        pa = p1;
+                sz = (pa - ps) + 1;
+                pp = unflatten_dt_alloc(&mem, sizeof(struct property) + sz,
+                                        __alignof__(struct property));
+                if (allnextpp) {
+                        pp->name = "name";
+                        pp->length = sz;
+                        pp->value = pp + 1;
+                        *prev_pp = pp;
+                        prev_pp = &pp->next;
+                        memcpy(pp->value, ps, sz - 1);
+                        ((char *)pp->value)[sz - 1] = 0;
+                        pr_debug("fixed up name for %s -> %s\n", pathp,
+                                (char *)pp->value);
+                }
+        }
+        if (allnextpp) {
+                *prev_pp = NULL;
+                np->name = of_get_property(np, "name", NULL);
+                np->type = of_get_property(np, "device_type", NULL);
+
+                if (!np->name)
+                        np->name = "<NULL>";
+                if (!np->type)
+                        np->type = "<NULL>";
+        }
+        while (tag == OF_DT_BEGIN_NODE) {
+                mem = unflatten_dt_node(mem, p, np, allnextpp, fpsize);
+                tag = be32_to_cpup((__be32 *)(*p));
+        }
+        if (tag != OF_DT_END_NODE) {
+                pr_err("Weird tag at end of node: %x\n", tag);
+                return mem;
+        }
+        *p += 4;
+        return mem;
+}
+
+#ifdef CONFIG_BLK_DEV_INITRD
+/**
+ * early_init_dt_check_for_initrd - Decode initrd location from flat tree
+ * @node: reference to node containing initrd location ('chosen')
+ */
+void __init early_init_dt_check_for_initrd(unsigned long node)
+{
+        unsigned long start, end, len;
+        __be32 *prop;
+
+        pr_debug("Looking for initrd properties... ");
+
+        prop = of_get_flat_dt_prop(node, "linux,initrd-start", &len);
+        if (!prop)
+                return;
+        start = of_read_ulong(prop, len/4);
+
+        prop = of_get_flat_dt_prop(node, "linux,initrd-end", &len);
+        if (!prop)
+                return;
+        end = of_read_ulong(prop, len/4);
+
+        early_init_dt_setup_initrd_arch(start, end);
+        pr_debug("initrd_start=0x%lx  initrd_end=0x%lx\n", start, end);
+}
+#else
+inline void early_init_dt_check_for_initrd(unsigned long node)
+{
+}
+#endif /* CONFIG_BLK_DEV_INITRD */
+
+/**
+ * early_init_dt_scan_root - fetch the top level address and size cells
+ */
+int __init early_init_dt_scan_root(unsigned long node, const char *uname,
+                                   int depth, void *data)
+{
+        __be32 *prop;
+
+        if (depth != 0)
+                return 0;
+
+        dt_root_size_cells = OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
+        dt_root_addr_cells = OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
+
+        prop = of_get_flat_dt_prop(node, "#size-cells", NULL);
+        if (prop)
+                dt_root_size_cells = be32_to_cpup(prop);
+        pr_debug("dt_root_size_cells = %x\n", dt_root_size_cells);
+
+        prop = of_get_flat_dt_prop(node, "#address-cells", NULL);
+        if (prop)
+                dt_root_addr_cells = be32_to_cpup(prop);
+        pr_debug("dt_root_addr_cells = %x\n", dt_root_addr_cells);
+
+        /* break now */
+        return 1;
+}
+
+u64 __init dt_mem_next_cell(int s, __be32 **cellp)
+{
+        __be32 *p = *cellp;
+
+        *cellp = p + s;
+        return of_read_number(p, s);
+}
+
+/**
+ * early_init_dt_scan_memory - Look for an parse memory nodes
+ */
+int __init early_init_dt_scan_memory(unsigned long node, const char *uname,
+                                     int depth, void *data)
+{
+        char *type = of_get_flat_dt_prop(node, "device_type", NULL);
+        __be32 *reg, *endp;
+        unsigned long l;
+
+        /* We are scanning "memory" nodes only */
+        if (type == NULL) {
+                /*
+                 * The longtrail doesn't have a device_type on the
+                 * /memory node, so look for the node called /memory@0.
+                 */
+                if (depth != 1 || strcmp(uname, "memory@0") != 0)
+                        return 0;
+        } else if (strcmp(type, "memory") != 0)
+                return 0;
+
+        reg = of_get_flat_dt_prop(node, "linux,usable-memory", &l);
+        if (reg == NULL)
+                reg = of_get_flat_dt_prop(node, "reg", &l);
+        if (reg == NULL)
+                return 0;
+
+        endp = reg + (l / sizeof(__be32));
+
+        pr_debug("memory scan node %s, reg size %ld, data: %x %x %x %x,\n",
+            uname, l, reg[0], reg[1], reg[2], reg[3]);
+
+        while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) {
+                u64 base, size;
+
+                base = dt_mem_next_cell(dt_root_addr_cells, &reg);
+                size = dt_mem_next_cell(dt_root_size_cells, &reg);
+
+                if (size == 0)
+                        continue;
+                pr_debug(" - %llx ,  %llx\n", (unsigned long long)base,
+                    (unsigned long long)size);
+
+                early_init_dt_add_memory_arch(base, size);
+        }
+
+        return 0;
+}
+
+int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
+                                     int depth, void *data)
+{
+        unsigned long l;
+        char *p;
+
+        pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
+
+        if (depth != 1 ||
+            (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
+                return 0;
+
+        early_init_dt_check_for_initrd(node);
+
+        /* Retreive command line */
+        p = of_get_flat_dt_prop(node, "bootargs", &l);
+        if (p != NULL && l > 0)
+                strlcpy(cmd_line, p, min((int)l, COMMAND_LINE_SIZE));
+
+#ifdef CONFIG_CMDLINE
+#ifndef CONFIG_CMDLINE_FORCE
+        if (p == NULL || l == 0 || (l == 1 && (*p) == 0))
+#endif
+                strlcpy(cmd_line, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
+#endif /* CONFIG_CMDLINE */
+
+        early_init_dt_scan_chosen_arch(node);
+
+        pr_debug("Command line is: %s\n", cmd_line);
+
+        /* break now */
+        return 1;
+}
+
+/**
+ * unflatten_device_tree - create tree of device_nodes from flat blob
+ *
+ * unflattens the device-tree passed by the firmware, creating the
+ * tree of struct device_node. It also fills the "name" and "type"
+ * pointers of the nodes so the normal device-tree walking functions
+ * can be used.
+ */
+void __init unflatten_device_tree(void)
+{
+        unsigned long start, mem, size;
+        struct device_node **allnextp = &allnodes;
+
+        pr_debug(" -> unflatten_device_tree()\n");
+
+        /* First pass, scan for size */
+        start = ((unsigned long)initial_boot_params) +
+                be32_to_cpu(initial_boot_params->off_dt_struct);
+        size = unflatten_dt_node(0, &start, NULL, NULL, 0);
+        size = (size | 3) + 1;
+
+        pr_debug("  size is %lx, allocating...\n", size);
+
+        /* Allocate memory for the expanded device tree */
+        mem = early_init_dt_alloc_memory_arch(size + 4,
+                        __alignof__(struct device_node));
+        mem = (unsigned long) __va(mem);
+
+        ((__be32 *)mem)[size / 4] = cpu_to_be32(0xdeadbeef);
+
+        pr_debug("  unflattening %lx...\n", mem);
+
+        /* Second pass, do actual unflattening */
+        start = ((unsigned long)initial_boot_params) +
+                be32_to_cpu(initial_boot_params->off_dt_struct);
+        unflatten_dt_node(mem, &start, NULL, &allnextp, 0);
+        if (be32_to_cpup((__be32 *)start) != OF_DT_END)
+                pr_warning("Weird tag at end of tree: %08x\n", *((u32 *)start));
+        if (be32_to_cpu(((__be32 *)mem)[size / 4]) != 0xdeadbeef)
+                pr_warning("End of tree marker overwritten: %08x\n",
+                           be32_to_cpu(((__be32 *)mem)[size / 4]));
+        *allnextp = NULL;
+
+        /* Get pointer to OF "/chosen" node for use everywhere */
+        of_chosen = of_find_node_by_path("/chosen");
+        if (of_chosen == NULL)
+                of_chosen = of_find_node_by_path("/chosen@0");
+
+        pr_debug(" <- unflatten_device_tree()\n");
+}
diff --git a/drivers/of/gpio.c b/drivers/of/gpio.c
index 6eea601a9204..24c3606217f8 100644
--- a/drivers/of/gpio.c
+++ b/drivers/of/gpio.c
@@ -36,7 +36,7 @@ int of_get_gpio_flags(struct device_node *np, int index,
         struct of_gpio_chip *of_gc = NULL;
         int size;
         const void *gpio_spec;
-        const u32 *gpio_cells;
+        const __be32 *gpio_cells;
 
         ret = of_parse_phandles_with_args(np, "gpios", "#gpio-cells", index,
                                           &gc, &gpio_spec);
@@ -55,7 +55,7 @@ int of_get_gpio_flags(struct device_node *np, int index,
 
         gpio_cells = of_get_property(gc, "#gpio-cells", &size);
         if (!gpio_cells || size != sizeof(*gpio_cells) ||
-                        *gpio_cells != of_gc->gpio_cells) {
+                        be32_to_cpup(gpio_cells) != of_gc->gpio_cells) {
                 pr_debug("%s: wrong #gpio-cells for %s\n",
                          np->full_name, gc->full_name);
                 ret = -EINVAL;
@@ -127,7 +127,8 @@ EXPORT_SYMBOL(of_gpio_count);
 int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
                          const void *gpio_spec, enum of_gpio_flags *flags)
 {
-        const u32 *gpio = gpio_spec;
+        const __be32 *gpio = gpio_spec;
+        const u32 n = be32_to_cpup(gpio);
 
         /*
          * We're discouraging gpio_cells < 2, since that way you'll have to
@@ -140,13 +141,13 @@ int of_gpio_simple_xlate(struct of_gpio_chip *of_gc, struct device_node *np,
                 return -EINVAL;
         }
 
-        if (*gpio > of_gc->gc.ngpio)
+        if (n > of_gc->gc.ngpio)
                 return -EINVAL;
 
         if (flags)
-                *flags = gpio[1];
+                *flags = be32_to_cpu(gpio[1]);
 
-        return *gpio;
+        return n;
 }
 EXPORT_SYMBOL(of_gpio_simple_xlate);
 
diff --git a/drivers/of/of_i2c.c b/drivers/of/of_i2c.c
index fa65a2b2ae2e..a3a708e590d0 100644
--- a/drivers/of/of_i2c.c
+++ b/drivers/of/of_i2c.c
@@ -25,7 +25,7 @@ void of_register_i2c_devices(struct i2c_adapter *adap,
         for_each_child_of_node(adap_node, node) {
                 struct i2c_board_info info = {};
                 struct dev_archdata dev_ad = {};
-                const u32 *addr;
+                const __be32 *addr;
                 int len;
 
                 if (of_modalias_node(node, info.type, sizeof(info.type)) < 0)
@@ -40,7 +40,7 @@ void of_register_i2c_devices(struct i2c_adapter *adap,
 
                 info.irq = irq_of_parse_and_map(node, 0);
 
-                info.addr = *addr;
+                info.addr = be32_to_cpup(addr);
 
                 dev_archdata_set_node(&dev_ad, node);
                 info.archdata = &dev_ad;
diff --git a/drivers/of/of_mdio.c b/drivers/of/of_mdio.c
index 4b22ba568b19..18ecae4a4375 100644
--- a/drivers/of/of_mdio.c
+++ b/drivers/of/of_mdio.c
@@ -51,7 +51,7 @@ int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
 
         /* Loop over the child nodes and register a phy_device for each one */
         for_each_child_of_node(np, child) {
-                const u32 *addr;
+                const __be32 *addr;
                 int len;
 
                 /* A PHY must have a reg property in the range [0-31] */
@@ -68,7 +68,7 @@ int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
                                 mdio->irq[*addr] = PHY_POLL;
                 }
 
-                phy = get_phy_device(mdio, *addr);
+                phy = get_phy_device(mdio, be32_to_cpup(addr));
                 if (!phy) {
                         dev_err(&mdio->dev, "error probing PHY at address %i\n",
                                 *addr);
@@ -160,7 +160,7 @@ struct phy_device *of_phy_connect_fixed_link(struct net_device *dev,
         struct device_node *net_np;
         char bus_id[MII_BUS_ID_SIZE + 3];
         struct phy_device *phy;
-        const u32 *phy_id;
+        const __be32 *phy_id;
         int sz;
 
         if (!dev->dev.parent)
@@ -174,7 +174,7 @@ struct phy_device *of_phy_connect_fixed_link(struct net_device *dev,
         if (!phy_id || sz < sizeof(*phy_id))
                 return NULL;
 
-        sprintf(bus_id, PHY_ID_FMT, "0", phy_id[0]);
+        sprintf(bus_id, PHY_ID_FMT, "0", be32_to_cpu(phy_id[0]));
 
         phy = phy_connect(dev, bus_id, hndlr, 0, iface);
         return IS_ERR(phy) ? NULL : phy;
diff --git a/drivers/of/of_spi.c b/drivers/of/of_spi.c
index bed0ed6dcdc1..f65f48b98448 100644
--- a/drivers/of/of_spi.c
+++ b/drivers/of/of_spi.c
@@ -23,7 +23,7 @@ void of_register_spi_devices(struct spi_master *master, struct device_node *np)
 {
         struct spi_device *spi;
         struct device_node *nc;
-        const u32 *prop;
+        const __be32 *prop;
         int rc;
         int len;
 
@@ -54,7 +54,7 @@ void of_register_spi_devices(struct spi_master *master, struct device_node *np)
                         spi_dev_put(spi);
                         continue;
                 }
-                spi->chip_select = *prop;
+                spi->chip_select = be32_to_cpup(prop);
 
                 /* Mode (clock phase/polarity/etc.) */
                 if (of_find_property(nc, "spi-cpha", NULL))
@@ -72,7 +72,7 @@ void of_register_spi_devices(struct spi_master *master, struct device_node *np)
                         spi_dev_put(spi);
                         continue;
                 }
-                spi->max_speed_hz = *prop;
+                spi->max_speed_hz = be32_to_cpup(prop);
 
                 /* IRQ */
                 spi->irq = irq_of_parse_and_map(nc, 0);
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index b1ecefa2a23d..7858a117e80b 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -21,17 +21,6 @@ config PCI_MSI
 
            If you don't know what to do here, say N.
 
-config PCI_LEGACY
-        bool "Enable deprecated pci_find_* API"
-        depends on PCI
-        default y
-        help
-          Say Y here if you want to include support for the deprecated
-          pci_find_device() API.  Most drivers have been converted over
-          to using the proper hotplug APIs, so this option serves to
-          include/exclude only a few drivers that are still using this
-          API.
-
 config PCI_DEBUG
         bool "PCI Debugging"
         depends on PCI && DEBUG_KERNEL
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index 4df48d58eaa6..8674c1ebe979 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -2,14 +2,13 @@
 # Makefile for the PCI bus specific drivers.
 #
 
-obj-y           += access.o bus.o probe.o remove.o pci.o quirks.o \
+obj-y           += access.o bus.o probe.o remove.o pci.o \
                         pci-driver.o search.o pci-sysfs.o rom.o setup-res.o \
                         irq.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_SYSFS) += slot.o
 
-obj-$(CONFIG_PCI_LEGACY) += legacy.o
-CFLAGS_legacy.o += -Wno-deprecated-declarations
+obj-$(CONFIG_PCI_QUIRKS) += quirks.o
 
 # Build PCI Express stuff if needed
 obj-$(CONFIG_PCIEPORTBUS) += pcie/
diff --git a/drivers/pci/bus.c b/drivers/pci/bus.c
index cef28a79103f..712250f5874a 100644
--- a/drivers/pci/bus.c
+++ b/drivers/pci/bus.c
@@ -17,6 +17,52 @@
 
 #include "pci.h"
 
+void pci_bus_add_resource(struct pci_bus *bus, struct resource *res,
+                          unsigned int flags)
+{
+        struct pci_bus_resource *bus_res;
+
+        bus_res = kzalloc(sizeof(struct pci_bus_resource), GFP_KERNEL);
+        if (!bus_res) {
+                dev_err(&bus->dev, "can't add %pR resource\n", res);
+                return;
+        }
+
+        bus_res->res = res;
+        bus_res->flags = flags;
+        list_add_tail(&bus_res->list, &bus->resources);
+}
+
+struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n)
+{
+        struct pci_bus_resource *bus_res;
+
+        if (n < PCI_BRIDGE_RESOURCE_NUM)
+                return bus->resource[n];
+
+        n -= PCI_BRIDGE_RESOURCE_NUM;
+        list_for_each_entry(bus_res, &bus->resources, list) {
+                if (n-- == 0)
+                        return bus_res->res;
+        }
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(pci_bus_resource_n);
+
+void pci_bus_remove_resources(struct pci_bus *bus)
+{
+        struct pci_bus_resource *bus_res, *tmp;
+        int i;
+
+        for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
+                bus->resource[i] = 0;
+
+        list_for_each_entry_safe(bus_res, tmp, &bus->resources, list) {
+                list_del(&bus_res->list);
+                kfree(bus_res);
+        }
+}
+
 /**
  * pci_bus_alloc_resource - allocate a resource from a parent bus
  * @bus: PCI bus
@@ -36,11 +82,14 @@ int
 pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
                 resource_size_t size, resource_size_t align,
                 resource_size_t min, unsigned int type_mask,
-                void (*alignf)(void *, struct resource *, resource_size_t,
-                                resource_size_t),
+                resource_size_t (*alignf)(void *,
+                                          const struct resource *,
+                                          resource_size_t,
+                                          resource_size_t),
                 void *alignf_data)
 {
         int i, ret = -ENOMEM;
+        struct resource *r;
         resource_size_t max = -1;
 
         type_mask |= IORESOURCE_IO | IORESOURCE_MEM;
@@ -49,8 +98,7 @@ pci_bus_alloc_resource(struct pci_bus *bus, struct resource *res,
         if (!(res->flags & IORESOURCE_MEM_64))
                 max = PCIBIOS_MAX_MEM_32;
 
-        for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
-                struct resource *r = bus->resource[i];
+        pci_bus_for_each_resource(bus, r, i) {
                 if (!r)
                         continue;
 
diff --git a/drivers/pci/hotplug/acpiphp_core.c b/drivers/pci/hotplug/acpiphp_core.c
index 4dd7114964ac..efa9f2de51c1 100644
--- a/drivers/pci/hotplug/acpiphp_core.c
+++ b/drivers/pci/hotplug/acpiphp_core.c
@@ -332,8 +332,6 @@ int acpiphp_register_hotplug_slot(struct acpiphp_slot *acpiphp_slot)
         slot->hotplug_slot->info->attention_status = 0;
         slot->hotplug_slot->info->latch_status = acpiphp_get_latch_status(slot->acpi_slot);
         slot->hotplug_slot->info->adapter_status = acpiphp_get_adapter_status(slot->acpi_slot);
-        slot->hotplug_slot->info->max_bus_speed = PCI_SPEED_UNKNOWN;
-        slot->hotplug_slot->info->cur_bus_speed = PCI_SPEED_UNKNOWN;
 
         acpiphp_slot->slot = slot;
         snprintf(name, SLOT_NAME_SIZE, "%llu", slot->acpi_slot->sun);
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index 8e952fdab764..cb2fd01eddae 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -720,12 +720,6 @@ static int acpiphp_bus_add(struct acpiphp_func *func)
                         -ret_val);
                 goto acpiphp_bus_add_out;
         }
-        /*
-         * try to start anyway.  We could have failed to add
-         * simply because this bus had previously been added
-         * on another add.  Don't bother with the return value
-         * we just keep going.
-         */
         ret_val = acpi_bus_start(device);
 
 acpiphp_bus_add_out:
diff --git a/drivers/pci/hotplug/cpcihp_generic.c b/drivers/pci/hotplug/cpcihp_generic.c
index 148fb463b81c..fb3f84661bdc 100644
--- a/drivers/pci/hotplug/cpcihp_generic.c
+++ b/drivers/pci/hotplug/cpcihp_generic.c
@@ -162,6 +162,7 @@ static int __init cpcihp_generic_init(void)
         dev = pci_get_slot(bus, PCI_DEVFN(bridge_slot, 0));
         if(!dev || dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
                 err("Invalid bridge device %s", bridge);
+                pci_dev_put(dev);
                 return -EINVAL;
         }
         bus = dev->subordinate;
diff --git a/drivers/pci/hotplug/cpqphp.h b/drivers/pci/hotplug/cpqphp.h
index 9c6a9fd26812..d8ffc7366801 100644
--- a/drivers/pci/hotplug/cpqphp.h
+++ b/drivers/pci/hotplug/cpqphp.h
@@ -310,8 +310,6 @@ struct controller {
         u8 first_slot;
         u8 add_support;
         u8 push_flag;
-        enum pci_bus_speed speed;
-        enum pci_bus_speed speed_capability;
         u8 push_button;                 /* 0 = no pushbutton, 1 = pushbutton present */
         u8 slot_switch_type;            /* 0 = no switch, 1 = switch present */
         u8 defeature_PHP;               /* 0 = PHP not supported, 1 = PHP supported */
diff --git a/drivers/pci/hotplug/cpqphp_core.c b/drivers/pci/hotplug/cpqphp_core.c
index 075b4f4b6e0d..f184d1d2ecbe 100644
--- a/drivers/pci/hotplug/cpqphp_core.c
+++ b/drivers/pci/hotplug/cpqphp_core.c
@@ -583,30 +583,6 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
         return 0;
 }
 
-static int get_max_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
-{
-        struct slot *slot = hotplug_slot->private;
-        struct controller *ctrl = slot->ctrl;
-
-        dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
-
-        *value = ctrl->speed_capability;
-
-        return 0;
-}
-
-static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
-{
-        struct slot *slot = hotplug_slot->private;
-        struct controller *ctrl = slot->ctrl;
-
-        dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));
-
-        *value = ctrl->speed;
-
-        return 0;
-}
-
 static struct hotplug_slot_ops cpqphp_hotplug_slot_ops = {
         .set_attention_status = set_attention_status,
         .enable_slot =          process_SI,
@@ -616,8 +592,6 @@ static struct hotplug_slot_ops cpqphp_hotplug_slot_ops = {
         .get_attention_status = get_attention_status,
         .get_latch_status =     get_latch_status,
         .get_adapter_status =   get_adapter_status,
-        .get_max_bus_speed =    get_max_bus_speed,
-        .get_cur_bus_speed =    get_cur_bus_speed,
 };
 
 #define SLOT_NAME_SIZE 10
@@ -629,6 +603,7 @@ static int ctrl_slot_setup(struct controller *ctrl,
         struct slot *slot;
         struct hotplug_slot *hotplug_slot;
         struct hotplug_slot_info *hotplug_slot_info;
+        struct pci_bus *bus = ctrl->pci_bus;
         u8 number_of_slots;
         u8 slot_device;
         u8 slot_number;
@@ -694,7 +669,7 @@ static int ctrl_slot_setup(struct controller *ctrl,
                         slot->capabilities |= PCISLOT_64_BIT_SUPPORTED;
                 if (is_slot66mhz(slot))
                         slot->capabilities |= PCISLOT_66_MHZ_SUPPORTED;
-                if (ctrl->speed == PCI_SPEED_66MHz)
+                if (bus->cur_bus_speed == PCI_SPEED_66MHz)
                         slot->capabilities |= PCISLOT_66_MHZ_OPERATION;
 
                 ctrl_slot =
@@ -844,6 +819,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         u32 rc;
         struct controller *ctrl;
         struct pci_func *func;
+        struct pci_bus *bus;
         int err;
 
         err = pci_enable_device(pdev);
@@ -852,6 +828,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         pci_name(pdev), err);
                 return err;
         }
+        bus = pdev->subordinate;
 
         /* Need to read VID early b/c it's used to differentiate CPQ and INTC
          * discovery
@@ -929,22 +906,22 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         pci_read_config_byte(pdev, 0x41, &bus_cap);
                         if (bus_cap & 0x80) {
                                 dbg("bus max supports 133MHz PCI-X\n");
-                                ctrl->speed_capability = PCI_SPEED_133MHz_PCIX;
+                                bus->max_bus_speed = PCI_SPEED_133MHz_PCIX;
                                 break;
                         }
                         if (bus_cap & 0x40) {
                                 dbg("bus max supports 100MHz PCI-X\n");
-                                ctrl->speed_capability = PCI_SPEED_100MHz_PCIX;
+                                bus->max_bus_speed = PCI_SPEED_100MHz_PCIX;
                                 break;
                         }
                         if (bus_cap & 20) {
                                 dbg("bus max supports 66MHz PCI-X\n");
-                                ctrl->speed_capability = PCI_SPEED_66MHz_PCIX;
+                                bus->max_bus_speed = PCI_SPEED_66MHz_PCIX;
                                 break;
                         }
                         if (bus_cap & 10) {
                                 dbg("bus max supports 66MHz PCI\n");
-                                ctrl->speed_capability = PCI_SPEED_66MHz;
+                                bus->max_bus_speed = PCI_SPEED_66MHz;
                                 break;
                         }
 
@@ -955,7 +932,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 case PCI_SUB_HPC_ID:
                         /* Original 6500/7000 implementation */
                         ctrl->slot_switch_type = 1;
-                        ctrl->speed_capability = PCI_SPEED_33MHz;
+                        bus->max_bus_speed = PCI_SPEED_33MHz;
                         ctrl->push_button = 0;
                         ctrl->pci_config_space = 1;
                         ctrl->defeature_PHP = 1;
@@ -966,7 +943,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         /* First Pushbutton implementation */
                         ctrl->push_flag = 1;
                         ctrl->slot_switch_type = 1;
-                        ctrl->speed_capability = PCI_SPEED_33MHz;
+                        bus->max_bus_speed = PCI_SPEED_33MHz;
                         ctrl->push_button = 1;
                         ctrl->pci_config_space = 1;
                         ctrl->defeature_PHP = 1;
@@ -976,7 +953,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 case PCI_SUB_HPC_ID_INTC:
                         /* Third party (6500/7000) */
                         ctrl->slot_switch_type = 1;
-                        ctrl->speed_capability = PCI_SPEED_33MHz;
+                        bus->max_bus_speed = PCI_SPEED_33MHz;
                         ctrl->push_button = 0;
                         ctrl->pci_config_space = 1;
                         ctrl->defeature_PHP = 1;
@@ -987,7 +964,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         /* First 66 Mhz implementation */
                         ctrl->push_flag = 1;
                         ctrl->slot_switch_type = 1;
-                        ctrl->speed_capability = PCI_SPEED_66MHz;
+                        bus->max_bus_speed = PCI_SPEED_66MHz;
                         ctrl->push_button = 1;
                         ctrl->pci_config_space = 1;
                         ctrl->defeature_PHP = 1;
@@ -998,7 +975,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                         /* First PCI-X implementation, 100MHz */
                         ctrl->push_flag = 1;
                         ctrl->slot_switch_type = 1;
-                        ctrl->speed_capability = PCI_SPEED_100MHz_PCIX;
+                        bus->max_bus_speed = PCI_SPEED_100MHz_PCIX;
                         ctrl->push_button = 1;
                         ctrl->pci_config_space = 1;
                         ctrl->defeature_PHP = 1;
@@ -1015,9 +992,9 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         case PCI_VENDOR_ID_INTEL:
                 /* Check for speed capability (0=33, 1=66) */
                 if (subsystem_deviceid & 0x0001)
-                        ctrl->speed_capability = PCI_SPEED_66MHz;
+                        bus->max_bus_speed = PCI_SPEED_66MHz;
                 else
-                        ctrl->speed_capability = PCI_SPEED_33MHz;
+                        bus->max_bus_speed = PCI_SPEED_33MHz;
 
                 /* Check for push button */
                 if (subsystem_deviceid & 0x0002)
@@ -1079,7 +1056,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                                         pdev->bus->number);
 
         dbg("Hotplug controller capabilities:\n");
-        dbg("    speed_capability       %d\n", ctrl->speed_capability);
+        dbg("    speed_capability       %d\n", bus->max_bus_speed);
         dbg("    slot_switch_type       %s\n", ctrl->slot_switch_type ?
                                         "switch present" : "no switch");
         dbg("    defeature_PHP          %s\n", ctrl->defeature_PHP ?
@@ -1142,7 +1119,7 @@ static int cpqhpc_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
 
         /* Check for 66Mhz operation */
-        ctrl->speed = get_controller_speed(ctrl);
+        bus->cur_bus_speed = get_controller_speed(ctrl);
 
 
         /********************************************************
diff --git a/drivers/pci/hotplug/cpqphp_ctrl.c b/drivers/pci/hotplug/cpqphp_ctrl.c
index 0ff689afa757..e43908d9b5df 100644
--- a/drivers/pci/hotplug/cpqphp_ctrl.c
+++ b/drivers/pci/hotplug/cpqphp_ctrl.c
@@ -1130,12 +1130,13 @@ static int is_bridge(struct pci_func * func)
 static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_slot)
 {
         struct slot *slot;
+        struct pci_bus *bus = ctrl->pci_bus;
         u8 reg;
         u8 slot_power = readb(ctrl->hpc_reg + SLOT_POWER);
         u16 reg16;
         u32 leds = readl(ctrl->hpc_reg + LED_CONTROL);
 
-        if (ctrl->speed == adapter_speed)
+        if (bus->cur_bus_speed == adapter_speed)
                 return 0;
 
         /* We don't allow freq/mode changes if we find another adapter running
@@ -1152,7 +1153,7 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
                  * lower speed/mode, we allow the new adapter to function at
                  * this rate if supported
                  */
-                if (ctrl->speed < adapter_speed)
+                if (bus->cur_bus_speed < adapter_speed)
                         return 0;
 
                 return 1;
@@ -1161,20 +1162,20 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
         /* If the controller doesn't support freq/mode changes and the
          * controller is running at a higher mode, we bail
          */
-        if ((ctrl->speed > adapter_speed) && (!ctrl->pcix_speed_capability))
+        if ((bus->cur_bus_speed > adapter_speed) && (!ctrl->pcix_speed_capability))
                 return 1;
 
         /* But we allow the adapter to run at a lower rate if possible */
-        if ((ctrl->speed < adapter_speed) && (!ctrl->pcix_speed_capability))
+        if ((bus->cur_bus_speed < adapter_speed) && (!ctrl->pcix_speed_capability))
                 return 0;
 
         /* We try to set the max speed supported by both the adapter and
          * controller
          */
-        if (ctrl->speed_capability < adapter_speed) {
-                if (ctrl->speed == ctrl->speed_capability)
+        if (bus->max_bus_speed < adapter_speed) {
+                if (bus->cur_bus_speed == bus->max_bus_speed)
                         return 0;
-                adapter_speed = ctrl->speed_capability;
+                adapter_speed = bus->max_bus_speed;
         }
 
         writel(0x0L, ctrl->hpc_reg + LED_CONTROL);
@@ -1229,8 +1230,8 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
         pci_write_config_byte(ctrl->pci_dev, 0x43, reg);
 
         /* Only if mode change...*/
-        if (((ctrl->speed == PCI_SPEED_66MHz) && (adapter_speed == PCI_SPEED_66MHz_PCIX)) ||
-                ((ctrl->speed == PCI_SPEED_66MHz_PCIX) && (adapter_speed == PCI_SPEED_66MHz))) 
+        if (((bus->cur_bus_speed == PCI_SPEED_66MHz) && (adapter_speed == PCI_SPEED_66MHz_PCIX)) ||
+                ((bus->cur_bus_speed == PCI_SPEED_66MHz_PCIX) && (adapter_speed == PCI_SPEED_66MHz))) 
                         set_SOGO(ctrl);
 
         wait_for_ctrl_irq(ctrl);
@@ -1243,7 +1244,7 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
         set_SOGO(ctrl);
         wait_for_ctrl_irq(ctrl);
 
-        ctrl->speed = adapter_speed;
+        bus->cur_bus_speed = adapter_speed;
         slot = cpqhp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
 
         info("Successfully changed frequency/mode for adapter in slot %d\n",
@@ -1269,6 +1270,7 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
  */
 static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
 {
+        struct pci_bus *bus = ctrl->pci_bus;
         u8 hp_slot;
         u8 temp_byte;
         u8 adapter_speed;
@@ -1309,7 +1311,7 @@ static u32 board_replaced(struct pci_func *func, struct controller *ctrl)
                 wait_for_ctrl_irq (ctrl);
 
                 adapter_speed = get_adapter_speed(ctrl, hp_slot);
-                if (ctrl->speed != adapter_speed)
+                if (bus->cur_bus_speed != adapter_speed)
                         if (set_controller_speed(ctrl, adapter_speed, hp_slot))
                                 rc = WRONG_BUS_FREQUENCY;
 
@@ -1426,6 +1428,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         u32 temp_register = 0xFFFFFFFF;
         u32 rc = 0;
         struct pci_func *new_slot = NULL;
+        struct pci_bus *bus = ctrl->pci_bus;
         struct slot *p_slot;
         struct resource_lists res_lists;
 
@@ -1456,7 +1459,7 @@ static u32 board_added(struct pci_func *func, struct controller *ctrl)
         wait_for_ctrl_irq (ctrl);
 
         adapter_speed = get_adapter_speed(ctrl, hp_slot);
-        if (ctrl->speed != adapter_speed)
+        if (bus->cur_bus_speed != adapter_speed)
                 if (set_controller_speed(ctrl, adapter_speed, hp_slot))
                         rc = WRONG_BUS_FREQUENCY;
 
diff --git a/drivers/pci/hotplug/ibmphp_core.c b/drivers/pci/hotplug/ibmphp_core.c
index 7485ffda950c..d934dd4fa873 100644
--- a/drivers/pci/hotplug/ibmphp_core.c
+++ b/drivers/pci/hotplug/ibmphp_core.c
@@ -395,89 +395,40 @@ static int get_adapter_present(struct hotplug_slot *hotplug_slot, u8 * value)
         return rc;
 }
 
-static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
+static int get_max_bus_speed(struct slot *slot)
 {
-        int rc = -ENODEV;
-        struct slot *pslot;
+        int rc;
         u8 mode = 0;
+        enum pci_bus_speed speed;
+        struct pci_bus *bus = slot->hotplug_slot->pci_slot->bus;
 
-        debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __func__,
-                hotplug_slot, value);
+        debug("%s - Entry slot[%p]\n", __func__, slot);
 
         ibmphp_lock_operations();
-
-        if (hotplug_slot) {
-                pslot = hotplug_slot->private;
-                if (pslot) {
-                        rc = 0;
-                        mode = pslot->supported_bus_mode;
-                        *value = pslot->supported_speed; 
-                        switch (*value) {
-                        case BUS_SPEED_33:
-                                break;
-                        case BUS_SPEED_66:
-                                if (mode == BUS_MODE_PCIX) 
-                                        *value += 0x01;
-                                break;
-                        case BUS_SPEED_100:
-                        case BUS_SPEED_133:
-                                *value = pslot->supported_speed + 0x01;
-                                break;
-                        default:
-                                /* Note (will need to change): there would be soon 256, 512 also */
-                                rc = -ENODEV;
-                        }
-                }
-        }
-
+        mode = slot->supported_bus_mode;
+        speed = slot->supported_speed; 
         ibmphp_unlock_operations();
-        debug("%s - Exit rc[%d] value[%x]\n", __func__, rc, *value);
-        return rc;
-}
 
-static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
-{
-        int rc = -ENODEV;
-        struct slot *pslot;
-        u8 mode = 0;
-
-        debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __func__,
-                hotplug_slot, value);
-
-        ibmphp_lock_operations();
-
-        if (hotplug_slot) {
-                pslot = hotplug_slot->private;
-                if (pslot) {
-                        rc = get_cur_bus_info(&pslot);
-                        if (!rc) {
-                                mode = pslot->bus_on->current_bus_mode;
-                                *value = pslot->bus_on->current_speed;
-                                switch (*value) {
-                                case BUS_SPEED_33:
-                                        break;
-                                case BUS_SPEED_66:
-                                        if (mode == BUS_MODE_PCIX) 
-                                                *value += 0x01;
-                                        else if (mode == BUS_MODE_PCI)
-                                                ;
-                                        else
-                                                *value = PCI_SPEED_UNKNOWN;
-                                        break;
-                                case BUS_SPEED_100:
-                                case BUS_SPEED_133:
-                                        *value += 0x01;
-                                        break;
-                                default:
-                                        /* Note of change: there would also be 256, 512 soon */
-                                        rc = -ENODEV;
-                                }
-                        }
-                }
+        switch (speed) {
+        case BUS_SPEED_33:
+                break;
+        case BUS_SPEED_66:
+                if (mode == BUS_MODE_PCIX) 
+                        speed += 0x01;
+                break;
+        case BUS_SPEED_100:
+        case BUS_SPEED_133:
+                speed += 0x01;
+                break;
+        default:
+                /* Note (will need to change): there would be soon 256, 512 also */
+                rc = -ENODEV;
         }
 
-        ibmphp_unlock_operations();
-        debug("%s - Exit rc[%d] value[%x]\n", __func__, rc, *value);
+        if (!rc)
+                bus->max_bus_speed = speed;
+
+        debug("%s - Exit rc[%d] speed[%x]\n", __func__, rc, speed);
         return rc;
 }
 
@@ -572,6 +523,7 @@ static int __init init_ops(void)
                 if (slot_cur->bus_on->current_speed == 0xFF) 
                         if (get_cur_bus_info(&slot_cur)) 
                                 return -1;
+                get_max_bus_speed(slot_cur);
 
                 if (slot_cur->ctrl->options == 0xFF)
                         if (get_hpc_options(slot_cur, &slot_cur->ctrl->options))
@@ -655,6 +607,7 @@ static int validate(struct slot *slot_cur, int opn)
 int ibmphp_update_slot_info(struct slot *slot_cur)
 {
         struct hotplug_slot_info *info;
+        struct pci_bus *bus = slot_cur->hotplug_slot->pci_slot->bus;
         int rc;
         u8 bus_speed;
         u8 mode;
@@ -700,8 +653,7 @@ int ibmphp_update_slot_info(struct slot *slot_cur)
                         bus_speed = PCI_SPEED_UNKNOWN;
         }
 
-        info->cur_bus_speed = bus_speed;
-        info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed;
+        bus->cur_bus_speed = bus_speed;
         // To do: bus_names 
         
         rc = pci_hp_change_slot_info(slot_cur->hotplug_slot, info);
@@ -1326,8 +1278,6 @@ struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
         .get_attention_status =         get_attention_status,
         .get_latch_status =             get_latch_status,
         .get_adapter_status =           get_adapter_present,
-        .get_max_bus_speed =            get_max_bus_speed,
-        .get_cur_bus_speed =            get_cur_bus_speed,
 /*      .get_max_adapter_speed =        get_max_adapter_speed,
         .get_bus_name_status =          get_bus_name,
 */
diff --git a/drivers/pci/hotplug/ibmphp_ebda.c b/drivers/pci/hotplug/ibmphp_ebda.c
index c1abac8ab5c3..5becbdee4027 100644
--- a/drivers/pci/hotplug/ibmphp_ebda.c
+++ b/drivers/pci/hotplug/ibmphp_ebda.c
@@ -245,7 +245,7 @@ static void __init print_ebda_hpc (void)
 
 int __init ibmphp_access_ebda (void)
 {
-        u8 format, num_ctlrs, rio_complete, hs_complete;
+        u8 format, num_ctlrs, rio_complete, hs_complete, ebda_sz;
         u16 ebda_seg, num_entries, next_offset, offset, blk_id, sub_addr, re, rc_id, re_id, base;
         int rc = 0;
 
@@ -260,7 +260,16 @@ int __init ibmphp_access_ebda (void)
         iounmap (io_mem);
         debug ("returned ebda segment: %x\n", ebda_seg);
         
-        io_mem = ioremap(ebda_seg<<4, 1024);
+        io_mem = ioremap(ebda_seg<<4, 1);
+        if (!io_mem)
+                return -ENOMEM;
+        ebda_sz = readb(io_mem);
+        iounmap(io_mem);
+        debug("ebda size: %d(KiB)\n", ebda_sz);
+        if (ebda_sz == 0)
+                return -ENOMEM;
+
+        io_mem = ioremap(ebda_seg<<4, (ebda_sz * 1024));
         if (!io_mem )
                 return -ENOMEM;
         next_offset = 0x180;
diff --git a/drivers/pci/hotplug/ibmphp_hpc.c b/drivers/pci/hotplug/ibmphp_hpc.c
index c7084f0eca5a..1aaf3f32d3cd 100644
--- a/drivers/pci/hotplug/ibmphp_hpc.c
+++ b/drivers/pci/hotplug/ibmphp_hpc.c
@@ -35,6 +35,7 @@
 #include <linux/init.h>
 #include <linux/mutex.h>
 #include <linux/sched.h>
+#include <linux/semaphore.h>
 #include <linux/kthread.h>
 #include "ibmphp.h"
 
diff --git a/drivers/pci/hotplug/pci_hotplug_core.c b/drivers/pci/hotplug/pci_hotplug_core.c
index 38183a534b65..728b119f71ad 100644
--- a/drivers/pci/hotplug/pci_hotplug_core.c
+++ b/drivers/pci/hotplug/pci_hotplug_core.c
@@ -64,32 +64,6 @@ static int debug;
 static LIST_HEAD(pci_hotplug_slot_list);
 static DEFINE_MUTEX(pci_hp_mutex);
 
-/* these strings match up with the values in pci_bus_speed */
-static char *pci_bus_speed_strings[] = {
-        "33 MHz PCI",           /* 0x00 */
-        "66 MHz PCI",           /* 0x01 */
-        "66 MHz PCI-X",         /* 0x02 */
-        "100 MHz PCI-X",        /* 0x03 */
-        "133 MHz PCI-X",        /* 0x04 */
-        NULL,                   /* 0x05 */
-        NULL,                   /* 0x06 */
-        NULL,                   /* 0x07 */
-        NULL,                   /* 0x08 */
-        "66 MHz PCI-X 266",     /* 0x09 */
-        "100 MHz PCI-X 266",    /* 0x0a */
-        "133 MHz PCI-X 266",    /* 0x0b */
-        NULL,                   /* 0x0c */
-        NULL,                   /* 0x0d */
-        NULL,                   /* 0x0e */
-        NULL,                   /* 0x0f */
-        NULL,                   /* 0x10 */
-        "66 MHz PCI-X 533",     /* 0x11 */
-        "100 MHz PCI-X 533",    /* 0x12 */
-        "133 MHz PCI-X 533",    /* 0x13 */
-        "2.5 GT/s PCIe",        /* 0x14 */
-        "5.0 GT/s PCIe",        /* 0x15 */
-};
-
 #ifdef CONFIG_HOTPLUG_PCI_CPCI
 extern int cpci_hotplug_init(int debug);
 extern void cpci_hotplug_exit(void);
@@ -118,8 +92,6 @@ GET_STATUS(power_status, u8)
 GET_STATUS(attention_status, u8)
 GET_STATUS(latch_status, u8)
 GET_STATUS(adapter_status, u8)
-GET_STATUS(max_bus_speed, enum pci_bus_speed)
-GET_STATUS(cur_bus_speed, enum pci_bus_speed)
 
 static ssize_t power_read_file(struct pci_slot *slot, char *buf)
 {
@@ -263,60 +235,6 @@ static struct pci_slot_attribute hotplug_slot_attr_presence = {
         .show = presence_read_file,
 };
 
-static char *unknown_speed = "Unknown bus speed";
-
-static ssize_t max_bus_speed_read_file(struct pci_slot *slot, char *buf)
-{
-        char *speed_string;
-        int retval;
-        enum pci_bus_speed value;
-        
-        retval = get_max_bus_speed(slot->hotplug, &value);
-        if (retval)
-                goto exit;
-
-        if (value == PCI_SPEED_UNKNOWN)
-                speed_string = unknown_speed;
-        else
-                speed_string = pci_bus_speed_strings[value];
-        
-        retval = sprintf (buf, "%s\n", speed_string);
-
-exit:
-        return retval;
-}
-
-static struct pci_slot_attribute hotplug_slot_attr_max_bus_speed = {
-        .attr = {.name = "max_bus_speed", .mode = S_IFREG | S_IRUGO},
-        .show = max_bus_speed_read_file,
-};
-
-static ssize_t cur_bus_speed_read_file(struct pci_slot *slot, char *buf)
-{
-        char *speed_string;
-        int retval;
-        enum pci_bus_speed value;
-
-        retval = get_cur_bus_speed(slot->hotplug, &value);
-        if (retval)
-                goto exit;
-
-        if (value == PCI_SPEED_UNKNOWN)
-                speed_string = unknown_speed;
-        else
-                speed_string = pci_bus_speed_strings[value];
-        
-        retval = sprintf (buf, "%s\n", speed_string);
-
-exit:
-        return retval;
-}
-
-static struct pci_slot_attribute hotplug_slot_attr_cur_bus_speed = {
-        .attr = {.name = "cur_bus_speed", .mode = S_IFREG | S_IRUGO},
-        .show = cur_bus_speed_read_file,
-};
-
 static ssize_t test_write_file(struct pci_slot *pci_slot, const char *buf,
                 size_t count)
 {
@@ -391,26 +309,6 @@ static bool has_adapter_file(struct pci_slot *pci_slot)
         return false;
 }
 
-static bool has_max_bus_speed_file(struct pci_slot *pci_slot)
-{
-        struct hotplug_slot *slot = pci_slot->hotplug;
-        if ((!slot) || (!slot->ops))
-                return false;
-        if (slot->ops->get_max_bus_speed)
-                return true;
-        return false;
-}
-
-static bool has_cur_bus_speed_file(struct pci_slot *pci_slot)
-{
-        struct hotplug_slot *slot = pci_slot->hotplug;
-        if ((!slot) || (!slot->ops))
-                return false;
-        if (slot->ops->get_cur_bus_speed)
-                return true;
-        return false;
-}
-
 static bool has_test_file(struct pci_slot *pci_slot)
 {
         struct hotplug_slot *slot = pci_slot->hotplug;
@@ -456,20 +354,6 @@ static int fs_add_slot(struct pci_slot *slot)
                         goto exit_adapter;
         }
 
-        if (has_max_bus_speed_file(slot)) {
-                retval = sysfs_create_file(&slot->kobj,
-                                        &hotplug_slot_attr_max_bus_speed.attr);
-                if (retval)
-                        goto exit_max_speed;
-        }
-
-        if (has_cur_bus_speed_file(slot)) {
-                retval = sysfs_create_file(&slot->kobj,
-                                        &hotplug_slot_attr_cur_bus_speed.attr);
-                if (retval)
-                        goto exit_cur_speed;
-        }
-
         if (has_test_file(slot)) {
                 retval = sysfs_create_file(&slot->kobj,
                                            &hotplug_slot_attr_test.attr);
@@ -480,14 +364,6 @@ static int fs_add_slot(struct pci_slot *slot)
         goto exit;
 
 exit_test:
-        if (has_cur_bus_speed_file(slot))
-                sysfs_remove_file(&slot->kobj,
-                                  &hotplug_slot_attr_cur_bus_speed.attr);
-exit_cur_speed:
-        if (has_max_bus_speed_file(slot))
-                sysfs_remove_file(&slot->kobj,
-                                  &hotplug_slot_attr_max_bus_speed.attr);
-exit_max_speed:
         if (has_adapter_file(slot))
                 sysfs_remove_file(&slot->kobj,
                                   &hotplug_slot_attr_presence.attr);
@@ -523,14 +399,6 @@ static void fs_remove_slot(struct pci_slot *slot)
                 sysfs_remove_file(&slot->kobj,
                                   &hotplug_slot_attr_presence.attr);
 
-        if (has_max_bus_speed_file(slot))
-                sysfs_remove_file(&slot->kobj,
-                                  &hotplug_slot_attr_max_bus_speed.attr);
-
-        if (has_cur_bus_speed_file(slot))
-                sysfs_remove_file(&slot->kobj,
-                                  &hotplug_slot_attr_cur_bus_speed.attr);
-
         if (has_test_file(slot))
                 sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_test.attr);
 
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 5674b2075bdc..920f820edf87 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -69,8 +69,6 @@ static int get_power_status	(struct hotplug_slot *slot, u8 *value);
 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
 static int get_latch_status     (struct hotplug_slot *slot, u8 *value);
 static int get_adapter_status   (struct hotplug_slot *slot, u8 *value);
-static int get_max_bus_speed    (struct hotplug_slot *slot, enum pci_bus_speed *value);
-static int get_cur_bus_speed    (struct hotplug_slot *slot, enum pci_bus_speed *value);
 
 /**
  * release_slot - free up the memory used by a slot
@@ -113,8 +111,6 @@ static int init_slot(struct controller *ctrl)
         ops->disable_slot = disable_slot;
         ops->get_power_status = get_power_status;
         ops->get_adapter_status = get_adapter_status;
-        ops->get_max_bus_speed = get_max_bus_speed;
-        ops->get_cur_bus_speed = get_cur_bus_speed;
         if (MRL_SENS(ctrl))
                 ops->get_latch_status = get_latch_status;
         if (ATTN_LED(ctrl)) {
@@ -227,27 +223,6 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 *value)
         return pciehp_get_adapter_status(slot, value);
 }
 
-static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
-                                enum pci_bus_speed *value)
-{
-        struct slot *slot = hotplug_slot->private;
-
-        ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
-                 __func__, slot_name(slot));
-
-        return pciehp_get_max_link_speed(slot, value);
-}
-
-static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
-{
-        struct slot *slot = hotplug_slot->private;
-
-        ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
-                 __func__, slot_name(slot));
-
-        return pciehp_get_cur_link_speed(slot, value);
-}
-
 static int pciehp_probe(struct pcie_device *dev)
 {
         int rc;
diff --git a/drivers/pci/hotplug/pciehp_ctrl.c b/drivers/pci/hotplug/pciehp_ctrl.c
index d6ac1b261dd9..9a7f247e8ac1 100644
--- a/drivers/pci/hotplug/pciehp_ctrl.c
+++ b/drivers/pci/hotplug/pciehp_ctrl.c
@@ -341,6 +341,7 @@ void pciehp_queue_pushbutton_work(struct work_struct *work)
                 p_slot->state = POWERON_STATE;
                 break;
         default:
+                kfree(info);
                 goto out;
         }
         queue_work(pciehp_wq, &info->work);
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index 10040d58c8ef..40b48f569b1e 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -492,6 +492,7 @@ int pciehp_power_on_slot(struct slot * slot)
         u16 slot_cmd;
         u16 cmd_mask;
         u16 slot_status;
+        u16 lnk_status;
         int retval = 0;
 
         /* Clear sticky power-fault bit from previous power failures */
@@ -523,6 +524,14 @@ int pciehp_power_on_slot(struct slot * slot)
         ctrl_dbg(ctrl, "%s: SLOTCTRL %x write cmd %x\n", __func__,
                  pci_pcie_cap(ctrl->pcie->port) + PCI_EXP_SLTCTL, slot_cmd);
 
+        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
+        if (retval) {
+                ctrl_err(ctrl, "%s: Cannot read LNKSTA register\n",
+                                __func__);
+                return retval;
+        }
+        pcie_update_link_speed(ctrl->pcie->port->subordinate, lnk_status);
+
         return retval;
 }
 
@@ -610,37 +619,6 @@ static irqreturn_t pcie_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-int pciehp_get_max_link_speed(struct slot *slot, enum pci_bus_speed *value)
-{
-        struct controller *ctrl = slot->ctrl;
-        enum pcie_link_speed lnk_speed;
-        u32     lnk_cap;
-        int retval = 0;
-
-        retval = pciehp_readl(ctrl, PCI_EXP_LNKCAP, &lnk_cap);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read LNKCAP register\n", __func__);
-                return retval;
-        }
-
-        switch (lnk_cap & 0x000F) {
-        case 1:
-                lnk_speed = PCIE_2_5GB;
-                break;
-        case 2:
-                lnk_speed = PCIE_5_0GB;
-                break;
-        default:
-                lnk_speed = PCIE_LNK_SPEED_UNKNOWN;
-                break;
-        }
-
-        *value = lnk_speed;
-        ctrl_dbg(ctrl, "Max link speed = %d\n", lnk_speed);
-
-        return retval;
-}
-
 int pciehp_get_max_lnk_width(struct slot *slot,
                                  enum pcie_link_width *value)
 {
@@ -691,38 +669,6 @@ int pciehp_get_max_lnk_width(struct slot *slot,
         return retval;
 }
 
-int pciehp_get_cur_link_speed(struct slot *slot, enum pci_bus_speed *value)
-{
-        struct controller *ctrl = slot->ctrl;
-        enum pcie_link_speed lnk_speed = PCI_SPEED_UNKNOWN;
-        int retval = 0;
-        u16 lnk_status;
-
-        retval = pciehp_readw(ctrl, PCI_EXP_LNKSTA, &lnk_status);
-        if (retval) {
-                ctrl_err(ctrl, "%s: Cannot read LNKSTATUS register\n",
-                         __func__);
-                return retval;
-        }
-
-        switch (lnk_status & PCI_EXP_LNKSTA_CLS) {
-        case 1:
-                lnk_speed = PCIE_2_5GB;
-                break;
-        case 2:
-                lnk_speed = PCIE_5_0GB;
-                break;
-        default:
-                lnk_speed = PCIE_LNK_SPEED_UNKNOWN;
-                break;
-        }
-
-        *value = lnk_speed;
-        ctrl_dbg(ctrl, "Current link speed = %d\n", lnk_speed);
-
-        return retval;
-}
-
 int pciehp_get_cur_lnk_width(struct slot *slot,
                                  enum pcie_link_width *value)
 {
diff --git a/drivers/pci/hotplug/pciehp_pci.c b/drivers/pci/hotplug/pciehp_pci.c
index 21733108adde..0a16444c14c9 100644
--- a/drivers/pci/hotplug/pciehp_pci.c
+++ b/drivers/pci/hotplug/pciehp_pci.c
@@ -53,17 +53,15 @@ static int __ref pciehp_add_bridge(struct pci_dev *dev)
                 busnr = pci_scan_bridge(parent, dev, busnr, pass);
         if (!dev->subordinate)
                 return -1;
-        pci_bus_size_bridges(dev->subordinate);
-        pci_bus_assign_resources(parent);
-        pci_enable_bridges(parent);
-        pci_bus_add_devices(parent);
+
         return 0;
 }
 
 int pciehp_configure_device(struct slot *p_slot)
 {
         struct pci_dev *dev;
-        struct pci_bus *parent = p_slot->ctrl->pcie->port->subordinate;
+        struct pci_dev *bridge = p_slot->ctrl->pcie->port;
+        struct pci_bus *parent = bridge->subordinate;
         int num, fn;
         struct controller *ctrl = p_slot->ctrl;
 
@@ -96,12 +94,25 @@ int pciehp_configure_device(struct slot *p_slot)
                                 (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)) {
                         pciehp_add_bridge(dev);
                 }
+                pci_dev_put(dev);
+        }
+
+        pci_assign_unassigned_bridge_resources(bridge);
+
+        for (fn = 0; fn < 8; fn++) {
+                dev = pci_get_slot(parent, PCI_DEVFN(0, fn));
+                if (!dev)
+                        continue;
+                if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
+                        pci_dev_put(dev);
+                        continue;
+                }
                 pci_configure_slot(dev);
                 pci_dev_put(dev);
         }
 
-        pci_bus_assign_resources(parent);
         pci_bus_add_devices(parent);
+
         return 0;
 }
 
diff --git a/drivers/pci/hotplug/rpaphp_core.c b/drivers/pci/hotplug/rpaphp_core.c
index c159223389ec..dcaae725fd79 100644
--- a/drivers/pci/hotplug/rpaphp_core.c
+++ b/drivers/pci/hotplug/rpaphp_core.c
@@ -130,10 +130,9 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 * value)
         return 0;
 }
 
-static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
+static enum pci_bus_speed get_max_bus_speed(struct slot *slot)
 {
-        struct slot *slot = (struct slot *)hotplug_slot->private;
-
+        enum pci_bus_speed speed;
         switch (slot->type) {
         case 1:
         case 2:
@@ -141,30 +140,30 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_spe
         case 4:
         case 5:
         case 6:
-                *value = PCI_SPEED_33MHz;       /* speed for case 1-6 */
+                speed = PCI_SPEED_33MHz;        /* speed for case 1-6 */
                 break;
         case 7:
         case 8:
-                *value = PCI_SPEED_66MHz;
+                speed = PCI_SPEED_66MHz;
                 break;
         case 11:
         case 14:
-                *value = PCI_SPEED_66MHz_PCIX;
+                speed = PCI_SPEED_66MHz_PCIX;
                 break;
         case 12:
         case 15:
-                *value = PCI_SPEED_100MHz_PCIX;
+                speed = PCI_SPEED_100MHz_PCIX;
                 break;
         case 13:
         case 16:
-                *value = PCI_SPEED_133MHz_PCIX;
+                speed = PCI_SPEED_133MHz_PCIX;
                 break;
         default:
-                *value = PCI_SPEED_UNKNOWN;
+                speed = PCI_SPEED_UNKNOWN;
                 break;
-
         }
-        return 0;
+
+        return speed;
 }
 
 static int get_children_props(struct device_node *dn, const int **drc_indexes,
@@ -408,6 +407,8 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
                 slot->state = NOT_VALID;
                 return -EINVAL;
         }
+
+        slot->bus->max_bus_speed = get_max_bus_speed(slot);
         return 0;
 }
 
@@ -429,7 +430,6 @@ struct hotplug_slot_ops rpaphp_hotplug_slot_ops = {
         .get_power_status = get_power_status,
         .get_attention_status = get_attention_status,
         .get_adapter_status = get_adapter_status,
-        .get_max_bus_speed = get_max_bus_speed,
 };
 
 module_init(rpaphp_init);
diff --git a/drivers/pci/hotplug/shpchp.h b/drivers/pci/hotplug/shpchp.h
index 8e210cd76e55..d2627e1c3ac1 100644
--- a/drivers/pci/hotplug/shpchp.h
+++ b/drivers/pci/hotplug/shpchp.h
@@ -333,8 +333,6 @@ struct hpc_ops {
         int (*set_attention_status)(struct slot *slot, u8 status);
         int (*get_latch_status)(struct slot *slot, u8 *status);
         int (*get_adapter_status)(struct slot *slot, u8 *status);
-        int (*get_max_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
-        int (*get_cur_bus_speed)(struct slot *slot, enum pci_bus_speed *speed);
         int (*get_adapter_speed)(struct slot *slot, enum pci_bus_speed *speed);
         int (*get_mode1_ECC_cap)(struct slot *slot, u8 *mode);
         int (*get_prog_int)(struct slot *slot, u8 *prog_int);
diff --git a/drivers/pci/hotplug/shpchp_core.c b/drivers/pci/hotplug/shpchp_core.c
index 8a520a3d0f59..a5062297f488 100644
--- a/drivers/pci/hotplug/shpchp_core.c
+++ b/drivers/pci/hotplug/shpchp_core.c
@@ -65,8 +65,6 @@ static int get_power_status	(struct hotplug_slot *slot, u8 *value);
 static int get_attention_status (struct hotplug_slot *slot, u8 *value);
 static int get_latch_status     (struct hotplug_slot *slot, u8 *value);
 static int get_adapter_status   (struct hotplug_slot *slot, u8 *value);
-static int get_max_bus_speed    (struct hotplug_slot *slot, enum pci_bus_speed *value);
-static int get_cur_bus_speed    (struct hotplug_slot *slot, enum pci_bus_speed *value);
 
 static struct hotplug_slot_ops shpchp_hotplug_slot_ops = {
         .set_attention_status = set_attention_status,
@@ -76,8 +74,6 @@ static struct hotplug_slot_ops shpchp_hotplug_slot_ops = {
         .get_attention_status = get_attention_status,
         .get_latch_status =     get_latch_status,
         .get_adapter_status =   get_adapter_status,
-        .get_max_bus_speed =    get_max_bus_speed,
-        .get_cur_bus_speed =    get_cur_bus_speed,
 };
 
 /**
@@ -279,37 +275,6 @@ static int get_adapter_status (struct hotplug_slot *hotplug_slot, u8 *value)
         return 0;
 }
 
-static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
-                                enum pci_bus_speed *value)
-{
-        struct slot *slot = get_slot(hotplug_slot);
-        int retval;
-
-        ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
-                 __func__, slot_name(slot));
-
-        retval = slot->hpc_ops->get_max_bus_speed(slot, value);
-        if (retval < 0)
-                *value = PCI_SPEED_UNKNOWN;
-
-        return 0;
-}
-
-static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
-{
-        struct slot *slot = get_slot(hotplug_slot);
-        int retval;
-
-        ctrl_dbg(slot->ctrl, "%s: physical_slot = %s\n",
-                 __func__, slot_name(slot));
-
-        retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
-        if (retval < 0)
-                *value = PCI_SPEED_UNKNOWN;
-
-        return 0;
-}
-
 static int is_shpc_capable(struct pci_dev *dev)
 {
         if ((dev->vendor == PCI_VENDOR_ID_AMD) || (dev->device ==
diff --git a/drivers/pci/hotplug/shpchp_ctrl.c b/drivers/pci/hotplug/shpchp_ctrl.c
index b8ab2796e66a..3bba0c0888ff 100644
--- a/drivers/pci/hotplug/shpchp_ctrl.c
+++ b/drivers/pci/hotplug/shpchp_ctrl.c
@@ -285,17 +285,8 @@ static int board_added(struct slot *p_slot)
                 return WRONG_BUS_FREQUENCY;
         }
 
-        rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bsp);
-        if (rc) {
-                ctrl_err(ctrl, "Can't get bus operation speed\n");
-                return WRONG_BUS_FREQUENCY;
-        }
-
-        rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &msp);
-        if (rc) {
-                ctrl_err(ctrl, "Can't get max bus operation speed\n");
-                msp = bsp;
-        }
+        bsp = ctrl->pci_dev->bus->cur_bus_speed;
+        msp = ctrl->pci_dev->bus->max_bus_speed;
 
         /* Check if there are other slots or devices on the same bus */
         if (!list_empty(&ctrl->pci_dev->subordinate->devices))
@@ -462,6 +453,7 @@ void shpchp_queue_pushbutton_work(struct work_struct *work)
                 p_slot->state = POWERON_STATE;
                 break;
         default:
+                kfree(info);
                 goto out;
         }
         queue_work(shpchp_wq, &info->work);
diff --git a/drivers/pci/hotplug/shpchp_hpc.c b/drivers/pci/hotplug/shpchp_hpc.c
index 86dc39847769..5f5e8d2e3552 100644
--- a/drivers/pci/hotplug/shpchp_hpc.c
+++ b/drivers/pci/hotplug/shpchp_hpc.c
@@ -660,6 +660,75 @@ static int hpc_slot_disable(struct slot * slot)
         return retval;
 }
 
+static int shpc_get_cur_bus_speed(struct controller *ctrl)
+{
+        int retval = 0;
+        struct pci_bus *bus = ctrl->pci_dev->subordinate;
+        enum pci_bus_speed bus_speed = PCI_SPEED_UNKNOWN;
+        u16 sec_bus_reg = shpc_readw(ctrl, SEC_BUS_CONFIG);
+        u8 pi = shpc_readb(ctrl, PROG_INTERFACE);
+        u8 speed_mode = (pi == 2) ? (sec_bus_reg & 0xF) : (sec_bus_reg & 0x7);
+
+        if ((pi == 1) && (speed_mode > 4)) {
+                retval = -ENODEV;
+                goto out;
+        }
+
+        switch (speed_mode) {
+        case 0x0:
+                bus_speed = PCI_SPEED_33MHz;
+                break;
+        case 0x1:
+                bus_speed = PCI_SPEED_66MHz;
+                break;
+        case 0x2:
+                bus_speed = PCI_SPEED_66MHz_PCIX;
+                break;
+        case 0x3:
+                bus_speed = PCI_SPEED_100MHz_PCIX;
+                break;
+        case 0x4:
+                bus_speed = PCI_SPEED_133MHz_PCIX;
+                break;
+        case 0x5:
+                bus_speed = PCI_SPEED_66MHz_PCIX_ECC;
+                break;
+        case 0x6:
+                bus_speed = PCI_SPEED_100MHz_PCIX_ECC;
+                break;
+        case 0x7:
+                bus_speed = PCI_SPEED_133MHz_PCIX_ECC;
+                break;
+        case 0x8:
+                bus_speed = PCI_SPEED_66MHz_PCIX_266;
+                break;
+        case 0x9:
+                bus_speed = PCI_SPEED_100MHz_PCIX_266;
+                break;
+        case 0xa:
+                bus_speed = PCI_SPEED_133MHz_PCIX_266;
+                break;
+        case 0xb:
+                bus_speed = PCI_SPEED_66MHz_PCIX_533;
+                break;
+        case 0xc:
+                bus_speed = PCI_SPEED_100MHz_PCIX_533;
+                break;
+        case 0xd:
+                bus_speed = PCI_SPEED_133MHz_PCIX_533;
+                break;
+        default:
+                retval = -ENODEV;
+                break;
+        }
+
+ out:
+        bus->cur_bus_speed = bus_speed;
+        dbg("Current bus speed = %d\n", bus_speed);
+        return retval;
+}
+
+
 static int hpc_set_bus_speed_mode(struct slot * slot, enum pci_bus_speed value)
 {
         int retval;
@@ -720,6 +789,8 @@ static int hpc_set_bus_speed_mode(struct slot * slot, enum pci_bus_speed value)
         retval = shpc_write_cmd(slot, 0, cmd);
         if (retval)
                 ctrl_err(ctrl, "%s: Write command failed!\n", __func__);
+        else
+                shpc_get_cur_bus_speed(ctrl);
 
         return retval;
 }
@@ -803,10 +874,10 @@ static irqreturn_t shpc_isr(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static int hpc_get_max_bus_speed (struct slot *slot, enum pci_bus_speed *value)
+static int shpc_get_max_bus_speed(struct controller *ctrl)
 {
         int retval = 0;
-        struct controller *ctrl = slot->ctrl;
+        struct pci_bus *bus = ctrl->pci_dev->subordinate;
         enum pci_bus_speed bus_speed = PCI_SPEED_UNKNOWN;
         u8 pi = shpc_readb(ctrl, PROG_INTERFACE);
         u32 slot_avail1 = shpc_readl(ctrl, SLOT_AVAIL1);
@@ -842,79 +913,12 @@ static int hpc_get_max_bus_speed (struct slot *slot, enum pci_bus_speed *value)
                         retval = -ENODEV;
         }
 
-        *value = bus_speed;
+        bus->max_bus_speed = bus_speed;
         ctrl_dbg(ctrl, "Max bus speed = %d\n", bus_speed);
 
         return retval;
 }
 
-static int hpc_get_cur_bus_speed (struct slot *slot, enum pci_bus_speed *value)
-{
-        int retval = 0;
-        struct controller *ctrl = slot->ctrl;
-        enum pci_bus_speed bus_speed = PCI_SPEED_UNKNOWN;
-        u16 sec_bus_reg = shpc_readw(ctrl, SEC_BUS_CONFIG);
-        u8 pi = shpc_readb(ctrl, PROG_INTERFACE);
-        u8 speed_mode = (pi == 2) ? (sec_bus_reg & 0xF) : (sec_bus_reg & 0x7);
-
-        if ((pi == 1) && (speed_mode > 4)) {
-                *value = PCI_SPEED_UNKNOWN;
-                return -ENODEV;
-        }
-
-        switch (speed_mode) {
-        case 0x0:
-                *value = PCI_SPEED_33MHz;
-                break;
-        case 0x1:
-                *value = PCI_SPEED_66MHz;
-                break;
-        case 0x2:
-                *value = PCI_SPEED_66MHz_PCIX;
-                break;
-        case 0x3:
-                *value = PCI_SPEED_100MHz_PCIX;
-                break;
-        case 0x4:
-                *value = PCI_SPEED_133MHz_PCIX;
-                break;
-        case 0x5:
-                *value = PCI_SPEED_66MHz_PCIX_ECC;
-                break;
-        case 0x6:
-                *value = PCI_SPEED_100MHz_PCIX_ECC;
-                break;
-        case 0x7:
-                *value = PCI_SPEED_133MHz_PCIX_ECC;
-                break;
-        case 0x8:
-                *value = PCI_SPEED_66MHz_PCIX_266;
-                break;
-        case 0x9:
-                *value = PCI_SPEED_100MHz_PCIX_266;
-                break;
-        case 0xa:
-                *value = PCI_SPEED_133MHz_PCIX_266;
-                break;
-        case 0xb:
-                *value = PCI_SPEED_66MHz_PCIX_533;
-                break;
-        case 0xc:
-                *value = PCI_SPEED_100MHz_PCIX_533;
-                break;
-        case 0xd:
-                *value = PCI_SPEED_133MHz_PCIX_533;
-                break;
-        default:
-                *value = PCI_SPEED_UNKNOWN;
-                retval = -ENODEV;
-                break;
-        }
-
-        ctrl_dbg(ctrl, "Current bus speed = %d\n", bus_speed);
-        return retval;
-}
-
 static struct hpc_ops shpchp_hpc_ops = {
         .power_on_slot                  = hpc_power_on_slot,
         .slot_enable                    = hpc_slot_enable,
@@ -926,8 +930,6 @@ static struct hpc_ops shpchp_hpc_ops = {
         .get_latch_status               = hpc_get_latch_status,
         .get_adapter_status             = hpc_get_adapter_status,
 
-        .get_max_bus_speed              = hpc_get_max_bus_speed,
-        .get_cur_bus_speed              = hpc_get_cur_bus_speed,
         .get_adapter_speed              = hpc_get_adapter_speed,
         .get_mode1_ECC_cap              = hpc_get_mode1_ECC_cap,
         .get_prog_int                   = hpc_get_prog_int,
@@ -1086,6 +1088,9 @@ int shpc_init(struct controller *ctrl, struct pci_dev *pdev)
         }
         ctrl_dbg(ctrl, "HPC at %s irq=%x\n", pci_name(pdev), pdev->irq);
 
+        shpc_get_max_bus_speed(ctrl);
+        shpc_get_cur_bus_speed(ctrl);
+
         /*
          * If this is the first controller to be initialized,
          * initialize the shpchpd work queue
diff --git a/drivers/pci/hotplug/shpchp_sysfs.c b/drivers/pci/hotplug/shpchp_sysfs.c
index 29fa9d26adae..071b7dc0094b 100644
--- a/drivers/pci/hotplug/shpchp_sysfs.c
+++ b/drivers/pci/hotplug/shpchp_sysfs.c
@@ -47,8 +47,7 @@ static ssize_t show_ctrl (struct device *dev, struct device_attribute *attr, cha
         bus = pdev->subordinate;
 
         out += sprintf(buf, "Free resources: memory\n");
-        for (index = 0; index < PCI_BUS_NUM_RESOURCES; index++) {
-                res = bus->resource[index];
+        pci_bus_for_each_resource(bus, res, index) {
                 if (res && (res->flags & IORESOURCE_MEM) &&
                                 !(res->flags & IORESOURCE_PREFETCH)) {
                         out += sprintf(out, "start = %8.8llx, "
@@ -58,8 +57,7 @@ static ssize_t show_ctrl (struct device *dev, struct device_attribute *attr, cha
                 }
         }
         out += sprintf(out, "Free resources: prefetchable memory\n");
-        for (index = 0; index < PCI_BUS_NUM_RESOURCES; index++) {
-                res = bus->resource[index];
+        pci_bus_for_each_resource(bus, res, index) {
                 if (res && (res->flags & IORESOURCE_MEM) &&
                                (res->flags & IORESOURCE_PREFETCH)) {
                         out += sprintf(out, "start = %8.8llx, "
@@ -69,8 +67,7 @@ static ssize_t show_ctrl (struct device *dev, struct device_attribute *attr, cha
                 }
         }
         out += sprintf(out, "Free resources: IO\n");
-        for (index = 0; index < PCI_BUS_NUM_RESOURCES; index++) {
-                res = bus->resource[index];
+        pci_bus_for_each_resource(bus, res, index) {
                 if (res && (res->flags & IORESOURCE_IO)) {
                         out += sprintf(out, "start = %8.8llx, "
                                         "length = %8.8llx\n",
diff --git a/drivers/pci/legacy.c b/drivers/pci/legacy.c
deleted file mode 100644
index 871f65c15936..000000000000
--- a/drivers/pci/legacy.c
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <linux/init.h>
-#include <linux/pci.h>
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include "pci.h"
-
-/**
- * pci_find_device - begin or continue searching for a PCI device by vendor/device id
- * @vendor: PCI vendor id to match, or %PCI_ANY_ID to match all vendor ids
- * @device: PCI device id to match, or %PCI_ANY_ID to match all device ids
- * @from: Previous PCI device found in search, or %NULL for new search.
- *
- * Iterates through the list of known PCI devices.  If a PCI device is found
- * with a matching @vendor and @device, a pointer to its device structure is
- * returned.  Otherwise, %NULL is returned.
- * A new search is initiated by passing %NULL as the @from argument.
- * Otherwise if @from is not %NULL, searches continue from next device
- * on the global list.
- *
- * NOTE: Do not use this function any more; use pci_get_device() instead, as
- * the PCI device returned by this function can disappear at any moment in
- * time.
- */
-struct pci_dev *pci_find_device(unsigned int vendor, unsigned int device,
-                                struct pci_dev *from)
-{
-        struct pci_dev *pdev;
-
-        pci_dev_get(from);
-        pdev = pci_get_subsys(vendor, device, PCI_ANY_ID, PCI_ANY_ID, from);
-        pci_dev_put(pdev);
-        return pdev;
-}
-EXPORT_SYMBOL(pci_find_device);
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 7e2829538a4c..c0c73913833d 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -16,8 +16,144 @@
 #include <acpi/acpi_bus.h>
 
 #include <linux/pci-acpi.h>
+#include <linux/pm_runtime.h>
 #include "pci.h"
 
+static DEFINE_MUTEX(pci_acpi_pm_notify_mtx);
+
+/**
+ * pci_acpi_wake_bus - Wake-up notification handler for root buses.
+ * @handle: ACPI handle of a device the notification is for.
+ * @event: Type of the signaled event.
+ * @context: PCI root bus to wake up devices on.
+ */
+static void pci_acpi_wake_bus(acpi_handle handle, u32 event, void *context)
+{
+        struct pci_bus *pci_bus = context;
+
+        if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_bus)
+                pci_pme_wakeup_bus(pci_bus);
+}
+
+/**
+ * pci_acpi_wake_dev - Wake-up notification handler for PCI devices.
+ * @handle: ACPI handle of a device the notification is for.
+ * @event: Type of the signaled event.
+ * @context: PCI device object to wake up.
+ */
+static void pci_acpi_wake_dev(acpi_handle handle, u32 event, void *context)
+{
+        struct pci_dev *pci_dev = context;
+
+        if (event == ACPI_NOTIFY_DEVICE_WAKE && pci_dev) {
+                pci_check_pme_status(pci_dev);
+                pm_runtime_resume(&pci_dev->dev);
+                if (pci_dev->subordinate)
+                        pci_pme_wakeup_bus(pci_dev->subordinate);
+        }
+}
+
+/**
+ * add_pm_notifier - Register PM notifier for given ACPI device.
+ * @dev: ACPI device to add the notifier for.
+ * @context: PCI device or bus to check for PME status if an event is signaled.
+ *
+ * NOTE: @dev need not be a run-wake or wake-up device to be a valid source of
+ * PM wake-up events.  For example, wake-up events may be generated for bridges
+ * if one of the devices below the bridge is signaling PME, even if the bridge
+ * itself doesn't have a wake-up GPE associated with it.
+ */
+static acpi_status add_pm_notifier(struct acpi_device *dev,
+                                   acpi_notify_handler handler,
+                                   void *context)
+{
+        acpi_status status = AE_ALREADY_EXISTS;
+
+        mutex_lock(&pci_acpi_pm_notify_mtx);
+
+        if (dev->wakeup.flags.notifier_present)
+                goto out;
+
+        status = acpi_install_notify_handler(dev->handle,
+                                             ACPI_SYSTEM_NOTIFY,
+                                             handler, context);
+        if (ACPI_FAILURE(status))
+                goto out;
+
+        dev->wakeup.flags.notifier_present = true;
+
+ out:
+        mutex_unlock(&pci_acpi_pm_notify_mtx);
+        return status;
+}
+
+/**
+ * remove_pm_notifier - Unregister PM notifier from given ACPI device.
+ * @dev: ACPI device to remove the notifier from.
+ */
+static acpi_status remove_pm_notifier(struct acpi_device *dev,
+                                      acpi_notify_handler handler)
+{
+        acpi_status status = AE_BAD_PARAMETER;
+
+        mutex_lock(&pci_acpi_pm_notify_mtx);
+
+        if (!dev->wakeup.flags.notifier_present)
+                goto out;
+
+        status = acpi_remove_notify_handler(dev->handle,
+                                            ACPI_SYSTEM_NOTIFY,
+                                            handler);
+        if (ACPI_FAILURE(status))
+                goto out;
+
+        dev->wakeup.flags.notifier_present = false;
+
+ out:
+        mutex_unlock(&pci_acpi_pm_notify_mtx);
+        return status;
+}
+
+/**
+ * pci_acpi_add_bus_pm_notifier - Register PM notifier for given PCI bus.
+ * @dev: ACPI device to add the notifier for.
+ * @pci_bus: PCI bus to walk checking for PME status if an event is signaled.
+ */
+acpi_status pci_acpi_add_bus_pm_notifier(struct acpi_device *dev,
+                                         struct pci_bus *pci_bus)
+{
+        return add_pm_notifier(dev, pci_acpi_wake_bus, pci_bus);
+}
+
+/**
+ * pci_acpi_remove_bus_pm_notifier - Unregister PCI bus PM notifier.
+ * @dev: ACPI device to remove the notifier from.
+ */
+acpi_status pci_acpi_remove_bus_pm_notifier(struct acpi_device *dev)
+{
+        return remove_pm_notifier(dev, pci_acpi_wake_bus);
+}
+
+/**
+ * pci_acpi_add_pm_notifier - Register PM notifier for given PCI device.
+ * @dev: ACPI device to add the notifier for.
+ * @pci_dev: PCI device to check for the PME status if an event is signaled.
+ */
+acpi_status pci_acpi_add_pm_notifier(struct acpi_device *dev,
+                                     struct pci_dev *pci_dev)
+{
+        return add_pm_notifier(dev, pci_acpi_wake_dev, pci_dev);
+}
+
+/**
+ * pci_acpi_remove_pm_notifier - Unregister PCI device PM notifier.
+ * @dev: ACPI device to remove the notifier from.
+ */
+acpi_status pci_acpi_remove_pm_notifier(struct acpi_device *dev)
+{
+        return remove_pm_notifier(dev, pci_acpi_wake_dev);
+}
+
 /*
  * _SxD returns the D-state with the highest power
  * (lowest D-state number) supported in the S-state "x".
@@ -131,12 +267,87 @@ static int acpi_pci_sleep_wake(struct pci_dev *dev, bool enable)
         return 0;
 }
 
+/**
+ * acpi_dev_run_wake - Enable/disable wake-up for given device.
+ * @phys_dev: Device to enable/disable the platform to wake-up the system for.
+ * @enable: Whether enable or disable the wake-up functionality.
+ *
+ * Find the ACPI device object corresponding to @pci_dev and try to
+ * enable/disable the GPE associated with it.
+ */
+static int acpi_dev_run_wake(struct device *phys_dev, bool enable)
+{
+        struct acpi_device *dev;
+        acpi_handle handle;
+        int error = -ENODEV;
+
+        if (!device_run_wake(phys_dev))
+                return -EINVAL;
+
+        handle = DEVICE_ACPI_HANDLE(phys_dev);
+        if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &dev))) {
+                dev_dbg(phys_dev, "ACPI handle has no context in %s!\n",
+                        __func__);
+                return -ENODEV;
+        }
+
+        if (enable) {
+                if (!dev->wakeup.run_wake_count++) {
+                        acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0);
+                        acpi_enable_gpe(dev->wakeup.gpe_device,
+                                        dev->wakeup.gpe_number,
+                                        ACPI_GPE_TYPE_RUNTIME);
+                }
+        } else if (dev->wakeup.run_wake_count > 0) {
+                if (!--dev->wakeup.run_wake_count) {
+                        acpi_disable_gpe(dev->wakeup.gpe_device,
+                                         dev->wakeup.gpe_number,
+                                         ACPI_GPE_TYPE_RUNTIME);
+                        acpi_disable_wakeup_device_power(dev);
+                }
+        } else {
+                error = -EALREADY;
+        }
+
+        return error;
+}
+
+static void acpi_pci_propagate_run_wake(struct pci_bus *bus, bool enable)
+{
+        while (bus->parent) {
+                struct pci_dev *bridge = bus->self;
+
+                if (bridge->pme_interrupt)
+                        return;
+                if (!acpi_dev_run_wake(&bridge->dev, enable))
+                        return;
+                bus = bus->parent;
+        }
+
+        /* We have reached the root bus. */
+        if (bus->bridge)
+                acpi_dev_run_wake(bus->bridge, enable);
+}
+
+static int acpi_pci_run_wake(struct pci_dev *dev, bool enable)
+{
+        if (dev->pme_interrupt)
+                return 0;
+
+        if (!acpi_dev_run_wake(&dev->dev, enable))
+                return 0;
+
+        acpi_pci_propagate_run_wake(dev->bus, enable);
+        return 0;
+}
+
 static struct pci_platform_pm_ops acpi_pci_platform_pm = {
         .is_manageable = acpi_pci_power_manageable,
         .set_state = acpi_pci_set_power_state,
         .choose_state = acpi_pci_choose_state,
         .can_wakeup = acpi_pci_can_wakeup,
         .sleep_wake = acpi_pci_sleep_wake,
+        .run_wake = acpi_pci_run_wake,
 };
 
 /* ACPI bus type */
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index e5d47be3c6d7..f9a0aec3abcf 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -17,6 +17,7 @@
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/cpu.h>
+#include <linux/pm_runtime.h>
 #include "pci.h"
 
 struct pci_dynid {
@@ -404,6 +405,35 @@ static void pci_device_shutdown(struct device *dev)
         pci_msix_shutdown(pci_dev);
 }
 
+#ifdef CONFIG_PM_OPS
+
+/* Auxiliary functions used for system resume and run-time resume. */
+
+/**
+ * pci_restore_standard_config - restore standard config registers of PCI device
+ * @pci_dev: PCI device to handle
+ */
+static int pci_restore_standard_config(struct pci_dev *pci_dev)
+{
+        pci_update_current_state(pci_dev, PCI_UNKNOWN);
+
+        if (pci_dev->current_state != PCI_D0) {
+                int error = pci_set_power_state(pci_dev, PCI_D0);
+                if (error)
+                        return error;
+        }
+
+        return pci_restore_state(pci_dev);
+}
+
+static void pci_pm_default_resume_early(struct pci_dev *pci_dev)
+{
+        pci_restore_standard_config(pci_dev);
+        pci_fixup_device(pci_fixup_resume_early, pci_dev);
+}
+
+#endif
+
 #ifdef CONFIG_PM_SLEEP
 
 /*
@@ -520,29 +550,6 @@ static int pci_legacy_resume(struct device *dev)
 
 /* Auxiliary functions used by the new power management framework */
 
-/**
- * pci_restore_standard_config - restore standard config registers of PCI device
- * @pci_dev: PCI device to handle
- */
-static int pci_restore_standard_config(struct pci_dev *pci_dev)
-{
-        pci_update_current_state(pci_dev, PCI_UNKNOWN);
-
-        if (pci_dev->current_state != PCI_D0) {
-                int error = pci_set_power_state(pci_dev, PCI_D0);
-                if (error)
-                        return error;
-        }
-
-        return pci_restore_state(pci_dev);
-}
-
-static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
-{
-        pci_restore_standard_config(pci_dev);
-        pci_fixup_device(pci_fixup_resume_early, pci_dev);
-}
-
 static void pci_pm_default_resume(struct pci_dev *pci_dev)
 {
         pci_fixup_device(pci_fixup_resume, pci_dev);
@@ -581,6 +588,17 @@ static int pci_pm_prepare(struct device *dev)
         struct device_driver *drv = dev->driver;
         int error = 0;
 
+        /*
+         * PCI devices suspended at run time need to be resumed at this
+         * point, because in general it is necessary to reconfigure them for
+         * system suspend.  Namely, if the device is supposed to wake up the
+         * system from the sleep state, we may need to reconfigure it for this
+         * purpose.  In turn, if the device is not supposed to wake up the
+         * system from the sleep state, we'll have to prevent it from signaling
+         * wake-up.
+         */
+        pm_runtime_resume(dev);
+
         if (drv && drv->pm && drv->pm->prepare)
                 error = drv->pm->prepare(dev);
 
@@ -595,6 +613,13 @@ static void pci_pm_complete(struct device *dev)
                 drv->pm->complete(dev);
 }
 
+#else /* !CONFIG_PM_SLEEP */
+
+#define pci_pm_prepare  NULL
+#define pci_pm_complete NULL
+
+#endif /* !CONFIG_PM_SLEEP */
+
 #ifdef CONFIG_SUSPEND
 
 static int pci_pm_suspend(struct device *dev)
@@ -681,7 +706,7 @@ static int pci_pm_resume_noirq(struct device *dev)
         struct device_driver *drv = dev->driver;
         int error = 0;
 
-        pci_pm_default_resume_noirq(pci_dev);
+        pci_pm_default_resume_early(pci_dev);
 
         if (pci_has_legacy_pm_support(pci_dev))
                 return pci_legacy_resume_early(dev);
@@ -879,7 +904,7 @@ static int pci_pm_restore_noirq(struct device *dev)
         struct device_driver *drv = dev->driver;
         int error = 0;
 
-        pci_pm_default_resume_noirq(pci_dev);
+        pci_pm_default_resume_early(pci_dev);
 
         if (pci_has_legacy_pm_support(pci_dev))
                 return pci_legacy_resume_early(dev);
@@ -931,6 +956,84 @@ static int pci_pm_restore(struct device *dev)
 
 #endif /* !CONFIG_HIBERNATION */
 
+#ifdef CONFIG_PM_RUNTIME
+
+static int pci_pm_runtime_suspend(struct device *dev)
+{
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+        pci_power_t prev = pci_dev->current_state;
+        int error;
+
+        if (!pm || !pm->runtime_suspend)
+                return -ENOSYS;
+
+        error = pm->runtime_suspend(dev);
+        suspend_report_result(pm->runtime_suspend, error);
+        if (error)
+                return error;
+
+        pci_fixup_device(pci_fixup_suspend, pci_dev);
+
+        if (!pci_dev->state_saved && pci_dev->current_state != PCI_D0
+            && pci_dev->current_state != PCI_UNKNOWN) {
+                WARN_ONCE(pci_dev->current_state != prev,
+                        "PCI PM: State of device not saved by %pF\n",
+                        pm->runtime_suspend);
+                return 0;
+        }
+
+        if (!pci_dev->state_saved)
+                pci_save_state(pci_dev);
+
+        pci_finish_runtime_suspend(pci_dev);
+
+        return 0;
+}
+
+static int pci_pm_runtime_resume(struct device *dev)
+{
+        struct pci_dev *pci_dev = to_pci_dev(dev);
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (!pm || !pm->runtime_resume)
+                return -ENOSYS;
+
+        pci_pm_default_resume_early(pci_dev);
+        __pci_enable_wake(pci_dev, PCI_D0, true, false);
+        pci_fixup_device(pci_fixup_resume, pci_dev);
+
+        return pm->runtime_resume(dev);
+}
+
+static int pci_pm_runtime_idle(struct device *dev)
+{
+        const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
+
+        if (!pm)
+                return -ENOSYS;
+
+        if (pm->runtime_idle) {
+                int ret = pm->runtime_idle(dev);
+                if (ret)
+                        return ret;
+        }
+
+        pm_runtime_suspend(dev);
+
+        return 0;
+}
+
+#else /* !CONFIG_PM_RUNTIME */
+
+#define pci_pm_runtime_suspend  NULL
+#define pci_pm_runtime_resume   NULL
+#define pci_pm_runtime_idle     NULL
+
+#endif /* !CONFIG_PM_RUNTIME */
+
+#ifdef CONFIG_PM_OPS
+
 const struct dev_pm_ops pci_dev_pm_ops = {
         .prepare = pci_pm_prepare,
         .complete = pci_pm_complete,
@@ -946,15 +1049,18 @@ const struct dev_pm_ops pci_dev_pm_ops = {
         .thaw_noirq = pci_pm_thaw_noirq,
         .poweroff_noirq = pci_pm_poweroff_noirq,
         .restore_noirq = pci_pm_restore_noirq,
+        .runtime_suspend = pci_pm_runtime_suspend,
+        .runtime_resume = pci_pm_runtime_resume,
+        .runtime_idle = pci_pm_runtime_idle,
 };
 
 #define PCI_PM_OPS_PTR  (&pci_dev_pm_ops)
 
-#else /* !CONFIG_PM_SLEEP */
+#else /* !COMFIG_PM_OPS */
 
 #define PCI_PM_OPS_PTR  NULL
 
-#endif /* !CONFIG_PM_SLEEP */
+#endif /* !COMFIG_PM_OPS */
 
 /**
  * __pci_register_driver - register a new pci driver
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 315fea47e784..f4a2738bf0bf 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -19,8 +19,8 @@
 #include <linux/pci-aspm.h>
 #include <linux/pm_wakeup.h>
 #include <linux/interrupt.h>
-#include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include <linux/device.h>
+#include <linux/pm_runtime.h>
 #include <asm/setup.h>
 #include "pci.h"
 
@@ -29,6 +29,12 @@ const char *pci_power_names[] = {
 };
 EXPORT_SYMBOL_GPL(pci_power_names);
 
+int isa_dma_bridge_buggy;
+EXPORT_SYMBOL(isa_dma_bridge_buggy);
+
+int pci_pci_problems;
+EXPORT_SYMBOL(pci_pci_problems);
+
 unsigned int pci_pm_d3_delay;
 
 static void pci_dev_d3_sleep(struct pci_dev *dev)
@@ -380,10 +386,9 @@ pci_find_parent_resource(const struct pci_dev *dev, struct resource *res)
 {
         const struct pci_bus *bus = dev->bus;
         int i;
-        struct resource *best = NULL;
+        struct resource *best = NULL, *r;
 
-        for(i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
-                struct resource *r = bus->resource[i];
+        pci_bus_for_each_resource(bus, r, i) {
                 if (!r)
                         continue;
                 if (res->start && !(res->start >= r->start && res->end <= r->end))
@@ -457,6 +462,12 @@ static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
                         pci_platform_pm->sleep_wake(dev, enable) : -ENODEV;
 }
 
+static inline int platform_pci_run_wake(struct pci_dev *dev, bool enable)
+{
+        return pci_platform_pm ?
+                        pci_platform_pm->run_wake(dev, enable) : -ENODEV;
+}
+
 /**
  * pci_raw_set_power_state - Use PCI PM registers to set the power state of
  *                           given PCI device
@@ -1190,6 +1201,66 @@ int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state)
 }
 
 /**
+ * pci_check_pme_status - Check if given device has generated PME.
+ * @dev: Device to check.
+ *
+ * Check the PME status of the device and if set, clear it and clear PME enable
+ * (if set).  Return 'true' if PME status and PME enable were both set or
+ * 'false' otherwise.
+ */
+bool pci_check_pme_status(struct pci_dev *dev)
+{
+        int pmcsr_pos;
+        u16 pmcsr;
+        bool ret = false;
+
+        if (!dev->pm_cap)
+                return false;
+
+        pmcsr_pos = dev->pm_cap + PCI_PM_CTRL;
+        pci_read_config_word(dev, pmcsr_pos, &pmcsr);
+        if (!(pmcsr & PCI_PM_CTRL_PME_STATUS))
+                return false;
+
+        /* Clear PME status. */
+        pmcsr |= PCI_PM_CTRL_PME_STATUS;
+        if (pmcsr & PCI_PM_CTRL_PME_ENABLE) {
+                /* Disable PME to avoid interrupt flood. */
+                pmcsr &= ~PCI_PM_CTRL_PME_ENABLE;
+                ret = true;
+        }
+
+        pci_write_config_word(dev, pmcsr_pos, pmcsr);
+
+        return ret;
+}
+
+/**
+ * pci_pme_wakeup - Wake up a PCI device if its PME Status bit is set.
+ * @dev: Device to handle.
+ * @ign: Ignored.
+ *
+ * Check if @dev has generated PME and queue a resume request for it in that
+ * case.
+ */
+static int pci_pme_wakeup(struct pci_dev *dev, void *ign)
+{
+        if (pci_check_pme_status(dev))
+                pm_request_resume(&dev->dev);
+        return 0;
+}
+
+/**
+ * pci_pme_wakeup_bus - Walk given bus and wake up devices on it, if necessary.
+ * @bus: Top bus of the subtree to walk.
+ */
+void pci_pme_wakeup_bus(struct pci_bus *bus)
+{
+        if (bus)
+                pci_walk_bus(bus, pci_pme_wakeup, NULL);
+}
+
+/**
  * pci_pme_capable - check the capability of PCI device to generate PME#
  * @dev: PCI device to handle.
  * @state: PCI state from which device will issue PME#.
@@ -1230,9 +1301,10 @@ void pci_pme_active(struct pci_dev *dev, bool enable)
 }
 
 /**
- * pci_enable_wake - enable PCI device as wakeup event source
+ * __pci_enable_wake - enable PCI device as wakeup event source
  * @dev: PCI device affected
  * @state: PCI state from which device will issue wakeup events
+ * @runtime: True if the events are to be generated at run time
  * @enable: True to enable event generation; false to disable
  *
  * This enables the device as a wakeup event source, or disables it.
@@ -1248,11 +1320,12 @@ void pci_pme_active(struct pci_dev *dev, bool enable)
  * Error code depending on the platform is returned if both the platform and
  * the native mechanism fail to enable the generation of wake-up events
  */
-int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable)
+int __pci_enable_wake(struct pci_dev *dev, pci_power_t state,
+                      bool runtime, bool enable)
 {
         int ret = 0;
 
-        if (enable && !device_may_wakeup(&dev->dev))
+        if (enable && !runtime && !device_may_wakeup(&dev->dev))
                 return -EINVAL;
 
         /* Don't do the same thing twice in a row for one device. */
@@ -1272,19 +1345,24 @@ int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable)
                         pci_pme_active(dev, true);
                 else
                         ret = 1;
-                error = platform_pci_sleep_wake(dev, true);
+                error = runtime ? platform_pci_run_wake(dev, true) :
+                                        platform_pci_sleep_wake(dev, true);
                 if (ret)
                         ret = error;
                 if (!ret)
                         dev->wakeup_prepared = true;
         } else {
-                platform_pci_sleep_wake(dev, false);
+                if (runtime)
+                        platform_pci_run_wake(dev, false);
+                else
+                        platform_pci_sleep_wake(dev, false);
                 pci_pme_active(dev, false);
                 dev->wakeup_prepared = false;
         }
 
         return ret;
 }
+EXPORT_SYMBOL(__pci_enable_wake);
 
 /**
  * pci_wake_from_d3 - enable/disable device to wake up from D3_hot or D3_cold
@@ -1394,6 +1472,66 @@ int pci_back_from_sleep(struct pci_dev *dev)
 }
 
 /**
+ * pci_finish_runtime_suspend - Carry out PCI-specific part of runtime suspend.
+ * @dev: PCI device being suspended.
+ *
+ * Prepare @dev to generate wake-up events at run time and put it into a low
+ * power state.
+ */
+int pci_finish_runtime_suspend(struct pci_dev *dev)
+{
+        pci_power_t target_state = pci_target_state(dev);
+        int error;
+
+        if (target_state == PCI_POWER_ERROR)
+                return -EIO;
+
+        __pci_enable_wake(dev, target_state, true, pci_dev_run_wake(dev));
+
+        error = pci_set_power_state(dev, target_state);
+
+        if (error)
+                __pci_enable_wake(dev, target_state, true, false);
+
+        return error;
+}
+
+/**
+ * pci_dev_run_wake - Check if device can generate run-time wake-up events.
+ * @dev: Device to check.
+ *
+ * Return true if the device itself is cabable of generating wake-up events
+ * (through the platform or using the native PCIe PME) or if the device supports
+ * PME and one of its upstream bridges can generate wake-up events.
+ */
+bool pci_dev_run_wake(struct pci_dev *dev)
+{
+        struct pci_bus *bus = dev->bus;
+
+        if (device_run_wake(&dev->dev))
+                return true;
+
+        if (!dev->pme_support)
+                return false;
+
+        while (bus->parent) {
+                struct pci_dev *bridge = bus->self;
+
+                if (device_run_wake(&bridge->dev))
+                        return true;
+
+                bus = bus->parent;
+        }
+
+        /* We have reached the root bus. */
+        if (bus->bridge)
+                return device_run_wake(bus->bridge);
+
+        return false;
+}
+EXPORT_SYMBOL_GPL(pci_dev_run_wake);
+
+/**
  * pci_pm_init - Initialize PM functions of given PCI device
  * @dev: PCI device to handle.
  */
@@ -2871,7 +3009,6 @@ EXPORT_SYMBOL(pci_save_state);
 EXPORT_SYMBOL(pci_restore_state);
 EXPORT_SYMBOL(pci_pme_capable);
 EXPORT_SYMBOL(pci_pme_active);
-EXPORT_SYMBOL(pci_enable_wake);
 EXPORT_SYMBOL(pci_wake_from_d3);
 EXPORT_SYMBOL(pci_target_state);
 EXPORT_SYMBOL(pci_prepare_to_sleep);
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index fbd0e3adbca3..4eb10f48d270 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -35,6 +35,10 @@ int pci_probe_reset_function(struct pci_dev *dev);
  *
  * @sleep_wake: enables/disables the system wake up capability of given device
  *
+ * @run_wake: enables/disables the platform to generate run-time wake-up events
+ *              for given device (the device's wake-up capability has to be
+ *              enabled by @sleep_wake for this feature to work)
+ *
  * If given platform is generally capable of power managing PCI devices, all of
  * these callbacks are mandatory.
  */
@@ -44,11 +48,16 @@ struct pci_platform_pm_ops {
         pci_power_t (*choose_state)(struct pci_dev *dev);
         bool (*can_wakeup)(struct pci_dev *dev);
         int (*sleep_wake)(struct pci_dev *dev, bool enable);
+        int (*run_wake)(struct pci_dev *dev, bool enable);
 };
 
 extern int pci_set_platform_pm(struct pci_platform_pm_ops *ops);
 extern void pci_update_current_state(struct pci_dev *dev, pci_power_t state);
 extern void pci_disable_enabled_device(struct pci_dev *dev);
+extern bool pci_check_pme_status(struct pci_dev *dev);
+extern int pci_finish_runtime_suspend(struct pci_dev *dev);
+extern int __pci_pme_wakeup(struct pci_dev *dev, void *ign);
+extern void pci_pme_wakeup_bus(struct pci_bus *bus);
 extern void pci_pm_init(struct pci_dev *dev);
 extern void platform_pci_wakeup_init(struct pci_dev *dev);
 extern void pci_allocate_cap_save_buffers(struct pci_dev *dev);
@@ -319,6 +328,13 @@ struct pci_dev_reset_methods {
         int (*reset)(struct pci_dev *dev, int probe);
 };
 
+#ifdef CONFIG_PCI_QUIRKS
 extern int pci_dev_specific_reset(struct pci_dev *dev, int probe);
+#else
+static inline int pci_dev_specific_reset(struct pci_dev *dev, int probe)
+{
+        return -ENOTTY;
+}
+#endif
 
 #endif /* DRIVERS_PCI_H */
diff --git a/drivers/pci/pcie/Kconfig b/drivers/pci/pcie/Kconfig
index 5a0c6ad53f8e..b8b494b3e0d0 100644
--- a/drivers/pci/pcie/Kconfig
+++ b/drivers/pci/pcie/Kconfig
@@ -46,3 +46,7 @@ config PCIEASPM_DEBUG
         help
           This enables PCI Express ASPM debug support. It will add per-device
           interface to control ASPM.
+
+config PCIE_PME
+        def_bool y
+        depends on PCIEPORTBUS && PM_RUNTIME && EXPERIMENTAL && ACPI
diff --git a/drivers/pci/pcie/Makefile b/drivers/pci/pcie/Makefile
index 11f6bb1eae24..ea654545e7c4 100644
--- a/drivers/pci/pcie/Makefile
+++ b/drivers/pci/pcie/Makefile
@@ -11,3 +11,5 @@ obj-$(CONFIG_PCIEPORTBUS)	+= pcieportdrv.o
 
 # Build PCI Express AER if needed
 obj-$(CONFIG_PCIEAER)           += aer/
+
+obj-$(CONFIG_PCIE_PME) += pme/
diff --git a/drivers/pci/pcie/pme/Makefile b/drivers/pci/pcie/pme/Makefile
new file mode 100644
index 000000000000..8b9238053080
--- /dev/null
+++ b/drivers/pci/pcie/pme/Makefile
@@ -0,0 +1,8 @@
+#
+# Makefile for PCI-Express Root Port PME signaling driver
+#
+
+obj-$(CONFIG_PCIE_PME) += pmedriver.o
+
+pmedriver-objs := pcie_pme.o
+pmedriver-$(CONFIG_ACPI) += pcie_pme_acpi.o
diff --git a/drivers/pci/pcie/pme/pcie_pme.c b/drivers/pci/pcie/pme/pcie_pme.c
new file mode 100644
index 000000000000..7b3cbff547ee
--- /dev/null
+++ b/drivers/pci/pcie/pme/pcie_pme.c
@@ -0,0 +1,505 @@
+/*
+ * PCIe Native PME support
+ *
+ * Copyright (C) 2007 - 2009 Intel Corp
+ * Copyright (C) 2007 - 2009 Shaohua Li <shaohua.li@intel.com>
+ * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License V2.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/device.h>
+#include <linux/pcieport_if.h>
+#include <linux/acpi.h>
+#include <linux/pci-acpi.h>
+#include <linux/pm_runtime.h>
+
+#include "../../pci.h"
+#include "pcie_pme.h"
+
+#define PCI_EXP_RTSTA_PME       0x10000 /* PME status */
+#define PCI_EXP_RTSTA_PENDING   0x20000 /* PME pending */
+
+/*
+ * If set, this switch will prevent the PCIe root port PME service driver from
+ * being registered.  Consequently, the interrupt-based PCIe PME signaling will
+ * not be used by any PCIe root ports in that case.
+ */
+static bool pcie_pme_disabled;
+
+/*
+ * The PCI Express Base Specification 2.0, Section 6.1.8, states the following:
+ * "In order to maintain compatibility with non-PCI Express-aware system
+ * software, system power management logic must be configured by firmware to use
+ * the legacy mechanism of signaling PME by default.  PCI Express-aware system
+ * software must notify the firmware prior to enabling native, interrupt-based
+ * PME signaling."  However, if the platform doesn't provide us with a suitable
+ * notification mechanism or the notification fails, it is not clear whether or
+ * not we are supposed to use the interrupt-based PCIe PME signaling.  The
+ * switch below can be used to indicate the desired behaviour.  When set, it
+ * will make the kernel use the interrupt-based PCIe PME signaling regardless of
+ * the platform notification status, although the kernel will attempt to notify
+ * the platform anyway.  When unset, it will prevent the kernel from using the
+ * the interrupt-based PCIe PME signaling if the platform notification fails,
+ * which is the default.
+ */
+static bool pcie_pme_force_enable;
+
+/*
+ * If this switch is set, MSI will not be used for PCIe PME signaling.  This
+ * causes the PCIe port driver to use INTx interrupts only, but it turns out
+ * that using MSI for PCIe PME signaling doesn't play well with PCIe PME-based
+ * wake-up from system sleep states.
+ */
+bool pcie_pme_msi_disabled;
+
+static int __init pcie_pme_setup(char *str)
+{
+        if (!strcmp(str, "off"))
+                pcie_pme_disabled = true;
+        else if (!strcmp(str, "force"))
+                pcie_pme_force_enable = true;
+        else if (!strcmp(str, "nomsi"))
+                pcie_pme_msi_disabled = true;
+        return 1;
+}
+__setup("pcie_pme=", pcie_pme_setup);
+
+/**
+ * pcie_pme_platform_setup - Ensure that the kernel controls the PCIe PME.
+ * @srv: PCIe PME root port service to use for carrying out the check.
+ *
+ * Notify the platform that the native PCIe PME is going to be used and return
+ * 'true' if the control of the PCIe PME registers has been acquired from the
+ * platform.
+ */
+static bool pcie_pme_platform_setup(struct pcie_device *srv)
+{
+        if (!pcie_pme_platform_notify(srv))
+                return true;
+        return pcie_pme_force_enable;
+}
+
+struct pcie_pme_service_data {
+        spinlock_t lock;
+        struct pcie_device *srv;
+        struct work_struct work;
+        bool noirq; /* Don't enable the PME interrupt used by this service. */
+};
+
+/**
+ * pcie_pme_interrupt_enable - Enable/disable PCIe PME interrupt generation.
+ * @dev: PCIe root port or event collector.
+ * @enable: Enable or disable the interrupt.
+ */
+static void pcie_pme_interrupt_enable(struct pci_dev *dev, bool enable)
+{
+        int rtctl_pos;
+        u16 rtctl;
+
+        rtctl_pos = pci_pcie_cap(dev) + PCI_EXP_RTCTL;
+
+        pci_read_config_word(dev, rtctl_pos, &rtctl);
+        if (enable)
+                rtctl |= PCI_EXP_RTCTL_PMEIE;
+        else
+                rtctl &= ~PCI_EXP_RTCTL_PMEIE;
+        pci_write_config_word(dev, rtctl_pos, rtctl);
+}
+
+/**
+ * pcie_pme_clear_status - Clear root port PME interrupt status.
+ * @dev: PCIe root port or event collector.
+ */
+static void pcie_pme_clear_status(struct pci_dev *dev)
+{
+        int rtsta_pos;
+        u32 rtsta;
+
+        rtsta_pos = pci_pcie_cap(dev) + PCI_EXP_RTSTA;
+
+        pci_read_config_dword(dev, rtsta_pos, &rtsta);
+        rtsta |= PCI_EXP_RTSTA_PME;
+        pci_write_config_dword(dev, rtsta_pos, rtsta);
+}
+
+/**
+ * pcie_pme_walk_bus - Scan a PCI bus for devices asserting PME#.
+ * @bus: PCI bus to scan.
+ *
+ * Scan given PCI bus and all buses under it for devices asserting PME#.
+ */
+static bool pcie_pme_walk_bus(struct pci_bus *bus)
+{
+        struct pci_dev *dev;
+        bool ret = false;
+
+        list_for_each_entry(dev, &bus->devices, bus_list) {
+                /* Skip PCIe devices in case we started from a root port. */
+                if (!pci_is_pcie(dev) && pci_check_pme_status(dev)) {
+                        pm_request_resume(&dev->dev);
+                        ret = true;
+                }
+
+                if (dev->subordinate && pcie_pme_walk_bus(dev->subordinate))
+                        ret = true;
+        }
+
+        return ret;
+}
+
+/**
+ * pcie_pme_from_pci_bridge - Check if PCIe-PCI bridge generated a PME.
+ * @bus: Secondary bus of the bridge.
+ * @devfn: Device/function number to check.
+ *
+ * PME from PCI devices under a PCIe-PCI bridge may be converted to an in-band
+ * PCIe PME message.  In such that case the bridge should use the Requester ID
+ * of device/function number 0 on its secondary bus.
+ */
+static bool pcie_pme_from_pci_bridge(struct pci_bus *bus, u8 devfn)
+{
+        struct pci_dev *dev;
+        bool found = false;
+
+        if (devfn)
+                return false;
+
+        dev = pci_dev_get(bus->self);
+        if (!dev)
+                return false;
+
+        if (pci_is_pcie(dev) && dev->pcie_type == PCI_EXP_TYPE_PCI_BRIDGE) {
+                down_read(&pci_bus_sem);
+                if (pcie_pme_walk_bus(bus))
+                        found = true;
+                up_read(&pci_bus_sem);
+        }
+
+        pci_dev_put(dev);
+        return found;
+}
+
+/**
+ * pcie_pme_handle_request - Find device that generated PME and handle it.
+ * @port: Root port or event collector that generated the PME interrupt.
+ * @req_id: PCIe Requester ID of the device that generated the PME.
+ */
+static void pcie_pme_handle_request(struct pci_dev *port, u16 req_id)
+{
+        u8 busnr = req_id >> 8, devfn = req_id & 0xff;
+        struct pci_bus *bus;
+        struct pci_dev *dev;
+        bool found = false;
+
+        /* First, check if the PME is from the root port itself. */
+        if (port->devfn == devfn && port->bus->number == busnr) {
+                if (pci_check_pme_status(port)) {
+                        pm_request_resume(&port->dev);
+                        found = true;
+                } else {
+                        /*
+                         * Apparently, the root port generated the PME on behalf
+                         * of a non-PCIe device downstream.  If this is done by
+                         * a root port, the Requester ID field in its status
+                         * register may contain either the root port's, or the
+                         * source device's information (PCI Express Base
+                         * Specification, Rev. 2.0, Section 6.1.9).
+                         */
+                        down_read(&pci_bus_sem);
+                        found = pcie_pme_walk_bus(port->subordinate);
+                        up_read(&pci_bus_sem);
+                }
+                goto out;
+        }
+
+        /* Second, find the bus the source device is on. */
+        bus = pci_find_bus(pci_domain_nr(port->bus), busnr);
+        if (!bus)
+                goto out;
+
+        /* Next, check if the PME is from a PCIe-PCI bridge. */
+        found = pcie_pme_from_pci_bridge(bus, devfn);
+        if (found)
+                goto out;
+
+        /* Finally, try to find the PME source on the bus. */
+        down_read(&pci_bus_sem);
+        list_for_each_entry(dev, &bus->devices, bus_list) {
+                pci_dev_get(dev);
+                if (dev->devfn == devfn) {
+                        found = true;
+                        break;
+                }
+                pci_dev_put(dev);
+        }
+        up_read(&pci_bus_sem);
+
+        if (found) {
+                /* The device is there, but we have to check its PME status. */
+                found = pci_check_pme_status(dev);
+                if (found)
+                        pm_request_resume(&dev->dev);
+                pci_dev_put(dev);
+        } else if (devfn) {
+                /*
+                 * The device is not there, but we can still try to recover by
+                 * assuming that the PME was reported by a PCIe-PCI bridge that
+                 * used devfn different from zero.
+                 */
+                dev_dbg(&port->dev, "PME interrupt generated for "
+                        "non-existent device %02x:%02x.%d\n",
+                        busnr, PCI_SLOT(devfn), PCI_FUNC(devfn));
+                found = pcie_pme_from_pci_bridge(bus, 0);
+        }
+
+ out:
+        if (!found)
+                dev_dbg(&port->dev, "Spurious native PME interrupt!\n");
+}
+
+/**
+ * pcie_pme_work_fn - Work handler for PCIe PME interrupt.
+ * @work: Work structure giving access to service data.
+ */
+static void pcie_pme_work_fn(struct work_struct *work)
+{
+        struct pcie_pme_service_data *data =
+                        container_of(work, struct pcie_pme_service_data, work);
+        struct pci_dev *port = data->srv->port;
+        int rtsta_pos;
+        u32 rtsta;
+
+        rtsta_pos = pci_pcie_cap(port) + PCI_EXP_RTSTA;
+
+        spin_lock_irq(&data->lock);
+
+        for (;;) {
+                if (data->noirq)
+                        break;
+
+                pci_read_config_dword(port, rtsta_pos, &rtsta);
+                if (rtsta & PCI_EXP_RTSTA_PME) {
+                        /*
+                         * Clear PME status of the port.  If there are other
+                         * pending PMEs, the status will be set again.
+                         */
+                        pcie_pme_clear_status(port);
+
+                        spin_unlock_irq(&data->lock);
+                        pcie_pme_handle_request(port, rtsta & 0xffff);
+                        spin_lock_irq(&data->lock);
+
+                        continue;
+                }
+
+                /* No need to loop if there are no more PMEs pending. */
+                if (!(rtsta & PCI_EXP_RTSTA_PENDING))
+                        break;
+
+                spin_unlock_irq(&data->lock);
+                cpu_relax();
+                spin_lock_irq(&data->lock);
+        }
+
+        if (!data->noirq)
+                pcie_pme_interrupt_enable(port, true);
+
+        spin_unlock_irq(&data->lock);
+}
+
+/**
+ * pcie_pme_irq - Interrupt handler for PCIe root port PME interrupt.
+ * @irq: Interrupt vector.
+ * @context: Interrupt context pointer.
+ */
+static irqreturn_t pcie_pme_irq(int irq, void *context)
+{
+        struct pci_dev *port;
+        struct pcie_pme_service_data *data;
+        int rtsta_pos;
+        u32 rtsta;
+        unsigned long flags;
+
+        port = ((struct pcie_device *)context)->port;
+        data = get_service_data((struct pcie_device *)context);
+
+        rtsta_pos = pci_pcie_cap(port) + PCI_EXP_RTSTA;
+
+        spin_lock_irqsave(&data->lock, flags);
+        pci_read_config_dword(port, rtsta_pos, &rtsta);
+
+        if (!(rtsta & PCI_EXP_RTSTA_PME)) {
+                spin_unlock_irqrestore(&data->lock, flags);
+                return IRQ_NONE;
+        }
+
+        pcie_pme_interrupt_enable(port, false);
+        spin_unlock_irqrestore(&data->lock, flags);
+
+        /* We don't use pm_wq, because it's freezable. */
+        schedule_work(&data->work);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * pcie_pme_set_native - Set the PME interrupt flag for given device.
+ * @dev: PCI device to handle.
+ * @ign: Ignored.
+ */
+static int pcie_pme_set_native(struct pci_dev *dev, void *ign)
+{
+        dev_info(&dev->dev, "Signaling PME through PCIe PME interrupt\n");
+
+        device_set_run_wake(&dev->dev, true);
+        dev->pme_interrupt = true;
+        return 0;
+}
+
+/**
+ * pcie_pme_mark_devices - Set the PME interrupt flag for devices below a port.
+ * @port: PCIe root port or event collector to handle.
+ *
+ * For each device below given root port, including the port itself (or for each
+ * root complex integrated endpoint if @port is a root complex event collector)
+ * set the flag indicating that it can signal run-time wake-up events via PCIe
+ * PME interrupts.
+ */
+static void pcie_pme_mark_devices(struct pci_dev *port)
+{
+        pcie_pme_set_native(port, NULL);
+        if (port->subordinate) {
+                pci_walk_bus(port->subordinate, pcie_pme_set_native, NULL);
+        } else {
+                struct pci_bus *bus = port->bus;
+                struct pci_dev *dev;
+
+                /* Check if this is a root port event collector. */
+                if (port->pcie_type != PCI_EXP_TYPE_RC_EC || !bus)
+                        return;
+
+                down_read(&pci_bus_sem);
+                list_for_each_entry(dev, &bus->devices, bus_list)
+                        if (pci_is_pcie(dev)
+                            && dev->pcie_type == PCI_EXP_TYPE_RC_END)
+                                pcie_pme_set_native(dev, NULL);
+                up_read(&pci_bus_sem);
+        }
+}
+
+/**
+ * pcie_pme_probe - Initialize PCIe PME service for given root port.
+ * @srv: PCIe service to initialize.
+ */
+static int pcie_pme_probe(struct pcie_device *srv)
+{
+        struct pci_dev *port;
+        struct pcie_pme_service_data *data;
+        int ret;
+
+        if (!pcie_pme_platform_setup(srv))
+                return -EACCES;
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        spin_lock_init(&data->lock);
+        INIT_WORK(&data->work, pcie_pme_work_fn);
+        data->srv = srv;
+        set_service_data(srv, data);
+
+        port = srv->port;
+        pcie_pme_interrupt_enable(port, false);
+        pcie_pme_clear_status(port);
+
+        ret = request_irq(srv->irq, pcie_pme_irq, IRQF_SHARED, "PCIe PME", srv);
+        if (ret) {
+                kfree(data);
+        } else {
+                pcie_pme_mark_devices(port);
+                pcie_pme_interrupt_enable(port, true);
+        }
+
+        return ret;
+}
+
+/**
+ * pcie_pme_suspend - Suspend PCIe PME service device.
+ * @srv: PCIe service device to suspend.
+ */
+static int pcie_pme_suspend(struct pcie_device *srv)
+{
+        struct pcie_pme_service_data *data = get_service_data(srv);
+        struct pci_dev *port = srv->port;
+
+        spin_lock_irq(&data->lock);
+        pcie_pme_interrupt_enable(port, false);
+        pcie_pme_clear_status(port);
+        data->noirq = true;
+        spin_unlock_irq(&data->lock);
+
+        synchronize_irq(srv->irq);
+
+        return 0;
+}
+
+/**
+ * pcie_pme_resume - Resume PCIe PME service device.
+ * @srv - PCIe service device to resume.
+ */
+static int pcie_pme_resume(struct pcie_device *srv)
+{
+        struct pcie_pme_service_data *data = get_service_data(srv);
+        struct pci_dev *port = srv->port;
+
+        spin_lock_irq(&data->lock);
+        data->noirq = false;
+        pcie_pme_clear_status(port);
+        pcie_pme_interrupt_enable(port, true);
+        spin_unlock_irq(&data->lock);
+
+        return 0;
+}
+
+/**
+ * pcie_pme_remove - Prepare PCIe PME service device for removal.
+ * @srv - PCIe service device to resume.
+ */
+static void pcie_pme_remove(struct pcie_device *srv)
+{
+        pcie_pme_suspend(srv);
+        free_irq(srv->irq, srv);
+        kfree(get_service_data(srv));
+}
+
+static struct pcie_port_service_driver pcie_pme_driver = {
+        .name           = "pcie_pme",
+        .port_type      = PCI_EXP_TYPE_ROOT_PORT,
+        .service        = PCIE_PORT_SERVICE_PME,
+
+        .probe          = pcie_pme_probe,
+        .suspend        = pcie_pme_suspend,
+        .resume         = pcie_pme_resume,
+        .remove         = pcie_pme_remove,
+};
+
+/**
+ * pcie_pme_service_init - Register the PCIe PME service driver.
+ */
+static int __init pcie_pme_service_init(void)
+{
+        return pcie_pme_disabled ?
+                -ENODEV : pcie_port_service_register(&pcie_pme_driver);
+}
+
+module_init(pcie_pme_service_init);
diff --git a/drivers/pci/pcie/pme/pcie_pme.h b/drivers/pci/pcie/pme/pcie_pme.h
new file mode 100644
index 000000000000..b30d2b7c9775
--- /dev/null
+++ b/drivers/pci/pcie/pme/pcie_pme.h
@@ -0,0 +1,28 @@
+/*
+ * drivers/pci/pcie/pme/pcie_pme.h
+ *
+ * PCI Express Root Port PME signaling support
+ *
+ * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ */
+
+#ifndef _PCIE_PME_H_
+#define _PCIE_PME_H_
+
+struct pcie_device;
+
+#ifdef CONFIG_ACPI
+extern int pcie_pme_acpi_setup(struct pcie_device *srv);
+
+static inline int pcie_pme_platform_notify(struct pcie_device *srv)
+{
+        return pcie_pme_acpi_setup(srv);
+}
+#else /* !CONFIG_ACPI */
+static inline int pcie_pme_platform_notify(struct pcie_device *srv)
+{
+        return 0;
+}
+#endif /* !CONFIG_ACPI */
+
+#endif
diff --git a/drivers/pci/pcie/pme/pcie_pme_acpi.c b/drivers/pci/pcie/pme/pcie_pme_acpi.c
new file mode 100644
index 000000000000..83ab2287ae3f
--- /dev/null
+++ b/drivers/pci/pcie/pme/pcie_pme_acpi.c
@@ -0,0 +1,54 @@
+/*
+ * PCIe Native PME support, ACPI-related part
+ *
+ * Copyright (C) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License V2.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#include <linux/pci.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/acpi.h>
+#include <linux/pci-acpi.h>
+#include <linux/pcieport_if.h>
+
+/**
+ * pcie_pme_acpi_setup - Request the ACPI BIOS to release control over PCIe PME.
+ * @srv - PCIe PME service for a root port or event collector.
+ *
+ * Invoked when the PCIe bus type loads PCIe PME service driver.  To avoid
+ * conflict with the BIOS PCIe support requires the BIOS to yield PCIe PME
+ * control to the kernel.
+ */
+int pcie_pme_acpi_setup(struct pcie_device *srv)
+{
+        acpi_status status = AE_NOT_FOUND;
+        struct pci_dev *port = srv->port;
+        acpi_handle handle;
+        int error = 0;
+
+        if (acpi_pci_disabled)
+                return -ENOSYS;
+
+        dev_info(&port->dev, "Requesting control of PCIe PME from ACPI BIOS\n");
+
+        handle = acpi_find_root_bridge_handle(port);
+        if (!handle)
+                return -EINVAL;
+
+        status = acpi_pci_osc_control_set(handle,
+                        OSC_PCI_EXPRESS_PME_CONTROL |
+                        OSC_PCI_EXPRESS_CAP_STRUCTURE_CONTROL);
+        if (ACPI_FAILURE(status)) {
+                dev_info(&port->dev,
+                        "Failed to receive control of PCIe PME service: %s\n",
+                        (status == AE_SUPPORT || status == AE_NOT_FOUND) ?
+                        "no _OSC support" : "ACPI _OSC failed");
+                error = -ENODEV;
+        }
+
+        return error;
+}
diff --git a/drivers/pci/pcie/portdrv.h b/drivers/pci/pcie/portdrv.h
index aaeb9d21cba5..813a5c3427b6 100644
--- a/drivers/pci/pcie/portdrv.h
+++ b/drivers/pci/pcie/portdrv.h
@@ -30,4 +30,21 @@ extern void pcie_port_device_remove(struct pci_dev *dev);
 extern int __must_check pcie_port_bus_register(void);
 extern void pcie_port_bus_unregister(void);
 
+#ifdef CONFIG_PCIE_PME
+extern bool pcie_pme_msi_disabled;
+
+static inline void pcie_pme_disable_msi(void)
+{
+        pcie_pme_msi_disabled = true;
+}
+
+static inline bool pcie_pme_no_msi(void)
+{
+        return pcie_pme_msi_disabled;
+}
+#else /* !CONFIG_PCIE_PME */
+static inline void pcie_pme_disable_msi(void) {}
+static inline bool pcie_pme_no_msi(void) { return false; }
+#endif /* !CONFIG_PCIE_PME */
+
 #endif /* _PORTDRV_H_ */
diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index b174188ac121..0d34ff415399 100644
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -186,16 +186,24 @@ static int pcie_port_enable_msix(struct pci_dev *dev, int *vectors, int mask)
  */
 static int init_service_irqs(struct pci_dev *dev, int *irqs, int mask)
 {
-        int i, irq;
+        int i, irq = -1;
+
+        /* We have to use INTx if MSI cannot be used for PCIe PME. */
+        if ((mask & PCIE_PORT_SERVICE_PME) && pcie_pme_no_msi()) {
+                if (dev->pin)
+                        irq = dev->irq;
+                goto no_msi;
+        }
 
         /* Try to use MSI-X if supported */
         if (!pcie_port_enable_msix(dev, irqs, mask))
                 return 0;
+
         /* We're not going to use MSI-X, so try MSI and fall back to INTx */
-        irq = -1;
         if (!pci_enable_msi(dev) || dev->pin)
                 irq = dev->irq;
 
+ no_msi:
         for (i = 0; i < PCIE_PORT_DEVICE_MAXSERVICES; i++)
                 irqs[i] = irq;
         irqs[PCIE_PORT_SERVICE_VC_SHIFT] = -1;
diff --git a/drivers/pci/pcie/portdrv_pci.c b/drivers/pci/pcie/portdrv_pci.c
index 13c8972886e6..127e8f169d9c 100644
--- a/drivers/pci/pcie/portdrv_pci.c
+++ b/drivers/pci/pcie/portdrv_pci.c
@@ -15,6 +15,7 @@
 #include <linux/slab.h>
 #include <linux/pcieport_if.h>
 #include <linux/aer.h>
+#include <linux/dmi.h>
 
 #include "portdrv.h"
 #include "aer/aerdrv.h"
@@ -273,10 +274,36 @@ static struct pci_driver pcie_portdriver = {
         .driver.pm      = PCIE_PORTDRV_PM_OPS,
 };
 
+static int __init dmi_pcie_pme_disable_msi(const struct dmi_system_id *d)
+{
+        pr_notice("%s detected: will not use MSI for PCIe PME signaling\n",
+                        d->ident);
+        pcie_pme_disable_msi();
+        return 0;
+}
+
+static struct dmi_system_id __initdata pcie_portdrv_dmi_table[] = {
+        /*
+         * Boxes that should not use MSI for PCIe PME signaling.
+         */
+        {
+         .callback = dmi_pcie_pme_disable_msi,
+         .ident = "MSI Wind U-100",
+         .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR,
+                                "MICRO-STAR INTERNATIONAL CO., LTD"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "U-100"),
+                     },
+         },
+         {}
+};
+
 static int __init pcie_portdrv_init(void)
 {
         int retval;
 
+        dmi_check_system(pcie_portdrv_dmi_table);
+
         retval = pcie_port_bus_register();
         if (retval) {
                 printk(KERN_WARNING "PCIE: bus_register error: %d\n", retval);
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index 446e4a94d7d3..270d069819f7 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -89,6 +89,7 @@ static void release_pcibus_dev(struct device *dev)
 
         if (pci_bus->bridge)
                 put_device(pci_bus->bridge);
+        pci_bus_remove_resources(pci_bus);
         kfree(pci_bus);
 }
 
@@ -281,26 +282,12 @@ static void pci_read_bases(struct pci_dev *dev, unsigned int howmany, int rom)
         }
 }
 
-void __devinit pci_read_bridge_bases(struct pci_bus *child)
+static void __devinit pci_read_bridge_io(struct pci_bus *child)
 {
         struct pci_dev *dev = child->self;
         u8 io_base_lo, io_limit_lo;
-        u16 mem_base_lo, mem_limit_lo;
         unsigned long base, limit;
         struct resource *res;
-        int i;
-
-        if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
-                return;
-
-        dev_info(&dev->dev, "PCI bridge to [bus %02x-%02x]%s\n",
-                 child->secondary, child->subordinate,
-                 dev->transparent ? " (subtractive decode)": "");
-
-        if (dev->transparent) {
-                for(i = 3; i < PCI_BUS_NUM_RESOURCES; i++)
-                        child->resource[i] = child->parent->resource[i - 3];
-        }
 
         res = child->resource[0];
         pci_read_config_byte(dev, PCI_IO_BASE, &io_base_lo);
@@ -316,26 +303,50 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                 limit |= (io_limit_hi << 16);
         }
 
-        if (base <= limit) {
+        if (base && base <= limit) {
                 res->flags = (io_base_lo & PCI_IO_RANGE_TYPE_MASK) | IORESOURCE_IO;
                 if (!res->start)
                         res->start = base;
                 if (!res->end)
                         res->end = limit + 0xfff;
                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
+        } else {
+                dev_printk(KERN_DEBUG, &dev->dev,
+                         "  bridge window [io  %04lx - %04lx] reg reading\n",
+                                 base, limit);
         }
+}
+
+static void __devinit pci_read_bridge_mmio(struct pci_bus *child)
+{
+        struct pci_dev *dev = child->self;
+        u16 mem_base_lo, mem_limit_lo;
+        unsigned long base, limit;
+        struct resource *res;
 
         res = child->resource[1];
         pci_read_config_word(dev, PCI_MEMORY_BASE, &mem_base_lo);
         pci_read_config_word(dev, PCI_MEMORY_LIMIT, &mem_limit_lo);
         base = (mem_base_lo & PCI_MEMORY_RANGE_MASK) << 16;
         limit = (mem_limit_lo & PCI_MEMORY_RANGE_MASK) << 16;
-        if (base <= limit) {
+        if (base && base <= limit) {
                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
                 res->start = base;
                 res->end = limit + 0xfffff;
                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
+        } else {
+                dev_printk(KERN_DEBUG, &dev->dev,
+                        "  bridge window [mem 0x%08lx - 0x%08lx] reg reading\n",
+                                         base, limit + 0xfffff);
         }
+}
+
+static void __devinit pci_read_bridge_mmio_pref(struct pci_bus *child)
+{
+        struct pci_dev *dev = child->self;
+        u16 mem_base_lo, mem_limit_lo;
+        unsigned long base, limit;
+        struct resource *res;
 
         res = child->resource[2];
         pci_read_config_word(dev, PCI_PREF_MEMORY_BASE, &mem_base_lo);
@@ -366,7 +377,7 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
 #endif
                 }
         }
-        if (base <= limit) {
+        if (base && base <= limit) {
                 res->flags = (mem_base_lo & PCI_PREF_RANGE_TYPE_MASK) |
                                          IORESOURCE_MEM | IORESOURCE_PREFETCH;
                 if (res->flags & PCI_PREF_RANGE_TYPE_64)
@@ -374,6 +385,44 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                 res->start = base;
                 res->end = limit + 0xfffff;
                 dev_printk(KERN_DEBUG, &dev->dev, "  bridge window %pR\n", res);
+        } else {
+                dev_printk(KERN_DEBUG, &dev->dev,
+                     "  bridge window [mem 0x%08lx - %08lx pref] reg reading\n",
+                                         base, limit + 0xfffff);
+        }
+}
+
+void __devinit pci_read_bridge_bases(struct pci_bus *child)
+{
+        struct pci_dev *dev = child->self;
+        struct resource *res;
+        int i;
+
+        if (pci_is_root_bus(child))     /* It's a host bus, nothing to read */
+                return;
+
+        dev_info(&dev->dev, "PCI bridge to [bus %02x-%02x]%s\n",
+                 child->secondary, child->subordinate,
+                 dev->transparent ? " (subtractive decode)" : "");
+
+        pci_bus_remove_resources(child);
+        for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++)
+                child->resource[i] = &dev->resource[PCI_BRIDGE_RESOURCES+i];
+
+        pci_read_bridge_io(child);
+        pci_read_bridge_mmio(child);
+        pci_read_bridge_mmio_pref(child);
+
+        if (dev->transparent) {
+                pci_bus_for_each_resource(child->parent, res, i) {
+                        if (res) {
+                                pci_bus_add_resource(child, res,
+                                                     PCI_SUBTRACTIVE_DECODE);
+                                dev_printk(KERN_DEBUG, &dev->dev,
+                                           "  bridge window %pR (subtractive decode)\n",
+                                           res);
+                        }
+                }
         }
 }
 
@@ -387,10 +436,147 @@ static struct pci_bus * pci_alloc_bus(void)
                 INIT_LIST_HEAD(&b->children);
                 INIT_LIST_HEAD(&b->devices);
                 INIT_LIST_HEAD(&b->slots);
+                INIT_LIST_HEAD(&b->resources);
+                b->max_bus_speed = PCI_SPEED_UNKNOWN;
+                b->cur_bus_speed = PCI_SPEED_UNKNOWN;
         }
         return b;
 }
 
+static unsigned char pcix_bus_speed[] = {
+        PCI_SPEED_UNKNOWN,              /* 0 */
+        PCI_SPEED_66MHz_PCIX,           /* 1 */
+        PCI_SPEED_100MHz_PCIX,          /* 2 */
+        PCI_SPEED_133MHz_PCIX,          /* 3 */
+        PCI_SPEED_UNKNOWN,              /* 4 */
+        PCI_SPEED_66MHz_PCIX_ECC,       /* 5 */
+        PCI_SPEED_100MHz_PCIX_ECC,      /* 6 */
+        PCI_SPEED_133MHz_PCIX_ECC,      /* 7 */
+        PCI_SPEED_UNKNOWN,              /* 8 */
+        PCI_SPEED_66MHz_PCIX_266,       /* 9 */
+        PCI_SPEED_100MHz_PCIX_266,      /* A */
+        PCI_SPEED_133MHz_PCIX_266,      /* B */
+        PCI_SPEED_UNKNOWN,              /* C */
+        PCI_SPEED_66MHz_PCIX_533,       /* D */
+        PCI_SPEED_100MHz_PCIX_533,      /* E */
+        PCI_SPEED_133MHz_PCIX_533       /* F */
+};
+
+static unsigned char pcie_link_speed[] = {
+        PCI_SPEED_UNKNOWN,              /* 0 */
+        PCIE_SPEED_2_5GT,               /* 1 */
+        PCIE_SPEED_5_0GT,               /* 2 */
+        PCIE_SPEED_8_0GT,               /* 3 */
+        PCI_SPEED_UNKNOWN,              /* 4 */
+        PCI_SPEED_UNKNOWN,              /* 5 */
+        PCI_SPEED_UNKNOWN,              /* 6 */
+        PCI_SPEED_UNKNOWN,              /* 7 */
+        PCI_SPEED_UNKNOWN,              /* 8 */
+        PCI_SPEED_UNKNOWN,              /* 9 */
+        PCI_SPEED_UNKNOWN,              /* A */
+        PCI_SPEED_UNKNOWN,              /* B */
+        PCI_SPEED_UNKNOWN,              /* C */
+        PCI_SPEED_UNKNOWN,              /* D */
+        PCI_SPEED_UNKNOWN,              /* E */
+        PCI_SPEED_UNKNOWN               /* F */
+};
+
+void pcie_update_link_speed(struct pci_bus *bus, u16 linksta)
+{
+        bus->cur_bus_speed = pcie_link_speed[linksta & 0xf];
+}
+EXPORT_SYMBOL_GPL(pcie_update_link_speed);
+
+static unsigned char agp_speeds[] = {
+        AGP_UNKNOWN,
+        AGP_1X,
+        AGP_2X,
+        AGP_4X,
+        AGP_8X
+};
+
+static enum pci_bus_speed agp_speed(int agp3, int agpstat)
+{
+        int index = 0;
+
+        if (agpstat & 4)
+                index = 3;
+        else if (agpstat & 2)
+                index = 2;
+        else if (agpstat & 1)
+                index = 1;
+        else
+                goto out;
+        
+        if (agp3) {
+                index += 2;
+                if (index == 5)
+                        index = 0;
+        }
+
+ out:
+        return agp_speeds[index];
+}
+
+
+static void pci_set_bus_speed(struct pci_bus *bus)
+{
+        struct pci_dev *bridge = bus->self;
+        int pos;
+
+        pos = pci_find_capability(bridge, PCI_CAP_ID_AGP);
+        if (!pos)
+                pos = pci_find_capability(bridge, PCI_CAP_ID_AGP3);
+        if (pos) {
+                u32 agpstat, agpcmd;
+
+                pci_read_config_dword(bridge, pos + PCI_AGP_STATUS, &agpstat);
+                bus->max_bus_speed = agp_speed(agpstat & 8, agpstat & 7);
+
+                pci_read_config_dword(bridge, pos + PCI_AGP_COMMAND, &agpcmd);
+                bus->cur_bus_speed = agp_speed(agpstat & 8, agpcmd & 7);
+        }
+
+        pos = pci_find_capability(bridge, PCI_CAP_ID_PCIX);
+        if (pos) {
+                u16 status;
+                enum pci_bus_speed max;
+                pci_read_config_word(bridge, pos + 2, &status);
+
+                if (status & 0x8000) {
+                        max = PCI_SPEED_133MHz_PCIX_533;
+                } else if (status & 0x4000) {
+                        max = PCI_SPEED_133MHz_PCIX_266;
+                } else if (status & 0x0002) {
+                        if (((status >> 12) & 0x3) == 2) {
+                                max = PCI_SPEED_133MHz_PCIX_ECC;
+                        } else {
+                                max = PCI_SPEED_133MHz_PCIX;
+                        }
+                } else {
+                        max = PCI_SPEED_66MHz_PCIX;
+                }
+
+                bus->max_bus_speed = max;
+                bus->cur_bus_speed = pcix_bus_speed[(status >> 6) & 0xf];
+
+                return;
+        }
+
+        pos = pci_find_capability(bridge, PCI_CAP_ID_EXP);
+        if (pos) {
+                u32 linkcap;
+                u16 linksta;
+
+                pci_read_config_dword(bridge, pos + PCI_EXP_LNKCAP, &linkcap);
+                bus->max_bus_speed = pcie_link_speed[linkcap & 0xf];
+
+                pci_read_config_word(bridge, pos + PCI_EXP_LNKSTA, &linksta);
+                pcie_update_link_speed(bus, linksta);
+        }
+}
+
+
 static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
                                            struct pci_dev *bridge, int busnr)
 {
@@ -430,6 +616,8 @@ static struct pci_bus *pci_alloc_child_bus(struct pci_bus *parent,
         child->self = bridge;
         child->bridge = get_device(&bridge->dev);
 
+        pci_set_bus_speed(child);
+
         /* Set up default resource pointers and names.. */
         for (i = 0; i < PCI_BRIDGE_RESOURCE_NUM; i++) {
                 child->resource[i] = &bridge->resource[PCI_BRIDGE_RESOURCES+i];
@@ -1081,6 +1269,45 @@ struct pci_dev *__ref pci_scan_single_device(struct pci_bus *bus, int devfn)
 }
 EXPORT_SYMBOL(pci_scan_single_device);
 
+static unsigned next_ari_fn(struct pci_dev *dev, unsigned fn)
+{
+        u16 cap;
+        unsigned pos, next_fn;
+
+        if (!dev)
+                return 0;
+
+        pos = pci_find_ext_capability(dev, PCI_EXT_CAP_ID_ARI);
+        if (!pos)
+                return 0;
+        pci_read_config_word(dev, pos + 4, &cap);
+        next_fn = cap >> 8;
+        if (next_fn <= fn)
+                return 0;
+        return next_fn;
+}
+
+static unsigned next_trad_fn(struct pci_dev *dev, unsigned fn)
+{
+        return (fn + 1) % 8;
+}
+
+static unsigned no_next_fn(struct pci_dev *dev, unsigned fn)
+{
+        return 0;
+}
+
+static int only_one_child(struct pci_bus *bus)
+{
+        struct pci_dev *parent = bus->self;
+        if (!parent || !pci_is_pcie(parent))
+                return 0;
+        if (parent->pcie_type == PCI_EXP_TYPE_ROOT_PORT ||
+            parent->pcie_type == PCI_EXP_TYPE_DOWNSTREAM)
+                return 1;
+        return 0;
+}
+
 /**
  * pci_scan_slot - scan a PCI slot on a bus for devices.
  * @bus: PCI bus to scan
@@ -1094,21 +1321,30 @@ EXPORT_SYMBOL(pci_scan_single_device);
  */
 int pci_scan_slot(struct pci_bus *bus, int devfn)
 {
-        int fn, nr = 0;
+        unsigned fn, nr = 0;
         struct pci_dev *dev;
+        unsigned (*next_fn)(struct pci_dev *, unsigned) = no_next_fn;
+
+        if (only_one_child(bus) && (devfn > 0))
+                return 0; /* Already scanned the entire slot */
 
         dev = pci_scan_single_device(bus, devfn);
-        if (dev && !dev->is_added)      /* new device? */
+        if (!dev)
+                return 0;
+        if (!dev->is_added)
                 nr++;
 
-        if (dev && dev->multifunction) {
-                for (fn = 1; fn < 8; fn++) {
-                        dev = pci_scan_single_device(bus, devfn + fn);
-                        if (dev) {
-                                if (!dev->is_added)
-                                        nr++;
-                                dev->multifunction = 1;
-                        }
+        if (pci_ari_enabled(bus))
+                next_fn = next_ari_fn;
+        else if (dev->multifunction)
+                next_fn = next_trad_fn;
+
+        for (fn = next_fn(dev, 0); fn > 0; fn = next_fn(dev, fn)) {
+                dev = pci_scan_single_device(bus, devfn + fn);
+                if (dev) {
+                        if (!dev->is_added)
+                                nr++;
+                        dev->multifunction = 1;
                 }
         }
 
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index d58b94030ef3..790eb69a4aa9 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -25,14 +25,9 @@
 #include <linux/dmi.h>
 #include <linux/pci-aspm.h>
 #include <linux/ioport.h>
+#include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include "pci.h"
 
-int isa_dma_bridge_buggy;
-EXPORT_SYMBOL(isa_dma_bridge_buggy);
-int pci_pci_problems;
-EXPORT_SYMBOL(pci_pci_problems);
-
-#ifdef CONFIG_PCI_QUIRKS
 /*
  * This quirk function disables memory decoding and releases memory resources
  * of the device specified by kernel's boot parameter 'pci=resource_alignment='.
@@ -2612,6 +2607,7 @@ void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev)
         }
         pci_do_fixups(dev, start, end);
 }
+EXPORT_SYMBOL(pci_fixup_device);
 
 static int __init pci_apply_final_quirks(void)
 {
@@ -2723,9 +2719,3 @@ int pci_dev_specific_reset(struct pci_dev *dev, int probe)
 
         return -ENOTTY;
 }
-
-#else
-void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev) {}
-int pci_dev_specific_reset(struct pci_dev *dev, int probe) { return -ENOTTY; }
-#endif
-EXPORT_SYMBOL(pci_fixup_device);
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index c48cd377b3f5..bf32f07c4efb 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -27,37 +27,83 @@
 #include <linux/slab.h>
 #include "pci.h"
 
-static void pbus_assign_resources_sorted(const struct pci_bus *bus)
-{
-        struct pci_dev *dev;
+struct resource_list_x {
+        struct resource_list_x *next;
         struct resource *res;
-        struct resource_list head, *list, *tmp;
-        int idx;
+        struct pci_dev *dev;
+        resource_size_t start;
+        resource_size_t end;
+        unsigned long flags;
+};
 
-        head.next = NULL;
-        list_for_each_entry(dev, &bus->devices, bus_list) {
-                u16 class = dev->class >> 8;
+static void add_to_failed_list(struct resource_list_x *head,
+                                 struct pci_dev *dev, struct resource *res)
+{
+        struct resource_list_x *list = head;
+        struct resource_list_x *ln = list->next;
+        struct resource_list_x *tmp;
 
-                /* Don't touch classless devices or host bridges or ioapics.  */
-                if (class == PCI_CLASS_NOT_DEFINED ||
-                    class == PCI_CLASS_BRIDGE_HOST)
-                        continue;
+        tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
+        if (!tmp) {
+                pr_warning("add_to_failed_list: kmalloc() failed!\n");
+                return;
+        }
 
-                /* Don't touch ioapic devices already enabled by firmware */
-                if (class == PCI_CLASS_SYSTEM_PIC) {
-                        u16 command;
-                        pci_read_config_word(dev, PCI_COMMAND, &command);
-                        if (command & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY))
-                                continue;
-                }
+        tmp->next = ln;
+        tmp->res = res;
+        tmp->dev = dev;
+        tmp->start = res->start;
+        tmp->end = res->end;
+        tmp->flags = res->flags;
+        list->next = tmp;
+}
+
+static void free_failed_list(struct resource_list_x *head)
+{
+        struct resource_list_x *list, *tmp;
 
-                pdev_sort_resources(dev, &head);
+        for (list = head->next; list;) {
+                tmp = list;
+                list = list->next;
+                kfree(tmp);
         }
 
-        for (list = head.next; list;) {
+        head->next = NULL;
+}
+
+static void __dev_sort_resources(struct pci_dev *dev,
+                                 struct resource_list *head)
+{
+        u16 class = dev->class >> 8;
+
+        /* Don't touch classless devices or host bridges or ioapics.  */
+        if (class == PCI_CLASS_NOT_DEFINED || class == PCI_CLASS_BRIDGE_HOST)
+                return;
+
+        /* Don't touch ioapic devices already enabled by firmware */
+        if (class == PCI_CLASS_SYSTEM_PIC) {
+                u16 command;
+                pci_read_config_word(dev, PCI_COMMAND, &command);
+                if (command & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY))
+                        return;
+        }
+
+        pdev_sort_resources(dev, head);
+}
+
+static void __assign_resources_sorted(struct resource_list *head,
+                                 struct resource_list_x *fail_head)
+{
+        struct resource *res;
+        struct resource_list *list, *tmp;
+        int idx;
+
+        for (list = head->next; list;) {
                 res = list->res;
                 idx = res - &list->dev->resource[0];
                 if (pci_assign_resource(list->dev, idx)) {
+                        if (fail_head && !pci_is_root_bus(list->dev->bus))
+                                add_to_failed_list(fail_head, list->dev, res);
                         res->start = 0;
                         res->end = 0;
                         res->flags = 0;
@@ -68,6 +114,30 @@ static void pbus_assign_resources_sorted(const struct pci_bus *bus)
         }
 }
 
+static void pdev_assign_resources_sorted(struct pci_dev *dev,
+                                 struct resource_list_x *fail_head)
+{
+        struct resource_list head;
+
+        head.next = NULL;
+        __dev_sort_resources(dev, &head);
+        __assign_resources_sorted(&head, fail_head);
+
+}
+
+static void pbus_assign_resources_sorted(const struct pci_bus *bus,
+                                         struct resource_list_x *fail_head)
+{
+        struct pci_dev *dev;
+        struct resource_list head;
+
+        head.next = NULL;
+        list_for_each_entry(dev, &bus->devices, bus_list)
+                __dev_sort_resources(dev, &head);
+
+        __assign_resources_sorted(&head, fail_head);
+}
+
 void pci_setup_cardbus(struct pci_bus *bus)
 {
         struct pci_dev *bridge = bus->self;
@@ -134,18 +204,12 @@ EXPORT_SYMBOL(pci_setup_cardbus);
    config space writes, so it's quite possible that an I/O window of
    the bridge will have some undesirable address (e.g. 0) after the
    first write. Ditto 64-bit prefetchable MMIO.  */
-static void pci_setup_bridge(struct pci_bus *bus)
+static void pci_setup_bridge_io(struct pci_bus *bus)
 {
         struct pci_dev *bridge = bus->self;
         struct resource *res;
         struct pci_bus_region region;
-        u32 l, bu, lu, io_upper16;
-
-        if (pci_is_enabled(bridge))
-                return;
-
-        dev_info(&bridge->dev, "PCI bridge to [bus %02x-%02x]\n",
-                 bus->secondary, bus->subordinate);
+        u32 l, io_upper16;
 
         /* Set up the top and bottom of the PCI I/O segment for this bus. */
         res = bus->resource[0];
@@ -158,8 +222,7 @@ static void pci_setup_bridge(struct pci_bus *bus)
                 /* Set up upper 16 bits of I/O base/limit. */
                 io_upper16 = (region.end & 0xffff0000) | (region.start >> 16);
                 dev_info(&bridge->dev, "  bridge window %pR\n", res);
-        }
-        else {
+        } else {
                 /* Clear upper 16 bits of I/O base/limit. */
                 io_upper16 = 0;
                 l = 0x00f0;
@@ -171,21 +234,35 @@ static void pci_setup_bridge(struct pci_bus *bus)
         pci_write_config_dword(bridge, PCI_IO_BASE, l);
         /* Update upper 16 bits of I/O base/limit. */
         pci_write_config_dword(bridge, PCI_IO_BASE_UPPER16, io_upper16);
+}
 
-        /* Set up the top and bottom of the PCI Memory segment
-           for this bus. */
+static void pci_setup_bridge_mmio(struct pci_bus *bus)
+{
+        struct pci_dev *bridge = bus->self;
+        struct resource *res;
+        struct pci_bus_region region;
+        u32 l;
+
+        /* Set up the top and bottom of the PCI Memory segment for this bus. */
         res = bus->resource[1];
         pcibios_resource_to_bus(bridge, &region, res);
         if (res->flags & IORESOURCE_MEM) {
                 l = (region.start >> 16) & 0xfff0;
                 l |= region.end & 0xfff00000;
                 dev_info(&bridge->dev, "  bridge window %pR\n", res);
-        }
-        else {
+        } else {
                 l = 0x0000fff0;
                 dev_info(&bridge->dev, "  bridge window [mem disabled]\n");
         }
         pci_write_config_dword(bridge, PCI_MEMORY_BASE, l);
+}
+
+static void pci_setup_bridge_mmio_pref(struct pci_bus *bus)
+{
+        struct pci_dev *bridge = bus->self;
+        struct resource *res;
+        struct pci_bus_region region;
+        u32 l, bu, lu;
 
         /* Clear out the upper 32 bits of PREF limit.
            If PCI_PREF_BASE_UPPER32 was non-zero, this temporarily
@@ -204,8 +281,7 @@ static void pci_setup_bridge(struct pci_bus *bus)
                         lu = upper_32_bits(region.end);
                 }
                 dev_info(&bridge->dev, "  bridge window %pR\n", res);
-        }
-        else {
+        } else {
                 l = 0x0000fff0;
                 dev_info(&bridge->dev, "  bridge window [mem pref disabled]\n");
         }
@@ -214,10 +290,35 @@ static void pci_setup_bridge(struct pci_bus *bus)
         /* Set the upper 32 bits of PREF base & limit. */
         pci_write_config_dword(bridge, PCI_PREF_BASE_UPPER32, bu);
         pci_write_config_dword(bridge, PCI_PREF_LIMIT_UPPER32, lu);
+}
+
+static void __pci_setup_bridge(struct pci_bus *bus, unsigned long type)
+{
+        struct pci_dev *bridge = bus->self;
+
+        dev_info(&bridge->dev, "PCI bridge to [bus %02x-%02x]\n",
+                 bus->secondary, bus->subordinate);
+
+        if (type & IORESOURCE_IO)
+                pci_setup_bridge_io(bus);
+
+        if (type & IORESOURCE_MEM)
+                pci_setup_bridge_mmio(bus);
+
+        if (type & IORESOURCE_PREFETCH)
+                pci_setup_bridge_mmio_pref(bus);
 
         pci_write_config_word(bridge, PCI_BRIDGE_CONTROL, bus->bridge_ctl);
 }
 
+static void pci_setup_bridge(struct pci_bus *bus)
+{
+        unsigned long type = IORESOURCE_IO | IORESOURCE_MEM |
+                                  IORESOURCE_PREFETCH;
+
+        __pci_setup_bridge(bus, type);
+}
+
 /* Check whether the bridge supports optional I/O and
    prefetchable memory ranges. If not, the respective
    base/limit registers must be read-only and read as 0. */
@@ -253,8 +354,11 @@ static void pci_bridge_check_ranges(struct pci_bus *bus)
         }
         if (pmem) {
                 b_res[2].flags |= IORESOURCE_MEM | IORESOURCE_PREFETCH;
-                if ((pmem & PCI_PREF_RANGE_TYPE_MASK) == PCI_PREF_RANGE_TYPE_64)
+                if ((pmem & PCI_PREF_RANGE_TYPE_MASK) ==
+                    PCI_PREF_RANGE_TYPE_64) {
                         b_res[2].flags |= IORESOURCE_MEM_64;
+                        b_res[2].flags |= PCI_PREF_RANGE_TYPE_64;
+                }
         }
 
         /* double check if bridge does support 64 bit pref */
@@ -283,8 +387,7 @@ static struct resource *find_free_bus_resource(struct pci_bus *bus, unsigned lon
         unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
                                   IORESOURCE_PREFETCH;
 
-        for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
-                r = bus->resource[i];
+        pci_bus_for_each_resource(bus, r, i) {
                 if (r == &ioport_resource || r == &iomem_resource)
                         continue;
                 if (r && (r->flags & type_mask) == type && !r->parent)
@@ -301,7 +404,7 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size)
 {
         struct pci_dev *dev;
         struct resource *b_res = find_free_bus_resource(bus, IORESOURCE_IO);
-        unsigned long size = 0, size1 = 0;
+        unsigned long size = 0, size1 = 0, old_size;
 
         if (!b_res)
                 return;
@@ -326,12 +429,17 @@ static void pbus_size_io(struct pci_bus *bus, resource_size_t min_size)
         }
         if (size < min_size)
                 size = min_size;
+        old_size = resource_size(b_res);
+        if (old_size == 1)
+                old_size = 0;
 /* To be fixed in 2.5: we should have sort of HAVE_ISA
    flag in the struct pci_bus. */
 #if defined(CONFIG_ISA) || defined(CONFIG_EISA)
         size = (size & 0xff) + ((size & ~0xffUL) << 2);
 #endif
         size = ALIGN(size + size1, 4096);
+        if (size < old_size)
+                size = old_size;
         if (!size) {
                 if (b_res->start || b_res->end)
                         dev_info(&bus->self->dev, "disabling bridge window "
@@ -352,7 +460,7 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
                          unsigned long type, resource_size_t min_size)
 {
         struct pci_dev *dev;
-        resource_size_t min_align, align, size;
+        resource_size_t min_align, align, size, old_size;
         resource_size_t aligns[12];     /* Alignments from 1Mb to 2Gb */
         int order, max_order;
         struct resource *b_res = find_free_bus_resource(bus, type);
@@ -402,6 +510,11 @@ static int pbus_size_mem(struct pci_bus *bus, unsigned long mask,
         }
         if (size < min_size)
                 size = min_size;
+        old_size = resource_size(b_res);
+        if (old_size == 1)
+                old_size = 0;
+        if (size < old_size)
+                size = old_size;
 
         align = 0;
         min_align = 0;
@@ -538,23 +651,25 @@ void __ref pci_bus_size_bridges(struct pci_bus *bus)
 }
 EXPORT_SYMBOL(pci_bus_size_bridges);
 
-void __ref pci_bus_assign_resources(const struct pci_bus *bus)
+static void __ref __pci_bus_assign_resources(const struct pci_bus *bus,
+                                         struct resource_list_x *fail_head)
 {
         struct pci_bus *b;
         struct pci_dev *dev;
 
-        pbus_assign_resources_sorted(bus);
+        pbus_assign_resources_sorted(bus, fail_head);
 
         list_for_each_entry(dev, &bus->devices, bus_list) {
                 b = dev->subordinate;
                 if (!b)
                         continue;
 
-                pci_bus_assign_resources(b);
+                __pci_bus_assign_resources(b, fail_head);
 
                 switch (dev->class >> 8) {
                 case PCI_CLASS_BRIDGE_PCI:
-                        pci_setup_bridge(b);
+                        if (!pci_is_enabled(dev))
+                                pci_setup_bridge(b);
                         break;
 
                 case PCI_CLASS_BRIDGE_CARDBUS:
@@ -568,15 +683,130 @@ void __ref pci_bus_assign_resources(const struct pci_bus *bus)
                 }
         }
 }
+
+void __ref pci_bus_assign_resources(const struct pci_bus *bus)
+{
+        __pci_bus_assign_resources(bus, NULL);
+}
 EXPORT_SYMBOL(pci_bus_assign_resources);
 
+static void __ref __pci_bridge_assign_resources(const struct pci_dev *bridge,
+                                         struct resource_list_x *fail_head)
+{
+        struct pci_bus *b;
+
+        pdev_assign_resources_sorted((struct pci_dev *)bridge, fail_head);
+
+        b = bridge->subordinate;
+        if (!b)
+                return;
+
+        __pci_bus_assign_resources(b, fail_head);
+
+        switch (bridge->class >> 8) {
+        case PCI_CLASS_BRIDGE_PCI:
+                pci_setup_bridge(b);
+                break;
+
+        case PCI_CLASS_BRIDGE_CARDBUS:
+                pci_setup_cardbus(b);
+                break;
+
+        default:
+                dev_info(&bridge->dev, "not setting up bridge for bus "
+                         "%04x:%02x\n", pci_domain_nr(b), b->number);
+                break;
+        }
+}
+static void pci_bridge_release_resources(struct pci_bus *bus,
+                                          unsigned long type)
+{
+        int idx;
+        bool changed = false;
+        struct pci_dev *dev;
+        struct resource *r;
+        unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
+                                  IORESOURCE_PREFETCH;
+
+        dev = bus->self;
+        for (idx = PCI_BRIDGE_RESOURCES; idx <= PCI_BRIDGE_RESOURCE_END;
+             idx++) {
+                r = &dev->resource[idx];
+                if ((r->flags & type_mask) != type)
+                        continue;
+                if (!r->parent)
+                        continue;
+                /*
+                 * if there are children under that, we should release them
+                 *  all
+                 */
+                release_child_resources(r);
+                if (!release_resource(r)) {
+                        dev_printk(KERN_DEBUG, &dev->dev,
+                                 "resource %d %pR released\n", idx, r);
+                        /* keep the old size */
+                        r->end = resource_size(r) - 1;
+                        r->start = 0;
+                        r->flags = 0;
+                        changed = true;
+                }
+        }
+
+        if (changed) {
+                /* avoiding touch the one without PREF */
+                if (type & IORESOURCE_PREFETCH)
+                        type = IORESOURCE_PREFETCH;
+                __pci_setup_bridge(bus, type);
+        }
+}
+
+enum release_type {
+        leaf_only,
+        whole_subtree,
+};
+/*
+ * try to release pci bridge resources that is from leaf bridge,
+ * so we can allocate big new one later
+ */
+static void __ref pci_bus_release_bridge_resources(struct pci_bus *bus,
+                                                   unsigned long type,
+                                                   enum release_type rel_type)
+{
+        struct pci_dev *dev;
+        bool is_leaf_bridge = true;
+
+        list_for_each_entry(dev, &bus->devices, bus_list) {
+                struct pci_bus *b = dev->subordinate;
+                if (!b)
+                        continue;
+
+                is_leaf_bridge = false;
+
+                if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI)
+                        continue;
+
+                if (rel_type == whole_subtree)
+                        pci_bus_release_bridge_resources(b, type,
+                                                 whole_subtree);
+        }
+
+        if (pci_is_root_bus(bus))
+                return;
+
+        if ((bus->self->class >> 8) != PCI_CLASS_BRIDGE_PCI)
+                return;
+
+        if ((rel_type == whole_subtree) || is_leaf_bridge)
+                pci_bridge_release_resources(bus, type);
+}
+
 static void pci_bus_dump_res(struct pci_bus *bus)
 {
-        int i;
+        struct resource *res;
+        int i;
 
-        for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
-                struct resource *res = bus->resource[i];
-                if (!res || !res->end)
+        pci_bus_for_each_resource(bus, res, i) {
+                if (!res || !res->end || !res->flags)
                         continue;
 
                 dev_printk(KERN_DEBUG, &bus->dev, "resource %d %pR\n", i, res);
@@ -600,11 +830,65 @@ static void pci_bus_dump_resources(struct pci_bus *bus)
         }
 }
 
+static int __init pci_bus_get_depth(struct pci_bus *bus)
+{
+        int depth = 0;
+        struct pci_dev *dev;
+
+        list_for_each_entry(dev, &bus->devices, bus_list) {
+                int ret;
+                struct pci_bus *b = dev->subordinate;
+                if (!b)
+                        continue;
+
+                ret = pci_bus_get_depth(b);
+                if (ret + 1 > depth)
+                        depth = ret + 1;
+        }
+
+        return depth;
+}
+static int __init pci_get_max_depth(void)
+{
+        int depth = 0;
+        struct pci_bus *bus;
+
+        list_for_each_entry(bus, &pci_root_buses, node) {
+                int ret;
+
+                ret = pci_bus_get_depth(bus);
+                if (ret > depth)
+                        depth = ret;
+        }
+
+        return depth;
+}
+
+/*
+ * first try will not touch pci bridge res
+ * second  and later try will clear small leaf bridge res
+ * will stop till to the max  deepth if can not find good one
+ */
 void __init
 pci_assign_unassigned_resources(void)
 {
         struct pci_bus *bus;
+        int tried_times = 0;
+        enum release_type rel_type = leaf_only;
+        struct resource_list_x head, *list;
+        unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
+                                  IORESOURCE_PREFETCH;
+        unsigned long failed_type;
+        int max_depth = pci_get_max_depth();
+        int pci_try_num;
 
+        head.next = NULL;
+
+        pci_try_num = max_depth + 1;
+        printk(KERN_DEBUG "PCI: max bus depth: %d pci_try_num: %d\n",
+                 max_depth, pci_try_num);
+
+again:
         /* Depth first, calculate sizes and alignments of all
            subordinate buses. */
         list_for_each_entry(bus, &pci_root_buses, node) {
@@ -612,12 +896,130 @@ pci_assign_unassigned_resources(void)
         }
         /* Depth last, allocate resources and update the hardware. */
         list_for_each_entry(bus, &pci_root_buses, node) {
-                pci_bus_assign_resources(bus);
-                pci_enable_bridges(bus);
+                __pci_bus_assign_resources(bus, &head);
         }
+        tried_times++;
+
+        /* any device complain? */
+        if (!head.next)
+                goto enable_and_dump;
+        failed_type = 0;
+        for (list = head.next; list;) {
+                failed_type |= list->flags;
+                list = list->next;
+        }
+        /*
+         * io port are tight, don't try extra
+         * or if reach the limit, don't want to try more
+         */
+        failed_type &= type_mask;
+        if ((failed_type == IORESOURCE_IO) || (tried_times >= pci_try_num)) {
+                free_failed_list(&head);
+                goto enable_and_dump;
+        }
+
+        printk(KERN_DEBUG "PCI: No. %d try to assign unassigned res\n",
+                         tried_times + 1);
+
+        /* third times and later will not check if it is leaf */
+        if ((tried_times + 1) > 2)
+                rel_type = whole_subtree;
+
+        /*
+         * Try to release leaf bridge's resources that doesn't fit resource of
+         * child device under that bridge
+         */
+        for (list = head.next; list;) {
+                bus = list->dev->bus;
+                pci_bus_release_bridge_resources(bus, list->flags & type_mask,
+                                                  rel_type);
+                list = list->next;
+        }
+        /* restore size and flags */
+        for (list = head.next; list;) {
+                struct resource *res = list->res;
+
+                res->start = list->start;
+                res->end = list->end;
+                res->flags = list->flags;
+                if (list->dev->subordinate)
+                        res->flags = 0;
+
+                list = list->next;
+        }
+        free_failed_list(&head);
+
+        goto again;
+
+enable_and_dump:
+        /* Depth last, update the hardware. */
+        list_for_each_entry(bus, &pci_root_buses, node)
+                pci_enable_bridges(bus);
 
         /* dump the resource on buses */
         list_for_each_entry(bus, &pci_root_buses, node) {
                 pci_bus_dump_resources(bus);
         }
 }
+
+void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge)
+{
+        struct pci_bus *parent = bridge->subordinate;
+        int tried_times = 0;
+        struct resource_list_x head, *list;
+        int retval;
+        unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM |
+                                  IORESOURCE_PREFETCH;
+
+        head.next = NULL;
+
+again:
+        pci_bus_size_bridges(parent);
+        __pci_bridge_assign_resources(bridge, &head);
+        retval = pci_reenable_device(bridge);
+        pci_set_master(bridge);
+        pci_enable_bridges(parent);
+
+        tried_times++;
+
+        if (!head.next)
+                return;
+
+        if (tried_times >= 2) {
+                /* still fail, don't need to try more */
+                free_failed_list(&head);
+                return;
+        }
+
+        printk(KERN_DEBUG "PCI: No. %d try to assign unassigned res\n",
+                         tried_times + 1);
+
+        /*
+         * Try to release leaf bridge's resources that doesn't fit resource of
+         * child device under that bridge
+         */
+        for (list = head.next; list;) {
+                struct pci_bus *bus = list->dev->bus;
+                unsigned long flags = list->flags;
+
+                pci_bus_release_bridge_resources(bus, flags & type_mask,
+                                                 whole_subtree);
+                list = list->next;
+        }
+        /* restore size and flags */
+        for (list = head.next; list;) {
+                struct resource *res = list->res;
+
+                res->start = list->start;
+                res->end = list->end;
+                res->flags = list->flags;
+                if (list->dev->subordinate)
+                        res->flags = 0;
+
+                list = list->next;
+        }
+        free_failed_list(&head);
+
+        goto again;
+}
+EXPORT_SYMBOL_GPL(pci_assign_unassigned_bridge_resources);
diff --git a/drivers/pci/slot.c b/drivers/pci/slot.c
index 8c02b6c53bdb..49c9e6c9779a 100644
--- a/drivers/pci/slot.c
+++ b/drivers/pci/slot.c
@@ -47,6 +47,55 @@ static ssize_t address_read_file(struct pci_slot *slot, char *buf)
                                 slot->number);
 }
 
+/* these strings match up with the values in pci_bus_speed */
+static char *pci_bus_speed_strings[] = {
+        "33 MHz PCI",           /* 0x00 */
+        "66 MHz PCI",           /* 0x01 */
+        "66 MHz PCI-X",         /* 0x02 */
+        "100 MHz PCI-X",        /* 0x03 */
+        "133 MHz PCI-X",        /* 0x04 */
+        NULL,                   /* 0x05 */
+        NULL,                   /* 0x06 */
+        NULL,                   /* 0x07 */
+        NULL,                   /* 0x08 */
+        "66 MHz PCI-X 266",     /* 0x09 */
+        "100 MHz PCI-X 266",    /* 0x0a */
+        "133 MHz PCI-X 266",    /* 0x0b */
+        "Unknown AGP",          /* 0x0c */
+        "1x AGP",               /* 0x0d */
+        "2x AGP",               /* 0x0e */
+        "4x AGP",               /* 0x0f */
+        "8x AGP",               /* 0x10 */
+        "66 MHz PCI-X 533",     /* 0x11 */
+        "100 MHz PCI-X 533",    /* 0x12 */
+        "133 MHz PCI-X 533",    /* 0x13 */
+        "2.5 GT/s PCIe",        /* 0x14 */
+        "5.0 GT/s PCIe",        /* 0x15 */
+        "8.0 GT/s PCIe",        /* 0x16 */
+};
+
+static ssize_t bus_speed_read(enum pci_bus_speed speed, char *buf)
+{
+        const char *speed_string;
+
+        if (speed < ARRAY_SIZE(pci_bus_speed_strings))
+                speed_string = pci_bus_speed_strings[speed];
+        else
+                speed_string = "Unknown";
+
+        return sprintf(buf, "%s\n", speed_string);
+}
+
+static ssize_t max_speed_read_file(struct pci_slot *slot, char *buf)
+{
+        return bus_speed_read(slot->bus->max_bus_speed, buf);
+}
+
+static ssize_t cur_speed_read_file(struct pci_slot *slot, char *buf)
+{
+        return bus_speed_read(slot->bus->cur_bus_speed, buf);
+}
+
 static void pci_slot_release(struct kobject *kobj)
 {
         struct pci_dev *dev;
@@ -66,9 +115,15 @@ static void pci_slot_release(struct kobject *kobj)
 
 static struct pci_slot_attribute pci_slot_attr_address =
         __ATTR(address, (S_IFREG | S_IRUGO), address_read_file, NULL);
+static struct pci_slot_attribute pci_slot_attr_max_speed =
+        __ATTR(max_bus_speed, (S_IFREG | S_IRUGO), max_speed_read_file, NULL);
+static struct pci_slot_attribute pci_slot_attr_cur_speed =
+        __ATTR(cur_bus_speed, (S_IFREG | S_IRUGO), cur_speed_read_file, NULL);
 
 static struct attribute *pci_slot_default_attrs[] = {
         &pci_slot_attr_address.attr,
+        &pci_slot_attr_max_speed.attr,
+        &pci_slot_attr_cur_speed.attr,
         NULL,
 };
 
diff --git a/drivers/pcmcia/rsrc_mgr.c b/drivers/pcmcia/rsrc_mgr.c
index 52db17263d8b..f8401a0ef89b 100644
--- a/drivers/pcmcia/rsrc_mgr.c
+++ b/drivers/pcmcia/rsrc_mgr.c
@@ -114,22 +114,21 @@ struct pcmcia_align_data {
         unsigned long   offset;
 };
 
-static void pcmcia_align(void *align_data, struct resource *res,
-                        unsigned long size, unsigned long align)
+static resource_size_t pcmcia_align(void *align_data,
+                                const struct resource *res,
+                                resource_size_t size, resource_size_t align)
 {
         struct pcmcia_align_data *data = align_data;
-        unsigned long start;
+        resource_size_t start;
 
         start = (res->start & ~data->mask) + data->offset;
         if (start < res->start)
                 start += data->mask + 1;
-        res->start = start;
 
 #ifdef CONFIG_X86
         if (res->flags & IORESOURCE_IO) {
                 if (start & 0x300) {
                         start = (start + 0x3ff) & ~0x3ff;
-                        res->start = start;
                 }
         }
 #endif
@@ -137,9 +136,11 @@ static void pcmcia_align(void *align_data, struct resource *res,
 #ifdef CONFIG_M68K
         if (res->flags & IORESOURCE_IO) {
                 if ((res->start + size - 1) >= 1024)
-                        res->start = res->end;
+                        start = res->end;
         }
 #endif
+
+        return start;
 }
 
 
diff --git a/drivers/pcmcia/rsrc_nonstatic.c b/drivers/pcmcia/rsrc_nonstatic.c
index 9b0dc433a8c3..c67638fe6914 100644
--- a/drivers/pcmcia/rsrc_nonstatic.c
+++ b/drivers/pcmcia/rsrc_nonstatic.c
@@ -533,8 +533,8 @@ struct pcmcia_align_data {
         struct resource_map     *map;
 };
 
-static void
-pcmcia_common_align(void *align_data, struct resource *res,
+static resource_size_t
+pcmcia_common_align(void *align_data, const struct resource *res,
                         resource_size_t size, resource_size_t align)
 {
         struct pcmcia_align_data *data = align_data;
@@ -545,17 +545,18 @@ pcmcia_common_align(void *align_data, struct resource *res,
         start = (res->start & ~data->mask) + data->offset;
         if (start < res->start)
                 start += data->mask + 1;
-        res->start = start;
+        return start;
 }
 
-static void
-pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
-                resource_size_t align)
+static resource_size_t
+pcmcia_align(void *align_data, const struct resource *res,
+        resource_size_t size, resource_size_t align)
 {
         struct pcmcia_align_data *data = align_data;
         struct resource_map *m;
+        resource_size_t start;
 
-        pcmcia_common_align(data, res, size, align);
+        start = pcmcia_common_align(data, res, size, align);
 
         for (m = data->map->next; m != data->map; m = m->next) {
                 unsigned long start = m->base;
@@ -567,8 +568,7 @@ pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
                  * fit here.
                  */
                 if (res->start < start) {
-                        res->start = start;
-                        pcmcia_common_align(data, res, size, align);
+                        start = pcmcia_common_align(data, res, size, align);
                 }
 
                 /*
@@ -586,7 +586,9 @@ pcmcia_align(void *align_data, struct resource *res, resource_size_t size,
          * If we failed to find something suitable, ensure we fail.
          */
         if (m == data->map)
-                res->start = res->end;
+                start = res->end;
+
+        return start;
 }
 
 /*
@@ -801,8 +803,7 @@ static int nonstatic_autoadd_resources(struct pcmcia_socket *s)
                 return -EINVAL;
 #endif
 
-        for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
-                res = s->cb_dev->bus->resource[i];
+        pci_bus_for_each_resource(s->cb_dev->bus, res, i) {
                 if (!res)
                         continue;
 
diff --git a/drivers/pcmcia/yenta_socket.c b/drivers/pcmcia/yenta_socket.c
index e4d12acdd525..1f2039d5e966 100644
--- a/drivers/pcmcia/yenta_socket.c
+++ b/drivers/pcmcia/yenta_socket.c
@@ -649,9 +649,10 @@ static int yenta_search_one_res(struct resource *root, struct resource *res,
 static int yenta_search_res(struct yenta_socket *socket, struct resource *res,
                             u32 min)
 {
+        struct resource *root;
         int i;
-        for (i = 0; i < PCI_BUS_NUM_RESOURCES; i++) {
-                struct resource *root = socket->dev->bus->resource[i];
+
+        pci_bus_for_each_resource(socket->dev->bus, root, i) {
                 if (!root)
                         continue;
 
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index 07d14dfdf0b4..226b3e93498c 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -934,7 +934,7 @@ static int __devinit acer_backlight_init(struct device *dev)
         acer_backlight_device = bd;
 
         bd->props.power = FB_BLANK_UNBLANK;
-        bd->props.brightness = max_brightness;
+        bd->props.brightness = read_brightness(bd);
         bd->props.max_brightness = max_brightness;
         backlight_update_status(bd);
         return 0;
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index e67e4feb35cb..eb603f1d55ca 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -5771,7 +5771,7 @@ static void thermal_exit(void)
         case TPACPI_THERMAL_ACPI_TMP07:
         case TPACPI_THERMAL_ACPI_UPDT:
                 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj,
-                                   &thermal_temp_input16_group);
+                                   &thermal_temp_input8_group);
                 break;
         case TPACPI_THERMAL_NONE:
         default:
diff --git a/drivers/sbus/char/openprom.c b/drivers/sbus/char/openprom.c
index 75ac19b1192f..fc2f676e984d 100644
--- a/drivers/sbus/char/openprom.c
+++ b/drivers/sbus/char/openprom.c
@@ -233,7 +233,7 @@ static int opromnext(void __user *argp, unsigned int cmd, struct device_node *dp
 
         ph = 0;
         if (dp)
-                ph = dp->node;
+                ph = dp->phandle;
 
         data->current_node = dp;
         *((int *) op->oprom_array) = ph;
@@ -256,7 +256,7 @@ static int oprompci2node(void __user *argp, struct device_node *dp, struct openp
 
                 dp = pci_device_to_OF_node(pdev);
                 data->current_node = dp;
-                *((int *)op->oprom_array) = dp->node;
+                *((int *)op->oprom_array) = dp->phandle;
                 op->oprom_size = sizeof(int);
                 err = copyout(argp, op, bufsize + sizeof(int));
 
@@ -273,7 +273,7 @@ static int oprompath2node(void __user *argp, struct device_node *dp, struct open
 
         dp = of_find_node_by_path(op->oprom_array);
         if (dp)
-                ph = dp->node;
+                ph = dp->phandle;
         data->current_node = dp;
         *((int *)op->oprom_array) = ph;
         op->oprom_size = sizeof(int);
@@ -540,7 +540,7 @@ static int opiocgetnext(unsigned int cmd, void __user *argp)
                 }
         }
         if (dp)
-                nd = dp->node;
+                nd = dp->phandle;
         if (copy_to_user(argp, &nd, sizeof(phandle)))
                 return -EFAULT;
 
@@ -570,7 +570,7 @@ static int openprom_bsd_ioctl(struct inode * inode, struct file * file,
         case OPIOCGETOPTNODE:
                 BUILD_BUG_ON(sizeof(phandle) != sizeof(int));
 
-                if (copy_to_user(argp, &options_node->node, sizeof(phandle)))
+                if (copy_to_user(argp, &options_node->phandle, sizeof(phandle)))
                         return -EFAULT;
 
                 return 0;
diff --git a/drivers/scsi/arm/fas216.c b/drivers/scsi/arm/fas216.c
index 477542602284..9e71ac611146 100644
--- a/drivers/scsi/arm/fas216.c
+++ b/drivers/scsi/arm/fas216.c
@@ -2516,7 +2516,7 @@ int fas216_eh_device_reset(struct scsi_cmnd *SCpnt)
                 if (info->scsi.phase == PHASE_IDLE)
                         fas216_kick(info);
 
-                mod_timer(&info->eh_timer, 30 * HZ);
+                mod_timer(&info->eh_timer, jiffies + 30 * HZ);
                 spin_unlock_irqrestore(&info->host_lock, flags);
 
                 /*
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index 10be9f36a4cc..2f47ae7cce91 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -2009,6 +2009,8 @@ static int fcoe_destroy(const char *buffer, struct kernel_param *kp)
         fcoe_interface_cleanup(fcoe);
         rtnl_unlock();
         fcoe_if_destroy(fcoe->ctlr.lp);
+        module_put(THIS_MODULE);
+
 out_putdev:
         dev_put(netdev);
 out_nodev:
@@ -2059,6 +2061,11 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
         }
 #endif
 
+        if (!try_module_get(THIS_MODULE)) {
+                rc = -EINVAL;
+                goto out_nomod;
+        }
+
         rtnl_lock();
         netdev = fcoe_if_to_netdev(buffer);
         if (!netdev) {
@@ -2099,17 +2106,24 @@ static int fcoe_create(const char *buffer, struct kernel_param *kp)
         if (!fcoe_link_ok(lport))
                 fcoe_ctlr_link_up(&fcoe->ctlr);
 
-        rc = 0;
-out_free:
         /*
          * Release from init in fcoe_interface_create(), on success lport
          * should be holding a reference taken in fcoe_if_create().
          */
         fcoe_interface_put(fcoe);
+        dev_put(netdev);
+        rtnl_unlock();
+        mutex_unlock(&fcoe_config_mutex);
+
+        return 0;
+out_free:
+        fcoe_interface_put(fcoe);
 out_putdev:
         dev_put(netdev);
 out_nodev:
         rtnl_unlock();
+        module_put(THIS_MODULE);
+out_nomod:
         mutex_unlock(&fcoe_config_mutex);
         return rc;
 }
diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index 9823291395ad..511cb6b371ee 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -1187,7 +1187,7 @@ static void fcoe_ctlr_timeout(unsigned long arg)
                         next_timer = fip->ctlr_ka_time;
 
                 if (time_after_eq(jiffies, fip->port_ka_time)) {
-                        fip->port_ka_time += jiffies +
+                        fip->port_ka_time = jiffies +
                                 msecs_to_jiffies(FIP_VN_KA_PERIOD);
                         fip->send_port_ka = 1;
                 }
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 19d711cb938c..7f4364770e4a 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -1890,7 +1890,7 @@ static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
         fc_exch_setup_hdr(ep, fp, ep->f_ctl);
         sp->cnt++;
 
-        if (ep->xid <= lport->lro_xid)
+        if (ep->xid <= lport->lro_xid && fh->fh_r_ctl == FC_RCTL_DD_UNSOL_CMD)
                 fc_fcp_ddp_setup(fr_fsp(fp), ep->xid);
 
         if (unlikely(lport->tt.frame_send(lport, fp)))
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 881d5dfe8c74..6fde2fabfd9b 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -298,9 +298,6 @@ void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
 {
         struct fc_lport *lport;
 
-        if (!fsp)
-                return;
-
         lport = fsp->lp;
         if ((fsp->req_flags & FC_SRB_READ) &&
             (lport->lro_enabled) && (lport->tt.ddp_setup)) {
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 0b165024a219..7ec8ce75007c 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -1800,7 +1800,8 @@ int fc_lport_bsg_request(struct fc_bsg_job *job)
         u32 did;
 
         job->reply->reply_payload_rcv_len = 0;
-        rsp->resid_len = job->reply_payload.payload_len;
+        if (rsp)
+                rsp->resid_len = job->reply_payload.payload_len;
 
         mutex_lock(&lport->lp_mutex);
 
diff --git a/drivers/scsi/libfc/fc_rport.c b/drivers/scsi/libfc/fc_rport.c
index 02300523b234..97923bb07765 100644
--- a/drivers/scsi/libfc/fc_rport.c
+++ b/drivers/scsi/libfc/fc_rport.c
@@ -623,7 +623,7 @@ static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 
                 tov = ntohl(plp->fl_csp.sp_e_d_tov);
                 if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
-                        tov /= 1000;
+                        tov /= 1000000;
                 if (tov > rdata->e_d_tov)
                         rdata->e_d_tov = tov;
                 csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index db6856c138fc..4ad87fd74ddd 100644
--- a/drivers/scsi/libiscsi_tcp.c
+++ b/drivers/scsi/libiscsi_tcp.c
@@ -992,12 +992,10 @@ static struct iscsi_r2t_info *iscsi_tcp_get_curr_r2t(struct iscsi_task *task)
                 if (r2t == NULL) {
                         if (kfifo_out(&tcp_task->r2tqueue,
                             (void *)&tcp_task->r2t, sizeof(void *)) !=
-                            sizeof(void *)) {
-                                WARN_ONCE(1, "unexpected fifo state");
+                            sizeof(void *))
                                 r2t = NULL;
-                        }
-
-                        r2t = tcp_task->r2t;
+                        else
+                                r2t = tcp_task->r2t;
                 }
                 spin_unlock_bh(&session->lock);
         }
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index 708ea3157b60..d9b8ca5116bc 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -3781,6 +3781,7 @@ static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
         int i;
         int error = 0;
+        compat_uptr_t ptr;
 
         if (clear_user(ioc, sizeof(*ioc)))
                 return -EFAULT;
@@ -3793,9 +3794,22 @@ static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
                 return -EFAULT;
 
-        for (i = 0; i < MAX_IOCTL_SGE; i++) {
-                compat_uptr_t ptr;
+        /*
+         * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
+         * sense_len is not null, so prepare the 64bit value under
+         * the same condition.
+         */
+        if (ioc->sense_len) {
+                void __user **sense_ioc_ptr =
+                        (void __user **)(ioc->frame.raw + ioc->sense_off);
+                compat_uptr_t *sense_cioc_ptr =
+                        (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
+                if (get_user(ptr, sense_cioc_ptr) ||
+                    put_user(compat_ptr(ptr), sense_ioc_ptr))
+                        return -EFAULT;
+        }
 
+        for (i = 0; i < MAX_IOCTL_SGE; i++) {
                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
                     copy_in_user(&ioc->sgl[i].iov_len,
diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index c3e37c8e7e26..e9b15c3746fa 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -83,6 +83,9 @@ static unsigned int skip_txen_test; /* force skip of txen test at init time */
 
 #define PASS_LIMIT      256
 
+#define BOTH_EMPTY      (UART_LSR_TEMT | UART_LSR_THRE)
+
+
 /*
  * We default to IRQ0 for the "no irq" hack.   Some
  * machine types want others as well - they're free
@@ -1792,7 +1795,7 @@ static unsigned int serial8250_tx_empty(struct uart_port *port)
         up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
         spin_unlock_irqrestore(&up->port.lock, flags);
 
-        return lsr & UART_LSR_TEMT ? TIOCSER_TEMT : 0;
+        return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
 }
 
 static unsigned int serial8250_get_mctrl(struct uart_port *port)
@@ -1850,8 +1853,6 @@ static void serial8250_break_ctl(struct uart_port *port, int break_state)
         spin_unlock_irqrestore(&up->port.lock, flags);
 }
 
-#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE)
-
 /*
  *      Wait for transmitter & holding register to empty
  */
diff --git a/drivers/serial/pmac_zilog.c b/drivers/serial/pmac_zilog.c
index 683e66f18e8c..3e2ae4807ae2 100644
--- a/drivers/serial/pmac_zilog.c
+++ b/drivers/serial/pmac_zilog.c
@@ -2031,9 +2031,9 @@ static int __init pmz_console_setup(struct console *co, char *options)
         /*
          * XServe's default to 57600 bps
          */
-        if (machine_is_compatible("RackMac1,1")
-            || machine_is_compatible("RackMac1,2")
-            || machine_is_compatible("MacRISC4"))
+        if (of_machine_is_compatible("RackMac1,1")
+            || of_machine_is_compatible("RackMac1,2")
+            || of_machine_is_compatible("MacRISC4"))
                 baud = 57600;
 
         /*
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index f55eb0107336..0fee95cd9a49 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -100,6 +100,23 @@ config SPI_BUTTERFLY
           inexpensive battery powered microcontroller evaluation board.
           This same cable can be used to flash new firmware.
 
+config SPI_COLDFIRE_QSPI
+        tristate "Freescale Coldfire QSPI controller"
+        depends on (M520x || M523x || M5249 || M527x || M528x || M532x)
+        help
+          This enables support for the Coldfire QSPI controller in master
+          mode.
+
+          This driver can also be built as a module.  If so, the module
+          will be called coldfire_qspi.
+
+config SPI_DAVINCI
+        tristate "SPI controller driver for DaVinci/DA8xx SoC's"
+        depends on SPI_MASTER && ARCH_DAVINCI
+        select SPI_BITBANG
+        help
+          SPI master controller for DaVinci and DA8xx SPI modules.
+
 config SPI_GPIO
         tristate "GPIO-based bitbanging SPI Master"
         depends on GENERIC_GPIO
@@ -308,7 +325,7 @@ config SPI_NUC900
 #
 
 config SPI_DESIGNWARE
-        bool "DesignWare SPI controller core support"
+        tristate "DesignWare SPI controller core support"
         depends on SPI_MASTER
         help
           general driver for SPI controller core from DesignWare
@@ -317,6 +334,10 @@ config SPI_DW_PCI
         tristate "PCI interface driver for DW SPI core"
         depends on SPI_DESIGNWARE && PCI
 
+config SPI_DW_MMIO
+        tristate "Memory-mapped io interface driver for DW SPI core"
+        depends on SPI_DESIGNWARE && HAVE_CLK
+
 #
 # There are lots of SPI device types, with sensors and memory
 # being probably the most widely used ones.
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index f3d2810ba11c..d7d0f89b797b 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -16,8 +16,11 @@ obj-$(CONFIG_SPI_BFIN)			+= spi_bfin5xx.o
 obj-$(CONFIG_SPI_BITBANG)               += spi_bitbang.o
 obj-$(CONFIG_SPI_AU1550)                += au1550_spi.o
 obj-$(CONFIG_SPI_BUTTERFLY)             += spi_butterfly.o
+obj-$(CONFIG_SPI_COLDFIRE_QSPI)         += coldfire_qspi.o
+obj-$(CONFIG_SPI_DAVINCI)               += davinci_spi.o
 obj-$(CONFIG_SPI_DESIGNWARE)            += dw_spi.o
 obj-$(CONFIG_SPI_DW_PCI)                += dw_spi_pci.o
+obj-$(CONFIG_SPI_DW_MMIO)               += dw_spi_mmio.o
 obj-$(CONFIG_SPI_GPIO)                  += spi_gpio.o
 obj-$(CONFIG_SPI_IMX)                   += spi_imx.o
 obj-$(CONFIG_SPI_LM70_LLP)              += spi_lm70llp.o
diff --git a/drivers/spi/coldfire_qspi.c b/drivers/spi/coldfire_qspi.c
new file mode 100644
index 000000000000..59be3efe0636
--- /dev/null
+++ b/drivers/spi/coldfire_qspi.c
@@ -0,0 +1,640 @@
+/*
+ * Freescale/Motorola Coldfire Queued SPI driver
+ *
+ * Copyright 2010 Steven King <sfking@fdwdc.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., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA
+ *
+*/
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/errno.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/spi/spi.h>
+
+#include <asm/coldfire.h>
+#include <asm/mcfqspi.h>
+
+#define DRIVER_NAME "mcfqspi"
+
+#define MCFQSPI_BUSCLK                  (MCF_BUSCLK / 2)
+
+#define MCFQSPI_QMR                     0x00
+#define         MCFQSPI_QMR_MSTR        0x8000
+#define         MCFQSPI_QMR_CPOL        0x0200
+#define         MCFQSPI_QMR_CPHA        0x0100
+#define MCFQSPI_QDLYR                   0x04
+#define         MCFQSPI_QDLYR_SPE       0x8000
+#define MCFQSPI_QWR                     0x08
+#define         MCFQSPI_QWR_HALT        0x8000
+#define         MCFQSPI_QWR_WREN        0x4000
+#define         MCFQSPI_QWR_CSIV        0x1000
+#define MCFQSPI_QIR                     0x0C
+#define         MCFQSPI_QIR_WCEFB       0x8000
+#define         MCFQSPI_QIR_ABRTB       0x4000
+#define         MCFQSPI_QIR_ABRTL       0x1000
+#define         MCFQSPI_QIR_WCEFE       0x0800
+#define         MCFQSPI_QIR_ABRTE       0x0400
+#define         MCFQSPI_QIR_SPIFE       0x0100
+#define         MCFQSPI_QIR_WCEF        0x0008
+#define         MCFQSPI_QIR_ABRT        0x0004
+#define         MCFQSPI_QIR_SPIF        0x0001
+#define MCFQSPI_QAR                     0x010
+#define         MCFQSPI_QAR_TXBUF       0x00
+#define         MCFQSPI_QAR_RXBUF       0x10
+#define         MCFQSPI_QAR_CMDBUF      0x20
+#define MCFQSPI_QDR                     0x014
+#define MCFQSPI_QCR                     0x014
+#define         MCFQSPI_QCR_CONT        0x8000
+#define         MCFQSPI_QCR_BITSE       0x4000
+#define         MCFQSPI_QCR_DT          0x2000
+
+struct mcfqspi {
+        void __iomem *iobase;
+        int irq;
+        struct clk *clk;
+        struct mcfqspi_cs_control *cs_control;
+
+        wait_queue_head_t waitq;
+
+        struct work_struct work;
+        struct workqueue_struct *workq;
+        spinlock_t lock;
+        struct list_head msgq;
+};
+
+static void mcfqspi_wr_qmr(struct mcfqspi *mcfqspi, u16 val)
+{
+        writew(val, mcfqspi->iobase + MCFQSPI_QMR);
+}
+
+static void mcfqspi_wr_qdlyr(struct mcfqspi *mcfqspi, u16 val)
+{
+        writew(val, mcfqspi->iobase + MCFQSPI_QDLYR);
+}
+
+static u16 mcfqspi_rd_qdlyr(struct mcfqspi *mcfqspi)
+{
+        return readw(mcfqspi->iobase + MCFQSPI_QDLYR);
+}
+
+static void mcfqspi_wr_qwr(struct mcfqspi *mcfqspi, u16 val)
+{
+        writew(val, mcfqspi->iobase + MCFQSPI_QWR);
+}
+
+static void mcfqspi_wr_qir(struct mcfqspi *mcfqspi, u16 val)
+{
+        writew(val, mcfqspi->iobase + MCFQSPI_QIR);
+}
+
+static void mcfqspi_wr_qar(struct mcfqspi *mcfqspi, u16 val)
+{
+        writew(val, mcfqspi->iobase + MCFQSPI_QAR);
+}
+
+static void mcfqspi_wr_qdr(struct mcfqspi *mcfqspi, u16 val)
+{
+        writew(val, mcfqspi->iobase + MCFQSPI_QDR);
+}
+
+static u16 mcfqspi_rd_qdr(struct mcfqspi *mcfqspi)
+{
+        return readw(mcfqspi->iobase + MCFQSPI_QDR);
+}
+
+static void mcfqspi_cs_select(struct mcfqspi *mcfqspi, u8 chip_select,
+                            bool cs_high)
+{
+        mcfqspi->cs_control->select(mcfqspi->cs_control, chip_select, cs_high);
+}
+
+static void mcfqspi_cs_deselect(struct mcfqspi *mcfqspi, u8 chip_select,
+                                bool cs_high)
+{
+        mcfqspi->cs_control->deselect(mcfqspi->cs_control, chip_select, cs_high);
+}
+
+static int mcfqspi_cs_setup(struct mcfqspi *mcfqspi)
+{
+        return (mcfqspi->cs_control && mcfqspi->cs_control->setup) ?
+                mcfqspi->cs_control->setup(mcfqspi->cs_control) : 0;
+}
+
+static void mcfqspi_cs_teardown(struct mcfqspi *mcfqspi)
+{
+        if (mcfqspi->cs_control && mcfqspi->cs_control->teardown)
+                mcfqspi->cs_control->teardown(mcfqspi->cs_control);
+}
+
+static u8 mcfqspi_qmr_baud(u32 speed_hz)
+{
+        return clamp((MCFQSPI_BUSCLK + speed_hz - 1) / speed_hz, 2u, 255u);
+}
+
+static bool mcfqspi_qdlyr_spe(struct mcfqspi *mcfqspi)
+{
+        return mcfqspi_rd_qdlyr(mcfqspi) & MCFQSPI_QDLYR_SPE;
+}
+
+static irqreturn_t mcfqspi_irq_handler(int this_irq, void *dev_id)
+{
+        struct mcfqspi *mcfqspi = dev_id;
+
+        /* clear interrupt */
+        mcfqspi_wr_qir(mcfqspi, MCFQSPI_QIR_SPIFE | MCFQSPI_QIR_SPIF);
+        wake_up(&mcfqspi->waitq);
+
+        return IRQ_HANDLED;
+}
+
+static void mcfqspi_transfer_msg8(struct mcfqspi *mcfqspi, unsigned count,
+                                  const u8 *txbuf, u8 *rxbuf)
+{
+        unsigned i, n, offset = 0;
+
+        n = min(count, 16u);
+
+        mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_CMDBUF);
+        for (i = 0; i < n; ++i)
+                mcfqspi_wr_qdr(mcfqspi, MCFQSPI_QCR_BITSE);
+
+        mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_TXBUF);
+        if (txbuf)
+                for (i = 0; i < n; ++i)
+                        mcfqspi_wr_qdr(mcfqspi, *txbuf++);
+        else
+                for (i = 0; i < count; ++i)
+                        mcfqspi_wr_qdr(mcfqspi, 0);
+
+        count -= n;
+        if (count) {
+                u16 qwr = 0xf08;
+                mcfqspi_wr_qwr(mcfqspi, 0x700);
+                mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+
+                do {
+                        wait_event(mcfqspi->waitq, !mcfqspi_qdlyr_spe(mcfqspi));
+                        mcfqspi_wr_qwr(mcfqspi, qwr);
+                        mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+                        if (rxbuf) {
+                                mcfqspi_wr_qar(mcfqspi,
+                                               MCFQSPI_QAR_RXBUF + offset);
+                                for (i = 0; i < 8; ++i)
+                                        *rxbuf++ = mcfqspi_rd_qdr(mcfqspi);
+                        }
+                        n = min(count, 8u);
+                        if (txbuf) {
+                                mcfqspi_wr_qar(mcfqspi,
+                                               MCFQSPI_QAR_TXBUF + offset);
+                                for (i = 0; i < n; ++i)
+                                        mcfqspi_wr_qdr(mcfqspi, *txbuf++);
+                        }
+                        qwr = (offset ? 0x808 : 0) + ((n - 1) << 8);
+                        offset ^= 8;
+                        count -= n;
+                } while (count);
+                wait_event(mcfqspi->waitq, !mcfqspi_qdlyr_spe(mcfqspi));
+                mcfqspi_wr_qwr(mcfqspi, qwr);
+                mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+                if (rxbuf) {
+                        mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_RXBUF + offset);
+                        for (i = 0; i < 8; ++i)
+                                *rxbuf++ = mcfqspi_rd_qdr(mcfqspi);
+                        offset ^= 8;
+                }
+        } else {
+                mcfqspi_wr_qwr(mcfqspi, (n - 1) << 8);
+                mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+        }
+        wait_event(mcfqspi->waitq, !mcfqspi_qdlyr_spe(mcfqspi));
+        if (rxbuf) {
+                mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_RXBUF + offset);
+                for (i = 0; i < n; ++i)
+                        *rxbuf++ = mcfqspi_rd_qdr(mcfqspi);
+        }
+}
+
+static void mcfqspi_transfer_msg16(struct mcfqspi *mcfqspi, unsigned count,
+                                   const u16 *txbuf, u16 *rxbuf)
+{
+        unsigned i, n, offset = 0;
+
+        n = min(count, 16u);
+
+        mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_CMDBUF);
+        for (i = 0; i < n; ++i)
+                mcfqspi_wr_qdr(mcfqspi, MCFQSPI_QCR_BITSE);
+
+        mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_TXBUF);
+        if (txbuf)
+                for (i = 0; i < n; ++i)
+                        mcfqspi_wr_qdr(mcfqspi, *txbuf++);
+        else
+                for (i = 0; i < count; ++i)
+                        mcfqspi_wr_qdr(mcfqspi, 0);
+
+        count -= n;
+        if (count) {
+                u16 qwr = 0xf08;
+                mcfqspi_wr_qwr(mcfqspi, 0x700);
+                mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+
+                do {
+                        wait_event(mcfqspi->waitq, !mcfqspi_qdlyr_spe(mcfqspi));
+                        mcfqspi_wr_qwr(mcfqspi, qwr);
+                        mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+                        if (rxbuf) {
+                                mcfqspi_wr_qar(mcfqspi,
+                                               MCFQSPI_QAR_RXBUF + offset);
+                                for (i = 0; i < 8; ++i)
+                                        *rxbuf++ = mcfqspi_rd_qdr(mcfqspi);
+                        }
+                        n = min(count, 8u);
+                        if (txbuf) {
+                                mcfqspi_wr_qar(mcfqspi,
+                                               MCFQSPI_QAR_TXBUF + offset);
+                                for (i = 0; i < n; ++i)
+                                        mcfqspi_wr_qdr(mcfqspi, *txbuf++);
+                        }
+                        qwr = (offset ? 0x808 : 0x000) + ((n - 1) << 8);
+                        offset ^= 8;
+                        count -= n;
+                } while (count);
+                wait_event(mcfqspi->waitq, !mcfqspi_qdlyr_spe(mcfqspi));
+                mcfqspi_wr_qwr(mcfqspi, qwr);
+                mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+                if (rxbuf) {
+                        mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_RXBUF + offset);
+                        for (i = 0; i < 8; ++i)
+                                *rxbuf++ = mcfqspi_rd_qdr(mcfqspi);
+                        offset ^= 8;
+                }
+        } else {
+                mcfqspi_wr_qwr(mcfqspi, (n - 1) << 8);
+                mcfqspi_wr_qdlyr(mcfqspi, MCFQSPI_QDLYR_SPE);
+        }
+        wait_event(mcfqspi->waitq, !mcfqspi_qdlyr_spe(mcfqspi));
+        if (rxbuf) {
+                mcfqspi_wr_qar(mcfqspi, MCFQSPI_QAR_RXBUF + offset);
+                for (i = 0; i < n; ++i)
+                        *rxbuf++ = mcfqspi_rd_qdr(mcfqspi);
+        }
+}
+
+static void mcfqspi_work(struct work_struct *work)
+{
+        struct mcfqspi *mcfqspi = container_of(work, struct mcfqspi, work);
+        unsigned long flags;
+
+        spin_lock_irqsave(&mcfqspi->lock, flags);
+        while (!list_empty(&mcfqspi->msgq)) {
+                struct spi_message *msg;
+                struct spi_device *spi;
+                struct spi_transfer *xfer;
+                int status = 0;
+
+                msg = container_of(mcfqspi->msgq.next, struct spi_message,
+                                   queue);
+
+                list_del_init(&mcfqspi->msgq);
+                spin_unlock_irqrestore(&mcfqspi->lock, flags);
+
+                spi = msg->spi;
+
+                list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+                        bool cs_high = spi->mode & SPI_CS_HIGH;
+                        u16 qmr = MCFQSPI_QMR_MSTR;
+
+                        if (xfer->bits_per_word)
+                                qmr |= xfer->bits_per_word << 10;
+                        else
+                                qmr |= spi->bits_per_word << 10;
+                        if (spi->mode & SPI_CPHA)
+                                qmr |= MCFQSPI_QMR_CPHA;
+                        if (spi->mode & SPI_CPOL)
+                                qmr |= MCFQSPI_QMR_CPOL;
+                        if (xfer->speed_hz)
+                                qmr |= mcfqspi_qmr_baud(xfer->speed_hz);
+                        else
+                                qmr |= mcfqspi_qmr_baud(spi->max_speed_hz);
+                        mcfqspi_wr_qmr(mcfqspi, qmr);
+
+                        mcfqspi_cs_select(mcfqspi, spi->chip_select, cs_high);
+
+                        mcfqspi_wr_qir(mcfqspi, MCFQSPI_QIR_SPIFE);
+                        if ((xfer->bits_per_word ? xfer->bits_per_word :
+                                                spi->bits_per_word) == 8)
+                                mcfqspi_transfer_msg8(mcfqspi, xfer->len,
+                                                      xfer->tx_buf,
+                                                      xfer->rx_buf);
+                        else
+                                mcfqspi_transfer_msg16(mcfqspi, xfer->len / 2,
+                                                       xfer->tx_buf,
+                                                       xfer->rx_buf);
+                        mcfqspi_wr_qir(mcfqspi, 0);
+
+                        if (xfer->delay_usecs)
+                                udelay(xfer->delay_usecs);
+                        if (xfer->cs_change) {
+                                if (!list_is_last(&xfer->transfer_list,
+                                                  &msg->transfers))
+                                        mcfqspi_cs_deselect(mcfqspi,
+                                                            spi->chip_select,
+                                                            cs_high);
+                        } else {
+                                if (list_is_last(&xfer->transfer_list,
+                                                 &msg->transfers))
+                                        mcfqspi_cs_deselect(mcfqspi,
+                                                            spi->chip_select,
+                                                            cs_high);
+                        }
+                        msg->actual_length += xfer->len;
+                }
+                msg->status = status;
+                msg->complete(msg->context);
+
+                spin_lock_irqsave(&mcfqspi->lock, flags);
+        }
+        spin_unlock_irqrestore(&mcfqspi->lock, flags);
+}
+
+static int mcfqspi_transfer(struct spi_device *spi, struct spi_message *msg)
+{
+        struct mcfqspi *mcfqspi;
+        struct spi_transfer *xfer;
+        unsigned long flags;
+
+        mcfqspi = spi_master_get_devdata(spi->master);
+
+        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+                if (xfer->bits_per_word && ((xfer->bits_per_word < 8)
+                                        || (xfer->bits_per_word > 16))) {
+                        dev_dbg(&spi->dev,
+                                "%d bits per word is not supported\n",
+                                xfer->bits_per_word);
+                        goto fail;
+                }
+                if (xfer->speed_hz) {
+                        u32 real_speed = MCFQSPI_BUSCLK /
+                                mcfqspi_qmr_baud(xfer->speed_hz);
+                        if (real_speed != xfer->speed_hz)
+                                dev_dbg(&spi->dev,
+                                        "using speed %d instead of %d\n",
+                                        real_speed, xfer->speed_hz);
+                }
+        }
+        msg->status = -EINPROGRESS;
+        msg->actual_length = 0;
+
+        spin_lock_irqsave(&mcfqspi->lock, flags);
+        list_add_tail(&msg->queue, &mcfqspi->msgq);
+        queue_work(mcfqspi->workq, &mcfqspi->work);
+        spin_unlock_irqrestore(&mcfqspi->lock, flags);
+
+        return 0;
+fail:
+        msg->status = -EINVAL;
+        return -EINVAL;
+}
+
+static int mcfqspi_setup(struct spi_device *spi)
+{
+        if ((spi->bits_per_word < 8) || (spi->bits_per_word > 16)) {
+                dev_dbg(&spi->dev, "%d bits per word is not supported\n",
+                        spi->bits_per_word);
+                return -EINVAL;
+        }
+        if (spi->chip_select >= spi->master->num_chipselect) {
+                dev_dbg(&spi->dev, "%d chip select is out of range\n",
+                        spi->chip_select);
+                return -EINVAL;
+        }
+
+        mcfqspi_cs_deselect(spi_master_get_devdata(spi->master),
+                            spi->chip_select, spi->mode & SPI_CS_HIGH);
+
+        dev_dbg(&spi->dev,
+                        "bits per word %d, chip select %d, speed %d KHz\n",
+                        spi->bits_per_word, spi->chip_select,
+                        (MCFQSPI_BUSCLK / mcfqspi_qmr_baud(spi->max_speed_hz))
+                        / 1000);
+
+        return 0;
+}
+
+static int __devinit mcfqspi_probe(struct platform_device *pdev)
+{
+        struct spi_master *master;
+        struct mcfqspi *mcfqspi;
+        struct resource *res;
+        struct mcfqspi_platform_data *pdata;
+        int status;
+
+        master = spi_alloc_master(&pdev->dev, sizeof(*mcfqspi));
+        if (master == NULL) {
+                dev_dbg(&pdev->dev, "spi_alloc_master failed\n");
+                return -ENOMEM;
+        }
+
+        mcfqspi = spi_master_get_devdata(master);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_dbg(&pdev->dev, "platform_get_resource failed\n");
+                status = -ENXIO;
+                goto fail0;
+        }
+
+        if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
+                dev_dbg(&pdev->dev, "request_mem_region failed\n");
+                status = -EBUSY;
+                goto fail0;
+        }
+
+        mcfqspi->iobase = ioremap(res->start, resource_size(res));
+        if (!mcfqspi->iobase) {
+                dev_dbg(&pdev->dev, "ioremap failed\n");
+                status = -ENOMEM;
+                goto fail1;
+        }
+
+        mcfqspi->irq = platform_get_irq(pdev, 0);
+        if (mcfqspi->irq < 0) {
+                dev_dbg(&pdev->dev, "platform_get_irq failed\n");
+                status = -ENXIO;
+                goto fail2;
+        }
+
+        status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, IRQF_DISABLED,
+                             pdev->name, mcfqspi);
+        if (status) {
+                dev_dbg(&pdev->dev, "request_irq failed\n");
+                goto fail2;
+        }
+
+        mcfqspi->clk = clk_get(&pdev->dev, "qspi_clk");
+        if (IS_ERR(mcfqspi->clk)) {
+                dev_dbg(&pdev->dev, "clk_get failed\n");
+                status = PTR_ERR(mcfqspi->clk);
+                goto fail3;
+        }
+        clk_enable(mcfqspi->clk);
+
+        mcfqspi->workq = create_singlethread_workqueue(dev_name(master->dev.parent));
+        if (!mcfqspi->workq) {
+                dev_dbg(&pdev->dev, "create_workqueue failed\n");
+                status = -ENOMEM;
+                goto fail4;
+        }
+        INIT_WORK(&mcfqspi->work, mcfqspi_work);
+        spin_lock_init(&mcfqspi->lock);
+        INIT_LIST_HEAD(&mcfqspi->msgq);
+        init_waitqueue_head(&mcfqspi->waitq);
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_dbg(&pdev->dev, "platform data is missing\n");
+                goto fail5;
+        }
+        master->bus_num = pdata->bus_num;
+        master->num_chipselect = pdata->num_chipselect;
+
+        mcfqspi->cs_control = pdata->cs_control;
+        status = mcfqspi_cs_setup(mcfqspi);
+        if (status) {
+                dev_dbg(&pdev->dev, "error initializing cs_control\n");
+                goto fail5;
+        }
+
+        master->mode_bits = SPI_CS_HIGH | SPI_CPOL | SPI_CPHA;
+        master->setup = mcfqspi_setup;
+        master->transfer = mcfqspi_transfer;
+
+        platform_set_drvdata(pdev, master);
+
+        status = spi_register_master(master);
+        if (status) {
+                dev_dbg(&pdev->dev, "spi_register_master failed\n");
+                goto fail6;
+        }
+        dev_info(&pdev->dev, "Coldfire QSPI bus driver\n");
+
+        return 0;
+
+fail6:
+        mcfqspi_cs_teardown(mcfqspi);
+fail5:
+        destroy_workqueue(mcfqspi->workq);
+fail4:
+        clk_disable(mcfqspi->clk);
+        clk_put(mcfqspi->clk);
+fail3:
+        free_irq(mcfqspi->irq, mcfqspi);
+fail2:
+        iounmap(mcfqspi->iobase);
+fail1:
+        release_mem_region(res->start, resource_size(res));
+fail0:
+        spi_master_put(master);
+
+        dev_dbg(&pdev->dev, "Coldfire QSPI probe failed\n");
+
+        return status;
+}
+
+static int __devexit mcfqspi_remove(struct platform_device *pdev)
+{
+        struct spi_master *master = platform_get_drvdata(pdev);
+        struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
+        struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        /* disable the hardware (set the baud rate to 0) */
+        mcfqspi_wr_qmr(mcfqspi, MCFQSPI_QMR_MSTR);
+
+        platform_set_drvdata(pdev, NULL);
+        mcfqspi_cs_teardown(mcfqspi);
+        destroy_workqueue(mcfqspi->workq);
+        clk_disable(mcfqspi->clk);
+        clk_put(mcfqspi->clk);
+        free_irq(mcfqspi->irq, mcfqspi);
+        iounmap(mcfqspi->iobase);
+        release_mem_region(res->start, resource_size(res));
+        spi_unregister_master(master);
+        spi_master_put(master);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+
+static int mcfqspi_suspend(struct device *dev)
+{
+        struct mcfqspi *mcfqspi = platform_get_drvdata(to_platform_device(dev));
+
+        clk_disable(mcfqspi->clk);
+
+        return 0;
+}
+
+static int mcfqspi_resume(struct device *dev)
+{
+        struct mcfqspi *mcfqspi = platform_get_drvdata(to_platform_device(dev));
+
+        clk_enable(mcfqspi->clk);
+
+        return 0;
+}
+
+static struct dev_pm_ops mcfqspi_dev_pm_ops = {
+        .suspend        = mcfqspi_suspend,
+        .resume         = mcfqspi_resume,
+};
+
+#define MCFQSPI_DEV_PM_OPS      (&mcfqspi_dev_pm_ops)
+#else
+#define MCFQSPI_DEV_PM_OPS      NULL
+#endif
+
+static struct platform_driver mcfqspi_driver = {
+        .driver.name    = DRIVER_NAME,
+        .driver.owner   = THIS_MODULE,
+        .driver.pm      = MCFQSPI_DEV_PM_OPS,
+        .remove         = __devexit_p(mcfqspi_remove),
+};
+
+static int __init mcfqspi_init(void)
+{
+        return platform_driver_probe(&mcfqspi_driver, mcfqspi_probe);
+}
+module_init(mcfqspi_init);
+
+static void __exit mcfqspi_exit(void)
+{
+        platform_driver_unregister(&mcfqspi_driver);
+}
+module_exit(mcfqspi_exit);
+
+MODULE_AUTHOR("Steven King <sfking@fdwdc.com>");
+MODULE_DESCRIPTION("Coldfire QSPI Controller Driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRIVER_NAME);
diff --git a/drivers/spi/davinci_spi.c b/drivers/spi/davinci_spi.c
new file mode 100644
index 000000000000..225ab60b02c4
--- /dev/null
+++ b/drivers/spi/davinci_spi.c
@@ -0,0 +1,1255 @@
+/*
+ * Copyright (C) 2009 Texas Instruments.
+ *
+ * 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/interrupt.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/dma-mapping.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+
+#include <mach/spi.h>
+#include <mach/edma.h>
+
+#define SPI_NO_RESOURCE         ((resource_size_t)-1)
+
+#define SPI_MAX_CHIPSELECT      2
+
+#define CS_DEFAULT      0xFF
+
+#define SPI_BUFSIZ      (SMP_CACHE_BYTES + 1)
+#define DAVINCI_DMA_DATA_TYPE_S8        0x01
+#define DAVINCI_DMA_DATA_TYPE_S16       0x02
+#define DAVINCI_DMA_DATA_TYPE_S32       0x04
+
+#define SPIFMT_PHASE_MASK       BIT(16)
+#define SPIFMT_POLARITY_MASK    BIT(17)
+#define SPIFMT_DISTIMER_MASK    BIT(18)
+#define SPIFMT_SHIFTDIR_MASK    BIT(20)
+#define SPIFMT_WAITENA_MASK     BIT(21)
+#define SPIFMT_PARITYENA_MASK   BIT(22)
+#define SPIFMT_ODD_PARITY_MASK  BIT(23)
+#define SPIFMT_WDELAY_MASK      0x3f000000u
+#define SPIFMT_WDELAY_SHIFT     24
+#define SPIFMT_CHARLEN_MASK     0x0000001Fu
+
+/* SPIGCR1 */
+#define SPIGCR1_SPIENA_MASK     0x01000000u
+
+/* SPIPC0 */
+#define SPIPC0_DIFUN_MASK       BIT(11)         /* MISO */
+#define SPIPC0_DOFUN_MASK       BIT(10)         /* MOSI */
+#define SPIPC0_CLKFUN_MASK      BIT(9)          /* CLK */
+#define SPIPC0_SPIENA_MASK      BIT(8)          /* nREADY */
+#define SPIPC0_EN1FUN_MASK      BIT(1)
+#define SPIPC0_EN0FUN_MASK      BIT(0)
+
+#define SPIINT_MASKALL          0x0101035F
+#define SPI_INTLVL_1            0x000001FFu
+#define SPI_INTLVL_0            0x00000000u
+
+/* SPIDAT1 */
+#define SPIDAT1_CSHOLD_SHIFT    28
+#define SPIDAT1_CSNR_SHIFT      16
+#define SPIGCR1_CLKMOD_MASK     BIT(1)
+#define SPIGCR1_MASTER_MASK     BIT(0)
+#define SPIGCR1_LOOPBACK_MASK   BIT(16)
+
+/* SPIBUF */
+#define SPIBUF_TXFULL_MASK      BIT(29)
+#define SPIBUF_RXEMPTY_MASK     BIT(31)
+
+/* Error Masks */
+#define SPIFLG_DLEN_ERR_MASK            BIT(0)
+#define SPIFLG_TIMEOUT_MASK             BIT(1)
+#define SPIFLG_PARERR_MASK              BIT(2)
+#define SPIFLG_DESYNC_MASK              BIT(3)
+#define SPIFLG_BITERR_MASK              BIT(4)
+#define SPIFLG_OVRRUN_MASK              BIT(6)
+#define SPIFLG_RX_INTR_MASK             BIT(8)
+#define SPIFLG_TX_INTR_MASK             BIT(9)
+#define SPIFLG_BUF_INIT_ACTIVE_MASK     BIT(24)
+#define SPIFLG_MASK                     (SPIFLG_DLEN_ERR_MASK \
+                                | SPIFLG_TIMEOUT_MASK | SPIFLG_PARERR_MASK \
+                                | SPIFLG_DESYNC_MASK | SPIFLG_BITERR_MASK \
+                                | SPIFLG_OVRRUN_MASK | SPIFLG_RX_INTR_MASK \
+                                | SPIFLG_TX_INTR_MASK \
+                                | SPIFLG_BUF_INIT_ACTIVE_MASK)
+
+#define SPIINT_DLEN_ERR_INTR    BIT(0)
+#define SPIINT_TIMEOUT_INTR     BIT(1)
+#define SPIINT_PARERR_INTR      BIT(2)
+#define SPIINT_DESYNC_INTR      BIT(3)
+#define SPIINT_BITERR_INTR      BIT(4)
+#define SPIINT_OVRRUN_INTR      BIT(6)
+#define SPIINT_RX_INTR          BIT(8)
+#define SPIINT_TX_INTR          BIT(9)
+#define SPIINT_DMA_REQ_EN       BIT(16)
+#define SPIINT_ENABLE_HIGHZ     BIT(24)
+
+#define SPI_T2CDELAY_SHIFT      16
+#define SPI_C2TDELAY_SHIFT      24
+
+/* SPI Controller registers */
+#define SPIGCR0         0x00
+#define SPIGCR1         0x04
+#define SPIINT          0x08
+#define SPILVL          0x0c
+#define SPIFLG          0x10
+#define SPIPC0          0x14
+#define SPIPC1          0x18
+#define SPIPC2          0x1c
+#define SPIPC3          0x20
+#define SPIPC4          0x24
+#define SPIPC5          0x28
+#define SPIPC6          0x2c
+#define SPIPC7          0x30
+#define SPIPC8          0x34
+#define SPIDAT0         0x38
+#define SPIDAT1         0x3c
+#define SPIBUF          0x40
+#define SPIEMU          0x44
+#define SPIDELAY        0x48
+#define SPIDEF          0x4c
+#define SPIFMT0         0x50
+#define SPIFMT1         0x54
+#define SPIFMT2         0x58
+#define SPIFMT3         0x5c
+#define TGINTVEC0       0x60
+#define TGINTVEC1       0x64
+
+struct davinci_spi_slave {
+        u32     cmd_to_write;
+        u32     clk_ctrl_to_write;
+        u32     bytes_per_word;
+        u8      active_cs;
+};
+
+/* We have 2 DMA channels per CS, one for RX and one for TX */
+struct davinci_spi_dma {
+        int                     dma_tx_channel;
+        int                     dma_rx_channel;
+        int                     dma_tx_sync_dev;
+        int                     dma_rx_sync_dev;
+        enum dma_event_q        eventq;
+
+        struct completion       dma_tx_completion;
+        struct completion       dma_rx_completion;
+};
+
+/* SPI Controller driver's private data. */
+struct davinci_spi {
+        struct spi_bitbang      bitbang;
+        struct clk              *clk;
+
+        u8                      version;
+        resource_size_t         pbase;
+        void __iomem            *base;
+        size_t                  region_size;
+        u32                     irq;
+        struct completion       done;
+
+        const void              *tx;
+        void                    *rx;
+        u8                      *tmp_buf;
+        int                     count;
+        struct davinci_spi_dma  *dma_channels;
+        struct                  davinci_spi_platform_data *pdata;
+
+        void                    (*get_rx)(u32 rx_data, struct davinci_spi *);
+        u32                     (*get_tx)(struct davinci_spi *);
+
+        struct davinci_spi_slave slave[SPI_MAX_CHIPSELECT];
+};
+
+static unsigned use_dma;
+
+static void davinci_spi_rx_buf_u8(u32 data, struct davinci_spi *davinci_spi)
+{
+        u8 *rx = davinci_spi->rx;
+
+        *rx++ = (u8)data;
+        davinci_spi->rx = rx;
+}
+
+static void davinci_spi_rx_buf_u16(u32 data, struct davinci_spi *davinci_spi)
+{
+        u16 *rx = davinci_spi->rx;
+
+        *rx++ = (u16)data;
+        davinci_spi->rx = rx;
+}
+
+static u32 davinci_spi_tx_buf_u8(struct davinci_spi *davinci_spi)
+{
+        u32 data;
+        const u8 *tx = davinci_spi->tx;
+
+        data = *tx++;
+        davinci_spi->tx = tx;
+        return data;
+}
+
+static u32 davinci_spi_tx_buf_u16(struct davinci_spi *davinci_spi)
+{
+        u32 data;
+        const u16 *tx = davinci_spi->tx;
+
+        data = *tx++;
+        davinci_spi->tx = tx;
+        return data;
+}
+
+static inline void set_io_bits(void __iomem *addr, u32 bits)
+{
+        u32 v = ioread32(addr);
+
+        v |= bits;
+        iowrite32(v, addr);
+}
+
+static inline void clear_io_bits(void __iomem *addr, u32 bits)
+{
+        u32 v = ioread32(addr);
+
+        v &= ~bits;
+        iowrite32(v, addr);
+}
+
+static inline void set_fmt_bits(void __iomem *addr, u32 bits, int cs_num)
+{
+        set_io_bits(addr + SPIFMT0 + (0x4 * cs_num), bits);
+}
+
+static inline void clear_fmt_bits(void __iomem *addr, u32 bits, int cs_num)
+{
+        clear_io_bits(addr + SPIFMT0 + (0x4 * cs_num), bits);
+}
+
+static void davinci_spi_set_dma_req(const struct spi_device *spi, int enable)
+{
+        struct davinci_spi *davinci_spi = spi_master_get_devdata(spi->master);
+
+        if (enable)
+                set_io_bits(davinci_spi->base + SPIINT, SPIINT_DMA_REQ_EN);
+        else
+                clear_io_bits(davinci_spi->base + SPIINT, SPIINT_DMA_REQ_EN);
+}
+
+/*
+ * Interface to control the chip select signal
+ */
+static void davinci_spi_chipselect(struct spi_device *spi, int value)
+{
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_platform_data *pdata;
+        u32 data1_reg_val = 0;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        pdata = davinci_spi->pdata;
+
+        /*
+         * Board specific chip select logic decides the polarity and cs
+         * line for the controller
+         */
+        if (value == BITBANG_CS_INACTIVE) {
+                set_io_bits(davinci_spi->base + SPIDEF, CS_DEFAULT);
+
+                data1_reg_val |= CS_DEFAULT << SPIDAT1_CSNR_SHIFT;
+                iowrite32(data1_reg_val, davinci_spi->base + SPIDAT1);
+
+                while ((ioread32(davinci_spi->base + SPIBUF)
+                                        & SPIBUF_RXEMPTY_MASK) == 0)
+                        cpu_relax();
+        }
+}
+
+/**
+ * davinci_spi_setup_transfer - This functions will determine transfer method
+ * @spi: spi device on which data transfer to be done
+ * @t: spi transfer in which transfer info is filled
+ *
+ * This function determines data transfer method (8/16/32 bit transfer).
+ * It will also set the SPI Clock Control register according to
+ * SPI slave device freq.
+ */
+static int davinci_spi_setup_transfer(struct spi_device *spi,
+                struct spi_transfer *t)
+{
+
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_platform_data *pdata;
+        u8 bits_per_word = 0;
+        u32 hz = 0, prescale;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        pdata = davinci_spi->pdata;
+
+        if (t) {
+                bits_per_word = t->bits_per_word;
+                hz = t->speed_hz;
+        }
+
+        /* if bits_per_word is not set then set it default */
+        if (!bits_per_word)
+                bits_per_word = spi->bits_per_word;
+
+        /*
+         * Assign function pointer to appropriate transfer method
+         * 8bit, 16bit or 32bit transfer
+         */
+        if (bits_per_word <= 8 && bits_per_word >= 2) {
+                davinci_spi->get_rx = davinci_spi_rx_buf_u8;
+                davinci_spi->get_tx = davinci_spi_tx_buf_u8;
+                davinci_spi->slave[spi->chip_select].bytes_per_word = 1;
+        } else if (bits_per_word <= 16 && bits_per_word >= 2) {
+                davinci_spi->get_rx = davinci_spi_rx_buf_u16;
+                davinci_spi->get_tx = davinci_spi_tx_buf_u16;
+                davinci_spi->slave[spi->chip_select].bytes_per_word = 2;
+        } else
+                return -EINVAL;
+
+        if (!hz)
+                hz = spi->max_speed_hz;
+
+        clear_fmt_bits(davinci_spi->base, SPIFMT_CHARLEN_MASK,
+                        spi->chip_select);
+        set_fmt_bits(davinci_spi->base, bits_per_word & 0x1f,
+                        spi->chip_select);
+
+        prescale = ((clk_get_rate(davinci_spi->clk) / hz) - 1) & 0xff;
+
+        clear_fmt_bits(davinci_spi->base, 0x0000ff00, spi->chip_select);
+        set_fmt_bits(davinci_spi->base, prescale << 8, spi->chip_select);
+
+        return 0;
+}
+
+static void davinci_spi_dma_rx_callback(unsigned lch, u16 ch_status, void *data)
+{
+        struct spi_device *spi = (struct spi_device *)data;
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_dma *davinci_spi_dma;
+        struct davinci_spi_platform_data *pdata;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        davinci_spi_dma = &(davinci_spi->dma_channels[spi->chip_select]);
+        pdata = davinci_spi->pdata;
+
+        if (ch_status == DMA_COMPLETE)
+                edma_stop(davinci_spi_dma->dma_rx_channel);
+        else
+                edma_clean_channel(davinci_spi_dma->dma_rx_channel);
+
+        complete(&davinci_spi_dma->dma_rx_completion);
+        /* We must disable the DMA RX request */
+        davinci_spi_set_dma_req(spi, 0);
+}
+
+static void davinci_spi_dma_tx_callback(unsigned lch, u16 ch_status, void *data)
+{
+        struct spi_device *spi = (struct spi_device *)data;
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_dma *davinci_spi_dma;
+        struct davinci_spi_platform_data *pdata;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        davinci_spi_dma = &(davinci_spi->dma_channels[spi->chip_select]);
+        pdata = davinci_spi->pdata;
+
+        if (ch_status == DMA_COMPLETE)
+                edma_stop(davinci_spi_dma->dma_tx_channel);
+        else
+                edma_clean_channel(davinci_spi_dma->dma_tx_channel);
+
+        complete(&davinci_spi_dma->dma_tx_completion);
+        /* We must disable the DMA TX request */
+        davinci_spi_set_dma_req(spi, 0);
+}
+
+static int davinci_spi_request_dma(struct spi_device *spi)
+{
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_dma *davinci_spi_dma;
+        struct davinci_spi_platform_data *pdata;
+        struct device *sdev;
+        int r;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
+        pdata = davinci_spi->pdata;
+        sdev = davinci_spi->bitbang.master->dev.parent;
+
+        r = edma_alloc_channel(davinci_spi_dma->dma_rx_sync_dev,
+                                davinci_spi_dma_rx_callback, spi,
+                                davinci_spi_dma->eventq);
+        if (r < 0) {
+                dev_dbg(sdev, "Unable to request DMA channel for SPI RX\n");
+                return -EAGAIN;
+        }
+        davinci_spi_dma->dma_rx_channel = r;
+        r = edma_alloc_channel(davinci_spi_dma->dma_tx_sync_dev,
+                                davinci_spi_dma_tx_callback, spi,
+                                davinci_spi_dma->eventq);
+        if (r < 0) {
+                edma_free_channel(davinci_spi_dma->dma_rx_channel);
+                davinci_spi_dma->dma_rx_channel = -1;
+                dev_dbg(sdev, "Unable to request DMA channel for SPI TX\n");
+                return -EAGAIN;
+        }
+        davinci_spi_dma->dma_tx_channel = r;
+
+        return 0;
+}
+
+/**
+ * davinci_spi_setup - This functions will set default transfer method
+ * @spi: spi device on which data transfer to be done
+ *
+ * This functions sets the default transfer method.
+ */
+
+static int davinci_spi_setup(struct spi_device *spi)
+{
+        int retval;
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_dma *davinci_spi_dma;
+        struct device *sdev;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        sdev = davinci_spi->bitbang.master->dev.parent;
+
+        /* if bits per word length is zero then set it default 8 */
+        if (!spi->bits_per_word)
+                spi->bits_per_word = 8;
+
+        davinci_spi->slave[spi->chip_select].cmd_to_write = 0;
+
+        if (use_dma && davinci_spi->dma_channels) {
+                davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
+
+                if ((davinci_spi_dma->dma_rx_channel == -1)
+                                || (davinci_spi_dma->dma_tx_channel == -1)) {
+                        retval = davinci_spi_request_dma(spi);
+                        if (retval < 0)
+                                return retval;
+                }
+        }
+
+        /*
+         * SPI in DaVinci and DA8xx operate between
+         * 600 KHz and 50 MHz
+         */
+        if (spi->max_speed_hz < 600000 || spi->max_speed_hz > 50000000) {
+                dev_dbg(sdev, "Operating frequency is not in acceptable "
+                                "range\n");
+                return -EINVAL;
+        }
+
+        /*
+         * Set up SPIFMTn register, unique to this chipselect.
+         *
+         * NOTE: we could do all of these with one write.  Also, some
+         * of the "version 2" features are found in chips that don't
+         * support all of them...
+         */
+        if (spi->mode & SPI_LSB_FIRST)
+                set_fmt_bits(davinci_spi->base, SPIFMT_SHIFTDIR_MASK,
+                                spi->chip_select);
+        else
+                clear_fmt_bits(davinci_spi->base, SPIFMT_SHIFTDIR_MASK,
+                                spi->chip_select);
+
+        if (spi->mode & SPI_CPOL)
+                set_fmt_bits(davinci_spi->base, SPIFMT_POLARITY_MASK,
+                                spi->chip_select);
+        else
+                clear_fmt_bits(davinci_spi->base, SPIFMT_POLARITY_MASK,
+                                spi->chip_select);
+
+        if (!(spi->mode & SPI_CPHA))
+                set_fmt_bits(davinci_spi->base, SPIFMT_PHASE_MASK,
+                                spi->chip_select);
+        else
+                clear_fmt_bits(davinci_spi->base, SPIFMT_PHASE_MASK,
+                                spi->chip_select);
+
+        /*
+         * Version 1 hardware supports two basic SPI modes:
+         *  - Standard SPI mode uses 4 pins, with chipselect
+         *  - 3 pin SPI is a 4 pin variant without CS (SPI_NO_CS)
+         *      (distinct from SPI_3WIRE, with just one data wire;
+         *      or similar variants without MOSI or without MISO)
+         *
+         * Version 2 hardware supports an optional handshaking signal,
+         * so it can support two more modes:
+         *  - 5 pin SPI variant is standard SPI plus SPI_READY
+         *  - 4 pin with enable is (SPI_READY | SPI_NO_CS)
+         */
+
+        if (davinci_spi->version == SPI_VERSION_2) {
+                clear_fmt_bits(davinci_spi->base, SPIFMT_WDELAY_MASK,
+                                spi->chip_select);
+                set_fmt_bits(davinci_spi->base,
+                                (davinci_spi->pdata->wdelay
+                                                << SPIFMT_WDELAY_SHIFT)
+                                        & SPIFMT_WDELAY_MASK,
+                                spi->chip_select);
+
+                if (davinci_spi->pdata->odd_parity)
+                        set_fmt_bits(davinci_spi->base,
+                                        SPIFMT_ODD_PARITY_MASK,
+                                        spi->chip_select);
+                else
+                        clear_fmt_bits(davinci_spi->base,
+                                        SPIFMT_ODD_PARITY_MASK,
+                                        spi->chip_select);
+
+                if (davinci_spi->pdata->parity_enable)
+                        set_fmt_bits(davinci_spi->base,
+                                        SPIFMT_PARITYENA_MASK,
+                                        spi->chip_select);
+                else
+                        clear_fmt_bits(davinci_spi->base,
+                                        SPIFMT_PARITYENA_MASK,
+                                        spi->chip_select);
+
+                if (davinci_spi->pdata->wait_enable)
+                        set_fmt_bits(davinci_spi->base,
+                                        SPIFMT_WAITENA_MASK,
+                                        spi->chip_select);
+                else
+                        clear_fmt_bits(davinci_spi->base,
+                                        SPIFMT_WAITENA_MASK,
+                                        spi->chip_select);
+
+                if (davinci_spi->pdata->timer_disable)
+                        set_fmt_bits(davinci_spi->base,
+                                        SPIFMT_DISTIMER_MASK,
+                                        spi->chip_select);
+                else
+                        clear_fmt_bits(davinci_spi->base,
+                                        SPIFMT_DISTIMER_MASK,
+                                        spi->chip_select);
+        }
+
+        retval = davinci_spi_setup_transfer(spi, NULL);
+
+        return retval;
+}
+
+static void davinci_spi_cleanup(struct spi_device *spi)
+{
+        struct davinci_spi *davinci_spi = spi_master_get_devdata(spi->master);
+        struct davinci_spi_dma *davinci_spi_dma;
+
+        davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
+
+        if (use_dma && davinci_spi->dma_channels) {
+                davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
+
+                if ((davinci_spi_dma->dma_rx_channel != -1)
+                                && (davinci_spi_dma->dma_tx_channel != -1)) {
+                        edma_free_channel(davinci_spi_dma->dma_tx_channel);
+                        edma_free_channel(davinci_spi_dma->dma_rx_channel);
+                }
+        }
+}
+
+static int davinci_spi_bufs_prep(struct spi_device *spi,
+                                 struct davinci_spi *davinci_spi)
+{
+        int op_mode = 0;
+
+        /*
+         * REVISIT  unless devices disagree about SPI_LOOP or
+         * SPI_READY (SPI_NO_CS only allows one device!), this
+         * should not need to be done before each message...
+         * optimize for both flags staying cleared.
+         */
+
+        op_mode = SPIPC0_DIFUN_MASK
+                | SPIPC0_DOFUN_MASK
+                | SPIPC0_CLKFUN_MASK;
+        if (!(spi->mode & SPI_NO_CS))
+                op_mode |= 1 << spi->chip_select;
+        if (spi->mode & SPI_READY)
+                op_mode |= SPIPC0_SPIENA_MASK;
+
+        iowrite32(op_mode, davinci_spi->base + SPIPC0);
+
+        if (spi->mode & SPI_LOOP)
+                set_io_bits(davinci_spi->base + SPIGCR1,
+                                SPIGCR1_LOOPBACK_MASK);
+        else
+                clear_io_bits(davinci_spi->base + SPIGCR1,
+                                SPIGCR1_LOOPBACK_MASK);
+
+        return 0;
+}
+
+static int davinci_spi_check_error(struct davinci_spi *davinci_spi,
+                                   int int_status)
+{
+        struct device *sdev = davinci_spi->bitbang.master->dev.parent;
+
+        if (int_status & SPIFLG_TIMEOUT_MASK) {
+                dev_dbg(sdev, "SPI Time-out Error\n");
+                return -ETIMEDOUT;
+        }
+        if (int_status & SPIFLG_DESYNC_MASK) {
+                dev_dbg(sdev, "SPI Desynchronization Error\n");
+                return -EIO;
+        }
+        if (int_status & SPIFLG_BITERR_MASK) {
+                dev_dbg(sdev, "SPI Bit error\n");
+                return -EIO;
+        }
+
+        if (davinci_spi->version == SPI_VERSION_2) {
+                if (int_status & SPIFLG_DLEN_ERR_MASK) {
+                        dev_dbg(sdev, "SPI Data Length Error\n");
+                        return -EIO;
+                }
+                if (int_status & SPIFLG_PARERR_MASK) {
+                        dev_dbg(sdev, "SPI Parity Error\n");
+                        return -EIO;
+                }
+                if (int_status & SPIFLG_OVRRUN_MASK) {
+                        dev_dbg(sdev, "SPI Data Overrun error\n");
+                        return -EIO;
+                }
+                if (int_status & SPIFLG_TX_INTR_MASK) {
+                        dev_dbg(sdev, "SPI TX intr bit set\n");
+                        return -EIO;
+                }
+                if (int_status & SPIFLG_BUF_INIT_ACTIVE_MASK) {
+                        dev_dbg(sdev, "SPI Buffer Init Active\n");
+                        return -EBUSY;
+                }
+        }
+
+        return 0;
+}
+
+/**
+ * davinci_spi_bufs - functions which will handle transfer data
+ * @spi: spi device on which data transfer to be done
+ * @t: spi transfer in which transfer info is filled
+ *
+ * This function will put data to be transferred into data register
+ * of SPI controller and then wait until the completion will be marked
+ * by the IRQ Handler.
+ */
+static int davinci_spi_bufs_pio(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct davinci_spi *davinci_spi;
+        int int_status, count, ret;
+        u8 conv, tmp;
+        u32 tx_data, data1_reg_val;
+        u32 buf_val, flg_val;
+        struct davinci_spi_platform_data *pdata;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        pdata = davinci_spi->pdata;
+
+        davinci_spi->tx = t->tx_buf;
+        davinci_spi->rx = t->rx_buf;
+
+        /* convert len to words based on bits_per_word */
+        conv = davinci_spi->slave[spi->chip_select].bytes_per_word;
+        davinci_spi->count = t->len / conv;
+
+        INIT_COMPLETION(davinci_spi->done);
+
+        ret = davinci_spi_bufs_prep(spi, davinci_spi);
+        if (ret)
+                return ret;
+
+        /* Enable SPI */
+        set_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
+
+        iowrite32(0 | (pdata->c2tdelay << SPI_C2TDELAY_SHIFT) |
+                        (pdata->t2cdelay << SPI_T2CDELAY_SHIFT),
+                        davinci_spi->base + SPIDELAY);
+
+        count = davinci_spi->count;
+        data1_reg_val = pdata->cs_hold << SPIDAT1_CSHOLD_SHIFT;
+        tmp = ~(0x1 << spi->chip_select);
+
+        clear_io_bits(davinci_spi->base + SPIDEF, ~tmp);
+
+        data1_reg_val |= tmp << SPIDAT1_CSNR_SHIFT;
+
+        while ((ioread32(davinci_spi->base + SPIBUF)
+                                & SPIBUF_RXEMPTY_MASK) == 0)
+                cpu_relax();
+
+        /* Determine the command to execute READ or WRITE */
+        if (t->tx_buf) {
+                clear_io_bits(davinci_spi->base + SPIINT, SPIINT_MASKALL);
+
+                while (1) {
+                        tx_data = davinci_spi->get_tx(davinci_spi);
+
+                        data1_reg_val &= ~(0xFFFF);
+                        data1_reg_val |= (0xFFFF & tx_data);
+
+                        buf_val = ioread32(davinci_spi->base + SPIBUF);
+                        if ((buf_val & SPIBUF_TXFULL_MASK) == 0) {
+                                iowrite32(data1_reg_val,
+                                                davinci_spi->base + SPIDAT1);
+
+                                count--;
+                        }
+                        while (ioread32(davinci_spi->base + SPIBUF)
+                                        & SPIBUF_RXEMPTY_MASK)
+                                cpu_relax();
+
+                        /* getting the returned byte */
+                        if (t->rx_buf) {
+                                buf_val = ioread32(davinci_spi->base + SPIBUF);
+                                davinci_spi->get_rx(buf_val, davinci_spi);
+                        }
+                        if (count <= 0)
+                                break;
+                }
+        } else {
+                if (pdata->poll_mode) {
+                        while (1) {
+                                /* keeps the serial clock going */
+                                if ((ioread32(davinci_spi->base + SPIBUF)
+                                                & SPIBUF_TXFULL_MASK) == 0)
+                                        iowrite32(data1_reg_val,
+                                                davinci_spi->base + SPIDAT1);
+
+                                while (ioread32(davinci_spi->base + SPIBUF) &
+                                                SPIBUF_RXEMPTY_MASK)
+                                        cpu_relax();
+
+                                flg_val = ioread32(davinci_spi->base + SPIFLG);
+                                buf_val = ioread32(davinci_spi->base + SPIBUF);
+
+                                davinci_spi->get_rx(buf_val, davinci_spi);
+
+                                count--;
+                                if (count <= 0)
+                                        break;
+                        }
+                } else {        /* Receive in Interrupt mode */
+                        int i;
+
+                        for (i = 0; i < davinci_spi->count; i++) {
+                                set_io_bits(davinci_spi->base + SPIINT,
+                                                SPIINT_BITERR_INTR
+                                                | SPIINT_OVRRUN_INTR
+                                                | SPIINT_RX_INTR);
+
+                                iowrite32(data1_reg_val,
+                                                davinci_spi->base + SPIDAT1);
+
+                                while (ioread32(davinci_spi->base + SPIINT) &
+                                                SPIINT_RX_INTR)
+                                        cpu_relax();
+                        }
+                        iowrite32((data1_reg_val & 0x0ffcffff),
+                                        davinci_spi->base + SPIDAT1);
+                }
+        }
+
+        /*
+         * Check for bit error, desync error,parity error,timeout error and
+         * receive overflow errors
+         */
+        int_status = ioread32(davinci_spi->base + SPIFLG);
+
+        ret = davinci_spi_check_error(davinci_spi, int_status);
+        if (ret != 0)
+                return ret;
+
+        /* SPI Framework maintains the count only in bytes so convert back */
+        davinci_spi->count *= conv;
+
+        return t->len;
+}
+
+#define DAVINCI_DMA_DATA_TYPE_S8        0x01
+#define DAVINCI_DMA_DATA_TYPE_S16       0x02
+#define DAVINCI_DMA_DATA_TYPE_S32       0x04
+
+static int davinci_spi_bufs_dma(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct davinci_spi *davinci_spi;
+        int int_status = 0;
+        int count, temp_count;
+        u8 conv = 1;
+        u8 tmp;
+        u32 data1_reg_val;
+        struct davinci_spi_dma *davinci_spi_dma;
+        int word_len, data_type, ret;
+        unsigned long tx_reg, rx_reg;
+        struct davinci_spi_platform_data *pdata;
+        struct device *sdev;
+
+        davinci_spi = spi_master_get_devdata(spi->master);
+        pdata = davinci_spi->pdata;
+        sdev = davinci_spi->bitbang.master->dev.parent;
+
+        davinci_spi_dma = &davinci_spi->dma_channels[spi->chip_select];
+
+        tx_reg = (unsigned long)davinci_spi->pbase + SPIDAT1;
+        rx_reg = (unsigned long)davinci_spi->pbase + SPIBUF;
+
+        davinci_spi->tx = t->tx_buf;
+        davinci_spi->rx = t->rx_buf;
+
+        /* convert len to words based on bits_per_word */
+        conv = davinci_spi->slave[spi->chip_select].bytes_per_word;
+        davinci_spi->count = t->len / conv;
+
+        INIT_COMPLETION(davinci_spi->done);
+
+        init_completion(&davinci_spi_dma->dma_rx_completion);
+        init_completion(&davinci_spi_dma->dma_tx_completion);
+
+        word_len = conv * 8;
+
+        if (word_len <= 8)
+                data_type = DAVINCI_DMA_DATA_TYPE_S8;
+        else if (word_len <= 16)
+                data_type = DAVINCI_DMA_DATA_TYPE_S16;
+        else if (word_len <= 32)
+                data_type = DAVINCI_DMA_DATA_TYPE_S32;
+        else
+                return -EINVAL;
+
+        ret = davinci_spi_bufs_prep(spi, davinci_spi);
+        if (ret)
+                return ret;
+
+        /* Put delay val if required */
+        iowrite32(0 | (pdata->c2tdelay << SPI_C2TDELAY_SHIFT) |
+                        (pdata->t2cdelay << SPI_T2CDELAY_SHIFT),
+                        davinci_spi->base + SPIDELAY);
+
+        count = davinci_spi->count;     /* the number of elements */
+        data1_reg_val = pdata->cs_hold << SPIDAT1_CSHOLD_SHIFT;
+
+        /* CS default = 0xFF */
+        tmp = ~(0x1 << spi->chip_select);
+
+        clear_io_bits(davinci_spi->base + SPIDEF, ~tmp);
+
+        data1_reg_val |= tmp << SPIDAT1_CSNR_SHIFT;
+
+        /* disable all interrupts for dma transfers */
+        clear_io_bits(davinci_spi->base + SPIINT, SPIINT_MASKALL);
+        /* Disable SPI to write configuration bits in SPIDAT */
+        clear_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
+        iowrite32(data1_reg_val, davinci_spi->base + SPIDAT1);
+        /* Enable SPI */
+        set_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
+
+        while ((ioread32(davinci_spi->base + SPIBUF)
+                                & SPIBUF_RXEMPTY_MASK) == 0)
+                cpu_relax();
+
+
+        if (t->tx_buf) {
+                t->tx_dma = dma_map_single(&spi->dev, (void *)t->tx_buf, count,
+                                DMA_TO_DEVICE);
+                if (dma_mapping_error(&spi->dev, t->tx_dma)) {
+                        dev_dbg(sdev, "Unable to DMA map a %d bytes"
+                                " TX buffer\n", count);
+                        return -ENOMEM;
+                }
+                temp_count = count;
+        } else {
+                /* We need TX clocking for RX transaction */
+                t->tx_dma = dma_map_single(&spi->dev,
+                                (void *)davinci_spi->tmp_buf, count + 1,
+                                DMA_TO_DEVICE);
+                if (dma_mapping_error(&spi->dev, t->tx_dma)) {
+                        dev_dbg(sdev, "Unable to DMA map a %d bytes"
+                                " TX tmp buffer\n", count);
+                        return -ENOMEM;
+                }
+                temp_count = count + 1;
+        }
+
+        edma_set_transfer_params(davinci_spi_dma->dma_tx_channel,
+                                        data_type, temp_count, 1, 0, ASYNC);
+        edma_set_dest(davinci_spi_dma->dma_tx_channel, tx_reg, INCR, W8BIT);
+        edma_set_src(davinci_spi_dma->dma_tx_channel, t->tx_dma, INCR, W8BIT);
+        edma_set_src_index(davinci_spi_dma->dma_tx_channel, data_type, 0);
+        edma_set_dest_index(davinci_spi_dma->dma_tx_channel, 0, 0);
+
+        if (t->rx_buf) {
+                /* initiate transaction */
+                iowrite32(data1_reg_val, davinci_spi->base + SPIDAT1);
+
+                t->rx_dma = dma_map_single(&spi->dev, (void *)t->rx_buf, count,
+                                DMA_FROM_DEVICE);
+                if (dma_mapping_error(&spi->dev, t->rx_dma)) {
+                        dev_dbg(sdev, "Couldn't DMA map a %d bytes RX buffer\n",
+                                        count);
+                        if (t->tx_buf != NULL)
+                                dma_unmap_single(NULL, t->tx_dma,
+                                                 count, DMA_TO_DEVICE);
+                        return -ENOMEM;
+                }
+                edma_set_transfer_params(davinci_spi_dma->dma_rx_channel,
+                                data_type, count, 1, 0, ASYNC);
+                edma_set_src(davinci_spi_dma->dma_rx_channel,
+                                rx_reg, INCR, W8BIT);
+                edma_set_dest(davinci_spi_dma->dma_rx_channel,
+                                t->rx_dma, INCR, W8BIT);
+                edma_set_src_index(davinci_spi_dma->dma_rx_channel, 0, 0);
+                edma_set_dest_index(davinci_spi_dma->dma_rx_channel,
+                                data_type, 0);
+        }
+
+        if ((t->tx_buf) || (t->rx_buf))
+                edma_start(davinci_spi_dma->dma_tx_channel);
+
+        if (t->rx_buf)
+                edma_start(davinci_spi_dma->dma_rx_channel);
+
+        if ((t->rx_buf) || (t->tx_buf))
+                davinci_spi_set_dma_req(spi, 1);
+
+        if (t->tx_buf)
+                wait_for_completion_interruptible(
+                                &davinci_spi_dma->dma_tx_completion);
+
+        if (t->rx_buf)
+                wait_for_completion_interruptible(
+                                &davinci_spi_dma->dma_rx_completion);
+
+        dma_unmap_single(NULL, t->tx_dma, temp_count, DMA_TO_DEVICE);
+
+        if (t->rx_buf)
+                dma_unmap_single(NULL, t->rx_dma, count, DMA_FROM_DEVICE);
+
+        /*
+         * Check for bit error, desync error,parity error,timeout error and
+         * receive overflow errors
+         */
+        int_status = ioread32(davinci_spi->base + SPIFLG);
+
+        ret = davinci_spi_check_error(davinci_spi, int_status);
+        if (ret != 0)
+                return ret;
+
+        /* SPI Framework maintains the count only in bytes so convert back */
+        davinci_spi->count *= conv;
+
+        return t->len;
+}
+
+/**
+ * davinci_spi_irq - IRQ handler for DaVinci SPI
+ * @irq: IRQ number for this SPI Master
+ * @context_data: structure for SPI Master controller davinci_spi
+ */
+static irqreturn_t davinci_spi_irq(s32 irq, void *context_data)
+{
+        struct davinci_spi *davinci_spi = context_data;
+        u32 int_status, rx_data = 0;
+        irqreturn_t ret = IRQ_NONE;
+
+        int_status = ioread32(davinci_spi->base + SPIFLG);
+
+        while ((int_status & SPIFLG_RX_INTR_MASK)) {
+                if (likely(int_status & SPIFLG_RX_INTR_MASK)) {
+                        ret = IRQ_HANDLED;
+
+                        rx_data = ioread32(davinci_spi->base + SPIBUF);
+                        davinci_spi->get_rx(rx_data, davinci_spi);
+
+                        /* Disable Receive Interrupt */
+                        iowrite32(~(SPIINT_RX_INTR | SPIINT_TX_INTR),
+                                        davinci_spi->base + SPIINT);
+                } else
+                        (void)davinci_spi_check_error(davinci_spi, int_status);
+
+                int_status = ioread32(davinci_spi->base + SPIFLG);
+        }
+
+        return ret;
+}
+
+/**
+ * davinci_spi_probe - probe function for SPI Master Controller
+ * @pdev: platform_device structure which contains plateform specific data
+ */
+static int davinci_spi_probe(struct platform_device *pdev)
+{
+        struct spi_master *master;
+        struct davinci_spi *davinci_spi;
+        struct davinci_spi_platform_data *pdata;
+        struct resource *r, *mem;
+        resource_size_t dma_rx_chan = SPI_NO_RESOURCE;
+        resource_size_t dma_tx_chan = SPI_NO_RESOURCE;
+        resource_size_t dma_eventq = SPI_NO_RESOURCE;
+        int i = 0, ret = 0;
+
+        pdata = pdev->dev.platform_data;
+        if (pdata == NULL) {
+                ret = -ENODEV;
+                goto err;
+        }
+
+        master = spi_alloc_master(&pdev->dev, sizeof(struct davinci_spi));
+        if (master == NULL) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        dev_set_drvdata(&pdev->dev, master);
+
+        davinci_spi = spi_master_get_devdata(master);
+        if (davinci_spi == NULL) {
+                ret = -ENOENT;
+                goto free_master;
+        }
+
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (r == NULL) {
+                ret = -ENOENT;
+                goto free_master;
+        }
+
+        davinci_spi->pbase = r->start;
+        davinci_spi->region_size = resource_size(r);
+        davinci_spi->pdata = pdata;
+
+        mem = request_mem_region(r->start, davinci_spi->region_size,
+                                        pdev->name);
+        if (mem == NULL) {
+                ret = -EBUSY;
+                goto free_master;
+        }
+
+        davinci_spi->base = (struct davinci_spi_reg __iomem *)
+                        ioremap(r->start, davinci_spi->region_size);
+        if (davinci_spi->base == NULL) {
+                ret = -ENOMEM;
+                goto release_region;
+        }
+
+        davinci_spi->irq = platform_get_irq(pdev, 0);
+        if (davinci_spi->irq <= 0) {
+                ret = -EINVAL;
+                goto unmap_io;
+        }
+
+        ret = request_irq(davinci_spi->irq, davinci_spi_irq, IRQF_DISABLED,
+                          dev_name(&pdev->dev), davinci_spi);
+        if (ret)
+                goto unmap_io;
+
+        /* Allocate tmp_buf for tx_buf */
+        davinci_spi->tmp_buf = kzalloc(SPI_BUFSIZ, GFP_KERNEL);
+        if (davinci_spi->tmp_buf == NULL) {
+                ret = -ENOMEM;
+                goto irq_free;
+        }
+
+        davinci_spi->bitbang.master = spi_master_get(master);
+        if (davinci_spi->bitbang.master == NULL) {
+                ret = -ENODEV;
+                goto free_tmp_buf;
+        }
+
+        davinci_spi->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(davinci_spi->clk)) {
+                ret = -ENODEV;
+                goto put_master;
+        }
+        clk_enable(davinci_spi->clk);
+
+
+        master->bus_num = pdev->id;
+        master->num_chipselect = pdata->num_chipselect;
+        master->setup = davinci_spi_setup;
+        master->cleanup = davinci_spi_cleanup;
+
+        davinci_spi->bitbang.chipselect = davinci_spi_chipselect;
+        davinci_spi->bitbang.setup_transfer = davinci_spi_setup_transfer;
+
+        davinci_spi->version = pdata->version;
+        use_dma = pdata->use_dma;
+
+        davinci_spi->bitbang.flags = SPI_NO_CS | SPI_LSB_FIRST | SPI_LOOP;
+        if (davinci_spi->version == SPI_VERSION_2)
+                davinci_spi->bitbang.flags |= SPI_READY;
+
+        if (use_dma) {
+                        r = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+                        if (r)
+                                dma_rx_chan = r->start;
+                        r = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+                        if (r)
+                                dma_tx_chan = r->start;
+                        r = platform_get_resource(pdev, IORESOURCE_DMA, 2);
+                        if (r)
+                                dma_eventq = r->start;
+        }
+
+        if (!use_dma ||
+            dma_rx_chan == SPI_NO_RESOURCE ||
+            dma_tx_chan == SPI_NO_RESOURCE ||
+            dma_eventq  == SPI_NO_RESOURCE) {
+                davinci_spi->bitbang.txrx_bufs = davinci_spi_bufs_pio;
+                use_dma = 0;
+        } else {
+                davinci_spi->bitbang.txrx_bufs = davinci_spi_bufs_dma;
+                davinci_spi->dma_channels = kzalloc(master->num_chipselect
+                                * sizeof(struct davinci_spi_dma), GFP_KERNEL);
+                if (davinci_spi->dma_channels == NULL) {
+                        ret = -ENOMEM;
+                        goto free_clk;
+                }
+
+                for (i = 0; i < master->num_chipselect; i++) {
+                        davinci_spi->dma_channels[i].dma_rx_channel = -1;
+                        davinci_spi->dma_channels[i].dma_rx_sync_dev =
+                                dma_rx_chan;
+                        davinci_spi->dma_channels[i].dma_tx_channel = -1;
+                        davinci_spi->dma_channels[i].dma_tx_sync_dev =
+                                dma_tx_chan;
+                        davinci_spi->dma_channels[i].eventq = dma_eventq;
+                }
+                dev_info(&pdev->dev, "DaVinci SPI driver in EDMA mode\n"
+                                "Using RX channel = %d , TX channel = %d and "
+                                "event queue = %d", dma_rx_chan, dma_tx_chan,
+                                dma_eventq);
+        }
+
+        davinci_spi->get_rx = davinci_spi_rx_buf_u8;
+        davinci_spi->get_tx = davinci_spi_tx_buf_u8;
+
+        init_completion(&davinci_spi->done);
+
+        /* Reset In/OUT SPI module */
+        iowrite32(0, davinci_spi->base + SPIGCR0);
+        udelay(100);
+        iowrite32(1, davinci_spi->base + SPIGCR0);
+
+        /* Clock internal */
+        if (davinci_spi->pdata->clk_internal)
+                set_io_bits(davinci_spi->base + SPIGCR1,
+                                SPIGCR1_CLKMOD_MASK);
+        else
+                clear_io_bits(davinci_spi->base + SPIGCR1,
+                                SPIGCR1_CLKMOD_MASK);
+
+        /* master mode default */
+        set_io_bits(davinci_spi->base + SPIGCR1, SPIGCR1_MASTER_MASK);
+
+        if (davinci_spi->pdata->intr_level)
+                iowrite32(SPI_INTLVL_1, davinci_spi->base + SPILVL);
+        else
+                iowrite32(SPI_INTLVL_0, davinci_spi->base + SPILVL);
+
+        ret = spi_bitbang_start(&davinci_spi->bitbang);
+        if (ret)
+                goto free_clk;
+
+        dev_info(&pdev->dev, "Controller at 0x%p \n", davinci_spi->base);
+
+        if (!pdata->poll_mode)
+                dev_info(&pdev->dev, "Operating in interrupt mode"
+                        " using IRQ %d\n", davinci_spi->irq);
+
+        return ret;
+
+free_clk:
+        clk_disable(davinci_spi->clk);
+        clk_put(davinci_spi->clk);
+put_master:
+        spi_master_put(master);
+free_tmp_buf:
+        kfree(davinci_spi->tmp_buf);
+irq_free:
+        free_irq(davinci_spi->irq, davinci_spi);
+unmap_io:
+        iounmap(davinci_spi->base);
+release_region:
+        release_mem_region(davinci_spi->pbase, davinci_spi->region_size);
+free_master:
+        kfree(master);
+err:
+        return ret;
+}
+
+/**
+ * davinci_spi_remove - remove function for SPI Master Controller
+ * @pdev: platform_device structure which contains plateform specific data
+ *
+ * This function will do the reverse action of davinci_spi_probe function
+ * It will free the IRQ and SPI controller's memory region.
+ * It will also call spi_bitbang_stop to destroy the work queue which was
+ * created by spi_bitbang_start.
+ */
+static int __exit davinci_spi_remove(struct platform_device *pdev)
+{
+        struct davinci_spi *davinci_spi;
+        struct spi_master *master;
+
+        master = dev_get_drvdata(&pdev->dev);
+        davinci_spi = spi_master_get_devdata(master);
+
+        spi_bitbang_stop(&davinci_spi->bitbang);
+
+        clk_disable(davinci_spi->clk);
+        clk_put(davinci_spi->clk);
+        spi_master_put(master);
+        kfree(davinci_spi->tmp_buf);
+        free_irq(davinci_spi->irq, davinci_spi);
+        iounmap(davinci_spi->base);
+        release_mem_region(davinci_spi->pbase, davinci_spi->region_size);
+
+        return 0;
+}
+
+static struct platform_driver davinci_spi_driver = {
+        .driver.name = "spi_davinci",
+        .remove = __exit_p(davinci_spi_remove),
+};
+
+static int __init davinci_spi_init(void)
+{
+        return platform_driver_probe(&davinci_spi_driver, davinci_spi_probe);
+}
+module_init(davinci_spi_init);
+
+static void __exit davinci_spi_exit(void)
+{
+        platform_driver_unregister(&davinci_spi_driver);
+}
+module_exit(davinci_spi_exit);
+
+MODULE_DESCRIPTION("TI DaVinci SPI Master Controller Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/spi/dw_spi.c b/drivers/spi/dw_spi.c
index 31620fae77be..8ed38f1d6c18 100644
--- a/drivers/spi/dw_spi.c
+++ b/drivers/spi/dw_spi.c
@@ -152,6 +152,7 @@ static void mrst_spi_debugfs_remove(struct dw_spi *dws)
 #else
 static inline int mrst_spi_debugfs_init(struct dw_spi *dws)
 {
+        return 0;
 }
 
 static inline void mrst_spi_debugfs_remove(struct dw_spi *dws)
@@ -161,14 +162,14 @@ static inline void mrst_spi_debugfs_remove(struct dw_spi *dws)
 
 static void wait_till_not_busy(struct dw_spi *dws)
 {
-        unsigned long end = jiffies + usecs_to_jiffies(1000);
+        unsigned long end = jiffies + 1 + usecs_to_jiffies(1000);
 
         while (time_before(jiffies, end)) {
                 if (!(dw_readw(dws, sr) & SR_BUSY))
                         return;
         }
         dev_err(&dws->master->dev,
-                "DW SPI: Stutus keeps busy for 1000us after a read/write!\n");
+                "DW SPI: Status keeps busy for 1000us after a read/write!\n");
 }
 
 static void flush(struct dw_spi *dws)
@@ -358,6 +359,8 @@ static void transfer_complete(struct dw_spi *dws)
 static irqreturn_t interrupt_transfer(struct dw_spi *dws)
 {
         u16 irq_status, irq_mask = 0x3f;
+        u32 int_level = dws->fifo_len / 2;
+        u32 left;
 
         irq_status = dw_readw(dws, isr) & irq_mask;
         /* Error handling */
@@ -369,22 +372,23 @@ static irqreturn_t interrupt_transfer(struct dw_spi *dws)
                 return IRQ_HANDLED;
         }
 
-        /* INT comes from tx */
-        if (dws->tx && (irq_status & SPI_INT_TXEI)) {
-                while (dws->tx < dws->tx_end)
+        if (irq_status & SPI_INT_TXEI) {
+                spi_mask_intr(dws, SPI_INT_TXEI);
+
+                left = (dws->tx_end - dws->tx) / dws->n_bytes;
+                left = (left > int_level) ? int_level : left;
+
+                while (left--)
                         dws->write(dws);
+                dws->read(dws);
 
-                if (dws->tx == dws->tx_end) {
-                        spi_mask_intr(dws, SPI_INT_TXEI);
+                /* Re-enable the IRQ if there is still data left to tx */
+                if (dws->tx_end > dws->tx)
+                        spi_umask_intr(dws, SPI_INT_TXEI);
+                else
                         transfer_complete(dws);
-                }
         }
 
-        /* INT comes from rx */
-        if (dws->rx && (irq_status & SPI_INT_RXFI)) {
-                if (dws->read(dws))
-                        transfer_complete(dws);
-        }
         return IRQ_HANDLED;
 }
 
@@ -404,12 +408,9 @@ static irqreturn_t dw_spi_irq(int irq, void *dev_id)
 /* Must be called inside pump_transfers() */
 static void poll_transfer(struct dw_spi *dws)
 {
-        if (dws->tx) {
-                while (dws->write(dws))
-                        dws->read(dws);
-        }
+        while (dws->write(dws))
+                dws->read(dws);
 
-        dws->read(dws);
         transfer_complete(dws);
 }
 
@@ -428,6 +429,7 @@ static void pump_transfers(unsigned long data)
         u8 bits = 0;
         u8 imask = 0;
         u8 cs_change = 0;
+        u16 txint_level = 0;
         u16 clk_div = 0;
         u32 speed = 0;
         u32 cr0 = 0;
@@ -438,6 +440,9 @@ static void pump_transfers(unsigned long data)
         chip = dws->cur_chip;
         spi = message->spi;
 
+        if (unlikely(!chip->clk_div))
+                chip->clk_div = dws->max_freq / chip->speed_hz;
+
         if (message->state == ERROR_STATE) {
                 message->status = -EIO;
                 goto early_exit;
@@ -492,7 +497,7 @@ static void pump_transfers(unsigned long data)
 
                         /* clk_div doesn't support odd number */
                         clk_div = dws->max_freq / speed;
-                        clk_div = (clk_div >> 1) << 1;
+                        clk_div = (clk_div + 1) & 0xfffe;
 
                         chip->speed_hz = speed;
                         chip->clk_div = clk_div;
@@ -532,14 +537,35 @@ static void pump_transfers(unsigned long data)
         }
         message->state = RUNNING_STATE;
 
+        /*
+         * Adjust transfer mode if necessary. Requires platform dependent
+         * chipselect mechanism.
+         */
+        if (dws->cs_control) {
+                if (dws->rx && dws->tx)
+                        chip->tmode = 0x00;
+                else if (dws->rx)
+                        chip->tmode = 0x02;
+                else
+                        chip->tmode = 0x01;
+
+                cr0 &= ~(0x3 << SPI_MODE_OFFSET);
+                cr0 |= (chip->tmode << SPI_TMOD_OFFSET);
+        }
+
         /* Check if current transfer is a DMA transaction */
         dws->dma_mapped = map_dma_buffers(dws);
 
+        /*
+         * Interrupt mode
+         * we only need set the TXEI IRQ, as TX/RX always happen syncronizely
+         */
         if (!dws->dma_mapped && !chip->poll_mode) {
-                if (dws->rx)
-                        imask |= SPI_INT_RXFI;
-                if (dws->tx)
-                        imask |= SPI_INT_TXEI;
+                int templen = dws->len / dws->n_bytes;
+                txint_level = dws->fifo_len / 2;
+                txint_level = (templen > txint_level) ? txint_level : templen;
+
+                imask |= SPI_INT_TXEI;
                 dws->transfer_handler = interrupt_transfer;
         }
 
@@ -549,21 +575,23 @@ static void pump_transfers(unsigned long data)
          *      2. clk_div is changed
          *      3. control value changes
          */
-        if (dw_readw(dws, ctrl0) != cr0 || cs_change || clk_div) {
+        if (dw_readw(dws, ctrl0) != cr0 || cs_change || clk_div || imask) {
                 spi_enable_chip(dws, 0);
 
                 if (dw_readw(dws, ctrl0) != cr0)
                         dw_writew(dws, ctrl0, cr0);
 
+                spi_set_clk(dws, clk_div ? clk_div : chip->clk_div);
+                spi_chip_sel(dws, spi->chip_select);
+
                 /* Set the interrupt mask, for poll mode just diable all int */
                 spi_mask_intr(dws, 0xff);
-                if (!chip->poll_mode)
+                if (imask)
                         spi_umask_intr(dws, imask);
+                if (txint_level)
+                        dw_writew(dws, txfltr, txint_level);
 
-                spi_set_clk(dws, clk_div ? clk_div : chip->clk_div);
-                spi_chip_sel(dws, spi->chip_select);
                 spi_enable_chip(dws, 1);
-
                 if (cs_change)
                         dws->prev_chip = chip;
         }
@@ -712,11 +740,11 @@ static int dw_spi_setup(struct spi_device *spi)
         }
         chip->bits_per_word = spi->bits_per_word;
 
+        if (!spi->max_speed_hz) {
+                dev_err(&spi->dev, "No max speed HZ parameter\n");
+                return -EINVAL;
+        }
         chip->speed_hz = spi->max_speed_hz;
-        if (chip->speed_hz)
-                chip->clk_div = 25000000 / chip->speed_hz;
-        else
-                chip->clk_div = 8;      /* default value */
 
         chip->tmode = 0; /* Tx & Rx */
         /* Default SPI mode is SCPOL = 0, SCPH = 0 */
@@ -735,7 +763,7 @@ static void dw_spi_cleanup(struct spi_device *spi)
         kfree(chip);
 }
 
-static int __init init_queue(struct dw_spi *dws)
+static int __devinit init_queue(struct dw_spi *dws)
 {
         INIT_LIST_HEAD(&dws->queue);
         spin_lock_init(&dws->lock);
@@ -817,6 +845,22 @@ static void spi_hw_init(struct dw_spi *dws)
         spi_mask_intr(dws, 0xff);
         spi_enable_chip(dws, 1);
         flush(dws);
+
+        /*
+         * Try to detect the FIFO depth if not set by interface driver,
+         * the depth could be from 2 to 256 from HW spec
+         */
+        if (!dws->fifo_len) {
+                u32 fifo;
+                for (fifo = 2; fifo <= 257; fifo++) {
+                        dw_writew(dws, txfltr, fifo);
+                        if (fifo != dw_readw(dws, txfltr))
+                                break;
+                }
+
+                dws->fifo_len = (fifo == 257) ? 0 : fifo;
+                dw_writew(dws, txfltr, 0);
+        }
 }
 
 int __devinit dw_spi_add_host(struct dw_spi *dws)
@@ -913,6 +957,7 @@ void __devexit dw_spi_remove_host(struct dw_spi *dws)
         /* Disconnect from the SPI framework */
         spi_unregister_master(dws->master);
 }
+EXPORT_SYMBOL(dw_spi_remove_host);
 
 int dw_spi_suspend_host(struct dw_spi *dws)
 {
diff --git a/drivers/spi/dw_spi_mmio.c b/drivers/spi/dw_spi_mmio.c
new file mode 100644
index 000000000000..e35b45ac5174
--- /dev/null
+++ b/drivers/spi/dw_spi_mmio.c
@@ -0,0 +1,147 @@
+/*
+ * dw_spi_mmio.c - Memory-mapped interface driver for DW SPI Core
+ *
+ * Copyright (c) 2010, Octasic semiconductor.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ */
+
+#include <linux/clk.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/spi/dw_spi.h>
+#include <linux/spi/spi.h>
+
+#define DRIVER_NAME "dw_spi_mmio"
+
+struct dw_spi_mmio {
+        struct dw_spi  dws;
+        struct clk     *clk;
+};
+
+static int __devinit dw_spi_mmio_probe(struct platform_device *pdev)
+{
+        struct dw_spi_mmio *dwsmmio;
+        struct dw_spi *dws;
+        struct resource *mem, *ioarea;
+        int ret;
+
+        dwsmmio = kzalloc(sizeof(struct dw_spi_mmio), GFP_KERNEL);
+        if (!dwsmmio) {
+                ret = -ENOMEM;
+                goto err_end;
+        }
+
+        dws = &dwsmmio->dws;
+
+        /* Get basic io resource and map it */
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!mem) {
+                dev_err(&pdev->dev, "no mem resource?\n");
+                ret = -EINVAL;
+                goto err_kfree;
+        }
+
+        ioarea = request_mem_region(mem->start, resource_size(mem),
+                        pdev->name);
+        if (!ioarea) {
+                dev_err(&pdev->dev, "SPI region already claimed\n");
+                ret = -EBUSY;
+                goto err_kfree;
+        }
+
+        dws->regs = ioremap_nocache(mem->start, resource_size(mem));
+        if (!dws->regs) {
+                dev_err(&pdev->dev, "SPI region already mapped\n");
+                ret = -ENOMEM;
+                goto err_release_reg;
+        }
+
+        dws->irq = platform_get_irq(pdev, 0);
+        if (dws->irq < 0) {
+                dev_err(&pdev->dev, "no irq resource?\n");
+                ret = dws->irq; /* -ENXIO */
+                goto err_unmap;
+        }
+
+        dwsmmio->clk = clk_get(&pdev->dev, NULL);
+        if (!dwsmmio->clk) {
+                ret = -ENODEV;
+                goto err_irq;
+        }
+        clk_enable(dwsmmio->clk);
+
+        dws->parent_dev = &pdev->dev;
+        dws->bus_num = 0;
+        dws->num_cs = 4;
+        dws->max_freq = clk_get_rate(dwsmmio->clk);
+
+        ret = dw_spi_add_host(dws);
+        if (ret)
+                goto err_clk;
+
+        platform_set_drvdata(pdev, dwsmmio);
+        return 0;
+
+err_clk:
+        clk_disable(dwsmmio->clk);
+        clk_put(dwsmmio->clk);
+        dwsmmio->clk = NULL;
+err_irq:
+        free_irq(dws->irq, dws);
+err_unmap:
+        iounmap(dws->regs);
+err_release_reg:
+        release_mem_region(mem->start, resource_size(mem));
+err_kfree:
+        kfree(dwsmmio);
+err_end:
+        return ret;
+}
+
+static int __devexit dw_spi_mmio_remove(struct platform_device *pdev)
+{
+        struct dw_spi_mmio *dwsmmio = platform_get_drvdata(pdev);
+        struct resource *mem;
+
+        platform_set_drvdata(pdev, NULL);
+
+        clk_disable(dwsmmio->clk);
+        clk_put(dwsmmio->clk);
+        dwsmmio->clk = NULL;
+
+        free_irq(dwsmmio->dws.irq, &dwsmmio->dws);
+        dw_spi_remove_host(&dwsmmio->dws);
+        iounmap(dwsmmio->dws.regs);
+        kfree(dwsmmio);
+
+        mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(mem->start, resource_size(mem));
+        return 0;
+}
+
+static struct platform_driver dw_spi_mmio_driver = {
+        .remove         = __devexit_p(dw_spi_mmio_remove),
+        .driver         = {
+                .name   = DRIVER_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init dw_spi_mmio_init(void)
+{
+        return platform_driver_probe(&dw_spi_mmio_driver, dw_spi_mmio_probe);
+}
+module_init(dw_spi_mmio_init);
+
+static void __exit dw_spi_mmio_exit(void)
+{
+        platform_driver_unregister(&dw_spi_mmio_driver);
+}
+module_exit(dw_spi_mmio_exit);
+
+MODULE_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>");
+MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/dw_spi_pci.c b/drivers/spi/dw_spi_pci.c
index 34ba69161734..1f0735f9cc76 100644
--- a/drivers/spi/dw_spi_pci.c
+++ b/drivers/spi/dw_spi_pci.c
@@ -73,6 +73,7 @@ static int __devinit spi_pci_probe(struct pci_dev *pdev,
         dws->num_cs = 4;
         dws->max_freq = 25000000;       /* for Moorestwon */
         dws->irq = pdev->irq;
+        dws->fifo_len = 40;             /* FIFO has 40 words buffer */
 
         ret = dw_spi_add_host(dws);
         if (ret)
@@ -98,6 +99,7 @@ static void __devexit spi_pci_remove(struct pci_dev *pdev)
         struct dw_spi_pci *dwpci = pci_get_drvdata(pdev);
 
         pci_set_drvdata(pdev, NULL);
+        dw_spi_remove_host(&dwpci->dws);
         iounmap(dwpci->dws.regs);
         pci_release_region(pdev, 0);
         kfree(dwpci);
diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index f50c81df336a..04747868d6c4 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -503,7 +503,7 @@ static int __exit mpc52xx_psc_spi_of_remove(struct of_device *op)
         return mpc52xx_psc_spi_do_remove(&op->dev);
 }
 
-static struct of_device_id mpc52xx_psc_spi_of_match[] = {
+static const struct of_device_id mpc52xx_psc_spi_of_match[] = {
         { .compatible = "fsl,mpc5200-psc-spi", },
         { .compatible = "mpc5200-psc-spi", }, /* old */
         {}
diff --git a/drivers/spi/mpc52xx_spi.c b/drivers/spi/mpc52xx_spi.c
index 45bfe6458173..6eab46537a0a 100644
--- a/drivers/spi/mpc52xx_spi.c
+++ b/drivers/spi/mpc52xx_spi.c
@@ -550,7 +550,7 @@ static int __devexit mpc52xx_spi_remove(struct of_device *op)
         return 0;
 }
 
-static struct of_device_id mpc52xx_spi_match[] __devinitdata = {
+static const struct of_device_id mpc52xx_spi_match[] __devinitconst = {
         { .compatible = "fsl,mpc5200-spi", },
         {}
 };
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 1893f1e96dc4..0ddbbe45e834 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -469,7 +469,7 @@ static int spi_imx_setup(struct spi_device *spi)
         struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
         int gpio = spi_imx->chipselect[spi->chip_select];
 
-        pr_debug("%s: mode %d, %u bpw, %d hz\n", __func__,
+        dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n", __func__,
                  spi->mode, spi->bits_per_word, spi->max_speed_hz);
 
         if (gpio >= 0)
diff --git a/drivers/spi/spi_mpc8xxx.c b/drivers/spi/spi_mpc8xxx.c
index 1fb2a6ea328c..4f0cc9d457e0 100644
--- a/drivers/spi/spi_mpc8xxx.c
+++ b/drivers/spi/spi_mpc8xxx.c
@@ -365,7 +365,7 @@ int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
 
         if ((mpc8xxx_spi->spibrg / hz) > 64) {
                 cs->hw_mode |= SPMODE_DIV16;
-                pm = mpc8xxx_spi->spibrg / (hz * 64);
+                pm = (mpc8xxx_spi->spibrg - 1) / (hz * 64) + 1;
 
                 WARN_ONCE(pm > 16, "%s: Requested speed is too low: %d Hz. "
                           "Will use %d Hz instead.\n", dev_name(&spi->dev),
@@ -373,7 +373,7 @@ int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                 if (pm > 16)
                         pm = 16;
         } else
-                pm = mpc8xxx_spi->spibrg / (hz * 4);
+                pm = (mpc8xxx_spi->spibrg - 1) / (hz * 4) + 1;
         if (pm)
                 pm--;
 
@@ -1328,7 +1328,7 @@ static struct of_platform_driver of_mpc8xxx_spi_driver = {
 static int __devinit plat_mpc8xxx_spi_probe(struct platform_device *pdev)
 {
         struct resource *mem;
-        unsigned int irq;
+        int irq;
         struct spi_master *master;
 
         if (!pdev->dev.platform_data)
@@ -1339,7 +1339,7 @@ static int __devinit plat_mpc8xxx_spi_probe(struct platform_device *pdev)
                 return -EINVAL;
 
         irq = platform_get_irq(pdev, 0);
-        if (!irq)
+        if (irq <= 0)
                 return -EINVAL;
 
         master = mpc8xxx_spi_probe(&pdev->dev, mem, irq);
diff --git a/drivers/spi/spi_ppc4xx.c b/drivers/spi/spi_ppc4xx.c
index 140a18d6cf3e..6d8d4026a07a 100644
--- a/drivers/spi/spi_ppc4xx.c
+++ b/drivers/spi/spi_ppc4xx.c
@@ -578,7 +578,7 @@ static int __exit spi_ppc4xx_of_remove(struct of_device *op)
         return 0;
 }
 
-static struct of_device_id spi_ppc4xx_of_match[] = {
+static const struct of_device_id spi_ppc4xx_of_match[] = {
         { .compatible = "ibm,ppc4xx-spi", },
         {},
 };
diff --git a/drivers/spi/spi_s3c64xx.c b/drivers/spi/spi_s3c64xx.c
index 88a456dba967..97365815a729 100644
--- a/drivers/spi/spi_s3c64xx.c
+++ b/drivers/spi/spi_s3c64xx.c
@@ -28,7 +28,7 @@
 #include <linux/spi/spi.h>
 
 #include <mach/dma.h>
-#include <plat/spi.h>
+#include <plat/s3c64xx-spi.h>
 
 /* Registers and bit-fields */
 
@@ -137,6 +137,7 @@
 /**
  * struct s3c64xx_spi_driver_data - Runtime info holder for SPI driver.
  * @clk: Pointer to the spi clock.
+ * @src_clk: Pointer to the clock used to generate SPI signals.
  * @master: Pointer to the SPI Protocol master.
  * @workqueue: Work queue for the SPI xfer requests.
  * @cntrlr_info: Platform specific data for the controller this driver manages.
@@ -157,10 +158,11 @@
 struct s3c64xx_spi_driver_data {
         void __iomem                    *regs;
         struct clk                      *clk;
+        struct clk                      *src_clk;
         struct platform_device          *pdev;
         struct spi_master               *master;
         struct workqueue_struct         *workqueue;
-        struct s3c64xx_spi_cntrlr_info  *cntrlr_info;
+        struct s3c64xx_spi_info  *cntrlr_info;
         struct spi_device               *tgl_spi;
         struct work_struct              work;
         struct list_head                queue;
@@ -180,7 +182,7 @@ static struct s3c2410_dma_client s3c64xx_spi_dma_client = {
 
 static void flush_fifo(struct s3c64xx_spi_driver_data *sdd)
 {
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         unsigned long loops;
         u32 val;
@@ -225,7 +227,7 @@ static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
                                 struct spi_device *spi,
                                 struct spi_transfer *xfer, int dma_mode)
 {
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         u32 modecfg, chcfg;
 
@@ -298,19 +300,20 @@ static inline void enable_cs(struct s3c64xx_spi_driver_data *sdd,
                 if (sdd->tgl_spi != spi) { /* if last mssg on diff device */
                         /* Deselect the last toggled device */
                         cs = sdd->tgl_spi->controller_data;
-                        cs->set_level(spi->mode & SPI_CS_HIGH ? 0 : 1);
+                        cs->set_level(cs->line,
+                                        spi->mode & SPI_CS_HIGH ? 0 : 1);
                 }
                 sdd->tgl_spi = NULL;
         }
 
         cs = spi->controller_data;
-        cs->set_level(spi->mode & SPI_CS_HIGH ? 1 : 0);
+        cs->set_level(cs->line, spi->mode & SPI_CS_HIGH ? 1 : 0);
 }
 
 static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd,
                                 struct spi_transfer *xfer, int dma_mode)
 {
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         unsigned long val;
         int ms;
@@ -384,12 +387,11 @@ static inline void disable_cs(struct s3c64xx_spi_driver_data *sdd,
         if (sdd->tgl_spi == spi)
                 sdd->tgl_spi = NULL;
 
-        cs->set_level(spi->mode & SPI_CS_HIGH ? 0 : 1);
+        cs->set_level(cs->line, spi->mode & SPI_CS_HIGH ? 0 : 1);
 }
 
 static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
 {
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         u32 val;
 
@@ -435,7 +437,7 @@ static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
         /* Configure Clock */
         val = readl(regs + S3C64XX_SPI_CLK_CFG);
         val &= ~S3C64XX_SPI_PSR_MASK;
-        val |= ((clk_get_rate(sci->src_clk) / sdd->cur_speed / 2 - 1)
+        val |= ((clk_get_rate(sdd->src_clk) / sdd->cur_speed / 2 - 1)
                         & S3C64XX_SPI_PSR_MASK);
         writel(val, regs + S3C64XX_SPI_CLK_CFG);
 
@@ -558,7 +560,7 @@ static void s3c64xx_spi_unmap_mssg(struct s3c64xx_spi_driver_data *sdd,
 static void handle_msg(struct s3c64xx_spi_driver_data *sdd,
                                         struct spi_message *msg)
 {
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         struct spi_device *spi = msg->spi;
         struct s3c64xx_spi_csinfo *cs = spi->controller_data;
         struct spi_transfer *xfer;
@@ -632,8 +634,8 @@ static void handle_msg(struct s3c64xx_spi_driver_data *sdd,
                 S3C64XX_SPI_DEACT(sdd);
 
                 if (status) {
-                        dev_err(&spi->dev, "I/O Error: \
-                                rx-%d tx-%d res:rx-%c tx-%c len-%d\n",
+                        dev_err(&spi->dev, "I/O Error: "
+                                "rx-%d tx-%d res:rx-%c tx-%c len-%d\n",
                                 xfer->rx_buf ? 1 : 0, xfer->tx_buf ? 1 : 0,
                                 (sdd->state & RXBUSY) ? 'f' : 'p',
                                 (sdd->state & TXBUSY) ? 'f' : 'p',
@@ -786,7 +788,7 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
 {
         struct s3c64xx_spi_csinfo *cs = spi->controller_data;
         struct s3c64xx_spi_driver_data *sdd;
-        struct s3c64xx_spi_cntrlr_info *sci;
+        struct s3c64xx_spi_info *sci;
         struct spi_message *msg;
         u32 psr, speed;
         unsigned long flags;
@@ -831,17 +833,17 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
         }
 
         /* Check if we can provide the requested rate */
-        speed = clk_get_rate(sci->src_clk) / 2 / (0 + 1); /* Max possible */
+        speed = clk_get_rate(sdd->src_clk) / 2 / (0 + 1); /* Max possible */
 
         if (spi->max_speed_hz > speed)
                 spi->max_speed_hz = speed;
 
-        psr = clk_get_rate(sci->src_clk) / 2 / spi->max_speed_hz - 1;
+        psr = clk_get_rate(sdd->src_clk) / 2 / spi->max_speed_hz - 1;
         psr &= S3C64XX_SPI_PSR_MASK;
         if (psr == S3C64XX_SPI_PSR_MASK)
                 psr--;
 
-        speed = clk_get_rate(sci->src_clk) / 2 / (psr + 1);
+        speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
         if (spi->max_speed_hz < speed) {
                 if (psr+1 < S3C64XX_SPI_PSR_MASK) {
                         psr++;
@@ -851,7 +853,7 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
                 }
         }
 
-        speed = clk_get_rate(sci->src_clk) / 2 / (psr + 1);
+        speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
         if (spi->max_speed_hz >= speed)
                 spi->max_speed_hz = speed;
         else
@@ -867,7 +869,7 @@ setup_exit:
 
 static void s3c64xx_spi_hwinit(struct s3c64xx_spi_driver_data *sdd, int channel)
 {
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         unsigned int val;
 
@@ -902,7 +904,7 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
 {
         struct resource *mem_res, *dmatx_res, *dmarx_res;
         struct s3c64xx_spi_driver_data *sdd;
-        struct s3c64xx_spi_cntrlr_info *sci;
+        struct s3c64xx_spi_info *sci;
         struct spi_master *master;
         int ret;
 
@@ -1000,18 +1002,15 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
                 goto err4;
         }
 
-        if (sci->src_clk_nr == S3C64XX_SPI_SRCCLK_PCLK)
-                sci->src_clk = sdd->clk;
-        else
-                sci->src_clk = clk_get(&pdev->dev, sci->src_clk_name);
-        if (IS_ERR(sci->src_clk)) {
+        sdd->src_clk = clk_get(&pdev->dev, sci->src_clk_name);
+        if (IS_ERR(sdd->src_clk)) {
                 dev_err(&pdev->dev,
                         "Unable to acquire clock '%s'\n", sci->src_clk_name);
-                ret = PTR_ERR(sci->src_clk);
+                ret = PTR_ERR(sdd->src_clk);
                 goto err5;
         }
 
-        if (sci->src_clk != sdd->clk && clk_enable(sci->src_clk)) {
+        if (clk_enable(sdd->src_clk)) {
                 dev_err(&pdev->dev, "Couldn't enable clock '%s'\n",
                                                         sci->src_clk_name);
                 ret = -EBUSY;
@@ -1040,11 +1039,10 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
                 goto err8;
         }
 
-        dev_dbg(&pdev->dev, "Samsung SoC SPI Driver loaded for Bus SPI-%d \
-                                        with %d Slaves attached\n",
+        dev_dbg(&pdev->dev, "Samsung SoC SPI Driver loaded for Bus SPI-%d "
+                                        "with %d Slaves attached\n",
                                         pdev->id, master->num_chipselect);
-        dev_dbg(&pdev->dev, "\tIOmem=[0x%x-0x%x]\
-                                        \tDMA=[Rx-%d, Tx-%d]\n",
+        dev_dbg(&pdev->dev, "\tIOmem=[0x%x-0x%x]\tDMA=[Rx-%d, Tx-%d]\n",
                                         mem_res->end, mem_res->start,
                                         sdd->rx_dmach, sdd->tx_dmach);
 
@@ -1053,11 +1051,9 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
 err8:
         destroy_workqueue(sdd->workqueue);
 err7:
-        if (sci->src_clk != sdd->clk)
-                clk_disable(sci->src_clk);
+        clk_disable(sdd->src_clk);
 err6:
-        if (sci->src_clk != sdd->clk)
-                clk_put(sci->src_clk);
+        clk_put(sdd->src_clk);
 err5:
         clk_disable(sdd->clk);
 err4:
@@ -1078,7 +1074,6 @@ static int s3c64xx_spi_remove(struct platform_device *pdev)
 {
         struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
         struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
         struct resource *mem_res;
         unsigned long flags;
 
@@ -1093,11 +1088,8 @@ static int s3c64xx_spi_remove(struct platform_device *pdev)
 
         destroy_workqueue(sdd->workqueue);
 
-        if (sci->src_clk != sdd->clk)
-                clk_disable(sci->src_clk);
-
-        if (sci->src_clk != sdd->clk)
-                clk_put(sci->src_clk);
+        clk_disable(sdd->src_clk);
+        clk_put(sdd->src_clk);
 
         clk_disable(sdd->clk);
         clk_put(sdd->clk);
@@ -1105,7 +1097,8 @@ static int s3c64xx_spi_remove(struct platform_device *pdev)
         iounmap((void *) sdd->regs);
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        release_mem_region(mem_res->start, resource_size(mem_res));
+        if (mem_res != NULL)
+                release_mem_region(mem_res->start, resource_size(mem_res));
 
         platform_set_drvdata(pdev, NULL);
         spi_master_put(master);
@@ -1118,8 +1111,6 @@ static int s3c64xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
         struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
-        struct s3c64xx_spi_csinfo *cs;
         unsigned long flags;
 
         spin_lock_irqsave(&sdd->lock, flags);
@@ -1130,9 +1121,7 @@ static int s3c64xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
                 msleep(10);
 
         /* Disable the clock */
-        if (sci->src_clk != sdd->clk)
-                clk_disable(sci->src_clk);
-
+        clk_disable(sdd->src_clk);
         clk_disable(sdd->clk);
 
         sdd->cur_speed = 0; /* Output Clock is stopped */
@@ -1144,15 +1133,13 @@ static int s3c64xx_spi_resume(struct platform_device *pdev)
 {
         struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
         struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
-        struct s3c64xx_spi_cntrlr_info *sci = sdd->cntrlr_info;
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         unsigned long flags;
 
         sci->cfg_gpio(pdev);
 
         /* Enable the clock */
-        if (sci->src_clk != sdd->clk)
-                clk_enable(sci->src_clk);
-
+        clk_enable(sdd->src_clk);
         clk_enable(sdd->clk);
 
         s3c64xx_spi_hwinit(sdd, pdev->id);
diff --git a/drivers/spi/spi_sh_msiof.c b/drivers/spi/spi_sh_msiof.c
index 30973ec16a93..d93b66743ba7 100644
--- a/drivers/spi/spi_sh_msiof.c
+++ b/drivers/spi/spi_sh_msiof.c
@@ -20,12 +20,12 @@
 #include <linux/bitmap.h>
 #include <linux/clk.h>
 #include <linux/io.h>
+#include <linux/err.h>
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
 #include <linux/spi/sh_msiof.h>
 
-#include <asm/spi.h>
 #include <asm/unaligned.h>
 
 struct sh_msiof_spi_priv {
diff --git a/drivers/spi/spi_stmp.c b/drivers/spi/spi_stmp.c
index 2552bb364005..fadff76eb7e0 100644
--- a/drivers/spi/spi_stmp.c
+++ b/drivers/spi/spi_stmp.c
@@ -76,7 +76,7 @@ struct stmp_spi {
                         break;                                          \
                 }                                                       \
                 cpu_relax();                                            \
-        } while (time_before(end_jiffies, jiffies));                    \
+        } while (time_before(jiffies, end_jiffies));                    \
         succeeded;                                                      \
         })
 
diff --git a/drivers/spi/xilinx_spi.c b/drivers/spi/xilinx_spi.c
index 9f386379c169..1b47363cb73f 100644
--- a/drivers/spi/xilinx_spi.c
+++ b/drivers/spi/xilinx_spi.c
@@ -93,6 +93,26 @@ struct xilinx_spi {
         void (*rx_fn) (struct xilinx_spi *);
 };
 
+static void xspi_write32(u32 val, void __iomem *addr)
+{
+        iowrite32(val, addr);
+}
+
+static unsigned int xspi_read32(void __iomem *addr)
+{
+        return ioread32(addr);
+}
+
+static void xspi_write32_be(u32 val, void __iomem *addr)
+{
+        iowrite32be(val, addr);
+}
+
+static unsigned int xspi_read32_be(void __iomem *addr)
+{
+        return ioread32be(addr);
+}
+
 static void xspi_tx8(struct xilinx_spi *xspi)
 {
         xspi->write_fn(*xspi->tx_ptr, xspi->regs + XSPI_TXD_OFFSET);
@@ -374,11 +394,11 @@ struct spi_master *xilinx_spi_init(struct device *dev, struct resource *mem,
         xspi->mem = *mem;
         xspi->irq = irq;
         if (pdata->little_endian) {
-                xspi->read_fn = ioread32;
-                xspi->write_fn = iowrite32;
+                xspi->read_fn = xspi_read32;
+                xspi->write_fn = xspi_write32;
         } else {
-                xspi->read_fn = ioread32be;
-                xspi->write_fn = iowrite32be;
+                xspi->read_fn = xspi_read32_be;
+                xspi->write_fn = xspi_write32_be;
         }
         xspi->bits_per_word = pdata->bits_per_word;
         if (xspi->bits_per_word == 8) {
diff --git a/drivers/spi/xilinx_spi_of.c b/drivers/spi/xilinx_spi_of.c
index 71dc3adc0495..ed34a8d419c7 100644
--- a/drivers/spi/xilinx_spi_of.c
+++ b/drivers/spi/xilinx_spi_of.c
@@ -99,7 +99,7 @@ static int __exit xilinx_spi_of_remove(struct of_device *op)
         return xilinx_spi_remove(op);
 }
 
-static struct of_device_id xilinx_spi_of_match[] = {
+static const struct of_device_id xilinx_spi_of_match[] = {
         { .compatible = "xlnx,xps-spi-2.00.a", },
         { .compatible = "xlnx,xps-spi-2.00.b", },
         {}
diff --git a/drivers/ssb/main.c b/drivers/ssb/main.c
index 5681ebed9c65..03dfd27c4bfb 100644
--- a/drivers/ssb/main.c
+++ b/drivers/ssb/main.c
@@ -494,8 +494,7 @@ static int ssb_devices_register(struct ssb_bus *bus)
 #endif
                         break;
                 case SSB_BUSTYPE_SDIO:
-#ifdef CONFIG_SSB_SDIO
-                        sdev->irq = bus->host_sdio->dev.irq;
+#ifdef CONFIG_SSB_SDIOHOST
                         dev->parent = &bus->host_sdio->dev;
 #endif
                         break;
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index 6e8bcdfd23b4..a678186f218f 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -1312,9 +1312,9 @@ static int processcompl(struct async *as, void __user * __user *arg)
         void __user *addr = as->userurb;
         unsigned int i;
 
-        if (as->userbuffer)
+        if (as->userbuffer && urb->actual_length)
                 if (copy_to_user(as->userbuffer, urb->transfer_buffer,
-                                 urb->transfer_buffer_length))
+                                 urb->actual_length))
                         goto err_out;
         if (put_user(as->status, &userurb->status))
                 goto err_out;
@@ -1334,14 +1334,11 @@ static int processcompl(struct async *as, void __user * __user *arg)
                 }
         }
 
-        free_async(as);
-
         if (put_user(addr, (void __user * __user *)arg))
                 return -EFAULT;
         return 0;
 
 err_out:
-        free_async(as);
         return -EFAULT;
 }
 
@@ -1371,8 +1368,11 @@ static struct async *reap_as(struct dev_state *ps)
 static int proc_reapurb(struct dev_state *ps, void __user *arg)
 {
         struct async *as = reap_as(ps);
-        if (as)
-                return processcompl(as, (void __user * __user *)arg);
+        if (as) {
+                int retval = processcompl(as, (void __user * __user *)arg);
+                free_async(as);
+                return retval;
+        }
         if (signal_pending(current))
                 return -EINTR;
         return -EIO;
@@ -1380,11 +1380,16 @@ static int proc_reapurb(struct dev_state *ps, void __user *arg)
 
 static int proc_reapurbnonblock(struct dev_state *ps, void __user *arg)
 {
+        int retval;
         struct async *as;
 
-        if (!(as = async_getcompleted(ps)))
-                return -EAGAIN;
-        return processcompl(as, (void __user * __user *)arg);
+        as = async_getcompleted(ps);
+        retval = -EAGAIN;
+        if (as) {
+                retval = processcompl(as, (void __user * __user *)arg);
+                free_async(as);
+        }
+        return retval;
 }
 
 #ifdef CONFIG_COMPAT
@@ -1475,9 +1480,9 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
         void __user *addr = as->userurb;
         unsigned int i;
 
-        if (as->userbuffer)
+        if (as->userbuffer && urb->actual_length)
                 if (copy_to_user(as->userbuffer, urb->transfer_buffer,
-                                 urb->transfer_buffer_length))
+                                 urb->actual_length))
                         return -EFAULT;
         if (put_user(as->status, &userurb->status))
                 return -EFAULT;
@@ -1497,7 +1502,6 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
                 }
         }
 
-        free_async(as);
         if (put_user(ptr_to_compat(addr), (u32 __user *)arg))
                 return -EFAULT;
         return 0;
@@ -1506,8 +1510,11 @@ static int processcompl_compat(struct async *as, void __user * __user *arg)
 static int proc_reapurb_compat(struct dev_state *ps, void __user *arg)
 {
         struct async *as = reap_as(ps);
-        if (as)
-                return processcompl_compat(as, (void __user * __user *)arg);
+        if (as) {
+                int retval = processcompl_compat(as, (void __user * __user *)arg);
+                free_async(as);
+                return retval;
+        }
         if (signal_pending(current))
                 return -EINTR;
         return -EIO;
@@ -1515,11 +1522,16 @@ static int proc_reapurb_compat(struct dev_state *ps, void __user *arg)
 
 static int proc_reapurbnonblock_compat(struct dev_state *ps, void __user *arg)
 {
+        int retval;
         struct async *as;
 
-        if (!(as = async_getcompleted(ps)))
-                return -EAGAIN;
-        return processcompl_compat(as, (void __user * __user *)arg);
+        retval = -EAGAIN;
+        as = async_getcompleted(ps);
+        if (as) {
+                retval = processcompl_compat(as, (void __user * __user *)arg);
+                free_async(as);
+        }
+        return retval;
 }
 
 
diff --git a/drivers/usb/gadget/f_eem.c b/drivers/usb/gadget/f_eem.c
index 0a577d5694fd..d4f0db58a8ad 100644
--- a/drivers/usb/gadget/f_eem.c
+++ b/drivers/usb/gadget/f_eem.c
@@ -358,7 +358,7 @@ done:
          * b15:         bmType (0 == data)
          */
         len = skb->len;
-        put_unaligned_le16((len & 0x3FFF) | BIT(14), skb_push(skb, 2));
+        put_unaligned_le16(len & 0x3FFF, skb_push(skb, 2));
 
         /* add a zero-length EEM packet, if needed */
         if (padlen)
@@ -464,7 +464,6 @@ static int eem_unwrap(struct gether *port,
                         }
 
                         /* validate CRC */
-                        crc = get_unaligned_le32(skb->data + len - ETH_FCS_LEN);
                         if (header & BIT(14)) {
                                 crc = get_unaligned_le32(skb->data + len
                                                         - ETH_FCS_LEN);
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
index 429560100b10..76496f5d272c 100644
--- a/drivers/usb/gadget/multi.c
+++ b/drivers/usb/gadget/multi.c
@@ -29,7 +29,7 @@
 #if defined USB_ETH_RNDIS
 #  undef USB_ETH_RNDIS
 #endif
-#ifdef CONFIG_USB_ETH_RNDIS
+#ifdef CONFIG_USB_G_MULTI_RNDIS
 #  define USB_ETH_RNDIS y
 #endif
 
diff --git a/drivers/usb/gadget/r8a66597-udc.c b/drivers/usb/gadget/r8a66597-udc.c
index e220fb8091a3..8b45145b9136 100644
--- a/drivers/usb/gadget/r8a66597-udc.c
+++ b/drivers/usb/gadget/r8a66597-udc.c
@@ -26,6 +26,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/err.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index 4b5dbd0127f5..5fc80a104150 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -2582,6 +2582,7 @@ err:
         hsotg->gadget.dev.driver = NULL;
         return ret;
 }
+EXPORT_SYMBOL(usb_gadget_register_driver);
 
 int usb_gadget_unregister_driver(struct usb_gadget_driver *driver)
 {
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index c75d9270c752..19372673bf09 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -196,7 +196,9 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                         if (hostpc_reg) {
                                 u32     t3;
 
+                                spin_unlock_irq(&ehci->lock);
                                 msleep(5);/* 5ms for HCD enter low pwr mode */
+                                spin_lock_irq(&ehci->lock);
                                 t3 = ehci_readl(ehci, hostpc_reg);
                                 ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
                                 t3 = ehci_readl(ehci, hostpc_reg);
@@ -904,17 +906,18 @@ static int ehci_hub_control (
                         if ((temp & PORT_PE) == 0
                                         || (temp & PORT_RESET) != 0)
                                 goto error;
-                        ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
+
                         /* After above check the port must be connected.
                          * Set appropriate bit thus could put phy into low power
                          * mode if we have hostpc feature
                          */
+                        temp &= ~PORT_WKCONN_E;
+                        temp |= PORT_WKDISC_E | PORT_WKOC_E;
+                        ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
                         if (hostpc_reg) {
-                                temp &= ~PORT_WKCONN_E;
-                                temp |= (PORT_WKDISC_E | PORT_WKOC_E);
-                                ehci_writel(ehci, temp | PORT_SUSPEND,
-                                                        status_reg);
+                                spin_unlock_irqrestore(&ehci->lock, flags);
                                 msleep(5);/* 5ms for HCD enter low pwr mode */
+                                spin_lock_irqsave(&ehci->lock, flags);
                                 temp1 = ehci_readl(ehci, hostpc_reg);
                                 ehci_writel(ehci, temp1 | HOSTPC_PHCD,
                                         hostpc_reg);
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index d224ab467a40..e1232890c78b 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -105,7 +105,7 @@ void fhci_ep0_free(struct fhci_usb *usb)
                 if (ep->td_base)
                         cpm_muram_free(cpm_muram_offset(ep->td_base));
 
-                if (ep->conf_frame_Q) {
+                if (kfifo_initialized(&ep->conf_frame_Q)) {
                         size = cq_howmany(&ep->conf_frame_Q);
                         for (; size; size--) {
                                 struct packet *pkt = cq_get(&ep->conf_frame_Q);
@@ -115,7 +115,7 @@ void fhci_ep0_free(struct fhci_usb *usb)
                         cq_delete(&ep->conf_frame_Q);
                 }
 
-                if (ep->empty_frame_Q) {
+                if (kfifo_initialized(&ep->empty_frame_Q)) {
                         size = cq_howmany(&ep->empty_frame_Q);
                         for (; size; size--) {
                                 struct packet *pkt = cq_get(&ep->empty_frame_Q);
@@ -125,7 +125,7 @@ void fhci_ep0_free(struct fhci_usb *usb)
                         cq_delete(&ep->empty_frame_Q);
                 }
 
-                if (ep->dummy_packets_Q) {
+                if (kfifo_initialized(&ep->dummy_packets_Q)) {
                         size = cq_howmany(&ep->dummy_packets_Q);
                         for (; size; size--) {
                                 u8 *buff = cq_get(&ep->dummy_packets_Q);
diff --git a/drivers/usb/misc/sisusbvga/sisusb.c b/drivers/usb/misc/sisusbvga/sisusb.c
index 0025847743f3..8b37a4b9839e 100644
--- a/drivers/usb/misc/sisusbvga/sisusb.c
+++ b/drivers/usb/misc/sisusbvga/sisusb.c
@@ -3245,6 +3245,7 @@ static struct usb_device_id sisusb_table [] = {
         { USB_DEVICE(0x0711, 0x0902) },
         { USB_DEVICE(0x0711, 0x0903) },
         { USB_DEVICE(0x0711, 0x0918) },
+        { USB_DEVICE(0x0711, 0x0920) },
         { USB_DEVICE(0x182d, 0x021c) },
         { USB_DEVICE(0x182d, 0x0269) },
         { }
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index de56b3d743d7..3d2d3e549bd1 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -44,6 +44,7 @@ config ISP1301_OMAP
 config USB_ULPI
         bool "Generic ULPI Transceiver Driver"
         depends on ARM
+        select USB_OTG_UTILS
         help
           Enable this to support ULPI connected USB OTG transceivers which
           are likely found on embedded boards.
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 216f187582ab..7638828e7317 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -50,7 +50,7 @@
  * Version Information
  */
 #define DRIVER_VERSION "v1.5.0"
-#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>, Andreas Mohr"
 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 
 static int debug;
@@ -145,10 +145,15 @@ static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
 
 
 
+/*
+ * Device ID not listed? Test via module params product/vendor or
+ * /sys/bus/usb/ftdi_sio/new_id, then send patch/report!
+ */
 static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
@@ -552,9 +557,16 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
         /*
-         * Due to many user requests for multiple ELV devices we enable
-         * them by default.
+         * ELV devices:
          */
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
@@ -571,11 +583,17 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
         { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
         { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
         { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
@@ -697,6 +715,7 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
         { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
         { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
+        { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
         { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index da92b4952ffb..c8951aeed983 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -38,6 +38,8 @@
 /* www.candapter.com Ewert Energy Systems CANdapter device */
 #define FTDI_CANDAPTER_PID 0x9F80 /* Product Id */
 
+#define FTDI_NXTCAM_PID         0xABB8 /* NXTCam for Mindstorms NXT */
+
 /* OOCDlink by Joern Kaipf <joernk@web.de>
  * (http://www.joernonline.de/dw/doku.php?id=start&idx=projects:oocdlink) */
 #define FTDI_OOCDLINK_PID       0xbaf8  /* Amontec JTAGkey */
@@ -161,22 +163,37 @@
 /*
  * ELV USB devices submitted by Christian Abt of ELV (www.elv.de).
  * All of these devices use FTDI's vendor ID (0x0403).
+ * Further IDs taken from ELV Windows .inf file.
  *
  * The previously included PID for the UO 100 module was incorrect.
  * In fact, that PID was for ELV's UR 100 USB-RS232 converter (0xFB58).
  *
  * Armin Laeuger originally sent the PID for the UM 100 module.
  */
+#define FTDI_ELV_USR_PID        0xE000  /* ELV Universal-Sound-Recorder */
+#define FTDI_ELV_MSM1_PID       0xE001  /* ELV Mini-Sound-Modul */
+#define FTDI_ELV_KL100_PID      0xE002  /* ELV Kfz-Leistungsmesser KL 100 */
+#define FTDI_ELV_WS550_PID      0xE004  /* WS 550 */
+#define FTDI_ELV_EC3000_PID     0xE006  /* ENERGY CONTROL 3000 USB */
+#define FTDI_ELV_WS888_PID      0xE008  /* WS 888 */
+#define FTDI_ELV_TWS550_PID     0xE009  /* Technoline WS 550 */
+#define FTDI_ELV_FEM_PID        0xE00A  /* Funk Energie Monitor */
 #define FTDI_ELV_FHZ1300PC_PID  0xE0E8  /* FHZ 1300 PC */
 #define FTDI_ELV_WS500_PID      0xE0E9  /* PC-Wetterstation (WS 500) */
 #define FTDI_ELV_HS485_PID      0xE0EA  /* USB to RS-485 adapter */
+#define FTDI_ELV_UMS100_PID     0xE0EB  /* ELV USB Master-Slave Schaltsteckdose UMS 100 */
+#define FTDI_ELV_TFD128_PID     0xE0EC  /* ELV Temperatur-Feuchte-Datenlogger TFD 128 */
+#define FTDI_ELV_FM3RX_PID      0xE0ED  /* ELV Messwertuebertragung FM3 RX */
+#define FTDI_ELV_WS777_PID      0xE0EE  /* Conrad WS 777 */
 #define FTDI_ELV_EM1010PC_PID   0xE0EF  /* Engery monitor EM 1010 PC */
 #define FTDI_ELV_CSI8_PID       0xE0F0  /* Computer-Schalt-Interface (CSI 8) */
 #define FTDI_ELV_EM1000DL_PID   0xE0F1  /* PC-Datenlogger fuer Energiemonitor (EM 1000 DL) */
 #define FTDI_ELV_PCK100_PID     0xE0F2  /* PC-Kabeltester (PCK 100) */
 #define FTDI_ELV_RFP500_PID     0xE0F3  /* HF-Leistungsmesser (RFP 500) */
 #define FTDI_ELV_FS20SIG_PID    0xE0F4  /* Signalgeber (FS 20 SIG) */
+#define FTDI_ELV_UTP8_PID       0xE0F5  /* ELV UTP 8 */
 #define FTDI_ELV_WS300PC_PID    0xE0F6  /* PC-Wetterstation (WS 300 PC) */
+#define FTDI_ELV_WS444PC_PID    0xE0F7  /* Conrad WS 444 PC */
 #define FTDI_PHI_FISCO_PID      0xE40B  /* PHI Fisco USB to Serial cable */
 #define FTDI_ELV_UAD8_PID       0xF068  /* USB-AD-Wandler (UAD 8) */
 #define FTDI_ELV_UDA7_PID       0xF069  /* USB-DA-Wandler (UDA 7) */
@@ -968,6 +985,7 @@
 #define PAPOUCH_VID                     0x5050  /* Vendor ID */
 #define PAPOUCH_TMU_PID                 0x0400  /* TMU USB Thermometer */
 #define PAPOUCH_QUIDO4x4_PID            0x0900  /* Quido 4/4 Module */
+#define PAPOUCH_AD4USB_PID              0x8003  /* AD4USB Measurement Module */
 
 /*
  * Marvell SheevaPlug
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index ac1b6449fb6a..3eb6143bb646 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -298,6 +298,7 @@ static struct usb_device_id id_table [] = {
         { USB_DEVICE(0x1199, 0x68A3),   /* Sierra Wireless Direct IP modems */
           .driver_info = (kernel_ulong_t)&direct_ip_interface_blacklist
         },
+       { USB_DEVICE(0x413C, 0x08133) }, /* Dell Computer Corp. Wireless 5720 VZW Mobile Broadband (EVDO Rev-A) Minicard GPS Port */
 
         { }
 };
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index c932f9053188..49575fba3756 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -941,7 +941,7 @@ UNUSUAL_DEV(  0x07ab, 0xfccd, 0x0000, 0x9999,
 UNUSUAL_DEV(  0x07af, 0x0004, 0x0100, 0x0133,
                 "Microtech",
                 "USB-SCSI-DB25",
-                US_SC_SCSI, US_PR_BULK, usb_stor_euscsi_init,
+                US_SC_DEVICE, US_PR_DEVICE, usb_stor_euscsi_init,
                 US_FL_SCM_MULT_TARG ), 
 
 UNUSUAL_DEV(  0x07af, 0x0005, 0x0100, 0x0100,
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index e9f995486ec1..bbeeb92a2131 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -78,7 +78,7 @@ MODULE_AUTHOR("Matthew Dharm <mdharm-usb@one-eyed-alien.net>");
 MODULE_DESCRIPTION("USB Mass Storage driver for Linux");
 MODULE_LICENSE("GPL");
 
-static unsigned int delay_use = 5;
+static unsigned int delay_use = 1;
 module_param(delay_use, uint, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(delay_use, "seconds to delay before using a new device");
 
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index e4e4d433b007..9ee67d6da710 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1931,22 +1931,22 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
                          * PowerMac2,2 summer 2000 iMacs
                          * PowerMac4,1 january 2001 iMacs "flower power"
                          */
-                        if (machine_is_compatible("PowerMac2,1") ||
-                            machine_is_compatible("PowerMac2,2") ||
-                            machine_is_compatible("PowerMac4,1"))
+                        if (of_machine_is_compatible("PowerMac2,1") ||
+                            of_machine_is_compatible("PowerMac2,2") ||
+                            of_machine_is_compatible("PowerMac4,1"))
                                 default_vmode = VMODE_1024_768_75;
 
                         /* iBook SE */
-                        if (machine_is_compatible("PowerBook2,2"))
+                        if (of_machine_is_compatible("PowerBook2,2"))
                                 default_vmode = VMODE_800_600_60;
 
                         /* PowerBook Firewire (Pismo), iBook Dual USB */
-                        if (machine_is_compatible("PowerBook3,1") ||
-                            machine_is_compatible("PowerBook4,1"))
+                        if (of_machine_is_compatible("PowerBook3,1") ||
+                            of_machine_is_compatible("PowerBook4,1"))
                                 default_vmode = VMODE_1024_768_60;
 
                         /* PowerBook Titanium */
-                        if (machine_is_compatible("PowerBook3,2"))
+                        if (of_machine_is_compatible("PowerBook3,2"))
                                 default_vmode = VMODE_1152_768_60;
         
                         if (default_cmode > 16) 
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 1ddeb4c34763..e45ab8db2ddc 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2439,7 +2439,7 @@ static int __devinit aty_init(struct fb_info *info)
          * The Apple iBook1 uses non-standard memory frequencies.
          * We detect it and set the frequency manually.
          */
-        if (machine_is_compatible("PowerBook2,1")) {
+        if (of_machine_is_compatible("PowerBook2,1")) {
                 par->pll_limits.mclk = 70;
                 par->pll_limits.xclk = 53;
         }
@@ -2659,7 +2659,7 @@ static int __devinit aty_init(struct fb_info *info)
                       FBINFO_HWACCEL_YPAN;
 
 #ifdef CONFIG_PMAC_BACKLIGHT
-        if (M64_HAS(G3_PB_1_1) && machine_is_compatible("PowerBook1,1")) {
+        if (M64_HAS(G3_PB_1_1) && of_machine_is_compatible("PowerBook1,1")) {
                 /*
                  * these bits let the 101 powerbook
                  * wake up from sleep -- paulus
@@ -2690,9 +2690,9 @@ static int __devinit aty_init(struct fb_info *info)
                                 if (M64_HAS(G3_PB_1024x768))
                                         /* G3 PowerBook with 1024x768 LCD */
                                         default_vmode = VMODE_1024_768_60;
-                                else if (machine_is_compatible("iMac"))
+                                else if (of_machine_is_compatible("iMac"))
                                         default_vmode = VMODE_1024_768_75;
-                                else if (machine_is_compatible("PowerBook2,1"))
+                                else if (of_machine_is_compatible("PowerBook2,1"))
                                         /* iBook with 800x600 LCD */
                                         default_vmode = VMODE_800_600_60;
                                 else
@@ -3104,7 +3104,7 @@ static int __devinit atyfb_setup_sparc(struct pci_dev *pdev,
         }
 
         dp = pci_device_to_OF_node(pdev);
-        if (node == dp->node) {
+        if (node == dp->phandle) {
                 struct fb_var_screeninfo *var = &default_var;
                 unsigned int N, P, Q, M, T, R;
                 u32 v_total, h_total;
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index 1a056adb61c8..fa1198c4ccc5 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -175,9 +175,9 @@ void radeonfb_bl_init(struct radeonfb_info *rinfo)
 
 #ifdef CONFIG_PMAC_BACKLIGHT
         pdata->negative = pdata->negative ||
-                machine_is_compatible("PowerBook4,3") ||
-                machine_is_compatible("PowerBook6,3") ||
-                machine_is_compatible("PowerBook6,5");
+                of_machine_is_compatible("PowerBook4,3") ||
+                of_machine_is_compatible("PowerBook6,3") ||
+                of_machine_is_compatible("PowerBook6,5");
 #endif
 
         rinfo->info->bl_dev = bd;
diff --git a/drivers/video/efifb.c b/drivers/video/efifb.c
index eb12182b2059..d25df51bb0d2 100644
--- a/drivers/video/efifb.c
+++ b/drivers/video/efifb.c
@@ -161,8 +161,17 @@ static int efifb_setcolreg(unsigned regno, unsigned red, unsigned green,
         return 0;
 }
 
+static void efifb_destroy(struct fb_info *info)
+{
+        if (info->screen_base)
+                iounmap(info->screen_base);
+        release_mem_region(info->aperture_base, info->aperture_size);
+        framebuffer_release(info);
+}
+
 static struct fb_ops efifb_ops = {
         .owner          = THIS_MODULE,
+        .fb_destroy     = efifb_destroy,
         .fb_setcolreg   = efifb_setcolreg,
         .fb_fillrect    = cfb_fillrect,
         .fb_copyarea    = cfb_copyarea,
@@ -281,7 +290,7 @@ static int __init efifb_probe(struct platform_device *dev)
         info->par = NULL;
 
         info->aperture_base = efifb_fix.smem_start;
-        info->aperture_size = size_total;
+        info->aperture_size = size_remap;
 
         info->screen_base = ioremap(efifb_fix.smem_start, efifb_fix.smem_len);
         if (!info->screen_base) {
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 505be88c82ae..369f2eebbad1 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -28,7 +28,7 @@
 struct virtio_balloon
 {
         struct virtio_device *vdev;
-        struct virtqueue *inflate_vq, *deflate_vq;
+        struct virtqueue *inflate_vq, *deflate_vq, *stats_vq;
 
         /* Where the ballooning thread waits for config to change. */
         wait_queue_head_t config_change;
@@ -49,6 +49,10 @@ struct virtio_balloon
         /* The array of pfns we tell the Host about. */
         unsigned int num_pfns;
         u32 pfns[256];
+
+        /* Memory statistics */
+        int need_stats_update;
+        struct virtio_balloon_stat stats[VIRTIO_BALLOON_S_NR];
 };
 
 static struct virtio_device_id id_table[] = {
@@ -154,6 +158,72 @@ static void leak_balloon(struct virtio_balloon *vb, size_t num)
         }
 }
 
+static inline void update_stat(struct virtio_balloon *vb, int idx,
+                               u16 tag, u64 val)
+{
+        BUG_ON(idx >= VIRTIO_BALLOON_S_NR);
+        vb->stats[idx].tag = tag;
+        vb->stats[idx].val = val;
+}
+
+#define pages_to_bytes(x) ((u64)(x) << PAGE_SHIFT)
+
+static void update_balloon_stats(struct virtio_balloon *vb)
+{
+        unsigned long events[NR_VM_EVENT_ITEMS];
+        struct sysinfo i;
+        int idx = 0;
+
+        all_vm_events(events);
+        si_meminfo(&i);
+
+        update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_IN,
+                                pages_to_bytes(events[PSWPIN]));
+        update_stat(vb, idx++, VIRTIO_BALLOON_S_SWAP_OUT,
+                                pages_to_bytes(events[PSWPOUT]));
+        update_stat(vb, idx++, VIRTIO_BALLOON_S_MAJFLT, events[PGMAJFAULT]);
+        update_stat(vb, idx++, VIRTIO_BALLOON_S_MINFLT, events[PGFAULT]);
+        update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMFREE,
+                                pages_to_bytes(i.freeram));
+        update_stat(vb, idx++, VIRTIO_BALLOON_S_MEMTOT,
+                                pages_to_bytes(i.totalram));
+}
+
+/*
+ * While most virtqueues communicate guest-initiated requests to the hypervisor,
+ * the stats queue operates in reverse.  The driver initializes the virtqueue
+ * with a single buffer.  From that point forward, all conversations consist of
+ * a hypervisor request (a call to this function) which directs us to refill
+ * the virtqueue with a fresh stats buffer.  Since stats collection can sleep,
+ * we notify our kthread which does the actual work via stats_handle_request().
+ */
+static void stats_request(struct virtqueue *vq)
+{
+        struct virtio_balloon *vb;
+        unsigned int len;
+
+        vb = vq->vq_ops->get_buf(vq, &len);
+        if (!vb)
+                return;
+        vb->need_stats_update = 1;
+        wake_up(&vb->config_change);
+}
+
+static void stats_handle_request(struct virtio_balloon *vb)
+{
+        struct virtqueue *vq;
+        struct scatterlist sg;
+
+        vb->need_stats_update = 0;
+        update_balloon_stats(vb);
+
+        vq = vb->stats_vq;
+        sg_init_one(&sg, vb->stats, sizeof(vb->stats));
+        if (vq->vq_ops->add_buf(vq, &sg, 1, 0, vb) < 0)
+                BUG();
+        vq->vq_ops->kick(vq);
+}
+
 static void virtballoon_changed(struct virtio_device *vdev)
 {
         struct virtio_balloon *vb = vdev->priv;
@@ -190,8 +260,11 @@ static int balloon(void *_vballoon)
                 try_to_freeze();
                 wait_event_interruptible(vb->config_change,
                                          (diff = towards_target(vb)) != 0
+                                         || vb->need_stats_update
                                          || kthread_should_stop()
                                          || freezing(current));
+                if (vb->need_stats_update)
+                        stats_handle_request(vb);
                 if (diff > 0)
                         fill_balloon(vb, diff);
                 else if (diff < 0)
@@ -204,10 +277,10 @@ static int balloon(void *_vballoon)
 static int virtballoon_probe(struct virtio_device *vdev)
 {
         struct virtio_balloon *vb;
-        struct virtqueue *vqs[2];
-        vq_callback_t *callbacks[] = { balloon_ack, balloon_ack };
-        const char *names[] = { "inflate", "deflate" };
-        int err;
+        struct virtqueue *vqs[3];
+        vq_callback_t *callbacks[] = { balloon_ack, balloon_ack, stats_request };
+        const char *names[] = { "inflate", "deflate", "stats" };
+        int err, nvqs;
 
         vdev->priv = vb = kmalloc(sizeof(*vb), GFP_KERNEL);
         if (!vb) {
@@ -219,14 +292,31 @@ static int virtballoon_probe(struct virtio_device *vdev)
         vb->num_pages = 0;
         init_waitqueue_head(&vb->config_change);
         vb->vdev = vdev;
+        vb->need_stats_update = 0;
 
-        /* We expect two virtqueues. */
-        err = vdev->config->find_vqs(vdev, 2, vqs, callbacks, names);
+        /* We expect two virtqueues: inflate and deflate,
+         * and optionally stat. */
+        nvqs = virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ) ? 3 : 2;
+        err = vdev->config->find_vqs(vdev, nvqs, vqs, callbacks, names);
         if (err)
                 goto out_free_vb;
 
         vb->inflate_vq = vqs[0];
         vb->deflate_vq = vqs[1];
+        if (virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_STATS_VQ)) {
+                struct scatterlist sg;
+                vb->stats_vq = vqs[2];
+
+                /*
+                 * Prime this virtqueue with one buffer so the hypervisor can
+                 * use it to signal us later.
+                 */
+                sg_init_one(&sg, vb->stats, sizeof vb->stats);
+                if (vb->stats_vq->vq_ops->add_buf(vb->stats_vq,
+                                                  &sg, 1, 0, vb) < 0)
+                        BUG();
+                vb->stats_vq->vq_ops->kick(vb->stats_vq);
+        }
 
         vb->thread = kthread_run(balloon, vb, "vballoon");
         if (IS_ERR(vb->thread)) {
@@ -264,7 +354,10 @@ static void __devexit virtballoon_remove(struct virtio_device *vdev)
         kfree(vb);
 }
 
-static unsigned int features[] = { VIRTIO_BALLOON_F_MUST_TELL_HOST };
+static unsigned int features[] = {
+        VIRTIO_BALLOON_F_MUST_TELL_HOST,
+        VIRTIO_BALLOON_F_STATS_VQ,
+};
 
 static struct virtio_driver virtio_balloon_driver = {
         .feature_table = features,
diff --git a/drivers/virtio/virtio_pci.c b/drivers/virtio/virtio_pci.c
index 28d9cf7cf72f..1d5191fab62e 100644
--- a/drivers/virtio/virtio_pci.c
+++ b/drivers/virtio/virtio_pci.c
@@ -702,7 +702,7 @@ static struct pci_driver virtio_pci_driver = {
         .name           = "virtio-pci",
         .id_table       = virtio_pci_id_table,
         .probe          = virtio_pci_probe,
-        .remove         = virtio_pci_remove,
+        .remove         = __devexit_p(virtio_pci_remove),
 #ifdef CONFIG_PM
         .suspend        = virtio_pci_suspend,
         .resume         = virtio_pci_resume,
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index fbd2ecde93e4..0db906b3c95d 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -21,6 +21,24 @@
 #include <linux/virtio_config.h>
 #include <linux/device.h>
 
+/* virtio guest is communicating with a virtual "device" that actually runs on
+ * a host processor.  Memory barriers are used to control SMP effects. */
+#ifdef CONFIG_SMP
+/* Where possible, use SMP barriers which are more lightweight than mandatory
+ * barriers, because mandatory barriers control MMIO effects on accesses
+ * through relaxed memory I/O windows (which virtio does not use). */
+#define virtio_mb() smp_mb()
+#define virtio_rmb() smp_rmb()
+#define virtio_wmb() smp_wmb()
+#else
+/* We must force memory ordering even if guest is UP since host could be
+ * running on another CPU, but SMP barriers are defined to barrier() in that
+ * configuration. So fall back to mandatory barriers instead. */
+#define virtio_mb() mb()
+#define virtio_rmb() rmb()
+#define virtio_wmb() wmb()
+#endif
+
 #ifdef DEBUG
 /* For development, we want to crash whenever the ring is screwed. */
 #define BAD_RING(_vq, fmt, args...)                             \
@@ -36,10 +54,9 @@
                         panic("%s:in_use = %i\n",               \
                               (_vq)->vq.name, (_vq)->in_use);   \
                 (_vq)->in_use = __LINE__;                       \
-                mb();                                           \
         } while (0)
 #define END_USE(_vq) \
-        do { BUG_ON(!(_vq)->in_use); (_vq)->in_use = 0; mb(); } while(0)
+        do { BUG_ON(!(_vq)->in_use); (_vq)->in_use = 0; } while(0)
 #else
 #define BAD_RING(_vq, fmt, args...)                             \
         do {                                                    \
@@ -221,13 +238,13 @@ static void vring_kick(struct virtqueue *_vq)
         START_USE(vq);
         /* Descriptors and available array need to be set before we expose the
          * new available array entries. */
-        wmb();
+        virtio_wmb();
 
         vq->vring.avail->idx += vq->num_added;
         vq->num_added = 0;
 
         /* Need to update avail index before checking if we should notify */
-        mb();
+        virtio_mb();
 
         if (!(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY))
                 /* Prod other side to tell it about changes. */
@@ -286,7 +303,7 @@ static void *vring_get_buf(struct virtqueue *_vq, unsigned int *len)
         }
 
         /* Only get used array entries after they have been exposed by host. */
-        rmb();
+        virtio_rmb();
 
         i = vq->vring.used->ring[vq->last_used_idx%vq->vring.num].id;
         *len = vq->vring.used->ring[vq->last_used_idx%vq->vring.num].len;
@@ -324,7 +341,7 @@ static bool vring_enable_cb(struct virtqueue *_vq)
         /* We optimistically turn back on interrupts, then check if there was
          * more to do. */
         vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
-        mb();
+        virtio_mb();
         if (unlikely(more_used(vq))) {
                 END_USE(vq);
                 return false;
@@ -334,6 +351,30 @@ static bool vring_enable_cb(struct virtqueue *_vq)
         return true;
 }
 
+static void *vring_detach_unused_buf(struct virtqueue *_vq)
+{
+        struct vring_virtqueue *vq = to_vvq(_vq);
+        unsigned int i;
+        void *buf;
+
+        START_USE(vq);
+
+        for (i = 0; i < vq->vring.num; i++) {
+                if (!vq->data[i])
+                        continue;
+                /* detach_buf clears data, so grab it now. */
+                buf = vq->data[i];
+                detach_buf(vq, i);
+                END_USE(vq);
+                return buf;
+        }
+        /* That should have freed everything. */
+        BUG_ON(vq->num_free != vq->vring.num);
+
+        END_USE(vq);
+        return NULL;
+}
+
 irqreturn_t vring_interrupt(int irq, void *_vq)
 {
         struct vring_virtqueue *vq = to_vvq(_vq);
@@ -360,6 +401,7 @@ static struct virtqueue_ops vring_vq_ops = {
         .kick = vring_kick,
         .disable_cb = vring_disable_cb,
         .enable_cb = vring_enable_cb,
+        .detach_unused_buf = vring_detach_unused_buf,
 };
 
 struct virtqueue *vring_new_virtqueue(unsigned int num,
@@ -406,8 +448,11 @@ struct virtqueue *vring_new_virtqueue(unsigned int num,
         /* Put everything in free lists. */
         vq->num_free = num;
         vq->free_head = 0;
-        for (i = 0; i < num-1; i++)
+        for (i = 0; i < num-1; i++) {
                 vq->vring.desc[i].next = i+1;
+                vq->data[i] = NULL;
+        }
+        vq->data[i] = NULL;
 
         return &vq->vq;
 }
diff --git a/drivers/watchdog/bfin_wdt.c b/drivers/watchdog/bfin_wdt.c
index c7b3f9df2317..2159e668751c 100644
--- a/drivers/watchdog/bfin_wdt.c
+++ b/drivers/watchdog/bfin_wdt.c
@@ -1,9 +1,8 @@
 /*
  * Blackfin On-Chip Watchdog Driver
- *  Supports BF53[123]/BF53[467]/BF54[2489]/BF561
  *
  * Originally based on softdog.c
- * Copyright 2006-2007 Analog Devices Inc.
+ * Copyright 2006-2010 Analog Devices Inc.
  * Copyright 2006-2007 Michele d'Amico
  * Copyright 1996 Alan Cox <alan@lxorguk.ukuu.org.uk>
  *
@@ -137,13 +136,15 @@ static int bfin_wdt_running(void)
  */
 static int bfin_wdt_set_timeout(unsigned long t)
 {
-        u32 cnt;
+        u32 cnt, max_t, sclk;
         unsigned long flags;
 
-        stampit();
+        sclk = get_sclk();
+        max_t = -1 / sclk;
+        cnt = t * sclk;
+        stamp("maxtimeout=%us newtimeout=%lus (cnt=%#x)", max_t, t, cnt);
 
-        cnt = t * get_sclk();
-        if (cnt < get_sclk()) {
+        if (t > max_t) {
                 printk(KERN_WARNING PFX "timeout value is too large\n");
                 return -EINVAL;
         }