298 files changed, 20506 insertions, 5397 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/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/scan.c b/drivers/acpi/scan.c
index 3e009674f333..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;
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/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/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/sh_cmt.c b/drivers/clocksource/sh_cmt.c
index 6b3e0c2f33e2..6fe4f7701188 100644
--- a/drivers/clocksource/sh_cmt.c
+++ b/drivers/clocksource/sh_cmt.c
@@ -603,18 +603,13 @@ static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
         p->irqaction.handler = sh_cmt_interrupt;
         p->irqaction.dev_id = p;
         p->irqaction.flags = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL;
-        ret = setup_irq(irq, &p->irqaction);
-        if (ret) {
-                pr_err("sh_cmt: failed to request irq %d\n", irq);
-                goto err1;
-        }
 
         /* get hold of clock */
         p->clk = clk_get(&p->pdev->dev, cfg->clk);
         if (IS_ERR(p->clk)) {
                 pr_err("sh_cmt: cannot get clock \"%s\"\n", cfg->clk);
                 ret = PTR_ERR(p->clk);
-                goto err2;
+                goto err1;
         }
 
         if (resource_size(res) == 6) {
@@ -627,14 +622,25 @@ static int sh_cmt_setup(struct sh_cmt_priv *p, struct platform_device *pdev)
                 p->clear_bits = ~0xc000;
         }
 
-        return sh_cmt_register(p, cfg->name,
-                               cfg->clockevent_rating,
-                               cfg->clocksource_rating);
- err2:
-        remove_irq(irq, &p->irqaction);
- err1:
+        ret = sh_cmt_register(p, cfg->name,
+                              cfg->clockevent_rating,
+                              cfg->clocksource_rating);
+        if (ret) {
+                pr_err("sh_cmt: registration failed\n");
+                goto err1;
+        }
+
+        ret = setup_irq(irq, &p->irqaction);
+        if (ret) {
+                pr_err("sh_cmt: failed to request irq %d\n", irq);
+                goto err1;
+        }
+
+        return 0;
+
+err1:
         iounmap(p->mapbase);
- err0:
+err0:
         return ret;
 }
 
diff --git a/drivers/clocksource/sh_mtu2.c b/drivers/clocksource/sh_mtu2.c
index 973e714d6051..4c8a759e60cd 100644
--- a/drivers/clocksource/sh_mtu2.c
+++ b/drivers/clocksource/sh_mtu2.c
@@ -221,15 +221,15 @@ static void sh_mtu2_register_clockevent(struct sh_mtu2_priv *p,
         ced->cpumask = cpumask_of(0);
         ced->set_mode = sh_mtu2_clock_event_mode;
 
+        pr_info("sh_mtu2: %s used for clock events\n", ced->name);
+        clockevents_register_device(ced);
+
         ret = setup_irq(p->irqaction.irq, &p->irqaction);
         if (ret) {
                 pr_err("sh_mtu2: failed to request irq %d\n",
                        p->irqaction.irq);
                 return;
         }
-
-        pr_info("sh_mtu2: %s used for clock events\n", ced->name);
-        clockevents_register_device(ced);
 }
 
 static int sh_mtu2_register(struct sh_mtu2_priv *p, char *name,
diff --git a/drivers/clocksource/sh_tmu.c b/drivers/clocksource/sh_tmu.c
index 93c2322feab7..961f5b5ef6a3 100644
--- a/drivers/clocksource/sh_tmu.c
+++ b/drivers/clocksource/sh_tmu.c
@@ -323,15 +323,15 @@ static void sh_tmu_register_clockevent(struct sh_tmu_priv *p,
         ced->set_next_event = sh_tmu_clock_event_next;
         ced->set_mode = sh_tmu_clock_event_mode;
 
+        pr_info("sh_tmu: %s used for clock events\n", ced->name);
+        clockevents_register_device(ced);
+
         ret = setup_irq(p->irqaction.irq, &p->irqaction);
         if (ret) {
                 pr_err("sh_tmu: failed to request irq %d\n",
                        p->irqaction.irq);
                 return;
         }
-
-        pr_info("sh_tmu: %s used for clock events\n", ced->name);
-        clockevents_register_device(ced);
 }
 
 static int sh_tmu_register(struct sh_tmu_priv *p, char *name,
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/dma/shdma.c b/drivers/dma/shdma.c
index d10cc899c460..b75ce8b84c46 100644
--- a/drivers/dma/shdma.c
+++ b/drivers/dma/shdma.c
@@ -48,23 +48,20 @@ enum sh_dmae_desc_status {
  */
 #define RS_DEFAULT  (RS_DUAL)
 
+/* A bitmask with bits enough for enum sh_dmae_slave_chan_id */
+static unsigned long sh_dmae_slave_used[BITS_TO_LONGS(SHDMA_SLAVE_NUMBER)];
+
 static void sh_dmae_chan_ld_cleanup(struct sh_dmae_chan *sh_chan, bool all);
 
 #define SH_DMAC_CHAN_BASE(id) (dma_base_addr[id])
 static void sh_dmae_writel(struct sh_dmae_chan *sh_dc, u32 data, u32 reg)
 {
-        ctrl_outl(data, (SH_DMAC_CHAN_BASE(sh_dc->id) + reg));
+        ctrl_outl(data, SH_DMAC_CHAN_BASE(sh_dc->id) + reg);
 }
 
 static u32 sh_dmae_readl(struct sh_dmae_chan *sh_dc, u32 reg)
 {
-        return ctrl_inl((SH_DMAC_CHAN_BASE(sh_dc->id) + reg));
-}
-
-static void dmae_init(struct sh_dmae_chan *sh_chan)
-{
-        u32 chcr = RS_DEFAULT; /* default is DUAL mode */
-        sh_dmae_writel(sh_chan, chcr, CHCR);
+        return ctrl_inl(SH_DMAC_CHAN_BASE(sh_dc->id) + reg);
 }
 
 /*
@@ -95,27 +92,30 @@ static int sh_dmae_rst(int id)
         return 0;
 }
 
-static int dmae_is_busy(struct sh_dmae_chan *sh_chan)
+static bool dmae_is_busy(struct sh_dmae_chan *sh_chan)
 {
         u32 chcr = sh_dmae_readl(sh_chan, CHCR);
-        if (chcr & CHCR_DE) {
-                if (!(chcr & CHCR_TE))
-                        return -EBUSY; /* working */
-        }
-        return 0; /* waiting */
+
+        if ((chcr & (CHCR_DE | CHCR_TE)) == CHCR_DE)
+                return true; /* working */
+
+        return false; /* waiting */
 }
 
-static inline unsigned int calc_xmit_shift(struct sh_dmae_chan *sh_chan)
+static unsigned int ts_shift[] = TS_SHIFT;
+static inline unsigned int calc_xmit_shift(u32 chcr)
 {
-        u32 chcr = sh_dmae_readl(sh_chan, CHCR);
-        return ts_shift[(chcr & CHCR_TS_MASK) >> CHCR_TS_SHIFT];
+        int cnt = ((chcr & CHCR_TS_LOW_MASK) >> CHCR_TS_LOW_SHIFT) |
+                ((chcr & CHCR_TS_HIGH_MASK) >> CHCR_TS_HIGH_SHIFT);
+
+        return ts_shift[cnt];
 }
 
 static void dmae_set_reg(struct sh_dmae_chan *sh_chan, struct sh_dmae_regs *hw)
 {
         sh_dmae_writel(sh_chan, hw->sar, SAR);
         sh_dmae_writel(sh_chan, hw->dar, DAR);
-        sh_dmae_writel(sh_chan, hw->tcr >> calc_xmit_shift(sh_chan), TCR);
+        sh_dmae_writel(sh_chan, hw->tcr >> sh_chan->xmit_shift, TCR);
 }
 
 static void dmae_start(struct sh_dmae_chan *sh_chan)
@@ -123,7 +123,7 @@ static void dmae_start(struct sh_dmae_chan *sh_chan)
         u32 chcr = sh_dmae_readl(sh_chan, CHCR);
 
         chcr |= CHCR_DE | CHCR_IE;
-        sh_dmae_writel(sh_chan, chcr, CHCR);
+        sh_dmae_writel(sh_chan, chcr & ~CHCR_TE, CHCR);
 }
 
 static void dmae_halt(struct sh_dmae_chan *sh_chan)
@@ -134,55 +134,50 @@ static void dmae_halt(struct sh_dmae_chan *sh_chan)
         sh_dmae_writel(sh_chan, chcr, CHCR);
 }
 
+static void dmae_init(struct sh_dmae_chan *sh_chan)
+{
+        u32 chcr = RS_DEFAULT; /* default is DUAL mode */
+        sh_chan->xmit_shift = calc_xmit_shift(chcr);
+        sh_dmae_writel(sh_chan, chcr, CHCR);
+}
+
 static int dmae_set_chcr(struct sh_dmae_chan *sh_chan, u32 val)
 {
-        int ret = dmae_is_busy(sh_chan);
         /* When DMA was working, can not set data to CHCR */
-        if (ret)
-                return ret;
+        if (dmae_is_busy(sh_chan))
+                return -EBUSY;
 
+        sh_chan->xmit_shift = calc_xmit_shift(val);
         sh_dmae_writel(sh_chan, val, CHCR);
+
         return 0;
 }
 
-#define DMARS1_ADDR     0x04
-#define DMARS2_ADDR     0x08
-#define DMARS_SHIFT 8
-#define DMARS_CHAN_MSK 0x01
+#define DMARS_SHIFT     8
+#define DMARS_CHAN_MSK  0x01
 static int dmae_set_dmars(struct sh_dmae_chan *sh_chan, u16 val)
 {
         u32 addr;
         int shift = 0;
-        int ret = dmae_is_busy(sh_chan);
-        if (ret)
-                return ret;
+
+        if (dmae_is_busy(sh_chan))
+                return -EBUSY;
 
         if (sh_chan->id & DMARS_CHAN_MSK)
                 shift = DMARS_SHIFT;
 
-        switch (sh_chan->id) {
-        /* DMARS0 */
-        case 0:
-        case 1:
-                addr = SH_DMARS_BASE;
-                break;
-        /* DMARS1 */
-        case 2:
-        case 3:
-                addr = (SH_DMARS_BASE + DMARS1_ADDR);
-                break;
-        /* DMARS2 */
-        case 4:
-        case 5:
-                addr = (SH_DMARS_BASE + DMARS2_ADDR);
-                break;
-        default:
+        if (sh_chan->id < 6)
+                /* DMA0RS0 - DMA0RS2 */
+                addr = SH_DMARS_BASE0 + (sh_chan->id / 2) * 4;
+#ifdef SH_DMARS_BASE1
+        else if (sh_chan->id < 12)
+                /* DMA1RS0 - DMA1RS2 */
+                addr = SH_DMARS_BASE1 + ((sh_chan->id - 6) / 2) * 4;
+#endif
+        else
                 return -EINVAL;
-        }
 
-        ctrl_outw((val << shift) |
-                (ctrl_inw(addr) & (shift ? 0xFF00 : 0x00FF)),
-                addr);
+        ctrl_outw((val << shift) | (ctrl_inw(addr) & (0xFF00 >> shift)), addr);
 
         return 0;
 }
@@ -250,10 +245,53 @@ static struct sh_desc *sh_dmae_get_desc(struct sh_dmae_chan *sh_chan)
         return NULL;
 }
 
+static struct sh_dmae_slave_config *sh_dmae_find_slave(
+        struct sh_dmae_chan *sh_chan, enum sh_dmae_slave_chan_id slave_id)
+{
+        struct dma_device *dma_dev = sh_chan->common.device;
+        struct sh_dmae_device *shdev = container_of(dma_dev,
+                                        struct sh_dmae_device, common);
+        struct sh_dmae_pdata *pdata = &shdev->pdata;
+        int i;
+
+        if ((unsigned)slave_id >= SHDMA_SLAVE_NUMBER)
+                return NULL;
+
+        for (i = 0; i < pdata->config_num; i++)
+                if (pdata->config[i].slave_id == slave_id)
+                        return pdata->config + i;
+
+        return NULL;
+}
+
 static int sh_dmae_alloc_chan_resources(struct dma_chan *chan)
 {
         struct sh_dmae_chan *sh_chan = to_sh_chan(chan);
         struct sh_desc *desc;
+        struct sh_dmae_slave *param = chan->private;
+
+        /*
+         * This relies on the guarantee from dmaengine that alloc_chan_resources
+         * never runs concurrently with itself or free_chan_resources.
+         */
+        if (param) {
+                struct sh_dmae_slave_config *cfg;
+
+                cfg = sh_dmae_find_slave(sh_chan, param->slave_id);
+                if (!cfg)
+                        return -EINVAL;
+
+                if (test_and_set_bit(param->slave_id, sh_dmae_slave_used))
+                        return -EBUSY;
+
+                param->config = cfg;
+
+                dmae_set_dmars(sh_chan, cfg->mid_rid);
+                dmae_set_chcr(sh_chan, cfg->chcr);
+        } else {
+                if ((sh_dmae_readl(sh_chan, CHCR) & 0x700) != 0x400)
+                        dmae_set_chcr(sh_chan, RS_DEFAULT);
+        }
 
         spin_lock_bh(&sh_chan->desc_lock);
         while (sh_chan->descs_allocated < NR_DESCS_PER_CHANNEL) {
@@ -286,10 +324,18 @@ static void sh_dmae_free_chan_resources(struct dma_chan *chan)
         struct sh_desc *desc, *_desc;
         LIST_HEAD(list);
 
+        dmae_halt(sh_chan);
+
         /* Prepared and not submitted descriptors can still be on the queue */
         if (!list_empty(&sh_chan->ld_queue))
                 sh_dmae_chan_ld_cleanup(sh_chan, true);
 
+        if (chan->private) {
+                /* The caller is holding dma_list_mutex */
+                struct sh_dmae_slave *param = chan->private;
+                clear_bit(param->slave_id, sh_dmae_slave_used);
+        }
+
         spin_lock_bh(&sh_chan->desc_lock);
 
         list_splice_init(&sh_chan->ld_free, &list);
@@ -301,23 +347,97 @@ static void sh_dmae_free_chan_resources(struct dma_chan *chan)
                 kfree(desc);
 }
 
-static struct dma_async_tx_descriptor *sh_dmae_prep_memcpy(
-        struct dma_chan *chan, dma_addr_t dma_dest, dma_addr_t dma_src,
-        size_t len, unsigned long flags)
+/**
+ * sh_dmae_add_desc - get, set up and return one transfer descriptor
+ * @sh_chan:    DMA channel
+ * @flags:      DMA transfer flags
+ * @dest:       destination DMA address, incremented when direction equals
+ *              DMA_FROM_DEVICE or DMA_BIDIRECTIONAL
+ * @src:        source DMA address, incremented when direction equals
+ *              DMA_TO_DEVICE or DMA_BIDIRECTIONAL
+ * @len:        DMA transfer length
+ * @first:      if NULL, set to the current descriptor and cookie set to -EBUSY
+ * @direction:  needed for slave DMA to decide which address to keep constant,
+ *              equals DMA_BIDIRECTIONAL for MEMCPY
+ * Returns 0 or an error
+ * Locks: called with desc_lock held
+ */
+static struct sh_desc *sh_dmae_add_desc(struct sh_dmae_chan *sh_chan,
+        unsigned long flags, dma_addr_t *dest, dma_addr_t *src, size_t *len,
+        struct sh_desc **first, enum dma_data_direction direction)
 {
-        struct sh_dmae_chan *sh_chan;
-        struct sh_desc *first = NULL, *prev = NULL, *new;
+        struct sh_desc *new;
         size_t copy_size;
-        LIST_HEAD(tx_list);
-        int chunks = (len + SH_DMA_TCR_MAX) / (SH_DMA_TCR_MAX + 1);
 
-        if (!chan)
+        if (!*len)
                 return NULL;
 
-        if (!len)
+        /* Allocate the link descriptor from the free list */
+        new = sh_dmae_get_desc(sh_chan);
+        if (!new) {
+                dev_err(sh_chan->dev, "No free link descriptor available\n");
                 return NULL;
+        }
 
-        sh_chan = to_sh_chan(chan);
+        copy_size = min(*len, (size_t)SH_DMA_TCR_MAX + 1);
+
+        new->hw.sar = *src;
+        new->hw.dar = *dest;
+        new->hw.tcr = copy_size;
+
+        if (!*first) {
+                /* First desc */
+                new->async_tx.cookie = -EBUSY;
+                *first = new;
+        } else {
+                /* Other desc - invisible to the user */
+                new->async_tx.cookie = -EINVAL;
+        }
+
+        dev_dbg(sh_chan->dev,
+                "chaining (%u/%u)@%x -> %x with %p, cookie %d, shift %d\n",
+                copy_size, *len, *src, *dest, &new->async_tx,
+                new->async_tx.cookie, sh_chan->xmit_shift);
+
+        new->mark = DESC_PREPARED;
+        new->async_tx.flags = flags;
+        new->direction = direction;
+
+        *len -= copy_size;
+        if (direction == DMA_BIDIRECTIONAL || direction == DMA_TO_DEVICE)
+                *src += copy_size;
+        if (direction == DMA_BIDIRECTIONAL || direction == DMA_FROM_DEVICE)
+                *dest += copy_size;
+
+        return new;
+}
+
+/*
+ * sh_dmae_prep_sg - prepare transfer descriptors from an SG list
+ *
+ * Common routine for public (MEMCPY) and slave DMA. The MEMCPY case is also
+ * converted to scatter-gather to guarantee consistent locking and a correct
+ * list manipulation. For slave DMA direction carries the usual meaning, and,
+ * logically, the SG list is RAM and the addr variable contains slave address,
+ * e.g., the FIFO I/O register. For MEMCPY direction equals DMA_BIDIRECTIONAL
+ * and the SG list contains only one element and points at the source buffer.
+ */
+static struct dma_async_tx_descriptor *sh_dmae_prep_sg(struct sh_dmae_chan *sh_chan,
+        struct scatterlist *sgl, unsigned int sg_len, dma_addr_t *addr,
+        enum dma_data_direction direction, unsigned long flags)
+{
+        struct scatterlist *sg;
+        struct sh_desc *first = NULL, *new = NULL /* compiler... */;
+        LIST_HEAD(tx_list);
+        int chunks = 0;
+        int i;
+
+        if (!sg_len)
+                return NULL;
+
+        for_each_sg(sgl, sg, sg_len, i)
+                chunks += (sg_dma_len(sg) + SH_DMA_TCR_MAX) /
+                        (SH_DMA_TCR_MAX + 1);
 
         /* Have to lock the whole loop to protect against concurrent release */
         spin_lock_bh(&sh_chan->desc_lock);
@@ -333,49 +453,32 @@ static struct dma_async_tx_descriptor *sh_dmae_prep_memcpy(
          *      only during this function, then they are immediately spliced
          *      back onto the free list in form of a chain
          */
-        do {
-                /* Allocate the link descriptor from the free list */
-                new = sh_dmae_get_desc(sh_chan);
-                if (!new) {
-                        dev_err(sh_chan->dev,
-                                "No free memory for link descriptor\n");
-                        list_for_each_entry(new, &tx_list, node)
-                                new->mark = DESC_IDLE;
-                        list_splice(&tx_list, &sh_chan->ld_free);
-                        spin_unlock_bh(&sh_chan->desc_lock);
-                        return NULL;
-                }
-
-                copy_size = min(len, (size_t)SH_DMA_TCR_MAX + 1);
-
-                new->hw.sar = dma_src;
-                new->hw.dar = dma_dest;
-                new->hw.tcr = copy_size;
-                if (!first) {
-                        /* First desc */
-                        new->async_tx.cookie = -EBUSY;
-                        first = new;
-                } else {
-                        /* Other desc - invisible to the user */
-                        new->async_tx.cookie = -EINVAL;
-                }
-
-                dev_dbg(sh_chan->dev,
-                        "chaining %u of %u with %p, dst %x, cookie %d\n",
-                        copy_size, len, &new->async_tx, dma_dest,
-                        new->async_tx.cookie);
-
-                new->mark = DESC_PREPARED;
-                new->async_tx.flags = flags;
-                new->chunks = chunks--;
-
-                prev = new;
-                len -= copy_size;
-                dma_src += copy_size;
-                dma_dest += copy_size;
-                /* Insert the link descriptor to the LD ring */
-                list_add_tail(&new->node, &tx_list);
-        } while (len);
+        for_each_sg(sgl, sg, sg_len, i) {
+                dma_addr_t sg_addr = sg_dma_address(sg);
+                size_t len = sg_dma_len(sg);
+
+                if (!len)
+                        goto err_get_desc;
+
+                do {
+                        dev_dbg(sh_chan->dev, "Add SG #%d@%p[%d], dma %llx\n",
+                                i, sg, len, (unsigned long long)sg_addr);
+
+                        if (direction == DMA_FROM_DEVICE)
+                                new = sh_dmae_add_desc(sh_chan, flags,
+                                                &sg_addr, addr, &len, &first,
+                                                direction);
+                        else
+                                new = sh_dmae_add_desc(sh_chan, flags,
+                                                addr, &sg_addr, &len, &first,
+                                                direction);
+                        if (!new)
+                                goto err_get_desc;
+
+                        new->chunks = chunks--;
+                        list_add_tail(&new->node, &tx_list);
+                } while (len);
+        }
 
         if (new != first)
                 new->async_tx.cookie = -ENOSPC;
@@ -386,6 +489,77 @@ static struct dma_async_tx_descriptor *sh_dmae_prep_memcpy(
         spin_unlock_bh(&sh_chan->desc_lock);
 
         return &first->async_tx;
+
+err_get_desc:
+        list_for_each_entry(new, &tx_list, node)
+                new->mark = DESC_IDLE;
+        list_splice(&tx_list, &sh_chan->ld_free);
+
+        spin_unlock_bh(&sh_chan->desc_lock);
+
+        return NULL;
+}
+
+static struct dma_async_tx_descriptor *sh_dmae_prep_memcpy(
+        struct dma_chan *chan, dma_addr_t dma_dest, dma_addr_t dma_src,
+        size_t len, unsigned long flags)
+{
+        struct sh_dmae_chan *sh_chan;
+        struct scatterlist sg;
+
+        if (!chan || !len)
+                return NULL;
+
+        chan->private = NULL;
+
+        sh_chan = to_sh_chan(chan);
+
+        sg_init_table(&sg, 1);
+        sg_set_page(&sg, pfn_to_page(PFN_DOWN(dma_src)), len,
+                    offset_in_page(dma_src));
+        sg_dma_address(&sg) = dma_src;
+        sg_dma_len(&sg) = len;
+
+        return sh_dmae_prep_sg(sh_chan, &sg, 1, &dma_dest, DMA_BIDIRECTIONAL,
+                               flags);
+}
+
+static struct dma_async_tx_descriptor *sh_dmae_prep_slave_sg(
+        struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len,
+        enum dma_data_direction direction, unsigned long flags)
+{
+        struct sh_dmae_slave *param;
+        struct sh_dmae_chan *sh_chan;
+
+        if (!chan)
+                return NULL;
+
+        sh_chan = to_sh_chan(chan);
+        param = chan->private;
+
+        /* Someone calling slave DMA on a public channel? */
+        if (!param || !sg_len) {
+                dev_warn(sh_chan->dev, "%s: bad parameter: %p, %d, %d\n",
+                         __func__, param, sg_len, param ? param->slave_id : -1);
+                return NULL;
+        }
+
+        /*
+         * if (param != NULL), this is a successfully requested slave channel,
+         * therefore param->config != NULL too.
+         */
+        return sh_dmae_prep_sg(sh_chan, sgl, sg_len, &param->config->addr,
+                               direction, flags);
+}
+
+static void sh_dmae_terminate_all(struct dma_chan *chan)
+{
+        struct sh_dmae_chan *sh_chan = to_sh_chan(chan);
+
+        if (!chan)
+                return;
+
+        sh_dmae_chan_ld_cleanup(sh_chan, true);
 }
 
 static dma_async_tx_callback __ld_cleanup(struct sh_dmae_chan *sh_chan, bool all)
@@ -419,7 +593,11 @@ static dma_async_tx_callback __ld_cleanup(struct sh_dmae_chan *sh_chan, bool all
                         cookie = tx->cookie;
 
                 if (desc->mark == DESC_COMPLETED && desc->chunks == 1) {
-                        BUG_ON(sh_chan->completed_cookie != desc->cookie - 1);
+                        if (sh_chan->completed_cookie != desc->cookie - 1)
+                                dev_dbg(sh_chan->dev,
+                                        "Completing cookie %d, expected %d\n",
+                                        desc->cookie,
+                                        sh_chan->completed_cookie + 1);
                         sh_chan->completed_cookie = desc->cookie;
                 }
 
@@ -492,7 +670,7 @@ static void sh_chan_xfer_ld_queue(struct sh_dmae_chan *sh_chan)
                 return;
         }
 
-        /* Find the first un-transfer desciptor */
+        /* Find the first not transferred desciptor */
         list_for_each_entry(sd, &sh_chan->ld_queue, node)
                 if (sd->mark == DESC_SUBMITTED) {
                         /* Get the ld start address from ld_queue */
@@ -559,7 +737,7 @@ static irqreturn_t sh_dmae_err(int irq, void *data)
 
         /* IRQ Multi */
         if (shdev->pdata.mode & SHDMA_MIX_IRQ) {
-                int cnt = 0;
+                int __maybe_unused cnt = 0;
                 switch (irq) {
 #if defined(DMTE6_IRQ) && defined(DMAE1_IRQ)
                 case DMTE6_IRQ:
@@ -596,11 +774,14 @@ static void dmae_do_tasklet(unsigned long data)
         struct sh_dmae_chan *sh_chan = (struct sh_dmae_chan *)data;
         struct sh_desc *desc;
         u32 sar_buf = sh_dmae_readl(sh_chan, SAR);
+        u32 dar_buf = sh_dmae_readl(sh_chan, DAR);
 
         spin_lock(&sh_chan->desc_lock);
         list_for_each_entry(desc, &sh_chan->ld_queue, node) {
-                if ((desc->hw.sar + desc->hw.tcr) == sar_buf &&
-                    desc->mark == DESC_SUBMITTED) {
+                if (desc->mark == DESC_SUBMITTED &&
+                    ((desc->direction == DMA_FROM_DEVICE &&
+                      (desc->hw.dar + desc->hw.tcr) == dar_buf) ||
+                     (desc->hw.sar + desc->hw.tcr) == sar_buf)) {
                         dev_dbg(sh_chan->dev, "done #%d@%p dst %u\n",
                                 desc->async_tx.cookie, &desc->async_tx,
                                 desc->hw.dar);
@@ -673,7 +854,7 @@ static int __devinit sh_dmae_chan_probe(struct sh_dmae_device *shdev, int id)
         }
 
         snprintf(new_sh_chan->dev_id, sizeof(new_sh_chan->dev_id),
-                        "sh-dmae%d", new_sh_chan->id);
+                 "sh-dmae%d", new_sh_chan->id);
 
         /* set up channel irq */
         err = request_irq(irq, &sh_dmae_interrupt, irqflags,
@@ -684,11 +865,6 @@ static int __devinit sh_dmae_chan_probe(struct sh_dmae_device *shdev, int id)
                 goto err_no_irq;
         }
 
-        /* CHCR register control function */
-        new_sh_chan->set_chcr = dmae_set_chcr;
-        /* DMARS register control function */
-        new_sh_chan->set_dmars = dmae_set_dmars;
-
         shdev->chan[id] = new_sh_chan;
         return 0;
 
@@ -759,12 +935,19 @@ static int __init sh_dmae_probe(struct platform_device *pdev)
         INIT_LIST_HEAD(&shdev->common.channels);
 
         dma_cap_set(DMA_MEMCPY, shdev->common.cap_mask);
+        dma_cap_set(DMA_SLAVE, shdev->common.cap_mask);
+
         shdev->common.device_alloc_chan_resources
                 = sh_dmae_alloc_chan_resources;
         shdev->common.device_free_chan_resources = sh_dmae_free_chan_resources;
         shdev->common.device_prep_dma_memcpy = sh_dmae_prep_memcpy;
         shdev->common.device_is_tx_complete = sh_dmae_is_complete;
         shdev->common.device_issue_pending = sh_dmae_memcpy_issue_pending;
+
+        /* Compulsory for DMA_SLAVE fields */
+        shdev->common.device_prep_slave_sg = sh_dmae_prep_slave_sg;
+        shdev->common.device_terminate_all = sh_dmae_terminate_all;
+
         shdev->common.dev = &pdev->dev;
         /* Default transfer size of 32 bytes requires 32-byte alignment */
         shdev->common.copy_align = 5;
diff --git a/drivers/dma/shdma.h b/drivers/dma/shdma.h
index 108f1cffb6f5..7e227f3c87c4 100644
--- a/drivers/dma/shdma.h
+++ b/drivers/dma/shdma.h
@@ -29,6 +29,7 @@ struct sh_desc {
         struct sh_dmae_regs hw;
         struct list_head node;
         struct dma_async_tx_descriptor async_tx;
+        enum dma_data_direction direction;
         dma_cookie_t cookie;
         int chunks;
         int mark;
@@ -45,13 +46,9 @@ struct sh_dmae_chan {
         struct device *dev;             /* Channel device */
         struct tasklet_struct tasklet;  /* Tasklet */
         int descs_allocated;            /* desc count */
+        int xmit_shift;                 /* log_2(bytes_per_xfer) */
         int id;                         /* Raw id of this channel */
         char dev_id[16];                /* unique name per DMAC of channel */
-
-        /* Set chcr */
-        int (*set_chcr)(struct sh_dmae_chan *sh_chan, u32 regs);
-        /* Set DMA resource */
-        int (*set_dmars)(struct sh_dmae_chan *sh_chan, u16 res);
 };
 
 struct sh_dmae_device {
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/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/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/media/dvb/dvb-core/dvb_net.c b/drivers/media/dvb/dvb-core/dvb_net.c
index 8b8558fcb042..b11533f76195 100644
--- a/drivers/media/dvb/dvb-core/dvb_net.c
+++ b/drivers/media/dvb/dvb-core/dvb_net.c
@@ -504,6 +504,7 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
                                        "bytes left in TS.  Resyncing.\n", ts_remain);
                                 priv->ule_sndu_len = 0;
                                 priv->need_pusi = 1;
+                                ts += TS_SZ;
                                 continue;
                         }
 
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 44d2037e9e56..5382b5a44aff 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -126,8 +126,6 @@ static int mfcounter = 0;
  *  Public data...
  */
 
-static struct proc_dir_entry *mpt_proc_root_dir;
-
 #define WHOINIT_UNKNOWN         0xAA
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
@@ -146,6 +144,9 @@ static MPT_EVHANDLER		 MptEvHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 static MPT_RESETHANDLER          MptResetHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 static struct mpt_pci_driver    *MptDeviceDriverHandlers[MPT_MAX_PROTOCOL_DRIVERS];
 
+#ifdef CONFIG_PROC_FS
+static struct proc_dir_entry    *mpt_proc_root_dir;
+#endif
 
 /*
  *  Driver Callback Index's
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index b4948671eb92..9718c8f2e959 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -76,8 +76,8 @@
 #define COPYRIGHT       "Copyright (c) 1999-2008 " MODULEAUTHOR
 #endif
 
-#define MPT_LINUX_VERSION_COMMON        "3.04.13"
-#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.13"
+#define MPT_LINUX_VERSION_COMMON        "3.04.14"
+#define MPT_LINUX_PACKAGE_NAME          "@(#)mptlinux-3.04.14"
 #define WHAT_MAGIC_STRING               "@" "(" "#" ")"
 
 #define show_mptmod_ver(s,ver)  \
diff --git a/drivers/message/fusion/mptctl.c b/drivers/message/fusion/mptctl.c
index 352acd05c46b..caa8f568a41c 100644
--- a/drivers/message/fusion/mptctl.c
+++ b/drivers/message/fusion/mptctl.c
@@ -360,8 +360,8 @@ static int mptctl_bus_reset(MPT_ADAPTER *ioc, u8 function)
         u16              iocstatus;
 
         /* bus reset is only good for SCSI IO, RAID PASSTHRU */
-        if (!(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH) ||
-            (function == MPI_FUNCTION_SCSI_IO_REQUEST)) {
+        if (!(function == MPI_FUNCTION_RAID_SCSI_IO_PASSTHROUGH ||
+                function == MPI_FUNCTION_SCSI_IO_REQUEST)) {
                 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT
                         "TaskMgmt, not SCSI_IO!!\n", ioc->name));
                 return -EPERM;
diff --git a/drivers/message/fusion/mptfc.c b/drivers/message/fusion/mptfc.c
index ebf6ae024da4..612ab3c51a6b 100644
--- a/drivers/message/fusion/mptfc.c
+++ b/drivers/message/fusion/mptfc.c
@@ -195,29 +195,34 @@ mptfc_block_error_handler(struct scsi_cmnd *SCpnt,
         unsigned long           flags;
         int                     ready;
         MPT_ADAPTER             *ioc;
+        int                     loops = 40;     /* seconds */
 
         hd = shost_priv(SCpnt->device->host);
         ioc = hd->ioc;
         spin_lock_irqsave(shost->host_lock, flags);
-        while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY) {
+        while ((ready = fc_remote_port_chkready(rport) >> 16) == DID_IMM_RETRY
+         || (loops > 0 && ioc->active == 0)) {
                 spin_unlock_irqrestore(shost->host_lock, flags);
                 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
                         "mptfc_block_error_handler.%d: %d:%d, port status is "
-                        "DID_IMM_RETRY, deferring %s recovery.\n",
+                        "%x, active flag %d, deferring %s recovery.\n",
                         ioc->name, ioc->sh->host_no,
-                        SCpnt->device->id, SCpnt->device->lun, caller));
+                        SCpnt->device->id, SCpnt->device->lun,
+                        ready, ioc->active, caller));
                 msleep(1000);
                 spin_lock_irqsave(shost->host_lock, flags);
+                loops --;
         }
         spin_unlock_irqrestore(shost->host_lock, flags);
 
-        if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata) {
+        if (ready == DID_NO_CONNECT || !SCpnt->device->hostdata
+         || ioc->active == 0) {
                 dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
                         "%s.%d: %d:%d, failing recovery, "
-                        "port state %d, vdevice %p.\n", caller,
+                        "port state %x, active %d, vdevice %p.\n", caller,
                         ioc->name, ioc->sh->host_no,
                         SCpnt->device->id, SCpnt->device->lun, ready,
-                        SCpnt->device->hostdata));
+                        ioc->active, SCpnt->device->hostdata));
                 return FAILED;
         }
         dfcprintk (ioc, printk(MYIOC_s_DEBUG_FMT
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index 83873e3d0ce7..c20bbe45da82 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -1075,6 +1075,19 @@ mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id)
         return 0;
 }
 
+static void
+mptsas_block_io_sdev(struct scsi_device *sdev, void *data)
+{
+        scsi_device_set_state(sdev, SDEV_BLOCK);
+}
+
+static void
+mptsas_block_io_starget(struct scsi_target *starget)
+{
+        if (starget)
+                starget_for_each_device(starget, NULL, mptsas_block_io_sdev);
+}
+
 /**
  * mptsas_target_reset_queue
  *
@@ -1098,10 +1111,11 @@ mptsas_target_reset_queue(MPT_ADAPTER *ioc,
         id = sas_event_data->TargetID;
         channel = sas_event_data->Bus;
 
-        if (!(vtarget = mptsas_find_vtarget(ioc, channel, id)))
-                return;
-
-        vtarget->deleted = 1; /* block IO */
+        vtarget = mptsas_find_vtarget(ioc, channel, id);
+        if (vtarget) {
+                mptsas_block_io_starget(vtarget->starget);
+                vtarget->deleted = 1; /* block IO */
+        }
 
         target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event),
             GFP_ATOMIC);
@@ -1868,7 +1882,8 @@ mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
         if (ioc->sas_discovery_quiesce_io)
                 return SCSI_MLQUEUE_HOST_BUSY;
 
-//      scsi_print_command(SCpnt);
+        if (ioc->debug_level & MPT_DEBUG_SCSI)
+                scsi_print_command(SCpnt);
 
         return mptscsih_qcmd(SCpnt,done);
 }
@@ -2686,6 +2701,187 @@ mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info,
         return error;
 }
 
+struct rep_manu_request{
+        u8 smp_frame_type;
+        u8 function;
+        u8 reserved;
+        u8 request_length;
+};
+
+struct rep_manu_reply{
+        u8 smp_frame_type; /* 0x41 */
+        u8 function; /* 0x01 */
+        u8 function_result;
+        u8 response_length;
+        u16 expander_change_count;
+        u8 reserved0[2];
+        u8 sas_format:1;
+        u8 reserved1:7;
+        u8 reserved2[3];
+        u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN];
+        u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN];
+        u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN];
+        u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN];
+        u16 component_id;
+        u8 component_revision_id;
+        u8 reserved3;
+        u8 vendor_specific[8];
+};
+
+/**
+  * mptsas_exp_repmanufacture_info -
+  * @ioc: per adapter object
+  * @sas_address: expander sas address
+  * @edev: the sas_expander_device object
+  *
+  * Fills in the sas_expander_device object when SMP port is created.
+  *
+  * Returns 0 for success, non-zero for failure.
+  */
+static int
+mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc,
+        u64 sas_address, struct sas_expander_device *edev)
+{
+        MPT_FRAME_HDR *mf;
+        SmpPassthroughRequest_t *smpreq;
+        SmpPassthroughReply_t *smprep;
+        struct rep_manu_reply *manufacture_reply;
+        struct rep_manu_request *manufacture_request;
+        int ret;
+        int flagsLength;
+        unsigned long timeleft;
+        char *psge;
+        unsigned long flags;
+        void *data_out = NULL;
+        dma_addr_t data_out_dma = 0;
+        u32 sz;
+
+        spin_lock_irqsave(&ioc->taskmgmt_lock, flags);
+        if (ioc->ioc_reset_in_progress) {
+                spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+                printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n",
+                        __func__, ioc->name);
+                return -EFAULT;
+        }
+        spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags);
+
+        ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex);
+        if (ret)
+                goto out;
+
+        mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc);
+        if (!mf) {
+                ret = -ENOMEM;
+                goto out_unlock;
+        }
+
+        smpreq = (SmpPassthroughRequest_t *)mf;
+        memset(smpreq, 0, sizeof(*smpreq));
+
+        sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply);
+
+        data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma);
+        if (!data_out) {
+                printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n",
+                        __FILE__, __LINE__, __func__);
+                ret = -ENOMEM;
+                goto put_mf;
+        }
+
+        manufacture_request = data_out;
+        manufacture_request->smp_frame_type = 0x40;
+        manufacture_request->function = 1;
+        manufacture_request->reserved = 0;
+        manufacture_request->request_length = 0;
+
+        smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH;
+        smpreq->PhysicalPort = 0xFF;
+        *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address);
+        smpreq->RequestDataLength = sizeof(struct rep_manu_request);
+
+        psge = (char *)
+                (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4));
+
+        flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+                MPI_SGE_FLAGS_SYSTEM_ADDRESS |
+                MPI_SGE_FLAGS_HOST_TO_IOC |
+                MPI_SGE_FLAGS_END_OF_BUFFER;
+        flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
+        flagsLength |= sizeof(struct rep_manu_request);
+
+        ioc->add_sge(psge, flagsLength, data_out_dma);
+        psge += ioc->SGE_size;
+
+        flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT |
+                MPI_SGE_FLAGS_SYSTEM_ADDRESS |
+                MPI_SGE_FLAGS_IOC_TO_HOST |
+                MPI_SGE_FLAGS_END_OF_BUFFER;
+        flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT;
+        flagsLength |= sizeof(struct rep_manu_reply);
+        ioc->add_sge(psge, flagsLength, data_out_dma +
+        sizeof(struct rep_manu_request));
+
+        INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status)
+        mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf);
+
+        timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ);
+        if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) {
+                ret = -ETIME;
+                mpt_free_msg_frame(ioc, mf);
+                mf = NULL;
+                if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET)
+                        goto out_free;
+                if (!timeleft)
+                        mpt_HardResetHandler(ioc, CAN_SLEEP);
+                goto out_free;
+        }
+
+        mf = NULL;
+
+        if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) {
+                u8 *tmp;
+
+        smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply;
+        if (le16_to_cpu(smprep->ResponseDataLength) !=
+                sizeof(struct rep_manu_reply))
+                        goto out_free;
+
+        manufacture_reply = data_out + sizeof(struct rep_manu_request);
+        strncpy(edev->vendor_id, manufacture_reply->vendor_id,
+                SAS_EXPANDER_VENDOR_ID_LEN);
+        strncpy(edev->product_id, manufacture_reply->product_id,
+                SAS_EXPANDER_PRODUCT_ID_LEN);
+        strncpy(edev->product_rev, manufacture_reply->product_rev,
+                SAS_EXPANDER_PRODUCT_REV_LEN);
+        edev->level = manufacture_reply->sas_format;
+        if (manufacture_reply->sas_format) {
+                strncpy(edev->component_vendor_id,
+                        manufacture_reply->component_vendor_id,
+                                SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN);
+                tmp = (u8 *)&manufacture_reply->component_id;
+                edev->component_id = tmp[0] << 8 | tmp[1];
+                edev->component_revision_id =
+                        manufacture_reply->component_revision_id;
+                }
+        } else {
+                printk(MYIOC_s_ERR_FMT
+                        "%s: smp passthru reply failed to be returned\n",
+                        ioc->name, __func__);
+                ret = -ENXIO;
+        }
+out_free:
+        if (data_out_dma)
+                pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma);
+put_mf:
+        if (mf)
+                mpt_free_msg_frame(ioc, mf);
+out_unlock:
+        CLEAR_MGMT_STATUS(ioc->sas_mgmt.status)
+        mutex_unlock(&ioc->sas_mgmt.mutex);
+out:
+        return ret;
+ }
+
 static void
 mptsas_parse_device_info(struct sas_identify *identify,
                 struct mptsas_devinfo *device_info)
@@ -2967,6 +3163,11 @@ static int mptsas_probe_one_phy(struct device *dev,
                         goto out;
                 }
                 mptsas_set_rphy(ioc, phy_info, rphy);
+                if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE ||
+                        identify.device_type == SAS_FANOUT_EXPANDER_DEVICE)
+                                mptsas_exp_repmanufacture_info(ioc,
+                                        identify.sas_address,
+                                        rphy_to_expander_device(rphy));
         }
 
  out:
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index 81279b3d694c..4a7d1afcb666 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -1438,9 +1438,14 @@ mptscsih_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
             && (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_Q_YES)
             && (SCpnt->device->tagged_supported)) {
                 scsictl = scsidir | MPI_SCSIIO_CONTROL_SIMPLEQ;
-        } else {
+                if (SCpnt->request && SCpnt->request->ioprio) {
+                        if (((SCpnt->request->ioprio & 0x7) == 1) ||
+                                !(SCpnt->request->ioprio & 0x7))
+                                scsictl |= MPI_SCSIIO_CONTROL_HEADOFQ;
+                }
+        } else
                 scsictl = scsidir | MPI_SCSIIO_CONTROL_UNTAGGED;
-        }
+
 
         /* Use the above information to set up the message frame
          */
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index 677cd53f18c3..bb6465604235 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -457,10 +457,10 @@ config MTD_NAND_NOMADIK
 
 config MTD_NAND_SH_FLCTL
         tristate "Support for NAND on Renesas SuperH FLCTL"
-        depends on MTD_NAND && SUPERH && CPU_SUBTYPE_SH7723
+        depends on MTD_NAND && SUPERH
         help
           Several Renesas SuperH CPU has FLCTL. This option enables support
-          for NAND Flash using FLCTL. This driver support SH7723.
+          for NAND Flash using FLCTL.
 
 config MTD_NAND_DAVINCI
         tristate "Support NAND on DaVinci SoC"
diff --git a/drivers/mtd/nand/sh_flctl.c b/drivers/mtd/nand/sh_flctl.c
index 02bef21f2e4b..1842df8bdd93 100644
--- a/drivers/mtd/nand/sh_flctl.c
+++ b/drivers/mtd/nand/sh_flctl.c
@@ -1,10 +1,10 @@
 /*
  * SuperH FLCTL nand controller
  *
- * Copyright © 2008 Renesas Solutions Corp.
- * Copyright © 2008 Atom Create Engineering Co., Ltd.
+ * Copyright (c) 2008 Renesas Solutions Corp.
+ * Copyright (c) 2008 Atom Create Engineering Co., Ltd.
  *
- * Based on fsl_elbc_nand.c, Copyright © 2006-2007 Freescale Semiconductor
+ * Based on fsl_elbc_nand.c, Copyright (c) 2006-2007 Freescale Semiconductor
  *
  * 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
@@ -75,6 +75,11 @@ static void start_translation(struct sh_flctl *flctl)
         writeb(TRSTRT, FLTRCR(flctl));
 }
 
+static void timeout_error(struct sh_flctl *flctl, const char *str)
+{
+        dev_err(&flctl->pdev->dev, "Timeout occured in %s\n", str);
+}
+
 static void wait_completion(struct sh_flctl *flctl)
 {
         uint32_t timeout = LOOP_TIMEOUT_MAX;
@@ -87,7 +92,7 @@ static void wait_completion(struct sh_flctl *flctl)
                 udelay(1);
         }
 
-        printk(KERN_ERR "wait_completion(): Timeout occured \n");
+        timeout_error(flctl, __func__);
         writeb(0x0, FLTRCR(flctl));
 }
 
@@ -100,6 +105,8 @@ static void set_addr(struct mtd_info *mtd, int column, int page_addr)
                 addr = page_addr;       /* ERASE1 */
         } else if (page_addr != -1) {
                 /* SEQIN, READ0, etc.. */
+                if (flctl->chip.options & NAND_BUSWIDTH_16)
+                        column >>= 1;
                 if (flctl->page_size) {
                         addr = column & 0x0FFF;
                         addr |= (page_addr & 0xff) << 16;
@@ -132,7 +139,7 @@ static void wait_rfifo_ready(struct sh_flctl *flctl)
                         return;
                 udelay(1);
         }
-        printk(KERN_ERR "wait_rfifo_ready(): Timeout occured \n");
+        timeout_error(flctl, __func__);
 }
 
 static void wait_wfifo_ready(struct sh_flctl *flctl)
@@ -146,7 +153,7 @@ static void wait_wfifo_ready(struct sh_flctl *flctl)
                         return;
                 udelay(1);
         }
-        printk(KERN_ERR "wait_wfifo_ready(): Timeout occured \n");
+        timeout_error(flctl, __func__);
 }
 
 static int wait_recfifo_ready(struct sh_flctl *flctl, int sector_number)
@@ -198,7 +205,7 @@ static int wait_recfifo_ready(struct sh_flctl *flctl, int sector_number)
                 writel(0, FL4ECCCR(flctl));
         }
 
-        printk(KERN_ERR "wait_recfifo_ready(): Timeout occured \n");
+        timeout_error(flctl, __func__);
         return 1;       /* timeout */
 }
 
@@ -214,7 +221,7 @@ static void wait_wecfifo_ready(struct sh_flctl *flctl)
                         return;
                 udelay(1);
         }
-        printk(KERN_ERR "wait_wecfifo_ready(): Timeout occured \n");
+        timeout_error(flctl, __func__);
 }
 
 static void read_datareg(struct sh_flctl *flctl, int offset)
@@ -275,7 +282,7 @@ static void write_fiforeg(struct sh_flctl *flctl, int rlen, int offset)
 static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_val)
 {
         struct sh_flctl *flctl = mtd_to_flctl(mtd);
-        uint32_t flcmncr_val = readl(FLCMNCR(flctl));
+        uint32_t flcmncr_val = readl(FLCMNCR(flctl)) & ~SEL_16BIT;
         uint32_t flcmdcr_val, addr_len_bytes = 0;
 
         /* Set SNAND bit if page size is 2048byte */
@@ -297,6 +304,8 @@ static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_va
         case NAND_CMD_READOOB:
                 addr_len_bytes = flctl->rw_ADRCNT;
                 flcmdcr_val |= CDSRC_E;
+                if (flctl->chip.options & NAND_BUSWIDTH_16)
+                        flcmncr_val |= SEL_16BIT;
                 break;
         case NAND_CMD_SEQIN:
                 /* This case is that cmd is READ0 or READ1 or READ00 */
@@ -305,6 +314,8 @@ static void set_cmd_regs(struct mtd_info *mtd, uint32_t cmd, uint32_t flcmcdr_va
         case NAND_CMD_PAGEPROG:
                 addr_len_bytes = flctl->rw_ADRCNT;
                 flcmdcr_val |= DOCMD2_E | CDSRC_E | SELRW;
+                if (flctl->chip.options & NAND_BUSWIDTH_16)
+                        flcmncr_val |= SEL_16BIT;
                 break;
         case NAND_CMD_READID:
                 flcmncr_val &= ~SNAND_E;
@@ -523,6 +534,8 @@ static void flctl_cmdfunc(struct mtd_info *mtd, unsigned int command,
                 set_addr(mtd, 0, page_addr);
 
                 flctl->read_bytes = mtd->writesize + mtd->oobsize;
+                if (flctl->chip.options & NAND_BUSWIDTH_16)
+                        column >>= 1;
                 flctl->index += column;
                 goto read_normal_exit;
 
@@ -686,6 +699,18 @@ static uint8_t flctl_read_byte(struct mtd_info *mtd)
         return data;
 }
 
+static uint16_t flctl_read_word(struct mtd_info *mtd)
+{
+       struct sh_flctl *flctl = mtd_to_flctl(mtd);
+       int index = flctl->index;
+       uint16_t data;
+       uint16_t *buf = (uint16_t *)&flctl->done_buff[index];
+
+       data = *buf;
+       flctl->index += 2;
+       return data;
+}
+
 static void flctl_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
         int i;
@@ -769,38 +794,36 @@ static int flctl_chip_init_tail(struct mtd_info *mtd)
         return 0;
 }
 
-static int __init flctl_probe(struct platform_device *pdev)
+static int __devinit flctl_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct sh_flctl *flctl;
         struct mtd_info *flctl_mtd;
         struct nand_chip *nand;
         struct sh_flctl_platform_data *pdata;
-        int ret;
+        int ret = -ENXIO;
 
         pdata = pdev->dev.platform_data;
         if (pdata == NULL) {
-                printk(KERN_ERR "sh_flctl platform_data not found.\n");
-                return -ENODEV;
+                dev_err(&pdev->dev, "no platform data defined\n");
+                return -EINVAL;
         }
 
         flctl = kzalloc(sizeof(struct sh_flctl), GFP_KERNEL);
         if (!flctl) {
-                printk(KERN_ERR "Unable to allocate NAND MTD dev structure.\n");
+                dev_err(&pdev->dev, "failed to allocate driver data\n");
                 return -ENOMEM;
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
-                printk(KERN_ERR "%s: resource not found.\n", __func__);
-                ret = -ENODEV;
+                dev_err(&pdev->dev, "failed to get I/O memory\n");
                 goto err;
         }
 
-        flctl->reg = ioremap(res->start, res->end - res->start + 1);
+        flctl->reg = ioremap(res->start, resource_size(res));
         if (flctl->reg == NULL) {
-                printk(KERN_ERR "%s: ioremap error.\n", __func__);
-                ret = -ENOMEM;
+                dev_err(&pdev->dev, "failed to remap I/O memory\n");
                 goto err;
         }
 
@@ -808,6 +831,7 @@ static int __init flctl_probe(struct platform_device *pdev)
         flctl_mtd = &flctl->mtd;
         nand = &flctl->chip;
         flctl_mtd->priv = nand;
+        flctl->pdev = pdev;
         flctl->hwecc = pdata->has_hwecc;
 
         flctl_register_init(flctl, pdata->flcmncr_val);
@@ -825,6 +849,11 @@ static int __init flctl_probe(struct platform_device *pdev)
         nand->select_chip = flctl_select_chip;
         nand->cmdfunc = flctl_cmdfunc;
 
+        if (pdata->flcmncr_val & SEL_16BIT) {
+                nand->options |= NAND_BUSWIDTH_16;
+                nand->read_word = flctl_read_word;
+        }
+
         ret = nand_scan_ident(flctl_mtd, 1);
         if (ret)
                 goto err;
@@ -846,7 +875,7 @@ err:
         return ret;
 }
 
-static int __exit flctl_remove(struct platform_device *pdev)
+static int __devexit flctl_remove(struct platform_device *pdev)
 {
         struct sh_flctl *flctl = platform_get_drvdata(pdev);
 
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/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/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/s390/scsi/zfcp_aux.c b/drivers/s390/scsi/zfcp_aux.c
index 9d0c941b7d33..66d6c01fcf3e 100644
--- a/drivers/s390/scsi/zfcp_aux.c
+++ b/drivers/s390/scsi/zfcp_aux.c
@@ -3,7 +3,7 @@
  *
  * Module interface and handling of zfcp data structures.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 /*
@@ -32,6 +32,7 @@
 #include <linux/seq_file.h>
 #include "zfcp_ext.h"
 #include "zfcp_fc.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_BUS_ID_SIZE        20
 
@@ -49,36 +50,6 @@ static struct kmem_cache *zfcp_cache_hw_align(const char *name,
         return kmem_cache_create(name, size, roundup_pow_of_two(size), 0, NULL);
 }
 
-static int zfcp_reqlist_alloc(struct zfcp_adapter *adapter)
-{
-        int idx;
-
-        adapter->req_list = kcalloc(REQUEST_LIST_SIZE, sizeof(struct list_head),
-                                    GFP_KERNEL);
-        if (!adapter->req_list)
-                return -ENOMEM;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
-                INIT_LIST_HEAD(&adapter->req_list[idx]);
-        return 0;
-}
-
-/**
- * zfcp_reqlist_isempty - is the request list empty
- * @adapter: pointer to struct zfcp_adapter
- *
- * Returns: true if list is empty, false otherwise
- */
-int zfcp_reqlist_isempty(struct zfcp_adapter *adapter)
-{
-        unsigned int idx;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++)
-                if (!list_empty(&adapter->req_list[idx]))
-                        return 0;
-        return 1;
-}
-
 static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
 {
         struct ccw_device *cdev;
@@ -110,7 +81,7 @@ static void __init zfcp_init_device_configure(char *busid, u64 wwpn, u64 lun)
         flush_work(&unit->scsi_work);
 
 out_unit:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 out_port:
         zfcp_ccw_adapter_put(adapter);
 out_ccw_device:
@@ -255,7 +226,7 @@ struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *port, u64 fcp_lun)
         read_lock_irqsave(&port->unit_list_lock, flags);
         list_for_each_entry(unit, &port->unit_list, list)
                 if (unit->fcp_lun == fcp_lun) {
-                        if (!get_device(&unit->sysfs_device))
+                        if (!get_device(&unit->dev))
                                 unit = NULL;
                         read_unlock_irqrestore(&port->unit_list_lock, flags);
                         return unit;
@@ -280,7 +251,7 @@ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
         read_lock_irqsave(&adapter->port_list_lock, flags);
         list_for_each_entry(port, &adapter->port_list, list)
                 if (port->wwpn == wwpn) {
-                        if (!get_device(&port->sysfs_device))
+                        if (!get_device(&port->dev))
                                 port = NULL;
                         read_unlock_irqrestore(&adapter->port_list_lock, flags);
                         return port;
@@ -298,10 +269,9 @@ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter,
  */
 static void zfcp_unit_release(struct device *dev)
 {
-        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit,
-                                              sysfs_device);
+        struct zfcp_unit *unit = container_of(dev, struct zfcp_unit, dev);
 
-        put_device(&unit->port->sysfs_device);
+        put_device(&unit->port->dev);
         kfree(unit);
 }
 
@@ -318,11 +288,11 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
         struct zfcp_unit *unit;
         int retval = -ENOMEM;
 
-        get_device(&port->sysfs_device);
+        get_device(&port->dev);
 
         unit = zfcp_get_unit_by_lun(port, fcp_lun);
         if (unit) {
-                put_device(&unit->sysfs_device);
+                put_device(&unit->dev);
                 retval = -EEXIST;
                 goto err_out;
         }
@@ -333,10 +303,10 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
 
         unit->port = port;
         unit->fcp_lun = fcp_lun;
-        unit->sysfs_device.parent = &port->sysfs_device;
-        unit->sysfs_device.release = zfcp_unit_release;
+        unit->dev.parent = &port->dev;
+        unit->dev.release = zfcp_unit_release;
 
-        if (dev_set_name(&unit->sysfs_device, "0x%016llx",
+        if (dev_set_name(&unit->dev, "0x%016llx",
                          (unsigned long long) fcp_lun)) {
                 kfree(unit);
                 goto err_out;
@@ -353,13 +323,12 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
         unit->latencies.cmd.channel.min = 0xFFFFFFFF;
         unit->latencies.cmd.fabric.min = 0xFFFFFFFF;
 
-        if (device_register(&unit->sysfs_device)) {
-                put_device(&unit->sysfs_device);
+        if (device_register(&unit->dev)) {
+                put_device(&unit->dev);
                 goto err_out;
         }
 
-        if (sysfs_create_group(&unit->sysfs_device.kobj,
-                               &zfcp_sysfs_unit_attrs))
+        if (sysfs_create_group(&unit->dev.kobj, &zfcp_sysfs_unit_attrs))
                 goto err_out_put;
 
         write_lock_irq(&port->unit_list_lock);
@@ -371,9 +340,9 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, u64 fcp_lun)
         return unit;
 
 err_out_put:
-        device_unregister(&unit->sysfs_device);
+        device_unregister(&unit->dev);
 err_out:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
         return ERR_PTR(retval);
 }
 
@@ -539,7 +508,8 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
         if (zfcp_allocate_low_mem_buffers(adapter))
                 goto failed;
 
-        if (zfcp_reqlist_alloc(adapter))
+        adapter->req_list = zfcp_reqlist_alloc();
+        if (!adapter->req_list)
                 goto failed;
 
         if (zfcp_dbf_adapter_register(adapter))
@@ -560,8 +530,6 @@ struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *ccw_device)
         INIT_LIST_HEAD(&adapter->erp_ready_head);
         INIT_LIST_HEAD(&adapter->erp_running_head);
 
-        spin_lock_init(&adapter->req_list_lock);
-
         rwlock_init(&adapter->erp_lock);
         rwlock_init(&adapter->abort_lock);
 
@@ -640,8 +608,7 @@ void zfcp_device_unregister(struct device *dev,
 
 static void zfcp_port_release(struct device *dev)
 {
-        struct zfcp_port *port = container_of(dev, struct zfcp_port,
-                                              sysfs_device);
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
 
         zfcp_ccw_adapter_put(port->adapter);
         kfree(port);
@@ -669,7 +636,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
 
         port = zfcp_get_port_by_wwpn(adapter, wwpn);
         if (port) {
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
                 retval = -EEXIST;
                 goto err_out;
         }
@@ -689,22 +656,21 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
         port->d_id = d_id;
         port->wwpn = wwpn;
         port->rport_task = RPORT_NONE;
-        port->sysfs_device.parent = &adapter->ccw_device->dev;
-        port->sysfs_device.release = zfcp_port_release;
+        port->dev.parent = &adapter->ccw_device->dev;
+        port->dev.release = zfcp_port_release;
 
-        if (dev_set_name(&port->sysfs_device, "0x%016llx",
-                         (unsigned long long)wwpn)) {
+        if (dev_set_name(&port->dev, "0x%016llx", (unsigned long long)wwpn)) {
                 kfree(port);
                 goto err_out;
         }
         retval = -EINVAL;
 
-        if (device_register(&port->sysfs_device)) {
-                put_device(&port->sysfs_device);
+        if (device_register(&port->dev)) {
+                put_device(&port->dev);
                 goto err_out;
         }
 
-        if (sysfs_create_group(&port->sysfs_device.kobj,
+        if (sysfs_create_group(&port->dev.kobj,
                                &zfcp_sysfs_port_attrs))
                 goto err_out_put;
 
@@ -717,7 +683,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, u64 wwpn,
         return port;
 
 err_out_put:
-        device_unregister(&port->sysfs_device);
+        device_unregister(&port->dev);
 err_out:
         zfcp_ccw_adapter_put(adapter);
         return ERR_PTR(retval);
diff --git a/drivers/s390/scsi/zfcp_ccw.c b/drivers/s390/scsi/zfcp_ccw.c
index c22cb72a5ae8..ce1cc7a11fb4 100644
--- a/drivers/s390/scsi/zfcp_ccw.c
+++ b/drivers/s390/scsi/zfcp_ccw.c
@@ -3,13 +3,14 @@
  *
  * Registration and callback for the s390 common I/O layer.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include "zfcp_ext.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_MODEL_PRIV 0x4
 
@@ -122,12 +123,10 @@ static void zfcp_ccw_remove(struct ccw_device *cdev)
         zfcp_ccw_adapter_put(adapter); /* put from zfcp_ccw_adapter_by_cdev */
 
         list_for_each_entry_safe(unit, u, &unit_remove_lh, list)
-                zfcp_device_unregister(&unit->sysfs_device,
-                                       &zfcp_sysfs_unit_attrs);
+                zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
 
         list_for_each_entry_safe(port, p, &port_remove_lh, list)
-                zfcp_device_unregister(&port->sysfs_device,
-                                       &zfcp_sysfs_port_attrs);
+                zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
 
         zfcp_adapter_unregister(adapter);
 }
@@ -162,7 +161,7 @@ static int zfcp_ccw_set_online(struct ccw_device *cdev)
         }
 
         /* initialize request counter */
-        BUG_ON(!zfcp_reqlist_isempty(adapter));
+        BUG_ON(!zfcp_reqlist_isempty(adapter->req_list));
         adapter->req_no = 0;
 
         zfcp_erp_modify_adapter_status(adapter, "ccsonl1", NULL,
diff --git a/drivers/s390/scsi/zfcp_dbf.c b/drivers/s390/scsi/zfcp_dbf.c
index 7369c8911bcf..7a149fd85f6d 100644
--- a/drivers/s390/scsi/zfcp_dbf.c
+++ b/drivers/s390/scsi/zfcp_dbf.c
@@ -140,9 +140,9 @@ void _zfcp_dbf_hba_fsf_response(const char *tag2, int level,
         memcpy(response->fsf_status_qual,
                fsf_status_qual, FSF_STATUS_QUALIFIER_SIZE);
         response->fsf_req_status = fsf_req->status;
-        response->sbal_first = fsf_req->queue_req.sbal_first;
-        response->sbal_last = fsf_req->queue_req.sbal_last;
-        response->sbal_response = fsf_req->queue_req.sbal_response;
+        response->sbal_first = fsf_req->qdio_req.sbal_first;
+        response->sbal_last = fsf_req->qdio_req.sbal_last;
+        response->sbal_response = fsf_req->qdio_req.sbal_response;
         response->pool = fsf_req->pool != NULL;
         response->erp_action = (unsigned long)fsf_req->erp_action;
 
@@ -576,7 +576,8 @@ void zfcp_dbf_rec_adapter(char *id, void *ref, struct zfcp_dbf *dbf)
         struct zfcp_adapter *adapter = dbf->adapter;
 
         zfcp_dbf_rec_target(id, ref, dbf, &adapter->status,
-                                  &adapter->erp_counter, 0, 0, 0);
+                            &adapter->erp_counter, 0, 0,
+                            ZFCP_DBF_INVALID_LUN);
 }
 
 /**
@@ -590,8 +591,8 @@ void zfcp_dbf_rec_port(char *id, void *ref, struct zfcp_port *port)
         struct zfcp_dbf *dbf = port->adapter->dbf;
 
         zfcp_dbf_rec_target(id, ref, dbf, &port->status,
-                                  &port->erp_counter, port->wwpn, port->d_id,
-                                  0);
+                            &port->erp_counter, port->wwpn, port->d_id,
+                            ZFCP_DBF_INVALID_LUN);
 }
 
 /**
@@ -642,10 +643,9 @@ void zfcp_dbf_rec_trigger(char *id2, void *ref, u8 want, u8 need, void *action,
                 r->u.trigger.ps = atomic_read(&port->status);
                 r->u.trigger.wwpn = port->wwpn;
         }
-        if (unit) {
+        if (unit)
                 r->u.trigger.us = atomic_read(&unit->status);
-                r->u.trigger.fcp_lun = unit->fcp_lun;
-        }
+        r->u.trigger.fcp_lun = unit ? unit->fcp_lun : ZFCP_DBF_INVALID_LUN;
         debug_event(dbf->rec, action ? 1 : 4, r, sizeof(*r));
         spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
@@ -668,7 +668,7 @@ void zfcp_dbf_rec_action(char *id2, struct zfcp_erp_action *erp_action)
         r->u.action.action = (unsigned long)erp_action;
         r->u.action.status = erp_action->status;
         r->u.action.step = erp_action->step;
-        r->u.action.fsf_req = (unsigned long)erp_action->fsf_req;
+        r->u.action.fsf_req = erp_action->fsf_req_id;
         debug_event(dbf->rec, 5, r, sizeof(*r));
         spin_unlock_irqrestore(&dbf->rec_lock, flags);
 }
diff --git a/drivers/s390/scsi/zfcp_dbf.h b/drivers/s390/scsi/zfcp_dbf.h
index 8b7fd9a1033e..457e046f2d28 100644
--- a/drivers/s390/scsi/zfcp_dbf.h
+++ b/drivers/s390/scsi/zfcp_dbf.h
@@ -30,6 +30,8 @@
 #define ZFCP_DBF_TAG_SIZE      4
 #define ZFCP_DBF_ID_SIZE       7
 
+#define ZFCP_DBF_INVALID_LUN    0xFFFFFFFFFFFFFFFFull
+
 struct zfcp_dbf_dump {
         u8 tag[ZFCP_DBF_TAG_SIZE];
         u32 total_size;         /* size of total dump data */
@@ -192,10 +194,10 @@ struct zfcp_dbf_san_record {
                 struct zfcp_dbf_san_record_ct_response ct_resp;
                 struct zfcp_dbf_san_record_els els;
         } u;
-#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
-        u8 payload[32];
 } __attribute__ ((packed));
 
+#define ZFCP_DBF_SAN_MAX_PAYLOAD 1024
+
 struct zfcp_dbf_scsi_record {
         u8 tag[ZFCP_DBF_TAG_SIZE];
         u8 tag2[ZFCP_DBF_TAG_SIZE];
@@ -301,17 +303,31 @@ void zfcp_dbf_scsi(const char *tag, const char *tag2, int level,
 
 /**
  * zfcp_dbf_scsi_result - trace event for SCSI command completion
- * @tag: tag indicating success or failure of SCSI command
- * @level: trace level applicable for this event
- * @adapter: adapter that has been used to issue the SCSI command
+ * @dbf: adapter dbf trace
+ * @scmd: SCSI command pointer
+ * @req: FSF request used to issue SCSI command
+ */
+static inline
+void zfcp_dbf_scsi_result(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd,
+                          struct zfcp_fsf_req *req)
+{
+        if (scmd->result != 0)
+                zfcp_dbf_scsi("rslt", "erro", 3, dbf, scmd, req, 0);
+        else if (scmd->retries > 0)
+                zfcp_dbf_scsi("rslt", "retr", 4, dbf, scmd, req, 0);
+        else
+                zfcp_dbf_scsi("rslt", "norm", 6, dbf, scmd, req, 0);
+}
+
+/**
+ * zfcp_dbf_scsi_fail_send - trace event for failure to send SCSI command
+ * @dbf: adapter dbf trace
  * @scmd: SCSI command pointer
- * @fsf_req: request used to issue SCSI command (might be NULL)
  */
 static inline
-void zfcp_dbf_scsi_result(const char *tag, int level, struct zfcp_dbf *dbf,
-                          struct scsi_cmnd *scmd, struct zfcp_fsf_req *fsf_req)
+void zfcp_dbf_scsi_fail_send(struct zfcp_dbf *dbf, struct scsi_cmnd *scmd)
 {
-        zfcp_dbf_scsi("rslt", tag, level, dbf, scmd, fsf_req, 0);
+        zfcp_dbf_scsi("rslt", "fail", 4, dbf, scmd, NULL, 0);
 }
 
 /**
diff --git a/drivers/s390/scsi/zfcp_def.h b/drivers/s390/scsi/zfcp_def.h
index e1b5b88e2ddb..7131c7db1f04 100644
--- a/drivers/s390/scsi/zfcp_def.h
+++ b/drivers/s390/scsi/zfcp_def.h
@@ -3,7 +3,7 @@
  *
  * Global definitions for the zfcp device driver.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #ifndef ZFCP_DEF_H
@@ -33,15 +33,13 @@
 #include <scsi/scsi_transport_fc.h>
 #include <scsi/scsi_bsg_fc.h>
 #include <asm/ccwdev.h>
-#include <asm/qdio.h>
 #include <asm/debug.h>
 #include <asm/ebcdic.h>
 #include <asm/sysinfo.h>
 #include "zfcp_fsf.h"
+#include "zfcp_qdio.h"
 
-/********************* GENERAL DEFINES *********************************/
-
-#define REQUEST_LIST_SIZE 128
+struct zfcp_reqlist;
 
 /********************* SCSI SPECIFIC DEFINES *********************************/
 #define ZFCP_SCSI_ER_TIMEOUT                    (10*HZ)
@@ -129,12 +127,6 @@ struct zfcp_adapter_mempool {
         mempool_t *qtcb_pool;
 };
 
-struct zfcp_qdio_queue {
-        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
-        u8                 first;       /* index of next free bfr in queue */
-        atomic_t           count;       /* number of free buffers in queue */
-};
-
 struct zfcp_erp_action {
         struct list_head list;
         int action;                   /* requested action code */
@@ -143,8 +135,7 @@ struct zfcp_erp_action {
         struct zfcp_unit *unit;
         u32             status;       /* recovery status */
         u32 step;                     /* active step of this erp action */
-        struct zfcp_fsf_req *fsf_req; /* fsf request currently pending
-                                         for this action */
+        unsigned long           fsf_req_id;
         struct timer_list timer;
 };
 
@@ -167,29 +158,6 @@ struct zfcp_latencies {
         spinlock_t lock;
 };
 
-/** struct zfcp_qdio - basic QDIO data structure
- * @resp_q: response queue
- * @req_q: request queue
- * @stat_lock: lock to protect req_q_util and req_q_time
- * @req_q_lock; lock to serialize access to request queue
- * @req_q_time: time of last fill level change
- * @req_q_util: used for accounting
- * @req_q_full: queue full incidents
- * @req_q_wq: used to wait for SBAL availability
- * @adapter: adapter used in conjunction with this QDIO structure
- */
-struct zfcp_qdio {
-        struct zfcp_qdio_queue  resp_q;
-        struct zfcp_qdio_queue  req_q;
-        spinlock_t              stat_lock;
-        spinlock_t              req_q_lock;
-        unsigned long long      req_q_time;
-        u64                     req_q_util;
-        atomic_t                req_q_full;
-        wait_queue_head_t       req_q_wq;
-        struct zfcp_adapter     *adapter;
-};
-
 struct zfcp_adapter {
         struct kref             ref;
         u64                     peer_wwnn;         /* P2P peer WWNN */
@@ -207,8 +175,7 @@ struct zfcp_adapter {
         struct list_head        port_list;         /* remote port list */
         rwlock_t                port_list_lock;    /* port list lock */
         unsigned long           req_no;            /* unique FSF req number */
-        struct list_head        *req_list;         /* list of pending reqs */
-        spinlock_t              req_list_lock;     /* request list lock */
+        struct zfcp_reqlist     *req_list;
         u32                     fsf_req_seq_no;    /* FSF cmnd seq number */
         rwlock_t                abort_lock;        /* Protects against SCSI
                                                       stack abort/command
@@ -241,7 +208,7 @@ struct zfcp_adapter {
 };
 
 struct zfcp_port {
-        struct device          sysfs_device;   /* sysfs device */
+        struct device          dev;
         struct fc_rport        *rport;         /* rport of fc transport class */
         struct list_head       list;           /* list of remote ports */
         struct zfcp_adapter    *adapter;       /* adapter used to access port */
@@ -263,7 +230,7 @@ struct zfcp_port {
 };
 
 struct zfcp_unit {
-        struct device          sysfs_device;   /* sysfs device */
+        struct device          dev;
         struct list_head       list;           /* list of logical units */
         struct zfcp_port       *port;          /* remote port of unit */
         atomic_t               status;         /* status of this logical unit */
@@ -277,33 +244,11 @@ struct zfcp_unit {
 };
 
 /**
- * struct zfcp_queue_req - queue related values for a request
- * @sbal_number: number of free SBALs
- * @sbal_first: first SBAL for this request
- * @sbal_last: last SBAL for this request
- * @sbal_limit: last possible SBAL for this request
- * @sbale_curr: current SBALE at creation of this request
- * @sbal_response: SBAL used in interrupt
- * @qdio_outb_usage: usage of outbound queue
- * @qdio_inb_usage: usage of inbound queue
- */
-struct zfcp_queue_req {
-        u8                     sbal_number;
-        u8                     sbal_first;
-        u8                     sbal_last;
-        u8                     sbal_limit;
-        u8                     sbale_curr;
-        u8                     sbal_response;
-        u16                    qdio_outb_usage;
-        u16                    qdio_inb_usage;
-};
-
-/**
  * struct zfcp_fsf_req - basic FSF request structure
  * @list: list of FSF requests
  * @req_id: unique request ID
  * @adapter: adapter this request belongs to
- * @queue_req: queue related values
+ * @qdio_req: qdio queue related values
  * @completion: used to signal the completion of the request
  * @status: status of the request
  * @fsf_command: FSF command issued
@@ -321,7 +266,7 @@ struct zfcp_fsf_req {
         struct list_head        list;
         unsigned long           req_id;
         struct zfcp_adapter     *adapter;
-        struct zfcp_queue_req   queue_req;
+        struct zfcp_qdio_req    qdio_req;
         struct completion       completion;
         u32                     status;
         u32                     fsf_command;
@@ -352,45 +297,4 @@ struct zfcp_data {
 #define ZFCP_SET                0x00000100
 #define ZFCP_CLEAR              0x00000200
 
-/*
- * Helper functions for request ID management.
- */
-static inline int zfcp_reqlist_hash(unsigned long req_id)
-{
-        return req_id % REQUEST_LIST_SIZE;
-}
-
-static inline void zfcp_reqlist_remove(struct zfcp_adapter *adapter,
-                                       struct zfcp_fsf_req *fsf_req)
-{
-        list_del(&fsf_req->list);
-}
-
-static inline struct zfcp_fsf_req *
-zfcp_reqlist_find(struct zfcp_adapter *adapter, unsigned long req_id)
-{
-        struct zfcp_fsf_req *request;
-        unsigned int idx;
-
-        idx = zfcp_reqlist_hash(req_id);
-        list_for_each_entry(request, &adapter->req_list[idx], list)
-                if (request->req_id == req_id)
-                        return request;
-        return NULL;
-}
-
-static inline struct zfcp_fsf_req *
-zfcp_reqlist_find_safe(struct zfcp_adapter *adapter, struct zfcp_fsf_req *req)
-{
-        struct zfcp_fsf_req *request;
-        unsigned int idx;
-
-        for (idx = 0; idx < REQUEST_LIST_SIZE; idx++) {
-                list_for_each_entry(request, &adapter->req_list[idx], list)
-                        if (request == req)
-                                return request;
-        }
-        return NULL;
-}
-
 #endif /* ZFCP_DEF_H */
diff --git a/drivers/s390/scsi/zfcp_erp.c b/drivers/s390/scsi/zfcp_erp.c
index b51a11a82e63..0be5e7ea2828 100644
--- a/drivers/s390/scsi/zfcp_erp.c
+++ b/drivers/s390/scsi/zfcp_erp.c
@@ -3,7 +3,7 @@
  *
  * Error Recovery Procedures (ERP).
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -11,6 +11,7 @@
 
 #include <linux/kthread.h>
 #include "zfcp_ext.h"
+#include "zfcp_reqlist.h"
 
 #define ZFCP_MAX_ERPS                   3
 
@@ -174,7 +175,7 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
 
         switch (need) {
         case ZFCP_ERP_ACTION_REOPEN_UNIT:
-                if (!get_device(&unit->sysfs_device))
+                if (!get_device(&unit->dev))
                         return NULL;
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
                 erp_action = &unit->erp_action;
@@ -184,7 +185,7 @@ static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
 
         case ZFCP_ERP_ACTION_REOPEN_PORT:
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
-                if (!get_device(&port->sysfs_device))
+                if (!get_device(&port->dev))
                         return NULL;
                 zfcp_erp_action_dismiss_port(port);
                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
@@ -478,26 +479,27 @@ static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
 {
         struct zfcp_adapter *adapter = act->adapter;
+        struct zfcp_fsf_req *req;
 
-        if (!act->fsf_req)
+        if (!act->fsf_req_id)
                 return;
 
-        spin_lock(&adapter->req_list_lock);
-        if (zfcp_reqlist_find_safe(adapter, act->fsf_req) &&
-            act->fsf_req->erp_action == act) {
+        spin_lock(&adapter->req_list->lock);
+        req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
+        if (req && req->erp_action == act) {
                 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
                                    ZFCP_STATUS_ERP_TIMEDOUT)) {
-                        act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
+                        req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
                         zfcp_dbf_rec_action("erscf_1", act);
-                        act->fsf_req->erp_action = NULL;
+                        req->erp_action = NULL;
                 }
                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
                         zfcp_dbf_rec_action("erscf_2", act);
-                if (act->fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
-                        act->fsf_req = NULL;
+                if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
+                        act->fsf_req_id = 0;
         } else
-                act->fsf_req = NULL;
-        spin_unlock(&adapter->req_list_lock);
+                act->fsf_req_id = 0;
+        spin_unlock(&adapter->req_list->lock);
 }
 
 /**
@@ -1179,19 +1181,19 @@ static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
         switch (act->action) {
         case ZFCP_ERP_ACTION_REOPEN_UNIT:
                 if ((result == ZFCP_ERP_SUCCEEDED) && !unit->device) {
-                        get_device(&unit->sysfs_device);
+                        get_device(&unit->dev);
                         if (scsi_queue_work(unit->port->adapter->scsi_host,
                                             &unit->scsi_work) <= 0)
-                                put_device(&unit->sysfs_device);
+                                put_device(&unit->dev);
                 }
-                put_device(&unit->sysfs_device);
+                put_device(&unit->dev);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
         case ZFCP_ERP_ACTION_REOPEN_PORT:
                 if (result == ZFCP_ERP_SUCCEEDED)
                         zfcp_scsi_schedule_rport_register(port);
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
                 break;
 
         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
diff --git a/drivers/s390/scsi/zfcp_ext.h b/drivers/s390/scsi/zfcp_ext.h
index 66bdb34143cb..8786a79c7f8f 100644
--- a/drivers/s390/scsi/zfcp_ext.h
+++ b/drivers/s390/scsi/zfcp_ext.h
@@ -21,7 +21,6 @@ extern struct zfcp_adapter *zfcp_adapter_enqueue(struct ccw_device *);
 extern struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *, u64, u32,
                                            u32);
 extern struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *, u64);
-extern int zfcp_reqlist_isempty(struct zfcp_adapter *);
 extern void zfcp_sg_free_table(struct scatterlist *, int);
 extern int zfcp_sg_setup_table(struct scatterlist *, int);
 extern void zfcp_device_unregister(struct device *,
@@ -144,13 +143,9 @@ extern void zfcp_fsf_reqid_check(struct zfcp_qdio *, int);
 /* zfcp_qdio.c */
 extern int zfcp_qdio_setup(struct zfcp_adapter *);
 extern void zfcp_qdio_destroy(struct zfcp_qdio *);
-extern int zfcp_qdio_send(struct zfcp_qdio *, struct zfcp_queue_req *);
-extern struct qdio_buffer_element
-        *zfcp_qdio_sbale_req(struct zfcp_qdio *, struct zfcp_queue_req *);
-extern struct qdio_buffer_element
-        *zfcp_qdio_sbale_curr(struct zfcp_qdio *, struct zfcp_queue_req *);
+extern int zfcp_qdio_send(struct zfcp_qdio *, struct zfcp_qdio_req *);
 extern int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *,
-                                   struct zfcp_queue_req *, unsigned long,
+                                   struct zfcp_qdio_req *, unsigned long,
                                    struct scatterlist *, int);
 extern int zfcp_qdio_open(struct zfcp_qdio *);
 extern void zfcp_qdio_close(struct zfcp_qdio *);
diff --git a/drivers/s390/scsi/zfcp_fc.c b/drivers/s390/scsi/zfcp_fc.c
index 271399f62f1b..5219670f0c99 100644
--- a/drivers/s390/scsi/zfcp_fc.c
+++ b/drivers/s390/scsi/zfcp_fc.c
@@ -3,7 +3,7 @@
  *
  * Fibre Channel related functions for the zfcp device driver.
  *
- * Copyright IBM Corporation 2008, 2009
+ * Copyright IBM Corporation 2008, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -316,7 +316,7 @@ void zfcp_fc_port_did_lookup(struct work_struct *work)
 
         zfcp_erp_port_reopen(port, 0, "fcgpn_3", NULL);
 out:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 }
 
 /**
@@ -325,9 +325,9 @@ out:
  */
 void zfcp_fc_trigger_did_lookup(struct zfcp_port *port)
 {
-        get_device(&port->sysfs_device);
+        get_device(&port->dev);
         if (!queue_work(port->adapter->work_queue, &port->gid_pn_work))
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
 }
 
 /**
@@ -389,7 +389,7 @@ static void zfcp_fc_adisc_handler(void *data)
         zfcp_scsi_schedule_rport_register(port);
  out:
         atomic_clear_mask(ZFCP_STATUS_PORT_LINK_TEST, &port->status);
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
         kmem_cache_free(zfcp_data.adisc_cache, adisc);
 }
 
@@ -436,7 +436,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
                 container_of(work, struct zfcp_port, test_link_work);
         int retval;
 
-        get_device(&port->sysfs_device);
+        get_device(&port->dev);
         port->rport_task = RPORT_DEL;
         zfcp_scsi_rport_work(&port->rport_work);
 
@@ -455,7 +455,7 @@ void zfcp_fc_link_test_work(struct work_struct *work)
         zfcp_erp_port_forced_reopen(port, 0, "fcltwk1", NULL);
 
 out:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 }
 
 /**
@@ -468,9 +468,9 @@ out:
  */
 void zfcp_fc_test_link(struct zfcp_port *port)
 {
-        get_device(&port->sysfs_device);
+        get_device(&port->dev);
         if (!queue_work(port->adapter->work_queue, &port->test_link_work))
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
 }
 
 static void zfcp_free_sg_env(struct zfcp_fc_gpn_ft *gpn_ft, int buf_num)
@@ -617,8 +617,7 @@ static int zfcp_fc_eval_gpn_ft(struct zfcp_fc_gpn_ft *gpn_ft,
 
         list_for_each_entry_safe(port, tmp, &remove_lh, list) {
                 zfcp_erp_port_shutdown(port, 0, "fcegpf2", NULL);
-                zfcp_device_unregister(&port->sysfs_device,
-                                       &zfcp_sysfs_port_attrs);
+                zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
         }
 
         return ret;
@@ -731,7 +730,7 @@ static int zfcp_fc_exec_els_job(struct fc_bsg_job *job,
                         return -EINVAL;
 
                 d_id = port->d_id;
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
         } else
                 d_id = ntoh24(job->request->rqst_data.h_els.port_id);
 
diff --git a/drivers/s390/scsi/zfcp_fsf.c b/drivers/s390/scsi/zfcp_fsf.c
index e8fb4d9baa8b..6538742b421a 100644
--- a/drivers/s390/scsi/zfcp_fsf.c
+++ b/drivers/s390/scsi/zfcp_fsf.c
@@ -3,7 +3,7 @@
  *
  * Implementation of FSF commands.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -14,6 +14,8 @@
 #include "zfcp_ext.h"
 #include "zfcp_fc.h"
 #include "zfcp_dbf.h"
+#include "zfcp_qdio.h"
+#include "zfcp_reqlist.h"
 
 static void zfcp_fsf_request_timeout_handler(unsigned long data)
 {
@@ -393,7 +395,7 @@ static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req)
         case FSF_PROT_LINK_DOWN:
                 zfcp_fsf_link_down_info_eval(req, "fspse_5",
                                              &psq->link_down_info);
-                /* FIXME: reopening adapter now? better wait for link up */
+                /* go through reopen to flush pending requests */
                 zfcp_erp_adapter_reopen(adapter, 0, "fspse_6", req);
                 break;
         case FSF_PROT_REEST_QUEUE:
@@ -457,15 +459,10 @@ static void zfcp_fsf_req_complete(struct zfcp_fsf_req *req)
 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter)
 {
         struct zfcp_fsf_req *req, *tmp;
-        unsigned long flags;
         LIST_HEAD(remove_queue);
-        unsigned int i;
 
         BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP);
-        spin_lock_irqsave(&adapter->req_list_lock, flags);
-        for (i = 0; i < REQUEST_LIST_SIZE; i++)
-                list_splice_init(&adapter->req_list[i], &remove_queue);
-        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+        zfcp_reqlist_move(adapter->req_list, &remove_queue);
 
         list_for_each_entry_safe(req, tmp, &remove_queue, list) {
                 list_del(&req->list);
@@ -495,8 +492,6 @@ static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req)
         fc_host_port_id(shost) = ntoh24(bottom->s_id);
         fc_host_speed(shost) = bottom->fc_link_speed;
         fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3;
-        fc_host_supported_fc4s(shost)[2] = 1; /* FCP */
-        fc_host_active_fc4s(shost)[2] = 1; /* FCP */
 
         adapter->hydra_version = bottom->adapter_type;
         adapter->timer_ticks = bottom->timer_interval;
@@ -619,6 +614,10 @@ static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req)
                 fc_host_permanent_port_name(shost) = fc_host_port_name(shost);
         fc_host_maxframe_size(shost) = bottom->maximum_frame_size;
         fc_host_supported_speeds(shost) = bottom->supported_speed;
+        memcpy(fc_host_supported_fc4s(shost), bottom->supported_fc4_types,
+               FC_FC4_LIST_SIZE);
+        memcpy(fc_host_active_fc4s(shost), bottom->active_fc4_types,
+               FC_FC4_LIST_SIZE);
 }
 
 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req)
@@ -725,12 +724,12 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
         req->adapter = adapter;
         req->fsf_command = fsf_cmd;
         req->req_id = adapter->req_no;
-        req->queue_req.sbal_number = 1;
-        req->queue_req.sbal_first = req_q->first;
-        req->queue_req.sbal_last = req_q->first;
-        req->queue_req.sbale_curr = 1;
+        req->qdio_req.sbal_number = 1;
+        req->qdio_req.sbal_first = req_q->first;
+        req->qdio_req.sbal_last = req_q->first;
+        req->qdio_req.sbale_curr = 1;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].addr = (void *) req->req_id;
         sbale[0].flags |= SBAL_FLAGS0_COMMAND;
 
@@ -745,6 +744,7 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
                         return ERR_PTR(-ENOMEM);
                 }
 
+                req->seq_no = adapter->fsf_req_seq_no;
                 req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
                 req->qtcb->prefix.req_id = req->req_id;
                 req->qtcb->prefix.ulp_info = 26;
@@ -752,8 +752,6 @@ static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_qdio *qdio,
                 req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION;
                 req->qtcb->header.req_handle = req->req_id;
                 req->qtcb->header.fsf_command = req->fsf_command;
-                req->seq_no = adapter->fsf_req_seq_no;
-                req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no;
                 sbale[1].addr = (void *) req->qtcb;
                 sbale[1].length = sizeof(struct fsf_qtcb);
         }
@@ -770,25 +768,17 @@ static int zfcp_fsf_req_send(struct zfcp_fsf_req *req)
 {
         struct zfcp_adapter *adapter = req->adapter;
         struct zfcp_qdio *qdio = adapter->qdio;
-        unsigned long        flags;
-        int                  idx;
-        int                  with_qtcb = (req->qtcb != NULL);
+        int with_qtcb = (req->qtcb != NULL);
+        int req_id = req->req_id;
 
-        /* put allocated FSF request into hash table */
-        spin_lock_irqsave(&adapter->req_list_lock, flags);
-        idx = zfcp_reqlist_hash(req->req_id);
-        list_add_tail(&req->list, &adapter->req_list[idx]);
-        spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+        zfcp_reqlist_add(adapter->req_list, req);
 
-        req->queue_req.qdio_outb_usage = atomic_read(&qdio->req_q.count);
+        req->qdio_req.qdio_outb_usage = atomic_read(&qdio->req_q.count);
         req->issued = get_clock();
-        if (zfcp_qdio_send(qdio, &req->queue_req)) {
+        if (zfcp_qdio_send(qdio, &req->qdio_req)) {
                 del_timer(&req->timer);
-                spin_lock_irqsave(&adapter->req_list_lock, flags);
                 /* lookup request again, list might have changed */
-                if (zfcp_reqlist_find_safe(adapter, req))
-                        zfcp_reqlist_remove(adapter, req);
-                spin_unlock_irqrestore(&adapter->req_list_lock, flags);
+                zfcp_reqlist_find_rm(adapter->req_list, req_id);
                 zfcp_erp_adapter_reopen(adapter, 0, "fsrs__1", req);
                 return -EIO;
         }
@@ -826,9 +816,9 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
                 goto out;
         }
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY;
-        req->queue_req.sbale_curr = 2;
+        req->qdio_req.sbale_curr = 2;
 
         sr_buf = mempool_alloc(adapter->pool.status_read_data, GFP_ATOMIC);
         if (!sr_buf) {
@@ -837,7 +827,7 @@ int zfcp_fsf_status_read(struct zfcp_qdio *qdio)
         }
         memset(sr_buf, 0, sizeof(*sr_buf));
         req->data = sr_buf;
-        sbale = zfcp_qdio_sbale_curr(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_curr(qdio, &req->qdio_req);
         sbale->addr = (void *) sr_buf;
         sbale->length = sizeof(*sr_buf);
 
@@ -934,7 +924,7 @@ struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id,
                        ZFCP_STATUS_COMMON_UNBLOCKED)))
                 goto out_error_free;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1029,7 +1019,7 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
 {
         struct zfcp_adapter *adapter = req->adapter;
         struct qdio_buffer_element *sbale = zfcp_qdio_sbale_req(adapter->qdio,
-                                                               &req->queue_req);
+                                                               &req->qdio_req);
         u32 feat = adapter->adapter_features;
         int bytes;
 
@@ -1047,15 +1037,15 @@ static int zfcp_fsf_setup_ct_els_sbals(struct zfcp_fsf_req *req,
                 return 0;
         }
 
-        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req,
+        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->qdio_req,
                                         SBAL_FLAGS0_TYPE_WRITE_READ,
                                         sg_req, max_sbals);
         if (bytes <= 0)
                 return -EIO;
         req->qtcb->bottom.support.req_buf_length = bytes;
-        req->queue_req.sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
+        req->qdio_req.sbale_curr = ZFCP_LAST_SBALE_PER_SBAL;
 
-        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->queue_req,
+        bytes = zfcp_qdio_sbals_from_sg(adapter->qdio, &req->qdio_req,
                                         SBAL_FLAGS0_TYPE_WRITE_READ,
                                         sg_resp, max_sbals);
         req->qtcb->bottom.support.resp_buf_length = bytes;
@@ -1251,7 +1241,7 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1262,13 +1252,13 @@ int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action)
                         FSF_FEATURE_UPDATE_ALERT;
         req->erp_action = erp_action;
         req->handler = zfcp_fsf_exchange_config_data_handler;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1293,7 +1283,7 @@ int zfcp_fsf_exchange_config_data_sync(struct zfcp_qdio *qdio,
                 goto out_unlock;
         }
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
         req->handler = zfcp_fsf_exchange_config_data_handler;
@@ -1349,19 +1339,19 @@ int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
         req->handler = zfcp_fsf_exchange_port_data_handler;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1398,7 +1388,7 @@ int zfcp_fsf_exchange_port_data_sync(struct zfcp_qdio *qdio,
         if (data)
                 req->data = data;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1484,7 +1474,7 @@ static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req)
         }
 
 out:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 }
 
 /**
@@ -1513,7 +1503,7 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1521,15 +1511,15 @@ int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action)
         hton24(req->qtcb->bottom.support.d_id, port->d_id);
         req->data = port;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
-        get_device(&port->sysfs_device);
+        erp_action->fsf_req_id = req->req_id;
+        get_device(&port->dev);
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
-                put_device(&port->sysfs_device);
+                erp_action->fsf_req_id = 0;
+                put_device(&port->dev);
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1583,7 +1573,7 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1591,13 +1581,13 @@ int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action)
         req->data = erp_action->port;
         req->erp_action = erp_action;
         req->qtcb->header.port_handle = erp_action->port->handle;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1660,7 +1650,7 @@ int zfcp_fsf_open_wka_port(struct zfcp_fc_wka_port *wka_port)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1715,7 +1705,7 @@ int zfcp_fsf_close_wka_port(struct zfcp_fc_wka_port *wka_port)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1809,7 +1799,7 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1817,13 +1807,13 @@ int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action)
         req->qtcb->header.port_handle = erp_action->port->handle;
         req->erp_action = erp_action;
         req->handler = zfcp_fsf_close_physical_port_handler;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -1982,7 +1972,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -1991,7 +1981,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         req->handler = zfcp_fsf_open_unit_handler;
         req->data = erp_action->unit;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE))
                 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING;
@@ -2000,7 +1990,7 @@ int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action)
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -2068,7 +2058,7 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_READ;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -2077,13 +2067,13 @@ int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action)
         req->handler = zfcp_fsf_close_unit_handler;
         req->data = erp_action->unit;
         req->erp_action = erp_action;
-        erp_action->fsf_req = req;
+        erp_action->fsf_req_id = req->req_id;
 
         zfcp_fsf_start_erp_timer(req);
         retval = zfcp_fsf_req_send(req);
         if (retval) {
                 zfcp_fsf_req_free(req);
-                erp_action->fsf_req = NULL;
+                erp_action->fsf_req_id = 0;
         }
 out:
         spin_unlock_bh(&qdio->req_q_lock);
@@ -2111,8 +2101,8 @@ static void zfcp_fsf_req_trace(struct zfcp_fsf_req *req, struct scsi_cmnd *scsi)
         blktrc.magic = ZFCP_BLK_DRV_DATA_MAGIC;
         if (req->status & ZFCP_STATUS_FSFREQ_ERROR)
                 blktrc.flags |= ZFCP_BLK_REQ_ERROR;
-        blktrc.inb_usage = req->queue_req.qdio_inb_usage;
-        blktrc.outb_usage = req->queue_req.qdio_outb_usage;
+        blktrc.inb_usage = req->qdio_req.qdio_inb_usage;
+        blktrc.outb_usage = req->qdio_req.qdio_outb_usage;
 
         if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) {
                 blktrc.flags |= ZFCP_BLK_LAT_VALID;
@@ -2169,12 +2159,7 @@ static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req)
         zfcp_fsf_req_trace(req, scpnt);
 
 skip_fsfstatus:
-        if (scpnt->result != 0)
-                zfcp_dbf_scsi_result("erro", 3, req->adapter->dbf, scpnt, req);
-        else if (scpnt->retries > 0)
-                zfcp_dbf_scsi_result("retr", 4, req->adapter->dbf, scpnt, req);
-        else
-                zfcp_dbf_scsi_result("norm", 6, req->adapter->dbf, scpnt, req);
+        zfcp_dbf_scsi_result(req->adapter->dbf, scpnt, req);
 
         scpnt->host_scribble = NULL;
         (scpnt->scsi_done) (scpnt);
@@ -2274,7 +2259,7 @@ skip_fsfstatus:
         else {
                 zfcp_fsf_send_fcp_command_task_handler(req);
                 req->unit = NULL;
-                put_device(&unit->sysfs_device);
+                put_device(&unit->dev);
         }
 }
 
@@ -2312,7 +2297,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         }
 
         req->status |= ZFCP_STATUS_FSFREQ_CLEANUP;
-        get_device(&unit->sysfs_device);
+        get_device(&unit->dev);
         req->unit = unit;
         req->data = scsi_cmnd;
         req->handler = zfcp_fsf_send_fcp_command_handler;
@@ -2346,11 +2331,11 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         fcp_cmnd = (struct fcp_cmnd *) &req->qtcb->bottom.io.fcp_cmnd;
         zfcp_fc_scsi_to_fcp(fcp_cmnd, scsi_cmnd);
 
-        real_bytes = zfcp_qdio_sbals_from_sg(qdio, &req->queue_req, sbtype,
+        real_bytes = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req, sbtype,
                                              scsi_sglist(scsi_cmnd),
                                              FSF_MAX_SBALS_PER_REQ);
         if (unlikely(real_bytes < 0)) {
-                if (req->queue_req.sbal_number >= FSF_MAX_SBALS_PER_REQ) {
+                if (req->qdio_req.sbal_number >= FSF_MAX_SBALS_PER_REQ) {
                         dev_err(&adapter->ccw_device->dev,
                                 "Oversize data package, unit 0x%016Lx "
                                 "on port 0x%016Lx closed\n",
@@ -2369,7 +2354,7 @@ int zfcp_fsf_send_fcp_command_task(struct zfcp_unit *unit,
         goto out;
 
 failed_scsi_cmnd:
-        put_device(&unit->sysfs_device);
+        put_device(&unit->dev);
         zfcp_fsf_req_free(req);
         scsi_cmnd->host_scribble = NULL;
 out:
@@ -2415,7 +2400,7 @@ struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_unit *unit, u8 tm_flags)
         req->qtcb->bottom.io.service_class = FSF_CLASS_3;
         req->qtcb->bottom.io.fcp_cmnd_length = FCP_CMND_LEN;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE;
         sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY;
 
@@ -2478,14 +2463,14 @@ struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter,
 
         req->handler = zfcp_fsf_control_file_handler;
 
-        sbale = zfcp_qdio_sbale_req(qdio, &req->queue_req);
+        sbale = zfcp_qdio_sbale_req(qdio, &req->qdio_req);
         sbale[0].flags |= direction;
 
         bottom = &req->qtcb->bottom.support;
         bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE;
         bottom->option = fsf_cfdc->option;
 
-        bytes = zfcp_qdio_sbals_from_sg(qdio, &req->queue_req,
+        bytes = zfcp_qdio_sbals_from_sg(qdio, &req->qdio_req,
                                         direction, fsf_cfdc->sg,
                                         FSF_MAX_SBALS_PER_REQ);
         if (bytes != ZFCP_CFDC_MAX_SIZE) {
@@ -2516,15 +2501,14 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
         struct qdio_buffer *sbal = qdio->resp_q.sbal[sbal_idx];
         struct qdio_buffer_element *sbale;
         struct zfcp_fsf_req *fsf_req;
-        unsigned long flags, req_id;
+        unsigned long req_id;
         int idx;
 
         for (idx = 0; idx < QDIO_MAX_ELEMENTS_PER_BUFFER; idx++) {
 
                 sbale = &sbal->element[idx];
                 req_id = (unsigned long) sbale->addr;
-                spin_lock_irqsave(&adapter->req_list_lock, flags);
-                fsf_req = zfcp_reqlist_find(adapter, req_id);
+                fsf_req = zfcp_reqlist_find_rm(adapter->req_list, req_id);
 
                 if (!fsf_req)
                         /*
@@ -2534,11 +2518,8 @@ void zfcp_fsf_reqid_check(struct zfcp_qdio *qdio, int sbal_idx)
                         panic("error: unknown req_id (%lx) on adapter %s.\n",
                               req_id, dev_name(&adapter->ccw_device->dev));
 
-                list_del(&fsf_req->list);
-                spin_unlock_irqrestore(&adapter->req_list_lock, flags);
-
-                fsf_req->queue_req.sbal_response = sbal_idx;
-                fsf_req->queue_req.qdio_inb_usage =
+                fsf_req->qdio_req.sbal_response = sbal_idx;
+                fsf_req->qdio_req.qdio_inb_usage =
                         atomic_read(&qdio->resp_q.count);
                 zfcp_fsf_req_complete(fsf_req);
 
diff --git a/drivers/s390/scsi/zfcp_qdio.c b/drivers/s390/scsi/zfcp_qdio.c
index 6c5228b627fc..71b97ff77cf0 100644
--- a/drivers/s390/scsi/zfcp_qdio.c
+++ b/drivers/s390/scsi/zfcp_qdio.c
@@ -10,6 +10,7 @@
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 
 #include "zfcp_ext.h"
+#include "zfcp_qdio.h"
 
 #define QBUFF_PER_PAGE          (PAGE_SIZE / sizeof(struct qdio_buffer))
 
@@ -28,12 +29,6 @@ static int zfcp_qdio_buffers_enqueue(struct qdio_buffer **sbal)
         return 0;
 }
 
-static struct qdio_buffer_element *
-zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
-{
-        return &q->sbal[sbal_idx]->element[sbale_idx];
-}
-
 static void zfcp_qdio_handler_error(struct zfcp_qdio *qdio, char *id)
 {
         struct zfcp_adapter *adapter = qdio->adapter;
@@ -106,7 +101,7 @@ static void zfcp_qdio_resp_put_back(struct zfcp_qdio *qdio, int processed)
 
         if (unlikely(retval)) {
                 atomic_set(&queue->count, count);
-                /* FIXME: Recover this with an adapter reopen? */
+                zfcp_erp_adapter_reopen(qdio->adapter, 0, "qdrpb_1", NULL);
         } else {
                 queue->first += count;
                 queue->first %= QDIO_MAX_BUFFERS_PER_Q;
@@ -145,32 +140,8 @@ static void zfcp_qdio_int_resp(struct ccw_device *cdev, unsigned int qdio_err,
         zfcp_qdio_resp_put_back(qdio, count);
 }
 
-/**
- * zfcp_qdio_sbale_req - return ptr to SBALE of req_q for a struct zfcp_fsf_req
- * @qdio: pointer to struct zfcp_qdio
- * @q_rec: pointer to struct zfcp_queue_rec
- * Returns: pointer to qdio_buffer_element (SBALE) structure
- */
-struct qdio_buffer_element *zfcp_qdio_sbale_req(struct zfcp_qdio *qdio,
-                                                struct zfcp_queue_req *q_req)
-{
-        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0);
-}
-
-/**
- * zfcp_qdio_sbale_curr - return curr SBALE on req_q for a struct zfcp_fsf_req
- * @fsf_req: pointer to struct fsf_req
- * Returns: pointer to qdio_buffer_element (SBALE) structure
- */
-struct qdio_buffer_element *zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio,
-                                                 struct zfcp_queue_req *q_req)
-{
-        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last,
-                               q_req->sbale_curr);
-}
-
 static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio,
-                                 struct zfcp_queue_req *q_req, int max_sbals)
+                                 struct zfcp_qdio_req *q_req, int max_sbals)
 {
         int count = atomic_read(&qdio->req_q.count);
         count = min(count, max_sbals);
@@ -179,7 +150,7 @@ static void zfcp_qdio_sbal_limit(struct zfcp_qdio *qdio,
 }
 
 static struct qdio_buffer_element *
-zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
+zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
                      unsigned long sbtype)
 {
         struct qdio_buffer_element *sbale;
@@ -214,7 +185,7 @@ zfcp_qdio_sbal_chain(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
 }
 
 static struct qdio_buffer_element *
-zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
+zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
                      unsigned int sbtype)
 {
         if (q_req->sbale_curr == ZFCP_LAST_SBALE_PER_SBAL)
@@ -224,7 +195,7 @@ zfcp_qdio_sbale_next(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req,
 }
 
 static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio,
-                                 struct zfcp_queue_req *q_req)
+                                 struct zfcp_qdio_req *q_req)
 {
         struct qdio_buffer **sbal = qdio->req_q.sbal;
         int first = q_req->sbal_first;
@@ -235,7 +206,7 @@ static void zfcp_qdio_undo_sbals(struct zfcp_qdio *qdio,
 }
 
 static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio,
-                                struct zfcp_queue_req *q_req,
+                                struct zfcp_qdio_req *q_req,
                                 unsigned int sbtype, void *start_addr,
                                 unsigned int total_length)
 {
@@ -271,8 +242,7 @@ static int zfcp_qdio_fill_sbals(struct zfcp_qdio *qdio,
  * @max_sbals: upper bound for number of SBALs to be used
  * Returns: number of bytes, or error (negativ)
  */
-int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio,
-                            struct zfcp_queue_req *q_req,
+int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req,
                             unsigned long sbtype, struct scatterlist *sg,
                             int max_sbals)
 {
@@ -304,10 +274,10 @@ int zfcp_qdio_sbals_from_sg(struct zfcp_qdio *qdio,
 /**
  * zfcp_qdio_send - set PCI flag in first SBALE and send req to QDIO
  * @qdio: pointer to struct zfcp_qdio
- * @q_req: pointer to struct zfcp_queue_req
+ * @q_req: pointer to struct zfcp_qdio_req
  * Returns: 0 on success, error otherwise
  */
-int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_queue_req *q_req)
+int zfcp_qdio_send(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
 {
         struct zfcp_qdio_queue *req_q = &qdio->req_q;
         int first = q_req->sbal_first;
diff --git a/drivers/s390/scsi/zfcp_qdio.h b/drivers/s390/scsi/zfcp_qdio.h
new file mode 100644
index 000000000000..8cca54631e1e
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_qdio.h
@@ -0,0 +1,109 @@
+/*
+ * zfcp device driver
+ *
+ * Header file for zfcp qdio interface
+ *
+ * Copyright IBM Corporation 2010
+ */
+
+#ifndef ZFCP_QDIO_H
+#define ZFCP_QDIO_H
+
+#include <asm/qdio.h>
+
+/**
+ * struct zfcp_qdio_queue - qdio queue buffer, zfcp index and free count
+ * @sbal: qdio buffers
+ * @first: index of next free buffer in queue
+ * @count: number of free buffers in queue
+ */
+struct zfcp_qdio_queue {
+        struct qdio_buffer *sbal[QDIO_MAX_BUFFERS_PER_Q];
+        u8                 first;
+        atomic_t           count;
+};
+
+/**
+ * struct zfcp_qdio - basic qdio data structure
+ * @resp_q: response queue
+ * @req_q: request queue
+ * @stat_lock: lock to protect req_q_util and req_q_time
+ * @req_q_lock: lock to serialize access to request queue
+ * @req_q_time: time of last fill level change
+ * @req_q_util: used for accounting
+ * @req_q_full: queue full incidents
+ * @req_q_wq: used to wait for SBAL availability
+ * @adapter: adapter used in conjunction with this qdio structure
+ */
+struct zfcp_qdio {
+        struct zfcp_qdio_queue  resp_q;
+        struct zfcp_qdio_queue  req_q;
+        spinlock_t              stat_lock;
+        spinlock_t              req_q_lock;
+        unsigned long long      req_q_time;
+        u64                     req_q_util;
+        atomic_t                req_q_full;
+        wait_queue_head_t       req_q_wq;
+        struct zfcp_adapter     *adapter;
+};
+
+/**
+ * struct zfcp_qdio_req - qdio queue related values for a request
+ * @sbal_number: number of free sbals
+ * @sbal_first: first sbal for this request
+ * @sbal_last: last sbal for this request
+ * @sbal_limit: last possible sbal for this request
+ * @sbale_curr: current sbale at creation of this request
+ * @sbal_response: sbal used in interrupt
+ * @qdio_outb_usage: usage of outbound queue
+ * @qdio_inb_usage: usage of inbound queue
+ */
+struct zfcp_qdio_req {
+        u8      sbal_number;
+        u8      sbal_first;
+        u8      sbal_last;
+        u8      sbal_limit;
+        u8      sbale_curr;
+        u8      sbal_response;
+        u16     qdio_outb_usage;
+        u16     qdio_inb_usage;
+};
+
+/**
+ * zfcp_qdio_sbale - return pointer to sbale in qdio queue
+ * @q: queue where to find sbal
+ * @sbal_idx: sbal index in queue
+ * @sbale_idx: sbale index in sbal
+ */
+static inline struct qdio_buffer_element *
+zfcp_qdio_sbale(struct zfcp_qdio_queue *q, int sbal_idx, int sbale_idx)
+{
+        return &q->sbal[sbal_idx]->element[sbale_idx];
+}
+
+/**
+ * zfcp_qdio_sbale_req - return pointer to sbale on req_q for a request
+ * @qdio: pointer to struct zfcp_qdio
+ * @q_rec: pointer to struct zfcp_qdio_req
+ * Returns: pointer to qdio_buffer_element (sbale) structure
+ */
+static inline struct qdio_buffer_element *
+zfcp_qdio_sbale_req(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
+{
+        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last, 0);
+}
+
+/**
+ * zfcp_qdio_sbale_curr - return current sbale on req_q for a request
+ * @qdio: pointer to struct zfcp_qdio
+ * @fsf_req: pointer to struct zfcp_fsf_req
+ * Returns: pointer to qdio_buffer_element (sbale) structure
+ */
+static inline struct qdio_buffer_element *
+zfcp_qdio_sbale_curr(struct zfcp_qdio *qdio, struct zfcp_qdio_req *q_req)
+{
+        return zfcp_qdio_sbale(&qdio->req_q, q_req->sbal_last,
+                               q_req->sbale_curr);
+}
+
+#endif /* ZFCP_QDIO_H */
diff --git a/drivers/s390/scsi/zfcp_reqlist.h b/drivers/s390/scsi/zfcp_reqlist.h
new file mode 100644
index 000000000000..a72d1b730aba
--- /dev/null
+++ b/drivers/s390/scsi/zfcp_reqlist.h
@@ -0,0 +1,183 @@
+/*
+ * zfcp device driver
+ *
+ * Data structure and helper functions for tracking pending FSF
+ * requests.
+ *
+ * Copyright IBM Corporation 2009
+ */
+
+#ifndef ZFCP_REQLIST_H
+#define ZFCP_REQLIST_H
+
+/* number of hash buckets */
+#define ZFCP_REQ_LIST_BUCKETS 128
+
+/**
+ * struct zfcp_reqlist - Container for request list (reqlist)
+ * @lock: Spinlock for protecting the hash list
+ * @list: Array of hashbuckets, each is a list of requests in this bucket
+ */
+struct zfcp_reqlist {
+        spinlock_t lock;
+        struct list_head buckets[ZFCP_REQ_LIST_BUCKETS];
+};
+
+static inline int zfcp_reqlist_hash(unsigned long req_id)
+{
+        return req_id % ZFCP_REQ_LIST_BUCKETS;
+}
+
+/**
+ * zfcp_reqlist_alloc - Allocate and initialize reqlist
+ *
+ * Returns pointer to allocated reqlist on success, or NULL on
+ * allocation failure.
+ */
+static inline struct zfcp_reqlist *zfcp_reqlist_alloc(void)
+{
+        unsigned int i;
+        struct zfcp_reqlist *rl;
+
+        rl = kzalloc(sizeof(struct zfcp_reqlist), GFP_KERNEL);
+        if (!rl)
+                return NULL;
+
+        spin_lock_init(&rl->lock);
+
+        for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
+                INIT_LIST_HEAD(&rl->buckets[i]);
+
+        return rl;
+}
+
+/**
+ * zfcp_reqlist_isempty - Check whether the request list empty
+ * @rl: pointer to reqlist
+ *
+ * Returns: 1 if list is empty, 0 if not
+ */
+static inline int zfcp_reqlist_isempty(struct zfcp_reqlist *rl)
+{
+        unsigned int i;
+
+        for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
+                if (!list_empty(&rl->buckets[i]))
+                        return 0;
+        return 1;
+}
+
+/**
+ * zfcp_reqlist_free - Free allocated memory for reqlist
+ * @rl: The reqlist where to free memory
+ */
+static inline void zfcp_reqlist_free(struct zfcp_reqlist *rl)
+{
+        /* sanity check */
+        BUG_ON(!zfcp_reqlist_isempty(rl));
+
+        kfree(rl);
+}
+
+static inline struct zfcp_fsf_req *
+_zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
+{
+        struct zfcp_fsf_req *req;
+        unsigned int i;
+
+        i = zfcp_reqlist_hash(req_id);
+        list_for_each_entry(req, &rl->buckets[i], list)
+                if (req->req_id == req_id)
+                        return req;
+        return NULL;
+}
+
+/**
+ * zfcp_reqlist_find - Lookup FSF request by its request id
+ * @rl: The reqlist where to lookup the FSF request
+ * @req_id: The request id to look for
+ *
+ * Returns a pointer to the FSF request with the specified request id
+ * or NULL if there is no known FSF request with this id.
+ */
+static inline struct zfcp_fsf_req *
+zfcp_reqlist_find(struct zfcp_reqlist *rl, unsigned long req_id)
+{
+        unsigned long flags;
+        struct zfcp_fsf_req *req;
+
+        spin_lock_irqsave(&rl->lock, flags);
+        req = _zfcp_reqlist_find(rl, req_id);
+        spin_unlock_irqrestore(&rl->lock, flags);
+
+        return req;
+}
+
+/**
+ * zfcp_reqlist_find_rm - Lookup request by id and remove it from reqlist
+ * @rl: reqlist where to search and remove entry
+ * @req_id: The request id of the request to look for
+ *
+ * This functions tries to find the FSF request with the specified
+ * id and then removes it from the reqlist. The reqlist lock is held
+ * during both steps of the operation.
+ *
+ * Returns: Pointer to the FSF request if the request has been found,
+ * NULL if it has not been found.
+ */
+static inline struct zfcp_fsf_req *
+zfcp_reqlist_find_rm(struct zfcp_reqlist *rl, unsigned long req_id)
+{
+        unsigned long flags;
+        struct zfcp_fsf_req *req;
+
+        spin_lock_irqsave(&rl->lock, flags);
+        req = _zfcp_reqlist_find(rl, req_id);
+        if (req)
+                list_del(&req->list);
+        spin_unlock_irqrestore(&rl->lock, flags);
+
+        return req;
+}
+
+/**
+ * zfcp_reqlist_add - Add entry to reqlist
+ * @rl: reqlist where to add the entry
+ * @req: The entry to add
+ *
+ * The request id always increases. As an optimization new requests
+ * are added here with list_add_tail at the end of the bucket lists
+ * while old requests are looked up starting at the beginning of the
+ * lists.
+ */
+static inline void zfcp_reqlist_add(struct zfcp_reqlist *rl,
+                                    struct zfcp_fsf_req *req)
+{
+        unsigned int i;
+        unsigned long flags;
+
+        i = zfcp_reqlist_hash(req->req_id);
+
+        spin_lock_irqsave(&rl->lock, flags);
+        list_add_tail(&req->list, &rl->buckets[i]);
+        spin_unlock_irqrestore(&rl->lock, flags);
+}
+
+/**
+ * zfcp_reqlist_move - Move all entries from reqlist to simple list
+ * @rl: The zfcp_reqlist where to remove all entries
+ * @list: The list where to move all entries
+ */
+static inline void zfcp_reqlist_move(struct zfcp_reqlist *rl,
+                                     struct list_head *list)
+{
+        unsigned int i;
+        unsigned long flags;
+
+        spin_lock_irqsave(&rl->lock, flags);
+        for (i = 0; i < ZFCP_REQ_LIST_BUCKETS; i++)
+                list_splice_init(&rl->buckets[i], list);
+        spin_unlock_irqrestore(&rl->lock, flags);
+}
+
+#endif /* ZFCP_REQLIST_H */
diff --git a/drivers/s390/scsi/zfcp_scsi.c b/drivers/s390/scsi/zfcp_scsi.c
index 8e6fc68d6bd4..c3c4178888af 100644
--- a/drivers/s390/scsi/zfcp_scsi.c
+++ b/drivers/s390/scsi/zfcp_scsi.c
@@ -3,7 +3,7 @@
  *
  * Interface to Linux SCSI midlayer.
  *
- * Copyright IBM Corporation 2002, 2009
+ * Copyright IBM Corporation 2002, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -15,6 +15,7 @@
 #include "zfcp_ext.h"
 #include "zfcp_dbf.h"
 #include "zfcp_fc.h"
+#include "zfcp_reqlist.h"
 
 static unsigned int default_depth = 32;
 module_param_named(queue_depth, default_depth, uint, 0600);
@@ -43,7 +44,7 @@ static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt)
 {
         struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata;
         unit->device = NULL;
-        put_device(&unit->sysfs_device);
+        put_device(&unit->dev);
 }
 
 static int zfcp_scsi_slave_configure(struct scsi_device *sdp)
@@ -59,10 +60,9 @@ static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result)
 {
         struct zfcp_adapter *adapter =
                 (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
+
         set_host_byte(scpnt, result);
-        if ((scpnt->device != NULL) && (scpnt->device->host != NULL))
-                zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL);
-        /* return directly */
+        zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
         scpnt->scsi_done(scpnt);
 }
 
@@ -86,18 +86,10 @@ static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt,
         adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0];
         unit = scpnt->device->hostdata;
 
-        BUG_ON(!adapter || (adapter != unit->port->adapter));
-        BUG_ON(!scpnt->scsi_done);
-
-        if (unlikely(!unit)) {
-                zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT);
-                return 0;
-        }
-
         scsi_result = fc_remote_port_chkready(rport);
         if (unlikely(scsi_result)) {
                 scpnt->result = scsi_result;
-                zfcp_dbf_scsi_result("fail", 4, adapter->dbf, scpnt, NULL);
+                zfcp_dbf_scsi_fail_send(adapter->dbf, scpnt);
                 scpnt->scsi_done(scpnt);
                 return 0;
         }
@@ -189,9 +181,7 @@ static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt)
         /* avoid race condition between late normal completion and abort */
         write_lock_irqsave(&adapter->abort_lock, flags);
 
-        spin_lock(&adapter->req_list_lock);
-        old_req = zfcp_reqlist_find(adapter, old_reqid);
-        spin_unlock(&adapter->req_list_lock);
+        old_req = zfcp_reqlist_find(adapter->req_list, old_reqid);
         if (!old_req) {
                 write_unlock_irqrestore(&adapter->abort_lock, flags);
                 zfcp_dbf_scsi_abort("lte1", adapter->dbf, scpnt, NULL,
@@ -521,7 +511,7 @@ static void zfcp_scsi_terminate_rport_io(struct fc_rport *rport)
 
         if (port) {
                 zfcp_erp_port_reopen(port, 0, "sctrpi1", NULL);
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
         }
 }
 
@@ -563,23 +553,23 @@ static void zfcp_scsi_rport_block(struct zfcp_port *port)
 
 void zfcp_scsi_schedule_rport_register(struct zfcp_port *port)
 {
-        get_device(&port->sysfs_device);
+        get_device(&port->dev);
         port->rport_task = RPORT_ADD;
 
         if (!queue_work(port->adapter->work_queue, &port->rport_work))
-                put_device(&port->sysfs_device);
+                put_device(&port->dev);
 }
 
 void zfcp_scsi_schedule_rport_block(struct zfcp_port *port)
 {
-        get_device(&port->sysfs_device);
+        get_device(&port->dev);
         port->rport_task = RPORT_DEL;
 
         if (port->rport && queue_work(port->adapter->work_queue,
                                       &port->rport_work))
                 return;
 
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 }
 
 void zfcp_scsi_schedule_rports_block(struct zfcp_adapter *adapter)
@@ -608,7 +598,7 @@ void zfcp_scsi_rport_work(struct work_struct *work)
                 }
         }
 
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 }
 
 
@@ -626,7 +616,7 @@ void zfcp_scsi_scan(struct work_struct *work)
                                  scsilun_to_int((struct scsi_lun *)
                                                 &unit->fcp_lun), 0);
 
-        put_device(&unit->sysfs_device);
+        put_device(&unit->dev);
 }
 
 struct fc_function_template zfcp_transport_functions = {
diff --git a/drivers/s390/scsi/zfcp_sysfs.c b/drivers/s390/scsi/zfcp_sysfs.c
index f539e006683c..a43035d4bd70 100644
--- a/drivers/s390/scsi/zfcp_sysfs.c
+++ b/drivers/s390/scsi/zfcp_sysfs.c
@@ -3,7 +3,7 @@
  *
  * sysfs attributes.
  *
- * Copyright IBM Corporation 2008, 2009
+ * Copyright IBM Corporation 2008, 2010
  */
 
 #define KMSG_COMPONENT "zfcp"
@@ -19,8 +19,7 @@ static ssize_t zfcp_sysfs_##_feat##_##_name##_show(struct device *dev,	       \
                                                    struct device_attribute *at,\
                                                    char *buf)                  \
 {                                                                              \
-        struct _feat_def *_feat = container_of(dev, struct _feat_def,          \
-                                               sysfs_device);                  \
+        struct _feat_def *_feat = container_of(dev, struct _feat_def, dev);    \
                                                                                \
         return sprintf(buf, _format, _value);                                  \
 }                                                                              \
@@ -87,8 +86,7 @@ static ssize_t zfcp_sysfs_##_feat##_failed_show(struct device *dev,	       \
                                                 struct device_attribute *attr, \
                                                 char *buf)                     \
 {                                                                              \
-        struct _feat_def *_feat = container_of(dev, struct _feat_def,          \
-                                               sysfs_device);                  \
+        struct _feat_def *_feat = container_of(dev, struct _feat_def, dev);    \
                                                                                \
         if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_ERP_FAILED)       \
                 return sprintf(buf, "1\n");                                    \
@@ -99,12 +97,11 @@ static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev,	       \
                                                  struct device_attribute *attr,\
                                                  const char *buf, size_t count)\
 {                                                                              \
-        struct _feat_def *_feat = container_of(dev, struct _feat_def,          \
-                                               sysfs_device);                  \
+        struct _feat_def *_feat = container_of(dev, struct _feat_def, dev);    \
         unsigned long val;                                                     \
         int retval = 0;                                                        \
                                                                                \
-        if (!(_feat && get_device(&_feat->sysfs_device)))                      \
+        if (!(_feat && get_device(&_feat->dev)))                               \
                 return -EBUSY;                                                 \
                                                                                \
         if (strict_strtoul(buf, 0, &val) || val != 0) {                        \
@@ -118,7 +115,7 @@ static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev,	       \
                                   _reopen_id, NULL);                           \
         zfcp_erp_wait(_adapter);                                               \
 out:                                                                           \
-        put_device(&_feat->sysfs_device);                                      \
+        put_device(&_feat->dev);                                               \
         return retval ? retval : (ssize_t) count;                              \
 }                                                                              \
 static ZFCP_DEV_ATTR(_feat, failed, S_IWUSR | S_IRUGO,                         \
@@ -224,10 +221,10 @@ static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
         list_del(&port->list);
         write_unlock_irq(&adapter->port_list_lock);
 
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
 
         zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL);
-        zfcp_device_unregister(&port->sysfs_device, &zfcp_sysfs_port_attrs);
+        zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
  out:
         zfcp_ccw_adapter_put(adapter);
         return retval ? retval : (ssize_t) count;
@@ -258,13 +255,12 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
                                          struct device_attribute *attr,
                                          const char *buf, size_t count)
 {
-        struct zfcp_port *port = container_of(dev, struct zfcp_port,
-                                              sysfs_device);
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
         struct zfcp_unit *unit;
         u64 fcp_lun;
         int retval = -EINVAL;
 
-        if (!(port && get_device(&port->sysfs_device)))
+        if (!(port && get_device(&port->dev)))
                 return -EBUSY;
 
         if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
@@ -280,7 +276,7 @@ static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
         zfcp_erp_wait(unit->port->adapter);
         flush_work(&unit->scsi_work);
 out:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
         return retval ? retval : (ssize_t) count;
 }
 static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store);
@@ -289,13 +285,12 @@ static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev,
                                             struct device_attribute *attr,
                                             const char *buf, size_t count)
 {
-        struct zfcp_port *port = container_of(dev, struct zfcp_port,
-                                              sysfs_device);
+        struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
         struct zfcp_unit *unit;
         u64 fcp_lun;
         int retval = -EINVAL;
 
-        if (!(port && get_device(&port->sysfs_device)))
+        if (!(port && get_device(&port->dev)))
                 return -EBUSY;
 
         if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
@@ -314,12 +309,12 @@ static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev,
         list_del(&unit->list);
         write_unlock_irq(&port->unit_list_lock);
 
-        put_device(&unit->sysfs_device);
+        put_device(&unit->dev);
 
         zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL);
-        zfcp_device_unregister(&unit->sysfs_device, &zfcp_sysfs_unit_attrs);
+        zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
 out:
-        put_device(&port->sysfs_device);
+        put_device(&port->dev);
         return retval ? retval : (ssize_t) count;
 }
 static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
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/FlashPoint.c b/drivers/scsi/FlashPoint.c
index b898d382b7b0..e40cdfb7541f 100644
--- a/drivers/scsi/FlashPoint.c
+++ b/drivers/scsi/FlashPoint.c
@@ -3924,7 +3924,7 @@ static void FPT_sinits(struct sccb *p_sccb, unsigned char p_card)
 {
         struct sccb_mgr_tar_info *currTar_Info;
 
-        if ((p_sccb->TargID > MAX_SCSI_TAR) || (p_sccb->Lun > MAX_LUN)) {
+        if ((p_sccb->TargID >= MAX_SCSI_TAR) || (p_sccb->Lun >= MAX_LUN)) {
                 return;
         }
         currTar_Info = &FPT_sccbMgrTbl[p_card][p_sccb->TargID];
diff --git a/drivers/scsi/be2iscsi/be.h b/drivers/scsi/be2iscsi/be.h
index a93a5040f087..136b49cea791 100644
--- a/drivers/scsi/be2iscsi/be.h
+++ b/drivers/scsi/be2iscsi/be.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -24,6 +24,10 @@
 #define FW_VER_LEN      32
 #define MCC_Q_LEN       128
 #define MCC_CQ_LEN      256
+#define MAX_MCC_CMD     16
+/* BladeEngine Generation numbers */
+#define BE_GEN2 2
+#define BE_GEN3 3
 
 struct be_dma_mem {
         void *va;
@@ -57,6 +61,11 @@ static inline void *queue_head_node(struct be_queue_info *q)
         return q->dma_mem.va + q->head * q->entry_size;
 }
 
+static inline void *queue_get_wrb(struct be_queue_info *q, unsigned int wrb_num)
+{
+        return q->dma_mem.va + wrb_num * q->entry_size;
+}
+
 static inline void *queue_tail_node(struct be_queue_info *q)
 {
         return q->dma_mem.va + q->tail * q->entry_size;
@@ -104,15 +113,19 @@ struct be_ctrl_info {
         spinlock_t mcc_lock;    /* For serializing mcc cmds to BE card */
         spinlock_t mcc_cq_lock;
 
-        /* MCC Async callback */
-        void (*async_cb) (void *adapter, bool link_up);
-        void *adapter_ctxt;
+        wait_queue_head_t mcc_wait[MAX_MCC_CMD + 1];
+        unsigned int mcc_tag[MAX_MCC_CMD];
+        unsigned int mcc_numtag[MAX_MCC_CMD + 1];
+        unsigned short mcc_alloc_index;
+        unsigned short mcc_free_index;
+        unsigned int mcc_tag_available;
 };
 
 #include "be_cmds.h"
 
 #define PAGE_SHIFT_4K 12
 #define PAGE_SIZE_4K (1 << PAGE_SHIFT_4K)
+#define mcc_timeout             120000 /* 5s timeout */
 
 /* Returns number of pages spanned by the data starting at the given addr */
 #define PAGES_4K_SPANNED(_address, size)                                \
diff --git a/drivers/scsi/be2iscsi/be_cmds.c b/drivers/scsi/be2iscsi/be_cmds.c
index f008708f1b08..67098578fba4 100644
--- a/drivers/scsi/be2iscsi/be_cmds.c
+++ b/drivers/scsi/be2iscsi/be_cmds.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -19,7 +19,7 @@
 #include "be_mgmt.h"
 #include "be_main.h"
 
-static void be_mcc_notify(struct beiscsi_hba *phba)
+void be_mcc_notify(struct beiscsi_hba *phba)
 {
         struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
         u32 val = 0;
@@ -29,6 +29,52 @@ static void be_mcc_notify(struct beiscsi_hba *phba)
         iowrite32(val, phba->db_va + DB_MCCQ_OFFSET);
 }
 
+unsigned int alloc_mcc_tag(struct beiscsi_hba *phba)
+{
+        unsigned int tag = 0;
+        unsigned int num = 0;
+
+mcc_tag_rdy:
+        if (phba->ctrl.mcc_tag_available) {
+                tag = phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index];
+                phba->ctrl.mcc_tag[phba->ctrl.mcc_alloc_index] = 0;
+                phba->ctrl.mcc_numtag[tag] = 0;
+        } else {
+                udelay(100);
+                num++;
+                if (num < mcc_timeout)
+                        goto mcc_tag_rdy;
+        }
+        if (tag) {
+                phba->ctrl.mcc_tag_available--;
+                if (phba->ctrl.mcc_alloc_index == (MAX_MCC_CMD - 1))
+                        phba->ctrl.mcc_alloc_index = 0;
+                else
+                        phba->ctrl.mcc_alloc_index++;
+        }
+        return tag;
+}
+
+void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag)
+{
+        spin_lock(&ctrl->mbox_lock);
+        tag = tag & 0x000000FF;
+        ctrl->mcc_tag[ctrl->mcc_free_index] = tag;
+        if (ctrl->mcc_free_index == (MAX_MCC_CMD - 1))
+                ctrl->mcc_free_index = 0;
+        else
+                ctrl->mcc_free_index++;
+        ctrl->mcc_tag_available++;
+        spin_unlock(&ctrl->mbox_lock);
+}
+
+bool is_link_state_evt(u32 trailer)
+{
+        return (((trailer >> ASYNC_TRAILER_EVENT_CODE_SHIFT) &
+                  ASYNC_TRAILER_EVENT_CODE_MASK) ==
+                  ASYNC_EVENT_CODE_LINK_STATE);
+}
+
 static inline bool be_mcc_compl_is_new(struct be_mcc_compl *compl)
 {
         if (compl->flags != 0) {
@@ -64,12 +110,30 @@ static int be_mcc_compl_process(struct be_ctrl_info *ctrl,
         return 0;
 }
 
-
-static inline bool is_link_state_evt(u32 trailer)
+int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
+                                    struct be_mcc_compl *compl)
 {
-        return (((trailer >> ASYNC_TRAILER_EVENT_CODE_SHIFT) &
-                  ASYNC_TRAILER_EVENT_CODE_MASK) ==
-                  ASYNC_EVENT_CODE_LINK_STATE);
+        u16 compl_status, extd_status;
+        unsigned short tag;
+
+        be_dws_le_to_cpu(compl, 4);
+
+        compl_status = (compl->status >> CQE_STATUS_COMPL_SHIFT) &
+                                        CQE_STATUS_COMPL_MASK;
+        /* The ctrl.mcc_numtag[tag] is filled with
+         * [31] = valid, [30:24] = Rsvd, [23:16] = wrb, [15:8] = extd_status,
+         * [7:0] = compl_status
+         */
+        tag = (compl->tag0 & 0x000000FF);
+        extd_status = (compl->status >> CQE_STATUS_EXTD_SHIFT) &
+                                        CQE_STATUS_EXTD_MASK;
+
+        ctrl->mcc_numtag[tag]  = 0x80000000;
+        ctrl->mcc_numtag[tag] |= (compl->tag0 & 0x00FF0000);
+        ctrl->mcc_numtag[tag] |= (extd_status & 0x000000FF) << 8;
+        ctrl->mcc_numtag[tag] |= (compl_status & 0x000000FF);
+        wake_up_interruptible(&ctrl->mcc_wait[tag]);
+        return 0;
 }
 
 static struct be_mcc_compl *be_mcc_compl_get(struct beiscsi_hba *phba)
@@ -89,7 +153,7 @@ static void be2iscsi_fail_session(struct iscsi_cls_session *cls_session)
         iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_CONN_FAILED);
 }
 
-static void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
+void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
                 struct be_async_event_link_state *evt)
 {
         switch (evt->port_link_status) {
@@ -97,13 +161,13 @@ static void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
                 SE_DEBUG(DBG_LVL_1, "Link Down on Physical Port %d \n",
                                                 evt->physical_port);
                 phba->state |= BE_ADAPTER_LINK_DOWN;
+                iscsi_host_for_each_session(phba->shost,
+                                            be2iscsi_fail_session);
                 break;
         case ASYNC_EVENT_LINK_UP:
                 phba->state = BE_ADAPTER_UP;
                 SE_DEBUG(DBG_LVL_1, "Link UP on Physical Port %d \n",
                                                 evt->physical_port);
-                iscsi_host_for_each_session(phba->shost,
-                                            be2iscsi_fail_session);
                 break;
         default:
                 SE_DEBUG(DBG_LVL_1, "Unexpected Async Notification %d on"
@@ -162,7 +226,6 @@ int beiscsi_process_mcc(struct beiscsi_hba *phba)
 /* Wait till no more pending mcc requests are present */
 static int be_mcc_wait_compl(struct beiscsi_hba *phba)
 {
-#define mcc_timeout             120000 /* 5s timeout */
         int i, status;
         for (i = 0; i < mcc_timeout; i++) {
                 status = beiscsi_process_mcc(phba);
@@ -372,9 +435,10 @@ struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba)
 
         BUG_ON(atomic_read(&mccq->used) >= mccq->len);
         wrb = queue_head_node(mccq);
+        memset(wrb, 0, sizeof(*wrb));
+        wrb->tag0 = (mccq->head & 0x000000FF) << 16;
         queue_head_inc(mccq);
         atomic_inc(&mccq->used);
-        memset(wrb, 0, sizeof(*wrb));
         return wrb;
 }
 
diff --git a/drivers/scsi/be2iscsi/be_cmds.h b/drivers/scsi/be2iscsi/be_cmds.h
index 5de8acb924cb..49fcc787ee8b 100644
--- a/drivers/scsi/be2iscsi/be_cmds.h
+++ b/drivers/scsi/be2iscsi/be_cmds.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -425,14 +425,20 @@ int beiscsi_cmd_mccq_create(struct beiscsi_hba *phba,
 int be_poll_mcc(struct be_ctrl_info *ctrl);
 unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
                                       struct beiscsi_hba *phba);
-int be_cmd_get_mac_addr(struct beiscsi_hba *phba, u8 *mac_addr);
-
+unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba);
+void free_mcc_tag(struct be_ctrl_info *ctrl, unsigned int tag);
 /*ISCSI Functuions */
 int be_cmd_fw_initialize(struct be_ctrl_info *ctrl);
 
 struct be_mcc_wrb *wrb_from_mbox(struct be_dma_mem *mbox_mem);
 struct be_mcc_wrb *wrb_from_mccq(struct beiscsi_hba *phba);
 int be_mcc_notify_wait(struct beiscsi_hba *phba);
+void be_mcc_notify(struct beiscsi_hba *phba);
+unsigned int alloc_mcc_tag(struct beiscsi_hba *phba);
+void beiscsi_async_link_state_process(struct beiscsi_hba *phba,
+                struct be_async_event_link_state *evt);
+int be_mcc_compl_process_isr(struct be_ctrl_info *ctrl,
+                                    struct be_mcc_compl *compl);
 
 int be_mbox_notify(struct be_ctrl_info *ctrl);
 
@@ -448,6 +454,8 @@ int be_cmd_iscsi_post_sgl_pages(struct be_ctrl_info *ctrl,
 int be_cmd_wrbq_create(struct be_ctrl_info *ctrl, struct be_dma_mem *q_mem,
                        struct be_queue_info *wrbq);
 
+bool is_link_state_evt(u32 trailer);
+
 struct be_default_pdu_context {
         u32 dw[4];
 } __packed;
diff --git a/drivers/scsi/be2iscsi/be_iscsi.c b/drivers/scsi/be2iscsi/be_iscsi.c
index d587b0362f18..29a3aaf35f9f 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.c
+++ b/drivers/scsi/be2iscsi/be_iscsi.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -101,6 +101,7 @@ void beiscsi_session_destroy(struct iscsi_cls_session *cls_session)
         struct iscsi_session *sess = cls_session->dd_data;
         struct beiscsi_session *beiscsi_sess = sess->dd_data;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_session_destroy\n");
         pci_pool_destroy(beiscsi_sess->bhs_pool);
         iscsi_session_teardown(cls_session);
 }
@@ -224,6 +225,7 @@ int beiscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
         struct beiscsi_conn *beiscsi_conn = conn->dd_data;
         int len = 0;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_get_param, param= %d\n", param);
         beiscsi_ep = beiscsi_conn->ep;
         if (!beiscsi_ep) {
                 SE_DEBUG(DBG_LVL_1,
@@ -254,6 +256,7 @@ int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
         struct iscsi_session *session = conn->session;
         int ret;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_set_param, param= %d\n", param);
         ret = iscsi_set_param(cls_conn, param, buf, buflen);
         if (ret)
                 return ret;
@@ -271,8 +274,8 @@ int beiscsi_set_param(struct iscsi_cls_conn *cls_conn,
                         conn->max_recv_dlength = 65536;
                 break;
         case ISCSI_PARAM_MAX_BURST:
-                if (session->first_burst > 262144)
-                        session->first_burst = 262144;
+                if (session->max_burst > 262144)
+                        session->max_burst = 262144;
                 break;
         default:
                 return 0;
@@ -293,12 +296,41 @@ int beiscsi_get_host_param(struct Scsi_Host *shost,
                            enum iscsi_host_param param, char *buf)
 {
         struct beiscsi_hba *phba = (struct beiscsi_hba *)iscsi_host_priv(shost);
+        struct be_cmd_resp_get_mac_addr *resp;
+        struct be_mcc_wrb *wrb;
+        unsigned int tag, wrb_num;
         int len = 0;
+        unsigned short status, extd_status;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_get_host_param, param= %d\n", param);
         switch (param) {
         case ISCSI_HOST_PARAM_HWADDRESS:
-                be_cmd_get_mac_addr(phba, phba->mac_address);
-                len = sysfs_format_mac(buf, phba->mac_address, ETH_ALEN);
+                tag = be_cmd_get_mac_addr(phba);
+                if (!tag) {
+                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed \n");
+                        return -1;
+                } else
+                        wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                                 phba->ctrl.mcc_numtag[tag]);
+
+                wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+                extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+                status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+                if (status || extd_status) {
+                        SE_DEBUG(DBG_LVL_1, "be_cmd_get_mac_addr Failed"
+                                            " status = %d extd_status = %d \n",
+                                            status, extd_status);
+                        free_mcc_tag(&phba->ctrl, tag);
+                        return -1;
+                } else {
+                        wrb = queue_get_wrb(mccq, wrb_num);
+                        free_mcc_tag(&phba->ctrl, tag);
+                        resp = embedded_payload(wrb);
+                        memcpy(phba->mac_address, resp->mac_address, ETH_ALEN);
+                        len = sysfs_format_mac(buf, phba->mac_address,
+                                               ETH_ALEN);
+                }
                 break;
         default:
                 return iscsi_host_get_param(shost, param, buf);
@@ -378,6 +410,7 @@ int beiscsi_conn_start(struct iscsi_cls_conn *cls_conn)
         struct beiscsi_endpoint *beiscsi_ep;
         struct beiscsi_offload_params params;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_start\n");
         memset(&params, 0, sizeof(struct beiscsi_offload_params));
         beiscsi_ep = beiscsi_conn->ep;
         if (!beiscsi_ep)
@@ -422,8 +455,14 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
 {
         struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
+        struct be_queue_info *mccq = &phba->ctrl.mcc_obj.q;
+        struct be_mcc_wrb *wrb;
+        struct tcp_connect_and_offload_out *ptcpcnct_out;
+        unsigned short status, extd_status;
+        unsigned int tag, wrb_num;
         int ret = -1;
 
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_open_conn\n");
         beiscsi_ep->ep_cid = beiscsi_get_cid(phba);
         if (beiscsi_ep->ep_cid == 0xFFFF) {
                 SE_DEBUG(DBG_LVL_1, "No free cid available\n");
@@ -431,15 +470,44 @@ static int beiscsi_open_conn(struct iscsi_endpoint *ep,
         }
         SE_DEBUG(DBG_LVL_8, "In beiscsi_open_conn, ep_cid=%d ",
                  beiscsi_ep->ep_cid);
-        phba->ep_array[beiscsi_ep->ep_cid] = ep;
-        if (beiscsi_ep->ep_cid >
-            (phba->fw_config.iscsi_cid_start + phba->params.cxns_per_ctrl)) {
+        phba->ep_array[beiscsi_ep->ep_cid -
+                       phba->fw_config.iscsi_cid_start] = ep;
+        if (beiscsi_ep->ep_cid > (phba->fw_config.iscsi_cid_start +
+                                  phba->params.cxns_per_ctrl * 2)) {
                 SE_DEBUG(DBG_LVL_1, "Failed in allocate iscsi cid\n");
                 return ret;
         }
 
         beiscsi_ep->cid_vld = 0;
-        return mgmt_open_connection(phba, dst_addr, beiscsi_ep);
+        tag = mgmt_open_connection(phba, dst_addr, beiscsi_ep);
+        if (!tag) {
+                SE_DEBUG(DBG_LVL_1,
+                         "mgmt_invalidate_connection Failed for cid=%d \n",
+                         beiscsi_ep->ep_cid);
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+        }
+        wrb_num = (phba->ctrl.mcc_numtag[tag] & 0x00FF0000) >> 16;
+        extd_status = (phba->ctrl.mcc_numtag[tag] & 0x0000FF00) >> 8;
+        status = phba->ctrl.mcc_numtag[tag] & 0x000000FF;
+        if (status || extd_status) {
+                SE_DEBUG(DBG_LVL_1, "mgmt_open_connection Failed"
+                                    " status = %d extd_status = %d \n",
+                                    status, extd_status);
+                free_mcc_tag(&phba->ctrl, tag);
+                return -1;
+        } else {
+                wrb = queue_get_wrb(mccq, wrb_num);
+                free_mcc_tag(&phba->ctrl, tag);
+
+                ptcpcnct_out =  embedded_payload(wrb);
+                beiscsi_ep = ep->dd_data;
+                beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
+                beiscsi_ep->cid_vld = 1;
+                SE_DEBUG(DBG_LVL_8, "mgmt_open_connection Success\n");
+        }
+        return 0;
 }
 
 /**
@@ -459,14 +527,12 @@ static void beiscsi_put_cid(struct beiscsi_hba *phba, unsigned short cid)
  * beiscsi_free_ep - free endpoint
  * @ep: pointer to iscsi endpoint structure
  */
-static void beiscsi_free_ep(struct iscsi_endpoint *ep)
+static void beiscsi_free_ep(struct beiscsi_endpoint *beiscsi_ep)
 {
-        struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
 
         beiscsi_put_cid(phba, beiscsi_ep->ep_cid);
         beiscsi_ep->phba = NULL;
-        iscsi_destroy_endpoint(ep);
 }
 
 /**
@@ -495,9 +561,9 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
                 return ERR_PTR(ret);
         }
 
-        if (phba->state) {
+        if (phba->state != BE_ADAPTER_UP) {
                 ret = -EBUSY;
-                SE_DEBUG(DBG_LVL_1, "The Adapet state is Not UP \n");
+                SE_DEBUG(DBG_LVL_1, "The Adapter state is Not UP \n");
                 return ERR_PTR(ret);
         }
 
@@ -509,9 +575,9 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
 
         beiscsi_ep = ep->dd_data;
         beiscsi_ep->phba = phba;
-
+        beiscsi_ep->openiscsi_ep = ep;
         if (beiscsi_open_conn(ep, NULL, dst_addr, non_blocking)) {
-                SE_DEBUG(DBG_LVL_1, "Failed in allocate iscsi cid\n");
+                SE_DEBUG(DBG_LVL_1, "Failed in beiscsi_open_conn \n");
                 ret = -ENOMEM;
                 goto free_ep;
         }
@@ -519,7 +585,7 @@ beiscsi_ep_connect(struct Scsi_Host *shost, struct sockaddr *dst_addr,
         return ep;
 
 free_ep:
-        beiscsi_free_ep(ep);
+        beiscsi_free_ep(beiscsi_ep);
         return ERR_PTR(ret);
 }
 
@@ -546,20 +612,22 @@ int beiscsi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
  * @ep: The iscsi endpoint
  * @flag: The type of connection closure
  */
-static int beiscsi_close_conn(struct iscsi_endpoint *ep, int flag)
+static int beiscsi_close_conn(struct  beiscsi_endpoint *beiscsi_ep, int flag)
 {
         int ret = 0;
-        struct beiscsi_endpoint *beiscsi_ep = ep->dd_data;
+        unsigned int tag;
         struct beiscsi_hba *phba = beiscsi_ep->phba;
 
-        if (MGMT_STATUS_SUCCESS !=
-            mgmt_upload_connection(phba, beiscsi_ep->ep_cid,
-                CONNECTION_UPLOAD_GRACEFUL)) {
+        tag = mgmt_upload_connection(phba, beiscsi_ep->ep_cid, flag);
+        if (!tag) {
                 SE_DEBUG(DBG_LVL_8, "upload failed for cid 0x%x",
                          beiscsi_ep->ep_cid);
                 ret = -1;
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+                free_mcc_tag(&phba->ctrl, tag);
         }
-
         return ret;
 }
 
@@ -574,19 +642,17 @@ void beiscsi_ep_disconnect(struct iscsi_endpoint *ep)
         struct beiscsi_conn *beiscsi_conn;
         struct beiscsi_endpoint *beiscsi_ep;
         struct beiscsi_hba *phba;
-        int flag = 0;
 
         beiscsi_ep = ep->dd_data;
         phba = beiscsi_ep->phba;
-        SE_DEBUG(DBG_LVL_8, "In beiscsi_ep_disconnect\n");
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_ep_disconnect for ep_cid = %d\n",
+                             beiscsi_ep->ep_cid);
 
         if (beiscsi_ep->conn) {
                 beiscsi_conn = beiscsi_ep->conn;
                 iscsi_suspend_queue(beiscsi_conn->conn);
-                beiscsi_close_conn(ep, flag);
         }
 
-        beiscsi_free_ep(ep);
 }
 
 /**
@@ -619,23 +685,31 @@ void beiscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         struct iscsi_session *session = conn->session;
         struct Scsi_Host *shost = iscsi_session_to_shost(session->cls_session);
         struct beiscsi_hba *phba = iscsi_host_priv(shost);
-        unsigned int status;
+        unsigned int tag;
         unsigned short savecfg_flag = CMD_ISCSI_SESSION_SAVE_CFG_ON_FLASH;
 
-        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_stop\n");
         beiscsi_ep = beiscsi_conn->ep;
         if (!beiscsi_ep) {
                 SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_stop , no beiscsi_ep\n");
                 return;
         }
-        status = mgmt_invalidate_connection(phba, beiscsi_ep,
+        SE_DEBUG(DBG_LVL_8, "In beiscsi_conn_stop  ep_cid = %d\n",
+                             beiscsi_ep->ep_cid);
+        tag = mgmt_invalidate_connection(phba, beiscsi_ep,
                                             beiscsi_ep->ep_cid, 1,
                                             savecfg_flag);
-        if (status != MGMT_STATUS_SUCCESS) {
+        if (!tag) {
                 SE_DEBUG(DBG_LVL_1,
                          "mgmt_invalidate_connection Failed for cid=%d \n",
                          beiscsi_ep->ep_cid);
+        } else {
+                wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                         phba->ctrl.mcc_numtag[tag]);
+                free_mcc_tag(&phba->ctrl, tag);
         }
+        beiscsi_close_conn(beiscsi_ep, CONNECTION_UPLOAD_GRACEFUL);
+        beiscsi_free_ep(beiscsi_ep);
+        iscsi_destroy_endpoint(beiscsi_ep->openiscsi_ep);
         beiscsi_unbind_conn_to_cid(phba, beiscsi_ep->ep_cid);
         iscsi_conn_stop(cls_conn, flag);
 }
diff --git a/drivers/scsi/be2iscsi/be_iscsi.h b/drivers/scsi/be2iscsi/be_iscsi.h
index f92ffc5349fb..1f512c28cbf9 100644
--- a/drivers/scsi/be2iscsi/be_iscsi.h
+++ b/drivers/scsi/be2iscsi/be_iscsi.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 1a557fa77888..7c22616ab141 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -40,7 +40,6 @@
 static unsigned int be_iopoll_budget = 10;
 static unsigned int be_max_phys_size = 64;
 static unsigned int enable_msix = 1;
-static unsigned int ring_mode;
 
 MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
 MODULE_DESCRIPTION(DRV_DESC " " BUILD_STR);
@@ -62,10 +61,10 @@ static int beiscsi_slave_configure(struct scsi_device *sdev)
 /*------------------- PCI Driver operations and data ----------------- */
 static DEFINE_PCI_DEVICE_TABLE(beiscsi_pci_id_table) = {
         { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
+        { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
         { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID3) },
-        { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID4) },
         { 0 }
 };
 MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
@@ -112,6 +111,7 @@ static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
         memset(phba, 0, sizeof(*phba));
         phba->shost = shost;
         phba->pcidev = pci_dev_get(pcidev);
+        pci_set_drvdata(pcidev, phba);
 
         if (iscsi_host_add(shost, &phba->pcidev->dev))
                 goto free_devices;
@@ -143,6 +143,7 @@ static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
                                 struct pci_dev *pcidev)
 {
         u8 __iomem *addr;
+        int pcicfg_reg;
 
         addr = ioremap_nocache(pci_resource_start(pcidev, 2),
                                pci_resource_len(pcidev, 2));
@@ -159,13 +160,19 @@ static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
         phba->db_va = addr;
         phba->db_pa.u.a64.address =  pci_resource_start(pcidev, 4);
 
-        addr = ioremap_nocache(pci_resource_start(pcidev, 1),
-                               pci_resource_len(pcidev, 1));
+        if (phba->generation == BE_GEN2)
+                pcicfg_reg = 1;
+        else
+                pcicfg_reg = 0;
+
+        addr = ioremap_nocache(pci_resource_start(pcidev, pcicfg_reg),
+                               pci_resource_len(pcidev, pcicfg_reg));
+
         if (addr == NULL)
                 goto pci_map_err;
         phba->ctrl.pcicfg = addr;
         phba->pci_va = addr;
-        phba->pci_pa.u.a64.address = pci_resource_start(pcidev, 1);
+        phba->pci_pa.u.a64.address = pci_resource_start(pcidev, pcicfg_reg);
         return 0;
 
 pci_map_err:
@@ -230,29 +237,27 @@ static int be_ctrl_init(struct beiscsi_hba *phba, struct pci_dev *pdev)
 
 static void beiscsi_get_params(struct beiscsi_hba *phba)
 {
-        phba->params.ios_per_ctrl = BE2_IO_DEPTH;
-        phba->params.cxns_per_ctrl = BE2_MAX_SESSIONS;
-        phba->params.asyncpdus_per_ctrl = BE2_ASYNCPDUS;
-        phba->params.icds_per_ctrl = BE2_MAX_ICDS / 2;
+        phba->params.ios_per_ctrl = (phba->fw_config.iscsi_icd_count
+                                    - (phba->fw_config.iscsi_cid_count
+                                    + BE2_TMFS
+                                    + BE2_NOPOUT_REQ));
+        phba->params.cxns_per_ctrl = phba->fw_config.iscsi_cid_count;
+        phba->params.asyncpdus_per_ctrl = phba->fw_config.iscsi_cid_count;;
+        phba->params.icds_per_ctrl = phba->fw_config.iscsi_icd_count;;
         phba->params.num_sge_per_io = BE2_SGE;
         phba->params.defpdu_hdr_sz = BE2_DEFPDU_HDR_SZ;
         phba->params.defpdu_data_sz = BE2_DEFPDU_DATA_SZ;
         phba->params.eq_timer = 64;
         phba->params.num_eq_entries =
-            (((BE2_CMDS_PER_CXN * 2 + BE2_LOGOUTS + BE2_TMFS + BE2_ASYNCPDUS) /
-                                                                512) + 1) * 512;
+            (((BE2_CMDS_PER_CXN * 2 + phba->fw_config.iscsi_cid_count * 2
+                                    + BE2_TMFS) / 512) + 1) * 512;
         phba->params.num_eq_entries = (phba->params.num_eq_entries < 1024)
                                 ? 1024 : phba->params.num_eq_entries;
         SE_DEBUG(DBG_LVL_8, "phba->params.num_eq_entries=%d \n",
-                 phba->params.num_eq_entries);
+                             phba->params.num_eq_entries);
         phba->params.num_cq_entries =
-            (((BE2_CMDS_PER_CXN * 2 + BE2_LOGOUTS + BE2_TMFS + BE2_ASYNCPDUS) /
-                                                                512) + 1) * 512;
-        SE_DEBUG(DBG_LVL_8,
-                "phba->params.num_cq_entries=%d BE2_CMDS_PER_CXN=%d"
-                "BE2_LOGOUTS=%d BE2_TMFS=%d BE2_ASYNCPDUS=%d \n",
-                phba->params.num_cq_entries, BE2_CMDS_PER_CXN,
-                BE2_LOGOUTS, BE2_TMFS, BE2_ASYNCPDUS);
+            (((BE2_CMDS_PER_CXN * 2 +  phba->fw_config.iscsi_cid_count * 2
+                                    + BE2_TMFS) / 512) + 1) * 512;
         phba->params.wrbs_per_cxn = 256;
 }
 
@@ -443,7 +448,7 @@ static irqreturn_t be_isr(int irq, void *dev_id)
                         if (phba->todo_mcc_cq)
                                 queue_work(phba->wq, &phba->work_cqs);
 
-                if ((num_mcceq_processed) && (!num_ioeq_processed))
+                        if ((num_mcceq_processed) && (!num_ioeq_processed))
                                 hwi_ring_eq_db(phba, eq->id, 0,
                                               (num_ioeq_processed +
                                                num_mcceq_processed) , 1, 1);
@@ -561,6 +566,7 @@ beiscsi_process_async_pdu(struct beiscsi_conn *beiscsi_conn,
                 SE_DEBUG(DBG_LVL_1, "In ISCSI_OP_REJECT\n");
                 break;
         case ISCSI_OP_LOGIN_RSP:
+        case ISCSI_OP_TEXT_RSP:
                 task = conn->login_task;
                 io_task = task->dd_data;
                 login_hdr = (struct iscsi_hdr *)ppdu;
@@ -631,29 +637,29 @@ free_io_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
  * alloc_wrb_handle - To allocate a wrb handle
  * @phba: The hba pointer
  * @cid: The cid to use for allocation
- * @index: index allocation and wrb index
  *
  * This happens under session_lock until submission to chip
  */
-struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid,
-                                    int index)
+struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid)
 {
         struct hwi_wrb_context *pwrb_context;
         struct hwi_controller *phwi_ctrlr;
-        struct wrb_handle *pwrb_handle;
+        struct wrb_handle *pwrb_handle, *pwrb_handle_tmp;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         pwrb_context = &phwi_ctrlr->wrb_context[cid];
-        if (pwrb_context->wrb_handles_available) {
+        if (pwrb_context->wrb_handles_available >= 2) {
                 pwrb_handle = pwrb_context->pwrb_handle_base[
                                             pwrb_context->alloc_index];
                 pwrb_context->wrb_handles_available--;
-                pwrb_handle->nxt_wrb_index = pwrb_handle->wrb_index;
                 if (pwrb_context->alloc_index ==
                                                 (phba->params.wrbs_per_cxn - 1))
                         pwrb_context->alloc_index = 0;
                 else
                         pwrb_context->alloc_index++;
+                pwrb_handle_tmp = pwrb_context->pwrb_handle_base[
+                                                pwrb_context->alloc_index];
+                pwrb_handle->nxt_wrb_index = pwrb_handle_tmp->wrb_index;
         } else
                 pwrb_handle = NULL;
         return pwrb_handle;
@@ -671,9 +677,7 @@ static void
 free_wrb_handle(struct beiscsi_hba *phba, struct hwi_wrb_context *pwrb_context,
                 struct wrb_handle *pwrb_handle)
 {
-        if (!ring_mode)
-                pwrb_context->pwrb_handle_base[pwrb_context->free_index] =
-                                               pwrb_handle;
+        pwrb_context->pwrb_handle_base[pwrb_context->free_index] = pwrb_handle;
         pwrb_context->wrb_handles_available++;
         if (pwrb_context->free_index == (phba->params.wrbs_per_cxn - 1))
                 pwrb_context->free_index = 0;
@@ -790,6 +794,7 @@ be_complete_io(struct beiscsi_conn *beiscsi_conn,
                 memcpy(task->sc->sense_buffer, sense,
                        min_t(u16, sense_len, SCSI_SENSE_BUFFERSIZE));
         }
+
         if (io_task->cmd_bhs->iscsi_hdr.flags & ISCSI_FLAG_CMD_READ) {
                 if (psol->dw[offsetof(struct amap_sol_cqe, i_res_cnt) / 32]
                                                         & SOL_RES_CNT_MASK)
@@ -811,6 +816,7 @@ be_complete_logout(struct beiscsi_conn *beiscsi_conn,
         struct iscsi_conn *conn = beiscsi_conn->conn;
 
         hdr = (struct iscsi_logout_rsp *)task->hdr;
+        hdr->opcode = ISCSI_OP_LOGOUT_RSP;
         hdr->t2wait = 5;
         hdr->t2retain = 0;
         hdr->flags = ((psol->dw[offsetof(struct amap_sol_cqe, i_flags) / 32]
@@ -825,6 +831,9 @@ be_complete_logout(struct beiscsi_conn *beiscsi_conn,
                                         & SOL_EXP_CMD_SN_MASK) +
                         ((psol->dw[offsetof(struct amap_sol_cqe, i_cmd_wnd)
                                         / 32] & SOL_CMD_WND_MASK) >> 24) - 1);
+        hdr->dlength[0] = 0;
+        hdr->dlength[1] = 0;
+        hdr->dlength[2] = 0;
         hdr->hlength = 0;
         hdr->itt = io_task->libiscsi_itt;
         __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
@@ -839,6 +848,7 @@ be_complete_tmf(struct beiscsi_conn *beiscsi_conn,
         struct beiscsi_io_task *io_task = task->dd_data;
 
         hdr = (struct iscsi_tm_rsp *)task->hdr;
+        hdr->opcode = ISCSI_OP_SCSI_TMFUNC_RSP;
         hdr->flags = ((psol->dw[offsetof(struct amap_sol_cqe, i_flags) / 32]
                                         & SOL_FLAGS_MASK) >> 24) | 0x80;
         hdr->response = (psol->dw[offsetof(struct amap_sol_cqe, i_resp) /
@@ -859,7 +869,6 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
 {
         struct hwi_wrb_context *pwrb_context;
         struct wrb_handle *pwrb_handle = NULL;
-        struct sgl_handle *psgl_handle = NULL;
         struct hwi_controller *phwi_ctrlr;
         struct iscsi_task *task;
         struct beiscsi_io_task *io_task;
@@ -867,22 +876,14 @@ hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
         struct iscsi_session *session = conn->session;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        if (ring_mode) {
-                psgl_handle = phba->sgl_hndl_array[((psol->
-                              dw[offsetof(struct amap_sol_cqe_ring, icd_index) /
-                                32] & SOL_ICD_INDEX_MASK) >> 6)];
-                pwrb_context = &phwi_ctrlr->wrb_context[psgl_handle->cid];
-                task = psgl_handle->task;
-                pwrb_handle = NULL;
-        } else {
-                pwrb_context = &phwi_ctrlr->wrb_context[((psol->
+        pwrb_context = &phwi_ctrlr->wrb_context[((psol->
                                 dw[offsetof(struct amap_sol_cqe, cid) / 32] &
-                                SOL_CID_MASK) >> 6)];
-                pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
+                                SOL_CID_MASK) >> 6) -
+                                phba->fw_config.iscsi_cid_start];
+        pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
                                 dw[offsetof(struct amap_sol_cqe, wrb_index) /
                                 32] & SOL_WRB_INDEX_MASK) >> 16)];
-                task = pwrb_handle->pio_handle;
-        }
+        task = pwrb_handle->pio_handle;
 
         io_task = task->dd_data;
         spin_lock(&phba->mgmt_sgl_lock);
@@ -923,31 +924,23 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
         struct iscsi_wrb *pwrb = NULL;
         struct hwi_controller *phwi_ctrlr;
         struct iscsi_task *task;
-        struct sgl_handle *psgl_handle = NULL;
         unsigned int type;
         struct iscsi_conn *conn = beiscsi_conn->conn;
         struct iscsi_session *session = conn->session;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        if (ring_mode) {
-                psgl_handle = phba->sgl_hndl_array[((psol->
-                              dw[offsetof(struct amap_sol_cqe_ring, icd_index) /
-                              32] & SOL_ICD_INDEX_MASK) >> 6)];
-                task = psgl_handle->task;
-                type = psgl_handle->type;
-        } else {
-                pwrb_context = &phwi_ctrlr->
-                                wrb_context[((psol->dw[offsetof
+        pwrb_context = &phwi_ctrlr->wrb_context[((psol->dw[offsetof
                                 (struct amap_sol_cqe, cid) / 32]
-                                & SOL_CID_MASK) >> 6)];
-                pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
+                                & SOL_CID_MASK) >> 6) -
+                                phba->fw_config.iscsi_cid_start];
+        pwrb_handle = pwrb_context->pwrb_handle_basestd[((psol->
                                 dw[offsetof(struct amap_sol_cqe, wrb_index) /
                                 32] & SOL_WRB_INDEX_MASK) >> 16)];
-                task = pwrb_handle->pio_handle;
-                pwrb = pwrb_handle->pwrb;
-                type = (pwrb->dw[offsetof(struct amap_iscsi_wrb, type) / 32] &
-                         WRB_TYPE_MASK) >> 28;
-        }
+        task = pwrb_handle->pio_handle;
+        pwrb = pwrb_handle->pwrb;
+        type = (pwrb->dw[offsetof(struct amap_iscsi_wrb, type) / 32] &
+                                 WRB_TYPE_MASK) >> 28;
+
         spin_lock_bh(&session->lock);
         switch (type) {
         case HWH_TYPE_IO:
@@ -978,15 +971,7 @@ static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
                 break;
 
         default:
-                if (ring_mode)
-                        shost_printk(KERN_WARNING, phba->shost,
-                                "In hwi_complete_cmd, unknown type = %d"
-                                "icd_index 0x%x CID 0x%x\n", type,
-                                ((psol->dw[offsetof(struct amap_sol_cqe_ring,
-                                icd_index) / 32] & SOL_ICD_INDEX_MASK) >> 6),
-                                psgl_handle->cid);
-                else
-                        shost_printk(KERN_WARNING, phba->shost,
+                shost_printk(KERN_WARNING, phba->shost,
                                 "In hwi_complete_cmd, unknown type = %d"
                                 "wrb_index 0x%x CID 0x%x\n", type,
                                 ((psol->dw[offsetof(struct amap_iscsi_wrb,
@@ -1077,7 +1062,8 @@ hwi_get_async_handle(struct beiscsi_hba *phba,
 
         WARN_ON(!pasync_handle);
 
-        pasync_handle->cri = (unsigned short)beiscsi_conn->beiscsi_conn_cid;
+        pasync_handle->cri = (unsigned short)beiscsi_conn->beiscsi_conn_cid -
+                                             phba->fw_config.iscsi_cid_start;
         pasync_handle->is_header = is_header;
         pasync_handle->buffer_len = ((pdpdu_cqe->
                         dw[offsetof(struct amap_i_t_dpdu_cqe, dpl) / 32]
@@ -1327,9 +1313,10 @@ hwi_fwd_async_msg(struct beiscsi_conn *beiscsi_conn,
         }
 
         status = beiscsi_process_async_pdu(beiscsi_conn, phba,
-                                           beiscsi_conn->beiscsi_conn_cid,
-                                           phdr, hdr_len, pfirst_buffer,
-                                           buf_len);
+                                           (beiscsi_conn->beiscsi_conn_cid -
+                                            phba->fw_config.iscsi_cid_start),
+                                            phdr, hdr_len, pfirst_buffer,
+                                            buf_len);
 
         if (status == 0)
                 hwi_free_async_msg(phba, cri);
@@ -1422,6 +1409,48 @@ static void hwi_process_default_pdu_ring(struct beiscsi_conn *beiscsi_conn,
         hwi_post_async_buffers(phba, pasync_handle->is_header);
 }
 
+static void  beiscsi_process_mcc_isr(struct beiscsi_hba *phba)
+{
+        struct be_queue_info *mcc_cq;
+        struct  be_mcc_compl *mcc_compl;
+        unsigned int num_processed = 0;
+
+        mcc_cq = &phba->ctrl.mcc_obj.cq;
+        mcc_compl = queue_tail_node(mcc_cq);
+        mcc_compl->flags = le32_to_cpu(mcc_compl->flags);
+        while (mcc_compl->flags & CQE_FLAGS_VALID_MASK) {
+
+                if (num_processed >= 32) {
+                        hwi_ring_cq_db(phba, mcc_cq->id,
+                                        num_processed, 0, 0);
+                        num_processed = 0;
+                }
+                if (mcc_compl->flags & CQE_FLAGS_ASYNC_MASK) {
+                        /* Interpret flags as an async trailer */
+                        if (is_link_state_evt(mcc_compl->flags))
+                                /* Interpret compl as a async link evt */
+                                beiscsi_async_link_state_process(phba,
+                                (struct be_async_event_link_state *) mcc_compl);
+                        else
+                                SE_DEBUG(DBG_LVL_1,
+                                        " Unsupported Async Event, flags"
+                                        " = 0x%08x \n", mcc_compl->flags);
+                } else if (mcc_compl->flags & CQE_FLAGS_COMPLETED_MASK) {
+                        be_mcc_compl_process_isr(&phba->ctrl, mcc_compl);
+                        atomic_dec(&phba->ctrl.mcc_obj.q.used);
+                }
+
+                mcc_compl->flags = 0;
+                queue_tail_inc(mcc_cq);
+                mcc_compl = queue_tail_node(mcc_cq);
+                mcc_compl->flags = le32_to_cpu(mcc_compl->flags);
+                num_processed++;
+        }
+
+        if (num_processed > 0)
+                hwi_ring_cq_db(phba, mcc_cq->id, num_processed, 1, 0);
+
+}
 
 static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
 {
@@ -1431,7 +1460,8 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
         unsigned int num_processed = 0;
         unsigned int tot_nump = 0;
         struct beiscsi_conn *beiscsi_conn;
-        struct sgl_handle *psgl_handle = NULL;
+        struct beiscsi_endpoint *beiscsi_ep;
+        struct iscsi_endpoint *ep;
         struct beiscsi_hba *phba;
 
         cq = pbe_eq->cq;
@@ -1442,32 +1472,13 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                CQE_VALID_MASK) {
                 be_dws_le_to_cpu(sol, sizeof(struct sol_cqe));
 
-                if (ring_mode) {
-                        psgl_handle = phba->sgl_hndl_array[((sol->
-                                      dw[offsetof(struct amap_sol_cqe_ring,
-                                      icd_index) / 32] & SOL_ICD_INDEX_MASK)
-                                      >> 6)];
-                        beiscsi_conn = phba->conn_table[psgl_handle->cid];
-                        if (!beiscsi_conn || !beiscsi_conn->ep) {
-                                shost_printk(KERN_WARNING, phba->shost,
-                                     "Connection table empty for cid = %d\n",
-                                      psgl_handle->cid);
-                                return 0;
-                        }
+                ep = phba->ep_array[(u32) ((sol->
+                                   dw[offsetof(struct amap_sol_cqe, cid) / 32] &
+                                   SOL_CID_MASK) >> 6) -
+                                   phba->fw_config.iscsi_cid_start];
 
-                } else {
-                        beiscsi_conn = phba->conn_table[(u32) (sol->
-                                 dw[offsetof(struct amap_sol_cqe, cid) / 32] &
-                                 SOL_CID_MASK) >> 6];
-
-                        if (!beiscsi_conn || !beiscsi_conn->ep) {
-                                shost_printk(KERN_WARNING, phba->shost,
-                                     "Connection table empty for cid = %d\n",
-                                     (u32)(sol->dw[offsetof(struct amap_sol_cqe,
-                                     cid) / 32] & SOL_CID_MASK) >> 6);
-                                return 0;
-                        }
-                }
+                beiscsi_ep = ep->dd_data;
+                beiscsi_conn = beiscsi_ep->conn;
 
                 if (num_processed >= 32) {
                         hwi_ring_cq_db(phba, cq->id,
@@ -1511,21 +1522,13 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                 case CMD_CXN_KILLED_ITT_INVALID:
                 case CMD_CXN_KILLED_SEQ_OUTOFORDER:
                 case CMD_CXN_KILLED_INVALID_DATASN_RCVD:
-                        if (ring_mode) {
-                                SE_DEBUG(DBG_LVL_1,
-                                 "CQ Error notification for cmd.. "
-                                 "code %d cid 0x%x\n",
-                                 sol->dw[offsetof(struct amap_sol_cqe, code) /
-                                 32] & CQE_CODE_MASK, psgl_handle->cid);
-                        } else {
-                                SE_DEBUG(DBG_LVL_1,
+                        SE_DEBUG(DBG_LVL_1,
                                  "CQ Error notification for cmd.. "
                                  "code %d cid 0x%x\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
                                  (sol->dw[offsetof(struct amap_sol_cqe, cid) /
                                  32] & SOL_CID_MASK));
-                        }
                         break;
                 case UNSOL_DATA_DIGEST_ERROR_NOTIFY:
                         SE_DEBUG(DBG_LVL_1,
@@ -1547,37 +1550,23 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                 case CXN_KILLED_OVER_RUN_RESIDUAL:
                 case CXN_KILLED_UNDER_RUN_RESIDUAL:
                 case CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN:
-                        if (ring_mode) {
-                                SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
-                                 "0x%x...\n",
-                                 sol->dw[offsetof(struct amap_sol_cqe, code) /
-                                 32] & CQE_CODE_MASK, psgl_handle->cid);
-                        } else {
-                                SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
+                        SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset CID "
                                  "0x%x...\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
-                                 sol->dw[offsetof(struct amap_sol_cqe, cid) /
-                                 32] & CQE_CID_MASK);
-                        }
+                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
+                                 32] & CQE_CID_MASK));
                         iscsi_conn_failure(beiscsi_conn->conn,
                                            ISCSI_ERR_CONN_FAILED);
                         break;
                 case CXN_KILLED_RST_SENT:
                 case CXN_KILLED_RST_RCVD:
-                        if (ring_mode) {
-                                SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
-                                "received/sent on CID 0x%x...\n",
-                                 sol->dw[offsetof(struct amap_sol_cqe, code) /
-                                 32] & CQE_CODE_MASK, psgl_handle->cid);
-                        } else {
-                                SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
+                        SE_DEBUG(DBG_LVL_1, "CQ Error %d, reset"
                                 "received/sent on CID 0x%x...\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
-                                 sol->dw[offsetof(struct amap_sol_cqe, cid) /
-                                 32] & CQE_CID_MASK);
-                        }
+                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
+                                 32] & CQE_CID_MASK));
                         iscsi_conn_failure(beiscsi_conn->conn,
                                            ISCSI_ERR_CONN_FAILED);
                         break;
@@ -1586,8 +1575,8 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
                                  "received on CID 0x%x...\n",
                                  sol->dw[offsetof(struct amap_sol_cqe, code) /
                                  32] & CQE_CODE_MASK,
-                                 sol->dw[offsetof(struct amap_sol_cqe, cid) /
-                                 32] & CQE_CID_MASK);
+                                 (sol->dw[offsetof(struct amap_sol_cqe, cid) /
+                                 32] & CQE_CID_MASK));
                         break;
                 }
 
@@ -1604,7 +1593,7 @@ static unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq)
         return tot_nump;
 }
 
-static void beiscsi_process_all_cqs(struct work_struct *work)
+void beiscsi_process_all_cqs(struct work_struct *work)
 {
         unsigned long flags;
         struct hwi_controller *phwi_ctrlr;
@@ -1624,6 +1613,7 @@ static void beiscsi_process_all_cqs(struct work_struct *work)
                 spin_lock_irqsave(&phba->isr_lock, flags);
                 phba->todo_mcc_cq = 0;
                 spin_unlock_irqrestore(&phba->isr_lock, flags);
+                beiscsi_process_mcc_isr(phba);
         }
 
         if (phba->todo_cq) {
@@ -1668,7 +1658,8 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
                                       io_task->bhs_pa.u.a32.address_hi);
 
         l_sg = sg;
-        for (index = 0; (index < num_sg) && (index < 2); index++, sg_next(sg)) {
+        for (index = 0; (index < num_sg) && (index < 2); index++,
+                                                         sg = sg_next(sg)) {
                 if (index == 0) {
                         sg_len = sg_dma_len(sg);
                         addr = (u64) sg_dma_address(sg);
@@ -1679,11 +1670,7 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
                         AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_len, pwrb,
                                                         sg_len);
                         sge_len = sg_len;
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
-                                                        1);
                 } else {
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
-                                                        0);
                         AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_r2t_offset,
                                                         pwrb, sge_len);
                         sg_len = sg_dma_len(sg);
@@ -1706,13 +1693,27 @@ hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
         AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
                         io_task->bhs_pa.u.a32.address_lo);
 
-        if (num_sg == 2)
-                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb, 1);
+        if (num_sg == 1) {
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                                1);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                                0);
+        } else if (num_sg == 2) {
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                                0);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                                1);
+        } else {
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
+                                                                0);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
+                                                                0);
+        }
         sg = l_sg;
         psgl++;
         psgl++;
         offset = 0;
-        for (index = 0; index < num_sg; index++, sg_next(sg), psgl++) {
+        for (index = 0; index < num_sg; index++, sg = sg_next(sg), psgl++) {
                 sg_len = sg_dma_len(sg);
                 addr = (u64) sg_dma_address(sg);
                 AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
@@ -2048,10 +2049,9 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
         }
         idx = 0;
         pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-        num_cxn_wrb =
-            ((mem_descr_wrb->mem_array[idx].size) / (sizeof(struct iscsi_wrb)) *
-             phba->params.wrbs_per_cxn);
-
+        num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
+                      ((sizeof(struct iscsi_wrb) *
+                        phba->params.wrbs_per_cxn));
         for (index = 0; index < phba->params.cxns_per_ctrl; index += 2) {
                 pwrb_context = &phwi_ctrlr->wrb_context[index];
                 if (num_cxn_wrb) {
@@ -2064,9 +2064,9 @@ static void beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
                 } else {
                         idx++;
                         pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
-                        num_cxn_wrb = ((mem_descr_wrb->mem_array[idx].size) /
-                                        (sizeof(struct iscsi_wrb)) *
-                                        phba->params.wrbs_per_cxn);
+                        num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
+                                      ((sizeof(struct iscsi_wrb) *
+                                        phba->params.wrbs_per_cxn));
                         for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
                                 pwrb_handle = pwrb_context->pwrb_handle_base[j];
                                 pwrb_handle->pwrb = pwrb;
@@ -2383,7 +2383,7 @@ static int beiscsi_create_cqs(struct beiscsi_hba *phba,
                                                      &paddr);
                 if (!cq_vaddress)
                         goto create_cq_error;
-                ret = be_fill_queue(cq, phba->params.icds_per_ctrl / 2,
+                ret = be_fill_queue(cq, phba->params.num_cq_entries,
                                     sizeof(struct sol_cqe), cq_vaddress);
                 if (ret) {
                         shost_printk(KERN_ERR, phba->shost,
@@ -2634,7 +2634,8 @@ beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
                                      "wrbq create failed.");
                         return status;
                 }
-                phwi_ctrlr->wrb_context[i].cid = phwi_context->be_wrbq[i].id;
+                phwi_ctrlr->wrb_context[i * 2].cid = phwi_context->be_wrbq[i].
+                                                                   id;
         }
         kfree(pwrb_arr);
         return 0;
@@ -2803,17 +2804,6 @@ static int hwi_init_port(struct beiscsi_hba *phba)
                 goto error;
         }
 
-        if (phba->fw_config.iscsi_features == 0x1)
-                ring_mode = 1;
-        else
-                ring_mode = 0;
-        status = mgmt_get_fw_config(ctrl, phba);
-        if (status != 0) {
-                shost_printk(KERN_ERR, phba->shost,
-                             "Error getting fw config\n");
-                goto error;
-        }
-
         status = beiscsi_create_cqs(phba, phwi_context);
         if (status != 0) {
                 shost_printk(KERN_ERR, phba->shost, "CQ not created\n");
@@ -2941,17 +2931,6 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
         phba->io_sgl_hndl_avbl = 0;
         phba->eh_sgl_hndl_avbl = 0;
 
-        if (ring_mode) {
-                phba->sgl_hndl_array = kzalloc(sizeof(struct sgl_handle *) *
-                                              phba->params.icds_per_ctrl,
-                                                 GFP_KERNEL);
-                if (!phba->sgl_hndl_array) {
-                        shost_printk(KERN_ERR, phba->shost,
-                             "Mem Alloc Failed. Failing to load\n");
-                        return -ENOMEM;
-                }
-        }
-
         mem_descr_sglh = phba->init_mem;
         mem_descr_sglh += HWI_MEM_SGLH;
         if (1 == mem_descr_sglh->num_elements) {
@@ -2959,8 +2938,6 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
                                                  phba->params.ios_per_ctrl,
                                                  GFP_KERNEL);
                 if (!phba->io_sgl_hndl_base) {
-                        if (ring_mode)
-                                kfree(phba->sgl_hndl_array);
                         shost_printk(KERN_ERR, phba->shost,
                                      "Mem Alloc Failed. Failing to load\n");
                         return -ENOMEM;
@@ -3032,7 +3009,7 @@ static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
                         AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, pfrag, 0);
                         pfrag += phba->params.num_sge_per_io;
                         psgl_handle->sgl_index =
-                                phba->fw_config.iscsi_cid_start + arr_index++;
+                                phba->fw_config.iscsi_icd_start + arr_index++;
                 }
                 idx++;
         }
@@ -3047,7 +3024,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
 {
         int i, new_cid;
 
-        phba->cid_array = kmalloc(sizeof(void *) * phba->params.cxns_per_ctrl,
+        phba->cid_array = kzalloc(sizeof(void *) * phba->params.cxns_per_ctrl,
                                   GFP_KERNEL);
         if (!phba->cid_array) {
                 shost_printk(KERN_ERR, phba->shost,
@@ -3055,7 +3032,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
                              "hba_setup_cid_tbls\n");
                 return -ENOMEM;
         }
-        phba->ep_array = kmalloc(sizeof(struct iscsi_endpoint *) *
+        phba->ep_array = kzalloc(sizeof(struct iscsi_endpoint *) *
                                  phba->params.cxns_per_ctrl * 2, GFP_KERNEL);
         if (!phba->ep_array) {
                 shost_printk(KERN_ERR, phba->shost,
@@ -3064,7 +3041,7 @@ static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
                 kfree(phba->cid_array);
                 return -ENOMEM;
         }
-        new_cid = phba->fw_config.iscsi_icd_start;
+        new_cid = phba->fw_config.iscsi_cid_start;
         for (i = 0; i < phba->params.cxns_per_ctrl; i++) {
                 phba->cid_array[i] = new_cid;
                 new_cid += 2;
@@ -3145,8 +3122,6 @@ static int beiscsi_init_port(struct beiscsi_hba *phba)
         if (hba_setup_cid_tbls(phba)) {
                 shost_printk(KERN_ERR, phba->shost,
                              "Failed in hba_setup_cid_tbls\n");
-                if (ring_mode)
-                        kfree(phba->sgl_hndl_array);
                 kfree(phba->io_sgl_hndl_base);
                 kfree(phba->eh_sgl_hndl_base);
                 goto do_cleanup_ctrlr;
@@ -3166,6 +3141,7 @@ static void hwi_purge_eq(struct beiscsi_hba *phba)
         struct be_queue_info *eq;
         struct be_eq_entry *eqe = NULL;
         int i, eq_msix;
+        unsigned int num_processed;
 
         phwi_ctrlr = phba->phwi_ctrlr;
         phwi_context = phwi_ctrlr->phwi_ctxt;
@@ -3177,13 +3153,17 @@ static void hwi_purge_eq(struct beiscsi_hba *phba)
         for (i = 0; i < (phba->num_cpus + eq_msix); i++) {
                 eq = &phwi_context->be_eq[i].q;
                 eqe = queue_tail_node(eq);
-
+                num_processed = 0;
                 while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
                                         & EQE_VALID_MASK) {
                         AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
                         queue_tail_inc(eq);
                         eqe = queue_tail_node(eq);
+                        num_processed++;
                 }
+
+                if (num_processed)
+                        hwi_ring_eq_db(phba, eq->id, 1, num_processed, 1, 1);
         }
 }
 
@@ -3195,10 +3175,9 @@ static void beiscsi_clean_port(struct beiscsi_hba *phba)
         if (mgmt_status)
                 shost_printk(KERN_WARNING, phba->shost,
                              "mgmt_epfw_cleanup FAILED \n");
-        hwi_cleanup(phba);
+
         hwi_purge_eq(phba);
-        if (ring_mode)
-                kfree(phba->sgl_hndl_array);
+        hwi_cleanup(phba);
         kfree(phba->io_sgl_hndl_base);
         kfree(phba->eh_sgl_hndl_base);
         kfree(phba->cid_array);
@@ -3219,7 +3198,8 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
          * We can always use 0 here because it is reserved by libiscsi for
          * login/startup related tasks.
          */
-        pwrb_handle = alloc_wrb_handle(phba, beiscsi_conn->beiscsi_conn_cid, 0);
+        pwrb_handle = alloc_wrb_handle(phba, (beiscsi_conn->beiscsi_conn_cid -
+                                       phba->fw_config.iscsi_cid_start));
         pwrb = (struct iscsi_target_context_update_wrb *)pwrb_handle->pwrb;
         memset(pwrb, 0, sizeof(*pwrb));
         AMAP_SET_BITS(struct amap_iscsi_target_context_update_wrb,
@@ -3283,8 +3263,7 @@ beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
         be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_target_context_update_wrb));
 
         doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
-        if (!ring_mode)
-                doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK)
+        doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK)
                              << DB_DEF_PDU_WRB_INDEX_SHIFT;
         doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
 
@@ -3328,8 +3307,9 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
         io_task->bhs_pa.u.a64.address = paddr;
         io_task->libiscsi_itt = (itt_t)task->itt;
         io_task->pwrb_handle = alloc_wrb_handle(phba,
-                                                beiscsi_conn->beiscsi_conn_cid,
-                                                task->itt);
+                                                beiscsi_conn->beiscsi_conn_cid -
+                                                phba->fw_config.iscsi_cid_start
+                                                );
         io_task->conn = beiscsi_conn;
 
         task->hdr = (struct iscsi_hdr *)&io_task->cmd_bhs->iscsi_hdr;
@@ -3343,7 +3323,7 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
                         goto free_hndls;
         } else {
                 io_task->scsi_cmnd = NULL;
-                if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
+                if ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
                         if (!beiscsi_conn->login_in_progress) {
                                 spin_lock(&phba->mgmt_sgl_lock);
                                 io_task->psgl_handle = (struct sgl_handle *)
@@ -3370,21 +3350,16 @@ static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
         itt = (itt_t) cpu_to_be32(((unsigned int)io_task->pwrb_handle->
                                  wrb_index << 16) | (unsigned int)
                                 (io_task->psgl_handle->sgl_index));
-        if (ring_mode) {
-                phba->sgl_hndl_array[io_task->psgl_handle->sgl_index -
-                                     phba->fw_config.iscsi_cid_start] =
-                                     io_task->psgl_handle;
-                io_task->psgl_handle->task = task;
-                io_task->psgl_handle->cid = beiscsi_conn->beiscsi_conn_cid;
-        } else
-                io_task->pwrb_handle->pio_handle = task;
+        io_task->pwrb_handle->pio_handle = task;
 
         io_task->cmd_bhs->iscsi_hdr.itt = itt;
         return 0;
 
 free_hndls:
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid];
+        pwrb_context = &phwi_ctrlr->wrb_context[
+                        beiscsi_conn->beiscsi_conn_cid -
+                        phba->fw_config.iscsi_cid_start];
         free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
         io_task->pwrb_handle = NULL;
         pci_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
@@ -3404,7 +3379,8 @@ static void beiscsi_cleanup_task(struct iscsi_task *task)
         struct hwi_controller *phwi_ctrlr;
 
         phwi_ctrlr = phba->phwi_ctrlr;
-        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid];
+        pwrb_context = &phwi_ctrlr->wrb_context[beiscsi_conn->beiscsi_conn_cid
+                        - phba->fw_config.iscsi_cid_start];
         if (io_task->pwrb_handle) {
                 free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
                 io_task->pwrb_handle = NULL;
@@ -3460,18 +3436,12 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
                               ISCSI_OPCODE_SCSI_DATA_OUT);
                 AMAP_SET_BITS(struct amap_pdu_data_out, final_bit,
                               &io_task->cmd_bhs->iscsi_data_pdu, 1);
-                if (ring_mode)
-                        io_task->psgl_handle->type = INI_WR_CMD;
-                else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                      INI_WR_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_WR_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
         } else {
-                if (ring_mode)
-                        io_task->psgl_handle->type = INI_RD_CMD;
-                else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                      INI_RD_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_RD_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);
         }
         memcpy(&io_task->cmd_bhs->iscsi_data_pdu.
@@ -3496,8 +3466,7 @@ static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
         be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
 
         doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
-        if (!ring_mode)
-                doorbell |= (io_task->pwrb_handle->wrb_index &
+        doorbell |= (io_task->pwrb_handle->wrb_index &
                      DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
         doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
 
@@ -3519,49 +3488,46 @@ static int beiscsi_mtask(struct iscsi_task *task)
         unsigned int doorbell = 0;
         unsigned int i, cid;
         struct iscsi_task *aborted_task;
+        unsigned int tag;
 
         cid = beiscsi_conn->beiscsi_conn_cid;
         pwrb = io_task->pwrb_handle->pwrb;
+        memset(pwrb, 0, sizeof(*pwrb));
         AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,
                       be32_to_cpu(task->cmdsn));
         AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
                       io_task->pwrb_handle->wrb_index);
         AMAP_SET_BITS(struct amap_iscsi_wrb, sgl_icd_idx, pwrb,
                       io_task->psgl_handle->sgl_index);
-
         switch (task->hdr->opcode & ISCSI_OPCODE_MASK) {
         case ISCSI_OP_LOGIN:
-                if (ring_mode)
-                        io_task->psgl_handle->type = TGT_DM_CMD;
-                else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                      TGT_DM_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              TGT_DM_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb, 1);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_NOOP_OUT:
-                if (ring_mode)
-                        io_task->psgl_handle->type = INI_RD_CMD;
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_RD_CMD);
+                if (task->hdr->ttt == ISCSI_RESERVED_TAG)
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                      INI_RD_CMD);
+                        AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 1);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_TEXT:
-                if (ring_mode)
-                        io_task->psgl_handle->type = INI_WR_CMD;
-                else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                      INI_WR_CMD);
-                AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              TGT_DM_CMD);
+                AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_SCSI_TMFUNC:
                 session = conn->session;
                 i = ((struct iscsi_tm *)task->hdr)->rtt;
                 phwi_ctrlr = phba->phwi_ctrlr;
-                pwrb_context = &phwi_ctrlr->wrb_context[cid];
+                pwrb_context = &phwi_ctrlr->wrb_context[cid -
+                                            phba->fw_config.iscsi_cid_start];
                 pwrb_handle = pwrb_context->pwrb_handle_basestd[be32_to_cpu(i)
                                                                 >> 16];
                 aborted_task = pwrb_handle->pio_handle;
@@ -3572,22 +3538,25 @@ static int beiscsi_mtask(struct iscsi_task *task)
                 if (!aborted_io_task->scsi_cmnd)
                         return 0;
 
-                mgmt_invalidate_icds(phba,
+                tag = mgmt_invalidate_icds(phba,
                                      aborted_io_task->psgl_handle->sgl_index,
                                      cid);
-                if (ring_mode)
-                        io_task->psgl_handle->type = INI_TMF_CMD;
-                else
-                        AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
-                                      INI_TMF_CMD);
+                if (!tag) {
+                        shost_printk(KERN_WARNING, phba->shost,
+                                     "mgmt_invalidate_icds could not be"
+                                     " submitted\n");
+                } else {
+                        wait_event_interruptible(phba->ctrl.mcc_wait[tag],
+                                                 phba->ctrl.mcc_numtag[tag]);
+                        free_mcc_tag(&phba->ctrl, tag);
+                }
+                AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
+                              INI_TMF_CMD);
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
                 hwi_write_buffer(pwrb, task);
                 break;
         case ISCSI_OP_LOGOUT:
                 AMAP_SET_BITS(struct amap_iscsi_wrb, dmsg, pwrb, 0);
-                if (ring_mode)
-                        io_task->psgl_handle->type = HWH_TYPE_LOGOUT;
-                else
                 AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
                                 HWH_TYPE_LOGOUT);
                 hwi_write_buffer(pwrb, task);
@@ -3600,14 +3569,13 @@ static int beiscsi_mtask(struct iscsi_task *task)
         }
 
         AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb,
-                      be32_to_cpu(task->data_count));
+                      task->data_count);
         AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,
                       io_task->pwrb_handle->nxt_wrb_index);
         be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
 
         doorbell |= cid & DB_WRB_POST_CID_MASK;
-        if (!ring_mode)
-                doorbell |= (io_task->pwrb_handle->wrb_index &
+        doorbell |= (io_task->pwrb_handle->wrb_index &
                      DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
         doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
         iowrite32(doorbell, phba->db_va + DB_TXULP0_OFFSET);
@@ -3649,7 +3617,6 @@ static int beiscsi_task_xmit(struct iscsi_task *task)
         return beiscsi_iotask(task, sg, num_sg, xferlen, writedir);
 }
 
-
 static void beiscsi_remove(struct pci_dev *pcidev)
 {
         struct beiscsi_hba *phba = NULL;
@@ -3734,7 +3701,20 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
         }
         SE_DEBUG(DBG_LVL_8, " phba = %p \n", phba);
 
-        pci_set_drvdata(pcidev, phba);
+        switch (pcidev->device) {
+        case BE_DEVICE_ID1:
+        case OC_DEVICE_ID1:
+        case OC_DEVICE_ID2:
+                phba->generation = BE_GEN2;
+                break;
+        case BE_DEVICE_ID2:
+        case OC_DEVICE_ID3:
+                phba->generation = BE_GEN3;
+                break;
+        default:
+                phba->generation = 0;
+        }
+
         if (enable_msix)
                 num_cpus = find_num_cpus();
         else
@@ -3754,7 +3734,15 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
         spin_lock_init(&phba->io_sgl_lock);
         spin_lock_init(&phba->mgmt_sgl_lock);
         spin_lock_init(&phba->isr_lock);
+        ret = mgmt_get_fw_config(&phba->ctrl, phba);
+        if (ret != 0) {
+                shost_printk(KERN_ERR, phba->shost,
+                             "Error getting fw config\n");
+                goto free_port;
+        }
+        phba->shost->max_id = phba->fw_config.iscsi_cid_count;
         beiscsi_get_params(phba);
+        phba->shost->can_queue = phba->params.ios_per_ctrl;
         ret = beiscsi_init_port(phba);
         if (ret < 0) {
                 shost_printk(KERN_ERR, phba->shost, "beiscsi_dev_probe-"
@@ -3762,6 +3750,15 @@ static int __devinit beiscsi_dev_probe(struct pci_dev *pcidev,
                 goto free_port;
         }
 
+        for (i = 0; i < MAX_MCC_CMD ; i++) {
+                init_waitqueue_head(&phba->ctrl.mcc_wait[i + 1]);
+                phba->ctrl.mcc_tag[i] = i + 1;
+                phba->ctrl.mcc_numtag[i + 1] = 0;
+                phba->ctrl.mcc_tag_available++;
+        }
+
+        phba->ctrl.mcc_alloc_index = phba->ctrl.mcc_free_index = 0;
+
         snprintf(phba->wq_name, sizeof(phba->wq_name), "beiscsi_q_irq%u",
                  phba->shost->host_no);
         phba->wq = create_workqueue(phba->wq_name);
@@ -3836,7 +3833,7 @@ disable_pci:
 struct iscsi_transport beiscsi_iscsi_transport = {
         .owner = THIS_MODULE,
         .name = DRV_NAME,
-        .caps = CAP_RECOVERY_L0 | CAP_HDRDGST |
+        .caps = CAP_RECOVERY_L0 | CAP_HDRDGST | CAP_TEXT_NEGO |
                 CAP_MULTI_R2T | CAP_DATADGST | CAP_DATA_PATH_OFFLOAD,
         .param_mask = ISCSI_MAX_RECV_DLENGTH |
                 ISCSI_MAX_XMIT_DLENGTH |
@@ -3859,7 +3856,7 @@ struct iscsi_transport beiscsi_iscsi_transport = {
                 ISCSI_USERNAME | ISCSI_PASSWORD |
                 ISCSI_USERNAME_IN | ISCSI_PASSWORD_IN |
                 ISCSI_FAST_ABORT | ISCSI_ABORT_TMO |
-                ISCSI_LU_RESET_TMO | ISCSI_TGT_RESET_TMO |
+                ISCSI_LU_RESET_TMO |
                 ISCSI_PING_TMO | ISCSI_RECV_TMO |
                 ISCSI_IFACE_NAME | ISCSI_INITIATOR_NAME,
         .host_param_mask = ISCSI_HOST_HWADDRESS | ISCSI_HOST_IPADDRESS |
@@ -3905,7 +3902,7 @@ static int __init beiscsi_module_init(void)
                 SE_DEBUG(DBG_LVL_1,
                          "beiscsi_module_init - Unable to  register beiscsi"
                          "transport.\n");
-                ret = -ENOMEM;
+                return -ENOMEM;
         }
         SE_DEBUG(DBG_LVL_8, "In beiscsi_module_init, tt=%p \n",
                  &beiscsi_iscsi_transport);
@@ -3917,7 +3914,6 @@ static int __init beiscsi_module_init(void)
                          "beiscsi pci driver.\n");
                 goto unregister_iscsi_transport;
         }
-        ring_mode = 0;
         return 0;
 
 unregister_iscsi_transport:
diff --git a/drivers/scsi/be2iscsi/be_main.h b/drivers/scsi/be2iscsi/be_main.h
index 25e6b208b771..c53a80ab796c 100644
--- a/drivers/scsi/be2iscsi/be_main.h
+++ b/drivers/scsi/be2iscsi/be_main.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -40,31 +40,29 @@
 #define DRV_DESC                BE_NAME " " "Driver"
 
 #define BE_VENDOR_ID            0x19A2
+/* DEVICE ID's for BE2 */
 #define BE_DEVICE_ID1           0x212
 #define OC_DEVICE_ID1           0x702
 #define OC_DEVICE_ID2           0x703
+
+/* DEVICE ID's for BE3 */
+#define BE_DEVICE_ID2           0x222
 #define OC_DEVICE_ID3           0x712
-#define OC_DEVICE_ID4           0x222
 
-#define BE2_MAX_SESSIONS        64
+#define BE2_IO_DEPTH            1024
+#define BE2_MAX_SESSIONS        256
 #define BE2_CMDS_PER_CXN        128
-#define BE2_LOGOUTS             BE2_MAX_SESSIONS
 #define BE2_TMFS                16
 #define BE2_NOPOUT_REQ          16
-#define BE2_ASYNCPDUS           BE2_MAX_SESSIONS
-#define BE2_MAX_ICDS            2048
 #define BE2_SGE                 32
 #define BE2_DEFPDU_HDR_SZ       64
 #define BE2_DEFPDU_DATA_SZ      8192
-#define BE2_IO_DEPTH \
-        (BE2_MAX_ICDS / 2 - (BE2_LOGOUTS + BE2_TMFS + BE2_NOPOUT_REQ))
 
 #define MAX_CPUS                31
-#define BEISCSI_SGLIST_ELEMENTS BE2_SGE
+#define BEISCSI_SGLIST_ELEMENTS 30
 
-#define BEISCSI_MAX_CMNDS       1024    /* Max IO's per Ctrlr sht->can_queue */
 #define BEISCSI_CMD_PER_LUN     128     /* scsi_host->cmd_per_lun */
-#define BEISCSI_MAX_SECTORS     2048    /* scsi_host->max_sectors */
+#define BEISCSI_MAX_SECTORS     256     /* scsi_host->max_sectors */
 
 #define BEISCSI_MAX_CMD_LEN     16      /* scsi_host->max_cmd_len */
 #define BEISCSI_NUM_MAX_LUN     256     /* scsi_host->max_lun */
@@ -330,6 +328,7 @@ struct beiscsi_hba {
         struct workqueue_struct *wq;    /* The actuak work queue */
         struct work_struct work_cqs;    /* The work being queued */
         struct be_ctrl_info ctrl;
+        unsigned int generation;
 };
 
 struct beiscsi_session {
@@ -656,11 +655,12 @@ struct amap_iscsi_wrb {
 
 } __packed;
 
-struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid,
-                                    int index);
+struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid);
 void
 free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle);
 
+void beiscsi_process_all_cqs(struct work_struct *work);
+
 struct pdu_nop_out {
         u32 dw[12];
 };
@@ -802,7 +802,6 @@ struct hwi_controller {
         struct be_ring default_pdu_hdr;
         struct be_ring default_pdu_data;
         struct hwi_context_memory *phwi_ctxt;
-        unsigned short cq_errors[CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN];
 };
 
 enum hwh_type_enum {
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index 79c2bd525a84..317bcd042ced 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -48,6 +48,14 @@ unsigned char mgmt_get_fw_config(struct be_ctrl_info *ctrl,
                                         pfw_cfg->ulp[0].sq_base;
                 phba->fw_config.iscsi_cid_count =
                                         pfw_cfg->ulp[0].sq_count;
+                if (phba->fw_config.iscsi_cid_count > (BE2_MAX_SESSIONS / 2)) {
+                        SE_DEBUG(DBG_LVL_8,
+                                "FW reported MAX CXNS as %d \t"
+                                "Max Supported = %d.\n",
+                                phba->fw_config.iscsi_cid_count,
+                                BE2_MAX_SESSIONS);
+                        phba->fw_config.iscsi_cid_count = BE2_MAX_SESSIONS / 2;
+                }
         } else {
                 shost_printk(KERN_WARNING, phba->shost,
                              "Failed in mgmt_get_fw_config \n");
@@ -77,6 +85,7 @@ unsigned char mgmt_check_supported_fw(struct be_ctrl_info *ctrl,
         }
         nonemb_cmd.size = sizeof(struct be_mgmt_controller_attributes);
         req = nonemb_cmd.va;
+        memset(req, 0, sizeof(*req));
         spin_lock(&ctrl->mbox_lock);
         memset(wrb, 0, sizeof(*wrb));
         be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
@@ -140,10 +149,17 @@ unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
 {
         struct be_dma_mem nonemb_cmd;
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
-        struct be_sge *sge = nonembedded_sgl(wrb);
+        struct be_mcc_wrb *wrb;
+        struct be_sge *sge;
         struct invalidate_commands_params_in *req;
-        int status = 0;
+        unsigned int tag = 0;
+
+        spin_lock(&ctrl->mbox_lock);
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
 
         nonemb_cmd.va = pci_alloc_consistent(ctrl->pdev,
                                 sizeof(struct invalidate_commands_params_in),
@@ -156,8 +172,10 @@ unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
         }
         nonemb_cmd.size = sizeof(struct invalidate_commands_params_in);
         req = nonemb_cmd.va;
-        spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        memset(req, 0, sizeof(*req));
+        wrb = wrb_from_mccq(phba);
+        sge = nonembedded_sgl(wrb);
+        wrb->tag0 |= tag;
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), false, 1);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
@@ -172,14 +190,12 @@ unsigned char mgmt_invalidate_icds(struct beiscsi_hba *phba,
         sge->pa_lo = cpu_to_le32(nonemb_cmd.dma & 0xFFFFFFFF);
         sge->len = cpu_to_le32(nonemb_cmd.size);
 
-        status = be_mcc_notify_wait(phba);
-        if (status)
-                SE_DEBUG(DBG_LVL_1, "ICDS Invalidation Failed\n");
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
         if (nonemb_cmd.va)
                 pci_free_consistent(ctrl->pdev, nonemb_cmd.size,
                                     nonemb_cmd.va, nonemb_cmd.dma);
-        return status;
+        return tag;
 }
 
 unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
@@ -189,13 +205,19 @@ unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
                                          unsigned short savecfg_flag)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
-        struct iscsi_invalidate_connection_params_in *req =
-                                                embedded_payload(wrb);
-        int status = 0;
+        struct be_mcc_wrb *wrb;
+        struct iscsi_invalidate_connection_params_in *req;
+        unsigned int tag = 0;
 
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+        wrb = wrb_from_mccq(phba);
+        wrb->tag0 |= tag;
+        req = embedded_payload(wrb);
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI_INI,
@@ -208,35 +230,37 @@ unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
         else
                 req->cleanup_type = CMD_ISCSI_CONNECTION_INVALIDATE;
         req->save_cfg = savecfg_flag;
-        status =  be_mcc_notify_wait(phba);
-        if (status)
-                SE_DEBUG(DBG_LVL_1, "Invalidation Failed\n");
-
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
 
 unsigned char mgmt_upload_connection(struct beiscsi_hba *phba,
                                 unsigned short cid, unsigned int upload_flag)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
-        struct tcp_upload_params_in *req = embedded_payload(wrb);
-        int status = 0;
+        struct be_mcc_wrb *wrb;
+        struct tcp_upload_params_in *req;
+        unsigned int tag = 0;
 
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_COMMON_TCP_UPLOAD,
                            OPCODE_COMMON_TCP_UPLOAD, sizeof(*req));
         req->id = (unsigned short)cid;
         req->upload_type = (unsigned char)upload_flag;
-        status = be_mcc_notify_wait(phba);
-        if (status)
-                SE_DEBUG(DBG_LVL_1, "mgmt_upload_connection Failed\n");
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
 
 int mgmt_open_connection(struct beiscsi_hba *phba,
@@ -248,13 +272,13 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         struct sockaddr_in *daddr_in = (struct sockaddr_in *)dst_addr;
         struct sockaddr_in6 *daddr_in6 = (struct sockaddr_in6 *)dst_addr;
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
-        struct tcp_connect_and_offload_in *req = embedded_payload(wrb);
+        struct be_mcc_wrb *wrb;
+        struct tcp_connect_and_offload_in *req;
         unsigned short def_hdr_id;
         unsigned short def_data_id;
         struct phys_addr template_address = { 0, 0 };
         struct phys_addr *ptemplate_address;
-        int status = 0;
+        unsigned int tag = 0;
         unsigned int i;
         unsigned short cid = beiscsi_ep->ep_cid;
 
@@ -266,7 +290,14 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         ptemplate_address = &template_address;
         ISCSI_GET_PDU_TEMPLATE_ADDRESS(phba, ptemplate_address);
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
 
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
@@ -311,46 +342,36 @@ int mgmt_open_connection(struct beiscsi_hba *phba,
         req->do_offload = 1;
         req->dataout_template_pa.lo = ptemplate_address->lo;
         req->dataout_template_pa.hi = ptemplate_address->hi;
-        status = be_mcc_notify_wait(phba);
-        if (!status) {
-                struct iscsi_endpoint *ep;
-                struct tcp_connect_and_offload_out *ptcpcnct_out =
-                                                        embedded_payload(wrb);
-
-                ep = phba->ep_array[ptcpcnct_out->cid];
-                beiscsi_ep = ep->dd_data;
-                beiscsi_ep->fw_handle = ptcpcnct_out->connection_handle;
-                beiscsi_ep->cid_vld = 1;
-                SE_DEBUG(DBG_LVL_8, "mgmt_open_connection Success\n");
-        } else
-                SE_DEBUG(DBG_LVL_1, "mgmt_open_connection Failed\n");
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
 
-int be_cmd_get_mac_addr(struct beiscsi_hba *phba, u8 *mac_addr)
+unsigned int be_cmd_get_mac_addr(struct beiscsi_hba *phba)
 {
         struct be_ctrl_info *ctrl = &phba->ctrl;
-        struct be_mcc_wrb *wrb = wrb_from_mccq(phba);
-        struct be_cmd_req_get_mac_addr *req = embedded_payload(wrb);
-        int status;
+        struct be_mcc_wrb *wrb;
+        struct be_cmd_req_get_mac_addr *req;
+        unsigned int tag = 0;
 
         SE_DEBUG(DBG_LVL_8, "In be_cmd_get_mac_addr\n");
         spin_lock(&ctrl->mbox_lock);
-        memset(wrb, 0, sizeof(*wrb));
+        tag = alloc_mcc_tag(phba);
+        if (!tag) {
+                spin_unlock(&ctrl->mbox_lock);
+                return tag;
+        }
+
+        wrb = wrb_from_mccq(phba);
+        req = embedded_payload(wrb);
+        wrb->tag0 |= tag;
         be_wrb_hdr_prepare(wrb, sizeof(*req), true, 0);
         be_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ISCSI,
                            OPCODE_COMMON_ISCSI_NTWK_GET_NIC_CONFIG,
                            sizeof(*req));
 
-        status = be_mcc_notify_wait(phba);
-        if (!status) {
-                struct be_cmd_resp_get_mac_addr *resp = embedded_payload(wrb);
-
-                memcpy(mac_addr, resp->mac_address, ETH_ALEN);
-        }
-
+        be_mcc_notify(phba);
         spin_unlock(&ctrl->mbox_lock);
-        return status;
+        return tag;
 }
 
diff --git a/drivers/scsi/be2iscsi/be_mgmt.h b/drivers/scsi/be2iscsi/be_mgmt.h
index 24eaff923f85..ecead6a5aa56 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.h
+++ b/drivers/scsi/be2iscsi/be_mgmt.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (C) 2005 - 2009 ServerEngines
+ * Copyright (C) 2005 - 2010 ServerEngines
  * All rights reserved.
  *
  * This program is free software; you can redistribute it and/or
@@ -231,6 +231,7 @@ struct beiscsi_endpoint {
         struct beiscsi_hba *phba;
         struct beiscsi_sess *sess;
         struct beiscsi_conn *conn;
+        struct iscsi_endpoint *openiscsi_ep;
         unsigned short ip_type;
         char dst6_addr[ISCSI_ADDRESS_BUF_LEN];
         unsigned long dst_addr;
@@ -249,7 +250,4 @@ unsigned char mgmt_invalidate_connection(struct beiscsi_hba *phba,
                                          unsigned short issue_reset,
                                          unsigned short savecfg_flag);
 
-unsigned char mgmt_fw_cmd(struct be_ctrl_info *ctrl,
-                          struct beiscsi_hba *phba,
-                          char *buf, unsigned int len);
 #endif
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index 33b2294625bb..1c4d1215769d 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -1426,8 +1426,8 @@ static int bnx2i_conn_get_param(struct iscsi_cls_conn *cls_conn,
                 break;
         case ISCSI_PARAM_CONN_ADDRESS:
                 if (bnx2i_conn->ep)
-                        len = sprintf(buf, NIPQUAD_FMT "\n",
-                                      NIPQUAD(bnx2i_conn->ep->cm_sk->dst_ip));
+                        len = sprintf(buf, "%pI4\n",
+                                      &bnx2i_conn->ep->cm_sk->dst_ip);
                 break;
         default:
                 return iscsi_conn_get_param(cls_conn, param, buf);
@@ -1990,6 +1990,7 @@ static struct scsi_host_template bnx2i_host_template = {
         .eh_abort_handler       = iscsi_eh_abort,
         .eh_device_reset_handler = iscsi_eh_device_reset,
         .eh_target_reset_handler = iscsi_eh_target_reset,
+        .change_queue_depth     = iscsi_change_queue_depth,
         .can_queue              = 1024,
         .max_sectors            = 127,
         .cmd_per_lun            = 32,
diff --git a/drivers/scsi/constants.c b/drivers/scsi/constants.c
index 9129bcf117cf..cd05e049d5f6 100644
--- a/drivers/scsi/constants.c
+++ b/drivers/scsi/constants.c
@@ -219,18 +219,15 @@ static void print_opcode_name(unsigned char * cdbp, int cdb_len)
                         break;
                 }
                 sa = (cdbp[8] << 8) + cdbp[9];
-                name = get_sa_name(maint_in_arr, MAINT_IN_SZ, sa);
-                if (name) {
+                name = get_sa_name(variable_length_arr, VARIABLE_LENGTH_SZ, sa);
+                if (name)
                         printk("%s", name);
-                        if ((cdb_len > 0) && (len != cdb_len))
-                                printk(", in_cdb_len=%d, ext_len=%d",
-                                       len, cdb_len);
-                } else {
+                else
                         printk("cdb[0]=0x%x, sa=0x%x", cdb0, sa);
-                        if ((cdb_len > 0) && (len != cdb_len))
-                                printk(", in_cdb_len=%d, ext_len=%d",
-                                       len, cdb_len);
-                }
+
+                if ((cdb_len > 0) && (len != cdb_len))
+                        printk(", in_cdb_len=%d, ext_len=%d", len, cdb_len);
+
                 break;
         case MAINTENANCE_IN:
                 sa = cdbp[1] & 0x1f;
@@ -349,6 +346,9 @@ void scsi_print_command(struct scsi_cmnd *cmd)
 {
         int k;
 
+        if (cmd->cmnd == NULL)
+                return;
+
         scmd_printk(KERN_INFO, cmd, "CDB: ");
         print_opcode_name(cmd->cmnd, cmd->cmd_len);
 
diff --git a/drivers/scsi/cxgb3i/cxgb3i_iscsi.c b/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
index 969c83162cc4..412853c65372 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_iscsi.c
@@ -591,8 +591,7 @@ static int cxgb3i_conn_bind(struct iscsi_cls_session *cls_session,
         cxgb3i_conn_max_recv_dlength(conn);
 
         spin_lock_bh(&conn->session->lock);
-        sprintf(conn->portal_address, NIPQUAD_FMT,
-                NIPQUAD(c3cn->daddr.sin_addr.s_addr));
+        sprintf(conn->portal_address, "%pI4", &c3cn->daddr.sin_addr.s_addr);
         conn->portal_port = ntohs(c3cn->daddr.sin_port);
         spin_unlock_bh(&conn->session->lock);
 
@@ -709,6 +708,12 @@ static int cxgb3i_host_set_param(struct Scsi_Host *shost,
 {
         struct cxgb3i_hba *hba = iscsi_host_priv(shost);
 
+        if (!hba->ndev) {
+                shost_printk(KERN_ERR, shost, "Could not set host param. "
+                             "Netdev for host not set.\n");
+                return -ENODEV;
+        }
+
         cxgb3i_api_debug("param %d, buf %s.\n", param, buf);
 
         switch (param) {
@@ -739,6 +744,12 @@ static int cxgb3i_host_get_param(struct Scsi_Host *shost,
         struct cxgb3i_hba *hba = iscsi_host_priv(shost);
         int len = 0;
 
+        if (!hba->ndev) {
+                shost_printk(KERN_ERR, shost, "Could not set host param. "
+                             "Netdev for host not set.\n");
+                return -ENODEV;
+        }
+
         cxgb3i_api_debug("hba %s, param %d.\n", hba->ndev->name, param);
 
         switch (param) {
@@ -753,7 +764,7 @@ static int cxgb3i_host_get_param(struct Scsi_Host *shost,
                 __be32 addr;
 
                 addr = cxgb3i_get_private_ipv4addr(hba->ndev);
-                len = sprintf(buf, NIPQUAD_FMT, NIPQUAD(addr));
+                len = sprintf(buf, "%pI4", &addr);
                 break;
         }
         default:
diff --git a/drivers/scsi/cxgb3i/cxgb3i_offload.c b/drivers/scsi/cxgb3i/cxgb3i_offload.c
index 15a00e8b7122..3e08c430ff29 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_offload.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_offload.c
@@ -1675,10 +1675,11 @@ int cxgb3i_c3cn_connect(struct net_device *dev, struct s3_conn *c3cn,
         } else
                 c3cn->saddr.sin_addr.s_addr = sipv4;
 
-        c3cn_conn_debug("c3cn 0x%p, %u.%u.%u.%u,%u-%u.%u.%u.%u,%u SYN_SENT.\n",
-                        c3cn, NIPQUAD(c3cn->saddr.sin_addr.s_addr),
+        c3cn_conn_debug("c3cn 0x%p, %pI4,%u-%pI4,%u SYN_SENT.\n",
+                        c3cn,
+                        &c3cn->saddr.sin_addr.s_addr,
                         ntohs(c3cn->saddr.sin_port),
-                        NIPQUAD(c3cn->daddr.sin_addr.s_addr),
+                        &c3cn->daddr.sin_addr.s_addr,
                         ntohs(c3cn->daddr.sin_port));
 
         c3cn_set_state(c3cn, C3CN_STATE_CONNECTING);
diff --git a/drivers/scsi/cxgb3i/cxgb3i_pdu.c b/drivers/scsi/cxgb3i/cxgb3i_pdu.c
index 1fe3b0f1f3c9..9c38539557fc 100644
--- a/drivers/scsi/cxgb3i/cxgb3i_pdu.c
+++ b/drivers/scsi/cxgb3i/cxgb3i_pdu.c
@@ -461,10 +461,8 @@ void cxgb3i_conn_pdu_ready(struct s3_conn *c3cn)
                 skb = skb_peek(&c3cn->receive_queue);
         }
         read_unlock(&c3cn->callback_lock);
-        if (c3cn) {
-                c3cn->copied_seq += read;
-                cxgb3i_c3cn_rx_credits(c3cn, read);
-        }
+        c3cn->copied_seq += read;
+        cxgb3i_c3cn_rx_credits(c3cn, read);
         conn->rxdata_octets += read;
 
         if (err) {
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index 4f0d0138f48b..bc9e94f5915e 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -717,6 +717,8 @@ static const struct scsi_dh_devlist alua_dev_list[] = {
         {"IBM", "2145" },
         {"Pillar", "Axiom" },
         {"Intel", "Multi-Flex"},
+        {"NETAPP", "LUN"},
+        {"AIX", "NVDISK"},
         {NULL, NULL}
 };
 
diff --git a/drivers/scsi/eata.c b/drivers/scsi/eata.c
index c7076ce25e21..3c5abf7cd762 100644
--- a/drivers/scsi/eata.c
+++ b/drivers/scsi/eata.c
@@ -1509,7 +1509,7 @@ static int option_setup(char *str)
         char *cur = str;
         int i = 1;
 
-        while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
+        while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
                 ints[i++] = simple_strtoul(cur, NULL, 0);
 
                 if ((cur = strchr(cur, ',')) != NULL)
diff --git a/drivers/scsi/esp_scsi.c b/drivers/scsi/esp_scsi.c
index a680e18b5f3b..e2bc779f86c1 100644
--- a/drivers/scsi/esp_scsi.c
+++ b/drivers/scsi/esp_scsi.c
@@ -1449,9 +1449,6 @@ static void esp_msgin_sdtr(struct esp *esp, struct esp_target_data *tp)
         if (offset > 15)
                 goto do_reject;
 
-        if (esp->flags & ESP_FLAG_DISABLE_SYNC)
-                offset = 0;
-
         if (offset) {
                 int one_clock;
 
@@ -2405,12 +2402,6 @@ static int esp_slave_configure(struct scsi_device *dev)
         struct esp_target_data *tp = &esp->target[dev->id];
         int goal_tags, queue_depth;
 
-        if (esp->flags & ESP_FLAG_DISABLE_SYNC) {
-                /* Bypass async domain validation */
-                dev->ppr  = 0;
-                dev->sdtr = 0;
-        }
-
         goal_tags = 0;
 
         if (dev->tagged_supported) {
@@ -2660,7 +2651,10 @@ static void esp_set_offset(struct scsi_target *target, int offset)
         struct esp *esp = shost_priv(host);
         struct esp_target_data *tp = &esp->target[target->id];
 
-        tp->nego_goal_offset = offset;
+        if (esp->flags & ESP_FLAG_DISABLE_SYNC)
+                tp->nego_goal_offset = 0;
+        else
+                tp->nego_goal_offset = offset;
         tp->flags |= ESP_TGT_CHECK_NEGO;
 }
 
diff --git a/drivers/scsi/fnic/fnic.h b/drivers/scsi/fnic/fnic.h
index bb208a6091e7..3966c71d0095 100644
--- a/drivers/scsi/fnic/fnic.h
+++ b/drivers/scsi/fnic/fnic.h
@@ -36,7 +36,7 @@
 
 #define DRV_NAME                "fnic"
 #define DRV_DESCRIPTION         "Cisco FCoE HBA Driver"
-#define DRV_VERSION             "1.0.0.1121"
+#define DRV_VERSION             "1.4.0.98"
 #define PFX                     DRV_NAME ": "
 #define DFX                     DRV_NAME "%d: "
 
diff --git a/drivers/scsi/fnic/fnic_main.c b/drivers/scsi/fnic/fnic_main.c
index fe1b1031f7ab..507e26c1c29f 100644
--- a/drivers/scsi/fnic/fnic_main.c
+++ b/drivers/scsi/fnic/fnic_main.c
@@ -620,6 +620,8 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
         if (fnic->config.flags & VFCF_FIP_CAPABLE) {
                 shost_printk(KERN_INFO, fnic->lport->host,
                              "firmware supports FIP\n");
+                /* enable directed and multicast */
+                vnic_dev_packet_filter(fnic->vdev, 1, 1, 0, 0, 0);
                 vnic_dev_add_addr(fnic->vdev, FIP_ALL_ENODE_MACS);
                 vnic_dev_add_addr(fnic->vdev, fnic->ctlr.ctl_src_addr);
         } else {
@@ -698,6 +700,8 @@ static int __devinit fnic_probe(struct pci_dev *pdev,
                 goto err_out_remove_scsi_host;
         }
 
+        fc_lport_init_stats(lp);
+
         fc_lport_config(lp);
 
         if (fc_set_mfs(lp, fnic->config.maxdatafieldsize +
diff --git a/drivers/scsi/fnic/vnic_devcmd.h b/drivers/scsi/fnic/vnic_devcmd.h
index d62b9061bf12..7c9ccbd4134b 100644
--- a/drivers/scsi/fnic/vnic_devcmd.h
+++ b/drivers/scsi/fnic/vnic_devcmd.h
@@ -94,7 +94,7 @@ enum vnic_devcmd_cmd {
         CMD_STATS_DUMP          = _CMDC(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 4),
 
         /* set Rx packet filter: (u32)a0=filters (see CMD_PFILTER_*) */
-        CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ENET, 7),
+        CMD_PACKET_FILTER       = _CMDCNW(_CMD_DIR_WRITE, _CMD_VTYPE_ALL, 7),
 
         /* hang detection notification */
         CMD_HANG_NOTIFY         = _CMDC(_CMD_DIR_NONE, _CMD_VTYPE_ALL, 8),
diff --git a/drivers/scsi/gdth.c b/drivers/scsi/gdth.c
index 9e8fce0f0c1b..ba3c94c9c25f 100644
--- a/drivers/scsi/gdth.c
+++ b/drivers/scsi/gdth.c
@@ -140,40 +140,40 @@
 #include "gdth.h"
 
 static void gdth_delay(int milliseconds);
-static void gdth_eval_mapping(ulong32 size, ulong32 *cyls, int *heads, int *secs);
+static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs);
 static irqreturn_t gdth_interrupt(int irq, void *dev_id);
 static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
                                     int gdth_from_wait, int* pIndex);
-static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
+static int gdth_sync_event(gdth_ha_str *ha, int service, u8 index,
                                                                Scsi_Cmnd *scp);
 static int gdth_async_event(gdth_ha_str *ha);
 static void gdth_log_event(gdth_evt_data *dvr, char *buffer);
 
-static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority);
+static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 priority);
 static void gdth_next(gdth_ha_str *ha);
-static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b);
+static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 b);
 static int gdth_special_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp);
-static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, ushort source,
-                                      ushort idx, gdth_evt_data *evt);
+static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source,
+                                      u16 idx, gdth_evt_data *evt);
 static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr);
-static void gdth_readapp_event(gdth_ha_str *ha, unchar application, 
+static void gdth_readapp_event(gdth_ha_str *ha, u8 application, 
                                gdth_evt_str *estr);
 static void gdth_clear_events(void);
 
 static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp,
-                                    char *buffer, ushort count);
+                                    char *buffer, u16 count);
 static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp);
-static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive);
+static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u16 hdrive);
 
 static void gdth_enable_int(gdth_ha_str *ha);
 static int gdth_test_busy(gdth_ha_str *ha);
 static int gdth_get_cmd_index(gdth_ha_str *ha);
 static void gdth_release_event(gdth_ha_str *ha);
-static int gdth_wait(gdth_ha_str *ha, int index,ulong32 time);
-static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
-                                             ulong32 p1, ulong64 p2,ulong64 p3);
+static int gdth_wait(gdth_ha_str *ha, int index,u32 time);
+static int gdth_internal_cmd(gdth_ha_str *ha, u8 service, u16 opcode,
+                                             u32 p1, u64 p2,u64 p3);
 static int gdth_search_drives(gdth_ha_str *ha);
-static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive);
+static int gdth_analyse_hdrive(gdth_ha_str *ha, u16 hdrive);
 
 static const char *gdth_ctr_name(gdth_ha_str *ha);
 
@@ -189,7 +189,7 @@ static int __gdth_queuecommand(gdth_ha_str *ha, struct scsi_cmnd *scp,
 static void gdth_scsi_done(struct scsi_cmnd *scp);
 
 #ifdef DEBUG_GDTH
-static unchar   DebugState = DEBUG_GDTH;
+static u8   DebugState = DEBUG_GDTH;
 
 #ifdef __SERIAL__
 #define MAX_SERBUF 160
@@ -270,30 +270,30 @@ static int ser_printk(const char *fmt, ...)
 #endif
 
 #ifdef GDTH_STATISTICS
-static ulong32 max_rq=0, max_index=0, max_sg=0;
+static u32 max_rq=0, max_index=0, max_sg=0;
 #ifdef INT_COAL
-static ulong32 max_int_coal=0;
+static u32 max_int_coal=0;
 #endif
-static ulong32 act_ints=0, act_ios=0, act_stats=0, act_rq=0;
+static u32 act_ints=0, act_ios=0, act_stats=0, act_rq=0;
 static struct timer_list gdth_timer;
 #endif
 
-#define PTR2USHORT(a)   (ushort)(ulong)(a)
+#define PTR2USHORT(a)   (u16)(unsigned long)(a)
 #define GDTOFFSOF(a,b)  (size_t)&(((a*)0)->b)
 #define INDEX_OK(i,t)   ((i)<ARRAY_SIZE(t))
 
 #define BUS_L2P(a,b)    ((b)>(a)->virt_bus ? (b-1):(b))
 
 #ifdef CONFIG_ISA
-static unchar   gdth_drq_tab[4] = {5,6,7,7};            /* DRQ table */
+static u8   gdth_drq_tab[4] = {5,6,7,7};            /* DRQ table */
 #endif
 #if defined(CONFIG_EISA) || defined(CONFIG_ISA)
-static unchar   gdth_irq_tab[6] = {0,10,11,12,14,0};    /* IRQ table */
+static u8   gdth_irq_tab[6] = {0,10,11,12,14,0};    /* IRQ table */
 #endif
-static unchar   gdth_polling;                           /* polling if TRUE */
+static u8   gdth_polling;                           /* polling if TRUE */
 static int      gdth_ctr_count  = 0;                    /* controller count */
 static LIST_HEAD(gdth_instances);                       /* controller list */
-static unchar   gdth_write_through = FALSE;             /* write through */
+static u8   gdth_write_through = FALSE;             /* write through */
 static gdth_evt_str ebuffer[MAX_EVENTS];                /* event buffer */
 static int elastidx;
 static int eoldidx;
@@ -303,7 +303,7 @@ static int major;
 #define DOU     2                               /* OUT data direction */
 #define DNO     DIN                             /* no data transfer */
 #define DUN     DIN                             /* unknown data direction */
-static unchar gdth_direction_tab[0x100] = {
+static u8 gdth_direction_tab[0x100] = {
     DNO,DNO,DIN,DIN,DOU,DIN,DIN,DOU,DIN,DUN,DOU,DOU,DUN,DUN,DUN,DIN,
     DNO,DIN,DIN,DOU,DIN,DOU,DNO,DNO,DOU,DNO,DIN,DNO,DIN,DOU,DNO,DUN,
     DIN,DUN,DIN,DUN,DOU,DIN,DUN,DUN,DIN,DIN,DOU,DNO,DUN,DIN,DOU,DOU,
@@ -390,7 +390,7 @@ static gdth_ha_str *gdth_find_ha(int hanum)
 static struct gdth_cmndinfo *gdth_get_cmndinfo(gdth_ha_str *ha)
 {
         struct gdth_cmndinfo *priv = NULL;
-        ulong flags;
+        unsigned long flags;
         int i;
 
         spin_lock_irqsave(&ha->smp_lock, flags);
@@ -493,7 +493,7 @@ int gdth_execute(struct Scsi_Host *shost, gdth_cmd_str *gdtcmd, char *cmnd,
     return rval;
 }
 
-static void gdth_eval_mapping(ulong32 size, ulong32 *cyls, int *heads, int *secs)
+static void gdth_eval_mapping(u32 size, u32 *cyls, int *heads, int *secs)
 {
     *cyls = size /HEADS/SECS;
     if (*cyls <= MAXCYLS) {
@@ -514,9 +514,9 @@ static void gdth_eval_mapping(ulong32 size, ulong32 *cyls, int *heads, int *secs
 
 /* controller search and initialization functions */
 #ifdef CONFIG_EISA
-static int __init gdth_search_eisa(ushort eisa_adr)
+static int __init gdth_search_eisa(u16 eisa_adr)
 {
-    ulong32 id;
+    u32 id;
     
     TRACE(("gdth_search_eisa() adr. %x\n",eisa_adr));
     id = inl(eisa_adr+ID0REG);
@@ -533,13 +533,13 @@ static int __init gdth_search_eisa(ushort eisa_adr)
 #endif /* CONFIG_EISA */
 
 #ifdef CONFIG_ISA
-static int __init gdth_search_isa(ulong32 bios_adr)
+static int __init gdth_search_isa(u32 bios_adr)
 {
     void __iomem *addr;
-    ulong32 id;
+    u32 id;
 
     TRACE(("gdth_search_isa() bios adr. %x\n",bios_adr));
-    if ((addr = ioremap(bios_adr+BIOS_ID_OFFS, sizeof(ulong32))) != NULL) {
+    if ((addr = ioremap(bios_adr+BIOS_ID_OFFS, sizeof(u32))) != NULL) {
         id = readl(addr);
         iounmap(addr);
         if (id == GDT2_ID)                          /* GDT2000 */
@@ -551,7 +551,7 @@ static int __init gdth_search_isa(ulong32 bios_adr)
 
 #ifdef CONFIG_PCI
 
-static bool gdth_search_vortex(ushort device)
+static bool gdth_search_vortex(u16 device)
 {
         if (device <= PCI_DEVICE_ID_VORTEX_GDT6555)
                 return true;
@@ -603,9 +603,9 @@ static void __devexit gdth_pci_remove_one(struct pci_dev *pdev)
 static int __devinit gdth_pci_init_one(struct pci_dev *pdev,
                                        const struct pci_device_id *ent)
 {
-        ushort vendor = pdev->vendor;
-        ushort device = pdev->device;
-        ulong base0, base1, base2;
+        u16 vendor = pdev->vendor;
+        u16 device = pdev->device;
+        unsigned long base0, base1, base2;
         int rc;
         gdth_pci_str gdth_pcistr;
         gdth_ha_str *ha = NULL;
@@ -658,10 +658,10 @@ static int __devinit gdth_pci_init_one(struct pci_dev *pdev,
 #endif /* CONFIG_PCI */
 
 #ifdef CONFIG_EISA
-static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
+static int __init gdth_init_eisa(u16 eisa_adr,gdth_ha_str *ha)
 {
-    ulong32 retries,id;
-    unchar prot_ver,eisacf,i,irq_found;
+    u32 retries,id;
+    u8 prot_ver,eisacf,i,irq_found;
 
     TRACE(("gdth_init_eisa() adr. %x\n",eisa_adr));
     
@@ -688,7 +688,7 @@ static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
         return 0;
     }
     ha->bmic = eisa_adr;
-    ha->brd_phys = (ulong32)eisa_adr >> 12;
+    ha->brd_phys = (u32)eisa_adr >> 12;
 
     outl(0,eisa_adr+MAILBOXREG);
     outl(0,eisa_adr+MAILBOXREG+4);
@@ -752,12 +752,12 @@ static int __init gdth_init_eisa(ushort eisa_adr,gdth_ha_str *ha)
 #endif /* CONFIG_EISA */
 
 #ifdef CONFIG_ISA
-static int __init gdth_init_isa(ulong32 bios_adr,gdth_ha_str *ha)
+static int __init gdth_init_isa(u32 bios_adr,gdth_ha_str *ha)
 {
     register gdt2_dpram_str __iomem *dp2_ptr;
     int i;
-    unchar irq_drq,prot_ver;
-    ulong32 retries;
+    u8 irq_drq,prot_ver;
+    u32 retries;
 
     TRACE(("gdth_init_isa() bios adr. %x\n",bios_adr));
 
@@ -812,7 +812,7 @@ static int __init gdth_init_isa(ulong32 bios_adr,gdth_ha_str *ha)
         }
         gdth_delay(1);
     }
-    prot_ver = (unchar)readl(&dp2_ptr->u.ic.S_Info[0]);
+    prot_ver = (u8)readl(&dp2_ptr->u.ic.S_Info[0]);
     writeb(0, &dp2_ptr->u.ic.Status);
     writeb(0xff, &dp2_ptr->io.irqdel);
     if (prot_ver != PROTOCOL_VERSION) {
@@ -859,9 +859,9 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
     register gdt6_dpram_str __iomem *dp6_ptr;
     register gdt6c_dpram_str __iomem *dp6c_ptr;
     register gdt6m_dpram_str __iomem *dp6m_ptr;
-    ulong32 retries;
-    unchar prot_ver;
-    ushort command;
+    u32 retries;
+    u8 prot_ver;
+    u16 command;
     int i, found = FALSE;
 
     TRACE(("gdth_init_pci()\n"));
@@ -871,7 +871,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
     else
         ha->oem_id = OEM_ID_ICP;
     ha->brd_phys = (pdev->bus->number << 8) | (pdev->devfn & 0xf8);
-    ha->stype = (ulong32)pdev->device;
+    ha->stype = (u32)pdev->device;
     ha->irq = pdev->irq;
     ha->pdev = pdev;
     
@@ -891,7 +891,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             found = FALSE;
             for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
                 iounmap(ha->brd);
-                ha->brd = ioremap(i, sizeof(ushort)); 
+                ha->brd = ioremap(i, sizeof(u16)); 
                 if (ha->brd == NULL) {
                     printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
                     return 0;
@@ -947,7 +947,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)readl(&dp6_ptr->u.ic.S_Info[0]);
+        prot_ver = (u8)readl(&dp6_ptr->u.ic.S_Info[0]);
         writeb(0, &dp6_ptr->u.ic.S_Status);
         writeb(0xff, &dp6_ptr->io.irqdel);
         if (prot_ver != PROTOCOL_VERSION) {
@@ -1000,7 +1000,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             found = FALSE;
             for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
                 iounmap(ha->brd);
-                ha->brd = ioremap(i, sizeof(ushort)); 
+                ha->brd = ioremap(i, sizeof(u16)); 
                 if (ha->brd == NULL) {
                     printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
                     return 0;
@@ -1059,7 +1059,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)readl(&dp6c_ptr->u.ic.S_Info[0]);
+        prot_ver = (u8)readl(&dp6c_ptr->u.ic.S_Info[0]);
         writeb(0, &dp6c_ptr->u.ic.Status);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
@@ -1128,7 +1128,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             found = FALSE;
             for (i = 0xC8000; i < 0xE8000; i += 0x4000) {
                 iounmap(ha->brd);
-                ha->brd = ioremap(i, sizeof(ushort)); 
+                ha->brd = ioremap(i, sizeof(u16)); 
                 if (ha->brd == NULL) {
                     printk("GDT-PCI: Initialization error (DPMEM remap error)\n");
                     return 0;
@@ -1180,7 +1180,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)readl(&dp6m_ptr->u.ic.S_Info[0]);
+        prot_ver = (u8)readl(&dp6m_ptr->u.ic.S_Info[0]);
         writeb(0, &dp6m_ptr->u.ic.S_Status);
         if (prot_ver != PROTOCOL_VERSION) {
             printk("GDT-PCI: Illegal protocol version\n");
@@ -1223,7 +1223,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
             }
             gdth_delay(1);
         }
-        prot_ver = (unchar)(readl(&dp6m_ptr->u.ic.S_Info[0]) >> 16);
+        prot_ver = (u8)(readl(&dp6m_ptr->u.ic.S_Info[0]) >> 16);
         writeb(0, &dp6m_ptr->u.ic.S_Status);
         if (prot_ver < 0x2b)      /* FW < x.43: no 64-bit DMA support */
             ha->dma64_support = 0;
@@ -1239,7 +1239,7 @@ static int __devinit gdth_init_pci(struct pci_dev *pdev, gdth_pci_str *pcistr,
 
 static void __devinit gdth_enable_int(gdth_ha_str *ha)
 {
-    ulong flags;
+    unsigned long flags;
     gdt2_dpram_str __iomem *dp2_ptr;
     gdt6_dpram_str __iomem *dp6_ptr;
     gdt6m_dpram_str __iomem *dp6m_ptr;
@@ -1274,14 +1274,14 @@ static void __devinit gdth_enable_int(gdth_ha_str *ha)
 }
 
 /* return IStatus if interrupt was from this card else 0 */
-static unchar gdth_get_status(gdth_ha_str *ha)
+static u8 gdth_get_status(gdth_ha_str *ha)
 {
-    unchar IStatus = 0;
+    u8 IStatus = 0;
 
     TRACE(("gdth_get_status() irq %d ctr_count %d\n", ha->irq, gdth_ctr_count));
 
         if (ha->type == GDT_EISA)
-            IStatus = inb((ushort)ha->bmic + EDOORREG);
+            IStatus = inb((u16)ha->bmic + EDOORREG);
         else if (ha->type == GDT_ISA)
             IStatus =
                 readb(&((gdt2_dpram_str __iomem *)ha->brd)->u.ic.Cmd_Index);
@@ -1329,7 +1329,7 @@ static int gdth_get_cmd_index(gdth_ha_str *ha)
         if (ha->cmd_tab[i].cmnd == UNUSED_CMND) {
             ha->cmd_tab[i].cmnd = ha->pccb->RequestBuffer;
             ha->cmd_tab[i].service = ha->pccb->Service;
-            ha->pccb->CommandIndex = (ulong32)i+2;
+            ha->pccb->CommandIndex = (u32)i+2;
             return (i+2);
         }
     }
@@ -1362,7 +1362,7 @@ static void gdth_copy_command(gdth_ha_str *ha)
     register gdt6c_dpram_str __iomem *dp6c_ptr;
     gdt6_dpram_str __iomem *dp6_ptr;
     gdt2_dpram_str __iomem *dp2_ptr;
-    ushort cp_count,dp_offset,cmd_no;
+    u16 cp_count,dp_offset,cmd_no;
     
     TRACE(("gdth_copy_command() hanum %d\n", ha->hanum));
 
@@ -1386,28 +1386,28 @@ static void gdth_copy_command(gdth_ha_str *ha)
         dp2_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp2_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp2_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp2_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCI) {
         dp6_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp6_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp6_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp6_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCINEW) {
         dp6c_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp6c_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp6c_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp6c_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     } else if (ha->type == GDT_PCIMPR) {
         dp6m_ptr = ha->brd;
         writew(dp_offset + DPMEM_COMMAND_OFFSET,
                     &dp6m_ptr->u.ic.comm_queue[cmd_no].offset);
-        writew((ushort)cmd_ptr->Service,
+        writew((u16)cmd_ptr->Service,
                     &dp6m_ptr->u.ic.comm_queue[cmd_no].serv_id);
         memcpy_toio(&dp6m_ptr->u.ic.gdt_dpr_cmd[dp_offset],cmd_ptr,cp_count);
     }
@@ -1420,14 +1420,14 @@ static void gdth_release_event(gdth_ha_str *ha)
 
 #ifdef GDTH_STATISTICS
     {
-        ulong32 i,j;
+        u32 i,j;
         for (i=0,j=0; j<GDTH_MAXCMDS; ++j) {
             if (ha->cmd_tab[j].cmnd != UNUSED_CMND)
                 ++i;
         }
         if (max_index < i) {
             max_index = i;
-            TRACE3(("GDT: max_index = %d\n",(ushort)i));
+            TRACE3(("GDT: max_index = %d\n",(u16)i));
         }
     }
 #endif
@@ -1450,7 +1450,7 @@ static void gdth_release_event(gdth_ha_str *ha)
     }
 }
 
-static int gdth_wait(gdth_ha_str *ha, int index, ulong32 time)
+static int gdth_wait(gdth_ha_str *ha, int index, u32 time)
 {
     int answer_found = FALSE;
     int wait_index = 0;
@@ -1476,8 +1476,8 @@ static int gdth_wait(gdth_ha_str *ha, int index, ulong32 time)
 }
 
 
-static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
-                                            ulong32 p1, ulong64 p2, ulong64 p3)
+static int gdth_internal_cmd(gdth_ha_str *ha, u8 service, u16 opcode,
+                                            u32 p1, u64 p2, u64 p3)
 {
     register gdth_cmd_str *cmd_ptr;
     int retries,index;
@@ -1501,35 +1501,35 @@ static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
         if (service == CACHESERVICE) {
             if (opcode == GDT_IOCTL) {
                 cmd_ptr->u.ioctl.subfunc = p1;
-                cmd_ptr->u.ioctl.channel = (ulong32)p2;
-                cmd_ptr->u.ioctl.param_size = (ushort)p3;
+                cmd_ptr->u.ioctl.channel = (u32)p2;
+                cmd_ptr->u.ioctl.param_size = (u16)p3;
                 cmd_ptr->u.ioctl.p_param = ha->scratch_phys;
             } else {
                 if (ha->cache_feat & GDT_64BIT) {
-                    cmd_ptr->u.cache64.DeviceNo = (ushort)p1;
+                    cmd_ptr->u.cache64.DeviceNo = (u16)p1;
                     cmd_ptr->u.cache64.BlockNo  = p2;
                 } else {
-                    cmd_ptr->u.cache.DeviceNo = (ushort)p1;
-                    cmd_ptr->u.cache.BlockNo  = (ulong32)p2;
+                    cmd_ptr->u.cache.DeviceNo = (u16)p1;
+                    cmd_ptr->u.cache.BlockNo  = (u32)p2;
                 }
             }
         } else if (service == SCSIRAWSERVICE) {
             if (ha->raw_feat & GDT_64BIT) {
                 cmd_ptr->u.raw64.direction  = p1;
-                cmd_ptr->u.raw64.bus        = (unchar)p2;
-                cmd_ptr->u.raw64.target     = (unchar)p3;
-                cmd_ptr->u.raw64.lun        = (unchar)(p3 >> 8);
+                cmd_ptr->u.raw64.bus        = (u8)p2;
+                cmd_ptr->u.raw64.target     = (u8)p3;
+                cmd_ptr->u.raw64.lun        = (u8)(p3 >> 8);
             } else {
                 cmd_ptr->u.raw.direction  = p1;
-                cmd_ptr->u.raw.bus        = (unchar)p2;
-                cmd_ptr->u.raw.target     = (unchar)p3;
-                cmd_ptr->u.raw.lun        = (unchar)(p3 >> 8);
+                cmd_ptr->u.raw.bus        = (u8)p2;
+                cmd_ptr->u.raw.target     = (u8)p3;
+                cmd_ptr->u.raw.lun        = (u8)(p3 >> 8);
             }
         } else if (service == SCREENSERVICE) {
             if (opcode == GDT_REALTIME) {
-                *(ulong32 *)&cmd_ptr->u.screen.su.data[0] = p1;
-                *(ulong32 *)&cmd_ptr->u.screen.su.data[4] = (ulong32)p2;
-                *(ulong32 *)&cmd_ptr->u.screen.su.data[8] = (ulong32)p3;
+                *(u32 *)&cmd_ptr->u.screen.su.data[0] = p1;
+                *(u32 *)&cmd_ptr->u.screen.su.data[4] = (u32)p2;
+                *(u32 *)&cmd_ptr->u.screen.su.data[8] = (u32)p3;
             }
         }
         ha->cmd_len          = sizeof(gdth_cmd_str);
@@ -1555,9 +1555,9 @@ static int gdth_internal_cmd(gdth_ha_str *ha, unchar service, ushort opcode,
 
 static int __devinit gdth_search_drives(gdth_ha_str *ha)
 {
-    ushort cdev_cnt, i;
+    u16 cdev_cnt, i;
     int ok;
-    ulong32 bus_no, drv_cnt, drv_no, j;
+    u32 bus_no, drv_cnt, drv_no, j;
     gdth_getch_str *chn;
     gdth_drlist_str *drl;
     gdth_iochan_str *ioc;
@@ -1570,8 +1570,8 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
 #endif
 
 #ifdef GDTH_RTC
-    unchar rtc[12];
-    ulong flags;
+    u8 rtc[12];
+    unsigned long flags;
 #endif     
    
     TRACE(("gdth_search_drives() hanum %d\n", ha->hanum));
@@ -1584,7 +1584,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (ok)
             ha->screen_feat = GDT_64BIT;
     }
-    if (force_dma32 || (!ok && ha->status == (ushort)S_NOFUNC))
+    if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
         ok = gdth_internal_cmd(ha, SCREENSERVICE, GDT_INIT, 0, 0, 0);
     if (!ok) {
         printk("GDT-HA %d: Initialization error screen service (code %d)\n",
@@ -1609,11 +1609,11 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
             rtc[j] = CMOS_READ(j);
     } while (rtc[0] != CMOS_READ(0));
     spin_unlock_irqrestore(&rtc_lock, flags);
-    TRACE2(("gdth_search_drives(): RTC: %x/%x/%x\n",*(ulong32 *)&rtc[0],
-            *(ulong32 *)&rtc[4], *(ulong32 *)&rtc[8]));
+    TRACE2(("gdth_search_drives(): RTC: %x/%x/%x\n",*(u32 *)&rtc[0],
+            *(u32 *)&rtc[4], *(u32 *)&rtc[8]));
     /* 3. send to controller firmware */
-    gdth_internal_cmd(ha, SCREENSERVICE, GDT_REALTIME, *(ulong32 *)&rtc[0],
-                      *(ulong32 *)&rtc[4], *(ulong32 *)&rtc[8]);
+    gdth_internal_cmd(ha, SCREENSERVICE, GDT_REALTIME, *(u32 *)&rtc[0],
+                      *(u32 *)&rtc[4], *(u32 *)&rtc[8]);
 #endif  
  
     /* unfreeze all IOs */
@@ -1627,7 +1627,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (ok)
             ha->cache_feat = GDT_64BIT;
     }
-    if (force_dma32 || (!ok && ha->status == (ushort)S_NOFUNC))
+    if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
         ok = gdth_internal_cmd(ha, CACHESERVICE, GDT_INIT, LINUX_OS, 0, 0);
     if (!ok) {
         printk("GDT-HA %d: Initialization error cache service (code %d)\n",
@@ -1635,7 +1635,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         return 0;
     }
     TRACE2(("gdth_search_drives(): CACHESERVICE initialized\n"));
-    cdev_cnt = (ushort)ha->info;
+    cdev_cnt = (u16)ha->info;
     ha->fw_vers = ha->service;
 
 #ifdef INT_COAL
@@ -1644,7 +1644,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         pmod = (gdth_perf_modes *)ha->pscratch;
         pmod->version          = 1;
         pmod->st_mode          = 1;    /* enable one status buffer */
-        *((ulong64 *)&pmod->st_buff_addr1) = ha->coal_stat_phys;
+        *((u64 *)&pmod->st_buff_addr1) = ha->coal_stat_phys;
         pmod->st_buff_indx1    = COALINDEX;
         pmod->st_buff_addr2    = 0;
         pmod->st_buff_u_addr2  = 0;
@@ -1705,7 +1705,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
             else
                 ha->bus_id[bus_no] = 0xff;
         }       
-        ha->bus_cnt = (unchar)bus_no;
+        ha->bus_cnt = (u8)bus_no;
     }
     TRACE2(("gdth_search_drives() %d channels\n",ha->bus_cnt));
 
@@ -1789,12 +1789,12 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
 
         /* logical drives */
         if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_DRV_CNT,
-                              INVALID_CHANNEL,sizeof(ulong32))) {
-            drv_cnt = *(ulong32 *)ha->pscratch;
+                              INVALID_CHANNEL,sizeof(u32))) {
+            drv_cnt = *(u32 *)ha->pscratch;
             if (gdth_internal_cmd(ha, CACHESERVICE, GDT_IOCTL, CACHE_DRV_LIST,
-                                  INVALID_CHANNEL,drv_cnt * sizeof(ulong32))) {
+                                  INVALID_CHANNEL,drv_cnt * sizeof(u32))) {
                 for (j = 0; j < drv_cnt; ++j) {
-                    drv_no = ((ulong32 *)ha->pscratch)[j];
+                    drv_no = ((u32 *)ha->pscratch)[j];
                     if (drv_no < MAX_LDRIVES) {
                         ha->hdr[drv_no].is_logdrv = TRUE;
                         TRACE2(("Drive %d is log. drive\n",drv_no));
@@ -1838,7 +1838,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (ok)
             ha->raw_feat = GDT_64BIT;
     }
-    if (force_dma32 || (!ok && ha->status == (ushort)S_NOFUNC))
+    if (force_dma32 || (!ok && ha->status == (u16)S_NOFUNC))
         ok = gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_INIT, 0, 0, 0);
     if (!ok) {
         printk("GDT-HA %d: Initialization error raw service (code %d)\n",
@@ -1854,7 +1854,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (gdth_internal_cmd(ha, SCSIRAWSERVICE, GDT_GET_FEAT, 0, 0, 0)) {
             TRACE2(("gdth_search_dr(): get feat RAWSERVICE %d\n",
                     ha->info));
-            ha->raw_feat |= (ushort)ha->info;
+            ha->raw_feat |= (u16)ha->info;
         }
     } 
 
@@ -1865,7 +1865,7 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
         if (gdth_internal_cmd(ha, CACHESERVICE, GDT_GET_FEAT, 0, 0, 0)) {
             TRACE2(("gdth_search_dr(): get feat CACHESERV. %d\n",
                     ha->info));
-            ha->cache_feat |= (ushort)ha->info;
+            ha->cache_feat |= (u16)ha->info;
         }
     }
 
@@ -1923,9 +1923,9 @@ static int __devinit gdth_search_drives(gdth_ha_str *ha)
     return 1;
 }
 
-static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
+static int gdth_analyse_hdrive(gdth_ha_str *ha, u16 hdrive)
 {
-    ulong32 drv_cyls;
+    u32 drv_cyls;
     int drv_hds, drv_secs;
 
     TRACE(("gdth_analyse_hdrive() hanum %d drive %d\n", ha->hanum, hdrive));
@@ -1944,17 +1944,17 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
     } else {
         drv_hds = ha->info2 & 0xff;
         drv_secs = (ha->info2 >> 8) & 0xff;
-        drv_cyls = (ulong32)ha->hdr[hdrive].size / drv_hds / drv_secs;
+        drv_cyls = (u32)ha->hdr[hdrive].size / drv_hds / drv_secs;
     }
-    ha->hdr[hdrive].heads = (unchar)drv_hds;
-    ha->hdr[hdrive].secs  = (unchar)drv_secs;
+    ha->hdr[hdrive].heads = (u8)drv_hds;
+    ha->hdr[hdrive].secs  = (u8)drv_secs;
     /* round size */
     ha->hdr[hdrive].size  = drv_cyls * drv_hds * drv_secs;
     
     if (ha->cache_feat & GDT_64BIT) {
         if (gdth_internal_cmd(ha, CACHESERVICE, GDT_X_INFO, hdrive, 0, 0)
             && ha->info2 != 0) {
-            ha->hdr[hdrive].size = ((ulong64)ha->info2 << 32) | ha->info;
+            ha->hdr[hdrive].size = ((u64)ha->info2 << 32) | ha->info;
         }
     }
     TRACE2(("gdth_search_dr() cdr. %d size %d hds %d scs %d\n",
@@ -1964,7 +1964,7 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
     if (gdth_internal_cmd(ha, CACHESERVICE, GDT_DEVTYPE, hdrive, 0, 0)) {
         TRACE2(("gdth_search_dr() cache drive %d devtype %d\n",
                 hdrive,ha->info));
-        ha->hdr[hdrive].devtype = (ushort)ha->info;
+        ha->hdr[hdrive].devtype = (u16)ha->info;
     }
 
     /* cluster info */
@@ -1972,14 +1972,14 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
         TRACE2(("gdth_search_dr() cache drive %d cluster info %d\n",
                 hdrive,ha->info));
         if (!shared_access)
-            ha->hdr[hdrive].cluster_type = (unchar)ha->info;
+            ha->hdr[hdrive].cluster_type = (u8)ha->info;
     }
 
     /* R/W attributes */
     if (gdth_internal_cmd(ha, CACHESERVICE, GDT_RW_ATTRIBS, hdrive, 0, 0)) {
         TRACE2(("gdth_search_dr() cache drive %d r/w attrib. %d\n",
                 hdrive,ha->info));
-        ha->hdr[hdrive].rw_attribs = (unchar)ha->info;
+        ha->hdr[hdrive].rw_attribs = (u8)ha->info;
     }
 
     return 1;
@@ -1988,12 +1988,12 @@ static int gdth_analyse_hdrive(gdth_ha_str *ha, ushort hdrive)
 
 /* command queueing/sending functions */
 
-static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority)
+static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 priority)
 {
     struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
     register Scsi_Cmnd *pscp;
     register Scsi_Cmnd *nscp;
-    ulong flags;
+    unsigned long flags;
 
     TRACE(("gdth_putq() priority %d\n",priority));
     spin_lock_irqsave(&ha->smp_lock, flags);
@@ -2023,7 +2023,7 @@ static void gdth_putq(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar priority)
         ++flags;
     if (max_rq < flags) {
         max_rq = flags;
-        TRACE3(("GDT: max_rq = %d\n",(ushort)max_rq));
+        TRACE3(("GDT: max_rq = %d\n",(u16)max_rq));
     }
 #endif
 }
@@ -2032,9 +2032,9 @@ static void gdth_next(gdth_ha_str *ha)
 {
     register Scsi_Cmnd *pscp;
     register Scsi_Cmnd *nscp;
-    unchar b, t, l, firsttime;
-    unchar this_cmd, next_cmd;
-    ulong flags = 0;
+    u8 b, t, l, firsttime;
+    u8 this_cmd, next_cmd;
+    unsigned long flags = 0;
     int cmd_index;
 
     TRACE(("gdth_next() hanum %d\n", ha->hanum));
@@ -2282,20 +2282,20 @@ static void gdth_next(gdth_ha_str *ha)
  * buffers, kmap_atomic() as needed.
  */
 static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp,
-                                    char *buffer, ushort count)
+                                    char *buffer, u16 count)
 {
-    ushort cpcount,i, max_sg = scsi_sg_count(scp);
-    ushort cpsum,cpnow;
+    u16 cpcount,i, max_sg = scsi_sg_count(scp);
+    u16 cpsum,cpnow;
     struct scatterlist *sl;
     char *address;
 
-    cpcount = min_t(ushort, count, scsi_bufflen(scp));
+    cpcount = min_t(u16, count, scsi_bufflen(scp));
 
     if (cpcount) {
         cpsum=0;
         scsi_for_each_sg(scp, sl, max_sg, i) {
             unsigned long flags;
-            cpnow = (ushort)sl->length;
+            cpnow = (u16)sl->length;
             TRACE(("copy_internal() now %d sum %d count %d %d\n",
                           cpnow, cpsum, cpcount, scsi_bufflen(scp)));
             if (cpsum+cpnow > cpcount) 
@@ -2325,7 +2325,7 @@ static void gdth_copy_internal_data(gdth_ha_str *ha, Scsi_Cmnd *scp,
 
 static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
 {
-    unchar t;
+    u8 t;
     gdth_inq_data inq;
     gdth_rdcap_data rdc;
     gdth_sense_data sd;
@@ -2389,7 +2389,7 @@ static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
 
       case READ_CAPACITY:
         TRACE2(("Read capacity hdrive %d\n",t));
-        if (ha->hdr[t].size > (ulong64)0xffffffff)
+        if (ha->hdr[t].size > (u64)0xffffffff)
             rdc.last_block_no = 0xffffffff;
         else
             rdc.last_block_no = cpu_to_be32(ha->hdr[t].size-1);
@@ -2425,12 +2425,12 @@ static int gdth_internal_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
     return 0;
 }
 
-static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
+static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u16 hdrive)
 {
     register gdth_cmd_str *cmdp;
     struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
-    ulong32 cnt, blockcnt;
-    ulong64 no, blockno;
+    u32 cnt, blockcnt;
+    u64 no, blockno;
     int i, cmd_index, read_write, sgcnt, mode64;
 
     cmdp = ha->pccb;
@@ -2498,17 +2498,17 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
 
     if (read_write) {
         if (scp->cmd_len == 16) {
-            memcpy(&no, &scp->cmnd[2], sizeof(ulong64));
+            memcpy(&no, &scp->cmnd[2], sizeof(u64));
             blockno = be64_to_cpu(no);
-            memcpy(&cnt, &scp->cmnd[10], sizeof(ulong32));
+            memcpy(&cnt, &scp->cmnd[10], sizeof(u32));
             blockcnt = be32_to_cpu(cnt);
         } else if (scp->cmd_len == 10) {
-            memcpy(&no, &scp->cmnd[2], sizeof(ulong32));
+            memcpy(&no, &scp->cmnd[2], sizeof(u32));
             blockno = be32_to_cpu(no);
-            memcpy(&cnt, &scp->cmnd[7], sizeof(ushort));
+            memcpy(&cnt, &scp->cmnd[7], sizeof(u16));
             blockcnt = be16_to_cpu(cnt);
         } else {
-            memcpy(&no, &scp->cmnd[0], sizeof(ulong32));
+            memcpy(&no, &scp->cmnd[0], sizeof(u32));
             blockno = be32_to_cpu(no) & 0x001fffffUL;
             blockcnt= scp->cmnd[4]==0 ? 0x100 : scp->cmnd[4];
         }
@@ -2516,7 +2516,7 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
             cmdp->u.cache64.BlockNo = blockno;
             cmdp->u.cache64.BlockCnt = blockcnt;
         } else {
-            cmdp->u.cache.BlockNo = (ulong32)blockno;
+            cmdp->u.cache.BlockNo = (u32)blockno;
             cmdp->u.cache.BlockCnt = blockcnt;
         }
 
@@ -2528,12 +2528,12 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
             if (mode64) {
                 struct scatterlist *sl;
 
-                cmdp->u.cache64.DestAddr= (ulong64)-1;
+                cmdp->u.cache64.DestAddr= (u64)-1;
                 cmdp->u.cache64.sg_canz = sgcnt;
                 scsi_for_each_sg(scp, sl, sgcnt, i) {
                     cmdp->u.cache64.sg_lst[i].sg_ptr = sg_dma_address(sl);
 #ifdef GDTH_DMA_STATISTICS
-                    if (cmdp->u.cache64.sg_lst[i].sg_ptr > (ulong64)0xffffffff)
+                    if (cmdp->u.cache64.sg_lst[i].sg_ptr > (u64)0xffffffff)
                         ha->dma64_cnt++;
                     else
                         ha->dma32_cnt++;
@@ -2555,8 +2555,8 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
             }
 
 #ifdef GDTH_STATISTICS
-            if (max_sg < (ulong32)sgcnt) {
-                max_sg = (ulong32)sgcnt;
+            if (max_sg < (u32)sgcnt) {
+                max_sg = (u32)sgcnt;
                 TRACE3(("GDT: max_sg = %d\n",max_sg));
             }
 #endif
@@ -2572,7 +2572,7 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
         TRACE(("cache cmd: cmd %d blockno. %d, blockcnt %d\n",
                cmdp->OpCode,cmdp->u.cache64.BlockNo,cmdp->u.cache64.BlockCnt));
         ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache64.sg_lst) +
-            (ushort)cmdp->u.cache64.sg_canz * sizeof(gdth_sg64_str);
+            (u16)cmdp->u.cache64.sg_canz * sizeof(gdth_sg64_str);
     } else {
         TRACE(("cache cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
                cmdp->u.cache.DestAddr,cmdp->u.cache.sg_canz,
@@ -2581,7 +2581,7 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
         TRACE(("cache cmd: cmd %d blockno. %d, blockcnt %d\n",
                cmdp->OpCode,cmdp->u.cache.BlockNo,cmdp->u.cache.BlockCnt));
         ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.cache.sg_lst) +
-            (ushort)cmdp->u.cache.sg_canz * sizeof(gdth_sg_str);
+            (u16)cmdp->u.cache.sg_canz * sizeof(gdth_sg_str);
     }
     if (ha->cmd_len & 3)
         ha->cmd_len += (4 - (ha->cmd_len & 3));
@@ -2600,15 +2600,15 @@ static int gdth_fill_cache_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, ushort hdrive)
     return cmd_index;
 }
 
-static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
+static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, u8 b)
 {
     register gdth_cmd_str *cmdp;
-    ushort i;
+    u16 i;
     dma_addr_t sense_paddr;
     int cmd_index, sgcnt, mode64;
-    unchar t,l;
+    u8 t,l;
     struct page *page;
-    ulong offset;
+    unsigned long offset;
     struct gdth_cmndinfo *cmndinfo;
 
     t = scp->device->id;
@@ -2654,7 +2654,7 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
 
     } else {
         page = virt_to_page(scp->sense_buffer);
-        offset = (ulong)scp->sense_buffer & ~PAGE_MASK;
+        offset = (unsigned long)scp->sense_buffer & ~PAGE_MASK;
         sense_paddr = pci_map_page(ha->pdev,page,offset,
                                    16,PCI_DMA_FROMDEVICE);
 
@@ -2703,12 +2703,12 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
             if (mode64) {
                 struct scatterlist *sl;
 
-                cmdp->u.raw64.sdata = (ulong64)-1;
+                cmdp->u.raw64.sdata = (u64)-1;
                 cmdp->u.raw64.sg_ranz = sgcnt;
                 scsi_for_each_sg(scp, sl, sgcnt, i) {
                     cmdp->u.raw64.sg_lst[i].sg_ptr = sg_dma_address(sl);
 #ifdef GDTH_DMA_STATISTICS
-                    if (cmdp->u.raw64.sg_lst[i].sg_ptr > (ulong64)0xffffffff)
+                    if (cmdp->u.raw64.sg_lst[i].sg_ptr > (u64)0xffffffff)
                         ha->dma64_cnt++;
                     else
                         ha->dma32_cnt++;
@@ -2744,7 +2744,7 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
                    cmdp->u.raw64.sg_lst[0].sg_len));
             /* evaluate command size */
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw64.sg_lst) +
-                (ushort)cmdp->u.raw64.sg_ranz * sizeof(gdth_sg64_str);
+                (u16)cmdp->u.raw64.sg_ranz * sizeof(gdth_sg64_str);
         } else {
             TRACE(("raw cmd: addr. %x sganz %x sgptr0 %x sglen0 %x\n",
                    cmdp->u.raw.sdata,cmdp->u.raw.sg_ranz,
@@ -2752,7 +2752,7 @@ static int gdth_fill_raw_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp, unchar b)
                    cmdp->u.raw.sg_lst[0].sg_len));
             /* evaluate command size */
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.raw.sg_lst) +
-                (ushort)cmdp->u.raw.sg_ranz * sizeof(gdth_sg_str);
+                (u16)cmdp->u.raw.sg_ranz * sizeof(gdth_sg_str);
         }
     }
     /* check space */
@@ -2802,7 +2802,7 @@ static int gdth_special_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
     if (cmdp->OpCode == GDT_IOCTL) {
         TRACE2(("IOCTL\n"));
         ha->cmd_len = 
-            GDTOFFSOF(gdth_cmd_str,u.ioctl.p_param) + sizeof(ulong64);
+            GDTOFFSOF(gdth_cmd_str,u.ioctl.p_param) + sizeof(u64);
     } else if (cmdp->Service == CACHESERVICE) {
         TRACE2(("cache command %d\n",cmdp->OpCode));
         if (ha->cache_feat & GDT_64BIT)
@@ -2840,8 +2840,8 @@ static int gdth_special_cmd(gdth_ha_str *ha, Scsi_Cmnd *scp)
 
 
 /* Controller event handling functions */
-static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, ushort source, 
-                                      ushort idx, gdth_evt_data *evt)
+static gdth_evt_str *gdth_store_event(gdth_ha_str *ha, u16 source, 
+                                      u16 idx, gdth_evt_data *evt)
 {
     gdth_evt_str *e;
     struct timeval tv;
@@ -2890,7 +2890,7 @@ static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr)
 {
     gdth_evt_str *e;
     int eindex;
-    ulong flags;
+    unsigned long flags;
 
     TRACE2(("gdth_read_event() handle %d\n", handle));
     spin_lock_irqsave(&ha->smp_lock, flags);
@@ -2919,12 +2919,12 @@ static int gdth_read_event(gdth_ha_str *ha, int handle, gdth_evt_str *estr)
 }
 
 static void gdth_readapp_event(gdth_ha_str *ha,
-                               unchar application, gdth_evt_str *estr)
+                               u8 application, gdth_evt_str *estr)
 {
     gdth_evt_str *e;
     int eindex;
-    ulong flags;
-    unchar found = FALSE;
+    unsigned long flags;
+    u8 found = FALSE;
 
     TRACE2(("gdth_readapp_event() app. %d\n", application));
     spin_lock_irqsave(&ha->smp_lock, flags);
@@ -2969,9 +2969,9 @@ static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
     gdt2_dpram_str __iomem *dp2_ptr;
     Scsi_Cmnd *scp;
     int rval, i;
-    unchar IStatus;
-    ushort Service;
-    ulong flags = 0;
+    u8 IStatus;
+    u16 Service;
+    unsigned long flags = 0;
 #ifdef INT_COAL
     int coalesced = FALSE;
     int next = FALSE;
@@ -3018,7 +3018,7 @@ static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
         if (coalesced) {
             /* For coalesced requests all status
                information is found in the status buffer */
-            IStatus = (unchar)(pcs->status & 0xff);
+            IStatus = (u8)(pcs->status & 0xff);
         }
 #endif
     
@@ -3197,7 +3197,7 @@ static irqreturn_t __gdth_interrupt(gdth_ha_str *ha,
             ++act_int_coal;
             if (act_int_coal > max_int_coal) {
                 max_int_coal = act_int_coal;
-                printk("GDT: max_int_coal = %d\n",(ushort)max_int_coal);
+                printk("GDT: max_int_coal = %d\n",(u16)max_int_coal);
             }
 #endif      
             /* see if there is another status */
@@ -3225,12 +3225,12 @@ static irqreturn_t gdth_interrupt(int irq, void *dev_id)
         return __gdth_interrupt(ha, false, NULL);
 }
 
-static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
+static int gdth_sync_event(gdth_ha_str *ha, int service, u8 index,
                                                               Scsi_Cmnd *scp)
 {
     gdth_msg_str *msg;
     gdth_cmd_str *cmdp;
-    unchar b, t;
+    u8 b, t;
     struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
 
     cmdp = ha->pccb;
@@ -3263,7 +3263,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
             cmdp->u.screen.su.msg.msg_addr  = ha->msg_phys;
             ha->cmd_offs_dpmem = 0;
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr) 
-                + sizeof(ulong64);
+                + sizeof(u64);
             ha->cmd_cnt = 0;
             gdth_copy_command(ha);
             gdth_release_event(ha);
@@ -3297,7 +3297,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
             cmdp->u.screen.su.msg.msg_addr  = ha->msg_phys;
             ha->cmd_offs_dpmem = 0;
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr) 
-                + sizeof(ulong64);
+                + sizeof(u64);
             ha->cmd_cnt = 0;
             gdth_copy_command(ha);
             gdth_release_event(ha);
@@ -3335,7 +3335,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
                         cmndinfo->OpCode));
                 /* special commands GDT_CLUST_INFO/GDT_MOUNT ? */
                 if (cmndinfo->OpCode == GDT_CLUST_INFO) {
-                    ha->hdr[t].cluster_type = (unchar)ha->info;
+                    ha->hdr[t].cluster_type = (u8)ha->info;
                     if (!(ha->hdr[t].cluster_type & 
                         CLUSTER_MOUNTED)) {
                         /* NOT MOUNTED -> MOUNT */
@@ -3397,7 +3397,7 @@ static int gdth_sync_event(gdth_ha_str *ha, int service, unchar index,
                     ha->hdr[t].cluster_type &= ~CLUSTER_RESERVED;
                 }
                 memset((char*)scp->sense_buffer,0,16);
-                if (ha->status == (ushort)S_CACHE_RESERV) {
+                if (ha->status == (u16)S_CACHE_RESERV) {
                     scp->result = (DID_OK << 16) | (RESERVATION_CONFLICT << 1);
                 } else {
                     scp->sense_buffer[0] = 0x70;
@@ -3614,16 +3614,16 @@ static int gdth_async_event(gdth_ha_str *ha)
             cmdp->u.screen.su.msg.msg_addr  = ha->msg_phys;
             ha->cmd_offs_dpmem = 0;
             ha->cmd_len = GDTOFFSOF(gdth_cmd_str,u.screen.su.msg.msg_addr) 
-                + sizeof(ulong64);
+                + sizeof(u64);
             ha->cmd_cnt = 0;
             gdth_copy_command(ha);
             if (ha->type == GDT_EISA)
-                printk("[EISA slot %d] ",(ushort)ha->brd_phys);
+                printk("[EISA slot %d] ",(u16)ha->brd_phys);
             else if (ha->type == GDT_ISA)
-                printk("[DPMEM 0x%4X] ",(ushort)ha->brd_phys);
+                printk("[DPMEM 0x%4X] ",(u16)ha->brd_phys);
             else 
-                printk("[PCI %d/%d] ",(ushort)(ha->brd_phys>>8),
-                       (ushort)((ha->brd_phys>>3)&0x1f));
+                printk("[PCI %d/%d] ",(u16)(ha->brd_phys>>8),
+                       (u16)((ha->brd_phys>>3)&0x1f));
             gdth_release_event(ha);
         }
 
@@ -3640,7 +3640,7 @@ static int gdth_async_event(gdth_ha_str *ha)
             ha->dvr.eu.async.service = ha->service;
             ha->dvr.eu.async.status  = ha->status;
             ha->dvr.eu.async.info    = ha->info;
-            *(ulong32 *)ha->dvr.eu.async.scsi_coord  = ha->info2;
+            *(u32 *)ha->dvr.eu.async.scsi_coord  = ha->info2;
         }
         gdth_store_event( ha, ES_ASYNC, ha->service, &ha->dvr );
         gdth_log_event( &ha->dvr, NULL );
@@ -3648,8 +3648,8 @@ static int gdth_async_event(gdth_ha_str *ha)
         /* new host drive from expand? */
         if (ha->service == CACHESERVICE && ha->status == 56) {
             TRACE2(("gdth_async_event(): new host drive %d created\n",
-                    (ushort)ha->info));
-            /* gdth_analyse_hdrive(hanum, (ushort)ha->info); */
+                    (u16)ha->info));
+            /* gdth_analyse_hdrive(hanum, (u16)ha->info); */
         }   
     }
     return 1;
@@ -3680,13 +3680,13 @@ static void gdth_log_event(gdth_evt_data *dvr, char *buffer)
         for (j=0,i=1; i < f[0]; i+=2) {
             switch (f[i+1]) {
               case 4:
-                stack.b[j++] = *(ulong32*)&dvr->eu.stream[(int)f[i]];
+                stack.b[j++] = *(u32*)&dvr->eu.stream[(int)f[i]];
                 break;
               case 2:
-                stack.b[j++] = *(ushort*)&dvr->eu.stream[(int)f[i]];
+                stack.b[j++] = *(u16*)&dvr->eu.stream[(int)f[i]];
                 break;
               case 1:
-                stack.b[j++] = *(unchar*)&dvr->eu.stream[(int)f[i]];
+                stack.b[j++] = *(u8*)&dvr->eu.stream[(int)f[i]];
                 break;
               default:
                 break;
@@ -3712,14 +3712,14 @@ static void gdth_log_event(gdth_evt_data *dvr, char *buffer)
 }
 
 #ifdef GDTH_STATISTICS
-static unchar   gdth_timer_running;
+static u8       gdth_timer_running;
 
-static void gdth_timeout(ulong data)
+static void gdth_timeout(unsigned long data)
 {
-    ulong32 i;
+    u32 i;
     Scsi_Cmnd *nscp;
     gdth_ha_str *ha;
-    ulong flags;
+    unsigned long flags;
 
     if(unlikely(list_empty(&gdth_instances))) {
             gdth_timer_running = 0;
@@ -3891,8 +3891,8 @@ static enum blk_eh_timer_return gdth_timed_out(struct scsi_cmnd *scp)
 {
         gdth_ha_str *ha = shost_priv(scp->device->host);
         struct gdth_cmndinfo *cmndinfo = gdth_cmnd_priv(scp);
-        unchar b, t;
-        ulong flags;
+        u8 b, t;
+        unsigned long flags;
         enum blk_eh_timer_return retval = BLK_EH_NOT_HANDLED;
 
         TRACE(("%s() cmd 0x%x\n", scp->cmnd[0], __func__));
@@ -3924,9 +3924,9 @@ static int gdth_eh_bus_reset(Scsi_Cmnd *scp)
 {
     gdth_ha_str *ha = shost_priv(scp->device->host);
     int i;
-    ulong flags;
+    unsigned long flags;
     Scsi_Cmnd *cmnd;
-    unchar b;
+    u8 b;
 
     TRACE2(("gdth_eh_bus_reset()\n"));
 
@@ -3974,7 +3974,7 @@ static int gdth_eh_bus_reset(Scsi_Cmnd *scp)
 
 static int gdth_bios_param(struct scsi_device *sdev,struct block_device *bdev,sector_t cap,int *ip)
 {
-    unchar b, t;
+    u8 b, t;
     gdth_ha_str *ha = shost_priv(sdev->host);
     struct scsi_device *sd;
     unsigned capacity;
@@ -4062,7 +4062,7 @@ static int ioc_event(void __user *arg)
 {
     gdth_ioctl_event evt;
     gdth_ha_str *ha;
-    ulong flags;
+    unsigned long flags;
 
     if (copy_from_user(&evt, arg, sizeof(gdth_ioctl_event)))
         return -EFAULT;
@@ -4098,8 +4098,8 @@ static int ioc_event(void __user *arg)
 static int ioc_lockdrv(void __user *arg)
 {
     gdth_ioctl_lockdrv ldrv;
-    unchar i, j;
-    ulong flags;
+    u8 i, j;
+    unsigned long flags;
     gdth_ha_str *ha;
 
     if (copy_from_user(&ldrv, arg, sizeof(gdth_ioctl_lockdrv)))
@@ -4165,7 +4165,7 @@ static int ioc_general(void __user *arg, char *cmnd)
 {
     gdth_ioctl_general gen;
     char *buf = NULL;
-    ulong64 paddr; 
+    u64 paddr; 
     gdth_ha_str *ha;
     int rval;
 
@@ -4194,7 +4194,7 @@ static int ioc_general(void __user *arg, char *cmnd)
                 gen.command.u.cache64.DeviceNo = gen.command.u.cache.DeviceNo;
                 /* addresses */
                 if (ha->cache_feat & SCATTER_GATHER) {
-                    gen.command.u.cache64.DestAddr = (ulong64)-1;
+                    gen.command.u.cache64.DestAddr = (u64)-1;
                     gen.command.u.cache64.sg_canz = 1;
                     gen.command.u.cache64.sg_lst[0].sg_ptr = paddr;
                     gen.command.u.cache64.sg_lst[0].sg_len = gen.data_len;
@@ -4207,7 +4207,7 @@ static int ioc_general(void __user *arg, char *cmnd)
                 if (ha->cache_feat & SCATTER_GATHER) {
                     gen.command.u.cache.DestAddr = 0xffffffff;
                     gen.command.u.cache.sg_canz = 1;
-                    gen.command.u.cache.sg_lst[0].sg_ptr = (ulong32)paddr;
+                    gen.command.u.cache.sg_lst[0].sg_ptr = (u32)paddr;
                     gen.command.u.cache.sg_lst[0].sg_len = gen.data_len;
                     gen.command.u.cache.sg_lst[1].sg_len = 0;
                 } else {
@@ -4230,7 +4230,7 @@ static int ioc_general(void __user *arg, char *cmnd)
                 gen.command.u.raw64.direction = gen.command.u.raw.direction;
                 /* addresses */
                 if (ha->raw_feat & SCATTER_GATHER) {
-                    gen.command.u.raw64.sdata = (ulong64)-1;
+                    gen.command.u.raw64.sdata = (u64)-1;
                     gen.command.u.raw64.sg_ranz = 1;
                     gen.command.u.raw64.sg_lst[0].sg_ptr = paddr;
                     gen.command.u.raw64.sg_lst[0].sg_len = gen.data_len;
@@ -4244,14 +4244,14 @@ static int ioc_general(void __user *arg, char *cmnd)
                 if (ha->raw_feat & SCATTER_GATHER) {
                     gen.command.u.raw.sdata = 0xffffffff;
                     gen.command.u.raw.sg_ranz = 1;
-                    gen.command.u.raw.sg_lst[0].sg_ptr = (ulong32)paddr;
+                    gen.command.u.raw.sg_lst[0].sg_ptr = (u32)paddr;
                     gen.command.u.raw.sg_lst[0].sg_len = gen.data_len;
                     gen.command.u.raw.sg_lst[1].sg_len = 0;
                 } else {
                     gen.command.u.raw.sdata = paddr;
                     gen.command.u.raw.sg_ranz = 0;
                 }
-                gen.command.u.raw.sense_data = (ulong32)paddr + gen.data_len;
+                gen.command.u.raw.sense_data = (u32)paddr + gen.data_len;
             }
         } else {
             gdth_ioctl_free(ha, gen.data_len+gen.sense_len, buf, paddr);
@@ -4283,7 +4283,7 @@ static int ioc_hdrlist(void __user *arg, char *cmnd)
     gdth_ioctl_rescan *rsc;
     gdth_cmd_str *cmd;
     gdth_ha_str *ha;
-    unchar i;
+    u8 i;
     int rc = -ENOMEM;
     u32 cluster_type = 0;
 
@@ -4335,11 +4335,11 @@ static int ioc_rescan(void __user *arg, char *cmnd)
 {
     gdth_ioctl_rescan *rsc;
     gdth_cmd_str *cmd;
-    ushort i, status, hdr_cnt;
-    ulong32 info;
+    u16 i, status, hdr_cnt;
+    u32 info;
     int cyls, hds, secs;
     int rc = -ENOMEM;
-    ulong flags;
+    unsigned long flags;
     gdth_ha_str *ha; 
 
     rsc = kmalloc(sizeof(*rsc), GFP_KERNEL);
@@ -4367,7 +4367,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
 
         status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
         i = 0;
-        hdr_cnt = (status == S_OK ? (ushort)info : 0);
+        hdr_cnt = (status == S_OK ? (u16)info : 0);
     } else {
         i = rsc->hdr_no;
         hdr_cnt = i + 1;
@@ -4418,7 +4418,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
         status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
 
         spin_lock_irqsave(&ha->smp_lock, flags);
-        ha->hdr[i].devtype = (status == S_OK ? (ushort)info : 0);
+        ha->hdr[i].devtype = (status == S_OK ? (u16)info : 0);
         spin_unlock_irqrestore(&ha->smp_lock, flags);
 
         cmd->Service = CACHESERVICE;
@@ -4432,7 +4432,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
 
         spin_lock_irqsave(&ha->smp_lock, flags);
         ha->hdr[i].cluster_type = 
-            ((status == S_OK && !shared_access) ? (ushort)info : 0);
+            ((status == S_OK && !shared_access) ? (u16)info : 0);
         spin_unlock_irqrestore(&ha->smp_lock, flags);
         rsc->hdr_list[i].cluster_type = ha->hdr[i].cluster_type;
 
@@ -4446,7 +4446,7 @@ static int ioc_rescan(void __user *arg, char *cmnd)
         status = __gdth_execute(ha->sdev, cmd, cmnd, 30, &info);
 
         spin_lock_irqsave(&ha->smp_lock, flags);
-        ha->hdr[i].rw_attribs = (status == S_OK ? (ushort)info : 0);
+        ha->hdr[i].rw_attribs = (status == S_OK ? (u16)info : 0);
         spin_unlock_irqrestore(&ha->smp_lock, flags);
     }
  
@@ -4466,7 +4466,7 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
 {
     gdth_ha_str *ha; 
     Scsi_Cmnd *scp;
-    ulong flags;
+    unsigned long flags;
     char cmnd[MAX_COMMAND_SIZE];   
     void __user *argp = (void __user *)arg;
 
@@ -4495,9 +4495,9 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
       { 
         gdth_ioctl_osvers osv; 
 
-        osv.version = (unchar)(LINUX_VERSION_CODE >> 16);
-        osv.subversion = (unchar)(LINUX_VERSION_CODE >> 8);
-        osv.revision = (ushort)(LINUX_VERSION_CODE & 0xff);
+        osv.version = (u8)(LINUX_VERSION_CODE >> 16);
+        osv.subversion = (u8)(LINUX_VERSION_CODE >> 8);
+        osv.revision = (u16)(LINUX_VERSION_CODE & 0xff);
         if (copy_to_user(argp, &osv, sizeof(gdth_ioctl_osvers)))
                 return -EFAULT;
         break;
@@ -4512,10 +4512,10 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
             return -EFAULT;
 
         if (ha->type == GDT_ISA || ha->type == GDT_EISA) {
-            ctrt.type = (unchar)((ha->stype>>20) - 0x10);
+            ctrt.type = (u8)((ha->stype>>20) - 0x10);
         } else {
             if (ha->type != GDT_PCIMPR) {
-                ctrt.type = (unchar)((ha->stype<<4) + 6);
+                ctrt.type = (u8)((ha->stype<<4) + 6);
             } else {
                 ctrt.type = 
                     (ha->oem_id == OEM_ID_INTEL ? 0xfd : 0xfe);
@@ -4546,7 +4546,7 @@ static int gdth_ioctl(struct inode *inode, struct file *filep,
       case GDTIOCTL_LOCKCHN:
       {
         gdth_ioctl_lockchn lchn;
-        unchar i, j;
+        u8 i, j;
 
         if (copy_from_user(&lchn, argp, sizeof(gdth_ioctl_lockchn)) ||
             (NULL == (ha = gdth_find_ha(lchn.ionode))))
@@ -4670,7 +4670,7 @@ static struct scsi_host_template gdth_template = {
 };
 
 #ifdef CONFIG_ISA
-static int __init gdth_isa_probe_one(ulong32 isa_bios)
+static int __init gdth_isa_probe_one(u32 isa_bios)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
@@ -4802,7 +4802,7 @@ static int __init gdth_isa_probe_one(ulong32 isa_bios)
 #endif /* CONFIG_ISA */
 
 #ifdef CONFIG_EISA
-static int __init gdth_eisa_probe_one(ushort eisa_slot)
+static int __init gdth_eisa_probe_one(u16 eisa_slot)
 {
         struct Scsi_Host *shp;
         gdth_ha_str *ha;
@@ -5120,7 +5120,7 @@ static void gdth_remove_one(gdth_ha_str *ha)
         scsi_host_put(shp);
 }
 
-static int gdth_halt(struct notifier_block *nb, ulong event, void *buf)
+static int gdth_halt(struct notifier_block *nb, unsigned long event, void *buf)
 {
         gdth_ha_str *ha;
 
@@ -5158,14 +5158,14 @@ static int __init gdth_init(void)
         if (probe_eisa_isa) {
                 /* scanning for controllers, at first: ISA controller */
 #ifdef CONFIG_ISA
-                ulong32 isa_bios;
+                u32 isa_bios;
                 for (isa_bios = 0xc8000UL; isa_bios <= 0xd8000UL;
                                 isa_bios += 0x8000UL)
                         gdth_isa_probe_one(isa_bios);
 #endif
 #ifdef CONFIG_EISA
                 {
-                        ushort eisa_slot;
+                        u16 eisa_slot;
                         for (eisa_slot = 0x1000; eisa_slot <= 0x8000;
                                                  eisa_slot += 0x1000)
                                 gdth_eisa_probe_one(eisa_slot);
diff --git a/drivers/scsi/gdth.h b/drivers/scsi/gdth.h
index 1646444e9bd5..120a0625a7b5 100644
--- a/drivers/scsi/gdth.h
+++ b/drivers/scsi/gdth.h
@@ -321,524 +321,524 @@
 
 /* screenservice message */
 typedef struct {                               
-    ulong32     msg_handle;                     /* message handle */
-    ulong32     msg_len;                        /* size of message */
-    ulong32     msg_alen;                       /* answer length */
-    unchar      msg_answer;                     /* answer flag */
-    unchar      msg_ext;                        /* more messages */
-    unchar      msg_reserved[2];
+    u32     msg_handle;                     /* message handle */
+    u32     msg_len;                        /* size of message */
+    u32     msg_alen;                       /* answer length */
+    u8      msg_answer;                     /* answer flag */
+    u8      msg_ext;                        /* more messages */
+    u8      msg_reserved[2];
     char        msg_text[MSGLEN+2];             /* the message text */
-} PACKED gdth_msg_str;
+} __attribute__((packed)) gdth_msg_str;
 
 
 /* IOCTL data structures */
 
 /* Status coalescing buffer for returning multiple requests per interrupt */
 typedef struct {
-    ulong32     status;
-    ulong32     ext_status;
-    ulong32     info0;
-    ulong32     info1;
-} PACKED gdth_coal_status;
+    u32     status;
+    u32     ext_status;
+    u32     info0;
+    u32     info1;
+} __attribute__((packed)) gdth_coal_status;
 
 /* performance mode data structure */
 typedef struct {
-    ulong32     version;            /* The version of this IOCTL structure. */
-    ulong32     st_mode;            /* 0=dis., 1=st_buf_addr1 valid, 2=both  */
-    ulong32     st_buff_addr1;      /* physical address of status buffer 1 */
-    ulong32     st_buff_u_addr1;    /* reserved for 64 bit addressing */
-    ulong32     st_buff_indx1;      /* reserved command idx. for this buffer */
-    ulong32     st_buff_addr2;      /* physical address of status buffer 1 */
-    ulong32     st_buff_u_addr2;    /* reserved for 64 bit addressing */
-    ulong32     st_buff_indx2;      /* reserved command idx. for this buffer */
-    ulong32     st_buff_size;       /* size of each buffer in bytes */
-    ulong32     cmd_mode;           /* 0 = mode disabled, 1 = cmd_buff_addr1 */ 
-    ulong32     cmd_buff_addr1;     /* physical address of cmd buffer 1 */   
-    ulong32     cmd_buff_u_addr1;   /* reserved for 64 bit addressing */
-    ulong32     cmd_buff_indx1;     /* cmd buf addr1 unique identifier */
-    ulong32     cmd_buff_addr2;     /* physical address of cmd buffer 1 */   
-    ulong32     cmd_buff_u_addr2;   /* reserved for 64 bit addressing */
-    ulong32     cmd_buff_indx2;     /* cmd buf addr1 unique identifier */
-    ulong32     cmd_buff_size;      /* size of each cmd bufer in bytes */
-    ulong32     reserved1;
-    ulong32     reserved2;
-} PACKED gdth_perf_modes;
+    u32     version;            /* The version of this IOCTL structure. */
+    u32     st_mode;            /* 0=dis., 1=st_buf_addr1 valid, 2=both  */
+    u32     st_buff_addr1;      /* physical address of status buffer 1 */
+    u32     st_buff_u_addr1;    /* reserved for 64 bit addressing */
+    u32     st_buff_indx1;      /* reserved command idx. for this buffer */
+    u32     st_buff_addr2;      /* physical address of status buffer 1 */
+    u32     st_buff_u_addr2;    /* reserved for 64 bit addressing */
+    u32     st_buff_indx2;      /* reserved command idx. for this buffer */
+    u32     st_buff_size;       /* size of each buffer in bytes */
+    u32     cmd_mode;           /* 0 = mode disabled, 1 = cmd_buff_addr1 */ 
+    u32     cmd_buff_addr1;     /* physical address of cmd buffer 1 */   
+    u32     cmd_buff_u_addr1;   /* reserved for 64 bit addressing */
+    u32     cmd_buff_indx1;     /* cmd buf addr1 unique identifier */
+    u32     cmd_buff_addr2;     /* physical address of cmd buffer 1 */   
+    u32     cmd_buff_u_addr2;   /* reserved for 64 bit addressing */
+    u32     cmd_buff_indx2;     /* cmd buf addr1 unique identifier */
+    u32     cmd_buff_size;      /* size of each cmd bufer in bytes */
+    u32     reserved1;
+    u32     reserved2;
+} __attribute__((packed)) gdth_perf_modes;
 
 /* SCSI drive info */
 typedef struct {
-    unchar      vendor[8];                      /* vendor string */
-    unchar      product[16];                    /* product string */
-    unchar      revision[4];                    /* revision */
-    ulong32     sy_rate;                        /* current rate for sync. tr. */
-    ulong32     sy_max_rate;                    /* max. rate for sync. tr. */
-    ulong32     no_ldrive;                      /* belongs to this log. drv.*/
-    ulong32     blkcnt;                         /* number of blocks */
-    ushort      blksize;                        /* size of block in bytes */
-    unchar      available;                      /* flag: access is available */
-    unchar      init;                           /* medium is initialized */
-    unchar      devtype;                        /* SCSI devicetype */
-    unchar      rm_medium;                      /* medium is removable */
-    unchar      wp_medium;                      /* medium is write protected */
-    unchar      ansi;                           /* SCSI I/II or III? */
-    unchar      protocol;                       /* same as ansi */
-    unchar      sync;                           /* flag: sync. transfer enab. */
-    unchar      disc;                           /* flag: disconnect enabled */
-    unchar      queueing;                       /* flag: command queing enab. */
-    unchar      cached;                         /* flag: caching enabled */
-    unchar      target_id;                      /* target ID of device */
-    unchar      lun;                            /* LUN id of device */
-    unchar      orphan;                         /* flag: drive fragment */
-    ulong32     last_error;                     /* sense key or drive state */
-    ulong32     last_result;                    /* result of last command */
-    ulong32     check_errors;                   /* err. in last surface check */
-    unchar      percent;                        /* progress for surface check */
-    unchar      last_check;                     /* IOCTRL operation */
-    unchar      res[2];
-    ulong32     flags;                          /* from 1.19/2.19: raw reserv.*/
-    unchar      multi_bus;                      /* multi bus dev? (fibre ch.) */
-    unchar      mb_status;                      /* status: available? */
-    unchar      res2[2];
-    unchar      mb_alt_status;                  /* status on second bus */
-    unchar      mb_alt_bid;                     /* number of second bus */
-    unchar      mb_alt_tid;                     /* target id on second bus */
-    unchar      res3;
-    unchar      fc_flag;                        /* from 1.22/2.22: info valid?*/
-    unchar      res4;
-    ushort      fc_frame_size;                  /* frame size (bytes) */
+    u8      vendor[8];                      /* vendor string */
+    u8      product[16];                    /* product string */
+    u8      revision[4];                    /* revision */
+    u32     sy_rate;                        /* current rate for sync. tr. */
+    u32     sy_max_rate;                    /* max. rate for sync. tr. */
+    u32     no_ldrive;                      /* belongs to this log. drv.*/
+    u32     blkcnt;                         /* number of blocks */
+    u16      blksize;                        /* size of block in bytes */
+    u8      available;                      /* flag: access is available */
+    u8      init;                           /* medium is initialized */
+    u8      devtype;                        /* SCSI devicetype */
+    u8      rm_medium;                      /* medium is removable */
+    u8      wp_medium;                      /* medium is write protected */
+    u8      ansi;                           /* SCSI I/II or III? */
+    u8      protocol;                       /* same as ansi */
+    u8      sync;                           /* flag: sync. transfer enab. */
+    u8      disc;                           /* flag: disconnect enabled */
+    u8      queueing;                       /* flag: command queing enab. */
+    u8      cached;                         /* flag: caching enabled */
+    u8      target_id;                      /* target ID of device */
+    u8      lun;                            /* LUN id of device */
+    u8      orphan;                         /* flag: drive fragment */
+    u32     last_error;                     /* sense key or drive state */
+    u32     last_result;                    /* result of last command */
+    u32     check_errors;                   /* err. in last surface check */
+    u8      percent;                        /* progress for surface check */
+    u8      last_check;                     /* IOCTRL operation */
+    u8      res[2];
+    u32     flags;                          /* from 1.19/2.19: raw reserv.*/
+    u8      multi_bus;                      /* multi bus dev? (fibre ch.) */
+    u8      mb_status;                      /* status: available? */
+    u8      res2[2];
+    u8      mb_alt_status;                  /* status on second bus */
+    u8      mb_alt_bid;                     /* number of second bus */
+    u8      mb_alt_tid;                     /* target id on second bus */
+    u8      res3;
+    u8      fc_flag;                        /* from 1.22/2.22: info valid?*/
+    u8      res4;
+    u16      fc_frame_size;                  /* frame size (bytes) */
     char        wwn[8];                         /* world wide name */
-} PACKED gdth_diskinfo_str;
+} __attribute__((packed)) gdth_diskinfo_str;
 
 /* get SCSI channel count  */
 typedef struct {
-    ulong32     channel_no;                     /* number of channel */
-    ulong32     drive_cnt;                      /* drive count */
-    unchar      siop_id;                        /* SCSI processor ID */
-    unchar      siop_state;                     /* SCSI processor state */ 
-} PACKED gdth_getch_str;
+    u32     channel_no;                     /* number of channel */
+    u32     drive_cnt;                      /* drive count */
+    u8      siop_id;                        /* SCSI processor ID */
+    u8      siop_state;                     /* SCSI processor state */ 
+} __attribute__((packed)) gdth_getch_str;
 
 /* get SCSI drive numbers */
 typedef struct {
-    ulong32     sc_no;                          /* SCSI channel */
-    ulong32     sc_cnt;                         /* sc_list[] elements */
-    ulong32     sc_list[MAXID];                 /* minor device numbers */
-} PACKED gdth_drlist_str;
+    u32     sc_no;                          /* SCSI channel */
+    u32     sc_cnt;                         /* sc_list[] elements */
+    u32     sc_list[MAXID];                 /* minor device numbers */
+} __attribute__((packed)) gdth_drlist_str;
 
 /* get grown/primary defect count */
 typedef struct {
-    unchar      sddc_type;                      /* 0x08: grown, 0x10: prim. */
-    unchar      sddc_format;                    /* list entry format */
-    unchar      sddc_len;                       /* list entry length */
-    unchar      sddc_res;
-    ulong32     sddc_cnt;                       /* entry count */
-} PACKED gdth_defcnt_str;
+    u8      sddc_type;                      /* 0x08: grown, 0x10: prim. */
+    u8      sddc_format;                    /* list entry format */
+    u8      sddc_len;                       /* list entry length */
+    u8      sddc_res;
+    u32     sddc_cnt;                       /* entry count */
+} __attribute__((packed)) gdth_defcnt_str;
 
 /* disk statistics */
 typedef struct {
-    ulong32     bid;                            /* SCSI channel */
-    ulong32     first;                          /* first SCSI disk */
-    ulong32     entries;                        /* number of elements */
-    ulong32     count;                          /* (R) number of init. el. */
-    ulong32     mon_time;                       /* time stamp */
+    u32     bid;                            /* SCSI channel */
+    u32     first;                          /* first SCSI disk */
+    u32     entries;                        /* number of elements */
+    u32     count;                          /* (R) number of init. el. */
+    u32     mon_time;                       /* time stamp */
     struct {
-        unchar  tid;                            /* target ID */
-        unchar  lun;                            /* LUN */
-        unchar  res[2];
-        ulong32 blk_size;                       /* block size in bytes */
-        ulong32 rd_count;                       /* bytes read */
-        ulong32 wr_count;                       /* bytes written */
-        ulong32 rd_blk_count;                   /* blocks read */
-        ulong32 wr_blk_count;                   /* blocks written */
-        ulong32 retries;                        /* retries */
-        ulong32 reassigns;                      /* reassigns */
-    } PACKED list[1];
-} PACKED gdth_dskstat_str;
+        u8  tid;                            /* target ID */
+        u8  lun;                            /* LUN */
+        u8  res[2];
+        u32 blk_size;                       /* block size in bytes */
+        u32 rd_count;                       /* bytes read */
+        u32 wr_count;                       /* bytes written */
+        u32 rd_blk_count;                   /* blocks read */
+        u32 wr_blk_count;                   /* blocks written */
+        u32 retries;                        /* retries */
+        u32 reassigns;                      /* reassigns */
+    } __attribute__((packed)) list[1];
+} __attribute__((packed)) gdth_dskstat_str;
 
 /* IO channel header */
 typedef struct {
-    ulong32     version;                        /* version (-1UL: newest) */
-    unchar      list_entries;                   /* list entry count */
-    unchar      first_chan;                     /* first channel number */
-    unchar      last_chan;                      /* last channel number */
-    unchar      chan_count;                     /* (R) channel count */
-    ulong32     list_offset;                    /* offset of list[0] */
-} PACKED gdth_iochan_header;
+    u32     version;                        /* version (-1UL: newest) */
+    u8      list_entries;                   /* list entry count */
+    u8      first_chan;                     /* first channel number */
+    u8      last_chan;                      /* last channel number */
+    u8      chan_count;                     /* (R) channel count */
+    u32     list_offset;                    /* offset of list[0] */
+} __attribute__((packed)) gdth_iochan_header;
 
 /* get IO channel description */
 typedef struct {
     gdth_iochan_header  hdr;
     struct {
-        ulong32         address;                /* channel address */
-        unchar          type;                   /* type (SCSI, FCAL) */
-        unchar          local_no;               /* local number */
-        ushort          features;               /* channel features */
-    } PACKED list[MAXBUS];
-} PACKED gdth_iochan_str;
+        u32         address;                /* channel address */
+        u8          type;                   /* type (SCSI, FCAL) */
+        u8          local_no;               /* local number */
+        u16          features;               /* channel features */
+    } __attribute__((packed)) list[MAXBUS];
+} __attribute__((packed)) gdth_iochan_str;
 
 /* get raw IO channel description */
 typedef struct {
     gdth_iochan_header  hdr;
     struct {
-        unchar      proc_id;                    /* processor id */
-        unchar      proc_defect;                /* defect ? */
-        unchar      reserved[2];
-    } PACKED list[MAXBUS];
-} PACKED gdth_raw_iochan_str;
+        u8      proc_id;                    /* processor id */
+        u8      proc_defect;                /* defect ? */
+        u8      reserved[2];
+    } __attribute__((packed)) list[MAXBUS];
+} __attribute__((packed)) gdth_raw_iochan_str;
 
 /* array drive component */
 typedef struct {
-    ulong32     al_controller;                  /* controller ID */
-    unchar      al_cache_drive;                 /* cache drive number */
-    unchar      al_status;                      /* cache drive state */
-    unchar      al_res[2];     
-} PACKED gdth_arraycomp_str;
+    u32     al_controller;                  /* controller ID */
+    u8      al_cache_drive;                 /* cache drive number */
+    u8      al_status;                      /* cache drive state */
+    u8      al_res[2];     
+} __attribute__((packed)) gdth_arraycomp_str;
 
 /* array drive information */
 typedef struct {
-    unchar      ai_type;                        /* array type (RAID0,4,5) */
-    unchar      ai_cache_drive_cnt;             /* active cachedrives */
-    unchar      ai_state;                       /* array drive state */
-    unchar      ai_master_cd;                   /* master cachedrive */
-    ulong32     ai_master_controller;           /* ID of master controller */
-    ulong32     ai_size;                        /* user capacity [sectors] */
-    ulong32     ai_striping_size;               /* striping size [sectors] */
-    ulong32     ai_secsize;                     /* sector size [bytes] */
-    ulong32     ai_err_info;                    /* failed cache drive */
-    unchar      ai_name[8];                     /* name of the array drive */
-    unchar      ai_controller_cnt;              /* number of controllers */
-    unchar      ai_removable;                   /* flag: removable */
-    unchar      ai_write_protected;             /* flag: write protected */
-    unchar      ai_devtype;                     /* type: always direct access */
+    u8      ai_type;                        /* array type (RAID0,4,5) */
+    u8      ai_cache_drive_cnt;             /* active cachedrives */
+    u8      ai_state;                       /* array drive state */
+    u8      ai_master_cd;                   /* master cachedrive */
+    u32     ai_master_controller;           /* ID of master controller */
+    u32     ai_size;                        /* user capacity [sectors] */
+    u32     ai_striping_size;               /* striping size [sectors] */
+    u32     ai_secsize;                     /* sector size [bytes] */
+    u32     ai_err_info;                    /* failed cache drive */
+    u8      ai_name[8];                     /* name of the array drive */
+    u8      ai_controller_cnt;              /* number of controllers */
+    u8      ai_removable;                   /* flag: removable */
+    u8      ai_write_protected;             /* flag: write protected */
+    u8      ai_devtype;                     /* type: always direct access */
     gdth_arraycomp_str  ai_drives[35];          /* drive components: */
-    unchar      ai_drive_entries;               /* number of drive components */
-    unchar      ai_protected;                   /* protection flag */
-    unchar      ai_verify_state;                /* state of a parity verify */
-    unchar      ai_ext_state;                   /* extended array drive state */
-    unchar      ai_expand_state;                /* array expand state (>=2.18)*/
-    unchar      ai_reserved[3];
-} PACKED gdth_arrayinf_str;
+    u8      ai_drive_entries;               /* number of drive components */
+    u8      ai_protected;                   /* protection flag */
+    u8      ai_verify_state;                /* state of a parity verify */
+    u8      ai_ext_state;                   /* extended array drive state */
+    u8      ai_expand_state;                /* array expand state (>=2.18)*/
+    u8      ai_reserved[3];
+} __attribute__((packed)) gdth_arrayinf_str;
 
 /* get array drive list */
 typedef struct {
-    ulong32     controller_no;                  /* controller no. */
-    unchar      cd_handle;                      /* master cachedrive */
-    unchar      is_arrayd;                      /* Flag: is array drive? */
-    unchar      is_master;                      /* Flag: is array master? */
-    unchar      is_parity;                      /* Flag: is parity drive? */
-    unchar      is_hotfix;                      /* Flag: is hotfix drive? */
-    unchar      res[3];
-} PACKED gdth_alist_str;
+    u32     controller_no;                  /* controller no. */
+    u8      cd_handle;                      /* master cachedrive */
+    u8      is_arrayd;                      /* Flag: is array drive? */
+    u8      is_master;                      /* Flag: is array master? */
+    u8      is_parity;                      /* Flag: is parity drive? */
+    u8      is_hotfix;                      /* Flag: is hotfix drive? */
+    u8      res[3];
+} __attribute__((packed)) gdth_alist_str;
 
 typedef struct {
-    ulong32     entries_avail;                  /* allocated entries */
-    ulong32     entries_init;                   /* returned entries */
-    ulong32     first_entry;                    /* first entry number */
-    ulong32     list_offset;                    /* offset of following list */
+    u32     entries_avail;                  /* allocated entries */
+    u32     entries_init;                   /* returned entries */
+    u32     first_entry;                    /* first entry number */
+    u32     list_offset;                    /* offset of following list */
     gdth_alist_str list[1];                     /* list */
-} PACKED gdth_arcdl_str;
+} __attribute__((packed)) gdth_arcdl_str;
 
 /* cache info/config IOCTL */
 typedef struct {
-    ulong32     version;                        /* firmware version */
-    ushort      state;                          /* cache state (on/off) */
-    ushort      strategy;                       /* cache strategy */
-    ushort      write_back;                     /* write back state (on/off) */
-    ushort      block_size;                     /* cache block size */
-} PACKED gdth_cpar_str;
+    u32     version;                        /* firmware version */
+    u16      state;                          /* cache state (on/off) */
+    u16      strategy;                       /* cache strategy */
+    u16      write_back;                     /* write back state (on/off) */
+    u16      block_size;                     /* cache block size */
+} __attribute__((packed)) gdth_cpar_str;
 
 typedef struct {
-    ulong32     csize;                          /* cache size */
-    ulong32     read_cnt;                       /* read/write counter */
-    ulong32     write_cnt;
-    ulong32     tr_hits;                        /* hits */
-    ulong32     sec_hits;
-    ulong32     sec_miss;                       /* misses */
-} PACKED gdth_cstat_str;
+    u32     csize;                          /* cache size */
+    u32     read_cnt;                       /* read/write counter */
+    u32     write_cnt;
+    u32     tr_hits;                        /* hits */
+    u32     sec_hits;
+    u32     sec_miss;                       /* misses */
+} __attribute__((packed)) gdth_cstat_str;
 
 typedef struct {
     gdth_cpar_str   cpar;
     gdth_cstat_str  cstat;
-} PACKED gdth_cinfo_str;
+} __attribute__((packed)) gdth_cinfo_str;
 
 /* cache drive info */
 typedef struct {
-    unchar      cd_name[8];                     /* cache drive name */
-    ulong32     cd_devtype;                     /* SCSI devicetype */
-    ulong32     cd_ldcnt;                       /* number of log. drives */
-    ulong32     cd_last_error;                  /* last error */
-    unchar      cd_initialized;                 /* drive is initialized */
-    unchar      cd_removable;                   /* media is removable */
-    unchar      cd_write_protected;             /* write protected */
-    unchar      cd_flags;                       /* Pool Hot Fix? */
-    ulong32     ld_blkcnt;                      /* number of blocks */
-    ulong32     ld_blksize;                     /* blocksize */
-    ulong32     ld_dcnt;                        /* number of disks */
-    ulong32     ld_slave;                       /* log. drive index */
-    ulong32     ld_dtype;                       /* type of logical drive */
-    ulong32     ld_last_error;                  /* last error */
-    unchar      ld_name[8];                     /* log. drive name */
-    unchar      ld_error;                       /* error */
-} PACKED gdth_cdrinfo_str;
+    u8      cd_name[8];                     /* cache drive name */
+    u32     cd_devtype;                     /* SCSI devicetype */
+    u32     cd_ldcnt;                       /* number of log. drives */
+    u32     cd_last_error;                  /* last error */
+    u8      cd_initialized;                 /* drive is initialized */
+    u8      cd_removable;                   /* media is removable */
+    u8      cd_write_protected;             /* write protected */
+    u8      cd_flags;                       /* Pool Hot Fix? */
+    u32     ld_blkcnt;                      /* number of blocks */
+    u32     ld_blksize;                     /* blocksize */
+    u32     ld_dcnt;                        /* number of disks */
+    u32     ld_slave;                       /* log. drive index */
+    u32     ld_dtype;                       /* type of logical drive */
+    u32     ld_last_error;                  /* last error */
+    u8      ld_name[8];                     /* log. drive name */
+    u8      ld_error;                       /* error */
+} __attribute__((packed)) gdth_cdrinfo_str;
 
 /* OEM string */
 typedef struct {
-    ulong32     ctl_version;
-    ulong32     file_major_version;
-    ulong32     file_minor_version;
-    ulong32     buffer_size;
-    ulong32     cpy_count;
-    ulong32     ext_error;
-    ulong32     oem_id;
-    ulong32     board_id;
-} PACKED gdth_oem_str_params;
-
-typedef struct {
-    unchar      product_0_1_name[16];
-    unchar      product_4_5_name[16];
-    unchar      product_cluster_name[16];
-    unchar      product_reserved[16];
-    unchar      scsi_cluster_target_vendor_id[16];
-    unchar      cluster_raid_fw_name[16];
-    unchar      oem_brand_name[16];
-    unchar      oem_raid_type[16];
-    unchar      bios_type[13];
-    unchar      bios_title[50];
-    unchar      oem_company_name[37];
-    ulong32     pci_id_1;
-    ulong32     pci_id_2;
-    unchar      validation_status[80];
-    unchar      reserved_1[4];
-    unchar      scsi_host_drive_inquiry_vendor_id[16];
-    unchar      library_file_template[16];
-    unchar      reserved_2[16];
-    unchar      tool_name_1[32];
-    unchar      tool_name_2[32];
-    unchar      tool_name_3[32];
-    unchar      oem_contact_1[84];
-    unchar      oem_contact_2[84];
-    unchar      oem_contact_3[84];
-} PACKED gdth_oem_str;
+    u32     ctl_version;
+    u32     file_major_version;
+    u32     file_minor_version;
+    u32     buffer_size;
+    u32     cpy_count;
+    u32     ext_error;
+    u32     oem_id;
+    u32     board_id;
+} __attribute__((packed)) gdth_oem_str_params;
+
+typedef struct {
+    u8      product_0_1_name[16];
+    u8      product_4_5_name[16];
+    u8      product_cluster_name[16];
+    u8      product_reserved[16];
+    u8      scsi_cluster_target_vendor_id[16];
+    u8      cluster_raid_fw_name[16];
+    u8      oem_brand_name[16];
+    u8      oem_raid_type[16];
+    u8      bios_type[13];
+    u8      bios_title[50];
+    u8      oem_company_name[37];
+    u32     pci_id_1;
+    u32     pci_id_2;
+    u8      validation_status[80];
+    u8      reserved_1[4];
+    u8      scsi_host_drive_inquiry_vendor_id[16];
+    u8      library_file_template[16];
+    u8      reserved_2[16];
+    u8      tool_name_1[32];
+    u8      tool_name_2[32];
+    u8      tool_name_3[32];
+    u8      oem_contact_1[84];
+    u8      oem_contact_2[84];
+    u8      oem_contact_3[84];
+} __attribute__((packed)) gdth_oem_str;
 
 typedef struct {
     gdth_oem_str_params params;
     gdth_oem_str        text;
-} PACKED gdth_oem_str_ioctl;
+} __attribute__((packed)) gdth_oem_str_ioctl;
 
 /* board features */
 typedef struct {
-    unchar      chaining;                       /* Chaining supported */
-    unchar      striping;                       /* Striping (RAID-0) supp. */
-    unchar      mirroring;                      /* Mirroring (RAID-1) supp. */
-    unchar      raid;                           /* RAID-4/5/10 supported */
-} PACKED gdth_bfeat_str;
+    u8      chaining;                       /* Chaining supported */
+    u8      striping;                       /* Striping (RAID-0) supp. */
+    u8      mirroring;                      /* Mirroring (RAID-1) supp. */
+    u8      raid;                           /* RAID-4/5/10 supported */
+} __attribute__((packed)) gdth_bfeat_str;
 
 /* board info IOCTL */
 typedef struct {
-    ulong32     ser_no;                         /* serial no. */
-    unchar      oem_id[2];                      /* OEM ID */
-    ushort      ep_flags;                       /* eprom flags */
-    ulong32     proc_id;                        /* processor ID */
-    ulong32     memsize;                        /* memory size (bytes) */
-    unchar      mem_banks;                      /* memory banks */
-    unchar      chan_type;                      /* channel type */
-    unchar      chan_count;                     /* channel count */
-    unchar      rdongle_pres;                   /* dongle present? */
-    ulong32     epr_fw_ver;                     /* (eprom) firmware version */
-    ulong32     upd_fw_ver;                     /* (update) firmware version */
-    ulong32     upd_revision;                   /* update revision */
+    u32     ser_no;                         /* serial no. */
+    u8      oem_id[2];                      /* OEM ID */
+    u16      ep_flags;                       /* eprom flags */
+    u32     proc_id;                        /* processor ID */
+    u32     memsize;                        /* memory size (bytes) */
+    u8      mem_banks;                      /* memory banks */
+    u8      chan_type;                      /* channel type */
+    u8      chan_count;                     /* channel count */
+    u8      rdongle_pres;                   /* dongle present? */
+    u32     epr_fw_ver;                     /* (eprom) firmware version */
+    u32     upd_fw_ver;                     /* (update) firmware version */
+    u32     upd_revision;                   /* update revision */
     char        type_string[16];                /* controller name */
     char        raid_string[16];                /* RAID firmware name */
-    unchar      update_pres;                    /* update present? */
-    unchar      xor_pres;                       /* XOR engine present? */
-    unchar      prom_type;                      /* ROM type (eprom/flash) */
-    unchar      prom_count;                     /* number of ROM devices */
-    ulong32     dup_pres;                       /* duplexing module present? */
-    ulong32     chan_pres;                      /* number of expansion chn. */
-    ulong32     mem_pres;                       /* memory expansion inst. ? */
-    unchar      ft_bus_system;                  /* fault bus supported? */
-    unchar      subtype_valid;                  /* board_subtype valid? */
-    unchar      board_subtype;                  /* subtype/hardware level */
-    unchar      ramparity_pres;                 /* RAM parity check hardware? */
-} PACKED gdth_binfo_str; 
+    u8      update_pres;                    /* update present? */
+    u8      xor_pres;                       /* XOR engine present? */
+    u8      prom_type;                      /* ROM type (eprom/flash) */
+    u8      prom_count;                     /* number of ROM devices */
+    u32     dup_pres;                       /* duplexing module present? */
+    u32     chan_pres;                      /* number of expansion chn. */
+    u32     mem_pres;                       /* memory expansion inst. ? */
+    u8      ft_bus_system;                  /* fault bus supported? */
+    u8      subtype_valid;                  /* board_subtype valid? */
+    u8      board_subtype;                  /* subtype/hardware level */
+    u8      ramparity_pres;                 /* RAM parity check hardware? */
+} __attribute__((packed)) gdth_binfo_str; 
 
 /* get host drive info */
 typedef struct {
     char        name[8];                        /* host drive name */
-    ulong32     size;                           /* size (sectors) */
-    unchar      host_drive;                     /* host drive number */
-    unchar      log_drive;                      /* log. drive (master) */
-    unchar      reserved;
-    unchar      rw_attribs;                     /* r/w attribs */
-    ulong32     start_sec;                      /* start sector */
-} PACKED gdth_hentry_str;
-
-typedef struct {
-    ulong32     entries;                        /* entry count */
-    ulong32     offset;                         /* offset of entries */
-    unchar      secs_p_head;                    /* sectors/head */
-    unchar      heads_p_cyl;                    /* heads/cylinder */
-    unchar      reserved;
-    unchar      clust_drvtype;                  /* cluster drive type */
-    ulong32     location;                       /* controller number */
+    u32     size;                           /* size (sectors) */
+    u8      host_drive;                     /* host drive number */
+    u8      log_drive;                      /* log. drive (master) */
+    u8      reserved;
+    u8      rw_attribs;                     /* r/w attribs */
+    u32     start_sec;                      /* start sector */
+} __attribute__((packed)) gdth_hentry_str;
+
+typedef struct {
+    u32     entries;                        /* entry count */
+    u32     offset;                         /* offset of entries */
+    u8      secs_p_head;                    /* sectors/head */
+    u8      heads_p_cyl;                    /* heads/cylinder */
+    u8      reserved;
+    u8      clust_drvtype;                  /* cluster drive type */
+    u32     location;                       /* controller number */
     gdth_hentry_str entry[MAX_HDRIVES];         /* entries */
-} PACKED gdth_hget_str;    
+} __attribute__((packed)) gdth_hget_str;    
 
 
 /* DPRAM structures */
 
 /* interface area ISA/PCI */
 typedef struct {
-    unchar              S_Cmd_Indx;             /* special command */
-    unchar volatile     S_Status;               /* status special command */
-    ushort              reserved1;
-    ulong32             S_Info[4];              /* add. info special command */
-    unchar volatile     Sema0;                  /* command semaphore */
-    unchar              reserved2[3];
-    unchar              Cmd_Index;              /* command number */
-    unchar              reserved3[3];
-    ushort volatile     Status;                 /* command status */
-    ushort              Service;                /* service(for async.events) */
-    ulong32             Info[2];                /* additional info */
+    u8              S_Cmd_Indx;             /* special command */
+    u8 volatile     S_Status;               /* status special command */
+    u16              reserved1;
+    u32             S_Info[4];              /* add. info special command */
+    u8 volatile     Sema0;                  /* command semaphore */
+    u8              reserved2[3];
+    u8              Cmd_Index;              /* command number */
+    u8              reserved3[3];
+    u16 volatile     Status;                 /* command status */
+    u16              Service;                /* service(for async.events) */
+    u32             Info[2];                /* additional info */
     struct {
-        ushort          offset;                 /* command offs. in the DPRAM*/
-        ushort          serv_id;                /* service */
-    } PACKED comm_queue[MAXOFFSETS];            /* command queue */
-    ulong32             bios_reserved[2];
-    unchar              gdt_dpr_cmd[1];         /* commands */
-} PACKED gdt_dpr_if;
+        u16          offset;                 /* command offs. in the DPRAM*/
+        u16          serv_id;                /* service */
+    } __attribute__((packed)) comm_queue[MAXOFFSETS];            /* command queue */
+    u32             bios_reserved[2];
+    u8              gdt_dpr_cmd[1];         /* commands */
+} __attribute__((packed)) gdt_dpr_if;
 
 /* SRAM structure PCI controllers */
 typedef struct {
-    ulong32     magic;                          /* controller ID from BIOS */
-    ushort      need_deinit;                    /* switch betw. BIOS/driver */
-    unchar      switch_support;                 /* see need_deinit */
-    unchar      padding[9];
-    unchar      os_used[16];                    /* OS code per service */
-    unchar      unused[28];
-    unchar      fw_magic;                       /* contr. ID from firmware */
-} PACKED gdt_pci_sram;
+    u32     magic;                          /* controller ID from BIOS */
+    u16      need_deinit;                    /* switch betw. BIOS/driver */
+    u8      switch_support;                 /* see need_deinit */
+    u8      padding[9];
+    u8      os_used[16];                    /* OS code per service */
+    u8      unused[28];
+    u8      fw_magic;                       /* contr. ID from firmware */
+} __attribute__((packed)) gdt_pci_sram;
 
 /* SRAM structure EISA controllers (but NOT GDT3000/3020) */
 typedef struct {
-    unchar      os_used[16];                    /* OS code per service */
-    ushort      need_deinit;                    /* switch betw. BIOS/driver */
-    unchar      switch_support;                 /* see need_deinit */
-    unchar      padding;
-} PACKED gdt_eisa_sram;
+    u8      os_used[16];                    /* OS code per service */
+    u16      need_deinit;                    /* switch betw. BIOS/driver */
+    u8      switch_support;                 /* see need_deinit */
+    u8      padding;
+} __attribute__((packed)) gdt_eisa_sram;
 
 
 /* DPRAM ISA controllers */
 typedef struct {
     union {
         struct {
-            unchar      bios_used[0x3c00-32];   /* 15KB - 32Bytes BIOS */
-            ulong32     magic;                  /* controller (EISA) ID */
-            ushort      need_deinit;            /* switch betw. BIOS/driver */
-            unchar      switch_support;         /* see need_deinit */
-            unchar      padding[9];
-            unchar      os_used[16];            /* OS code per service */
-        } PACKED dp_sram;
-        unchar          bios_area[0x4000];      /* 16KB reserved for BIOS */
+            u8      bios_used[0x3c00-32];   /* 15KB - 32Bytes BIOS */
+            u32     magic;                  /* controller (EISA) ID */
+            u16      need_deinit;            /* switch betw. BIOS/driver */
+            u8      switch_support;         /* see need_deinit */
+            u8      padding[9];
+            u8      os_used[16];            /* OS code per service */
+        } __attribute__((packed)) dp_sram;
+        u8          bios_area[0x4000];      /* 16KB reserved for BIOS */
     } bu;
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0x3000];        /* 12KB for interface */
+        u8          if_area[0x3000];        /* 12KB for interface */
     } u;
     struct {
-        unchar          memlock;                /* write protection DPRAM */
-        unchar          event;                  /* release event */
-        unchar          irqen;                  /* board interrupts enable */
-        unchar          irqdel;                 /* acknowledge board int. */
-        unchar volatile Sema1;                  /* status semaphore */
-        unchar          rq;                     /* IRQ/DRQ configuration */
-    } PACKED io;
-} PACKED gdt2_dpram_str;
+        u8          memlock;                /* write protection DPRAM */
+        u8          event;                  /* release event */
+        u8          irqen;                  /* board interrupts enable */
+        u8          irqdel;                 /* acknowledge board int. */
+        u8 volatile Sema1;                  /* status semaphore */
+        u8          rq;                     /* IRQ/DRQ configuration */
+    } __attribute__((packed)) io;
+} __attribute__((packed)) gdt2_dpram_str;
 
 /* DPRAM PCI controllers */
 typedef struct {
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0xff0-sizeof(gdt_pci_sram)];
+        u8          if_area[0xff0-sizeof(gdt_pci_sram)];
     } u;
     gdt_pci_sram        gdt6sr;                 /* SRAM structure */
     struct {
-        unchar          unused0[1];
-        unchar volatile Sema1;                  /* command semaphore */
-        unchar          unused1[3];
-        unchar          irqen;                  /* board interrupts enable */
-        unchar          unused2[2];
-        unchar          event;                  /* release event */
-        unchar          unused3[3];
-        unchar          irqdel;                 /* acknowledge board int. */
-        unchar          unused4[3];
-    } PACKED io;
-} PACKED gdt6_dpram_str;
+        u8          unused0[1];
+        u8 volatile Sema1;                  /* command semaphore */
+        u8          unused1[3];
+        u8          irqen;                  /* board interrupts enable */
+        u8          unused2[2];
+        u8          event;                  /* release event */
+        u8          unused3[3];
+        u8          irqdel;                 /* acknowledge board int. */
+        u8          unused4[3];
+    } __attribute__((packed)) io;
+} __attribute__((packed)) gdt6_dpram_str;
 
 /* PLX register structure (new PCI controllers) */
 typedef struct {
-    unchar              cfg_reg;        /* DPRAM cfg.(2:below 1MB,0:anywhere)*/
-    unchar              unused1[0x3f];
-    unchar volatile     sema0_reg;              /* command semaphore */
-    unchar volatile     sema1_reg;              /* status semaphore */
-    unchar              unused2[2];
-    ushort volatile     status;                 /* command status */
-    ushort              service;                /* service */
-    ulong32             info[2];                /* additional info */
-    unchar              unused3[0x10];
-    unchar              ldoor_reg;              /* PCI to local doorbell */
-    unchar              unused4[3];
-    unchar volatile     edoor_reg;              /* local to PCI doorbell */
-    unchar              unused5[3];
-    unchar              control0;               /* control0 register(unused) */
-    unchar              control1;               /* board interrupts enable */
-    unchar              unused6[0x16];
-} PACKED gdt6c_plx_regs;
+    u8              cfg_reg;        /* DPRAM cfg.(2:below 1MB,0:anywhere)*/
+    u8              unused1[0x3f];
+    u8 volatile     sema0_reg;              /* command semaphore */
+    u8 volatile     sema1_reg;              /* status semaphore */
+    u8              unused2[2];
+    u16 volatile     status;                 /* command status */
+    u16              service;                /* service */
+    u32             info[2];                /* additional info */
+    u8              unused3[0x10];
+    u8              ldoor_reg;              /* PCI to local doorbell */
+    u8              unused4[3];
+    u8 volatile     edoor_reg;              /* local to PCI doorbell */
+    u8              unused5[3];
+    u8              control0;               /* control0 register(unused) */
+    u8              control1;               /* board interrupts enable */
+    u8              unused6[0x16];
+} __attribute__((packed)) gdt6c_plx_regs;
 
 /* DPRAM new PCI controllers */
 typedef struct {
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0x4000-sizeof(gdt_pci_sram)];
+        u8          if_area[0x4000-sizeof(gdt_pci_sram)];
     } u;
     gdt_pci_sram        gdt6sr;                 /* SRAM structure */
-} PACKED gdt6c_dpram_str;
+} __attribute__((packed)) gdt6c_dpram_str;
 
 /* i960 register structure (PCI MPR controllers) */
 typedef struct {
-    unchar              unused1[16];
-    unchar volatile     sema0_reg;              /* command semaphore */
-    unchar              unused2;
-    unchar volatile     sema1_reg;              /* status semaphore */
-    unchar              unused3;
-    ushort volatile     status;                 /* command status */
-    ushort              service;                /* service */
-    ulong32             info[2];                /* additional info */
-    unchar              ldoor_reg;              /* PCI to local doorbell */
-    unchar              unused4[11];
-    unchar volatile     edoor_reg;              /* local to PCI doorbell */
-    unchar              unused5[7];
-    unchar              edoor_en_reg;           /* board interrupts enable */
-    unchar              unused6[27];
-    ulong32             unused7[939];         
-    ulong32             severity;       
+    u8              unused1[16];
+    u8 volatile     sema0_reg;              /* command semaphore */
+    u8              unused2;
+    u8 volatile     sema1_reg;              /* status semaphore */
+    u8              unused3;
+    u16 volatile     status;                 /* command status */
+    u16              service;                /* service */
+    u32             info[2];                /* additional info */
+    u8              ldoor_reg;              /* PCI to local doorbell */
+    u8              unused4[11];
+    u8 volatile     edoor_reg;              /* local to PCI doorbell */
+    u8              unused5[7];
+    u8              edoor_en_reg;           /* board interrupts enable */
+    u8              unused6[27];
+    u32             unused7[939];         
+    u32             severity;       
     char                evt_str[256];           /* event string */
-} PACKED gdt6m_i960_regs;
+} __attribute__((packed)) gdt6m_i960_regs;
 
 /* DPRAM PCI MPR controllers */
 typedef struct {
     gdt6m_i960_regs     i960r;                  /* 4KB i960 registers */
     union {
         gdt_dpr_if      ic;                     /* interface area */
-        unchar          if_area[0x3000-sizeof(gdt_pci_sram)];
+        u8          if_area[0x3000-sizeof(gdt_pci_sram)];
     } u;
     gdt_pci_sram        gdt6sr;                 /* SRAM structure */
-} PACKED gdt6m_dpram_str;
+} __attribute__((packed)) gdt6m_dpram_str;
 
 
 /* PCI resources */
 typedef struct {
     struct pci_dev      *pdev;
-    ulong               dpmem;                  /* DPRAM address */
-    ulong               io;                     /* IO address */
+    unsigned long               dpmem;                  /* DPRAM address */
+    unsigned long               io;                     /* IO address */
 } gdth_pci_str;
 
 
@@ -846,93 +846,93 @@ typedef struct {
 typedef struct {
     struct Scsi_Host    *shost;
     struct list_head    list;
-    ushort              hanum;
-    ushort              oem_id;                 /* OEM */
-    ushort              type;                   /* controller class */
-    ulong32             stype;                  /* subtype (PCI: device ID) */
-    ushort              fw_vers;                /* firmware version */
-    ushort              cache_feat;             /* feat. cache serv. (s/g,..)*/
-    ushort              raw_feat;               /* feat. raw service (s/g,..)*/
-    ushort              screen_feat;            /* feat. raw service (s/g,..)*/
-    ushort              bmic;                   /* BMIC address (EISA) */
+    u16         hanum;
+    u16              oem_id;                 /* OEM */
+    u16              type;                   /* controller class */
+    u32             stype;                  /* subtype (PCI: device ID) */
+    u16              fw_vers;                /* firmware version */
+    u16              cache_feat;             /* feat. cache serv. (s/g,..)*/
+    u16              raw_feat;               /* feat. raw service (s/g,..)*/
+    u16              screen_feat;            /* feat. raw service (s/g,..)*/
+    u16              bmic;                   /* BMIC address (EISA) */
     void __iomem        *brd;                   /* DPRAM address */
-    ulong32             brd_phys;               /* slot number/BIOS address */
+    u32             brd_phys;               /* slot number/BIOS address */
     gdt6c_plx_regs      *plx;                   /* PLX regs (new PCI contr.) */
     gdth_cmd_str        cmdext;
     gdth_cmd_str        *pccb;                  /* address command structure */
-    ulong32             ccb_phys;               /* phys. address */
+    u32             ccb_phys;               /* phys. address */
 #ifdef INT_COAL
     gdth_coal_status    *coal_stat;             /* buffer for coalescing int.*/
-    ulong64             coal_stat_phys;         /* phys. address */
+    u64             coal_stat_phys;         /* phys. address */
 #endif
     char                *pscratch;              /* scratch (DMA) buffer */
-    ulong64             scratch_phys;           /* phys. address */
-    unchar              scratch_busy;           /* in use? */
-    unchar              dma64_support;          /* 64-bit DMA supported? */
+    u64             scratch_phys;           /* phys. address */
+    u8              scratch_busy;           /* in use? */
+    u8              dma64_support;          /* 64-bit DMA supported? */
     gdth_msg_str        *pmsg;                  /* message buffer */
-    ulong64             msg_phys;               /* phys. address */
-    unchar              scan_mode;              /* current scan mode */
-    unchar              irq;                    /* IRQ */
-    unchar              drq;                    /* DRQ (ISA controllers) */
-    ushort              status;                 /* command status */
-    ushort              service;                /* service/firmware ver./.. */
-    ulong32             info;
-    ulong32             info2;                  /* additional info */
+    u64             msg_phys;               /* phys. address */
+    u8              scan_mode;              /* current scan mode */
+    u8              irq;                    /* IRQ */
+    u8              drq;                    /* DRQ (ISA controllers) */
+    u16              status;                 /* command status */
+    u16              service;                /* service/firmware ver./.. */
+    u32             info;
+    u32             info2;                  /* additional info */
     Scsi_Cmnd           *req_first;             /* top of request queue */
     struct {
-        unchar          present;                /* Flag: host drive present? */
-        unchar          is_logdrv;              /* Flag: log. drive (master)? */
-        unchar          is_arraydrv;            /* Flag: array drive? */
-        unchar          is_master;              /* Flag: array drive master? */
-        unchar          is_parity;              /* Flag: parity drive? */
-        unchar          is_hotfix;              /* Flag: hotfix drive? */
-        unchar          master_no;              /* number of master drive */
-        unchar          lock;                   /* drive locked? (hot plug) */
-        unchar          heads;                  /* mapping */
-        unchar          secs;
-        ushort          devtype;                /* further information */
-        ulong64         size;                   /* capacity */
-        unchar          ldr_no;                 /* log. drive no. */
-        unchar          rw_attribs;             /* r/w attributes */
-        unchar          cluster_type;           /* cluster properties */
-        unchar          media_changed;          /* Flag:MOUNT/UNMOUNT occured */
-        ulong32         start_sec;              /* start sector */
+        u8          present;                /* Flag: host drive present? */
+        u8          is_logdrv;              /* Flag: log. drive (master)? */
+        u8          is_arraydrv;            /* Flag: array drive? */
+        u8          is_master;              /* Flag: array drive master? */
+        u8          is_parity;              /* Flag: parity drive? */
+        u8          is_hotfix;              /* Flag: hotfix drive? */
+        u8          master_no;              /* number of master drive */
+        u8          lock;                   /* drive locked? (hot plug) */
+        u8          heads;                  /* mapping */
+        u8          secs;
+        u16          devtype;                /* further information */
+        u64         size;                   /* capacity */
+        u8          ldr_no;                 /* log. drive no. */
+        u8          rw_attribs;             /* r/w attributes */
+        u8          cluster_type;           /* cluster properties */
+        u8          media_changed;          /* Flag:MOUNT/UNMOUNT occured */
+        u32         start_sec;              /* start sector */
     } hdr[MAX_LDRIVES];                         /* host drives */
     struct {
-        unchar          lock;                   /* channel locked? (hot plug) */
-        unchar          pdev_cnt;               /* physical device count */
-        unchar          local_no;               /* local channel number */
-        unchar          io_cnt[MAXID];          /* current IO count */
-        ulong32         address;                /* channel address */
-        ulong32         id_list[MAXID];         /* IDs of the phys. devices */
+        u8          lock;                   /* channel locked? (hot plug) */
+        u8          pdev_cnt;               /* physical device count */
+        u8          local_no;               /* local channel number */
+        u8          io_cnt[MAXID];          /* current IO count */
+        u32         address;                /* channel address */
+        u32         id_list[MAXID];         /* IDs of the phys. devices */
     } raw[MAXBUS];                              /* SCSI channels */
     struct {
         Scsi_Cmnd       *cmnd;                  /* pending request */
-        ushort          service;                /* service */
+        u16          service;                /* service */
     } cmd_tab[GDTH_MAXCMDS];                    /* table of pend. requests */
     struct gdth_cmndinfo {                      /* per-command private info */
         int index;
         int internal_command;                   /* don't call scsi_done */
         gdth_cmd_str *internal_cmd_str;         /* crier for internal messages*/
         dma_addr_t sense_paddr;                 /* sense dma-addr */
-        unchar priority;
+        u8 priority;
         int timeout_count;                      /* # of timeout calls */
         volatile int wait_for_completion;
-        ushort status;
-        ulong32 info;
+        u16 status;
+        u32 info;
         enum dma_data_direction dma_dir;
         int phase;                              /* ???? */
         int OpCode;
     } cmndinfo[GDTH_MAXCMDS];                   /* index==0 is free */
-    unchar              bus_cnt;                /* SCSI bus count */
-    unchar              tid_cnt;                /* Target ID count */
-    unchar              bus_id[MAXBUS];         /* IOP IDs */
-    unchar              virt_bus;               /* number of virtual bus */
-    unchar              more_proc;              /* more /proc info supported */
-    ushort              cmd_cnt;                /* command count in DPRAM */
-    ushort              cmd_len;                /* length of actual command */
-    ushort              cmd_offs_dpmem;         /* actual offset in DPRAM */
-    ushort              ic_all_size;            /* sizeof DPRAM interf. area */
+    u8              bus_cnt;                /* SCSI bus count */
+    u8              tid_cnt;                /* Target ID count */
+    u8              bus_id[MAXBUS];         /* IOP IDs */
+    u8              virt_bus;               /* number of virtual bus */
+    u8              more_proc;              /* more /proc info supported */
+    u16              cmd_cnt;                /* command count in DPRAM */
+    u16              cmd_len;                /* length of actual command */
+    u16              cmd_offs_dpmem;         /* actual offset in DPRAM */
+    u16              ic_all_size;            /* sizeof DPRAM interf. area */
     gdth_cpar_str       cpar;                   /* controller cache par. */
     gdth_bfeat_str      bfeat;                  /* controller features */
     gdth_binfo_str      binfo;                  /* controller info */
@@ -941,7 +941,7 @@ typedef struct {
     struct pci_dev      *pdev;
     char                oem_name[8];
 #ifdef GDTH_DMA_STATISTICS
-    ulong               dma32_cnt, dma64_cnt;   /* statistics: DMA buffer */
+    unsigned long               dma32_cnt, dma64_cnt;   /* statistics: DMA buffer */
 #endif
     struct scsi_device         *sdev;
 } gdth_ha_str;
@@ -953,65 +953,65 @@ static inline struct gdth_cmndinfo *gdth_cmnd_priv(struct scsi_cmnd* cmd)
 
 /* INQUIRY data format */
 typedef struct {
-    unchar      type_qual;
-    unchar      modif_rmb;
-    unchar      version;
-    unchar      resp_aenc;
-    unchar      add_length;
-    unchar      reserved1;
-    unchar      reserved2;
-    unchar      misc;
-    unchar      vendor[8];
-    unchar      product[16];
-    unchar      revision[4];
-} PACKED gdth_inq_data;
+    u8      type_qual;
+    u8      modif_rmb;
+    u8      version;
+    u8      resp_aenc;
+    u8      add_length;
+    u8      reserved1;
+    u8      reserved2;
+    u8      misc;
+    u8      vendor[8];
+    u8      product[16];
+    u8      revision[4];
+} __attribute__((packed)) gdth_inq_data;
 
 /* READ_CAPACITY data format */
 typedef struct {
-    ulong32     last_block_no;
-    ulong32     block_length;
-} PACKED gdth_rdcap_data;
+    u32     last_block_no;
+    u32     block_length;
+} __attribute__((packed)) gdth_rdcap_data;
 
 /* READ_CAPACITY (16) data format */
 typedef struct {
-    ulong64     last_block_no;
-    ulong32     block_length;
-} PACKED gdth_rdcap16_data;
+    u64     last_block_no;
+    u32     block_length;
+} __attribute__((packed)) gdth_rdcap16_data;
 
 /* REQUEST_SENSE data format */
 typedef struct {
-    unchar      errorcode;
-    unchar      segno;
-    unchar      key;
-    ulong32     info;
-    unchar      add_length;
-    ulong32     cmd_info;
-    unchar      adsc;
-    unchar      adsq;
-    unchar      fruc;
-    unchar      key_spec[3];
-} PACKED gdth_sense_data;
+    u8      errorcode;
+    u8      segno;
+    u8      key;
+    u32     info;
+    u8      add_length;
+    u32     cmd_info;
+    u8      adsc;
+    u8      adsq;
+    u8      fruc;
+    u8      key_spec[3];
+} __attribute__((packed)) gdth_sense_data;
 
 /* MODE_SENSE data format */
 typedef struct {
     struct {
-        unchar  data_length;
-        unchar  med_type;
-        unchar  dev_par;
-        unchar  bd_length;
-    } PACKED hd;
+        u8  data_length;
+        u8  med_type;
+        u8  dev_par;
+        u8  bd_length;
+    } __attribute__((packed)) hd;
     struct {
-        unchar  dens_code;
-        unchar  block_count[3];
-        unchar  reserved;
-        unchar  block_length[3];
-    } PACKED bd;
-} PACKED gdth_modep_data;
+        u8  dens_code;
+        u8  block_count[3];
+        u8  reserved;
+        u8  block_length[3];
+    } __attribute__((packed)) bd;
+} __attribute__((packed)) gdth_modep_data;
 
 /* stack frame */
 typedef struct {
-    ulong       b[10];                          /* 32/64 bit compiler ! */
-} PACKED gdth_stackframe;
+    unsigned long       b[10];                          /* 32/64 bit compiler ! */
+} __attribute__((packed)) gdth_stackframe;
 
 
 /* function prototyping */
diff --git a/drivers/scsi/gdth_ioctl.h b/drivers/scsi/gdth_ioctl.h
index 783fae737f17..b004c6165887 100644
--- a/drivers/scsi/gdth_ioctl.h
+++ b/drivers/scsi/gdth_ioctl.h
@@ -32,109 +32,101 @@
 #define MAX_HDRIVES     MAX_LDRIVES             /* max. host drive count */
 #endif
 
-/* typedefs */
-#ifdef __KERNEL__
-typedef u32     ulong32;
-typedef u64     ulong64;
-#endif
-
-#define PACKED  __attribute__((packed))
-
 /* scatter/gather element */
 typedef struct {
-    ulong32     sg_ptr;                         /* address */
-    ulong32     sg_len;                         /* length */
-} PACKED gdth_sg_str;
+    u32     sg_ptr;                         /* address */
+    u32     sg_len;                         /* length */
+} __attribute__((packed)) gdth_sg_str;
 
 /* scatter/gather element - 64bit addresses */
 typedef struct {
-    ulong64     sg_ptr;                         /* address */
-    ulong32     sg_len;                         /* length */
-} PACKED gdth_sg64_str;
+    u64     sg_ptr;                         /* address */
+    u32     sg_len;                         /* length */
+} __attribute__((packed)) gdth_sg64_str;
 
 /* command structure */
 typedef struct {
-    ulong32     BoardNode;                      /* board node (always 0) */
-    ulong32     CommandIndex;                   /* command number */
-    ushort      OpCode;                         /* the command (READ,..) */
+    u32     BoardNode;                      /* board node (always 0) */
+    u32     CommandIndex;                   /* command number */
+    u16      OpCode;                         /* the command (READ,..) */
     union {
         struct {
-            ushort      DeviceNo;               /* number of cache drive */
-            ulong32     BlockNo;                /* block number */
-            ulong32     BlockCnt;               /* block count */
-            ulong32     DestAddr;               /* dest. addr. (if s/g: -1) */
-            ulong32     sg_canz;                /* s/g element count */
+            u16      DeviceNo;               /* number of cache drive */
+            u32     BlockNo;                /* block number */
+            u32     BlockCnt;               /* block count */
+            u32     DestAddr;               /* dest. addr. (if s/g: -1) */
+            u32     sg_canz;                /* s/g element count */
             gdth_sg_str sg_lst[GDTH_MAXSG];     /* s/g list */
-        } PACKED cache;                         /* cache service cmd. str. */
+        } __attribute__((packed)) cache;                         /* cache service cmd. str. */
         struct {
-            ushort      DeviceNo;               /* number of cache drive */
-            ulong64     BlockNo;                /* block number */
-            ulong32     BlockCnt;               /* block count */
-            ulong64     DestAddr;               /* dest. addr. (if s/g: -1) */
-            ulong32     sg_canz;                /* s/g element count */
+            u16      DeviceNo;               /* number of cache drive */
+            u64     BlockNo;                /* block number */
+            u32     BlockCnt;               /* block count */
+            u64     DestAddr;               /* dest. addr. (if s/g: -1) */
+            u32     sg_canz;                /* s/g element count */
             gdth_sg64_str sg_lst[GDTH_MAXSG];   /* s/g list */
-        } PACKED cache64;                       /* cache service cmd. str. */
+        } __attribute__((packed)) cache64;                       /* cache service cmd. str. */
         struct {
-            ushort      param_size;             /* size of p_param buffer */
-            ulong32     subfunc;                /* IOCTL function */
-            ulong32     channel;                /* device */
-            ulong64     p_param;                /* buffer */
-        } PACKED ioctl;                         /* IOCTL command structure */
+            u16      param_size;             /* size of p_param buffer */
+            u32     subfunc;                /* IOCTL function */
+            u32     channel;                /* device */
+            u64     p_param;                /* buffer */
+        } __attribute__((packed)) ioctl;                         /* IOCTL command structure */
         struct {
-            ushort      reserved;
+            u16      reserved;
             union {
                 struct {
-                    ulong32  msg_handle;        /* message handle */
-                    ulong64  msg_addr;          /* message buffer address */
-                } PACKED msg;
-                unchar       data[12];          /* buffer for rtc data, ... */
+                    u32  msg_handle;        /* message handle */
+                    u64  msg_addr;          /* message buffer address */
+                } __attribute__((packed)) msg;
+                u8       data[12];          /* buffer for rtc data, ... */
             } su;
-        } PACKED screen;                        /* screen service cmd. str. */
+        } __attribute__((packed)) screen;                        /* screen service cmd. str. */
         struct {
-            ushort      reserved;
-            ulong32     direction;              /* data direction */
-            ulong32     mdisc_time;             /* disc. time (0: no timeout)*/
-            ulong32     mcon_time;              /* connect time(0: no to.) */
-            ulong32     sdata;                  /* dest. addr. (if s/g: -1) */
-            ulong32     sdlen;                  /* data length (bytes) */
-            ulong32     clen;                   /* SCSI cmd. length(6,10,12) */
-            unchar      cmd[12];                /* SCSI command */
-            unchar      target;                 /* target ID */
-            unchar      lun;                    /* LUN */
-            unchar      bus;                    /* SCSI bus number */
-            unchar      priority;               /* only 0 used */
-            ulong32     sense_len;              /* sense data length */
-            ulong32     sense_data;             /* sense data addr. */
-            ulong32     link_p;                 /* linked cmds (not supp.) */
-            ulong32     sg_ranz;                /* s/g element count */
+            u16      reserved;
+            u32     direction;              /* data direction */
+            u32     mdisc_time;             /* disc. time (0: no timeout)*/
+            u32     mcon_time;              /* connect time(0: no to.) */
+            u32     sdata;                  /* dest. addr. (if s/g: -1) */
+            u32     sdlen;                  /* data length (bytes) */
+            u32     clen;                   /* SCSI cmd. length(6,10,12) */
+            u8      cmd[12];                /* SCSI command */
+            u8      target;                 /* target ID */
+            u8      lun;                    /* LUN */
+            u8      bus;                    /* SCSI bus number */
+            u8      priority;               /* only 0 used */
+            u32     sense_len;              /* sense data length */
+            u32     sense_data;             /* sense data addr. */
+            u32     link_p;                 /* linked cmds (not supp.) */
+            u32     sg_ranz;                /* s/g element count */
             gdth_sg_str sg_lst[GDTH_MAXSG];     /* s/g list */
-        } PACKED raw;                           /* raw service cmd. struct. */
+        } __attribute__((packed)) raw;                           /* raw service cmd. struct. */
         struct {
-            ushort      reserved;
-            ulong32     direction;              /* data direction */
-            ulong32     mdisc_time;             /* disc. time (0: no timeout)*/
-            ulong32     mcon_time;              /* connect time(0: no to.) */
-            ulong64     sdata;                  /* dest. addr. (if s/g: -1) */
-            ulong32     sdlen;                  /* data length (bytes) */
-            ulong32     clen;                   /* SCSI cmd. length(6,..,16) */
-            unchar      cmd[16];                /* SCSI command */
-            unchar      target;                 /* target ID */
-            unchar      lun;                    /* LUN */
-            unchar      bus;                    /* SCSI bus number */
-            unchar      priority;               /* only 0 used */
-            ulong32     sense_len;              /* sense data length */
-            ulong64     sense_data;             /* sense data addr. */
-            ulong32     sg_ranz;                /* s/g element count */
+            u16      reserved;
+            u32     direction;              /* data direction */
+            u32     mdisc_time;             /* disc. time (0: no timeout)*/
+            u32     mcon_time;              /* connect time(0: no to.) */
+            u64     sdata;                  /* dest. addr. (if s/g: -1) */
+            u32     sdlen;                  /* data length (bytes) */
+            u32     clen;                   /* SCSI cmd. length(6,..,16) */
+            u8      cmd[16];                /* SCSI command */
+            u8      target;                 /* target ID */
+            u8      lun;                    /* LUN */
+            u8      bus;                    /* SCSI bus number */
+            u8      priority;               /* only 0 used */
+            u32     sense_len;              /* sense data length */
+            u64     sense_data;             /* sense data addr. */
+            u32     sg_ranz;                /* s/g element count */
             gdth_sg64_str sg_lst[GDTH_MAXSG];   /* s/g list */
-        } PACKED raw64;                         /* raw service cmd. struct. */
+        } __attribute__((packed)) raw64;                         /* raw service cmd. struct. */
     } u;
     /* additional variables */
-    unchar      Service;                        /* controller service */
-    unchar      reserved;
-    ushort      Status;                         /* command result */
-    ulong32     Info;                           /* additional information */
+    u8      Service;                        /* controller service */
+    u8      reserved;
+    u16      Status;                         /* command result */
+    u32     Info;                           /* additional information */
     void        *RequestBuffer;                 /* request buffer */
-} PACKED gdth_cmd_str;
+} __attribute__((packed)) gdth_cmd_str;
 
 /* controller event structure */
 #define ES_ASYNC    1
@@ -142,129 +134,129 @@ typedef struct {
 #define ES_TEST     3
 #define ES_SYNC     4
 typedef struct {
-    ushort                  size;               /* size of structure */
+    u16                  size;               /* size of structure */
     union {
         char                stream[16];
         struct {
-            ushort          ionode;
-            ushort          service;
-            ulong32         index;
-        } PACKED driver;
+            u16          ionode;
+            u16          service;
+            u32         index;
+        } __attribute__((packed)) driver;
         struct {
-            ushort          ionode;
-            ushort          service;
-            ushort          status;
-            ulong32         info;
-            unchar          scsi_coord[3];
-        } PACKED async;
+            u16          ionode;
+            u16          service;
+            u16          status;
+            u32         info;
+            u8          scsi_coord[3];
+        } __attribute__((packed)) async;
         struct {
-            ushort          ionode;
-            ushort          service;
-            ushort          status;
-            ulong32         info;
-            ushort          hostdrive;
-            unchar          scsi_coord[3];
-            unchar          sense_key;
-        } PACKED sync;
+            u16          ionode;
+            u16          service;
+            u16          status;
+            u32         info;
+            u16          hostdrive;
+            u8          scsi_coord[3];
+            u8          sense_key;
+        } __attribute__((packed)) sync;
         struct {
-            ulong32         l1, l2, l3, l4;
-        } PACKED test;
+            u32         l1, l2, l3, l4;
+        } __attribute__((packed)) test;
     } eu;
-    ulong32                 severity;
-    unchar                  event_string[256];          
-} PACKED gdth_evt_data;
+    u32                 severity;
+    u8                  event_string[256];          
+} __attribute__((packed)) gdth_evt_data;
 
 typedef struct {
-    ulong32         first_stamp;
-    ulong32         last_stamp;
-    ushort          same_count;
-    ushort          event_source;
-    ushort          event_idx;
-    unchar          application;
-    unchar          reserved;
+    u32         first_stamp;
+    u32         last_stamp;
+    u16          same_count;
+    u16          event_source;
+    u16          event_idx;
+    u8          application;
+    u8          reserved;
     gdth_evt_data   event_data;
-} PACKED gdth_evt_str;
+} __attribute__((packed)) gdth_evt_str;
 
 
 #ifdef GDTH_IOCTL_PROC
 /* IOCTL structure (write) */
 typedef struct {
-    ulong32                 magic;              /* IOCTL magic */
-    ushort                  ioctl;              /* IOCTL */
-    ushort                  ionode;             /* controller number */
-    ushort                  service;            /* controller service */
-    ushort                  timeout;            /* timeout */
+    u32                 magic;              /* IOCTL magic */
+    u16                  ioctl;              /* IOCTL */
+    u16                  ionode;             /* controller number */
+    u16                  service;            /* controller service */
+    u16                  timeout;            /* timeout */
     union {
         struct {
-            unchar          command[512];       /* controller command */
-            unchar          data[1];            /* add. data */
+            u8          command[512];       /* controller command */
+            u8          data[1];            /* add. data */
         } general;
         struct {
-            unchar          lock;               /* lock/unlock */
-            unchar          drive_cnt;          /* drive count */
-            ushort          drives[MAX_HDRIVES];/* drives */
+            u8          lock;               /* lock/unlock */
+            u8          drive_cnt;          /* drive count */
+            u16          drives[MAX_HDRIVES];/* drives */
         } lockdrv;
         struct {
-            unchar          lock;               /* lock/unlock */
-            unchar          channel;            /* channel */
+            u8          lock;               /* lock/unlock */
+            u8          channel;            /* channel */
         } lockchn;
         struct {
             int             erase;              /* erase event ? */
             int             handle;
-            unchar          evt[EVENT_SIZE];    /* event structure */
+            u8          evt[EVENT_SIZE];    /* event structure */
         } event;
         struct {
-            unchar          bus;                /* SCSI bus */
-            unchar          target;             /* target ID */
-            unchar          lun;                /* LUN */
-            unchar          cmd_len;            /* command length */
-            unchar          cmd[12];            /* SCSI command */
+            u8          bus;                /* SCSI bus */
+            u8          target;             /* target ID */
+            u8          lun;                /* LUN */
+            u8          cmd_len;            /* command length */
+            u8          cmd[12];            /* SCSI command */
         } scsi;
         struct {
-            ushort          hdr_no;             /* host drive number */
-            unchar          flag;               /* old meth./add/remove */
+            u16          hdr_no;             /* host drive number */
+            u8          flag;               /* old meth./add/remove */
         } rescan;
     } iu;
 } gdth_iowr_str;
 
 /* IOCTL structure (read) */
 typedef struct {
-    ulong32                 size;               /* buffer size */
-    ulong32                 status;             /* IOCTL error code */
+    u32                 size;               /* buffer size */
+    u32                 status;             /* IOCTL error code */
     union {
         struct {
-            unchar          data[1];            /* data */
+            u8          data[1];            /* data */
         } general;
         struct {
-            ushort          version;            /* driver version */
+            u16          version;            /* driver version */
         } drvers;
         struct {
-            unchar          type;               /* controller type */
-            ushort          info;               /* slot etc. */
-            ushort          oem_id;             /* OEM ID */
-            ushort          bios_ver;           /* not used */
-            ushort          access;             /* not used */
-            ushort          ext_type;           /* extended type */
-            ushort          device_id;          /* device ID */
-            ushort          sub_device_id;      /* sub device ID */
+            u8          type;               /* controller type */
+            u16          info;               /* slot etc. */
+            u16          oem_id;             /* OEM ID */
+            u16          bios_ver;           /* not used */
+            u16          access;             /* not used */
+            u16          ext_type;           /* extended type */
+            u16          device_id;          /* device ID */
+            u16          sub_device_id;      /* sub device ID */
         } ctrtype;
         struct {
-            unchar          version;            /* OS version */
-            unchar          subversion;         /* OS subversion */
-            ushort          revision;           /* revision */
+            u8          version;            /* OS version */
+            u8          subversion;         /* OS subversion */
+            u16          revision;           /* revision */
         } osvers;
         struct {
-            ushort          count;              /* controller count */
+            u16          count;              /* controller count */
         } ctrcnt;
         struct {
             int             handle;
-            unchar          evt[EVENT_SIZE];    /* event structure */
+            u8          evt[EVENT_SIZE];    /* event structure */
         } event;
         struct {
-            unchar          bus;                /* SCSI bus, 0xff: invalid */
-            unchar          target;             /* target ID */
-            unchar          lun;                /* LUN */
-            unchar          cluster_type;       /* cluster properties */
+            u8          bus;                /* SCSI bus, 0xff: invalid */
+            u8          target;             /* target ID */
+            u8          lun;                /* LUN */
+            u8          cluster_type;       /* cluster properties */
         } hdr_list[MAX_HDRIVES];                /* index is host drive number */
     } iu;
 } gdth_iord_str;
@@ -272,53 +264,53 @@ typedef struct {
 
 /* GDTIOCTL_GENERAL */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    ushort timeout;                             /* timeout */
-    ulong32 info;                               /* error info */ 
-    ushort status;                              /* status */
-    ulong data_len;                             /* data buffer size */
-    ulong sense_len;                            /* sense buffer size */
+    u16 ionode;                              /* controller number */
+    u16 timeout;                             /* timeout */
+    u32 info;                               /* error info */ 
+    u16 status;                              /* status */
+    unsigned long data_len;                             /* data buffer size */
+    unsigned long sense_len;                            /* sense buffer size */
     gdth_cmd_str command;                       /* command */                   
 } gdth_ioctl_general;
 
 /* GDTIOCTL_LOCKDRV */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar lock;                                /* lock/unlock */
-    unchar drive_cnt;                           /* drive count */
-    ushort drives[MAX_HDRIVES];                 /* drives */
+    u16 ionode;                              /* controller number */
+    u8 lock;                                /* lock/unlock */
+    u8 drive_cnt;                           /* drive count */
+    u16 drives[MAX_HDRIVES];                 /* drives */
 } gdth_ioctl_lockdrv;
 
 /* GDTIOCTL_LOCKCHN */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar lock;                                /* lock/unlock */
-    unchar channel;                             /* channel */
+    u16 ionode;                              /* controller number */
+    u8 lock;                                /* lock/unlock */
+    u8 channel;                             /* channel */
 } gdth_ioctl_lockchn;
 
 /* GDTIOCTL_OSVERS */
 typedef struct {
-    unchar version;                             /* OS version */
-    unchar subversion;                          /* OS subversion */
-    ushort revision;                            /* revision */
+    u8 version;                             /* OS version */
+    u8 subversion;                          /* OS subversion */
+    u16 revision;                            /* revision */
 } gdth_ioctl_osvers;
 
 /* GDTIOCTL_CTRTYPE */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar type;                                /* controller type */
-    ushort info;                                /* slot etc. */
-    ushort oem_id;                              /* OEM ID */
-    ushort bios_ver;                            /* not used */
-    ushort access;                              /* not used */
-    ushort ext_type;                            /* extended type */
-    ushort device_id;                           /* device ID */
-    ushort sub_device_id;                       /* sub device ID */
+    u16 ionode;                              /* controller number */
+    u8 type;                                /* controller type */
+    u16 info;                                /* slot etc. */
+    u16 oem_id;                              /* OEM ID */
+    u16 bios_ver;                            /* not used */
+    u16 access;                              /* not used */
+    u16 ext_type;                            /* extended type */
+    u16 device_id;                           /* device ID */
+    u16 sub_device_id;                       /* sub device ID */
 } gdth_ioctl_ctrtype;
 
 /* GDTIOCTL_EVENT */
 typedef struct {
-    ushort ionode;
+    u16 ionode;
     int erase;                                  /* erase event? */
     int handle;                                 /* event handle */
     gdth_evt_str event;
@@ -326,22 +318,22 @@ typedef struct {
 
 /* GDTIOCTL_RESCAN/GDTIOCTL_HDRLIST */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    unchar flag;                                /* add/remove */
-    ushort hdr_no;                              /* drive no. */
+    u16 ionode;                              /* controller number */
+    u8 flag;                                /* add/remove */
+    u16 hdr_no;                              /* drive no. */
     struct {
-        unchar bus;                             /* SCSI bus */
-        unchar target;                          /* target ID */
-        unchar lun;                             /* LUN */
-        unchar cluster_type;                    /* cluster properties */
+        u8 bus;                             /* SCSI bus */
+        u8 target;                          /* target ID */
+        u8 lun;                             /* LUN */
+        u8 cluster_type;                    /* cluster properties */
     } hdr_list[MAX_HDRIVES];                    /* index is host drive number */
 } gdth_ioctl_rescan;
 
 /* GDTIOCTL_RESET_BUS/GDTIOCTL_RESET_DRV */
 typedef struct {
-    ushort ionode;                              /* controller number */
-    ushort number;                              /* bus/host drive number */
-    ushort status;                              /* status */
+    u16 ionode;                              /* controller number */
+    u16 number;                              /* bus/host drive number */
+    u16 status;                              /* status */
 } gdth_ioctl_reset;
 
 #endif
diff --git a/drivers/scsi/gdth_proc.c b/drivers/scsi/gdth_proc.c
index 1258da34fbc2..ffb2b21992ba 100644
--- a/drivers/scsi/gdth_proc.c
+++ b/drivers/scsi/gdth_proc.c
@@ -43,7 +43,7 @@ static int gdth_set_asc_info(struct Scsi_Host *host, char *buffer,
     int i, found;
     gdth_cmd_str    gdtcmd;
     gdth_cpar_str   *pcpar;
-    ulong64         paddr;
+    u64         paddr;
 
     char            cmnd[MAX_COMMAND_SIZE];
     memset(cmnd, 0xff, 12);
@@ -156,8 +156,8 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
     off_t begin = 0,pos = 0;
     int id, i, j, k, sec, flag;
     int no_mdrv = 0, drv_no, is_mirr;
-    ulong32 cnt;
-    ulong64 paddr;
+    u32 cnt;
+    u64 paddr;
     int rc = -ENOMEM;
 
     gdth_cmd_str *gdtcmd;
@@ -220,14 +220,14 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
 
     if (ha->more_proc)
         sprintf(hrec, "%d.%02d.%02d-%c%03X", 
-                (unchar)(ha->binfo.upd_fw_ver>>24),
-                (unchar)(ha->binfo.upd_fw_ver>>16),
-                (unchar)(ha->binfo.upd_fw_ver),
+                (u8)(ha->binfo.upd_fw_ver>>24),
+                (u8)(ha->binfo.upd_fw_ver>>16),
+                (u8)(ha->binfo.upd_fw_ver),
                 ha->bfeat.raid ? 'R':'N',
                 ha->binfo.upd_revision);
     else
-        sprintf(hrec, "%d.%02d", (unchar)(ha->cpar.version>>8),
-                (unchar)(ha->cpar.version));
+        sprintf(hrec, "%d.%02d", (u8)(ha->cpar.version>>8),
+                (u8)(ha->cpar.version));
 
     size = sprintf(buffer+len,
                    " Driver Ver.:  \t%-10s\tFirmware Ver.: \t%s\n",
@@ -281,7 +281,7 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
             pds->bid = ha->raw[i].local_no;
             pds->first = 0;
             pds->entries = ha->raw[i].pdev_cnt;
-            cnt = (3*GDTH_SCRATCH/4 - 5 * sizeof(ulong32)) /
+            cnt = (3*GDTH_SCRATCH/4 - 5 * sizeof(u32)) /
                 sizeof(pds->list[0]);
             if (pds->entries > cnt)
                 pds->entries = cnt;
@@ -604,7 +604,7 @@ static int gdth_get_info(char *buffer,char **start,off_t offset,int length,
 
             size = sprintf(buffer+len,
                            " Capacity [MB]:\t%-6d    \tStart Sector:  \t%d\n",
-                           (ulong32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
+                           (u32)(ha->hdr[i].size/2048), ha->hdr[i].start_sec);
             len += size;  pos = begin + len;
             if (pos < offset) {
                 len = 0;
@@ -664,9 +664,9 @@ free_fail:
 }
 
 static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
-                              ulong64 *paddr)
+                              u64 *paddr)
 {
-    ulong flags;
+    unsigned long flags;
     char *ret_val;
 
     if (size == 0)
@@ -691,9 +691,9 @@ static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
     return ret_val;
 }
 
-static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr)
+static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, u64 paddr)
 {
-    ulong flags;
+    unsigned long flags;
 
     if (buf == ha->pscratch) {
         spin_lock_irqsave(&ha->smp_lock, flags);
@@ -705,16 +705,16 @@ static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr)
 }
 
 #ifdef GDTH_IOCTL_PROC
-static int gdth_ioctl_check_bin(gdth_ha_str *ha, ushort size)
+static int gdth_ioctl_check_bin(gdth_ha_str *ha, u16 size)
 {
-    ulong flags;
+    unsigned long flags;
     int ret_val;
 
     spin_lock_irqsave(&ha->smp_lock, flags);
 
     ret_val = FALSE;
     if (ha->scratch_busy) {
-        if (((gdth_iord_str *)ha->pscratch)->size == (ulong32)size)
+        if (((gdth_iord_str *)ha->pscratch)->size == (u32)size)
             ret_val = TRUE;
     }
     spin_unlock_irqrestore(&ha->smp_lock, flags);
@@ -724,11 +724,11 @@ static int gdth_ioctl_check_bin(gdth_ha_str *ha, ushort size)
 
 static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
 {
-    ulong flags;
+    unsigned long flags;
     int i;
     Scsi_Cmnd *scp;
     struct gdth_cmndinfo *cmndinfo;
-    unchar b, t;
+    u8 b, t;
 
     spin_lock_irqsave(&ha->smp_lock, flags);
 
@@ -738,8 +738,8 @@ static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id)
 
         b = scp->device->channel;
         t = scp->device->id;
-        if (!SPECIAL_SCP(scp) && t == (unchar)id && 
-            b == (unchar)busnum) {
+        if (!SPECIAL_SCP(scp) && t == (u8)id && 
+            b == (u8)busnum) {
             cmndinfo->wait_for_completion = 0;
             spin_unlock_irqrestore(&ha->smp_lock, flags);
             while (!cmndinfo->wait_for_completion)
diff --git a/drivers/scsi/gdth_proc.h b/drivers/scsi/gdth_proc.h
index 9b900cc9ebe8..dab15f59f2cc 100644
--- a/drivers/scsi/gdth_proc.h
+++ b/drivers/scsi/gdth_proc.h
@@ -17,8 +17,8 @@ static int gdth_set_asc_info(struct Scsi_Host *host, char *buffer,
                              int length, gdth_ha_str *ha);
 
 static char *gdth_ioctl_alloc(gdth_ha_str *ha, int size, int scratch,
-                              ulong64 *paddr);
-static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, ulong64 paddr);
+                              u64 *paddr);
+static void gdth_ioctl_free(gdth_ha_str *ha, int size, char *buf, u64 paddr);
 static void gdth_wait_completion(gdth_ha_str *ha, int busnum, int id);
 
 #endif
diff --git a/drivers/scsi/hpsa.c b/drivers/scsi/hpsa.c
index bb96fdd58e23..03697ba94251 100644
--- a/drivers/scsi/hpsa.c
+++ b/drivers/scsi/hpsa.c
@@ -52,7 +52,7 @@
 #include "hpsa.h"
 
 /* HPSA_DRIVER_VERSION must be 3 byte values (0-255) separated by '.' */
-#define HPSA_DRIVER_VERSION "1.0.0"
+#define HPSA_DRIVER_VERSION "2.0.1-3"
 #define DRIVER_NAME "HP HPSA Driver (v " HPSA_DRIVER_VERSION ")"
 
 /* How long to wait (in milliseconds) for board to go into simple mode */
@@ -77,9 +77,6 @@ MODULE_PARM_DESC(hpsa_allow_any,
 
 /* define the PCI info for the cards we can control */
 static const struct pci_device_id hpsa_pci_device_id[] = {
-        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3223},
-        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x3234},
-        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSC,     0x103C, 0x323D},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3241},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3243},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3245},
@@ -87,6 +84,9 @@ static const struct pci_device_id hpsa_pci_device_id[] = {
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3249},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x324a},
         {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x324b},
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSE,     0x103C, 0x3233},
+#define PCI_DEVICE_ID_HP_CISSF 0x333f
+        {PCI_VENDOR_ID_HP,     PCI_DEVICE_ID_HP_CISSF,     0x103C, 0x333F},
         {PCI_VENDOR_ID_HP,     PCI_ANY_ID,             PCI_ANY_ID, PCI_ANY_ID,
                 PCI_CLASS_STORAGE_RAID << 8, 0xffff << 8, 0},
         {0,}
@@ -99,9 +99,6 @@ MODULE_DEVICE_TABLE(pci, hpsa_pci_device_id);
  *  access = Address of the struct of function pointers
  */
 static struct board_type products[] = {
-        {0x3223103C, "Smart Array P800", &SA5_access},
-        {0x3234103C, "Smart Array P400", &SA5_access},
-        {0x323d103c, "Smart Array P700M", &SA5_access},
         {0x3241103C, "Smart Array P212", &SA5_access},
         {0x3243103C, "Smart Array P410", &SA5_access},
         {0x3245103C, "Smart Array P410i", &SA5_access},
@@ -109,6 +106,8 @@ static struct board_type products[] = {
         {0x3249103C, "Smart Array P812", &SA5_access},
         {0x324a103C, "Smart Array P712m", &SA5_access},
         {0x324b103C, "Smart Array P711m", &SA5_access},
+        {0x3233103C, "StorageWorks P1210m", &SA5_access},
+        {0x333F103C, "StorageWorks P1210m", &SA5_access},
         {0xFFFF103C, "Unknown Smart Array", &SA5_access},
 };
 
@@ -126,12 +125,15 @@ static void cmd_free(struct ctlr_info *h, struct CommandList *c);
 static void cmd_special_free(struct ctlr_info *h, struct CommandList *c);
 static struct CommandList *cmd_alloc(struct ctlr_info *h);
 static struct CommandList *cmd_special_alloc(struct ctlr_info *h);
-static void fill_cmd(struct CommandList *c, __u8 cmd, struct ctlr_info *h,
-        void *buff, size_t size, __u8 page_code, unsigned char *scsi3addr,
+static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
+        void *buff, size_t size, u8 page_code, unsigned char *scsi3addr,
         int cmd_type);
 
 static int hpsa_scsi_queue_command(struct scsi_cmnd *cmd,
                 void (*done)(struct scsi_cmnd *));
+static void hpsa_scan_start(struct Scsi_Host *);
+static int hpsa_scan_finished(struct Scsi_Host *sh,
+        unsigned long elapsed_time);
 
 static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd);
 static int hpsa_slave_alloc(struct scsi_device *sdev);
@@ -150,6 +152,11 @@ static int check_for_unit_attention(struct ctlr_info *h,
         struct CommandList *c);
 static void check_ioctl_unit_attention(struct ctlr_info *h,
         struct CommandList *c);
+/* performant mode helper functions */
+static void calc_bucket_map(int *bucket, int num_buckets,
+        int nsgs, int *bucket_map);
+static void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h);
+static inline u32 next_command(struct ctlr_info *h);
 
 static DEVICE_ATTR(raid_level, S_IRUGO, raid_level_show, NULL);
 static DEVICE_ATTR(lunid, S_IRUGO, lunid_show, NULL);
@@ -173,10 +180,10 @@ static struct scsi_host_template hpsa_driver_template = {
         .name                   = "hpsa",
         .proc_name              = "hpsa",
         .queuecommand           = hpsa_scsi_queue_command,
-        .can_queue              = 512,
+        .scan_start             = hpsa_scan_start,
+        .scan_finished          = hpsa_scan_finished,
         .this_id                = -1,
         .sg_tablesize           = MAXSGENTRIES,
-        .cmd_per_lun            = 512,
         .use_clustering         = ENABLE_CLUSTERING,
         .eh_device_reset_handler = hpsa_eh_device_reset_handler,
         .ioctl                  = hpsa_ioctl,
@@ -195,6 +202,12 @@ static inline struct ctlr_info *sdev_to_hba(struct scsi_device *sdev)
         return (struct ctlr_info *) *priv;
 }
 
+static inline struct ctlr_info *shost_to_hba(struct Scsi_Host *sh)
+{
+        unsigned long *priv = shost_priv(sh);
+        return (struct ctlr_info *) *priv;
+}
+
 static struct task_struct *hpsa_scan_thread;
 static DEFINE_MUTEX(hpsa_scan_mutex);
 static LIST_HEAD(hpsa_scan_q);
@@ -312,7 +325,7 @@ static int hpsa_scan_func(__attribute__((unused)) void *data)
                         h->busy_scanning = 1;
                         mutex_unlock(&hpsa_scan_mutex);
                         host_no = h->scsi_host ?  h->scsi_host->host_no : -1;
-                        hpsa_update_scsi_devices(h, host_no);
+                        hpsa_scan_start(h->scsi_host);
                         complete_all(&h->scan_wait);
                         mutex_lock(&hpsa_scan_mutex);
                         h->busy_scanning = 0;
@@ -379,8 +392,7 @@ static ssize_t host_store_rescan(struct device *dev,
 {
         struct ctlr_info *h;
         struct Scsi_Host *shost = class_to_shost(dev);
-        unsigned long *priv = shost_priv(shost);
-        h = (struct ctlr_info *) *priv;
+        h = shost_to_hba(shost);
         if (add_to_scan_list(h)) {
                 wake_up_process(hpsa_scan_thread);
                 wait_for_completion_interruptible(&h->scan_wait);
@@ -394,10 +406,44 @@ static inline void addQ(struct hlist_head *list, struct CommandList *c)
         hlist_add_head(&c->list, list);
 }
 
+static inline u32 next_command(struct ctlr_info *h)
+{
+        u32 a;
+
+        if (unlikely(h->transMethod != CFGTBL_Trans_Performant))
+                return h->access.command_completed(h);
+
+        if ((*(h->reply_pool_head) & 1) == (h->reply_pool_wraparound)) {
+                a = *(h->reply_pool_head); /* Next cmd in ring buffer */
+                (h->reply_pool_head)++;
+                h->commands_outstanding--;
+        } else {
+                a = FIFO_EMPTY;
+        }
+        /* Check for wraparound */
+        if (h->reply_pool_head == (h->reply_pool + h->max_commands)) {
+                h->reply_pool_head = h->reply_pool;
+                h->reply_pool_wraparound ^= 1;
+        }
+        return a;
+}
+
+/* set_performant_mode: Modify the tag for cciss performant
+ * set bit 0 for pull model, bits 3-1 for block fetch
+ * register number
+ */
+static void set_performant_mode(struct ctlr_info *h, struct CommandList *c)
+{
+        if (likely(h->transMethod == CFGTBL_Trans_Performant))
+                c->busaddr |= 1 | (h->blockFetchTable[c->Header.SGList] << 1);
+}
+
 static void enqueue_cmd_and_start_io(struct ctlr_info *h,
         struct CommandList *c)
 {
         unsigned long flags;
+
+        set_performant_mode(h, c);
         spin_lock_irqsave(&h->lock, flags);
         addQ(&h->reqQ, c);
         h->Qdepth++;
@@ -422,6 +468,15 @@ static inline int is_logical_dev_addr_mode(unsigned char scsi3addr[])
         return (scsi3addr[3] & 0xC0) == 0x40;
 }
 
+static inline int is_scsi_rev_5(struct ctlr_info *h)
+{
+        if (!h->hba_inquiry_data)
+                return 0;
+        if ((h->hba_inquiry_data[2] & 0x07) == 5)
+                return 1;
+        return 0;
+}
+
 static const char *raid_label[] = { "0", "4", "1(1+0)", "5", "5+1", "ADG",
         "UNKNOWN"
 };
@@ -431,7 +486,7 @@ static ssize_t raid_level_show(struct device *dev,
              struct device_attribute *attr, char *buf)
 {
         ssize_t l = 0;
-        int rlevel;
+        unsigned char rlevel;
         struct ctlr_info *h;
         struct scsi_device *sdev;
         struct hpsa_scsi_dev_t *hdev;
@@ -455,7 +510,7 @@ static ssize_t raid_level_show(struct device *dev,
 
         rlevel = hdev->raid_level;
         spin_unlock_irqrestore(&h->lock, flags);
-        if (rlevel < 0 || rlevel > RAID_UNKNOWN)
+        if (rlevel > RAID_UNKNOWN)
                 rlevel = RAID_UNKNOWN;
         l = snprintf(buf, PAGE_SIZE, "RAID %s\n", raid_label[rlevel]);
         return l;
@@ -620,6 +675,24 @@ lun_assigned:
         return 0;
 }
 
+/* Replace an entry from h->dev[] array. */
+static void hpsa_scsi_replace_entry(struct ctlr_info *h, int hostno,
+        int entry, struct hpsa_scsi_dev_t *new_entry,
+        struct hpsa_scsi_dev_t *added[], int *nadded,
+        struct hpsa_scsi_dev_t *removed[], int *nremoved)
+{
+        /* assumes h->devlock is held */
+        BUG_ON(entry < 0 || entry >= HPSA_MAX_SCSI_DEVS_PER_HBA);
+        removed[*nremoved] = h->dev[entry];
+        (*nremoved)++;
+        h->dev[entry] = new_entry;
+        added[*nadded] = new_entry;
+        (*nadded)++;
+        dev_info(&h->pdev->dev, "%s device c%db%dt%dl%d changed.\n",
+                scsi_device_type(new_entry->devtype), hostno, new_entry->bus,
+                        new_entry->target, new_entry->lun);
+}
+
 /* Remove an entry from h->dev[] array. */
 static void hpsa_scsi_remove_entry(struct ctlr_info *h, int hostno, int entry,
         struct hpsa_scsi_dev_t *removed[], int *nremoved)
@@ -628,8 +701,7 @@ static void hpsa_scsi_remove_entry(struct ctlr_info *h, int hostno, int entry,
         int i;
         struct hpsa_scsi_dev_t *sd;
 
-        if (entry < 0 || entry >= HPSA_MAX_SCSI_DEVS_PER_HBA)
-                BUG();
+        BUG_ON(entry < 0 || entry >= HPSA_MAX_SCSI_DEVS_PER_HBA);
 
         sd = h->dev[entry];
         removed[*nremoved] = h->dev[entry];
@@ -722,6 +794,8 @@ static int hpsa_scsi_find_entry(struct hpsa_scsi_dev_t *needle,
 #define DEVICE_CHANGED 1
 #define DEVICE_SAME 2
         for (i = 0; i < haystack_size; i++) {
+                if (haystack[i] == NULL) /* previously removed. */
+                        continue;
                 if (SCSI3ADDR_EQ(needle->scsi3addr, haystack[i]->scsi3addr)) {
                         *index = i;
                         if (device_is_the_same(needle, haystack[i]))
@@ -734,7 +808,7 @@ static int hpsa_scsi_find_entry(struct hpsa_scsi_dev_t *needle,
         return DEVICE_NOT_FOUND;
 }
 
-static int adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
+static void adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
         struct hpsa_scsi_dev_t *sd[], int nsds)
 {
         /* sd contains scsi3 addresses and devtypes, and inquiry
@@ -779,12 +853,12 @@ static int adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
                         continue; /* remove ^^^, hence i not incremented */
                 } else if (device_change == DEVICE_CHANGED) {
                         changes++;
-                        hpsa_scsi_remove_entry(h, hostno, i,
-                                removed, &nremoved);
-                        (void) hpsa_scsi_add_entry(h, hostno, sd[entry],
-                                added, &nadded);
-                        /* add can't fail, we just removed one. */
-                        sd[entry] = NULL; /* prevent it from being freed */
+                        hpsa_scsi_replace_entry(h, hostno, i, sd[entry],
+                                added, &nadded, removed, &nremoved);
+                        /* Set it to NULL to prevent it from being freed
+                         * at the bottom of hpsa_update_scsi_devices()
+                         */
+                        sd[entry] = NULL;
                 }
                 i++;
         }
@@ -860,7 +934,6 @@ static int adjust_hpsa_scsi_table(struct ctlr_info *h, int hostno,
 free_and_out:
         kfree(added);
         kfree(removed);
-        return 0;
 }
 
 /*
@@ -900,7 +973,7 @@ static int hpsa_slave_alloc(struct scsi_device *sdev)
 
 static void hpsa_slave_destroy(struct scsi_device *sdev)
 {
-        return; /* nothing to do. */
+        /* nothing to do. */
 }
 
 static void hpsa_scsi_setup(struct ctlr_info *h)
@@ -908,11 +981,10 @@ static void hpsa_scsi_setup(struct ctlr_info *h)
         h->ndevices = 0;
         h->scsi_host = NULL;
         spin_lock_init(&h->devlock);
-        return;
 }
 
 static void complete_scsi_command(struct CommandList *cp,
-        int timeout, __u32 tag)
+        int timeout, u32 tag)
 {
         struct scsi_cmnd *cmd;
         struct ctlr_info *h;
@@ -987,7 +1059,6 @@ static void complete_scsi_command(struct CommandList *cp,
                                  * required
                                  */
                                 if ((asc == 0x04) && (ascq == 0x03)) {
-                                        cmd->result = DID_NO_CONNECT << 16;
                                         dev_warn(&h->pdev->dev, "cp %p "
                                                 "has check condition: unit "
                                                 "not ready, manual "
@@ -995,14 +1066,22 @@ static void complete_scsi_command(struct CommandList *cp,
                                         break;
                                 }
                         }
-
-
+                        if (sense_key == ABORTED_COMMAND) {
+                                /* Aborted command is retryable */
+                                dev_warn(&h->pdev->dev, "cp %p "
+                                        "has check condition: aborted command: "
+                                        "ASC: 0x%x, ASCQ: 0x%x\n",
+                                        cp, asc, ascq);
+                                cmd->result = DID_SOFT_ERROR << 16;
+                                break;
+                        }
                         /* Must be some other type of check condition */
                         dev_warn(&h->pdev->dev, "cp %p has check condition: "
                                         "unknown type: "
                                         "Sense: 0x%x, ASC: 0x%x, ASCQ: 0x%x, "
                                         "Returning result: 0x%x, "
                                         "cmd=[%02x %02x %02x %02x %02x "
+                                        "%02x %02x %02x %02x %02x %02x "
                                         "%02x %02x %02x %02x %02x]\n",
                                         cp, sense_key, asc, ascq,
                                         cmd->result,
@@ -1010,7 +1089,10 @@ static void complete_scsi_command(struct CommandList *cp,
                                         cmd->cmnd[2], cmd->cmnd[3],
                                         cmd->cmnd[4], cmd->cmnd[5],
                                         cmd->cmnd[6], cmd->cmnd[7],
-                                        cmd->cmnd[8], cmd->cmnd[9]);
+                                        cmd->cmnd[8], cmd->cmnd[9],
+                                        cmd->cmnd[10], cmd->cmnd[11],
+                                        cmd->cmnd[12], cmd->cmnd[13],
+                                        cmd->cmnd[14], cmd->cmnd[15]);
                         break;
                 }
 
@@ -1086,7 +1168,7 @@ static void complete_scsi_command(struct CommandList *cp,
                 dev_warn(&h->pdev->dev, "cp %p reports abort failed\n", cp);
                 break;
         case CMD_UNSOLICITED_ABORT:
-                cmd->result = DID_ABORT << 16;
+                cmd->result = DID_RESET << 16;
                 dev_warn(&h->pdev->dev, "cp %p aborted do to an unsolicited "
                         "abort\n", cp);
                 break;
@@ -1119,9 +1201,11 @@ static int hpsa_scsi_detect(struct ctlr_info *h)
         sh->max_cmd_len = MAX_COMMAND_SIZE;
         sh->max_lun = HPSA_MAX_LUN;
         sh->max_id = HPSA_MAX_LUN;
+        sh->can_queue = h->nr_cmds;
+        sh->cmd_per_lun = h->nr_cmds;
         h->scsi_host = sh;
         sh->hostdata[0] = (unsigned long) h;
-        sh->irq = h->intr[SIMPLE_MODE_INT];
+        sh->irq = h->intr[PERF_MODE_INT];
         sh->unique_id = sh->irq;
         error = scsi_add_host(sh, &h->pdev->dev);
         if (error)
@@ -1133,11 +1217,11 @@ static int hpsa_scsi_detect(struct ctlr_info *h)
         dev_err(&h->pdev->dev, "hpsa_scsi_detect: scsi_add_host"
                 " failed for controller %d\n", h->ctlr);
         scsi_host_put(sh);
-        return -1;
+        return error;
  fail:
         dev_err(&h->pdev->dev, "hpsa_scsi_detect: scsi_host_alloc"
                 " failed for controller %d\n", h->ctlr);
-        return -1;
+        return -ENOMEM;
 }
 
 static void hpsa_pci_unmap(struct pci_dev *pdev,
@@ -1160,7 +1244,7 @@ static void hpsa_map_one(struct pci_dev *pdev,
                 size_t buflen,
                 int data_direction)
 {
-        __u64 addr64;
+        u64 addr64;
 
         if (buflen == 0 || data_direction == PCI_DMA_NONE) {
                 cp->Header.SGList = 0;
@@ -1168,14 +1252,14 @@ static void hpsa_map_one(struct pci_dev *pdev,
                 return;
         }
 
-        addr64 = (__u64) pci_map_single(pdev, buf, buflen, data_direction);
+        addr64 = (u64) pci_map_single(pdev, buf, buflen, data_direction);
         cp->SG[0].Addr.lower =
-          (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
+          (u32) (addr64 & (u64) 0x00000000FFFFFFFF);
         cp->SG[0].Addr.upper =
-          (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
+          (u32) ((addr64 >> 32) & (u64) 0x00000000FFFFFFFF);
         cp->SG[0].Len = buflen;
-        cp->Header.SGList = (__u8) 1;   /* no. SGs contig in this cmd */
-        cp->Header.SGTotal = (__u16) 1; /* total sgs in this cmd list */
+        cp->Header.SGList = (u8) 1;   /* no. SGs contig in this cmd */
+        cp->Header.SGTotal = (u16) 1; /* total sgs in this cmd list */
 }
 
 static inline void hpsa_scsi_do_simple_cmd_core(struct ctlr_info *h,
@@ -1274,7 +1358,7 @@ static int hpsa_scsi_do_inquiry(struct ctlr_info *h, unsigned char *scsi3addr,
 
         if (c == NULL) {                        /* trouble... */
                 dev_warn(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
-                return -1;
+                return -ENOMEM;
         }
 
         fill_cmd(c, HPSA_INQUIRY, h, buf, bufsize, page, scsi3addr, TYPE_CMD);
@@ -1366,9 +1450,8 @@ static int hpsa_scsi_do_report_luns(struct ctlr_info *h, int logical,
                 dev_err(&h->pdev->dev, "cmd_special_alloc returned NULL!\n");
                 return -1;
         }
-
-        memset(&scsi3addr[0], 0, 8); /* address the controller */
-
+        /* address the controller */
+        memset(scsi3addr, 0, sizeof(scsi3addr));
         fill_cmd(c, logical ? HPSA_REPORT_LOG : HPSA_REPORT_PHYS, h,
                 buf, bufsize, 0, scsi3addr, TYPE_CMD);
         if (extended_response)
@@ -1409,13 +1492,12 @@ static int hpsa_update_device_info(struct ctlr_info *h,
         unsigned char scsi3addr[], struct hpsa_scsi_dev_t *this_device)
 {
 #define OBDR_TAPE_INQ_SIZE 49
-        unsigned char *inq_buff = NULL;
+        unsigned char *inq_buff;
 
-        inq_buff = kmalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
+        inq_buff = kzalloc(OBDR_TAPE_INQ_SIZE, GFP_KERNEL);
         if (!inq_buff)
                 goto bail_out;
 
-        memset(inq_buff, 0, OBDR_TAPE_INQ_SIZE);
         /* Do an inquiry to the device to see what it is. */
         if (hpsa_scsi_do_inquiry(h, scsi3addr, 0, inq_buff,
                 (unsigned char) OBDR_TAPE_INQ_SIZE) != 0) {
@@ -1485,32 +1567,51 @@ static int is_msa2xxx(struct ctlr_info *h, struct hpsa_scsi_dev_t *device)
  * in hpsa_find_target_lun, called by hpsa_scsi_add_entry.)
  */
 static void figure_bus_target_lun(struct ctlr_info *h,
-        __u8 *lunaddrbytes, int *bus, int *target, int *lun,
+        u8 *lunaddrbytes, int *bus, int *target, int *lun,
         struct hpsa_scsi_dev_t *device)
 {
-
-        __u32 lunid;
+        u32 lunid;
 
         if (is_logical_dev_addr_mode(lunaddrbytes)) {
                 /* logical device */
-                memcpy(&lunid, lunaddrbytes, sizeof(lunid));
-                lunid = le32_to_cpu(lunid);
-
-                if (is_msa2xxx(h, device)) {
-                        *bus = 1;
-                        *target = (lunid >> 16) & 0x3fff;
-                        *lun = lunid & 0x00ff;
-                } else {
+                if (unlikely(is_scsi_rev_5(h))) {
+                        /* p1210m, logical drives lun assignments
+                         * match SCSI REPORT LUNS data.
+                         */
+                        lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
                         *bus = 0;
-                        *lun = 0;
-                        *target = lunid & 0x3fff;
+                        *target = 0;
+                        *lun = (lunid & 0x3fff) + 1;
+                } else {
+                        /* not p1210m... */
+                        lunid = le32_to_cpu(*((__le32 *) lunaddrbytes));
+                        if (is_msa2xxx(h, device)) {
+                                /* msa2xxx way, put logicals on bus 1
+                                 * and match target/lun numbers box
+                                 * reports.
+                                 */
+                                *bus = 1;
+                                *target = (lunid >> 16) & 0x3fff;
+                                *lun = lunid & 0x00ff;
+                        } else {
+                                /* Traditional smart array way. */
+                                *bus = 0;
+                                *lun = 0;
+                                *target = lunid & 0x3fff;
+                        }
                 }
         } else {
                 /* physical device */
                 if (is_hba_lunid(lunaddrbytes))
-                        *bus = 3;
+                        if (unlikely(is_scsi_rev_5(h))) {
+                                *bus = 0; /* put p1210m ctlr at 0,0,0 */
+                                *target = 0;
+                                *lun = 0;
+                                return;
+                        } else
+                                *bus = 3; /* traditional smartarray */
                 else
-                        *bus = 2;
+                        *bus = 2; /* physical disk */
                 *target = -1;
                 *lun = -1; /* we will fill these in later. */
         }
@@ -1529,7 +1630,7 @@ static void figure_bus_target_lun(struct ctlr_info *h,
  */
 static int add_msa2xxx_enclosure_device(struct ctlr_info *h,
         struct hpsa_scsi_dev_t *tmpdevice,
-        struct hpsa_scsi_dev_t *this_device, __u8 *lunaddrbytes,
+        struct hpsa_scsi_dev_t *this_device, u8 *lunaddrbytes,
         int bus, int target, int lun, unsigned long lunzerobits[],
         int *nmsa2xxx_enclosures)
 {
@@ -1550,6 +1651,9 @@ static int add_msa2xxx_enclosure_device(struct ctlr_info *h,
         if (is_hba_lunid(scsi3addr))
                 return 0; /* Don't add the RAID controller here. */
 
+        if (is_scsi_rev_5(h))
+                return 0; /* p1210m doesn't need to do this. */
+
 #define MAX_MSA2XXX_ENCLOSURES 32
         if (*nmsa2xxx_enclosures >= MAX_MSA2XXX_ENCLOSURES) {
                 dev_warn(&h->pdev->dev, "Maximum number of MSA2XXX "
@@ -1576,18 +1680,14 @@ static int add_msa2xxx_enclosure_device(struct ctlr_info *h,
  */
 static int hpsa_gather_lun_info(struct ctlr_info *h,
         int reportlunsize,
-        struct ReportLUNdata *physdev, __u32 *nphysicals,
-        struct ReportLUNdata *logdev, __u32 *nlogicals)
+        struct ReportLUNdata *physdev, u32 *nphysicals,
+        struct ReportLUNdata *logdev, u32 *nlogicals)
 {
         if (hpsa_scsi_do_report_phys_luns(h, physdev, reportlunsize, 0)) {
                 dev_err(&h->pdev->dev, "report physical LUNs failed.\n");
                 return -1;
         }
-        memcpy(nphysicals, &physdev->LUNListLength[0], sizeof(*nphysicals));
-        *nphysicals = be32_to_cpu(*nphysicals) / 8;
-#ifdef DEBUG
-        dev_info(&h->pdev->dev, "number of physical luns is %d\n", *nphysicals);
-#endif
+        *nphysicals = be32_to_cpu(*((__be32 *)physdev->LUNListLength)) / 8;
         if (*nphysicals > HPSA_MAX_PHYS_LUN) {
                 dev_warn(&h->pdev->dev, "maximum physical LUNs (%d) exceeded."
                         "  %d LUNs ignored.\n", HPSA_MAX_PHYS_LUN,
@@ -1598,11 +1698,7 @@ static int hpsa_gather_lun_info(struct ctlr_info *h,
                 dev_err(&h->pdev->dev, "report logical LUNs failed.\n");
                 return -1;
         }
-        memcpy(nlogicals, &logdev->LUNListLength[0], sizeof(*nlogicals));
-        *nlogicals = be32_to_cpu(*nlogicals) / 8;
-#ifdef DEBUG
-        dev_info(&h->pdev->dev, "number of logical luns is %d\n", *nlogicals);
-#endif
+        *nlogicals = be32_to_cpu(*((__be32 *) logdev->LUNListLength)) / 8;
         /* Reject Logicals in excess of our max capability. */
         if (*nlogicals > HPSA_MAX_LUN) {
                 dev_warn(&h->pdev->dev,
@@ -1621,6 +1717,31 @@ static int hpsa_gather_lun_info(struct ctlr_info *h,
         return 0;
 }
 
+u8 *figure_lunaddrbytes(struct ctlr_info *h, int raid_ctlr_position, int i,
+        int nphysicals, int nlogicals, struct ReportLUNdata *physdev_list,
+        struct ReportLUNdata *logdev_list)
+{
+        /* Helper function, figure out where the LUN ID info is coming from
+         * given index i, lists of physical and logical devices, where in
+         * the list the raid controller is supposed to appear (first or last)
+         */
+
+        int logicals_start = nphysicals + (raid_ctlr_position == 0);
+        int last_device = nphysicals + nlogicals + (raid_ctlr_position == 0);
+
+        if (i == raid_ctlr_position)
+                return RAID_CTLR_LUNID;
+
+        if (i < logicals_start)
+                return &physdev_list->LUN[i - (raid_ctlr_position == 0)][0];
+
+        if (i < last_device)
+                return &logdev_list->LUN[i - nphysicals -
+                        (raid_ctlr_position == 0)][0];
+        BUG();
+        return NULL;
+}
+
 static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
 {
         /* the idea here is we could get notified
@@ -1636,14 +1757,15 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
         struct ReportLUNdata *physdev_list = NULL;
         struct ReportLUNdata *logdev_list = NULL;
         unsigned char *inq_buff = NULL;
-        __u32 nphysicals = 0;
-        __u32 nlogicals = 0;
-        __u32 ndev_allocated = 0;
+        u32 nphysicals = 0;
+        u32 nlogicals = 0;
+        u32 ndev_allocated = 0;
         struct hpsa_scsi_dev_t **currentsd, *this_device, *tmpdevice;
         int ncurrent = 0;
         int reportlunsize = sizeof(*physdev_list) + HPSA_MAX_PHYS_LUN * 8;
         int i, nmsa2xxx_enclosures, ndevs_to_allocate;
         int bus, target, lun;
+        int raid_ctlr_position;
         DECLARE_BITMAP(lunzerobits, HPSA_MAX_TARGETS_PER_CTLR);
 
         currentsd = kzalloc(sizeof(*currentsd) * HPSA_MAX_SCSI_DEVS_PER_HBA,
@@ -1681,23 +1803,22 @@ static void hpsa_update_scsi_devices(struct ctlr_info *h, int hostno)
                 ndev_allocated++;
         }
 
+        if (unlikely(is_scsi_rev_5(h)))
+                raid_ctlr_position = 0;
+        else
+                raid_ctlr_position = nphysicals + nlogicals;
+
         /* adjust our table of devices */
         nmsa2xxx_enclosures = 0;
         for (i = 0; i < nphysicals + nlogicals + 1; i++) {
-                __u8 *lunaddrbytes;
+                u8 *lunaddrbytes;
 
                 /* Figure out where the LUN ID info is coming from */
-                if (i < nphysicals)
-                        lunaddrbytes = &physdev_list->LUN[i][0];
-                else
-                        if (i < nphysicals + nlogicals)
-                                lunaddrbytes =
-                                        &logdev_list->LUN[i-nphysicals][0];
-                        else /* jam in the RAID controller at the end */
-                                lunaddrbytes = RAID_CTLR_LUNID;
-
+                lunaddrbytes = figure_lunaddrbytes(h, raid_ctlr_position,
+                        i, nphysicals, nlogicals, physdev_list, logdev_list);
                 /* skip masked physical devices. */
-                if (lunaddrbytes[3] & 0xC0 && i < nphysicals)
+                if (lunaddrbytes[3] & 0xC0 &&
+                        i < nphysicals + (raid_ctlr_position == 0))
                         continue;
 
                 /* Get device type, vendor, model, device id */
@@ -1777,7 +1898,6 @@ out:
         kfree(inq_buff);
         kfree(physdev_list);
         kfree(logdev_list);
-        return;
 }
 
 /* hpsa_scatter_gather takes a struct scsi_cmnd, (cmd), and does the pci
@@ -1790,7 +1910,7 @@ static int hpsa_scatter_gather(struct pci_dev *pdev,
 {
         unsigned int len;
         struct scatterlist *sg;
-        __u64 addr64;
+        u64 addr64;
         int use_sg, i;
 
         BUG_ON(scsi_sg_count(cmd) > MAXSGENTRIES);
@@ -1803,20 +1923,20 @@ static int hpsa_scatter_gather(struct pci_dev *pdev,
                 goto sglist_finished;
 
         scsi_for_each_sg(cmd, sg, use_sg, i) {
-                addr64 = (__u64) sg_dma_address(sg);
+                addr64 = (u64) sg_dma_address(sg);
                 len  = sg_dma_len(sg);
                 cp->SG[i].Addr.lower =
-                        (__u32) (addr64 & (__u64) 0x00000000FFFFFFFF);
+                        (u32) (addr64 & (u64) 0x00000000FFFFFFFF);
                 cp->SG[i].Addr.upper =
-                        (__u32) ((addr64 >> 32) & (__u64) 0x00000000FFFFFFFF);
+                        (u32) ((addr64 >> 32) & (u64) 0x00000000FFFFFFFF);
                 cp->SG[i].Len = len;
                 cp->SG[i].Ext = 0;  /* we are not chaining */
         }
 
 sglist_finished:
 
-        cp->Header.SGList = (__u8) use_sg;   /* no. SGs contig in this cmd */
-        cp->Header.SGTotal = (__u16) use_sg; /* total sgs in this cmd list */
+        cp->Header.SGList = (u8) use_sg;   /* no. SGs contig in this cmd */
+        cp->Header.SGTotal = (u16) use_sg; /* total sgs in this cmd list */
         return 0;
 }
 
@@ -1860,7 +1980,8 @@ static int hpsa_scsi_queue_command(struct scsi_cmnd *cmd,
         c->scsi_cmd = cmd;
         c->Header.ReplyQueue = 0;  /* unused in simple mode */
         memcpy(&c->Header.LUN.LunAddrBytes[0], &scsi3addr[0], 8);
-        c->Header.Tag.lower = c->busaddr;  /* Use k. address of cmd as tag */
+        c->Header.Tag.lower = (c->cmdindex << DIRECT_LOOKUP_SHIFT);
+        c->Header.Tag.lower |= DIRECT_LOOKUP_BIT;
 
         /* Fill in the request block... */
 
@@ -1914,6 +2035,48 @@ static int hpsa_scsi_queue_command(struct scsi_cmnd *cmd,
         return 0;
 }
 
+static void hpsa_scan_start(struct Scsi_Host *sh)
+{
+        struct ctlr_info *h = shost_to_hba(sh);
+        unsigned long flags;
+
+        /* wait until any scan already in progress is finished. */
+        while (1) {
+                spin_lock_irqsave(&h->scan_lock, flags);
+                if (h->scan_finished)
+                        break;
+                spin_unlock_irqrestore(&h->scan_lock, flags);
+                wait_event(h->scan_wait_queue, h->scan_finished);
+                /* Note: We don't need to worry about a race between this
+                 * thread and driver unload because the midlayer will
+                 * have incremented the reference count, so unload won't
+                 * happen if we're in here.
+                 */
+        }
+        h->scan_finished = 0; /* mark scan as in progress */
+        spin_unlock_irqrestore(&h->scan_lock, flags);
+
+        hpsa_update_scsi_devices(h, h->scsi_host->host_no);
+
+        spin_lock_irqsave(&h->scan_lock, flags);
+        h->scan_finished = 1; /* mark scan as finished. */
+        wake_up_all(&h->scan_wait_queue);
+        spin_unlock_irqrestore(&h->scan_lock, flags);
+}
+
+static int hpsa_scan_finished(struct Scsi_Host *sh,
+        unsigned long elapsed_time)
+{
+        struct ctlr_info *h = shost_to_hba(sh);
+        unsigned long flags;
+        int finished;
+
+        spin_lock_irqsave(&h->scan_lock, flags);
+        finished = h->scan_finished;
+        spin_unlock_irqrestore(&h->scan_lock, flags);
+        return finished;
+}
+
 static void hpsa_unregister_scsi(struct ctlr_info *h)
 {
         /* we are being forcibly unloaded, and may not refuse. */
@@ -1926,7 +2089,6 @@ static int hpsa_register_scsi(struct ctlr_info *h)
 {
         int rc;
 
-        hpsa_update_scsi_devices(h, -1);
         rc = hpsa_scsi_detect(h);
         if (rc != 0)
                 dev_err(&h->pdev->dev, "hpsa_register_scsi: failed"
@@ -2003,14 +2165,14 @@ static int hpsa_eh_device_reset_handler(struct scsi_cmnd *scsicmd)
         h = sdev_to_hba(scsicmd->device);
         if (h == NULL) /* paranoia */
                 return FAILED;
-        dev_warn(&h->pdev->dev, "resetting drive\n");
-
         dev = scsicmd->device->hostdata;
         if (!dev) {
                 dev_err(&h->pdev->dev, "hpsa_eh_device_reset_handler: "
                         "device lookup failed.\n");
                 return FAILED;
         }
+        dev_warn(&h->pdev->dev, "resetting device %d:%d:%d:%d\n",
+                h->scsi_host->host_no, dev->bus, dev->target, dev->lun);
         /* send a reset to the SCSI LUN which the command was sent to */
         rc = hpsa_send_reset(h, dev->scsi3addr);
         if (rc == 0 && wait_for_device_to_become_ready(h, dev->scsi3addr) == 0)
@@ -2053,8 +2215,8 @@ static struct CommandList *cmd_alloc(struct ctlr_info *h)
         c->cmdindex = i;
 
         INIT_HLIST_NODE(&c->list);
-        c->busaddr = (__u32) cmd_dma_handle;
-        temp64.val = (__u64) err_dma_handle;
+        c->busaddr = (u32) cmd_dma_handle;
+        temp64.val = (u64) err_dma_handle;
         c->ErrDesc.Addr.lower = temp64.val32.lower;
         c->ErrDesc.Addr.upper = temp64.val32.upper;
         c->ErrDesc.Len = sizeof(*c->err_info);
@@ -2091,8 +2253,8 @@ static struct CommandList *cmd_special_alloc(struct ctlr_info *h)
         memset(c->err_info, 0, sizeof(*c->err_info));
 
         INIT_HLIST_NODE(&c->list);
-        c->busaddr = (__u32) cmd_dma_handle;
-        temp64.val = (__u64) err_dma_handle;
+        c->busaddr = (u32) cmd_dma_handle;
+        temp64.val = (u64) err_dma_handle;
         c->ErrDesc.Addr.lower = temp64.val32.lower;
         c->ErrDesc.Addr.upper = temp64.val32.upper;
         c->ErrDesc.Len = sizeof(*c->err_info);
@@ -2125,50 +2287,6 @@ static void cmd_special_free(struct ctlr_info *h, struct CommandList *c)
 
 #ifdef CONFIG_COMPAT
 
-static int do_ioctl(struct scsi_device *dev, int cmd, void *arg)
-{
-        int ret;
-
-        lock_kernel();
-        ret = hpsa_ioctl(dev, cmd, arg);
-        unlock_kernel();
-        return ret;
-}
-
-static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg);
-static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
-        int cmd, void *arg);
-
-static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void *arg)
-{
-        switch (cmd) {
-        case CCISS_GETPCIINFO:
-        case CCISS_GETINTINFO:
-        case CCISS_SETINTINFO:
-        case CCISS_GETNODENAME:
-        case CCISS_SETNODENAME:
-        case CCISS_GETHEARTBEAT:
-        case CCISS_GETBUSTYPES:
-        case CCISS_GETFIRMVER:
-        case CCISS_GETDRIVVER:
-        case CCISS_REVALIDVOLS:
-        case CCISS_DEREGDISK:
-        case CCISS_REGNEWDISK:
-        case CCISS_REGNEWD:
-        case CCISS_RESCANDISK:
-        case CCISS_GETLUNINFO:
-                return do_ioctl(dev, cmd, arg);
-
-        case CCISS_PASSTHRU32:
-                return hpsa_ioctl32_passthru(dev, cmd, arg);
-        case CCISS_BIG_PASSTHRU32:
-                return hpsa_ioctl32_big_passthru(dev, cmd, arg);
-
-        default:
-                return -ENOIOCTLCMD;
-        }
-}
-
 static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg)
 {
         IOCTL32_Command_struct __user *arg32 =
@@ -2193,7 +2311,7 @@ static int hpsa_ioctl32_passthru(struct scsi_device *dev, int cmd, void *arg)
         if (err)
                 return -EFAULT;
 
-        err = do_ioctl(dev, CCISS_PASSTHRU, (void *)p);
+        err = hpsa_ioctl(dev, CCISS_PASSTHRU, (void *)p);
         if (err)
                 return err;
         err |= copy_in_user(&arg32->error_info, &p->error_info,
@@ -2230,7 +2348,7 @@ static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
         if (err)
                 return -EFAULT;
 
-        err = do_ioctl(dev, CCISS_BIG_PASSTHRU, (void *)p);
+        err = hpsa_ioctl(dev, CCISS_BIG_PASSTHRU, (void *)p);
         if (err)
                 return err;
         err |= copy_in_user(&arg32->error_info, &p->error_info,
@@ -2239,6 +2357,36 @@ static int hpsa_ioctl32_big_passthru(struct scsi_device *dev,
                 return -EFAULT;
         return err;
 }
+
+static int hpsa_compat_ioctl(struct scsi_device *dev, int cmd, void *arg)
+{
+        switch (cmd) {
+        case CCISS_GETPCIINFO:
+        case CCISS_GETINTINFO:
+        case CCISS_SETINTINFO:
+        case CCISS_GETNODENAME:
+        case CCISS_SETNODENAME:
+        case CCISS_GETHEARTBEAT:
+        case CCISS_GETBUSTYPES:
+        case CCISS_GETFIRMVER:
+        case CCISS_GETDRIVVER:
+        case CCISS_REVALIDVOLS:
+        case CCISS_DEREGDISK:
+        case CCISS_REGNEWDISK:
+        case CCISS_REGNEWD:
+        case CCISS_RESCANDISK:
+        case CCISS_GETLUNINFO:
+                return hpsa_ioctl(dev, cmd, arg);
+
+        case CCISS_PASSTHRU32:
+                return hpsa_ioctl32_passthru(dev, cmd, arg);
+        case CCISS_BIG_PASSTHRU32:
+                return hpsa_ioctl32_big_passthru(dev, cmd, arg);
+
+        default:
+                return -ENOIOCTLCMD;
+        }
+}
 #endif
 
 static int hpsa_getpciinfo_ioctl(struct ctlr_info *h, void __user *argp)
@@ -2378,8 +2526,8 @@ static int hpsa_big_passthru_ioctl(struct ctlr_info *h, void __user *argp)
         BYTE sg_used = 0;
         int status = 0;
         int i;
-        __u32 left;
-        __u32 sz;
+        u32 left;
+        u32 sz;
         BYTE __user *data_ptr;
 
         if (!argp)
@@ -2527,7 +2675,7 @@ static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg)
         case CCISS_DEREGDISK:
         case CCISS_REGNEWDISK:
         case CCISS_REGNEWD:
-                hpsa_update_scsi_devices(h, dev->host->host_no);
+                hpsa_scan_start(h->scsi_host);
                 return 0;
         case CCISS_GETPCIINFO:
                 return hpsa_getpciinfo_ioctl(h, argp);
@@ -2542,8 +2690,8 @@ static int hpsa_ioctl(struct scsi_device *dev, int cmd, void *arg)
         }
 }
 
-static void fill_cmd(struct CommandList *c, __u8 cmd, struct ctlr_info *h,
-        void *buff, size_t size, __u8 page_code, unsigned char *scsi3addr,
+static void fill_cmd(struct CommandList *c, u8 cmd, struct ctlr_info *h,
+        void *buff, size_t size, u8 page_code, unsigned char *scsi3addr,
         int cmd_type)
 {
         int pci_dir = XFER_NONE;
@@ -2710,19 +2858,20 @@ static inline unsigned long get_next_completion(struct ctlr_info *h)
         return h->access.command_completed(h);
 }
 
-static inline int interrupt_pending(struct ctlr_info *h)
+static inline bool interrupt_pending(struct ctlr_info *h)
 {
         return h->access.intr_pending(h);
 }
 
 static inline long interrupt_not_for_us(struct ctlr_info *h)
 {
-        return ((h->access.intr_pending(h) == 0) ||
-                 (h->interrupts_enabled == 0));
+        return !(h->msi_vector || h->msix_vector) &&
+                ((h->access.intr_pending(h) == 0) ||
+                (h->interrupts_enabled == 0));
 }
 
-static inline int bad_tag(struct ctlr_info *h, __u32 tag_index,
-        __u32 raw_tag)
+static inline int bad_tag(struct ctlr_info *h, u32 tag_index,
+        u32 raw_tag)
 {
         if (unlikely(tag_index >= h->nr_cmds)) {
                 dev_warn(&h->pdev->dev, "bad tag 0x%08x ignored.\n", raw_tag);
@@ -2731,7 +2880,7 @@ static inline int bad_tag(struct ctlr_info *h, __u32 tag_index,
         return 0;
 }
 
-static inline void finish_cmd(struct CommandList *c, __u32 raw_tag)
+static inline void finish_cmd(struct CommandList *c, u32 raw_tag)
 {
         removeQ(c);
         if (likely(c->cmd_type == CMD_SCSI))
@@ -2740,42 +2889,79 @@ static inline void finish_cmd(struct CommandList *c, __u32 raw_tag)
                 complete(c->waiting);
 }
 
+static inline u32 hpsa_tag_contains_index(u32 tag)
+{
+#define DIRECT_LOOKUP_BIT 0x10
+        return tag & DIRECT_LOOKUP_BIT;
+}
+
+static inline u32 hpsa_tag_to_index(u32 tag)
+{
+#define DIRECT_LOOKUP_SHIFT 5
+        return tag >> DIRECT_LOOKUP_SHIFT;
+}
+
+static inline u32 hpsa_tag_discard_error_bits(u32 tag)
+{
+#define HPSA_ERROR_BITS 0x03
+        return tag & ~HPSA_ERROR_BITS;
+}
+
+/* process completion of an indexed ("direct lookup") command */
+static inline u32 process_indexed_cmd(struct ctlr_info *h,
+        u32 raw_tag)
+{
+        u32 tag_index;
+        struct CommandList *c;
+
+        tag_index = hpsa_tag_to_index(raw_tag);
+        if (bad_tag(h, tag_index, raw_tag))
+                return next_command(h);
+        c = h->cmd_pool + tag_index;
+        finish_cmd(c, raw_tag);
+        return next_command(h);
+}
+
+/* process completion of a non-indexed command */
+static inline u32 process_nonindexed_cmd(struct ctlr_info *h,
+        u32 raw_tag)
+{
+        u32 tag;
+        struct CommandList *c = NULL;
+        struct hlist_node *tmp;
+
+        tag = hpsa_tag_discard_error_bits(raw_tag);
+        hlist_for_each_entry(c, tmp, &h->cmpQ, list) {
+                if ((c->busaddr & 0xFFFFFFE0) == (tag & 0xFFFFFFE0)) {
+                        finish_cmd(c, raw_tag);
+                        return next_command(h);
+                }
+        }
+        bad_tag(h, h->nr_cmds + 1, raw_tag);
+        return next_command(h);
+}
+
 static irqreturn_t do_hpsa_intr(int irq, void *dev_id)
 {
         struct ctlr_info *h = dev_id;
-        struct CommandList *c;
         unsigned long flags;
-        __u32 raw_tag, tag, tag_index;
-        struct hlist_node *tmp;
+        u32 raw_tag;
 
         if (interrupt_not_for_us(h))
                 return IRQ_NONE;
         spin_lock_irqsave(&h->lock, flags);
-        while (interrupt_pending(h)) {
-                while ((raw_tag = get_next_completion(h)) != FIFO_EMPTY) {
-                        if (likely(HPSA_TAG_CONTAINS_INDEX(raw_tag))) {
-                                tag_index = HPSA_TAG_TO_INDEX(raw_tag);
-                                if (bad_tag(h, tag_index, raw_tag))
-                                        return IRQ_HANDLED;
-                                c = h->cmd_pool + tag_index;
-                                finish_cmd(c, raw_tag);
-                                continue;
-                        }
-                        tag = HPSA_TAG_DISCARD_ERROR_BITS(raw_tag);
-                        c = NULL;
-                        hlist_for_each_entry(c, tmp, &h->cmpQ, list) {
-                                if (c->busaddr == tag) {
-                                        finish_cmd(c, raw_tag);
-                                        break;
-                                }
-                        }
-                }
+        raw_tag = get_next_completion(h);
+        while (raw_tag != FIFO_EMPTY) {
+                if (hpsa_tag_contains_index(raw_tag))
+                        raw_tag = process_indexed_cmd(h, raw_tag);
+                else
+                        raw_tag = process_nonindexed_cmd(h, raw_tag);
         }
         spin_unlock_irqrestore(&h->lock, flags);
         return IRQ_HANDLED;
 }
 
-/* Send a message CDB to the firmware. */
+/* Send a message CDB to the firmwart. */
 static __devinit int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
                                                 unsigned char type)
 {
@@ -2841,7 +3027,7 @@ static __devinit int hpsa_message(struct pci_dev *pdev, unsigned char opcode,
 
         for (i = 0; i < HPSA_MSG_SEND_RETRY_LIMIT; i++) {
                 tag = readl(vaddr + SA5_REPLY_PORT_OFFSET);
-                if (HPSA_TAG_DISCARD_ERROR_BITS(tag) == paddr32)
+                if (hpsa_tag_discard_error_bits(tag) == paddr32)
                         break;
                 msleep(HPSA_MSG_SEND_RETRY_INTERVAL_MSECS);
         }
@@ -3063,7 +3249,7 @@ static int find_PCI_BAR_index(struct pci_dev *pdev, unsigned long pci_bar_addr)
  */
 
 static void __devinit hpsa_interrupt_mode(struct ctlr_info *h,
-                                           struct pci_dev *pdev, __u32 board_id)
+                                           struct pci_dev *pdev, u32 board_id)
 {
 #ifdef CONFIG_PCI_MSI
         int err;
@@ -3107,22 +3293,22 @@ static void __devinit hpsa_interrupt_mode(struct ctlr_info *h,
 default_int_mode:
 #endif                          /* CONFIG_PCI_MSI */
         /* if we get here we're going to use the default interrupt mode */
-        h->intr[SIMPLE_MODE_INT] = pdev->irq;
-        return;
+        h->intr[PERF_MODE_INT] = pdev->irq;
 }
 
 static int hpsa_pci_init(struct ctlr_info *h, struct pci_dev *pdev)
 {
         ushort subsystem_vendor_id, subsystem_device_id, command;
-        __u32 board_id, scratchpad = 0;
-        __u64 cfg_offset;
-        __u32 cfg_base_addr;
-        __u64 cfg_base_addr_index;
+        u32 board_id, scratchpad = 0;
+        u64 cfg_offset;
+        u32 cfg_base_addr;
+        u64 cfg_base_addr_index;
+        u32 trans_offset;
         int i, prod_index, err;
 
         subsystem_vendor_id = pdev->subsystem_vendor;
         subsystem_device_id = pdev->subsystem_device;
-        board_id = (((__u32) (subsystem_device_id << 16) & 0xffff0000) |
+        board_id = (((u32) (subsystem_device_id << 16) & 0xffff0000) |
                     subsystem_vendor_id);
 
         for (i = 0; i < ARRAY_SIZE(products); i++)
@@ -3199,7 +3385,7 @@ static int hpsa_pci_init(struct ctlr_info *h, struct pci_dev *pdev)
 
         /* get the address index number */
         cfg_base_addr = readl(h->vaddr + SA5_CTCFG_OFFSET);
-        cfg_base_addr &= (__u32) 0x0000ffff;
+        cfg_base_addr &= (u32) 0x0000ffff;
         cfg_base_addr_index = find_PCI_BAR_index(pdev, cfg_base_addr);
         if (cfg_base_addr_index == -1) {
                 dev_warn(&pdev->dev, "cannot find cfg_base_addr_index\n");
@@ -3211,11 +3397,14 @@ static int hpsa_pci_init(struct ctlr_info *h, struct pci_dev *pdev)
         h->cfgtable = remap_pci_mem(pci_resource_start(pdev,
                                cfg_base_addr_index) + cfg_offset,
                                 sizeof(h->cfgtable));
-        h->board_id = board_id;
-
-        /* Query controller for max supported commands: */
-        h->max_commands = readl(&(h->cfgtable->CmdsOutMax));
+        /* Find performant mode table. */
+        trans_offset = readl(&(h->cfgtable->TransMethodOffset));
+        h->transtable = remap_pci_mem(pci_resource_start(pdev,
+                                cfg_base_addr_index)+cfg_offset+trans_offset,
+                                sizeof(*h->transtable));
 
+        h->board_id = board_id;
+        h->max_commands = readl(&(h->cfgtable->MaxPerformantModeCommands));
         h->product_name = products[prod_index].product_name;
         h->access = *(products[prod_index].access);
         /* Allow room for some ioctls */
@@ -3232,7 +3421,7 @@ static int hpsa_pci_init(struct ctlr_info *h, struct pci_dev *pdev)
 #ifdef CONFIG_X86
         {
                 /* Need to enable prefetch in the SCSI core for 6400 in x86 */
-                __u32 prefetch;
+                u32 prefetch;
                 prefetch = readl(&(h->cfgtable->SCSI_Prefetch));
                 prefetch |= 0x100;
                 writel(prefetch, &(h->cfgtable->SCSI_Prefetch));
@@ -3244,7 +3433,7 @@ static int hpsa_pci_init(struct ctlr_info *h, struct pci_dev *pdev)
          * physical memory.
          */
         if (board_id == 0x3225103C) {
-                __u32 dma_prefetch;
+                u32 dma_prefetch;
                 dma_prefetch = readl(h->vaddr + I2O_DMA1_CFG);
                 dma_prefetch |= 0x8000;
                 writel(dma_prefetch, h->vaddr + I2O_DMA1_CFG);
@@ -3286,10 +3475,26 @@ err_out_free_res:
         return err;
 }
 
+static void __devinit hpsa_hba_inquiry(struct ctlr_info *h)
+{
+        int rc;
+
+#define HBA_INQUIRY_BYTE_COUNT 64
+        h->hba_inquiry_data = kmalloc(HBA_INQUIRY_BYTE_COUNT, GFP_KERNEL);
+        if (!h->hba_inquiry_data)
+                return;
+        rc = hpsa_scsi_do_inquiry(h, RAID_CTLR_LUNID, 0,
+                h->hba_inquiry_data, HBA_INQUIRY_BYTE_COUNT);
+        if (rc != 0) {
+                kfree(h->hba_inquiry_data);
+                h->hba_inquiry_data = NULL;
+        }
+}
+
 static int __devinit hpsa_init_one(struct pci_dev *pdev,
                                     const struct pci_device_id *ent)
 {
-        int i;
+        int i, rc;
         int dac;
         struct ctlr_info *h;
 
@@ -3314,17 +3519,23 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
                 }
         }
 
-        BUILD_BUG_ON(sizeof(struct CommandList) % 8);
+        /* Command structures must be aligned on a 32-byte boundary because
+         * the 5 lower bits of the address are used by the hardware. and by
+         * the driver.  See comments in hpsa.h for more info.
+         */
+#define COMMANDLIST_ALIGNMENT 32
+        BUILD_BUG_ON(sizeof(struct CommandList) % COMMANDLIST_ALIGNMENT);
         h = kzalloc(sizeof(*h), GFP_KERNEL);
         if (!h)
-                return -1;
+                return -ENOMEM;
 
         h->busy_initializing = 1;
         INIT_HLIST_HEAD(&h->cmpQ);
         INIT_HLIST_HEAD(&h->reqQ);
         mutex_init(&h->busy_shutting_down);
         init_completion(&h->scan_wait);
-        if (hpsa_pci_init(h, pdev) != 0)
+        rc = hpsa_pci_init(h, pdev);
+        if (rc != 0)
                 goto clean1;
 
         sprintf(h->devname, "hpsa%d", number_of_controllers);
@@ -3333,27 +3544,32 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
         h->pdev = pdev;
 
         /* configure PCI DMA stuff */
-        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
+        rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(64));
+        if (rc == 0) {
                 dac = 1;
-        else if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))
-                dac = 0;
-        else {
-                dev_err(&pdev->dev, "no suitable DMA available\n");
-                goto clean1;
+        } else {
+                rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
+                if (rc == 0) {
+                        dac = 0;
+                } else {
+                        dev_err(&pdev->dev, "no suitable DMA available\n");
+                        goto clean1;
+                }
         }
 
         /* make sure the board interrupts are off */
         h->access.set_intr_mask(h, HPSA_INTR_OFF);
-        if (request_irq(h->intr[SIMPLE_MODE_INT], do_hpsa_intr,
-                        IRQF_DISABLED | IRQF_SHARED, h->devname, h)) {
+        rc = request_irq(h->intr[PERF_MODE_INT], do_hpsa_intr,
+                        IRQF_DISABLED, h->devname, h);
+        if (rc) {
                 dev_err(&pdev->dev, "unable to get irq %d for %s\n",
-                       h->intr[SIMPLE_MODE_INT], h->devname);
+                       h->intr[PERF_MODE_INT], h->devname);
                 goto clean2;
         }
 
-        dev_info(&pdev->dev, "%s: <0x%x> at PCI %s IRQ %d%s using DAC\n",
-               h->devname, pdev->device, pci_name(pdev),
-               h->intr[SIMPLE_MODE_INT], dac ? "" : " not");
+        dev_info(&pdev->dev, "%s: <0x%x> at IRQ %d%s using DAC\n",
+               h->devname, pdev->device,
+               h->intr[PERF_MODE_INT], dac ? "" : " not");
 
         h->cmd_pool_bits =
             kmalloc(((h->nr_cmds + BITS_PER_LONG -
@@ -3368,9 +3584,13 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
             || (h->cmd_pool == NULL)
             || (h->errinfo_pool == NULL)) {
                 dev_err(&pdev->dev, "out of memory");
+                rc = -ENOMEM;
                 goto clean4;
         }
         spin_lock_init(&h->lock);
+        spin_lock_init(&h->scan_lock);
+        init_waitqueue_head(&h->scan_wait_queue);
+        h->scan_finished = 1; /* no scan currently in progress */
 
         pci_set_drvdata(pdev, h);
         memset(h->cmd_pool_bits, 0,
@@ -3382,6 +3602,8 @@ static int __devinit hpsa_init_one(struct pci_dev *pdev,
         /* Turn the interrupts on so we can service requests */
         h->access.set_intr_mask(h, HPSA_INTR_ON);
 
+        hpsa_put_ctlr_into_performant_mode(h);
+        hpsa_hba_inquiry(h);
         hpsa_register_scsi(h);  /* hook ourselves into SCSI subsystem */
         h->busy_initializing = 0;
         return 1;
@@ -3397,12 +3619,12 @@ clean4:
                             h->nr_cmds * sizeof(struct ErrorInfo),
                             h->errinfo_pool,
                             h->errinfo_pool_dhandle);
-        free_irq(h->intr[SIMPLE_MODE_INT], h);
+        free_irq(h->intr[PERF_MODE_INT], h);
 clean2:
 clean1:
         h->busy_initializing = 0;
         kfree(h);
-        return -1;
+        return rc;
 }
 
 static void hpsa_flush_cache(struct ctlr_info *h)
@@ -3441,7 +3663,7 @@ static void hpsa_shutdown(struct pci_dev *pdev)
          */
         hpsa_flush_cache(h);
         h->access.set_intr_mask(h, HPSA_INTR_OFF);
-        free_irq(h->intr[2], h);
+        free_irq(h->intr[PERF_MODE_INT], h);
 #ifdef CONFIG_PCI_MSI
         if (h->msix_vector)
                 pci_disable_msix(h->pdev);
@@ -3470,7 +3692,11 @@ static void __devexit hpsa_remove_one(struct pci_dev *pdev)
         pci_free_consistent(h->pdev,
                 h->nr_cmds * sizeof(struct ErrorInfo),
                 h->errinfo_pool, h->errinfo_pool_dhandle);
+        pci_free_consistent(h->pdev, h->reply_pool_size,
+                h->reply_pool, h->reply_pool_dhandle);
         kfree(h->cmd_pool_bits);
+        kfree(h->blockFetchTable);
+        kfree(h->hba_inquiry_data);
         /*
          * Deliberately omit pci_disable_device(): it does something nasty to
          * Smart Array controllers that pci_enable_device does not undo
@@ -3502,6 +3728,129 @@ static struct pci_driver hpsa_pci_driver = {
         .resume = hpsa_resume,
 };
 
+/* Fill in bucket_map[], given nsgs (the max number of
+ * scatter gather elements supported) and bucket[],
+ * which is an array of 8 integers.  The bucket[] array
+ * contains 8 different DMA transfer sizes (in 16
+ * byte increments) which the controller uses to fetch
+ * commands.  This function fills in bucket_map[], which
+ * maps a given number of scatter gather elements to one of
+ * the 8 DMA transfer sizes.  The point of it is to allow the
+ * controller to only do as much DMA as needed to fetch the
+ * command, with the DMA transfer size encoded in the lower
+ * bits of the command address.
+ */
+static void  calc_bucket_map(int bucket[], int num_buckets,
+        int nsgs, int *bucket_map)
+{
+        int i, j, b, size;
+
+        /* even a command with 0 SGs requires 4 blocks */
+#define MINIMUM_TRANSFER_BLOCKS 4
+#define NUM_BUCKETS 8
+        /* Note, bucket_map must have nsgs+1 entries. */
+        for (i = 0; i <= nsgs; i++) {
+                /* Compute size of a command with i SG entries */
+                size = i + MINIMUM_TRANSFER_BLOCKS;
+                b = num_buckets; /* Assume the biggest bucket */
+                /* Find the bucket that is just big enough */
+                for (j = 0; j < 8; j++) {
+                        if (bucket[j] >= size) {
+                                b = j;
+                                break;
+                        }
+                }
+                /* for a command with i SG entries, use bucket b. */
+                bucket_map[i] = b;
+        }
+}
+
+static void hpsa_put_ctlr_into_performant_mode(struct ctlr_info *h)
+{
+        u32 trans_support;
+        u64 trans_offset;
+        /*  5 = 1 s/g entry or 4k
+         *  6 = 2 s/g entry or 8k
+         *  8 = 4 s/g entry or 16k
+         * 10 = 6 s/g entry or 24k
+         */
+        int bft[8] = {5, 6, 8, 10, 12, 20, 28, 35}; /* for scatter/gathers */
+        int i = 0;
+        int l = 0;
+        unsigned long register_value;
+
+        trans_support = readl(&(h->cfgtable->TransportSupport));
+        if (!(trans_support & PERFORMANT_MODE))
+                return;
+
+        h->max_commands = readl(&(h->cfgtable->MaxPerformantModeCommands));
+        h->max_sg_entries = 32;
+        /* Performant mode ring buffer and supporting data structures */
+        h->reply_pool_size = h->max_commands * sizeof(u64);
+        h->reply_pool = pci_alloc_consistent(h->pdev, h->reply_pool_size,
+                                &(h->reply_pool_dhandle));
+
+        /* Need a block fetch table for performant mode */
+        h->blockFetchTable = kmalloc(((h->max_sg_entries+1) *
+                                sizeof(u32)), GFP_KERNEL);
+
+        if ((h->reply_pool == NULL)
+                || (h->blockFetchTable == NULL))
+                goto clean_up;
+
+        h->reply_pool_wraparound = 1; /* spec: init to 1 */
+
+        /* Controller spec: zero out this buffer. */
+        memset(h->reply_pool, 0, h->reply_pool_size);
+        h->reply_pool_head = h->reply_pool;
+
+        trans_offset = readl(&(h->cfgtable->TransMethodOffset));
+        bft[7] = h->max_sg_entries + 4;
+        calc_bucket_map(bft, ARRAY_SIZE(bft), 32, h->blockFetchTable);
+        for (i = 0; i < 8; i++)
+                writel(bft[i], &h->transtable->BlockFetch[i]);
+
+        /* size of controller ring buffer */
+        writel(h->max_commands, &h->transtable->RepQSize);
+        writel(1, &h->transtable->RepQCount);
+        writel(0, &h->transtable->RepQCtrAddrLow32);
+        writel(0, &h->transtable->RepQCtrAddrHigh32);
+        writel(h->reply_pool_dhandle, &h->transtable->RepQAddr0Low32);
+        writel(0, &h->transtable->RepQAddr0High32);
+        writel(CFGTBL_Trans_Performant,
+                &(h->cfgtable->HostWrite.TransportRequest));
+        writel(CFGTBL_ChangeReq, h->vaddr + SA5_DOORBELL);
+        /* under certain very rare conditions, this can take awhile.
+         * (e.g.: hot replace a failed 144GB drive in a RAID 5 set right
+         * as we enter this code.) */
+        for (l = 0; l < MAX_CONFIG_WAIT; l++) {
+                register_value = readl(h->vaddr + SA5_DOORBELL);
+                if (!(register_value & CFGTBL_ChangeReq))
+                        break;
+                /* delay and try again */
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule_timeout(10);
+        }
+        register_value = readl(&(h->cfgtable->TransportActive));
+        if (!(register_value & CFGTBL_Trans_Performant)) {
+                dev_warn(&h->pdev->dev, "unable to get board into"
+                                        " performant mode\n");
+                return;
+        }
+
+        /* Change the access methods to the performant access methods */
+        h->access = SA5_performant_access;
+        h->transMethod = CFGTBL_Trans_Performant;
+
+        return;
+
+clean_up:
+        if (h->reply_pool)
+                pci_free_consistent(h->pdev, h->reply_pool_size,
+                        h->reply_pool, h->reply_pool_dhandle);
+        kfree(h->blockFetchTable);
+}
+
 /*
  *  This is it.  Register the PCI driver information for the cards we control
  *  the OS will call our registered routines when it finds one of our cards.
diff --git a/drivers/scsi/hpsa.h b/drivers/scsi/hpsa.h
index 6bd1949144b5..a0502b3ac17e 100644
--- a/drivers/scsi/hpsa.h
+++ b/drivers/scsi/hpsa.h
@@ -33,7 +33,7 @@ struct access_method {
                 struct CommandList *c);
         void (*set_intr_mask)(struct ctlr_info *h, unsigned long val);
         unsigned long (*fifo_full)(struct ctlr_info *h);
-        unsigned long (*intr_pending)(struct ctlr_info *h);
+        bool (*intr_pending)(struct ctlr_info *h);
         unsigned long (*command_completed)(struct ctlr_info *h);
 };
 
@@ -55,19 +55,20 @@ struct ctlr_info {
         char    *product_name;
         char    firm_ver[4]; /* Firmware version */
         struct pci_dev *pdev;
-        __u32   board_id;
+        u32     board_id;
         void __iomem *vaddr;
         unsigned long paddr;
         int     nr_cmds; /* Number of commands allowed on this controller */
         struct CfgTable __iomem *cfgtable;
+        int     max_sg_entries;
         int     interrupts_enabled;
         int     major;
         int     max_commands;
         int     commands_outstanding;
         int     max_outstanding; /* Debug */
         int     usage_count;  /* number of opens all all minor devices */
-#       define DOORBELL_INT     0
-#       define PERF_MODE_INT    1
+#       define PERF_MODE_INT    0
+#       define DOORBELL_INT     1
 #       define SIMPLE_MODE_INT  2
 #       define MEMQ_MODE_INT    3
         unsigned int intr[4];
@@ -93,6 +94,9 @@ struct ctlr_info {
         int                     nr_frees;
         int                     busy_initializing;
         int                     busy_scanning;
+        int                     scan_finished;
+        spinlock_t              scan_lock;
+        wait_queue_head_t       scan_wait_queue;
         struct mutex            busy_shutting_down;
         struct list_head        scan_list;
         struct completion       scan_wait;
@@ -102,6 +106,24 @@ struct ctlr_info {
         int ndevices; /* number of used elements in .dev[] array. */
 #define HPSA_MAX_SCSI_DEVS_PER_HBA 256
         struct hpsa_scsi_dev_t *dev[HPSA_MAX_SCSI_DEVS_PER_HBA];
+        /*
+         * Performant mode tables.
+         */
+        u32 trans_support;
+        u32 trans_offset;
+        struct TransTable_struct *transtable;
+        unsigned long transMethod;
+
+        /*
+         * Performant mode completion buffer
+         */
+        u64 *reply_pool;
+        dma_addr_t reply_pool_dhandle;
+        u64 *reply_pool_head;
+        size_t reply_pool_size;
+        unsigned char reply_pool_wraparound;
+        u32 *blockFetchTable;
+        unsigned char *hba_inquiry_data;
 };
 #define HPSA_ABORT_MSG 0
 #define HPSA_DEVICE_RESET_MSG 1
@@ -164,9 +186,16 @@ struct ctlr_info {
 #define HPSA_FIRMWARE_READY     0xffff0000 /* value in scratchpad register */
 
 #define HPSA_ERROR_BIT          0x02
-#define HPSA_TAG_CONTAINS_INDEX(tag) ((tag) & 0x04)
-#define HPSA_TAG_TO_INDEX(tag) ((tag) >> 3)
-#define HPSA_TAG_DISCARD_ERROR_BITS(tag) ((tag) & ~3)
+
+/* Performant mode flags */
+#define SA5_PERF_INTR_PENDING   0x04
+#define SA5_PERF_INTR_OFF       0x05
+#define SA5_OUTDB_STATUS_PERF_BIT       0x01
+#define SA5_OUTDB_CLEAR_PERF_BIT        0x01
+#define SA5_OUTDB_CLEAR         0xA0
+#define SA5_OUTDB_CLEAR_PERF_BIT        0x01
+#define SA5_OUTDB_STATUS        0x9C
+
 
 #define HPSA_INTR_ON    1
 #define HPSA_INTR_OFF   0
@@ -176,10 +205,8 @@ struct ctlr_info {
 static void SA5_submit_command(struct ctlr_info *h,
         struct CommandList *c)
 {
-#ifdef HPSA_DEBUG
-         printk(KERN_WARNING "hpsa: Sending %x - down to controller\n",
-                c->busaddr);
-#endif /* HPSA_DEBUG */
+        dev_dbg(&h->pdev->dev, "Sending %x, tag = %x\n", c->busaddr,
+                c->Header.Tag.lower);
         writel(c->busaddr, h->vaddr + SA5_REQUEST_PORT_OFFSET);
         h->commands_outstanding++;
         if (h->commands_outstanding > h->max_outstanding)
@@ -202,6 +229,52 @@ static void SA5_intr_mask(struct ctlr_info *h, unsigned long val)
                         h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
         }
 }
+
+static void SA5_performant_intr_mask(struct ctlr_info *h, unsigned long val)
+{
+        if (val) { /* turn on interrupts */
+                h->interrupts_enabled = 1;
+                writel(0, h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+        } else {
+                h->interrupts_enabled = 0;
+                writel(SA5_PERF_INTR_OFF,
+                        h->vaddr + SA5_REPLY_INTR_MASK_OFFSET);
+        }
+}
+
+static unsigned long SA5_performant_completed(struct ctlr_info *h)
+{
+        unsigned long register_value = FIFO_EMPTY;
+
+        /* flush the controller write of the reply queue by reading
+         * outbound doorbell status register.
+         */
+        register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+        /* msi auto clears the interrupt pending bit. */
+        if (!(h->msi_vector || h->msix_vector)) {
+                writel(SA5_OUTDB_CLEAR_PERF_BIT, h->vaddr + SA5_OUTDB_CLEAR);
+                /* Do a read in order to flush the write to the controller
+                 * (as per spec.)
+                 */
+                register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+        }
+
+        if ((*(h->reply_pool_head) & 1) == (h->reply_pool_wraparound)) {
+                register_value = *(h->reply_pool_head);
+                (h->reply_pool_head)++;
+                h->commands_outstanding--;
+        } else {
+                register_value = FIFO_EMPTY;
+        }
+        /* Check for wraparound */
+        if (h->reply_pool_head == (h->reply_pool + h->max_commands)) {
+                h->reply_pool_head = h->reply_pool;
+                h->reply_pool_wraparound ^= 1;
+        }
+
+        return register_value;
+}
+
 /*
  *  Returns true if fifo is full.
  *
@@ -228,10 +301,10 @@ static unsigned long SA5_completed(struct ctlr_info *h)
 
 #ifdef HPSA_DEBUG
         if (register_value != FIFO_EMPTY)
-                printk(KERN_INFO "hpsa:  Read %lx back from board\n",
+                dev_dbg(&h->pdev->dev, "Read %lx back from board\n",
                         register_value);
         else
-                printk(KERN_INFO "hpsa:  FIFO Empty read\n");
+                dev_dbg(&h->pdev->dev, "hpsa: FIFO Empty read\n");
 #endif
 
         return register_value;
@@ -239,18 +312,28 @@ static unsigned long SA5_completed(struct ctlr_info *h)
 /*
  *      Returns true if an interrupt is pending..
  */
-static unsigned long SA5_intr_pending(struct ctlr_info *h)
+static bool SA5_intr_pending(struct ctlr_info *h)
 {
         unsigned long register_value  =
                 readl(h->vaddr + SA5_INTR_STATUS);
-#ifdef HPSA_DEBUG
-        printk(KERN_INFO "hpsa: intr_pending %lx\n", register_value);
-#endif  /* HPSA_DEBUG */
-        if (register_value &  SA5_INTR_PENDING)
-                return  1;
-        return 0 ;
+        dev_dbg(&h->pdev->dev, "intr_pending %lx\n", register_value);
+        return register_value & SA5_INTR_PENDING;
 }
 
+static bool SA5_performant_intr_pending(struct ctlr_info *h)
+{
+        unsigned long register_value = readl(h->vaddr + SA5_INTR_STATUS);
+
+        if (!register_value)
+                return false;
+
+        if (h->msi_vector || h->msix_vector)
+                return true;
+
+        /* Read outbound doorbell to flush */
+        register_value = readl(h->vaddr + SA5_OUTDB_STATUS);
+        return register_value & SA5_OUTDB_STATUS_PERF_BIT;
+}
 
 static struct access_method SA5_access = {
         SA5_submit_command,
@@ -260,14 +343,19 @@ static struct access_method SA5_access = {
         SA5_completed,
 };
 
+static struct access_method SA5_performant_access = {
+        SA5_submit_command,
+        SA5_performant_intr_mask,
+        SA5_fifo_full,
+        SA5_performant_intr_pending,
+        SA5_performant_completed,
+};
+
 struct board_type {
-        __u32   board_id;
+        u32     board_id;
         char    *product_name;
         struct access_method *access;
 };
 
-
-/* end of old hpsa_scsi.h file */
-
 #endif /* HPSA_H */
 
diff --git a/drivers/scsi/hpsa_cmd.h b/drivers/scsi/hpsa_cmd.h
index 12d71387ed9a..3e0abdf76689 100644
--- a/drivers/scsi/hpsa_cmd.h
+++ b/drivers/scsi/hpsa_cmd.h
@@ -101,19 +101,20 @@
 #define CFGTBL_AccCmds          0x00000001l
 
 #define CFGTBL_Trans_Simple     0x00000002l
+#define CFGTBL_Trans_Performant 0x00000004l
 
 #define CFGTBL_BusType_Ultra2   0x00000001l
 #define CFGTBL_BusType_Ultra3   0x00000002l
 #define CFGTBL_BusType_Fibre1G  0x00000100l
 #define CFGTBL_BusType_Fibre2G  0x00000200l
 struct vals32 {
-        __u32   lower;
-        __u32   upper;
+        u32   lower;
+        u32   upper;
 };
 
 union u64bit {
         struct vals32 val32;
-        __u64 val;
+        u64 val;
 };
 
 /* FIXME this is a per controller value (barf!) */
@@ -126,34 +127,34 @@ union u64bit {
 
 #define HPSA_INQUIRY 0x12
 struct InquiryData {
-        __u8 data_byte[36];
+        u8 data_byte[36];
 };
 
 #define HPSA_REPORT_LOG 0xc2    /* Report Logical LUNs */
 #define HPSA_REPORT_PHYS 0xc3   /* Report Physical LUNs */
 struct ReportLUNdata {
-        __u8 LUNListLength[4];
-        __u32 reserved;
-        __u8 LUN[HPSA_MAX_LUN][8];
+        u8 LUNListLength[4];
+        u32 reserved;
+        u8 LUN[HPSA_MAX_LUN][8];
 };
 
 struct ReportExtendedLUNdata {
-        __u8 LUNListLength[4];
-        __u8 extended_response_flag;
-        __u8 reserved[3];
-        __u8 LUN[HPSA_MAX_LUN][24];
+        u8 LUNListLength[4];
+        u8 extended_response_flag;
+        u8 reserved[3];
+        u8 LUN[HPSA_MAX_LUN][24];
 };
 
 struct SenseSubsystem_info {
-        __u8 reserved[36];
-        __u8 portname[8];
-        __u8 reserved1[1108];
+        u8 reserved[36];
+        u8 portname[8];
+        u8 reserved1[1108];
 };
 
 #define HPSA_READ_CAPACITY 0x25 /* Read Capacity */
 struct ReadCapdata {
-        __u8 total_size[4];     /* Total size in blocks */
-        __u8 block_size[4];     /* Size of blocks in bytes */
+        u8 total_size[4];       /* Total size in blocks */
+        u8 block_size[4];       /* Size of blocks in bytes */
 };
 
 #if 0
@@ -174,112 +175,131 @@ struct ReadCapdata {
 /* Command List Structure */
 union SCSI3Addr {
         struct {
-                __u8 Dev;
-                __u8 Bus:6;
-                __u8 Mode:2;        /* b00 */
+                u8 Dev;
+                u8 Bus:6;
+                u8 Mode:2;        /* b00 */
         } PeripDev;
         struct {
-                __u8 DevLSB;
-                __u8 DevMSB:6;
-                __u8 Mode:2;        /* b01 */
+                u8 DevLSB;
+                u8 DevMSB:6;
+                u8 Mode:2;        /* b01 */
         } LogDev;
         struct {
-                __u8 Dev:5;
-                __u8 Bus:3;
-                __u8 Targ:6;
-                __u8 Mode:2;        /* b10 */
+                u8 Dev:5;
+                u8 Bus:3;
+                u8 Targ:6;
+                u8 Mode:2;        /* b10 */
         } LogUnit;
 };
 
 struct PhysDevAddr {
-        __u32             TargetId:24;
-        __u32             Bus:6;
-        __u32             Mode:2;
+        u32             TargetId:24;
+        u32             Bus:6;
+        u32             Mode:2;
         /* 2 level target device addr */
         union SCSI3Addr  Target[2];
 };
 
 struct LogDevAddr {
-        __u32            VolId:30;
-        __u32            Mode:2;
-        __u8             reserved[4];
+        u32            VolId:30;
+        u32            Mode:2;
+        u8             reserved[4];
 };
 
 union LUNAddr {
-        __u8               LunAddrBytes[8];
+        u8               LunAddrBytes[8];
         union SCSI3Addr    SCSI3Lun[4];
         struct PhysDevAddr PhysDev;
         struct LogDevAddr  LogDev;
 };
 
 struct CommandListHeader {
-        __u8              ReplyQueue;
-        __u8              SGList;
-        __u16             SGTotal;
+        u8              ReplyQueue;
+        u8              SGList;
+        u16             SGTotal;
         struct vals32     Tag;
         union LUNAddr     LUN;
 };
 
 struct RequestBlock {
-        __u8   CDBLen;
+        u8   CDBLen;
         struct {
-                __u8 Type:3;
-                __u8 Attribute:3;
-                __u8 Direction:2;
+                u8 Type:3;
+                u8 Attribute:3;
+                u8 Direction:2;
         } Type;
-        __u16  Timeout;
-        __u8   CDB[16];
+        u16  Timeout;
+        u8   CDB[16];
 };
 
 struct ErrDescriptor {
         struct vals32 Addr;
-        __u32  Len;
+        u32  Len;
 };
 
 struct SGDescriptor {
         struct vals32 Addr;
-        __u32  Len;
-        __u32  Ext;
+        u32  Len;
+        u32  Ext;
 };
 
 union MoreErrInfo {
         struct {
-                __u8  Reserved[3];
-                __u8  Type;
-                __u32 ErrorInfo;
+                u8  Reserved[3];
+                u8  Type;
+                u32 ErrorInfo;
         } Common_Info;
         struct {
-                __u8  Reserved[2];
-                __u8  offense_size; /* size of offending entry */
-                __u8  offense_num;  /* byte # of offense 0-base */
-                __u32 offense_value;
+                u8  Reserved[2];
+                u8  offense_size; /* size of offending entry */
+                u8  offense_num;  /* byte # of offense 0-base */
+                u32 offense_value;
         } Invalid_Cmd;
 };
 struct ErrorInfo {
-        __u8               ScsiStatus;
-        __u8               SenseLen;
-        __u16              CommandStatus;
-        __u32              ResidualCnt;
+        u8               ScsiStatus;
+        u8               SenseLen;
+        u16              CommandStatus;
+        u32              ResidualCnt;
         union MoreErrInfo  MoreErrInfo;
-        __u8               SenseInfo[SENSEINFOBYTES];
+        u8               SenseInfo[SENSEINFOBYTES];
 };
 /* Command types */
 #define CMD_IOCTL_PEND  0x01
 #define CMD_SCSI        0x03
 
+/* This structure needs to be divisible by 32 for new
+ * indexing method and performant mode.
+ */
+#define PAD32 32
+#define PAD64DIFF 0
+#define USEEXTRA ((sizeof(void *) - 4)/4)
+#define PADSIZE (PAD32 + PAD64DIFF * USEEXTRA)
+
+#define DIRECT_LOOKUP_SHIFT 5
+#define DIRECT_LOOKUP_BIT 0x10
+
+#define HPSA_ERROR_BIT          0x02
 struct ctlr_info; /* defined in hpsa.h */
-/* The size of this structure needs to be divisible by 8
- * od on all architectures, because the controller uses 2
- * lower bits of the address, and the driver uses 1 lower
- * bit (3 bits total.)
+/* The size of this structure needs to be divisible by 32
+ * on all architectures because low 5 bits of the addresses
+ * are used as follows:
+ *
+ * bit 0: to device, used to indicate "performant mode" command
+ *        from device, indidcates error status.
+ * bit 1-3: to device, indicates block fetch table entry for
+ *          reducing DMA in fetching commands from host memory.
+ * bit 4: used to indicate whether tag is "direct lookup" (index),
+ *        or a bus address.
  */
+
 struct CommandList {
         struct CommandListHeader Header;
         struct RequestBlock      Request;
         struct ErrDescriptor     ErrDesc;
         struct SGDescriptor      SG[MAXSGENTRIES];
         /* information associated with the command */
-        __u32                      busaddr; /* physical addr of this record */
+        u32                        busaddr; /* physical addr of this record */
         struct ErrorInfo *err_info; /* pointer to the allocated mem */
         struct ctlr_info           *h;
         int                        cmd_type;
@@ -291,35 +311,63 @@ struct CommandList {
         struct completion *waiting;
         int      retry_count;
         void   *scsi_cmd;
+
+/* on 64 bit architectures, to get this to be 32-byte-aligned
+ * it so happens we need no padding, on 32 bit systems,
+ * we need 8 bytes of padding.   This does that.
+ */
+#define COMMANDLIST_PAD ((8 - sizeof(long))/4 * 8)
+        u8 pad[COMMANDLIST_PAD];
+
 };
 
 /* Configuration Table Structure */
 struct HostWrite {
-        __u32 TransportRequest;
-        __u32 Reserved;
-        __u32 CoalIntDelay;
-        __u32 CoalIntCount;
+        u32 TransportRequest;
+        u32 Reserved;
+        u32 CoalIntDelay;
+        u32 CoalIntCount;
 };
 
+#define SIMPLE_MODE     0x02
+#define PERFORMANT_MODE 0x04
+#define MEMQ_MODE       0x08
+
 struct CfgTable {
-        __u8             Signature[4];
-        __u32            SpecValence;
-        __u32            TransportSupport;
-        __u32            TransportActive;
-        struct HostWrite HostWrite;
-        __u32            CmdsOutMax;
-        __u32            BusTypes;
-        __u32            Reserved;
-        __u8             ServerName[16];
-        __u32            HeartBeat;
-        __u32            SCSI_Prefetch;
+        u8            Signature[4];
+        u32             SpecValence;
+        u32           TransportSupport;
+        u32           TransportActive;
+        struct          HostWrite HostWrite;
+        u32           CmdsOutMax;
+        u32           BusTypes;
+        u32           TransMethodOffset;
+        u8            ServerName[16];
+        u32           HeartBeat;
+        u32           SCSI_Prefetch;
+        u32             MaxScatterGatherElements;
+        u32             MaxLogicalUnits;
+        u32             MaxPhysicalDevices;
+        u32             MaxPhysicalDrivesPerLogicalUnit;
+        u32             MaxPerformantModeCommands;
+};
+
+#define NUM_BLOCKFETCH_ENTRIES 8
+struct TransTable_struct {
+        u32            BlockFetch[NUM_BLOCKFETCH_ENTRIES];
+        u32            RepQSize;
+        u32            RepQCount;
+        u32            RepQCtrAddrLow32;
+        u32            RepQCtrAddrHigh32;
+        u32            RepQAddr0Low32;
+        u32            RepQAddr0High32;
 };
 
 struct hpsa_pci_info {
         unsigned char   bus;
         unsigned char   dev_fn;
         unsigned short  domain;
-        __u32           board_id;
+        u32             board_id;
 };
 
 #pragma pack()
diff --git a/drivers/scsi/ibmmca.c b/drivers/scsi/ibmmca.c
index 9c1e6a5b5af0..9a4b69d4f4eb 100644
--- a/drivers/scsi/ibmmca.c
+++ b/drivers/scsi/ibmmca.c
@@ -2336,7 +2336,7 @@ static int option_setup(char *str)
         char *cur = str;
         int i = 1;
 
-        while (cur && isdigit(*cur) && i <= IM_MAX_HOSTS) {
+        while (cur && isdigit(*cur) && i < IM_MAX_HOSTS) {
                 ints[i++] = simple_strtoul(cur, NULL, 0);
                 if ((cur = strchr(cur, ',')) != NULL)
                         cur++;
diff --git a/drivers/scsi/ibmvscsi/ibmvscsi.c b/drivers/scsi/ibmvscsi/ibmvscsi.c
index e475b7957c2d..e3a18e0ef276 100644
--- a/drivers/scsi/ibmvscsi/ibmvscsi.c
+++ b/drivers/scsi/ibmvscsi/ibmvscsi.c
@@ -40,7 +40,7 @@
  * (CRQ), which is just a buffer of 16 byte entries in the receiver's 
  * Senders cannot access the buffer directly, but send messages by
  * making a hypervisor call and passing in the 16 bytes.  The hypervisor
- * puts the message in the next 16 byte space in round-robbin fashion,
+ * puts the message in the next 16 byte space in round-robin fashion,
  * turns on the high order bit of the message (the valid bit), and 
  * generates an interrupt to the receiver (if interrupts are turned on.) 
  * The receiver just turns off the valid bit when they have copied out
diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
index 517da3fd89d3..8a89ba900588 100644
--- a/drivers/scsi/iscsi_tcp.c
+++ b/drivers/scsi/iscsi_tcp.c
@@ -584,9 +584,10 @@ static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         struct iscsi_conn *conn = cls_conn->dd_data;
         struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
         struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
+        struct socket *sock = tcp_sw_conn->sock;
 
         /* userspace may have goofed up and not bound us */
-        if (!tcp_sw_conn->sock)
+        if (!sock)
                 return;
         /*
          * Make sure our recv side is stopped.
@@ -597,6 +598,11 @@ static void iscsi_sw_tcp_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
         write_unlock_bh(&tcp_sw_conn->sock->sk->sk_callback_lock);
 
+        if (sock->sk->sk_sleep && waitqueue_active(sock->sk->sk_sleep)) {
+                sock->sk->sk_err = EIO;
+                wake_up_interruptible(sock->sk->sk_sleep);
+        }
+
         iscsi_conn_stop(cls_conn, flag);
         iscsi_sw_tcp_release_conn(conn);
 }
diff --git a/drivers/scsi/libiscsi.c b/drivers/scsi/libiscsi.c
index c28a712fd4db..703eb6a88790 100644
--- a/drivers/scsi/libiscsi.c
+++ b/drivers/scsi/libiscsi.c
@@ -1919,10 +1919,11 @@ static int iscsi_has_ping_timed_out(struct iscsi_conn *conn)
 static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
 {
         enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
-        struct iscsi_task *task = NULL;
+        struct iscsi_task *task = NULL, *running_task;
         struct iscsi_cls_session *cls_session;
         struct iscsi_session *session;
         struct iscsi_conn *conn;
+        int i;
 
         cls_session = starget_to_session(scsi_target(sc->device));
         session = cls_session->dd_data;
@@ -1947,8 +1948,15 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
         }
 
         task = (struct iscsi_task *)sc->SCp.ptr;
-        if (!task)
+        if (!task) {
+                /*
+                 * Raced with completion. Just reset timer, and let it
+                 * complete normally
+                 */
+                rc = BLK_EH_RESET_TIMER;
                 goto done;
+        }
+
         /*
          * If we have sent (at least queued to the network layer) a pdu or
          * recvd one for the task since the last timeout ask for
@@ -1956,10 +1964,10 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
          * we can check if it is the task or connection when we send the
          * nop as a ping.
          */
-        if (time_after_eq(task->last_xfer, task->last_timeout)) {
+        if (time_after(task->last_xfer, task->last_timeout)) {
                 ISCSI_DBG_EH(session, "Command making progress. Asking "
                              "scsi-ml for more time to complete. "
-                             "Last data recv at %lu. Last timeout was at "
+                             "Last data xfer at %lu. Last timeout was at "
                              "%lu\n.", task->last_xfer, task->last_timeout);
                 task->have_checked_conn = false;
                 rc = BLK_EH_RESET_TIMER;
@@ -1977,6 +1985,43 @@ static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
                 goto done;
         }
 
+        for (i = 0; i < conn->session->cmds_max; i++) {
+                running_task = conn->session->cmds[i];
+                if (!running_task->sc || running_task == task ||
+                     running_task->state != ISCSI_TASK_RUNNING)
+                        continue;
+
+                /*
+                 * Only check if cmds started before this one have made
+                 * progress, or this could never fail
+                 */
+                if (time_after(running_task->sc->jiffies_at_alloc,
+                               task->sc->jiffies_at_alloc))
+                        continue;
+
+                if (time_after(running_task->last_xfer, task->last_timeout)) {
+                        /*
+                         * This task has not made progress, but a task
+                         * started before us has transferred data since
+                         * we started/last-checked. We could be queueing
+                         * too many tasks or the LU is bad.
+                         *
+                         * If the device is bad the cmds ahead of us on
+                         * other devs will complete, and this loop will
+                         * eventually fail starting the scsi eh.
+                         */
+                        ISCSI_DBG_EH(session, "Command has not made progress "
+                                     "but commands ahead of it have. "
+                                     "Asking scsi-ml for more time to "
+                                     "complete. Our last xfer vs running task "
+                                     "last xfer %lu/%lu. Last check %lu.\n",
+                                     task->last_xfer, running_task->last_xfer,
+                                     task->last_timeout);
+                        rc = BLK_EH_RESET_TIMER;
+                        goto done;
+                }
+        }
+
         /* Assumes nop timeout is shorter than scsi cmd timeout */
         if (task->have_checked_conn)
                 goto done;
diff --git a/drivers/scsi/libsrp.c b/drivers/scsi/libsrp.c
index ab19b3b4be52..22775165bf6a 100644
--- a/drivers/scsi/libsrp.c
+++ b/drivers/scsi/libsrp.c
@@ -1,5 +1,5 @@
 /*
- * SCSI RDAM Protocol lib functions
+ * SCSI RDMA Protocol lib functions
  *
  * Copyright (C) 2006 FUJITA Tomonori <tomof@acm.org>
  *
@@ -328,7 +328,7 @@ int srp_transfer_data(struct scsi_cmnd *sc, struct srp_cmd *cmd,
         int offset, err = 0;
         u8 format;
 
-        offset = cmd->add_cdb_len * 4;
+        offset = cmd->add_cdb_len & ~3;
 
         dir = srp_cmd_direction(cmd);
         if (dir == DMA_FROM_DEVICE)
@@ -366,7 +366,7 @@ static int vscsis_data_length(struct srp_cmd *cmd, enum dma_data_direction dir)
 {
         struct srp_direct_buf *md;
         struct srp_indirect_buf *id;
-        int len = 0, offset = cmd->add_cdb_len * 4;
+        int len = 0, offset = cmd->add_cdb_len & ~3;
         u8 fmt;
 
         if (dir == DMA_TO_DEVICE)
@@ -440,6 +440,6 @@ int srp_cmd_queue(struct Scsi_Host *shost, struct srp_cmd *cmd, void *info,
 }
 EXPORT_SYMBOL_GPL(srp_cmd_queue);
 
-MODULE_DESCRIPTION("SCSI RDAM Protocol lib functions");
+MODULE_DESCRIPTION("SCSI RDMA Protocol lib functions");
 MODULE_AUTHOR("FUJITA Tomonori");
 MODULE_LICENSE("GPL");
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 1cc23a69db5e..84b696463a58 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -315,6 +315,9 @@ struct lpfc_vport {
 #define FC_VPORT_NEEDS_REG_VPI  0x80000  /* Needs to have its vpi registered */
 #define FC_RSCN_DEFERRED        0x100000 /* A deferred RSCN being processed */
 #define FC_VPORT_NEEDS_INIT_VPI 0x200000 /* Need to INIT_VPI before FDISC */
+#define FC_VPORT_CVL_RCVD       0x400000 /* VLink failed due to CVL      */
+#define FC_VFI_REGISTERED       0x800000 /* VFI is registered */
+#define FC_FDISC_COMPLETED      0x1000000/* FDISC completed */
 
         uint32_t ct_flags;
 #define FC_CT_RFF_ID            0x1      /* RFF_ID accepted by switch */
@@ -448,6 +451,8 @@ struct unsol_rcv_ct_ctx {
         uint32_t ctxt_id;
         uint32_t SID;
         uint32_t oxid;
+        uint32_t flags;
+#define UNSOL_VALID     0x00000001
 };
 
 struct lpfc_hba {
@@ -499,6 +504,10 @@ struct lpfc_hba {
                 (struct lpfc_hba *);
         void (*lpfc_stop_port)
                 (struct lpfc_hba *);
+        int (*lpfc_hba_init_link)
+                (struct lpfc_hba *);
+        int (*lpfc_hba_down_link)
+                (struct lpfc_hba *);
 
 
         /* SLI4 specific HBA data structure */
@@ -613,6 +622,7 @@ struct lpfc_hba {
         uint32_t cfg_enable_bg;
         uint32_t cfg_log_verbose;
         uint32_t cfg_aer_support;
+        uint32_t cfg_suppress_link_up;
 
         lpfc_vpd_t vpd;         /* vital product data */
 
@@ -790,7 +800,7 @@ struct lpfc_hba {
         uint16_t vlan_id;
         struct list_head fcf_conn_rec_list;
 
-        struct mutex ct_event_mutex; /* synchronize access to ct_ev_waiters */
+        spinlock_t ct_ev_lock; /* synchronize access to ct_ev_waiters */
         struct list_head ct_ev_waiters;
         struct unsol_rcv_ct_ctx ct_ctx[64];
         uint32_t ctx_idx;
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 91542f786edf..c992e8328f9e 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -482,6 +482,41 @@ lpfc_link_state_show(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * lpfc_link_state_store - Transition the link_state on an HBA port
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: one or more lpfc_polling_flags values.
+ * @count: not used.
+ *
+ * Returns:
+ * -EINVAL if the buffer is not "up" or "down"
+ * return from link state change function if non-zero
+ * length of the buf on success
+ **/
+static ssize_t
+lpfc_link_state_store(struct device *dev, struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct Scsi_Host  *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba   *phba = vport->phba;
+
+        int status = -EINVAL;
+
+        if ((strncmp(buf, "up", sizeof("up") - 1) == 0) &&
+                        (phba->link_state == LPFC_LINK_DOWN))
+                status = phba->lpfc_hba_init_link(phba);
+        else if ((strncmp(buf, "down", sizeof("down") - 1) == 0) &&
+                        (phba->link_state >= LPFC_LINK_UP))
+                status = phba->lpfc_hba_down_link(phba);
+
+        if (status == 0)
+                return strlen(buf);
+        else
+                return status;
+}
+
+/**
  * lpfc_num_discovered_ports_show - Return sum of mapped and unmapped vports
  * @dev: class device that is converted into a Scsi_host.
  * @attr: device attribute, not used.
@@ -1219,7 +1254,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
-        int val = 0;\
+        uint val = 0;\
         val = phba->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%d\n",\
                         phba->cfg_##attr);\
@@ -1247,7 +1282,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
-        int val = 0;\
+        uint val = 0;\
         val = phba->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%#x\n",\
                         phba->cfg_##attr);\
@@ -1274,7 +1309,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
  **/
 #define lpfc_param_init(attr, default, minval, maxval)  \
 static int \
-lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
+lpfc_##attr##_init(struct lpfc_hba *phba, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 phba->cfg_##attr = val;\
@@ -1309,7 +1344,7 @@ lpfc_##attr##_init(struct lpfc_hba *phba, int val) \
  **/
 #define lpfc_param_set(attr, default, minval, maxval)   \
 static int \
-lpfc_##attr##_set(struct lpfc_hba *phba, int val) \
+lpfc_##attr##_set(struct lpfc_hba *phba, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 phba->cfg_##attr = val;\
@@ -1350,7 +1385,7 @@ lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
         struct lpfc_hba   *phba = vport->phba;\
-        int val=0;\
+        uint val = 0;\
         if (!isdigit(buf[0]))\
                 return -EINVAL;\
         if (sscanf(buf, "%i", &val) != 1)\
@@ -1382,7 +1417,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
 { \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
-        int val = 0;\
+        uint val = 0;\
         val = vport->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%d\n", vport->cfg_##attr);\
 }
@@ -1409,7 +1444,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
 { \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
-        int val = 0;\
+        uint val = 0;\
         val = vport->cfg_##attr;\
         return snprintf(buf, PAGE_SIZE, "%#x\n", vport->cfg_##attr);\
 }
@@ -1434,7 +1469,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
  **/
 #define lpfc_vport_param_init(attr, default, minval, maxval)    \
 static int \
-lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
+lpfc_##attr##_init(struct lpfc_vport *vport, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 vport->cfg_##attr = val;\
@@ -1466,7 +1501,7 @@ lpfc_##attr##_init(struct lpfc_vport *vport, int val) \
  **/
 #define lpfc_vport_param_set(attr, default, minval, maxval)     \
 static int \
-lpfc_##attr##_set(struct lpfc_vport *vport, int val) \
+lpfc_##attr##_set(struct lpfc_vport *vport, uint val) \
 { \
         if (val >= minval && val <= maxval) {\
                 vport->cfg_##attr = val;\
@@ -1502,7 +1537,7 @@ lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
 { \
         struct Scsi_Host  *shost = class_to_shost(dev);\
         struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;\
-        int val=0;\
+        uint val = 0;\
         if (!isdigit(buf[0]))\
                 return -EINVAL;\
         if (sscanf(buf, "%i", &val) != 1)\
@@ -1515,22 +1550,22 @@ lpfc_##attr##_store(struct device *dev, struct device_attribute *attr, \
 
 
 #define LPFC_ATTR(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_init(name, defval, minval, maxval)
 
 #define LPFC_ATTR_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_ATTR_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
@@ -1540,16 +1575,16 @@ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
                    lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_ATTR_HEX_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_hex_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_param_hex_show(name)\
 lpfc_param_init(name, defval, minval, maxval)\
@@ -1559,22 +1594,22 @@ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
                    lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_VPORT_ATTR(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_init(name, defval, minval, maxval)
 
 #define LPFC_VPORT_ATTR_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_VPORT_ATTR_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
@@ -1584,16 +1619,16 @@ static DEVICE_ATTR(lpfc_##name, S_IRUGO | S_IWUSR,\
                    lpfc_##name##_show, lpfc_##name##_store)
 
 #define LPFC_VPORT_ATTR_HEX_R(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_hex_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
 static DEVICE_ATTR(lpfc_##name, S_IRUGO , lpfc_##name##_show, NULL)
 
 #define LPFC_VPORT_ATTR_HEX_RW(name, defval, minval, maxval, desc) \
-static int lpfc_##name = defval;\
-module_param(lpfc_##name, int, 0);\
+static uint lpfc_##name = defval;\
+module_param(lpfc_##name, uint, 0);\
 MODULE_PARM_DESC(lpfc_##name, desc);\
 lpfc_vport_param_hex_show(name)\
 lpfc_vport_param_init(name, defval, minval, maxval)\
@@ -1614,7 +1649,8 @@ static DEVICE_ATTR(programtype, S_IRUGO, lpfc_programtype_show, NULL);
 static DEVICE_ATTR(portnum, S_IRUGO, lpfc_vportnum_show, NULL);
 static DEVICE_ATTR(fwrev, S_IRUGO, lpfc_fwrev_show, NULL);
 static DEVICE_ATTR(hdw, S_IRUGO, lpfc_hdw_show, NULL);
-static DEVICE_ATTR(link_state, S_IRUGO, lpfc_link_state_show, NULL);
+static DEVICE_ATTR(link_state, S_IRUGO | S_IWUSR, lpfc_link_state_show,
+                lpfc_link_state_store);
 static DEVICE_ATTR(option_rom_version, S_IRUGO,
                    lpfc_option_rom_version_show, NULL);
 static DEVICE_ATTR(num_discovered_ports, S_IRUGO,
@@ -1897,6 +1933,15 @@ static DEVICE_ATTR(lpfc_enable_npiv, S_IRUGO,
                          lpfc_enable_npiv_show, NULL);
 
 /*
+# lpfc_suppress_link_up:  Bring link up at initialization
+#            0x0  = bring link up (issue MBX_INIT_LINK)
+#            0x1  = do NOT bring link up at initialization(MBX_INIT_LINK)
+#            0x2  = never bring up link
+# Default value is 0.
+*/
+LPFC_ATTR_R(suppress_link_up, 0, 0, 2, "Suppress Link Up at initialization");
+
+/*
 # lpfc_nodev_tmo: If set, it will hold all I/O errors on devices that disappear
 # until the timer expires. Value range is [0,255]. Default value is 30.
 */
@@ -3114,12 +3159,12 @@ LPFC_ATTR_RW(poll_tmo, 10, 1, 255,
 /*
 # lpfc_use_msi: Use MSI (Message Signaled Interrupts) in systems that
 #               support this feature
-#       0  = MSI disabled (default)
+#       0  = MSI disabled
 #       1  = MSI enabled
-#       2  = MSI-X enabled
-# Value range is [0,2]. Default value is 0.
+#       2  = MSI-X enabled (default)
+# Value range is [0,2]. Default value is 2.
 */
-LPFC_ATTR_R(use_msi, 0, 0, 2, "Use Message Signaled Interrupts (1) or "
+LPFC_ATTR_R(use_msi, 2, 0, 2, "Use Message Signaled Interrupts (1) or "
             "MSI-X (2), if possible");
 
 /*
@@ -3278,6 +3323,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_prot_sg_seg_cnt,
         &dev_attr_lpfc_aer_support,
         &dev_attr_lpfc_aer_state_cleanup,
+        &dev_attr_lpfc_suppress_link_up,
         NULL,
 };
 
@@ -4456,7 +4502,7 @@ lpfc_get_cfgparam(struct lpfc_hba *phba)
         lpfc_hba_queue_depth_init(phba, lpfc_hba_queue_depth);
         lpfc_hba_log_verbose_init(phba, lpfc_log_verbose);
         lpfc_aer_support_init(phba, lpfc_aer_support);
-
+        lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
         return;
 }
 
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index a5d9048235d9..f3f1bf1a0a71 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2009 Emulex.  All rights reserved.                *
+ * Copyright (C) 2009-2010 Emulex.  All rights reserved.                *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -21,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/mempool.h>
 #include <linux/pci.h>
+#include <linux/delay.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
@@ -33,6 +34,7 @@
 #include "lpfc_sli.h"
 #include "lpfc_sli4.h"
 #include "lpfc_nl.h"
+#include "lpfc_bsg.h"
 #include "lpfc_disc.h"
 #include "lpfc_scsi.h"
 #include "lpfc.h"
@@ -41,14 +43,183 @@
 #include "lpfc_vport.h"
 #include "lpfc_version.h"
 
+struct lpfc_bsg_event {
+        struct list_head node;
+        struct kref kref;
+        wait_queue_head_t wq;
+
+        /* Event type and waiter identifiers */
+        uint32_t type_mask;
+        uint32_t req_id;
+        uint32_t reg_id;
+
+        /* next two flags are here for the auto-delete logic */
+        unsigned long wait_time_stamp;
+        int waiting;
+
+        /* seen and not seen events */
+        struct list_head events_to_get;
+        struct list_head events_to_see;
+
+        /* job waiting for this event to finish */
+        struct fc_bsg_job *set_job;
+};
+
+struct lpfc_bsg_iocb {
+        struct lpfc_iocbq *cmdiocbq;
+        struct lpfc_iocbq *rspiocbq;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_nodelist *ndlp;
+
+        /* job waiting for this iocb to finish */
+        struct fc_bsg_job *set_job;
+};
+
+struct lpfc_bsg_mbox {
+        LPFC_MBOXQ_t *pmboxq;
+        MAILBOX_t *mb;
+
+        /* job waiting for this mbox command to finish */
+        struct fc_bsg_job *set_job;
+};
+
+#define TYPE_EVT        1
+#define TYPE_IOCB       2
+#define TYPE_MBOX       3
+struct bsg_job_data {
+        uint32_t type;
+        union {
+                struct lpfc_bsg_event *evt;
+                struct lpfc_bsg_iocb iocb;
+                struct lpfc_bsg_mbox mbox;
+        } context_un;
+};
+
+struct event_data {
+        struct list_head node;
+        uint32_t type;
+        uint32_t immed_dat;
+        void *data;
+        uint32_t len;
+};
+
+#define BUF_SZ_4K 4096
+#define SLI_CT_ELX_LOOPBACK 0x10
+
+enum ELX_LOOPBACK_CMD {
+        ELX_LOOPBACK_XRI_SETUP,
+        ELX_LOOPBACK_DATA,
+};
+
+#define ELX_LOOPBACK_HEADER_SZ \
+        (size_t)(&((struct lpfc_sli_ct_request *)NULL)->un)
+
+struct lpfc_dmabufext {
+        struct lpfc_dmabuf dma;
+        uint32_t size;
+        uint32_t flag;
+};
+
+/**
+ * lpfc_bsg_send_mgmt_cmd_cmp - lpfc_bsg_send_mgmt_cmd's completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_bsg_send_mgmt_cmd function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from another thread which
+ * cleans up the SLI layer objects.
+ * This function copies the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_bsg_send_mgmt_cmd_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        unsigned long iflags;
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_nodelist *ndlp;
+        struct lpfc_bsg_iocb *iocb;
+        unsigned long flags;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        iocb = &dd_data->context_un.iocb;
+        job = iocb->set_job;
+        job->dd_data = NULL; /* so timeout handler does not reply */
+
+        spin_lock_irqsave(&phba->hbalock, iflags);
+        cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
+        if (cmdiocbq->context2 && rspiocbq)
+                memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
+                       &rspiocbq->iocb, sizeof(IOCB_t));
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
+
+        bmp = iocb->bmp;
+        rspiocbq = iocb->rspiocbq;
+        rsp = &rspiocbq->iocb;
+        ndlp = iocb->ndlp;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        if (rsp->ulpStatus) {
+                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
+                        switch (rsp->un.ulpWord[4] & 0xff) {
+                        case IOERR_SEQUENCE_TIMEOUT:
+                                rc = -ETIMEDOUT;
+                                break;
+                        case IOERR_INVALID_RPI:
+                                rc = -EFAULT;
+                                break;
+                        default:
+                                rc = -EACCES;
+                                break;
+                        }
+                } else
+                        rc = -EACCES;
+        } else
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.genreq64.bdl.bdeSize;
+
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+        lpfc_sli_release_iocbq(phba, rspiocbq);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        lpfc_nlp_put(ndlp);
+        kfree(bmp);
+        kfree(dd_data);
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        /* complete the job back to userspace */
+        job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
+}
+
 /**
- * lpfc_bsg_rport_ct - send a CT command from a bsg request
+ * lpfc_bsg_send_mgmt_cmd - send a CT command from a bsg request
  * @job: fc_bsg_job to handle
- */
+ **/
 static int
-lpfc_bsg_rport_ct(struct fc_bsg_job *job)
+lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
 {
-        struct Scsi_Host *shost = job->shost;
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
         struct lpfc_rport_data *rdata = job->rport->dd_data;
@@ -65,57 +236,60 @@ lpfc_bsg_rport_ct(struct fc_bsg_job *job)
         struct scatterlist *sgel = NULL;
         int numbde;
         dma_addr_t busaddr;
+        struct bsg_job_data *dd_data;
+        uint32_t creg_val;
         int rc = 0;
 
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
 
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2733 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
         if (!lpfc_nlp_get(ndlp)) {
-                job->reply->result = -ENODEV;
-                return 0;
+                rc = -ENODEV;
+                goto no_ndlp;
+        }
+
+        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!bmp) {
+                rc = -ENOMEM;
+                goto free_ndlp;
         }
 
         if (ndlp->nlp_flag & NLP_ELS_SND_MASK) {
                 rc = -ENODEV;
-                goto free_ndlp_exit;
+                goto free_bmp;
         }
 
-        spin_lock_irq(shost->host_lock);
         cmdiocbq = lpfc_sli_get_iocbq(phba);
         if (!cmdiocbq) {
                 rc = -ENOMEM;
-                spin_unlock_irq(shost->host_lock);
-                goto free_ndlp_exit;
+                goto free_bmp;
         }
-        cmd = &cmdiocbq->iocb;
 
+        cmd = &cmdiocbq->iocb;
         rspiocbq = lpfc_sli_get_iocbq(phba);
         if (!rspiocbq) {
                 rc = -ENOMEM;
                 goto free_cmdiocbq;
         }
-        spin_unlock_irq(shost->host_lock);
 
         rsp = &rspiocbq->iocb;
-
-        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-        if (!bmp) {
-                rc = -ENOMEM;
-                spin_lock_irq(shost->host_lock);
-                goto free_rspiocbq;
-        }
-
-        spin_lock_irq(shost->host_lock);
         bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
         if (!bmp->virt) {
                 rc = -ENOMEM;
-                goto free_bmp;
+                goto free_rspiocbq;
         }
-        spin_unlock_irq(shost->host_lock);
 
         INIT_LIST_HEAD(&bmp->list);
         bpl = (struct ulp_bde64 *) bmp->virt;
-
         request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
                                   job->request_payload.sg_cnt, DMA_TO_DEVICE);
         for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
@@ -157,78 +331,152 @@ lpfc_bsg_rport_ct(struct fc_bsg_job *job)
         cmd->ulpContext = ndlp->nlp_rpi;
         cmd->ulpOwner = OWN_CHIP;
         cmdiocbq->vport = phba->pport;
-        cmdiocbq->context1 = NULL;
-        cmdiocbq->context2 = NULL;
+        cmdiocbq->context3 = bmp;
         cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
-
         timeout = phba->fc_ratov * 2;
-        job->dd_data = cmdiocbq;
-
-        rc = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq, rspiocbq,
-                                        timeout + LPFC_DRVR_TIMEOUT);
-
-        if (rc != IOCB_TIMEDOUT) {
-                pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
-                             job->request_payload.sg_cnt, DMA_TO_DEVICE);
-                pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
-                             job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        cmd->ulpTimeout = timeout;
+
+        cmdiocbq->iocb_cmpl = lpfc_bsg_send_mgmt_cmd_cmp;
+        cmdiocbq->context1 = dd_data;
+        cmdiocbq->context2 = rspiocbq;
+        dd_data->type = TYPE_IOCB;
+        dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
+        dd_data->context_un.iocb.rspiocbq = rspiocbq;
+        dd_data->context_un.iocb.set_job = job;
+        dd_data->context_un.iocb.bmp = bmp;
+        dd_data->context_un.iocb.ndlp = ndlp;
+
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
         }
 
-        if (rc == IOCB_TIMEDOUT) {
-                lpfc_sli_release_iocbq(phba, rspiocbq);
-                rc = -EACCES;
-                goto free_ndlp_exit;
-        }
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
 
-        if (rc != IOCB_SUCCESS) {
-                rc = -EACCES;
-                goto free_outdmp;
-        }
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
 
-        if (rsp->ulpStatus) {
-                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
-                        switch (rsp->un.ulpWord[4] & 0xff) {
-                        case IOERR_SEQUENCE_TIMEOUT:
-                                rc = -ETIMEDOUT;
-                                break;
-                        case IOERR_INVALID_RPI:
-                                rc = -EFAULT;
-                                break;
-                        default:
-                                rc = -EACCES;
-                                break;
-                        }
-                        goto free_outdmp;
-                }
-        } else
-                job->reply->reply_payload_rcv_len =
-                        rsp->un.genreq64.bdl.bdeSize;
+        /* iocb failed so cleanup */
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 
-free_outdmp:
-        spin_lock_irq(shost->host_lock);
         lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
-free_bmp:
-        kfree(bmp);
+
 free_rspiocbq:
         lpfc_sli_release_iocbq(phba, rspiocbq);
 free_cmdiocbq:
         lpfc_sli_release_iocbq(phba, cmdiocbq);
-        spin_unlock_irq(shost->host_lock);
-free_ndlp_exit:
+free_bmp:
+        kfree(bmp);
+free_ndlp:
         lpfc_nlp_put(ndlp);
+no_ndlp:
+        kfree(dd_data);
+no_dd_data:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        return rc;
+}
+
+/**
+ * lpfc_bsg_rport_els_cmp - lpfc_bsg_rport_els's completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_bsg_rport_els_cmp function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from other thread which
+ * cleans up the SLI layer objects.
+ * This function copies the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_bsg_rport_els_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_nodelist *ndlp;
+        struct lpfc_dmabuf *pbuflist = NULL;
+        struct fc_bsg_ctels_reply *els_reply;
+        uint8_t *rjt_data;
+        unsigned long flags;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        /* normal completion and timeout crossed paths, already done */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->hbalock, flags);
+                return;
+        }
+
+        cmdiocbq->iocb_flag |= LPFC_IO_WAKE;
+        if (cmdiocbq->context2 && rspiocbq)
+                memcpy(&((struct lpfc_iocbq *)cmdiocbq->context2)->iocb,
+                       &rspiocbq->iocb, sizeof(IOCB_t));
+
+        job = dd_data->context_un.iocb.set_job;
+        cmdiocbq = dd_data->context_un.iocb.cmdiocbq;
+        rspiocbq = dd_data->context_un.iocb.rspiocbq;
+        rsp = &rspiocbq->iocb;
+        ndlp = dd_data->context_un.iocb.ndlp;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
 
+        if (job->reply->result == -EAGAIN)
+                rc = -EAGAIN;
+        else if (rsp->ulpStatus == IOSTAT_SUCCESS)
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.elsreq64.bdl.bdeSize;
+        else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
+                job->reply->reply_payload_rcv_len =
+                        sizeof(struct fc_bsg_ctels_reply);
+                /* LS_RJT data returned in word 4 */
+                rjt_data = (uint8_t *)&rsp->un.ulpWord[4];
+                els_reply = &job->reply->reply_data.ctels_reply;
+                els_reply->status = FC_CTELS_STATUS_REJECT;
+                els_reply->rjt_data.action = rjt_data[3];
+                els_reply->rjt_data.reason_code = rjt_data[2];
+                els_reply->rjt_data.reason_explanation = rjt_data[1];
+                els_reply->rjt_data.vendor_unique = rjt_data[0];
+        } else
+                rc = -EIO;
+
+        pbuflist = (struct lpfc_dmabuf *) cmdiocbq->context3;
+        lpfc_mbuf_free(phba, pbuflist->virt, pbuflist->phys);
+        lpfc_sli_release_iocbq(phba, rspiocbq);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        lpfc_nlp_put(ndlp);
+        kfree(dd_data);
         /* make error code available to userspace */
         job->reply->result = rc;
+        job->dd_data = NULL;
         /* complete the job back to userspace */
         job->job_done(job);
-
-        return 0;
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
 }
 
 /**
  * lpfc_bsg_rport_els - send an ELS command from a bsg request
  * @job: fc_bsg_job to handle
- */
+ **/
 static int
 lpfc_bsg_rport_els(struct fc_bsg_job *job)
 {
@@ -236,7 +484,6 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         struct lpfc_hba *phba = vport->phba;
         struct lpfc_rport_data *rdata = job->rport->dd_data;
         struct lpfc_nodelist *ndlp = rdata->pnode;
-
         uint32_t elscmd;
         uint32_t cmdsize;
         uint32_t rspsize;
@@ -248,20 +495,30 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         struct lpfc_dmabuf *prsp;
         struct lpfc_dmabuf *pbuflist = NULL;
         struct ulp_bde64 *bpl;
-        int iocb_status;
         int request_nseg;
         int reply_nseg;
         struct scatterlist *sgel = NULL;
         int numbde;
         dma_addr_t busaddr;
+        struct bsg_job_data *dd_data;
+        uint32_t creg_val;
         int rc = 0;
 
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
 
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2735 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
         if (!lpfc_nlp_get(ndlp)) {
                 rc = -ENODEV;
-                goto out;
+                goto free_dd_data;
         }
 
         elscmd = job->request->rqst_data.r_els.els_code;
@@ -271,24 +528,24 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         if (!rspiocbq) {
                 lpfc_nlp_put(ndlp);
                 rc = -ENOMEM;
-                goto out;
+                goto free_dd_data;
         }
 
         rsp = &rspiocbq->iocb;
         rpi = ndlp->nlp_rpi;
 
-        cmdiocbq = lpfc_prep_els_iocb(phba->pport, 1, cmdsize, 0, ndlp,
+        cmdiocbq = lpfc_prep_els_iocb(vport, 1, cmdsize, 0, ndlp,
                                       ndlp->nlp_DID, elscmd);
-
         if (!cmdiocbq) {
-                lpfc_sli_release_iocbq(phba, rspiocbq);
-                return -EIO;
+                rc = -EIO;
+                goto free_rspiocbq;
         }
 
-        job->dd_data = cmdiocbq;
+        /* prep els iocb set context1 to the ndlp, context2 to the command
+         * dmabuf, context3 holds the data dmabuf
+         */
         pcmd = (struct lpfc_dmabuf *) cmdiocbq->context2;
         prsp = (struct lpfc_dmabuf *) pcmd->list.next;
-
         lpfc_mbuf_free(phba, pcmd->virt, pcmd->phys);
         kfree(pcmd);
         lpfc_mbuf_free(phba, prsp->virt, prsp->phys);
@@ -300,7 +557,6 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
 
         request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
                                   job->request_payload.sg_cnt, DMA_TO_DEVICE);
-
         for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
                 busaddr = sg_dma_address(sgel);
                 bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
@@ -322,7 +578,6 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
                 bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
                 bpl++;
         }
-
         cmdiocbq->iocb.un.elsreq64.bdl.bdeSize =
                 (request_nseg + reply_nseg) * sizeof(struct ulp_bde64);
         cmdiocbq->iocb.ulpContext = rpi;
@@ -330,102 +585,62 @@ lpfc_bsg_rport_els(struct fc_bsg_job *job)
         cmdiocbq->context1 = NULL;
         cmdiocbq->context2 = NULL;
 
-        iocb_status = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
-                                        rspiocbq, (phba->fc_ratov * 2)
-                                               + LPFC_DRVR_TIMEOUT);
-
-        /* release the new ndlp once the iocb completes */
-        lpfc_nlp_put(ndlp);
-        if (iocb_status != IOCB_TIMEDOUT) {
-                pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
-                             job->request_payload.sg_cnt, DMA_TO_DEVICE);
-                pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
-                             job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        cmdiocbq->iocb_cmpl = lpfc_bsg_rport_els_cmp;
+        cmdiocbq->context1 = dd_data;
+        cmdiocbq->context2 = rspiocbq;
+        dd_data->type = TYPE_IOCB;
+        dd_data->context_un.iocb.cmdiocbq = cmdiocbq;
+        dd_data->context_un.iocb.rspiocbq = rspiocbq;
+        dd_data->context_un.iocb.set_job = job;
+        dd_data->context_un.iocb.bmp = NULL;;
+        dd_data->context_un.iocb.ndlp = ndlp;
+
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
         }
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
+        lpfc_nlp_put(ndlp);
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
 
-        if (iocb_status == IOCB_SUCCESS) {
-                if (rsp->ulpStatus == IOSTAT_SUCCESS) {
-                        job->reply->reply_payload_rcv_len =
-                                rsp->un.elsreq64.bdl.bdeSize;
-                        rc = 0;
-                } else if (rsp->ulpStatus == IOSTAT_LS_RJT) {
-                        struct fc_bsg_ctels_reply *els_reply;
-                        /* LS_RJT data returned in word 4 */
-                        uint8_t *rjt_data = (uint8_t *)&rsp->un.ulpWord[4];
-
-                        els_reply = &job->reply->reply_data.ctels_reply;
-                        job->reply->result = 0;
-                        els_reply->status = FC_CTELS_STATUS_REJECT;
-                        els_reply->rjt_data.action = rjt_data[0];
-                        els_reply->rjt_data.reason_code = rjt_data[1];
-                        els_reply->rjt_data.reason_explanation = rjt_data[2];
-                        els_reply->rjt_data.vendor_unique = rjt_data[3];
-                } else
-                        rc = -EIO;
-        } else
-                rc = -EIO;
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        pci_unmap_sg(phba->pcidev, job->reply_payload.sg_list,
+                     job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+        lpfc_mbuf_free(phba, pbuflist->virt, pbuflist->phys);
 
-        if (iocb_status != IOCB_TIMEDOUT)
-                lpfc_els_free_iocb(phba, cmdiocbq);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
 
+free_rspiocbq:
         lpfc_sli_release_iocbq(phba, rspiocbq);
 
-out:
+free_dd_data:
+        kfree(dd_data);
+
+no_dd_data:
         /* make error code available to userspace */
         job->reply->result = rc;
-        /* complete the job back to userspace */
-        job->job_done(job);
-
-        return 0;
-}
-
-struct lpfc_ct_event {
-        struct list_head node;
-        int ref;
-        wait_queue_head_t wq;
-
-        /* Event type and waiter identifiers */
-        uint32_t type_mask;
-        uint32_t req_id;
-        uint32_t reg_id;
-
-        /* next two flags are here for the auto-delete logic */
-        unsigned long wait_time_stamp;
-        int waiting;
-
-        /* seen and not seen events */
-        struct list_head events_to_get;
-        struct list_head events_to_see;
-};
-
-struct event_data {
-        struct list_head node;
-        uint32_t type;
-        uint32_t immed_dat;
-        void *data;
-        uint32_t len;
-};
-
-static struct lpfc_ct_event *
-lpfc_ct_event_new(int ev_reg_id, uint32_t ev_req_id)
-{
-        struct lpfc_ct_event *evt = kzalloc(sizeof(*evt), GFP_KERNEL);
-        if (!evt)
-                return NULL;
-
-        INIT_LIST_HEAD(&evt->events_to_get);
-        INIT_LIST_HEAD(&evt->events_to_see);
-        evt->req_id = ev_req_id;
-        evt->reg_id = ev_reg_id;
-        evt->wait_time_stamp = jiffies;
-        init_waitqueue_head(&evt->wq);
-
-        return evt;
+        job->dd_data = NULL;
+        return rc;
 }
 
+/**
+ * lpfc_bsg_event_free - frees an allocated event structure
+ * @kref: Pointer to a kref.
+ *
+ * Called from kref_put. Back cast the kref into an event structure address.
+ * Free any events to get, delete associated nodes, free any events to see,
+ * free any data then free the event itself.
+ **/
 static void
-lpfc_ct_event_free(struct lpfc_ct_event *evt)
+lpfc_bsg_event_free(struct kref *kref)
 {
+        struct lpfc_bsg_event *evt = container_of(kref, struct lpfc_bsg_event,
+                                                  kref);
         struct event_data *ed;
 
         list_del(&evt->node);
@@ -447,25 +662,82 @@ lpfc_ct_event_free(struct lpfc_ct_event *evt)
         kfree(evt);
 }
 
+/**
+ * lpfc_bsg_event_ref - increments the kref for an event
+ * @evt: Pointer to an event structure.
+ **/
 static inline void
-lpfc_ct_event_ref(struct lpfc_ct_event *evt)
+lpfc_bsg_event_ref(struct lpfc_bsg_event *evt)
 {
-        evt->ref++;
+        kref_get(&evt->kref);
 }
 
+/**
+ * lpfc_bsg_event_unref - Uses kref_put to free an event structure
+ * @evt: Pointer to an event structure.
+ **/
 static inline void
-lpfc_ct_event_unref(struct lpfc_ct_event *evt)
+lpfc_bsg_event_unref(struct lpfc_bsg_event *evt)
 {
-        if (--evt->ref < 0)
-                lpfc_ct_event_free(evt);
+        kref_put(&evt->kref, lpfc_bsg_event_free);
 }
 
-#define SLI_CT_ELX_LOOPBACK 0x10
+/**
+ * lpfc_bsg_event_new - allocate and initialize a event structure
+ * @ev_mask: Mask of events.
+ * @ev_reg_id: Event reg id.
+ * @ev_req_id: Event request id.
+ **/
+static struct lpfc_bsg_event *
+lpfc_bsg_event_new(uint32_t ev_mask, int ev_reg_id, uint32_t ev_req_id)
+{
+        struct lpfc_bsg_event *evt = kzalloc(sizeof(*evt), GFP_KERNEL);
 
-enum ELX_LOOPBACK_CMD {
-        ELX_LOOPBACK_XRI_SETUP,
-        ELX_LOOPBACK_DATA,
-};
+        if (!evt)
+                return NULL;
+
+        INIT_LIST_HEAD(&evt->events_to_get);
+        INIT_LIST_HEAD(&evt->events_to_see);
+        evt->type_mask = ev_mask;
+        evt->req_id = ev_req_id;
+        evt->reg_id = ev_reg_id;
+        evt->wait_time_stamp = jiffies;
+        init_waitqueue_head(&evt->wq);
+        kref_init(&evt->kref);
+        return evt;
+}
+
+/**
+ * diag_cmd_data_free - Frees an lpfc dma buffer extension
+ * @phba: Pointer to HBA context object.
+ * @mlist: Pointer to an lpfc dma buffer extension.
+ **/
+static int
+diag_cmd_data_free(struct lpfc_hba *phba, struct lpfc_dmabufext *mlist)
+{
+        struct lpfc_dmabufext *mlast;
+        struct pci_dev *pcidev;
+        struct list_head head, *curr, *next;
+
+        if ((!mlist) || (!lpfc_is_link_up(phba) &&
+                (phba->link_flag & LS_LOOPBACK_MODE))) {
+                return 0;
+        }
+
+        pcidev = phba->pcidev;
+        list_add_tail(&head, &mlist->dma.list);
+
+        list_for_each_safe(curr, next, &head) {
+                mlast = list_entry(curr, struct lpfc_dmabufext , dma.list);
+                if (mlast->dma.virt)
+                        dma_free_coherent(&pcidev->dev,
+                                          mlast->size,
+                                          mlast->dma.virt,
+                                          mlast->dma.phys);
+                kfree(mlast);
+        }
+        return 0;
+}
 
 /**
  * lpfc_bsg_ct_unsol_event - process an unsolicited CT command
@@ -474,9 +746,9 @@ enum ELX_LOOPBACK_CMD {
  * @piocbq:
  *
  * This function is called when an unsolicited CT command is received.  It
- * forwards the event to any processes registerd to receive CT events.
- */
-void
+ * forwards the event to any processes registered to receive CT events.
+ **/
+int
 lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         struct lpfc_iocbq *piocbq)
 {
@@ -484,7 +756,7 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         uint32_t cmd;
         uint32_t len;
         struct lpfc_dmabuf *dmabuf = NULL;
-        struct lpfc_ct_event *evt;
+        struct lpfc_bsg_event *evt;
         struct event_data *evt_dat = NULL;
         struct lpfc_iocbq *iocbq;
         size_t offset = 0;
@@ -496,6 +768,9 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         struct lpfc_dmabuf *bdeBuf2 = piocbq->context3;
         struct lpfc_hbq_entry *hbqe;
         struct lpfc_sli_ct_request *ct_req;
+        struct fc_bsg_job *job = NULL;
+        unsigned long flags;
+        int size = 0;
 
         INIT_LIST_HEAD(&head);
         list_add_tail(&head, &piocbq->list);
@@ -504,6 +779,10 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
             piocbq->iocb.un.cont64[0].tus.f.bdeSize == 0)
                 goto error_ct_unsol_exit;
 
+        if (phba->link_state == LPFC_HBA_ERROR ||
+                (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE)))
+                goto error_ct_unsol_exit;
+
         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED)
                 dmabuf = bdeBuf1;
         else {
@@ -511,7 +790,8 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                     piocbq->iocb.un.cont64[0].addrLow);
                 dmabuf = lpfc_sli_ringpostbuf_get(phba, pring, dma_addr);
         }
-
+        if (dmabuf == NULL)
+                goto error_ct_unsol_exit;
         ct_req = (struct lpfc_sli_ct_request *)dmabuf->virt;
         evt_req_id = ct_req->FsType;
         cmd = ct_req->CommandResponse.bits.CmdRsp;
@@ -519,24 +799,24 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         if (!(phba->sli3_options & LPFC_SLI3_HBQ_ENABLED))
                 lpfc_sli_ringpostbuf_put(phba, pring, dmabuf);
 
-        mutex_lock(&phba->ct_event_mutex);
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
-                if (evt->req_id != evt_req_id)
+                if (!(evt->type_mask & FC_REG_CT_EVENT) ||
+                        evt->req_id != evt_req_id)
                         continue;
 
-                lpfc_ct_event_ref(evt);
-
+                lpfc_bsg_event_ref(evt);
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                 evt_dat = kzalloc(sizeof(*evt_dat), GFP_KERNEL);
-                if (!evt_dat) {
-                        lpfc_ct_event_unref(evt);
+                if (evt_dat == NULL) {
+                        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                        lpfc_bsg_event_unref(evt);
                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                         "2614 Memory allocation failed for "
                                         "CT event\n");
                         break;
                 }
 
-                mutex_unlock(&phba->ct_event_mutex);
-
                 if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
                         /* take accumulated byte count from the last iocbq */
                         iocbq = list_entry(head.prev, typeof(*iocbq), list);
@@ -550,25 +830,25 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                 }
 
                 evt_dat->data = kzalloc(evt_dat->len, GFP_KERNEL);
-                if (!evt_dat->data) {
+                if (evt_dat->data == NULL) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                         "2615 Memory allocation failed for "
                                         "CT event data, size %d\n",
                                         evt_dat->len);
                         kfree(evt_dat);
-                        mutex_lock(&phba->ct_event_mutex);
-                        lpfc_ct_event_unref(evt);
-                        mutex_unlock(&phba->ct_event_mutex);
+                        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                        lpfc_bsg_event_unref(evt);
+                        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                         goto error_ct_unsol_exit;
                 }
 
                 list_for_each_entry(iocbq, &head, list) {
+                        size = 0;
                         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
                                 bdeBuf1 = iocbq->context2;
                                 bdeBuf2 = iocbq->context3;
                         }
                         for (i = 0; i < iocbq->iocb.ulpBdeCount; i++) {
-                                int size = 0;
                                 if (phba->sli3_options &
                                     LPFC_SLI3_HBQ_ENABLED) {
                                         if (i == 0) {
@@ -601,9 +881,11 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                                 iocbq);
                                         kfree(evt_dat->data);
                                         kfree(evt_dat);
-                                        mutex_lock(&phba->ct_event_mutex);
-                                        lpfc_ct_event_unref(evt);
-                                        mutex_unlock(&phba->ct_event_mutex);
+                                        spin_lock_irqsave(&phba->ct_ev_lock,
+                                                flags);
+                                        lpfc_bsg_event_unref(evt);
+                                        spin_unlock_irqrestore(
+                                                &phba->ct_ev_lock, flags);
                                         goto error_ct_unsol_exit;
                                 }
                                 memcpy((char *)(evt_dat->data) + offset,
@@ -616,15 +898,24 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                                                  dmabuf);
                                 } else {
                                         switch (cmd) {
+                                        case ELX_LOOPBACK_DATA:
+                                                diag_cmd_data_free(phba,
+                                                (struct lpfc_dmabufext *)
+                                                        dmabuf);
+                                                break;
                                         case ELX_LOOPBACK_XRI_SETUP:
-                                                if (!(phba->sli3_options &
-                                                      LPFC_SLI3_HBQ_ENABLED))
+                                                if ((phba->sli_rev ==
+                                                        LPFC_SLI_REV2) ||
+                                                        (phba->sli3_options &
+                                                        LPFC_SLI3_HBQ_ENABLED
+                                                        )) {
+                                                        lpfc_in_buf_free(phba,
+                                                                        dmabuf);
+                                                } else {
                                                         lpfc_post_buffer(phba,
                                                                          pring,
                                                                          1);
-                                                else
-                                                        lpfc_in_buf_free(phba,
-                                                                        dmabuf);
+                                                }
                                                 break;
                                         default:
                                                 if (!(phba->sli3_options &
@@ -638,7 +929,7 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         }
                 }
 
-                mutex_lock(&phba->ct_event_mutex);
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
                 if (phba->sli_rev == LPFC_SLI_REV4) {
                         evt_dat->immed_dat = phba->ctx_idx;
                         phba->ctx_idx = (phba->ctx_idx + 1) % 64;
@@ -651,122 +942,144 @@ lpfc_bsg_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 
                 evt_dat->type = FC_REG_CT_EVENT;
                 list_add(&evt_dat->node, &evt->events_to_see);
-                wake_up_interruptible(&evt->wq);
-                lpfc_ct_event_unref(evt);
-                if (evt_req_id == SLI_CT_ELX_LOOPBACK)
+                if (evt_req_id == SLI_CT_ELX_LOOPBACK) {
+                        wake_up_interruptible(&evt->wq);
+                        lpfc_bsg_event_unref(evt);
                         break;
+                }
+
+                list_move(evt->events_to_see.prev, &evt->events_to_get);
+                lpfc_bsg_event_unref(evt);
+
+                job = evt->set_job;
+                evt->set_job = NULL;
+                if (job) {
+                        job->reply->reply_payload_rcv_len = size;
+                        /* make error code available to userspace */
+                        job->reply->result = 0;
+                        job->dd_data = NULL;
+                        /* complete the job back to userspace */
+                        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                        job->job_done(job);
+                        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                }
         }
-        mutex_unlock(&phba->ct_event_mutex);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
 error_ct_unsol_exit:
         if (!list_empty(&head))
                 list_del(&head);
-
-        return;
+        if (evt_req_id == SLI_CT_ELX_LOOPBACK)
+                return 0;
+        return 1;
 }
 
 /**
- * lpfc_bsg_set_event - process a SET_EVENT bsg vendor command
+ * lpfc_bsg_hba_set_event - process a SET_EVENT bsg vendor command
  * @job: SET_EVENT fc_bsg_job
- */
+ **/
 static int
-lpfc_bsg_set_event(struct fc_bsg_job *job)
+lpfc_bsg_hba_set_event(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
         struct set_ct_event *event_req;
-        struct lpfc_ct_event *evt;
+        struct lpfc_bsg_event *evt;
         int rc = 0;
+        struct bsg_job_data *dd_data = NULL;
+        uint32_t ev_mask;
+        unsigned long flags;
 
         if (job->request_len <
             sizeof(struct fc_bsg_request) + sizeof(struct set_ct_event)) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                 "2612 Received SET_CT_EVENT below minimum "
                                 "size\n");
-                return -EINVAL;
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (dd_data == NULL) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2734 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto job_error;
         }
 
         event_req = (struct set_ct_event *)
                 job->request->rqst_data.h_vendor.vendor_cmd;
-
-        mutex_lock(&phba->ct_event_mutex);
+        ev_mask = ((uint32_t)(unsigned long)event_req->type_mask &
+                                FC_REG_EVENT_MASK);
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
                 if (evt->reg_id == event_req->ev_reg_id) {
-                        lpfc_ct_event_ref(evt);
+                        lpfc_bsg_event_ref(evt);
                         evt->wait_time_stamp = jiffies;
                         break;
                 }
         }
-        mutex_unlock(&phba->ct_event_mutex);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
         if (&evt->node == &phba->ct_ev_waiters) {
                 /* no event waiting struct yet - first call */
-                evt = lpfc_ct_event_new(event_req->ev_reg_id,
+                evt = lpfc_bsg_event_new(ev_mask, event_req->ev_reg_id,
                                         event_req->ev_req_id);
                 if (!evt) {
                         lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                         "2617 Failed allocation of event "
                                         "waiter\n");
-                        return -ENOMEM;
+                        rc = -ENOMEM;
+                        goto job_error;
                 }
 
-                mutex_lock(&phba->ct_event_mutex);
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
                 list_add(&evt->node, &phba->ct_ev_waiters);
-                lpfc_ct_event_ref(evt);
-                mutex_unlock(&phba->ct_event_mutex);
+                lpfc_bsg_event_ref(evt);
+                evt->wait_time_stamp = jiffies;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
         }
 
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         evt->waiting = 1;
-        if (wait_event_interruptible(evt->wq,
-                                     !list_empty(&evt->events_to_see))) {
-                mutex_lock(&phba->ct_event_mutex);
-                lpfc_ct_event_unref(evt); /* release ref */
-                lpfc_ct_event_unref(evt); /* delete */
-                mutex_unlock(&phba->ct_event_mutex);
-                rc = -EINTR;
-                goto set_event_out;
-        }
-
-        evt->wait_time_stamp = jiffies;
-        evt->waiting = 0;
-
-        mutex_lock(&phba->ct_event_mutex);
-        list_move(evt->events_to_see.prev, &evt->events_to_get);
-        lpfc_ct_event_unref(evt); /* release ref */
-        mutex_unlock(&phba->ct_event_mutex);
-
-set_event_out:
-        /* set_event carries no reply payload */
-        job->reply->reply_payload_rcv_len = 0;
-        /* make error code available to userspace */
-        job->reply->result = rc;
-        /* complete the job back to userspace */
-        job->job_done(job);
-
-        return 0;
+        dd_data->type = TYPE_EVT;
+        dd_data->context_un.evt = evt;
+        evt->set_job = job; /* for unsolicited command */
+        job->dd_data = dd_data; /* for fc transport timeout callback*/
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return 0; /* call job done later */
+
+job_error:
+        if (dd_data != NULL)
+                kfree(dd_data);
+
+        job->dd_data = NULL;
+        return rc;
 }
 
 /**
- * lpfc_bsg_get_event - process a GET_EVENT bsg vendor command
+ * lpfc_bsg_hba_get_event - process a GET_EVENT bsg vendor command
  * @job: GET_EVENT fc_bsg_job
- */
+ **/
 static int
-lpfc_bsg_get_event(struct fc_bsg_job *job)
+lpfc_bsg_hba_get_event(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
         struct get_ct_event *event_req;
         struct get_ct_event_reply *event_reply;
-        struct lpfc_ct_event *evt;
+        struct lpfc_bsg_event *evt;
         struct event_data *evt_dat = NULL;
-        int rc = 0;
+        unsigned long flags;
+        uint32_t rc = 0;
 
         if (job->request_len <
             sizeof(struct fc_bsg_request) + sizeof(struct get_ct_event)) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
                                 "2613 Received GET_CT_EVENT request below "
                                 "minimum size\n");
-                return -EINVAL;
+                rc = -EINVAL;
+                goto job_error;
         }
 
         event_req = (struct get_ct_event *)
@@ -774,13 +1087,12 @@ lpfc_bsg_get_event(struct fc_bsg_job *job)
 
         event_reply = (struct get_ct_event_reply *)
                 job->reply->reply_data.vendor_reply.vendor_rsp;
-
-        mutex_lock(&phba->ct_event_mutex);
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
         list_for_each_entry(evt, &phba->ct_ev_waiters, node) {
                 if (evt->reg_id == event_req->ev_reg_id) {
                         if (list_empty(&evt->events_to_get))
                                 break;
-                        lpfc_ct_event_ref(evt);
+                        lpfc_bsg_event_ref(evt);
                         evt->wait_time_stamp = jiffies;
                         evt_dat = list_entry(evt->events_to_get.prev,
                                              struct event_data, node);
@@ -788,45 +1100,1539 @@ lpfc_bsg_get_event(struct fc_bsg_job *job)
                         break;
                 }
         }
-        mutex_unlock(&phba->ct_event_mutex);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
 
-        if (!evt_dat) {
+        /* The app may continue to ask for event data until it gets
+         * an error indicating that there isn't anymore
+         */
+        if (evt_dat == NULL) {
                 job->reply->reply_payload_rcv_len = 0;
                 rc = -ENOENT;
-                goto error_get_event_exit;
+                goto job_error;
         }
 
-        if (evt_dat->len > job->reply_payload.payload_len) {
-                evt_dat->len = job->reply_payload.payload_len;
-                        lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
-                                        "2618 Truncated event data at %d "
-                                        "bytes\n",
-                                        job->reply_payload.payload_len);
+        if (evt_dat->len > job->request_payload.payload_len) {
+                evt_dat->len = job->request_payload.payload_len;
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2618 Truncated event data at %d "
+                                "bytes\n",
+                                job->request_payload.payload_len);
         }
 
+        event_reply->type = evt_dat->type;
         event_reply->immed_data = evt_dat->immed_dat;
-
         if (evt_dat->len > 0)
                 job->reply->reply_payload_rcv_len =
-                        sg_copy_from_buffer(job->reply_payload.sg_list,
-                                            job->reply_payload.sg_cnt,
+                        sg_copy_from_buffer(job->request_payload.sg_list,
+                                            job->request_payload.sg_cnt,
                                             evt_dat->data, evt_dat->len);
         else
                 job->reply->reply_payload_rcv_len = 0;
-        rc = 0;
 
-        if (evt_dat)
+        if (evt_dat) {
                 kfree(evt_dat->data);
-        kfree(evt_dat);
-        mutex_lock(&phba->ct_event_mutex);
-        lpfc_ct_event_unref(evt);
-        mutex_unlock(&phba->ct_event_mutex);
+                kfree(evt_dat);
+        }
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        lpfc_bsg_event_unref(evt);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        job->dd_data = NULL;
+        job->reply->result = 0;
+        job->job_done(job);
+        return 0;
+
+job_error:
+        job->dd_data = NULL;
+        job->reply->result = rc;
+        return rc;
+}
+
+/**
+ * lpfc_issue_ct_rsp_cmp - lpfc_issue_ct_rsp's completion handler
+ * @phba: Pointer to HBA context object.
+ * @cmdiocbq: Pointer to command iocb.
+ * @rspiocbq: Pointer to response iocb.
+ *
+ * This function is the completion handler for iocbs issued using
+ * lpfc_issue_ct_rsp_cmp function. This function is called by the
+ * ring event handler function without any lock held. This function
+ * can be called from both worker thread context and interrupt
+ * context. This function also can be called from other thread which
+ * cleans up the SLI layer objects.
+ * This function copy the contents of the response iocb to the
+ * response iocb memory object provided by the caller of
+ * lpfc_sli_issue_iocb_wait and then wakes up the thread which
+ * sleeps for the iocb completion.
+ **/
+static void
+lpfc_issue_ct_rsp_cmp(struct lpfc_hba *phba,
+                        struct lpfc_iocbq *cmdiocbq,
+                        struct lpfc_iocbq *rspiocbq)
+{
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        IOCB_t *rsp;
+        struct lpfc_dmabuf *bmp;
+        struct lpfc_nodelist *ndlp;
+        unsigned long flags;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = cmdiocbq->context1;
+        /* normal completion and timeout crossed paths, already done */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->hbalock, flags);
+                return;
+        }
 
-error_get_event_exit:
+        job = dd_data->context_un.iocb.set_job;
+        bmp = dd_data->context_un.iocb.bmp;
+        rsp = &rspiocbq->iocb;
+        ndlp = dd_data->context_un.iocb.ndlp;
+
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                     job->request_payload.sg_cnt, DMA_TO_DEVICE);
+
+        if (rsp->ulpStatus) {
+                if (rsp->ulpStatus == IOSTAT_LOCAL_REJECT) {
+                        switch (rsp->un.ulpWord[4] & 0xff) {
+                        case IOERR_SEQUENCE_TIMEOUT:
+                                rc = -ETIMEDOUT;
+                                break;
+                        case IOERR_INVALID_RPI:
+                                rc = -EFAULT;
+                                break;
+                        default:
+                                rc = -EACCES;
+                                break;
+                        }
+                } else
+                        rc = -EACCES;
+        } else
+                job->reply->reply_payload_rcv_len =
+                        rsp->un.genreq64.bdl.bdeSize;
+
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+        lpfc_sli_release_iocbq(phba, cmdiocbq);
+        lpfc_nlp_put(ndlp);
+        kfree(bmp);
+        kfree(dd_data);
         /* make error code available to userspace */
         job->reply->result = rc;
+        job->dd_data = NULL;
         /* complete the job back to userspace */
         job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        return;
+}
+
+/**
+ * lpfc_issue_ct_rsp - issue a ct response
+ * @phba: Pointer to HBA context object.
+ * @job: Pointer to the job object.
+ * @tag: tag index value into the ports context exchange array.
+ * @bmp: Pointer to a dma buffer descriptor.
+ * @num_entry: Number of enties in the bde.
+ **/
+static int
+lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
+                  struct lpfc_dmabuf *bmp, int num_entry)
+{
+        IOCB_t *icmd;
+        struct lpfc_iocbq *ctiocb = NULL;
+        int rc = 0;
+        struct lpfc_nodelist *ndlp = NULL;
+        struct bsg_job_data *dd_data;
+        uint32_t creg_val;
+
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2736 Failed allocation of dd_data\n");
+                rc = -ENOMEM;
+                goto no_dd_data;
+        }
+
+        /* Allocate buffer for  command iocb */
+        ctiocb = lpfc_sli_get_iocbq(phba);
+        if (!ctiocb) {
+                rc = ENOMEM;
+                goto no_ctiocb;
+        }
+
+        icmd = &ctiocb->iocb;
+        icmd->un.xseq64.bdl.ulpIoTag32 = 0;
+        icmd->un.xseq64.bdl.addrHigh = putPaddrHigh(bmp->phys);
+        icmd->un.xseq64.bdl.addrLow = putPaddrLow(bmp->phys);
+        icmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        icmd->un.xseq64.bdl.bdeSize = (num_entry * sizeof(struct ulp_bde64));
+        icmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
+        icmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        icmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_SOL_CTL;
+        icmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
+
+        /* Fill in rest of iocb */
+        icmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
+        icmd->ulpBdeCount = 1;
+        icmd->ulpLe = 1;
+        icmd->ulpClass = CLASS3;
+        if (phba->sli_rev == LPFC_SLI_REV4) {
+                /* Do not issue unsol response if oxid not marked as valid */
+                if (!(phba->ct_ctx[tag].flags & UNSOL_VALID)) {
+                        rc = IOCB_ERROR;
+                        goto issue_ct_rsp_exit;
+                }
+                icmd->ulpContext = phba->ct_ctx[tag].oxid;
+                ndlp = lpfc_findnode_did(phba->pport, phba->ct_ctx[tag].SID);
+                if (!ndlp) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_ELS,
+                                 "2721 ndlp null for oxid %x SID %x\n",
+                                        icmd->ulpContext,
+                                        phba->ct_ctx[tag].SID);
+                        rc = IOCB_ERROR;
+                        goto issue_ct_rsp_exit;
+                }
+                icmd->un.ulpWord[3] = ndlp->nlp_rpi;
+                /* The exchange is done, mark the entry as invalid */
+                phba->ct_ctx[tag].flags &= ~UNSOL_VALID;
+        } else
+                icmd->ulpContext = (ushort) tag;
+
+        icmd->ulpTimeout = phba->fc_ratov * 2;
+
+        /* Xmit CT response on exchange <xid> */
+        lpfc_printf_log(phba, KERN_INFO, LOG_ELS,
+                        "2722 Xmit CT response on exchange x%x Data: x%x x%x\n",
+                        icmd->ulpContext, icmd->ulpIoTag, phba->link_state);
+
+        ctiocb->iocb_cmpl = NULL;
+        ctiocb->iocb_flag |= LPFC_IO_LIBDFC;
+        ctiocb->vport = phba->pport;
+        ctiocb->context3 = bmp;
+
+        ctiocb->iocb_cmpl = lpfc_issue_ct_rsp_cmp;
+        ctiocb->context1 = dd_data;
+        ctiocb->context2 = NULL;
+        dd_data->type = TYPE_IOCB;
+        dd_data->context_un.iocb.cmdiocbq = ctiocb;
+        dd_data->context_un.iocb.rspiocbq = NULL;
+        dd_data->context_un.iocb.set_job = job;
+        dd_data->context_un.iocb.bmp = bmp;
+        dd_data->context_un.iocb.ndlp = ndlp;
+
+        if (phba->cfg_poll & DISABLE_FCP_RING_INT) {
+                creg_val = readl(phba->HCregaddr);
+                creg_val |= (HC_R0INT_ENA << LPFC_FCP_RING);
+                writel(creg_val, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
+        }
+
+        rc = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, ctiocb, 0);
+
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
+
+issue_ct_rsp_exit:
+        lpfc_sli_release_iocbq(phba, ctiocb);
+no_ctiocb:
+        kfree(dd_data);
+no_dd_data:
+        return rc;
+}
+
+/**
+ * lpfc_bsg_send_mgmt_rsp - process a SEND_MGMT_RESP bsg vendor command
+ * @job: SEND_MGMT_RESP fc_bsg_job
+ **/
+static int
+lpfc_bsg_send_mgmt_rsp(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct send_mgmt_resp *mgmt_resp = (struct send_mgmt_resp *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+        struct ulp_bde64 *bpl;
+        struct lpfc_dmabuf *bmp = NULL;
+        struct scatterlist *sgel = NULL;
+        int request_nseg;
+        int numbde;
+        dma_addr_t busaddr;
+        uint32_t tag = mgmt_resp->tag;
+        unsigned long reqbfrcnt =
+                        (unsigned long)job->request_payload.payload_len;
+        int rc = 0;
+
+        /* in case no data is transferred */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (!reqbfrcnt || (reqbfrcnt > (80 * BUF_SZ_4K))) {
+                rc = -ERANGE;
+                goto send_mgmt_rsp_exit;
+        }
+
+        bmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!bmp) {
+                rc = -ENOMEM;
+                goto send_mgmt_rsp_exit;
+        }
+
+        bmp->virt = lpfc_mbuf_alloc(phba, 0, &bmp->phys);
+        if (!bmp->virt) {
+                rc = -ENOMEM;
+                goto send_mgmt_rsp_free_bmp;
+        }
+
+        INIT_LIST_HEAD(&bmp->list);
+        bpl = (struct ulp_bde64 *) bmp->virt;
+        request_nseg = pci_map_sg(phba->pcidev, job->request_payload.sg_list,
+                                  job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        for_each_sg(job->request_payload.sg_list, sgel, request_nseg, numbde) {
+                busaddr = sg_dma_address(sgel);
+                bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64;
+                bpl->tus.f.bdeSize = sg_dma_len(sgel);
+                bpl->tus.w = cpu_to_le32(bpl->tus.w);
+                bpl->addrLow = cpu_to_le32(putPaddrLow(busaddr));
+                bpl->addrHigh = cpu_to_le32(putPaddrHigh(busaddr));
+                bpl++;
+        }
+
+        rc = lpfc_issue_ct_rsp(phba, job, tag, bmp, request_nseg);
+
+        if (rc == IOCB_SUCCESS)
+                return 0; /* done for now */
+
+        /* TBD need to handle a timeout */
+        pci_unmap_sg(phba->pcidev, job->request_payload.sg_list,
+                          job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        rc = -EACCES;
+        lpfc_mbuf_free(phba, bmp->virt, bmp->phys);
+
+send_mgmt_rsp_free_bmp:
+        kfree(bmp);
+send_mgmt_rsp_exit:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        return rc;
+}
+
+/**
+ * lpfc_bsg_diag_mode - process a LPFC_BSG_VENDOR_DIAG_MODE bsg vendor command
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE
+ *
+ * This function is responsible for placing a port into diagnostic loopback
+ * mode in order to perform a diagnostic loopback test.
+ * All new scsi requests are blocked, a small delay is used to allow the
+ * scsi requests to complete then the link is brought down. If the link is
+ * is placed in loopback mode then scsi requests are again allowed
+ * so the scsi mid-layer doesn't give up on the port.
+ * All of this is done in-line.
+ */
+static int
+lpfc_bsg_diag_mode(struct fc_bsg_job *job)
+{
+        struct Scsi_Host *shost = job->shost;
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct diag_mode_set *loopback_mode;
+        struct lpfc_sli *psli = &phba->sli;
+        struct lpfc_sli_ring *pring = &psli->ring[LPFC_FCP_RING];
+        uint32_t link_flags;
+        uint32_t timeout;
+        struct lpfc_vport **vports;
+        LPFC_MBOXQ_t *pmboxq;
+        int mbxstatus;
+        int i = 0;
+        int rc = 0;
+
+        /* no data to return just the return code */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct diag_mode_set)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2738 Received DIAG MODE request below minimum "
+                                "size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        loopback_mode = (struct diag_mode_set *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+        link_flags = loopback_mode->type;
+        timeout = loopback_mode->timeout;
+
+        if ((phba->link_state == LPFC_HBA_ERROR) ||
+            (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
+            (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
+                rc = -EACCES;
+                goto job_error;
+        }
+
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                rc = -ENOMEM;
+                goto job_error;
+        }
+
+        vports = lpfc_create_vport_work_array(phba);
+        if (vports) {
+                for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        scsi_block_requests(shost);
+                }
+
+                lpfc_destroy_vport_work_array(phba, vports);
+        } else {
+                shost = lpfc_shost_from_vport(phba->pport);
+                scsi_block_requests(shost);
+        }
+
+        while (pring->txcmplq_cnt) {
+                if (i++ > 500)  /* wait up to 5 seconds */
+                        break;
+
+                msleep(10);
+        }
+
+        memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+        pmboxq->u.mb.mbxCommand = MBX_DOWN_LINK;
+        pmboxq->u.mb.mbxOwner = OWN_HOST;
+
+        mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
+
+        if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0)) {
+                /* wait for link down before proceeding */
+                i = 0;
+                while (phba->link_state != LPFC_LINK_DOWN) {
+                        if (i++ > timeout) {
+                                rc = -ETIMEDOUT;
+                                goto loopback_mode_exit;
+                        }
+
+                        msleep(10);
+                }
+
+                memset((void *)pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+                if (link_flags == INTERNAL_LOOP_BACK)
+                        pmboxq->u.mb.un.varInitLnk.link_flags = FLAGS_LOCAL_LB;
+                else
+                        pmboxq->u.mb.un.varInitLnk.link_flags =
+                                FLAGS_TOPOLOGY_MODE_LOOP;
+
+                pmboxq->u.mb.mbxCommand = MBX_INIT_LINK;
+                pmboxq->u.mb.mbxOwner = OWN_HOST;
+
+                mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq,
+                                                     LPFC_MBOX_TMO);
+
+                if ((mbxstatus != MBX_SUCCESS) || (pmboxq->u.mb.mbxStatus))
+                        rc = -ENODEV;
+                else {
+                        phba->link_flag |= LS_LOOPBACK_MODE;
+                        /* wait for the link attention interrupt */
+                        msleep(100);
+
+                        i = 0;
+                        while (phba->link_state != LPFC_HBA_READY) {
+                                if (i++ > timeout) {
+                                        rc = -ETIMEDOUT;
+                                        break;
+                                }
+
+                                msleep(10);
+                        }
+                }
+
+        } else
+                rc = -ENODEV;
+
+loopback_mode_exit:
+        vports = lpfc_create_vport_work_array(phba);
+        if (vports) {
+                for (i = 0; i <= phba->max_vpi && vports[i] != NULL; i++) {
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        scsi_unblock_requests(shost);
+                }
+                lpfc_destroy_vport_work_array(phba, vports);
+        } else {
+                shost = lpfc_shost_from_vport(phba->pport);
+                scsi_unblock_requests(shost);
+        }
+
+        /*
+         * Let SLI layer release mboxq if mbox command completed after timeout.
+         */
+        if (mbxstatus != MBX_TIMEOUT)
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+
+job_error:
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        /* complete the job back to userspace if no error */
+        if (rc == 0)
+                job->job_done(job);
+        return rc;
+}
+
+/**
+ * lpfcdiag_loop_self_reg - obtains a remote port login id
+ * @phba: Pointer to HBA context object
+ * @rpi: Pointer to a remote port login id
+ *
+ * This function obtains a remote port login id so the diag loopback test
+ * can send and receive its own unsolicited CT command.
+ **/
+static int lpfcdiag_loop_self_reg(struct lpfc_hba *phba, uint16_t * rpi)
+{
+        LPFC_MBOXQ_t *mbox;
+        struct lpfc_dmabuf *dmabuff;
+        int status;
+
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return ENOMEM;
+
+        status = lpfc_reg_rpi(phba, 0, phba->pport->fc_myDID,
+                                (uint8_t *)&phba->pport->fc_sparam, mbox, 0);
+        if (status) {
+                mempool_free(mbox, phba->mbox_mem_pool);
+                return ENOMEM;
+        }
+
+        dmabuff = (struct lpfc_dmabuf *) mbox->context1;
+        mbox->context1 = NULL;
+        status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
+
+        if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
+                lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
+                kfree(dmabuff);
+                if (status != MBX_TIMEOUT)
+                        mempool_free(mbox, phba->mbox_mem_pool);
+                return ENODEV;
+        }
+
+        *rpi = mbox->u.mb.un.varWords[0];
+
+        lpfc_mbuf_free(phba, dmabuff->virt, dmabuff->phys);
+        kfree(dmabuff);
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return 0;
+}
+
+/**
+ * lpfcdiag_loop_self_unreg - unregs from the rpi
+ * @phba: Pointer to HBA context object
+ * @rpi: Remote port login id
+ *
+ * This function unregisters the rpi obtained in lpfcdiag_loop_self_reg
+ **/
+static int lpfcdiag_loop_self_unreg(struct lpfc_hba *phba, uint16_t rpi)
+{
+        LPFC_MBOXQ_t *mbox;
+        int status;
+
+        /* Allocate mboxq structure */
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (mbox == NULL)
+                return ENOMEM;
+
+        lpfc_unreg_login(phba, 0, rpi, mbox);
+        status = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
+
+        if ((status != MBX_SUCCESS) || (mbox->u.mb.mbxStatus)) {
+                if (status != MBX_TIMEOUT)
+                        mempool_free(mbox, phba->mbox_mem_pool);
+                return EIO;
+        }
+
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return 0;
+}
+
+/**
+ * lpfcdiag_loop_get_xri - obtains the transmit and receive ids
+ * @phba: Pointer to HBA context object
+ * @rpi: Remote port login id
+ * @txxri: Pointer to transmit exchange id
+ * @rxxri: Pointer to response exchabge id
+ *
+ * This function obtains the transmit and receive ids required to send
+ * an unsolicited ct command with a payload. A special lpfc FsType and CmdRsp
+ * flags are used to the unsolicted response handler is able to process
+ * the ct command sent on the same port.
+ **/
+static int lpfcdiag_loop_get_xri(struct lpfc_hba *phba, uint16_t rpi,
+                         uint16_t *txxri, uint16_t * rxxri)
+{
+        struct lpfc_bsg_event *evt;
+        struct lpfc_iocbq *cmdiocbq, *rspiocbq;
+        IOCB_t *cmd, *rsp;
+        struct lpfc_dmabuf *dmabuf;
+        struct ulp_bde64 *bpl = NULL;
+        struct lpfc_sli_ct_request *ctreq = NULL;
+        int ret_val = 0;
+        unsigned long flags;
+
+        *txxri = 0;
+        *rxxri = 0;
+        evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
+                                SLI_CT_ELX_LOOPBACK);
+        if (!evt)
+                return ENOMEM;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        list_add(&evt->node, &phba->ct_ev_waiters);
+        lpfc_bsg_event_ref(evt);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        rspiocbq = lpfc_sli_get_iocbq(phba);
+
+        dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (dmabuf) {
+                dmabuf->virt = lpfc_mbuf_alloc(phba, 0, &dmabuf->phys);
+                INIT_LIST_HEAD(&dmabuf->list);
+                bpl = (struct ulp_bde64 *) dmabuf->virt;
+                memset(bpl, 0, sizeof(*bpl));
+                ctreq = (struct lpfc_sli_ct_request *)(bpl + 1);
+                bpl->addrHigh =
+                        le32_to_cpu(putPaddrHigh(dmabuf->phys + sizeof(*bpl)));
+                bpl->addrLow =
+                        le32_to_cpu(putPaddrLow(dmabuf->phys + sizeof(*bpl)));
+                bpl->tus.f.bdeFlags = 0;
+                bpl->tus.f.bdeSize = ELX_LOOPBACK_HEADER_SZ;
+                bpl->tus.w = le32_to_cpu(bpl->tus.w);
+        }
+
+        if (cmdiocbq == NULL || rspiocbq == NULL ||
+            dmabuf == NULL || bpl == NULL || ctreq == NULL) {
+                ret_val = ENOMEM;
+                goto err_get_xri_exit;
+        }
+
+        cmd = &cmdiocbq->iocb;
+        rsp = &rspiocbq->iocb;
+
+        memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
+
+        ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
+        ctreq->RevisionId.bits.InId = 0;
+        ctreq->FsType = SLI_CT_ELX_LOOPBACK;
+        ctreq->FsSubType = 0;
+        ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_XRI_SETUP;
+        ctreq->CommandResponse.bits.Size = 0;
+
+
+        cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(dmabuf->phys);
+        cmd->un.xseq64.bdl.addrLow = putPaddrLow(dmabuf->phys);
+        cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        cmd->un.xseq64.bdl.bdeSize = sizeof(*bpl);
+
+        cmd->un.xseq64.w5.hcsw.Fctl = LA;
+        cmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
+        cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
+
+        cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CR;
+        cmd->ulpBdeCount = 1;
+        cmd->ulpLe = 1;
+        cmd->ulpClass = CLASS3;
+        cmd->ulpContext = rpi;
+
+        cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
+        cmdiocbq->vport = phba->pport;
+
+        ret_val = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq,
+                                rspiocbq,
+                                (phba->fc_ratov * 2)
+                                + LPFC_DRVR_TIMEOUT);
+        if (ret_val)
+                goto err_get_xri_exit;
+
+        *txxri =  rsp->ulpContext;
+
+        evt->waiting = 1;
+        evt->wait_time_stamp = jiffies;
+        ret_val = wait_event_interruptible_timeout(
+                evt->wq, !list_empty(&evt->events_to_see),
+                ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
+        if (list_empty(&evt->events_to_see))
+                ret_val = (ret_val) ? EINTR : ETIMEDOUT;
+        else {
+                ret_val = IOCB_SUCCESS;
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                list_move(evt->events_to_see.prev, &evt->events_to_get);
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                *rxxri = (list_entry(evt->events_to_get.prev,
+                                     typeof(struct event_data),
+                                     node))->immed_dat;
+        }
+        evt->waiting = 0;
+
+err_get_xri_exit:
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        lpfc_bsg_event_unref(evt); /* release ref */
+        lpfc_bsg_event_unref(evt); /* delete */
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        if (dmabuf) {
+                if (dmabuf->virt)
+                        lpfc_mbuf_free(phba, dmabuf->virt, dmabuf->phys);
+                kfree(dmabuf);
+        }
+
+        if (cmdiocbq && (ret_val != IOCB_TIMEDOUT))
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
+        if (rspiocbq)
+                lpfc_sli_release_iocbq(phba, rspiocbq);
+        return ret_val;
+}
+
+/**
+ * diag_cmd_data_alloc - fills in a bde struct with dma buffers
+ * @phba: Pointer to HBA context object
+ * @bpl: Pointer to 64 bit bde structure
+ * @size: Number of bytes to process
+ * @nocopydata: Flag to copy user data into the allocated buffer
+ *
+ * This function allocates page size buffers and populates an lpfc_dmabufext.
+ * If allowed the user data pointed to with indataptr is copied into the kernel
+ * memory. The chained list of page size buffers is returned.
+ **/
+static struct lpfc_dmabufext *
+diag_cmd_data_alloc(struct lpfc_hba *phba,
+                   struct ulp_bde64 *bpl, uint32_t size,
+                   int nocopydata)
+{
+        struct lpfc_dmabufext *mlist = NULL;
+        struct lpfc_dmabufext *dmp;
+        int cnt, offset = 0, i = 0;
+        struct pci_dev *pcidev;
+
+        pcidev = phba->pcidev;
+
+        while (size) {
+                /* We get chunks of 4K */
+                if (size > BUF_SZ_4K)
+                        cnt = BUF_SZ_4K;
+                else
+                        cnt = size;
+
+                /* allocate struct lpfc_dmabufext buffer header */
+                dmp = kmalloc(sizeof(struct lpfc_dmabufext), GFP_KERNEL);
+                if (!dmp)
+                        goto out;
+
+                INIT_LIST_HEAD(&dmp->dma.list);
+
+                /* Queue it to a linked list */
+                if (mlist)
+                        list_add_tail(&dmp->dma.list, &mlist->dma.list);
+                else
+                        mlist = dmp;
+
+                /* allocate buffer */
+                dmp->dma.virt = dma_alloc_coherent(&pcidev->dev,
+                                                   cnt,
+                                                   &(dmp->dma.phys),
+                                                   GFP_KERNEL);
+
+                if (!dmp->dma.virt)
+                        goto out;
+
+                dmp->size = cnt;
+
+                if (nocopydata) {
+                        bpl->tus.f.bdeFlags = 0;
+                        pci_dma_sync_single_for_device(phba->pcidev,
+                                dmp->dma.phys, LPFC_BPL_SIZE, PCI_DMA_TODEVICE);
+
+                } else {
+                        memset((uint8_t *)dmp->dma.virt, 0, cnt);
+                        bpl->tus.f.bdeFlags = BUFF_TYPE_BDE_64I;
+                }
+
+                /* build buffer ptr list for IOCB */
+                bpl->addrLow = le32_to_cpu(putPaddrLow(dmp->dma.phys));
+                bpl->addrHigh = le32_to_cpu(putPaddrHigh(dmp->dma.phys));
+                bpl->tus.f.bdeSize = (ushort) cnt;
+                bpl->tus.w = le32_to_cpu(bpl->tus.w);
+                bpl++;
+
+                i++;
+                offset += cnt;
+                size -= cnt;
+        }
+
+        mlist->flag = i;
+        return mlist;
+out:
+        diag_cmd_data_free(phba, mlist);
+        return NULL;
+}
+
+/**
+ * lpfcdiag_loop_post_rxbufs - post the receive buffers for an unsol CT cmd
+ * @phba: Pointer to HBA context object
+ * @rxxri: Receive exchange id
+ * @len: Number of data bytes
+ *
+ * This function allocates and posts a data buffer of sufficient size to recieve
+ * an unsolicted CT command.
+ **/
+static int lpfcdiag_loop_post_rxbufs(struct lpfc_hba *phba, uint16_t rxxri,
+                             size_t len)
+{
+        struct lpfc_sli *psli = &phba->sli;
+        struct lpfc_sli_ring *pring = &psli->ring[LPFC_ELS_RING];
+        struct lpfc_iocbq *cmdiocbq;
+        IOCB_t *cmd = NULL;
+        struct list_head head, *curr, *next;
+        struct lpfc_dmabuf *rxbmp;
+        struct lpfc_dmabuf *dmp;
+        struct lpfc_dmabuf *mp[2] = {NULL, NULL};
+        struct ulp_bde64 *rxbpl = NULL;
+        uint32_t num_bde;
+        struct lpfc_dmabufext *rxbuffer = NULL;
+        int ret_val = 0;
+        int i = 0;
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (rxbmp != NULL) {
+                rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
+                INIT_LIST_HEAD(&rxbmp->list);
+                rxbpl = (struct ulp_bde64 *) rxbmp->virt;
+                rxbuffer = diag_cmd_data_alloc(phba, rxbpl, len, 0);
+        }
+
+        if (!cmdiocbq || !rxbmp || !rxbpl || !rxbuffer) {
+                ret_val = ENOMEM;
+                goto err_post_rxbufs_exit;
+        }
+
+        /* Queue buffers for the receive exchange */
+        num_bde = (uint32_t)rxbuffer->flag;
+        dmp = &rxbuffer->dma;
+
+        cmd = &cmdiocbq->iocb;
+        i = 0;
+
+        INIT_LIST_HEAD(&head);
+        list_add_tail(&head, &dmp->list);
+        list_for_each_safe(curr, next, &head) {
+                mp[i] = list_entry(curr, struct lpfc_dmabuf, list);
+                list_del(curr);
+
+                if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
+                        mp[i]->buffer_tag = lpfc_sli_get_buffer_tag(phba);
+                        cmd->un.quexri64cx.buff.bde.addrHigh =
+                                putPaddrHigh(mp[i]->phys);
+                        cmd->un.quexri64cx.buff.bde.addrLow =
+                                putPaddrLow(mp[i]->phys);
+                        cmd->un.quexri64cx.buff.bde.tus.f.bdeSize =
+                                ((struct lpfc_dmabufext *)mp[i])->size;
+                        cmd->un.quexri64cx.buff.buffer_tag = mp[i]->buffer_tag;
+                        cmd->ulpCommand = CMD_QUE_XRI64_CX;
+                        cmd->ulpPU = 0;
+                        cmd->ulpLe = 1;
+                        cmd->ulpBdeCount = 1;
+                        cmd->unsli3.que_xri64cx_ext_words.ebde_count = 0;
+
+                } else {
+                        cmd->un.cont64[i].addrHigh = putPaddrHigh(mp[i]->phys);
+                        cmd->un.cont64[i].addrLow = putPaddrLow(mp[i]->phys);
+                        cmd->un.cont64[i].tus.f.bdeSize =
+                                ((struct lpfc_dmabufext *)mp[i])->size;
+                                        cmd->ulpBdeCount = ++i;
+
+                        if ((--num_bde > 0) && (i < 2))
+                                continue;
+
+                        cmd->ulpCommand = CMD_QUE_XRI_BUF64_CX;
+                        cmd->ulpLe = 1;
+                }
+
+                cmd->ulpClass = CLASS3;
+                cmd->ulpContext = rxxri;
+
+                ret_val = lpfc_sli_issue_iocb(phba, LPFC_ELS_RING, cmdiocbq, 0);
+
+                if (ret_val == IOCB_ERROR) {
+                        diag_cmd_data_free(phba,
+                                (struct lpfc_dmabufext *)mp[0]);
+                        if (mp[1])
+                                diag_cmd_data_free(phba,
+                                          (struct lpfc_dmabufext *)mp[1]);
+                        dmp = list_entry(next, struct lpfc_dmabuf, list);
+                        ret_val = EIO;
+                        goto err_post_rxbufs_exit;
+                }
+
+                lpfc_sli_ringpostbuf_put(phba, pring, mp[0]);
+                if (mp[1]) {
+                        lpfc_sli_ringpostbuf_put(phba, pring, mp[1]);
+                        mp[1] = NULL;
+                }
+
+                /* The iocb was freed by lpfc_sli_issue_iocb */
+                cmdiocbq = lpfc_sli_get_iocbq(phba);
+                if (!cmdiocbq) {
+                        dmp = list_entry(next, struct lpfc_dmabuf, list);
+                        ret_val = EIO;
+                        goto err_post_rxbufs_exit;
+                }
+
+                cmd = &cmdiocbq->iocb;
+                i = 0;
+        }
+        list_del(&head);
+
+err_post_rxbufs_exit:
+
+        if (rxbmp) {
+                if (rxbmp->virt)
+                        lpfc_mbuf_free(phba, rxbmp->virt, rxbmp->phys);
+                kfree(rxbmp);
+        }
+
+        if (cmdiocbq)
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
+        return ret_val;
+}
+
+/**
+ * lpfc_bsg_diag_test - with a port in loopback issues a Ct cmd to itself
+ * @job: LPFC_BSG_VENDOR_DIAG_TEST fc_bsg_job
+ *
+ * This function receives a user data buffer to be transmitted and received on
+ * the same port, the link must be up and in loopback mode prior
+ * to being called.
+ * 1. A kernel buffer is allocated to copy the user data into.
+ * 2. The port registers with "itself".
+ * 3. The transmit and receive exchange ids are obtained.
+ * 4. The receive exchange id is posted.
+ * 5. A new els loopback event is created.
+ * 6. The command and response iocbs are allocated.
+ * 7. The cmd iocb FsType is set to elx loopback and the CmdRsp to looppback.
+ *
+ * This function is meant to be called n times while the port is in loopback
+ * so it is the apps responsibility to issue a reset to take the port out
+ * of loopback mode.
+ **/
+static int
+lpfc_bsg_diag_test(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct diag_mode_test *diag_mode;
+        struct lpfc_bsg_event *evt;
+        struct event_data *evdat;
+        struct lpfc_sli *psli = &phba->sli;
+        uint32_t size;
+        uint32_t full_size;
+        size_t segment_len = 0, segment_offset = 0, current_offset = 0;
+        uint16_t rpi;
+        struct lpfc_iocbq *cmdiocbq, *rspiocbq;
+        IOCB_t *cmd, *rsp;
+        struct lpfc_sli_ct_request *ctreq;
+        struct lpfc_dmabuf *txbmp;
+        struct ulp_bde64 *txbpl = NULL;
+        struct lpfc_dmabufext *txbuffer = NULL;
+        struct list_head head;
+        struct lpfc_dmabuf  *curr;
+        uint16_t txxri, rxxri;
+        uint32_t num_bde;
+        uint8_t *ptr = NULL, *rx_databuf = NULL;
+        int rc = 0;
+        unsigned long flags;
+        void *dataout = NULL;
+        uint32_t total_mem;
+
+        /* in case no data is returned return just the return code */
+        job->reply->reply_payload_rcv_len = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct diag_mode_test)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2739 Received DIAG TEST request below minimum "
+                                "size\n");
+                rc = -EINVAL;
+                goto loopback_test_exit;
+        }
+
+        if (job->request_payload.payload_len !=
+                job->reply_payload.payload_len) {
+                rc = -EINVAL;
+                goto loopback_test_exit;
+        }
+
+        diag_mode = (struct diag_mode_test *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+
+        if ((phba->link_state == LPFC_HBA_ERROR) ||
+            (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
+            (!(psli->sli_flag & LPFC_SLI_ACTIVE))) {
+                rc = -EACCES;
+                goto loopback_test_exit;
+        }
+
+        if (!lpfc_is_link_up(phba) || !(phba->link_flag & LS_LOOPBACK_MODE)) {
+                rc = -EACCES;
+                goto loopback_test_exit;
+        }
+
+        size = job->request_payload.payload_len;
+        full_size = size + ELX_LOOPBACK_HEADER_SZ; /* plus the header */
+
+        if ((size == 0) || (size > 80 * BUF_SZ_4K)) {
+                rc = -ERANGE;
+                goto loopback_test_exit;
+        }
+
+        if (size >= BUF_SZ_4K) {
+                /*
+                 * Allocate memory for ioctl data. If buffer is bigger than 64k,
+                 * then we allocate 64k and re-use that buffer over and over to
+                 * xfer the whole block. This is because Linux kernel has a
+                 * problem allocating more than 120k of kernel space memory. Saw
+                 * problem with GET_FCPTARGETMAPPING...
+                 */
+                if (size <= (64 * 1024))
+                        total_mem = size;
+                else
+                        total_mem = 64 * 1024;
+        } else
+                /* Allocate memory for ioctl data */
+                total_mem = BUF_SZ_4K;
+
+        dataout = kmalloc(total_mem, GFP_KERNEL);
+        if (dataout == NULL) {
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        ptr = dataout;
+        ptr += ELX_LOOPBACK_HEADER_SZ;
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                                job->request_payload.sg_cnt,
+                                ptr, size);
+
+        rc = lpfcdiag_loop_self_reg(phba, &rpi);
+        if (rc) {
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        rc = lpfcdiag_loop_get_xri(phba, rpi, &txxri, &rxxri);
+        if (rc) {
+                lpfcdiag_loop_self_unreg(phba, rpi);
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        rc = lpfcdiag_loop_post_rxbufs(phba, rxxri, full_size);
+        if (rc) {
+                lpfcdiag_loop_self_unreg(phba, rpi);
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        evt = lpfc_bsg_event_new(FC_REG_CT_EVENT, current->pid,
+                                SLI_CT_ELX_LOOPBACK);
+        if (!evt) {
+                lpfcdiag_loop_self_unreg(phba, rpi);
+                rc = -ENOMEM;
+                goto loopback_test_exit;
+        }
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        list_add(&evt->node, &phba->ct_ev_waiters);
+        lpfc_bsg_event_ref(evt);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        cmdiocbq = lpfc_sli_get_iocbq(phba);
+        rspiocbq = lpfc_sli_get_iocbq(phba);
+        txbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+
+        if (txbmp) {
+                txbmp->virt = lpfc_mbuf_alloc(phba, 0, &txbmp->phys);
+                INIT_LIST_HEAD(&txbmp->list);
+                txbpl = (struct ulp_bde64 *) txbmp->virt;
+                if (txbpl)
+                        txbuffer = diag_cmd_data_alloc(phba,
+                                                        txbpl, full_size, 0);
+        }
+
+        if (!cmdiocbq || !rspiocbq || !txbmp || !txbpl || !txbuffer) {
+                rc = -ENOMEM;
+                goto err_loopback_test_exit;
+        }
+
+        cmd = &cmdiocbq->iocb;
+        rsp = &rspiocbq->iocb;
+
+        INIT_LIST_HEAD(&head);
+        list_add_tail(&head, &txbuffer->dma.list);
+        list_for_each_entry(curr, &head, list) {
+                segment_len = ((struct lpfc_dmabufext *)curr)->size;
+                if (current_offset == 0) {
+                        ctreq = curr->virt;
+                        memset(ctreq, 0, ELX_LOOPBACK_HEADER_SZ);
+                        ctreq->RevisionId.bits.Revision = SLI_CT_REVISION;
+                        ctreq->RevisionId.bits.InId = 0;
+                        ctreq->FsType = SLI_CT_ELX_LOOPBACK;
+                        ctreq->FsSubType = 0;
+                        ctreq->CommandResponse.bits.CmdRsp = ELX_LOOPBACK_DATA;
+                        ctreq->CommandResponse.bits.Size   = size;
+                        segment_offset = ELX_LOOPBACK_HEADER_SZ;
+                } else
+                        segment_offset = 0;
+
+                BUG_ON(segment_offset >= segment_len);
+                memcpy(curr->virt + segment_offset,
+                        ptr + current_offset,
+                        segment_len - segment_offset);
+
+                current_offset += segment_len - segment_offset;
+                BUG_ON(current_offset > size);
+        }
+        list_del(&head);
+
+        /* Build the XMIT_SEQUENCE iocb */
+
+        num_bde = (uint32_t)txbuffer->flag;
+
+        cmd->un.xseq64.bdl.addrHigh = putPaddrHigh(txbmp->phys);
+        cmd->un.xseq64.bdl.addrLow = putPaddrLow(txbmp->phys);
+        cmd->un.xseq64.bdl.bdeFlags = BUFF_TYPE_BLP_64;
+        cmd->un.xseq64.bdl.bdeSize = (num_bde * sizeof(struct ulp_bde64));
+
+        cmd->un.xseq64.w5.hcsw.Fctl = (LS | LA);
+        cmd->un.xseq64.w5.hcsw.Dfctl = 0;
+        cmd->un.xseq64.w5.hcsw.Rctl = FC_RCTL_DD_UNSOL_CTL;
+        cmd->un.xseq64.w5.hcsw.Type = FC_TYPE_CT;
+
+        cmd->ulpCommand = CMD_XMIT_SEQUENCE64_CX;
+        cmd->ulpBdeCount = 1;
+        cmd->ulpLe = 1;
+        cmd->ulpClass = CLASS3;
+        cmd->ulpContext = txxri;
+
+        cmdiocbq->iocb_flag |= LPFC_IO_LIBDFC;
+        cmdiocbq->vport = phba->pport;
+
+        rc = lpfc_sli_issue_iocb_wait(phba, LPFC_ELS_RING, cmdiocbq, rspiocbq,
+                                      (phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT);
+
+        if ((rc != IOCB_SUCCESS) || (rsp->ulpStatus != IOCB_SUCCESS)) {
+                rc = -EIO;
+                goto err_loopback_test_exit;
+        }
+
+        evt->waiting = 1;
+        rc = wait_event_interruptible_timeout(
+                evt->wq, !list_empty(&evt->events_to_see),
+                ((phba->fc_ratov * 2) + LPFC_DRVR_TIMEOUT) * HZ);
+        evt->waiting = 0;
+        if (list_empty(&evt->events_to_see))
+                rc = (rc) ? -EINTR : -ETIMEDOUT;
+        else {
+                spin_lock_irqsave(&phba->ct_ev_lock, flags);
+                list_move(evt->events_to_see.prev, &evt->events_to_get);
+                evdat = list_entry(evt->events_to_get.prev,
+                                   typeof(*evdat), node);
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                rx_databuf = evdat->data;
+                if (evdat->len != full_size) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                "1603 Loopback test did not receive expected "
+                                "data length. actual length 0x%x expected "
+                                "length 0x%x\n",
+                                evdat->len, full_size);
+                        rc = -EIO;
+                } else if (rx_databuf == NULL)
+                        rc = -EIO;
+                else {
+                        rc = IOCB_SUCCESS;
+                        /* skip over elx loopback header */
+                        rx_databuf += ELX_LOOPBACK_HEADER_SZ;
+                        job->reply->reply_payload_rcv_len =
+                                sg_copy_from_buffer(job->reply_payload.sg_list,
+                                                    job->reply_payload.sg_cnt,
+                                                    rx_databuf, size);
+                        job->reply->reply_payload_rcv_len = size;
+                }
+        }
+
+err_loopback_test_exit:
+        lpfcdiag_loop_self_unreg(phba, rpi);
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        lpfc_bsg_event_unref(evt); /* release ref */
+        lpfc_bsg_event_unref(evt); /* delete */
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+        if (cmdiocbq != NULL)
+                lpfc_sli_release_iocbq(phba, cmdiocbq);
+
+        if (rspiocbq != NULL)
+                lpfc_sli_release_iocbq(phba, rspiocbq);
+
+        if (txbmp != NULL) {
+                if (txbpl != NULL) {
+                        if (txbuffer != NULL)
+                                diag_cmd_data_free(phba, txbuffer);
+                        lpfc_mbuf_free(phba, txbmp->virt, txbmp->phys);
+                }
+                kfree(txbmp);
+        }
+
+loopback_test_exit:
+        kfree(dataout);
+        /* make error code available to userspace */
+        job->reply->result = rc;
+        job->dd_data = NULL;
+        /* complete the job back to userspace if no error */
+        if (rc == 0)
+                job->job_done(job);
+        return rc;
+}
+
+/**
+ * lpfc_bsg_get_dfc_rev - process a GET_DFC_REV bsg vendor command
+ * @job: GET_DFC_REV fc_bsg_job
+ **/
+static int
+lpfc_bsg_get_dfc_rev(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct get_mgmt_rev *event_req;
+        struct get_mgmt_rev_reply *event_reply;
+        int rc = 0;
+
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2740 Received GET_DFC_REV request below "
+                                "minimum size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        event_req = (struct get_mgmt_rev *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+
+        event_reply = (struct get_mgmt_rev_reply *)
+                job->reply->reply_data.vendor_reply.vendor_rsp;
+
+        if (job->reply_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct get_mgmt_rev_reply)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2741 Received GET_DFC_REV reply below "
+                                "minimum size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        event_reply->info.a_Major = MANAGEMENT_MAJOR_REV;
+        event_reply->info.a_Minor = MANAGEMENT_MINOR_REV;
+job_error:
+        job->reply->result = rc;
+        if (rc == 0)
+                job->job_done(job);
+        return rc;
+}
+
+/**
+ * lpfc_bsg_wake_mbox_wait - lpfc_bsg_issue_mbox mbox completion handler
+ * @phba: Pointer to HBA context object.
+ * @pmboxq: Pointer to mailbox command.
+ *
+ * This is completion handler function for mailbox commands issued from
+ * lpfc_bsg_issue_mbox function. This function is called by the
+ * mailbox event handler function with no lock held. This function
+ * will wake up thread waiting on the wait queue pointed by context1
+ * of the mailbox.
+ **/
+void
+lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
+{
+        struct bsg_job_data *dd_data;
+        MAILBOX_t *pmb;
+        MAILBOX_t *mb;
+        struct fc_bsg_job *job;
+        uint32_t size;
+        unsigned long flags;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = pmboxq->context1;
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return;
+        }
+
+        pmb = &dd_data->context_un.mbox.pmboxq->u.mb;
+        mb = dd_data->context_un.mbox.mb;
+        job = dd_data->context_un.mbox.set_job;
+        memcpy(mb, pmb, sizeof(*pmb));
+        size = job->request_payload.payload_len;
+        job->reply->reply_payload_rcv_len =
+                sg_copy_from_buffer(job->reply_payload.sg_list,
+                                job->reply_payload.sg_cnt,
+                                mb, size);
+        job->reply->result = 0;
+        dd_data->context_un.mbox.set_job = NULL;
+        job->dd_data = NULL;
+        job->job_done(job);
+        spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+        mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
+        kfree(mb);
+        kfree(dd_data);
+        return;
+}
+
+/**
+ * lpfc_bsg_check_cmd_access - test for a supported mailbox command
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a mailbox object.
+ * @vport: Pointer to a vport object.
+ *
+ * Some commands require the port to be offline, some may not be called from
+ * the application.
+ **/
+static int lpfc_bsg_check_cmd_access(struct lpfc_hba *phba,
+        MAILBOX_t *mb, struct lpfc_vport *vport)
+{
+        /* return negative error values for bsg job */
+        switch (mb->mbxCommand) {
+        /* Offline only */
+        case MBX_INIT_LINK:
+        case MBX_DOWN_LINK:
+        case MBX_CONFIG_LINK:
+        case MBX_CONFIG_RING:
+        case MBX_RESET_RING:
+        case MBX_UNREG_LOGIN:
+        case MBX_CLEAR_LA:
+        case MBX_DUMP_CONTEXT:
+        case MBX_RUN_DIAGS:
+        case MBX_RESTART:
+        case MBX_SET_MASK:
+                if (!(vport->fc_flag & FC_OFFLINE_MODE)) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2743 Command 0x%x is illegal in on-line "
+                                "state\n",
+                                mb->mbxCommand);
+                        return -EPERM;
+                }
+        case MBX_WRITE_NV:
+        case MBX_WRITE_VPARMS:
+        case MBX_LOAD_SM:
+        case MBX_READ_NV:
+        case MBX_READ_CONFIG:
+        case MBX_READ_RCONFIG:
+        case MBX_READ_STATUS:
+        case MBX_READ_XRI:
+        case MBX_READ_REV:
+        case MBX_READ_LNK_STAT:
+        case MBX_DUMP_MEMORY:
+        case MBX_DOWN_LOAD:
+        case MBX_UPDATE_CFG:
+        case MBX_KILL_BOARD:
+        case MBX_LOAD_AREA:
+        case MBX_LOAD_EXP_ROM:
+        case MBX_BEACON:
+        case MBX_DEL_LD_ENTRY:
+        case MBX_SET_DEBUG:
+        case MBX_WRITE_WWN:
+        case MBX_SLI4_CONFIG:
+        case MBX_READ_EVENT_LOG_STATUS:
+        case MBX_WRITE_EVENT_LOG:
+        case MBX_PORT_CAPABILITIES:
+        case MBX_PORT_IOV_CONTROL:
+                break;
+        case MBX_SET_VARIABLE:
+        case MBX_RUN_BIU_DIAG64:
+        case MBX_READ_EVENT_LOG:
+        case MBX_READ_SPARM64:
+        case MBX_READ_LA:
+        case MBX_READ_LA64:
+        case MBX_REG_LOGIN:
+        case MBX_REG_LOGIN64:
+        case MBX_CONFIG_PORT:
+        case MBX_RUN_BIU_DIAG:
+        default:
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                        "2742 Unknown Command 0x%x\n",
+                        mb->mbxCommand);
+                return -EPERM;
+        }
+
+        return 0; /* ok */
+}
+
+/**
+ * lpfc_bsg_issue_mbox - issues a mailbox command on behalf of an app
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a mailbox object.
+ * @vport: Pointer to a vport object.
+ *
+ * Allocate a tracking object, mailbox command memory, get a mailbox
+ * from the mailbox pool, copy the caller mailbox command.
+ *
+ * If offline and the sli is active we need to poll for the command (port is
+ * being reset) and com-plete the job, otherwise issue the mailbox command and
+ * let our completion handler finish the command.
+ **/
+static uint32_t
+lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
+        struct lpfc_vport *vport)
+{
+        LPFC_MBOXQ_t *pmboxq;
+        MAILBOX_t *pmb;
+        MAILBOX_t *mb;
+        struct bsg_job_data *dd_data;
+        uint32_t size;
+        int rc = 0;
+
+        /* allocate our bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2727 Failed allocation of dd_data\n");
+                return -ENOMEM;
+        }
+
+        mb = kzalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!mb) {
+                kfree(dd_data);
+                return -ENOMEM;
+        }
+
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                kfree(dd_data);
+                kfree(mb);
+                return -ENOMEM;
+        }
+
+        size = job->request_payload.payload_len;
+        job->reply->reply_payload_rcv_len =
+                sg_copy_to_buffer(job->request_payload.sg_list,
+                                job->request_payload.sg_cnt,
+                                mb, size);
+
+        rc = lpfc_bsg_check_cmd_access(phba, mb, vport);
+        if (rc != 0) {
+                kfree(dd_data);
+                kfree(mb);
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+                return rc; /* must be negative */
+        }
+
+        memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+        pmb = &pmboxq->u.mb;
+        memcpy(pmb, mb, sizeof(*pmb));
+        pmb->mbxOwner = OWN_HOST;
+        pmboxq->context1 = NULL;
+        pmboxq->vport = vport;
+
+        if ((vport->fc_flag & FC_OFFLINE_MODE) ||
+            (!(phba->sli.sli_flag & LPFC_SLI_ACTIVE))) {
+                rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
+                if (rc != MBX_SUCCESS) {
+                        if (rc != MBX_TIMEOUT) {
+                                kfree(dd_data);
+                                kfree(mb);
+                                mempool_free(pmboxq, phba->mbox_mem_pool);
+                        }
+                        return  (rc == MBX_TIMEOUT) ? -ETIME : -ENODEV;
+                }
+
+                memcpy(mb, pmb, sizeof(*pmb));
+                job->reply->reply_payload_rcv_len =
+                        sg_copy_from_buffer(job->reply_payload.sg_list,
+                                        job->reply_payload.sg_cnt,
+                                        mb, size);
+                kfree(dd_data);
+                kfree(mb);
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+                /* not waiting mbox already done */
+                return 0;
+        }
+
+        /* setup wake call as IOCB callback */
+        pmboxq->mbox_cmpl = lpfc_bsg_wake_mbox_wait;
+        /* setup context field to pass wait_queue pointer to wake function */
+        pmboxq->context1 = dd_data;
+        dd_data->type = TYPE_MBOX;
+        dd_data->context_un.mbox.pmboxq = pmboxq;
+        dd_data->context_un.mbox.mb = mb;
+        dd_data->context_un.mbox.set_job = job;
+        job->dd_data = dd_data;
+        rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
+        if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
+                kfree(dd_data);
+                kfree(mb);
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+                return -EIO;
+        }
+
+        return 1;
+}
+
+/**
+ * lpfc_bsg_mbox_cmd - process an fc bsg LPFC_BSG_VENDOR_MBOX command
+ * @job: MBOX fc_bsg_job for LPFC_BSG_VENDOR_MBOX.
+ **/
+static int
+lpfc_bsg_mbox_cmd(struct fc_bsg_job *job)
+{
+        struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        int rc = 0;
+
+        /* in case no data is transferred */
+        job->reply->reply_payload_rcv_len = 0;
+        if (job->request_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct dfc_mbox_req)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "2737 Received MBOX_REQ request below "
+                                "minimum size\n");
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        if (job->request_payload.payload_len != PAGE_SIZE) {
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
+                rc = -EAGAIN;
+                goto job_error;
+        }
+
+        rc = lpfc_bsg_issue_mbox(phba, job, vport);
+
+job_error:
+        if (rc == 0) {
+                /* job done */
+                job->reply->result = 0;
+                job->dd_data = NULL;
+                job->job_done(job);
+        } else if (rc == 1)
+                /* job submitted, will complete later*/
+                rc = 0; /* return zero, no error */
+        else {
+                /* some error occurred */
+                job->reply->result = rc;
+                job->dd_data = NULL;
+        }
 
         return rc;
 }
@@ -834,38 +2640,57 @@ error_get_event_exit:
 /**
  * lpfc_bsg_hst_vendor - process a vendor-specific fc_bsg_job
  * @job: fc_bsg_job to handle
- */
+ **/
 static int
 lpfc_bsg_hst_vendor(struct fc_bsg_job *job)
 {
         int command = job->request->rqst_data.h_vendor.vendor_cmd[0];
+        int rc;
 
         switch (command) {
         case LPFC_BSG_VENDOR_SET_CT_EVENT:
-                return lpfc_bsg_set_event(job);
+                rc = lpfc_bsg_hba_set_event(job);
                 break;
-
         case LPFC_BSG_VENDOR_GET_CT_EVENT:
-                return lpfc_bsg_get_event(job);
+                rc = lpfc_bsg_hba_get_event(job);
+                break;
+        case LPFC_BSG_VENDOR_SEND_MGMT_RESP:
+                rc = lpfc_bsg_send_mgmt_rsp(job);
+                break;
+        case LPFC_BSG_VENDOR_DIAG_MODE:
+                rc = lpfc_bsg_diag_mode(job);
+                break;
+        case LPFC_BSG_VENDOR_DIAG_TEST:
+                rc = lpfc_bsg_diag_test(job);
+                break;
+        case LPFC_BSG_VENDOR_GET_MGMT_REV:
+                rc = lpfc_bsg_get_dfc_rev(job);
+                break;
+        case LPFC_BSG_VENDOR_MBOX:
+                rc = lpfc_bsg_mbox_cmd(job);
                 break;
-
         default:
-                return -EINVAL;
+                rc = -EINVAL;
+                job->reply->reply_payload_rcv_len = 0;
+                /* make error code available to userspace */
+                job->reply->result = rc;
+                break;
         }
+
+        return rc;
 }
 
 /**
  * lpfc_bsg_request - handle a bsg request from the FC transport
  * @job: fc_bsg_job to handle
- */
+ **/
 int
 lpfc_bsg_request(struct fc_bsg_job *job)
 {
         uint32_t msgcode;
-        int rc = -EINVAL;
+        int rc;
 
         msgcode = job->request->msgcode;
-
         switch (msgcode) {
         case FC_BSG_HST_VENDOR:
                 rc = lpfc_bsg_hst_vendor(job);
@@ -874,9 +2699,13 @@ lpfc_bsg_request(struct fc_bsg_job *job)
                 rc = lpfc_bsg_rport_els(job);
                 break;
         case FC_BSG_RPT_CT:
-                rc = lpfc_bsg_rport_ct(job);
+                rc = lpfc_bsg_send_mgmt_cmd(job);
                 break;
         default:
+                rc = -EINVAL;
+                job->reply->reply_payload_rcv_len = 0;
+                /* make error code available to userspace */
+                job->reply->result = rc;
                 break;
         }
 
@@ -889,17 +2718,71 @@ lpfc_bsg_request(struct fc_bsg_job *job)
  *
  * This function just aborts the job's IOCB.  The aborted IOCB will return to
  * the waiting function which will handle passing the error back to userspace
- */
+ **/
 int
 lpfc_bsg_timeout(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
-        struct lpfc_iocbq *cmdiocb = (struct lpfc_iocbq *)job->dd_data;
+        struct lpfc_iocbq *cmdiocb;
+        struct lpfc_bsg_event *evt;
+        struct lpfc_bsg_iocb *iocb;
+        struct lpfc_bsg_mbox *mbox;
         struct lpfc_sli_ring *pring = &phba->sli.ring[LPFC_ELS_RING];
+        struct bsg_job_data *dd_data;
+        unsigned long flags;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = (struct bsg_job_data *)job->dd_data;
+        /* timeout and completion crossed paths if no dd_data */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                return 0;
+        }
 
-        if (cmdiocb)
+        switch (dd_data->type) {
+        case TYPE_IOCB:
+                iocb = &dd_data->context_un.iocb;
+                cmdiocb = iocb->cmdiocbq;
+                /* hint to completion handler that the job timed out */
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                /* this will call our completion handler */
+                spin_lock_irq(&phba->hbalock);
                 lpfc_sli_issue_abort_iotag(phba, pring, cmdiocb);
+                spin_unlock_irq(&phba->hbalock);
+                break;
+        case TYPE_EVT:
+                evt = dd_data->context_un.evt;
+                /* this event has no job anymore */
+                evt->set_job = NULL;
+                job->dd_data = NULL;
+                job->reply->reply_payload_rcv_len = 0;
+                /* Return -EAGAIN which is our way of signallying the
+                 * app to retry.
+                 */
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                job->job_done(job);
+                break;
+        case TYPE_MBOX:
+                mbox = &dd_data->context_un.mbox;
+                /* this mbox has no job anymore */
+                mbox->set_job = NULL;
+                job->dd_data = NULL;
+                job->reply->reply_payload_rcv_len = 0;
+                job->reply->result = -EAGAIN;
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                job->job_done(job);
+                break;
+        default:
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                break;
+        }
 
+        /* scsi transport fc fc_bsg_job_timeout expects a zero return code,
+         * otherwise an error message will be displayed on the console
+         * so always return success (zero)
+         */
         return 0;
 }
diff --git a/drivers/scsi/lpfc/lpfc_bsg.h b/drivers/scsi/lpfc/lpfc_bsg.h
new file mode 100644
index 000000000000..6c8f87e39b98
--- /dev/null
+++ b/drivers/scsi/lpfc/lpfc_bsg.h
@@ -0,0 +1,98 @@
+/*******************************************************************
+ * This file is part of the Emulex Linux Device Driver for         *
+ * Fibre Channel Host Bus Adapters.                                *
+ * Copyright (C) 2010 Emulex.  All rights reserved.                *
+ * EMULEX and SLI are trademarks of Emulex.                        *
+ * www.emulex.com                                                  *
+ *                                                                 *
+ * This program is free software; you can redistribute it and/or   *
+ * modify it under the terms of version 2 of the GNU General       *
+ * Public License as published by the Free Software Foundation.    *
+ * This program is distributed in the hope that it will be useful. *
+ * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND          *
+ * WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY,  *
+ * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT, ARE      *
+ * DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH DISCLAIMERS ARE HELD *
+ * TO BE LEGALLY INVALID.  See the GNU General Public License for  *
+ * more details, a copy of which can be found in the file COPYING  *
+ * included with this package.                                     *
+ *******************************************************************/
+/* bsg definitions
+ * No pointers to user data are allowed, all application buffers and sizes will
+ * derived through the bsg interface.
+ *
+ * These are the vendor unique structures passed in using the bsg
+ * FC_BSG_HST_VENDOR message code type.
+ */
+#define LPFC_BSG_VENDOR_SET_CT_EVENT    1
+#define LPFC_BSG_VENDOR_GET_CT_EVENT    2
+#define LPFC_BSG_VENDOR_SEND_MGMT_RESP  3
+#define LPFC_BSG_VENDOR_DIAG_MODE       4
+#define LPFC_BSG_VENDOR_DIAG_TEST       5
+#define LPFC_BSG_VENDOR_GET_MGMT_REV    6
+#define LPFC_BSG_VENDOR_MBOX            7
+
+struct set_ct_event {
+        uint32_t command;
+        uint32_t type_mask;
+        uint32_t ev_req_id;
+        uint32_t ev_reg_id;
+};
+
+struct get_ct_event {
+        uint32_t command;
+        uint32_t ev_reg_id;
+        uint32_t ev_req_id;
+};
+
+struct get_ct_event_reply {
+        uint32_t immed_data;
+        uint32_t type;
+};
+
+struct send_mgmt_resp {
+        uint32_t command;
+        uint32_t tag;
+};
+
+
+#define INTERNAL_LOOP_BACK 0x1 /* adapter short cuts the loop internally */
+#define EXTERNAL_LOOP_BACK 0x2 /* requires an external loopback plug */
+
+struct diag_mode_set {
+        uint32_t command;
+        uint32_t type;
+        uint32_t timeout;
+};
+
+struct diag_mode_test {
+        uint32_t command;
+};
+
+#define LPFC_WWNN_TYPE          0
+#define LPFC_WWPN_TYPE          1
+
+struct get_mgmt_rev {
+        uint32_t command;
+};
+
+#define MANAGEMENT_MAJOR_REV   1
+#define MANAGEMENT_MINOR_REV   0
+
+/* the MgmtRevInfo structure */
+struct MgmtRevInfo {
+        uint32_t a_Major;
+        uint32_t a_Minor;
+};
+
+struct get_mgmt_rev_reply {
+        struct MgmtRevInfo info;
+};
+
+struct dfc_mbox_req {
+        uint32_t command;
+        uint32_t inExtWLen;
+        uint32_t outExtWLen;
+        uint8_t mbOffset;
+};
+
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index 650494d622c1..6f0fb51eb461 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2008 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -44,18 +44,26 @@ int lpfc_reg_rpi(struct lpfc_hba *, uint16_t, uint32_t, uint8_t *,
 void lpfc_unreg_login(struct lpfc_hba *, uint16_t, uint32_t, LPFC_MBOXQ_t *);
 void lpfc_unreg_did(struct lpfc_hba *, uint16_t, uint32_t, LPFC_MBOXQ_t *);
 void lpfc_reg_vpi(struct lpfc_vport *, LPFC_MBOXQ_t *);
+void lpfc_register_new_vport(struct lpfc_hba *, struct lpfc_vport *,
+                        struct lpfc_nodelist *);
 void lpfc_unreg_vpi(struct lpfc_hba *, uint16_t, LPFC_MBOXQ_t *);
 void lpfc_init_link(struct lpfc_hba *, LPFC_MBOXQ_t *, uint32_t, uint32_t);
 void lpfc_request_features(struct lpfc_hba *, struct lpfcMboxq *);
+void lpfc_supported_pages(struct lpfcMboxq *);
+void lpfc_sli4_params(struct lpfcMboxq *);
+int lpfc_pc_sli4_params_get(struct lpfc_hba *, LPFC_MBOXQ_t *);
 
 struct lpfc_vport *lpfc_find_vport_by_did(struct lpfc_hba *, uint32_t);
 void lpfc_cleanup_rcv_buffers(struct lpfc_vport *);
 void lpfc_rcv_seq_check_edtov(struct lpfc_vport *);
 void lpfc_cleanup_rpis(struct lpfc_vport *, int);
+void lpfc_cleanup_pending_mbox(struct lpfc_vport *);
 int lpfc_linkdown(struct lpfc_hba *);
 void lpfc_linkdown_port(struct lpfc_vport *);
 void lpfc_port_link_failure(struct lpfc_vport *);
 void lpfc_mbx_cmpl_read_la(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_init_vpi_cmpl(struct lpfc_hba *, LPFC_MBOXQ_t *);
+void lpfc_retry_pport_discovery(struct lpfc_hba *);
 
 void lpfc_mbx_cmpl_reg_login(struct lpfc_hba *, LPFC_MBOXQ_t *);
 void lpfc_mbx_cmpl_dflt_rpi(struct lpfc_hba *, LPFC_MBOXQ_t *);
@@ -73,6 +81,7 @@ void lpfc_set_disctmo(struct lpfc_vport *);
 int  lpfc_can_disctmo(struct lpfc_vport *);
 int  lpfc_unreg_rpi(struct lpfc_vport *, struct lpfc_nodelist *);
 void lpfc_unreg_all_rpis(struct lpfc_vport *);
+void lpfc_unreg_hba_rpis(struct lpfc_hba *);
 void lpfc_unreg_default_rpis(struct lpfc_vport *);
 void lpfc_issue_reg_vpi(struct lpfc_hba *, struct lpfc_vport *);
 
@@ -99,7 +108,7 @@ int lpfc_disc_state_machine(struct lpfc_vport *, struct lpfc_nodelist *, void *,
 
 void lpfc_do_scr_ns_plogi(struct lpfc_hba *, struct lpfc_vport *);
 int lpfc_check_sparm(struct lpfc_vport *, struct lpfc_nodelist *,
-                     struct serv_parm *, uint32_t);
+                     struct serv_parm *, uint32_t, int);
 int lpfc_els_abort(struct lpfc_hba *, struct lpfc_nodelist *);
 void lpfc_more_plogi(struct lpfc_vport *);
 void lpfc_more_adisc(struct lpfc_vport *);
@@ -197,6 +206,7 @@ void lpfc_reg_fcfi(struct lpfc_hba *, struct lpfcMboxq *);
 void lpfc_unreg_fcfi(struct lpfcMboxq *, uint16_t);
 void lpfc_resume_rpi(struct lpfcMboxq *, struct lpfc_nodelist *);
 int lpfc_check_pending_fcoe_event(struct lpfc_hba *, uint8_t);
+void lpfc_issue_init_vpi(struct lpfc_vport *);
 
 void lpfc_config_hbq(struct lpfc_hba *, uint32_t, struct lpfc_hbq_init *,
         uint32_t , LPFC_MBOXQ_t *);
@@ -206,7 +216,11 @@ struct hbq_dmabuf *lpfc_sli4_rb_alloc(struct lpfc_hba *);
 void lpfc_sli4_rb_free(struct lpfc_hba *, struct hbq_dmabuf *);
 void lpfc_sli4_build_dflt_fcf_record(struct lpfc_hba *, struct fcf_record *,
                         uint16_t);
+void lpfc_unregister_fcf(struct lpfc_hba *);
+void lpfc_unregister_fcf_rescan(struct lpfc_hba *);
 void lpfc_unregister_unused_fcf(struct lpfc_hba *);
+int lpfc_sli4_redisc_fcf_table(struct lpfc_hba *);
+void lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *);
 
 int lpfc_mem_alloc(struct lpfc_hba *, int align);
 void lpfc_mem_free(struct lpfc_hba *);
@@ -365,6 +379,8 @@ void lpfc_free_fast_evt(struct lpfc_hba *, struct lpfc_fast_path_event *);
 void lpfc_create_static_vport(struct lpfc_hba *);
 void lpfc_stop_hba_timers(struct lpfc_hba *);
 void lpfc_stop_port(struct lpfc_hba *);
+void __lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *);
+void lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *);
 void lpfc_parse_fcoe_conf(struct lpfc_hba *, uint8_t *, uint32_t);
 int lpfc_parse_vpd(struct lpfc_hba *, uint8_t *, int);
 void lpfc_start_fdiscs(struct lpfc_hba *phba);
@@ -378,5 +394,5 @@ struct lpfc_vport *lpfc_find_vport_by_vpid(struct lpfc_hba *, uint16_t);
 /* functions to support SGIOv4/bsg interface */
 int lpfc_bsg_request(struct fc_bsg_job *);
 int lpfc_bsg_timeout(struct fc_bsg_job *);
-void lpfc_bsg_ct_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
+int lpfc_bsg_ct_unsol_event(struct lpfc_hba *, struct lpfc_sli_ring *,
                              struct lpfc_iocbq *);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index 0ebcd9baca79..c7e921973f66 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -97,7 +97,8 @@ lpfc_ct_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
         struct list_head head;
         struct lpfc_dmabuf *bdeBuf;
 
-        lpfc_bsg_ct_unsol_event(phba, pring, piocbq);
+        if (lpfc_bsg_ct_unsol_event(phba, pring, piocbq) == 0)
+                return;
 
         if (unlikely(icmd->ulpStatus == IOSTAT_NEED_BUFFER)) {
                 lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
@@ -181,7 +182,8 @@ lpfc_sli4_ct_abort_unsol_event(struct lpfc_hba *phba,
         uint32_t size;
 
         /* Forward abort event to any process registered to receive ct event */
-        lpfc_bsg_ct_unsol_event(phba, pring, piocbq);
+        if (lpfc_bsg_ct_unsol_event(phba, pring, piocbq) == 0)
+                return;
 
         /* If there is no BDE associated with IOCB, there is nothing to do */
         if (icmd->ulpBdeCount == 0)
@@ -1843,12 +1845,7 @@ lpfc_decode_firmware_rev(struct lpfc_hba *phba, char *fwrevision, int flag)
                 c  = (rev & 0x0000ff00) >> 8;
                 b4 = (rev & 0x000000ff);
 
-                if (flag)
-                        sprintf(fwrevision, "%d.%d%d%c%d ", b1,
-                                b2, b3, c, b4);
-                else
-                        sprintf(fwrevision, "%d.%d%d%c%d ", b1,
-                                b2, b3, c, b4);
+                sprintf(fwrevision, "%d.%d%d%c%d", b1, b2, b3, c, b4);
         }
         return;
 }
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index 2cc39684ce97..08b6634cb994 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -50,9 +50,6 @@ static int lpfc_issue_els_fdisc(struct lpfc_vport *vport,
                                 struct lpfc_nodelist *ndlp, uint8_t retry);
 static int lpfc_issue_fabric_iocb(struct lpfc_hba *phba,
                                   struct lpfc_iocbq *iocb);
-static void lpfc_register_new_vport(struct lpfc_hba *phba,
-                                    struct lpfc_vport *vport,
-                                    struct lpfc_nodelist *ndlp);
 
 static int lpfc_max_els_tries = 3;
 
@@ -592,6 +589,15 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
                         spin_unlock_irq(shost->host_lock);
                 }
+                /*
+                 * If VPI is unreged, driver need to do INIT_VPI
+                 * before re-registering
+                 */
+                if (phba->sli_rev == LPFC_SLI_REV4) {
+                        spin_lock_irq(shost->host_lock);
+                        vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
+                        spin_unlock_irq(shost->host_lock);
+                }
         }
 
         if (phba->sli_rev < LPFC_SLI_REV4) {
@@ -604,10 +610,13 @@ lpfc_cmpl_els_flogi_fabric(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         } else {
                 ndlp->nlp_type |= NLP_FABRIC;
                 lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
-                if (vport->vpi_state & LPFC_VPI_REGISTERED) {
+                if ((!(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)) &&
+                        (vport->vpi_state & LPFC_VPI_REGISTERED)) {
                         lpfc_start_fdiscs(phba);
                         lpfc_do_scr_ns_plogi(phba, vport);
-                } else
+                } else if (vport->fc_flag & FC_VFI_REGISTERED)
+                        lpfc_issue_init_vpi(vport);
+                else
                         lpfc_issue_reg_vfi(vport);
         }
         return 0;
@@ -804,6 +813,9 @@ lpfc_cmpl_els_flogi(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                                  irsp->ulpTimeout);
                 goto flogifail;
         }
+        spin_lock_irq(shost->host_lock);
+        vport->fc_flag &= ~FC_VPORT_CVL_RCVD;
+        spin_unlock_irq(shost->host_lock);
 
         /*
          * The FLogI succeeded.  Sync the data for the CPU before
@@ -2720,7 +2732,7 @@ lpfc_els_retry(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
         if (did == FDMI_DID)
                 retry = 1;
 
-        if ((cmd == ELS_CMD_FLOGI) &&
+        if (((cmd == ELS_CMD_FLOGI) || (cmd == ELS_CMD_FDISC)) &&
             (phba->fc_topology != TOPOLOGY_LOOP) &&
             !lpfc_error_lost_link(irsp)) {
                 /* FLOGI retry policy */
@@ -4385,7 +4397,7 @@ lpfc_els_rcv_flogi(struct lpfc_vport *vport, struct lpfc_iocbq *cmdiocb,
 
         did = Fabric_DID;
 
-        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3))) {
+        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 1))) {
                 /* For a FLOGI we accept, then if our portname is greater
                  * then the remote portname we initiate Nport login.
                  */
@@ -5915,6 +5927,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         struct Scsi_Host  *shost = lpfc_shost_from_vport(vport);
         struct lpfc_nodelist *ndlp = (struct lpfc_nodelist *) pmb->context2;
         MAILBOX_t *mb = &pmb->u.mb;
+        int rc;
 
         spin_lock_irq(shost->host_lock);
         vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
@@ -5936,6 +5949,26 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                         spin_unlock_irq(shost->host_lock);
                         lpfc_can_disctmo(vport);
                         break;
+                /* If reg_vpi fail with invalid VPI status, re-init VPI */
+                case 0x20:
+                        spin_lock_irq(shost->host_lock);
+                        vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                        spin_unlock_irq(shost->host_lock);
+                        lpfc_init_vpi(phba, pmb, vport->vpi);
+                        pmb->vport = vport;
+                        pmb->mbox_cmpl = lpfc_init_vpi_cmpl;
+                        rc = lpfc_sli_issue_mbox(phba, pmb,
+                                MBX_NOWAIT);
+                        if (rc == MBX_NOT_FINISHED) {
+                                lpfc_printf_vlog(vport,
+                                        KERN_ERR, LOG_MBOX,
+                                        "2732 Failed to issue INIT_VPI"
+                                        " mailbox command\n");
+                        } else {
+                                lpfc_nlp_put(ndlp);
+                                return;
+                        }
+
                 default:
                         /* Try to recover from this error */
                         lpfc_mbx_unreg_vpi(vport);
@@ -5949,13 +5982,17 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                         break;
                 }
         } else {
+                spin_lock_irq(shost->host_lock);
                 vport->vpi_state |= LPFC_VPI_REGISTERED;
-                if (vport == phba->pport)
+                spin_unlock_irq(shost->host_lock);
+                if (vport == phba->pport) {
                         if (phba->sli_rev < LPFC_SLI_REV4)
                                 lpfc_issue_fabric_reglogin(vport);
-                        else
-                                lpfc_issue_reg_vfi(vport);
-                else
+                        else {
+                                lpfc_start_fdiscs(phba);
+                                lpfc_do_scr_ns_plogi(phba, vport);
+                        }
+                } else
                         lpfc_do_scr_ns_plogi(phba, vport);
         }
 
@@ -5977,7 +6014,7 @@ lpfc_cmpl_reg_new_vport(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
  * This routine registers the @vport as a new virtual port with a HBA.
  * It is done through a registering vpi mailbox command.
  **/
-static void
+void
 lpfc_register_new_vport(struct lpfc_hba *phba, struct lpfc_vport *vport,
                         struct lpfc_nodelist *ndlp)
 {
@@ -6018,6 +6055,78 @@ mbox_err_exit:
 }
 
 /**
+ * lpfc_retry_pport_discovery - Start timer to retry FLOGI.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine abort all pending discovery commands and
+ * start a timer to retry FLOGI for the physical port
+ * discovery.
+ **/
+void
+lpfc_retry_pport_discovery(struct lpfc_hba *phba)
+{
+        struct lpfc_vport **vports;
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host  *shost;
+        int i;
+        uint32_t link_state;
+
+        /* Treat this failure as linkdown for all vports */
+        link_state = phba->link_state;
+        lpfc_linkdown(phba);
+        phba->link_state = link_state;
+
+        vports = lpfc_create_vport_work_array(phba);
+
+        if (vports) {
+                for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                        ndlp = lpfc_findnode_did(vports[i], Fabric_DID);
+                        if (ndlp)
+                                lpfc_cancel_retry_delay_tmo(vports[i], ndlp);
+                        lpfc_els_flush_cmd(vports[i]);
+                }
+                lpfc_destroy_vport_work_array(phba, vports);
+        }
+
+        /* If fabric require FLOGI, then re-instantiate physical login */
+        ndlp = lpfc_findnode_did(phba->pport, Fabric_DID);
+        if (!ndlp)
+                return;
+
+
+        shost = lpfc_shost_from_vport(phba->pport);
+        mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
+        spin_lock_irq(shost->host_lock);
+        ndlp->nlp_flag |= NLP_DELAY_TMO;
+        spin_unlock_irq(shost->host_lock);
+        ndlp->nlp_last_elscmd = ELS_CMD_FLOGI;
+        phba->pport->port_state = LPFC_FLOGI;
+        return;
+}
+
+/**
+ * lpfc_fabric_login_reqd - Check if FLOGI required.
+ * @phba: pointer to lpfc hba data structure.
+ * @cmdiocb: pointer to FDISC command iocb.
+ * @rspiocb: pointer to FDISC response iocb.
+ *
+ * This routine checks if a FLOGI is reguired for FDISC
+ * to succeed.
+ **/
+static int
+lpfc_fabric_login_reqd(struct lpfc_hba *phba,
+                struct lpfc_iocbq *cmdiocb,
+                struct lpfc_iocbq *rspiocb)
+{
+
+        if ((rspiocb->iocb.ulpStatus != IOSTAT_FABRIC_RJT) ||
+                (rspiocb->iocb.un.ulpWord[4] != RJT_LOGIN_REQUIRED))
+                return 0;
+        else
+                return 1;
+}
+
+/**
  * lpfc_cmpl_els_fdisc - Completion function for fdisc iocb command
  * @phba: pointer to lpfc hba data structure.
  * @cmdiocb: pointer to lpfc command iocb data structure.
@@ -6066,6 +6175,12 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 irsp->ulpStatus, irsp->un.ulpWord[4], vport->fc_prevDID);
 
         if (irsp->ulpStatus) {
+
+                if (lpfc_fabric_login_reqd(phba, cmdiocb, rspiocb)) {
+                        lpfc_retry_pport_discovery(phba);
+                        goto out;
+                }
+
                 /* Check for retry */
                 if (lpfc_els_retry(phba, cmdiocb, rspiocb))
                         goto out;
@@ -6076,6 +6191,7 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 goto fdisc_failed;
         }
         spin_lock_irq(shost->host_lock);
+        vport->fc_flag &= ~FC_VPORT_CVL_RCVD;
         vport->fc_flag |= FC_FABRIC;
         if (vport->phba->fc_topology == TOPOLOGY_LOOP)
                 vport->fc_flag |=  FC_PUBLIC_LOOP;
@@ -6103,10 +6219,13 @@ lpfc_cmpl_els_fdisc(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                 lpfc_mbx_unreg_vpi(vport);
                 spin_lock_irq(shost->host_lock);
                 vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                vport->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
                 spin_unlock_irq(shost->host_lock);
         }
 
-        if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
+        if (vport->fc_flag & FC_VPORT_NEEDS_INIT_VPI)
+                lpfc_issue_init_vpi(vport);
+        else if (vport->fc_flag & FC_VPORT_NEEDS_REG_VPI)
                 lpfc_register_new_vport(phba, vport, ndlp);
         else
                 lpfc_do_scr_ns_plogi(phba, vport);
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 2445e399fd60..2359d0bfb734 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -525,6 +525,8 @@ lpfc_work_done(struct lpfc_hba *phba)
                         spin_unlock_irq(&phba->hbalock);
                         lpfc_sli_hbqbuf_add_hbqs(phba, LPFC_ELS_HBQ);
                 }
+                if (phba->fcf.fcf_flag & FCF_REDISC_EVT)
+                        lpfc_sli4_fcf_redisc_event_proc(phba);
         }
 
         vports = lpfc_create_vport_work_array(phba);
@@ -706,6 +708,8 @@ lpfc_cleanup_rpis(struct lpfc_vport *vport, int remove)
 void
 lpfc_port_link_failure(struct lpfc_vport *vport)
 {
+        lpfc_vport_set_state(vport, FC_VPORT_LINKDOWN);
+
         /* Cleanup any outstanding received buffers */
         lpfc_cleanup_rcv_buffers(vport);
 
@@ -752,12 +756,14 @@ lpfc_linkdown(struct lpfc_hba *phba)
         lpfc_scsi_dev_block(phba);
 
         spin_lock_irq(&phba->hbalock);
-        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_DISCOVERED);
+        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
+        spin_unlock_irq(&phba->hbalock);
         if (phba->link_state > LPFC_LINK_DOWN) {
                 phba->link_state = LPFC_LINK_DOWN;
+                spin_lock_irq(shost->host_lock);
                 phba->pport->fc_flag &= ~FC_LBIT;
+                spin_unlock_irq(shost->host_lock);
         }
-        spin_unlock_irq(&phba->hbalock);
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL)
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
@@ -1023,7 +1029,7 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 return;
         }
         spin_lock_irqsave(&phba->hbalock, flags);
-        phba->fcf.fcf_flag |= (FCF_DISCOVERED | FCF_IN_USE);
+        phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
         phba->hba_flag &= ~FCF_DISC_INPROGRESS;
         spin_unlock_irqrestore(&phba->hbalock, flags);
         if (vport->port_state != LPFC_FLOGI)
@@ -1045,25 +1051,23 @@ lpfc_mbx_cmpl_reg_fcfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 static uint32_t
 lpfc_fab_name_match(uint8_t *fab_name, struct fcf_record *new_fcf_record)
 {
-        if ((fab_name[0] ==
-                bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record)) &&
-            (fab_name[1] ==
-                bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record)) &&
-            (fab_name[2] ==
-                bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record)) &&
-            (fab_name[3] ==
-                bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record)) &&
-            (fab_name[4] ==
-                bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record)) &&
-            (fab_name[5] ==
-                bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record)) &&
-            (fab_name[6] ==
-                bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record)) &&
-            (fab_name[7] ==
-                bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record)))
-                return 1;
-        else
+        if (fab_name[0] != bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record))
+                return 0;
+        if (fab_name[1] != bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record))
+                return 0;
+        if (fab_name[2] != bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record))
                 return 0;
+        if (fab_name[3] != bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record))
+                return 0;
+        if (fab_name[4] != bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record))
+                return 0;
+        if (fab_name[5] != bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record))
+                return 0;
+        if (fab_name[6] != bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record))
+                return 0;
+        if (fab_name[7] != bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record))
+                return 0;
+        return 1;
 }
 
 /**
@@ -1078,30 +1082,28 @@ lpfc_fab_name_match(uint8_t *fab_name, struct fcf_record *new_fcf_record)
 static uint32_t
 lpfc_sw_name_match(uint8_t *sw_name, struct fcf_record *new_fcf_record)
 {
-        if ((sw_name[0] ==
-                bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record)) &&
-            (sw_name[1] ==
-                bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record)) &&
-            (sw_name[2] ==
-                bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record)) &&
-            (sw_name[3] ==
-                bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record)) &&
-            (sw_name[4] ==
-                bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record)) &&
-            (sw_name[5] ==
-                bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record)) &&
-            (sw_name[6] ==
-                bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record)) &&
-            (sw_name[7] ==
-                bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record)))
-                return 1;
-        else
+        if (sw_name[0] != bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record))
                 return 0;
+        if (sw_name[1] != bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record))
+                return 0;
+        if (sw_name[2] != bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record))
+                return 0;
+        if (sw_name[3] != bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record))
+                return 0;
+        if (sw_name[4] != bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record))
+                return 0;
+        if (sw_name[5] != bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record))
+                return 0;
+        if (sw_name[6] != bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record))
+                return 0;
+        if (sw_name[7] != bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record))
+                return 0;
+        return 1;
 }
 
 /**
  * lpfc_mac_addr_match - Check if the fcf mac address match.
- * @phba: pointer to lpfc hba data structure.
+ * @mac_addr: pointer to mac address.
  * @new_fcf_record: pointer to fcf record.
  *
  * This routine compare the fcf record's mac address with HBA's
@@ -1109,85 +1111,115 @@ lpfc_sw_name_match(uint8_t *sw_name, struct fcf_record *new_fcf_record)
  * returns 1 else return 0.
  **/
 static uint32_t
-lpfc_mac_addr_match(struct lpfc_hba *phba, struct fcf_record *new_fcf_record)
+lpfc_mac_addr_match(uint8_t *mac_addr, struct fcf_record *new_fcf_record)
 {
-        if ((phba->fcf.mac_addr[0] ==
-                bf_get(lpfc_fcf_record_mac_0, new_fcf_record)) &&
-            (phba->fcf.mac_addr[1] ==
-                bf_get(lpfc_fcf_record_mac_1, new_fcf_record)) &&
-            (phba->fcf.mac_addr[2] ==
-                bf_get(lpfc_fcf_record_mac_2, new_fcf_record)) &&
-            (phba->fcf.mac_addr[3] ==
-                bf_get(lpfc_fcf_record_mac_3, new_fcf_record)) &&
-            (phba->fcf.mac_addr[4] ==
-                bf_get(lpfc_fcf_record_mac_4, new_fcf_record)) &&
-            (phba->fcf.mac_addr[5] ==
-                bf_get(lpfc_fcf_record_mac_5, new_fcf_record)))
-                return 1;
-        else
+        if (mac_addr[0] != bf_get(lpfc_fcf_record_mac_0, new_fcf_record))
+                return 0;
+        if (mac_addr[1] != bf_get(lpfc_fcf_record_mac_1, new_fcf_record))
+                return 0;
+        if (mac_addr[2] != bf_get(lpfc_fcf_record_mac_2, new_fcf_record))
                 return 0;
+        if (mac_addr[3] != bf_get(lpfc_fcf_record_mac_3, new_fcf_record))
+                return 0;
+        if (mac_addr[4] != bf_get(lpfc_fcf_record_mac_4, new_fcf_record))
+                return 0;
+        if (mac_addr[5] != bf_get(lpfc_fcf_record_mac_5, new_fcf_record))
+                return 0;
+        return 1;
+}
+
+static bool
+lpfc_vlan_id_match(uint16_t curr_vlan_id, uint16_t new_vlan_id)
+{
+        return (curr_vlan_id == new_vlan_id);
 }
 
 /**
  * lpfc_copy_fcf_record - Copy fcf information to lpfc_hba.
- * @phba: pointer to lpfc hba data structure.
+ * @fcf: pointer to driver fcf record.
  * @new_fcf_record: pointer to fcf record.
  *
  * This routine copies the FCF information from the FCF
  * record to lpfc_hba data structure.
  **/
 static void
-lpfc_copy_fcf_record(struct lpfc_hba *phba, struct fcf_record *new_fcf_record)
+lpfc_copy_fcf_record(struct lpfc_fcf_rec *fcf_rec,
+                     struct fcf_record *new_fcf_record)
 {
-        phba->fcf.fabric_name[0] =
+        /* Fabric name */
+        fcf_rec->fabric_name[0] =
                 bf_get(lpfc_fcf_record_fab_name_0, new_fcf_record);
-        phba->fcf.fabric_name[1] =
+        fcf_rec->fabric_name[1] =
                 bf_get(lpfc_fcf_record_fab_name_1, new_fcf_record);
-        phba->fcf.fabric_name[2] =
+        fcf_rec->fabric_name[2] =
                 bf_get(lpfc_fcf_record_fab_name_2, new_fcf_record);
-        phba->fcf.fabric_name[3] =
+        fcf_rec->fabric_name[3] =
                 bf_get(lpfc_fcf_record_fab_name_3, new_fcf_record);
-        phba->fcf.fabric_name[4] =
+        fcf_rec->fabric_name[4] =
                 bf_get(lpfc_fcf_record_fab_name_4, new_fcf_record);
-        phba->fcf.fabric_name[5] =
+        fcf_rec->fabric_name[5] =
                 bf_get(lpfc_fcf_record_fab_name_5, new_fcf_record);
-        phba->fcf.fabric_name[6] =
+        fcf_rec->fabric_name[6] =
                 bf_get(lpfc_fcf_record_fab_name_6, new_fcf_record);
-        phba->fcf.fabric_name[7] =
+        fcf_rec->fabric_name[7] =
                 bf_get(lpfc_fcf_record_fab_name_7, new_fcf_record);
-        phba->fcf.mac_addr[0] =
-                bf_get(lpfc_fcf_record_mac_0, new_fcf_record);
-        phba->fcf.mac_addr[1] =
-                bf_get(lpfc_fcf_record_mac_1, new_fcf_record);
-        phba->fcf.mac_addr[2] =
-                bf_get(lpfc_fcf_record_mac_2, new_fcf_record);
-        phba->fcf.mac_addr[3] =
-                bf_get(lpfc_fcf_record_mac_3, new_fcf_record);
-        phba->fcf.mac_addr[4] =
-                bf_get(lpfc_fcf_record_mac_4, new_fcf_record);
-        phba->fcf.mac_addr[5] =
-                bf_get(lpfc_fcf_record_mac_5, new_fcf_record);
-        phba->fcf.fcf_indx = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
-        phba->fcf.priority = new_fcf_record->fip_priority;
-        phba->fcf.switch_name[0] =
+        /* Mac address */
+        fcf_rec->mac_addr[0] = bf_get(lpfc_fcf_record_mac_0, new_fcf_record);
+        fcf_rec->mac_addr[1] = bf_get(lpfc_fcf_record_mac_1, new_fcf_record);
+        fcf_rec->mac_addr[2] = bf_get(lpfc_fcf_record_mac_2, new_fcf_record);
+        fcf_rec->mac_addr[3] = bf_get(lpfc_fcf_record_mac_3, new_fcf_record);
+        fcf_rec->mac_addr[4] = bf_get(lpfc_fcf_record_mac_4, new_fcf_record);
+        fcf_rec->mac_addr[5] = bf_get(lpfc_fcf_record_mac_5, new_fcf_record);
+        /* FCF record index */
+        fcf_rec->fcf_indx = bf_get(lpfc_fcf_record_fcf_index, new_fcf_record);
+        /* FCF record priority */
+        fcf_rec->priority = new_fcf_record->fip_priority;
+        /* Switch name */
+        fcf_rec->switch_name[0] =
                 bf_get(lpfc_fcf_record_switch_name_0, new_fcf_record);
-        phba->fcf.switch_name[1] =
+        fcf_rec->switch_name[1] =
                 bf_get(lpfc_fcf_record_switch_name_1, new_fcf_record);
-        phba->fcf.switch_name[2] =
+        fcf_rec->switch_name[2] =
                 bf_get(lpfc_fcf_record_switch_name_2, new_fcf_record);
-        phba->fcf.switch_name[3] =
+        fcf_rec->switch_name[3] =
                 bf_get(lpfc_fcf_record_switch_name_3, new_fcf_record);
-        phba->fcf.switch_name[4] =
+        fcf_rec->switch_name[4] =
                 bf_get(lpfc_fcf_record_switch_name_4, new_fcf_record);
-        phba->fcf.switch_name[5] =
+        fcf_rec->switch_name[5] =
                 bf_get(lpfc_fcf_record_switch_name_5, new_fcf_record);
-        phba->fcf.switch_name[6] =
+        fcf_rec->switch_name[6] =
                 bf_get(lpfc_fcf_record_switch_name_6, new_fcf_record);
-        phba->fcf.switch_name[7] =
+        fcf_rec->switch_name[7] =
                 bf_get(lpfc_fcf_record_switch_name_7, new_fcf_record);
 }
 
 /**
+ * lpfc_update_fcf_record - Update driver fcf record
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_rec: pointer to driver fcf record.
+ * @new_fcf_record: pointer to hba fcf record.
+ * @addr_mode: address mode to be set to the driver fcf record.
+ * @vlan_id: vlan tag to be set to the driver fcf record.
+ * @flag: flag bits to be set to the driver fcf record.
+ *
+ * This routine updates the driver FCF record from the new HBA FCF record
+ * together with the address mode, vlan_id, and other informations. This
+ * routine is called with the host lock held.
+ **/
+static void
+__lpfc_update_fcf_record(struct lpfc_hba *phba, struct lpfc_fcf_rec *fcf_rec,
+                       struct fcf_record *new_fcf_record, uint32_t addr_mode,
+                       uint16_t vlan_id, uint32_t flag)
+{
+        /* Copy the fields from the HBA's FCF record */
+        lpfc_copy_fcf_record(fcf_rec, new_fcf_record);
+        /* Update other fields of driver FCF record */
+        fcf_rec->addr_mode = addr_mode;
+        fcf_rec->vlan_id = vlan_id;
+        fcf_rec->flag |= (flag | RECORD_VALID);
+}
+
+/**
  * lpfc_register_fcf - Register the FCF with hba.
  * @phba: pointer to lpfc hba data structure.
  *
@@ -1212,7 +1244,7 @@ lpfc_register_fcf(struct lpfc_hba *phba)
 
         /* The FCF is already registered, start discovery */
         if (phba->fcf.fcf_flag & FCF_REGISTERED) {
-                phba->fcf.fcf_flag |= (FCF_DISCOVERED | FCF_IN_USE);
+                phba->fcf.fcf_flag |= (FCF_SCAN_DONE | FCF_IN_USE);
                 phba->hba_flag &= ~FCF_DISC_INPROGRESS;
                 spin_unlock_irqrestore(&phba->hbalock, flags);
                 if (phba->pport->port_state != LPFC_FLOGI)
@@ -1250,6 +1282,7 @@ lpfc_register_fcf(struct lpfc_hba *phba)
  * @new_fcf_record: pointer to fcf record.
  * @boot_flag: Indicates if this record used by boot bios.
  * @addr_mode: The address mode to be used by this FCF
+ * @vlan_id: The vlan id to be used as vlan tagging by this FCF.
  *
  * This routine compare the fcf record with connect list obtained from the
  * config region to decide if this FCF can be used for SAN discovery. It returns
@@ -1323,7 +1356,8 @@ lpfc_match_fcf_conn_list(struct lpfc_hba *phba,
                 return 1;
         }
 
-        list_for_each_entry(conn_entry, &phba->fcf_conn_rec_list, list) {
+        list_for_each_entry(conn_entry,
+                            &phba->fcf_conn_rec_list, list) {
                 if (!(conn_entry->conn_rec.flags & FCFCNCT_VALID))
                         continue;
 
@@ -1470,6 +1504,7 @@ lpfc_check_pending_fcoe_event(struct lpfc_hba *phba, uint8_t unreg_fcf)
                  */
                 spin_lock_irq(&phba->hbalock);
                 phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
                 spin_unlock_irq(&phba->hbalock);
         }
 
@@ -1524,11 +1559,12 @@ lpfc_mbx_cmpl_read_fcf_record(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         uint32_t shdr_status, shdr_add_status;
         union lpfc_sli4_cfg_shdr *shdr;
         struct fcf_record *new_fcf_record;
-        int rc;
         uint32_t boot_flag, addr_mode;
         uint32_t next_fcf_index;
-        unsigned long flags;
+        struct lpfc_fcf_rec *fcf_rec = NULL;
+        unsigned long iflags;
         uint16_t vlan_id;
+        int rc;
 
         /* If there is pending FCoE event restart FCF table scan */
         if (lpfc_check_pending_fcoe_event(phba, 0)) {
@@ -1583,9 +1619,8 @@ lpfc_mbx_cmpl_read_fcf_record(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                               sizeof(struct fcf_record));
         bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
 
-        rc = lpfc_match_fcf_conn_list(phba, new_fcf_record,
-                                      &boot_flag, &addr_mode,
-                                        &vlan_id);
+        rc = lpfc_match_fcf_conn_list(phba, new_fcf_record, &boot_flag,
+                                      &addr_mode, &vlan_id);
         /*
          * If the fcf record does not match with connect list entries
          * read the next entry.
@@ -1594,90 +1629,159 @@ lpfc_mbx_cmpl_read_fcf_record(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 goto read_next_fcf;
         /*
          * If this is not the first FCF discovery of the HBA, use last
-         * FCF record for the discovery.
+         * FCF record for the discovery. The condition that a rescan
+         * matches the in-use FCF record: fabric name, switch name, mac
+         * address, and vlan_id.
          */
-        spin_lock_irqsave(&phba->hbalock, flags);
+        spin_lock_irqsave(&phba->hbalock, iflags);
         if (phba->fcf.fcf_flag & FCF_IN_USE) {
-                if (lpfc_fab_name_match(phba->fcf.fabric_name,
+                if (lpfc_fab_name_match(phba->fcf.current_rec.fabric_name,
                                         new_fcf_record) &&
-                    lpfc_sw_name_match(phba->fcf.switch_name,
+                    lpfc_sw_name_match(phba->fcf.current_rec.switch_name,
                                         new_fcf_record) &&
-                    lpfc_mac_addr_match(phba, new_fcf_record)) {
+                    lpfc_mac_addr_match(phba->fcf.current_rec.mac_addr,
+                                        new_fcf_record) &&
+                    lpfc_vlan_id_match(phba->fcf.current_rec.vlan_id,
+                                        vlan_id)) {
                         phba->fcf.fcf_flag |= FCF_AVAILABLE;
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
+                        if (phba->fcf.fcf_flag & FCF_REDISC_PEND)
+                                /* Stop FCF redisc wait timer if pending */
+                                __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
+                        else if (phba->fcf.fcf_flag & FCF_REDISC_FOV)
+                                /* If in fast failover, mark it's completed */
+                                phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
                         goto out;
                 }
-                spin_unlock_irqrestore(&phba->hbalock, flags);
-                goto read_next_fcf;
+                /*
+                 * Read next FCF record from HBA searching for the matching
+                 * with in-use record only if not during the fast failover
+                 * period. In case of fast failover period, it shall try to
+                 * determine whether the FCF record just read should be the
+                 * next candidate.
+                 */
+                if (!(phba->fcf.fcf_flag & FCF_REDISC_FOV)) {
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
+                        goto read_next_fcf;
+                }
         }
+        /*
+         * Update on failover FCF record only if it's in FCF fast-failover
+         * period; otherwise, update on current FCF record.
+         */
+        if (phba->fcf.fcf_flag & FCF_REDISC_FOV) {
+                /* Fast FCF failover only to the same fabric name */
+                if (lpfc_fab_name_match(phba->fcf.current_rec.fabric_name,
+                                        new_fcf_record))
+                        fcf_rec = &phba->fcf.failover_rec;
+                else
+                        goto read_next_fcf;
+        } else
+                fcf_rec = &phba->fcf.current_rec;
+
         if (phba->fcf.fcf_flag & FCF_AVAILABLE) {
                 /*
-                 * If the current FCF record does not have boot flag
-                 * set and new fcf record has boot flag set, use the
-                 * new fcf record.
+                 * If the driver FCF record does not have boot flag
+                 * set and new hba fcf record has boot flag set, use
+                 * the new hba fcf record.
                  */
-                if (boot_flag && !(phba->fcf.fcf_flag & FCF_BOOT_ENABLE)) {
-                        /* Use this FCF record */
-                        lpfc_copy_fcf_record(phba, new_fcf_record);
-                        phba->fcf.addr_mode = addr_mode;
-                        phba->fcf.fcf_flag |= FCF_BOOT_ENABLE;
-                        if (vlan_id != 0xFFFF) {
-                                phba->fcf.fcf_flag |= FCF_VALID_VLAN;
-                                phba->fcf.vlan_id = vlan_id;
-                        }
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
+                if (boot_flag && !(fcf_rec->flag & BOOT_ENABLE)) {
+                        /* Choose this FCF record */
+                        __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
+                                        addr_mode, vlan_id, BOOT_ENABLE);
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
                         goto read_next_fcf;
                 }
                 /*
-                 * If the current FCF record has boot flag set and the
-                 * new FCF record does not have boot flag, read the next
-                 * FCF record.
+                 * If the driver FCF record has boot flag set and the
+                 * new hba FCF record does not have boot flag, read
+                 * the next FCF record.
                  */
-                if (!boot_flag && (phba->fcf.fcf_flag & FCF_BOOT_ENABLE)) {
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
+                if (!boot_flag && (fcf_rec->flag & BOOT_ENABLE)) {
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
                         goto read_next_fcf;
                 }
                 /*
-                 * If there is a record with lower priority value for
-                 * the current FCF, use that record.
+                 * If the new hba FCF record has lower priority value
+                 * than the driver FCF record, use the new record.
                  */
-                if (lpfc_fab_name_match(phba->fcf.fabric_name,
-                                        new_fcf_record) &&
-                    (new_fcf_record->fip_priority < phba->fcf.priority)) {
-                        /* Use this FCF record */
-                        lpfc_copy_fcf_record(phba, new_fcf_record);
-                        phba->fcf.addr_mode = addr_mode;
-                        if (vlan_id != 0xFFFF) {
-                                phba->fcf.fcf_flag |= FCF_VALID_VLAN;
-                                phba->fcf.vlan_id = vlan_id;
-                        }
-                        spin_unlock_irqrestore(&phba->hbalock, flags);
-                        goto read_next_fcf;
+                if (lpfc_fab_name_match(fcf_rec->fabric_name, new_fcf_record) &&
+                    (new_fcf_record->fip_priority < fcf_rec->priority)) {
+                        /* Choose this FCF record */
+                        __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
+                                        addr_mode, vlan_id, 0);
                 }
-                spin_unlock_irqrestore(&phba->hbalock, flags);
+                spin_unlock_irqrestore(&phba->hbalock, iflags);
                 goto read_next_fcf;
         }
         /*
-         * This is the first available FCF record, use this
-         * record.
+         * This is the first suitable FCF record, choose this record for
+         * initial best-fit FCF.
          */
-        lpfc_copy_fcf_record(phba, new_fcf_record);
-        phba->fcf.addr_mode = addr_mode;
-        if (boot_flag)
-                phba->fcf.fcf_flag |= FCF_BOOT_ENABLE;
-        phba->fcf.fcf_flag |= FCF_AVAILABLE;
-        if (vlan_id != 0xFFFF) {
-                phba->fcf.fcf_flag |= FCF_VALID_VLAN;
-                phba->fcf.vlan_id = vlan_id;
+        if (fcf_rec) {
+                __lpfc_update_fcf_record(phba, fcf_rec, new_fcf_record,
+                                         addr_mode, vlan_id, (boot_flag ?
+                                         BOOT_ENABLE : 0));
+                phba->fcf.fcf_flag |= FCF_AVAILABLE;
         }
-        spin_unlock_irqrestore(&phba->hbalock, flags);
+        spin_unlock_irqrestore(&phba->hbalock, iflags);
         goto read_next_fcf;
 
 read_next_fcf:
         lpfc_sli4_mbox_cmd_free(phba, mboxq);
-        if (next_fcf_index == LPFC_FCOE_FCF_NEXT_NONE || next_fcf_index == 0)
-                lpfc_register_fcf(phba);
-        else
+        if (next_fcf_index == LPFC_FCOE_FCF_NEXT_NONE || next_fcf_index == 0) {
+                if (phba->fcf.fcf_flag & FCF_REDISC_FOV) {
+                        /*
+                         * Case of FCF fast failover scan
+                         */
+
+                        /*
+                         * It has not found any suitable FCF record, cancel
+                         * FCF scan inprogress, and do nothing
+                         */
+                        if (!(phba->fcf.failover_rec.flag & RECORD_VALID)) {
+                                spin_lock_irqsave(&phba->hbalock, iflags);
+                                phba->hba_flag &= ~FCF_DISC_INPROGRESS;
+                                spin_unlock_irqrestore(&phba->hbalock, iflags);
+                                return;
+                        }
+                        /*
+                         * It has found a suitable FCF record that is not
+                         * the same as in-use FCF record, unregister the
+                         * in-use FCF record, replace the in-use FCF record
+                         * with the new FCF record, mark FCF fast failover
+                         * completed, and then start register the new FCF
+                         * record.
+                         */
+
+                        /* unregister the current in-use FCF record */
+                        lpfc_unregister_fcf(phba);
+                        /* replace in-use record with the new record */
+                        memcpy(&phba->fcf.current_rec,
+                               &phba->fcf.failover_rec,
+                               sizeof(struct lpfc_fcf_rec));
+                        /* mark the FCF fast failover completed */
+                        spin_lock_irqsave(&phba->hbalock, iflags);
+                        phba->fcf.fcf_flag &= ~FCF_REDISC_FOV;
+                        spin_unlock_irqrestore(&phba->hbalock, iflags);
+                        /* Register to the new FCF record */
+                        lpfc_register_fcf(phba);
+                } else {
+                        /*
+                         * In case of transaction period to fast FCF failover,
+                         * do nothing when search to the end of the FCF table.
+                         */
+                        if ((phba->fcf.fcf_flag & FCF_REDISC_EVT) ||
+                            (phba->fcf.fcf_flag & FCF_REDISC_PEND))
+                                return;
+                        /*
+                         * Otherwise, initial scan or post linkdown rescan,
+                         * register with the best fit FCF record found so
+                         * far through the scanning process.
+                         */
+                        lpfc_register_fcf(phba);
+                }
+        } else
                 lpfc_sli4_read_fcf_record(phba, next_fcf_index);
         return;
 
@@ -1695,10 +1799,13 @@ out:
  *
  * This function handles completion of init vpi mailbox command.
  */
-static void
+void
 lpfc_init_vpi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 {
         struct lpfc_vport *vport = mboxq->vport;
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
+
         if (mboxq->u.mb.mbxStatus) {
                 lpfc_printf_vlog(vport, KERN_ERR,
                                 LOG_MBOX,
@@ -1708,9 +1815,23 @@ lpfc_init_vpi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 lpfc_vport_set_state(vport, FC_VPORT_FAILED);
                 return;
         }
-        spin_lock_irq(&phba->hbalock);
+        spin_lock_irq(shost->host_lock);
         vport->fc_flag &= ~FC_VPORT_NEEDS_INIT_VPI;
-        spin_unlock_irq(&phba->hbalock);
+        spin_unlock_irq(shost->host_lock);
+
+        /* If this port is physical port or FDISC is done, do reg_vpi */
+        if ((phba->pport == vport) || (vport->port_state == LPFC_FDISC)) {
+                        ndlp = lpfc_findnode_did(vport, Fabric_DID);
+                        if (!ndlp)
+                                lpfc_printf_vlog(vport, KERN_ERR,
+                                        LOG_DISCOVERY,
+                                        "2731 Cannot find fabric "
+                                        "controller node\n");
+                        else
+                                lpfc_register_new_vport(phba, vport, ndlp);
+                        mempool_free(mboxq, phba->mbox_mem_pool);
+                        return;
+        }
 
         if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
                 lpfc_initial_fdisc(vport);
@@ -1719,10 +1840,42 @@ lpfc_init_vpi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_ELS,
                                  "2606 No NPIV Fabric support\n");
         }
+        mempool_free(mboxq, phba->mbox_mem_pool);
         return;
 }
 
 /**
+ * lpfc_issue_init_vpi - Issue init_vpi mailbox command.
+ * @vport: pointer to lpfc_vport data structure.
+ *
+ * This function issue a init_vpi mailbox command to initialize
+ * VPI for the vport.
+ */
+void
+lpfc_issue_init_vpi(struct lpfc_vport *vport)
+{
+        LPFC_MBOXQ_t *mboxq;
+        int rc;
+
+        mboxq = mempool_alloc(vport->phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                        LOG_MBOX, "2607 Failed to allocate "
+                        "init_vpi mailbox\n");
+                return;
+        }
+        lpfc_init_vpi(vport->phba, mboxq, vport->vpi);
+        mboxq->vport = vport;
+        mboxq->mbox_cmpl = lpfc_init_vpi_cmpl;
+        rc = lpfc_sli_issue_mbox(vport->phba, mboxq, MBX_NOWAIT);
+        if (rc == MBX_NOT_FINISHED) {
+                lpfc_printf_vlog(vport, KERN_ERR,
+                        LOG_MBOX, "2608 Failed to issue init_vpi mailbox\n");
+                mempool_free(mboxq, vport->phba->mbox_mem_pool);
+        }
+}
+
+/**
  * lpfc_start_fdiscs - send fdiscs for each vports on this port.
  * @phba: pointer to lpfc hba data structure.
  *
@@ -1734,8 +1887,6 @@ lpfc_start_fdiscs(struct lpfc_hba *phba)
 {
         struct lpfc_vport **vports;
         int i;
-        LPFC_MBOXQ_t *mboxq;
-        int rc;
 
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL) {
@@ -1754,26 +1905,7 @@ lpfc_start_fdiscs(struct lpfc_hba *phba)
                                 continue;
                         }
                         if (vports[i]->fc_flag & FC_VPORT_NEEDS_INIT_VPI) {
-                                mboxq = mempool_alloc(phba->mbox_mem_pool,
-                                        GFP_KERNEL);
-                                if (!mboxq) {
-                                        lpfc_printf_vlog(vports[i], KERN_ERR,
-                                        LOG_MBOX, "2607 Failed to allocate "
-                                        "init_vpi mailbox\n");
-                                        continue;
-                                }
-                                lpfc_init_vpi(phba, mboxq, vports[i]->vpi);
-                                mboxq->vport = vports[i];
-                                mboxq->mbox_cmpl = lpfc_init_vpi_cmpl;
-                                rc = lpfc_sli_issue_mbox(phba, mboxq,
-                                        MBX_NOWAIT);
-                                if (rc == MBX_NOT_FINISHED) {
-                                        lpfc_printf_vlog(vports[i], KERN_ERR,
-                                        LOG_MBOX, "2608 Failed to issue "
-                                        "init_vpi mailbox\n");
-                                        mempool_free(mboxq,
-                                                phba->mbox_mem_pool);
-                                }
+                                lpfc_issue_init_vpi(vports[i]);
                                 continue;
                         }
                         if (phba->link_flag & LS_NPIV_FAB_SUPPORTED)
@@ -1796,6 +1928,7 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 {
         struct lpfc_dmabuf *dmabuf = mboxq->context1;
         struct lpfc_vport *vport = mboxq->vport;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
         if (mboxq->u.mb.mbxStatus) {
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_MBOX,
@@ -1813,7 +1946,11 @@ lpfc_mbx_cmpl_reg_vfi(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                 goto fail_free_mem;
         }
         /* The VPI is implicitly registered when the VFI is registered */
+        spin_lock_irq(shost->host_lock);
         vport->vpi_state |= LPFC_VPI_REGISTERED;
+        vport->fc_flag |= FC_VFI_REGISTERED;
+        vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
+        spin_unlock_irq(shost->host_lock);
 
         if (vport->port_state == LPFC_FABRIC_CFG_LINK) {
                 lpfc_start_fdiscs(phba);
@@ -2050,8 +2187,7 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, READ_LA_VAR *la)
                         return;
                 }
                 spin_unlock_irq(&phba->hbalock);
-                rc = lpfc_sli4_read_fcf_record(phba,
-                                        LPFC_FCOE_FCF_GET_FIRST);
+                rc = lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
                 if (rc)
                         goto out;
         }
@@ -2139,10 +2275,12 @@ lpfc_mbx_cmpl_read_la(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         }
 
         phba->fc_eventTag = la->eventTag;
+        spin_lock_irq(&phba->hbalock);
         if (la->mm)
                 phba->sli.sli_flag |= LPFC_MENLO_MAINT;
         else
                 phba->sli.sli_flag &= ~LPFC_MENLO_MAINT;
+        spin_unlock_irq(&phba->hbalock);
 
         phba->link_events++;
         if (la->attType == AT_LINK_UP && (!la->mm)) {
@@ -2271,10 +2409,10 @@ lpfc_mbx_cmpl_unreg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                                  mb->mbxStatus);
                 break;
         }
-        spin_lock_irq(&phba->hbalock);
+        spin_lock_irq(shost->host_lock);
         vport->vpi_state &= ~LPFC_VPI_REGISTERED;
         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
-        spin_unlock_irq(&phba->hbalock);
+        spin_unlock_irq(shost->host_lock);
         vport->unreg_vpi_cmpl = VPORT_OK;
         mempool_free(pmb, phba->mbox_mem_pool);
         /*
@@ -2332,7 +2470,10 @@ lpfc_mbx_cmpl_reg_vpi(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 goto out;
         }
 
+        spin_lock_irq(shost->host_lock);
         vport->vpi_state |= LPFC_VPI_REGISTERED;
+        vport->fc_flag &= ~FC_VPORT_NEEDS_REG_VPI;
+        spin_unlock_irq(shost->host_lock);
         vport->num_disc_nodes = 0;
         /* go thru NPR list and issue ELS PLOGIs */
         if (vport->fc_npr_cnt)
@@ -3218,6 +3359,34 @@ lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
         return 0;
 }
 
+/**
+ * lpfc_unreg_hba_rpis - Unregister rpis registered to the hba.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to unregister all the currently registered RPIs
+ * to the HBA.
+ **/
+void
+lpfc_unreg_hba_rpis(struct lpfc_hba *phba)
+{
+        struct lpfc_vport **vports;
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost;
+        int i;
+
+        vports = lpfc_create_vport_work_array(phba);
+        for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                shost = lpfc_shost_from_vport(vports[i]);
+                spin_lock_irq(shost->host_lock);
+                list_for_each_entry(ndlp, &vports[i]->fc_nodes, nlp_listp) {
+                        if (ndlp->nlp_flag & NLP_RPI_VALID)
+                                lpfc_unreg_rpi(vports[i], ndlp);
+                }
+                spin_unlock_irq(shost->host_lock);
+        }
+        lpfc_destroy_vport_work_array(phba, vports);
+}
+
 void
 lpfc_unreg_all_rpis(struct lpfc_vport *vport)
 {
@@ -4448,63 +4617,56 @@ lpfc_unregister_fcfi_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
 }
 
 /**
- * lpfc_unregister_unused_fcf - Unregister FCF if all devices are disconnected.
+ * lpfc_unregister_fcf_prep - Unregister fcf record preparation
  * @phba: Pointer to hba context object.
  *
- * This function check if there are any connected remote port for the FCF and
- * if all the devices are disconnected, this function unregister FCFI.
- * This function also tries to use another FCF for discovery.
+ * This function prepare the HBA for unregistering the currently registered
+ * FCF from the HBA. It performs unregistering, in order, RPIs, VPIs, and
+ * VFIs.
  */
-void
-lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
+int
+lpfc_unregister_fcf_prep(struct lpfc_hba *phba)
 {
         LPFC_MBOXQ_t *mbox;
-        int rc;
         struct lpfc_vport **vports;
-        int i;
-
-        spin_lock_irq(&phba->hbalock);
-        /*
-         * If HBA is not running in FIP mode or
-         * If HBA does not support FCoE or
-         * If FCF is not registered.
-         * do nothing.
-         */
-        if (!(phba->hba_flag & HBA_FCOE_SUPPORT) ||
-                !(phba->fcf.fcf_flag & FCF_REGISTERED) ||
-                (!(phba->hba_flag & HBA_FIP_SUPPORT))) {
-                spin_unlock_irq(&phba->hbalock);
-                return;
-        }
-        spin_unlock_irq(&phba->hbalock);
+        struct lpfc_nodelist *ndlp;
+        struct Scsi_Host *shost;
+        int i, rc;
 
+        /* Unregister RPIs */
         if (lpfc_fcf_inuse(phba))
-                return;
+                lpfc_unreg_hba_rpis(phba);
 
         /* At this point, all discovery is aborted */
         phba->pport->port_state = LPFC_VPORT_UNKNOWN;
 
         /* Unregister VPIs */
         vports = lpfc_create_vport_work_array(phba);
-        if (vports &&
-                (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED))
+        if (vports && (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED))
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
+                        /* Stop FLOGI/FDISC retries */
+                        ndlp = lpfc_findnode_did(vports[i], Fabric_DID);
+                        if (ndlp)
+                                lpfc_cancel_retry_delay_tmo(vports[i], ndlp);
                         lpfc_mbx_unreg_vpi(vports[i]);
-                        spin_lock_irq(&phba->hbalock);
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        spin_lock_irq(shost->host_lock);
                         vports[i]->fc_flag |= FC_VPORT_NEEDS_INIT_VPI;
                         vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
-                        spin_unlock_irq(&phba->hbalock);
+                        spin_unlock_irq(shost->host_lock);
                 }
         lpfc_destroy_vport_work_array(phba, vports);
 
+        /* Cleanup any outstanding ELS commands */
+        lpfc_els_flush_all_cmd(phba);
+
         /* Unregister VFI */
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mbox) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2556 UNREG_VFI mbox allocation failed"
-                        "HBA state x%x\n",
-                        phba->pport->port_state);
-                return;
+                                "2556 UNREG_VFI mbox allocation failed"
+                                "HBA state x%x\n", phba->pport->port_state);
+                return -ENOMEM;
         }
 
         lpfc_unreg_vfi(mbox, phba->pport);
@@ -4514,58 +4676,163 @@ lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
         if (rc == MBX_NOT_FINISHED) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2557 UNREG_VFI issue mbox failed rc x%x "
-                        "HBA state x%x\n",
-                        rc, phba->pport->port_state);
+                                "2557 UNREG_VFI issue mbox failed rc x%x "
+                                "HBA state x%x\n",
+                                rc, phba->pport->port_state);
                 mempool_free(mbox, phba->mbox_mem_pool);
-                return;
+                return -EIO;
         }
 
-        /* Unregister FCF */
+        shost = lpfc_shost_from_vport(phba->pport);
+        spin_lock_irq(shost->host_lock);
+        phba->pport->fc_flag &= ~FC_VFI_REGISTERED;
+        spin_unlock_irq(shost->host_lock);
+
+        return 0;
+}
+
+/**
+ * lpfc_sli4_unregister_fcf - Unregister currently registered FCF record
+ * @phba: Pointer to hba context object.
+ *
+ * This function issues synchronous unregister FCF mailbox command to HBA to
+ * unregister the currently registered FCF record. The driver does not reset
+ * the driver FCF usage state flags.
+ *
+ * Return 0 if successfully issued, none-zero otherwise.
+ */
+int
+lpfc_sli4_unregister_fcf(struct lpfc_hba *phba)
+{
+        LPFC_MBOXQ_t *mbox;
+        int rc;
+
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mbox) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2551 UNREG_FCFI mbox allocation failed"
-                        "HBA state x%x\n",
-                        phba->pport->port_state);
-                return;
+                                "2551 UNREG_FCFI mbox allocation failed"
+                                "HBA state x%x\n", phba->pport->port_state);
+                return -ENOMEM;
         }
-
         lpfc_unreg_fcfi(mbox, phba->fcf.fcfi);
         mbox->vport = phba->pport;
         mbox->mbox_cmpl = lpfc_unregister_fcfi_cmpl;
         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
 
         if (rc == MBX_NOT_FINISHED) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2552 UNREG_FCFI issue mbox failed rc x%x "
-                        "HBA state x%x\n",
-                        rc, phba->pport->port_state);
-                mempool_free(mbox, phba->mbox_mem_pool);
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2552 Unregister FCFI command failed rc x%x "
+                                "HBA state x%x\n",
+                                rc, phba->pport->port_state);
+                return -EINVAL;
+        }
+        return 0;
+}
+
+/**
+ * lpfc_unregister_fcf_rescan - Unregister currently registered fcf and rescan
+ * @phba: Pointer to hba context object.
+ *
+ * This function unregisters the currently reigstered FCF. This function
+ * also tries to find another FCF for discovery by rescan the HBA FCF table.
+ */
+void
+lpfc_unregister_fcf_rescan(struct lpfc_hba *phba)
+{
+        int rc;
+
+        /* Preparation for unregistering fcf */
+        rc = lpfc_unregister_fcf_prep(phba);
+        if (rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                                "2748 Failed to prepare for unregistering "
+                                "HBA's FCF record: rc=%d\n", rc);
                 return;
         }
 
-        spin_lock_irq(&phba->hbalock);
-        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_REGISTERED |
-                FCF_DISCOVERED | FCF_BOOT_ENABLE | FCF_IN_USE |
-                FCF_VALID_VLAN);
-        spin_unlock_irq(&phba->hbalock);
+        /* Now, unregister FCF record and reset HBA FCF state */
+        rc = lpfc_sli4_unregister_fcf(phba);
+        if (rc)
+                return;
+        /* Reset HBA FCF states after successful unregister FCF */
+        phba->fcf.fcf_flag = 0;
 
         /*
          * If driver is not unloading, check if there is any other
          * FCF record that can be used for discovery.
          */
         if ((phba->pport->load_flag & FC_UNLOADING) ||
-                (phba->link_state < LPFC_LINK_UP))
+            (phba->link_state < LPFC_LINK_UP))
                 return;
 
         rc = lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
 
         if (rc)
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY|LOG_MBOX,
-                        "2553 lpfc_unregister_unused_fcf failed to read FCF"
-                        " record HBA state x%x\n",
-                        phba->pport->port_state);
+                                "2553 lpfc_unregister_unused_fcf failed "
+                                "to read FCF record HBA state x%x\n",
+                                phba->pport->port_state);
+}
+
+/**
+ * lpfc_unregister_fcf - Unregister the currently registered fcf record
+ * @phba: Pointer to hba context object.
+ *
+ * This function just unregisters the currently reigstered FCF. It does not
+ * try to find another FCF for discovery.
+ */
+void
+lpfc_unregister_fcf(struct lpfc_hba *phba)
+{
+        int rc;
+
+        /* Preparation for unregistering fcf */
+        rc = lpfc_unregister_fcf_prep(phba);
+        if (rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                                "2749 Failed to prepare for unregistering "
+                                "HBA's FCF record: rc=%d\n", rc);
+                return;
+        }
+
+        /* Now, unregister FCF record and reset HBA FCF state */
+        rc = lpfc_sli4_unregister_fcf(phba);
+        if (rc)
+                return;
+        /* Set proper HBA FCF states after successful unregister FCF */
+        spin_lock_irq(&phba->hbalock);
+        phba->fcf.fcf_flag &= ~FCF_REGISTERED;
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_unregister_unused_fcf - Unregister FCF if all devices are disconnected.
+ * @phba: Pointer to hba context object.
+ *
+ * This function check if there are any connected remote port for the FCF and
+ * if all the devices are disconnected, this function unregister FCFI.
+ * This function also tries to use another FCF for discovery.
+ */
+void
+lpfc_unregister_unused_fcf(struct lpfc_hba *phba)
+{
+        /*
+         * If HBA is not running in FIP mode or if HBA does not support
+         * FCoE or if FCF is not registered, do nothing.
+         */
+        spin_lock_irq(&phba->hbalock);
+        if (!(phba->hba_flag & HBA_FCOE_SUPPORT) ||
+            !(phba->fcf.fcf_flag & FCF_REGISTERED) ||
+            !(phba->hba_flag & HBA_FIP_SUPPORT)) {
+                spin_unlock_irq(&phba->hbalock);
+                return;
+        }
+        spin_unlock_irq(&phba->hbalock);
+
+        if (lpfc_fcf_inuse(phba))
+                return;
+
+        lpfc_unregister_fcf_rescan(phba);
 }
 
 /**
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index c9faa1d8c3c8..89ff7c09e298 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -1346,6 +1346,9 @@ typedef struct {		/* FireFly BIU registers */
 #define MBX_HEARTBEAT       0x31
 #define MBX_WRITE_VPARMS    0x32
 #define MBX_ASYNCEVT_ENABLE 0x33
+#define MBX_READ_EVENT_LOG_STATUS 0x37
+#define MBX_READ_EVENT_LOG  0x38
+#define MBX_WRITE_EVENT_LOG 0x39
 
 #define MBX_PORT_CAPABILITIES 0x3B
 #define MBX_PORT_IOV_CONTROL 0x3C
@@ -1465,17 +1468,13 @@ typedef struct {		/* FireFly BIU registers */
 #define CMD_IOCB_LOGENTRY_CN            0x94
 #define CMD_IOCB_LOGENTRY_ASYNC_CN      0x96
 
-/* Unhandled Data Security SLI Commands */
-#define DSSCMD_IWRITE64_CR              0xD8
-#define DSSCMD_IWRITE64_CX              0xD9
-#define DSSCMD_IREAD64_CR               0xDA
-#define DSSCMD_IREAD64_CX               0xDB
-#define DSSCMD_INVALIDATE_DEK           0xDC
-#define DSSCMD_SET_KEK                  0xDD
-#define DSSCMD_GET_KEK_ID               0xDE
-#define DSSCMD_GEN_XFER                 0xDF
-
-#define CMD_MAX_IOCB_CMD        0xE6
+/* Data Security SLI Commands */
+#define DSSCMD_IWRITE64_CR              0xF8
+#define DSSCMD_IWRITE64_CX              0xF9
+#define DSSCMD_IREAD64_CR               0xFA
+#define DSSCMD_IREAD64_CX               0xFB
+
+#define CMD_MAX_IOCB_CMD        0xFB
 #define CMD_IOCB_MASK           0xff
 
 #define MAX_MSG_DATA            28      /* max msg data in CMD_ADAPTER_MSG
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 8a2a1c5935c6..820015fbc4d6 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -52,35 +52,37 @@ struct dma_address {
         uint32_t addr_hi;
 };
 
-#define LPFC_SLIREV_CONF_WORD   0x58
 struct lpfc_sli_intf {
         uint32_t word0;
-#define lpfc_sli_intf_iftype_MASK       0x00000007
-#define lpfc_sli_intf_iftype_SHIFT      0
-#define lpfc_sli_intf_iftype_WORD       word0
-#define lpfc_sli_intf_rev_MASK          0x0000000f
-#define lpfc_sli_intf_rev_SHIFT         4
-#define lpfc_sli_intf_rev_WORD          word0
-#define LPFC_SLIREV_CONF_SLI4   4
-#define lpfc_sli_intf_family_MASK       0x000000ff
-#define lpfc_sli_intf_family_SHIFT      8
-#define lpfc_sli_intf_family_WORD       word0
-#define lpfc_sli_intf_feat1_MASK        0x000000ff
-#define lpfc_sli_intf_feat1_SHIFT       16
-#define lpfc_sli_intf_feat1_WORD        word0
-#define lpfc_sli_intf_feat2_MASK        0x0000001f
-#define lpfc_sli_intf_feat2_SHIFT       24
-#define lpfc_sli_intf_feat2_WORD        word0
-#define lpfc_sli_intf_valid_MASK        0x00000007
-#define lpfc_sli_intf_valid_SHIFT       29
-#define lpfc_sli_intf_valid_WORD        word0
+#define lpfc_sli_intf_valid_SHIFT               29
+#define lpfc_sli_intf_valid_MASK                0x00000007
+#define lpfc_sli_intf_valid_WORD                word0
 #define LPFC_SLI_INTF_VALID             6
+#define lpfc_sli_intf_featurelevel2_SHIFT       24
+#define lpfc_sli_intf_featurelevel2_MASK        0x0000001F
+#define lpfc_sli_intf_featurelevel2_WORD        word0
+#define lpfc_sli_intf_featurelevel1_SHIFT       16
+#define lpfc_sli_intf_featurelevel1_MASK        0x000000FF
+#define lpfc_sli_intf_featurelevel1_WORD        word0
+#define LPFC_SLI_INTF_FEATURELEVEL1_1   1
+#define LPFC_SLI_INTF_FEATURELEVEL1_2   2
+#define lpfc_sli_intf_sli_family_SHIFT          8
+#define lpfc_sli_intf_sli_family_MASK           0x000000FF
+#define lpfc_sli_intf_sli_family_WORD           word0
+#define LPFC_SLI_INTF_FAMILY_BE2        0
+#define LPFC_SLI_INTF_FAMILY_BE3        1
+#define lpfc_sli_intf_slirev_SHIFT              4
+#define lpfc_sli_intf_slirev_MASK               0x0000000F
+#define lpfc_sli_intf_slirev_WORD               word0
+#define LPFC_SLI_INTF_REV_SLI3          3
+#define LPFC_SLI_INTF_REV_SLI4          4
+#define lpfc_sli_intf_if_type_SHIFT             0
+#define lpfc_sli_intf_if_type_MASK              0x00000007
+#define lpfc_sli_intf_if_type_WORD              word0
+#define LPFC_SLI_INTF_IF_TYPE_0         0
+#define LPFC_SLI_INTF_IF_TYPE_1         1
 };
 
-#define LPFC_SLI4_BAR0          1
-#define LPFC_SLI4_BAR1          2
-#define LPFC_SLI4_BAR2          4
-
 #define LPFC_SLI4_MBX_EMBED     true
 #define LPFC_SLI4_MBX_NEMBED    false
 
@@ -161,6 +163,9 @@ struct lpfc_sli_intf {
 #define LPFC_FP_DEF_IMAX       10000
 #define LPFC_SP_DEF_IMAX       10000
 
+/* PORT_CAPABILITIES constants. */
+#define LPFC_MAX_SUPPORTED_PAGES        8
+
 struct ulp_bde64 {
         union ULP_BDE_TUS {
                 uint32_t w;
@@ -516,7 +521,7 @@ struct lpfc_register {
 #define LPFC_UERR_STATUS_LO             0x00A0
 #define LPFC_UE_MASK_HI                 0x00AC
 #define LPFC_UE_MASK_LO                 0x00A8
-#define LPFC_SCRATCHPAD                 0x0058
+#define LPFC_SLI_INTF                   0x0058
 
 /* BAR0 Registers */
 #define LPFC_HST_STATE                  0x00AC
@@ -576,19 +581,6 @@ struct lpfc_register {
 #define LPFC_POST_STAGE_ARMFW_READY                     0xC000
 #define LPFC_POST_STAGE_ARMFW_UE                        0xF000
 
-#define lpfc_scratchpad_slirev_SHIFT                    4
-#define lpfc_scratchpad_slirev_MASK                     0xF
-#define lpfc_scratchpad_slirev_WORD                     word0
-#define lpfc_scratchpad_chiptype_SHIFT                  8
-#define lpfc_scratchpad_chiptype_MASK                   0xFF
-#define lpfc_scratchpad_chiptype_WORD                   word0
-#define lpfc_scratchpad_featurelevel1_SHIFT             16
-#define lpfc_scratchpad_featurelevel1_MASK              0xFF
-#define lpfc_scratchpad_featurelevel1_WORD              word0
-#define lpfc_scratchpad_featurelevel2_SHIFT             24
-#define lpfc_scratchpad_featurelevel2_MASK              0xFF
-#define lpfc_scratchpad_featurelevel2_WORD              word0
-
 /* BAR1 Registers */
 #define LPFC_IMR_MASK_ALL       0xFFFFFFFF
 #define LPFC_ISCR_CLEAR_ALL     0xFFFFFFFF
@@ -801,6 +793,7 @@ struct mbox_header {
 #define LPFC_MBOX_OPCODE_FCOE_ADD_FCF                   0x09
 #define LPFC_MBOX_OPCODE_FCOE_DELETE_FCF                0x0A
 #define LPFC_MBOX_OPCODE_FCOE_POST_HDR_TEMPLATE         0x0B
+#define LPFC_MBOX_OPCODE_FCOE_REDISCOVER_FCF            0x10
 
 /* Mailbox command structures */
 struct eq_context {
@@ -1149,10 +1142,7 @@ struct sli4_sge {	/* SLI-4 */
                                                 this  flag !! */
 #define lpfc_sli4_sge_last_MASK         0x00000001
 #define lpfc_sli4_sge_last_WORD         word2
-        uint32_t word3;
-#define lpfc_sli4_sge_len_SHIFT         0
-#define lpfc_sli4_sge_len_MASK          0x0001FFFF
-#define lpfc_sli4_sge_len_WORD          word3
+        uint32_t sge_len;
 };
 
 struct fcf_record {
@@ -1301,6 +1291,19 @@ struct lpfc_mbx_del_fcf_tbl_entry {
 #define lpfc_mbx_del_fcf_tbl_index_WORD         word10
 };
 
+struct lpfc_mbx_redisc_fcf_tbl {
+        struct mbox_header header;
+        uint32_t word10;
+#define lpfc_mbx_redisc_fcf_count_SHIFT         0
+#define lpfc_mbx_redisc_fcf_count_MASK          0x0000FFFF
+#define lpfc_mbx_redisc_fcf_count_WORD          word10
+        uint32_t resvd;
+        uint32_t word12;
+#define lpfc_mbx_redisc_fcf_index_SHIFT         0
+#define lpfc_mbx_redisc_fcf_index_MASK          0x0000FFFF
+#define lpfc_mbx_redisc_fcf_index_WORD          word12
+};
+
 struct lpfc_mbx_query_fw_cfg {
         struct mbox_header header;
         uint32_t config_number;
@@ -1834,6 +1837,177 @@ struct lpfc_mbx_request_features {
 #define lpfc_mbx_rq_ftr_rsp_ifip_WORD           word3
 };
 
+struct lpfc_mbx_supp_pages {
+        uint32_t word1;
+#define qs_SHIFT                                0
+#define qs_MASK                                 0x00000001
+#define qs_WORD                                 word1
+#define wr_SHIFT                                1
+#define wr_MASK                                 0x00000001
+#define wr_WORD                                 word1
+#define pf_SHIFT                                8
+#define pf_MASK                                 0x000000ff
+#define pf_WORD                                 word1
+#define cpn_SHIFT                               16
+#define cpn_MASK                                0x000000ff
+#define cpn_WORD                                word1
+        uint32_t word2;
+#define list_offset_SHIFT                       0
+#define list_offset_MASK                        0x000000ff
+#define list_offset_WORD                        word2
+#define next_offset_SHIFT                       8
+#define next_offset_MASK                        0x000000ff
+#define next_offset_WORD                        word2
+#define elem_cnt_SHIFT                          16
+#define elem_cnt_MASK                           0x000000ff
+#define elem_cnt_WORD                           word2
+        uint32_t word3;
+#define pn_0_SHIFT                              24
+#define pn_0_MASK                               0x000000ff
+#define pn_0_WORD                               word3
+#define pn_1_SHIFT                              16
+#define pn_1_MASK                               0x000000ff
+#define pn_1_WORD                               word3
+#define pn_2_SHIFT                              8
+#define pn_2_MASK                               0x000000ff
+#define pn_2_WORD                               word3
+#define pn_3_SHIFT                              0
+#define pn_3_MASK                               0x000000ff
+#define pn_3_WORD                               word3
+        uint32_t word4;
+#define pn_4_SHIFT                              24
+#define pn_4_MASK                               0x000000ff
+#define pn_4_WORD                               word4
+#define pn_5_SHIFT                              16
+#define pn_5_MASK                               0x000000ff
+#define pn_5_WORD                               word4
+#define pn_6_SHIFT                              8
+#define pn_6_MASK                               0x000000ff
+#define pn_6_WORD                               word4
+#define pn_7_SHIFT                              0
+#define pn_7_MASK                               0x000000ff
+#define pn_7_WORD                               word4
+        uint32_t rsvd[27];
+#define LPFC_SUPP_PAGES                 0
+#define LPFC_BLOCK_GUARD_PROFILES       1
+#define LPFC_SLI4_PARAMETERS            2
+};
+
+struct lpfc_mbx_sli4_params {
+        uint32_t word1;
+#define qs_SHIFT                                0
+#define qs_MASK                                 0x00000001
+#define qs_WORD                                 word1
+#define wr_SHIFT                                1
+#define wr_MASK                                 0x00000001
+#define wr_WORD                                 word1
+#define pf_SHIFT                                8
+#define pf_MASK                                 0x000000ff
+#define pf_WORD                                 word1
+#define cpn_SHIFT                               16
+#define cpn_MASK                                0x000000ff
+#define cpn_WORD                                word1
+        uint32_t word2;
+#define if_type_SHIFT                           0
+#define if_type_MASK                            0x00000007
+#define if_type_WORD                            word2
+#define sli_rev_SHIFT                           4
+#define sli_rev_MASK                            0x0000000f
+#define sli_rev_WORD                            word2
+#define sli_family_SHIFT                        8
+#define sli_family_MASK                         0x000000ff
+#define sli_family_WORD                         word2
+#define featurelevel_1_SHIFT                    16
+#define featurelevel_1_MASK                     0x000000ff
+#define featurelevel_1_WORD                     word2
+#define featurelevel_2_SHIFT                    24
+#define featurelevel_2_MASK                     0x0000001f
+#define featurelevel_2_WORD                     word2
+        uint32_t word3;
+#define fcoe_SHIFT                              0
+#define fcoe_MASK                               0x00000001
+#define fcoe_WORD                               word3
+#define fc_SHIFT                                1
+#define fc_MASK                                 0x00000001
+#define fc_WORD                                 word3
+#define nic_SHIFT                               2
+#define nic_MASK                                0x00000001
+#define nic_WORD                                word3
+#define iscsi_SHIFT                             3
+#define iscsi_MASK                              0x00000001
+#define iscsi_WORD                              word3
+#define rdma_SHIFT                              4
+#define rdma_MASK                               0x00000001
+#define rdma_WORD                               word3
+        uint32_t sge_supp_len;
+        uint32_t word5;
+#define if_page_sz_SHIFT                        0
+#define if_page_sz_MASK                         0x0000ffff
+#define if_page_sz_WORD                         word5
+#define loopbk_scope_SHIFT                      24
+#define loopbk_scope_MASK                       0x0000000f
+#define loopbk_scope_WORD                       word5
+#define rq_db_window_SHIFT                      28
+#define rq_db_window_MASK                       0x0000000f
+#define rq_db_window_WORD                       word5
+        uint32_t word6;
+#define eq_pages_SHIFT                          0
+#define eq_pages_MASK                           0x0000000f
+#define eq_pages_WORD                           word6
+#define eqe_size_SHIFT                          8
+#define eqe_size_MASK                           0x000000ff
+#define eqe_size_WORD                           word6
+        uint32_t word7;
+#define cq_pages_SHIFT                          0
+#define cq_pages_MASK                           0x0000000f
+#define cq_pages_WORD                           word7
+#define cqe_size_SHIFT                          8
+#define cqe_size_MASK                           0x000000ff
+#define cqe_size_WORD                           word7
+        uint32_t word8;
+#define mq_pages_SHIFT                          0
+#define mq_pages_MASK                           0x0000000f
+#define mq_pages_WORD                           word8
+#define mqe_size_SHIFT                          8
+#define mqe_size_MASK                           0x000000ff
+#define mqe_size_WORD                           word8
+#define mq_elem_cnt_SHIFT                       16
+#define mq_elem_cnt_MASK                        0x000000ff
+#define mq_elem_cnt_WORD                        word8
+        uint32_t word9;
+#define wq_pages_SHIFT                          0
+#define wq_pages_MASK                           0x0000ffff
+#define wq_pages_WORD                           word9
+#define wqe_size_SHIFT                          8
+#define wqe_size_MASK                           0x000000ff
+#define wqe_size_WORD                           word9
+        uint32_t word10;
+#define rq_pages_SHIFT                          0
+#define rq_pages_MASK                           0x0000ffff
+#define rq_pages_WORD                           word10
+#define rqe_size_SHIFT                          8
+#define rqe_size_MASK                           0x000000ff
+#define rqe_size_WORD                           word10
+        uint32_t word11;
+#define hdr_pages_SHIFT                         0
+#define hdr_pages_MASK                          0x0000000f
+#define hdr_pages_WORD                          word11
+#define hdr_size_SHIFT                          8
+#define hdr_size_MASK                           0x0000000f
+#define hdr_size_WORD                           word11
+#define hdr_pp_align_SHIFT                      16
+#define hdr_pp_align_MASK                       0x0000ffff
+#define hdr_pp_align_WORD                       word11
+        uint32_t word12;
+#define sgl_pages_SHIFT                         0
+#define sgl_pages_MASK                          0x0000000f
+#define sgl_pages_WORD                          word12
+#define sgl_pp_align_SHIFT                      16
+#define sgl_pp_align_MASK                       0x0000ffff
+#define sgl_pp_align_WORD                       word12
+        uint32_t rsvd_13_63[51];
+};
+
 /* Mailbox Completion Queue Error Messages */
 #define MB_CQE_STATUS_SUCCESS                   0x0
 #define MB_CQE_STATUS_INSUFFICIENT_PRIVILEGES   0x1
@@ -1863,6 +2037,7 @@ struct lpfc_mqe {
                 struct lpfc_mbx_read_fcf_tbl read_fcf_tbl;
                 struct lpfc_mbx_add_fcf_tbl_entry add_fcf_entry;
                 struct lpfc_mbx_del_fcf_tbl_entry del_fcf_entry;
+                struct lpfc_mbx_redisc_fcf_tbl redisc_fcf_tbl;
                 struct lpfc_mbx_reg_fcfi reg_fcfi;
                 struct lpfc_mbx_unreg_fcfi unreg_fcfi;
                 struct lpfc_mbx_mq_create mq_create;
@@ -1883,6 +2058,8 @@ struct lpfc_mqe {
                 struct lpfc_mbx_request_features req_ftrs;
                 struct lpfc_mbx_post_hdr_tmpl hdr_tmpl;
                 struct lpfc_mbx_query_fw_cfg query_fw_cfg;
+                struct lpfc_mbx_supp_pages supp_pages;
+                struct lpfc_mbx_sli4_params sli4_params;
                 struct lpfc_mbx_nop nop;
         } un;
 };
@@ -1959,6 +2136,9 @@ struct lpfc_acqe_link {
 #define LPFC_ASYNC_LINK_FAULT_NONE      0x0
 #define LPFC_ASYNC_LINK_FAULT_LOCAL     0x1
 #define LPFC_ASYNC_LINK_FAULT_REMOTE    0x2
+#define lpfc_acqe_qos_link_speed_SHIFT  16
+#define lpfc_acqe_qos_link_speed_MASK   0x0000FFFF
+#define lpfc_acqe_qos_link_speed_WORD   word1
         uint32_t event_tag;
         uint32_t trailer;
 };
@@ -1976,6 +2156,7 @@ struct lpfc_acqe_fcoe {
 #define LPFC_FCOE_EVENT_TYPE_FCF_TABLE_FULL     0x2
 #define LPFC_FCOE_EVENT_TYPE_FCF_DEAD           0x3
 #define LPFC_FCOE_EVENT_TYPE_CVL                0x4
+#define LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD      0x5
         uint32_t event_tag;
         uint32_t trailer;
 };
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index b8eb1b6e5e77..d29ac7c317d9 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  * Portions Copyright (C) 2004-2005 Christoph Hellwig              *
@@ -544,7 +544,7 @@ lpfc_config_port_post(struct lpfc_hba *phba)
                         mempool_free(pmb, phba->mbox_mem_pool);
                         return -EIO;
                 }
-        } else {
+        } else if (phba->cfg_suppress_link_up == 0) {
                 lpfc_init_link(phba, pmb, phba->cfg_topology,
                         phba->cfg_link_speed);
                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
@@ -603,6 +603,102 @@ lpfc_config_port_post(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_hba_init_link - Initialize the FC link
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine will issue the INIT_LINK mailbox command call.
+ * It is available to other drivers through the lpfc_hba data
+ * structure for use as a delayed link up mechanism with the
+ * module parameter lpfc_suppress_link_up.
+ *
+ * Return code
+ *              0 - success
+ *              Any other value - error
+ **/
+int
+lpfc_hba_init_link(struct lpfc_hba *phba)
+{
+        struct lpfc_vport *vport = phba->pport;
+        LPFC_MBOXQ_t *pmb;
+        MAILBOX_t *mb;
+        int rc;
+
+        pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                phba->link_state = LPFC_HBA_ERROR;
+                return -ENOMEM;
+        }
+        mb = &pmb->u.mb;
+        pmb->vport = vport;
+
+        lpfc_init_link(phba, pmb, phba->cfg_topology,
+                phba->cfg_link_speed);
+        pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        lpfc_set_loopback_flag(phba);
+        rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+        if (rc != MBX_SUCCESS) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "0498 Adapter failed to init, mbxCmd x%x "
+                        "INIT_LINK, mbxStatus x%x\n",
+                        mb->mbxCommand, mb->mbxStatus);
+                /* Clear all interrupt enable conditions */
+                writel(0, phba->HCregaddr);
+                readl(phba->HCregaddr); /* flush */
+                /* Clear all pending interrupts */
+                writel(0xffffffff, phba->HAregaddr);
+                readl(phba->HAregaddr); /* flush */
+                phba->link_state = LPFC_HBA_ERROR;
+                if (rc != MBX_BUSY)
+                        mempool_free(pmb, phba->mbox_mem_pool);
+                return -EIO;
+        }
+        phba->cfg_suppress_link_up = 0;
+
+        return 0;
+}
+
+/**
+ * lpfc_hba_down_link - this routine downs the FC link
+ *
+ * This routine will issue the DOWN_LINK mailbox command call.
+ * It is available to other drivers through the lpfc_hba data
+ * structure for use to stop the link.
+ *
+ * Return code
+ *              0 - success
+ *              Any other value - error
+ **/
+int
+lpfc_hba_down_link(struct lpfc_hba *phba)
+{
+        LPFC_MBOXQ_t *pmb;
+        int rc;
+
+        pmb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmb) {
+                phba->link_state = LPFC_HBA_ERROR;
+                return -ENOMEM;
+        }
+
+        lpfc_printf_log(phba,
+                KERN_ERR, LOG_INIT,
+                "0491 Adapter Link is disabled.\n");
+        lpfc_down_link(phba, pmb);
+        pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+        if ((rc != MBX_SUCCESS) && (rc != MBX_BUSY)) {
+                lpfc_printf_log(phba,
+                KERN_ERR, LOG_INIT,
+                "2522 Adapter failed to issue DOWN_LINK"
+                " mbox command rc 0x%x\n", rc);
+
+                mempool_free(pmb, phba->mbox_mem_pool);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
  * lpfc_hba_down_prep - Perform lpfc uninitialization prior to HBA reset
  * @phba: pointer to lpfc HBA data structure.
  *
@@ -2073,6 +2169,44 @@ lpfc_stop_vport_timers(struct lpfc_vport *vport)
 }
 
 /**
+ * __lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine stops the SLI4 FCF rediscover wait timer if it's on. The
+ * caller of this routine should already hold the host lock.
+ **/
+void
+__lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
+{
+        /* Clear pending FCF rediscovery wait timer */
+        phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
+        /* Now, try to stop the timer */
+        del_timer(&phba->fcf.redisc_wait);
+}
+
+/**
+ * lpfc_sli4_stop_fcf_redisc_wait_timer - Stop FCF rediscovery wait timer
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine stops the SLI4 FCF rediscover wait timer if it's on. It
+ * checks whether the FCF rediscovery wait timer is pending with the host
+ * lock held before proceeding with disabling the timer and clearing the
+ * wait timer pendig flag.
+ **/
+void
+lpfc_sli4_stop_fcf_redisc_wait_timer(struct lpfc_hba *phba)
+{
+        spin_lock_irq(&phba->hbalock);
+        if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
+                /* FCF rediscovery timer already fired or stopped */
+                spin_unlock_irq(&phba->hbalock);
+                return;
+        }
+        __lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
  * lpfc_stop_hba_timers - Stop all the timers associated with an HBA
  * @phba: pointer to lpfc hba data structure.
  *
@@ -2096,6 +2230,7 @@ lpfc_stop_hba_timers(struct lpfc_hba *phba)
                 break;
         case LPFC_PCI_DEV_OC:
                 /* Stop any OneConnect device sepcific driver timers */
+                lpfc_sli4_stop_fcf_redisc_wait_timer(phba);
                 break;
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -2228,6 +2363,7 @@ lpfc_offline_prep(struct lpfc_hba * phba)
         struct lpfc_vport *vport = phba->pport;
         struct lpfc_nodelist  *ndlp, *next_ndlp;
         struct lpfc_vport **vports;
+        struct Scsi_Host *shost;
         int i;
 
         if (vport->fc_flag & FC_OFFLINE_MODE)
@@ -2241,11 +2377,15 @@ lpfc_offline_prep(struct lpfc_hba * phba)
         vports = lpfc_create_vport_work_array(phba);
         if (vports != NULL) {
                 for (i = 0; i <= phba->max_vports && vports[i] != NULL; i++) {
-                        struct Scsi_Host *shost;
-
                         if (vports[i]->load_flag & FC_UNLOADING)
                                 continue;
+                        shost = lpfc_shost_from_vport(vports[i]);
+                        spin_lock_irq(shost->host_lock);
                         vports[i]->vpi_state &= ~LPFC_VPI_REGISTERED;
+                        vports[i]->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
+                        vports[i]->fc_flag &= ~FC_VFI_REGISTERED;
+                        spin_unlock_irq(shost->host_lock);
+
                         shost = lpfc_shost_from_vport(vports[i]);
                         list_for_each_entry_safe(ndlp, next_ndlp,
                                                  &vports[i]->fc_nodes,
@@ -2401,7 +2541,8 @@ lpfc_create_port(struct lpfc_hba *phba, int instance, struct device *dev)
         shost->this_id = -1;
         shost->max_cmd_len = 16;
         if (phba->sli_rev == LPFC_SLI_REV4) {
-                shost->dma_boundary = LPFC_SLI4_MAX_SEGMENT_SIZE;
+                shost->dma_boundary =
+                        phba->sli4_hba.pc_sli4_params.sge_supp_len;
                 shost->sg_tablesize = phba->cfg_sg_seg_cnt;
         }
 
@@ -2650,8 +2791,6 @@ lpfc_stop_port_s4(struct lpfc_hba *phba)
         lpfc_stop_hba_timers(phba);
         phba->pport->work_port_events = 0;
         phba->sli4_hba.intr_enable = 0;
-        /* Hard clear it for now, shall have more graceful way to wait later */
-        phba->sli.sli_flag &= ~LPFC_SLI_MBOX_ACTIVE;
 }
 
 /**
@@ -2703,7 +2842,7 @@ lpfc_sli_remove_dflt_fcf(struct lpfc_hba *phba)
         del_fcf_record = &mboxq->u.mqe.un.del_fcf_entry;
         bf_set(lpfc_mbx_del_fcf_tbl_count, del_fcf_record, 1);
         bf_set(lpfc_mbx_del_fcf_tbl_index, del_fcf_record,
-               phba->fcf.fcf_indx);
+               phba->fcf.current_rec.fcf_indx);
 
         if (!phba->sli4_hba.intr_enable)
                 rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
@@ -2727,6 +2866,57 @@ lpfc_sli_remove_dflt_fcf(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_fcf_redisc_wait_start_timer - Start fcf rediscover wait timer
+ * @phba: Pointer to hba for which this call is being executed.
+ *
+ * This routine starts the timer waiting for the FCF rediscovery to complete.
+ **/
+void
+lpfc_fcf_redisc_wait_start_timer(struct lpfc_hba *phba)
+{
+        unsigned long fcf_redisc_wait_tmo =
+                (jiffies + msecs_to_jiffies(LPFC_FCF_REDISCOVER_WAIT_TMO));
+        /* Start fcf rediscovery wait period timer */
+        mod_timer(&phba->fcf.redisc_wait, fcf_redisc_wait_tmo);
+        spin_lock_irq(&phba->hbalock);
+        /* Allow action to new fcf asynchronous event */
+        phba->fcf.fcf_flag &= ~(FCF_AVAILABLE | FCF_SCAN_DONE);
+        /* Mark the FCF rediscovery pending state */
+        phba->fcf.fcf_flag |= FCF_REDISC_PEND;
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
+ * lpfc_sli4_fcf_redisc_wait_tmo - FCF table rediscover wait timeout
+ * @ptr: Map to lpfc_hba data structure pointer.
+ *
+ * This routine is invoked when waiting for FCF table rediscover has been
+ * timed out. If new FCF record(s) has (have) been discovered during the
+ * wait period, a new FCF event shall be added to the FCOE async event
+ * list, and then worker thread shall be waked up for processing from the
+ * worker thread context.
+ **/
+void
+lpfc_sli4_fcf_redisc_wait_tmo(unsigned long ptr)
+{
+        struct lpfc_hba *phba = (struct lpfc_hba *)ptr;
+
+        /* Don't send FCF rediscovery event if timer cancelled */
+        spin_lock_irq(&phba->hbalock);
+        if (!(phba->fcf.fcf_flag & FCF_REDISC_PEND)) {
+                spin_unlock_irq(&phba->hbalock);
+                return;
+        }
+        /* Clear FCF rediscovery timer pending flag */
+        phba->fcf.fcf_flag &= ~FCF_REDISC_PEND;
+        /* FCF rediscovery event to worker thread */
+        phba->fcf.fcf_flag |= FCF_REDISC_EVT;
+        spin_unlock_irq(&phba->hbalock);
+        /* wake up worker thread */
+        lpfc_worker_wake_up(phba);
+}
+
+/**
  * lpfc_sli4_fw_cfg_check - Read the firmware config and verify FCoE support
  * @phba: pointer to lpfc hba data structure.
  *
@@ -2978,6 +3168,8 @@ lpfc_sli4_async_link_evt(struct lpfc_hba *phba,
                                 bf_get(lpfc_acqe_link_physical, acqe_link);
         phba->sli4_hba.link_state.fault =
                                 bf_get(lpfc_acqe_link_fault, acqe_link);
+        phba->sli4_hba.link_state.logical_speed =
+                                bf_get(lpfc_acqe_qos_link_speed, acqe_link);
 
         /* Invoke the lpfc_handle_latt mailbox command callback function */
         lpfc_mbx_cmpl_read_la(phba, pmb);
@@ -3007,22 +3199,34 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
         struct lpfc_nodelist *ndlp;
         struct Scsi_Host  *shost;
         uint32_t link_state;
+        int active_vlink_present;
+        struct lpfc_vport **vports;
+        int i;
 
         phba->fc_eventTag = acqe_fcoe->event_tag;
         phba->fcoe_eventtag = acqe_fcoe->event_tag;
         switch (event_type) {
         case LPFC_FCOE_EVENT_TYPE_NEW_FCF:
+        case LPFC_FCOE_EVENT_TYPE_FCF_PARAM_MOD:
                 lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
                         "2546 New FCF found index 0x%x tag 0x%x\n",
                         acqe_fcoe->index,
                         acqe_fcoe->event_tag);
-                /*
-                 * If the current FCF is in discovered state, or
-                 * FCF discovery is in progress do nothing.
-                 */
                 spin_lock_irq(&phba->hbalock);
-                if ((phba->fcf.fcf_flag & FCF_DISCOVERED) ||
-                   (phba->hba_flag & FCF_DISC_INPROGRESS)) {
+                if ((phba->fcf.fcf_flag & FCF_SCAN_DONE) ||
+                    (phba->hba_flag & FCF_DISC_INPROGRESS)) {
+                        /*
+                         * If the current FCF is in discovered state or
+                         * FCF discovery is in progress, do nothing.
+                         */
+                        spin_unlock_irq(&phba->hbalock);
+                        break;
+                }
+                if (phba->fcf.fcf_flag & FCF_REDISC_EVT) {
+                        /*
+                         * If fast FCF failover rescan event is pending,
+                         * do nothing.
+                         */
                         spin_unlock_irq(&phba->hbalock);
                         break;
                 }
@@ -3049,7 +3253,7 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                         " tag 0x%x\n", acqe_fcoe->index,
                         acqe_fcoe->event_tag);
                 /* If the event is not for currently used fcf do nothing */
-                if (phba->fcf.fcf_indx != acqe_fcoe->index)
+                if (phba->fcf.current_rec.fcf_indx != acqe_fcoe->index)
                         break;
                 /*
                  * Currently, driver support only one FCF - so treat this as
@@ -3074,14 +3278,58 @@ lpfc_sli4_async_fcoe_evt(struct lpfc_hba *phba,
                 if (!ndlp)
                         break;
                 shost = lpfc_shost_from_vport(vport);
+                if (phba->pport->port_state <= LPFC_FLOGI)
+                        break;
+                /* If virtual link is not yet instantiated ignore CVL */
+                if (vport->port_state <= LPFC_FDISC)
+                        break;
+
                 lpfc_linkdown_port(vport);
-                if (vport->port_type != LPFC_NPIV_PORT) {
+                lpfc_cleanup_pending_mbox(vport);
+                spin_lock_irq(shost->host_lock);
+                vport->fc_flag |= FC_VPORT_CVL_RCVD;
+                spin_unlock_irq(shost->host_lock);
+                active_vlink_present = 0;
+
+                vports = lpfc_create_vport_work_array(phba);
+                if (vports) {
+                        for (i = 0; i <= phba->max_vports && vports[i] != NULL;
+                                        i++) {
+                                if ((!(vports[i]->fc_flag &
+                                        FC_VPORT_CVL_RCVD)) &&
+                                        (vports[i]->port_state > LPFC_FDISC)) {
+                                        active_vlink_present = 1;
+                                        break;
+                                }
+                        }
+                        lpfc_destroy_vport_work_array(phba, vports);
+                }
+
+                if (active_vlink_present) {
+                        /*
+                         * If there are other active VLinks present,
+                         * re-instantiate the Vlink using FDISC.
+                         */
                         mod_timer(&ndlp->nlp_delayfunc, jiffies + HZ);
                         spin_lock_irq(shost->host_lock);
                         ndlp->nlp_flag |= NLP_DELAY_TMO;
                         spin_unlock_irq(shost->host_lock);
-                        ndlp->nlp_last_elscmd = ELS_CMD_FLOGI;
-                        vport->port_state = LPFC_FLOGI;
+                        ndlp->nlp_last_elscmd = ELS_CMD_FDISC;
+                        vport->port_state = LPFC_FDISC;
+                } else {
+                        /*
+                         * Otherwise, we request port to rediscover
+                         * the entire FCF table for a fast recovery
+                         * from possible case that the current FCF
+                         * is no longer valid.
+                         */
+                        rc = lpfc_sli4_redisc_fcf_table(phba);
+                        if (rc)
+                                /*
+                                 * Last resort will be re-try on the
+                                 * the current registered FCF entry.
+                                 */
+                                lpfc_retry_pport_discovery(phba);
                 }
                 break;
         default:
@@ -3158,6 +3406,34 @@ void lpfc_sli4_async_event_proc(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli4_fcf_redisc_event_proc - Process fcf table rediscovery event
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked by the worker thread to process FCF table
+ * rediscovery pending completion event.
+ **/
+void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *phba)
+{
+        int rc;
+
+        spin_lock_irq(&phba->hbalock);
+        /* Clear FCF rediscovery timeout event */
+        phba->fcf.fcf_flag &= ~FCF_REDISC_EVT;
+        /* Clear driver fast failover FCF record flag */
+        phba->fcf.failover_rec.flag = 0;
+        /* Set state for FCF fast failover */
+        phba->fcf.fcf_flag |= FCF_REDISC_FOV;
+        spin_unlock_irq(&phba->hbalock);
+
+        /* Scan FCF table from the first entry to re-discover SAN */
+        rc = lpfc_sli4_read_fcf_record(phba, LPFC_FCOE_FCF_GET_FIRST);
+        if (rc)
+                lpfc_printf_log(phba, KERN_ERR, LOG_DISCOVERY,
+                                "2747 Post FCF rediscovery read FCF record "
+                                "failed 0x%x\n", rc);
+}
+
+/**
  * lpfc_api_table_setup - Set up per hba pci-device group func api jump table
  * @phba: pointer to lpfc hba data structure.
  * @dev_grp: The HBA PCI-Device group number.
@@ -3442,8 +3718,10 @@ static int
 lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
 {
         struct lpfc_sli *psli;
-        int rc;
-        int i, hbq_count;
+        LPFC_MBOXQ_t *mboxq;
+        int rc, i, hbq_count, buf_size, dma_buf_size, max_buf_size;
+        uint8_t pn_page[LPFC_MAX_SUPPORTED_PAGES] = {0};
+        struct lpfc_mqe *mqe;
 
         /* Before proceed, wait for POST done and device ready */
         rc = lpfc_sli4_post_status_check(phba);
@@ -3472,6 +3750,11 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         init_timer(&phba->eratt_poll);
         phba->eratt_poll.function = lpfc_poll_eratt;
         phba->eratt_poll.data = (unsigned long) phba;
+        /* FCF rediscover timer */
+        init_timer(&phba->fcf.redisc_wait);
+        phba->fcf.redisc_wait.function = lpfc_sli4_fcf_redisc_wait_tmo;
+        phba->fcf.redisc_wait.data = (unsigned long)phba;
+
         /*
          * We need to do a READ_CONFIG mailbox command here before
          * calling lpfc_get_cfgparam. For VFs this will report the
@@ -3496,31 +3779,26 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
          * used to create the sg_dma_buf_pool must be dynamically calculated.
          * 2 segments are added since the IOCB needs a command and response bde.
          * To insure that the scsi sgl does not cross a 4k page boundary only
-         * sgl sizes of 1k, 2k, 4k, and 8k are supported.
-         * Table of sgl sizes and seg_cnt:
-         * sgl size,    sg_seg_cnt      total seg
-         * 1k           50              52
-         * 2k           114             116
-         * 4k           242             244
-         * 8k           498             500
-         * cmd(32) + rsp(160) + (52 * sizeof(sli4_sge)) = 1024
-         * cmd(32) + rsp(160) + (116 * sizeof(sli4_sge)) = 2048
-         * cmd(32) + rsp(160) + (244 * sizeof(sli4_sge)) = 4096
-         * cmd(32) + rsp(160) + (500 * sizeof(sli4_sge)) = 8192
+         * sgl sizes of must be a power of 2.
          */
-        if (phba->cfg_sg_seg_cnt <= LPFC_DEFAULT_SG_SEG_CNT)
-                phba->cfg_sg_seg_cnt = 50;
-        else if (phba->cfg_sg_seg_cnt <= 114)
-                phba->cfg_sg_seg_cnt = 114;
-        else if (phba->cfg_sg_seg_cnt <= 242)
-                phba->cfg_sg_seg_cnt = 242;
+        buf_size = (sizeof(struct fcp_cmnd) + sizeof(struct fcp_rsp) +
+                    ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge)));
+        /* Feature Level 1 hardware is limited to 2 pages */
+        if ((bf_get(lpfc_sli_intf_featurelevel1, &phba->sli4_hba.sli_intf) ==
+             LPFC_SLI_INTF_FEATURELEVEL1_1))
+                max_buf_size = LPFC_SLI4_FL1_MAX_BUF_SIZE;
         else
-                phba->cfg_sg_seg_cnt = 498;
-
-        phba->cfg_sg_dma_buf_size = sizeof(struct fcp_cmnd)
-                                        + sizeof(struct fcp_rsp);
-        phba->cfg_sg_dma_buf_size +=
-                ((phba->cfg_sg_seg_cnt + 2) * sizeof(struct sli4_sge));
+                max_buf_size = LPFC_SLI4_MAX_BUF_SIZE;
+        for (dma_buf_size = LPFC_SLI4_MIN_BUF_SIZE;
+             dma_buf_size < max_buf_size && buf_size > dma_buf_size;
+             dma_buf_size = dma_buf_size << 1)
+                ;
+        if (dma_buf_size == max_buf_size)
+                phba->cfg_sg_seg_cnt = (dma_buf_size -
+                        sizeof(struct fcp_cmnd) - sizeof(struct fcp_rsp) -
+                        (2 * sizeof(struct sli4_sge))) /
+                                sizeof(struct sli4_sge);
+        phba->cfg_sg_dma_buf_size = dma_buf_size;
 
         /* Initialize buffer queue management fields */
         hbq_count = lpfc_sli_hbq_count();
@@ -3638,6 +3916,43 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 goto out_free_fcp_eq_hdl;
         }
 
+        mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool,
+                                                       GFP_KERNEL);
+        if (!mboxq) {
+                rc = -ENOMEM;
+                goto out_free_fcp_eq_hdl;
+        }
+
+        /* Get the Supported Pages. It is always available. */
+        lpfc_supported_pages(mboxq);
+        rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+        if (unlikely(rc)) {
+                rc = -EIO;
+                mempool_free(mboxq, phba->mbox_mem_pool);
+                goto out_free_fcp_eq_hdl;
+        }
+
+        mqe = &mboxq->u.mqe;
+        memcpy(&pn_page[0], ((uint8_t *)&mqe->un.supp_pages.word3),
+               LPFC_MAX_SUPPORTED_PAGES);
+        for (i = 0; i < LPFC_MAX_SUPPORTED_PAGES; i++) {
+                switch (pn_page[i]) {
+                case LPFC_SLI4_PARAMETERS:
+                        phba->sli4_hba.pc_sli4_params.supported = 1;
+                        break;
+                default:
+                        break;
+                }
+        }
+
+        /* Read the port's SLI4 Parameters capabilities if supported. */
+        if (phba->sli4_hba.pc_sli4_params.supported)
+                rc = lpfc_pc_sli4_params_get(phba, mboxq);
+        mempool_free(mboxq, phba->mbox_mem_pool);
+        if (rc) {
+                rc = -EIO;
+                goto out_free_fcp_eq_hdl;
+        }
         return rc;
 
 out_free_fcp_eq_hdl:
@@ -3733,6 +4048,8 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
 int
 lpfc_init_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
 {
+        phba->lpfc_hba_init_link = lpfc_hba_init_link;
+        phba->lpfc_hba_down_link = lpfc_hba_down_link;
         switch (dev_grp) {
         case LPFC_PCI_DEV_LP:
                 phba->lpfc_hba_down_post = lpfc_hba_down_post_s3;
@@ -4291,7 +4608,7 @@ lpfc_hba_alloc(struct pci_dev *pdev)
                 return NULL;
         }
 
-        mutex_init(&phba->ct_event_mutex);
+        spin_lock_init(&phba->ct_ev_lock);
         INIT_LIST_HEAD(&phba->ct_ev_waiters);
 
         return phba;
@@ -4641,7 +4958,7 @@ lpfc_sli_pci_mem_unset(struct lpfc_hba *phba)
 int
 lpfc_sli4_post_status_check(struct lpfc_hba *phba)
 {
-        struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg, scratchpad;
+        struct lpfc_register sta_reg, uerrlo_reg, uerrhi_reg;
         int i, port_error = -ENODEV;
 
         if (!phba->sli4_hba.STAregaddr)
@@ -4677,14 +4994,21 @@ lpfc_sli4_post_status_check(struct lpfc_hba *phba)
                         bf_get(lpfc_hst_state_port_status, &sta_reg));
 
         /* Log device information */
-        scratchpad.word0 =  readl(phba->sli4_hba.SCRATCHPADregaddr);
-        lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
-                        "2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
-                        "FeatureL1=0x%x, FeatureL2=0x%x\n",
-                        bf_get(lpfc_scratchpad_chiptype, &scratchpad),
-                        bf_get(lpfc_scratchpad_slirev, &scratchpad),
-                        bf_get(lpfc_scratchpad_featurelevel1, &scratchpad),
-                        bf_get(lpfc_scratchpad_featurelevel2, &scratchpad));
+        phba->sli4_hba.sli_intf.word0 = readl(phba->sli4_hba.SLIINTFregaddr);
+        if (bf_get(lpfc_sli_intf_valid,
+                   &phba->sli4_hba.sli_intf) == LPFC_SLI_INTF_VALID) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "2534 Device Info: ChipType=0x%x, SliRev=0x%x, "
+                                "FeatureL1=0x%x, FeatureL2=0x%x\n",
+                                bf_get(lpfc_sli_intf_sli_family,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_slirev,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_featurelevel1,
+                                       &phba->sli4_hba.sli_intf),
+                                bf_get(lpfc_sli_intf_featurelevel2,
+                                       &phba->sli4_hba.sli_intf));
+        }
         phba->sli4_hba.ue_mask_lo = readl(phba->sli4_hba.UEMASKLOregaddr);
         phba->sli4_hba.ue_mask_hi = readl(phba->sli4_hba.UEMASKHIregaddr);
         /* With uncoverable error, log the error message and return error */
@@ -4723,8 +5047,8 @@ lpfc_sli4_bar0_register_memmap(struct lpfc_hba *phba)
                                         LPFC_UE_MASK_LO;
         phba->sli4_hba.UEMASKHIregaddr = phba->sli4_hba.conf_regs_memmap_p +
                                         LPFC_UE_MASK_HI;
-        phba->sli4_hba.SCRATCHPADregaddr = phba->sli4_hba.conf_regs_memmap_p +
-                                        LPFC_SCRATCHPAD;
+        phba->sli4_hba.SLIINTFregaddr = phba->sli4_hba.conf_regs_memmap_p +
+                                        LPFC_SLI_INTF;
 }
 
 /**
@@ -5999,7 +6323,7 @@ lpfc_sli4_fcfi_unreg(struct lpfc_hba *phba, uint16_t fcfi)
                 spin_lock_irqsave(&phba->hbalock, flags);
                 /* Mark the FCFI is no longer registered */
                 phba->fcf.fcf_flag &=
-                        ~(FCF_AVAILABLE | FCF_REGISTERED | FCF_DISCOVERED);
+                        ~(FCF_AVAILABLE | FCF_REGISTERED | FCF_SCAN_DONE);
                 spin_unlock_irqrestore(&phba->hbalock, flags);
         }
 }
@@ -6039,16 +6363,20 @@ lpfc_sli4_pci_mem_setup(struct lpfc_hba *phba)
 
         /* Get the bus address of SLI4 device Bar0, Bar1, and Bar2 and the
          * number of bytes required by each mapping. They are actually
-         * mapping to the PCI BAR regions 1, 2, and 4 by the SLI4 device.
+         * mapping to the PCI BAR regions 0 or 1, 2, and 4 by the SLI4 device.
          */
-        phba->pci_bar0_map = pci_resource_start(pdev, LPFC_SLI4_BAR0);
-        bar0map_len = pci_resource_len(pdev, LPFC_SLI4_BAR0);
-
-        phba->pci_bar1_map = pci_resource_start(pdev, LPFC_SLI4_BAR1);
-        bar1map_len = pci_resource_len(pdev, LPFC_SLI4_BAR1);
+        if (pci_resource_start(pdev, 0)) {
+                phba->pci_bar0_map = pci_resource_start(pdev, 0);
+                bar0map_len = pci_resource_len(pdev, 0);
+        } else {
+                phba->pci_bar0_map = pci_resource_start(pdev, 1);
+                bar0map_len = pci_resource_len(pdev, 1);
+        }
+        phba->pci_bar1_map = pci_resource_start(pdev, 2);
+        bar1map_len = pci_resource_len(pdev, 2);
 
-        phba->pci_bar2_map = pci_resource_start(pdev, LPFC_SLI4_BAR2);
-        bar2map_len = pci_resource_len(pdev, LPFC_SLI4_BAR2);
+        phba->pci_bar2_map = pci_resource_start(pdev, 4);
+        bar2map_len = pci_resource_len(pdev, 4);
 
         /* Map SLI4 PCI Config Space Register base to a kernel virtual addr */
         phba->sli4_hba.conf_regs_memmap_p =
@@ -6793,6 +7121,73 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba)
         phba->pport->work_port_events = 0;
 }
 
+ /**
+ * lpfc_pc_sli4_params_get - Get the SLI4_PARAMS port capabilities.
+ * @phba: Pointer to HBA context object.
+ * @mboxq: Pointer to the mailboxq memory for the mailbox command response.
+ *
+ * This function is called in the SLI4 code path to read the port's
+ * sli4 capabilities.
+ *
+ * This function may be be called from any context that can block-wait
+ * for the completion.  The expectation is that this routine is called
+ * typically from probe_one or from the online routine.
+ **/
+int
+lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
+{
+        int rc;
+        struct lpfc_mqe *mqe;
+        struct lpfc_pc_sli4_params *sli4_params;
+        uint32_t mbox_tmo;
+
+        rc = 0;
+        mqe = &mboxq->u.mqe;
+
+        /* Read the port's SLI4 Parameters port capabilities */
+        lpfc_sli4_params(mboxq);
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_PORT_CAPABILITIES);
+                rc = lpfc_sli_issue_mbox_wait(phba, mboxq, mbox_tmo);
+        }
+
+        if (unlikely(rc))
+                return 1;
+
+        sli4_params = &phba->sli4_hba.pc_sli4_params;
+        sli4_params->if_type = bf_get(if_type, &mqe->un.sli4_params);
+        sli4_params->sli_rev = bf_get(sli_rev, &mqe->un.sli4_params);
+        sli4_params->sli_family = bf_get(sli_family, &mqe->un.sli4_params);
+        sli4_params->featurelevel_1 = bf_get(featurelevel_1,
+                                             &mqe->un.sli4_params);
+        sli4_params->featurelevel_2 = bf_get(featurelevel_2,
+                                             &mqe->un.sli4_params);
+        sli4_params->proto_types = mqe->un.sli4_params.word3;
+        sli4_params->sge_supp_len = mqe->un.sli4_params.sge_supp_len;
+        sli4_params->if_page_sz = bf_get(if_page_sz, &mqe->un.sli4_params);
+        sli4_params->rq_db_window = bf_get(rq_db_window, &mqe->un.sli4_params);
+        sli4_params->loopbk_scope = bf_get(loopbk_scope, &mqe->un.sli4_params);
+        sli4_params->eq_pages_max = bf_get(eq_pages, &mqe->un.sli4_params);
+        sli4_params->eqe_size = bf_get(eqe_size, &mqe->un.sli4_params);
+        sli4_params->cq_pages_max = bf_get(cq_pages, &mqe->un.sli4_params);
+        sli4_params->cqe_size = bf_get(cqe_size, &mqe->un.sli4_params);
+        sli4_params->mq_pages_max = bf_get(mq_pages, &mqe->un.sli4_params);
+        sli4_params->mqe_size = bf_get(mqe_size, &mqe->un.sli4_params);
+        sli4_params->mq_elem_cnt = bf_get(mq_elem_cnt, &mqe->un.sli4_params);
+        sli4_params->wq_pages_max = bf_get(wq_pages, &mqe->un.sli4_params);
+        sli4_params->wqe_size = bf_get(wqe_size, &mqe->un.sli4_params);
+        sli4_params->rq_pages_max = bf_get(rq_pages, &mqe->un.sli4_params);
+        sli4_params->rqe_size = bf_get(rqe_size, &mqe->un.sli4_params);
+        sli4_params->hdr_pages_max = bf_get(hdr_pages, &mqe->un.sli4_params);
+        sli4_params->hdr_size = bf_get(hdr_size, &mqe->un.sli4_params);
+        sli4_params->hdr_pp_align = bf_get(hdr_pp_align, &mqe->un.sli4_params);
+        sli4_params->sgl_pages_max = bf_get(sgl_pages, &mqe->un.sli4_params);
+        sli4_params->sgl_pp_align = bf_get(sgl_pp_align, &mqe->un.sli4_params);
+        return rc;
+}
+
 /**
  * lpfc_pci_probe_one_s3 - PCI probe func to reg SLI-3 device to PCI subsystem.
  * @pdev: pointer to PCI device
@@ -7134,6 +7529,12 @@ lpfc_pci_resume_one_s3(struct pci_dev *pdev)
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
 
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
@@ -7317,6 +7718,13 @@ lpfc_io_slot_reset_s3(struct pci_dev *pdev)
         }
 
         pci_restore_state(pdev);
+
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
@@ -7726,6 +8134,13 @@ lpfc_pci_resume_one_s4(struct pci_dev *pdev)
         /* Restore device state from PCI config space */
         pci_set_power_state(pdev, PCI_D0);
         pci_restore_state(pdev);
+
+        /*
+         * As the new kernel behavior of pci_restore_state() API call clears
+         * device saved_state flag, need to save the restored state again.
+         */
+        pci_save_state(pdev);
+
         if (pdev->is_busmaster)
                 pci_set_master(pdev);
 
@@ -7845,11 +8260,11 @@ lpfc_pci_probe_one(struct pci_dev *pdev, const struct pci_device_id *pid)
         int rc;
         struct lpfc_sli_intf intf;
 
-        if (pci_read_config_dword(pdev, LPFC_SLIREV_CONF_WORD, &intf.word0))
+        if (pci_read_config_dword(pdev, LPFC_SLI_INTF, &intf.word0))
                 return -ENODEV;
 
         if ((bf_get(lpfc_sli_intf_valid, &intf) == LPFC_SLI_INTF_VALID) &&
-                (bf_get(lpfc_sli_intf_rev, &intf) == LPFC_SLIREV_CONF_SLI4))
+            (bf_get(lpfc_sli_intf_slirev, &intf) == LPFC_SLI_INTF_REV_SLI4))
                 rc = lpfc_pci_probe_one_s4(pdev, pid);
         else
                 rc = lpfc_pci_probe_one_s3(pdev, pid);
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index a9afd8b94b6a..6c4dce1a30ca 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -1707,7 +1707,8 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
                                 alloc_len - sizeof(union  lpfc_sli4_cfg_shdr);
         }
         /* The sub-header is in DMA memory, which needs endian converstion */
-        lpfc_sli_pcimem_bcopy(cfg_shdr, cfg_shdr,
+        if (cfg_shdr)
+                lpfc_sli_pcimem_bcopy(cfg_shdr, cfg_shdr,
                               sizeof(union  lpfc_sli4_cfg_shdr));
 
         return alloc_len;
@@ -1747,6 +1748,65 @@ lpfc_sli4_mbox_opcode_get(struct lpfc_hba *phba, struct lpfcMboxq *mbox)
 }
 
 /**
+ * lpfc_sli4_mbx_read_fcf_record - Allocate and construct read fcf mbox cmd
+ * @phba: pointer to lpfc hba data structure.
+ * @fcf_index: index to fcf table.
+ *
+ * This routine routine allocates and constructs non-embedded mailbox command
+ * for reading a FCF table entry refered by @fcf_index.
+ *
+ * Return: pointer to the mailbox command constructed if successful, otherwise
+ * NULL.
+ **/
+int
+lpfc_sli4_mbx_read_fcf_record(struct lpfc_hba *phba,
+                              struct lpfcMboxq *mboxq,
+                              uint16_t fcf_index)
+{
+        void *virt_addr;
+        dma_addr_t phys_addr;
+        uint8_t *bytep;
+        struct lpfc_mbx_sge sge;
+        uint32_t alloc_len, req_len;
+        struct lpfc_mbx_read_fcf_tbl *read_fcf;
+
+        if (!mboxq)
+                return -ENOMEM;
+
+        req_len = sizeof(struct fcf_record) +
+                  sizeof(union lpfc_sli4_cfg_shdr) + 2 * sizeof(uint32_t);
+
+        /* Set up READ_FCF SLI4_CONFIG mailbox-ioctl command */
+        alloc_len = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
+                        LPFC_MBOX_OPCODE_FCOE_READ_FCF_TABLE, req_len,
+                        LPFC_SLI4_MBX_NEMBED);
+
+        if (alloc_len < req_len) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+                                "0291 Allocated DMA memory size (x%x) is "
+                                "less than the requested DMA memory "
+                                "size (x%x)\n", alloc_len, req_len);
+                return -ENOMEM;
+        }
+
+        /* Get the first SGE entry from the non-embedded DMA memory. This
+         * routine only uses a single SGE.
+         */
+        lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
+        phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
+        virt_addr = mboxq->sge_array->addr[0];
+        read_fcf = (struct lpfc_mbx_read_fcf_tbl *)virt_addr;
+
+        /* Set up command fields */
+        bf_set(lpfc_mbx_read_fcf_tbl_indx, &read_fcf->u.request, fcf_index);
+        /* Perform necessary endian conversion */
+        bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
+        lpfc_sli_pcimem_bcopy(bytep, bytep, sizeof(uint32_t));
+
+        return 0;
+}
+
+/**
  * lpfc_request_features: Configure SLI4 REQUEST_FEATURES mailbox
  * @mboxq: pointer to lpfc mbox command.
  *
@@ -1946,13 +2006,14 @@ lpfc_reg_fcfi(struct lpfc_hba *phba, struct lpfcMboxq *mbox)
         bf_set(lpfc_reg_fcfi_rq_id1, reg_fcfi, REG_FCF_INVALID_QID);
         bf_set(lpfc_reg_fcfi_rq_id2, reg_fcfi, REG_FCF_INVALID_QID);
         bf_set(lpfc_reg_fcfi_rq_id3, reg_fcfi, REG_FCF_INVALID_QID);
-        bf_set(lpfc_reg_fcfi_info_index, reg_fcfi, phba->fcf.fcf_indx);
+        bf_set(lpfc_reg_fcfi_info_index, reg_fcfi,
+               phba->fcf.current_rec.fcf_indx);
         /* reg_fcf addr mode is bit wise inverted value of fcf addr_mode */
-        bf_set(lpfc_reg_fcfi_mam, reg_fcfi,
-                (~phba->fcf.addr_mode) & 0x3);
-        if (phba->fcf.fcf_flag & FCF_VALID_VLAN) {
+        bf_set(lpfc_reg_fcfi_mam, reg_fcfi, (~phba->fcf.addr_mode) & 0x3);
+        if (phba->fcf.current_rec.vlan_id != 0xFFFF) {
                 bf_set(lpfc_reg_fcfi_vv, reg_fcfi, 1);
-                bf_set(lpfc_reg_fcfi_vlan_tag, reg_fcfi, phba->fcf.vlan_id);
+                bf_set(lpfc_reg_fcfi_vlan_tag, reg_fcfi,
+                       phba->fcf.current_rec.vlan_id);
         }
 }
 
@@ -1992,3 +2053,41 @@ lpfc_resume_rpi(struct lpfcMboxq *mbox, struct lpfc_nodelist *ndlp)
         bf_set(lpfc_resume_rpi_ii, resume_rpi, RESUME_INDEX_RPI);
         resume_rpi->event_tag = ndlp->phba->fc_eventTag;
 }
+
+/**
+ * lpfc_supported_pages - Initialize the PORT_CAPABILITIES supported pages
+ *                        mailbox command.
+ * @mbox: pointer to lpfc mbox command to initialize.
+ *
+ * The PORT_CAPABILITIES supported pages mailbox command is issued to
+ * retrieve the particular feature pages supported by the port.
+ **/
+void
+lpfc_supported_pages(struct lpfcMboxq *mbox)
+{
+        struct lpfc_mbx_supp_pages *supp_pages;
+
+        memset(mbox, 0, sizeof(*mbox));
+        supp_pages = &mbox->u.mqe.un.supp_pages;
+        bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_PORT_CAPABILITIES);
+        bf_set(cpn, supp_pages, LPFC_SUPP_PAGES);
+}
+
+/**
+ * lpfc_sli4_params - Initialize the PORT_CAPABILITIES SLI4 Params
+ *                    mailbox command.
+ * @mbox: pointer to lpfc mbox command to initialize.
+ *
+ * The PORT_CAPABILITIES SLI4 parameters mailbox command is issued to
+ * retrieve the particular SLI4 features supported by the port.
+ **/
+void
+lpfc_sli4_params(struct lpfcMboxq *mbox)
+{
+        struct lpfc_mbx_sli4_params *sli4_params;
+
+        memset(mbox, 0, sizeof(*mbox));
+        sli4_params = &mbox->u.mqe.un.sli4_params;
+        bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_PORT_CAPABILITIES);
+        bf_set(cpn, sli4_params, LPFC_SLI4_PARAMETERS);
+}
diff --git a/drivers/scsi/lpfc/lpfc_nl.h b/drivers/scsi/lpfc/lpfc_nl.h
index d655ed3eebef..f3cfbe2ce986 100644
--- a/drivers/scsi/lpfc/lpfc_nl.h
+++ b/drivers/scsi/lpfc/lpfc_nl.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2008 Emulex.  All rights reserved.                *
+ * Copyright (C) 2010 Emulex.  All rights reserved.                *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -177,23 +177,3 @@ struct temp_event {
         uint32_t data;
 };
 
-/* bsg definitions */
-#define LPFC_BSG_VENDOR_SET_CT_EVENT    1
-#define LPFC_BSG_VENDOR_GET_CT_EVENT    2
-
-struct set_ct_event {
-        uint32_t command;
-        uint32_t ev_req_id;
-        uint32_t ev_reg_id;
-};
-
-struct get_ct_event {
-        uint32_t command;
-        uint32_t ev_reg_id;
-        uint32_t ev_req_id;
-};
-
-struct get_ct_event_reply {
-        uint32_t immed_data;
-        uint32_t type;
-};
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index 2ed6af194932..d20ae6b3b3cf 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -62,7 +62,7 @@ lpfc_check_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
 
 int
 lpfc_check_sparm(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
-                 struct serv_parm * sp, uint32_t class)
+                 struct serv_parm *sp, uint32_t class, int flogi)
 {
         volatile struct serv_parm *hsp = &vport->fc_sparam;
         uint16_t hsp_value, ssp_value = 0;
@@ -75,49 +75,56 @@ lpfc_check_sparm(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
          * correcting the byte values.
          */
         if (sp->cls1.classValid) {
-                hsp_value = (hsp->cls1.rcvDataSizeMsb << 8) |
-                                hsp->cls1.rcvDataSizeLsb;
-                ssp_value = (sp->cls1.rcvDataSizeMsb << 8) |
-                                sp->cls1.rcvDataSizeLsb;
-                if (!ssp_value)
-                        goto bad_service_param;
-                if (ssp_value > hsp_value) {
-                        sp->cls1.rcvDataSizeLsb = hsp->cls1.rcvDataSizeLsb;
-                        sp->cls1.rcvDataSizeMsb = hsp->cls1.rcvDataSizeMsb;
+                if (!flogi) {
+                        hsp_value = ((hsp->cls1.rcvDataSizeMsb << 8) |
+                                     hsp->cls1.rcvDataSizeLsb);
+                        ssp_value = ((sp->cls1.rcvDataSizeMsb << 8) |
+                                     sp->cls1.rcvDataSizeLsb);
+                        if (!ssp_value)
+                                goto bad_service_param;
+                        if (ssp_value > hsp_value) {
+                                sp->cls1.rcvDataSizeLsb =
+                                        hsp->cls1.rcvDataSizeLsb;
+                                sp->cls1.rcvDataSizeMsb =
+                                        hsp->cls1.rcvDataSizeMsb;
+                        }
                 }
-        } else if (class == CLASS1) {
+        } else if (class == CLASS1)
                 goto bad_service_param;
-        }
-
         if (sp->cls2.classValid) {
-                hsp_value = (hsp->cls2.rcvDataSizeMsb << 8) |
-                                hsp->cls2.rcvDataSizeLsb;
-                ssp_value = (sp->cls2.rcvDataSizeMsb << 8) |
-                                sp->cls2.rcvDataSizeLsb;
-                if (!ssp_value)
-                        goto bad_service_param;
-                if (ssp_value > hsp_value) {
-                        sp->cls2.rcvDataSizeLsb = hsp->cls2.rcvDataSizeLsb;
-                        sp->cls2.rcvDataSizeMsb = hsp->cls2.rcvDataSizeMsb;
+                if (!flogi) {
+                        hsp_value = ((hsp->cls2.rcvDataSizeMsb << 8) |
+                                     hsp->cls2.rcvDataSizeLsb);
+                        ssp_value = ((sp->cls2.rcvDataSizeMsb << 8) |
+                                     sp->cls2.rcvDataSizeLsb);
+                        if (!ssp_value)
+                                goto bad_service_param;
+                        if (ssp_value > hsp_value) {
+                                sp->cls2.rcvDataSizeLsb =
+                                        hsp->cls2.rcvDataSizeLsb;
+                                sp->cls2.rcvDataSizeMsb =
+                                        hsp->cls2.rcvDataSizeMsb;
+                        }
                 }
-        } else if (class == CLASS2) {
+        } else if (class == CLASS2)
                 goto bad_service_param;
-        }
-
         if (sp->cls3.classValid) {
-                hsp_value = (hsp->cls3.rcvDataSizeMsb << 8) |
-                                hsp->cls3.rcvDataSizeLsb;
-                ssp_value = (sp->cls3.rcvDataSizeMsb << 8) |
-                                sp->cls3.rcvDataSizeLsb;
-                if (!ssp_value)
-                        goto bad_service_param;
-                if (ssp_value > hsp_value) {
-                        sp->cls3.rcvDataSizeLsb = hsp->cls3.rcvDataSizeLsb;
-                        sp->cls3.rcvDataSizeMsb = hsp->cls3.rcvDataSizeMsb;
+                if (!flogi) {
+                        hsp_value = ((hsp->cls3.rcvDataSizeMsb << 8) |
+                                     hsp->cls3.rcvDataSizeLsb);
+                        ssp_value = ((sp->cls3.rcvDataSizeMsb << 8) |
+                                     sp->cls3.rcvDataSizeLsb);
+                        if (!ssp_value)
+                                goto bad_service_param;
+                        if (ssp_value > hsp_value) {
+                                sp->cls3.rcvDataSizeLsb =
+                                        hsp->cls3.rcvDataSizeLsb;
+                                sp->cls3.rcvDataSizeMsb =
+                                        hsp->cls3.rcvDataSizeMsb;
+                        }
                 }
-        } else if (class == CLASS3) {
+        } else if (class == CLASS3)
                 goto bad_service_param;
-        }
 
         /*
          * Preserve the upper four bits of the MSB from the PLOGI response.
@@ -247,7 +254,7 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         int rc;
 
         memset(&stat, 0, sizeof (struct ls_rjt));
-        if (vport->port_state <= LPFC_FLOGI) {
+        if (vport->port_state <= LPFC_FDISC) {
                 /* Before responding to PLOGI, check for pt2pt mode.
                  * If we are pt2pt, with an outstanding FLOGI, abort
                  * the FLOGI and resend it first.
@@ -295,7 +302,7 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                         NULL);
                 return 0;
         }
-        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3) == 0)) {
+        if ((lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0) == 0)) {
                 /* Reject this request because invalid parameters */
                 stat.un.b.lsRjtRsnCode = LSRJT_UNABLE_TPC;
                 stat.un.b.lsRjtRsnCodeExp = LSEXP_SPARM_OPTIONS;
@@ -831,7 +838,7 @@ lpfc_cmpl_plogi_plogi_issue(struct lpfc_vport *vport,
                                  "0142 PLOGI RSP: Invalid WWN.\n");
                 goto out;
         }
-        if (!lpfc_check_sparm(vport, ndlp, sp, CLASS3))
+        if (!lpfc_check_sparm(vport, ndlp, sp, CLASS3, 0))
                 goto out;
         /* PLOGI chkparm OK */
         lpfc_printf_vlog(vport, KERN_INFO, LOG_ELS,
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index a246410ce9df..7f21b47db791 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -626,6 +626,7 @@ lpfc_sli4_fcp_xri_aborted(struct lpfc_hba *phba,
                 &phba->sli4_hba.lpfc_abts_scsi_buf_list, list) {
                 if (psb->cur_iocbq.sli4_xritag == xri) {
                         list_del(&psb->list);
+                        psb->exch_busy = 0;
                         psb->status = IOSTAT_SUCCESS;
                         spin_unlock_irqrestore(
                                 &phba->sli4_hba.abts_scsi_buf_list_lock,
@@ -688,11 +689,12 @@ lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
                                          list);
                         if (status) {
                                 /* Put this back on the abort scsi list */
-                                psb->status = IOSTAT_LOCAL_REJECT;
-                                psb->result = IOERR_ABORT_REQUESTED;
+                                psb->exch_busy = 1;
                                 rc++;
-                        } else
+                        } else {
+                                psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                        }
                         /* Put it back into the SCSI buffer list */
                         lpfc_release_scsi_buf_s4(phba, psb);
                 }
@@ -796,19 +798,17 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                  */
                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_cmd));
                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_cmd));
-                bf_set(lpfc_sli4_sge_len, sgl, sizeof(struct fcp_cmnd));
                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                 sgl->word2 = cpu_to_le32(sgl->word2);
-                sgl->word3 = cpu_to_le32(sgl->word3);
+                sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd));
                 sgl++;
 
                 /* Setup the physical region for the FCP RSP */
                 sgl->addr_hi = cpu_to_le32(putPaddrHigh(pdma_phys_fcp_rsp));
                 sgl->addr_lo = cpu_to_le32(putPaddrLow(pdma_phys_fcp_rsp));
-                bf_set(lpfc_sli4_sge_len, sgl, sizeof(struct fcp_rsp));
                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                 sgl->word2 = cpu_to_le32(sgl->word2);
-                sgl->word3 = cpu_to_le32(sgl->word3);
+                sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp));
 
                 /*
                  * Since the IOCB for the FCP I/O is built into this
@@ -839,11 +839,12 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                                                 psb->cur_iocbq.sli4_xritag);
                         if (status) {
                                 /* Put this back on the abort scsi list */
-                                psb->status = IOSTAT_LOCAL_REJECT;
-                                psb->result = IOERR_ABORT_REQUESTED;
+                                psb->exch_busy = 1;
                                 rc++;
-                        } else
+                        } else {
+                                psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                        }
                         /* Put it back into the SCSI buffer list */
                         lpfc_release_scsi_buf_s4(phba, psb);
                         break;
@@ -857,11 +858,12 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                                  list);
                         if (status) {
                                 /* Put this back on the abort scsi list */
-                                psb->status = IOSTAT_LOCAL_REJECT;
-                                psb->result = IOERR_ABORT_REQUESTED;
+                                psb->exch_busy = 1;
                                 rc++;
-                        } else
+                        } else {
+                                psb->exch_busy = 0;
                                 psb->status = IOSTAT_SUCCESS;
+                        }
                         /* Put it back into the SCSI buffer list */
                         lpfc_release_scsi_buf_s4(phba, psb);
                 }
@@ -951,8 +953,7 @@ lpfc_release_scsi_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *psb)
 {
         unsigned long iflag = 0;
 
-        if (psb->status == IOSTAT_LOCAL_REJECT
-                && psb->result == IOERR_ABORT_REQUESTED) {
+        if (psb->exch_busy) {
                 spin_lock_irqsave(&phba->sli4_hba.abts_scsi_buf_list_lock,
                                         iflag);
                 psb->pCmd = NULL;
@@ -1869,7 +1870,6 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                 scsi_for_each_sg(scsi_cmnd, sgel, nseg, num_bde) {
                         physaddr = sg_dma_address(sgel);
                         dma_len = sg_dma_len(sgel);
-                        bf_set(lpfc_sli4_sge_len, sgl, sg_dma_len(sgel));
                         sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
                         sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
                         if ((num_bde + 1) == nseg)
@@ -1878,7 +1878,7 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                         bf_set(lpfc_sli4_sge_offset, sgl, dma_offset);
                         sgl->word2 = cpu_to_le32(sgl->word2);
-                        sgl->word3 = cpu_to_le32(sgl->word3);
+                        sgl->sge_len = cpu_to_le32(dma_len);
                         dma_offset += dma_len;
                         sgl++;
                 }
@@ -2221,6 +2221,9 @@ lpfc_scsi_cmd_iocb_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *pIocbIn,
 
         lpfc_cmd->result = pIocbOut->iocb.un.ulpWord[4];
         lpfc_cmd->status = pIocbOut->iocb.ulpStatus;
+        /* pick up SLI4 exhange busy status from HBA */
+        lpfc_cmd->exch_busy = pIocbOut->iocb_flag & LPFC_EXCHANGE_BUSY;
+
         if (pnode && NLP_CHK_NODE_ACT(pnode))
                 atomic_dec(&pnode->cmd_pending);
 
@@ -2637,6 +2640,7 @@ lpfc_scsi_api_table_setup(struct lpfc_hba *phba, uint8_t dev_grp)
         }
         phba->lpfc_get_scsi_buf = lpfc_get_scsi_buf;
         phba->lpfc_rampdown_queue_depth = lpfc_rampdown_queue_depth;
+        phba->lpfc_scsi_cmd_iocb_cmpl = lpfc_scsi_cmd_iocb_cmpl;
         return 0;
 }
 
@@ -2695,6 +2699,13 @@ lpfc_info(struct Scsi_Host *host)
                                  " port %s",
                                  phba->Port);
                 }
+                len = strlen(lpfcinfobuf);
+                if (phba->sli4_hba.link_state.logical_speed) {
+                        snprintf(lpfcinfobuf + len,
+                                 384-len,
+                                 " Logical Link Speed: %d Mbps",
+                                 phba->sli4_hba.link_state.logical_speed * 10);
+                }
         }
         return lpfcinfobuf;
 }
@@ -2990,6 +3001,7 @@ lpfc_abort_handler(struct scsi_cmnd *cmnd)
 
         /* ABTS WQE must go to the same WQ as the WQE to be aborted */
         abtsiocb->fcp_wqidx = iocb->fcp_wqidx;
+        abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
 
         if (lpfc_is_link_up(phba))
                 icmd->ulpCommand = CMD_ABORT_XRI_CN;
diff --git a/drivers/scsi/lpfc/lpfc_scsi.h b/drivers/scsi/lpfc/lpfc_scsi.h
index 65dfc8bd5b49..5932273870a5 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.h
+++ b/drivers/scsi/lpfc/lpfc_scsi.h
@@ -118,6 +118,7 @@ struct lpfc_scsi_buf {
 
         uint32_t timeout;
 
+        uint16_t exch_busy;     /* SLI4 hba reported XB on complete WCQE */
         uint16_t status;        /* From IOCB Word 7- ulpStatus */
         uint32_t result;        /* From IOCB Word 4. */
 
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 589549b2bf0e..35e3b96d4e07 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -580,10 +580,7 @@ __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
         else
                 sglq = __lpfc_clear_active_sglq(phba, iocbq->sli4_xritag);
         if (sglq)  {
-                if (iocbq->iocb_flag & LPFC_DRIVER_ABORTED
-                        && ((iocbq->iocb.ulpStatus == IOSTAT_LOCAL_REJECT)
-                        && (iocbq->iocb.un.ulpWord[4]
-                                == IOERR_ABORT_REQUESTED))) {
+                if (iocbq->iocb_flag & LPFC_EXCHANGE_BUSY) {
                         spin_lock_irqsave(&phba->sli4_hba.abts_sgl_list_lock,
                                         iflag);
                         list_add(&sglq->list,
@@ -764,10 +761,6 @@ lpfc_sli_iocb_cmd_type(uint8_t iocb_cmnd)
         case DSSCMD_IWRITE64_CX:
         case DSSCMD_IREAD64_CR:
         case DSSCMD_IREAD64_CX:
-        case DSSCMD_INVALIDATE_DEK:
-        case DSSCMD_SET_KEK:
-        case DSSCMD_GET_KEK_ID:
-        case DSSCMD_GEN_XFER:
                 type = LPFC_SOL_IOCB;
                 break;
         case CMD_ABORT_XRI_CN:
@@ -1717,6 +1710,7 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         struct lpfc_dmabuf *mp;
         uint16_t rpi, vpi;
         int rc;
+        struct lpfc_vport  *vport = pmb->vport;
 
         mp = (struct lpfc_dmabuf *) (pmb->context1);
 
@@ -1745,6 +1739,18 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                         return;
         }
 
+        /* Unreg VPI, if the REG_VPI succeed after VLink failure */
+        if ((pmb->u.mb.mbxCommand == MBX_REG_VPI) &&
+                !(phba->pport->load_flag & FC_UNLOADING) &&
+                !pmb->u.mb.mbxStatus) {
+                lpfc_unreg_vpi(phba, pmb->u.mb.un.varRegVpi.vpi, pmb);
+                pmb->vport = vport;
+                pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+                rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
+                if (rc != MBX_NOT_FINISHED)
+                        return;
+        }
+
         if (bf_get(lpfc_mqe_command, &pmb->u.mqe) == MBX_SLI4_CONFIG)
                 lpfc_sli4_mbox_cmd_free(phba, pmb);
         else
@@ -2228,9 +2234,15 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                          * All other are passed to the completion callback.
                          */
                         if (pring->ringno == LPFC_ELS_RING) {
-                                if (cmdiocbp->iocb_flag & LPFC_DRIVER_ABORTED) {
+                                if ((phba->sli_rev < LPFC_SLI_REV4) &&
+                                    (cmdiocbp->iocb_flag &
+                                                        LPFC_DRIVER_ABORTED)) {
+                                        spin_lock_irqsave(&phba->hbalock,
+                                                          iflag);
                                         cmdiocbp->iocb_flag &=
                                                 ~LPFC_DRIVER_ABORTED;
+                                        spin_unlock_irqrestore(&phba->hbalock,
+                                                               iflag);
                                         saveq->iocb.ulpStatus =
                                                 IOSTAT_LOCAL_REJECT;
                                         saveq->iocb.un.ulpWord[4] =
@@ -2240,7 +2252,47 @@ lpfc_sli_process_sol_iocb(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                                          * of DMAing payload, so don't free data
                                          * buffer till after a hbeat.
                                          */
+                                        spin_lock_irqsave(&phba->hbalock,
+                                                          iflag);
                                         saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
+                                        spin_unlock_irqrestore(&phba->hbalock,
+                                                               iflag);
+                                }
+                                if ((phba->sli_rev == LPFC_SLI_REV4) &&
+                                    (saveq->iocb_flag & LPFC_EXCHANGE_BUSY)) {
+                                        /* Set cmdiocb flag for the exchange
+                                         * busy so sgl (xri) will not be
+                                         * released until the abort xri is
+                                         * received from hba, clear the
+                                         * LPFC_DRIVER_ABORTED bit in case
+                                         * it was driver initiated abort.
+                                         */
+                                        spin_lock_irqsave(&phba->hbalock,
+                                                          iflag);
+                                        cmdiocbp->iocb_flag &=
+                                                ~LPFC_DRIVER_ABORTED;
+                                        cmdiocbp->iocb_flag |=
+                                                LPFC_EXCHANGE_BUSY;
+                                        spin_unlock_irqrestore(&phba->hbalock,
+                                                               iflag);
+                                        cmdiocbp->iocb.ulpStatus =
+                                                IOSTAT_LOCAL_REJECT;
+                                        cmdiocbp->iocb.un.ulpWord[4] =
+                                                IOERR_ABORT_REQUESTED;
+                                        /*
+                                         * For SLI4, irsiocb contains NO_XRI
+                                         * in sli_xritag, it shall not affect
+                                         * releasing sgl (xri) process.
+                                         */
+                                        saveq->iocb.ulpStatus =
+                                                IOSTAT_LOCAL_REJECT;
+                                        saveq->iocb.un.ulpWord[4] =
+                                                IOERR_SLI_ABORTED;
+                                        spin_lock_irqsave(&phba->hbalock,
+                                                          iflag);
+                                        saveq->iocb_flag |= LPFC_DELAY_MEM_FREE;
+                                        spin_unlock_irqrestore(&phba->hbalock,
+                                                               iflag);
                                 }
                         }
                         (cmdiocbp->iocb_cmpl) (phba, cmdiocbp, saveq);
@@ -5687,19 +5739,19 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
 
                 for (i = 0; i < numBdes; i++) {
                         /* Should already be byte swapped. */
-                        sgl->addr_hi =  bpl->addrHigh;
-                        sgl->addr_lo =  bpl->addrLow;
-                        /* swap the size field back to the cpu so we
-                         * can assign it to the sgl.
-                         */
-                        bde.tus.w  = le32_to_cpu(bpl->tus.w);
-                        bf_set(lpfc_sli4_sge_len, sgl, bde.tus.f.bdeSize);
+                        sgl->addr_hi = bpl->addrHigh;
+                        sgl->addr_lo = bpl->addrLow;
+
                         if ((i+1) == numBdes)
                                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                         else
                                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                         sgl->word2 = cpu_to_le32(sgl->word2);
-                        sgl->word3 = cpu_to_le32(sgl->word3);
+                        /* swap the size field back to the cpu so we
+                         * can assign it to the sgl.
+                         */
+                        bde.tus.w = le32_to_cpu(bpl->tus.w);
+                        sgl->sge_len = cpu_to_le32(bde.tus.f.bdeSize);
                         bpl++;
                         sgl++;
                 }
@@ -5712,11 +5764,10 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
                                 cpu_to_le32(icmd->un.genreq64.bdl.addrHigh);
                         sgl->addr_lo =
                                 cpu_to_le32(icmd->un.genreq64.bdl.addrLow);
-                        bf_set(lpfc_sli4_sge_len, sgl,
-                                icmd->un.genreq64.bdl.bdeSize);
                         bf_set(lpfc_sli4_sge_last, sgl, 1);
                         sgl->word2 = cpu_to_le32(sgl->word2);
-                        sgl->word3 = cpu_to_le32(sgl->word3);
+                        sgl->sge_len =
+                                cpu_to_le32(icmd->un.genreq64.bdl.bdeSize);
         }
         return sglq->sli4_xritag;
 }
@@ -5987,12 +6038,10 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 else
                         bf_set(abort_cmd_ia, &wqe->abort_cmd, 0);
                 bf_set(abort_cmd_criteria, &wqe->abort_cmd, T_XRI_TAG);
-                abort_tag = iocbq->iocb.un.acxri.abortIoTag;
                 wqe->words[5] = 0;
                 bf_set(lpfc_wqe_gen_ct, &wqe->generic,
                         ((iocbq->iocb.ulpCt_h << 1) | iocbq->iocb.ulpCt_l));
                 abort_tag = iocbq->iocb.un.acxri.abortIoTag;
-                wqe->generic.abort_tag = abort_tag;
                 /*
                  * The abort handler will send us CMD_ABORT_XRI_CN or
                  * CMD_CLOSE_XRI_CN and the fw only accepts CMD_ABORT_XRI_CX
@@ -6121,15 +6170,15 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
         if (lpfc_sli4_iocb2wqe(phba, piocb, &wqe))
                 return IOCB_ERROR;
 
-        if (piocb->iocb_flag &  LPFC_IO_FCP) {
+        if ((piocb->iocb_flag & LPFC_IO_FCP) ||
+                (piocb->iocb_flag & LPFC_USE_FCPWQIDX)) {
                 /*
                  * For FCP command IOCB, get a new WQ index to distribute
                  * WQE across the WQsr. On the other hand, for abort IOCB,
                  * it carries the same WQ index to the original command
                  * IOCB.
                  */
-                if ((piocb->iocb.ulpCommand != CMD_ABORT_XRI_CN) &&
-                    (piocb->iocb.ulpCommand != CMD_CLOSE_XRI_CN))
+                if (piocb->iocb_flag & LPFC_IO_FCP)
                         piocb->fcp_wqidx = lpfc_sli4_scmd_to_wqidx_distr(phba);
                 if (lpfc_sli4_wq_put(phba->sli4_hba.fcp_wq[piocb->fcp_wqidx],
                                      &wqe))
@@ -7004,7 +7053,14 @@ lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                     abort_iocb->iocb.ulpContext != abort_context ||
                     (abort_iocb->iocb_flag & LPFC_DRIVER_ABORTED) == 0)
                         spin_unlock_irq(&phba->hbalock);
-                else {
+                else if (phba->sli_rev < LPFC_SLI_REV4) {
+                        /*
+                         * leave the SLI4 aborted command on the txcmplq
+                         * list and the command complete WCQE's XB bit
+                         * will tell whether the SGL (XRI) can be released
+                         * immediately or to the aborted SGL list for the
+                         * following abort XRI from the HBA.
+                         */
                         list_del_init(&abort_iocb->list);
                         pring->txcmplq_cnt--;
                         spin_unlock_irq(&phba->hbalock);
@@ -7013,11 +7069,13 @@ lpfc_sli_abort_els_cmpl(struct lpfc_hba *phba, struct lpfc_iocbq *cmdiocb,
                          * payload, so don't free data buffer till after
                          * a hbeat.
                          */
+                        spin_lock_irq(&phba->hbalock);
                         abort_iocb->iocb_flag |= LPFC_DELAY_MEM_FREE;
-
                         abort_iocb->iocb_flag &= ~LPFC_DRIVER_ABORTED;
+                        spin_unlock_irq(&phba->hbalock);
+
                         abort_iocb->iocb.ulpStatus = IOSTAT_LOCAL_REJECT;
-                        abort_iocb->iocb.un.ulpWord[4] = IOERR_SLI_ABORTED;
+                        abort_iocb->iocb.un.ulpWord[4] = IOERR_ABORT_REQUESTED;
                         (abort_iocb->iocb_cmpl)(phba, abort_iocb, abort_iocb);
                 }
         }
@@ -7106,7 +7164,7 @@ lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                 return 0;
 
         /* This signals the response to set the correct status
-         * before calling the completion handler.
+         * before calling the completion handler
          */
         cmdiocb->iocb_flag |= LPFC_DRIVER_ABORTED;
 
@@ -7124,6 +7182,8 @@ lpfc_sli_issue_abort_iotag(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
 
         /* ABTS WQE must go to the same WQ as the WQE to be aborted */
         abtsiocbp->fcp_wqidx = cmdiocb->fcp_wqidx;
+        if (cmdiocb->iocb_flag & LPFC_IO_FCP)
+                abtsiocbp->iocb_flag |= LPFC_USE_FCPWQIDX;
 
         if (phba->link_state >= LPFC_LINK_UP)
                 iabt->ulpCommand = CMD_ABORT_XRI_CN;
@@ -7330,6 +7390,8 @@ lpfc_sli_abort_iocb(struct lpfc_vport *vport, struct lpfc_sli_ring *pring,
 
                 /* ABTS WQE must go to the same WQ as the WQE to be aborted */
                 abtsiocb->fcp_wqidx = iocbq->fcp_wqidx;
+                if (iocbq->iocb_flag & LPFC_IO_FCP)
+                        abtsiocb->iocb_flag |= LPFC_USE_FCPWQIDX;
 
                 if (lpfc_is_link_up(phba))
                         abtsiocb->iocb.ulpCommand = CMD_ABORT_XRI_CN;
@@ -8359,11 +8421,24 @@ void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *phba)
         }
 }
 
+/**
+ * lpfc_sli4_iocb_param_transfer - Transfer pIocbOut and cmpl status to pIocbIn
+ * @phba: pointer to lpfc hba data structure
+ * @pIocbIn: pointer to the rspiocbq
+ * @pIocbOut: pointer to the cmdiocbq
+ * @wcqe: pointer to the complete wcqe
+ *
+ * This routine transfers the fields of a command iocbq to a response iocbq
+ * by copying all the IOCB fields from command iocbq and transferring the
+ * completion status information from the complete wcqe.
+ **/
 static void
-lpfc_sli4_iocb_param_transfer(struct lpfc_iocbq *pIocbIn,
+lpfc_sli4_iocb_param_transfer(struct lpfc_hba *phba,
+                              struct lpfc_iocbq *pIocbIn,
                               struct lpfc_iocbq *pIocbOut,
                               struct lpfc_wcqe_complete *wcqe)
 {
+        unsigned long iflags;
         size_t offset = offsetof(struct lpfc_iocbq, iocb);
 
         memcpy((char *)pIocbIn + offset, (char *)pIocbOut + offset,
@@ -8377,8 +8452,17 @@ lpfc_sli4_iocb_param_transfer(struct lpfc_iocbq *pIocbIn,
                                         wcqe->total_data_placed;
                 else
                         pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
-        else
+        else {
                 pIocbIn->iocb.un.ulpWord[4] = wcqe->parameter;
+                pIocbIn->iocb.un.genreq64.bdl.bdeSize = wcqe->total_data_placed;
+        }
+
+        /* Pick up HBA exchange busy condition */
+        if (bf_get(lpfc_wcqe_c_xb, wcqe)) {
+                spin_lock_irqsave(&phba->hbalock, iflags);
+                pIocbIn->iocb_flag |= LPFC_EXCHANGE_BUSY;
+                spin_unlock_irqrestore(&phba->hbalock, iflags);
+        }
 }
 
 /**
@@ -8419,7 +8503,7 @@ lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *phba,
         }
 
         /* Fake the irspiocbq and copy necessary response information */
-        lpfc_sli4_iocb_param_transfer(irspiocbq, cmdiocbq, wcqe);
+        lpfc_sli4_iocb_param_transfer(phba, irspiocbq, cmdiocbq, wcqe);
 
         return irspiocbq;
 }
@@ -8849,8 +8933,7 @@ lpfc_sli4_sp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe)
         int ecount = 0;
         uint16_t cqid;
 
-        if (bf_get(lpfc_eqe_major_code, eqe) != 0 ||
-            bf_get(lpfc_eqe_minor_code, eqe) != 0) {
+        if (bf_get(lpfc_eqe_major_code, eqe) != 0) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0359 Not a valid slow-path completion "
                                 "event: majorcode=x%x, minorcode=x%x\n",
@@ -8976,7 +9059,7 @@ lpfc_sli4_fp_handle_fcp_wcqe(struct lpfc_hba *phba,
         }
 
         /* Fake the irspiocb and copy necessary response information */
-        lpfc_sli4_iocb_param_transfer(&irspiocbq, cmdiocbq, wcqe);
+        lpfc_sli4_iocb_param_transfer(phba, &irspiocbq, cmdiocbq, wcqe);
 
         /* Pass the cmd_iocb and the rsp state to the upper layer */
         (cmdiocbq->iocb_cmpl)(phba, cmdiocbq, &irspiocbq);
@@ -9082,8 +9165,7 @@ lpfc_sli4_fp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe,
         uint16_t cqid;
         int ecount = 0;
 
-        if (unlikely(bf_get(lpfc_eqe_major_code, eqe) != 0) ||
-            unlikely(bf_get(lpfc_eqe_minor_code, eqe) != 0)) {
+        if (unlikely(bf_get(lpfc_eqe_major_code, eqe) != 0)) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0366 Not a valid fast-path completion "
                                 "event: majorcode=x%x, minorcode=x%x\n",
@@ -11871,12 +11953,6 @@ lpfc_sli4_read_fcf_record(struct lpfc_hba *phba, uint16_t fcf_index)
 {
         int rc = 0, error;
         LPFC_MBOXQ_t *mboxq;
-        void *virt_addr;
-        dma_addr_t phys_addr;
-        uint8_t *bytep;
-        struct lpfc_mbx_sge sge;
-        uint32_t alloc_len, req_len;
-        struct lpfc_mbx_read_fcf_tbl *read_fcf;
 
         phba->fcoe_eventtag_at_fcf_scan = phba->fcoe_eventtag;
         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
@@ -11887,43 +11963,19 @@ lpfc_sli4_read_fcf_record(struct lpfc_hba *phba, uint16_t fcf_index)
                 error = -ENOMEM;
                 goto fail_fcfscan;
         }
-
-        req_len = sizeof(struct fcf_record) +
-                  sizeof(union lpfc_sli4_cfg_shdr) + 2 * sizeof(uint32_t);
-
-        /* Set up READ_FCF SLI4_CONFIG mailbox-ioctl command */
-        alloc_len = lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
-                         LPFC_MBOX_OPCODE_FCOE_READ_FCF_TABLE, req_len,
-                         LPFC_SLI4_MBX_NEMBED);
-
-        if (alloc_len < req_len) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "0291 Allocated DMA memory size (x%x) is "
-                                "less than the requested DMA memory "
-                                "size (x%x)\n", alloc_len, req_len);
-                error = -ENOMEM;
+        /* Construct the read FCF record mailbox command */
+        rc = lpfc_sli4_mbx_read_fcf_record(phba, mboxq, fcf_index);
+        if (rc) {
+                error = -EINVAL;
                 goto fail_fcfscan;
         }
-
-        /* Get the first SGE entry from the non-embedded DMA memory. This
-         * routine only uses a single SGE.
-         */
-        lpfc_sli4_mbx_sge_get(mboxq, 0, &sge);
-        phys_addr = getPaddr(sge.pa_hi, sge.pa_lo);
-        virt_addr = mboxq->sge_array->addr[0];
-        read_fcf = (struct lpfc_mbx_read_fcf_tbl *)virt_addr;
-
-        /* Set up command fields */
-        bf_set(lpfc_mbx_read_fcf_tbl_indx, &read_fcf->u.request, fcf_index);
-        /* Perform necessary endian conversion */
-        bytep = virt_addr + sizeof(union lpfc_sli4_cfg_shdr);
-        lpfc_sli_pcimem_bcopy(bytep, bytep, sizeof(uint32_t));
+        /* Issue the mailbox command asynchronously */
         mboxq->vport = phba->pport;
         mboxq->mbox_cmpl = lpfc_mbx_cmpl_read_fcf_record;
         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_NOWAIT);
-        if (rc == MBX_NOT_FINISHED) {
+        if (rc == MBX_NOT_FINISHED)
                 error = -EIO;
-        } else {
+        else {
                 spin_lock_irq(&phba->hbalock);
                 phba->hba_flag |= FCF_DISC_INPROGRESS;
                 spin_unlock_irq(&phba->hbalock);
@@ -11942,6 +11994,90 @@ fail_fcfscan:
 }
 
 /**
+ * lpfc_mbx_cmpl_redisc_fcf_table - completion routine for rediscover FCF table
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is the completion routine for the rediscover FCF table mailbox
+ * command. If the mailbox command returned failure, it will try to stop the
+ * FCF rediscover wait timer.
+ **/
+void
+lpfc_mbx_cmpl_redisc_fcf_table(struct lpfc_hba *phba, LPFC_MBOXQ_t *mbox)
+{
+        struct lpfc_mbx_redisc_fcf_tbl *redisc_fcf;
+        uint32_t shdr_status, shdr_add_status;
+
+        redisc_fcf = &mbox->u.mqe.un.redisc_fcf_tbl;
+
+        shdr_status = bf_get(lpfc_mbox_hdr_status,
+                             &redisc_fcf->header.cfg_shdr.response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                             &redisc_fcf->header.cfg_shdr.response);
+        if (shdr_status || shdr_add_status) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2746 Requesting for FCF rediscovery failed "
+                                "status x%x add_status x%x\n",
+                                shdr_status, shdr_add_status);
+                /*
+                 * Request failed, last resort to re-try current
+                 * registered FCF entry
+                 */
+                lpfc_retry_pport_discovery(phba);
+        } else
+                /*
+                 * Start FCF rediscovery wait timer for pending FCF
+                 * before rescan FCF record table.
+                 */
+                lpfc_fcf_redisc_wait_start_timer(phba);
+
+        mempool_free(mbox, phba->mbox_mem_pool);
+}
+
+/**
+ * lpfc_sli4_redisc_all_fcf - Request to rediscover entire FCF table by port.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to request for rediscovery of the entire FCF table
+ * by the port.
+ **/
+int
+lpfc_sli4_redisc_fcf_table(struct lpfc_hba *phba)
+{
+        LPFC_MBOXQ_t *mbox;
+        struct lpfc_mbx_redisc_fcf_tbl *redisc_fcf;
+        int rc, length;
+
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "2745 Failed to allocate mbox for "
+                                "requesting FCF rediscover.\n");
+                return -ENOMEM;
+        }
+
+        length = (sizeof(struct lpfc_mbx_redisc_fcf_tbl) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
+                         LPFC_MBOX_OPCODE_FCOE_REDISCOVER_FCF,
+                         length, LPFC_SLI4_MBX_EMBED);
+
+        redisc_fcf = &mbox->u.mqe.un.redisc_fcf_tbl;
+        /* Set count to 0 for invalidating the entire FCF database */
+        bf_set(lpfc_mbx_redisc_fcf_count, redisc_fcf, 0);
+
+        /* Issue the mailbox command asynchronously */
+        mbox->vport = phba->pport;
+        mbox->mbox_cmpl = lpfc_mbx_cmpl_redisc_fcf_table;
+        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
+
+        if (rc == MBX_NOT_FINISHED) {
+                mempool_free(mbox, phba->mbox_mem_pool);
+                return -EIO;
+        }
+        return 0;
+}
+
+/**
  * lpfc_sli_read_link_ste - Read region 23 to decide if link is disabled.
  * @phba: pointer to lpfc hba data structure.
  *
@@ -12069,3 +12205,48 @@ out:
         kfree(rgn23_data);
         return;
 }
+
+/**
+ * lpfc_cleanup_pending_mbox - Free up vport discovery mailbox commands.
+ * @vport: pointer to vport data structure.
+ *
+ * This function iterate through the mailboxq and clean up all REG_LOGIN
+ * and REG_VPI mailbox commands associated with the vport. This function
+ * is called when driver want to restart discovery of the vport due to
+ * a Clear Virtual Link event.
+ **/
+void
+lpfc_cleanup_pending_mbox(struct lpfc_vport *vport)
+{
+        struct lpfc_hba *phba = vport->phba;
+        LPFC_MBOXQ_t *mb, *nextmb;
+        struct lpfc_dmabuf *mp;
+
+        spin_lock_irq(&phba->hbalock);
+        list_for_each_entry_safe(mb, nextmb, &phba->sli.mboxq, list) {
+                if (mb->vport != vport)
+                        continue;
+
+                if ((mb->u.mb.mbxCommand != MBX_REG_LOGIN64) &&
+                        (mb->u.mb.mbxCommand != MBX_REG_VPI))
+                        continue;
+
+                if (mb->u.mb.mbxCommand == MBX_REG_LOGIN64) {
+                        mp = (struct lpfc_dmabuf *) (mb->context1);
+                        if (mp) {
+                                __lpfc_mbuf_free(phba, mp->virt, mp->phys);
+                                kfree(mp);
+                        }
+                }
+                list_del(&mb->list);
+                mempool_free(mb, phba->mbox_mem_pool);
+        }
+        mb = phba->sli.mbox_active;
+        if (mb && (mb->vport == vport)) {
+                if ((mb->u.mb.mbxCommand == MBX_REG_LOGIN64) ||
+                        (mb->u.mb.mbxCommand == MBX_REG_VPI))
+                        mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
+        }
+        spin_unlock_irq(&phba->hbalock);
+}
+
diff --git a/drivers/scsi/lpfc/lpfc_sli.h b/drivers/scsi/lpfc/lpfc_sli.h
index ba38de3c28f1..dfcf5437d1f5 100644
--- a/drivers/scsi/lpfc/lpfc_sli.h
+++ b/drivers/scsi/lpfc/lpfc_sli.h
@@ -53,17 +53,19 @@ struct lpfc_iocbq {
 
         IOCB_t iocb;            /* IOCB cmd */
         uint8_t retry;          /* retry counter for IOCB cmd - if needed */
-        uint8_t iocb_flag;
+        uint16_t iocb_flag;
 #define LPFC_IO_LIBDFC          1       /* libdfc iocb */
 #define LPFC_IO_WAKE            2       /* High Priority Queue signal flag */
 #define LPFC_IO_FCP             4       /* FCP command -- iocbq in scsi_buf */
 #define LPFC_DRIVER_ABORTED     8       /* driver aborted this request */
 #define LPFC_IO_FABRIC          0x10    /* Iocb send using fabric scheduler */
 #define LPFC_DELAY_MEM_FREE     0x20    /* Defer free'ing of FC data */
-#define LPFC_FIP_ELS_ID_MASK    0xc0    /* ELS_ID range 0-3 */
-#define LPFC_FIP_ELS_ID_SHIFT   6
+#define LPFC_EXCHANGE_BUSY      0x40    /* SLI4 hba reported XB in response */
+#define LPFC_USE_FCPWQIDX       0x80    /* Submit to specified FCPWQ index */
+
+#define LPFC_FIP_ELS_ID_MASK    0xc000  /* ELS_ID range 0-3, non-shifted mask */
+#define LPFC_FIP_ELS_ID_SHIFT   14
 
-        uint8_t abort_count;
         uint8_t rsvd2;
         uint32_t drvrTimeout;   /* driver timeout in seconds */
         uint32_t fcp_wqidx;     /* index to FCP work queue */
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index 44e5f574236b..86308836600f 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -22,6 +22,10 @@
 #define LPFC_RELEASE_NOTIFICATION_INTERVAL      32
 #define LPFC_GET_QE_REL_INT                     32
 #define LPFC_RPI_LOW_WATER_MARK                 10
+
+/* Amount of time in seconds for waiting FCF rediscovery to complete */
+#define LPFC_FCF_REDISCOVER_WAIT_TMO            2000 /* msec */
+
 /* Number of SGL entries can be posted in a 4KB nonembedded mbox command */
 #define LPFC_NEMBED_MBOX_SGL_CNT                254
 
@@ -126,24 +130,36 @@ struct lpfc_sli4_link {
         uint8_t status;
         uint8_t physical;
         uint8_t fault;
+        uint16_t logical_speed;
 };
 
-struct lpfc_fcf {
-        uint8_t  fabric_name[8];
-        uint8_t  switch_name[8];
+struct lpfc_fcf_rec {
+        uint8_t  fabric_name[8];
+        uint8_t  switch_name[8];
         uint8_t  mac_addr[6];
         uint16_t fcf_indx;
+        uint32_t priority;
+        uint16_t vlan_id;
+        uint32_t addr_mode;
+        uint32_t flag;
+#define BOOT_ENABLE     0x01
+#define RECORD_VALID    0x02
+};
+
+struct lpfc_fcf {
         uint16_t fcfi;
         uint32_t fcf_flag;
 #define FCF_AVAILABLE   0x01 /* FCF available for discovery */
 #define FCF_REGISTERED  0x02 /* FCF registered with FW */
-#define FCF_DISCOVERED  0x04 /* FCF discovery started  */
-#define FCF_BOOT_ENABLE 0x08 /* Boot bios use this FCF */
-#define FCF_IN_USE      0x10 /* Atleast one discovery completed */
-#define FCF_VALID_VLAN  0x20 /* Use the vlan id specified */
-        uint32_t priority;
+#define FCF_SCAN_DONE   0x04 /* FCF table scan done */
+#define FCF_IN_USE      0x08 /* Atleast one discovery completed */
+#define FCF_REDISC_PEND 0x10 /* FCF rediscovery pending */
+#define FCF_REDISC_EVT  0x20 /* FCF rediscovery event to worker thread */
+#define FCF_REDISC_FOV  0x40 /* Post FCF rediscovery fast failover */
         uint32_t addr_mode;
-        uint16_t vlan_id;
+        struct lpfc_fcf_rec current_rec;
+        struct lpfc_fcf_rec failover_rec;
+        struct timer_list redisc_wait;
 };
 
 #define LPFC_REGION23_SIGNATURE "RG23"
@@ -248,7 +264,10 @@ struct lpfc_bmbx {
 #define SLI4_CT_VFI 2
 #define SLI4_CT_FCFI 3
 
-#define LPFC_SLI4_MAX_SEGMENT_SIZE 0x10000
+#define LPFC_SLI4_FL1_MAX_SEGMENT_SIZE  0x10000
+#define LPFC_SLI4_FL1_MAX_BUF_SIZE      0X2000
+#define LPFC_SLI4_MIN_BUF_SIZE          0x400
+#define LPFC_SLI4_MAX_BUF_SIZE          0x20000
 
 /*
  * SLI4 specific data structures
@@ -282,6 +301,42 @@ struct lpfc_fcp_eq_hdl {
         struct lpfc_hba *phba;
 };
 
+/* Port Capabilities for SLI4 Parameters */
+struct lpfc_pc_sli4_params {
+        uint32_t supported;
+        uint32_t if_type;
+        uint32_t sli_rev;
+        uint32_t sli_family;
+        uint32_t featurelevel_1;
+        uint32_t featurelevel_2;
+        uint32_t proto_types;
+#define LPFC_SLI4_PROTO_FCOE    0x0000001
+#define LPFC_SLI4_PROTO_FC      0x0000002
+#define LPFC_SLI4_PROTO_NIC     0x0000004
+#define LPFC_SLI4_PROTO_ISCSI   0x0000008
+#define LPFC_SLI4_PROTO_RDMA    0x0000010
+        uint32_t sge_supp_len;
+        uint32_t if_page_sz;
+        uint32_t rq_db_window;
+        uint32_t loopbk_scope;
+        uint32_t eq_pages_max;
+        uint32_t eqe_size;
+        uint32_t cq_pages_max;
+        uint32_t cqe_size;
+        uint32_t mq_pages_max;
+        uint32_t mqe_size;
+        uint32_t mq_elem_cnt;
+        uint32_t wq_pages_max;
+        uint32_t wqe_size;
+        uint32_t rq_pages_max;
+        uint32_t rqe_size;
+        uint32_t hdr_pages_max;
+        uint32_t hdr_size;
+        uint32_t hdr_pp_align;
+        uint32_t sgl_pages_max;
+        uint32_t sgl_pp_align;
+};
+
 /* SLI4 HBA data structure entries */
 struct lpfc_sli4_hba {
         void __iomem *conf_regs_memmap_p; /* Kernel memory mapped address for
@@ -295,7 +350,7 @@ struct lpfc_sli4_hba {
         void __iomem *UERRHIregaddr; /* Address to UERR_STATUS_HI register */
         void __iomem *UEMASKLOregaddr; /* Address to UE_MASK_LO register */
         void __iomem *UEMASKHIregaddr; /* Address to UE_MASK_HI register */
-        void __iomem *SCRATCHPADregaddr; /* Address to scratchpad register */
+        void __iomem *SLIINTFregaddr; /* Address to SLI_INTF register */
         /* BAR1 FCoE function CSR register memory map */
         void __iomem *STAregaddr;    /* Address to HST_STATE register */
         void __iomem *ISRregaddr;    /* Address to HST_ISR register */
@@ -310,6 +365,8 @@ struct lpfc_sli4_hba {
 
         uint32_t ue_mask_lo;
         uint32_t ue_mask_hi;
+        struct lpfc_register sli_intf;
+        struct lpfc_pc_sli4_params pc_sli4_params;
         struct msix_entry *msix_entries;
         uint32_t cfg_eqn;
         struct lpfc_fcp_eq_hdl *fcp_eq_hdl; /* FCP per-WQ handle */
@@ -406,6 +463,8 @@ void lpfc_sli4_mbox_cmd_free(struct lpfc_hba *, struct lpfcMboxq *);
 void lpfc_sli4_mbx_sge_set(struct lpfcMboxq *, uint32_t, dma_addr_t, uint32_t);
 void lpfc_sli4_mbx_sge_get(struct lpfcMboxq *, uint32_t,
                            struct lpfc_mbx_sge *);
+int lpfc_sli4_mbx_read_fcf_record(struct lpfc_hba *, struct lpfcMboxq *,
+                                  uint16_t);
 
 void lpfc_sli4_hba_reset(struct lpfc_hba *);
 struct lpfc_queue *lpfc_sli4_queue_alloc(struct lpfc_hba *, uint32_t,
@@ -448,6 +507,7 @@ int lpfc_sli4_alloc_rpi(struct lpfc_hba *);
 void lpfc_sli4_free_rpi(struct lpfc_hba *, int);
 void lpfc_sli4_remove_rpis(struct lpfc_hba *);
 void lpfc_sli4_async_event_proc(struct lpfc_hba *);
+void lpfc_sli4_fcf_redisc_event_proc(struct lpfc_hba *);
 int lpfc_sli4_resume_rpi(struct lpfc_nodelist *);
 void lpfc_sli4_fcp_xri_abort_event_proc(struct lpfc_hba *);
 void lpfc_sli4_els_xri_abort_event_proc(struct lpfc_hba *);
diff --git a/drivers/scsi/lpfc/lpfc_version.h b/drivers/scsi/lpfc/lpfc_version.h
index 792f72263f1a..ac276aa46fba 100644
--- a/drivers/scsi/lpfc/lpfc_version.h
+++ b/drivers/scsi/lpfc/lpfc_version.h
@@ -1,7 +1,7 @@
 /*******************************************************************
  * This file is part of the Emulex Linux Device Driver for         *
  * Fibre Channel Host Bus Adapters.                                *
- * Copyright (C) 2004-2009 Emulex.  All rights reserved.           *
+ * Copyright (C) 2004-2010 Emulex.  All rights reserved.           *
  * EMULEX and SLI are trademarks of Emulex.                        *
  * www.emulex.com                                                  *
  *                                                                 *
@@ -18,7 +18,7 @@
  * included with this package.                                     *
  *******************************************************************/
 
-#define LPFC_DRIVER_VERSION "8.3.7"
+#define LPFC_DRIVER_VERSION "8.3.9"
 #define LPFC_DRIVER_NAME                "lpfc"
 #define LPFC_SP_DRIVER_HANDLER_NAME     "lpfc:sp"
 #define LPFC_FP_DRIVER_HANDLER_NAME     "lpfc:fp"
diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
index e3c7fa642306..dc86e873102a 100644
--- a/drivers/scsi/lpfc/lpfc_vport.c
+++ b/drivers/scsi/lpfc/lpfc_vport.c
@@ -389,7 +389,7 @@ lpfc_vport_create(struct fc_vport *fc_vport, bool disable)
          * by the port.
          */
         if ((phba->sli_rev == LPFC_SLI_REV4) &&
-            (pport->vpi_state & LPFC_VPI_REGISTERED)) {
+                (pport->fc_flag & FC_VFI_REGISTERED)) {
                 rc = lpfc_sli4_init_vpi(phba, vpi);
                 if (rc) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_VPORT,
@@ -505,6 +505,7 @@ enable_vport(struct fc_vport *fc_vport)
         struct lpfc_vport *vport = *(struct lpfc_vport **)fc_vport->dd_data;
         struct lpfc_hba   *phba = vport->phba;
         struct lpfc_nodelist *ndlp = NULL;
+        struct Scsi_Host *shost = lpfc_shost_from_vport(vport);
 
         if ((phba->link_state < LPFC_LINK_UP) ||
             (phba->fc_topology == TOPOLOGY_LOOP)) {
@@ -512,10 +513,10 @@ enable_vport(struct fc_vport *fc_vport)
                 return VPORT_OK;
         }
 
-        spin_lock_irq(&phba->hbalock);
+        spin_lock_irq(shost->host_lock);
         vport->load_flag |= FC_LOADING;
         vport->fc_flag |= FC_VPORT_NEEDS_REG_VPI;
-        spin_unlock_irq(&phba->hbalock);
+        spin_unlock_irq(shost->host_lock);
 
         /* Use the Physical nodes Fabric NDLP to determine if the link is
          * up and ready to FDISC.
diff --git a/drivers/scsi/mac_esp.c b/drivers/scsi/mac_esp.c
index c24e86f07804..dd808ae942a1 100644
--- a/drivers/scsi/mac_esp.c
+++ b/drivers/scsi/mac_esp.c
@@ -22,7 +22,6 @@
 
 #include <asm/irq.h>
 #include <asm/dma.h>
-
 #include <asm/macints.h>
 #include <asm/macintosh.h>
 
@@ -279,24 +278,27 @@ static void mac_esp_send_pdma_cmd(struct esp *esp, u32 addr, u32 esp_count,
  * Programmed IO routines follow.
  */
 
-static inline int mac_esp_wait_for_fifo(struct esp *esp)
+static inline unsigned int mac_esp_wait_for_fifo(struct esp *esp)
 {
         int i = 500000;
 
         do {
-                if (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES)
-                        return 0;
+                unsigned int fbytes = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
+
+                if (fbytes)
+                        return fbytes;
 
                 udelay(2);
         } while (--i);
 
         printk(KERN_ERR PFX "FIFO is empty (sreg %02x)\n",
                esp_read8(ESP_STATUS));
-        return 1;
+        return 0;
 }
 
 static inline int mac_esp_wait_for_intr(struct esp *esp)
 {
+        struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
         int i = 500000;
 
         do {
@@ -308,6 +310,7 @@ static inline int mac_esp_wait_for_intr(struct esp *esp)
         } while (--i);
 
         printk(KERN_ERR PFX "IRQ timeout (sreg %02x)\n", esp->sreg);
+        mep->error = 1;
         return 1;
 }
 
@@ -347,11 +350,10 @@ static inline int mac_esp_wait_for_intr(struct esp *esp)
 static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
                                  u32 dma_count, int write, u8 cmd)
 {
-        unsigned long flags;
         struct mac_esp_priv *mep = MAC_ESP_GET_PRIV(esp);
         u8 *fifo = esp->regs + ESP_FDATA * 16;
 
-        local_irq_save(flags);
+        disable_irq(esp->host->irq);
 
         cmd &= ~ESP_CMD_DMA;
         mep->error = 0;
@@ -359,11 +361,35 @@ static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
         if (write) {
                 scsi_esp_cmd(esp, cmd);
 
-                if (!mac_esp_wait_for_intr(esp)) {
-                        if (mac_esp_wait_for_fifo(esp))
-                                esp_count = 0;
-                } else {
-                        esp_count = 0;
+                while (1) {
+                        unsigned int n;
+
+                        n = mac_esp_wait_for_fifo(esp);
+                        if (!n)
+                                break;
+
+                        if (n > esp_count)
+                                n = esp_count;
+                        esp_count -= n;
+
+                        MAC_ESP_PIO_LOOP("%2@,%0@+", n);
+
+                        if (!esp_count)
+                                break;
+
+                        if (mac_esp_wait_for_intr(esp))
+                                break;
+
+                        if (((esp->sreg & ESP_STAT_PMASK) != ESP_DIP) &&
+                            ((esp->sreg & ESP_STAT_PMASK) != ESP_MIP))
+                                break;
+
+                        esp->ireg = esp_read8(ESP_INTRPT);
+                        if ((esp->ireg & (ESP_INTR_DC | ESP_INTR_BSERV)) !=
+                            ESP_INTR_BSERV)
+                                break;
+
+                        scsi_esp_cmd(esp, ESP_CMD_TI);
                 }
         } else {
                 scsi_esp_cmd(esp, ESP_CMD_FLUSH);
@@ -374,47 +400,24 @@ static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
                         MAC_ESP_PIO_LOOP("%0@+,%2@", esp_count);
 
                 scsi_esp_cmd(esp, cmd);
-        }
-
-        while (esp_count) {
-                unsigned int n;
-
-                if (mac_esp_wait_for_intr(esp)) {
-                        mep->error = 1;
-                        break;
-                }
-
-                if (esp->sreg & ESP_STAT_SPAM) {
-                        printk(KERN_ERR PFX "gross error\n");
-                        mep->error = 1;
-                        break;
-                }
 
-                n = esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES;
-
-                if (write) {
-                        if (n > esp_count)
-                                n = esp_count;
-                        esp_count -= n;
-
-                        MAC_ESP_PIO_LOOP("%2@,%0@+", n);
+                while (esp_count) {
+                        unsigned int n;
 
-                        if ((esp->sreg & ESP_STAT_PMASK) == ESP_STATP)
+                        if (mac_esp_wait_for_intr(esp))
                                 break;
 
-                        if (esp_count) {
-                                esp->ireg = esp_read8(ESP_INTRPT);
-                                if (esp->ireg & ESP_INTR_DC)
-                                        break;
+                        if (((esp->sreg & ESP_STAT_PMASK) != ESP_DOP) &&
+                            ((esp->sreg & ESP_STAT_PMASK) != ESP_MOP))
+                                break;
 
-                                scsi_esp_cmd(esp, ESP_CMD_TI);
-                        }
-                } else {
                         esp->ireg = esp_read8(ESP_INTRPT);
-                        if (esp->ireg & ESP_INTR_DC)
+                        if ((esp->ireg & (ESP_INTR_DC | ESP_INTR_BSERV)) !=
+                            ESP_INTR_BSERV)
                                 break;
 
-                        n = MAC_ESP_FIFO_SIZE - n;
+                        n = MAC_ESP_FIFO_SIZE -
+                            (esp_read8(ESP_FFLAGS) & ESP_FF_FBYTES);
                         if (n > esp_count)
                                 n = esp_count;
 
@@ -429,7 +432,7 @@ static void mac_esp_send_pio_cmd(struct esp *esp, u32 addr, u32 esp_count,
                 }
         }
 
-        local_irq_restore(flags);
+        enable_irq(esp->host->irq);
 }
 
 static int mac_esp_irq_pending(struct esp *esp)
diff --git a/drivers/scsi/megaraid/megaraid_sas.c b/drivers/scsi/megaraid/megaraid_sas.c
index d9b8ca5116bc..409648f5845f 100644
--- a/drivers/scsi/megaraid/megaraid_sas.c
+++ b/drivers/scsi/megaraid/megaraid_sas.c
@@ -10,7 +10,7 @@
  *         2 of the License, or (at your option) any later version.
  *
  * FILE         : megaraid_sas.c
- * Version     : v00.00.04.12-rc1
+ * Version     : v00.00.04.17.1-rc1
  *
  * Authors:
  *      (email-id : megaraidlinux@lsi.com)
@@ -843,6 +843,7 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
         pthru->lun = scp->device->lun;
         pthru->cdb_len = scp->cmd_len;
         pthru->timeout = 0;
+        pthru->pad_0 = 0;
         pthru->flags = flags;
         pthru->data_xfer_len = scsi_bufflen(scp);
 
@@ -874,6 +875,12 @@ megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
                 pthru->sge_count = megasas_make_sgl32(instance, scp,
                                                       &pthru->sgl);
 
+        if (pthru->sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
+                        pthru->sge_count);
+                return 0;
+        }
+
         /*
          * Sense info specific
          */
@@ -1000,6 +1007,12 @@ megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
         } else
                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
 
+        if (ldio->sge_count > instance->max_num_sge) {
+                printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
+                        ldio->sge_count);
+                return 0;
+        }
+
         /*
          * Sense info specific
          */
@@ -2250,6 +2263,7 @@ megasas_get_pd_list(struct megasas_instance *instance)
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
         dcmd->opcode = MR_DCMD_PD_LIST_QUERY;
         dcmd->sgl.sge32[0].phys_addr = ci_h;
@@ -2294,6 +2308,86 @@ megasas_get_pd_list(struct megasas_instance *instance)
         return ret;
 }
 
+/*
+ * megasas_get_ld_list_info -   Returns FW's ld_list structure
+ * @instance:                           Adapter soft state
+ * @ld_list:                            ld_list structure
+ *
+ * Issues an internal command (DCMD) to get the FW's controller PD
+ * list structure.  This information is mainly used to find out SYSTEM
+ * supported by the FW.
+ */
+static int
+megasas_get_ld_list(struct megasas_instance *instance)
+{
+        int ret = 0, ld_index = 0, ids = 0;
+        struct megasas_cmd *cmd;
+        struct megasas_dcmd_frame *dcmd;
+        struct MR_LD_LIST *ci;
+        dma_addr_t ci_h = 0;
+
+        cmd = megasas_get_cmd(instance);
+
+        if (!cmd) {
+                printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
+                return -ENOMEM;
+        }
+
+        dcmd = &cmd->frame->dcmd;
+
+        ci = pci_alloc_consistent(instance->pdev,
+                                sizeof(struct MR_LD_LIST),
+                                &ci_h);
+
+        if (!ci) {
+                printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
+                megasas_return_cmd(instance, cmd);
+                return -ENOMEM;
+        }
+
+        memset(ci, 0, sizeof(*ci));
+        memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
+
+        dcmd->cmd = MFI_CMD_DCMD;
+        dcmd->cmd_status = 0xFF;
+        dcmd->sge_count = 1;
+        dcmd->flags = MFI_FRAME_DIR_READ;
+        dcmd->timeout = 0;
+        dcmd->data_xfer_len = sizeof(struct MR_LD_LIST);
+        dcmd->opcode = MR_DCMD_LD_GET_LIST;
+        dcmd->sgl.sge32[0].phys_addr = ci_h;
+        dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST);
+        dcmd->pad_0  = 0;
+
+        if (!megasas_issue_polled(instance, cmd)) {
+                ret = 0;
+        } else {
+                ret = -1;
+        }
+
+        /* the following function will get the instance PD LIST */
+
+        if ((ret == 0) && (ci->ldCount < MAX_LOGICAL_DRIVES)) {
+                memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
+
+                for (ld_index = 0; ld_index < ci->ldCount; ld_index++) {
+                        if (ci->ldList[ld_index].state != 0) {
+                                ids = ci->ldList[ld_index].ref.targetId;
+                                instance->ld_ids[ids] =
+                                        ci->ldList[ld_index].ref.targetId;
+                        }
+                }
+        }
+
+        pci_free_consistent(instance->pdev,
+                                sizeof(struct MR_LD_LIST),
+                                ci,
+                                ci_h);
+
+        megasas_return_cmd(instance, cmd);
+        return ret;
+}
+
 /**
  * megasas_get_controller_info -        Returns FW's controller structure
  * @instance:                           Adapter soft state
@@ -2339,6 +2433,7 @@ megasas_get_ctrl_info(struct megasas_instance *instance,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
         dcmd->sgl.sge32[0].phys_addr = ci_h;
@@ -2590,6 +2685,9 @@ static int megasas_init_mfi(struct megasas_instance *instance)
                 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
         megasas_get_pd_list(instance);
 
+        memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
+        megasas_get_ld_list(instance);
+
         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
 
         /*
@@ -2714,6 +2812,7 @@ megasas_get_seq_num(struct megasas_instance *instance,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info);
         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
         dcmd->sgl.sge32[0].phys_addr = el_info_h;
@@ -2828,6 +2927,7 @@ megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
         dcmd->sge_count = 1;
         dcmd->flags = MFI_FRAME_DIR_READ;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = sizeof(struct megasas_evt_detail);
         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
         dcmd->mbox.w[0] = seq_num;
@@ -3166,6 +3266,7 @@ static void megasas_flush_cache(struct megasas_instance *instance)
         dcmd->sge_count = 0;
         dcmd->flags = MFI_FRAME_DIR_NONE;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = 0;
         dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
@@ -3205,6 +3306,7 @@ static void megasas_shutdown_controller(struct megasas_instance *instance,
         dcmd->sge_count = 0;
         dcmd->flags = MFI_FRAME_DIR_NONE;
         dcmd->timeout = 0;
+        dcmd->pad_0 = 0;
         dcmd->data_xfer_len = 0;
         dcmd->opcode = opcode;
 
@@ -3984,6 +4086,7 @@ megasas_aen_polling(struct work_struct *work)
         struct  Scsi_Host *host;
         struct  scsi_device *sdev1;
         u16     pd_index = 0;
+        u16     ld_index = 0;
         int     i, j, doscan = 0;
         u32 seq_num;
         int error;
@@ -3999,8 +4102,124 @@ megasas_aen_polling(struct work_struct *work)
 
                 switch (instance->evt_detail->code) {
                 case MR_EVT_PD_INSERTED:
+                        if (megasas_get_pd_list(instance) == 0) {
+                        for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                pd_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 =
+                                scsi_device_lookup(host, i, j, 0);
+
+                                if (instance->pd_list[pd_index].driveState
+                                                == MR_PD_STATE_SYSTEM) {
+                                                if (!sdev1) {
+                                                scsi_add_device(host, i, j, 0);
+                                                }
+
+                                        if (sdev1)
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                        }
+                        doscan = 0;
+                        break;
+
                 case MR_EVT_PD_REMOVED:
+                        if (megasas_get_pd_list(instance) == 0) {
+                        megasas_get_pd_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                pd_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 =
+                                scsi_device_lookup(host, i, j, 0);
+
+                                if (instance->pd_list[pd_index].driveState
+                                        == MR_PD_STATE_SYSTEM) {
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                                }
+                        }
+                        }
+                        doscan = 0;
+                        break;
+
+                case MR_EVT_LD_OFFLINE:
+                case MR_EVT_LD_DELETED:
+                        megasas_get_ld_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                                for (j = 0;
+                                j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                j++) {
+
+                                ld_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 = scsi_device_lookup(host,
+                                        i + MEGASAS_MAX_LD_CHANNELS,
+                                        j,
+                                        0);
+
+                                if (instance->ld_ids[ld_index] != 0xff) {
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                                }
+                        }
+                        doscan = 0;
+                        break;
+                case MR_EVT_LD_CREATED:
+                        megasas_get_ld_list(instance);
+                        for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                                for (j = 0;
+                                        j < MEGASAS_MAX_DEV_PER_CHANNEL;
+                                        j++) {
+                                        ld_index =
+                                        (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                        sdev1 = scsi_device_lookup(host,
+                                                i+MEGASAS_MAX_LD_CHANNELS,
+                                                j, 0);
+
+                                        if (instance->ld_ids[ld_index] !=
+                                                                0xff) {
+                                                if (!sdev1) {
+                                                        scsi_add_device(host,
+                                                                i + 2,
+                                                                j, 0);
+                                                }
+                                        }
+                                        if (sdev1) {
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                        doscan = 0;
+                        break;
                 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
+                case MR_EVT_FOREIGN_CFG_IMPORTED:
                         doscan = 1;
                         break;
                 default:
@@ -4035,6 +4254,31 @@ megasas_aen_polling(struct work_struct *work)
                                 }
                         }
                 }
+
+                megasas_get_ld_list(instance);
+                for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
+                        for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
+                                ld_index =
+                                (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
+
+                                sdev1 = scsi_device_lookup(host,
+                                        i+MEGASAS_MAX_LD_CHANNELS, j, 0);
+                                if (instance->ld_ids[ld_index] != 0xff) {
+                                        if (!sdev1) {
+                                                scsi_add_device(host,
+                                                                i+2,
+                                                                j, 0);
+                                        } else {
+                                                scsi_device_put(sdev1);
+                                        }
+                                } else {
+                                        if (sdev1) {
+                                                scsi_remove_device(sdev1);
+                                                scsi_device_put(sdev1);
+                                        }
+                                }
+                        }
+                }
         }
 
         if ( instance->aen_cmd != NULL ) {
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 72b28e436e32..9d8b6bf605aa 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -18,9 +18,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "00.00.04.12-rc1"
-#define MEGASAS_RELDATE                         "Sep. 17, 2009"
-#define MEGASAS_EXT_VERSION                     "Thu Sep. 17 11:41:51 PST 2009"
+#define MEGASAS_VERSION                 "00.00.04.17.1-rc1"
+#define MEGASAS_RELDATE                 "Oct. 29, 2009"
+#define MEGASAS_EXT_VERSION             "Thu. Oct. 29, 11:41:51 PST 2009"
 
 /*
  * Device IDs
@@ -117,6 +117,7 @@
 #define MFI_CMD_STP                             0x08
 
 #define MR_DCMD_CTRL_GET_INFO                   0x01010000
+#define MR_DCMD_LD_GET_LIST                     0x03010000
 
 #define MR_DCMD_CTRL_CACHE_FLUSH                0x01101000
 #define MR_FLUSH_CTRL_CACHE                     0x01
@@ -349,6 +350,32 @@ struct megasas_pd_list {
         u8             driveState;
 } __packed;
 
+ /*
+ * defines the logical drive reference structure
+ */
+union  MR_LD_REF {
+        struct {
+                u8      targetId;
+                u8      reserved;
+                u16     seqNum;
+        };
+        u32     ref;
+} __packed;
+
+/*
+ * defines the logical drive list structure
+ */
+struct MR_LD_LIST {
+        u32     ldCount;
+        u32     reserved;
+        struct {
+                union MR_LD_REF   ref;
+                u8          state;
+                u8          reserved[3];
+                u64         size;
+        } ldList[MAX_LOGICAL_DRIVES];
+} __packed;
+
 /*
  * SAS controller properties
  */
@@ -637,6 +664,8 @@ struct megasas_ctrl_info {
 #define MEGASAS_MAX_LD                          64
 #define MEGASAS_MAX_PD                          (MEGASAS_MAX_PD_CHANNELS * \
                                                 MEGASAS_MAX_DEV_PER_CHANNEL)
+#define MEGASAS_MAX_LD_IDS                      (MEGASAS_MAX_LD_CHANNELS * \
+                                                MEGASAS_MAX_DEV_PER_CHANNEL)
 
 #define MEGASAS_DBG_LVL                         1
 
@@ -1187,6 +1216,7 @@ struct megasas_instance {
         struct megasas_register_set __iomem *reg_set;
 
         struct megasas_pd_list          pd_list[MEGASAS_MAX_PD];
+        u8     ld_ids[MEGASAS_MAX_LD_IDS];
         s8 init_id;
 
         u16 max_num_sge;
diff --git a/drivers/scsi/mpt2sas/Kconfig b/drivers/scsi/mpt2sas/Kconfig
index 70c4c2467dd8..ba8e128de238 100644
--- a/drivers/scsi/mpt2sas/Kconfig
+++ b/drivers/scsi/mpt2sas/Kconfig
@@ -44,6 +44,7 @@ config SCSI_MPT2SAS
         tristate "LSI MPT Fusion SAS 2.0 Device Driver"
         depends on PCI && SCSI
         select SCSI_SAS_ATTRS
+        select RAID_ATTRS
         ---help---
         This driver supports PCI-Express SAS 6Gb/s Host Adapters.
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2.h b/drivers/scsi/mpt2sas/mpi/mpi2.h
index 914168105297..9958d847a88d 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2.h
@@ -8,7 +8,7 @@
  *                  scatter/gather formats.
  *  Creation Date:  June 21, 2006
  *
- *  mpi2.h Version:  02.00.13
+ *  mpi2.h Version:  02.00.14
  *
  *  Version History
  *  ---------------
@@ -53,6 +53,10 @@
  *                      bytes reserved.
  *                      Added RAID Accelerator functionality.
  *  07-30-09  02.00.13  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  10-28-09  02.00.14  Bumped MPI2_HEADER_VERSION_UNIT.
+ *                      Added MSI-x index mask and shift for Reply Post Host
+ *                      Index register.
+ *                      Added function code for Host Based Discovery Action.
  *  --------------------------------------------------------------------------
  */
 
@@ -78,7 +82,7 @@
 #define MPI2_VERSION_02_00                  (0x0200)
 
 /* versioning for this MPI header set */
-#define MPI2_HEADER_VERSION_UNIT            (0x0D)
+#define MPI2_HEADER_VERSION_UNIT            (0x0E)
 #define MPI2_HEADER_VERSION_DEV             (0x00)
 #define MPI2_HEADER_VERSION_UNIT_MASK       (0xFF00)
 #define MPI2_HEADER_VERSION_UNIT_SHIFT      (8)
@@ -232,9 +236,12 @@ typedef volatile struct _MPI2_SYSTEM_INTERFACE_REGS
 #define MPI2_REPLY_FREE_HOST_INDEX_OFFSET       (0x00000048)
 
 /*
- * Offset for the Reply Descriptor Post Queue
+ * Defines for the Reply Descriptor Post Queue
  */
 #define MPI2_REPLY_POST_HOST_INDEX_OFFSET       (0x0000006C)
+#define MPI2_REPLY_POST_HOST_INDEX_MASK         (0x00FFFFFF)
+#define MPI2_RPHI_MSIX_INDEX_MASK               (0xFF000000)
+#define MPI2_RPHI_MSIX_INDEX_SHIFT              (24)
 
 /*
  * Defines for the HCBSize and address
@@ -497,12 +504,13 @@ typedef union _MPI2_REPLY_DESCRIPTORS_UNION
 #define MPI2_FUNCTION_TARGET_CMD_BUF_BASE_POST      (0x24) /* Target Command Buffer Post Base */
 #define MPI2_FUNCTION_TARGET_CMD_BUF_LIST_POST      (0x25) /* Target Command Buffer Post List */
 #define MPI2_FUNCTION_RAID_ACCELERATOR              (0x2C) /* RAID Accelerator*/
+/* Host Based Discovery Action */
+#define MPI2_FUNCTION_HOST_BASED_DISCOVERY_ACTION   (0x2F)
 
 
 
 /* Doorbell functions */
 #define MPI2_FUNCTION_IOC_MESSAGE_UNIT_RESET        (0x40)
-/* #define MPI2_FUNCTION_IO_UNIT_RESET                 (0x41) */
 #define MPI2_FUNCTION_HANDSHAKE                     (0x42)
 
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
index 1611c57a6fdf..cf0ac9f40c97 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_cnfg.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Configuration messages and pages
  *  Creation Date:  November 10, 2006
  *
- *    mpi2_cnfg.h Version:  02.00.12
+ *    mpi2_cnfg.h Version:  02.00.13
  *
  *  Version History
  *  ---------------
@@ -107,6 +107,8 @@
  *                      to SAS Device Page 0 Flags field.
  *                      Added PhyInfo defines for power condition.
  *                      Added Ethernet configuration pages.
+ *  10-28-09  02.00.13  Added MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY.
+ *                      Added SAS PHY Page 4 structure and defines.
  *  --------------------------------------------------------------------------
  */
 
@@ -712,6 +714,7 @@ typedef struct _MPI2_CONFIG_PAGE_IO_UNIT_1
 #define MPI2_IOUNITPAGE1_PAGEVERSION                    (0x04)
 
 /* IO Unit Page 1 Flags defines */
+#define MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY    (0x00000800)
 #define MPI2_IOUNITPAGE1_MASK_SATA_WRITE_CACHE          (0x00000600)
 #define MPI2_IOUNITPAGE1_ENABLE_SATA_WRITE_CACHE        (0x00000000)
 #define MPI2_IOUNITPAGE1_DISABLE_SATA_WRITE_CACHE       (0x00000200)
@@ -2291,6 +2294,26 @@ typedef struct _MPI2_CONFIG_PAGE_SAS_PHY_3 {
 #define MPI2_SASPHY3_PAGEVERSION            (0x00)
 
 
+/* SAS PHY Page 4 */
+
+typedef struct _MPI2_CONFIG_PAGE_SAS_PHY_4 {
+    MPI2_CONFIG_EXTENDED_PAGE_HEADER    Header;                     /* 0x00 */
+    U16                                 Reserved1;                  /* 0x08 */
+    U8                                  Reserved2;                  /* 0x0A */
+    U8                                  Flags;                      /* 0x0B */
+    U8                                  InitialFrame[28];           /* 0x0C */
+} MPI2_CONFIG_PAGE_SAS_PHY_4, MPI2_POINTER PTR_MPI2_CONFIG_PAGE_SAS_PHY_4,
+  Mpi2SasPhyPage4_t, MPI2_POINTER pMpi2SasPhyPage4_t;
+
+#define MPI2_SASPHY4_PAGEVERSION            (0x00)
+
+/* values for the Flags field */
+#define MPI2_SASPHY4_FLAGS_FRAME_VALID        (0x02)
+#define MPI2_SASPHY4_FLAGS_SATA_FRAME         (0x01)
+
+
+
+
 /****************************************************************************
 *   SAS Port Config Pages
 ****************************************************************************/
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_history.txt b/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
index 65fcaa31cb30..c4adf76b49d9 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_history.txt
@@ -5,23 +5,24 @@
  Copyright (c) 2000-2009 LSI Corporation.
 
  ---------------------------------------
- Header Set Release Version:    02.00.12
- Header Set Release Date:       05-06-09
+ Header Set Release Version:    02.00.14
+ Header Set Release Date:       10-28-09
  ---------------------------------------
 
  Filename               Current version     Prior version
  ----------             ---------------     -------------
- mpi2.h                 02.00.12            02.00.11
- mpi2_cnfg.h            02.00.11            02.00.10
- mpi2_init.h            02.00.07            02.00.06
- mpi2_ioc.h             02.00.11            02.00.10
- mpi2_raid.h            02.00.03            02.00.03
- mpi2_sas.h             02.00.02            02.00.02
+ mpi2.h                 02.00.14            02.00.13
+ mpi2_cnfg.h            02.00.13            02.00.12
+ mpi2_init.h            02.00.08            02.00.07
+ mpi2_ioc.h             02.00.13            02.00.12
+ mpi2_raid.h            02.00.04            02.00.04
+ mpi2_sas.h             02.00.03            02.00.02
  mpi2_targ.h            02.00.03            02.00.03
- mpi2_tool.h            02.00.03            02.00.02
+ mpi2_tool.h            02.00.04            02.00.04
  mpi2_type.h            02.00.00            02.00.00
- mpi2_ra.h              02.00.00
- mpi2_history.txt       02.00.11            02.00.12
+ mpi2_ra.h              02.00.00            02.00.00
+ mpi2_hbd.h             02.00.00
+ mpi2_history.txt       02.00.14            02.00.13
 
 
  *  Date      Version   Description
@@ -65,6 +66,11 @@ mpi2.h
  *                      MPI2_SCSI_IO_SUCCESS_REPLY_DESCRIPTOR and made those
  *                      bytes reserved.
  *                      Added RAID Accelerator functionality.
+ *  07-30-09  02.00.13  Bumped MPI2_HEADER_VERSION_UNIT.
+ *  10-28-09  02.00.14  Bumped MPI2_HEADER_VERSION_UNIT.
+ *                      Added MSI-x index mask and shift for Reply Post Host
+ *                      Index register.
+ *                      Added function code for Host Based Discovery Action.
  *  --------------------------------------------------------------------------
 
 mpi2_cnfg.h
@@ -155,6 +161,15 @@ mpi2_cnfg.h
  *                      Added expander reduced functionality data to SAS
  *                      Expander Page 0.
  *                      Added SAS PHY Page 2 and SAS PHY Page 3.
+ *  07-30-09  02.00.12  Added IO Unit Page 7.
+ *                      Added new device ids.
+ *                      Added SAS IO Unit Page 5.
+ *                      Added partial and slumber power management capable flags
+ *                      to SAS Device Page 0 Flags field.
+ *                      Added PhyInfo defines for power condition.
+ *                      Added Ethernet configuration pages.
+ *  10-28-09  02.00.13  Added MPI2_IOUNITPAGE1_ENABLE_HOST_BASED_DISCOVERY.
+ *                      Added SAS PHY Page 4 structure and defines.
  *  --------------------------------------------------------------------------
 
 mpi2_init.h
@@ -172,6 +187,10 @@ mpi2_init.h
  *                      Query Asynchronous Event.
  *                      Defined two new bits in the SlotStatus field of the SCSI
  *                      Enclosure Processor Request and Reply.
+ *  10-28-09  02.00.08  Added defines for decoding the ResponseInfo bytes for
+ *                      both SCSI IO Error Reply and SCSI Task Management Reply.
+ *                      Added ResponseInfo field to MPI2_SCSI_TASK_MANAGE_REPLY.
+ *                      Added MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG define.
  *  --------------------------------------------------------------------------
 
 mpi2_ioc.h
@@ -246,6 +265,20 @@ mpi2_ioc.h
  *                      Added two new reason codes for SAS Device Status Change
  *                      Event.
  *                      Added new event: SAS PHY Counter.
+ *  07-30-09  02.00.12  Added GPIO Interrupt event define and structure.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER define.
+ *                      Added new product id family for 2208.
+ *  10-28-09  02.00.13  Added HostMSIxVectors field to MPI2_IOC_INIT_REQUEST.
+ *                      Added MaxMSIxVectors field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MinDevHandle field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_HOST_BASED_DISCOVERY.
+ *                      Added MPI2_EVENT_HOST_BASED_DISCOVERY_PHY define.
+ *                      Added MPI2_EVENT_SAS_TOPO_ES_NO_EXPANDER define.
+ *                      Added Host Based Discovery Phy Event data.
+ *                      Added defines for ProductID Product field
+ *                      (MPI2_FW_HEADER_PID_).
+ *                      Modified values for SAS ProductID Family
+ *                      (MPI2_FW_HEADER_PID_FAMILY_).
  *  --------------------------------------------------------------------------
 
 mpi2_raid.h
@@ -256,6 +289,8 @@ mpi2_raid.h
  *  05-21-08  02.00.03  Added MPI2_RAID_VOL_CREATION_NUM_PHYSDISKS so that
  *                      the PhysDisk array in MPI2_RAID_VOLUME_CREATION_STRUCT
  *                      can be sized by the build environment.
+ *  07-30-09  02.00.04  Added proper define for the Use Default Settings bit of
+ *                      VolumeCreationFlags and marked the old one as obsolete.
  *  --------------------------------------------------------------------------
 
 mpi2_sas.h
@@ -264,6 +299,8 @@ mpi2_sas.h
  *                      Control Request.
  *  10-02-08  02.00.02  Added Set IOC Parameter Operation to SAS IO Unit Control
  *                      Request.
+ *  10-28-09  02.00.03  Changed the type of SGL in MPI2_SATA_PASSTHROUGH_REQUEST
+ *                      to MPI2_SGE_IO_UNION since it supports chained SGLs.
  *  --------------------------------------------------------------------------
 
 mpi2_targ.h
@@ -283,6 +320,10 @@ mpi2_tool.h
  *                      structures and defines.
  *  02-29-08  02.00.02  Modified various names to make them 32-character unique.
  *  05-06-09  02.00.03  Added ISTWI Read Write Tool and Diagnostic CLI Tool.
+ *  07-30-09  02.00.04  Added ExtendedType field to DiagnosticBufferPost request
+ *                      and reply messages.
+ *                      Added MPI2_DIAG_BUF_TYPE_EXTENDED.
+ *                      Incremented MPI2_DIAG_BUF_TYPE_COUNT.
  *  --------------------------------------------------------------------------
 
 mpi2_type.h
@@ -293,20 +334,26 @@ mpi2_ra.h
  *  05-06-09  02.00.00  Initial version.
  *  --------------------------------------------------------------------------
 
+mpi2_hbd.h
+ *  10-28-09  02.00.00  Initial version.
+ *  --------------------------------------------------------------------------
+
+
 mpi2_history.txt         Parts list history
 
-Filename     02.00.12
-----------   --------
-mpi2.h       02.00.12
-mpi2_cnfg.h  02.00.11
-mpi2_init.h  02.00.07
-mpi2_ioc.h   02.00.11
-mpi2_raid.h  02.00.03
-mpi2_sas.h   02.00.02
-mpi2_targ.h  02.00.03
-mpi2_tool.h  02.00.03
-mpi2_type.h  02.00.00
-mpi2_ra.h    02.00.00
+Filename     02.00.14  02.00.13  02.00.12
+----------   --------  --------  --------
+mpi2.h       02.00.14  02.00.13  02.00.12
+mpi2_cnfg.h  02.00.13  02.00.12  02.00.11
+mpi2_init.h  02.00.08  02.00.07  02.00.07
+mpi2_ioc.h   02.00.13  02.00.12  02.00.11
+mpi2_raid.h  02.00.04  02.00.04  02.00.03
+mpi2_sas.h   02.00.03  02.00.02  02.00.02
+mpi2_targ.h  02.00.03  02.00.03  02.00.03
+mpi2_tool.h  02.00.04  02.00.04  02.00.03
+mpi2_type.h  02.00.00  02.00.00  02.00.00
+mpi2_ra.h    02.00.00  02.00.00  02.00.00
+mpi2_hbd.h   02.00.00
 
 Filename     02.00.11  02.00.10  02.00.09  02.00.08  02.00.07  02.00.06
 ----------   --------  --------  --------  --------  --------  --------
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_init.h b/drivers/scsi/mpt2sas/mpi/mpi2_init.h
index 563e56d2e945..6541945e97c3 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_init.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_init.h
@@ -6,7 +6,7 @@
  *          Title:  MPI SCSI initiator mode messages and structures
  *  Creation Date:  June 23, 2006
  *
- *    mpi2_init.h Version:  02.00.07
+ *    mpi2_init.h Version:  02.00.08
  *
  *  Version History
  *  ---------------
@@ -27,6 +27,10 @@
  *                      Query Asynchronous Event.
  *                      Defined two new bits in the SlotStatus field of the SCSI
  *                      Enclosure Processor Request and Reply.
+ *  10-28-09  02.00.08  Added defines for decoding the ResponseInfo bytes for
+ *                      both SCSI IO Error Reply and SCSI Task Management Reply.
+ *                      Added ResponseInfo field to MPI2_SCSI_TASK_MANAGE_REPLY.
+ *                      Added MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG define.
  *  --------------------------------------------------------------------------
  */
 
@@ -254,6 +258,11 @@ typedef struct _MPI2_SCSI_IO_REPLY
 #define MPI2_SCSI_STATE_AUTOSENSE_FAILED        (0x02)
 #define MPI2_SCSI_STATE_AUTOSENSE_VALID         (0x01)
 
+/* masks and shifts for the ResponseInfo field */
+
+#define MPI2_SCSI_RI_MASK_REASONCODE            (0x000000FF)
+#define MPI2_SCSI_RI_SHIFT_REASONCODE           (0)
+
 #define MPI2_SCSI_TASKTAG_UNKNOWN               (0xFFFF)
 
 
@@ -327,6 +336,7 @@ typedef struct _MPI2_SCSI_TASK_MANAGE_REPLY
     U16                     IOCStatus;                      /* 0x0E */
     U32                     IOCLogInfo;                     /* 0x10 */
     U32                     TerminationCount;               /* 0x14 */
+    U32                     ResponseInfo;                   /* 0x18 */
 } MPI2_SCSI_TASK_MANAGE_REPLY,
   MPI2_POINTER PTR_MPI2_SCSI_TASK_MANAGE_REPLY,
   Mpi2SCSITaskManagementReply_t, MPI2_POINTER pMpi2SCSIManagementReply_t;
@@ -339,8 +349,20 @@ typedef struct _MPI2_SCSI_TASK_MANAGE_REPLY
 #define MPI2_SCSITASKMGMT_RSP_TM_FAILED                 (0x05)
 #define MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED              (0x08)
 #define MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN            (0x09)
+#define MPI2_SCSITASKMGMT_RSP_TM_OVERLAPPED_TAG         (0x0A)
 #define MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC          (0x80)
 
+/* masks and shifts for the ResponseInfo field */
+
+#define MPI2_SCSITASKMGMT_RI_MASK_REASONCODE            (0x000000FF)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_REASONCODE           (0)
+#define MPI2_SCSITASKMGMT_RI_MASK_ARI2                  (0x0000FF00)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_ARI2                 (8)
+#define MPI2_SCSITASKMGMT_RI_MASK_ARI1                  (0x00FF0000)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_ARI1                 (16)
+#define MPI2_SCSITASKMGMT_RI_MASK_ARI0                  (0xFF000000)
+#define MPI2_SCSITASKMGMT_RI_SHIFT_ARI0                 (24)
+
 
 /****************************************************************************
 *  SCSI Enclosure Processor messages
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
index ea51ce868690..754938422f6a 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_ioc.h
@@ -6,7 +6,7 @@
  *          Title:  MPI IOC, Port, Event, FW Download, and FW Upload messages
  *  Creation Date:  October 11, 2006
  *
- *  mpi2_ioc.h Version:  02.00.12
+ *  mpi2_ioc.h Version:  02.00.13
  *
  *  Version History
  *  ---------------
@@ -87,6 +87,17 @@
  *  07-30-09  02.00.12  Added GPIO Interrupt event define and structure.
  *                      Added MPI2_IOCFACTS_CAPABILITY_EXTENDED_BUFFER define.
  *                      Added new product id family for 2208.
+ *  10-28-09  02.00.13  Added HostMSIxVectors field to MPI2_IOC_INIT_REQUEST.
+ *                      Added MaxMSIxVectors field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MinDevHandle field to MPI2_IOC_FACTS_REPLY.
+ *                      Added MPI2_IOCFACTS_CAPABILITY_HOST_BASED_DISCOVERY.
+ *                      Added MPI2_EVENT_HOST_BASED_DISCOVERY_PHY define.
+ *                      Added MPI2_EVENT_SAS_TOPO_ES_NO_EXPANDER define.
+ *                      Added Host Based Discovery Phy Event data.
+ *                      Added defines for ProductID Product field
+ *                      (MPI2_FW_HEADER_PID_).
+ *                      Modified values for SAS ProductID Family
+ *                      (MPI2_FW_HEADER_PID_FAMILY_).
  *  --------------------------------------------------------------------------
  */
 
@@ -119,8 +130,10 @@ typedef struct _MPI2_IOC_INIT_REQUEST
     U16                     MsgVersion;                     /* 0x0C */
     U16                     HeaderVersion;                  /* 0x0E */
     U32                     Reserved5;                      /* 0x10 */
-    U32                     Reserved6;                      /* 0x14 */
-    U16                     Reserved7;                      /* 0x18 */
+    U16                     Reserved6;                      /* 0x14 */
+    U8                      Reserved7;                      /* 0x16 */
+    U8                      HostMSIxVectors;                /* 0x17 */
+    U16                     Reserved8;                      /* 0x18 */
     U16                     SystemRequestFrameSize;         /* 0x1A */
     U16                     ReplyDescriptorPostQueueDepth;  /* 0x1C */
     U16                     ReplyFreeQueueDepth;            /* 0x1E */
@@ -215,7 +228,7 @@ typedef struct _MPI2_IOC_FACTS_REPLY
     U8                      MaxChainDepth;                  /* 0x14 */
     U8                      WhoInit;                        /* 0x15 */
     U8                      NumberOfPorts;                  /* 0x16 */
-    U8                      Reserved2;                      /* 0x17 */
+    U8                      MaxMSIxVectors;                 /* 0x17 */
     U16                     RequestCredit;                  /* 0x18 */
     U16                     ProductID;                      /* 0x1A */
     U32                     IOCCapabilities;                /* 0x1C */
@@ -233,7 +246,8 @@ typedef struct _MPI2_IOC_FACTS_REPLY
     U8                      MaxVolumes;                     /* 0x37 */
     U16                     MaxDevHandle;                   /* 0x38 */
     U16                     MaxPersistentEntries;           /* 0x3A */
-    U32                     Reserved4;                      /* 0x3C */
+    U16                     MinDevHandle;                   /* 0x3C */
+    U16                     Reserved4;                      /* 0x3E */
 } MPI2_IOC_FACTS_REPLY, MPI2_POINTER PTR_MPI2_IOC_FACTS_REPLY,
   Mpi2IOCFactsReply_t, MPI2_POINTER pMpi2IOCFactsReply_t;
 
@@ -269,6 +283,7 @@ typedef struct _MPI2_IOC_FACTS_REPLY
 /* ProductID field uses MPI2_FW_HEADER_PID_ */
 
 /* IOCCapabilities */
+#define MPI2_IOCFACTS_CAPABILITY_HOST_BASED_DISCOVERY   (0x00010000)
 #define MPI2_IOCFACTS_CAPABILITY_MSI_X_INDEX            (0x00008000)
 #define MPI2_IOCFACTS_CAPABILITY_RAID_ACCELERATOR       (0x00004000)
 #define MPI2_IOCFACTS_CAPABILITY_EVENT_REPLAY           (0x00002000)
@@ -453,6 +468,7 @@ typedef struct _MPI2_EVENT_NOTIFICATION_REPLY
 #define MPI2_EVENT_LOG_ENTRY_ADDED                  (0x0021)
 #define MPI2_EVENT_SAS_PHY_COUNTER                  (0x0022)
 #define MPI2_EVENT_GPIO_INTERRUPT                   (0x0023)
+#define MPI2_EVENT_HOST_BASED_DISCOVERY_PHY         (0x0024)
 
 
 /* Log Entry Added Event data */
@@ -793,6 +809,7 @@ typedef struct _MPI2_EVENT_DATA_SAS_TOPOLOGY_CHANGE_LIST
   MPI2_POINTER pMpi2EventDataSasTopologyChangeList_t;
 
 /* values for the ExpStatus field */
+#define MPI2_EVENT_SAS_TOPO_ES_NO_EXPANDER                  (0x00)
 #define MPI2_EVENT_SAS_TOPO_ES_ADDED                        (0x01)
 #define MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING               (0x02)
 #define MPI2_EVENT_SAS_TOPO_ES_RESPONDING                   (0x03)
@@ -878,6 +895,44 @@ typedef struct _MPI2_EVENT_DATA_SAS_PHY_COUNTER {
  * */
 
 
+/* Host Based Discovery Phy Event data */
+
+typedef struct _MPI2_EVENT_HBD_PHY_SAS {
+    U8          Flags;                      /* 0x00 */
+    U8          NegotiatedLinkRate;         /* 0x01 */
+    U8          PhyNum;                     /* 0x02 */
+    U8          PhysicalPort;               /* 0x03 */
+    U32         Reserved1;                  /* 0x04 */
+    U8          InitialFrame[28];           /* 0x08 */
+} MPI2_EVENT_HBD_PHY_SAS, MPI2_POINTER PTR_MPI2_EVENT_HBD_PHY_SAS,
+  Mpi2EventHbdPhySas_t, MPI2_POINTER pMpi2EventHbdPhySas_t;
+
+/* values for the Flags field */
+#define MPI2_EVENT_HBD_SAS_FLAGS_FRAME_VALID        (0x02)
+#define MPI2_EVENT_HBD_SAS_FLAGS_SATA_FRAME         (0x01)
+
+/* use MPI2_SAS_NEG_LINK_RATE_ defines from mpi2_cnfg.h for
+ * the NegotiatedLinkRate field */
+
+typedef union _MPI2_EVENT_HBD_DESCRIPTOR {
+    MPI2_EVENT_HBD_PHY_SAS      Sas;
+} MPI2_EVENT_HBD_DESCRIPTOR, MPI2_POINTER PTR_MPI2_EVENT_HBD_DESCRIPTOR,
+  Mpi2EventHbdDescriptor_t, MPI2_POINTER pMpi2EventHbdDescriptor_t;
+
+typedef struct _MPI2_EVENT_DATA_HBD_PHY {
+    U8                          DescriptorType;     /* 0x00 */
+    U8                          Reserved1;          /* 0x01 */
+    U16                         Reserved2;          /* 0x02 */
+    U32                         Reserved3;          /* 0x04 */
+    MPI2_EVENT_HBD_DESCRIPTOR   Descriptor;         /* 0x08 */
+} MPI2_EVENT_DATA_HBD_PHY, MPI2_POINTER PTR_MPI2_EVENT_DATA_HBD_PHY,
+  Mpi2EventDataHbdPhy_t, MPI2_POINTER pMpi2EventDataMpi2EventDataHbdPhy_t;
+
+/* values for the DescriptorType field */
+#define MPI2_EVENT_HBD_DT_SAS               (0x01)
+
+
+
 /****************************************************************************
 *  EventAck message
 ****************************************************************************/
@@ -1126,13 +1181,17 @@ typedef struct _MPI2_FW_IMAGE_HEADER
 #define MPI2_FW_HEADER_PID_TYPE_MASK            (0xF000)
 #define MPI2_FW_HEADER_PID_TYPE_SAS             (0x2000)
 
-#define MPI2_FW_HEADER_PID_PROD_MASK            (0x0F00)
-#define MPI2_FW_HEADER_PID_PROD_A               (0x0000)
+#define MPI2_FW_HEADER_PID_PROD_MASK                    (0x0F00)
+#define MPI2_FW_HEADER_PID_PROD_A                       (0x0000)
+#define MPI2_FW_HEADER_PID_PROD_MASK                    (0x0F00)
+#define MPI2_FW_HEADER_PID_PROD_TARGET_INITIATOR_SCSI   (0x0200)
+#define MPI2_FW_HEADER_PID_PROD_IR_SCSI                 (0x0700)
+
 
 #define MPI2_FW_HEADER_PID_FAMILY_MASK          (0x00FF)
 /* SAS */
-#define MPI2_FW_HEADER_PID_FAMILY_2108_SAS      (0x0010)
-#define MPI2_FW_HEADER_PID_FAMILY_2208_SAS      (0x0011)
+#define MPI2_FW_HEADER_PID_FAMILY_2108_SAS      (0x0013)
+#define MPI2_FW_HEADER_PID_FAMILY_2208_SAS      (0x0014)
 
 /* use MPI2_IOCFACTS_PROTOCOL_ defines for ProtocolFlags field */
 
diff --git a/drivers/scsi/mpt2sas/mpi/mpi2_sas.h b/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
index 8a42b136cf53..2d8aeed51392 100644
--- a/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
+++ b/drivers/scsi/mpt2sas/mpi/mpi2_sas.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Serial Attached SCSI structures and definitions
  *  Creation Date:  February 9, 2007
  *
- *  mpi2.h Version:  02.00.02
+ *  mpi2.h Version:  02.00.03
  *
  *  Version History
  *  ---------------
@@ -18,6 +18,8 @@
  *                      Control Request.
  *  10-02-08  02.00.02  Added Set IOC Parameter Operation to SAS IO Unit Control
  *                      Request.
+ *  10-28-09  02.00.03  Changed the type of SGL in MPI2_SATA_PASSTHROUGH_REQUEST
+ *                      to MPI2_SGE_IO_UNION since it supports chained SGLs.
  *  --------------------------------------------------------------------------
  */
 
@@ -160,7 +162,7 @@ typedef struct _MPI2_SATA_PASSTHROUGH_REQUEST
     U32                     Reserved4;          /* 0x14 */
     U32                     DataLength;         /* 0x18 */
     U8                      CommandFIS[20];     /* 0x1C */
-    MPI2_SIMPLE_SGE_UNION   SGL;                /* 0x20 */
+    MPI2_SGE_IO_UNION       SGL;                /* 0x20 */
 } MPI2_SATA_PASSTHROUGH_REQUEST, MPI2_POINTER PTR_MPI2_SATA_PASSTHROUGH_REQUEST,
   Mpi2SataPassthroughRequest_t, MPI2_POINTER pMpi2SataPassthroughRequest_t;
 
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.c b/drivers/scsi/mpt2sas/mpt2sas_base.c
index 89d02401b9ec..88e6eebc3159 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.c
@@ -107,8 +107,7 @@ _scsih_set_fwfault_debug(const char *val, struct kernel_param *kp)
         if (ret)
                 return ret;
 
-        printk(KERN_INFO "setting logging_level(0x%08x)\n",
-                                mpt2sas_fwfault_debug);
+        printk(KERN_INFO "setting fwfault_debug(%d)\n", mpt2sas_fwfault_debug);
         list_for_each_entry(ioc, &mpt2sas_ioc_list, list)
                 ioc->fwfault_debug = mpt2sas_fwfault_debug;
         return 0;
@@ -1222,6 +1221,8 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
         u32 memap_sz;
         u32 pio_sz;
         int i, r = 0;
+        u64 pio_chip = 0;
+        u64 chip_phys = 0;
 
         dinitprintk(ioc, printk(MPT2SAS_DEBUG_FMT "%s\n",
             ioc->name, __func__));
@@ -1255,12 +1256,13 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
                 if (pci_resource_flags(pdev, i) & PCI_BASE_ADDRESS_SPACE_IO) {
                         if (pio_sz)
                                 continue;
-                        ioc->pio_chip = pci_resource_start(pdev, i);
+                        pio_chip = (u64)pci_resource_start(pdev, i);
                         pio_sz = pci_resource_len(pdev, i);
                 } else {
                         if (memap_sz)
                                 continue;
                         ioc->chip_phys = pci_resource_start(pdev, i);
+                        chip_phys = (u64)ioc->chip_phys;
                         memap_sz = pci_resource_len(pdev, i);
                         ioc->chip = ioremap(ioc->chip_phys, memap_sz);
                         if (ioc->chip == NULL) {
@@ -1280,10 +1282,10 @@ mpt2sas_base_map_resources(struct MPT2SAS_ADAPTER *ioc)
         printk(MPT2SAS_INFO_FMT "%s: IRQ %d\n",
             ioc->name,  ((ioc->msix_enable) ? "PCI-MSI-X enabled" :
             "IO-APIC enabled"), ioc->pci_irq);
-        printk(MPT2SAS_INFO_FMT "iomem(0x%lx), mapped(0x%p), size(%d)\n",
-            ioc->name, ioc->chip_phys, ioc->chip, memap_sz);
-        printk(MPT2SAS_INFO_FMT "ioport(0x%lx), size(%d)\n",
-            ioc->name, ioc->pio_chip, pio_sz);
+        printk(MPT2SAS_INFO_FMT "iomem(0x%016llx), mapped(0x%p), size(%d)\n",
+            ioc->name, (unsigned long long)chip_phys, ioc->chip, memap_sz);
+        printk(MPT2SAS_INFO_FMT "ioport(0x%016llx), size(%d)\n",
+            ioc->name, (unsigned long long)pio_chip, pio_sz);
 
         return 0;
 
@@ -3573,6 +3575,8 @@ mpt2sas_base_attach(struct MPT2SAS_ADAPTER *ioc)
 
         init_waitqueue_head(&ioc->reset_wq);
 
+        ioc->fwfault_debug = mpt2sas_fwfault_debug;
+
         /* base internal command bits */
         mutex_init(&ioc->base_cmds.mutex);
         ioc->base_cmds.reply = kzalloc(ioc->reply_sz, GFP_KERNEL);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index bb4f14656afa..e18b0544c38f 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,10 +69,10 @@
 #define MPT2SAS_DRIVER_NAME             "mpt2sas"
 #define MPT2SAS_AUTHOR  "LSI Corporation <DL-MPTFusionLinux@lsi.com>"
 #define MPT2SAS_DESCRIPTION     "LSI MPT Fusion SAS 2.0 Device Driver"
-#define MPT2SAS_DRIVER_VERSION          "03.100.03.00"
-#define MPT2SAS_MAJOR_VERSION           03
+#define MPT2SAS_DRIVER_VERSION          "04.100.01.00"
+#define MPT2SAS_MAJOR_VERSION           04
 #define MPT2SAS_MINOR_VERSION           100
-#define MPT2SAS_BUILD_VERSION           03
+#define MPT2SAS_BUILD_VERSION           01
 #define MPT2SAS_RELEASE_VERSION         00
 
 /*
@@ -323,6 +323,7 @@ struct _sas_device {
  * @device_info: bitfield provides detailed info about the hidden components
  * @num_pds: number of hidden raid components
  * @responding: used in _scsih_raid_device_mark_responding
+ * @percent_complete: resync percent complete
  */
 struct _raid_device {
         struct list_head list;
@@ -336,6 +337,7 @@ struct _raid_device {
         u32     device_info;
         u8      num_pds;
         u8      responding;
+        u8      percent_complete;
 };
 
 /**
@@ -464,7 +466,6 @@ typedef void (*MPT_ADD_SGE)(void *paddr, u32 flags_length, dma_addr_t dma_addr);
  * @pdev: pci pdev object
  * @chip: memory mapped register space
  * @chip_phys: physical addrss prior to mapping
- * @pio_chip: I/O mapped register space
  * @logging_level: see mpt2sas_debug.h
  * @fwfault_debug: debuging FW timeouts
  * @ir_firmware: IR firmware present
@@ -587,8 +588,7 @@ struct MPT2SAS_ADAPTER {
         char            tmp_string[MPT_STRING_LENGTH];
         struct pci_dev  *pdev;
         Mpi2SystemInterfaceRegs_t __iomem *chip;
-        unsigned long   chip_phys;
-        unsigned long   pio_chip;
+        resource_size_t chip_phys;
         int             logging_level;
         int             fwfault_debug;
         u8              ir_firmware;
@@ -853,6 +853,8 @@ int mpt2sas_config_set_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2IOUnitPage1_t *config_page);
 int mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz);
+int mpt2sas_config_set_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc,
+    Mpi2ConfigReply_t *mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz);
 int mpt2sas_config_get_ioc_pg8(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
     *mpi_reply, Mpi2IOCPage8_t *config_page);
 int mpt2sas_config_get_expander_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
diff --git a/drivers/scsi/mpt2sas/mpt2sas_config.c b/drivers/scsi/mpt2sas/mpt2sas_config.c
index 594a389c6526..411c27d7f787 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_config.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_config.c
@@ -324,7 +324,9 @@ _config_request(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigRequest_t
                 if (r != 0)
                         goto out;
                 if (mpi_request->Action ==
-                    MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT) {
+                    MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT ||
+                    mpi_request->Action ==
+                    MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM) {
                         ioc->base_add_sg_single(&mpi_request->PageBufferSGE,
                             MPT2_CONFIG_COMMON_WRITE_SGLFLAGS | mem.sz,
                             mem.page_dma);
@@ -882,7 +884,7 @@ mpt2sas_config_get_sas_iounit_pg0(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
 }
 
 /**
- * mpt2sas_config_get_sas_iounit_pg1 - obtain sas iounit page 0
+ * mpt2sas_config_get_sas_iounit_pg1 - obtain sas iounit page 1
  * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
  * @config_page: contents of the config page
@@ -907,7 +909,7 @@ mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
         mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
         mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
         mpi_request.Header.PageNumber = 1;
-        mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE0_PAGEVERSION;
+        mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
         mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
         r = _config_request(ioc, &mpi_request, mpi_reply,
             MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
@@ -922,6 +924,49 @@ mpt2sas_config_get_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
 }
 
 /**
+ * mpt2sas_config_set_sas_iounit_pg1 - send sas iounit page 1
+ * @ioc: per adapter object
+ * @mpi_reply: reply mf payload returned from firmware
+ * @config_page: contents of the config page
+ * @sz: size of buffer passed in config_page
+ * Context: sleep.
+ *
+ * Calling function should call config_get_number_hba_phys prior to
+ * this function, so enough memory is allocated for config_page.
+ *
+ * Returns 0 for success, non-zero for failure.
+ */
+int
+mpt2sas_config_set_sas_iounit_pg1(struct MPT2SAS_ADAPTER *ioc, Mpi2ConfigReply_t
+    *mpi_reply, Mpi2SasIOUnitPage1_t *config_page, u16 sz)
+{
+        Mpi2ConfigRequest_t mpi_request;
+        int r;
+
+        memset(&mpi_request, 0, sizeof(Mpi2ConfigRequest_t));
+        mpi_request.Function = MPI2_FUNCTION_CONFIG;
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_HEADER;
+        mpi_request.Header.PageType = MPI2_CONFIG_PAGETYPE_EXTENDED;
+        mpi_request.ExtPageType = MPI2_CONFIG_EXTPAGETYPE_SAS_IO_UNIT;
+        mpi_request.Header.PageNumber = 1;
+        mpi_request.Header.PageVersion = MPI2_SASIOUNITPAGE1_PAGEVERSION;
+        mpt2sas_base_build_zero_len_sge(ioc, &mpi_request.PageBufferSGE);
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, NULL, 0);
+        if (r)
+                goto out;
+
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_CURRENT;
+        _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
+        mpi_request.Action = MPI2_CONFIG_ACTION_PAGE_WRITE_NVRAM;
+        r = _config_request(ioc, &mpi_request, mpi_reply,
+            MPT2_CONFIG_PAGE_DEFAULT_TIMEOUT, config_page, sz);
+ out:
+        return r;
+}
+
+/**
  * mpt2sas_config_get_expander_pg0 - obtain expander page 0
  * @ioc: per adapter object
  * @mpi_reply: reply mf payload returned from firmware
diff --git a/drivers/scsi/mpt2sas/mpt2sas_ctl.c b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
index 84a124f8e21f..fa9bf83819d5 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_ctl.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_ctl.c
@@ -891,6 +891,7 @@ _ctl_do_mpt_command(struct MPT2SAS_ADAPTER *ioc,
 
  issue_host_reset:
         if (issue_reset) {
+                ret = -ENODATA;
                 if ((mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST ||
                     mpi_request->Function ==
                     MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH)) {
@@ -2202,14 +2203,10 @@ _ctl_compat_mpt_command(struct file *file, unsigned cmd, unsigned long arg)
         karg.data_out_size = karg32.data_out_size;
         karg.max_sense_bytes = karg32.max_sense_bytes;
         karg.data_sge_offset = karg32.data_sge_offset;
-        memcpy(&karg.reply_frame_buf_ptr, &karg32.reply_frame_buf_ptr,
-            sizeof(uint32_t));
-        memcpy(&karg.data_in_buf_ptr, &karg32.data_in_buf_ptr,
-            sizeof(uint32_t));
-        memcpy(&karg.data_out_buf_ptr, &karg32.data_out_buf_ptr,
-            sizeof(uint32_t));
-        memcpy(&karg.sense_data_ptr, &karg32.sense_data_ptr,
-            sizeof(uint32_t));
+        karg.reply_frame_buf_ptr = compat_ptr(karg32.reply_frame_buf_ptr);
+        karg.data_in_buf_ptr = compat_ptr(karg32.data_in_buf_ptr);
+        karg.data_out_buf_ptr = compat_ptr(karg32.data_out_buf_ptr);
+        karg.sense_data_ptr = compat_ptr(karg32.sense_data_ptr);
         state = (file->f_flags & O_NONBLOCK) ? NON_BLOCKING : BLOCKING;
         return _ctl_do_mpt_command(ioc, karg, &uarg->mf, state);
 }
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index efabea1a3ce4..c7ec3f174782 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -52,6 +52,7 @@
 #include <linux/delay.h>
 #include <linux/pci.h>
 #include <linux/interrupt.h>
+#include <linux/raid_class.h>
 
 #include "mpt2sas_base.h"
 
@@ -133,6 +134,9 @@ struct fw_event_work {
         void                    *event_data;
 };
 
+/* raid transport support */
+static struct raid_template *mpt2sas_raid_template;
+
 /**
  * struct _scsi_io_transfer - scsi io transfer
  * @handle: sas device handle (assigned by firmware)
@@ -1305,7 +1309,6 @@ _scsih_slave_alloc(struct scsi_device *sdev)
         struct MPT2SAS_DEVICE *sas_device_priv_data;
         struct scsi_target *starget;
         struct _raid_device *raid_device;
-        struct _sas_device *sas_device;
         unsigned long flags;
 
         sas_device_priv_data = kzalloc(sizeof(struct scsi_device), GFP_KERNEL);
@@ -1332,21 +1335,8 @@ _scsih_slave_alloc(struct scsi_device *sdev)
                 if (raid_device)
                         raid_device->sdev = sdev; /* raid is single lun */
                 spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
-        } else {
-                /* set TLR bit for SSP devices */
-                if (!(ioc->facts.IOCCapabilities &
-                     MPI2_IOCFACTS_CAPABILITY_TLR))
-                        goto out;
-                spin_lock_irqsave(&ioc->sas_device_lock, flags);
-                sas_device = mpt2sas_scsih_sas_device_find_by_sas_address(ioc,
-                   sas_device_priv_data->sas_target->sas_address);
-                spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
-                if (sas_device && sas_device->device_info &
-                    MPI2_SAS_DEVICE_INFO_SSP_TARGET)
-                        sas_device_priv_data->flags |= MPT_DEVICE_TLR_ON;
         }
 
- out:
         return 0;
 }
 
@@ -1419,6 +1409,140 @@ _scsih_display_sata_capabilities(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_is_raid - return boolean indicating device is raid volume
+ * @dev the device struct object
+ */
+static int
+_scsih_is_raid(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+
+        return (sdev->channel == RAID_CHANNEL) ? 1 : 0;
+}
+
+/**
+ * _scsih_get_resync - get raid volume resync percent complete
+ * @dev the device struct object
+ */
+static void
+_scsih_get_resync(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
+        static struct _raid_device *raid_device;
+        unsigned long flags;
+        Mpi2RaidVolPage0_t vol_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u32 volume_status_flags;
+        u8 percent_complete = 0;
+
+        spin_lock_irqsave(&ioc->raid_device_lock, flags);
+        raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
+            sdev->channel);
+        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+
+        if (!raid_device)
+                goto out;
+
+        if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle,
+             sizeof(Mpi2RaidVolPage0_t))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+
+        volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags);
+        if (volume_status_flags & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)
+                percent_complete = raid_device->percent_complete;
+ out:
+        raid_set_resync(mpt2sas_raid_template, dev, percent_complete);
+}
+
+/**
+ * _scsih_get_state - get raid volume level
+ * @dev the device struct object
+ */
+static void
+_scsih_get_state(struct device *dev)
+{
+        struct scsi_device *sdev = to_scsi_device(dev);
+        struct MPT2SAS_ADAPTER *ioc = shost_priv(sdev->host);
+        static struct _raid_device *raid_device;
+        unsigned long flags;
+        Mpi2RaidVolPage0_t vol_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u32 volstate;
+        enum raid_state state = RAID_STATE_UNKNOWN;
+
+        spin_lock_irqsave(&ioc->raid_device_lock, flags);
+        raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id,
+            sdev->channel);
+        spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+
+        if (!raid_device)
+                goto out;
+
+        if (mpt2sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0,
+             MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle,
+             sizeof(Mpi2RaidVolPage0_t))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                goto out;
+        }
+
+        volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags);
+        if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) {
+                state = RAID_STATE_RESYNCING;
+                goto out;
+        }
+
+        switch (vol_pg0.VolumeState) {
+        case MPI2_RAID_VOL_STATE_OPTIMAL:
+        case MPI2_RAID_VOL_STATE_ONLINE:
+                state = RAID_STATE_ACTIVE;
+                break;
+        case  MPI2_RAID_VOL_STATE_DEGRADED:
+                state = RAID_STATE_DEGRADED;
+                break;
+        case MPI2_RAID_VOL_STATE_FAILED:
+        case MPI2_RAID_VOL_STATE_MISSING:
+                state = RAID_STATE_OFFLINE;
+                break;
+        }
+ out:
+        raid_set_state(mpt2sas_raid_template, dev, state);
+}
+
+/**
+ * _scsih_set_level - set raid level
+ * @sdev: scsi device struct
+ * @raid_device: raid_device object
+ */
+static void
+_scsih_set_level(struct scsi_device *sdev, struct _raid_device *raid_device)
+{
+        enum raid_level level = RAID_LEVEL_UNKNOWN;
+
+        switch (raid_device->volume_type) {
+        case MPI2_RAID_VOL_TYPE_RAID0:
+                level = RAID_LEVEL_0;
+                break;
+        case MPI2_RAID_VOL_TYPE_RAID10:
+                level = RAID_LEVEL_10;
+                break;
+        case MPI2_RAID_VOL_TYPE_RAID1E:
+                level = RAID_LEVEL_1E;
+                break;
+        case MPI2_RAID_VOL_TYPE_RAID1:
+                level = RAID_LEVEL_1;
+                break;
+        }
+
+        raid_set_level(mpt2sas_raid_template, &sdev->sdev_gendev, level);
+}
+
+/**
  * _scsih_get_volume_capabilities - volume capabilities
  * @ioc: per adapter object
  * @sas_device: the raid_device object
@@ -1479,6 +1603,32 @@ _scsih_get_volume_capabilities(struct MPT2SAS_ADAPTER *ioc,
 }
 
 /**
+ * _scsih_enable_tlr - setting TLR flags
+ * @ioc: per adapter object
+ * @sdev: scsi device struct
+ *
+ * Enabling Transaction Layer Retries for tape devices when
+ * vpd page 0x90 is present
+ *
+ */
+static void
+_scsih_enable_tlr(struct MPT2SAS_ADAPTER *ioc, struct scsi_device *sdev)
+{
+        /* only for TAPE */
+        if (sdev->type != TYPE_TAPE)
+                return;
+
+        if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR))
+                return;
+
+        sas_enable_tlr(sdev);
+        sdev_printk(KERN_INFO, sdev, "TLR %s\n",
+            sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled");
+        return;
+
+}
+
+/**
  * _scsih_slave_configure - device configure routine.
  * @sdev: scsi device struct
  *
@@ -1574,6 +1724,8 @@ _scsih_slave_configure(struct scsi_device *sdev)
                     (unsigned long long)raid_device->wwid,
                     raid_device->num_pds, ds);
                 _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
+                /* raid transport support */
+                _scsih_set_level(sdev, raid_device);
                 return 0;
         }
 
@@ -1621,8 +1773,10 @@ _scsih_slave_configure(struct scsi_device *sdev)
 
         _scsih_change_queue_depth(sdev, qdepth, SCSI_QDEPTH_DEFAULT);
 
-        if (ssp_target)
+        if (ssp_target) {
                 sas_read_port_mode_page(sdev);
+                _scsih_enable_tlr(ioc, sdev);
+        }
         return 0;
 }
 
@@ -2908,8 +3062,9 @@ _scsih_qcmd(struct scsi_cmnd *scmd, void (*done)(struct scsi_cmnd *))
 
         } else
                 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ;
-
-        if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON))
+        /* Make sure Device is not raid volume */
+        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+            sas_is_tlr_enabled(scmd->device))
                 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON;
 
         smid = mpt2sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd);
@@ -3298,10 +3453,12 @@ _scsih_io_done(struct MPT2SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply)
                     le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF;
         if (!sas_device_priv_data->tlr_snoop_check) {
                 sas_device_priv_data->tlr_snoop_check++;
-                if ((sas_device_priv_data->flags & MPT_DEVICE_TLR_ON) &&
-                    response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME)
-                        sas_device_priv_data->flags &=
-                            ~MPT_DEVICE_TLR_ON;
+        if (!_scsih_is_raid(&scmd->device->sdev_gendev) &&
+                sas_is_tlr_enabled(scmd->device) &&
+                    response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) {
+                        sas_disable_tlr(scmd->device);
+                        sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n");
+                }
         }
 
         xfer_cnt = le32_to_cpu(mpi_reply->TransferCount);
@@ -5170,11 +5327,33 @@ static void
 _scsih_sas_ir_operation_status_event(struct MPT2SAS_ADAPTER *ioc,
     struct fw_event_work *fw_event)
 {
+        Mpi2EventDataIrOperationStatus_t *event_data = fw_event->event_data;
+        static struct _raid_device *raid_device;
+        unsigned long flags;
+        u16 handle;
+
 #ifdef CONFIG_SCSI_MPT2SAS_LOGGING
         if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)
                 _scsih_sas_ir_operation_status_event_debug(ioc,
-                     fw_event->event_data);
+                     event_data);
 #endif
+
+        /* code added for raid transport support */
+        if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) {
+
+                handle = le16_to_cpu(event_data->VolDevHandle);
+
+                spin_lock_irqsave(&ioc->raid_device_lock, flags);
+                raid_device = _scsih_raid_device_find_by_handle(ioc, handle);
+                spin_unlock_irqrestore(&ioc->raid_device_lock, flags);
+
+                if (!raid_device)
+                        return;
+
+                if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC)
+                        raid_device->percent_complete =
+                            event_data->PercentComplete;
+        }
 }
 
 /**
@@ -5998,6 +6177,8 @@ _scsih_remove(struct pci_dev *pdev)
         struct _sas_port *mpt2sas_port;
         struct _sas_device *sas_device;
         struct _sas_node *expander_sibling;
+        struct _raid_device *raid_device, *next;
+        struct MPT2SAS_TARGET *sas_target_priv_data;
         struct workqueue_struct *wq;
         unsigned long flags;
 
@@ -6011,6 +6192,21 @@ _scsih_remove(struct pci_dev *pdev)
         if (wq)
                 destroy_workqueue(wq);
 
+        /* release all the volumes */
+        list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list,
+            list) {
+                if (raid_device->starget) {
+                        sas_target_priv_data =
+                            raid_device->starget->hostdata;
+                        sas_target_priv_data->deleted = 1;
+                        scsi_remove_target(&raid_device->starget->dev);
+                }
+                printk(MPT2SAS_INFO_FMT "removing handle(0x%04x), wwid"
+                    "(0x%016llx)\n", ioc->name,  raid_device->handle,
+                    (unsigned long long) raid_device->wwid);
+                _scsih_raid_device_remove(ioc, raid_device);
+        }
+
         /* free ports attached to the sas_host */
  retry_again:
         list_for_each_entry(mpt2sas_port,
@@ -6373,6 +6569,13 @@ static struct pci_driver scsih_driver = {
 #endif
 };
 
+/* raid transport support */
+static struct raid_function_template mpt2sas_raid_functions = {
+        .cookie         = &scsih_driver_template,
+        .is_raid        = _scsih_is_raid,
+        .get_resync     = _scsih_get_resync,
+        .get_state      = _scsih_get_state,
+};
 
 /**
  * _scsih_init - main entry point for this driver.
@@ -6392,6 +6595,12 @@ _scsih_init(void)
             sas_attach_transport(&mpt2sas_transport_functions);
         if (!mpt2sas_transport_template)
                 return -ENODEV;
+        /* raid transport support */
+        mpt2sas_raid_template = raid_class_attach(&mpt2sas_raid_functions);
+        if (!mpt2sas_raid_template) {
+                sas_release_transport(mpt2sas_transport_template);
+                return -ENODEV;
+        }
 
         mpt2sas_base_initialize_callback_handler();
 
@@ -6426,8 +6635,11 @@ _scsih_init(void)
         mpt2sas_ctl_init();
 
         error = pci_register_driver(&scsih_driver);
-        if (error)
+        if (error) {
+                /* raid transport support */
+                raid_class_release(mpt2sas_raid_template);
                 sas_release_transport(mpt2sas_transport_template);
+        }
 
         return error;
 }
@@ -6445,7 +6657,8 @@ _scsih_exit(void)
 
         pci_unregister_driver(&scsih_driver);
 
-        sas_release_transport(mpt2sas_transport_template);
+        mpt2sas_ctl_exit();
+
         mpt2sas_base_release_callback_handler(scsi_io_cb_idx);
         mpt2sas_base_release_callback_handler(tm_cb_idx);
         mpt2sas_base_release_callback_handler(base_cb_idx);
@@ -6457,7 +6670,10 @@ _scsih_exit(void)
         mpt2sas_base_release_callback_handler(tm_tr_cb_idx);
         mpt2sas_base_release_callback_handler(tm_sas_control_cb_idx);
 
-        mpt2sas_ctl_exit();
+        /* raid transport support */
+        raid_class_release(mpt2sas_raid_template);
+        sas_release_transport(mpt2sas_transport_template);
+
 }
 
 module_init(_scsih_init);
diff --git a/drivers/scsi/mpt2sas/mpt2sas_transport.c b/drivers/scsi/mpt2sas/mpt2sas_transport.c
index 3a82872bad44..789f9ee7f001 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_transport.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_transport.c
@@ -855,6 +855,17 @@ rphy_to_ioc(struct sas_rphy *rphy)
         return shost_priv(shost);
 }
 
+static struct _sas_phy *
+_transport_find_local_phy(struct MPT2SAS_ADAPTER *ioc, struct sas_phy *phy)
+{
+        int i;
+
+        for (i = 0; i < ioc->sas_hba.num_phys; i++)
+                if (ioc->sas_hba.phy[i].phy == phy)
+                        return(&ioc->sas_hba.phy[i]);
+        return NULL;
+}
+
 /**
  * _transport_get_linkerrors -
  * @phy: The sas phy object
@@ -870,14 +881,8 @@ _transport_get_linkerrors(struct sas_phy *phy)
         struct _sas_phy *mpt2sas_phy;
         Mpi2ConfigReply_t mpi_reply;
         Mpi2SasPhyPage1_t phy_pg1;
-        int i;
 
-        for (i = 0, mpt2sas_phy = NULL; i < ioc->sas_hba.num_phys &&
-            !mpt2sas_phy; i++) {
-                if (ioc->sas_hba.phy[i].phy != phy)
-                        continue;
-                mpt2sas_phy = &ioc->sas_hba.phy[i];
-        }
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
 
         if (!mpt2sas_phy) /* this phy not on sas_host */
                 return -EINVAL;
@@ -971,14 +976,8 @@ _transport_phy_reset(struct sas_phy *phy, int hard_reset)
         struct _sas_phy *mpt2sas_phy;
         Mpi2SasIoUnitControlReply_t mpi_reply;
         Mpi2SasIoUnitControlRequest_t mpi_request;
-        int i;
 
-        for (i = 0, mpt2sas_phy = NULL; i < ioc->sas_hba.num_phys &&
-            !mpt2sas_phy; i++) {
-                if (ioc->sas_hba.phy[i].phy != phy)
-                        continue;
-                mpt2sas_phy = &ioc->sas_hba.phy[i];
-        }
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
 
         if (!mpt2sas_phy) /* this phy not on sas_host */
                 return -EINVAL;
@@ -1006,6 +1005,173 @@ _transport_phy_reset(struct sas_phy *phy, int hard_reset)
 }
 
 /**
+ * _transport_phy_enable - enable/disable phys
+ * @phy: The sas phy object
+ * @enable: enable phy when true
+ *
+ * Only support sas_host direct attached phys.
+ * Returns 0 for success, non-zero for failure.
+ */
+static int
+_transport_phy_enable(struct sas_phy *phy, int enable)
+{
+        struct MPT2SAS_ADAPTER *ioc = phy_to_ioc(phy);
+        struct _sas_phy *mpt2sas_phy;
+        Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 ioc_status;
+        u16 sz;
+        int rc = 0;
+
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
+
+        if (!mpt2sas_phy) /* this phy not on sas_host */
+                return -EINVAL;
+
+        /* sas_iounit page 1 */
+        sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
+            sizeof(Mpi2SasIOUnit1PhyData_t));
+        sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
+        if (!sas_iounit_pg1) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENOMEM;
+                goto out;
+        }
+        if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
+            sas_iounit_pg1, sz))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -EIO;
+                goto out;
+        }
+
+        if (enable)
+                sas_iounit_pg1->PhyData[mpt2sas_phy->phy_id].PhyFlags
+                    &= ~MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
+        else
+                sas_iounit_pg1->PhyData[mpt2sas_phy->phy_id].PhyFlags
+                    |= MPI2_SASIOUNIT1_PHYFLAGS_PHY_DISABLE;
+
+        mpt2sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1, sz);
+
+ out:
+        kfree(sas_iounit_pg1);
+        return rc;
+}
+
+/**
+ * _transport_phy_speed - set phy min/max link rates
+ * @phy: The sas phy object
+ * @rates: rates defined in sas_phy_linkrates
+ *
+ * Only support sas_host direct attached phys.
+ * Returns 0 for success, non-zero for failure.
+ */
+static int
+_transport_phy_speed(struct sas_phy *phy, struct sas_phy_linkrates *rates)
+{
+        struct MPT2SAS_ADAPTER *ioc = phy_to_ioc(phy);
+        struct _sas_phy *mpt2sas_phy;
+        Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL;
+        Mpi2SasPhyPage0_t phy_pg0;
+        Mpi2ConfigReply_t mpi_reply;
+        u16 ioc_status;
+        u16 sz;
+        int i;
+        int rc = 0;
+
+        mpt2sas_phy = _transport_find_local_phy(ioc, phy);
+
+        if (!mpt2sas_phy) /* this phy not on sas_host */
+                return -EINVAL;
+
+        if (!rates->minimum_linkrate)
+                rates->minimum_linkrate = phy->minimum_linkrate;
+        else if (rates->minimum_linkrate < phy->minimum_linkrate_hw)
+                rates->minimum_linkrate = phy->minimum_linkrate_hw;
+
+        if (!rates->maximum_linkrate)
+                rates->maximum_linkrate = phy->maximum_linkrate;
+        else if (rates->maximum_linkrate > phy->maximum_linkrate_hw)
+                rates->maximum_linkrate = phy->maximum_linkrate_hw;
+
+        /* sas_iounit page 1 */
+        sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys *
+            sizeof(Mpi2SasIOUnit1PhyData_t));
+        sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL);
+        if (!sas_iounit_pg1) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENOMEM;
+                goto out;
+        }
+        if ((mpt2sas_config_get_sas_iounit_pg1(ioc, &mpi_reply,
+            sas_iounit_pg1, sz))) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+        ioc_status = le16_to_cpu(mpi_reply.IOCStatus) &
+            MPI2_IOCSTATUS_MASK;
+        if (ioc_status != MPI2_IOCSTATUS_SUCCESS) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -EIO;
+                goto out;
+        }
+
+        for (i = 0; i < ioc->sas_hba.num_phys; i++) {
+                if (mpt2sas_phy->phy_id != i) {
+                        sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
+                            (ioc->sas_hba.phy[i].phy->minimum_linkrate +
+                            (ioc->sas_hba.phy[i].phy->maximum_linkrate << 4));
+                } else {
+                        sas_iounit_pg1->PhyData[i].MaxMinLinkRate =
+                            (rates->minimum_linkrate +
+                            (rates->maximum_linkrate << 4));
+                }
+        }
+
+        if (mpt2sas_config_set_sas_iounit_pg1(ioc, &mpi_reply, sas_iounit_pg1,
+            sz)) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
+                    ioc->name, __FILE__, __LINE__, __func__);
+                rc = -ENXIO;
+                goto out;
+        }
+
+        /* link reset */
+        _transport_phy_reset(phy, 0);
+
+        /* read phy page 0, then update the rates in the sas transport phy */
+        if (!mpt2sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0,
+            mpt2sas_phy->phy_id)) {
+                phy->minimum_linkrate = _transport_convert_phy_link_rate(
+                    phy_pg0.ProgrammedLinkRate & MPI2_SAS_PRATE_MIN_RATE_MASK);
+                phy->maximum_linkrate = _transport_convert_phy_link_rate(
+                    phy_pg0.ProgrammedLinkRate >> 4);
+                phy->negotiated_linkrate = _transport_convert_phy_link_rate(
+                    phy_pg0.NegotiatedLinkRate &
+                    MPI2_SAS_NEG_LINK_RATE_MASK_PHYSICAL);
+        }
+
+ out:
+        kfree(sas_iounit_pg1);
+        return rc;
+}
+
+
+/**
  * _transport_smp_handler - transport portal for smp passthru
  * @shost: shost object
  * @rphy: sas transport rphy object
@@ -1207,6 +1373,8 @@ struct sas_function_template mpt2sas_transport_functions = {
         .get_enclosure_identifier = _transport_get_enclosure_identifier,
         .get_bay_identifier     = _transport_get_bay_identifier,
         .phy_reset              = _transport_phy_reset,
+        .phy_enable             = _transport_phy_enable,
+        .set_phy_speed          = _transport_phy_speed,
         .smp_handler            = _transport_smp_handler,
 };
 
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
index c2f1032496cb..f80c1da8f6ca 100644
--- a/drivers/scsi/pm8001/pm8001_init.c
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -654,7 +654,7 @@ static int __devinit pm8001_pci_probe(struct pci_dev *pdev,
         }
         chip = &pm8001_chips[ent->driver_data];
         SHOST_TO_SAS_HA(shost) =
-                kcalloc(1, sizeof(struct sas_ha_struct), GFP_KERNEL);
+                kzalloc(sizeof(struct sas_ha_struct), GFP_KERNEL);
         if (!SHOST_TO_SAS_HA(shost)) {
                 rc = -ENOMEM;
                 goto err_out_free_host;
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index 8371d917a9a2..49ac4148493b 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -1640,8 +1640,10 @@ qla1280_load_firmware_pio(struct scsi_qla_host *ha)
         uint16_t mb[MAILBOX_REGISTER_COUNT], i;
         int err;
 
+        spin_unlock_irq(ha->host->host_lock);
         err = request_firmware(&fw, ql1280_board_tbl[ha->devnum].fwname,
                                &ha->pdev->dev);
+        spin_lock_irq(ha->host->host_lock);
         if (err) {
                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
                        ql1280_board_tbl[ha->devnum].fwname, err);
@@ -1699,8 +1701,10 @@ qla1280_load_firmware_dma(struct scsi_qla_host *ha)
                 return -ENOMEM;
 #endif
 
+        spin_unlock_irq(ha->host->host_lock);
         err = request_firmware(&fw, ql1280_board_tbl[ha->devnum].fwname,
                                &ha->pdev->dev);
+        spin_lock_irq(ha->host->host_lock);
         if (err) {
                 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
                        ql1280_board_tbl[ha->devnum].fwname, err);
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 3a9f5b288aee..90d1e062ec4f 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -11,7 +11,9 @@
 #include <linux/delay.h>
 
 static int qla24xx_vport_disable(struct fc_vport *, bool);
-
+static int qla84xx_reset(scsi_qla_host_t *, struct msg_echo_lb *, struct fc_bsg_job *);
+int qla84xx_reset_chip(scsi_qla_host_t *, uint16_t, uint16_t *);
+static int qla84xx_mgmt_cmd(scsi_qla_host_t *, struct msg_echo_lb *, struct fc_bsg_job *);
 /* SYSFS attributes --------------------------------------------------------- */
 
 static ssize_t
@@ -1168,6 +1170,28 @@ qla2x00_total_isp_aborts_show(struct device *dev,
 }
 
 static ssize_t
+qla24xx_84xx_fw_version_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        int rval = QLA_SUCCESS;
+        uint16_t status[2] = {0, 0};
+        scsi_qla_host_t *vha = shost_priv(class_to_shost(dev));
+        struct qla_hw_data *ha = vha->hw;
+
+        if (IS_QLA84XX(ha) && ha->cs84xx) {
+                if (ha->cs84xx->op_fw_version == 0) {
+                        rval = qla84xx_verify_chip(vha, status);
+        }
+
+        if ((rval == QLA_SUCCESS) && (status[0] == 0))
+                return snprintf(buf, PAGE_SIZE, "%u\n",
+                        (uint32_t)ha->cs84xx->op_fw_version);
+        }
+
+        return snprintf(buf, PAGE_SIZE, "\n");
+}
+
+static ssize_t
 qla2x00_mpi_version_show(struct device *dev, struct device_attribute *attr,
     char *buf)
 {
@@ -1281,6 +1305,8 @@ static DEVICE_ATTR(optrom_fcode_version, S_IRUGO,
                    qla2x00_optrom_fcode_version_show, NULL);
 static DEVICE_ATTR(optrom_fw_version, S_IRUGO, qla2x00_optrom_fw_version_show,
                    NULL);
+static DEVICE_ATTR(84xx_fw_version, S_IRUGO, qla24xx_84xx_fw_version_show,
+                   NULL);
 static DEVICE_ATTR(total_isp_aborts, S_IRUGO, qla2x00_total_isp_aborts_show,
                    NULL);
 static DEVICE_ATTR(mpi_version, S_IRUGO, qla2x00_mpi_version_show, NULL);
@@ -1310,6 +1336,7 @@ struct device_attribute *qla2x00_host_attrs[] = {
         &dev_attr_optrom_efi_version,
         &dev_attr_optrom_fcode_version,
         &dev_attr_optrom_fw_version,
+        &dev_attr_84xx_fw_version,
         &dev_attr_total_isp_aborts,
         &dev_attr_mpi_version,
         &dev_attr_phy_version,
@@ -1504,8 +1531,6 @@ qla2x00_terminate_rport_io(struct fc_rport *rport)
                 fcport->vha->hw->isp_ops->fabric_logout(fcport->vha,
                         fcport->loop_id, fcport->d_id.b.domain,
                         fcport->d_id.b.area, fcport->d_id.b.al_pa);
-
-        qla2x00_abort_fcport_cmds(fcport);
 }
 
 static int
@@ -1795,6 +1820,581 @@ qla24xx_vport_disable(struct fc_vport *fc_vport, bool disable)
         return 0;
 }
 
+/* BSG support for ELS/CT pass through */
+inline srb_t *
+qla2x00_get_ctx_bsg_sp(scsi_qla_host_t *vha, fc_port_t *fcport, size_t size)
+{
+        srb_t *sp;
+        struct qla_hw_data *ha = vha->hw;
+        struct srb_bsg_ctx *ctx;
+
+        sp = mempool_alloc(ha->srb_mempool, GFP_KERNEL);
+        if (!sp)
+                goto done;
+        ctx = kzalloc(size, GFP_KERNEL);
+        if (!ctx) {
+                mempool_free(sp, ha->srb_mempool);
+                goto done;
+        }
+
+        memset(sp, 0, sizeof(*sp));
+        sp->fcport = fcport;
+        sp->ctx = ctx;
+done:
+        return sp;
+}
+
+static int
+qla2x00_process_els(struct fc_bsg_job *bsg_job)
+{
+        struct fc_rport *rport;
+        fc_port_t *fcport;
+        struct Scsi_Host *host;
+        scsi_qla_host_t *vha;
+        struct qla_hw_data *ha;
+        srb_t *sp;
+        const char *type;
+        int req_sg_cnt, rsp_sg_cnt;
+        int rval =  (DRIVER_ERROR << 16);
+        uint16_t nextlid = 0;
+        struct srb_bsg *els;
+
+        /*  Multiple SG's are not supported for ELS requests */
+        if (bsg_job->request_payload.sg_cnt > 1 ||
+                bsg_job->reply_payload.sg_cnt > 1) {
+                DEBUG2(printk(KERN_INFO
+                    "multiple SG's are not supported for ELS requests"
+                    " [request_sg_cnt: %x reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt,
+                    bsg_job->reply_payload.sg_cnt));
+                rval = -EPERM;
+                goto done;
+        }
+
+        /* ELS request for rport */
+        if (bsg_job->request->msgcode == FC_BSG_RPT_ELS) {
+                rport = bsg_job->rport;
+                fcport = *(fc_port_t **) rport->dd_data;
+                host = rport_to_shost(rport);
+                vha = shost_priv(host);
+                ha = vha->hw;
+                type = "FC_BSG_RPT_ELS";
+
+                /* make sure the rport is logged in,
+                 * if not perform fabric login
+                 */
+                if (qla2x00_fabric_login(vha, fcport, &nextlid)) {
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                            "failed to login port %06X for ELS passthru\n",
+                            fcport->d_id.b24));
+                        rval = -EIO;
+                        goto done;
+                }
+        } else {
+                host = bsg_job->shost;
+                vha = shost_priv(host);
+                ha = vha->hw;
+                type = "FC_BSG_HST_ELS_NOLOGIN";
+
+                /* Allocate a dummy fcport structure, since functions
+                 * preparing the IOCB and mailbox command retrieves port
+                 * specific information from fcport structure. For Host based
+                 * ELS commands there will be no fcport structure allocated
+                 */
+                fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
+                if (!fcport) {
+                        rval = -ENOMEM;
+                        goto done;
+                }
+
+                /* Initialize all required  fields of fcport */
+                fcport->vha = vha;
+                fcport->vp_idx = vha->vp_idx;
+                fcport->d_id.b.al_pa =
+                    bsg_job->request->rqst_data.h_els.port_id[0];
+                fcport->d_id.b.area =
+                    bsg_job->request->rqst_data.h_els.port_id[1];
+                fcport->d_id.b.domain =
+                    bsg_job->request->rqst_data.h_els.port_id[2];
+                fcport->loop_id =
+                    (fcport->d_id.b.al_pa == 0xFD) ?
+                    NPH_FABRIC_CONTROLLER : NPH_F_PORT;
+        }
+
+        if (!vha->flags.online) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "host not online\n"));
+                rval = -EIO;
+                goto done;
+        }
+
+        req_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        if (!req_sg_cnt) {
+                rval = -ENOMEM;
+                goto done_free_fcport;
+        }
+        rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if (!rsp_sg_cnt) {
+                rval = -ENOMEM;
+                goto done_free_fcport;
+        }
+
+        if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
+            (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt))
+        {
+                DEBUG2(printk(KERN_INFO
+                    "dma mapping resulted in different sg counts \
+                    [request_sg_cnt: %x dma_request_sg_cnt: %x\
+                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt, req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, rsp_sg_cnt));
+                rval = -EAGAIN;
+                goto done_unmap_sg;
+        }
+
+        /* Alloc SRB structure */
+        sp = qla2x00_get_ctx_bsg_sp(vha, fcport, sizeof(struct srb_bsg));
+        if (!sp) {
+                rval = -ENOMEM;
+                goto done_unmap_sg;
+        }
+
+        els = sp->ctx;
+        els->ctx.type =
+            (bsg_job->request->msgcode == FC_BSG_RPT_ELS ?
+            SRB_ELS_CMD_RPT : SRB_ELS_CMD_HST);
+        els->bsg_job = bsg_job;
+
+        DEBUG2(qla_printk(KERN_INFO, ha,
+            "scsi(%ld:%x): bsg rqst type: %s els type: %x - loop-id=%x "
+            "portid=%02x%02x%02x.\n", vha->host_no, sp->handle, type,
+            bsg_job->request->rqst_data.h_els.command_code,
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa));
+
+        rval = qla2x00_start_sp(sp);
+        if (rval != QLA_SUCCESS) {
+                kfree(sp->ctx);
+                mempool_free(sp, ha->srb_mempool);
+                rval = -EIO;
+                goto done_unmap_sg;
+        }
+        return rval;
+
+done_unmap_sg:
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+                bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+                bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        goto done_free_fcport;
+
+done_free_fcport:
+        if (bsg_job->request->msgcode == FC_BSG_HST_ELS_NOLOGIN)
+                kfree(fcport);
+done:
+        return rval;
+}
+
+static int
+qla2x00_process_ct(struct fc_bsg_job *bsg_job)
+{
+        srb_t *sp;
+        struct Scsi_Host *host = bsg_job->shost;
+        scsi_qla_host_t *vha = shost_priv(host);
+        struct qla_hw_data *ha = vha->hw;
+        int rval = (DRIVER_ERROR << 16);
+        int req_sg_cnt, rsp_sg_cnt;
+        uint16_t loop_id;
+        struct fc_port *fcport;
+        char  *type = "FC_BSG_HST_CT";
+        struct srb_bsg *ct;
+
+        /* pass through is supported only for ISP 4Gb or higher */
+        if (!IS_FWI2_CAPABLE(ha)) {
+                DEBUG2(qla_printk(KERN_INFO, ha,
+                    "scsi(%ld):Firmware is not capable to support FC "
+                    "CT pass thru\n", vha->host_no));
+                rval = -EPERM;
+                goto done;
+        }
+
+        req_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        if (!req_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+
+        rsp_sg_cnt = dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if (!rsp_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+
+        if ((req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
+                (rsp_sg_cnt != bsg_job->reply_payload.sg_cnt))
+        {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "dma mapping resulted in different sg counts \
+                    [request_sg_cnt: %x dma_request_sg_cnt: %x\
+                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt, req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, rsp_sg_cnt));
+                rval = -EAGAIN;
+                goto done_unmap_sg;
+        }
+
+        if (!vha->flags.online) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "host not online\n"));
+                rval = -EIO;
+                goto done_unmap_sg;
+        }
+
+        loop_id =
+            (bsg_job->request->rqst_data.h_ct.preamble_word1 & 0xFF000000)
+            >> 24;
+        switch (loop_id) {
+                case 0xFC:
+                        loop_id = cpu_to_le16(NPH_SNS);
+                        break;
+                case 0xFA:
+                        loop_id = vha->mgmt_svr_loop_id;
+                        break;
+                default:
+                        DEBUG2(qla_printk(KERN_INFO, ha,
+                            "Unknown loop id: %x\n", loop_id));
+                        rval = -EINVAL;
+                        goto done_unmap_sg;
+        }
+
+        /* Allocate a dummy fcport structure, since functions preparing the
+         * IOCB and mailbox command retrieves port specific information
+         * from fcport structure. For Host based ELS commands there will be
+         * no fcport structure allocated
+         */
+        fcport = qla2x00_alloc_fcport(vha, GFP_KERNEL);
+        if (!fcport)
+        {
+                rval = -ENOMEM;
+                goto  done_unmap_sg;
+        }
+
+        /* Initialize all required  fields of fcport */
+        fcport->vha = vha;
+        fcport->vp_idx = vha->vp_idx;
+        fcport->d_id.b.al_pa = bsg_job->request->rqst_data.h_ct.port_id[0];
+        fcport->d_id.b.area = bsg_job->request->rqst_data.h_ct.port_id[1];
+        fcport->d_id.b.domain = bsg_job->request->rqst_data.h_ct.port_id[2];
+        fcport->loop_id = loop_id;
+
+        /* Alloc SRB structure */
+        sp = qla2x00_get_ctx_bsg_sp(vha, fcport, sizeof(struct srb_bsg));
+        if (!sp) {
+                rval = -ENOMEM;
+                goto done_free_fcport;
+        }
+
+        ct = sp->ctx;
+        ct->ctx.type = SRB_CT_CMD;
+        ct->bsg_job = bsg_job;
+
+        DEBUG2(qla_printk(KERN_INFO, ha,
+            "scsi(%ld:%x): bsg rqst type: %s els type: %x - loop-id=%x "
+            "portid=%02x%02x%02x.\n", vha->host_no, sp->handle, type,
+            (bsg_job->request->rqst_data.h_ct.preamble_word2 >> 16),
+            fcport->loop_id, fcport->d_id.b.domain, fcport->d_id.b.area,
+            fcport->d_id.b.al_pa));
+
+        rval = qla2x00_start_sp(sp);
+        if (rval != QLA_SUCCESS) {
+                kfree(sp->ctx);
+                mempool_free(sp, ha->srb_mempool);
+                rval = -EIO;
+                goto done_free_fcport;
+        }
+        return rval;
+
+done_free_fcport:
+        kfree(fcport);
+done_unmap_sg:
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+done:
+        return rval;
+}
+
+static int
+qla2x00_process_vendor_specific(struct fc_bsg_job *bsg_job)
+{
+        struct Scsi_Host *host = bsg_job->shost;
+        scsi_qla_host_t *vha = shost_priv(host);
+        struct qla_hw_data *ha = vha->hw;
+        int rval;
+        uint8_t command_sent;
+        uint32_t vendor_cmd;
+        char *type;
+        struct msg_echo_lb elreq;
+        uint16_t response[MAILBOX_REGISTER_COUNT];
+        uint8_t* fw_sts_ptr;
+        uint8_t *req_data;
+        dma_addr_t req_data_dma;
+        uint32_t req_data_len;
+        uint8_t *rsp_data;
+        dma_addr_t rsp_data_dma;
+        uint32_t rsp_data_len;
+
+        if (test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) ||
+            test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) ||
+            test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
+                rval = -EBUSY;
+                goto done;
+        }
+
+        if (!vha->flags.online) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                    "host not online\n"));
+                rval = -EIO;
+                goto done;
+        }
+
+        elreq.req_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        if (!elreq.req_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+        elreq.rsp_sg_cnt =
+            dma_map_sg(&ha->pdev->dev, bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if (!elreq.rsp_sg_cnt) {
+                rval = -ENOMEM;
+                goto done;
+        }
+
+        if ((elreq.req_sg_cnt !=  bsg_job->request_payload.sg_cnt) ||
+            (elreq.rsp_sg_cnt != bsg_job->reply_payload.sg_cnt))
+        {
+                DEBUG2(printk(KERN_INFO
+                    "dma mapping resulted in different sg counts \
+                    [request_sg_cnt: %x dma_request_sg_cnt: %x\
+                    reply_sg_cnt: %x dma_reply_sg_cnt: %x]\n",
+                    bsg_job->request_payload.sg_cnt, elreq.req_sg_cnt,
+                    bsg_job->reply_payload.sg_cnt, elreq.rsp_sg_cnt));
+                rval = -EAGAIN;
+                goto done_unmap_sg;
+        }
+        req_data_len = rsp_data_len = bsg_job->request_payload.payload_len;
+        req_data = dma_alloc_coherent(&ha->pdev->dev, req_data_len,
+            &req_data_dma, GFP_KERNEL);
+
+        rsp_data = dma_alloc_coherent(&ha->pdev->dev, rsp_data_len,
+            &rsp_data_dma, GFP_KERNEL);
+
+        /* Copy the request buffer in req_data now */
+        sg_copy_to_buffer(bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, req_data,
+            req_data_len);
+
+        elreq.send_dma = req_data_dma;
+        elreq.rcv_dma = rsp_data_dma;
+        elreq.transfer_size = req_data_len;
+
+        /* Vendor cmd : loopback or ECHO diagnostic
+         * Options:
+         *      Loopback : Either internal or external loopback
+         *      ECHO: ECHO ELS or Vendor specific FC4  link data
+         */
+        vendor_cmd = bsg_job->request->rqst_data.h_vendor.vendor_cmd[0];
+        elreq.options =
+            *(((uint32_t *)bsg_job->request->rqst_data.h_vendor.vendor_cmd)
+            + 1);
+
+        switch (bsg_job->request->rqst_data.h_vendor.vendor_cmd[0]) {
+        case QL_VND_LOOPBACK:
+                if (ha->current_topology != ISP_CFG_F) {
+                        type = "FC_BSG_HST_VENDOR_LOOPBACK";
+
+                        DEBUG2(qla_printk(KERN_INFO, ha,
+                                "scsi(%ld) bsg rqst type: %s vendor rqst type: %x options: %x.\n",
+                                vha->host_no, type, vendor_cmd, elreq.options));
+
+                        command_sent = INT_DEF_LB_LOOPBACK_CMD;
+                        rval = qla2x00_loopback_test(vha, &elreq, response);
+                        if (IS_QLA81XX(ha)) {
+                                if (response[0] == MBS_COMMAND_ERROR && response[1] == MBS_LB_RESET) {
+                                        DEBUG2(printk(KERN_ERR "%s(%ld): ABORTing "
+                                                "ISP\n", __func__, vha->host_no));
+                                        set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
+                                        qla2xxx_wake_dpc(vha);
+                                 }
+                        }
+                } else {
+                        type = "FC_BSG_HST_VENDOR_ECHO_DIAG";
+                        DEBUG2(qla_printk(KERN_INFO, ha,
+                                "scsi(%ld) bsg rqst type: %s vendor rqst type: %x options: %x.\n",
+                                vha->host_no, type, vendor_cmd, elreq.options));
+
+                        command_sent = INT_DEF_LB_ECHO_CMD;
+                        rval = qla2x00_echo_test(vha, &elreq, response);
+                }
+                break;
+        case QLA84_RESET:
+                if (!IS_QLA84XX(vha->hw)) {
+                        rval = -EINVAL;
+                        DEBUG16(printk(
+                                "%s(%ld): 8xxx exiting.\n",
+                                __func__, vha->host_no));
+                        return rval;
+                }
+                rval = qla84xx_reset(vha, &elreq, bsg_job);
+                break;
+        case QLA84_MGMT_CMD:
+                if (!IS_QLA84XX(vha->hw)) {
+                        rval = -EINVAL;
+                        DEBUG16(printk(
+                                "%s(%ld): 8xxx exiting.\n",
+                                __func__, vha->host_no));
+                        return rval;
+                }
+                rval = qla84xx_mgmt_cmd(vha, &elreq, bsg_job);
+                break;
+        default:
+                rval = -ENOSYS;
+        }
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                        "scsi(%ld) Vendor request %s failed\n", vha->host_no, type));
+                rval = 0;
+                bsg_job->reply->result = (DID_ERROR << 16);
+                bsg_job->reply->reply_payload_rcv_len = 0;
+                fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                memcpy( fw_sts_ptr, response, sizeof(response));
+                fw_sts_ptr += sizeof(response);
+                *fw_sts_ptr = command_sent;
+        } else {
+                DEBUG2(qla_printk(KERN_WARNING, ha,
+                        "scsi(%ld) Vendor request %s completed\n", vha->host_no, type));
+                rval = bsg_job->reply->result = 0;
+                bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(response) + sizeof(uint8_t);
+                bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
+                fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                memcpy(fw_sts_ptr, response, sizeof(response));
+                fw_sts_ptr += sizeof(response);
+                *fw_sts_ptr = command_sent;
+                sg_copy_from_buffer(bsg_job->reply_payload.sg_list,
+                bsg_job->reply_payload.sg_cnt, rsp_data,
+                rsp_data_len);
+        }
+        bsg_job->job_done(bsg_job);
+
+done_unmap_sg:
+
+        if(req_data)
+                dma_free_coherent(&ha->pdev->dev, req_data_len,
+                        req_data, req_data_dma);
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+
+done:
+        return rval;
+}
+
+static int
+qla24xx_bsg_request(struct fc_bsg_job *bsg_job)
+{
+        int ret = -EINVAL;
+
+        switch (bsg_job->request->msgcode) {
+                case FC_BSG_RPT_ELS:
+                case FC_BSG_HST_ELS_NOLOGIN:
+                        ret = qla2x00_process_els(bsg_job);
+                        break;
+                case FC_BSG_HST_CT:
+                        ret = qla2x00_process_ct(bsg_job);
+                        break;
+                case FC_BSG_HST_VENDOR:
+                        ret = qla2x00_process_vendor_specific(bsg_job);
+                        break;
+                case FC_BSG_HST_ADD_RPORT:
+                case FC_BSG_HST_DEL_RPORT:
+                case FC_BSG_RPT_CT:
+                default:
+                        DEBUG2(printk("qla2xxx: unsupported BSG request\n"));
+                        break;
+        }
+        return ret;
+}
+
+static int
+qla24xx_bsg_timeout(struct fc_bsg_job *bsg_job)
+{
+        scsi_qla_host_t *vha = shost_priv(bsg_job->shost);
+        struct qla_hw_data *ha = vha->hw;
+        srb_t *sp;
+        int cnt, que;
+        unsigned long flags;
+        struct req_que *req;
+        struct srb_bsg *sp_bsg;
+
+        /* find the bsg job from the active list of commands */
+        spin_lock_irqsave(&ha->hardware_lock, flags);
+        for (que = 0; que < ha->max_req_queues; que++) {
+                req = ha->req_q_map[que];
+                if (!req)
+                        continue;
+
+                for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++ ) {
+                        sp = req->outstanding_cmds[cnt];
+
+                        if (sp) {
+                                sp_bsg = (struct srb_bsg*)sp->ctx;
+
+                                if (((sp_bsg->ctx.type == SRB_CT_CMD) ||
+                                    (sp_bsg->ctx.type == SRB_ELS_CMD_RPT)
+                                    || ( sp_bsg->ctx.type == SRB_ELS_CMD_HST)) &&
+                                    (sp_bsg->bsg_job == bsg_job)) {
+                                        if (ha->isp_ops->abort_command(sp)) {
+                                                DEBUG2(qla_printk(KERN_INFO, ha,
+                                                "scsi(%ld): mbx abort_command failed\n", vha->host_no));
+                                                bsg_job->req->errors = bsg_job->reply->result = -EIO;
+                                        } else {
+                                                DEBUG2(qla_printk(KERN_INFO, ha,
+                                                "scsi(%ld): mbx abort_command success\n", vha->host_no));
+                                                bsg_job->req->errors = bsg_job->reply->result = 0;
+                                        }
+                                        goto done;
+                                }
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&ha->hardware_lock, flags);
+        DEBUG2(qla_printk(KERN_INFO, ha,
+                "scsi(%ld) SRB not found to abort\n", vha->host_no));
+        bsg_job->req->errors = bsg_job->reply->result = -ENXIO;
+        return 0;
+
+done:
+        if (bsg_job->request->msgcode == FC_BSG_HST_CT)
+                kfree(sp->fcport);
+        kfree(sp->ctx);
+        mempool_free(sp, ha->srb_mempool);
+        return 0;
+}
+
 struct fc_function_template qla2xxx_transport_functions = {
 
         .show_host_node_name = 1,
@@ -1838,6 +2438,8 @@ struct fc_function_template qla2xxx_transport_functions = {
         .vport_create = qla24xx_vport_create,
         .vport_disable = qla24xx_vport_disable,
         .vport_delete = qla24xx_vport_delete,
+        .bsg_request = qla24xx_bsg_request,
+        .bsg_timeout = qla24xx_bsg_timeout,
 };
 
 struct fc_function_template qla2xxx_transport_vport_functions = {
@@ -1878,6 +2480,8 @@ struct fc_function_template qla2xxx_transport_vport_functions = {
         .dev_loss_tmo_callbk = qla2x00_dev_loss_tmo_callbk,
         .terminate_rport_io = qla2x00_terminate_rport_io,
         .get_fc_host_stats = qla2x00_get_fc_host_stats,
+        .bsg_request = qla24xx_bsg_request,
+        .bsg_timeout = qla24xx_bsg_timeout,
 };
 
 void
@@ -1906,3 +2510,125 @@ qla2x00_init_host_attr(scsi_qla_host_t *vha)
                 speed = FC_PORTSPEED_1GBIT;
         fc_host_supported_speeds(vha->host) = speed;
 }
+static int
+qla84xx_reset(scsi_qla_host_t *ha, struct msg_echo_lb *mreq, struct fc_bsg_job *bsg_job)
+{
+        int             ret = 0;
+        int             cmd;
+        uint16_t        cmd_status;
+
+        DEBUG16(printk("%s(%ld): entered.\n", __func__, ha->host_no));
+
+        cmd = (*((bsg_job->request->rqst_data.h_vendor.vendor_cmd) + 2))
+                        == A84_RESET_FLAG_ENABLE_DIAG_FW ?
+                                A84_ISSUE_RESET_DIAG_FW : A84_ISSUE_RESET_OP_FW;
+        ret = qla84xx_reset_chip(ha, cmd == A84_ISSUE_RESET_DIAG_FW,
+        &cmd_status);
+        return ret;
+}
+
+static int
+qla84xx_mgmt_cmd(scsi_qla_host_t *ha, struct msg_echo_lb *mreq, struct fc_bsg_job *bsg_job)
+{
+        struct access_chip_84xx *mn;
+        dma_addr_t mn_dma, mgmt_dma;
+        void *mgmt_b = NULL;
+        int ret = 0;
+        int rsp_hdr_len, len = 0;
+        struct qla84_msg_mgmt *ql84_mgmt;
+
+        ql84_mgmt = (struct qla84_msg_mgmt *) vmalloc(sizeof(struct qla84_msg_mgmt));
+        ql84_mgmt->cmd =
+                *((uint16_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 2));
+        ql84_mgmt->mgmtp.u.mem.start_addr =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 3));
+        ql84_mgmt->len =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 4));
+        ql84_mgmt->mgmtp.u.config.id =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 5));
+        ql84_mgmt->mgmtp.u.config.param0 =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 6));
+        ql84_mgmt->mgmtp.u.config.param1 =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 7));
+        ql84_mgmt->mgmtp.u.info.type =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 8));
+        ql84_mgmt->mgmtp.u.info.context =
+                *((uint32_t *)(bsg_job->request->rqst_data.h_vendor.vendor_cmd + 9));
+
+        rsp_hdr_len = bsg_job->request_payload.payload_len;
+
+        mn = dma_pool_alloc(ha->hw->s_dma_pool, GFP_KERNEL, &mn_dma);
+        if (mn == NULL) {
+                DEBUG2(printk(KERN_ERR "%s: dma alloc for fw buffer "
+                "failed%lu\n", __func__, ha->host_no));
+                return -ENOMEM;
+        }
+
+        memset(mn, 0, sizeof (struct access_chip_84xx));
+
+        mn->entry_type = ACCESS_CHIP_IOCB_TYPE;
+        mn->entry_count = 1;
+
+        switch (ql84_mgmt->cmd) {
+        case QLA84_MGMT_READ_MEM:
+                mn->options = cpu_to_le16(ACO_DUMP_MEMORY);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.mem.start_addr);
+                break;
+        case QLA84_MGMT_WRITE_MEM:
+                mn->options = cpu_to_le16(ACO_LOAD_MEMORY);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.mem.start_addr);
+                break;
+        case QLA84_MGMT_CHNG_CONFIG:
+                mn->options = cpu_to_le16(ACO_CHANGE_CONFIG_PARAM);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.config.id);
+                mn->parameter2 = cpu_to_le32(ql84_mgmt->mgmtp.u.config.param0);
+                mn->parameter3 = cpu_to_le32(ql84_mgmt->mgmtp.u.config.param1);
+                break;
+        case QLA84_MGMT_GET_INFO:
+                mn->options = cpu_to_le16(ACO_REQUEST_INFO);
+                mn->parameter1 = cpu_to_le32(ql84_mgmt->mgmtp.u.info.type);
+                mn->parameter2 = cpu_to_le32(ql84_mgmt->mgmtp.u.info.context);
+                break;
+        default:
+                ret = -EIO;
+                goto exit_mgmt0;
+        }
+
+        if ((len == ql84_mgmt->len) &&
+                ql84_mgmt->cmd != QLA84_MGMT_CHNG_CONFIG) {
+                mgmt_b = dma_alloc_coherent(&ha->hw->pdev->dev, len,
+                                &mgmt_dma, GFP_KERNEL);
+                if (mgmt_b == NULL) {
+                        DEBUG2(printk(KERN_ERR "%s: dma alloc mgmt_b "
+                        "failed%lu\n", __func__, ha->host_no));
+                        ret = -ENOMEM;
+                        goto exit_mgmt0;
+                }
+                mn->total_byte_cnt = cpu_to_le32(ql84_mgmt->len);
+                mn->dseg_count = cpu_to_le16(1);
+                mn->dseg_address[0] = cpu_to_le32(LSD(mgmt_dma));
+                mn->dseg_address[1] = cpu_to_le32(MSD(mgmt_dma));
+                mn->dseg_length = cpu_to_le32(len);
+
+                if (ql84_mgmt->cmd == QLA84_MGMT_WRITE_MEM) {
+                        memcpy(mgmt_b, ql84_mgmt->payload, len);
+                }
+        }
+
+        ret = qla2x00_issue_iocb(ha, mn, mn_dma, 0);
+        if ((ret != QLA_SUCCESS) || (ql84_mgmt->cmd == QLA84_MGMT_WRITE_MEM)
+                || (ql84_mgmt->cmd == QLA84_MGMT_CHNG_CONFIG)) {
+                        if (ret != QLA_SUCCESS)
+                                DEBUG2(printk(KERN_ERR "%s(%lu): failed\n",
+                                        __func__, ha->host_no));
+        } else if ((ql84_mgmt->cmd == QLA84_MGMT_READ_MEM) ||
+                        (ql84_mgmt->cmd == QLA84_MGMT_GET_INFO)) {
+        }
+
+        if (mgmt_b)
+                dma_free_coherent(&ha->hw->pdev->dev, len, mgmt_b, mgmt_dma);
+
+exit_mgmt0:
+        dma_pool_free(ha->hw->s_dma_pool, mn, mn_dma);
+        return ret;
+}
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 1263d9796e89..afa95614aaf8 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -31,6 +31,7 @@
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_transport_fc.h>
+#include <scsi/scsi_bsg_fc.h>
 
 #define QLA2XXX_DRIVER_NAME  "qla2xxx"
 
@@ -228,6 +229,27 @@ struct srb_logio {
         uint16_t flags;
 };
 
+struct srb_bsg_ctx {
+#define SRB_ELS_CMD_RPT 3
+#define SRB_ELS_CMD_HST 4
+#define SRB_CT_CMD 5
+        uint16_t type;
+};
+
+struct srb_bsg {
+        struct srb_bsg_ctx ctx;
+        struct fc_bsg_job *bsg_job;
+};
+
+struct msg_echo_lb {
+        dma_addr_t send_dma;
+        dma_addr_t rcv_dma;
+        uint16_t req_sg_cnt;
+        uint16_t rsp_sg_cnt;
+        uint16_t options;
+        uint32_t transfer_size;
+};
+
 /*
  * ISP I/O Register Set structure definitions.
  */
@@ -522,6 +544,8 @@ typedef struct {
 #define MBA_DISCARD_RND_FRAME   0x8048  /* discard RND frame due to error. */
 #define MBA_REJECTED_FCP_CMD    0x8049  /* rejected FCP_CMD. */
 
+/* ISP mailbox loopback echo diagnostic error code */
+#define MBS_LB_RESET    0x17
 /*
  * Firmware options 1, 2, 3.
  */
@@ -2230,6 +2254,13 @@ struct req_que {
         int max_q_depth;
 };
 
+/* Place holder for FW buffer parameters */
+struct qlfc_fw {
+        void *fw_buf;
+        dma_addr_t fw_dma;
+        uint32_t len;
+};
+
 /*
  * Qlogic host adapter specific data structure.
 */
@@ -2594,6 +2625,7 @@ struct qla_hw_data {
         struct qla_statistics qla_stats;
         struct isp_operations *isp_ops;
         struct workqueue_struct *wq;
+        struct qlfc_fw fw_buf;
 };
 
 /*
@@ -2766,4 +2798,127 @@ typedef struct scsi_qla_host {
 
 #define CMD_SP(Cmnd)            ((Cmnd)->SCp.ptr)
 
+/*
+ * BSG Vendor specific commands
+ */
+
+#define QL_VND_LOOPBACK         0x01
+#define QLA84_RESET             0x02
+#define QLA84_UPDATE_FW         0x03
+#define QLA84_MGMT_CMD          0x04
+
+/* BSG definations for interpreting CommandSent field */
+#define INT_DEF_LB_LOOPBACK_CMD         0
+#define INT_DEF_LB_ECHO_CMD             1
+
+/* BSG Vendor specific definations */
+typedef struct _A84_RESET {
+        uint16_t Flags;
+        uint16_t Reserved;
+#define A84_RESET_FLAG_ENABLE_DIAG_FW   1
+} __attribute__((packed)) A84_RESET, *PA84_RESET;
+
+#define A84_ISSUE_WRITE_TYPE_CMD        0
+#define A84_ISSUE_READ_TYPE_CMD         1
+#define A84_CLEANUP_CMD                 2
+#define A84_ISSUE_RESET_OP_FW           3
+#define A84_ISSUE_RESET_DIAG_FW         4
+#define A84_ISSUE_UPDATE_OPFW_CMD       5
+#define A84_ISSUE_UPDATE_DIAGFW_CMD     6
+
+struct qla84_mgmt_param {
+        union {
+                struct {
+                        uint32_t start_addr;
+                } mem; /* for QLA84_MGMT_READ/WRITE_MEM */
+                struct {
+                        uint32_t id;
+#define QLA84_MGMT_CONFIG_ID_UIF        1
+#define QLA84_MGMT_CONFIG_ID_FCOE_COS   2
+#define QLA84_MGMT_CONFIG_ID_PAUSE      3
+#define QLA84_MGMT_CONFIG_ID_TIMEOUTS   4
+
+                uint32_t param0;
+                uint32_t param1;
+        } config; /* for QLA84_MGMT_CHNG_CONFIG */
+
+        struct {
+                uint32_t type;
+#define QLA84_MGMT_INFO_CONFIG_LOG_DATA         1 /* Get Config Log Data */
+#define QLA84_MGMT_INFO_LOG_DATA                2 /* Get Log Data */
+#define QLA84_MGMT_INFO_PORT_STAT               3 /* Get Port Statistics */
+#define QLA84_MGMT_INFO_LIF_STAT                4 /* Get LIF Statistics  */
+#define QLA84_MGMT_INFO_ASIC_STAT               5 /* Get ASIC Statistics */
+#define QLA84_MGMT_INFO_CONFIG_PARAMS           6 /* Get Config Parameters */
+#define QLA84_MGMT_INFO_PANIC_LOG               7 /* Get Panic Log */
+
+                uint32_t context;
+/*
+* context definitions for QLA84_MGMT_INFO_CONFIG_LOG_DATA
+*/
+#define IC_LOG_DATA_LOG_ID_DEBUG_LOG                    0
+#define IC_LOG_DATA_LOG_ID_LEARN_LOG                    1
+#define IC_LOG_DATA_LOG_ID_FC_ACL_INGRESS_LOG           2
+#define IC_LOG_DATA_LOG_ID_FC_ACL_EGRESS_LOG            3
+#define IC_LOG_DATA_LOG_ID_ETHERNET_ACL_INGRESS_LOG     4
+#define IC_LOG_DATA_LOG_ID_ETHERNET_ACL_EGRESS_LOG      5
+#define IC_LOG_DATA_LOG_ID_MESSAGE_TRANSMIT_LOG         6
+#define IC_LOG_DATA_LOG_ID_MESSAGE_RECEIVE_LOG          7
+#define IC_LOG_DATA_LOG_ID_LINK_EVENT_LOG               8
+#define IC_LOG_DATA_LOG_ID_DCX_LOG                      9
+
+/*
+* context definitions for QLA84_MGMT_INFO_PORT_STAT
+*/
+#define IC_PORT_STATISTICS_PORT_NUMBER_ETHERNET_PORT0   0
+#define IC_PORT_STATISTICS_PORT_NUMBER_ETHERNET_PORT1   1
+#define IC_PORT_STATISTICS_PORT_NUMBER_NSL_PORT0        2
+#define IC_PORT_STATISTICS_PORT_NUMBER_NSL_PORT1        3
+#define IC_PORT_STATISTICS_PORT_NUMBER_FC_PORT0         4
+#define IC_PORT_STATISTICS_PORT_NUMBER_FC_PORT1         5
+
+
+/*
+* context definitions for QLA84_MGMT_INFO_LIF_STAT
+*/
+#define IC_LIF_STATISTICS_LIF_NUMBER_ETHERNET_PORT0     0
+#define IC_LIF_STATISTICS_LIF_NUMBER_ETHERNET_PORT1     1
+#define IC_LIF_STATISTICS_LIF_NUMBER_FC_PORT0           2
+#define IC_LIF_STATISTICS_LIF_NUMBER_FC_PORT1           3
+#define IC_LIF_STATISTICS_LIF_NUMBER_CPU                6
+
+                } info; /* for QLA84_MGMT_GET_INFO */
+        } u;
+};
+
+struct qla84_msg_mgmt {
+        uint16_t cmd;
+#define QLA84_MGMT_READ_MEM     0x00
+#define QLA84_MGMT_WRITE_MEM    0x01
+#define QLA84_MGMT_CHNG_CONFIG  0x02
+#define QLA84_MGMT_GET_INFO     0x03
+        uint16_t rsrvd;
+        struct qla84_mgmt_param mgmtp;/* parameters for cmd */
+        uint32_t len; /* bytes in payload following this struct */
+        uint8_t payload[0]; /* payload for cmd */
+};
+
+struct msg_update_fw {
+        /*
+        * diag_fw = 0  operational fw
+        *      otherwise diagnostic fw
+        * offset, len, fw_len are present to overcome the current limitation
+        * of 128Kb xfer size. The fw is sent in smaller chunks. Each chunk
+        * specifies the byte "offset" where it fits in the fw buffer. The
+        * number of bytes in each chunk is specified in "len". "fw_len"
+        * is the total size of fw. The first chunk should start at offset = 0.
+        * When offset+len == fw_len, the fw is written to the HBA.
+        */
+        uint32_t diag_fw;
+        uint32_t offset;/* start offset */
+        uint32_t len;   /* num bytes in cur xfer */
+        uint32_t fw_len; /* size of fw in bytes */
+        uint8_t fw_bytes[0];
+};
+
 #endif
diff --git a/drivers/scsi/qla2xxx/qla_fw.h b/drivers/scsi/qla2xxx/qla_fw.h
index 66a8da5d7d08..cebf4f1bb7d9 100644
--- a/drivers/scsi/qla2xxx/qla_fw.h
+++ b/drivers/scsi/qla2xxx/qla_fw.h
@@ -627,6 +627,39 @@ struct els_entry_24xx {
         uint32_t rx_len;                /* Data segment 1 length. */
 };
 
+struct els_sts_entry_24xx {
+        uint8_t entry_type;             /* Entry type. */
+        uint8_t entry_count;            /* Entry count. */
+        uint8_t sys_define;             /* System Defined. */
+        uint8_t entry_status;           /* Entry Status. */
+
+        uint32_t handle;                /* System handle. */
+
+        uint16_t comp_status;
+
+        uint16_t nport_handle;          /* N_PORT handle. */
+
+        uint16_t reserved_1;
+
+        uint8_t vp_index;
+        uint8_t sof_type;
+
+        uint32_t rx_xchg_address;       /* Receive exchange address. */
+        uint16_t reserved_2;
+
+        uint8_t opcode;
+        uint8_t reserved_3;
+
+        uint8_t port_id[3];
+        uint8_t reserved_4;
+
+        uint16_t reserved_5;
+
+        uint16_t control_flags;         /* Control flags. */
+        uint32_t total_byte_count;
+        uint32_t error_subcode_1;
+        uint32_t error_subcode_2;
+};
 /*
  * ISP queue - Mailbox Command entry structure definition.
  */
diff --git a/drivers/scsi/qla2xxx/qla_gbl.h b/drivers/scsi/qla2xxx/qla_gbl.h
index 8bc6f53691e9..3a89bc514e2b 100644
--- a/drivers/scsi/qla2xxx/qla_gbl.h
+++ b/drivers/scsi/qla2xxx/qla_gbl.h
@@ -60,6 +60,8 @@ extern int qla2x00_async_login_done(struct scsi_qla_host *, fc_port_t *,
 extern int qla2x00_async_logout_done(struct scsi_qla_host *, fc_port_t *,
     uint16_t *);
 
+extern fc_port_t *
+qla2x00_alloc_fcport(scsi_qla_host_t *, gfp_t );
 /*
  * Global Data in qla_os.c source file.
  */
@@ -76,6 +78,7 @@ extern int ql2xiidmaenable;
 extern int ql2xmaxqueues;
 extern int ql2xmultique_tag;
 extern int ql2xfwloadbin;
+extern int ql2xetsenable;
 
 extern int qla2x00_loop_reset(scsi_qla_host_t *);
 extern void qla2x00_abort_all_cmds(scsi_qla_host_t *, int);
@@ -94,7 +97,6 @@ extern int qla2x00_post_uevent_work(struct scsi_qla_host *, u32);
 
 extern int qla81xx_restart_mpi_firmware(scsi_qla_host_t *);
 
-extern void qla2x00_abort_fcport_cmds(fc_port_t *);
 extern struct scsi_qla_host *qla2x00_create_host(struct scsi_host_template *,
         struct qla_hw_data *);
 extern void qla2x00_free_host(struct scsi_qla_host *);
@@ -154,6 +156,7 @@ int qla2x00_marker(struct scsi_qla_host *, struct req_que *, struct rsp_que *,
 int __qla2x00_marker(struct scsi_qla_host *, struct req_que *, struct rsp_que *,
                                                 uint16_t, uint16_t, uint8_t);
 extern int qla2x00_start_sp(srb_t *);
+extern void qla2x00_ctx_sp_free(srb_t *);
 
 /*
  * Global Function Prototypes in qla_mbx.c source file.
@@ -426,6 +429,8 @@ extern void qla2x00_free_sysfs_attr(scsi_qla_host_t *);
 extern void qla2x00_init_host_attr(scsi_qla_host_t *);
 extern void qla2x00_alloc_sysfs_attr(scsi_qla_host_t *);
 extern void qla2x00_free_sysfs_attr(scsi_qla_host_t *);
+extern int qla2x00_loopback_test(scsi_qla_host_t *, struct msg_echo_lb *, uint16_t *);
+extern int qla2x00_echo_test(scsi_qla_host_t *, struct msg_echo_lb *, uint16_t *);
 
 /*
  * Global Function Prototypes in qla_dfs.c source file.
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 3f8e8495b743..a67b2bafb882 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -62,7 +62,7 @@ qla2x00_ctx_sp_timeout(unsigned long __data)
         ctx->free(sp);
 }
 
-static void
+void
 qla2x00_ctx_sp_free(srb_t *sp)
 {
         struct srb_ctx *ctx = sp->ctx;
@@ -338,6 +338,16 @@ qla2x00_initialize_adapter(scsi_qla_host_t *vha)
         rval = qla2x00_init_rings(vha);
         ha->flags.chip_reset_done = 1;
 
+        if (rval == QLA_SUCCESS && IS_QLA84XX(ha)) {
+        /* Issue verify 84xx FW IOCB to complete 84xx initialization */
+                rval = qla84xx_init_chip(vha);
+                if (rval != QLA_SUCCESS) {
+                        qla_printk(KERN_ERR, ha,
+                                "Unable to initialize ISP84XX.\n");
+                qla84xx_put_chip(vha);
+                }
+        }
+
         return (rval);
 }
 
@@ -2216,7 +2226,7 @@ qla2x00_rport_del(void *data)
  *
  * Returns a pointer to the allocated fcport, or NULL, if none available.
  */
-static fc_port_t *
+fc_port_t *
 qla2x00_alloc_fcport(scsi_qla_host_t *vha, gfp_t flags)
 {
         fc_port_t *fcport;
@@ -2900,8 +2910,13 @@ qla2x00_find_all_fabric_devs(scsi_qla_host_t *vha,
                 if (qla2x00_is_reserved_id(vha, loop_id))
                         continue;
 
-                if (atomic_read(&vha->loop_down_timer) || LOOP_TRANSITION(vha))
+                if (atomic_read(&vha->loop_down_timer) ||
+                    LOOP_TRANSITION(vha)) {
+                        atomic_set(&vha->loop_down_timer, 0);
+                        set_bit(LOOP_RESYNC_NEEDED, &vha->dpc_flags);
+                        set_bit(LOCAL_LOOP_UPDATE, &vha->dpc_flags);
                         break;
+                }
 
                 if (swl != NULL) {
                         if (last_dev) {
@@ -4877,6 +4892,15 @@ qla81xx_nvram_config(scsi_qla_host_t *vha)
 }
 
 void
-qla81xx_update_fw_options(scsi_qla_host_t *ha)
+qla81xx_update_fw_options(scsi_qla_host_t *vha)
 {
+        struct qla_hw_data *ha = vha->hw;
+
+        if (!ql2xetsenable)
+                return;
+
+        /* Enable ETS Burst. */
+        memset(ha->fw_options, 0, sizeof(ha->fw_options));
+        ha->fw_options[2] |= BIT_9;
+        qla2x00_set_fw_options(vha, ha->fw_options);
 }
diff --git a/drivers/scsi/qla2xxx/qla_iocb.c b/drivers/scsi/qla2xxx/qla_iocb.c
index c5ccac0bef76..8299a9891bfe 100644
--- a/drivers/scsi/qla2xxx/qla_iocb.c
+++ b/drivers/scsi/qla2xxx/qla_iocb.c
@@ -1025,6 +1025,119 @@ qla2x00_logout_iocb(srb_t *sp, struct mbx_entry *mbx)
         /* Implicit: mbx->mbx10 = 0. */
 }
 
+static void
+qla24xx_els_iocb(srb_t *sp, struct els_entry_24xx *els_iocb)
+{
+        struct fc_bsg_job *bsg_job = ((struct srb_bsg*)sp->ctx)->bsg_job;
+
+        els_iocb->entry_type = ELS_IOCB_TYPE;
+        els_iocb->entry_count = 1;
+        els_iocb->sys_define = 0;
+        els_iocb->entry_status = 0;
+        els_iocb->handle = sp->handle;
+        els_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
+        els_iocb->tx_dsd_count = __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
+        els_iocb->vp_index = sp->fcport->vp_idx;
+        els_iocb->sof_type = EST_SOFI3;
+        els_iocb->rx_dsd_count = __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt);
+
+        els_iocb->opcode =(((struct srb_bsg*)sp->ctx)->ctx.type == SRB_ELS_CMD_RPT) ?
+            bsg_job->request->rqst_data.r_els.els_code : bsg_job->request->rqst_data.h_els.command_code;
+        els_iocb->port_id[0] = sp->fcport->d_id.b.al_pa;
+        els_iocb->port_id[1] = sp->fcport->d_id.b.area;
+        els_iocb->port_id[2] = sp->fcport->d_id.b.domain;
+        els_iocb->control_flags = 0;
+        els_iocb->rx_byte_count =
+            cpu_to_le32(bsg_job->reply_payload.payload_len);
+        els_iocb->tx_byte_count =
+            cpu_to_le32(bsg_job->request_payload.payload_len);
+
+        els_iocb->tx_address[0] = cpu_to_le32(LSD(sg_dma_address
+            (bsg_job->request_payload.sg_list)));
+        els_iocb->tx_address[1] = cpu_to_le32(MSD(sg_dma_address
+            (bsg_job->request_payload.sg_list)));
+        els_iocb->tx_len = cpu_to_le32(sg_dma_len
+            (bsg_job->request_payload.sg_list));
+
+        els_iocb->rx_address[0] = cpu_to_le32(LSD(sg_dma_address
+            (bsg_job->reply_payload.sg_list)));
+        els_iocb->rx_address[1] = cpu_to_le32(MSD(sg_dma_address
+            (bsg_job->reply_payload.sg_list)));
+        els_iocb->rx_len = cpu_to_le32(sg_dma_len
+            (bsg_job->reply_payload.sg_list));
+}
+
+static void
+qla24xx_ct_iocb(srb_t *sp, struct ct_entry_24xx *ct_iocb)
+{
+        uint16_t        avail_dsds;
+        uint32_t        *cur_dsd;
+        struct scatterlist *sg;
+        int index;
+        uint16_t tot_dsds;
+        scsi_qla_host_t *vha = sp->fcport->vha;
+        struct fc_bsg_job *bsg_job = ((struct srb_bsg*)sp->ctx)->bsg_job;
+        int loop_iterartion = 0;
+        int cont_iocb_prsnt = 0;
+        int entry_count = 1;
+
+        ct_iocb->entry_type = CT_IOCB_TYPE;
+        ct_iocb->entry_status = 0;
+        ct_iocb->sys_define = 0;
+        ct_iocb->handle = sp->handle;
+
+        ct_iocb->nport_handle = cpu_to_le16(sp->fcport->loop_id);
+        ct_iocb->vp_index = sp->fcport->vp_idx;
+        ct_iocb->comp_status = __constant_cpu_to_le16(0);
+
+        ct_iocb->cmd_dsd_count =
+            __constant_cpu_to_le16(bsg_job->request_payload.sg_cnt);
+        ct_iocb->timeout = 0;
+        ct_iocb->rsp_dsd_count =
+            __constant_cpu_to_le16(bsg_job->reply_payload.sg_cnt);
+        ct_iocb->rsp_byte_count =
+            cpu_to_le32(bsg_job->reply_payload.payload_len);
+        ct_iocb->cmd_byte_count =
+            cpu_to_le32(bsg_job->request_payload.payload_len);
+        ct_iocb->dseg_0_address[0] = cpu_to_le32(LSD(sg_dma_address
+            (bsg_job->request_payload.sg_list)));
+        ct_iocb->dseg_0_address[1] = cpu_to_le32(MSD(sg_dma_address
+           (bsg_job->request_payload.sg_list)));
+        ct_iocb->dseg_0_len = cpu_to_le32(sg_dma_len
+            (bsg_job->request_payload.sg_list));
+
+        avail_dsds = 1;
+        cur_dsd = (uint32_t *)ct_iocb->dseg_1_address;
+        index = 0;
+        tot_dsds = bsg_job->reply_payload.sg_cnt;
+
+        for_each_sg(bsg_job->reply_payload.sg_list, sg, tot_dsds, index) {
+                dma_addr_t       sle_dma;
+                cont_a64_entry_t *cont_pkt;
+
+                /* Allocate additional continuation packets? */
+                if (avail_dsds == 0) {
+                        /*
+                        * Five DSDs are available in the Cont.
+                        * Type 1 IOCB.
+                               */
+                        cont_pkt = qla2x00_prep_cont_type1_iocb(vha);
+                        cur_dsd = (uint32_t *) cont_pkt->dseg_0_address;
+                        avail_dsds = 5;
+                        cont_iocb_prsnt = 1;
+                        entry_count++;
+                }
+
+                sle_dma = sg_dma_address(sg);
+                *cur_dsd++   = cpu_to_le32(LSD(sle_dma));
+                *cur_dsd++   = cpu_to_le32(MSD(sle_dma));
+                *cur_dsd++   = cpu_to_le32(sg_dma_len(sg));
+                loop_iterartion++;
+                avail_dsds--;
+        }
+        ct_iocb->entry_count = entry_count;
+}
+
 int
 qla2x00_start_sp(srb_t *sp)
 {
@@ -1052,6 +1165,13 @@ qla2x00_start_sp(srb_t *sp)
                     qla24xx_logout_iocb(sp, pkt):
                     qla2x00_logout_iocb(sp, pkt);
                 break;
+        case SRB_ELS_CMD_RPT:
+        case SRB_ELS_CMD_HST:
+                qla24xx_els_iocb(sp, pkt);
+                break;
+        case SRB_CT_CMD:
+                qla24xx_ct_iocb(sp, pkt);
+                break;
         default:
                 break;
         }
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 6fc63b98818c..ab90329ff2e4 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -8,6 +8,7 @@
 
 #include <linux/delay.h>
 #include <scsi/scsi_tcq.h>
+#include <scsi/scsi_bsg_fc.h>
 
 static void qla2x00_mbx_completion(scsi_qla_host_t *, uint16_t);
 static void qla2x00_process_completed_request(struct scsi_qla_host *,
@@ -881,7 +882,9 @@ qla2x00_get_sp_from_handle(scsi_qla_host_t *vha, const char *func,
                     index);
                 return NULL;
         }
+
         req->outstanding_cmds[index] = NULL;
+
 done:
         return sp;
 }
@@ -982,6 +985,100 @@ done_post_logio_done_work:
 }
 
 static void
+qla24xx_els_ct_entry(scsi_qla_host_t *vha, struct req_que *req,
+    struct sts_entry_24xx *pkt, int iocb_type)
+{
+        const char func[] = "ELS_CT_IOCB";
+        const char *type;
+        struct qla_hw_data *ha = vha->hw;
+        srb_t *sp;
+        struct srb_bsg *sp_bsg;
+        struct fc_bsg_job *bsg_job;
+        uint16_t comp_status;
+        uint32_t fw_status[3];
+        uint8_t* fw_sts_ptr;
+
+        sp = qla2x00_get_sp_from_handle(vha, func, req, pkt);
+        if (!sp)
+                return;
+        sp_bsg = (struct srb_bsg*)sp->ctx;
+        bsg_job = sp_bsg->bsg_job;
+
+        type = NULL;
+        switch (sp_bsg->ctx.type) {
+        case SRB_ELS_CMD_RPT:
+        case SRB_ELS_CMD_HST:
+                type = "els";
+                break;
+        case SRB_CT_CMD:
+                type = "ct pass-through";
+                break;
+        default:
+                qla_printk(KERN_WARNING, ha,
+                    "%s: Unrecognized SRB: (%p) type=%d.\n", func, sp,
+                    sp_bsg->ctx.type);
+                return;
+        }
+
+        comp_status = fw_status[0] = le16_to_cpu(pkt->comp_status);
+        fw_status[1] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1);
+        fw_status[2] = le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2);
+
+        /* return FC_CTELS_STATUS_OK and leave the decoding of the ELS/CT
+         * fc payload  to the caller
+         */
+        bsg_job->reply->reply_data.ctels_reply.status = FC_CTELS_STATUS_OK;
+        bsg_job->reply_len = sizeof(struct fc_bsg_reply) + sizeof(fw_status);
+
+        if (comp_status != CS_COMPLETE) {
+                if (comp_status == CS_DATA_UNDERRUN) {
+                        bsg_job->reply->result = DID_OK << 16;
+                        bsg_job->reply->reply_payload_rcv_len =
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count);
+
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                            "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
+                            "error subcode 1=0x%x error subcode 2=0x%x total_byte = 0x%x.\n",
+                                vha->host_no, sp->handle, type, comp_status, fw_status[1], fw_status[2],
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->total_byte_count)));
+                        fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                        memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
+                }
+                else {
+                        DEBUG2(qla_printk(KERN_WARNING, ha,
+                            "scsi(%ld:0x%x): ELS-CT pass-through-%s error comp_status-status=0x%x "
+                            "error subcode 1=0x%x error subcode 2=0x%x.\n",
+                                vha->host_no, sp->handle, type, comp_status,
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_1),
+                                le16_to_cpu(((struct els_sts_entry_24xx*)pkt)->error_subcode_2)));
+                        bsg_job->reply->result = DID_ERROR << 16;
+                        bsg_job->reply->reply_payload_rcv_len = 0;
+                        fw_sts_ptr = ((uint8_t*)bsg_job->req->sense) + sizeof(struct fc_bsg_reply);
+                        memcpy( fw_sts_ptr, fw_status, sizeof(fw_status));
+                }
+                DEBUG2(qla2x00_dump_buffer((uint8_t *)pkt, sizeof(*pkt)));
+        }
+        else {
+                bsg_job->reply->result =  DID_OK << 16;;
+                bsg_job->reply->reply_payload_rcv_len = bsg_job->reply_payload.payload_len;
+                bsg_job->reply_len = 0;
+        }
+
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->request_payload.sg_list,
+            bsg_job->request_payload.sg_cnt, DMA_TO_DEVICE);
+        dma_unmap_sg(&ha->pdev->dev,
+            bsg_job->reply_payload.sg_list,
+            bsg_job->reply_payload.sg_cnt, DMA_FROM_DEVICE);
+        if ((sp_bsg->ctx.type == SRB_ELS_CMD_HST) ||
+            (sp_bsg->ctx.type == SRB_CT_CMD))
+                kfree(sp->fcport);
+        kfree(sp->ctx);
+        mempool_free(sp, ha->srb_mempool);
+        bsg_job->job_done(bsg_job);
+}
+
+static void
 qla24xx_logio_entry(scsi_qla_host_t *vha, struct req_que *req,
     struct logio_entry_24xx *logio)
 {
@@ -1749,6 +1846,13 @@ void qla24xx_process_response_queue(struct scsi_qla_host *vha,
                         qla24xx_logio_entry(vha, rsp->req,
                             (struct logio_entry_24xx *)pkt);
                         break;
+                case CT_IOCB_TYPE:
+                        qla24xx_els_ct_entry(vha, rsp->req, pkt, CT_IOCB_TYPE);
+                        clear_bit(MBX_INTERRUPT, &vha->hw->mbx_cmd_flags);
+                        break;
+                case ELS_IOCB_TYPE:
+                        qla24xx_els_ct_entry(vha, rsp->req, pkt, ELS_IOCB_TYPE);
+                        break;
                 default:
                         /* Type Not Supported. */
                         DEBUG4(printk(KERN_WARNING
@@ -2049,7 +2153,6 @@ qla24xx_msix_default(int irq, void *dev_id)
                 set_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
                 complete(&ha->mbx_intr_comp);
         }
-
         return IRQ_HANDLED;
 }
 
@@ -2255,10 +2358,11 @@ qla2x00_free_irqs(scsi_qla_host_t *vha)
 
         if (ha->flags.msix_enabled)
                 qla24xx_disable_msix(ha);
-        else if (ha->flags.inta_enabled) {
+        else if (ha->flags.msi_enabled) {
                 free_irq(ha->pdev->irq, rsp);
                 pci_disable_msi(ha->pdev);
-        }
+        } else
+                free_irq(ha->pdev->irq, rsp);
 }
 
 
diff --git a/drivers/scsi/qla2xxx/qla_mbx.c b/drivers/scsi/qla2xxx/qla_mbx.c
index 056e4d4505f3..6e53bdbb1da8 100644
--- a/drivers/scsi/qla2xxx/qla_mbx.c
+++ b/drivers/scsi/qla2xxx/qla_mbx.c
@@ -3636,6 +3636,157 @@ qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
 }
 
 int
+qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq, uint16_t *mresp)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        uint32_t iter_cnt = 0x1;
+
+        DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
+
+        memset(mcp->mb, 0 , sizeof(mcp->mb));
+        mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
+        mcp->mb[1] = mreq->options | BIT_6;     // BIT_6 specifies 64 bit addressing
+
+        /* transfer count */
+        mcp->mb[10] = LSW(mreq->transfer_size);
+        mcp->mb[11] = MSW(mreq->transfer_size);
+
+        /* send data address */
+        mcp->mb[14] = LSW(mreq->send_dma);
+        mcp->mb[15] = MSW(mreq->send_dma);
+        mcp->mb[20] = LSW(MSD(mreq->send_dma));
+        mcp->mb[21] = MSW(MSD(mreq->send_dma));
+
+        /* recieve data address */
+        mcp->mb[16] = LSW(mreq->rcv_dma);
+        mcp->mb[17] = MSW(mreq->rcv_dma);
+        mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
+        mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
+
+        /* Iteration count */
+        mcp->mb[18] = LSW(iter_cnt);
+        mcp->mb[19] = MSW(iter_cnt);
+
+        mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
+            MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
+        if (IS_QLA81XX(vha->hw))
+                mcp->out_mb |= MBX_2;
+        mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
+
+        mcp->buf_size = mreq->transfer_size;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+
+        rval = qla2x00_mailbox_command(vha, mcp);
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2(printk(KERN_WARNING
+                    "(%ld): failed=%x mb[0]=0x%x "
+                        "mb[1]=0x%x mb[2]=0x%x mb[3]=0x%x mb[18]=0x%x mb[19]=0x%x. \n", vha->host_no, rval,
+                        mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3], mcp->mb[18], mcp->mb[19]));
+        } else {
+                DEBUG2(printk(KERN_WARNING
+                    "scsi(%ld): done.\n", vha->host_no));
+        }
+
+        /* Copy mailbox information */
+        memcpy( mresp, mcp->mb, 64);
+        mresp[3] = mcp->mb[18];
+        mresp[4] = mcp->mb[19];
+        return rval;
+}
+
+int
+qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq, uint16_t *mresp)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+        struct qla_hw_data *ha = vha->hw;
+
+        DEBUG11(printk("scsi(%ld): entered.\n", vha->host_no));
+
+        memset(mcp->mb, 0 , sizeof(mcp->mb));
+        mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
+        mcp->mb[1] = mreq->options | BIT_6;     /* BIT_6 specifies 64bit address */
+        if (IS_QLA81XX(ha))
+                mcp->mb[1] |= BIT_15;
+        mcp->mb[2] = IS_QLA81XX(ha) ? vha->fcoe_fcf_idx : 0;
+        mcp->mb[16] = LSW(mreq->rcv_dma);
+        mcp->mb[17] = MSW(mreq->rcv_dma);
+        mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
+        mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
+
+        mcp->mb[10] = LSW(mreq->transfer_size);
+
+        mcp->mb[14] = LSW(mreq->send_dma);
+        mcp->mb[15] = MSW(mreq->send_dma);
+        mcp->mb[20] = LSW(MSD(mreq->send_dma));
+        mcp->mb[21] = MSW(MSD(mreq->send_dma));
+
+        mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
+            MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
+        if (IS_QLA81XX(ha))
+                mcp->out_mb |= MBX_2;
+
+        mcp->in_mb = MBX_0;
+        if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha))
+                mcp->in_mb |= MBX_1;
+        if (IS_QLA81XX(ha))
+                mcp->in_mb |= MBX_3;
+
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+        mcp->buf_size = mreq->transfer_size;
+
+        rval = qla2x00_mailbox_command(vha, mcp);
+
+        if (rval != QLA_SUCCESS) {
+                DEBUG2(printk(KERN_WARNING
+                    "(%ld): failed=%x mb[0]=0x%x mb[1]=0x%x.\n",
+                    vha->host_no, rval, mcp->mb[0], mcp->mb[1]));
+        } else {
+                DEBUG2(printk(KERN_WARNING
+                    "scsi(%ld): done.\n", vha->host_no));
+        }
+
+        /* Copy mailbox information */
+        memcpy( mresp, mcp->mb, 32);
+        return rval;
+}
+int
+qla84xx_reset_chip(scsi_qla_host_t *ha, uint16_t enable_diagnostic,
+    uint16_t *cmd_status)
+{
+        int rval;
+        mbx_cmd_t mc;
+        mbx_cmd_t *mcp = &mc;
+
+        DEBUG16(printk("%s(%ld): enable_diag=%d entered.\n", __func__,
+                ha->host_no, enable_diagnostic));
+
+        mcp->mb[0] = MBC_ISP84XX_RESET;
+        mcp->mb[1] = enable_diagnostic;
+        mcp->out_mb = MBX_1|MBX_0;
+        mcp->in_mb = MBX_1|MBX_0;
+        mcp->tov = MBX_TOV_SECONDS;
+        mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
+        rval = qla2x00_mailbox_command(ha, mcp);
+
+        /* Return mailbox statuses. */
+        *cmd_status = mcp->mb[0];
+        if (rval != QLA_SUCCESS)
+                DEBUG16(printk("%s(%ld): failed=%x.\n", __func__, ha->host_no,
+                        rval));
+        else
+                DEBUG16(printk("%s(%ld): done.\n", __func__, ha->host_no));
+
+        return rval;
+}
+
+int
 qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
 {
         int rval;
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 8529eb1f3cd4..46720b23028f 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -107,6 +107,12 @@ MODULE_PARM_DESC(ql2xfwloadbin,
                 " 1 -- load firmware from flash.\n"
                 " 0 -- use default semantics.\n");
 
+int ql2xetsenable;
+module_param(ql2xetsenable, int, S_IRUGO|S_IRUSR);
+MODULE_PARM_DESC(ql2xetsenable,
+                "Enables firmware ETS burst."
+                "Default is 0 - skip ETS enablement.");
+
 /*
  * SCSI host template entry points
  */
@@ -682,44 +688,6 @@ qla2x00_wait_for_loop_ready(scsi_qla_host_t *vha)
         return (return_status);
 }
 
-void
-qla2x00_abort_fcport_cmds(fc_port_t *fcport)
-{
-        int cnt;
-        unsigned long flags;
-        srb_t *sp;
-        scsi_qla_host_t *vha = fcport->vha;
-        struct qla_hw_data *ha = vha->hw;
-        struct req_que *req;
-
-        spin_lock_irqsave(&ha->hardware_lock, flags);
-        req = vha->req;
-        for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
-                sp = req->outstanding_cmds[cnt];
-                if (!sp)
-                        continue;
-                if (sp->fcport != fcport)
-                        continue;
-                if (sp->ctx)
-                        continue;
-
-                spin_unlock_irqrestore(&ha->hardware_lock, flags);
-                if (ha->isp_ops->abort_command(sp)) {
-                        DEBUG2(qla_printk(KERN_WARNING, ha,
-                        "Abort failed --  %lx\n",
-                        sp->cmd->serial_number));
-                } else {
-                        if (qla2x00_eh_wait_on_command(sp->cmd) !=
-                                QLA_SUCCESS)
-                                DEBUG2(qla_printk(KERN_WARNING, ha,
-                                "Abort failed while waiting --  %lx\n",
-                                sp->cmd->serial_number));
-                }
-                spin_lock_irqsave(&ha->hardware_lock, flags);
-        }
-        spin_unlock_irqrestore(&ha->hardware_lock, flags);
-}
-
 /**************************************************************************
 * qla2xxx_eh_abort
 *
@@ -1095,6 +1063,20 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
         struct fc_port *fcport;
         struct qla_hw_data *ha = vha->hw;
 
+        if (ha->flags.enable_target_reset) {
+                list_for_each_entry(fcport, &vha->vp_fcports, list) {
+                        if (fcport->port_type != FCT_TARGET)
+                                continue;
+
+                        ret = ha->isp_ops->target_reset(fcport, 0, 0);
+                        if (ret != QLA_SUCCESS) {
+                                DEBUG2_3(printk("%s(%ld): bus_reset failed: "
+                                    "target_reset=%d d_id=%x.\n", __func__,
+                                    vha->host_no, ret, fcport->d_id.b24));
+                        }
+                }
+        }
+
         if (ha->flags.enable_lip_full_login && !IS_QLA81XX(ha)) {
                 ret = qla2x00_full_login_lip(vha);
                 if (ret != QLA_SUCCESS) {
@@ -1117,19 +1099,6 @@ qla2x00_loop_reset(scsi_qla_host_t *vha)
                         qla2x00_wait_for_loop_ready(vha);
         }
 
-        if (ha->flags.enable_target_reset) {
-                list_for_each_entry(fcport, &vha->vp_fcports, list) {
-                        if (fcport->port_type != FCT_TARGET)
-                                continue;
-
-                        ret = ha->isp_ops->target_reset(fcport, 0, 0);
-                        if (ret != QLA_SUCCESS) {
-                                DEBUG2_3(printk("%s(%ld): bus_reset failed: "
-                                    "target_reset=%d d_id=%x.\n", __func__,
-                                    vha->host_no, ret, fcport->d_id.b24));
-                        }
-                }
-        }
         /* Issue marker command only when we are going to start the I/O */
         vha->marker_needed = 1;
 
@@ -1160,8 +1129,19 @@ qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
                                         qla2x00_sp_compl(ha, sp);
                                 } else {
                                         ctx = sp->ctx;
-                                        del_timer_sync(&ctx->timer);
-                                        ctx->free(sp);
+                                        if (ctx->type == SRB_LOGIN_CMD || ctx->type == SRB_LOGOUT_CMD) {
+                                                del_timer_sync(&ctx->timer);
+                                                ctx->free(sp);
+                                        } else {
+                                                struct srb_bsg* sp_bsg = (struct srb_bsg*)sp->ctx;
+                                                if (sp_bsg->bsg_job->request->msgcode == FC_BSG_HST_CT)
+                                                        kfree(sp->fcport);
+                                                sp_bsg->bsg_job->req->errors = 0;
+                                                sp_bsg->bsg_job->reply->result = res;
+                                                sp_bsg->bsg_job->job_done(sp_bsg->bsg_job);
+                                                kfree(sp->ctx);
+                                                mempool_free(sp, ha->srb_mempool);
+                                        }
                                 }
                         }
                 }
@@ -1258,7 +1238,7 @@ qla2x00_change_queue_depth(struct scsi_device *sdev, int qdepth, int reason)
                 qla2x00_adjust_sdev_qdepth_up(sdev, qdepth);
                 break;
         default:
-                return EOPNOTSUPP;
+                return -EOPNOTSUPP;
         }
 
         return sdev->queue_depth;
@@ -1818,7 +1798,6 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         /* Set EEH reset type to fundamental if required by hba */
         if ( IS_QLA24XX(ha) || IS_QLA25XX(ha) || IS_QLA81XX(ha)) {
                 pdev->needs_freset = 1;
-                pci_save_state(pdev);
         }
 
         /* Configure PCI I/O space */
@@ -1970,11 +1949,15 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         host->max_channel = MAX_BUSES - 1;
         host->max_lun = MAX_LUNS;
         host->transportt = qla2xxx_transport_template;
+        sht->vendor_id = (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_QLOGIC);
 
         /* Set up the irqs */
         ret = qla2x00_request_irqs(ha, rsp);
         if (ret)
                 goto probe_init_failed;
+
+        pci_save_state(pdev);
+
         /* Alloc arrays of request and response ring ptrs */
 que_init:
         if (!qla2x00_alloc_queues(ha)) {
@@ -2176,6 +2159,8 @@ qla2x00_remove_one(struct pci_dev *pdev)
         kfree(ha);
         ha = NULL;
 
+        pci_disable_pcie_error_reporting(pdev);
+
         pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
 }
@@ -3310,6 +3295,7 @@ qla2xxx_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state)
                 return PCI_ERS_RESULT_CAN_RECOVER;
         case pci_channel_io_frozen:
                 ha->flags.eeh_busy = 1;
+                qla2x00_free_irqs(vha);
                 pci_disable_device(pdev);
                 return PCI_ERS_RESULT_NEED_RESET;
         case pci_channel_io_perm_failure:
@@ -3363,10 +3349,24 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
         pci_ers_result_t ret = PCI_ERS_RESULT_DISCONNECT;
         scsi_qla_host_t *base_vha = pci_get_drvdata(pdev);
         struct qla_hw_data *ha = base_vha->hw;
-        int rc;
+        struct rsp_que *rsp;
+        int rc, retries = 10;
 
         DEBUG17(qla_printk(KERN_WARNING, ha, "slot_reset\n"));
 
+        /* Workaround: qla2xxx driver which access hardware earlier
+         * needs error state to be pci_channel_io_online.
+         * Otherwise mailbox command timesout.
+         */
+        pdev->error_state = pci_channel_io_normal;
+
+        pci_restore_state(pdev);
+
+        /* pci_restore_state() clears the saved_state flag of the device
+         * save restored state which resets saved_state flag
+         */
+        pci_save_state(pdev);
+
         if (ha->mem_only)
                 rc = pci_enable_device_mem(pdev);
         else
@@ -3378,27 +3378,23 @@ qla2xxx_pci_slot_reset(struct pci_dev *pdev)
                 return ret;
         }
 
+        rsp = ha->rsp_q_map[0];
+        if (qla2x00_request_irqs(ha, rsp))
+                return ret;
+
         if (ha->isp_ops->pci_config(base_vha))
                 return ret;
 
-#ifdef QL_DEBUG_LEVEL_17
-        {
-                uint8_t b;
-                uint32_t i;
+        while (ha->flags.mbox_busy && retries--)
+                msleep(1000);
 
-                printk("slot_reset_1: ");
-                for (i = 0; i < 256; i++) {
-                        pci_read_config_byte(ha->pdev, i, &b);
-                        printk("%s%02x", (i%16) ? " " : "\n", b);
-                }
-                printk("\n");
-        }
-#endif
         set_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
         if (qla2x00_abort_isp(base_vha) == QLA_SUCCESS)
                 ret =  PCI_ERS_RESULT_RECOVERED;
         clear_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
 
+        pci_cleanup_aer_uncorrect_error_status(pdev);
+
         DEBUG17(qla_printk(KERN_WARNING, ha,
             "slot_reset-return:ret=%x\n", ret));
 
@@ -3422,8 +3418,6 @@ qla2xxx_pci_resume(struct pci_dev *pdev)
         }
 
         ha->flags.eeh_busy = 0;
-
-        pci_cleanup_aer_uncorrect_error_status(pdev);
 }
 
 static struct pci_error_handlers qla2xxx_err_handler = {
@@ -3536,4 +3530,3 @@ MODULE_FIRMWARE(FW_FILE_ISP2300);
 MODULE_FIRMWARE(FW_FILE_ISP2322);
 MODULE_FIRMWARE(FW_FILE_ISP24XX);
 MODULE_FIRMWARE(FW_FILE_ISP25XX);
-MODULE_FIRMWARE(FW_FILE_ISP81XX);
diff --git a/drivers/scsi/qla2xxx/qla_version.h b/drivers/scsi/qla2xxx/qla_version.h
index ed36279a33c1..8d2fc2fa7a6b 100644
--- a/drivers/scsi/qla2xxx/qla_version.h
+++ b/drivers/scsi/qla2xxx/qla_version.h
@@ -7,9 +7,9 @@
 /*
  * Driver version
  */
-#define QLA2XXX_VERSION      "8.03.01-k10"
+#define QLA2XXX_VERSION      "8.03.02-k1"
 
 #define QLA_DRIVER_MAJOR_VER    8
 #define QLA_DRIVER_MINOR_VER    3
-#define QLA_DRIVER_PATCH_VER    1
-#define QLA_DRIVER_BETA_VER     0
+#define QLA_DRIVER_PATCH_VER    2
+#define QLA_DRIVER_BETA_VER     1
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index af8c3233e8ae..92329a461c68 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -844,10 +844,10 @@ static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
         DEBUG2(printk("scsi%ld: %s: Get EEProm parameters \n", ha->host_no,
                       __func__));
         if (ql4xxx_lock_flash(ha) != QLA_SUCCESS)
-                return (QLA_ERROR);
+                return QLA_ERROR;
         if (ql4xxx_lock_nvram(ha) != QLA_SUCCESS) {
                 ql4xxx_unlock_flash(ha);
-                return (QLA_ERROR);
+                return QLA_ERROR;
         }
 
         /* Get EEPRom Parameters from NVRAM and validate */
@@ -858,20 +858,18 @@ static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
                         rd_nvram_word(ha, eeprom_ext_hw_conf_offset(ha));
                 spin_unlock_irqrestore(&ha->hardware_lock, flags);
         } else {
-                /*
-                 * QLogic adapters should always have a valid NVRAM.
-                 * If not valid, do not load.
-                 */
                 dev_warn(&ha->pdev->dev,
                            "scsi%ld: %s: EEProm checksum invalid.  "
                            "Please update your EEPROM\n", ha->host_no,
                            __func__);
 
-                /* set defaults */
+                /* Attempt to set defaults */
                 if (is_qla4010(ha))
                         extHwConfig.Asuint32_t = 0x1912;
                 else if (is_qla4022(ha) | is_qla4032(ha))
                         extHwConfig.Asuint32_t = 0x0023;
+                else
+                        return QLA_ERROR;
         }
         DEBUG(printk("scsi%ld: %s: Setting extHwConfig to 0xFFFF%04x\n",
                      ha->host_no, __func__, extHwConfig.Asuint32_t));
@@ -884,7 +882,7 @@ static int qla4xxx_config_nvram(struct scsi_qla_host *ha)
         ql4xxx_unlock_nvram(ha);
         ql4xxx_unlock_flash(ha);
 
-        return (QLA_SUCCESS);
+        return QLA_SUCCESS;
 }
 
 static void qla4x00_pci_config(struct scsi_qla_host *ha)
diff --git a/drivers/scsi/raid_class.c b/drivers/scsi/raid_class.c
index 8e5c169b03fb..bd88349b8526 100644
--- a/drivers/scsi/raid_class.c
+++ b/drivers/scsi/raid_class.c
@@ -149,6 +149,7 @@ static struct {
         { RAID_LEVEL_0, "raid0" },
         { RAID_LEVEL_1, "raid1" },
         { RAID_LEVEL_10, "raid10" },
+        { RAID_LEVEL_1E, "raid1e" },
         { RAID_LEVEL_3, "raid3" },
         { RAID_LEVEL_4, "raid4" },
         { RAID_LEVEL_5, "raid5" },
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index a60da5555577..513661f45e5f 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -1026,55 +1026,39 @@ static int scsi_vpd_inquiry(struct scsi_device *sdev, unsigned char *buffer,
  * responsible for calling kfree() on this pointer when it is no longer
  * needed.  If we cannot retrieve the VPD page this routine returns %NULL.
  */
-unsigned char *scsi_get_vpd_page(struct scsi_device *sdev, u8 page)
+int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
+                      int buf_len)
 {
         int i, result;
-        unsigned int len;
-        const unsigned int init_vpd_len = 255;
-        unsigned char *buf = kmalloc(init_vpd_len, GFP_KERNEL);
-
-        if (!buf)
-                return NULL;
 
         /* Ask for all the pages supported by this device */
-        result = scsi_vpd_inquiry(sdev, buf, 0, init_vpd_len);
+        result = scsi_vpd_inquiry(sdev, buf, 0, buf_len);
         if (result)
                 goto fail;
 
         /* If the user actually wanted this page, we can skip the rest */
         if (page == 0)
-                return buf;
+                return -EINVAL;
 
-        for (i = 0; i < buf[3]; i++)
+        for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
                 if (buf[i + 4] == page)
                         goto found;
+
+        if (i < buf[3] && i > buf_len)
+                /* ran off the end of the buffer, give us benefit of doubt */
+                goto found;
         /* The device claims it doesn't support the requested page */
         goto fail;
 
  found:
-        result = scsi_vpd_inquiry(sdev, buf, page, 255);
+        result = scsi_vpd_inquiry(sdev, buf, page, buf_len);
         if (result)
                 goto fail;
 
-        /*
-         * Some pages are longer than 255 bytes.  The actual length of
-         * the page is returned in the header.
-         */
-        len = ((buf[2] << 8) | buf[3]) + 4;
-        if (len <= init_vpd_len)
-                return buf;
-
-        kfree(buf);
-        buf = kmalloc(len, GFP_KERNEL);
-        result = scsi_vpd_inquiry(sdev, buf, page, len);
-        if (result)
-                goto fail;
-
-        return buf;
+        return 0;
 
  fail:
-        kfree(buf);
-        return NULL;
+        return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
 
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index c6642423cc67..56977097de9f 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -773,8 +773,14 @@ void scsi_io_completion(struct scsi_cmnd *cmd, unsigned int good_bytes)
          * we already took a copy of the original into rq->errors which
          * is what gets returned to the user
          */
-        if (sense_valid && sshdr.sense_key == RECOVERED_ERROR) {
-                if (!(req->cmd_flags & REQ_QUIET))
+        if (sense_valid && (sshdr.sense_key == RECOVERED_ERROR)) {
+                /* if ATA PASS-THROUGH INFORMATION AVAILABLE skip
+                 * print since caller wants ATA registers. Only occurs on
+                 * SCSI ATA PASS_THROUGH commands when CK_COND=1
+                 */
+                if ((sshdr.asc == 0x0) && (sshdr.ascq == 0x1d))
+                        ;
+                else if (!(req->cmd_flags & REQ_QUIET))
                         scsi_print_sense("", cmd);
                 result = 0;
                 /* BLOCK_PC may have set error */
diff --git a/drivers/scsi/scsi_sas_internal.h b/drivers/scsi/scsi_sas_internal.h
index 998cb5be6833..6266a5d73d0f 100644
--- a/drivers/scsi/scsi_sas_internal.h
+++ b/drivers/scsi/scsi_sas_internal.h
@@ -5,7 +5,7 @@
 #define SAS_PHY_ATTRS           17
 #define SAS_PORT_ATTRS          1
 #define SAS_RPORT_ATTRS         7
-#define SAS_END_DEV_ATTRS       3
+#define SAS_END_DEV_ATTRS       5
 #define SAS_EXPANDER_ATTRS      7
 
 struct sas_internal {
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index 012f73a96880..f697229ae5a9 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -1339,8 +1339,10 @@ static int scsi_report_lun_scan(struct scsi_target *starget, int bflags,
                 sdev = scsi_alloc_sdev(starget, 0, NULL);
                 if (!sdev)
                         return 0;
-                if (scsi_device_get(sdev))
+                if (scsi_device_get(sdev)) {
+                        __scsi_remove_device(sdev);
                         return 0;
+                }
         }
 
         sprintf(devname, "host %d channel %d id %d",
@@ -1907,10 +1909,9 @@ struct scsi_device *scsi_get_host_dev(struct Scsi_Host *shost)
                 goto out;
 
         sdev = scsi_alloc_sdev(starget, 0, NULL);
-        if (sdev) {
-                sdev->sdev_gendev.parent = get_device(&starget->dev);
+        if (sdev)
                 sdev->borken = 0;
-        } else
+        else
                 scsi_target_reap(starget);
         put_device(&starget->dev);
  out:
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 5a065055e68a..a4936c4e2f46 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -878,7 +878,8 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
         struct request_queue *rq = sdev->request_queue;
         struct scsi_target *starget = sdev->sdev_target;
 
-        if ((error = scsi_device_set_state(sdev, SDEV_RUNNING)) != 0)
+        error = scsi_device_set_state(sdev, SDEV_RUNNING);
+        if (error)
                 return error;
 
         error = scsi_target_add(starget);
@@ -889,13 +890,13 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
         error = device_add(&sdev->sdev_gendev);
         if (error) {
                 printk(KERN_INFO "error 1\n");
-                goto out_remove;
+                return error;
         }
         error = device_add(&sdev->sdev_dev);
         if (error) {
                 printk(KERN_INFO "error 2\n");
                 device_del(&sdev->sdev_gendev);
-                goto out_remove;
+                return error;
         }
         transport_add_device(&sdev->sdev_gendev);
         sdev->is_visible = 1;
@@ -910,14 +911,14 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
         else
                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_depth);
         if (error)
-                goto out_remove;
+                return error;
 
         if (sdev->host->hostt->change_queue_type)
                 error = device_create_file(&sdev->sdev_gendev, &sdev_attr_queue_type_rw);
         else
                 error = device_create_file(&sdev->sdev_gendev, &dev_attr_queue_type);
         if (error)
-                goto out_remove;
+                return error;
 
         error = bsg_register_queue(rq, &sdev->sdev_gendev, NULL, NULL);
 
@@ -933,16 +934,11 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
                         error = device_create_file(&sdev->sdev_gendev,
                                         sdev->host->hostt->sdev_attrs[i]);
                         if (error)
-                                goto out_remove;
+                                return error;
                 }
         }
 
-        return 0;
-
- out_remove:
-        __scsi_remove_device(sdev);
         return error;
-
 }
 
 void __scsi_remove_device(struct scsi_device *sdev)
diff --git a/drivers/scsi/scsi_transport_fc.c b/drivers/scsi/scsi_transport_fc.c
index 653f22a8deb9..79660ee3e211 100644
--- a/drivers/scsi/scsi_transport_fc.c
+++ b/drivers/scsi/scsi_transport_fc.c
@@ -475,7 +475,8 @@ MODULE_PARM_DESC(dev_loss_tmo,
                  "Maximum number of seconds that the FC transport should"
                  " insulate the loss of a remote port. Once this value is"
                  " exceeded, the scsi target is removed. Value should be"
-                 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT.");
+                 " between 1 and SCSI_DEVICE_BLOCK_MAX_TIMEOUT if"
+                 " fast_io_fail_tmo is not set.");
 
 /*
  * Netlink Infrastructure
@@ -842,9 +843,17 @@ store_fc_rport_dev_loss_tmo(struct device *dev, struct device_attribute *attr,
             (rport->port_state == FC_PORTSTATE_NOTPRESENT))
                 return -EBUSY;
         val = simple_strtoul(buf, &cp, 0);
-        if ((*cp && (*cp != '\n')) ||
-            (val < 0) || (val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT))
+        if ((*cp && (*cp != '\n')) || (val < 0))
                 return -EINVAL;
+
+        /*
+         * If fast_io_fail is off we have to cap
+         * dev_loss_tmo at SCSI_DEVICE_BLOCK_MAX_TIMEOUT
+         */
+        if (rport->fast_io_fail_tmo == -1 &&
+            val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT)
+                return -EINVAL;
+
         i->f->set_rport_dev_loss_tmo(rport, val);
         return count;
 }
@@ -925,9 +934,16 @@ store_fc_rport_fast_io_fail_tmo(struct device *dev,
                 rport->fast_io_fail_tmo = -1;
         else {
                 val = simple_strtoul(buf, &cp, 0);
-                if ((*cp && (*cp != '\n')) ||
-                    (val < 0) || (val >= rport->dev_loss_tmo))
+                if ((*cp && (*cp != '\n')) || (val < 0))
                         return -EINVAL;
+                /*
+                 * Cap fast_io_fail by dev_loss_tmo or
+                 * SCSI_DEVICE_BLOCK_MAX_TIMEOUT.
+                 */
+                if ((val >= rport->dev_loss_tmo) ||
+                    (val > SCSI_DEVICE_BLOCK_MAX_TIMEOUT))
+                        return -EINVAL;
+
                 rport->fast_io_fail_tmo = val;
         }
         return count;
diff --git a/drivers/scsi/scsi_transport_sas.c b/drivers/scsi/scsi_transport_sas.c
index f27e52d963d3..927e99cb7225 100644
--- a/drivers/scsi/scsi_transport_sas.c
+++ b/drivers/scsi/scsi_transport_sas.c
@@ -155,6 +155,17 @@ static struct {
 sas_bitfield_name_search(linkspeed, sas_linkspeed_names)
 sas_bitfield_name_set(linkspeed, sas_linkspeed_names)
 
+static struct sas_end_device *sas_sdev_to_rdev(struct scsi_device *sdev)
+{
+        struct sas_rphy *rphy = target_to_rphy(sdev->sdev_target);
+        struct sas_end_device *rdev;
+
+        BUG_ON(rphy->identify.device_type != SAS_END_DEVICE);
+
+        rdev = rphy_to_end_device(rphy);
+        return rdev;
+}
+
 static void sas_smp_request(struct request_queue *q, struct Scsi_Host *shost,
                             struct sas_rphy *rphy)
 {
@@ -358,6 +369,85 @@ void sas_remove_host(struct Scsi_Host *shost)
 }
 EXPORT_SYMBOL(sas_remove_host);
 
+/**
+ * sas_tlr_supported - checking TLR bit in vpd 0x90
+ * @sdev: scsi device struct
+ *
+ * Check Transport Layer Retries are supported or not.
+ * If vpd page 0x90 is present, TRL is supported.
+ *
+ */
+unsigned int
+sas_tlr_supported(struct scsi_device *sdev)
+{
+        const int vpd_len = 32;
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+        char *buffer = kzalloc(vpd_len, GFP_KERNEL);
+        int ret = 0;
+
+        if (scsi_get_vpd_page(sdev, 0x90, buffer, vpd_len))
+                goto out;
+
+        /*
+         * Magic numbers: the VPD Protocol page (0x90)
+         * has a 4 byte header and then one entry per device port
+         * the TLR bit is at offset 8 on each port entry
+         * if we take the first port, that's at total offset 12
+         */
+        ret = buffer[12] & 0x01;
+
+ out:
+        kfree(buffer);
+        rdev->tlr_supported = ret;
+        return ret;
+
+}
+EXPORT_SYMBOL_GPL(sas_tlr_supported);
+
+/**
+ * sas_disable_tlr - setting TLR flags
+ * @sdev: scsi device struct
+ *
+ * Seting tlr_enabled flag to 0.
+ *
+ */
+void
+sas_disable_tlr(struct scsi_device *sdev)
+{
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+
+        rdev->tlr_enabled = 0;
+}
+EXPORT_SYMBOL_GPL(sas_disable_tlr);
+
+/**
+ * sas_enable_tlr - setting TLR flags
+ * @sdev: scsi device struct
+ *
+ * Seting tlr_enabled flag 1.
+ *
+ */
+void sas_enable_tlr(struct scsi_device *sdev)
+{
+        unsigned int tlr_supported = 0;
+        tlr_supported  = sas_tlr_supported(sdev);
+
+        if (tlr_supported) {
+                struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+
+                rdev->tlr_enabled = 1;
+        }
+
+        return;
+}
+EXPORT_SYMBOL_GPL(sas_enable_tlr);
+
+unsigned int sas_is_tlr_enabled(struct scsi_device *sdev)
+{
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
+        return rdev->tlr_enabled;
+}
+EXPORT_SYMBOL_GPL(sas_is_tlr_enabled);
 
 /*
  * SAS Phy attributes
@@ -1146,15 +1236,10 @@ sas_rphy_simple_attr(identify.phy_identifier, phy_identifier, "%d\n", u8);
 int sas_read_port_mode_page(struct scsi_device *sdev)
 {
         char *buffer = kzalloc(BUF_SIZE, GFP_KERNEL), *msdata;
-        struct sas_rphy *rphy = target_to_rphy(sdev->sdev_target);
-        struct sas_end_device *rdev;
+        struct sas_end_device *rdev = sas_sdev_to_rdev(sdev);
         struct scsi_mode_data mode_data;
         int res, error;
 
-        BUG_ON(rphy->identify.device_type != SAS_END_DEVICE);
-
-        rdev = rphy_to_end_device(rphy);
-
         if (!buffer)
                 return -ENOMEM;
 
@@ -1207,6 +1292,10 @@ sas_end_dev_simple_attr(I_T_nexus_loss_timeout, I_T_nexus_loss_timeout,
                         "%d\n", int);
 sas_end_dev_simple_attr(initiator_response_timeout, initiator_response_timeout,
                         "%d\n", int);
+sas_end_dev_simple_attr(tlr_supported, tlr_supported,
+                        "%d\n", int);
+sas_end_dev_simple_attr(tlr_enabled, tlr_enabled,
+                        "%d\n", int);
 
 static DECLARE_TRANSPORT_CLASS(sas_expander_class,
                                "sas_expander", NULL, NULL, NULL);
@@ -1733,6 +1822,8 @@ sas_attach_transport(struct sas_function_template *ft)
         SETUP_END_DEV_ATTRIBUTE(end_dev_ready_led_meaning);
         SETUP_END_DEV_ATTRIBUTE(end_dev_I_T_nexus_loss_timeout);
         SETUP_END_DEV_ATTRIBUTE(end_dev_initiator_response_timeout);
+        SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_supported);
+        SETUP_END_DEV_ATTRIBUTE(end_dev_tlr_enabled);
         i->end_dev_attrs[count] = NULL;
 
         count = 0;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 255da53e5a01..1dd4d8407694 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1196,19 +1196,10 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 SCpnt->result = 0;
                 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
                 break;
-        case ABORTED_COMMAND:
-                if (sshdr.asc == 0x10) { /* DIF: Disk detected corruption */
-                        scsi_print_result(SCpnt);
-                        scsi_print_sense("sd", SCpnt);
+        case ABORTED_COMMAND: /* DIF: Target detected corruption */
+        case ILLEGAL_REQUEST: /* DIX: Host detected corruption */
+                if (sshdr.asc == 0x10)
                         good_bytes = sd_completed_bytes(SCpnt);
-                }
-                break;
-        case ILLEGAL_REQUEST:
-                if (sshdr.asc == 0x10) { /* DIX: HBA detected corruption */
-                        scsi_print_result(SCpnt);
-                        scsi_print_sense("sd", SCpnt);
-                        good_bytes = sd_completed_bytes(SCpnt);
-                }
                 break;
         default:
                 break;
@@ -1218,8 +1209,19 @@ static int sd_done(struct scsi_cmnd *SCpnt)
                 sd_dif_complete(SCpnt, good_bytes);
 
         if (scsi_host_dif_capable(sdkp->device->host, sdkp->protection_type)
-            == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd)
+            == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd) {
+
+                /* We have to print a failed command here as the
+                 * extended CDB gets freed before scsi_io_completion()
+                 * is called.
+                 */
+                if (result)
+                        scsi_print_command(SCpnt);
+
                 mempool_free(SCpnt->cmnd, sd_cdb_pool);
+                SCpnt->cmnd = NULL;
+                SCpnt->cmd_len = 0;
+        }
 
         return good_bytes;
 }
@@ -1946,13 +1948,13 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)
 {
         struct request_queue *q = sdkp->disk->queue;
         unsigned int sector_sz = sdkp->device->sector_size;
-        char *buffer;
+        const int vpd_len = 32;
+        unsigned char *buffer = kmalloc(vpd_len, GFP_KERNEL);
 
-        /* Block Limits VPD */
-        buffer = scsi_get_vpd_page(sdkp->device, 0xb0);
-
-        if (buffer == NULL)
-                return;
+        if (!buffer ||
+            /* Block Limits VPD */
+            scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len))
+                goto out;
 
         blk_queue_io_min(sdkp->disk->queue,
                          get_unaligned_be16(&buffer[6]) * sector_sz);
@@ -1984,6 +1986,7 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)
                                 get_unaligned_be32(&buffer[32]) & ~(1 << 31);
         }
 
+ out:
         kfree(buffer);
 }
 
@@ -1993,20 +1996,23 @@ static void sd_read_block_limits(struct scsi_disk *sdkp)
  */
 static void sd_read_block_characteristics(struct scsi_disk *sdkp)
 {
-        char *buffer;
+        unsigned char *buffer;
         u16 rot;
+        const int vpd_len = 32;
 
-        /* Block Device Characteristics VPD */
-        buffer = scsi_get_vpd_page(sdkp->device, 0xb1);
+        buffer = kmalloc(vpd_len, GFP_KERNEL);
 
-        if (buffer == NULL)
-                return;
+        if (!buffer ||
+            /* Block Device Characteristics VPD */
+            scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len))
+                goto out;
 
         rot = get_unaligned_be16(&buffer[4]);
 
         if (rot == 1)
                 queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue);
 
+ out:
         kfree(buffer);
 }
 
diff --git a/drivers/scsi/ses.c b/drivers/scsi/ses.c
index 55b034b72708..1d7a8780e00c 100644
--- a/drivers/scsi/ses.c
+++ b/drivers/scsi/ses.c
@@ -448,13 +448,17 @@ static void ses_match_to_enclosure(struct enclosure_device *edev,
                 .addr = 0,
         };
 
-        buf = scsi_get_vpd_page(sdev, 0x83);
-        if (!buf)
-                return;
+        buf = kmalloc(INIT_ALLOC_SIZE, GFP_KERNEL);
+        if (!buf || scsi_get_vpd_page(sdev, 0x83, buf, INIT_ALLOC_SIZE))
+                goto free;
 
         ses_enclosure_data_process(edev, to_scsi_device(edev->edev.parent), 0);
 
         vpd_len = ((buf[2] << 8) | buf[3]) + 4;
+        kfree(buf);
+        buf = kmalloc(vpd_len, GFP_KERNEL);
+        if (!buf ||scsi_get_vpd_page(sdev, 0x83, buf, vpd_len))
+                goto free;
 
         desc = buf + 4;
         while (desc < buf + vpd_len) {
diff --git a/drivers/scsi/u14-34f.c b/drivers/scsi/u14-34f.c
index 54023d41fd15..26e8e0e6b8dd 100644
--- a/drivers/scsi/u14-34f.c
+++ b/drivers/scsi/u14-34f.c
@@ -1070,7 +1070,7 @@ static int option_setup(char *str) {
    char *cur = str;
    int i = 1;
 
-   while (cur && isdigit(*cur) && i <= MAX_INT_PARAM) {
+   while (cur && isdigit(*cur) && i < MAX_INT_PARAM) {
       ints[i++] = simple_strtoul(cur, NULL, 0);
 
       if ((cur = strchr(cur, ',')) != NULL) cur++;
diff --git a/drivers/scsi/vmw_pvscsi.c b/drivers/scsi/vmw_pvscsi.c
index d2604c813a20..e4ac5829b637 100644
--- a/drivers/scsi/vmw_pvscsi.c
+++ b/drivers/scsi/vmw_pvscsi.c
@@ -1069,7 +1069,8 @@ static void pvscsi_free_sgls(const struct pvscsi_adapter *adapter)
                 free_pages((unsigned long)ctx->sgl, get_order(SGL_SIZE));
 }
 
-static int pvscsi_setup_msix(const struct pvscsi_adapter *adapter, int *irq)
+static int pvscsi_setup_msix(const struct pvscsi_adapter *adapter,
+                             unsigned int *irq)
 {
         struct msix_entry entry = { 0, PVSCSI_VECTOR_COMPLETION };
         int ret;
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/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 0efcded59ae6..f7d2589926d2 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -518,34 +518,6 @@ static inline int sci_rxd_in(struct uart_port *port)
 {
         if (port->mapbase == 0xfffffe80)
                 return __raw_readb(SCPDR)&0x01 ? 1 : 0; /* SCI */
-        if (port->mapbase == 0xa4000150)
-                return __raw_readb(SCPDR)&0x10 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xa4000140)
-                return __raw_readb(SCPDR)&0x04 ? 1 : 0; /* IRDA */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7705)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == SCIF0)
-                return __raw_readb(SCPDR)&0x04 ? 1 : 0; /* IRDA */
-        if (port->mapbase == SCIF2)
-                return __raw_readb(SCPDR)&0x10 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7710) || defined(CONFIG_CPU_SUBTYPE_SH7712)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-          return sci_in(port,SCxSR)&0x0010 ? 1 : 0;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7720) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7721)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xa4430000)
-                return sci_in(port, SCxSR) & 0x0003 ? 1 : 0;
-        else if (port->mapbase == 0xa4438000)
-                return sci_in(port, SCxSR) & 0x0003 ? 1 : 0;
         return 1;
 }
 #elif defined(CONFIG_CPU_SUBTYPE_SH7750)  || \
@@ -558,207 +530,17 @@ static inline int sci_rxd_in(struct uart_port *port)
 {
         if (port->mapbase == 0xffe00000)
                 return __raw_readb(SCSPTR1)&0x01 ? 1 : 0; /* SCI */
-        if (port->mapbase == 0xffe80000)
-                return __raw_readw(SCSPTR2)&0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH4_202)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe80000)
-                return __raw_readw(SCSPTR2)&0x0001 ? 1 : 0; /* SCIF */
         return 1;
 }
-#elif defined(CONFIG_CPU_SUBTYPE_SH7757)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xfe4b0000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0;
-        if (port->mapbase == 0xfe4c0000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0;
-        if (port->mapbase == 0xfe4d0000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7760)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xfe600000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfe610000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfe620000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7343)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffe10000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffe20000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffe30000)
-                return __raw_readw(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7366)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readb(SCPDR0) & 0x0001 ? 1 : 0; /* SCIF0 */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7722)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readb(PSDR) & 0x02 ? 1 : 0; /* SCIF0 */
-        if (port->mapbase == 0xffe10000)
-                return __raw_readb(PADR) & 0x40 ? 1 : 0; /* SCIF1 */
-        if (port->mapbase == 0xffe20000)
-                return __raw_readb(PWDR) & 0x04 ? 1 : 0; /* SCIF2 */
-
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7723)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readb(SCSPTR0) & 0x0008 ? 1 : 0; /* SCIF0 */
-        if (port->mapbase == 0xffe10000)
-                return __raw_readb(SCSPTR1) & 0x0020 ? 1 : 0; /* SCIF1 */
-        if (port->mapbase == 0xffe20000)
-                return __raw_readb(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF2 */
-        if (port->mapbase == 0xa4e30000)
-                return __raw_readb(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF3 */
-        if (port->mapbase == 0xa4e40000)
-                return __raw_readb(SCSPTR4) & 0x0001 ? 1 : 0; /* SCIF4 */
-        if (port->mapbase == 0xa4e50000)
-                return __raw_readb(SCSPTR5) & 0x0008 ? 1 : 0; /* SCIF5 */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7724)
-#  define SCFSR    0x0010
-#  define SCASSR   0x0014
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->type == PORT_SCIF)
-                return __raw_readw((port->mapbase + SCFSR))  & SCIF_BRK ? 1 : 0;
-        if (port->type == PORT_SCIFA)
-                return __raw_readw((port->mapbase + SCASSR)) & SCIF_BRK ? 1 : 0;
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH5_101) || defined(CONFIG_CPU_SUBTYPE_SH5_103)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-         return sci_in(port, SCSPTR)&0x0001 ? 1 : 0; /* SCIF */
-}
 #elif defined(__H8300H__) || defined(__H8300S__)
 static inline int sci_rxd_in(struct uart_port *port)
 {
         int ch = (port->mapbase - SMR0) >> 3;
         return (H8300_SCI_DR(ch) & h8300_sci_pins[ch].rx) ? 1 : 0;
 }
-#elif defined(CONFIG_CPU_SUBTYPE_SH7763)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffe08000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffe10000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF/IRDA */
-
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7770)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xff923000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xff924000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xff925000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7780)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffe00000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffe10000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7785) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7786)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xffea0000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffeb0000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffec0000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffed0000)
-                return __raw_readw(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffee0000)
-                return __raw_readw(SCSPTR4) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffef0000)
-                return __raw_readw(SCSPTR5) & 0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7201) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7203) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7206) || \
-      defined(CONFIG_CPU_SUBTYPE_SH7263)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xfffe8000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfffe8800)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfffe9000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfffe9800)
-                return __raw_readw(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF */
-#if defined(CONFIG_CPU_SUBTYPE_SH7201)
-        if (port->mapbase == 0xfffeA000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfffeA800)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfffeB000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xfffeB800)
-                return __raw_readw(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF */
-#endif
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SH7619)
-static inline int sci_rxd_in(struct uart_port *port)
-{
-        if (port->mapbase == 0xf8400000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xf8410000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xf8420000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        return 1;
-}
-#elif defined(CONFIG_CPU_SUBTYPE_SHX3)
+#else /* default case for non-SCI processors */
 static inline int sci_rxd_in(struct uart_port *port)
 {
-        if (port->mapbase == 0xffc30000)
-                return __raw_readw(SCSPTR0) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffc40000)
-                return __raw_readw(SCSPTR1) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffc50000)
-                return __raw_readw(SCSPTR2) & 0x0001 ? 1 : 0; /* SCIF */
-        if (port->mapbase == 0xffc60000)
-                return __raw_readw(SCSPTR3) & 0x0001 ? 1 : 0; /* SCIF */
         return 1;
 }
 #endif
diff --git a/drivers/sh/intc.c b/drivers/sh/intc.c
index d5d7f23c19a5..3a5a17db9474 100644
--- a/drivers/sh/intc.c
+++ b/drivers/sh/intc.c
@@ -259,6 +259,43 @@ static void intc_disable(unsigned int irq)
         }
 }
 
+static void (*intc_enable_noprio_fns[])(unsigned long addr,
+                                        unsigned long handle,
+                                        void (*fn)(unsigned long,
+                                                   unsigned long,
+                                                   unsigned long),
+                                        unsigned int irq) = {
+        [MODE_ENABLE_REG] = intc_mode_field,
+        [MODE_MASK_REG] = intc_mode_zero,
+        [MODE_DUAL_REG] = intc_mode_field,
+        [MODE_PRIO_REG] = intc_mode_field,
+        [MODE_PCLR_REG] = intc_mode_field,
+};
+
+static void intc_enable_disable(struct intc_desc_int *d,
+                                unsigned long handle, int do_enable)
+{
+        unsigned long addr;
+        unsigned int cpu;
+        void (*fn)(unsigned long, unsigned long,
+                   void (*)(unsigned long, unsigned long, unsigned long),
+                   unsigned int);
+
+        if (do_enable) {
+                for (cpu = 0; cpu < SMP_NR(d, _INTC_ADDR_E(handle)); cpu++) {
+                        addr = INTC_REG(d, _INTC_ADDR_E(handle), cpu);
+                        fn = intc_enable_noprio_fns[_INTC_MODE(handle)];
+                        fn(addr, handle, intc_reg_fns[_INTC_FN(handle)], 0);
+                }
+        } else {
+                for (cpu = 0; cpu < SMP_NR(d, _INTC_ADDR_D(handle)); cpu++) {
+                        addr = INTC_REG(d, _INTC_ADDR_D(handle), cpu);
+                        fn = intc_disable_fns[_INTC_MODE(handle)];
+                        fn(addr, handle, intc_reg_fns[_INTC_FN(handle)], 0);
+                }
+        }
+}
+
 static int intc_set_wake(unsigned int irq, unsigned int on)
 {
         return 0; /* allow wakeup, but setup hardware in intc_suspend() */
@@ -400,11 +437,11 @@ static unsigned int __init intc_get_reg(struct intc_desc_int *d,
 static intc_enum __init intc_grp_id(struct intc_desc *desc,
                                     intc_enum enum_id)
 {
-        struct intc_group *g = desc->groups;
+        struct intc_group *g = desc->hw.groups;
         unsigned int i, j;
 
-        for (i = 0; g && enum_id && i < desc->nr_groups; i++) {
-                g = desc->groups + i;
+        for (i = 0; g && enum_id && i < desc->hw.nr_groups; i++) {
+                g = desc->hw.groups + i;
 
                 for (j = 0; g->enum_ids[j]; j++) {
                         if (g->enum_ids[j] != enum_id)
@@ -417,19 +454,21 @@ static intc_enum __init intc_grp_id(struct intc_desc *desc,
         return 0;
 }
 
-static unsigned int __init intc_mask_data(struct intc_desc *desc,
-                                          struct intc_desc_int *d,
-                                          intc_enum enum_id, int do_grps)
+static unsigned int __init _intc_mask_data(struct intc_desc *desc,
+                                           struct intc_desc_int *d,
+                                           intc_enum enum_id,
+                                           unsigned int *reg_idx,
+                                           unsigned int *fld_idx)
 {
-        struct intc_mask_reg *mr = desc->mask_regs;
-        unsigned int i, j, fn, mode;
+        struct intc_mask_reg *mr = desc->hw.mask_regs;
+        unsigned int fn, mode;
         unsigned long reg_e, reg_d;
 
-        for (i = 0; mr && enum_id && i < desc->nr_mask_regs; i++) {
-                mr = desc->mask_regs + i;
+        while (mr && enum_id && *reg_idx < desc->hw.nr_mask_regs) {
+                mr = desc->hw.mask_regs + *reg_idx;
 
-                for (j = 0; j < ARRAY_SIZE(mr->enum_ids); j++) {
-                        if (mr->enum_ids[j] != enum_id)
+                for (; *fld_idx < ARRAY_SIZE(mr->enum_ids); (*fld_idx)++) {
+                        if (mr->enum_ids[*fld_idx] != enum_id)
                                 continue;
 
                         if (mr->set_reg && mr->clr_reg) {
@@ -455,29 +494,49 @@ static unsigned int __init intc_mask_data(struct intc_desc *desc,
                                         intc_get_reg(d, reg_e),
                                         intc_get_reg(d, reg_d),
                                         1,
-                                        (mr->reg_width - 1) - j);
+                                        (mr->reg_width - 1) - *fld_idx);
                 }
+
+                *fld_idx = 0;
+                (*reg_idx)++;
         }
 
+        return 0;
+}
+
+static unsigned int __init intc_mask_data(struct intc_desc *desc,
+                                          struct intc_desc_int *d,
+                                          intc_enum enum_id, int do_grps)
+{
+        unsigned int i = 0;
+        unsigned int j = 0;
+        unsigned int ret;
+
+        ret = _intc_mask_data(desc, d, enum_id, &i, &j);
+        if (ret)
+                return ret;
+
         if (do_grps)
                 return intc_mask_data(desc, d, intc_grp_id(desc, enum_id), 0);
 
         return 0;
 }
 
-static unsigned int __init intc_prio_data(struct intc_desc *desc,
-                                          struct intc_desc_int *d,
-                                          intc_enum enum_id, int do_grps)
+static unsigned int __init _intc_prio_data(struct intc_desc *desc,
+                                           struct intc_desc_int *d,
+                                           intc_enum enum_id,
+                                           unsigned int *reg_idx,
+                                           unsigned int *fld_idx)
 {
-        struct intc_prio_reg *pr = desc->prio_regs;
-        unsigned int i, j, fn, mode, bit;
+        struct intc_prio_reg *pr = desc->hw.prio_regs;
+        unsigned int fn, n, mode, bit;
         unsigned long reg_e, reg_d;
 
-        for (i = 0; pr && enum_id && i < desc->nr_prio_regs; i++) {
-                pr = desc->prio_regs + i;
+        while (pr && enum_id && *reg_idx < desc->hw.nr_prio_regs) {
+                pr = desc->hw.prio_regs + *reg_idx;
 
-                for (j = 0; j < ARRAY_SIZE(pr->enum_ids); j++) {
-                        if (pr->enum_ids[j] != enum_id)
+                for (; *fld_idx < ARRAY_SIZE(pr->enum_ids); (*fld_idx)++) {
+                        if (pr->enum_ids[*fld_idx] != enum_id)
                                 continue;
 
                         if (pr->set_reg && pr->clr_reg) {
@@ -495,34 +554,79 @@ static unsigned int __init intc_prio_data(struct intc_desc *desc,
                         }
 
                         fn += (pr->reg_width >> 3) - 1;
+                        n = *fld_idx + 1;
 
-                        BUG_ON((j + 1) * pr->field_width > pr->reg_width);
+                        BUG_ON(n * pr->field_width > pr->reg_width);
 
-                        bit = pr->reg_width - ((j + 1) * pr->field_width);
+                        bit = pr->reg_width - (n * pr->field_width);
 
                         return _INTC_MK(fn, mode,
                                         intc_get_reg(d, reg_e),
                                         intc_get_reg(d, reg_d),
                                         pr->field_width, bit);
                 }
+
+                *fld_idx = 0;
+                (*reg_idx)++;
         }
 
+        return 0;
+}
+
+static unsigned int __init intc_prio_data(struct intc_desc *desc,
+                                          struct intc_desc_int *d,
+                                          intc_enum enum_id, int do_grps)
+{
+        unsigned int i = 0;
+        unsigned int j = 0;
+        unsigned int ret;
+
+        ret = _intc_prio_data(desc, d, enum_id, &i, &j);
+        if (ret)
+                return ret;
+
         if (do_grps)
                 return intc_prio_data(desc, d, intc_grp_id(desc, enum_id), 0);
 
         return 0;
 }
 
+static void __init intc_enable_disable_enum(struct intc_desc *desc,
+                                            struct intc_desc_int *d,
+                                            intc_enum enum_id, int enable)
+{
+        unsigned int i, j, data;
+
+        /* go through and enable/disable all mask bits */
+        i = j = 0;
+        do {
+                data = _intc_mask_data(desc, d, enum_id, &i, &j);
+                if (data)
+                        intc_enable_disable(d, data, enable);
+                j++;
+        } while (data);
+
+        /* go through and enable/disable all priority fields */
+        i = j = 0;
+        do {
+                data = _intc_prio_data(desc, d, enum_id, &i, &j);
+                if (data)
+                        intc_enable_disable(d, data, enable);
+
+                j++;
+        } while (data);
+}
+
 static unsigned int __init intc_ack_data(struct intc_desc *desc,
                                           struct intc_desc_int *d,
                                           intc_enum enum_id)
 {
-        struct intc_mask_reg *mr = desc->ack_regs;
+        struct intc_mask_reg *mr = desc->hw.ack_regs;
         unsigned int i, j, fn, mode;
         unsigned long reg_e, reg_d;
 
-        for (i = 0; mr && enum_id && i < desc->nr_ack_regs; i++) {
-                mr = desc->ack_regs + i;
+        for (i = 0; mr && enum_id && i < desc->hw.nr_ack_regs; i++) {
+                mr = desc->hw.ack_regs + i;
 
                 for (j = 0; j < ARRAY_SIZE(mr->enum_ids); j++) {
                         if (mr->enum_ids[j] != enum_id)
@@ -549,11 +653,11 @@ static unsigned int __init intc_sense_data(struct intc_desc *desc,
                                            struct intc_desc_int *d,
                                            intc_enum enum_id)
 {
-        struct intc_sense_reg *sr = desc->sense_regs;
+        struct intc_sense_reg *sr = desc->hw.sense_regs;
         unsigned int i, j, fn, bit;
 
-        for (i = 0; sr && enum_id && i < desc->nr_sense_regs; i++) {
-                sr = desc->sense_regs + i;
+        for (i = 0; sr && enum_id && i < desc->hw.nr_sense_regs; i++) {
+                sr = desc->hw.sense_regs + i;
 
                 for (j = 0; j < ARRAY_SIZE(sr->enum_ids); j++) {
                         if (sr->enum_ids[j] != enum_id)
@@ -656,7 +760,7 @@ static void __init intc_register_irq(struct intc_desc *desc,
         /* irq should be disabled by default */
         d->chip.mask(irq);
 
-        if (desc->ack_regs)
+        if (desc->hw.ack_regs)
                 ack_handle[irq] = intc_ack_data(desc, d, enum_id);
 }
 
@@ -684,6 +788,7 @@ static void intc_redirect_irq(unsigned int irq, struct irq_desc *desc)
 void __init register_intc_controller(struct intc_desc *desc)
 {
         unsigned int i, k, smp;
+        struct intc_hw_desc *hw = &desc->hw;
         struct intc_desc_int *d;
 
         d = kzalloc(sizeof(*d), GFP_NOWAIT);
@@ -691,10 +796,10 @@ void __init register_intc_controller(struct intc_desc *desc)
         INIT_LIST_HEAD(&d->list);
         list_add(&d->list, &intc_list);
 
-        d->nr_reg = desc->mask_regs ? desc->nr_mask_regs * 2 : 0;
-        d->nr_reg += desc->prio_regs ? desc->nr_prio_regs * 2 : 0;
-        d->nr_reg += desc->sense_regs ? desc->nr_sense_regs : 0;
-        d->nr_reg += desc->ack_regs ? desc->nr_ack_regs : 0;
+        d->nr_reg = hw->mask_regs ? hw->nr_mask_regs * 2 : 0;
+        d->nr_reg += hw->prio_regs ? hw->nr_prio_regs * 2 : 0;
+        d->nr_reg += hw->sense_regs ? hw->nr_sense_regs : 0;
+        d->nr_reg += hw->ack_regs ? hw->nr_ack_regs : 0;
 
         d->reg = kzalloc(d->nr_reg * sizeof(*d->reg), GFP_NOWAIT);
 #ifdef CONFIG_SMP
@@ -702,30 +807,31 @@ void __init register_intc_controller(struct intc_desc *desc)
 #endif
         k = 0;
 
-        if (desc->mask_regs) {
-                for (i = 0; i < desc->nr_mask_regs; i++) {
-                        smp = IS_SMP(desc->mask_regs[i]);
-                        k += save_reg(d, k, desc->mask_regs[i].set_reg, smp);
-                        k += save_reg(d, k, desc->mask_regs[i].clr_reg, smp);
+        if (hw->mask_regs) {
+                for (i = 0; i < hw->nr_mask_regs; i++) {
+                        smp = IS_SMP(hw->mask_regs[i]);
+                        k += save_reg(d, k, hw->mask_regs[i].set_reg, smp);
+                        k += save_reg(d, k, hw->mask_regs[i].clr_reg, smp);
                 }
         }
 
-        if (desc->prio_regs) {
-                d->prio = kzalloc(desc->nr_vectors * sizeof(*d->prio), GFP_NOWAIT);
+        if (hw->prio_regs) {
+                d->prio = kzalloc(hw->nr_vectors * sizeof(*d->prio),
+                                  GFP_NOWAIT);
 
-                for (i = 0; i < desc->nr_prio_regs; i++) {
-                        smp = IS_SMP(desc->prio_regs[i]);
-                        k += save_reg(d, k, desc->prio_regs[i].set_reg, smp);
-                        k += save_reg(d, k, desc->prio_regs[i].clr_reg, smp);
+                for (i = 0; i < hw->nr_prio_regs; i++) {
+                        smp = IS_SMP(hw->prio_regs[i]);
+                        k += save_reg(d, k, hw->prio_regs[i].set_reg, smp);
+                        k += save_reg(d, k, hw->prio_regs[i].clr_reg, smp);
                 }
         }
 
-        if (desc->sense_regs) {
-                d->sense = kzalloc(desc->nr_vectors * sizeof(*d->sense), GFP_NOWAIT);
+        if (hw->sense_regs) {
+                d->sense = kzalloc(hw->nr_vectors * sizeof(*d->sense),
+                                   GFP_NOWAIT);
 
-                for (i = 0; i < desc->nr_sense_regs; i++) {
-                        k += save_reg(d, k, desc->sense_regs[i].reg, 0);
-                }
+                for (i = 0; i < hw->nr_sense_regs; i++)
+                        k += save_reg(d, k, hw->sense_regs[i].reg, 0);
         }
 
         d->chip.name = desc->name;
@@ -738,18 +844,26 @@ void __init register_intc_controller(struct intc_desc *desc)
         d->chip.set_type = intc_set_sense;
         d->chip.set_wake = intc_set_wake;
 
-        if (desc->ack_regs) {
-                for (i = 0; i < desc->nr_ack_regs; i++)
-                        k += save_reg(d, k, desc->ack_regs[i].set_reg, 0);
+        if (hw->ack_regs) {
+                for (i = 0; i < hw->nr_ack_regs; i++)
+                        k += save_reg(d, k, hw->ack_regs[i].set_reg, 0);
 
                 d->chip.mask_ack = intc_mask_ack;
         }
 
+        /* disable bits matching force_disable before registering irqs */
+        if (desc->force_disable)
+                intc_enable_disable_enum(desc, d, desc->force_disable, 0);
+
+        /* disable bits matching force_enable before registering irqs */
+        if (desc->force_enable)
+                intc_enable_disable_enum(desc, d, desc->force_enable, 0);
+
         BUG_ON(k > 256); /* _INTC_ADDR_E() and _INTC_ADDR_D() are 8 bits */
 
         /* register the vectors one by one */
-        for (i = 0; i < desc->nr_vectors; i++) {
-                struct intc_vect *vect = desc->vectors + i;
+        for (i = 0; i < hw->nr_vectors; i++) {
+                struct intc_vect *vect = hw->vectors + i;
                 unsigned int irq = evt2irq(vect->vect);
                 struct irq_desc *irq_desc;
 
@@ -764,8 +878,8 @@ void __init register_intc_controller(struct intc_desc *desc)
 
                 intc_register_irq(desc, d, vect->enum_id, irq);
 
-                for (k = i + 1; k < desc->nr_vectors; k++) {
-                        struct intc_vect *vect2 = desc->vectors + k;
+                for (k = i + 1; k < hw->nr_vectors; k++) {
+                        struct intc_vect *vect2 = hw->vectors + k;
                         unsigned int irq2 = evt2irq(vect2->vect);
 
                         if (vect->enum_id != vect2->enum_id)
@@ -785,11 +899,15 @@ void __init register_intc_controller(struct intc_desc *desc)
                         vect2->enum_id = 0;
 
                         /* redirect this interrupts to the first one */
-                        set_irq_chip_and_handler_name(irq2, &d->chip,
-                                        intc_redirect_irq, "redirect");
+                        set_irq_chip(irq2, &dummy_irq_chip);
+                        set_irq_chained_handler(irq2, intc_redirect_irq);
                         set_irq_data(irq2, (void *)irq);
                 }
         }
+
+        /* enable bits matching force_enable after registering irqs */
+        if (desc->force_enable)
+                intc_enable_disable_enum(desc, d, desc->force_enable, 1);
 }
 
 static int intc_suspend(struct sys_device *dev, pm_message_t state)
@@ -872,7 +990,7 @@ device_initcall(register_intc_sysdevs);
 /*
  * Dynamic IRQ allocation and deallocation
  */
-static unsigned int create_irq_on_node(unsigned int irq_want, int node)
+unsigned int create_irq_nr(unsigned int irq_want, int node)
 {
         unsigned int irq = 0, new;
         unsigned long flags;
@@ -881,24 +999,28 @@ static unsigned int create_irq_on_node(unsigned int irq_want, int node)
         spin_lock_irqsave(&vector_lock, flags);
 
         /*
-         * First try the wanted IRQ, then scan.
+         * First try the wanted IRQ
          */
-        if (test_and_set_bit(irq_want, intc_irq_map)) {
+        if (test_and_set_bit(irq_want, intc_irq_map) == 0) {
+                new = irq_want;
+        } else {
+                /* .. then fall back to scanning. */
                 new = find_first_zero_bit(intc_irq_map, nr_irqs);
                 if (unlikely(new == nr_irqs))
                         goto out_unlock;
 
-                desc = irq_to_desc_alloc_node(new, node);
-                if (unlikely(!desc)) {
-                        pr_info("can't get irq_desc for %d\n", new);
-                        goto out_unlock;
-                }
-
-                desc = move_irq_desc(desc, node);
                 __set_bit(new, intc_irq_map);
-                irq = new;
         }
 
+        desc = irq_to_desc_alloc_node(new, node);
+        if (unlikely(!desc)) {
+                pr_info("can't get irq_desc for %d\n", new);
+                goto out_unlock;
+        }
+
+        desc = move_irq_desc(desc, node);
+        irq = new;
+
 out_unlock:
         spin_unlock_irqrestore(&vector_lock, flags);
 
@@ -913,7 +1035,7 @@ int create_irq(void)
         int nid = cpu_to_node(smp_processor_id());
         int irq;
 
-        irq = create_irq_on_node(NR_IRQS_LEGACY, nid);
+        irq = create_irq_nr(NR_IRQS_LEGACY, nid);
         if (irq == 0)
                 irq = -1;
 
diff --git a/drivers/sh/pfc.c b/drivers/sh/pfc.c
index 082604edc4c2..cf0303acab8e 100644
--- a/drivers/sh/pfc.c
+++ b/drivers/sh/pfc.c
@@ -337,12 +337,39 @@ static int pinmux_config_gpio(struct pinmux_info *gpioc, unsigned gpio,
                 if (!enum_id)
                         break;
 
+                /* first check if this is a function enum */
                 in_range = enum_in_range(enum_id, &gpioc->function);
-                if (!in_range && range) {
-                        in_range = enum_in_range(enum_id, range);
-
-                        if (in_range && enum_id == range->force)
-                                continue;
+                if (!in_range) {
+                        /* not a function enum */
+                        if (range) {
+                                /*
+                                 * other range exists, so this pin is
+                                 * a regular GPIO pin that now is being
+                                 * bound to a specific direction.
+                                 *
+                                 * for this case we only allow function enums
+                                 * and the enums that match the other range.
+                                 */
+                                in_range = enum_in_range(enum_id, range);
+
+                                /*
+                                 * special case pass through for fixed
+                                 * input-only or output-only pins without
+                                 * function enum register association.
+                                 */
+                                if (in_range && enum_id == range->force)
+                                        continue;
+                        } else {
+                                /*
+                                 * no other range exists, so this pin
+                                 * must then be of the function type.
+                                 *
+                                 * allow function type pins to select
+                                 * any combination of function/in/out
+                                 * in their MARK lists.
+                                 */
+                                in_range = 1;
+                        }
                 }
 
                 if (!in_range)
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/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/pvr2fb.c b/drivers/video/pvr2fb.c
index 53f8f1100e81..f9975100d56d 100644
--- a/drivers/video/pvr2fb.c
+++ b/drivers/video/pvr2fb.c
@@ -831,7 +831,7 @@ static int __devinit pvr2fb_common_init(void)
         printk(KERN_NOTICE "fb%d: registering with SQ API\n", fb_info->node);
 
         pvr2fb_map = sq_remap(fb_info->fix.smem_start, fb_info->fix.smem_len,
-                              fb_info->fix.id, pgprot_val(PAGE_SHARED));
+                              fb_info->fix.id, PAGE_SHARED);
 
         printk(KERN_NOTICE "fb%d: Mapped video memory to SQ addr 0x%lx\n",
                fb_info->node, pvr2fb_map);
diff --git a/drivers/video/sh_mobile_lcdcfb.c b/drivers/video/sh_mobile_lcdcfb.c
index a69830d26f7f..8d7653e56df5 100644
--- a/drivers/video/sh_mobile_lcdcfb.c
+++ b/drivers/video/sh_mobile_lcdcfb.c
@@ -19,6 +19,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
 #include <linux/vmalloc.h>
+#include <linux/ioctl.h>
 #include <video/sh_mobile_lcdc.h>
 #include <asm/atomic.h>
 
@@ -106,6 +107,7 @@ static unsigned long lcdc_offs_sublcd[NR_CH_REGS] = {
 #define LDRCNTR_SRC     0x00010000
 #define LDRCNTR_MRS     0x00000002
 #define LDRCNTR_MRC     0x00000001
+#define LDSR_MRS        0x00000100
 
 struct sh_mobile_lcdc_priv;
 struct sh_mobile_lcdc_chan {
@@ -122,8 +124,8 @@ struct sh_mobile_lcdc_chan {
         struct scatterlist *sglist;
         unsigned long frame_end;
         unsigned long pan_offset;
-        unsigned long new_pan_offset;
         wait_queue_head_t frame_end_wait;
+        struct completion vsync_completion;
 };
 
 struct sh_mobile_lcdc_priv {
@@ -366,19 +368,8 @@ static irqreturn_t sh_mobile_lcdc_irq(int irq, void *data)
                 }
 
                 /* VSYNC End */
-                if (ldintr & LDINTR_VES) {
-                        unsigned long ldrcntr = lcdc_read(priv, _LDRCNTR);
-                        /* Set the source address for the next refresh */
-                        lcdc_write_chan_mirror(ch, LDSA1R, ch->dma_handle +
-                                               ch->new_pan_offset);
-                        if (lcdc_chan_is_sublcd(ch))
-                                lcdc_write(ch->lcdc, _LDRCNTR,
-                                           ldrcntr ^ LDRCNTR_SRS);
-                        else
-                                lcdc_write(ch->lcdc, _LDRCNTR,
-                                           ldrcntr ^ LDRCNTR_MRS);
-                        ch->pan_offset = ch->new_pan_offset;
-                }
+                if (ldintr & LDINTR_VES)
+                        complete(&ch->vsync_completion);
         }
 
         return IRQ_HANDLED;
@@ -767,25 +758,69 @@ static int sh_mobile_fb_pan_display(struct fb_var_screeninfo *var,
                                      struct fb_info *info)
 {
         struct sh_mobile_lcdc_chan *ch = info->par;
+        struct sh_mobile_lcdc_priv *priv = ch->lcdc;
+        unsigned long ldrcntr;
+        unsigned long new_pan_offset;
+
+        new_pan_offset = (var->yoffset * info->fix.line_length) +
+                (var->xoffset * (info->var.bits_per_pixel / 8));
 
-        if (info->var.xoffset == var->xoffset &&
-            info->var.yoffset == var->yoffset)
+        if (new_pan_offset == ch->pan_offset)
                 return 0;       /* No change, do nothing */
 
-        ch->new_pan_offset = (var->yoffset * info->fix.line_length) +
-                (var->xoffset * (info->var.bits_per_pixel / 8));
+        ldrcntr = lcdc_read(priv, _LDRCNTR);
 
-        if (ch->new_pan_offset != ch->pan_offset) {
-                unsigned long ldintr;
-                ldintr = lcdc_read(ch->lcdc, _LDINTR);
-                ldintr |= LDINTR_VEE;
-                lcdc_write(ch->lcdc, _LDINTR, ldintr);
-                sh_mobile_lcdc_deferred_io_touch(info);
-        }
+        /* Set the source address for the next refresh */
+        lcdc_write_chan_mirror(ch, LDSA1R, ch->dma_handle + new_pan_offset);
+        if (lcdc_chan_is_sublcd(ch))
+                lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_SRS);
+        else
+                lcdc_write(ch->lcdc, _LDRCNTR, ldrcntr ^ LDRCNTR_MRS);
+
+        ch->pan_offset = new_pan_offset;
+
+        sh_mobile_lcdc_deferred_io_touch(info);
+
+        return 0;
+}
+
+static int sh_mobile_wait_for_vsync(struct fb_info *info)
+{
+        struct sh_mobile_lcdc_chan *ch = info->par;
+        unsigned long ldintr;
+        int ret;
+
+        /* Enable VSync End interrupt */
+        ldintr = lcdc_read(ch->lcdc, _LDINTR);
+        ldintr |= LDINTR_VEE;
+        lcdc_write(ch->lcdc, _LDINTR, ldintr);
+
+        ret = wait_for_completion_interruptible_timeout(&ch->vsync_completion,
+                                                        msecs_to_jiffies(100));
+        if (!ret)
+                return -ETIMEDOUT;
 
         return 0;
 }
 
+static int sh_mobile_ioctl(struct fb_info *info, unsigned int cmd,
+                       unsigned long arg)
+{
+        int retval;
+
+        switch (cmd) {
+        case FBIO_WAITFORVSYNC:
+                retval = sh_mobile_wait_for_vsync(info);
+                break;
+
+        default:
+                retval = -ENOIOCTLCMD;
+                break;
+        }
+        return retval;
+}
+
+
 static struct fb_ops sh_mobile_lcdc_ops = {
         .owner          = THIS_MODULE,
         .fb_setcolreg   = sh_mobile_lcdc_setcolreg,
@@ -795,6 +830,7 @@ static struct fb_ops sh_mobile_lcdc_ops = {
         .fb_copyarea    = sh_mobile_lcdc_copyarea,
         .fb_imageblit   = sh_mobile_lcdc_imageblit,
         .fb_pan_display = sh_mobile_fb_pan_display,
+        .fb_ioctl       = sh_mobile_ioctl,
 };
 
 static int sh_mobile_lcdc_set_bpp(struct fb_var_screeninfo *var, int bpp)
@@ -962,8 +998,8 @@ static int __init sh_mobile_lcdc_probe(struct platform_device *pdev)
                         goto err1;
                 }
                 init_waitqueue_head(&priv->ch[i].frame_end_wait);
+                init_completion(&priv->ch[i].vsync_completion);
                 priv->ch[j].pan_offset = 0;
-                priv->ch[j].new_pan_offset = 0;
 
                 switch (pdata->ch[i].chan) {
                 case LCDC_CHAN_MAINLCD:
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;
 }