339 files changed, 16896 insertions, 4941 deletions

diff --git a/drivers/Makefile b/drivers/Makefile
index 6b17f5864340..09f3232bcdcd 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -17,6 +17,9 @@ obj-$(CONFIG_SFI)		+= sfi/
 # was used and do nothing if so
 obj-$(CONFIG_PNP)               += pnp/
 obj-$(CONFIG_ARM_AMBA)          += amba/
+# Many drivers will want to use DMA so this has to be made available
+# really early.
+obj-$(CONFIG_DMA_ENGINE)        += dma/
 
 obj-$(CONFIG_VIRTIO)            += virtio/
 obj-$(CONFIG_XEN)               += xen/
@@ -92,7 +95,6 @@ obj-$(CONFIG_EISA)		+= eisa/
 obj-y                           += lguest/
 obj-$(CONFIG_CPU_FREQ)          += cpufreq/
 obj-$(CONFIG_CPU_IDLE)          += cpuidle/
-obj-$(CONFIG_DMA_ENGINE)        += dma/
 obj-$(CONFIG_MMC)               += mmc/
 obj-$(CONFIG_MEMSTICK)          += memstick/
 obj-y                           += leds/
diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index bc2218db5ba9..de0e3df76776 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -369,6 +369,21 @@ config ACPI_HED
           which is used to report some hardware errors notified via
           SCI, mainly the corrected errors.
 
+config ACPI_CUSTOM_METHOD
+        tristate "Allow ACPI methods to be inserted/replaced at run time"
+        depends on DEBUG_FS
+        default n
+        help
+          This debug facility allows ACPI AML methods to me inserted and/or
+          replaced without rebooting the system. For details refer to:
+          Documentation/acpi/method-customizing.txt.
+
+          NOTE: This option is security sensitive, because it allows arbitrary
+          kernel memory to be written to by root (uid=0) users, allowing them
+          to bypass certain security measures (e.g. if root is not allowed to
+          load additional kernel modules after boot, this feature may be used
+          to override that restriction).
+
 source "drivers/acpi/apei/Kconfig"
 
 endif   # ACPI
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index b66fbb2fc85f..ecb26b4f29a0 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -61,6 +61,7 @@ obj-$(CONFIG_ACPI_SBS)		+= sbshc.o
 obj-$(CONFIG_ACPI_SBS)          += sbs.o
 obj-$(CONFIG_ACPI_HED)          += hed.o
 obj-$(CONFIG_ACPI_EC_DEBUGFS)   += ec_sys.o
+obj-$(CONFIG_ACPI_CUSTOM_METHOD)+= custom_method.o
 
 # processor has its own "processor." module_param namespace
 processor-y                     := processor_driver.o processor_throttling.o
diff --git a/drivers/acpi/acpica/Makefile b/drivers/acpi/acpica/Makefile
index a1224712fd0c..301bd2d388ad 100644
--- a/drivers/acpi/acpica/Makefile
+++ b/drivers/acpi/acpica/Makefile
@@ -14,7 +14,7 @@ acpi-y := dsfield.o   dsmthdat.o  dsopcode.o  dswexec.o  dswscope.o \
 
 acpi-y += evevent.o  evregion.o  evsci.o    evxfevnt.o \
          evmisc.o   evrgnini.o  evxface.o  evxfregn.o \
-         evgpe.o    evgpeblk.o evgpeinit.o  evgpeutil.o evxfgpe.o
+         evgpe.o    evgpeblk.o evgpeinit.o  evgpeutil.o evxfgpe.o evglock.o
 
 acpi-y += exconfig.o  exfield.o  exnames.o   exoparg6.o  exresolv.o  exstorob.o\
          exconvrt.o  exfldio.o  exoparg1.o  exprep.o    exresop.o   exsystem.o\
diff --git a/drivers/acpi/acpica/acconfig.h b/drivers/acpi/acpica/acconfig.h
index ab87396c2c07..bc533dde16c4 100644
--- a/drivers/acpi/acpica/acconfig.h
+++ b/drivers/acpi/acpica/acconfig.h
@@ -187,7 +187,6 @@
 
 /* Operation regions */
 
-#define ACPI_NUM_PREDEFINED_REGIONS     9
 #define ACPI_USER_REGION_BEGIN          0x80
 
 /* Maximum space_ids for Operation Regions */
diff --git a/drivers/acpi/acpica/acevents.h b/drivers/acpi/acpica/acevents.h
index 41d247daf461..bea3b4899183 100644
--- a/drivers/acpi/acpica/acevents.h
+++ b/drivers/acpi/acpica/acevents.h
@@ -58,12 +58,6 @@ u32 acpi_ev_fixed_event_detect(void);
  */
 u8 acpi_ev_is_notify_object(struct acpi_namespace_node *node);
 
-acpi_status acpi_ev_acquire_global_lock(u16 timeout);
-
-acpi_status acpi_ev_release_global_lock(void);
-
-acpi_status acpi_ev_init_global_lock_handler(void);
-
 u32 acpi_ev_get_gpe_number_index(u32 gpe_number);
 
 acpi_status
@@ -71,6 +65,17 @@ acpi_ev_queue_notify_request(struct acpi_namespace_node *node,
                              u32 notify_value);
 
 /*
+ * evglock - Global Lock support
+ */
+acpi_status acpi_ev_init_global_lock_handler(void);
+
+acpi_status acpi_ev_acquire_global_lock(u16 timeout);
+
+acpi_status acpi_ev_release_global_lock(void);
+
+acpi_status acpi_ev_remove_global_lock_handler(void);
+
+/*
  * evgpe - Low-level GPE support
  */
 u32 acpi_ev_gpe_detect(struct acpi_gpe_xrupt_info *gpe_xrupt_list);
diff --git a/drivers/acpi/acpica/acglobal.h b/drivers/acpi/acpica/acglobal.h
index d69750b83b36..73863d86f022 100644
--- a/drivers/acpi/acpica/acglobal.h
+++ b/drivers/acpi/acpica/acglobal.h
@@ -214,24 +214,23 @@ ACPI_EXTERN struct acpi_mutex_info acpi_gbl_mutex_info[ACPI_NUM_MUTEX];
 
 /*
  * Global lock mutex is an actual AML mutex object
- * Global lock semaphore works in conjunction with the HW global lock
+ * Global lock semaphore works in conjunction with the actual global lock
+ * Global lock spinlock is used for "pending" handshake
  */
 ACPI_EXTERN union acpi_operand_object *acpi_gbl_global_lock_mutex;
 ACPI_EXTERN acpi_semaphore acpi_gbl_global_lock_semaphore;
+ACPI_EXTERN acpi_spinlock acpi_gbl_global_lock_pending_lock;
 ACPI_EXTERN u16 acpi_gbl_global_lock_handle;
 ACPI_EXTERN u8 acpi_gbl_global_lock_acquired;
 ACPI_EXTERN u8 acpi_gbl_global_lock_present;
+ACPI_EXTERN u8 acpi_gbl_global_lock_pending;
 
 /*
  * Spinlocks are used for interfaces that can be possibly called at
  * interrupt level
  */
-ACPI_EXTERN spinlock_t _acpi_gbl_gpe_lock;      /* For GPE data structs and registers */
-ACPI_EXTERN spinlock_t _acpi_gbl_hardware_lock; /* For ACPI H/W except GPE registers */
-ACPI_EXTERN spinlock_t _acpi_ev_global_lock_pending_lock; /* For global lock */
-#define acpi_gbl_gpe_lock       &_acpi_gbl_gpe_lock
-#define acpi_gbl_hardware_lock  &_acpi_gbl_hardware_lock
-#define acpi_ev_global_lock_pending_lock &_acpi_ev_global_lock_pending_lock
+ACPI_EXTERN acpi_spinlock acpi_gbl_gpe_lock;    /* For GPE data structs and registers */
+ACPI_EXTERN acpi_spinlock acpi_gbl_hardware_lock;       /* For ACPI H/W except GPE registers */
 
 /*****************************************************************************
  *
diff --git a/drivers/acpi/acpica/amlcode.h b/drivers/acpi/acpica/amlcode.h
index f4f0998d3967..1077f17859ed 100644
--- a/drivers/acpi/acpica/amlcode.h
+++ b/drivers/acpi/acpica/amlcode.h
@@ -394,21 +394,6 @@
 #define AML_CLASS_METHOD_CALL       0x09
 #define AML_CLASS_UNKNOWN           0x0A
 
-/* Predefined Operation Region space_iDs */
-
-typedef enum {
-        REGION_MEMORY = 0,
-        REGION_IO,
-        REGION_PCI_CONFIG,
-        REGION_EC,
-        REGION_SMBUS,
-        REGION_CMOS,
-        REGION_PCI_BAR,
-        REGION_IPMI,
-        REGION_DATA_TABLE,      /* Internal use only */
-        REGION_FIXED_HW = 0x7F
-} AML_REGION_TYPES;
-
 /* Comparison operation codes for match_op operator */
 
 typedef enum {
diff --git a/drivers/acpi/acpica/dswload.c b/drivers/acpi/acpica/dswload.c
index 23a3b1ab20c1..324acec1179a 100644
--- a/drivers/acpi/acpica/dswload.c
+++ b/drivers/acpi/acpica/dswload.c
@@ -450,7 +450,7 @@ acpi_status acpi_ds_load1_end_op(struct acpi_walk_state *walk_state)
                         status =
                             acpi_ex_create_region(op->named.data,
                                                   op->named.length,
-                                                  REGION_DATA_TABLE,
+                                                  ACPI_ADR_SPACE_DATA_TABLE,
                                                   walk_state);
                         if (ACPI_FAILURE(status)) {
                                 return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/dswload2.c b/drivers/acpi/acpica/dswload2.c
index 4be4e921dfe1..976318138c56 100644
--- a/drivers/acpi/acpica/dswload2.c
+++ b/drivers/acpi/acpica/dswload2.c
@@ -562,7 +562,7 @@ acpi_status acpi_ds_load2_end_op(struct acpi_walk_state *walk_state)
                                     ((op->common.value.arg)->common.value.
                                      integer);
                         } else {
-                                region_space = REGION_DATA_TABLE;
+                                region_space = ACPI_ADR_SPACE_DATA_TABLE;
                         }
 
                         /*
diff --git a/drivers/acpi/acpica/evglock.c b/drivers/acpi/acpica/evglock.c
new file mode 100644
index 000000000000..56a562a1e5d7
--- /dev/null
+++ b/drivers/acpi/acpica/evglock.c
@@ -0,0 +1,335 @@
+/******************************************************************************
+ *
+ * Module Name: evglock - Global Lock support
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2011, Intel Corp.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions, and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    substantially similar to the "NO WARRANTY" disclaimer below
+ *    ("Disclaimer") and any redistribution must be conditioned upon
+ *    including a substantially similar Disclaimer requirement for further
+ *    binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <acpi/acpi.h>
+#include "accommon.h"
+#include "acevents.h"
+#include "acinterp.h"
+
+#define _COMPONENT          ACPI_EVENTS
+ACPI_MODULE_NAME("evglock")
+
+/* Local prototypes */
+static u32 acpi_ev_global_lock_handler(void *context);
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_init_global_lock_handler
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Install a handler for the global lock release event
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ev_init_global_lock_handler(void)
+{
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
+
+        /* Attempt installation of the global lock handler */
+
+        status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
+                                                  acpi_ev_global_lock_handler,
+                                                  NULL);
+
+        /*
+         * If the global lock does not exist on this platform, the attempt to
+         * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
+         * Map to AE_OK, but mark global lock as not present. Any attempt to
+         * actually use the global lock will be flagged with an error.
+         */
+        acpi_gbl_global_lock_present = FALSE;
+        if (status == AE_NO_HARDWARE_RESPONSE) {
+                ACPI_ERROR((AE_INFO,
+                            "No response from Global Lock hardware, disabling lock"));
+
+                return_ACPI_STATUS(AE_OK);
+        }
+
+        status = acpi_os_create_lock(&acpi_gbl_global_lock_pending_lock);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        acpi_gbl_global_lock_pending = FALSE;
+        acpi_gbl_global_lock_present = TRUE;
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_remove_global_lock_handler
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Remove the handler for the Global Lock
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ev_remove_global_lock_handler(void)
+{
+        acpi_status status;
+
+        ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
+
+        acpi_gbl_global_lock_present = FALSE;
+        status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
+                                                 acpi_ev_global_lock_handler);
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_global_lock_handler
+ *
+ * PARAMETERS:  Context         - From thread interface, not used
+ *
+ * RETURN:      ACPI_INTERRUPT_HANDLED
+ *
+ * DESCRIPTION: Invoked directly from the SCI handler when a global lock
+ *              release interrupt occurs. If there is actually a pending
+ *              request for the lock, signal the waiting thread.
+ *
+ ******************************************************************************/
+
+static u32 acpi_ev_global_lock_handler(void *context)
+{
+        acpi_status status;
+        acpi_cpu_flags flags;
+
+        flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
+
+        /*
+         * If a request for the global lock is not actually pending,
+         * we are done. This handles "spurious" global lock interrupts
+         * which are possible (and have been seen) with bad BIOSs.
+         */
+        if (!acpi_gbl_global_lock_pending) {
+                goto cleanup_and_exit;
+        }
+
+        /*
+         * Send a unit to the global lock semaphore. The actual acquisition
+         * of the global lock will be performed by the waiting thread.
+         */
+        status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
+        if (ACPI_FAILURE(status)) {
+                ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
+        }
+
+        acpi_gbl_global_lock_pending = FALSE;
+
+      cleanup_and_exit:
+
+        acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
+        return (ACPI_INTERRUPT_HANDLED);
+}
+
+/******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_acquire_global_lock
+ *
+ * PARAMETERS:  Timeout         - Max time to wait for the lock, in millisec.
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Attempt to gain ownership of the Global Lock.
+ *
+ * MUTEX:       Interpreter must be locked
+ *
+ * Note: The original implementation allowed multiple threads to "acquire" the
+ * Global Lock, and the OS would hold the lock until the last thread had
+ * released it. However, this could potentially starve the BIOS out of the
+ * lock, especially in the case where there is a tight handshake between the
+ * Embedded Controller driver and the BIOS. Therefore, this implementation
+ * allows only one thread to acquire the HW Global Lock at a time, and makes
+ * the global lock appear as a standard mutex on the OS side.
+ *
+ *****************************************************************************/
+
+acpi_status acpi_ev_acquire_global_lock(u16 timeout)
+{
+        acpi_cpu_flags flags;
+        acpi_status status;
+        u8 acquired = FALSE;
+
+        ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
+
+        /*
+         * Only one thread can acquire the GL at a time, the global_lock_mutex
+         * enforces this. This interface releases the interpreter if we must wait.
+         */
+        status =
+            acpi_ex_system_wait_mutex(acpi_gbl_global_lock_mutex->mutex.
+                                      os_mutex, timeout);
+        if (ACPI_FAILURE(status)) {
+                return_ACPI_STATUS(status);
+        }
+
+        /*
+         * Update the global lock handle and check for wraparound. The handle is
+         * only used for the external global lock interfaces, but it is updated
+         * here to properly handle the case where a single thread may acquire the
+         * lock via both the AML and the acpi_acquire_global_lock interfaces. The
+         * handle is therefore updated on the first acquire from a given thread
+         * regardless of where the acquisition request originated.
+         */
+        acpi_gbl_global_lock_handle++;
+        if (acpi_gbl_global_lock_handle == 0) {
+                acpi_gbl_global_lock_handle = 1;
+        }
+
+        /*
+         * Make sure that a global lock actually exists. If not, just
+         * treat the lock as a standard mutex.
+         */
+        if (!acpi_gbl_global_lock_present) {
+                acpi_gbl_global_lock_acquired = TRUE;
+                return_ACPI_STATUS(AE_OK);
+        }
+
+        flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
+
+        do {
+
+                /* Attempt to acquire the actual hardware lock */
+
+                ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
+                if (acquired) {
+                        acpi_gbl_global_lock_acquired = TRUE;
+                        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                          "Acquired hardware Global Lock\n"));
+                        break;
+                }
+
+                /*
+                 * Did not get the lock. The pending bit was set above, and
+                 * we must now wait until we receive the global lock
+                 * released interrupt.
+                 */
+                acpi_gbl_global_lock_pending = TRUE;
+                acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "Waiting for hardware Global Lock\n"));
+
+                /*
+                 * Wait for handshake with the global lock interrupt handler.
+                 * This interface releases the interpreter if we must wait.
+                 */
+                status =
+                    acpi_ex_system_wait_semaphore
+                    (acpi_gbl_global_lock_semaphore, ACPI_WAIT_FOREVER);
+
+                flags = acpi_os_acquire_lock(acpi_gbl_global_lock_pending_lock);
+
+        } while (ACPI_SUCCESS(status));
+
+        acpi_gbl_global_lock_pending = FALSE;
+        acpi_os_release_lock(acpi_gbl_global_lock_pending_lock, flags);
+
+        return_ACPI_STATUS(status);
+}
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_release_global_lock
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      Status
+ *
+ * DESCRIPTION: Releases ownership of the Global Lock.
+ *
+ ******************************************************************************/
+
+acpi_status acpi_ev_release_global_lock(void)
+{
+        u8 pending = FALSE;
+        acpi_status status = AE_OK;
+
+        ACPI_FUNCTION_TRACE(ev_release_global_lock);
+
+        /* Lock must be already acquired */
+
+        if (!acpi_gbl_global_lock_acquired) {
+                ACPI_WARNING((AE_INFO,
+                              "Cannot release the ACPI Global Lock, it has not been acquired"));
+                return_ACPI_STATUS(AE_NOT_ACQUIRED);
+        }
+
+        if (acpi_gbl_global_lock_present) {
+
+                /* Allow any thread to release the lock */
+
+                ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
+
+                /*
+                 * If the pending bit was set, we must write GBL_RLS to the control
+                 * register
+                 */
+                if (pending) {
+                        status =
+                            acpi_write_bit_register
+                            (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
+                             ACPI_ENABLE_EVENT);
+                }
+
+                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
+                                  "Released hardware Global Lock\n"));
+        }
+
+        acpi_gbl_global_lock_acquired = FALSE;
+
+        /* Release the local GL mutex */
+
+        acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
+        return_ACPI_STATUS(status);
+}
diff --git a/drivers/acpi/acpica/evmisc.c b/drivers/acpi/acpica/evmisc.c
index 7dc80946f7bd..d0b331844427 100644
--- a/drivers/acpi/acpica/evmisc.c
+++ b/drivers/acpi/acpica/evmisc.c
@@ -45,7 +45,6 @@
 #include "accommon.h"
 #include "acevents.h"
 #include "acnamesp.h"
-#include "acinterp.h"
 
 #define _COMPONENT          ACPI_EVENTS
 ACPI_MODULE_NAME("evmisc")
@@ -53,10 +52,6 @@ ACPI_MODULE_NAME("evmisc")
 /* Local prototypes */
 static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context);
 
-static u32 acpi_ev_global_lock_handler(void *context);
-
-static acpi_status acpi_ev_remove_global_lock_handler(void);
-
 /*******************************************************************************
  *
  * FUNCTION:    acpi_ev_is_notify_object
@@ -275,304 +270,6 @@ static void ACPI_SYSTEM_XFACE acpi_ev_notify_dispatch(void *context)
         acpi_ut_delete_generic_state(notify_info);
 }
 
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_global_lock_handler
- *
- * PARAMETERS:  Context         - From thread interface, not used
- *
- * RETURN:      ACPI_INTERRUPT_HANDLED
- *
- * DESCRIPTION: Invoked directly from the SCI handler when a global lock
- *              release interrupt occurs.  If there's a thread waiting for
- *              the global lock, signal it.
- *
- * NOTE: Assumes that the semaphore can be signaled from interrupt level. If
- * this is not possible for some reason, a separate thread will have to be
- * scheduled to do this.
- *
- ******************************************************************************/
-static u8 acpi_ev_global_lock_pending;
-
-static u32 acpi_ev_global_lock_handler(void *context)
-{
-        acpi_status status;
-        acpi_cpu_flags flags;
-
-        flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
-
-        if (!acpi_ev_global_lock_pending) {
-                goto out;
-        }
-
-        /* Send a unit to the semaphore */
-
-        status = acpi_os_signal_semaphore(acpi_gbl_global_lock_semaphore, 1);
-        if (ACPI_FAILURE(status)) {
-                ACPI_ERROR((AE_INFO, "Could not signal Global Lock semaphore"));
-        }
-
-        acpi_ev_global_lock_pending = FALSE;
-
- out:
-        acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
-
-        return (ACPI_INTERRUPT_HANDLED);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_init_global_lock_handler
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Install a handler for the global lock release event
- *
- ******************************************************************************/
-
-acpi_status acpi_ev_init_global_lock_handler(void)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_init_global_lock_handler);
-
-        /* Attempt installation of the global lock handler */
-
-        status = acpi_install_fixed_event_handler(ACPI_EVENT_GLOBAL,
-                                                  acpi_ev_global_lock_handler,
-                                                  NULL);
-
-        /*
-         * If the global lock does not exist on this platform, the attempt to
-         * enable GBL_STATUS will fail (the GBL_ENABLE bit will not stick).
-         * Map to AE_OK, but mark global lock as not present. Any attempt to
-         * actually use the global lock will be flagged with an error.
-         */
-        if (status == AE_NO_HARDWARE_RESPONSE) {
-                ACPI_ERROR((AE_INFO,
-                            "No response from Global Lock hardware, disabling lock"));
-
-                acpi_gbl_global_lock_present = FALSE;
-                return_ACPI_STATUS(AE_OK);
-        }
-
-        acpi_gbl_global_lock_present = TRUE;
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_remove_global_lock_handler
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Remove the handler for the Global Lock
- *
- ******************************************************************************/
-
-static acpi_status acpi_ev_remove_global_lock_handler(void)
-{
-        acpi_status status;
-
-        ACPI_FUNCTION_TRACE(ev_remove_global_lock_handler);
-
-        acpi_gbl_global_lock_present = FALSE;
-        status = acpi_remove_fixed_event_handler(ACPI_EVENT_GLOBAL,
-                                                 acpi_ev_global_lock_handler);
-
-        return_ACPI_STATUS(status);
-}
-
-/******************************************************************************
- *
- * FUNCTION:    acpi_ev_acquire_global_lock
- *
- * PARAMETERS:  Timeout         - Max time to wait for the lock, in millisec.
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Attempt to gain ownership of the Global Lock.
- *
- * MUTEX:       Interpreter must be locked
- *
- * Note: The original implementation allowed multiple threads to "acquire" the
- * Global Lock, and the OS would hold the lock until the last thread had
- * released it. However, this could potentially starve the BIOS out of the
- * lock, especially in the case where there is a tight handshake between the
- * Embedded Controller driver and the BIOS. Therefore, this implementation
- * allows only one thread to acquire the HW Global Lock at a time, and makes
- * the global lock appear as a standard mutex on the OS side.
- *
- *****************************************************************************/
-static acpi_thread_id acpi_ev_global_lock_thread_id;
-static int acpi_ev_global_lock_acquired;
-
-acpi_status acpi_ev_acquire_global_lock(u16 timeout)
-{
-        acpi_cpu_flags flags;
-        acpi_status status = AE_OK;
-        u8 acquired = FALSE;
-
-        ACPI_FUNCTION_TRACE(ev_acquire_global_lock);
-
-        /*
-         * Only one thread can acquire the GL at a time, the global_lock_mutex
-         * enforces this. This interface releases the interpreter if we must wait.
-         */
-        status = acpi_ex_system_wait_mutex(
-                        acpi_gbl_global_lock_mutex->mutex.os_mutex, 0);
-        if (status == AE_TIME) {
-                if (acpi_ev_global_lock_thread_id == acpi_os_get_thread_id()) {
-                        acpi_ev_global_lock_acquired++;
-                        return AE_OK;
-                }
-        }
-
-        if (ACPI_FAILURE(status)) {
-                status = acpi_ex_system_wait_mutex(
-                                acpi_gbl_global_lock_mutex->mutex.os_mutex,
-                                timeout);
-        }
-        if (ACPI_FAILURE(status)) {
-                return_ACPI_STATUS(status);
-        }
-
-        acpi_ev_global_lock_thread_id = acpi_os_get_thread_id();
-        acpi_ev_global_lock_acquired++;
-
-        /*
-         * Update the global lock handle and check for wraparound. The handle is
-         * only used for the external global lock interfaces, but it is updated
-         * here to properly handle the case where a single thread may acquire the
-         * lock via both the AML and the acpi_acquire_global_lock interfaces. The
-         * handle is therefore updated on the first acquire from a given thread
-         * regardless of where the acquisition request originated.
-         */
-        acpi_gbl_global_lock_handle++;
-        if (acpi_gbl_global_lock_handle == 0) {
-                acpi_gbl_global_lock_handle = 1;
-        }
-
-        /*
-         * Make sure that a global lock actually exists. If not, just treat the
-         * lock as a standard mutex.
-         */
-        if (!acpi_gbl_global_lock_present) {
-                acpi_gbl_global_lock_acquired = TRUE;
-                return_ACPI_STATUS(AE_OK);
-        }
-
-        flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
-
-        do {
-
-                /* Attempt to acquire the actual hardware lock */
-
-                ACPI_ACQUIRE_GLOBAL_LOCK(acpi_gbl_FACS, acquired);
-                if (acquired) {
-                        acpi_gbl_global_lock_acquired = TRUE;
-
-                        ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                          "Acquired hardware Global Lock\n"));
-                        break;
-                }
-
-                acpi_ev_global_lock_pending = TRUE;
-
-                acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
-
-                /*
-                 * Did not get the lock. The pending bit was set above, and we
-                 * must wait until we get the global lock released interrupt.
-                 */
-                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                  "Waiting for hardware Global Lock\n"));
-
-                /*
-                 * Wait for handshake with the global lock interrupt handler.
-                 * This interface releases the interpreter if we must wait.
-                 */
-                status = acpi_ex_system_wait_semaphore(
-                                                acpi_gbl_global_lock_semaphore,
-                                                ACPI_WAIT_FOREVER);
-
-                flags = acpi_os_acquire_lock(acpi_ev_global_lock_pending_lock);
-
-        } while (ACPI_SUCCESS(status));
-
-        acpi_ev_global_lock_pending = FALSE;
-
-        acpi_os_release_lock(acpi_ev_global_lock_pending_lock, flags);
-
-        return_ACPI_STATUS(status);
-}
-
-/*******************************************************************************
- *
- * FUNCTION:    acpi_ev_release_global_lock
- *
- * PARAMETERS:  None
- *
- * RETURN:      Status
- *
- * DESCRIPTION: Releases ownership of the Global Lock.
- *
- ******************************************************************************/
-
-acpi_status acpi_ev_release_global_lock(void)
-{
-        u8 pending = FALSE;
-        acpi_status status = AE_OK;
-
-        ACPI_FUNCTION_TRACE(ev_release_global_lock);
-
-        /* Lock must be already acquired */
-
-        if (!acpi_gbl_global_lock_acquired) {
-                ACPI_WARNING((AE_INFO,
-                              "Cannot release the ACPI Global Lock, it has not been acquired"));
-                return_ACPI_STATUS(AE_NOT_ACQUIRED);
-        }
-
-        acpi_ev_global_lock_acquired--;
-        if (acpi_ev_global_lock_acquired > 0) {
-                return AE_OK;
-        }
-
-        if (acpi_gbl_global_lock_present) {
-
-                /* Allow any thread to release the lock */
-
-                ACPI_RELEASE_GLOBAL_LOCK(acpi_gbl_FACS, pending);
-
-                /*
-                 * If the pending bit was set, we must write GBL_RLS to the control
-                 * register
-                 */
-                if (pending) {
-                        status =
-                            acpi_write_bit_register
-                            (ACPI_BITREG_GLOBAL_LOCK_RELEASE,
-                             ACPI_ENABLE_EVENT);
-                }
-
-                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
-                                  "Released hardware Global Lock\n"));
-        }
-
-        acpi_gbl_global_lock_acquired = FALSE;
-
-        /* Release the local GL mutex */
-        acpi_ev_global_lock_thread_id = 0;
-        acpi_ev_global_lock_acquired = 0;
-        acpi_os_release_mutex(acpi_gbl_global_lock_mutex->mutex.os_mutex);
-        return_ACPI_STATUS(status);
-}
-
 /******************************************************************************
  *
  * FUNCTION:    acpi_ev_terminate
diff --git a/drivers/acpi/acpica/evregion.c b/drivers/acpi/acpica/evregion.c
index bea7223d7a71..f0edf5c43c03 100644
--- a/drivers/acpi/acpica/evregion.c
+++ b/drivers/acpi/acpica/evregion.c
@@ -55,6 +55,8 @@ static u8
 acpi_ev_has_default_handler(struct acpi_namespace_node *node,
                             acpi_adr_space_type space_id);
 
+static void acpi_ev_orphan_ec_reg_method(void);
+
 static acpi_status
 acpi_ev_reg_run(acpi_handle obj_handle,
                 u32 level, void *context, void **return_value);
@@ -561,7 +563,9 @@ acpi_ev_detach_region(union acpi_operand_object *region_obj,
 
                         /* Now stop region accesses by executing the _REG method */
 
-                        status = acpi_ev_execute_reg_method(region_obj, 0);
+                        status =
+                            acpi_ev_execute_reg_method(region_obj,
+                                                       ACPI_REG_DISCONNECT);
                         if (ACPI_FAILURE(status)) {
                                 ACPI_EXCEPTION((AE_INFO, status,
                                                 "from region _REG, [%s]",
@@ -1062,6 +1066,12 @@ acpi_ev_execute_reg_methods(struct acpi_namespace_node *node,
                                         ACPI_NS_WALK_UNLOCK, acpi_ev_reg_run,
                                         NULL, &space_id, NULL);
 
+        /* Special case for EC: handle "orphan" _REG methods with no region */
+
+        if (space_id == ACPI_ADR_SPACE_EC) {
+                acpi_ev_orphan_ec_reg_method();
+        }
+
         return_ACPI_STATUS(status);
 }
 
@@ -1120,6 +1130,113 @@ acpi_ev_reg_run(acpi_handle obj_handle,
                 return (AE_OK);
         }
 
-        status = acpi_ev_execute_reg_method(obj_desc, 1);
+        status = acpi_ev_execute_reg_method(obj_desc, ACPI_REG_CONNECT);
         return (status);
 }
+
+/*******************************************************************************
+ *
+ * FUNCTION:    acpi_ev_orphan_ec_reg_method
+ *
+ * PARAMETERS:  None
+ *
+ * RETURN:      None
+ *
+ * DESCRIPTION: Execute an "orphan" _REG method that appears under the EC
+ *              device. This is a _REG method that has no corresponding region
+ *              within the EC device scope. The orphan _REG method appears to
+ *              have been enabled by the description of the ECDT in the ACPI
+ *              specification: "The availability of the region space can be
+ *              detected by providing a _REG method object underneath the
+ *              Embedded Controller device."
+ *
+ *              To quickly access the EC device, we use the EC_ID that appears
+ *              within the ECDT. Otherwise, we would need to perform a time-
+ *              consuming namespace walk, executing _HID methods to find the
+ *              EC device.
+ *
+ ******************************************************************************/
+
+static void acpi_ev_orphan_ec_reg_method(void)
+{
+        struct acpi_table_ecdt *table;
+        acpi_status status;
+        struct acpi_object_list args;
+        union acpi_object objects[2];
+        struct acpi_namespace_node *ec_device_node;
+        struct acpi_namespace_node *reg_method;
+        struct acpi_namespace_node *next_node;
+
+        ACPI_FUNCTION_TRACE(ev_orphan_ec_reg_method);
+
+        /* Get the ECDT (if present in system) */
+
+        status = acpi_get_table(ACPI_SIG_ECDT, 0,
+                                ACPI_CAST_INDIRECT_PTR(struct acpi_table_header,
+                                                       &table));
+        if (ACPI_FAILURE(status)) {
+                return_VOID;
+        }
+
+        /* We need a valid EC_ID string */
+
+        if (!(*table->id)) {
+                return_VOID;
+        }
+
+        /* Namespace is currently locked, must release */
+
+        (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
+
+        /* Get a handle to the EC device referenced in the ECDT */
+
+        status = acpi_get_handle(NULL,
+                                 ACPI_CAST_PTR(char, table->id),
+                                 ACPI_CAST_PTR(acpi_handle, &ec_device_node));
+        if (ACPI_FAILURE(status)) {
+                goto exit;
+        }
+
+        /* Get a handle to a _REG method immediately under the EC device */
+
+        status = acpi_get_handle(ec_device_node,
+                                 METHOD_NAME__REG, ACPI_CAST_PTR(acpi_handle,
+                                                                 &reg_method));
+        if (ACPI_FAILURE(status)) {
+                goto exit;
+        }
+
+        /*
+         * Execute the _REG method only if there is no Operation Region in
+         * this scope with the Embedded Controller space ID. Otherwise, it
+         * will already have been executed. Note, this allows for Regions
+         * with other space IDs to be present; but the code below will then
+         * execute the _REG method with the EC space ID argument.
+         */
+        next_node = acpi_ns_get_next_node(ec_device_node, NULL);
+        while (next_node) {
+                if ((next_node->type == ACPI_TYPE_REGION) &&
+                    (next_node->object) &&
+                    (next_node->object->region.space_id == ACPI_ADR_SPACE_EC)) {
+                        goto exit;      /* Do not execute _REG */
+                }
+                next_node = acpi_ns_get_next_node(ec_device_node, next_node);
+        }
+
+        /* Evaluate the _REG(EC,Connect) method */
+
+        args.count = 2;
+        args.pointer = objects;
+        objects[0].type = ACPI_TYPE_INTEGER;
+        objects[0].integer.value = ACPI_ADR_SPACE_EC;
+        objects[1].type = ACPI_TYPE_INTEGER;
+        objects[1].integer.value = ACPI_REG_CONNECT;
+
+        status = acpi_evaluate_object(reg_method, NULL, &args, NULL);
+
+      exit:
+        /* We ignore all errors from above, don't care */
+
+        status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
+        return_VOID;
+}
diff --git a/drivers/acpi/acpica/evrgnini.c b/drivers/acpi/acpica/evrgnini.c
index 9659cee6093e..55a5d35ef34a 100644
--- a/drivers/acpi/acpica/evrgnini.c
+++ b/drivers/acpi/acpica/evrgnini.c
@@ -637,7 +637,7 @@ acpi_ev_initialize_region(union acpi_operand_object *region_obj,
 
                                         status =
                                             acpi_ev_execute_reg_method
-                                            (region_obj, 1);
+                                            (region_obj, ACPI_REG_CONNECT);
 
                                         if (acpi_ns_locked) {
                                                 status =
diff --git a/drivers/acpi/acpica/evxfregn.c b/drivers/acpi/acpica/evxfregn.c
index c85c8c45599d..00cd95692a91 100644
--- a/drivers/acpi/acpica/evxfregn.c
+++ b/drivers/acpi/acpica/evxfregn.c
@@ -130,20 +130,21 @@ acpi_install_address_space_handler(acpi_handle device,
         case ACPI_ADR_SPACE_PCI_CONFIG:
         case ACPI_ADR_SPACE_DATA_TABLE:
 
-                if (acpi_gbl_reg_methods_executed) {
+                if (!acpi_gbl_reg_methods_executed) {
 
-                        /* Run all _REG methods for this address space */
-
-                        status = acpi_ev_execute_reg_methods(node, space_id);
+                        /* We will defer execution of the _REG methods for this space */
+                        goto unlock_and_exit;
                 }
                 break;
 
         default:
-
-                status = acpi_ev_execute_reg_methods(node, space_id);
                 break;
         }
 
+        /* Run all _REG methods for this address space */
+
+        status = acpi_ev_execute_reg_methods(node, space_id);
+
       unlock_and_exit:
         (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
         return_ACPI_STATUS(status);
diff --git a/drivers/acpi/acpica/excreate.c b/drivers/acpi/acpica/excreate.c
index e7b372d17667..110711afada8 100644
--- a/drivers/acpi/acpica/excreate.c
+++ b/drivers/acpi/acpica/excreate.c
@@ -305,7 +305,8 @@ acpi_ex_create_region(u8 * aml_start,
          * range
          */
         if ((region_space >= ACPI_NUM_PREDEFINED_REGIONS) &&
-            (region_space < ACPI_USER_REGION_BEGIN)) {
+            (region_space < ACPI_USER_REGION_BEGIN) &&
+            (region_space != ACPI_ADR_SPACE_DATA_TABLE)) {
                 ACPI_ERROR((AE_INFO, "Invalid AddressSpace type 0x%X",
                             region_space));
                 return_ACPI_STATUS(AE_AML_INVALID_SPACE_ID);
diff --git a/drivers/acpi/acpica/nsrepair.c b/drivers/acpi/acpica/nsrepair.c
index 1d76ac85b5e7..ac7b854b0bd7 100644
--- a/drivers/acpi/acpica/nsrepair.c
+++ b/drivers/acpi/acpica/nsrepair.c
@@ -74,7 +74,6 @@ ACPI_MODULE_NAME("nsrepair")
  *
  * Additional possible repairs:
  *
- * Optional/unnecessary NULL package elements removed
  * Required package elements that are NULL replaced by Integer/String/Buffer
  * Incorrect standalone package wrapped with required outer package
  *
@@ -623,16 +622,12 @@ acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
         ACPI_FUNCTION_NAME(ns_remove_null_elements);
 
         /*
-         * PTYPE1 packages contain no subpackages.
-         * PTYPE2 packages contain a variable number of sub-packages. We can
-         * safely remove all NULL elements from the PTYPE2 packages.
+         * We can safely remove all NULL elements from these package types:
+         * PTYPE1_VAR packages contain a variable number of simple data types.
+         * PTYPE2 packages contain a variable number of sub-packages.
          */
         switch (package_type) {
-        case ACPI_PTYPE1_FIXED:
         case ACPI_PTYPE1_VAR:
-        case ACPI_PTYPE1_OPTION:
-                return;
-
         case ACPI_PTYPE2:
         case ACPI_PTYPE2_COUNT:
         case ACPI_PTYPE2_PKG_COUNT:
@@ -642,6 +637,8 @@ acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
                 break;
 
         default:
+        case ACPI_PTYPE1_FIXED:
+        case ACPI_PTYPE1_OPTION:
                 return;
         }
 
diff --git a/drivers/acpi/acpica/utdecode.c b/drivers/acpi/acpica/utdecode.c
index 136a814cec69..97cb36f85ce9 100644
--- a/drivers/acpi/acpica/utdecode.c
+++ b/drivers/acpi/acpica/utdecode.c
@@ -170,8 +170,7 @@ const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = {
         "SMBus",
         "SystemCMOS",
         "PCIBARTarget",
-        "IPMI",
-        "DataTable"
+        "IPMI"
 };
 
 char *acpi_ut_get_region_name(u8 space_id)
@@ -179,6 +178,8 @@ char *acpi_ut_get_region_name(u8 space_id)
 
         if (space_id >= ACPI_USER_REGION_BEGIN) {
                 return ("UserDefinedRegion");
+        } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) {
+                return ("DataTable");
         } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
                 return ("FunctionalFixedHW");
         } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) {
diff --git a/drivers/acpi/acpica/utmutex.c b/drivers/acpi/acpica/utmutex.c
index a946c689f03b..7d797e2baecd 100644
--- a/drivers/acpi/acpica/utmutex.c
+++ b/drivers/acpi/acpica/utmutex.c
@@ -83,9 +83,15 @@ acpi_status acpi_ut_mutex_initialize(void)
 
         /* Create the spinlocks for use at interrupt level */
 
-        spin_lock_init(acpi_gbl_gpe_lock);
-        spin_lock_init(acpi_gbl_hardware_lock);
-        spin_lock_init(acpi_ev_global_lock_pending_lock);
+        status = acpi_os_create_lock (&acpi_gbl_gpe_lock);
+        if (ACPI_FAILURE (status)) {
+                return_ACPI_STATUS (status);
+        }
+
+        status = acpi_os_create_lock (&acpi_gbl_hardware_lock);
+        if (ACPI_FAILURE (status)) {
+                return_ACPI_STATUS (status);
+        }
 
         /* Mutex for _OSI support */
         status = acpi_os_create_mutex(&acpi_gbl_osi_mutex);
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 9749980ca6ca..d1e06c182cdb 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -227,7 +227,7 @@ static int __acpi_bus_set_power(struct acpi_device *device, int state)
         acpi_status status = AE_OK;
         char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' };
 
-        if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3))
+        if (!device || (state < ACPI_STATE_D0) || (state > ACPI_STATE_D3_COLD))
                 return -EINVAL;
 
         /* Make sure this is a valid target state */
diff --git a/drivers/acpi/custom_method.c b/drivers/acpi/custom_method.c
new file mode 100644
index 000000000000..5d42c2414ae5
--- /dev/null
+++ b/drivers/acpi/custom_method.c
@@ -0,0 +1,100 @@
+/*
+ * debugfs.c - ACPI debugfs interface to userspace.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <acpi/acpi_drivers.h>
+
+#include "internal.h"
+
+#define _COMPONENT              ACPI_SYSTEM_COMPONENT
+ACPI_MODULE_NAME("custom_method");
+MODULE_LICENSE("GPL");
+
+static struct dentry *cm_dentry;
+
+/* /sys/kernel/debug/acpi/custom_method */
+
+static ssize_t cm_write(struct file *file, const char __user * user_buf,
+                        size_t count, loff_t *ppos)
+{
+        static char *buf;
+        static u32 max_size;
+        static u32 uncopied_bytes;
+
+        struct acpi_table_header table;
+        acpi_status status;
+
+        if (!(*ppos)) {
+                /* parse the table header to get the table length */
+                if (count <= sizeof(struct acpi_table_header))
+                        return -EINVAL;
+                if (copy_from_user(&table, user_buf,
+                                   sizeof(struct acpi_table_header)))
+                        return -EFAULT;
+                uncopied_bytes = max_size = table.length;
+                buf = kzalloc(max_size, GFP_KERNEL);
+                if (!buf)
+                        return -ENOMEM;
+        }
+
+        if (buf == NULL)
+                return -EINVAL;
+
+        if ((*ppos > max_size) ||
+            (*ppos + count > max_size) ||
+            (*ppos + count < count) ||
+            (count > uncopied_bytes))
+                return -EINVAL;
+
+        if (copy_from_user(buf + (*ppos), user_buf, count)) {
+                kfree(buf);
+                buf = NULL;
+                return -EFAULT;
+        }
+
+        uncopied_bytes -= count;
+        *ppos += count;
+
+        if (!uncopied_bytes) {
+                status = acpi_install_method(buf);
+                kfree(buf);
+                buf = NULL;
+                if (ACPI_FAILURE(status))
+                        return -EINVAL;
+                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
+        }
+
+        return count;
+}
+
+static const struct file_operations cm_fops = {
+        .write = cm_write,
+        .llseek = default_llseek,
+};
+
+static int __init acpi_custom_method_init(void)
+{
+        if (acpi_debugfs_dir == NULL)
+                return -ENOENT;
+
+        cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
+                                        acpi_debugfs_dir, NULL, &cm_fops);
+        if (cm_dentry == NULL)
+                return -ENODEV;
+
+        return 0;
+}
+
+static void __exit acpi_custom_method_exit(void)
+{
+        if (cm_dentry)
+                debugfs_remove(cm_dentry);
+ }
+
+module_init(acpi_custom_method_init);
+module_exit(acpi_custom_method_exit);
diff --git a/drivers/acpi/debugfs.c b/drivers/acpi/debugfs.c
index 384f7abcff77..182a9fc36355 100644
--- a/drivers/acpi/debugfs.c
+++ b/drivers/acpi/debugfs.c
@@ -3,100 +3,16 @@
  */
 
 #include <linux/init.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/uaccess.h>
 #include <linux/debugfs.h>
 #include <acpi/acpi_drivers.h>
 
 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
 ACPI_MODULE_NAME("debugfs");
 
+struct dentry *acpi_debugfs_dir;
+EXPORT_SYMBOL_GPL(acpi_debugfs_dir);
 
-/* /sys/modules/acpi/parameters/aml_debug_output */
-
-module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
-                   bool, 0644);
-MODULE_PARM_DESC(aml_debug_output,
-                 "To enable/disable the ACPI Debug Object output.");
-
-/* /sys/kernel/debug/acpi/custom_method */
-
-static ssize_t cm_write(struct file *file, const char __user * user_buf,
-                        size_t count, loff_t *ppos)
+void __init acpi_debugfs_init(void)
 {
-        static char *buf;
-        static u32 max_size;
-        static u32 uncopied_bytes;
-
-        struct acpi_table_header table;
-        acpi_status status;
-
-        if (!(*ppos)) {
-                /* parse the table header to get the table length */
-                if (count <= sizeof(struct acpi_table_header))
-                        return -EINVAL;
-                if (copy_from_user(&table, user_buf,
-                                   sizeof(struct acpi_table_header)))
-                        return -EFAULT;
-                uncopied_bytes = max_size = table.length;
-                buf = kzalloc(max_size, GFP_KERNEL);
-                if (!buf)
-                        return -ENOMEM;
-        }
-
-        if (buf == NULL)
-                return -EINVAL;
-
-        if ((*ppos > max_size) ||
-            (*ppos + count > max_size) ||
-            (*ppos + count < count) ||
-            (count > uncopied_bytes))
-                return -EINVAL;
-
-        if (copy_from_user(buf + (*ppos), user_buf, count)) {
-                kfree(buf);
-                buf = NULL;
-                return -EFAULT;
-        }
-
-        uncopied_bytes -= count;
-        *ppos += count;
-
-        if (!uncopied_bytes) {
-                status = acpi_install_method(buf);
-                kfree(buf);
-                buf = NULL;
-                if (ACPI_FAILURE(status))
-                        return -EINVAL;
-                add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
-        }
-
-        return count;
-}
-
-static const struct file_operations cm_fops = {
-        .write = cm_write,
-        .llseek = default_llseek,
-};
-
-int __init acpi_debugfs_init(void)
-{
-        struct dentry *acpi_dir, *cm_dentry;
-
-        acpi_dir = debugfs_create_dir("acpi", NULL);
-        if (!acpi_dir)
-                goto err;
-
-        cm_dentry = debugfs_create_file("custom_method", S_IWUSR,
-                                        acpi_dir, NULL, &cm_fops);
-        if (!cm_dentry)
-                goto err;
-
-        return 0;
-
-err:
-        if (acpi_dir)
-                debugfs_remove(acpi_dir);
-        return -EINVAL;
+        acpi_debugfs_dir = debugfs_create_dir("acpi", NULL);
 }
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index fa848c4116a8..b19a18dd994f 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -69,7 +69,6 @@ enum ec_command {
 
 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
-#define ACPI_EC_CDELAY          10      /* Wait 10us before polling EC */
 #define ACPI_EC_MSI_UDELAY      550     /* Wait 550us for MSI EC */
 
 #define ACPI_EC_STORM_THRESHOLD 8       /* number of false interrupts
@@ -433,8 +432,7 @@ EXPORT_SYMBOL(ec_write);
 
 int ec_transaction(u8 command,
                    const u8 * wdata, unsigned wdata_len,
-                   u8 * rdata, unsigned rdata_len,
-                   int force_poll)
+                   u8 * rdata, unsigned rdata_len)
 {
         struct transaction t = {.command = command,
                                 .wdata = wdata, .rdata = rdata,
@@ -592,8 +590,6 @@ static void acpi_ec_gpe_query(void *ec_cxt)
         mutex_unlock(&ec->lock);
 }
 
-static void acpi_ec_gpe_query(void *ec_cxt);
-
 static int ec_check_sci(struct acpi_ec *ec, u8 state)
 {
         if (state & ACPI_EC_FLAG_SCI) {
@@ -808,8 +804,6 @@ static int acpi_ec_add(struct acpi_device *device)
                         return -EINVAL;
         }
 
-        ec->handle = device->handle;
-
         /* Find and register all query methods */
         acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
                             acpi_ec_register_query_methods, NULL, ec, NULL);
@@ -938,8 +932,19 @@ static struct dmi_system_id __initdata ec_dmi_table[] = {
         ec_flag_msi, "MSI hardware", {
         DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
         {
+        ec_flag_msi, "Quanta hardware", {
+        DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
+        DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
+        {
+        ec_flag_msi, "Quanta hardware", {
+        DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
+        DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
+        {
         ec_validate_ecdt, "ASUS hardware", {
         DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
+        {
+        ec_validate_ecdt, "ASUS hardware", {
+        DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
         {},
 };
 
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 4bfb759deb10..ca75b9ce0489 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -28,9 +28,10 @@ int acpi_scan_init(void);
 int acpi_sysfs_init(void);
 
 #ifdef CONFIG_DEBUG_FS
+extern struct dentry *acpi_debugfs_dir;
 int acpi_debugfs_init(void);
 #else
-static inline int acpi_debugfs_init(void) { return 0; }
+static inline void acpi_debugfs_init(void) { return; }
 #endif
 
 /* --------------------------------------------------------------------------
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 45ad4ffef533..52ca9649d769 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -902,14 +902,6 @@ void acpi_os_wait_events_complete(void *context)
 
 EXPORT_SYMBOL(acpi_os_wait_events_complete);
 
-/*
- * Deallocate the memory for a spinlock.
- */
-void acpi_os_delete_lock(acpi_spinlock handle)
-{
-        return;
-}
-
 acpi_status
 acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle)
 {
@@ -1341,6 +1333,31 @@ int acpi_resources_are_enforced(void)
 EXPORT_SYMBOL(acpi_resources_are_enforced);
 
 /*
+ * Create and initialize a spinlock.
+ */
+acpi_status
+acpi_os_create_lock(acpi_spinlock *out_handle)
+{
+        spinlock_t *lock;
+
+        lock = ACPI_ALLOCATE(sizeof(spinlock_t));
+        if (!lock)
+                return AE_NO_MEMORY;
+        spin_lock_init(lock);
+        *out_handle = lock;
+
+        return AE_OK;
+}
+
+/*
+ * Deallocate the memory for a spinlock.
+ */
+void acpi_os_delete_lock(acpi_spinlock handle)
+{
+        ACPI_FREE(handle);
+}
+
+/*
  * Acquire a spinlock.
  *
  * handle is a pointer to the spinlock_t.
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index 25bf17da69fd..02d2a4c9084d 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -37,7 +37,6 @@ static struct dmi_system_id __initdata processor_idle_dmi_table[] = {
         {},
 };
 
-#ifdef CONFIG_SMP
 static int map_lapic_id(struct acpi_subtable_header *entry,
                  u32 acpi_id, int *apic_id)
 {
@@ -165,7 +164,9 @@ exit:
 
 int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
 {
+#ifdef CONFIG_SMP
         int i;
+#endif
         int apic_id = -1;
 
         apic_id = map_mat_entry(handle, type, acpi_id);
@@ -174,14 +175,19 @@ int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
         if (apic_id == -1)
                 return apic_id;
 
+#ifdef CONFIG_SMP
         for_each_possible_cpu(i) {
                 if (cpu_physical_id(i) == apic_id)
                         return i;
         }
+#else
+        /* In UP kernel, only processor 0 is valid */
+        if (apic_id == 0)
+                return apic_id;
+#endif
         return -1;
 }
 EXPORT_SYMBOL_GPL(acpi_get_cpuid);
-#endif
 
 static bool __init processor_physically_present(acpi_handle handle)
 {
@@ -217,7 +223,7 @@ static bool __init processor_physically_present(acpi_handle handle)
         type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0;
         cpuid = acpi_get_cpuid(handle, type, acpi_id);
 
-        if ((cpuid == -1) && (num_possible_cpus() > 1))
+        if (cpuid == -1)
                 return false;
 
         return true;
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index d615b7d69bca..431ab11c8c1b 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -161,7 +161,7 @@ static void lapic_timer_check_state(int state, struct acpi_processor *pr,
         if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
                 return;
 
-        if (c1e_detected)
+        if (amd_e400_c1e_detected)
                 type = ACPI_STATE_C1;
 
         /*
diff --git a/drivers/acpi/sysfs.c b/drivers/acpi/sysfs.c
index 61891e75583d..77255f250dbb 100644
--- a/drivers/acpi/sysfs.c
+++ b/drivers/acpi/sysfs.c
@@ -220,6 +220,14 @@ module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
                   NULL, 0644);
 #endif /* CONFIG_ACPI_DEBUG */
 
+
+/* /sys/modules/acpi/parameters/aml_debug_output */
+
+module_param_named(aml_debug_output, acpi_gbl_enable_aml_debug_object,
+                   bool, 0644);
+MODULE_PARM_DESC(aml_debug_output,
+                 "To enable/disable the ACPI Debug Object output.");
+
 /* /sys/module/acpi/parameters/acpica_version */
 static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
 {
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index 7025593a58c8..d74926e0939e 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -603,6 +603,10 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
         if (ret)
                 goto err_out;
 
+        /* Hard-coded primecell ID instead of plug-n-play */
+        if (dev->periphid != 0)
+                goto skip_probe;
+
         /*
          * Dynamically calculate the size of the resource
          * and use this for iomap
@@ -643,6 +647,7 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
         if (ret)
                 goto err_release;
 
+ skip_probe:
         ret = device_add(&dev->dev);
         if (ret)
                 goto err_release;
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index db8f88586c8d..98de8f418676 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -1038,6 +1038,7 @@ static void floppy_disable_hlt(void)
 {
         unsigned long flags;
 
+        WARN_ONCE(1, "floppy_disable_hlt() scheduled for removal in 2012");
         spin_lock_irqsave(&floppy_hlt_lock, flags);
         if (!hlt_disabled) {
                 hlt_disabled = 1;
diff --git a/drivers/block/paride/pcd.c b/drivers/block/paride/pcd.c
index a0aabd904a51..46b8136c31bb 100644
--- a/drivers/block/paride/pcd.c
+++ b/drivers/block/paride/pcd.c
@@ -321,7 +321,6 @@ static void pcd_init_units(void)
                 strcpy(disk->disk_name, cd->name);      /* umm... */
                 disk->fops = &pcd_bdops;
                 disk->flags = GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
-                disk->events = DISK_EVENT_MEDIA_CHANGE;
         }
 }
 
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 6ecf89cdf006..079c08808d8a 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -6,10 +6,13 @@
 #include <linux/virtio.h>
 #include <linux/virtio_blk.h>
 #include <linux/scatterlist.h>
+#include <linux/string_helpers.h>
+#include <scsi/scsi_cmnd.h>
 
 #define PART_BITS 4
 
 static int major, index;
+struct workqueue_struct *virtblk_wq;
 
 struct virtio_blk
 {
@@ -26,6 +29,9 @@ struct virtio_blk
 
         mempool_t *pool;
 
+        /* Process context for config space updates */
+        struct work_struct config_work;
+
         /* What host tells us, plus 2 for header & tailer. */
         unsigned int sg_elems;
 
@@ -141,7 +147,7 @@ static bool do_req(struct request_queue *q, struct virtio_blk *vblk,
         num = blk_rq_map_sg(q, vbr->req, vblk->sg + out);
 
         if (vbr->req->cmd_type == REQ_TYPE_BLOCK_PC) {
-                sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, 96);
+                sg_set_buf(&vblk->sg[num + out + in++], vbr->req->sense, SCSI_SENSE_BUFFERSIZE);
                 sg_set_buf(&vblk->sg[num + out + in++], &vbr->in_hdr,
                            sizeof(vbr->in_hdr));
         }
@@ -291,6 +297,46 @@ static ssize_t virtblk_serial_show(struct device *dev,
 }
 DEVICE_ATTR(serial, S_IRUGO, virtblk_serial_show, NULL);
 
+static void virtblk_config_changed_work(struct work_struct *work)
+{
+        struct virtio_blk *vblk =
+                container_of(work, struct virtio_blk, config_work);
+        struct virtio_device *vdev = vblk->vdev;
+        struct request_queue *q = vblk->disk->queue;
+        char cap_str_2[10], cap_str_10[10];
+        u64 capacity, size;
+
+        /* Host must always specify the capacity. */
+        vdev->config->get(vdev, offsetof(struct virtio_blk_config, capacity),
+                          &capacity, sizeof(capacity));
+
+        /* If capacity is too big, truncate with warning. */
+        if ((sector_t)capacity != capacity) {
+                dev_warn(&vdev->dev, "Capacity %llu too large: truncating\n",
+                         (unsigned long long)capacity);
+                capacity = (sector_t)-1;
+        }
+
+        size = capacity * queue_logical_block_size(q);
+        string_get_size(size, STRING_UNITS_2, cap_str_2, sizeof(cap_str_2));
+        string_get_size(size, STRING_UNITS_10, cap_str_10, sizeof(cap_str_10));
+
+        dev_notice(&vdev->dev,
+                  "new size: %llu %d-byte logical blocks (%s/%s)\n",
+                  (unsigned long long)capacity,
+                  queue_logical_block_size(q),
+                  cap_str_10, cap_str_2);
+
+        set_capacity(vblk->disk, capacity);
+}
+
+static void virtblk_config_changed(struct virtio_device *vdev)
+{
+        struct virtio_blk *vblk = vdev->priv;
+
+        queue_work(virtblk_wq, &vblk->config_work);
+}
+
 static int __devinit virtblk_probe(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk;
@@ -327,6 +373,7 @@ static int __devinit virtblk_probe(struct virtio_device *vdev)
         vblk->vdev = vdev;
         vblk->sg_elems = sg_elems;
         sg_init_table(vblk->sg, vblk->sg_elems);
+        INIT_WORK(&vblk->config_work, virtblk_config_changed_work);
 
         /* We expect one virtqueue, for output. */
         vblk->vq = virtio_find_single_vq(vdev, blk_done, "requests");
@@ -477,6 +524,8 @@ static void __devexit virtblk_remove(struct virtio_device *vdev)
 {
         struct virtio_blk *vblk = vdev->priv;
 
+        flush_work(&vblk->config_work);
+
         /* Nothing should be pending. */
         BUG_ON(!list_empty(&vblk->reqs));
 
@@ -508,27 +557,47 @@ static unsigned int features[] = {
  * Use __refdata to avoid this warning.
  */
 static struct virtio_driver __refdata virtio_blk = {
-        .feature_table = features,
-        .feature_table_size = ARRAY_SIZE(features),
-        .driver.name =  KBUILD_MODNAME,
-        .driver.owner = THIS_MODULE,
-        .id_table =     id_table,
-        .probe =        virtblk_probe,
-        .remove =       __devexit_p(virtblk_remove),
+        .feature_table          = features,
+        .feature_table_size     = ARRAY_SIZE(features),
+        .driver.name            = KBUILD_MODNAME,
+        .driver.owner           = THIS_MODULE,
+        .id_table               = id_table,
+        .probe                  = virtblk_probe,
+        .remove                 = __devexit_p(virtblk_remove),
+        .config_changed         = virtblk_config_changed,
 };
 
 static int __init init(void)
 {
+        int error;
+
+        virtblk_wq = alloc_workqueue("virtio-blk", 0, 0);
+        if (!virtblk_wq)
+                return -ENOMEM;
+
         major = register_blkdev(0, "virtblk");
-        if (major < 0)
-                return major;
-        return register_virtio_driver(&virtio_blk);
+        if (major < 0) {
+                error = major;
+                goto out_destroy_workqueue;
+        }
+
+        error = register_virtio_driver(&virtio_blk);
+        if (error)
+                goto out_unregister_blkdev;
+        return 0;
+
+out_unregister_blkdev:
+        unregister_blkdev(major, "virtblk");
+out_destroy_workqueue:
+        destroy_workqueue(virtblk_wq);
+        return error;
 }
 
 static void __exit fini(void)
 {
         unregister_blkdev(major, "virtblk");
         unregister_virtio_driver(&virtio_blk);
+        destroy_workqueue(virtblk_wq);
 }
 module_init(init);
 module_exit(fini);
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index ae15a4ddaa9b..7878da89d29e 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -627,7 +627,6 @@ static int viocd_probe(struct vio_dev *vdev, const struct vio_device_id *id)
         gendisk->fops = &viocd_fops;
         gendisk->flags = GENHD_FL_CD | GENHD_FL_REMOVABLE |
                          GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
-        gendisk->events = DISK_EVENT_MEDIA_CHANGE;
         set_capacity(gendisk, 0);
         gendisk->private_data = d;
         d->viocd_disk = gendisk;
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index 838568a7dbf5..fb68b1295373 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -1677,17 +1677,12 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
         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;
-
                 vdev->config->get(vdev, offsetof(struct virtio_console_config,
                                                  max_nr_ports),
                                   &portdev->config.max_nr_ports,
                                   sizeof(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);
diff --git a/drivers/cpuidle/governors/menu.c b/drivers/cpuidle/governors/menu.c
index f508690eb958..c47f3d09c1ee 100644
--- a/drivers/cpuidle/governors/menu.c
+++ b/drivers/cpuidle/governors/menu.c
@@ -237,6 +237,7 @@ static int menu_select(struct cpuidle_device *dev)
         unsigned int power_usage = -1;
         int i;
         int multiplier;
+        struct timespec t;
 
         if (data->needs_update) {
                 menu_update(dev);
@@ -251,8 +252,9 @@ static int menu_select(struct cpuidle_device *dev)
                 return 0;
 
         /* determine the expected residency time, round up */
+        t = ktime_to_timespec(tick_nohz_get_sleep_length());
         data->expected_us =
-            DIV_ROUND_UP((u32)ktime_to_ns(tick_nohz_get_sleep_length()), 1000);
+                t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC;
 
 
         data->bucket = which_bucket(data->expected_us);
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index a572600e44eb..25cf327cd1cb 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -200,16 +200,18 @@ config PL330_DMA
           platform_data for a dma-pl330 device.
 
 config PCH_DMA
-        tristate "Intel EG20T PCH / OKI SEMICONDUCTOR ML7213 IOH DMA support"
+        tristate "Intel EG20T PCH / OKI Semi IOH(ML7213/ML7223) DMA support"
         depends on PCI && X86
         select DMA_ENGINE
         help
           Enable support for Intel EG20T PCH DMA engine.
 
-          This driver also can be used for OKI SEMICONDUCTOR ML7213 IOH(Input/
-          Output Hub) which is for IVI(In-Vehicle Infotainment) use.
-          ML7213 is companion chip for Intel Atom E6xx series.
-          ML7213 is completely compatible for Intel EG20T PCH.
+          This driver also can be used for OKI SEMICONDUCTOR IOH(Input/
+          Output Hub), ML7213 and ML7223.
+          ML7213 IOH is for IVI(In-Vehicle Infotainment) use and ML7223 IOH is
+          for MP(Media Phone) use.
+          ML7213/ML7223 is companion chip for Intel Atom E6xx series.
+          ML7213/ML7223 is completely compatible for Intel EG20T PCH.
 
 config IMX_SDMA
         tristate "i.MX SDMA support"
diff --git a/drivers/dma/TODO b/drivers/dma/TODO
new file mode 100644
index 000000000000..a4af8589330c
--- /dev/null
+++ b/drivers/dma/TODO
@@ -0,0 +1,14 @@
+TODO for slave dma
+
+1. Move remaining drivers to use new slave interface
+2. Remove old slave pointer machansim
+3. Make issue_pending to start the transaction in below drivers
+        - mpc512x_dma
+        - imx-dma
+        - imx-sdma
+        - mxs-dma.c
+        - dw_dmac
+        - intel_mid_dma
+        - ste_dma40
+4. Check other subsystems for dma drivers and merge/move to dmaengine
+5. Remove dma_slave_config's dma direction.
diff --git a/drivers/dma/at_hdmac.c b/drivers/dma/at_hdmac.c
index 235f53bf494e..36144f88d718 100644
--- a/drivers/dma/at_hdmac.c
+++ b/drivers/dma/at_hdmac.c
@@ -37,8 +37,8 @@
 
 #define ATC_DEFAULT_CFG         (ATC_FIFOCFG_HALFFIFO)
 #define ATC_DEFAULT_CTRLA       (0)
-#define ATC_DEFAULT_CTRLB       (ATC_SIF(0)     \
-                                |ATC_DIF(1))
+#define ATC_DEFAULT_CTRLB       (ATC_SIF(AT_DMA_MEM_IF) \
+                                |ATC_DIF(AT_DMA_MEM_IF))
 
 /*
  * Initial number of descriptors to allocate for each channel. This could
@@ -165,6 +165,29 @@ static void atc_desc_put(struct at_dma_chan *atchan, struct at_desc *desc)
 }
 
 /**
+ * atc_desc_chain - build chain adding a descripor
+ * @first: address of first descripor of the chain
+ * @prev: address of previous descripor of the chain
+ * @desc: descriptor to queue
+ *
+ * Called from prep_* functions
+ */
+static void atc_desc_chain(struct at_desc **first, struct at_desc **prev,
+                           struct at_desc *desc)
+{
+        if (!(*first)) {
+                *first = desc;
+        } else {
+                /* inform the HW lli about chaining */
+                (*prev)->lli.dscr = desc->txd.phys;
+                /* insert the link descriptor to the LD ring */
+                list_add_tail(&desc->desc_node,
+                                &(*first)->tx_list);
+        }
+        *prev = desc;
+}
+
+/**
  * atc_assign_cookie - compute and assign new cookie
  * @atchan: channel we work on
  * @desc: descriptor to assign cookie for
@@ -237,16 +260,12 @@ static void atc_dostart(struct at_dma_chan *atchan, struct at_desc *first)
 static void
 atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
 {
-        dma_async_tx_callback           callback;
-        void                            *param;
         struct dma_async_tx_descriptor  *txd = &desc->txd;
 
         dev_vdbg(chan2dev(&atchan->chan_common),
                 "descriptor %u complete\n", txd->cookie);
 
         atchan->completed_cookie = txd->cookie;
-        callback = txd->callback;
-        param = txd->callback_param;
 
         /* move children to free_list */
         list_splice_init(&desc->tx_list, &atchan->free_list);
@@ -278,12 +297,19 @@ atc_chain_complete(struct at_dma_chan *atchan, struct at_desc *desc)
                 }
         }
 
-        /*
-         * The API requires that no submissions are done from a
-         * callback, so we don't need to drop the lock here
-         */
-        if (callback)
-                callback(param);
+        /* for cyclic transfers,
+         * no need to replay callback function while stopping */
+        if (!test_bit(ATC_IS_CYCLIC, &atchan->status)) {
+                dma_async_tx_callback   callback = txd->callback;
+                void                    *param = txd->callback_param;
+
+                /*
+                 * The API requires that no submissions are done from a
+                 * callback, so we don't need to drop the lock here
+                 */
+                if (callback)
+                        callback(param);
+        }
 
         dma_run_dependencies(txd);
 }
@@ -419,6 +445,26 @@ static void atc_handle_error(struct at_dma_chan *atchan)
         atc_chain_complete(atchan, bad_desc);
 }
 
+/**
+ * atc_handle_cyclic - at the end of a period, run callback function
+ * @atchan: channel used for cyclic operations
+ *
+ * Called with atchan->lock held and bh disabled
+ */
+static void atc_handle_cyclic(struct at_dma_chan *atchan)
+{
+        struct at_desc                  *first = atc_first_active(atchan);
+        struct dma_async_tx_descriptor  *txd = &first->txd;
+        dma_async_tx_callback           callback = txd->callback;
+        void                            *param = txd->callback_param;
+
+        dev_vdbg(chan2dev(&atchan->chan_common),
+                        "new cyclic period llp 0x%08x\n",
+                        channel_readl(atchan, DSCR));
+
+        if (callback)
+                callback(param);
+}
 
 /*--  IRQ & Tasklet  ---------------------------------------------------*/
 
@@ -426,16 +472,11 @@ static void atc_tasklet(unsigned long data)
 {
         struct at_dma_chan *atchan = (struct at_dma_chan *)data;
 
-        /* Channel cannot be enabled here */
-        if (atc_chan_is_enabled(atchan)) {
-                dev_err(chan2dev(&atchan->chan_common),
-                        "BUG: channel enabled in tasklet\n");
-                return;
-        }
-
         spin_lock(&atchan->lock);
-        if (test_and_clear_bit(0, &atchan->error_status))
+        if (test_and_clear_bit(ATC_IS_ERROR, &atchan->status))
                 atc_handle_error(atchan);
+        else if (test_bit(ATC_IS_CYCLIC, &atchan->status))
+                atc_handle_cyclic(atchan);
         else
                 atc_advance_work(atchan);
 
@@ -464,12 +505,13 @@ static irqreturn_t at_dma_interrupt(int irq, void *dev_id)
 
                 for (i = 0; i < atdma->dma_common.chancnt; i++) {
                         atchan = &atdma->chan[i];
-                        if (pending & (AT_DMA_CBTC(i) | AT_DMA_ERR(i))) {
+                        if (pending & (AT_DMA_BTC(i) | AT_DMA_ERR(i))) {
                                 if (pending & AT_DMA_ERR(i)) {
                                         /* Disable channel on AHB error */
-                                        dma_writel(atdma, CHDR, atchan->mask);
+                                        dma_writel(atdma, CHDR,
+                                                AT_DMA_RES(i) | atchan->mask);
                                         /* Give information to tasklet */
-                                        set_bit(0, &atchan->error_status);
+                                        set_bit(ATC_IS_ERROR, &atchan->status);
                                 }
                                 tasklet_schedule(&atchan->tasklet);
                                 ret = IRQ_HANDLED;
@@ -549,7 +591,7 @@ atc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
         }
 
         ctrla =   ATC_DEFAULT_CTRLA;
-        ctrlb =   ATC_DEFAULT_CTRLB
+        ctrlb =   ATC_DEFAULT_CTRLB | ATC_IEN
                 | ATC_SRC_ADDR_MODE_INCR
                 | ATC_DST_ADDR_MODE_INCR
                 | ATC_FC_MEM2MEM;
@@ -584,16 +626,7 @@ atc_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
 
                 desc->txd.cookie = 0;
 
-                if (!first) {
-                        first = desc;
-                } else {
-                        /* inform the HW lli about chaining */
-                        prev->lli.dscr = desc->txd.phys;
-                        /* insert the link descriptor to the LD ring */
-                        list_add_tail(&desc->desc_node,
-                                        &first->tx_list);
-                }
-                prev = desc;
+                atc_desc_chain(&first, &prev, desc);
         }
 
         /* First descriptor of the chain embedds additional information */
@@ -639,7 +672,8 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         struct scatterlist      *sg;
         size_t                  total_len = 0;
 
-        dev_vdbg(chan2dev(chan), "prep_slave_sg: %s f0x%lx\n",
+        dev_vdbg(chan2dev(chan), "prep_slave_sg (%d): %s f0x%lx\n",
+                        sg_len,
                         direction == DMA_TO_DEVICE ? "TO DEVICE" : "FROM DEVICE",
                         flags);
 
@@ -651,14 +685,15 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
         reg_width = atslave->reg_width;
 
         ctrla = ATC_DEFAULT_CTRLA | atslave->ctrla;
-        ctrlb = ATC_DEFAULT_CTRLB | ATC_IEN;
+        ctrlb = ATC_IEN;
 
         switch (direction) {
         case DMA_TO_DEVICE:
                 ctrla |=  ATC_DST_WIDTH(reg_width);
                 ctrlb |=  ATC_DST_ADDR_MODE_FIXED
                         | ATC_SRC_ADDR_MODE_INCR
-                        | ATC_FC_MEM2PER;
+                        | ATC_FC_MEM2PER
+                        | ATC_SIF(AT_DMA_MEM_IF) | ATC_DIF(AT_DMA_PER_IF);
                 reg = atslave->tx_reg;
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct at_desc  *desc;
@@ -682,16 +717,7 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                                         | len >> mem_width;
                         desc->lli.ctrlb = ctrlb;
 
-                        if (!first) {
-                                first = desc;
-                        } else {
-                                /* inform the HW lli about chaining */
-                                prev->lli.dscr = desc->txd.phys;
-                                /* insert the link descriptor to the LD ring */
-                                list_add_tail(&desc->desc_node,
-                                                &first->tx_list);
-                        }
-                        prev = desc;
+                        atc_desc_chain(&first, &prev, desc);
                         total_len += len;
                 }
                 break;
@@ -699,7 +725,8 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 ctrla |=  ATC_SRC_WIDTH(reg_width);
                 ctrlb |=  ATC_DST_ADDR_MODE_INCR
                         | ATC_SRC_ADDR_MODE_FIXED
-                        | ATC_FC_PER2MEM;
+                        | ATC_FC_PER2MEM
+                        | ATC_SIF(AT_DMA_PER_IF) | ATC_DIF(AT_DMA_MEM_IF);
 
                 reg = atslave->rx_reg;
                 for_each_sg(sgl, sg, sg_len, i) {
@@ -724,16 +751,7 @@ atc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                                         | len >> reg_width;
                         desc->lli.ctrlb = ctrlb;
 
-                        if (!first) {
-                                first = desc;
-                        } else {
-                                /* inform the HW lli about chaining */
-                                prev->lli.dscr = desc->txd.phys;
-                                /* insert the link descriptor to the LD ring */
-                                list_add_tail(&desc->desc_node,
-                                                &first->tx_list);
-                        }
-                        prev = desc;
+                        atc_desc_chain(&first, &prev, desc);
                         total_len += len;
                 }
                 break;
@@ -759,41 +777,211 @@ err_desc_get:
         return NULL;
 }
 
+/**
+ * atc_dma_cyclic_check_values
+ * Check for too big/unaligned periods and unaligned DMA buffer
+ */
+static int
+atc_dma_cyclic_check_values(unsigned int reg_width, dma_addr_t buf_addr,
+                size_t period_len, enum dma_data_direction direction)
+{
+        if (period_len > (ATC_BTSIZE_MAX << reg_width))
+                goto err_out;
+        if (unlikely(period_len & ((1 << reg_width) - 1)))
+                goto err_out;
+        if (unlikely(buf_addr & ((1 << reg_width) - 1)))
+                goto err_out;
+        if (unlikely(!(direction & (DMA_TO_DEVICE | DMA_FROM_DEVICE))))
+                goto err_out;
+
+        return 0;
+
+err_out:
+        return -EINVAL;
+}
+
+/**
+ * atc_dma_cyclic_fill_desc - Fill one period decriptor
+ */
+static int
+atc_dma_cyclic_fill_desc(struct at_dma_slave *atslave, struct at_desc *desc,
+                unsigned int period_index, dma_addr_t buf_addr,
+                size_t period_len, enum dma_data_direction direction)
+{
+        u32             ctrla;
+        unsigned int    reg_width = atslave->reg_width;
+
+        /* prepare common CRTLA value */
+        ctrla =   ATC_DEFAULT_CTRLA | atslave->ctrla
+                | ATC_DST_WIDTH(reg_width)
+                | ATC_SRC_WIDTH(reg_width)
+                | period_len >> reg_width;
+
+        switch (direction) {
+        case DMA_TO_DEVICE:
+                desc->lli.saddr = buf_addr + (period_len * period_index);
+                desc->lli.daddr = atslave->tx_reg;
+                desc->lli.ctrla = ctrla;
+                desc->lli.ctrlb = ATC_DST_ADDR_MODE_FIXED
+                                | ATC_SRC_ADDR_MODE_INCR
+                                | ATC_FC_MEM2PER
+                                | ATC_SIF(AT_DMA_MEM_IF)
+                                | ATC_DIF(AT_DMA_PER_IF);
+                break;
+
+        case DMA_FROM_DEVICE:
+                desc->lli.saddr = atslave->rx_reg;
+                desc->lli.daddr = buf_addr + (period_len * period_index);
+                desc->lli.ctrla = ctrla;
+                desc->lli.ctrlb = ATC_DST_ADDR_MODE_INCR
+                                | ATC_SRC_ADDR_MODE_FIXED
+                                | ATC_FC_PER2MEM
+                                | ATC_SIF(AT_DMA_PER_IF)
+                                | ATC_DIF(AT_DMA_MEM_IF);
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+/**
+ * atc_prep_dma_cyclic - prepare the cyclic DMA transfer
+ * @chan: the DMA channel to prepare
+ * @buf_addr: physical DMA address where the buffer starts
+ * @buf_len: total number of bytes for the entire buffer
+ * @period_len: number of bytes for each period
+ * @direction: transfer direction, to or from device
+ */
+static struct dma_async_tx_descriptor *
+atc_prep_dma_cyclic(struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
+                size_t period_len, enum dma_data_direction direction)
+{
+        struct at_dma_chan      *atchan = to_at_dma_chan(chan);
+        struct at_dma_slave     *atslave = chan->private;
+        struct at_desc          *first = NULL;
+        struct at_desc          *prev = NULL;
+        unsigned long           was_cyclic;
+        unsigned int            periods = buf_len / period_len;
+        unsigned int            i;
+
+        dev_vdbg(chan2dev(chan), "prep_dma_cyclic: %s buf@0x%08x - %d (%d/%d)\n",
+                        direction == DMA_TO_DEVICE ? "TO DEVICE" : "FROM DEVICE",
+                        buf_addr,
+                        periods, buf_len, period_len);
+
+        if (unlikely(!atslave || !buf_len || !period_len)) {
+                dev_dbg(chan2dev(chan), "prep_dma_cyclic: length is zero!\n");
+                return NULL;
+        }
+
+        was_cyclic = test_and_set_bit(ATC_IS_CYCLIC, &atchan->status);
+        if (was_cyclic) {
+                dev_dbg(chan2dev(chan), "prep_dma_cyclic: channel in use!\n");
+                return NULL;
+        }
+
+        /* Check for too big/unaligned periods and unaligned DMA buffer */
+        if (atc_dma_cyclic_check_values(atslave->reg_width, buf_addr,
+                                        period_len, direction))
+                goto err_out;
+
+        /* build cyclic linked list */
+        for (i = 0; i < periods; i++) {
+                struct at_desc  *desc;
+
+                desc = atc_desc_get(atchan);
+                if (!desc)
+                        goto err_desc_get;
+
+                if (atc_dma_cyclic_fill_desc(atslave, desc, i, buf_addr,
+                                                period_len, direction))
+                        goto err_desc_get;
+
+                atc_desc_chain(&first, &prev, desc);
+        }
+
+        /* lets make a cyclic list */
+        prev->lli.dscr = first->txd.phys;
+
+        /* First descriptor of the chain embedds additional information */
+        first->txd.cookie = -EBUSY;
+        first->len = buf_len;
+
+        return &first->txd;
+
+err_desc_get:
+        dev_err(chan2dev(chan), "not enough descriptors available\n");
+        atc_desc_put(atchan, first);
+err_out:
+        clear_bit(ATC_IS_CYCLIC, &atchan->status);
+        return NULL;
+}
+
+
 static int atc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
                        unsigned long arg)
 {
         struct at_dma_chan      *atchan = to_at_dma_chan(chan);
         struct at_dma           *atdma = to_at_dma(chan->device);
-        struct at_desc          *desc, *_desc;
+        int                     chan_id = atchan->chan_common.chan_id;
+
         LIST_HEAD(list);
 
-        /* Only supports DMA_TERMINATE_ALL */
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
+        dev_vdbg(chan2dev(chan), "atc_control (%d)\n", cmd);
 
-        /*
-         * This is only called when something went wrong elsewhere, so
-         * we don't really care about the data. Just disable the
-         * channel. We still have to poll the channel enable bit due
-         * to AHB/HSB limitations.
-         */
-        spin_lock_bh(&atchan->lock);
+        if (cmd == DMA_PAUSE) {
+                spin_lock_bh(&atchan->lock);
 
-        dma_writel(atdma, CHDR, atchan->mask);
+                dma_writel(atdma, CHER, AT_DMA_SUSP(chan_id));
+                set_bit(ATC_IS_PAUSED, &atchan->status);
 
-        /* confirm that this channel is disabled */
-        while (dma_readl(atdma, CHSR) & atchan->mask)
-                cpu_relax();
+                spin_unlock_bh(&atchan->lock);
+        } else if (cmd == DMA_RESUME) {
+                if (!test_bit(ATC_IS_PAUSED, &atchan->status))
+                        return 0;
 
-        /* active_list entries will end up before queued entries */
-        list_splice_init(&atchan->queue, &list);
-        list_splice_init(&atchan->active_list, &list);
+                spin_lock_bh(&atchan->lock);
 
-        /* Flush all pending and queued descriptors */
-        list_for_each_entry_safe(desc, _desc, &list, desc_node)
-                atc_chain_complete(atchan, desc);
+                dma_writel(atdma, CHDR, AT_DMA_RES(chan_id));
+                clear_bit(ATC_IS_PAUSED, &atchan->status);
 
-        spin_unlock_bh(&atchan->lock);
+                spin_unlock_bh(&atchan->lock);
+        } else if (cmd == DMA_TERMINATE_ALL) {
+                struct at_desc  *desc, *_desc;
+                /*
+                 * This is only called when something went wrong elsewhere, so
+                 * we don't really care about the data. Just disable the
+                 * channel. We still have to poll the channel enable bit due
+                 * to AHB/HSB limitations.
+                 */
+                spin_lock_bh(&atchan->lock);
+
+                /* disabling channel: must also remove suspend state */
+                dma_writel(atdma, CHDR, AT_DMA_RES(chan_id) | atchan->mask);
+
+                /* confirm that this channel is disabled */
+                while (dma_readl(atdma, CHSR) & atchan->mask)
+                        cpu_relax();
+
+                /* active_list entries will end up before queued entries */
+                list_splice_init(&atchan->queue, &list);
+                list_splice_init(&atchan->active_list, &list);
+
+                /* Flush all pending and queued descriptors */
+                list_for_each_entry_safe(desc, _desc, &list, desc_node)
+                        atc_chain_complete(atchan, desc);
+
+                clear_bit(ATC_IS_PAUSED, &atchan->status);
+                /* if channel dedicated to cyclic operations, free it */
+                clear_bit(ATC_IS_CYCLIC, &atchan->status);
+
+                spin_unlock_bh(&atchan->lock);
+        } else {
+                return -ENXIO;
+        }
 
         return 0;
 }
@@ -835,9 +1023,17 @@ atc_tx_status(struct dma_chan *chan,
 
         spin_unlock_bh(&atchan->lock);
 
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
-        dev_vdbg(chan2dev(chan), "tx_status: %d (d%d, u%d)\n",
-                 cookie, last_complete ? last_complete : 0,
+        if (ret != DMA_SUCCESS)
+                dma_set_tx_state(txstate, last_complete, last_used,
+                        atc_first_active(atchan)->len);
+        else
+                dma_set_tx_state(txstate, last_complete, last_used, 0);
+
+        if (test_bit(ATC_IS_PAUSED, &atchan->status))
+                ret = DMA_PAUSED;
+
+        dev_vdbg(chan2dev(chan), "tx_status %d: cookie = %d (d%d, u%d)\n",
+                 ret, cookie, last_complete ? last_complete : 0,
                  last_used ? last_used : 0);
 
         return ret;
@@ -853,6 +1049,10 @@ static void atc_issue_pending(struct dma_chan *chan)
 
         dev_vdbg(chan2dev(chan), "issue_pending\n");
 
+        /* Not needed for cyclic transfers */
+        if (test_bit(ATC_IS_CYCLIC, &atchan->status))
+                return;
+
         spin_lock_bh(&atchan->lock);
         if (!atc_chan_is_enabled(atchan)) {
                 atc_advance_work(atchan);
@@ -959,6 +1159,7 @@ static void atc_free_chan_resources(struct dma_chan *chan)
         }
         list_splice_init(&atchan->free_list, &list);
         atchan->descs_allocated = 0;
+        atchan->status = 0;
 
         dev_vdbg(chan2dev(chan), "free_chan_resources: done\n");
 }
@@ -1092,10 +1293,15 @@ static int __init at_dma_probe(struct platform_device *pdev)
         if (dma_has_cap(DMA_MEMCPY, atdma->dma_common.cap_mask))
                 atdma->dma_common.device_prep_dma_memcpy = atc_prep_dma_memcpy;
 
-        if (dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask)) {
+        if (dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask))
                 atdma->dma_common.device_prep_slave_sg = atc_prep_slave_sg;
+
+        if (dma_has_cap(DMA_CYCLIC, atdma->dma_common.cap_mask))
+                atdma->dma_common.device_prep_dma_cyclic = atc_prep_dma_cyclic;
+
+        if (dma_has_cap(DMA_SLAVE, atdma->dma_common.cap_mask) ||
+            dma_has_cap(DMA_CYCLIC, atdma->dma_common.cap_mask))
                 atdma->dma_common.device_control = atc_control;
-        }
 
         dma_writel(atdma, EN, AT_DMA_ENABLE);
 
diff --git a/drivers/dma/at_hdmac_regs.h b/drivers/dma/at_hdmac_regs.h
index 495457e3dc4b..087dbf1dd39c 100644
--- a/drivers/dma/at_hdmac_regs.h
+++ b/drivers/dma/at_hdmac_regs.h
@@ -103,6 +103,10 @@
 /* Bitfields in CTRLB */
 #define ATC_SIF(i)              (0x3 & (i))     /* Src tx done via AHB-Lite Interface i */
 #define ATC_DIF(i)              ((0x3 & (i)) <<  4)     /* Dst tx done via AHB-Lite Interface i */
+                                  /* Specify AHB interfaces */
+#define AT_DMA_MEM_IF           0 /* interface 0 as memory interface */
+#define AT_DMA_PER_IF           1 /* interface 1 as peripheral interface */
+
 #define ATC_SRC_PIP             (0x1 <<  8)     /* Source Picture-in-Picture enabled */
 #define ATC_DST_PIP             (0x1 << 12)     /* Destination Picture-in-Picture enabled */
 #define ATC_SRC_DSCR_DIS        (0x1 << 16)     /* Src Descriptor fetch disable */
@@ -181,12 +185,23 @@ txd_to_at_desc(struct dma_async_tx_descriptor *txd)
 /*--  Channels  --------------------------------------------------------*/
 
 /**
+ * atc_status - information bits stored in channel status flag
+ *
+ * Manipulated with atomic operations.
+ */
+enum atc_status {
+        ATC_IS_ERROR = 0,
+        ATC_IS_PAUSED = 1,
+        ATC_IS_CYCLIC = 24,
+};
+
+/**
  * struct at_dma_chan - internal representation of an Atmel HDMAC channel
  * @chan_common: common dmaengine channel object members
  * @device: parent device
  * @ch_regs: memory mapped register base
  * @mask: channel index in a mask
- * @error_status: transmit error status information from irq handler
+ * @status: transmit status information from irq/prep* functions
  *                to tasklet (use atomic operations)
  * @tasklet: bottom half to finish transaction work
  * @lock: serializes enqueue/dequeue operations to descriptors lists
@@ -201,7 +216,7 @@ struct at_dma_chan {
         struct at_dma           *device;
         void __iomem            *ch_regs;
         u8                      mask;
-        unsigned long           error_status;
+        unsigned long           status;
         struct tasklet_struct   tasklet;
 
         spinlock_t              lock;
@@ -309,8 +324,8 @@ static void atc_setup_irq(struct at_dma_chan *atchan, int on)
         struct at_dma   *atdma = to_at_dma(atchan->chan_common.device);
         u32             ebci;
 
-        /* enable interrupts on buffer chain completion & error */
-        ebci =    AT_DMA_CBTC(atchan->chan_common.chan_id)
+        /* enable interrupts on buffer transfer completion & error */
+        ebci =    AT_DMA_BTC(atchan->chan_common.chan_id)
                 | AT_DMA_ERR(atchan->chan_common.chan_id);
         if (on)
                 dma_writel(atdma, EBCIER, ebci);
@@ -347,7 +362,12 @@ static inline int atc_chan_is_enabled(struct at_dma_chan *atchan)
  */
 static void set_desc_eol(struct at_desc *desc)
 {
-        desc->lli.ctrlb |= ATC_SRC_DSCR_DIS | ATC_DST_DSCR_DIS;
+        u32 ctrlb = desc->lli.ctrlb;
+
+        ctrlb &= ~ATC_IEN;
+        ctrlb |= ATC_SRC_DSCR_DIS | ATC_DST_DSCR_DIS;
+
+        desc->lli.ctrlb = ctrlb;
         desc->lli.dscr = 0;
 }
 
diff --git a/drivers/dma/coh901318.c b/drivers/dma/coh901318.c
index f48e54006518..af8c0b5ed70f 100644
--- a/drivers/dma/coh901318.c
+++ b/drivers/dma/coh901318.c
@@ -1610,7 +1610,7 @@ int __init coh901318_init(void)
 {
         return platform_driver_probe(&coh901318_driver, coh901318_probe);
 }
-arch_initcall(coh901318_init);
+subsys_initcall(coh901318_init);
 
 void __exit coh901318_exit(void)
 {
diff --git a/drivers/dma/dw_dmac.c b/drivers/dma/dw_dmac.c
index 2a2e2fa00e91..4d180ca9a1d8 100644
--- a/drivers/dma/dw_dmac.c
+++ b/drivers/dma/dw_dmac.c
@@ -3,6 +3,7 @@
  * AVR32 systems.)
  *
  * Copyright (C) 2007-2008 Atmel Corporation
+ * Copyright (C) 2010-2011 ST Microelectronics
  *
  * 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
@@ -93,8 +94,9 @@ static struct dw_desc *dwc_desc_get(struct dw_dma_chan *dwc)
         struct dw_desc *desc, *_desc;
         struct dw_desc *ret = NULL;
         unsigned int i = 0;
+        unsigned long flags;
 
-        spin_lock_bh(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
         list_for_each_entry_safe(desc, _desc, &dwc->free_list, desc_node) {
                 if (async_tx_test_ack(&desc->txd)) {
                         list_del(&desc->desc_node);
@@ -104,7 +106,7 @@ static struct dw_desc *dwc_desc_get(struct dw_dma_chan *dwc)
                 dev_dbg(chan2dev(&dwc->chan), "desc %p not ACKed\n", desc);
                 i++;
         }
-        spin_unlock_bh(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
         dev_vdbg(chan2dev(&dwc->chan), "scanned %u descriptors on freelist\n", i);
 
@@ -130,12 +132,14 @@ static void dwc_sync_desc_for_cpu(struct dw_dma_chan *dwc, struct dw_desc *desc)
  */
 static void dwc_desc_put(struct dw_dma_chan *dwc, struct dw_desc *desc)
 {
+        unsigned long flags;
+
         if (desc) {
                 struct dw_desc *child;
 
                 dwc_sync_desc_for_cpu(dwc, desc);
 
-                spin_lock_bh(&dwc->lock);
+                spin_lock_irqsave(&dwc->lock, flags);
                 list_for_each_entry(child, &desc->tx_list, desc_node)
                         dev_vdbg(chan2dev(&dwc->chan),
                                         "moving child desc %p to freelist\n",
@@ -143,7 +147,7 @@ static void dwc_desc_put(struct dw_dma_chan *dwc, struct dw_desc *desc)
                 list_splice_init(&desc->tx_list, &dwc->free_list);
                 dev_vdbg(chan2dev(&dwc->chan), "moving desc %p to freelist\n", desc);
                 list_add(&desc->desc_node, &dwc->free_list);
-                spin_unlock_bh(&dwc->lock);
+                spin_unlock_irqrestore(&dwc->lock, flags);
         }
 }
 
@@ -195,18 +199,23 @@ static void dwc_dostart(struct dw_dma_chan *dwc, struct dw_desc *first)
 /*----------------------------------------------------------------------*/
 
 static void
-dwc_descriptor_complete(struct dw_dma_chan *dwc, struct dw_desc *desc)
+dwc_descriptor_complete(struct dw_dma_chan *dwc, struct dw_desc *desc,
+                bool callback_required)
 {
-        dma_async_tx_callback           callback;
-        void                            *param;
+        dma_async_tx_callback           callback = NULL;
+        void                            *param = NULL;
         struct dma_async_tx_descriptor  *txd = &desc->txd;
         struct dw_desc                  *child;
+        unsigned long                   flags;
 
         dev_vdbg(chan2dev(&dwc->chan), "descriptor %u complete\n", txd->cookie);
 
+        spin_lock_irqsave(&dwc->lock, flags);
         dwc->completed = txd->cookie;
-        callback = txd->callback;
-        param = txd->callback_param;
+        if (callback_required) {
+                callback = txd->callback;
+                param = txd->callback_param;
+        }
 
         dwc_sync_desc_for_cpu(dwc, desc);
 
@@ -238,11 +247,9 @@ dwc_descriptor_complete(struct dw_dma_chan *dwc, struct dw_desc *desc)
                 }
         }
 
-        /*
-         * The API requires that no submissions are done from a
-         * callback, so we don't need to drop the lock here
-         */
-        if (callback)
+        spin_unlock_irqrestore(&dwc->lock, flags);
+
+        if (callback_required && callback)
                 callback(param);
 }
 
@@ -250,7 +257,9 @@ static void dwc_complete_all(struct dw_dma *dw, struct dw_dma_chan *dwc)
 {
         struct dw_desc *desc, *_desc;
         LIST_HEAD(list);
+        unsigned long flags;
 
+        spin_lock_irqsave(&dwc->lock, flags);
         if (dma_readl(dw, CH_EN) & dwc->mask) {
                 dev_err(chan2dev(&dwc->chan),
                         "BUG: XFER bit set, but channel not idle!\n");
@@ -271,8 +280,10 @@ static void dwc_complete_all(struct dw_dma *dw, struct dw_dma_chan *dwc)
                 dwc_dostart(dwc, dwc_first_active(dwc));
         }
 
+        spin_unlock_irqrestore(&dwc->lock, flags);
+
         list_for_each_entry_safe(desc, _desc, &list, desc_node)
-                dwc_descriptor_complete(dwc, desc);
+                dwc_descriptor_complete(dwc, desc, true);
 }
 
 static void dwc_scan_descriptors(struct dw_dma *dw, struct dw_dma_chan *dwc)
@@ -281,7 +292,9 @@ static void dwc_scan_descriptors(struct dw_dma *dw, struct dw_dma_chan *dwc)
         struct dw_desc *desc, *_desc;
         struct dw_desc *child;
         u32 status_xfer;
+        unsigned long flags;
 
+        spin_lock_irqsave(&dwc->lock, flags);
         /*
          * Clear block interrupt flag before scanning so that we don't
          * miss any, and read LLP before RAW_XFER to ensure it is
@@ -294,30 +307,47 @@ static void dwc_scan_descriptors(struct dw_dma *dw, struct dw_dma_chan *dwc)
         if (status_xfer & dwc->mask) {
                 /* Everything we've submitted is done */
                 dma_writel(dw, CLEAR.XFER, dwc->mask);
+                spin_unlock_irqrestore(&dwc->lock, flags);
+
                 dwc_complete_all(dw, dwc);
                 return;
         }
 
-        if (list_empty(&dwc->active_list))
+        if (list_empty(&dwc->active_list)) {
+                spin_unlock_irqrestore(&dwc->lock, flags);
                 return;
+        }
 
         dev_vdbg(chan2dev(&dwc->chan), "scan_descriptors: llp=0x%x\n", llp);
 
         list_for_each_entry_safe(desc, _desc, &dwc->active_list, desc_node) {
-                if (desc->lli.llp == llp)
+                /* check first descriptors addr */
+                if (desc->txd.phys == llp) {
+                        spin_unlock_irqrestore(&dwc->lock, flags);
+                        return;
+                }
+
+                /* check first descriptors llp */
+                if (desc->lli.llp == llp) {
                         /* This one is currently in progress */
+                        spin_unlock_irqrestore(&dwc->lock, flags);
                         return;
+                }
 
                 list_for_each_entry(child, &desc->tx_list, desc_node)
-                        if (child->lli.llp == llp)
+                        if (child->lli.llp == llp) {
                                 /* Currently in progress */
+                                spin_unlock_irqrestore(&dwc->lock, flags);
                                 return;
+                        }
 
                 /*
                  * No descriptors so far seem to be in progress, i.e.
                  * this one must be done.
                  */
-                dwc_descriptor_complete(dwc, desc);
+                spin_unlock_irqrestore(&dwc->lock, flags);
+                dwc_descriptor_complete(dwc, desc, true);
+                spin_lock_irqsave(&dwc->lock, flags);
         }
 
         dev_err(chan2dev(&dwc->chan),
@@ -332,6 +362,7 @@ static void dwc_scan_descriptors(struct dw_dma *dw, struct dw_dma_chan *dwc)
                 list_move(dwc->queue.next, &dwc->active_list);
                 dwc_dostart(dwc, dwc_first_active(dwc));
         }
+        spin_unlock_irqrestore(&dwc->lock, flags);
 }
 
 static void dwc_dump_lli(struct dw_dma_chan *dwc, struct dw_lli *lli)
@@ -346,9 +377,12 @@ static void dwc_handle_error(struct dw_dma *dw, struct dw_dma_chan *dwc)
 {
         struct dw_desc *bad_desc;
         struct dw_desc *child;
+        unsigned long flags;
 
         dwc_scan_descriptors(dw, dwc);
 
+        spin_lock_irqsave(&dwc->lock, flags);
+
         /*
          * The descriptor currently at the head of the active list is
          * borked. Since we don't have any way to report errors, we'll
@@ -378,8 +412,10 @@ static void dwc_handle_error(struct dw_dma *dw, struct dw_dma_chan *dwc)
         list_for_each_entry(child, &bad_desc->tx_list, desc_node)
                 dwc_dump_lli(dwc, &child->lli);
 
+        spin_unlock_irqrestore(&dwc->lock, flags);
+
         /* Pretend the descriptor completed successfully */
-        dwc_descriptor_complete(dwc, bad_desc);
+        dwc_descriptor_complete(dwc, bad_desc, true);
 }
 
 /* --------------------- Cyclic DMA API extensions -------------------- */
@@ -402,6 +438,8 @@ EXPORT_SYMBOL(dw_dma_get_dst_addr);
 static void dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
                 u32 status_block, u32 status_err, u32 status_xfer)
 {
+        unsigned long flags;
+
         if (status_block & dwc->mask) {
                 void (*callback)(void *param);
                 void *callback_param;
@@ -412,11 +450,9 @@ static void dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
 
                 callback = dwc->cdesc->period_callback;
                 callback_param = dwc->cdesc->period_callback_param;
-                if (callback) {
-                        spin_unlock(&dwc->lock);
+
+                if (callback)
                         callback(callback_param);
-                        spin_lock(&dwc->lock);
-                }
         }
 
         /*
@@ -430,6 +466,9 @@ static void dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
                 dev_err(chan2dev(&dwc->chan), "cyclic DMA unexpected %s "
                                 "interrupt, stopping DMA transfer\n",
                                 status_xfer ? "xfer" : "error");
+
+                spin_lock_irqsave(&dwc->lock, flags);
+
                 dev_err(chan2dev(&dwc->chan),
                         "  SAR: 0x%x DAR: 0x%x LLP: 0x%x CTL: 0x%x:%08x\n",
                         channel_readl(dwc, SAR),
@@ -453,6 +492,8 @@ static void dwc_handle_cyclic(struct dw_dma *dw, struct dw_dma_chan *dwc,
 
                 for (i = 0; i < dwc->cdesc->periods; i++)
                         dwc_dump_lli(dwc, &dwc->cdesc->desc[i]->lli);
+
+                spin_unlock_irqrestore(&dwc->lock, flags);
         }
 }
 
@@ -476,7 +517,6 @@ static void dw_dma_tasklet(unsigned long data)
 
         for (i = 0; i < dw->dma.chancnt; i++) {
                 dwc = &dw->chan[i];
-                spin_lock(&dwc->lock);
                 if (test_bit(DW_DMA_IS_CYCLIC, &dwc->flags))
                         dwc_handle_cyclic(dw, dwc, status_block, status_err,
                                         status_xfer);
@@ -484,7 +524,6 @@ static void dw_dma_tasklet(unsigned long data)
                         dwc_handle_error(dw, dwc);
                 else if ((status_block | status_xfer) & (1 << i))
                         dwc_scan_descriptors(dw, dwc);
-                spin_unlock(&dwc->lock);
         }
 
         /*
@@ -539,8 +578,9 @@ static dma_cookie_t dwc_tx_submit(struct dma_async_tx_descriptor *tx)
         struct dw_desc          *desc = txd_to_dw_desc(tx);
         struct dw_dma_chan      *dwc = to_dw_dma_chan(tx->chan);
         dma_cookie_t            cookie;
+        unsigned long           flags;
 
-        spin_lock_bh(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
         cookie = dwc_assign_cookie(dwc, desc);
 
         /*
@@ -560,7 +600,7 @@ static dma_cookie_t dwc_tx_submit(struct dma_async_tx_descriptor *tx)
                 list_add_tail(&desc->desc_node, &dwc->queue);
         }
 
-        spin_unlock_bh(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
         return cookie;
 }
@@ -689,9 +729,15 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 reg = dws->tx_reg;
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct dw_desc  *desc;
-                        u32             len;
-                        u32             mem;
+                        u32             len, dlen, mem;
+
+                        mem = sg_phys(sg);
+                        len = sg_dma_len(sg);
+                        mem_width = 2;
+                        if (unlikely(mem & 3 || len & 3))
+                                mem_width = 0;
 
+slave_sg_todev_fill_desc:
                         desc = dwc_desc_get(dwc);
                         if (!desc) {
                                 dev_err(chan2dev(chan),
@@ -699,16 +745,19 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                                 goto err_desc_get;
                         }
 
-                        mem = sg_phys(sg);
-                        len = sg_dma_len(sg);
-                        mem_width = 2;
-                        if (unlikely(mem & 3 || len & 3))
-                                mem_width = 0;
-
                         desc->lli.sar = mem;
                         desc->lli.dar = reg;
                         desc->lli.ctllo = ctllo | DWC_CTLL_SRC_WIDTH(mem_width);
-                        desc->lli.ctlhi = len >> mem_width;
+                        if ((len >> mem_width) > DWC_MAX_COUNT) {
+                                dlen = DWC_MAX_COUNT << mem_width;
+                                mem += dlen;
+                                len -= dlen;
+                        } else {
+                                dlen = len;
+                                len = 0;
+                        }
+
+                        desc->lli.ctlhi = dlen >> mem_width;
 
                         if (!first) {
                                 first = desc;
@@ -722,7 +771,10 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                                                 &first->tx_list);
                         }
                         prev = desc;
-                        total_len += len;
+                        total_len += dlen;
+
+                        if (len)
+                                goto slave_sg_todev_fill_desc;
                 }
                 break;
         case DMA_FROM_DEVICE:
@@ -735,15 +787,7 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                 reg = dws->rx_reg;
                 for_each_sg(sgl, sg, sg_len, i) {
                         struct dw_desc  *desc;
-                        u32             len;
-                        u32             mem;
-
-                        desc = dwc_desc_get(dwc);
-                        if (!desc) {
-                                dev_err(chan2dev(chan),
-                                        "not enough descriptors available\n");
-                                goto err_desc_get;
-                        }
+                        u32             len, dlen, mem;
 
                         mem = sg_phys(sg);
                         len = sg_dma_len(sg);
@@ -751,10 +795,26 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                         if (unlikely(mem & 3 || len & 3))
                                 mem_width = 0;
 
+slave_sg_fromdev_fill_desc:
+                        desc = dwc_desc_get(dwc);
+                        if (!desc) {
+                                dev_err(chan2dev(chan),
+                                                "not enough descriptors available\n");
+                                goto err_desc_get;
+                        }
+
                         desc->lli.sar = reg;
                         desc->lli.dar = mem;
                         desc->lli.ctllo = ctllo | DWC_CTLL_DST_WIDTH(mem_width);
-                        desc->lli.ctlhi = len >> reg_width;
+                        if ((len >> reg_width) > DWC_MAX_COUNT) {
+                                dlen = DWC_MAX_COUNT << reg_width;
+                                mem += dlen;
+                                len -= dlen;
+                        } else {
+                                dlen = len;
+                                len = 0;
+                        }
+                        desc->lli.ctlhi = dlen >> reg_width;
 
                         if (!first) {
                                 first = desc;
@@ -768,7 +828,10 @@ dwc_prep_slave_sg(struct dma_chan *chan, struct scatterlist *sgl,
                                                 &first->tx_list);
                         }
                         prev = desc;
-                        total_len += len;
+                        total_len += dlen;
+
+                        if (len)
+                                goto slave_sg_fromdev_fill_desc;
                 }
                 break;
         default:
@@ -799,34 +862,51 @@ static int dwc_control(struct dma_chan *chan, enum dma_ctrl_cmd cmd,
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
         struct dw_dma           *dw = to_dw_dma(chan->device);
         struct dw_desc          *desc, *_desc;
+        unsigned long           flags;
+        u32                     cfglo;
         LIST_HEAD(list);
 
-        /* Only supports DMA_TERMINATE_ALL */
-        if (cmd != DMA_TERMINATE_ALL)
-                return -ENXIO;
+        if (cmd == DMA_PAUSE) {
+                spin_lock_irqsave(&dwc->lock, flags);
 
-        /*
-         * This is only called when something went wrong elsewhere, so
-         * we don't really care about the data. Just disable the
-         * channel. We still have to poll the channel enable bit due
-         * to AHB/HSB limitations.
-         */
-        spin_lock_bh(&dwc->lock);
+                cfglo = channel_readl(dwc, CFG_LO);
+                channel_writel(dwc, CFG_LO, cfglo | DWC_CFGL_CH_SUSP);
+                while (!(channel_readl(dwc, CFG_LO) & DWC_CFGL_FIFO_EMPTY))
+                        cpu_relax();
 
-        channel_clear_bit(dw, CH_EN, dwc->mask);
+                dwc->paused = true;
+                spin_unlock_irqrestore(&dwc->lock, flags);
+        } else if (cmd == DMA_RESUME) {
+                if (!dwc->paused)
+                        return 0;
 
-        while (dma_readl(dw, CH_EN) & dwc->mask)
-                cpu_relax();
+                spin_lock_irqsave(&dwc->lock, flags);
 
-        /* active_list entries will end up before queued entries */
-        list_splice_init(&dwc->queue, &list);
-        list_splice_init(&dwc->active_list, &list);
+                cfglo = channel_readl(dwc, CFG_LO);
+                channel_writel(dwc, CFG_LO, cfglo & ~DWC_CFGL_CH_SUSP);
+                dwc->paused = false;
 
-        spin_unlock_bh(&dwc->lock);
+                spin_unlock_irqrestore(&dwc->lock, flags);
+        } else if (cmd == DMA_TERMINATE_ALL) {
+                spin_lock_irqsave(&dwc->lock, flags);
 
-        /* Flush all pending and queued descriptors */
-        list_for_each_entry_safe(desc, _desc, &list, desc_node)
-                dwc_descriptor_complete(dwc, desc);
+                channel_clear_bit(dw, CH_EN, dwc->mask);
+                while (dma_readl(dw, CH_EN) & dwc->mask)
+                        cpu_relax();
+
+                dwc->paused = false;
+
+                /* active_list entries will end up before queued entries */
+                list_splice_init(&dwc->queue, &list);
+                list_splice_init(&dwc->active_list, &list);
+
+                spin_unlock_irqrestore(&dwc->lock, flags);
+
+                /* Flush all pending and queued descriptors */
+                list_for_each_entry_safe(desc, _desc, &list, desc_node)
+                        dwc_descriptor_complete(dwc, desc, false);
+        } else
+                return -ENXIO;
 
         return 0;
 }
@@ -846,9 +926,7 @@ dwc_tx_status(struct dma_chan *chan,
 
         ret = dma_async_is_complete(cookie, last_complete, last_used);
         if (ret != DMA_SUCCESS) {
-                spin_lock_bh(&dwc->lock);
                 dwc_scan_descriptors(to_dw_dma(chan->device), dwc);
-                spin_unlock_bh(&dwc->lock);
 
                 last_complete = dwc->completed;
                 last_used = chan->cookie;
@@ -856,7 +934,14 @@ dwc_tx_status(struct dma_chan *chan,
                 ret = dma_async_is_complete(cookie, last_complete, last_used);
         }
 
-        dma_set_tx_state(txstate, last_complete, last_used, 0);
+        if (ret != DMA_SUCCESS)
+                dma_set_tx_state(txstate, last_complete, last_used,
+                                dwc_first_active(dwc)->len);
+        else
+                dma_set_tx_state(txstate, last_complete, last_used, 0);
+
+        if (dwc->paused)
+                return DMA_PAUSED;
 
         return ret;
 }
@@ -865,10 +950,8 @@ static void dwc_issue_pending(struct dma_chan *chan)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
 
-        spin_lock_bh(&dwc->lock);
         if (!list_empty(&dwc->queue))
                 dwc_scan_descriptors(to_dw_dma(chan->device), dwc);
-        spin_unlock_bh(&dwc->lock);
 }
 
 static int dwc_alloc_chan_resources(struct dma_chan *chan)
@@ -880,6 +963,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
         int                     i;
         u32                     cfghi;
         u32                     cfglo;
+        unsigned long           flags;
 
         dev_vdbg(chan2dev(chan), "alloc_chan_resources\n");
 
@@ -917,16 +1001,16 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
          * doesn't mean what you think it means), and status writeback.
          */
 
-        spin_lock_bh(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
         i = dwc->descs_allocated;
         while (dwc->descs_allocated < NR_DESCS_PER_CHANNEL) {
-                spin_unlock_bh(&dwc->lock);
+                spin_unlock_irqrestore(&dwc->lock, flags);
 
                 desc = kzalloc(sizeof(struct dw_desc), GFP_KERNEL);
                 if (!desc) {
                         dev_info(chan2dev(chan),
                                 "only allocated %d descriptors\n", i);
-                        spin_lock_bh(&dwc->lock);
+                        spin_lock_irqsave(&dwc->lock, flags);
                         break;
                 }
 
@@ -938,7 +1022,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
                                 sizeof(desc->lli), DMA_TO_DEVICE);
                 dwc_desc_put(dwc, desc);
 
-                spin_lock_bh(&dwc->lock);
+                spin_lock_irqsave(&dwc->lock, flags);
                 i = ++dwc->descs_allocated;
         }
 
@@ -947,7 +1031,7 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
         channel_set_bit(dw, MASK.BLOCK, dwc->mask);
         channel_set_bit(dw, MASK.ERROR, dwc->mask);
 
-        spin_unlock_bh(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
         dev_dbg(chan2dev(chan),
                 "alloc_chan_resources allocated %d descriptors\n", i);
@@ -960,6 +1044,7 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
         struct dw_dma           *dw = to_dw_dma(chan->device);
         struct dw_desc          *desc, *_desc;
+        unsigned long           flags;
         LIST_HEAD(list);
 
         dev_dbg(chan2dev(chan), "free_chan_resources (descs allocated=%u)\n",
@@ -970,7 +1055,7 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         BUG_ON(!list_empty(&dwc->queue));
         BUG_ON(dma_readl(to_dw_dma(chan->device), CH_EN) & dwc->mask);
 
-        spin_lock_bh(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
         list_splice_init(&dwc->free_list, &list);
         dwc->descs_allocated = 0;
 
@@ -979,7 +1064,7 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         channel_clear_bit(dw, MASK.BLOCK, dwc->mask);
         channel_clear_bit(dw, MASK.ERROR, dwc->mask);
 
-        spin_unlock_bh(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
         list_for_each_entry_safe(desc, _desc, &list, desc_node) {
                 dev_vdbg(chan2dev(chan), "  freeing descriptor %p\n", desc);
@@ -1004,13 +1089,14 @@ int dw_dma_cyclic_start(struct dma_chan *chan)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
         struct dw_dma           *dw = to_dw_dma(dwc->chan.device);
+        unsigned long           flags;
 
         if (!test_bit(DW_DMA_IS_CYCLIC, &dwc->flags)) {
                 dev_err(chan2dev(&dwc->chan), "missing prep for cyclic DMA\n");
                 return -ENODEV;
         }
 
-        spin_lock(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
 
         /* assert channel is idle */
         if (dma_readl(dw, CH_EN) & dwc->mask) {
@@ -1023,7 +1109,7 @@ int dw_dma_cyclic_start(struct dma_chan *chan)
                         channel_readl(dwc, LLP),
                         channel_readl(dwc, CTL_HI),
                         channel_readl(dwc, CTL_LO));
-                spin_unlock(&dwc->lock);
+                spin_unlock_irqrestore(&dwc->lock, flags);
                 return -EBUSY;
         }
 
@@ -1038,7 +1124,7 @@ int dw_dma_cyclic_start(struct dma_chan *chan)
 
         channel_set_bit(dw, CH_EN, dwc->mask);
 
-        spin_unlock(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
         return 0;
 }
@@ -1054,14 +1140,15 @@ void dw_dma_cyclic_stop(struct dma_chan *chan)
 {
         struct dw_dma_chan      *dwc = to_dw_dma_chan(chan);
         struct dw_dma           *dw = to_dw_dma(dwc->chan.device);
+        unsigned long           flags;
 
-        spin_lock(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
 
         channel_clear_bit(dw, CH_EN, dwc->mask);
         while (dma_readl(dw, CH_EN) & dwc->mask)
                 cpu_relax();
 
-        spin_unlock(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 }
 EXPORT_SYMBOL(dw_dma_cyclic_stop);
 
@@ -1090,17 +1177,18 @@ struct dw_cyclic_desc *dw_dma_cyclic_prep(struct dma_chan *chan,
         unsigned int                    reg_width;
         unsigned int                    periods;
         unsigned int                    i;
+        unsigned long                   flags;
 
-        spin_lock_bh(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
         if (!list_empty(&dwc->queue) || !list_empty(&dwc->active_list)) {
-                spin_unlock_bh(&dwc->lock);
+                spin_unlock_irqrestore(&dwc->lock, flags);
                 dev_dbg(chan2dev(&dwc->chan),
                                 "queue and/or active list are not empty\n");
                 return ERR_PTR(-EBUSY);
         }
 
         was_cyclic = test_and_set_bit(DW_DMA_IS_CYCLIC, &dwc->flags);
-        spin_unlock_bh(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
         if (was_cyclic) {
                 dev_dbg(chan2dev(&dwc->chan),
                                 "channel already prepared for cyclic DMA\n");
@@ -1214,13 +1302,14 @@ void dw_dma_cyclic_free(struct dma_chan *chan)
         struct dw_dma           *dw = to_dw_dma(dwc->chan.device);
         struct dw_cyclic_desc   *cdesc = dwc->cdesc;
         int                     i;
+        unsigned long           flags;
 
         dev_dbg(chan2dev(&dwc->chan), "cyclic free\n");
 
         if (!cdesc)
                 return;
 
-        spin_lock_bh(&dwc->lock);
+        spin_lock_irqsave(&dwc->lock, flags);
 
         channel_clear_bit(dw, CH_EN, dwc->mask);
         while (dma_readl(dw, CH_EN) & dwc->mask)
@@ -1230,7 +1319,7 @@ void dw_dma_cyclic_free(struct dma_chan *chan)
         dma_writel(dw, CLEAR.ERROR, dwc->mask);
         dma_writel(dw, CLEAR.XFER, dwc->mask);
 
-        spin_unlock_bh(&dwc->lock);
+        spin_unlock_irqrestore(&dwc->lock, flags);
 
         for (i = 0; i < cdesc->periods; i++)
                 dwc_desc_put(dwc, cdesc->desc[i]);
@@ -1487,3 +1576,4 @@ module_exit(dw_exit);
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("Synopsys DesignWare DMA Controller driver");
 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
+MODULE_AUTHOR("Viresh Kumar <viresh.kumar@st.com>");
diff --git a/drivers/dma/dw_dmac_regs.h b/drivers/dma/dw_dmac_regs.h
index 720f821527f8..c3419518d701 100644
--- a/drivers/dma/dw_dmac_regs.h
+++ b/drivers/dma/dw_dmac_regs.h
@@ -2,6 +2,7 @@
  * Driver for the Synopsys DesignWare AHB DMA Controller
  *
  * Copyright (C) 2005-2007 Atmel Corporation
+ * Copyright (C) 2010-2011 ST Microelectronics
  *
  * 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
@@ -138,6 +139,7 @@ struct dw_dma_chan {
         void __iomem            *ch_regs;
         u8                      mask;
         u8                      priority;
+        bool                    paused;
 
         spinlock_t              lock;
 
diff --git a/drivers/dma/intel_mid_dma.c b/drivers/dma/intel_mid_dma.c
index 3d4ec38b9b62..f653517ef744 100644
--- a/drivers/dma/intel_mid_dma.c
+++ b/drivers/dma/intel_mid_dma.c
@@ -1292,8 +1292,7 @@ static int __devinit intel_mid_dma_probe(struct pci_dev *pdev,
         if (err)
                 goto err_dma;
 
-        pm_runtime_set_active(&pdev->dev);
-        pm_runtime_enable(&pdev->dev);
+        pm_runtime_put_noidle(&pdev->dev);
         pm_runtime_allow(&pdev->dev);
         return 0;
 
@@ -1322,6 +1321,9 @@ err_enable_device:
 static void __devexit intel_mid_dma_remove(struct pci_dev *pdev)
 {
         struct middma_device *device = pci_get_drvdata(pdev);
+
+        pm_runtime_get_noresume(&pdev->dev);
+        pm_runtime_forbid(&pdev->dev);
         middma_shutdown(pdev);
         pci_dev_put(pdev);
         kfree(device);
@@ -1385,13 +1387,20 @@ int dma_resume(struct pci_dev *pci)
 static int dma_runtime_suspend(struct device *dev)
 {
         struct pci_dev *pci_dev = to_pci_dev(dev);
-        return dma_suspend(pci_dev, PMSG_SUSPEND);
+        struct middma_device *device = pci_get_drvdata(pci_dev);
+
+        device->state = SUSPENDED;
+        return 0;
 }
 
 static int dma_runtime_resume(struct device *dev)
 {
         struct pci_dev *pci_dev = to_pci_dev(dev);
-        return dma_resume(pci_dev);
+        struct middma_device *device = pci_get_drvdata(pci_dev);
+
+        device->state = RUNNING;
+        iowrite32(REG_BIT0, device->dma_base + DMA_CFG);
+        return 0;
 }
 
 static int dma_runtime_idle(struct device *dev)
diff --git a/drivers/dma/ioat/dma_v2.c b/drivers/dma/ioat/dma_v2.c
index f4a51d4d0349..5d65f8377971 100644
--- a/drivers/dma/ioat/dma_v2.c
+++ b/drivers/dma/ioat/dma_v2.c
@@ -508,6 +508,7 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
         struct ioat_ring_ent **ring;
         u64 status;
         int order;
+        int i = 0;
 
         /* have we already been set up? */
         if (ioat->ring)
@@ -548,8 +549,11 @@ int ioat2_alloc_chan_resources(struct dma_chan *c)
         ioat2_start_null_desc(ioat);
 
         /* check that we got off the ground */
-        udelay(5);
-        status = ioat_chansts(chan);
+        do {
+                udelay(1);
+                status = ioat_chansts(chan);
+        } while (i++ < 20 && !is_ioat_active(status) && !is_ioat_idle(status));
+
         if (is_ioat_active(status) || is_ioat_idle(status)) {
                 set_bit(IOAT_RUN, &chan->state);
                 return 1 << ioat->alloc_order;
diff --git a/drivers/dma/iop-adma.c b/drivers/dma/iop-adma.c
index c6b01f535b29..e03f811a83dd 100644
--- a/drivers/dma/iop-adma.c
+++ b/drivers/dma/iop-adma.c
@@ -619,7 +619,7 @@ iop_adma_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dma_dest,
 
         if (unlikely(!len))
                 return NULL;
-        BUG_ON(unlikely(len > IOP_ADMA_MAX_BYTE_COUNT));
+        BUG_ON(len > IOP_ADMA_MAX_BYTE_COUNT);
 
         dev_dbg(iop_chan->device->common.dev, "%s len: %u\n",
                 __func__, len);
@@ -652,7 +652,7 @@ iop_adma_prep_dma_memset(struct dma_chan *chan, dma_addr_t dma_dest,
 
         if (unlikely(!len))
                 return NULL;
-        BUG_ON(unlikely(len > IOP_ADMA_MAX_BYTE_COUNT));
+        BUG_ON(len > IOP_ADMA_MAX_BYTE_COUNT);
 
         dev_dbg(iop_chan->device->common.dev, "%s len: %u\n",
                 __func__, len);
@@ -686,7 +686,7 @@ iop_adma_prep_dma_xor(struct dma_chan *chan, dma_addr_t dma_dest,
 
         if (unlikely(!len))
                 return NULL;
-        BUG_ON(unlikely(len > IOP_ADMA_XOR_MAX_BYTE_COUNT));
+        BUG_ON(len > IOP_ADMA_XOR_MAX_BYTE_COUNT);
 
         dev_dbg(iop_chan->device->common.dev,
                 "%s src_cnt: %d len: %u flags: %lx\n",
diff --git a/drivers/dma/mv_xor.c b/drivers/dma/mv_xor.c
index a25f5f61e0e0..954e334e01bb 100644
--- a/drivers/dma/mv_xor.c
+++ b/drivers/dma/mv_xor.c
@@ -671,7 +671,7 @@ mv_xor_prep_dma_memcpy(struct dma_chan *chan, dma_addr_t dest, dma_addr_t src,
         if (unlikely(len < MV_XOR_MIN_BYTE_COUNT))
                 return NULL;
 
-        BUG_ON(unlikely(len > MV_XOR_MAX_BYTE_COUNT));
+        BUG_ON(len > MV_XOR_MAX_BYTE_COUNT);
 
         spin_lock_bh(&mv_chan->lock);
         slot_cnt = mv_chan_memcpy_slot_count(len);
@@ -710,7 +710,7 @@ mv_xor_prep_dma_memset(struct dma_chan *chan, dma_addr_t dest, int value,
         if (unlikely(len < MV_XOR_MIN_BYTE_COUNT))
                 return NULL;
 
-        BUG_ON(unlikely(len > MV_XOR_MAX_BYTE_COUNT));
+        BUG_ON(len > MV_XOR_MAX_BYTE_COUNT);
 
         spin_lock_bh(&mv_chan->lock);
         slot_cnt = mv_chan_memset_slot_count(len);
@@ -744,7 +744,7 @@ mv_xor_prep_dma_xor(struct dma_chan *chan, dma_addr_t dest, dma_addr_t *src,
         if (unlikely(len < MV_XOR_MIN_BYTE_COUNT))
                 return NULL;
 
-        BUG_ON(unlikely(len > MV_XOR_MAX_BYTE_COUNT));
+        BUG_ON(len > MV_XOR_MAX_BYTE_COUNT);
 
         dev_dbg(mv_chan->device->common.dev,
                 "%s src_cnt: %d len: dest %x %u flags: %ld\n",
diff --git a/drivers/dma/pch_dma.c b/drivers/dma/pch_dma.c
index 8d8fef1480a9..ff5b38f9d45b 100644
--- a/drivers/dma/pch_dma.c
+++ b/drivers/dma/pch_dma.c
@@ -77,10 +77,10 @@ struct pch_dma_regs {
         u32     dma_ctl0;
         u32     dma_ctl1;
         u32     dma_ctl2;
-        u32     reserved1;
+        u32     dma_ctl3;
         u32     dma_sts0;
         u32     dma_sts1;
-        u32     reserved2;
+        u32     dma_sts2;
         u32     reserved3;
         struct pch_dma_desc_regs desc[MAX_CHAN_NR];
 };
@@ -130,6 +130,7 @@ struct pch_dma {
 #define PCH_DMA_CTL0    0x00
 #define PCH_DMA_CTL1    0x04
 #define PCH_DMA_CTL2    0x08
+#define PCH_DMA_CTL3    0x0C
 #define PCH_DMA_STS0    0x10
 #define PCH_DMA_STS1    0x14
 
@@ -138,7 +139,8 @@ struct pch_dma {
 #define dma_writel(pd, name, val) \
         writel((val), (pd)->membase + PCH_DMA_##name)
 
-static inline struct pch_dma_desc *to_pd_desc(struct dma_async_tx_descriptor *txd)
+static inline
+struct pch_dma_desc *to_pd_desc(struct dma_async_tx_descriptor *txd)
 {
         return container_of(txd, struct pch_dma_desc, txd);
 }
@@ -163,13 +165,15 @@ static inline struct device *chan2parent(struct dma_chan *chan)
         return chan->dev->device.parent;
 }
 
-static inline struct pch_dma_desc *pdc_first_active(struct pch_dma_chan *pd_chan)
+static inline
+struct pch_dma_desc *pdc_first_active(struct pch_dma_chan *pd_chan)
 {
         return list_first_entry(&pd_chan->active_list,
                                 struct pch_dma_desc, desc_node);
 }
 
-static inline struct pch_dma_desc *pdc_first_queued(struct pch_dma_chan *pd_chan)
+static inline
+struct pch_dma_desc *pdc_first_queued(struct pch_dma_chan *pd_chan)
 {
         return list_first_entry(&pd_chan->queue,
                                 struct pch_dma_desc, desc_node);
@@ -199,16 +203,30 @@ static void pdc_set_dir(struct dma_chan *chan)
         struct pch_dma *pd = to_pd(chan->device);
         u32 val;
 
-        val = dma_readl(pd, CTL0);
+        if (chan->chan_id < 8) {
+                val = dma_readl(pd, CTL0);
 
-        if (pd_chan->dir == DMA_TO_DEVICE)
-                val |= 0x1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +
-                               DMA_CTL0_DIR_SHIFT_BITS);
-        else
-                val &= ~(0x1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +
-                                 DMA_CTL0_DIR_SHIFT_BITS));
+                if (pd_chan->dir == DMA_TO_DEVICE)
+                        val |= 0x1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +
+                                       DMA_CTL0_DIR_SHIFT_BITS);
+                else
+                        val &= ~(0x1 << (DMA_CTL0_BITS_PER_CH * chan->chan_id +
+                                         DMA_CTL0_DIR_SHIFT_BITS));
+
+                dma_writel(pd, CTL0, val);
+        } else {
+                int ch = chan->chan_id - 8; /* ch8-->0 ch9-->1 ... ch11->3 */
+                val = dma_readl(pd, CTL3);
 
-        dma_writel(pd, CTL0, val);
+                if (pd_chan->dir == DMA_TO_DEVICE)
+                        val |= 0x1 << (DMA_CTL0_BITS_PER_CH * ch +
+                                       DMA_CTL0_DIR_SHIFT_BITS);
+                else
+                        val &= ~(0x1 << (DMA_CTL0_BITS_PER_CH * ch +
+                                         DMA_CTL0_DIR_SHIFT_BITS));
+
+                dma_writel(pd, CTL3, val);
+        }
 
         dev_dbg(chan2dev(chan), "pdc_set_dir: chan %d -> %x\n",
                 chan->chan_id, val);
@@ -219,13 +237,26 @@ static void pdc_set_mode(struct dma_chan *chan, u32 mode)
         struct pch_dma *pd = to_pd(chan->device);
         u32 val;
 
-        val = dma_readl(pd, CTL0);
+        if (chan->chan_id < 8) {
+                val = dma_readl(pd, CTL0);
+
+                val &= ~(DMA_CTL0_MODE_MASK_BITS <<
+                        (DMA_CTL0_BITS_PER_CH * chan->chan_id));
+                val |= mode << (DMA_CTL0_BITS_PER_CH * chan->chan_id);
 
-        val &= ~(DMA_CTL0_MODE_MASK_BITS <<
-                (DMA_CTL0_BITS_PER_CH * chan->chan_id));
-        val |= mode << (DMA_CTL0_BITS_PER_CH * chan->chan_id);
+                dma_writel(pd, CTL0, val);
+        } else {
+                int ch = chan->chan_id - 8; /* ch8-->0 ch9-->1 ... ch11->3 */
+
+                val = dma_readl(pd, CTL3);
+
+                val &= ~(DMA_CTL0_MODE_MASK_BITS <<
+                        (DMA_CTL0_BITS_PER_CH * ch));
+                val |= mode << (DMA_CTL0_BITS_PER_CH * ch);
 
-        dma_writel(pd, CTL0, val);
+                dma_writel(pd, CTL3, val);
+
+        }
 
         dev_dbg(chan2dev(chan), "pdc_set_mode: chan %d -> %x\n",
                 chan->chan_id, val);
@@ -251,9 +282,6 @@ static bool pdc_is_idle(struct pch_dma_chan *pd_chan)
 
 static void pdc_dostart(struct pch_dma_chan *pd_chan, struct pch_dma_desc* desc)
 {
-        struct pch_dma *pd = to_pd(pd_chan->chan.device);
-        u32 val;
-
         if (!pdc_is_idle(pd_chan)) {
                 dev_err(chan2dev(&pd_chan->chan),
                         "BUG: Attempt to start non-idle channel\n");
@@ -279,10 +307,6 @@ static void pdc_dostart(struct pch_dma_chan *pd_chan, struct pch_dma_desc* desc)
                 channel_writel(pd_chan, NEXT, desc->txd.phys);
                 pdc_set_mode(&pd_chan->chan, DMA_CTL0_SG);
         }
-
-        val = dma_readl(pd, CTL2);
-        val |= 1 << (DMA_CTL2_START_SHIFT_BITS + pd_chan->chan.chan_id);
-        dma_writel(pd, CTL2, val);
 }
 
 static void pdc_chain_complete(struct pch_dma_chan *pd_chan,
@@ -403,7 +427,7 @@ static struct pch_dma_desc *pdc_desc_get(struct pch_dma_chan *pd_chan)
 {
         struct pch_dma_desc *desc, *_d;
         struct pch_dma_desc *ret = NULL;
-        int i;
+        int i = 0;
 
         spin_lock(&pd_chan->lock);
         list_for_each_entry_safe(desc, _d, &pd_chan->free_list, desc_node) {
@@ -478,7 +502,6 @@ static int pd_alloc_chan_resources(struct dma_chan *chan)
         spin_unlock_bh(&pd_chan->lock);
 
         pdc_enable_irq(chan, 1);
-        pdc_set_dir(chan);
 
         return pd_chan->descs_allocated;
 }
@@ -561,6 +584,9 @@ static struct dma_async_tx_descriptor *pd_prep_slave_sg(struct dma_chan *chan,
         else
                 return NULL;
 
+        pd_chan->dir = direction;
+        pdc_set_dir(chan);
+
         for_each_sg(sgl, sg, sg_len, i) {
                 desc = pdc_desc_get(pd_chan);
 
@@ -703,6 +729,7 @@ static void pch_dma_save_regs(struct pch_dma *pd)
         pd->regs.dma_ctl0 = dma_readl(pd, CTL0);
         pd->regs.dma_ctl1 = dma_readl(pd, CTL1);
         pd->regs.dma_ctl2 = dma_readl(pd, CTL2);
+        pd->regs.dma_ctl3 = dma_readl(pd, CTL3);
 
         list_for_each_entry_safe(chan, _c, &pd->dma.channels, device_node) {
                 pd_chan = to_pd_chan(chan);
@@ -725,6 +752,7 @@ static void pch_dma_restore_regs(struct pch_dma *pd)
         dma_writel(pd, CTL0, pd->regs.dma_ctl0);
         dma_writel(pd, CTL1, pd->regs.dma_ctl1);
         dma_writel(pd, CTL2, pd->regs.dma_ctl2);
+        dma_writel(pd, CTL3, pd->regs.dma_ctl3);
 
         list_for_each_entry_safe(chan, _c, &pd->dma.channels, device_node) {
                 pd_chan = to_pd_chan(chan);
@@ -850,8 +878,6 @@ static int __devinit pch_dma_probe(struct pci_dev *pdev,
 
                 pd_chan->membase = &regs->desc[i];
 
-                pd_chan->dir = (i % 2) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
-
                 spin_lock_init(&pd_chan->lock);
 
                 INIT_LIST_HEAD(&pd_chan->active_list);
@@ -929,13 +955,23 @@ static void __devexit pch_dma_remove(struct pci_dev *pdev)
 #define PCI_DEVICE_ID_ML7213_DMA1_8CH   0x8026
 #define PCI_DEVICE_ID_ML7213_DMA2_8CH   0x802B
 #define PCI_DEVICE_ID_ML7213_DMA3_4CH   0x8034
+#define PCI_DEVICE_ID_ML7213_DMA4_12CH  0x8032
+#define PCI_DEVICE_ID_ML7223_DMA1_4CH   0x800B
+#define PCI_DEVICE_ID_ML7223_DMA2_4CH   0x800E
+#define PCI_DEVICE_ID_ML7223_DMA3_4CH   0x8017
+#define PCI_DEVICE_ID_ML7223_DMA4_4CH   0x803B
 
-static const struct pci_device_id pch_dma_id_table[] = {
+DEFINE_PCI_DEVICE_TABLE(pch_dma_id_table) = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_EG20T_PCH_DMA_8CH), 8 },
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_EG20T_PCH_DMA_4CH), 4 },
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7213_DMA1_8CH), 8}, /* UART Video */
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7213_DMA2_8CH), 8}, /* PCMIF SPI */
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7213_DMA3_4CH), 4}, /* FPGA */
+        { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7213_DMA4_12CH), 12}, /* I2S */
+        { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7223_DMA1_4CH), 4}, /* UART */
+        { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7223_DMA2_4CH), 4}, /* Video SPI */
+        { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7223_DMA3_4CH), 4}, /* Security */
+        { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7223_DMA4_4CH), 4}, /* FPGA */
         { 0, },
 };
 
diff --git a/drivers/dma/ppc4xx/adma.c b/drivers/dma/ppc4xx/adma.c
index 3b0247e74cc4..fc457a7e8832 100644
--- a/drivers/dma/ppc4xx/adma.c
+++ b/drivers/dma/ppc4xx/adma.c
@@ -2313,7 +2313,7 @@ static struct dma_async_tx_descriptor *ppc440spe_adma_prep_dma_memcpy(
         if (unlikely(!len))
                 return NULL;
 
-        BUG_ON(unlikely(len > PPC440SPE_ADMA_DMA_MAX_BYTE_COUNT));
+        BUG_ON(len > PPC440SPE_ADMA_DMA_MAX_BYTE_COUNT);
 
         spin_lock_bh(&ppc440spe_chan->lock);
 
@@ -2354,7 +2354,7 @@ static struct dma_async_tx_descriptor *ppc440spe_adma_prep_dma_memset(
         if (unlikely(!len))
                 return NULL;
 
-        BUG_ON(unlikely(len > PPC440SPE_ADMA_DMA_MAX_BYTE_COUNT));
+        BUG_ON(len > PPC440SPE_ADMA_DMA_MAX_BYTE_COUNT);
 
         spin_lock_bh(&ppc440spe_chan->lock);
 
@@ -2397,7 +2397,7 @@ static struct dma_async_tx_descriptor *ppc440spe_adma_prep_dma_xor(
                                      dma_dest, dma_src, src_cnt));
         if (unlikely(!len))
                 return NULL;
-        BUG_ON(unlikely(len > PPC440SPE_ADMA_XOR_MAX_BYTE_COUNT));
+        BUG_ON(len > PPC440SPE_ADMA_XOR_MAX_BYTE_COUNT);
 
         dev_dbg(ppc440spe_chan->device->common.dev,
                 "ppc440spe adma%d: %s src_cnt: %d len: %u int_en: %d\n",
@@ -2887,7 +2887,7 @@ static struct dma_async_tx_descriptor *ppc440spe_adma_prep_dma_pq(
         ADMA_LL_DBG(prep_dma_pq_dbg(ppc440spe_chan->device->id,
                                     dst, src, src_cnt));
         BUG_ON(!len);
-        BUG_ON(unlikely(len > PPC440SPE_ADMA_XOR_MAX_BYTE_COUNT));
+        BUG_ON(len > PPC440SPE_ADMA_XOR_MAX_BYTE_COUNT);
         BUG_ON(!src_cnt);
 
         if (src_cnt == 1 && dst[1] == src[0]) {
diff --git a/drivers/dma/ste_dma40.c b/drivers/dma/ste_dma40.c
index 94ee15dd3aed..8f222d4db7de 100644
--- a/drivers/dma/ste_dma40.c
+++ b/drivers/dma/ste_dma40.c
@@ -1829,7 +1829,7 @@ d40_get_dev_addr(struct d40_chan *chan, enum dma_data_direction direction)
 {
         struct stedma40_platform_data *plat = chan->base->plat_data;
         struct stedma40_chan_cfg *cfg = &chan->dma_cfg;
-        dma_addr_t addr;
+        dma_addr_t addr = 0;
 
         if (chan->runtime_addr)
                 return chan->runtime_addr;
@@ -2962,4 +2962,4 @@ static int __init stedma40_init(void)
 {
         return platform_driver_probe(&d40_driver, d40_probe);
 }
-arch_initcall(stedma40_init);
+subsys_initcall(stedma40_init);
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index d21364603755..4a7f63143455 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -86,6 +86,34 @@ config GPIO_IT8761E
         help
           Say yes here to support GPIO functionality of IT8761E super I/O chip.
 
+config GPIO_EXYNOS4
+        bool "Samsung Exynos4 GPIO library support"
+        default y if CPU_EXYNOS4210
+        depends on ARM
+        help
+          Say yes here to support Samsung Exynos4 series SoCs GPIO library
+
+config GPIO_PLAT_SAMSUNG
+        bool "Samsung SoCs GPIO library support"
+        default y if SAMSUNG_GPIOLIB_4BIT
+        depends on ARM
+        help
+          Say yes here to support Samsung SoCs GPIO library
+
+config GPIO_S5PC100
+        bool "Samsung S5PC100 GPIO library support"
+        default y if CPU_S5PC100
+        depends on ARM
+        help
+          Say yes here to support Samsung S5PC100 SoCs GPIO library
+
+config GPIO_S5PV210
+        bool "Samsung S5PV210/S5PC110 GPIO library support"
+        default y if CPU_S5PV210
+        depends on ARM
+        help
+          Say yes here to support Samsung S5PV210/S5PC110 SoCs GPIO library
+
 config GPIO_PL061
         bool "PrimeCell PL061 GPIO support"
         depends on ARM_AMBA
@@ -303,7 +331,7 @@ comment "PCI GPIO expanders:"
 
 config GPIO_CS5535
         tristate "AMD CS5535/CS5536 GPIO support"
-        depends on PCI && X86 && !CS5535_GPIO
+        depends on PCI && X86 && !CS5535_GPIO && MFD_CS5535
         help
           The AMD CS5535 and CS5536 southbridges support 28 GPIO pins that
           can be used for quite a number of things.  The CS5535/6 is found on
@@ -334,13 +362,19 @@ config GPIO_LANGWELL
           Say Y here to support Intel Langwell/Penwell GPIO.
 
 config GPIO_PCH
-        tristate "PCH GPIO of Intel Topcliff"
+        tristate "Intel EG20T PCH / OKI SEMICONDUCTOR ML7223 IOH GPIO"
         depends on PCI && X86
         help
           This driver is for PCH(Platform controller Hub) GPIO of Intel Topcliff
           which is an IOH(Input/Output Hub) for x86 embedded processor.
           This driver can access PCH GPIO device.
 
+          This driver also can be used for OKI SEMICONDUCTOR IOH(Input/
+          Output Hub), ML7223.
+          ML7223 IOH is for MP(Media Phone) use.
+          ML7223 is companion chip for Intel Atom E6xx series.
+          ML7223 is completely compatible for Intel EG20T PCH.
+
 config GPIO_ML_IOH
         tristate "OKI SEMICONDUCTOR ML7213 IOH GPIO support"
         depends on PCI
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 6a3387acc0e5..b605f8ec6fbe 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -8,6 +8,10 @@ obj-$(CONFIG_GPIO_ADP5520)	+= adp5520-gpio.o
 obj-$(CONFIG_GPIO_ADP5588)      += adp5588-gpio.o
 obj-$(CONFIG_GPIO_BASIC_MMIO_CORE)      += basic_mmio_gpio.o
 obj-$(CONFIG_GPIO_BASIC_MMIO)   += basic_mmio_gpio.o
+obj-$(CONFIG_GPIO_EXYNOS4)      += gpio-exynos4.o
+obj-$(CONFIG_GPIO_PLAT_SAMSUNG) += gpio-plat-samsung.o
+obj-$(CONFIG_GPIO_S5PC100)      += gpio-s5pc100.o
+obj-$(CONFIG_GPIO_S5PV210)      += gpio-s5pv210.o
 obj-$(CONFIG_GPIO_LANGWELL)     += langwell_gpio.o
 obj-$(CONFIG_GPIO_MAX730X)      += max730x.o
 obj-$(CONFIG_GPIO_MAX7300)      += max7300.o
@@ -16,6 +20,7 @@ obj-$(CONFIG_GPIO_MAX732X)	+= max732x.o
 obj-$(CONFIG_GPIO_MC33880)      += mc33880.o
 obj-$(CONFIG_GPIO_MCP23S08)     += mcp23s08.o
 obj-$(CONFIG_GPIO_74X164)       += 74x164.o
+obj-$(CONFIG_ARCH_OMAP)         += gpio-omap.o
 obj-$(CONFIG_GPIO_PCA953X)      += pca953x.o
 obj-$(CONFIG_GPIO_PCF857X)      += pcf857x.o
 obj-$(CONFIG_GPIO_PCH)          += pch_gpio.o
@@ -34,6 +39,8 @@ obj-$(CONFIG_GPIO_WM831X)	+= wm831x-gpio.o
 obj-$(CONFIG_GPIO_WM8350)       += wm8350-gpiolib.o
 obj-$(CONFIG_GPIO_WM8994)       += wm8994-gpio.o
 obj-$(CONFIG_GPIO_SCH)          += sch_gpio.o
+obj-$(CONFIG_MACH_U300)         += gpio-u300.o
+obj-$(CONFIG_PLAT_NOMADIK)      += gpio-nomadik.o
 obj-$(CONFIG_GPIO_RDC321X)      += rdc321x-gpio.o
 obj-$(CONFIG_GPIO_JANZ_TTL)     += janz-ttl.o
 obj-$(CONFIG_GPIO_SX150X)       += sx150x.o
diff --git a/drivers/gpio/gpio-exynos4.c b/drivers/gpio/gpio-exynos4.c
new file mode 100644
index 000000000000..d54ca6adb660
--- /dev/null
+++ b/drivers/gpio/gpio-exynos4.c
@@ -0,0 +1,365 @@
+/* linux/arch/arm/mach-exynos4/gpiolib.c
+ *
+ * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * EXYNOS4 - GPIOlib support
+ *
+ * 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/irq.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+
+#include <mach/map.h>
+
+#include <plat/gpio-core.h>
+#include <plat/gpio-cfg.h>
+#include <plat/gpio-cfg-helpers.h>
+
+static struct s3c_gpio_cfg gpio_cfg = {
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+static struct s3c_gpio_cfg gpio_cfg_noint = {
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+/*
+ * Following are the gpio banks in v310.
+ *
+ * The 'config' member when left to NULL, is initialized to the default
+ * structure gpio_cfg in the init function below.
+ *
+ * The 'base' member is also initialized in the init function below.
+ * Note: The initialization of 'base' member of s3c_gpio_chip structure
+ * uses the above macro and depends on the banks being listed in order here.
+ */
+static struct s3c_gpio_chip exynos4_gpio_part1_4bit[] = {
+        {
+                .chip   = {
+                        .base   = EXYNOS4_GPA0(0),
+                        .ngpio  = EXYNOS4_GPIO_A0_NR,
+                        .label  = "GPA0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPA1(0),
+                        .ngpio  = EXYNOS4_GPIO_A1_NR,
+                        .label  = "GPA1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPB(0),
+                        .ngpio  = EXYNOS4_GPIO_B_NR,
+                        .label  = "GPB",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPC0(0),
+                        .ngpio  = EXYNOS4_GPIO_C0_NR,
+                        .label  = "GPC0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPC1(0),
+                        .ngpio  = EXYNOS4_GPIO_C1_NR,
+                        .label  = "GPC1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPD0(0),
+                        .ngpio  = EXYNOS4_GPIO_D0_NR,
+                        .label  = "GPD0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPD1(0),
+                        .ngpio  = EXYNOS4_GPIO_D1_NR,
+                        .label  = "GPD1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPE0(0),
+                        .ngpio  = EXYNOS4_GPIO_E0_NR,
+                        .label  = "GPE0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPE1(0),
+                        .ngpio  = EXYNOS4_GPIO_E1_NR,
+                        .label  = "GPE1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPE2(0),
+                        .ngpio  = EXYNOS4_GPIO_E2_NR,
+                        .label  = "GPE2",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPE3(0),
+                        .ngpio  = EXYNOS4_GPIO_E3_NR,
+                        .label  = "GPE3",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPE4(0),
+                        .ngpio  = EXYNOS4_GPIO_E4_NR,
+                        .label  = "GPE4",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPF0(0),
+                        .ngpio  = EXYNOS4_GPIO_F0_NR,
+                        .label  = "GPF0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPF1(0),
+                        .ngpio  = EXYNOS4_GPIO_F1_NR,
+                        .label  = "GPF1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPF2(0),
+                        .ngpio  = EXYNOS4_GPIO_F2_NR,
+                        .label  = "GPF2",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPF3(0),
+                        .ngpio  = EXYNOS4_GPIO_F3_NR,
+                        .label  = "GPF3",
+                },
+        },
+};
+
+static struct s3c_gpio_chip exynos4_gpio_part2_4bit[] = {
+        {
+                .chip   = {
+                        .base   = EXYNOS4_GPJ0(0),
+                        .ngpio  = EXYNOS4_GPIO_J0_NR,
+                        .label  = "GPJ0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPJ1(0),
+                        .ngpio  = EXYNOS4_GPIO_J1_NR,
+                        .label  = "GPJ1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPK0(0),
+                        .ngpio  = EXYNOS4_GPIO_K0_NR,
+                        .label  = "GPK0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPK1(0),
+                        .ngpio  = EXYNOS4_GPIO_K1_NR,
+                        .label  = "GPK1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPK2(0),
+                        .ngpio  = EXYNOS4_GPIO_K2_NR,
+                        .label  = "GPK2",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPK3(0),
+                        .ngpio  = EXYNOS4_GPIO_K3_NR,
+                        .label  = "GPK3",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPL0(0),
+                        .ngpio  = EXYNOS4_GPIO_L0_NR,
+                        .label  = "GPL0",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPL1(0),
+                        .ngpio  = EXYNOS4_GPIO_L1_NR,
+                        .label  = "GPL1",
+                },
+        }, {
+                .chip   = {
+                        .base   = EXYNOS4_GPL2(0),
+                        .ngpio  = EXYNOS4_GPIO_L2_NR,
+                        .label  = "GPL2",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY0(0),
+                        .ngpio  = EXYNOS4_GPIO_Y0_NR,
+                        .label  = "GPY0",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY1(0),
+                        .ngpio  = EXYNOS4_GPIO_Y1_NR,
+                        .label  = "GPY1",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY2(0),
+                        .ngpio  = EXYNOS4_GPIO_Y2_NR,
+                        .label  = "GPY2",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY3(0),
+                        .ngpio  = EXYNOS4_GPIO_Y3_NR,
+                        .label  = "GPY3",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY4(0),
+                        .ngpio  = EXYNOS4_GPIO_Y4_NR,
+                        .label  = "GPY4",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY5(0),
+                        .ngpio  = EXYNOS4_GPIO_Y5_NR,
+                        .label  = "GPY5",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = EXYNOS4_GPY6(0),
+                        .ngpio  = EXYNOS4_GPIO_Y6_NR,
+                        .label  = "GPY6",
+                },
+        }, {
+                .base   = (S5P_VA_GPIO2 + 0xC00),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(0),
+                .chip   = {
+                        .base   = EXYNOS4_GPX0(0),
+                        .ngpio  = EXYNOS4_GPIO_X0_NR,
+                        .label  = "GPX0",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO2 + 0xC20),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(8),
+                .chip   = {
+                        .base   = EXYNOS4_GPX1(0),
+                        .ngpio  = EXYNOS4_GPIO_X1_NR,
+                        .label  = "GPX1",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO2 + 0xC40),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(16),
+                .chip   = {
+                        .base   = EXYNOS4_GPX2(0),
+                        .ngpio  = EXYNOS4_GPIO_X2_NR,
+                        .label  = "GPX2",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO2 + 0xC60),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(24),
+                .chip   = {
+                        .base   = EXYNOS4_GPX3(0),
+                        .ngpio  = EXYNOS4_GPIO_X3_NR,
+                        .label  = "GPX3",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        },
+};
+
+static struct s3c_gpio_chip exynos4_gpio_part3_4bit[] = {
+        {
+                .chip   = {
+                        .base   = EXYNOS4_GPZ(0),
+                        .ngpio  = EXYNOS4_GPIO_Z_NR,
+                        .label  = "GPZ",
+                },
+        },
+};
+
+static __init int exynos4_gpiolib_init(void)
+{
+        struct s3c_gpio_chip *chip;
+        int i;
+        int group = 0;
+        int nr_chips;
+
+        /* GPIO part 1 */
+
+        chip = exynos4_gpio_part1_4bit;
+        nr_chips = ARRAY_SIZE(exynos4_gpio_part1_4bit);
+
+        for (i = 0; i < nr_chips; i++, chip++) {
+                if (chip->config == NULL) {
+                        chip->config = &gpio_cfg;
+                        /* Assign the GPIO interrupt group */
+                        chip->group = group++;
+                }
+                if (chip->base == NULL)
+                        chip->base = S5P_VA_GPIO1 + (i) * 0x20;
+        }
+
+        samsung_gpiolib_add_4bit_chips(exynos4_gpio_part1_4bit, nr_chips);
+
+        /* GPIO part 2 */
+
+        chip = exynos4_gpio_part2_4bit;
+        nr_chips = ARRAY_SIZE(exynos4_gpio_part2_4bit);
+
+        for (i = 0; i < nr_chips; i++, chip++) {
+                if (chip->config == NULL) {
+                        chip->config = &gpio_cfg;
+                        /* Assign the GPIO interrupt group */
+                        chip->group = group++;
+                }
+                if (chip->base == NULL)
+                        chip->base = S5P_VA_GPIO2 + (i) * 0x20;
+        }
+
+        samsung_gpiolib_add_4bit_chips(exynos4_gpio_part2_4bit, nr_chips);
+
+        /* GPIO part 3 */
+
+        chip = exynos4_gpio_part3_4bit;
+        nr_chips = ARRAY_SIZE(exynos4_gpio_part3_4bit);
+
+        for (i = 0; i < nr_chips; i++, chip++) {
+                if (chip->config == NULL) {
+                        chip->config = &gpio_cfg;
+                        /* Assign the GPIO interrupt group */
+                        chip->group = group++;
+                }
+                if (chip->base == NULL)
+                        chip->base = S5P_VA_GPIO3 + (i) * 0x20;
+        }
+
+        samsung_gpiolib_add_4bit_chips(exynos4_gpio_part3_4bit, nr_chips);
+        s5p_register_gpioint_bank(IRQ_GPIO_XA, 0, IRQ_GPIO1_NR_GROUPS);
+        s5p_register_gpioint_bank(IRQ_GPIO_XB, IRQ_GPIO1_NR_GROUPS, IRQ_GPIO2_NR_GROUPS);
+
+        return 0;
+}
+core_initcall(exynos4_gpiolib_init);
diff --git a/drivers/gpio/gpio-nomadik.c b/drivers/gpio/gpio-nomadik.c
new file mode 100644
index 000000000000..4961ef9bc153
--- /dev/null
+++ b/drivers/gpio/gpio-nomadik.c
@@ -0,0 +1,1069 @@
+/*
+ * Generic GPIO driver for logic cells found in the Nomadik SoC
+ *
+ * Copyright (C) 2008,2009 STMicroelectronics
+ * Copyright (C) 2009 Alessandro Rubini <rubini@unipv.it>
+ *   Rewritten based on work by Prafulla WADASKAR <prafulla.wadaskar@st.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/spinlock.h>
+#include <linux/interrupt.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+
+#include <asm/mach/irq.h>
+
+#include <plat/pincfg.h>
+#include <mach/hardware.h>
+#include <mach/gpio.h>
+
+/*
+ * The GPIO module in the Nomadik family of Systems-on-Chip is an
+ * AMBA device, managing 32 pins and alternate functions.  The logic block
+ * is currently used in the Nomadik and ux500.
+ *
+ * Symbols in this file are called "nmk_gpio" for "nomadik gpio"
+ */
+
+#define NMK_GPIO_PER_CHIP       32
+
+struct nmk_gpio_chip {
+        struct gpio_chip chip;
+        void __iomem *addr;
+        struct clk *clk;
+        unsigned int bank;
+        unsigned int parent_irq;
+        int secondary_parent_irq;
+        u32 (*get_secondary_status)(unsigned int bank);
+        void (*set_ioforce)(bool enable);
+        spinlock_t lock;
+        /* Keep track of configured edges */
+        u32 edge_rising;
+        u32 edge_falling;
+        u32 real_wake;
+        u32 rwimsc;
+        u32 fwimsc;
+        u32 slpm;
+        u32 enabled;
+        u32 pull_up;
+};
+
+static struct nmk_gpio_chip *
+nmk_gpio_chips[DIV_ROUND_UP(ARCH_NR_GPIOS, NMK_GPIO_PER_CHIP)];
+
+static DEFINE_SPINLOCK(nmk_gpio_slpm_lock);
+
+#define NUM_BANKS ARRAY_SIZE(nmk_gpio_chips)
+
+static void __nmk_gpio_set_mode(struct nmk_gpio_chip *nmk_chip,
+                                unsigned offset, int gpio_mode)
+{
+        u32 bit = 1 << offset;
+        u32 afunc, bfunc;
+
+        afunc = readl(nmk_chip->addr + NMK_GPIO_AFSLA) & ~bit;
+        bfunc = readl(nmk_chip->addr + NMK_GPIO_AFSLB) & ~bit;
+        if (gpio_mode & NMK_GPIO_ALT_A)
+                afunc |= bit;
+        if (gpio_mode & NMK_GPIO_ALT_B)
+                bfunc |= bit;
+        writel(afunc, nmk_chip->addr + NMK_GPIO_AFSLA);
+        writel(bfunc, nmk_chip->addr + NMK_GPIO_AFSLB);
+}
+
+static void __nmk_gpio_set_slpm(struct nmk_gpio_chip *nmk_chip,
+                                unsigned offset, enum nmk_gpio_slpm mode)
+{
+        u32 bit = 1 << offset;
+        u32 slpm;
+
+        slpm = readl(nmk_chip->addr + NMK_GPIO_SLPC);
+        if (mode == NMK_GPIO_SLPM_NOCHANGE)
+                slpm |= bit;
+        else
+                slpm &= ~bit;
+        writel(slpm, nmk_chip->addr + NMK_GPIO_SLPC);
+}
+
+static void __nmk_gpio_set_pull(struct nmk_gpio_chip *nmk_chip,
+                                unsigned offset, enum nmk_gpio_pull pull)
+{
+        u32 bit = 1 << offset;
+        u32 pdis;
+
+        pdis = readl(nmk_chip->addr + NMK_GPIO_PDIS);
+        if (pull == NMK_GPIO_PULL_NONE) {
+                pdis |= bit;
+                nmk_chip->pull_up &= ~bit;
+        } else {
+                pdis &= ~bit;
+        }
+
+        writel(pdis, nmk_chip->addr + NMK_GPIO_PDIS);
+
+        if (pull == NMK_GPIO_PULL_UP) {
+                nmk_chip->pull_up |= bit;
+                writel(bit, nmk_chip->addr + NMK_GPIO_DATS);
+        } else if (pull == NMK_GPIO_PULL_DOWN) {
+                nmk_chip->pull_up &= ~bit;
+                writel(bit, nmk_chip->addr + NMK_GPIO_DATC);
+        }
+}
+
+static void __nmk_gpio_make_input(struct nmk_gpio_chip *nmk_chip,
+                                  unsigned offset)
+{
+        writel(1 << offset, nmk_chip->addr + NMK_GPIO_DIRC);
+}
+
+static void __nmk_gpio_set_output(struct nmk_gpio_chip *nmk_chip,
+                                  unsigned offset, int val)
+{
+        if (val)
+                writel(1 << offset, nmk_chip->addr + NMK_GPIO_DATS);
+        else
+                writel(1 << offset, nmk_chip->addr + NMK_GPIO_DATC);
+}
+
+static void __nmk_gpio_make_output(struct nmk_gpio_chip *nmk_chip,
+                                  unsigned offset, int val)
+{
+        writel(1 << offset, nmk_chip->addr + NMK_GPIO_DIRS);
+        __nmk_gpio_set_output(nmk_chip, offset, val);
+}
+
+static void __nmk_gpio_set_mode_safe(struct nmk_gpio_chip *nmk_chip,
+                                     unsigned offset, int gpio_mode,
+                                     bool glitch)
+{
+        u32 rwimsc = readl(nmk_chip->addr + NMK_GPIO_RWIMSC);
+        u32 fwimsc = readl(nmk_chip->addr + NMK_GPIO_FWIMSC);
+
+        if (glitch && nmk_chip->set_ioforce) {
+                u32 bit = BIT(offset);
+
+                /* Prevent spurious wakeups */
+                writel(rwimsc & ~bit, nmk_chip->addr + NMK_GPIO_RWIMSC);
+                writel(fwimsc & ~bit, nmk_chip->addr + NMK_GPIO_FWIMSC);
+
+                nmk_chip->set_ioforce(true);
+        }
+
+        __nmk_gpio_set_mode(nmk_chip, offset, gpio_mode);
+
+        if (glitch && nmk_chip->set_ioforce) {
+                nmk_chip->set_ioforce(false);
+
+                writel(rwimsc, nmk_chip->addr + NMK_GPIO_RWIMSC);
+                writel(fwimsc, nmk_chip->addr + NMK_GPIO_FWIMSC);
+        }
+}
+
+static void __nmk_config_pin(struct nmk_gpio_chip *nmk_chip, unsigned offset,
+                             pin_cfg_t cfg, bool sleep, unsigned int *slpmregs)
+{
+        static const char *afnames[] = {
+                [NMK_GPIO_ALT_GPIO]     = "GPIO",
+                [NMK_GPIO_ALT_A]        = "A",
+                [NMK_GPIO_ALT_B]        = "B",
+                [NMK_GPIO_ALT_C]        = "C"
+        };
+        static const char *pullnames[] = {
+                [NMK_GPIO_PULL_NONE]    = "none",
+                [NMK_GPIO_PULL_UP]      = "up",
+                [NMK_GPIO_PULL_DOWN]    = "down",
+                [3] /* illegal */       = "??"
+        };
+        static const char *slpmnames[] = {
+                [NMK_GPIO_SLPM_INPUT]           = "input/wakeup",
+                [NMK_GPIO_SLPM_NOCHANGE]        = "no-change/no-wakeup",
+        };
+
+        int pin = PIN_NUM(cfg);
+        int pull = PIN_PULL(cfg);
+        int af = PIN_ALT(cfg);
+        int slpm = PIN_SLPM(cfg);
+        int output = PIN_DIR(cfg);
+        int val = PIN_VAL(cfg);
+        bool glitch = af == NMK_GPIO_ALT_C;
+
+        dev_dbg(nmk_chip->chip.dev, "pin %d [%#lx]: af %s, pull %s, slpm %s (%s%s)\n",
+                pin, cfg, afnames[af], pullnames[pull], slpmnames[slpm],
+                output ? "output " : "input",
+                output ? (val ? "high" : "low") : "");
+
+        if (sleep) {
+                int slpm_pull = PIN_SLPM_PULL(cfg);
+                int slpm_output = PIN_SLPM_DIR(cfg);
+                int slpm_val = PIN_SLPM_VAL(cfg);
+
+                af = NMK_GPIO_ALT_GPIO;
+
+                /*
+                 * The SLPM_* values are normal values + 1 to allow zero to
+                 * mean "same as normal".
+                 */
+                if (slpm_pull)
+                        pull = slpm_pull - 1;
+                if (slpm_output)
+                        output = slpm_output - 1;
+                if (slpm_val)
+                        val = slpm_val - 1;
+
+                dev_dbg(nmk_chip->chip.dev, "pin %d: sleep pull %s, dir %s, val %s\n",
+                        pin,
+                        slpm_pull ? pullnames[pull] : "same",
+                        slpm_output ? (output ? "output" : "input") : "same",
+                        slpm_val ? (val ? "high" : "low") : "same");
+        }
+
+        if (output)
+                __nmk_gpio_make_output(nmk_chip, offset, val);
+        else {
+                __nmk_gpio_make_input(nmk_chip, offset);
+                __nmk_gpio_set_pull(nmk_chip, offset, pull);
+        }
+
+        /*
+         * If we've backed up the SLPM registers (glitch workaround), modify
+         * the backups since they will be restored.
+         */
+        if (slpmregs) {
+                if (slpm == NMK_GPIO_SLPM_NOCHANGE)
+                        slpmregs[nmk_chip->bank] |= BIT(offset);
+                else
+                        slpmregs[nmk_chip->bank] &= ~BIT(offset);
+        } else
+                __nmk_gpio_set_slpm(nmk_chip, offset, slpm);
+
+        __nmk_gpio_set_mode_safe(nmk_chip, offset, af, glitch);
+}
+
+/*
+ * Safe sequence used to switch IOs between GPIO and Alternate-C mode:
+ *  - Save SLPM registers
+ *  - Set SLPM=0 for the IOs you want to switch and others to 1
+ *  - Configure the GPIO registers for the IOs that are being switched
+ *  - Set IOFORCE=1
+ *  - Modify the AFLSA/B registers for the IOs that are being switched
+ *  - Set IOFORCE=0
+ *  - Restore SLPM registers
+ *  - Any spurious wake up event during switch sequence to be ignored and
+ *    cleared
+ */
+static void nmk_gpio_glitch_slpm_init(unsigned int *slpm)
+{
+        int i;
+
+        for (i = 0; i < NUM_BANKS; i++) {
+                struct nmk_gpio_chip *chip = nmk_gpio_chips[i];
+                unsigned int temp = slpm[i];
+
+                if (!chip)
+                        break;
+
+                slpm[i] = readl(chip->addr + NMK_GPIO_SLPC);
+                writel(temp, chip->addr + NMK_GPIO_SLPC);
+        }
+}
+
+static void nmk_gpio_glitch_slpm_restore(unsigned int *slpm)
+{
+        int i;
+
+        for (i = 0; i < NUM_BANKS; i++) {
+                struct nmk_gpio_chip *chip = nmk_gpio_chips[i];
+
+                if (!chip)
+                        break;
+
+                writel(slpm[i], chip->addr + NMK_GPIO_SLPC);
+        }
+}
+
+static int __nmk_config_pins(pin_cfg_t *cfgs, int num, bool sleep)
+{
+        static unsigned int slpm[NUM_BANKS];
+        unsigned long flags;
+        bool glitch = false;
+        int ret = 0;
+        int i;
+
+        for (i = 0; i < num; i++) {
+                if (PIN_ALT(cfgs[i]) == NMK_GPIO_ALT_C) {
+                        glitch = true;
+                        break;
+                }
+        }
+
+        spin_lock_irqsave(&nmk_gpio_slpm_lock, flags);
+
+        if (glitch) {
+                memset(slpm, 0xff, sizeof(slpm));
+
+                for (i = 0; i < num; i++) {
+                        int pin = PIN_NUM(cfgs[i]);
+                        int offset = pin % NMK_GPIO_PER_CHIP;
+
+                        if (PIN_ALT(cfgs[i]) == NMK_GPIO_ALT_C)
+                                slpm[pin / NMK_GPIO_PER_CHIP] &= ~BIT(offset);
+                }
+
+                nmk_gpio_glitch_slpm_init(slpm);
+        }
+
+        for (i = 0; i < num; i++) {
+                struct nmk_gpio_chip *nmk_chip;
+                int pin = PIN_NUM(cfgs[i]);
+
+                nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(pin));
+                if (!nmk_chip) {
+                        ret = -EINVAL;
+                        break;
+                }
+
+                spin_lock(&nmk_chip->lock);
+                __nmk_config_pin(nmk_chip, pin - nmk_chip->chip.base,
+                                 cfgs[i], sleep, glitch ? slpm : NULL);
+                spin_unlock(&nmk_chip->lock);
+        }
+
+        if (glitch)
+                nmk_gpio_glitch_slpm_restore(slpm);
+
+        spin_unlock_irqrestore(&nmk_gpio_slpm_lock, flags);
+
+        return ret;
+}
+
+/**
+ * nmk_config_pin - configure a pin's mux attributes
+ * @cfg: pin confguration
+ *
+ * Configures a pin's mode (alternate function or GPIO), its pull up status,
+ * and its sleep mode based on the specified configuration.  The @cfg is
+ * usually one of the SoC specific macros defined in mach/<soc>-pins.h.  These
+ * are constructed using, and can be further enhanced with, the macros in
+ * plat/pincfg.h.
+ *
+ * If a pin's mode is set to GPIO, it is configured as an input to avoid
+ * side-effects.  The gpio can be manipulated later using standard GPIO API
+ * calls.
+ */
+int nmk_config_pin(pin_cfg_t cfg, bool sleep)
+{
+        return __nmk_config_pins(&cfg, 1, sleep);
+}
+EXPORT_SYMBOL(nmk_config_pin);
+
+/**
+ * nmk_config_pins - configure several pins at once
+ * @cfgs: array of pin configurations
+ * @num: number of elments in the array
+ *
+ * Configures several pins using nmk_config_pin().  Refer to that function for
+ * further information.
+ */
+int nmk_config_pins(pin_cfg_t *cfgs, int num)
+{
+        return __nmk_config_pins(cfgs, num, false);
+}
+EXPORT_SYMBOL(nmk_config_pins);
+
+int nmk_config_pins_sleep(pin_cfg_t *cfgs, int num)
+{
+        return __nmk_config_pins(cfgs, num, true);
+}
+EXPORT_SYMBOL(nmk_config_pins_sleep);
+
+/**
+ * nmk_gpio_set_slpm() - configure the sleep mode of a pin
+ * @gpio: pin number
+ * @mode: NMK_GPIO_SLPM_INPUT or NMK_GPIO_SLPM_NOCHANGE,
+ *
+ * Sets the sleep mode of a pin.  If @mode is NMK_GPIO_SLPM_INPUT, the pin is
+ * changed to an input (with pullup/down enabled) in sleep and deep sleep.  If
+ * @mode is NMK_GPIO_SLPM_NOCHANGE, the pin remains in the state it was
+ * configured even when in sleep and deep sleep.
+ *
+ * On DB8500v2 onwards, this setting loses the previous meaning and instead
+ * indicates if wakeup detection is enabled on the pin.  Note that
+ * enable_irq_wake() will automatically enable wakeup detection.
+ */
+int nmk_gpio_set_slpm(int gpio, enum nmk_gpio_slpm mode)
+{
+        struct nmk_gpio_chip *nmk_chip;
+        unsigned long flags;
+
+        nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+        if (!nmk_chip)
+                return -EINVAL;
+
+        spin_lock_irqsave(&nmk_gpio_slpm_lock, flags);
+        spin_lock(&nmk_chip->lock);
+
+        __nmk_gpio_set_slpm(nmk_chip, gpio - nmk_chip->chip.base, mode);
+
+        spin_unlock(&nmk_chip->lock);
+        spin_unlock_irqrestore(&nmk_gpio_slpm_lock, flags);
+
+        return 0;
+}
+
+/**
+ * nmk_gpio_set_pull() - enable/disable pull up/down on a gpio
+ * @gpio: pin number
+ * @pull: one of NMK_GPIO_PULL_DOWN, NMK_GPIO_PULL_UP, and NMK_GPIO_PULL_NONE
+ *
+ * Enables/disables pull up/down on a specified pin.  This only takes effect if
+ * the pin is configured as an input (either explicitly or by the alternate
+ * function).
+ *
+ * NOTE: If enabling the pull up/down, the caller must ensure that the GPIO is
+ * configured as an input.  Otherwise, due to the way the controller registers
+ * work, this function will change the value output on the pin.
+ */
+int nmk_gpio_set_pull(int gpio, enum nmk_gpio_pull pull)
+{
+        struct nmk_gpio_chip *nmk_chip;
+        unsigned long flags;
+
+        nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+        if (!nmk_chip)
+                return -EINVAL;
+
+        spin_lock_irqsave(&nmk_chip->lock, flags);
+        __nmk_gpio_set_pull(nmk_chip, gpio - nmk_chip->chip.base, pull);
+        spin_unlock_irqrestore(&nmk_chip->lock, flags);
+
+        return 0;
+}
+
+/* Mode functions */
+/**
+ * nmk_gpio_set_mode() - set the mux mode of a gpio pin
+ * @gpio: pin number
+ * @gpio_mode: one of NMK_GPIO_ALT_GPIO, NMK_GPIO_ALT_A,
+ *             NMK_GPIO_ALT_B, and NMK_GPIO_ALT_C
+ *
+ * Sets the mode of the specified pin to one of the alternate functions or
+ * plain GPIO.
+ */
+int nmk_gpio_set_mode(int gpio, int gpio_mode)
+{
+        struct nmk_gpio_chip *nmk_chip;
+        unsigned long flags;
+
+        nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+        if (!nmk_chip)
+                return -EINVAL;
+
+        spin_lock_irqsave(&nmk_chip->lock, flags);
+        __nmk_gpio_set_mode(nmk_chip, gpio - nmk_chip->chip.base, gpio_mode);
+        spin_unlock_irqrestore(&nmk_chip->lock, flags);
+
+        return 0;
+}
+EXPORT_SYMBOL(nmk_gpio_set_mode);
+
+int nmk_gpio_get_mode(int gpio)
+{
+        struct nmk_gpio_chip *nmk_chip;
+        u32 afunc, bfunc, bit;
+
+        nmk_chip = irq_get_chip_data(NOMADIK_GPIO_TO_IRQ(gpio));
+        if (!nmk_chip)
+                return -EINVAL;
+
+        bit = 1 << (gpio - nmk_chip->chip.base);
+
+        afunc = readl(nmk_chip->addr + NMK_GPIO_AFSLA) & bit;
+        bfunc = readl(nmk_chip->addr + NMK_GPIO_AFSLB) & bit;
+
+        return (afunc ? NMK_GPIO_ALT_A : 0) | (bfunc ? NMK_GPIO_ALT_B : 0);
+}
+EXPORT_SYMBOL(nmk_gpio_get_mode);
+
+
+/* IRQ functions */
+static inline int nmk_gpio_get_bitmask(int gpio)
+{
+        return 1 << (gpio % 32);
+}
+
+static void nmk_gpio_irq_ack(struct irq_data *d)
+{
+        int gpio;
+        struct nmk_gpio_chip *nmk_chip;
+
+        gpio = NOMADIK_IRQ_TO_GPIO(d->irq);
+        nmk_chip = irq_data_get_irq_chip_data(d);
+        if (!nmk_chip)
+                return;
+        writel(nmk_gpio_get_bitmask(gpio), nmk_chip->addr + NMK_GPIO_IC);
+}
+
+enum nmk_gpio_irq_type {
+        NORMAL,
+        WAKE,
+};
+
+static void __nmk_gpio_irq_modify(struct nmk_gpio_chip *nmk_chip,
+                                  int gpio, enum nmk_gpio_irq_type which,
+                                  bool enable)
+{
+        u32 rimsc = which == WAKE ? NMK_GPIO_RWIMSC : NMK_GPIO_RIMSC;
+        u32 fimsc = which == WAKE ? NMK_GPIO_FWIMSC : NMK_GPIO_FIMSC;
+        u32 bitmask = nmk_gpio_get_bitmask(gpio);
+        u32 reg;
+
+        /* we must individually set/clear the two edges */
+        if (nmk_chip->edge_rising & bitmask) {
+                reg = readl(nmk_chip->addr + rimsc);
+                if (enable)
+                        reg |= bitmask;
+                else
+                        reg &= ~bitmask;
+                writel(reg, nmk_chip->addr + rimsc);
+        }
+        if (nmk_chip->edge_falling & bitmask) {
+                reg = readl(nmk_chip->addr + fimsc);
+                if (enable)
+                        reg |= bitmask;
+                else
+                        reg &= ~bitmask;
+                writel(reg, nmk_chip->addr + fimsc);
+        }
+}
+
+static void __nmk_gpio_set_wake(struct nmk_gpio_chip *nmk_chip,
+                                int gpio, bool on)
+{
+        __nmk_gpio_irq_modify(nmk_chip, gpio, WAKE, on);
+}
+
+static int nmk_gpio_irq_maskunmask(struct irq_data *d, bool enable)
+{
+        int gpio;
+        struct nmk_gpio_chip *nmk_chip;
+        unsigned long flags;
+        u32 bitmask;
+
+        gpio = NOMADIK_IRQ_TO_GPIO(d->irq);
+        nmk_chip = irq_data_get_irq_chip_data(d);
+        bitmask = nmk_gpio_get_bitmask(gpio);
+        if (!nmk_chip)
+                return -EINVAL;
+
+        if (enable)
+                nmk_chip->enabled |= bitmask;
+        else
+                nmk_chip->enabled &= ~bitmask;
+
+        spin_lock_irqsave(&nmk_gpio_slpm_lock, flags);
+        spin_lock(&nmk_chip->lock);
+
+        __nmk_gpio_irq_modify(nmk_chip, gpio, NORMAL, enable);
+
+        if (!(nmk_chip->real_wake & bitmask))
+                __nmk_gpio_set_wake(nmk_chip, gpio, enable);
+
+        spin_unlock(&nmk_chip->lock);
+        spin_unlock_irqrestore(&nmk_gpio_slpm_lock, flags);
+
+        return 0;
+}
+
+static void nmk_gpio_irq_mask(struct irq_data *d)
+{
+        nmk_gpio_irq_maskunmask(d, false);
+}
+
+static void nmk_gpio_irq_unmask(struct irq_data *d)
+{
+        nmk_gpio_irq_maskunmask(d, true);
+}
+
+static int nmk_gpio_irq_set_wake(struct irq_data *d, unsigned int on)
+{
+        struct nmk_gpio_chip *nmk_chip;
+        unsigned long flags;
+        u32 bitmask;
+        int gpio;
+
+        gpio = NOMADIK_IRQ_TO_GPIO(d->irq);
+        nmk_chip = irq_data_get_irq_chip_data(d);
+        if (!nmk_chip)
+                return -EINVAL;
+        bitmask = nmk_gpio_get_bitmask(gpio);
+
+        spin_lock_irqsave(&nmk_gpio_slpm_lock, flags);
+        spin_lock(&nmk_chip->lock);
+
+        if (!(nmk_chip->enabled & bitmask))
+                __nmk_gpio_set_wake(nmk_chip, gpio, on);
+
+        if (on)
+                nmk_chip->real_wake |= bitmask;
+        else
+                nmk_chip->real_wake &= ~bitmask;
+
+        spin_unlock(&nmk_chip->lock);
+        spin_unlock_irqrestore(&nmk_gpio_slpm_lock, flags);
+
+        return 0;
+}
+
+static int nmk_gpio_irq_set_type(struct irq_data *d, unsigned int type)
+{
+        bool enabled, wake = irqd_is_wakeup_set(d);
+        int gpio;
+        struct nmk_gpio_chip *nmk_chip;
+        unsigned long flags;
+        u32 bitmask;
+
+        gpio = NOMADIK_IRQ_TO_GPIO(d->irq);
+        nmk_chip = irq_data_get_irq_chip_data(d);
+        bitmask = nmk_gpio_get_bitmask(gpio);
+        if (!nmk_chip)
+                return -EINVAL;
+
+        if (type & IRQ_TYPE_LEVEL_HIGH)
+                return -EINVAL;
+        if (type & IRQ_TYPE_LEVEL_LOW)
+                return -EINVAL;
+
+        enabled = nmk_chip->enabled & bitmask;
+
+        spin_lock_irqsave(&nmk_chip->lock, flags);
+
+        if (enabled)
+                __nmk_gpio_irq_modify(nmk_chip, gpio, NORMAL, false);
+
+        if (enabled || wake)
+                __nmk_gpio_irq_modify(nmk_chip, gpio, WAKE, false);
+
+        nmk_chip->edge_rising &= ~bitmask;
+        if (type & IRQ_TYPE_EDGE_RISING)
+                nmk_chip->edge_rising |= bitmask;
+
+        nmk_chip->edge_falling &= ~bitmask;
+        if (type & IRQ_TYPE_EDGE_FALLING)
+                nmk_chip->edge_falling |= bitmask;
+
+        if (enabled)
+                __nmk_gpio_irq_modify(nmk_chip, gpio, NORMAL, true);
+
+        if (enabled || wake)
+                __nmk_gpio_irq_modify(nmk_chip, gpio, WAKE, true);
+
+        spin_unlock_irqrestore(&nmk_chip->lock, flags);
+
+        return 0;
+}
+
+static struct irq_chip nmk_gpio_irq_chip = {
+        .name           = "Nomadik-GPIO",
+        .irq_ack        = nmk_gpio_irq_ack,
+        .irq_mask       = nmk_gpio_irq_mask,
+        .irq_unmask     = nmk_gpio_irq_unmask,
+        .irq_set_type   = nmk_gpio_irq_set_type,
+        .irq_set_wake   = nmk_gpio_irq_set_wake,
+};
+
+static void __nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc,
+                                   u32 status)
+{
+        struct nmk_gpio_chip *nmk_chip;
+        struct irq_chip *host_chip = irq_get_chip(irq);
+        unsigned int first_irq;
+
+        chained_irq_enter(host_chip, desc);
+
+        nmk_chip = irq_get_handler_data(irq);
+        first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
+        while (status) {
+                int bit = __ffs(status);
+
+                generic_handle_irq(first_irq + bit);
+                status &= ~BIT(bit);
+        }
+
+        chained_irq_exit(host_chip, desc);
+}
+
+static void nmk_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
+{
+        struct nmk_gpio_chip *nmk_chip = irq_get_handler_data(irq);
+        u32 status = readl(nmk_chip->addr + NMK_GPIO_IS);
+
+        __nmk_gpio_irq_handler(irq, desc, status);
+}
+
+static void nmk_gpio_secondary_irq_handler(unsigned int irq,
+                                           struct irq_desc *desc)
+{
+        struct nmk_gpio_chip *nmk_chip = irq_get_handler_data(irq);
+        u32 status = nmk_chip->get_secondary_status(nmk_chip->bank);
+
+        __nmk_gpio_irq_handler(irq, desc, status);
+}
+
+static int nmk_gpio_init_irq(struct nmk_gpio_chip *nmk_chip)
+{
+        unsigned int first_irq;
+        int i;
+
+        first_irq = NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base);
+        for (i = first_irq; i < first_irq + nmk_chip->chip.ngpio; i++) {
+                irq_set_chip_and_handler(i, &nmk_gpio_irq_chip,
+                                         handle_edge_irq);
+                set_irq_flags(i, IRQF_VALID);
+                irq_set_chip_data(i, nmk_chip);
+                irq_set_irq_type(i, IRQ_TYPE_EDGE_FALLING);
+        }
+
+        irq_set_chained_handler(nmk_chip->parent_irq, nmk_gpio_irq_handler);
+        irq_set_handler_data(nmk_chip->parent_irq, nmk_chip);
+
+        if (nmk_chip->secondary_parent_irq >= 0) {
+                irq_set_chained_handler(nmk_chip->secondary_parent_irq,
+                                        nmk_gpio_secondary_irq_handler);
+                irq_set_handler_data(nmk_chip->secondary_parent_irq, nmk_chip);
+        }
+
+        return 0;
+}
+
+/* I/O Functions */
+static int nmk_gpio_make_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct nmk_gpio_chip *nmk_chip =
+                container_of(chip, struct nmk_gpio_chip, chip);
+
+        writel(1 << offset, nmk_chip->addr + NMK_GPIO_DIRC);
+        return 0;
+}
+
+static int nmk_gpio_get_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct nmk_gpio_chip *nmk_chip =
+                container_of(chip, struct nmk_gpio_chip, chip);
+        u32 bit = 1 << offset;
+
+        return (readl(nmk_chip->addr + NMK_GPIO_DAT) & bit) != 0;
+}
+
+static void nmk_gpio_set_output(struct gpio_chip *chip, unsigned offset,
+                                int val)
+{
+        struct nmk_gpio_chip *nmk_chip =
+                container_of(chip, struct nmk_gpio_chip, chip);
+
+        __nmk_gpio_set_output(nmk_chip, offset, val);
+}
+
+static int nmk_gpio_make_output(struct gpio_chip *chip, unsigned offset,
+                                int val)
+{
+        struct nmk_gpio_chip *nmk_chip =
+                container_of(chip, struct nmk_gpio_chip, chip);
+
+        __nmk_gpio_make_output(nmk_chip, offset, val);
+
+        return 0;
+}
+
+static int nmk_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        struct nmk_gpio_chip *nmk_chip =
+                container_of(chip, struct nmk_gpio_chip, chip);
+
+        return NOMADIK_GPIO_TO_IRQ(nmk_chip->chip.base) + offset;
+}
+
+#ifdef CONFIG_DEBUG_FS
+
+#include <linux/seq_file.h>
+
+static void nmk_gpio_dbg_show(struct seq_file *s, struct gpio_chip *chip)
+{
+        int mode;
+        unsigned                i;
+        unsigned                gpio = chip->base;
+        int                     is_out;
+        struct nmk_gpio_chip *nmk_chip =
+                container_of(chip, struct nmk_gpio_chip, chip);
+        const char *modes[] = {
+                [NMK_GPIO_ALT_GPIO]     = "gpio",
+                [NMK_GPIO_ALT_A]        = "altA",
+                [NMK_GPIO_ALT_B]        = "altB",
+                [NMK_GPIO_ALT_C]        = "altC",
+        };
+
+        for (i = 0; i < chip->ngpio; i++, gpio++) {
+                const char *label = gpiochip_is_requested(chip, i);
+                bool pull;
+                u32 bit = 1 << i;
+
+                is_out = readl(nmk_chip->addr + NMK_GPIO_DIR) & bit;
+                pull = !(readl(nmk_chip->addr + NMK_GPIO_PDIS) & bit);
+                mode = nmk_gpio_get_mode(gpio);
+                seq_printf(s, " gpio-%-3d (%-20.20s) %s %s %s %s",
+                        gpio, label ?: "(none)",
+                        is_out ? "out" : "in ",
+                        chip->get
+                                ? (chip->get(chip, i) ? "hi" : "lo")
+                                : "?  ",
+                        (mode < 0) ? "unknown" : modes[mode],
+                        pull ? "pull" : "none");
+
+                if (label && !is_out) {
+                        int             irq = gpio_to_irq(gpio);
+                        struct irq_desc *desc = irq_to_desc(irq);
+
+                        /* This races with request_irq(), set_irq_type(),
+                         * and set_irq_wake() ... but those are "rare".
+                         */
+                        if (irq >= 0 && desc->action) {
+                                char *trigger;
+                                u32 bitmask = nmk_gpio_get_bitmask(gpio);
+
+                                if (nmk_chip->edge_rising & bitmask)
+                                        trigger = "edge-rising";
+                                else if (nmk_chip->edge_falling & bitmask)
+                                        trigger = "edge-falling";
+                                else
+                                        trigger = "edge-undefined";
+
+                                seq_printf(s, " irq-%d %s%s",
+                                        irq, trigger,
+                                        irqd_is_wakeup_set(&desc->irq_data)
+                                                ? " wakeup" : "");
+                        }
+                }
+
+                seq_printf(s, "\n");
+        }
+}
+
+#else
+#define nmk_gpio_dbg_show       NULL
+#endif
+
+/* This structure is replicated for each GPIO block allocated at probe time */
+static struct gpio_chip nmk_gpio_template = {
+        .direction_input        = nmk_gpio_make_input,
+        .get                    = nmk_gpio_get_input,
+        .direction_output       = nmk_gpio_make_output,
+        .set                    = nmk_gpio_set_output,
+        .to_irq                 = nmk_gpio_to_irq,
+        .dbg_show               = nmk_gpio_dbg_show,
+        .can_sleep              = 0,
+};
+
+/*
+ * Called from the suspend/resume path to only keep the real wakeup interrupts
+ * (those that have had set_irq_wake() called on them) as wakeup interrupts,
+ * and not the rest of the interrupts which we needed to have as wakeups for
+ * cpuidle.
+ *
+ * PM ops are not used since this needs to be done at the end, after all the
+ * other drivers are done with their suspend callbacks.
+ */
+void nmk_gpio_wakeups_suspend(void)
+{
+        int i;
+
+        for (i = 0; i < NUM_BANKS; i++) {
+                struct nmk_gpio_chip *chip = nmk_gpio_chips[i];
+
+                if (!chip)
+                        break;
+
+                chip->rwimsc = readl(chip->addr + NMK_GPIO_RWIMSC);
+                chip->fwimsc = readl(chip->addr + NMK_GPIO_FWIMSC);
+
+                writel(chip->rwimsc & chip->real_wake,
+                       chip->addr + NMK_GPIO_RWIMSC);
+                writel(chip->fwimsc & chip->real_wake,
+                       chip->addr + NMK_GPIO_FWIMSC);
+
+                if (cpu_is_u8500v2()) {
+                        chip->slpm = readl(chip->addr + NMK_GPIO_SLPC);
+
+                        /* 0 -> wakeup enable */
+                        writel(~chip->real_wake, chip->addr + NMK_GPIO_SLPC);
+                }
+        }
+}
+
+void nmk_gpio_wakeups_resume(void)
+{
+        int i;
+
+        for (i = 0; i < NUM_BANKS; i++) {
+                struct nmk_gpio_chip *chip = nmk_gpio_chips[i];
+
+                if (!chip)
+                        break;
+
+                writel(chip->rwimsc, chip->addr + NMK_GPIO_RWIMSC);
+                writel(chip->fwimsc, chip->addr + NMK_GPIO_FWIMSC);
+
+                if (cpu_is_u8500v2())
+                        writel(chip->slpm, chip->addr + NMK_GPIO_SLPC);
+        }
+}
+
+/*
+ * Read the pull up/pull down status.
+ * A bit set in 'pull_up' means that pull up
+ * is selected if pull is enabled in PDIS register.
+ * Note: only pull up/down set via this driver can
+ * be detected due to HW limitations.
+ */
+void nmk_gpio_read_pull(int gpio_bank, u32 *pull_up)
+{
+        if (gpio_bank < NUM_BANKS) {
+                struct nmk_gpio_chip *chip = nmk_gpio_chips[gpio_bank];
+
+                if (!chip)
+                        return;
+
+                *pull_up = chip->pull_up;
+        }
+}
+
+static int __devinit nmk_gpio_probe(struct platform_device *dev)
+{
+        struct nmk_gpio_platform_data *pdata = dev->dev.platform_data;
+        struct nmk_gpio_chip *nmk_chip;
+        struct gpio_chip *chip;
+        struct resource *res;
+        struct clk *clk;
+        int secondary_irq;
+        int irq;
+        int ret;
+
+        if (!pdata)
+                return -ENODEV;
+
+        res = platform_get_resource(dev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -ENOENT;
+                goto out;
+        }
+
+        irq = platform_get_irq(dev, 0);
+        if (irq < 0) {
+                ret = irq;
+                goto out;
+        }
+
+        secondary_irq = platform_get_irq(dev, 1);
+        if (secondary_irq >= 0 && !pdata->get_secondary_status) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        if (request_mem_region(res->start, resource_size(res),
+                               dev_name(&dev->dev)) == NULL) {
+                ret = -EBUSY;
+                goto out;
+        }
+
+        clk = clk_get(&dev->dev, NULL);
+        if (IS_ERR(clk)) {
+                ret = PTR_ERR(clk);
+                goto out_release;
+        }
+
+        clk_enable(clk);
+
+        nmk_chip = kzalloc(sizeof(*nmk_chip), GFP_KERNEL);
+        if (!nmk_chip) {
+                ret = -ENOMEM;
+                goto out_clk;
+        }
+        /*
+         * The virt address in nmk_chip->addr is in the nomadik register space,
+         * so we can simply convert the resource address, without remapping
+         */
+        nmk_chip->bank = dev->id;
+        nmk_chip->clk = clk;
+        nmk_chip->addr = io_p2v(res->start);
+        nmk_chip->chip = nmk_gpio_template;
+        nmk_chip->parent_irq = irq;
+        nmk_chip->secondary_parent_irq = secondary_irq;
+        nmk_chip->get_secondary_status = pdata->get_secondary_status;
+        nmk_chip->set_ioforce = pdata->set_ioforce;
+        spin_lock_init(&nmk_chip->lock);
+
+        chip = &nmk_chip->chip;
+        chip->base = pdata->first_gpio;
+        chip->ngpio = pdata->num_gpio;
+        chip->label = pdata->name ?: dev_name(&dev->dev);
+        chip->dev = &dev->dev;
+        chip->owner = THIS_MODULE;
+
+        ret = gpiochip_add(&nmk_chip->chip);
+        if (ret)
+                goto out_free;
+
+        BUG_ON(nmk_chip->bank >= ARRAY_SIZE(nmk_gpio_chips));
+
+        nmk_gpio_chips[nmk_chip->bank] = nmk_chip;
+        platform_set_drvdata(dev, nmk_chip);
+
+        nmk_gpio_init_irq(nmk_chip);
+
+        dev_info(&dev->dev, "Bits %i-%i at address %p\n",
+                 nmk_chip->chip.base, nmk_chip->chip.base+31, nmk_chip->addr);
+        return 0;
+
+out_free:
+        kfree(nmk_chip);
+out_clk:
+        clk_disable(clk);
+        clk_put(clk);
+out_release:
+        release_mem_region(res->start, resource_size(res));
+out:
+        dev_err(&dev->dev, "Failure %i for GPIO %i-%i\n", ret,
+                  pdata->first_gpio, pdata->first_gpio+31);
+        return ret;
+}
+
+static struct platform_driver nmk_gpio_driver = {
+        .driver = {
+                .owner = THIS_MODULE,
+                .name = "gpio",
+        },
+        .probe = nmk_gpio_probe,
+};
+
+static int __init nmk_gpio_init(void)
+{
+        return platform_driver_register(&nmk_gpio_driver);
+}
+
+core_initcall(nmk_gpio_init);
+
+MODULE_AUTHOR("Prafulla WADASKAR and Alessandro Rubini");
+MODULE_DESCRIPTION("Nomadik GPIO Driver");
+MODULE_LICENSE("GPL");
+
+
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
new file mode 100644
index 000000000000..6c51191da567
--- /dev/null
+++ b/drivers/gpio/gpio-omap.c
@@ -0,0 +1,2007 @@
+/*
+ * Support functions for OMAP GPIO
+ *
+ * Copyright (C) 2003-2005 Nokia Corporation
+ * Written by Juha Yrjölä <juha.yrjola@nokia.com>
+ *
+ * Copyright (C) 2009 Texas Instruments
+ * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/syscore_ops.h>
+#include <linux/err.h>
+#include <linux/clk.h>
+#include <linux/io.h>
+#include <linux/slab.h>
+#include <linux/pm_runtime.h>
+
+#include <mach/hardware.h>
+#include <asm/irq.h>
+#include <mach/irqs.h>
+#include <mach/gpio.h>
+#include <asm/mach/irq.h>
+
+struct gpio_bank {
+        unsigned long pbase;
+        void __iomem *base;
+        u16 irq;
+        u16 virtual_irq_start;
+        int method;
+#if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP2PLUS)
+        u32 suspend_wakeup;
+        u32 saved_wakeup;
+#endif
+        u32 non_wakeup_gpios;
+        u32 enabled_non_wakeup_gpios;
+
+        u32 saved_datain;
+        u32 saved_fallingdetect;
+        u32 saved_risingdetect;
+        u32 level_mask;
+        u32 toggle_mask;
+        spinlock_t lock;
+        struct gpio_chip chip;
+        struct clk *dbck;
+        u32 mod_usage;
+        u32 dbck_enable_mask;
+        struct device *dev;
+        bool dbck_flag;
+        int stride;
+};
+
+#ifdef CONFIG_ARCH_OMAP3
+struct omap3_gpio_regs {
+        u32 irqenable1;
+        u32 irqenable2;
+        u32 wake_en;
+        u32 ctrl;
+        u32 oe;
+        u32 leveldetect0;
+        u32 leveldetect1;
+        u32 risingdetect;
+        u32 fallingdetect;
+        u32 dataout;
+};
+
+static struct omap3_gpio_regs gpio_context[OMAP34XX_NR_GPIOS];
+#endif
+
+/*
+ * TODO: Cleanup gpio_bank usage as it is having information
+ * related to all instances of the device
+ */
+static struct gpio_bank *gpio_bank;
+
+static int bank_width;
+
+/* TODO: Analyze removing gpio_bank_count usage from driver code */
+int gpio_bank_count;
+
+static inline struct gpio_bank *get_gpio_bank(int gpio)
+{
+        if (cpu_is_omap15xx()) {
+                if (OMAP_GPIO_IS_MPUIO(gpio))
+                        return &gpio_bank[0];
+                return &gpio_bank[1];
+        }
+        if (cpu_is_omap16xx()) {
+                if (OMAP_GPIO_IS_MPUIO(gpio))
+                        return &gpio_bank[0];
+                return &gpio_bank[1 + (gpio >> 4)];
+        }
+        if (cpu_is_omap7xx()) {
+                if (OMAP_GPIO_IS_MPUIO(gpio))
+                        return &gpio_bank[0];
+                return &gpio_bank[1 + (gpio >> 5)];
+        }
+        if (cpu_is_omap24xx())
+                return &gpio_bank[gpio >> 5];
+        if (cpu_is_omap34xx() || cpu_is_omap44xx())
+                return &gpio_bank[gpio >> 5];
+        BUG();
+        return NULL;
+}
+
+static inline int get_gpio_index(int gpio)
+{
+        if (cpu_is_omap7xx())
+                return gpio & 0x1f;
+        if (cpu_is_omap24xx())
+                return gpio & 0x1f;
+        if (cpu_is_omap34xx() || cpu_is_omap44xx())
+                return gpio & 0x1f;
+        return gpio & 0x0f;
+}
+
+static inline int gpio_valid(int gpio)
+{
+        if (gpio < 0)
+                return -1;
+        if (cpu_class_is_omap1() && OMAP_GPIO_IS_MPUIO(gpio)) {
+                if (gpio >= OMAP_MAX_GPIO_LINES + 16)
+                        return -1;
+                return 0;
+        }
+        if (cpu_is_omap15xx() && gpio < 16)
+                return 0;
+        if ((cpu_is_omap16xx()) && gpio < 64)
+                return 0;
+        if (cpu_is_omap7xx() && gpio < 192)
+                return 0;
+        if (cpu_is_omap2420() && gpio < 128)
+                return 0;
+        if (cpu_is_omap2430() && gpio < 160)
+                return 0;
+        if ((cpu_is_omap34xx() || cpu_is_omap44xx()) && gpio < 192)
+                return 0;
+        return -1;
+}
+
+static int check_gpio(int gpio)
+{
+        if (unlikely(gpio_valid(gpio) < 0)) {
+                printk(KERN_ERR "omap-gpio: invalid GPIO %d\n", gpio);
+                dump_stack();
+                return -1;
+        }
+        return 0;
+}
+
+static void _set_gpio_direction(struct gpio_bank *bank, int gpio, int is_input)
+{
+        void __iomem *reg = bank->base;
+        u32 l;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_IO_CNTL / bank->stride;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_DIR_CONTROL;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                reg += OMAP1610_GPIO_DIRECTION;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_DIR_CONTROL;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                reg += OMAP24XX_GPIO_OE;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP4)
+        case METHOD_GPIO_44XX:
+                reg += OMAP4_GPIO_OE;
+                break;
+#endif
+        default:
+                WARN_ON(1);
+                return;
+        }
+        l = __raw_readl(reg);
+        if (is_input)
+                l |= 1 << gpio;
+        else
+                l &= ~(1 << gpio);
+        __raw_writel(l, reg);
+}
+
+static void _set_gpio_dataout(struct gpio_bank *bank, int gpio, int enable)
+{
+        void __iomem *reg = bank->base;
+        u32 l = 0;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_OUTPUT / bank->stride;
+                l = __raw_readl(reg);
+                if (enable)
+                        l |= 1 << gpio;
+                else
+                        l &= ~(1 << gpio);
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_DATA_OUTPUT;
+                l = __raw_readl(reg);
+                if (enable)
+                        l |= 1 << gpio;
+                else
+                        l &= ~(1 << gpio);
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                if (enable)
+                        reg += OMAP1610_GPIO_SET_DATAOUT;
+                else
+                        reg += OMAP1610_GPIO_CLEAR_DATAOUT;
+                l = 1 << gpio;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_DATA_OUTPUT;
+                l = __raw_readl(reg);
+                if (enable)
+                        l |= 1 << gpio;
+                else
+                        l &= ~(1 << gpio);
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                if (enable)
+                        reg += OMAP24XX_GPIO_SETDATAOUT;
+                else
+                        reg += OMAP24XX_GPIO_CLEARDATAOUT;
+                l = 1 << gpio;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+        case METHOD_GPIO_44XX:
+                if (enable)
+                        reg += OMAP4_GPIO_SETDATAOUT;
+                else
+                        reg += OMAP4_GPIO_CLEARDATAOUT;
+                l = 1 << gpio;
+                break;
+#endif
+        default:
+                WARN_ON(1);
+                return;
+        }
+        __raw_writel(l, reg);
+}
+
+static int _get_gpio_datain(struct gpio_bank *bank, int gpio)
+{
+        void __iomem *reg;
+
+        if (check_gpio(gpio) < 0)
+                return -EINVAL;
+        reg = bank->base;
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_INPUT_LATCH / bank->stride;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_DATA_INPUT;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                reg += OMAP1610_GPIO_DATAIN;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_DATA_INPUT;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                reg += OMAP24XX_GPIO_DATAIN;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+        case METHOD_GPIO_44XX:
+                reg += OMAP4_GPIO_DATAIN;
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
+        return (__raw_readl(reg)
+                        & (1 << get_gpio_index(gpio))) != 0;
+}
+
+static int _get_gpio_dataout(struct gpio_bank *bank, int gpio)
+{
+        void __iomem *reg;
+
+        if (check_gpio(gpio) < 0)
+                return -EINVAL;
+        reg = bank->base;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_OUTPUT / bank->stride;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_DATA_OUTPUT;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                reg += OMAP1610_GPIO_DATAOUT;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_DATA_OUTPUT;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                reg += OMAP24XX_GPIO_DATAOUT;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+        case METHOD_GPIO_44XX:
+                reg += OMAP4_GPIO_DATAOUT;
+                break;
+#endif
+        default:
+                return -EINVAL;
+        }
+
+        return (__raw_readl(reg) & (1 << get_gpio_index(gpio))) != 0;
+}
+
+#define MOD_REG_BIT(reg, bit_mask, set) \
+do {    \
+        int l = __raw_readl(base + reg); \
+        if (set) l |= bit_mask; \
+        else l &= ~bit_mask; \
+        __raw_writel(l, base + reg); \
+} while(0)
+
+/**
+ * _set_gpio_debounce - low level gpio debounce time
+ * @bank: the gpio bank we're acting upon
+ * @gpio: the gpio number on this @gpio
+ * @debounce: debounce time to use
+ *
+ * OMAP's debounce time is in 31us steps so we need
+ * to convert and round up to the closest unit.
+ */
+static void _set_gpio_debounce(struct gpio_bank *bank, unsigned gpio,
+                unsigned debounce)
+{
+        void __iomem            *reg = bank->base;
+        u32                     val;
+        u32                     l;
+
+        if (!bank->dbck_flag)
+                return;
+
+        if (debounce < 32)
+                debounce = 0x01;
+        else if (debounce > 7936)
+                debounce = 0xff;
+        else
+                debounce = (debounce / 0x1f) - 1;
+
+        l = 1 << get_gpio_index(gpio);
+
+        if (bank->method == METHOD_GPIO_44XX)
+                reg += OMAP4_GPIO_DEBOUNCINGTIME;
+        else
+                reg += OMAP24XX_GPIO_DEBOUNCE_VAL;
+
+        __raw_writel(debounce, reg);
+
+        reg = bank->base;
+        if (bank->method == METHOD_GPIO_44XX)
+                reg += OMAP4_GPIO_DEBOUNCENABLE;
+        else
+                reg += OMAP24XX_GPIO_DEBOUNCE_EN;
+
+        val = __raw_readl(reg);
+
+        if (debounce) {
+                val |= l;
+                clk_enable(bank->dbck);
+        } else {
+                val &= ~l;
+                clk_disable(bank->dbck);
+        }
+        bank->dbck_enable_mask = val;
+
+        __raw_writel(val, reg);
+}
+
+#ifdef CONFIG_ARCH_OMAP2PLUS
+static inline void set_24xx_gpio_triggering(struct gpio_bank *bank, int gpio,
+                                                int trigger)
+{
+        void __iomem *base = bank->base;
+        u32 gpio_bit = 1 << gpio;
+        u32 val;
+
+        if (cpu_is_omap44xx()) {
+                MOD_REG_BIT(OMAP4_GPIO_LEVELDETECT0, gpio_bit,
+                        trigger & IRQ_TYPE_LEVEL_LOW);
+                MOD_REG_BIT(OMAP4_GPIO_LEVELDETECT1, gpio_bit,
+                        trigger & IRQ_TYPE_LEVEL_HIGH);
+                MOD_REG_BIT(OMAP4_GPIO_RISINGDETECT, gpio_bit,
+                        trigger & IRQ_TYPE_EDGE_RISING);
+                MOD_REG_BIT(OMAP4_GPIO_FALLINGDETECT, gpio_bit,
+                        trigger & IRQ_TYPE_EDGE_FALLING);
+        } else {
+                MOD_REG_BIT(OMAP24XX_GPIO_LEVELDETECT0, gpio_bit,
+                        trigger & IRQ_TYPE_LEVEL_LOW);
+                MOD_REG_BIT(OMAP24XX_GPIO_LEVELDETECT1, gpio_bit,
+                        trigger & IRQ_TYPE_LEVEL_HIGH);
+                MOD_REG_BIT(OMAP24XX_GPIO_RISINGDETECT, gpio_bit,
+                        trigger & IRQ_TYPE_EDGE_RISING);
+                MOD_REG_BIT(OMAP24XX_GPIO_FALLINGDETECT, gpio_bit,
+                        trigger & IRQ_TYPE_EDGE_FALLING);
+        }
+        if (likely(!(bank->non_wakeup_gpios & gpio_bit))) {
+                if (cpu_is_omap44xx()) {
+                        if (trigger != 0)
+                                __raw_writel(1 << gpio, bank->base+
+                                                OMAP4_GPIO_IRQWAKEN0);
+                        else {
+                                val = __raw_readl(bank->base +
+                                                        OMAP4_GPIO_IRQWAKEN0);
+                                __raw_writel(val & (~(1 << gpio)), bank->base +
+                                                         OMAP4_GPIO_IRQWAKEN0);
+                        }
+                } else {
+                        /*
+                         * GPIO wakeup request can only be generated on edge
+                         * transitions
+                         */
+                        if (trigger & IRQ_TYPE_EDGE_BOTH)
+                                __raw_writel(1 << gpio, bank->base
+                                        + OMAP24XX_GPIO_SETWKUENA);
+                        else
+                                __raw_writel(1 << gpio, bank->base
+                                        + OMAP24XX_GPIO_CLEARWKUENA);
+                }
+        }
+        /* This part needs to be executed always for OMAP34xx */
+        if (cpu_is_omap34xx() || (bank->non_wakeup_gpios & gpio_bit)) {
+                /*
+                 * Log the edge gpio and manually trigger the IRQ
+                 * after resume if the input level changes
+                 * to avoid irq lost during PER RET/OFF mode
+                 * Applies for omap2 non-wakeup gpio and all omap3 gpios
+                 */
+                if (trigger & IRQ_TYPE_EDGE_BOTH)
+                        bank->enabled_non_wakeup_gpios |= gpio_bit;
+                else
+                        bank->enabled_non_wakeup_gpios &= ~gpio_bit;
+        }
+
+        if (cpu_is_omap44xx()) {
+                bank->level_mask =
+                        __raw_readl(bank->base + OMAP4_GPIO_LEVELDETECT0) |
+                        __raw_readl(bank->base + OMAP4_GPIO_LEVELDETECT1);
+        } else {
+                bank->level_mask =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT0) |
+                        __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT1);
+        }
+}
+#endif
+
+#ifdef CONFIG_ARCH_OMAP1
+/*
+ * This only applies to chips that can't do both rising and falling edge
+ * detection at once.  For all other chips, this function is a noop.
+ */
+static void _toggle_gpio_edge_triggering(struct gpio_bank *bank, int gpio)
+{
+        void __iomem *reg = bank->base;
+        u32 l = 0;
+
+        switch (bank->method) {
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_GPIO_INT_EDGE / bank->stride;
+                break;
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_INT_CONTROL;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_INT_CONTROL;
+                break;
+#endif
+        default:
+                return;
+        }
+
+        l = __raw_readl(reg);
+        if ((l >> gpio) & 1)
+                l &= ~(1 << gpio);
+        else
+                l |= 1 << gpio;
+
+        __raw_writel(l, reg);
+}
+#endif
+
+static int _set_gpio_triggering(struct gpio_bank *bank, int gpio, int trigger)
+{
+        void __iomem *reg = bank->base;
+        u32 l = 0;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_GPIO_INT_EDGE / bank->stride;
+                l = __raw_readl(reg);
+                if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
+                        bank->toggle_mask |= 1 << gpio;
+                if (trigger & IRQ_TYPE_EDGE_RISING)
+                        l |= 1 << gpio;
+                else if (trigger & IRQ_TYPE_EDGE_FALLING)
+                        l &= ~(1 << gpio);
+                else
+                        goto bad;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_INT_CONTROL;
+                l = __raw_readl(reg);
+                if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
+                        bank->toggle_mask |= 1 << gpio;
+                if (trigger & IRQ_TYPE_EDGE_RISING)
+                        l |= 1 << gpio;
+                else if (trigger & IRQ_TYPE_EDGE_FALLING)
+                        l &= ~(1 << gpio);
+                else
+                        goto bad;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                if (gpio & 0x08)
+                        reg += OMAP1610_GPIO_EDGE_CTRL2;
+                else
+                        reg += OMAP1610_GPIO_EDGE_CTRL1;
+                gpio &= 0x07;
+                l = __raw_readl(reg);
+                l &= ~(3 << (gpio << 1));
+                if (trigger & IRQ_TYPE_EDGE_RISING)
+                        l |= 2 << (gpio << 1);
+                if (trigger & IRQ_TYPE_EDGE_FALLING)
+                        l |= 1 << (gpio << 1);
+                if (trigger)
+                        /* Enable wake-up during idle for dynamic tick */
+                        __raw_writel(1 << gpio, bank->base + OMAP1610_GPIO_SET_WAKEUPENA);
+                else
+                        __raw_writel(1 << gpio, bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA);
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_INT_CONTROL;
+                l = __raw_readl(reg);
+                if ((trigger & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH)
+                        bank->toggle_mask |= 1 << gpio;
+                if (trigger & IRQ_TYPE_EDGE_RISING)
+                        l |= 1 << gpio;
+                else if (trigger & IRQ_TYPE_EDGE_FALLING)
+                        l &= ~(1 << gpio);
+                else
+                        goto bad;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP2PLUS
+        case METHOD_GPIO_24XX:
+        case METHOD_GPIO_44XX:
+                set_24xx_gpio_triggering(bank, gpio, trigger);
+                return 0;
+#endif
+        default:
+                goto bad;
+        }
+        __raw_writel(l, reg);
+        return 0;
+bad:
+        return -EINVAL;
+}
+
+static int gpio_irq_type(struct irq_data *d, unsigned type)
+{
+        struct gpio_bank *bank;
+        unsigned gpio;
+        int retval;
+        unsigned long flags;
+
+        if (!cpu_class_is_omap2() && d->irq > IH_MPUIO_BASE)
+                gpio = OMAP_MPUIO(d->irq - IH_MPUIO_BASE);
+        else
+                gpio = d->irq - IH_GPIO_BASE;
+
+        if (check_gpio(gpio) < 0)
+                return -EINVAL;
+
+        if (type & ~IRQ_TYPE_SENSE_MASK)
+                return -EINVAL;
+
+        /* OMAP1 allows only only edge triggering */
+        if (!cpu_class_is_omap2()
+                        && (type & (IRQ_TYPE_LEVEL_LOW|IRQ_TYPE_LEVEL_HIGH)))
+                return -EINVAL;
+
+        bank = irq_data_get_irq_chip_data(d);
+        spin_lock_irqsave(&bank->lock, flags);
+        retval = _set_gpio_triggering(bank, get_gpio_index(gpio), type);
+        spin_unlock_irqrestore(&bank->lock, flags);
+
+        if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
+                __irq_set_handler_locked(d->irq, handle_level_irq);
+        else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
+                __irq_set_handler_locked(d->irq, handle_edge_irq);
+
+        return retval;
+}
+
+static void _clear_gpio_irqbank(struct gpio_bank *bank, int gpio_mask)
+{
+        void __iomem *reg = bank->base;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                /* MPUIO irqstatus is reset by reading the status register,
+                 * so do nothing here */
+                return;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_INT_STATUS;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                reg += OMAP1610_GPIO_IRQSTATUS1;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_INT_STATUS;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                reg += OMAP24XX_GPIO_IRQSTATUS1;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP4)
+        case METHOD_GPIO_44XX:
+                reg += OMAP4_GPIO_IRQSTATUS0;
+                break;
+#endif
+        default:
+                WARN_ON(1);
+                return;
+        }
+        __raw_writel(gpio_mask, reg);
+
+        /* Workaround for clearing DSP GPIO interrupts to allow retention */
+        if (cpu_is_omap24xx() || cpu_is_omap34xx())
+                reg = bank->base + OMAP24XX_GPIO_IRQSTATUS2;
+        else if (cpu_is_omap44xx())
+                reg = bank->base + OMAP4_GPIO_IRQSTATUS1;
+
+        if (cpu_is_omap24xx() || cpu_is_omap34xx() || cpu_is_omap44xx()) {
+                __raw_writel(gpio_mask, reg);
+
+        /* Flush posted write for the irq status to avoid spurious interrupts */
+        __raw_readl(reg);
+        }
+}
+
+static inline void _clear_gpio_irqstatus(struct gpio_bank *bank, int gpio)
+{
+        _clear_gpio_irqbank(bank, 1 << get_gpio_index(gpio));
+}
+
+static u32 _get_gpio_irqbank_mask(struct gpio_bank *bank)
+{
+        void __iomem *reg = bank->base;
+        int inv = 0;
+        u32 l;
+        u32 mask;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_GPIO_MASKIT / bank->stride;
+                mask = 0xffff;
+                inv = 1;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_INT_MASK;
+                mask = 0xffff;
+                inv = 1;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                reg += OMAP1610_GPIO_IRQENABLE1;
+                mask = 0xffff;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_INT_MASK;
+                mask = 0xffffffff;
+                inv = 1;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                reg += OMAP24XX_GPIO_IRQENABLE1;
+                mask = 0xffffffff;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP4)
+        case METHOD_GPIO_44XX:
+                reg += OMAP4_GPIO_IRQSTATUSSET0;
+                mask = 0xffffffff;
+                break;
+#endif
+        default:
+                WARN_ON(1);
+                return 0;
+        }
+
+        l = __raw_readl(reg);
+        if (inv)
+                l = ~l;
+        l &= mask;
+        return l;
+}
+
+static void _enable_gpio_irqbank(struct gpio_bank *bank, int gpio_mask, int enable)
+{
+        void __iomem *reg = bank->base;
+        u32 l;
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP1
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_GPIO_MASKIT / bank->stride;
+                l = __raw_readl(reg);
+                if (enable)
+                        l &= ~(gpio_mask);
+                else
+                        l |= gpio_mask;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_INT_MASK;
+                l = __raw_readl(reg);
+                if (enable)
+                        l &= ~(gpio_mask);
+                else
+                        l |= gpio_mask;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_GPIO_1610:
+                if (enable)
+                        reg += OMAP1610_GPIO_SET_IRQENABLE1;
+                else
+                        reg += OMAP1610_GPIO_CLEAR_IRQENABLE1;
+                l = gpio_mask;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_INT_MASK;
+                l = __raw_readl(reg);
+                if (enable)
+                        l &= ~(gpio_mask);
+                else
+                        l |= gpio_mask;
+                break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        case METHOD_GPIO_24XX:
+                if (enable)
+                        reg += OMAP24XX_GPIO_SETIRQENABLE1;
+                else
+                        reg += OMAP24XX_GPIO_CLEARIRQENABLE1;
+                l = gpio_mask;
+                break;
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+        case METHOD_GPIO_44XX:
+                if (enable)
+                        reg += OMAP4_GPIO_IRQSTATUSSET0;
+                else
+                        reg += OMAP4_GPIO_IRQSTATUSCLR0;
+                l = gpio_mask;
+                break;
+#endif
+        default:
+                WARN_ON(1);
+                return;
+        }
+        __raw_writel(l, reg);
+}
+
+static inline void _set_gpio_irqenable(struct gpio_bank *bank, int gpio, int enable)
+{
+        _enable_gpio_irqbank(bank, 1 << get_gpio_index(gpio), enable);
+}
+
+/*
+ * Note that ENAWAKEUP needs to be enabled in GPIO_SYSCONFIG register.
+ * 1510 does not seem to have a wake-up register. If JTAG is connected
+ * to the target, system will wake up always on GPIO events. While
+ * system is running all registered GPIO interrupts need to have wake-up
+ * enabled. When system is suspended, only selected GPIO interrupts need
+ * to have wake-up enabled.
+ */
+static int _set_gpio_wakeup(struct gpio_bank *bank, int gpio, int enable)
+{
+        unsigned long uninitialized_var(flags);
+
+        switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP16XX
+        case METHOD_MPUIO:
+        case METHOD_GPIO_1610:
+                spin_lock_irqsave(&bank->lock, flags);
+                if (enable)
+                        bank->suspend_wakeup |= (1 << gpio);
+                else
+                        bank->suspend_wakeup &= ~(1 << gpio);
+                spin_unlock_irqrestore(&bank->lock, flags);
+                return 0;
+#endif
+#ifdef CONFIG_ARCH_OMAP2PLUS
+        case METHOD_GPIO_24XX:
+        case METHOD_GPIO_44XX:
+                if (bank->non_wakeup_gpios & (1 << gpio)) {
+                        printk(KERN_ERR "Unable to modify wakeup on "
+                                        "non-wakeup GPIO%d\n",
+                                        (bank - gpio_bank) * 32 + gpio);
+                        return -EINVAL;
+                }
+                spin_lock_irqsave(&bank->lock, flags);
+                if (enable)
+                        bank->suspend_wakeup |= (1 << gpio);
+                else
+                        bank->suspend_wakeup &= ~(1 << gpio);
+                spin_unlock_irqrestore(&bank->lock, flags);
+                return 0;
+#endif
+        default:
+                printk(KERN_ERR "Can't enable GPIO wakeup for method %i\n",
+                       bank->method);
+                return -EINVAL;
+        }
+}
+
+static void _reset_gpio(struct gpio_bank *bank, int gpio)
+{
+        _set_gpio_direction(bank, get_gpio_index(gpio), 1);
+        _set_gpio_irqenable(bank, gpio, 0);
+        _clear_gpio_irqstatus(bank, gpio);
+        _set_gpio_triggering(bank, get_gpio_index(gpio), IRQ_TYPE_NONE);
+}
+
+/* Use disable_irq_wake() and enable_irq_wake() functions from drivers */
+static int gpio_wake_enable(struct irq_data *d, unsigned int enable)
+{
+        unsigned int gpio = d->irq - IH_GPIO_BASE;
+        struct gpio_bank *bank;
+        int retval;
+
+        if (check_gpio(gpio) < 0)
+                return -ENODEV;
+        bank = irq_data_get_irq_chip_data(d);
+        retval = _set_gpio_wakeup(bank, get_gpio_index(gpio), enable);
+
+        return retval;
+}
+
+static int omap_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        struct gpio_bank *bank = container_of(chip, struct gpio_bank, chip);
+        unsigned long flags;
+
+        spin_lock_irqsave(&bank->lock, flags);
+
+        /* Set trigger to none. You need to enable the desired trigger with
+         * request_irq() or set_irq_type().
+         */
+        _set_gpio_triggering(bank, offset, IRQ_TYPE_NONE);
+
+#ifdef CONFIG_ARCH_OMAP15XX
+        if (bank->method == METHOD_GPIO_1510) {
+                void __iomem *reg;
+
+                /* Claim the pin for MPU */
+                reg = bank->base + OMAP1510_GPIO_PIN_CONTROL;
+                __raw_writel(__raw_readl(reg) | (1 << offset), reg);
+        }
+#endif
+        if (!cpu_class_is_omap1()) {
+                if (!bank->mod_usage) {
+                        void __iomem *reg = bank->base;
+                        u32 ctrl;
+
+                        if (cpu_is_omap24xx() || cpu_is_omap34xx())
+                                reg += OMAP24XX_GPIO_CTRL;
+                        else if (cpu_is_omap44xx())
+                                reg += OMAP4_GPIO_CTRL;
+                        ctrl = __raw_readl(reg);
+                        /* Module is enabled, clocks are not gated */
+                        ctrl &= 0xFFFFFFFE;
+                        __raw_writel(ctrl, reg);
+                }
+                bank->mod_usage |= 1 << offset;
+        }
+        spin_unlock_irqrestore(&bank->lock, flags);
+
+        return 0;
+}
+
+static void omap_gpio_free(struct gpio_chip *chip, unsigned offset)
+{
+        struct gpio_bank *bank = container_of(chip, struct gpio_bank, chip);
+        unsigned long flags;
+
+        spin_lock_irqsave(&bank->lock, flags);
+#ifdef CONFIG_ARCH_OMAP16XX
+        if (bank->method == METHOD_GPIO_1610) {
+                /* Disable wake-up during idle for dynamic tick */
+                void __iomem *reg = bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA;
+                __raw_writel(1 << offset, reg);
+        }
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        if (bank->method == METHOD_GPIO_24XX) {
+                /* Disable wake-up during idle for dynamic tick */
+                void __iomem *reg = bank->base + OMAP24XX_GPIO_CLEARWKUENA;
+                __raw_writel(1 << offset, reg);
+        }
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+        if (bank->method == METHOD_GPIO_44XX) {
+                /* Disable wake-up during idle for dynamic tick */
+                void __iomem *reg = bank->base + OMAP4_GPIO_IRQWAKEN0;
+                __raw_writel(1 << offset, reg);
+        }
+#endif
+        if (!cpu_class_is_omap1()) {
+                bank->mod_usage &= ~(1 << offset);
+                if (!bank->mod_usage) {
+                        void __iomem *reg = bank->base;
+                        u32 ctrl;
+
+                        if (cpu_is_omap24xx() || cpu_is_omap34xx())
+                                reg += OMAP24XX_GPIO_CTRL;
+                        else if (cpu_is_omap44xx())
+                                reg += OMAP4_GPIO_CTRL;
+                        ctrl = __raw_readl(reg);
+                        /* Module is disabled, clocks are gated */
+                        ctrl |= 1;
+                        __raw_writel(ctrl, reg);
+                }
+        }
+        _reset_gpio(bank, bank->chip.base + offset);
+        spin_unlock_irqrestore(&bank->lock, flags);
+}
+
+/*
+ * We need to unmask the GPIO bank interrupt as soon as possible to
+ * avoid missing GPIO interrupts for other lines in the bank.
+ * Then we need to mask-read-clear-unmask the triggered GPIO lines
+ * in the bank to avoid missing nested interrupts for a GPIO line.
+ * If we wait to unmask individual GPIO lines in the bank after the
+ * line's interrupt handler has been run, we may miss some nested
+ * interrupts.
+ */
+static void gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
+{
+        void __iomem *isr_reg = NULL;
+        u32 isr;
+        unsigned int gpio_irq, gpio_index;
+        struct gpio_bank *bank;
+        u32 retrigger = 0;
+        int unmasked = 0;
+        struct irq_chip *chip = irq_desc_get_chip(desc);
+
+        chained_irq_enter(chip, desc);
+
+        bank = irq_get_handler_data(irq);
+#ifdef CONFIG_ARCH_OMAP1
+        if (bank->method == METHOD_MPUIO)
+                isr_reg = bank->base +
+                                OMAP_MPUIO_GPIO_INT / bank->stride;
+#endif
+#ifdef CONFIG_ARCH_OMAP15XX
+        if (bank->method == METHOD_GPIO_1510)
+                isr_reg = bank->base + OMAP1510_GPIO_INT_STATUS;
+#endif
+#if defined(CONFIG_ARCH_OMAP16XX)
+        if (bank->method == METHOD_GPIO_1610)
+                isr_reg = bank->base + OMAP1610_GPIO_IRQSTATUS1;
+#endif
+#if defined(CONFIG_ARCH_OMAP730) || defined(CONFIG_ARCH_OMAP850)
+        if (bank->method == METHOD_GPIO_7XX)
+                isr_reg = bank->base + OMAP7XX_GPIO_INT_STATUS;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+        if (bank->method == METHOD_GPIO_24XX)
+                isr_reg = bank->base + OMAP24XX_GPIO_IRQSTATUS1;
+#endif
+#if defined(CONFIG_ARCH_OMAP4)
+        if (bank->method == METHOD_GPIO_44XX)
+                isr_reg = bank->base + OMAP4_GPIO_IRQSTATUS0;
+#endif
+
+        if (WARN_ON(!isr_reg))
+                goto exit;
+
+        while(1) {
+                u32 isr_saved, level_mask = 0;
+                u32 enabled;
+
+                enabled = _get_gpio_irqbank_mask(bank);
+                isr_saved = isr = __raw_readl(isr_reg) & enabled;
+
+                if (cpu_is_omap15xx() && (bank->method == METHOD_MPUIO))
+                        isr &= 0x0000ffff;
+
+                if (cpu_class_is_omap2()) {
+                        level_mask = bank->level_mask & enabled;
+                }
+
+                /* clear edge sensitive interrupts before handler(s) are
+                called so that we don't miss any interrupt occurred while
+                executing them */
+                _enable_gpio_irqbank(bank, isr_saved & ~level_mask, 0);
+                _clear_gpio_irqbank(bank, isr_saved & ~level_mask);
+                _enable_gpio_irqbank(bank, isr_saved & ~level_mask, 1);
+
+                /* if there is only edge sensitive GPIO pin interrupts
+                configured, we could unmask GPIO bank interrupt immediately */
+                if (!level_mask && !unmasked) {
+                        unmasked = 1;
+                        chained_irq_exit(chip, desc);
+                }
+
+                isr |= retrigger;
+                retrigger = 0;
+                if (!isr)
+                        break;
+
+                gpio_irq = bank->virtual_irq_start;
+                for (; isr != 0; isr >>= 1, gpio_irq++) {
+                        gpio_index = get_gpio_index(irq_to_gpio(gpio_irq));
+
+                        if (!(isr & 1))
+                                continue;
+
+#ifdef CONFIG_ARCH_OMAP1
+                        /*
+                         * Some chips can't respond to both rising and falling
+                         * at the same time.  If this irq was requested with
+                         * both flags, we need to flip the ICR data for the IRQ
+                         * to respond to the IRQ for the opposite direction.
+                         * This will be indicated in the bank toggle_mask.
+                         */
+                        if (bank->toggle_mask & (1 << gpio_index))
+                                _toggle_gpio_edge_triggering(bank, gpio_index);
+#endif
+
+                        generic_handle_irq(gpio_irq);
+                }
+        }
+        /* if bank has any level sensitive GPIO pin interrupt
+        configured, we must unmask the bank interrupt only after
+        handler(s) are executed in order to avoid spurious bank
+        interrupt */
+exit:
+        if (!unmasked)
+                chained_irq_exit(chip, desc);
+}
+
+static void gpio_irq_shutdown(struct irq_data *d)
+{
+        unsigned int gpio = d->irq - IH_GPIO_BASE;
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+
+        _reset_gpio(bank, gpio);
+}
+
+static void gpio_ack_irq(struct irq_data *d)
+{
+        unsigned int gpio = d->irq - IH_GPIO_BASE;
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+
+        _clear_gpio_irqstatus(bank, gpio);
+}
+
+static void gpio_mask_irq(struct irq_data *d)
+{
+        unsigned int gpio = d->irq - IH_GPIO_BASE;
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+
+        _set_gpio_irqenable(bank, gpio, 0);
+        _set_gpio_triggering(bank, get_gpio_index(gpio), IRQ_TYPE_NONE);
+}
+
+static void gpio_unmask_irq(struct irq_data *d)
+{
+        unsigned int gpio = d->irq - IH_GPIO_BASE;
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+        unsigned int irq_mask = 1 << get_gpio_index(gpio);
+        u32 trigger = irqd_get_trigger_type(d);
+
+        if (trigger)
+                _set_gpio_triggering(bank, get_gpio_index(gpio), trigger);
+
+        /* For level-triggered GPIOs, the clearing must be done after
+         * the HW source is cleared, thus after the handler has run */
+        if (bank->level_mask & irq_mask) {
+                _set_gpio_irqenable(bank, gpio, 0);
+                _clear_gpio_irqstatus(bank, gpio);
+        }
+
+        _set_gpio_irqenable(bank, gpio, 1);
+}
+
+static struct irq_chip gpio_irq_chip = {
+        .name           = "GPIO",
+        .irq_shutdown   = gpio_irq_shutdown,
+        .irq_ack        = gpio_ack_irq,
+        .irq_mask       = gpio_mask_irq,
+        .irq_unmask     = gpio_unmask_irq,
+        .irq_set_type   = gpio_irq_type,
+        .irq_set_wake   = gpio_wake_enable,
+};
+
+/*---------------------------------------------------------------------*/
+
+#ifdef CONFIG_ARCH_OMAP1
+
+/* MPUIO uses the always-on 32k clock */
+
+static void mpuio_ack_irq(struct irq_data *d)
+{
+        /* The ISR is reset automatically, so do nothing here. */
+}
+
+static void mpuio_mask_irq(struct irq_data *d)
+{
+        unsigned int gpio = OMAP_MPUIO(d->irq - IH_MPUIO_BASE);
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+
+        _set_gpio_irqenable(bank, gpio, 0);
+}
+
+static void mpuio_unmask_irq(struct irq_data *d)
+{
+        unsigned int gpio = OMAP_MPUIO(d->irq - IH_MPUIO_BASE);
+        struct gpio_bank *bank = irq_data_get_irq_chip_data(d);
+
+        _set_gpio_irqenable(bank, gpio, 1);
+}
+
+static struct irq_chip mpuio_irq_chip = {
+        .name           = "MPUIO",
+        .irq_ack        = mpuio_ack_irq,
+        .irq_mask       = mpuio_mask_irq,
+        .irq_unmask     = mpuio_unmask_irq,
+        .irq_set_type   = gpio_irq_type,
+#ifdef CONFIG_ARCH_OMAP16XX
+        /* REVISIT: assuming only 16xx supports MPUIO wake events */
+        .irq_set_wake   = gpio_wake_enable,
+#endif
+};
+
+
+#define bank_is_mpuio(bank)     ((bank)->method == METHOD_MPUIO)
+
+
+#ifdef CONFIG_ARCH_OMAP16XX
+
+#include <linux/platform_device.h>
+
+static int omap_mpuio_suspend_noirq(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct gpio_bank        *bank = platform_get_drvdata(pdev);
+        void __iomem            *mask_reg = bank->base +
+                                        OMAP_MPUIO_GPIO_MASKIT / bank->stride;
+        unsigned long           flags;
+
+        spin_lock_irqsave(&bank->lock, flags);
+        bank->saved_wakeup = __raw_readl(mask_reg);
+        __raw_writel(0xffff & ~bank->suspend_wakeup, mask_reg);
+        spin_unlock_irqrestore(&bank->lock, flags);
+
+        return 0;
+}
+
+static int omap_mpuio_resume_noirq(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct gpio_bank        *bank = platform_get_drvdata(pdev);
+        void __iomem            *mask_reg = bank->base +
+                                        OMAP_MPUIO_GPIO_MASKIT / bank->stride;
+        unsigned long           flags;
+
+        spin_lock_irqsave(&bank->lock, flags);
+        __raw_writel(bank->saved_wakeup, mask_reg);
+        spin_unlock_irqrestore(&bank->lock, flags);
+
+        return 0;
+}
+
+static const struct dev_pm_ops omap_mpuio_dev_pm_ops = {
+        .suspend_noirq = omap_mpuio_suspend_noirq,
+        .resume_noirq = omap_mpuio_resume_noirq,
+};
+
+/* use platform_driver for this. */
+static struct platform_driver omap_mpuio_driver = {
+        .driver         = {
+                .name   = "mpuio",
+                .pm     = &omap_mpuio_dev_pm_ops,
+        },
+};
+
+static struct platform_device omap_mpuio_device = {
+        .name           = "mpuio",
+        .id             = -1,
+        .dev = {
+                .driver = &omap_mpuio_driver.driver,
+        }
+        /* could list the /proc/iomem resources */
+};
+
+static inline void mpuio_init(void)
+{
+        struct gpio_bank *bank = get_gpio_bank(OMAP_MPUIO(0));
+        platform_set_drvdata(&omap_mpuio_device, bank);
+
+        if (platform_driver_register(&omap_mpuio_driver) == 0)
+                (void) platform_device_register(&omap_mpuio_device);
+}
+
+#else
+static inline void mpuio_init(void) {}
+#endif  /* 16xx */
+
+#else
+
+extern struct irq_chip mpuio_irq_chip;
+
+#define bank_is_mpuio(bank)     0
+static inline void mpuio_init(void) {}
+
+#endif
+
+/*---------------------------------------------------------------------*/
+
+/* REVISIT these are stupid implementations!  replace by ones that
+ * don't switch on METHOD_* and which mostly avoid spinlocks
+ */
+
+static int gpio_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct gpio_bank *bank;
+        unsigned long flags;
+
+        bank = container_of(chip, struct gpio_bank, chip);
+        spin_lock_irqsave(&bank->lock, flags);
+        _set_gpio_direction(bank, offset, 1);
+        spin_unlock_irqrestore(&bank->lock, flags);
+        return 0;
+}
+
+static int gpio_is_input(struct gpio_bank *bank, int mask)
+{
+        void __iomem *reg = bank->base;
+
+        switch (bank->method) {
+        case METHOD_MPUIO:
+                reg += OMAP_MPUIO_IO_CNTL / bank->stride;
+                break;
+        case METHOD_GPIO_1510:
+                reg += OMAP1510_GPIO_DIR_CONTROL;
+                break;
+        case METHOD_GPIO_1610:
+                reg += OMAP1610_GPIO_DIRECTION;
+                break;
+        case METHOD_GPIO_7XX:
+                reg += OMAP7XX_GPIO_DIR_CONTROL;
+                break;
+        case METHOD_GPIO_24XX:
+                reg += OMAP24XX_GPIO_OE;
+                break;
+        case METHOD_GPIO_44XX:
+                reg += OMAP4_GPIO_OE;
+                break;
+        default:
+                WARN_ONCE(1, "gpio_is_input: incorrect OMAP GPIO method");
+                return -EINVAL;
+        }
+        return __raw_readl(reg) & mask;
+}
+
+static int gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct gpio_bank *bank;
+        void __iomem *reg;
+        int gpio;
+        u32 mask;
+
+        gpio = chip->base + offset;
+        bank = get_gpio_bank(gpio);
+        reg = bank->base;
+        mask = 1 << get_gpio_index(gpio);
+
+        if (gpio_is_input(bank, mask))
+                return _get_gpio_datain(bank, gpio);
+        else
+                return _get_gpio_dataout(bank, gpio);
+}
+
+static int gpio_output(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct gpio_bank *bank;
+        unsigned long flags;
+
+        bank = container_of(chip, struct gpio_bank, chip);
+        spin_lock_irqsave(&bank->lock, flags);
+        _set_gpio_dataout(bank, offset, value);
+        _set_gpio_direction(bank, offset, 0);
+        spin_unlock_irqrestore(&bank->lock, flags);
+        return 0;
+}
+
+static int gpio_debounce(struct gpio_chip *chip, unsigned offset,
+                unsigned debounce)
+{
+        struct gpio_bank *bank;
+        unsigned long flags;
+
+        bank = container_of(chip, struct gpio_bank, chip);
+
+        if (!bank->dbck) {
+                bank->dbck = clk_get(bank->dev, "dbclk");
+                if (IS_ERR(bank->dbck))
+                        dev_err(bank->dev, "Could not get gpio dbck\n");
+        }
+
+        spin_lock_irqsave(&bank->lock, flags);
+        _set_gpio_debounce(bank, offset, debounce);
+        spin_unlock_irqrestore(&bank->lock, flags);
+
+        return 0;
+}
+
+static void gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct gpio_bank *bank;
+        unsigned long flags;
+
+        bank = container_of(chip, struct gpio_bank, chip);
+        spin_lock_irqsave(&bank->lock, flags);
+        _set_gpio_dataout(bank, offset, value);
+        spin_unlock_irqrestore(&bank->lock, flags);
+}
+
+static int gpio_2irq(struct gpio_chip *chip, unsigned offset)
+{
+        struct gpio_bank *bank;
+
+        bank = container_of(chip, struct gpio_bank, chip);
+        return bank->virtual_irq_start + offset;
+}
+
+/*---------------------------------------------------------------------*/
+
+static void __init omap_gpio_show_rev(struct gpio_bank *bank)
+{
+        u32 rev;
+
+        if (cpu_is_omap16xx() && !(bank->method != METHOD_MPUIO))
+                rev = __raw_readw(bank->base + OMAP1610_GPIO_REVISION);
+        else if (cpu_is_omap24xx() || cpu_is_omap34xx())
+                rev = __raw_readl(bank->base + OMAP24XX_GPIO_REVISION);
+        else if (cpu_is_omap44xx())
+                rev = __raw_readl(bank->base + OMAP4_GPIO_REVISION);
+        else
+                return;
+
+        printk(KERN_INFO "OMAP GPIO hardware version %d.%d\n",
+                (rev >> 4) & 0x0f, rev & 0x0f);
+}
+
+/* This lock class tells lockdep that GPIO irqs are in a different
+ * category than their parents, so it won't report false recursion.
+ */
+static struct lock_class_key gpio_lock_class;
+
+static inline int init_gpio_info(struct platform_device *pdev)
+{
+        /* TODO: Analyze removing gpio_bank_count usage from driver code */
+        gpio_bank = kzalloc(gpio_bank_count * sizeof(struct gpio_bank),
+                                GFP_KERNEL);
+        if (!gpio_bank) {
+                dev_err(&pdev->dev, "Memory alloc failed for gpio_bank\n");
+                return -ENOMEM;
+        }
+        return 0;
+}
+
+/* TODO: Cleanup cpu_is_* checks */
+static void omap_gpio_mod_init(struct gpio_bank *bank, int id)
+{
+        if (cpu_class_is_omap2()) {
+                if (cpu_is_omap44xx()) {
+                        __raw_writel(0xffffffff, bank->base +
+                                        OMAP4_GPIO_IRQSTATUSCLR0);
+                        __raw_writel(0x00000000, bank->base +
+                                         OMAP4_GPIO_DEBOUNCENABLE);
+                        /* Initialize interface clk ungated, module enabled */
+                        __raw_writel(0, bank->base + OMAP4_GPIO_CTRL);
+                } else if (cpu_is_omap34xx()) {
+                        __raw_writel(0x00000000, bank->base +
+                                        OMAP24XX_GPIO_IRQENABLE1);
+                        __raw_writel(0xffffffff, bank->base +
+                                        OMAP24XX_GPIO_IRQSTATUS1);
+                        __raw_writel(0x00000000, bank->base +
+                                        OMAP24XX_GPIO_DEBOUNCE_EN);
+
+                        /* Initialize interface clk ungated, module enabled */
+                        __raw_writel(0, bank->base + OMAP24XX_GPIO_CTRL);
+                } else if (cpu_is_omap24xx()) {
+                        static const u32 non_wakeup_gpios[] = {
+                                0xe203ffc0, 0x08700040
+                        };
+                        if (id < ARRAY_SIZE(non_wakeup_gpios))
+                                bank->non_wakeup_gpios = non_wakeup_gpios[id];
+                }
+        } else if (cpu_class_is_omap1()) {
+                if (bank_is_mpuio(bank))
+                        __raw_writew(0xffff, bank->base +
+                                OMAP_MPUIO_GPIO_MASKIT / bank->stride);
+                if (cpu_is_omap15xx() && bank->method == METHOD_GPIO_1510) {
+                        __raw_writew(0xffff, bank->base
+                                                + OMAP1510_GPIO_INT_MASK);
+                        __raw_writew(0x0000, bank->base
+                                                + OMAP1510_GPIO_INT_STATUS);
+                }
+                if (cpu_is_omap16xx() && bank->method == METHOD_GPIO_1610) {
+                        __raw_writew(0x0000, bank->base
+                                                + OMAP1610_GPIO_IRQENABLE1);
+                        __raw_writew(0xffff, bank->base
+                                                + OMAP1610_GPIO_IRQSTATUS1);
+                        __raw_writew(0x0014, bank->base
+                                                + OMAP1610_GPIO_SYSCONFIG);
+
+                        /*
+                         * Enable system clock for GPIO module.
+                         * The CAM_CLK_CTRL *is* really the right place.
+                         */
+                        omap_writel(omap_readl(ULPD_CAM_CLK_CTRL) | 0x04,
+                                                ULPD_CAM_CLK_CTRL);
+                }
+                if (cpu_is_omap7xx() && bank->method == METHOD_GPIO_7XX) {
+                        __raw_writel(0xffffffff, bank->base
+                                                + OMAP7XX_GPIO_INT_MASK);
+                        __raw_writel(0x00000000, bank->base
+                                                + OMAP7XX_GPIO_INT_STATUS);
+                }
+        }
+}
+
+static void __init omap_gpio_chip_init(struct gpio_bank *bank)
+{
+        int j;
+        static int gpio;
+
+        bank->mod_usage = 0;
+        /*
+         * REVISIT eventually switch from OMAP-specific gpio structs
+         * over to the generic ones
+         */
+        bank->chip.request = omap_gpio_request;
+        bank->chip.free = omap_gpio_free;
+        bank->chip.direction_input = gpio_input;
+        bank->chip.get = gpio_get;
+        bank->chip.direction_output = gpio_output;
+        bank->chip.set_debounce = gpio_debounce;
+        bank->chip.set = gpio_set;
+        bank->chip.to_irq = gpio_2irq;
+        if (bank_is_mpuio(bank)) {
+                bank->chip.label = "mpuio";
+#ifdef CONFIG_ARCH_OMAP16XX
+                bank->chip.dev = &omap_mpuio_device.dev;
+#endif
+                bank->chip.base = OMAP_MPUIO(0);
+        } else {
+                bank->chip.label = "gpio";
+                bank->chip.base = gpio;
+                gpio += bank_width;
+        }
+        bank->chip.ngpio = bank_width;
+
+        gpiochip_add(&bank->chip);
+
+        for (j = bank->virtual_irq_start;
+                     j < bank->virtual_irq_start + bank_width; j++) {
+                irq_set_lockdep_class(j, &gpio_lock_class);
+                irq_set_chip_data(j, bank);
+                if (bank_is_mpuio(bank))
+                        irq_set_chip(j, &mpuio_irq_chip);
+                else
+                        irq_set_chip(j, &gpio_irq_chip);
+                irq_set_handler(j, handle_simple_irq);
+                set_irq_flags(j, IRQF_VALID);
+        }
+        irq_set_chained_handler(bank->irq, gpio_irq_handler);
+        irq_set_handler_data(bank->irq, bank);
+}
+
+static int __devinit omap_gpio_probe(struct platform_device *pdev)
+{
+        static int gpio_init_done;
+        struct omap_gpio_platform_data *pdata;
+        struct resource *res;
+        int id;
+        struct gpio_bank *bank;
+
+        if (!pdev->dev.platform_data)
+                return -EINVAL;
+
+        pdata = pdev->dev.platform_data;
+
+        if (!gpio_init_done) {
+                int ret;
+
+                ret = init_gpio_info(pdev);
+                if (ret)
+                        return ret;
+        }
+
+        id = pdev->id;
+        bank = &gpio_bank[id];
+
+        res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (unlikely(!res)) {
+                dev_err(&pdev->dev, "GPIO Bank %i Invalid IRQ resource\n", id);
+                return -ENODEV;
+        }
+
+        bank->irq = res->start;
+        bank->virtual_irq_start = pdata->virtual_irq_start;
+        bank->method = pdata->bank_type;
+        bank->dev = &pdev->dev;
+        bank->dbck_flag = pdata->dbck_flag;
+        bank->stride = pdata->bank_stride;
+        bank_width = pdata->bank_width;
+
+        spin_lock_init(&bank->lock);
+
+        /* Static mapping, never released */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (unlikely(!res)) {
+                dev_err(&pdev->dev, "GPIO Bank %i Invalid mem resource\n", id);
+                return -ENODEV;
+        }
+
+        bank->base = ioremap(res->start, resource_size(res));
+        if (!bank->base) {
+                dev_err(&pdev->dev, "Could not ioremap gpio bank%i\n", id);
+                return -ENOMEM;
+        }
+
+        pm_runtime_enable(bank->dev);
+        pm_runtime_get_sync(bank->dev);
+
+        omap_gpio_mod_init(bank, id);
+        omap_gpio_chip_init(bank);
+        omap_gpio_show_rev(bank);
+
+        if (!gpio_init_done)
+                gpio_init_done = 1;
+
+        return 0;
+}
+
+#if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP2PLUS)
+static int omap_gpio_suspend(void)
+{
+        int i;
+
+        if (!cpu_class_is_omap2() && !cpu_is_omap16xx())
+                return 0;
+
+        for (i = 0; i < gpio_bank_count; i++) {
+                struct gpio_bank *bank = &gpio_bank[i];
+                void __iomem *wake_status;
+                void __iomem *wake_clear;
+                void __iomem *wake_set;
+                unsigned long flags;
+
+                switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP16XX
+                case METHOD_GPIO_1610:
+                        wake_status = bank->base + OMAP1610_GPIO_WAKEUPENABLE;
+                        wake_clear = bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA;
+                        wake_set = bank->base + OMAP1610_GPIO_SET_WAKEUPENA;
+                        break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+                case METHOD_GPIO_24XX:
+                        wake_status = bank->base + OMAP24XX_GPIO_WAKE_EN;
+                        wake_clear = bank->base + OMAP24XX_GPIO_CLEARWKUENA;
+                        wake_set = bank->base + OMAP24XX_GPIO_SETWKUENA;
+                        break;
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+                case METHOD_GPIO_44XX:
+                        wake_status = bank->base + OMAP4_GPIO_IRQWAKEN0;
+                        wake_clear = bank->base + OMAP4_GPIO_IRQWAKEN0;
+                        wake_set = bank->base + OMAP4_GPIO_IRQWAKEN0;
+                        break;
+#endif
+                default:
+                        continue;
+                }
+
+                spin_lock_irqsave(&bank->lock, flags);
+                bank->saved_wakeup = __raw_readl(wake_status);
+                __raw_writel(0xffffffff, wake_clear);
+                __raw_writel(bank->suspend_wakeup, wake_set);
+                spin_unlock_irqrestore(&bank->lock, flags);
+        }
+
+        return 0;
+}
+
+static void omap_gpio_resume(void)
+{
+        int i;
+
+        if (!cpu_class_is_omap2() && !cpu_is_omap16xx())
+                return;
+
+        for (i = 0; i < gpio_bank_count; i++) {
+                struct gpio_bank *bank = &gpio_bank[i];
+                void __iomem *wake_clear;
+                void __iomem *wake_set;
+                unsigned long flags;
+
+                switch (bank->method) {
+#ifdef CONFIG_ARCH_OMAP16XX
+                case METHOD_GPIO_1610:
+                        wake_clear = bank->base + OMAP1610_GPIO_CLEAR_WAKEUPENA;
+                        wake_set = bank->base + OMAP1610_GPIO_SET_WAKEUPENA;
+                        break;
+#endif
+#if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
+                case METHOD_GPIO_24XX:
+                        wake_clear = bank->base + OMAP24XX_GPIO_CLEARWKUENA;
+                        wake_set = bank->base + OMAP24XX_GPIO_SETWKUENA;
+                        break;
+#endif
+#ifdef CONFIG_ARCH_OMAP4
+                case METHOD_GPIO_44XX:
+                        wake_clear = bank->base + OMAP4_GPIO_IRQWAKEN0;
+                        wake_set = bank->base + OMAP4_GPIO_IRQWAKEN0;
+                        break;
+#endif
+                default:
+                        continue;
+                }
+
+                spin_lock_irqsave(&bank->lock, flags);
+                __raw_writel(0xffffffff, wake_clear);
+                __raw_writel(bank->saved_wakeup, wake_set);
+                spin_unlock_irqrestore(&bank->lock, flags);
+        }
+}
+
+static struct syscore_ops omap_gpio_syscore_ops = {
+        .suspend        = omap_gpio_suspend,
+        .resume         = omap_gpio_resume,
+};
+
+#endif
+
+#ifdef CONFIG_ARCH_OMAP2PLUS
+
+static int workaround_enabled;
+
+void omap2_gpio_prepare_for_idle(int off_mode)
+{
+        int i, c = 0;
+        int min = 0;
+
+        if (cpu_is_omap34xx())
+                min = 1;
+
+        for (i = min; i < gpio_bank_count; i++) {
+                struct gpio_bank *bank = &gpio_bank[i];
+                u32 l1 = 0, l2 = 0;
+                int j;
+
+                for (j = 0; j < hweight_long(bank->dbck_enable_mask); j++)
+                        clk_disable(bank->dbck);
+
+                if (!off_mode)
+                        continue;
+
+                /* If going to OFF, remove triggering for all
+                 * non-wakeup GPIOs.  Otherwise spurious IRQs will be
+                 * generated.  See OMAP2420 Errata item 1.101. */
+                if (!(bank->enabled_non_wakeup_gpios))
+                        continue;
+
+                if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
+                        bank->saved_datain = __raw_readl(bank->base +
+                                        OMAP24XX_GPIO_DATAIN);
+                        l1 = __raw_readl(bank->base +
+                                        OMAP24XX_GPIO_FALLINGDETECT);
+                        l2 = __raw_readl(bank->base +
+                                        OMAP24XX_GPIO_RISINGDETECT);
+                }
+
+                if (cpu_is_omap44xx()) {
+                        bank->saved_datain = __raw_readl(bank->base +
+                                                OMAP4_GPIO_DATAIN);
+                        l1 = __raw_readl(bank->base +
+                                                OMAP4_GPIO_FALLINGDETECT);
+                        l2 = __raw_readl(bank->base +
+                                                OMAP4_GPIO_RISINGDETECT);
+                }
+
+                bank->saved_fallingdetect = l1;
+                bank->saved_risingdetect = l2;
+                l1 &= ~bank->enabled_non_wakeup_gpios;
+                l2 &= ~bank->enabled_non_wakeup_gpios;
+
+                if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
+                        __raw_writel(l1, bank->base +
+                                        OMAP24XX_GPIO_FALLINGDETECT);
+                        __raw_writel(l2, bank->base +
+                                        OMAP24XX_GPIO_RISINGDETECT);
+                }
+
+                if (cpu_is_omap44xx()) {
+                        __raw_writel(l1, bank->base + OMAP4_GPIO_FALLINGDETECT);
+                        __raw_writel(l2, bank->base + OMAP4_GPIO_RISINGDETECT);
+                }
+
+                c++;
+        }
+        if (!c) {
+                workaround_enabled = 0;
+                return;
+        }
+        workaround_enabled = 1;
+}
+
+void omap2_gpio_resume_after_idle(void)
+{
+        int i;
+        int min = 0;
+
+        if (cpu_is_omap34xx())
+                min = 1;
+        for (i = min; i < gpio_bank_count; i++) {
+                struct gpio_bank *bank = &gpio_bank[i];
+                u32 l = 0, gen, gen0, gen1;
+                int j;
+
+                for (j = 0; j < hweight_long(bank->dbck_enable_mask); j++)
+                        clk_enable(bank->dbck);
+
+                if (!workaround_enabled)
+                        continue;
+
+                if (!(bank->enabled_non_wakeup_gpios))
+                        continue;
+
+                if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
+                        __raw_writel(bank->saved_fallingdetect,
+                                 bank->base + OMAP24XX_GPIO_FALLINGDETECT);
+                        __raw_writel(bank->saved_risingdetect,
+                                 bank->base + OMAP24XX_GPIO_RISINGDETECT);
+                        l = __raw_readl(bank->base + OMAP24XX_GPIO_DATAIN);
+                }
+
+                if (cpu_is_omap44xx()) {
+                        __raw_writel(bank->saved_fallingdetect,
+                                 bank->base + OMAP4_GPIO_FALLINGDETECT);
+                        __raw_writel(bank->saved_risingdetect,
+                                 bank->base + OMAP4_GPIO_RISINGDETECT);
+                        l = __raw_readl(bank->base + OMAP4_GPIO_DATAIN);
+                }
+
+                /* Check if any of the non-wakeup interrupt GPIOs have changed
+                 * state.  If so, generate an IRQ by software.  This is
+                 * horribly racy, but it's the best we can do to work around
+                 * this silicon bug. */
+                l ^= bank->saved_datain;
+                l &= bank->enabled_non_wakeup_gpios;
+
+                /*
+                 * No need to generate IRQs for the rising edge for gpio IRQs
+                 * configured with falling edge only; and vice versa.
+                 */
+                gen0 = l & bank->saved_fallingdetect;
+                gen0 &= bank->saved_datain;
+
+                gen1 = l & bank->saved_risingdetect;
+                gen1 &= ~(bank->saved_datain);
+
+                /* FIXME: Consider GPIO IRQs with level detections properly! */
+                gen = l & (~(bank->saved_fallingdetect) &
+                                ~(bank->saved_risingdetect));
+                /* Consider all GPIO IRQs needed to be updated */
+                gen |= gen0 | gen1;
+
+                if (gen) {
+                        u32 old0, old1;
+
+                        if (cpu_is_omap24xx() || cpu_is_omap34xx()) {
+                                old0 = __raw_readl(bank->base +
+                                        OMAP24XX_GPIO_LEVELDETECT0);
+                                old1 = __raw_readl(bank->base +
+                                        OMAP24XX_GPIO_LEVELDETECT1);
+                                __raw_writel(old0 | gen, bank->base +
+                                        OMAP24XX_GPIO_LEVELDETECT0);
+                                __raw_writel(old1 | gen, bank->base +
+                                        OMAP24XX_GPIO_LEVELDETECT1);
+                                __raw_writel(old0, bank->base +
+                                        OMAP24XX_GPIO_LEVELDETECT0);
+                                __raw_writel(old1, bank->base +
+                                        OMAP24XX_GPIO_LEVELDETECT1);
+                        }
+
+                        if (cpu_is_omap44xx()) {
+                                old0 = __raw_readl(bank->base +
+                                                OMAP4_GPIO_LEVELDETECT0);
+                                old1 = __raw_readl(bank->base +
+                                                OMAP4_GPIO_LEVELDETECT1);
+                                __raw_writel(old0 | l, bank->base +
+                                                OMAP4_GPIO_LEVELDETECT0);
+                                __raw_writel(old1 | l, bank->base +
+                                                OMAP4_GPIO_LEVELDETECT1);
+                                __raw_writel(old0, bank->base +
+                                                OMAP4_GPIO_LEVELDETECT0);
+                                __raw_writel(old1, bank->base +
+                                                OMAP4_GPIO_LEVELDETECT1);
+                        }
+                }
+        }
+
+}
+
+#endif
+
+#ifdef CONFIG_ARCH_OMAP3
+/* save the registers of bank 2-6 */
+void omap_gpio_save_context(void)
+{
+        int i;
+
+        /* saving banks from 2-6 only since GPIO1 is in WKUP */
+        for (i = 1; i < gpio_bank_count; i++) {
+                struct gpio_bank *bank = &gpio_bank[i];
+                gpio_context[i].irqenable1 =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_IRQENABLE1);
+                gpio_context[i].irqenable2 =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_IRQENABLE2);
+                gpio_context[i].wake_en =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_WAKE_EN);
+                gpio_context[i].ctrl =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_CTRL);
+                gpio_context[i].oe =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_OE);
+                gpio_context[i].leveldetect0 =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT0);
+                gpio_context[i].leveldetect1 =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_LEVELDETECT1);
+                gpio_context[i].risingdetect =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_RISINGDETECT);
+                gpio_context[i].fallingdetect =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_FALLINGDETECT);
+                gpio_context[i].dataout =
+                        __raw_readl(bank->base + OMAP24XX_GPIO_DATAOUT);
+        }
+}
+
+/* restore the required registers of bank 2-6 */
+void omap_gpio_restore_context(void)
+{
+        int i;
+
+        for (i = 1; i < gpio_bank_count; i++) {
+                struct gpio_bank *bank = &gpio_bank[i];
+                __raw_writel(gpio_context[i].irqenable1,
+                                bank->base + OMAP24XX_GPIO_IRQENABLE1);
+                __raw_writel(gpio_context[i].irqenable2,
+                                bank->base + OMAP24XX_GPIO_IRQENABLE2);
+                __raw_writel(gpio_context[i].wake_en,
+                                bank->base + OMAP24XX_GPIO_WAKE_EN);
+                __raw_writel(gpio_context[i].ctrl,
+                                bank->base + OMAP24XX_GPIO_CTRL);
+                __raw_writel(gpio_context[i].oe,
+                                bank->base + OMAP24XX_GPIO_OE);
+                __raw_writel(gpio_context[i].leveldetect0,
+                                bank->base + OMAP24XX_GPIO_LEVELDETECT0);
+                __raw_writel(gpio_context[i].leveldetect1,
+                                bank->base + OMAP24XX_GPIO_LEVELDETECT1);
+                __raw_writel(gpio_context[i].risingdetect,
+                                bank->base + OMAP24XX_GPIO_RISINGDETECT);
+                __raw_writel(gpio_context[i].fallingdetect,
+                                bank->base + OMAP24XX_GPIO_FALLINGDETECT);
+                __raw_writel(gpio_context[i].dataout,
+                                bank->base + OMAP24XX_GPIO_DATAOUT);
+        }
+}
+#endif
+
+static struct platform_driver omap_gpio_driver = {
+        .probe          = omap_gpio_probe,
+        .driver         = {
+                .name   = "omap_gpio",
+        },
+};
+
+/*
+ * gpio driver register needs to be done before
+ * machine_init functions access gpio APIs.
+ * Hence omap_gpio_drv_reg() is a postcore_initcall.
+ */
+static int __init omap_gpio_drv_reg(void)
+{
+        return platform_driver_register(&omap_gpio_driver);
+}
+postcore_initcall(omap_gpio_drv_reg);
+
+static int __init omap_gpio_sysinit(void)
+{
+        mpuio_init();
+
+#if defined(CONFIG_ARCH_OMAP16XX) || defined(CONFIG_ARCH_OMAP2PLUS)
+        if (cpu_is_omap16xx() || cpu_class_is_omap2())
+                register_syscore_ops(&omap_gpio_syscore_ops);
+#endif
+
+        return 0;
+}
+
+arch_initcall(omap_gpio_sysinit);
diff --git a/drivers/gpio/gpio-plat-samsung.c b/drivers/gpio/gpio-plat-samsung.c
new file mode 100644
index 000000000000..ea37c0461788
--- /dev/null
+++ b/drivers/gpio/gpio-plat-samsung.c
@@ -0,0 +1,206 @@
+/* arch/arm/plat-samsung/gpiolib.c
+ *
+ * Copyright 2008 Openmoko, Inc.
+ * Copyright 2008 Simtec Electronics
+ *      Ben Dooks <ben@simtec.co.uk>
+ *      http://armlinux.simtec.co.uk/
+ *
+ * Copyright (c) 2009 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com/
+ *
+ * SAMSUNG - GPIOlib support
+ *
+ * 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/irq.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <plat/gpio-core.h>
+#include <plat/gpio-cfg.h>
+#include <plat/gpio-cfg-helpers.h>
+
+#ifndef DEBUG_GPIO
+#define gpio_dbg(x...) do { } while (0)
+#else
+#define gpio_dbg(x...) printk(KERN_DEBUG x)
+#endif
+
+/* The samsung_gpiolib_4bit routines are to control the gpio banks where
+ * the gpio configuration register (GPxCON) has 4 bits per GPIO, as the
+ * following example:
+ *
+ * base + 0x00: Control register, 4 bits per gpio
+ *              gpio n: 4 bits starting at (4*n)
+ *              0000 = input, 0001 = output, others mean special-function
+ * base + 0x04: Data register, 1 bit per gpio
+ *              bit n: data bit n
+ *
+ * Note, since the data register is one bit per gpio and is at base + 0x4
+ * we can use s3c_gpiolib_get and s3c_gpiolib_set to change the state of
+ * the output.
+*/
+
+static int samsung_gpiolib_4bit_input(struct gpio_chip *chip,
+                                      unsigned int offset)
+{
+        struct s3c_gpio_chip *ourchip = to_s3c_gpio(chip);
+        void __iomem *base = ourchip->base;
+        unsigned long con;
+
+        con = __raw_readl(base + GPIOCON_OFF);
+        con &= ~(0xf << con_4bit_shift(offset));
+        __raw_writel(con, base + GPIOCON_OFF);
+
+        gpio_dbg("%s: %p: CON now %08lx\n", __func__, base, con);
+
+        return 0;
+}
+
+static int samsung_gpiolib_4bit_output(struct gpio_chip *chip,
+                                       unsigned int offset, int value)
+{
+        struct s3c_gpio_chip *ourchip = to_s3c_gpio(chip);
+        void __iomem *base = ourchip->base;
+        unsigned long con;
+        unsigned long dat;
+
+        con = __raw_readl(base + GPIOCON_OFF);
+        con &= ~(0xf << con_4bit_shift(offset));
+        con |= 0x1 << con_4bit_shift(offset);
+
+        dat = __raw_readl(base + GPIODAT_OFF);
+
+        if (value)
+                dat |= 1 << offset;
+        else
+                dat &= ~(1 << offset);
+
+        __raw_writel(dat, base + GPIODAT_OFF);
+        __raw_writel(con, base + GPIOCON_OFF);
+        __raw_writel(dat, base + GPIODAT_OFF);
+
+        gpio_dbg("%s: %p: CON %08lx, DAT %08lx\n", __func__, base, con, dat);
+
+        return 0;
+}
+
+/* The next set of routines are for the case where the GPIO configuration
+ * registers are 4 bits per GPIO but there is more than one register (the
+ * bank has more than 8 GPIOs.
+ *
+ * This case is the similar to the 4 bit case, but the registers are as
+ * follows:
+ *
+ * base + 0x00: Control register, 4 bits per gpio (lower 8 GPIOs)
+ *              gpio n: 4 bits starting at (4*n)
+ *              0000 = input, 0001 = output, others mean special-function
+ * base + 0x04: Control register, 4 bits per gpio (up to 8 additions GPIOs)
+ *              gpio n: 4 bits starting at (4*n)
+ *              0000 = input, 0001 = output, others mean special-function
+ * base + 0x08: Data register, 1 bit per gpio
+ *              bit n: data bit n
+ *
+ * To allow us to use the s3c_gpiolib_get and s3c_gpiolib_set routines we
+ * store the 'base + 0x4' address so that these routines see the data
+ * register at ourchip->base + 0x04.
+ */
+
+static int samsung_gpiolib_4bit2_input(struct gpio_chip *chip,
+                                       unsigned int offset)
+{
+        struct s3c_gpio_chip *ourchip = to_s3c_gpio(chip);
+        void __iomem *base = ourchip->base;
+        void __iomem *regcon = base;
+        unsigned long con;
+
+        if (offset > 7)
+                offset -= 8;
+        else
+                regcon -= 4;
+
+        con = __raw_readl(regcon);
+        con &= ~(0xf << con_4bit_shift(offset));
+        __raw_writel(con, regcon);
+
+        gpio_dbg("%s: %p: CON %08lx\n", __func__, base, con);
+
+        return 0;
+}
+
+static int samsung_gpiolib_4bit2_output(struct gpio_chip *chip,
+                                        unsigned int offset, int value)
+{
+        struct s3c_gpio_chip *ourchip = to_s3c_gpio(chip);
+        void __iomem *base = ourchip->base;
+        void __iomem *regcon = base;
+        unsigned long con;
+        unsigned long dat;
+        unsigned con_offset = offset;
+
+        if (con_offset > 7)
+                con_offset -= 8;
+        else
+                regcon -= 4;
+
+        con = __raw_readl(regcon);
+        con &= ~(0xf << con_4bit_shift(con_offset));
+        con |= 0x1 << con_4bit_shift(con_offset);
+
+        dat = __raw_readl(base + GPIODAT_OFF);
+
+        if (value)
+                dat |= 1 << offset;
+        else
+                dat &= ~(1 << offset);
+
+        __raw_writel(dat, base + GPIODAT_OFF);
+        __raw_writel(con, regcon);
+        __raw_writel(dat, base + GPIODAT_OFF);
+
+        gpio_dbg("%s: %p: CON %08lx, DAT %08lx\n", __func__, base, con, dat);
+
+        return 0;
+}
+
+void __init samsung_gpiolib_add_4bit(struct s3c_gpio_chip *chip)
+{
+        chip->chip.direction_input = samsung_gpiolib_4bit_input;
+        chip->chip.direction_output = samsung_gpiolib_4bit_output;
+        chip->pm = __gpio_pm(&s3c_gpio_pm_4bit);
+}
+
+void __init samsung_gpiolib_add_4bit2(struct s3c_gpio_chip *chip)
+{
+        chip->chip.direction_input = samsung_gpiolib_4bit2_input;
+        chip->chip.direction_output = samsung_gpiolib_4bit2_output;
+        chip->pm = __gpio_pm(&s3c_gpio_pm_4bit);
+}
+
+void __init samsung_gpiolib_add_4bit_chips(struct s3c_gpio_chip *chip,
+                                           int nr_chips)
+{
+        for (; nr_chips > 0; nr_chips--, chip++) {
+                samsung_gpiolib_add_4bit(chip);
+                s3c_gpiolib_add(chip);
+        }
+}
+
+void __init samsung_gpiolib_add_4bit2_chips(struct s3c_gpio_chip *chip,
+                                            int nr_chips)
+{
+        for (; nr_chips > 0; nr_chips--, chip++) {
+                samsung_gpiolib_add_4bit2(chip);
+                s3c_gpiolib_add(chip);
+        }
+}
+
+void __init samsung_gpiolib_add_2bit_chips(struct s3c_gpio_chip *chip,
+                                           int nr_chips)
+{
+        for (; nr_chips > 0; nr_chips--, chip++)
+                s3c_gpiolib_add(chip);
+}
diff --git a/drivers/gpio/gpio-s5pc100.c b/drivers/gpio/gpio-s5pc100.c
new file mode 100644
index 000000000000..2842394b28b5
--- /dev/null
+++ b/drivers/gpio/gpio-s5pc100.c
@@ -0,0 +1,355 @@
+/* linux/arch/arm/mach-s5pc100/gpiolib.c
+ *
+ * Copyright (c) 2010 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ *  Copyright 2009 Samsung Electronics Co
+ *  Kyungmin Park <kyungmin.park@samsung.com>
+ *
+ * S5PC100 - GPIOlib support
+ *
+ * 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/irq.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+
+#include <mach/map.h>
+#include <mach/regs-gpio.h>
+
+#include <plat/gpio-core.h>
+#include <plat/gpio-cfg.h>
+#include <plat/gpio-cfg-helpers.h>
+
+/* S5PC100 GPIO bank summary:
+ *
+ * Bank GPIOs   Style   INT Type
+ * A0   8       4Bit    GPIO_INT0
+ * A1   5       4Bit    GPIO_INT1
+ * B    8       4Bit    GPIO_INT2
+ * C    5       4Bit    GPIO_INT3
+ * D    7       4Bit    GPIO_INT4
+ * E0   8       4Bit    GPIO_INT5
+ * E1   6       4Bit    GPIO_INT6
+ * F0   8       4Bit    GPIO_INT7
+ * F1   8       4Bit    GPIO_INT8
+ * F2   8       4Bit    GPIO_INT9
+ * F3   4       4Bit    GPIO_INT10
+ * G0   8       4Bit    GPIO_INT11
+ * G1   3       4Bit    GPIO_INT12
+ * G2   7       4Bit    GPIO_INT13
+ * G3   7       4Bit    GPIO_INT14
+ * H0   8       4Bit    WKUP_INT
+ * H1   8       4Bit    WKUP_INT
+ * H2   8       4Bit    WKUP_INT
+ * H3   8       4Bit    WKUP_INT
+ * I    8       4Bit    GPIO_INT15
+ * J0   8       4Bit    GPIO_INT16
+ * J1   5       4Bit    GPIO_INT17
+ * J2   8       4Bit    GPIO_INT18
+ * J3   8       4Bit    GPIO_INT19
+ * J4   4       4Bit    GPIO_INT20
+ * K0   8       4Bit    None
+ * K1   6       4Bit    None
+ * K2   8       4Bit    None
+ * K3   8       4Bit    None
+ * L0   8       4Bit    None
+ * L1   8       4Bit    None
+ * L2   8       4Bit    None
+ * L3   8       4Bit    None
+ */
+
+static struct s3c_gpio_cfg gpio_cfg = {
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+static struct s3c_gpio_cfg gpio_cfg_eint = {
+        .cfg_eint       = 0xf,
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+static struct s3c_gpio_cfg gpio_cfg_noint = {
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+/*
+ * GPIO bank's base address given the index of the bank in the
+ * list of all gpio banks.
+ */
+#define S5PC100_BANK_BASE(bank_nr)      (S5P_VA_GPIO + ((bank_nr) * 0x20))
+
+/*
+ * Following are the gpio banks in S5PC100.
+ *
+ * The 'config' member when left to NULL, is initialized to the default
+ * structure gpio_cfg in the init function below.
+ *
+ * The 'base' member is also initialized in the init function below.
+ * Note: The initialization of 'base' member of s3c_gpio_chip structure
+ * uses the above macro and depends on the banks being listed in order here.
+ */
+static struct s3c_gpio_chip s5pc100_gpio_chips[] = {
+        {
+                .chip   = {
+                        .base   = S5PC100_GPA0(0),
+                        .ngpio  = S5PC100_GPIO_A0_NR,
+                        .label  = "GPA0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPA1(0),
+                        .ngpio  = S5PC100_GPIO_A1_NR,
+                        .label  = "GPA1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPB(0),
+                        .ngpio  = S5PC100_GPIO_B_NR,
+                        .label  = "GPB",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPC(0),
+                        .ngpio  = S5PC100_GPIO_C_NR,
+                        .label  = "GPC",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPD(0),
+                        .ngpio  = S5PC100_GPIO_D_NR,
+                        .label  = "GPD",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPE0(0),
+                        .ngpio  = S5PC100_GPIO_E0_NR,
+                        .label  = "GPE0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPE1(0),
+                        .ngpio  = S5PC100_GPIO_E1_NR,
+                        .label  = "GPE1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPF0(0),
+                        .ngpio  = S5PC100_GPIO_F0_NR,
+                        .label  = "GPF0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPF1(0),
+                        .ngpio  = S5PC100_GPIO_F1_NR,
+                        .label  = "GPF1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPF2(0),
+                        .ngpio  = S5PC100_GPIO_F2_NR,
+                        .label  = "GPF2",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPF3(0),
+                        .ngpio  = S5PC100_GPIO_F3_NR,
+                        .label  = "GPF3",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPG0(0),
+                        .ngpio  = S5PC100_GPIO_G0_NR,
+                        .label  = "GPG0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPG1(0),
+                        .ngpio  = S5PC100_GPIO_G1_NR,
+                        .label  = "GPG1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPG2(0),
+                        .ngpio  = S5PC100_GPIO_G2_NR,
+                        .label  = "GPG2",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPG3(0),
+                        .ngpio  = S5PC100_GPIO_G3_NR,
+                        .label  = "GPG3",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPI(0),
+                        .ngpio  = S5PC100_GPIO_I_NR,
+                        .label  = "GPI",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPJ0(0),
+                        .ngpio  = S5PC100_GPIO_J0_NR,
+                        .label  = "GPJ0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPJ1(0),
+                        .ngpio  = S5PC100_GPIO_J1_NR,
+                        .label  = "GPJ1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPJ2(0),
+                        .ngpio  = S5PC100_GPIO_J2_NR,
+                        .label  = "GPJ2",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPJ3(0),
+                        .ngpio  = S5PC100_GPIO_J3_NR,
+                        .label  = "GPJ3",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PC100_GPJ4(0),
+                        .ngpio  = S5PC100_GPIO_J4_NR,
+                        .label  = "GPJ4",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPK0(0),
+                        .ngpio  = S5PC100_GPIO_K0_NR,
+                        .label  = "GPK0",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPK1(0),
+                        .ngpio  = S5PC100_GPIO_K1_NR,
+                        .label  = "GPK1",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPK2(0),
+                        .ngpio  = S5PC100_GPIO_K2_NR,
+                        .label  = "GPK2",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPK3(0),
+                        .ngpio  = S5PC100_GPIO_K3_NR,
+                        .label  = "GPK3",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPL0(0),
+                        .ngpio  = S5PC100_GPIO_L0_NR,
+                        .label  = "GPL0",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPL1(0),
+                        .ngpio  = S5PC100_GPIO_L1_NR,
+                        .label  = "GPL1",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPL2(0),
+                        .ngpio  = S5PC100_GPIO_L2_NR,
+                        .label  = "GPL2",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPL3(0),
+                        .ngpio  = S5PC100_GPIO_L3_NR,
+                        .label  = "GPL3",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PC100_GPL4(0),
+                        .ngpio  = S5PC100_GPIO_L4_NR,
+                        .label  = "GPL4",
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC00),
+                .config = &gpio_cfg_eint,
+                .irq_base = IRQ_EINT(0),
+                .chip   = {
+                        .base   = S5PC100_GPH0(0),
+                        .ngpio  = S5PC100_GPIO_H0_NR,
+                        .label  = "GPH0",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC20),
+                .config = &gpio_cfg_eint,
+                .irq_base = IRQ_EINT(8),
+                .chip   = {
+                        .base   = S5PC100_GPH1(0),
+                        .ngpio  = S5PC100_GPIO_H1_NR,
+                        .label  = "GPH1",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC40),
+                .config = &gpio_cfg_eint,
+                .irq_base = IRQ_EINT(16),
+                .chip   = {
+                        .base   = S5PC100_GPH2(0),
+                        .ngpio  = S5PC100_GPIO_H2_NR,
+                        .label  = "GPH2",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC60),
+                .config = &gpio_cfg_eint,
+                .irq_base = IRQ_EINT(24),
+                .chip   = {
+                        .base   = S5PC100_GPH3(0),
+                        .ngpio  = S5PC100_GPIO_H3_NR,
+                        .label  = "GPH3",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        },
+};
+
+static __init int s5pc100_gpiolib_init(void)
+{
+        struct s3c_gpio_chip *chip = s5pc100_gpio_chips;
+        int nr_chips = ARRAY_SIZE(s5pc100_gpio_chips);
+        int gpioint_group = 0;
+        int i;
+
+        for (i = 0; i < nr_chips; i++, chip++) {
+                if (chip->config == NULL) {
+                        chip->config = &gpio_cfg;
+                        chip->group = gpioint_group++;
+                }
+                if (chip->base == NULL)
+                        chip->base = S5PC100_BANK_BASE(i);
+        }
+
+        samsung_gpiolib_add_4bit_chips(s5pc100_gpio_chips, nr_chips);
+        s5p_register_gpioint_bank(IRQ_GPIOINT, 0, S5P_GPIOINT_GROUP_MAXNR);
+
+        return 0;
+}
+core_initcall(s5pc100_gpiolib_init);
diff --git a/drivers/gpio/gpio-s5pv210.c b/drivers/gpio/gpio-s5pv210.c
new file mode 100644
index 000000000000..1ba20a703e05
--- /dev/null
+++ b/drivers/gpio/gpio-s5pv210.c
@@ -0,0 +1,288 @@
+/* linux/arch/arm/mach-s5pv210/gpiolib.c
+ *
+ * Copyright (c) 2010 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com/
+ *
+ * S5PV210 - GPIOlib support
+ *
+ * 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/irq.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <plat/gpio-core.h>
+#include <plat/gpio-cfg.h>
+#include <plat/gpio-cfg-helpers.h>
+#include <mach/map.h>
+
+static struct s3c_gpio_cfg gpio_cfg = {
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+static struct s3c_gpio_cfg gpio_cfg_noint = {
+        .set_config     = s3c_gpio_setcfg_s3c64xx_4bit,
+        .set_pull       = s3c_gpio_setpull_updown,
+        .get_pull       = s3c_gpio_getpull_updown,
+};
+
+/* GPIO bank's base address given the index of the bank in the
+ * list of all gpio banks.
+ */
+#define S5PV210_BANK_BASE(bank_nr)      (S5P_VA_GPIO + ((bank_nr) * 0x20))
+
+/*
+ * Following are the gpio banks in v210.
+ *
+ * The 'config' member when left to NULL, is initialized to the default
+ * structure gpio_cfg in the init function below.
+ *
+ * The 'base' member is also initialized in the init function below.
+ * Note: The initialization of 'base' member of s3c_gpio_chip structure
+ * uses the above macro and depends on the banks being listed in order here.
+ */
+static struct s3c_gpio_chip s5pv210_gpio_4bit[] = {
+        {
+                .chip   = {
+                        .base   = S5PV210_GPA0(0),
+                        .ngpio  = S5PV210_GPIO_A0_NR,
+                        .label  = "GPA0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPA1(0),
+                        .ngpio  = S5PV210_GPIO_A1_NR,
+                        .label  = "GPA1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPB(0),
+                        .ngpio  = S5PV210_GPIO_B_NR,
+                        .label  = "GPB",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPC0(0),
+                        .ngpio  = S5PV210_GPIO_C0_NR,
+                        .label  = "GPC0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPC1(0),
+                        .ngpio  = S5PV210_GPIO_C1_NR,
+                        .label  = "GPC1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPD0(0),
+                        .ngpio  = S5PV210_GPIO_D0_NR,
+                        .label  = "GPD0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPD1(0),
+                        .ngpio  = S5PV210_GPIO_D1_NR,
+                        .label  = "GPD1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPE0(0),
+                        .ngpio  = S5PV210_GPIO_E0_NR,
+                        .label  = "GPE0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPE1(0),
+                        .ngpio  = S5PV210_GPIO_E1_NR,
+                        .label  = "GPE1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPF0(0),
+                        .ngpio  = S5PV210_GPIO_F0_NR,
+                        .label  = "GPF0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPF1(0),
+                        .ngpio  = S5PV210_GPIO_F1_NR,
+                        .label  = "GPF1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPF2(0),
+                        .ngpio  = S5PV210_GPIO_F2_NR,
+                        .label  = "GPF2",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPF3(0),
+                        .ngpio  = S5PV210_GPIO_F3_NR,
+                        .label  = "GPF3",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPG0(0),
+                        .ngpio  = S5PV210_GPIO_G0_NR,
+                        .label  = "GPG0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPG1(0),
+                        .ngpio  = S5PV210_GPIO_G1_NR,
+                        .label  = "GPG1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPG2(0),
+                        .ngpio  = S5PV210_GPIO_G2_NR,
+                        .label  = "GPG2",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPG3(0),
+                        .ngpio  = S5PV210_GPIO_G3_NR,
+                        .label  = "GPG3",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PV210_GPI(0),
+                        .ngpio  = S5PV210_GPIO_I_NR,
+                        .label  = "GPI",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPJ0(0),
+                        .ngpio  = S5PV210_GPIO_J0_NR,
+                        .label  = "GPJ0",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPJ1(0),
+                        .ngpio  = S5PV210_GPIO_J1_NR,
+                        .label  = "GPJ1",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPJ2(0),
+                        .ngpio  = S5PV210_GPIO_J2_NR,
+                        .label  = "GPJ2",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPJ3(0),
+                        .ngpio  = S5PV210_GPIO_J3_NR,
+                        .label  = "GPJ3",
+                },
+        }, {
+                .chip   = {
+                        .base   = S5PV210_GPJ4(0),
+                        .ngpio  = S5PV210_GPIO_J4_NR,
+                        .label  = "GPJ4",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PV210_MP01(0),
+                        .ngpio  = S5PV210_GPIO_MP01_NR,
+                        .label  = "MP01",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PV210_MP02(0),
+                        .ngpio  = S5PV210_GPIO_MP02_NR,
+                        .label  = "MP02",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PV210_MP03(0),
+                        .ngpio  = S5PV210_GPIO_MP03_NR,
+                        .label  = "MP03",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PV210_MP04(0),
+                        .ngpio  = S5PV210_GPIO_MP04_NR,
+                        .label  = "MP04",
+                },
+        }, {
+                .config = &gpio_cfg_noint,
+                .chip   = {
+                        .base   = S5PV210_MP05(0),
+                        .ngpio  = S5PV210_GPIO_MP05_NR,
+                        .label  = "MP05",
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC00),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(0),
+                .chip   = {
+                        .base   = S5PV210_GPH0(0),
+                        .ngpio  = S5PV210_GPIO_H0_NR,
+                        .label  = "GPH0",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC20),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(8),
+                .chip   = {
+                        .base   = S5PV210_GPH1(0),
+                        .ngpio  = S5PV210_GPIO_H1_NR,
+                        .label  = "GPH1",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC40),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(16),
+                .chip   = {
+                        .base   = S5PV210_GPH2(0),
+                        .ngpio  = S5PV210_GPIO_H2_NR,
+                        .label  = "GPH2",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        }, {
+                .base   = (S5P_VA_GPIO + 0xC60),
+                .config = &gpio_cfg_noint,
+                .irq_base = IRQ_EINT(24),
+                .chip   = {
+                        .base   = S5PV210_GPH3(0),
+                        .ngpio  = S5PV210_GPIO_H3_NR,
+                        .label  = "GPH3",
+                        .to_irq = samsung_gpiolib_to_irq,
+                },
+        },
+};
+
+static __init int s5pv210_gpiolib_init(void)
+{
+        struct s3c_gpio_chip *chip = s5pv210_gpio_4bit;
+        int nr_chips = ARRAY_SIZE(s5pv210_gpio_4bit);
+        int gpioint_group = 0;
+        int i = 0;
+
+        for (i = 0; i < nr_chips; i++, chip++) {
+                if (chip->config == NULL) {
+                        chip->config = &gpio_cfg;
+                        chip->group = gpioint_group++;
+                }
+                if (chip->base == NULL)
+                        chip->base = S5PV210_BANK_BASE(i);
+        }
+
+        samsung_gpiolib_add_4bit_chips(s5pv210_gpio_4bit, nr_chips);
+        s5p_register_gpioint_bank(IRQ_GPIOINT, 0, S5P_GPIOINT_GROUP_MAXNR);
+
+        return 0;
+}
+core_initcall(s5pv210_gpiolib_init);
diff --git a/drivers/gpio/gpio-u300.c b/drivers/gpio/gpio-u300.c
new file mode 100644
index 000000000000..d92790140fe5
--- /dev/null
+++ b/drivers/gpio/gpio-u300.c
@@ -0,0 +1,700 @@
+/*
+ *
+ * arch/arm/mach-u300/gpio.c
+ *
+ *
+ * Copyright (C) 2007-2009 ST-Ericsson AB
+ * License terms: GNU General Public License (GPL) version 2
+ * U300 GPIO module.
+ * This can driver either of the two basic GPIO cores
+ * available in the U300 platforms:
+ * COH 901 335   - Used in DB3150 (U300 1.0) and DB3200 (U330 1.0)
+ * COH 901 571/3 - Used in DB3210 (U365 2.0) and DB3350 (U335 1.0)
+ * Notice that you also have inline macros in <asm-arch/gpio.h>
+ * Author: Linus Walleij <linus.walleij@stericsson.com>
+ * Author: Jonas Aaberg <jonas.aberg@stericsson.com>
+ *
+ */
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+
+/* Reference to GPIO block clock */
+static struct clk *clk;
+
+/* Memory resource */
+static struct resource *memres;
+static void __iomem *virtbase;
+static struct device *gpiodev;
+
+struct u300_gpio_port {
+        const char *name;
+        int irq;
+        int number;
+};
+
+
+static struct u300_gpio_port gpio_ports[] = {
+        {
+                .name = "gpio0",
+                .number = 0,
+        },
+        {
+                .name = "gpio1",
+                .number = 1,
+        },
+        {
+                .name = "gpio2",
+                .number = 2,
+        },
+#ifdef U300_COH901571_3
+        {
+                .name = "gpio3",
+                .number = 3,
+        },
+        {
+                .name = "gpio4",
+                .number = 4,
+        },
+#ifdef CONFIG_MACH_U300_BS335
+        {
+                .name = "gpio5",
+                .number = 5,
+        },
+        {
+                .name = "gpio6",
+                .number = 6,
+        },
+#endif
+#endif
+
+};
+
+
+#ifdef U300_COH901571_3
+
+/* Default input value */
+#define DEFAULT_OUTPUT_LOW   0
+#define DEFAULT_OUTPUT_HIGH  1
+
+/* GPIO Pull-Up status */
+#define DISABLE_PULL_UP  0
+#define ENABLE_PULL_UP  1
+
+#define GPIO_NOT_USED 0
+#define GPIO_IN       1
+#define GPIO_OUT      2
+
+struct u300_gpio_configuration_data {
+        unsigned char pin_usage;
+        unsigned char default_output_value;
+        unsigned char pull_up;
+};
+
+/* Initial configuration */
+const struct u300_gpio_configuration_data
+u300_gpio_config[U300_GPIO_NUM_PORTS][U300_GPIO_PINS_PER_PORT] = {
+#ifdef CONFIG_MACH_U300_BS335
+        /* Port 0, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 1, pins 0-7 */
+        {
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 2, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+        },
+        /* Port 3, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 4, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 5, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 6, pind 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        }
+#endif
+
+#ifdef CONFIG_MACH_U300_BS365
+        /* Port 0, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 1, pins 0-7 */
+        {
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_HIGH,  DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP}
+        },
+        /* Port 2, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,   DISABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+        },
+        /* Port 3, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+        },
+        /* Port 4, pins 0-7 */
+        {
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_IN,  DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                /* These 4 pins doesn't exist on DB3210 */
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP},
+                {GPIO_OUT, DEFAULT_OUTPUT_LOW,    ENABLE_PULL_UP}
+        }
+#endif
+};
+#endif
+
+
+/* No users == we can power down GPIO */
+static int gpio_users;
+
+struct gpio_struct {
+        int (*callback)(void *);
+        void *data;
+        int users;
+};
+
+static struct gpio_struct gpio_pin[U300_GPIO_MAX];
+
+/*
+ * Let drivers register callback in order to get notified when there is
+ * an interrupt on the gpio pin
+ */
+int gpio_register_callback(unsigned gpio, int (*func)(void *arg), void *data)
+{
+        if (gpio_pin[gpio].callback)
+                dev_warn(gpiodev, "%s: WARNING: callback already "
+                         "registered for gpio pin#%d\n", __func__, gpio);
+        gpio_pin[gpio].callback = func;
+        gpio_pin[gpio].data = data;
+
+        return 0;
+}
+EXPORT_SYMBOL(gpio_register_callback);
+
+int gpio_unregister_callback(unsigned gpio)
+{
+        if (!gpio_pin[gpio].callback)
+                dev_warn(gpiodev, "%s: WARNING: callback already "
+                         "unregistered for gpio pin#%d\n", __func__, gpio);
+        gpio_pin[gpio].callback = NULL;
+        gpio_pin[gpio].data = NULL;
+
+        return 0;
+}
+EXPORT_SYMBOL(gpio_unregister_callback);
+
+/* Non-zero means valid */
+int gpio_is_valid(int number)
+{
+        if (number >= 0 &&
+            number < (U300_GPIO_NUM_PORTS * U300_GPIO_PINS_PER_PORT))
+                return 1;
+        return 0;
+}
+EXPORT_SYMBOL(gpio_is_valid);
+
+int gpio_request(unsigned gpio, const char *label)
+{
+        if (gpio_pin[gpio].users)
+                return -EINVAL;
+        else
+                gpio_pin[gpio].users++;
+
+        gpio_users++;
+
+        return 0;
+}
+EXPORT_SYMBOL(gpio_request);
+
+void gpio_free(unsigned gpio)
+{
+        gpio_users--;
+        gpio_pin[gpio].users--;
+        if (unlikely(gpio_pin[gpio].users < 0)) {
+                dev_warn(gpiodev, "warning: gpio#%d release mismatch\n",
+                         gpio);
+                gpio_pin[gpio].users = 0;
+        }
+
+        return;
+}
+EXPORT_SYMBOL(gpio_free);
+
+/* This returns zero or nonzero */
+int gpio_get_value(unsigned gpio)
+{
+        return readl(virtbase + U300_GPIO_PXPDIR +
+          PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING) & (1 << (gpio & 0x07));
+}
+EXPORT_SYMBOL(gpio_get_value);
+
+/*
+ * We hope that the compiler will optimize away the unused branch
+ * in case "value" is a constant
+ */
+void gpio_set_value(unsigned gpio, int value)
+{
+        u32 val;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        if (value) {
+                /* set */
+                val = readl(virtbase + U300_GPIO_PXPDOR +
+                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING)
+                  & (1 << (gpio & 0x07));
+                writel(val | (1 << (gpio & 0x07)), virtbase +
+                  U300_GPIO_PXPDOR +
+                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
+        } else {
+                /* clear */
+                val = readl(virtbase + U300_GPIO_PXPDOR +
+                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING)
+                  & (1 << (gpio & 0x07));
+                writel(val & ~(1 << (gpio & 0x07)), virtbase +
+                  U300_GPIO_PXPDOR +
+                  PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
+        }
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL(gpio_set_value);
+
+int gpio_direction_input(unsigned gpio)
+{
+        unsigned long flags;
+        u32 val;
+
+        if (gpio > U300_GPIO_MAX)
+                return -EINVAL;
+
+        local_irq_save(flags);
+        val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        /* Mask out this pin*/
+        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1));
+        /* This is not needed since it sets the bits to zero.*/
+        /* val |= (U300_GPIO_PXPCR_PIN_MODE_INPUT << (gpio*2)); */
+        writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        local_irq_restore(flags);
+        return 0;
+}
+EXPORT_SYMBOL(gpio_direction_input);
+
+int gpio_direction_output(unsigned gpio, int value)
+{
+        unsigned long flags;
+        u32 val;
+
+        if (gpio > U300_GPIO_MAX)
+                return -EINVAL;
+
+        local_irq_save(flags);
+        val = readl(virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        /* Mask out this pin */
+        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << ((gpio & 0x07) << 1));
+        /*
+         * FIXME: configure for push/pull, open drain or open source per pin
+         * in setup. The current driver will only support push/pull.
+         */
+        val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL
+                        << ((gpio & 0x07) << 1));
+        writel(val, virtbase + U300_GPIO_PXPCR + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        gpio_set_value(gpio, value);
+        local_irq_restore(flags);
+        return 0;
+}
+EXPORT_SYMBOL(gpio_direction_output);
+
+/*
+ * Enable an IRQ, edge is rising edge (!= 0) or falling edge (==0).
+ */
+void enable_irq_on_gpio_pin(unsigned gpio, int edge)
+{
+        u32 val;
+        unsigned long flags;
+        local_irq_save(flags);
+
+        val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        val |= (1 << (gpio & 0x07));
+        writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        val = readl(virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        if (edge)
+                val |= (1 << (gpio & 0x07));
+        else
+                val &= ~(1 << (gpio & 0x07));
+        writel(val, virtbase + U300_GPIO_PXICR + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL(enable_irq_on_gpio_pin);
+
+void disable_irq_on_gpio_pin(unsigned gpio)
+{
+        u32 val;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        val = readl(virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        val &= ~(1 << (gpio & 0x07));
+        writel(val, virtbase + U300_GPIO_PXIEN + PIN_TO_PORT(gpio) *
+                                U300_GPIO_PORTX_SPACING);
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL(disable_irq_on_gpio_pin);
+
+/* Enable (value == 0) or disable (value == 1) internal pullup */
+void gpio_pullup(unsigned gpio, int value)
+{
+        u32 val;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        if (value) {
+                val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) *
+                                        U300_GPIO_PORTX_SPACING);
+                writel(val | (1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER +
+                                PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
+        } else {
+                val = readl(virtbase + U300_GPIO_PXPER + PIN_TO_PORT(gpio) *
+                                        U300_GPIO_PORTX_SPACING);
+                writel(val & ~(1 << (gpio & 0x07)), virtbase + U300_GPIO_PXPER +
+                                PIN_TO_PORT(gpio) * U300_GPIO_PORTX_SPACING);
+        }
+        local_irq_restore(flags);
+}
+EXPORT_SYMBOL(gpio_pullup);
+
+static irqreturn_t gpio_irq_handler(int irq, void *dev_id)
+{
+        struct u300_gpio_port *port = dev_id;
+        u32 val;
+        int pin;
+
+        /* Read event register */
+        val = readl(virtbase + U300_GPIO_PXIEV + port->number *
+                                U300_GPIO_PORTX_SPACING);
+        /* Mask with enable register */
+        val &= readl(virtbase + U300_GPIO_PXIEV + port->number *
+                                U300_GPIO_PORTX_SPACING);
+        /* Mask relevant bits */
+        val &= U300_GPIO_PXIEV_ALL_IRQ_EVENT_MASK;
+        /* ACK IRQ (clear event) */
+        writel(val, virtbase + U300_GPIO_PXIEV + port->number *
+                                U300_GPIO_PORTX_SPACING);
+        /* Print message */
+        while (val != 0) {
+                unsigned gpio;
+
+                pin = __ffs(val);
+                /* mask off this pin */
+                val &= ~(1 << pin);
+                gpio = (port->number << 3) + pin;
+
+                if (gpio_pin[gpio].callback)
+                        (void)gpio_pin[gpio].callback(gpio_pin[gpio].data);
+                else
+                        dev_dbg(gpiodev, "stray GPIO IRQ on line %d\n",
+                               gpio);
+        }
+        return IRQ_HANDLED;
+}
+
+static void gpio_set_initial_values(void)
+{
+#ifdef U300_COH901571_3
+        int i, j;
+        unsigned long flags;
+        u32 val;
+
+        /* Write default values to all pins */
+        for (i = 0; i < U300_GPIO_NUM_PORTS; i++) {
+                val = 0;
+                for (j = 0; j < 8; j++)
+                        val |= (u32) (u300_gpio_config[i][j].default_output_value != DEFAULT_OUTPUT_LOW) << j;
+                local_irq_save(flags);
+                writel(val, virtbase + U300_GPIO_PXPDOR + i * U300_GPIO_PORTX_SPACING);
+                local_irq_restore(flags);
+        }
+
+        /*
+         * Put all pins that are set to either 'GPIO_OUT' or 'GPIO_NOT_USED'
+         * to output and 'GPIO_IN' to input for each port. And initialize
+         * default value on outputs.
+         */
+        for (i = 0; i < U300_GPIO_NUM_PORTS; i++) {
+                for (j = 0; j < U300_GPIO_PINS_PER_PORT; j++) {
+                        local_irq_save(flags);
+                        val = readl(virtbase + U300_GPIO_PXPCR +
+                                         i * U300_GPIO_PORTX_SPACING);
+                        /* Mask out this pin */
+                        val &= ~(U300_GPIO_PXPCR_PIN_MODE_MASK << (j << 1));
+
+                        if (u300_gpio_config[i][j].pin_usage != GPIO_IN)
+                                val |= (U300_GPIO_PXPCR_PIN_MODE_OUTPUT_PUSH_PULL << (j << 1));
+                        writel(val, virtbase + U300_GPIO_PXPCR +
+                                         i * U300_GPIO_PORTX_SPACING);
+                        local_irq_restore(flags);
+                }
+        }
+
+        /* Enable or disable the internal pull-ups in the GPIO ASIC block */
+        for (i = 0; i < U300_GPIO_MAX; i++) {
+                val = 0;
+                for (j = 0; j < 8; j++)
+                        val |= (u32)((u300_gpio_config[i][j].pull_up == DISABLE_PULL_UP) << j);
+                local_irq_save(flags);
+                writel(val, virtbase + U300_GPIO_PXPER + i * U300_GPIO_PORTX_SPACING);
+                local_irq_restore(flags);
+        }
+#endif
+}
+
+static int __init gpio_probe(struct platform_device *pdev)
+{
+        u32 val;
+        int err = 0;
+        int i;
+        int num_irqs;
+
+        gpiodev = &pdev->dev;
+        memset(gpio_pin, 0, sizeof(gpio_pin));
+
+        /* Get GPIO clock */
+        clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(clk)) {
+                err = PTR_ERR(clk);
+                dev_err(gpiodev, "could not get GPIO clock\n");
+                goto err_no_clk;
+        }
+        err = clk_enable(clk);
+        if (err) {
+                dev_err(gpiodev, "could not enable GPIO clock\n");
+                goto err_no_clk_enable;
+        }
+
+        memres = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!memres)
+                goto err_no_resource;
+
+        if (request_mem_region(memres->start, memres->end - memres->start, "GPIO Controller")
+            == NULL) {
+                err = -ENODEV;
+                goto err_no_ioregion;
+        }
+
+        virtbase = ioremap(memres->start, resource_size(memres));
+        if (!virtbase) {
+                err = -ENOMEM;
+                goto err_no_ioremap;
+        }
+        dev_info(gpiodev, "remapped 0x%08x to %p\n",
+                 memres->start, virtbase);
+
+#ifdef U300_COH901335
+        dev_info(gpiodev, "initializing GPIO Controller COH 901 335\n");
+        /* Turn on the GPIO block */
+        writel(U300_GPIO_CR_BLOCK_CLOCK_ENABLE, virtbase + U300_GPIO_CR);
+#endif
+
+#ifdef U300_COH901571_3
+        dev_info(gpiodev, "initializing GPIO Controller COH 901 571/3\n");
+        val = readl(virtbase + U300_GPIO_CR);
+        dev_info(gpiodev, "COH901571/3 block version: %d, " \
+               "number of cores: %d\n",
+               ((val & 0x0000FE00) >> 9),
+               ((val & 0x000001FC) >> 2));
+        writel(U300_GPIO_CR_BLOCK_CLKRQ_ENABLE, virtbase + U300_GPIO_CR);
+#endif
+
+        gpio_set_initial_values();
+
+        for (num_irqs = 0 ; num_irqs < U300_GPIO_NUM_PORTS; num_irqs++) {
+
+                gpio_ports[num_irqs].irq =
+                        platform_get_irq_byname(pdev,
+                                                gpio_ports[num_irqs].name);
+
+                err = request_irq(gpio_ports[num_irqs].irq,
+                                  gpio_irq_handler, IRQF_DISABLED,
+                                  gpio_ports[num_irqs].name,
+                                  &gpio_ports[num_irqs]);
+                if (err) {
+                        dev_err(gpiodev, "cannot allocate IRQ for %s!\n",
+                                gpio_ports[num_irqs].name);
+                        goto err_no_irq;
+                }
+                /* Turns off PortX_irq_force */
+                writel(0x0, virtbase + U300_GPIO_PXIFR +
+                                 num_irqs * U300_GPIO_PORTX_SPACING);
+        }
+
+        return 0;
+
+ err_no_irq:
+        for (i = 0; i < num_irqs; i++)
+                free_irq(gpio_ports[i].irq, &gpio_ports[i]);
+        iounmap(virtbase);
+ err_no_ioremap:
+        release_mem_region(memres->start, memres->end - memres->start);
+ err_no_ioregion:
+ err_no_resource:
+        clk_disable(clk);
+ err_no_clk_enable:
+        clk_put(clk);
+ err_no_clk:
+        dev_info(gpiodev, "module ERROR:%d\n", err);
+        return err;
+}
+
+static int __exit gpio_remove(struct platform_device *pdev)
+{
+        int i;
+
+        /* Turn off the GPIO block */
+        writel(0x00000000U, virtbase + U300_GPIO_CR);
+        for (i = 0 ; i < U300_GPIO_NUM_PORTS; i++)
+                free_irq(gpio_ports[i].irq, &gpio_ports[i]);
+        iounmap(virtbase);
+        release_mem_region(memres->start, memres->end - memres->start);
+        clk_disable(clk);
+        clk_put(clk);
+        return 0;
+}
+
+static struct platform_driver gpio_driver = {
+        .driver         = {
+                .name   = "u300-gpio",
+        },
+        .remove         = __exit_p(gpio_remove),
+};
+
+
+static int __init u300_gpio_init(void)
+{
+        return platform_driver_probe(&gpio_driver, gpio_probe);
+}
+
+static void __exit u300_gpio_exit(void)
+{
+        platform_driver_unregister(&gpio_driver);
+}
+
+arch_initcall(u300_gpio_init);
+module_exit(u300_gpio_exit);
+
+MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
+
+#ifdef U300_COH901571_3
+MODULE_DESCRIPTION("ST-Ericsson AB COH 901 571/3 GPIO driver");
+#endif
+
+#ifdef U300_COH901335
+MODULE_DESCRIPTION("ST-Ericsson AB COH 901 335 GPIO driver");
+#endif
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 137a8ca67822..a971e3d043ba 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -1296,7 +1296,7 @@ EXPORT_SYMBOL_GPL(gpio_request_one);
  * @array:      array of the 'struct gpio'
  * @num:        how many GPIOs in the array
  */
-int gpio_request_array(struct gpio *array, size_t num)
+int gpio_request_array(const struct gpio *array, size_t num)
 {
         int i, err;
 
@@ -1319,7 +1319,7 @@ EXPORT_SYMBOL_GPL(gpio_request_array);
  * @array:      array of the 'struct gpio'
  * @num:        how many GPIOs in the array
  */
-void gpio_free_array(struct gpio *array, size_t num)
+void gpio_free_array(const struct gpio *array, size_t num)
 {
         while (num--)
                 gpio_free((array++)->gpio);
diff --git a/drivers/gpio/langwell_gpio.c b/drivers/gpio/langwell_gpio.c
index 1b06f67e1f69..bd6571e0097a 100644
--- a/drivers/gpio/langwell_gpio.c
+++ b/drivers/gpio/langwell_gpio.c
@@ -33,6 +33,7 @@
 #include <linux/io.h>
 #include <linux/gpio.h>
 #include <linux/slab.h>
+#include <linux/pm_runtime.h>
 
 /*
  * Langwell chip has 64 pins and thus there are 2 32bit registers to control
@@ -63,6 +64,7 @@ struct lnw_gpio {
         void                            *reg_base;
         spinlock_t                      lock;
         unsigned                        irq_base;
+        struct pci_dev                  *pdev;
 };
 
 static void __iomem *gpio_reg(struct gpio_chip *chip, unsigned offset,
@@ -104,11 +106,18 @@ static int lnw_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
         u32 value;
         unsigned long flags;
 
+        if (lnw->pdev)
+                pm_runtime_get(&lnw->pdev->dev);
+
         spin_lock_irqsave(&lnw->lock, flags);
         value = readl(gpdr);
         value &= ~BIT(offset % 32);
         writel(value, gpdr);
         spin_unlock_irqrestore(&lnw->lock, flags);
+
+        if (lnw->pdev)
+                pm_runtime_put(&lnw->pdev->dev);
+
         return 0;
 }
 
@@ -120,11 +129,19 @@ static int lnw_gpio_direction_output(struct gpio_chip *chip,
         unsigned long flags;
 
         lnw_gpio_set(chip, offset, value);
+
+        if (lnw->pdev)
+                pm_runtime_get(&lnw->pdev->dev);
+
         spin_lock_irqsave(&lnw->lock, flags);
         value = readl(gpdr);
         value |= BIT(offset % 32);
         writel(value, gpdr);
         spin_unlock_irqrestore(&lnw->lock, flags);
+
+        if (lnw->pdev)
+                pm_runtime_put(&lnw->pdev->dev);
+
         return 0;
 }
 
@@ -145,6 +162,10 @@ static int lnw_irq_type(struct irq_data *d, unsigned type)
 
         if (gpio >= lnw->chip.ngpio)
                 return -EINVAL;
+
+        if (lnw->pdev)
+                pm_runtime_get(&lnw->pdev->dev);
+
         spin_lock_irqsave(&lnw->lock, flags);
         if (type & IRQ_TYPE_EDGE_RISING)
                 value = readl(grer) | BIT(gpio % 32);
@@ -159,6 +180,9 @@ static int lnw_irq_type(struct irq_data *d, unsigned type)
         writel(value, gfer);
         spin_unlock_irqrestore(&lnw->lock, flags);
 
+        if (lnw->pdev)
+                pm_runtime_put(&lnw->pdev->dev);
+
         return 0;
 }
 
@@ -211,6 +235,39 @@ static void lnw_irq_handler(unsigned irq, struct irq_desc *desc)
         chip->irq_eoi(data);
 }
 
+#ifdef CONFIG_PM
+static int lnw_gpio_runtime_resume(struct device *dev)
+{
+        return 0;
+}
+
+static int lnw_gpio_runtime_suspend(struct device *dev)
+{
+        return 0;
+}
+
+static int lnw_gpio_runtime_idle(struct device *dev)
+{
+        int err = pm_schedule_suspend(dev, 500);
+
+        if (!err)
+                return 0;
+
+        return -EBUSY;
+}
+
+#else
+#define lnw_gpio_runtime_suspend        NULL
+#define lnw_gpio_runtime_resume         NULL
+#define lnw_gpio_runtime_idle           NULL
+#endif
+
+static const struct dev_pm_ops lnw_gpio_pm_ops = {
+        .runtime_suspend = lnw_gpio_runtime_suspend,
+        .runtime_resume = lnw_gpio_runtime_resume,
+        .runtime_idle = lnw_gpio_runtime_idle,
+};
+
 static int __devinit lnw_gpio_probe(struct pci_dev *pdev,
                         const struct pci_device_id *id)
 {
@@ -270,6 +327,7 @@ static int __devinit lnw_gpio_probe(struct pci_dev *pdev,
         lnw->chip.base = gpio_base;
         lnw->chip.ngpio = id->driver_data;
         lnw->chip.can_sleep = 0;
+        lnw->pdev = pdev;
         pci_set_drvdata(pdev, lnw);
         retval = gpiochip_add(&lnw->chip);
         if (retval) {
@@ -285,6 +343,10 @@ static int __devinit lnw_gpio_probe(struct pci_dev *pdev,
         }
 
         spin_lock_init(&lnw->lock);
+
+        pm_runtime_put_noidle(&pdev->dev);
+        pm_runtime_allow(&pdev->dev);
+
         goto done;
 err5:
         kfree(lnw);
@@ -302,6 +364,9 @@ static struct pci_driver lnw_gpio_driver = {
         .name           = "langwell_gpio",
         .id_table       = lnw_gpio_ids,
         .probe          = lnw_gpio_probe,
+        .driver         = {
+                .pm     = &lnw_gpio_pm_ops,
+        },
 };
 
 
diff --git a/drivers/gpio/pca953x.c b/drivers/gpio/pca953x.c
index 78a843947d82..0451d7ac94ac 100644
--- a/drivers/gpio/pca953x.c
+++ b/drivers/gpio/pca953x.c
@@ -24,33 +24,46 @@
 #include <linux/of_gpio.h>
 #endif
 
-#define PCA953X_INPUT          0
-#define PCA953X_OUTPUT         1
-#define PCA953X_INVERT         2
-#define PCA953X_DIRECTION      3
-
-#define PCA953X_GPIOS          0x00FF
-#define PCA953X_INT            0x0100
+#define PCA953X_INPUT           0
+#define PCA953X_OUTPUT          1
+#define PCA953X_INVERT          2
+#define PCA953X_DIRECTION       3
+
+#define PCA957X_IN              0
+#define PCA957X_INVRT           1
+#define PCA957X_BKEN            2
+#define PCA957X_PUPD            3
+#define PCA957X_CFG             4
+#define PCA957X_OUT             5
+#define PCA957X_MSK             6
+#define PCA957X_INTS            7
+
+#define PCA_GPIO_MASK           0x00FF
+#define PCA_INT                 0x0100
+#define PCA953X_TYPE            0x1000
+#define PCA957X_TYPE            0x2000
 
 static const struct i2c_device_id pca953x_id[] = {
-        { "pca9534", 8  | PCA953X_INT, },
-        { "pca9535", 16 | PCA953X_INT, },
-        { "pca9536", 4, },
-        { "pca9537", 4  | PCA953X_INT, },
-        { "pca9538", 8  | PCA953X_INT, },
-        { "pca9539", 16 | PCA953X_INT, },
-        { "pca9554", 8  | PCA953X_INT, },
-        { "pca9555", 16 | PCA953X_INT, },
-        { "pca9556", 8, },
-        { "pca9557", 8, },
-
-        { "max7310", 8, },
-        { "max7312", 16 | PCA953X_INT, },
-        { "max7313", 16 | PCA953X_INT, },
-        { "max7315", 8  | PCA953X_INT, },
-        { "pca6107", 8  | PCA953X_INT, },
-        { "tca6408", 8  | PCA953X_INT, },
-        { "tca6416", 16 | PCA953X_INT, },
+        { "pca9534", 8  | PCA953X_TYPE | PCA_INT, },
+        { "pca9535", 16 | PCA953X_TYPE | PCA_INT, },
+        { "pca9536", 4  | PCA953X_TYPE, },
+        { "pca9537", 4  | PCA953X_TYPE | PCA_INT, },
+        { "pca9538", 8  | PCA953X_TYPE | PCA_INT, },
+        { "pca9539", 16 | PCA953X_TYPE | PCA_INT, },
+        { "pca9554", 8  | PCA953X_TYPE | PCA_INT, },
+        { "pca9555", 16 | PCA953X_TYPE | PCA_INT, },
+        { "pca9556", 8  | PCA953X_TYPE, },
+        { "pca9557", 8  | PCA953X_TYPE, },
+        { "pca9574", 8  | PCA957X_TYPE | PCA_INT, },
+        { "pca9575", 16 | PCA957X_TYPE | PCA_INT, },
+
+        { "max7310", 8  | PCA953X_TYPE, },
+        { "max7312", 16 | PCA953X_TYPE | PCA_INT, },
+        { "max7313", 16 | PCA953X_TYPE | PCA_INT, },
+        { "max7315", 8  | PCA953X_TYPE | PCA_INT, },
+        { "pca6107", 8  | PCA953X_TYPE | PCA_INT, },
+        { "tca6408", 8  | PCA953X_TYPE | PCA_INT, },
+        { "tca6416", 16 | PCA953X_TYPE | PCA_INT, },
         /* NYET:  { "tca6424", 24, }, */
         { }
 };
@@ -75,16 +88,32 @@ struct pca953x_chip {
         struct pca953x_platform_data *dyn_pdata;
         struct gpio_chip gpio_chip;
         const char *const *names;
+        int     chip_type;
 };
 
 static int pca953x_write_reg(struct pca953x_chip *chip, int reg, uint16_t val)
 {
-        int ret;
+        int ret = 0;
 
         if (chip->gpio_chip.ngpio <= 8)
                 ret = i2c_smbus_write_byte_data(chip->client, reg, val);
-        else
-                ret = i2c_smbus_write_word_data(chip->client, reg << 1, val);
+        else {
+                switch (chip->chip_type) {
+                case PCA953X_TYPE:
+                        ret = i2c_smbus_write_word_data(chip->client,
+                                                        reg << 1, val);
+                        break;
+                case PCA957X_TYPE:
+                        ret = i2c_smbus_write_byte_data(chip->client, reg << 1,
+                                                        val & 0xff);
+                        if (ret < 0)
+                                break;
+                        ret = i2c_smbus_write_byte_data(chip->client,
+                                                        (reg << 1) + 1,
+                                                        (val & 0xff00) >> 8);
+                        break;
+                }
+        }
 
         if (ret < 0) {
                 dev_err(&chip->client->dev, "failed writing register\n");
@@ -116,13 +145,22 @@ static int pca953x_gpio_direction_input(struct gpio_chip *gc, unsigned off)
 {
         struct pca953x_chip *chip;
         uint16_t reg_val;
-        int ret;
+        int ret, offset = 0;
 
         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 
         mutex_lock(&chip->i2c_lock);
         reg_val = chip->reg_direction | (1u << off);
-        ret = pca953x_write_reg(chip, PCA953X_DIRECTION, reg_val);
+
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_DIRECTION;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_CFG;
+                break;
+        }
+        ret = pca953x_write_reg(chip, offset, reg_val);
         if (ret)
                 goto exit;
 
@@ -138,7 +176,7 @@ static int pca953x_gpio_direction_output(struct gpio_chip *gc,
 {
         struct pca953x_chip *chip;
         uint16_t reg_val;
-        int ret;
+        int ret, offset = 0;
 
         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 
@@ -149,7 +187,15 @@ static int pca953x_gpio_direction_output(struct gpio_chip *gc,
         else
                 reg_val = chip->reg_output & ~(1u << off);
 
-        ret = pca953x_write_reg(chip, PCA953X_OUTPUT, reg_val);
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_OUTPUT;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_OUT;
+                break;
+        }
+        ret = pca953x_write_reg(chip, offset, reg_val);
         if (ret)
                 goto exit;
 
@@ -157,7 +203,15 @@ static int pca953x_gpio_direction_output(struct gpio_chip *gc,
 
         /* then direction */
         reg_val = chip->reg_direction & ~(1u << off);
-        ret = pca953x_write_reg(chip, PCA953X_DIRECTION, reg_val);
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_DIRECTION;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_CFG;
+                break;
+        }
+        ret = pca953x_write_reg(chip, offset, reg_val);
         if (ret)
                 goto exit;
 
@@ -172,12 +226,20 @@ static int pca953x_gpio_get_value(struct gpio_chip *gc, unsigned off)
 {
         struct pca953x_chip *chip;
         uint16_t reg_val;
-        int ret;
+        int ret, offset = 0;
 
         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 
         mutex_lock(&chip->i2c_lock);
-        ret = pca953x_read_reg(chip, PCA953X_INPUT, &reg_val);
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_INPUT;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_IN;
+                break;
+        }
+        ret = pca953x_read_reg(chip, offset, &reg_val);
         mutex_unlock(&chip->i2c_lock);
         if (ret < 0) {
                 /* NOTE:  diagnostic already emitted; that's all we should
@@ -194,7 +256,7 @@ static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
 {
         struct pca953x_chip *chip;
         uint16_t reg_val;
-        int ret;
+        int ret, offset = 0;
 
         chip = container_of(gc, struct pca953x_chip, gpio_chip);
 
@@ -204,7 +266,15 @@ static void pca953x_gpio_set_value(struct gpio_chip *gc, unsigned off, int val)
         else
                 reg_val = chip->reg_output & ~(1u << off);
 
-        ret = pca953x_write_reg(chip, PCA953X_OUTPUT, reg_val);
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_OUTPUT;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_OUT;
+                break;
+        }
+        ret = pca953x_write_reg(chip, offset, reg_val);
         if (ret)
                 goto exit;
 
@@ -322,9 +392,17 @@ static uint16_t pca953x_irq_pending(struct pca953x_chip *chip)
         uint16_t old_stat;
         uint16_t pending;
         uint16_t trigger;
-        int ret;
-
-        ret = pca953x_read_reg(chip, PCA953X_INPUT, &cur_stat);
+        int ret, offset = 0;
+
+        switch (chip->chip_type) {
+        case PCA953X_TYPE:
+                offset = PCA953X_INPUT;
+                break;
+        case PCA957X_TYPE:
+                offset = PCA957X_IN;
+                break;
+        }
+        ret = pca953x_read_reg(chip, offset, &cur_stat);
         if (ret)
                 return 0;
 
@@ -372,14 +450,21 @@ static int pca953x_irq_setup(struct pca953x_chip *chip,
 {
         struct i2c_client *client = chip->client;
         struct pca953x_platform_data *pdata = client->dev.platform_data;
-        int ret;
+        int ret, offset = 0;
 
         if (pdata->irq_base != -1
-                        && (id->driver_data & PCA953X_INT)) {
+                        && (id->driver_data & PCA_INT)) {
                 int lvl;
 
-                ret = pca953x_read_reg(chip, PCA953X_INPUT,
-                                       &chip->irq_stat);
+                switch (chip->chip_type) {
+                case PCA953X_TYPE:
+                        offset = PCA953X_INPUT;
+                        break;
+                case PCA957X_TYPE:
+                        offset = PCA957X_IN;
+                        break;
+                }
+                ret = pca953x_read_reg(chip, offset, &chip->irq_stat);
                 if (ret)
                         goto out_failed;
 
@@ -439,7 +524,7 @@ static int pca953x_irq_setup(struct pca953x_chip *chip,
         struct i2c_client *client = chip->client;
         struct pca953x_platform_data *pdata = client->dev.platform_data;
 
-        if (pdata->irq_base != -1 && (id->driver_data & PCA953X_INT))
+        if (pdata->irq_base != -1 && (id->driver_data & PCA_INT))
                 dev_warn(&client->dev, "interrupt support not compiled in\n");
 
         return 0;
@@ -499,12 +584,65 @@ pca953x_get_alt_pdata(struct i2c_client *client)
 }
 #endif
 
+static int __devinit device_pca953x_init(struct pca953x_chip *chip, int invert)
+{
+        int ret;
+
+        ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
+        if (ret)
+                goto out;
+
+        ret = pca953x_read_reg(chip, PCA953X_DIRECTION,
+                               &chip->reg_direction);
+        if (ret)
+                goto out;
+
+        /* set platform specific polarity inversion */
+        ret = pca953x_write_reg(chip, PCA953X_INVERT, invert);
+        if (ret)
+                goto out;
+        return 0;
+out:
+        return ret;
+}
+
+static int __devinit device_pca957x_init(struct pca953x_chip *chip, int invert)
+{
+        int ret;
+        uint16_t val = 0;
+
+        /* Let every port in proper state, that could save power */
+        pca953x_write_reg(chip, PCA957X_PUPD, 0x0);
+        pca953x_write_reg(chip, PCA957X_CFG, 0xffff);
+        pca953x_write_reg(chip, PCA957X_OUT, 0x0);
+
+        ret = pca953x_read_reg(chip, PCA957X_IN, &val);
+        if (ret)
+                goto out;
+        ret = pca953x_read_reg(chip, PCA957X_OUT, &chip->reg_output);
+        if (ret)
+                goto out;
+        ret = pca953x_read_reg(chip, PCA957X_CFG, &chip->reg_direction);
+        if (ret)
+                goto out;
+
+        /* set platform specific polarity inversion */
+        pca953x_write_reg(chip, PCA957X_INVRT, invert);
+
+        /* To enable register 6, 7 to controll pull up and pull down */
+        pca953x_write_reg(chip, PCA957X_BKEN, 0x202);
+
+        return 0;
+out:
+        return ret;
+}
+
 static int __devinit pca953x_probe(struct i2c_client *client,
                                    const struct i2c_device_id *id)
 {
         struct pca953x_platform_data *pdata;
         struct pca953x_chip *chip;
-        int ret;
+        int ret = 0;
 
         chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
         if (chip == NULL)
@@ -531,25 +669,20 @@ static int __devinit pca953x_probe(struct i2c_client *client,
         chip->gpio_start = pdata->gpio_base;
 
         chip->names = pdata->names;
+        chip->chip_type = id->driver_data & (PCA953X_TYPE | PCA957X_TYPE);
 
         mutex_init(&chip->i2c_lock);
 
         /* initialize cached registers from their original values.
          * we can't share this chip with another i2c master.
          */
-        pca953x_setup_gpio(chip, id->driver_data & PCA953X_GPIOS);
+        pca953x_setup_gpio(chip, id->driver_data & PCA_GPIO_MASK);
 
-        ret = pca953x_read_reg(chip, PCA953X_OUTPUT, &chip->reg_output);
-        if (ret)
-                goto out_failed;
-
-        ret = pca953x_read_reg(chip, PCA953X_DIRECTION, &chip->reg_direction);
-        if (ret)
-                goto out_failed;
-
-        /* set platform specific polarity inversion */
-        ret = pca953x_write_reg(chip, PCA953X_INVERT, pdata->invert);
-        if (ret)
+        if (chip->chip_type == PCA953X_TYPE)
+                device_pca953x_init(chip, pdata->invert);
+        else if (chip->chip_type == PCA957X_TYPE)
+                device_pca957x_init(chip, pdata->invert);
+        else
                 goto out_failed;
 
         ret = pca953x_irq_setup(chip, id);
diff --git a/drivers/gpio/pch_gpio.c b/drivers/gpio/pch_gpio.c
index f970a5f3585e..36919e77c495 100644
--- a/drivers/gpio/pch_gpio.c
+++ b/drivers/gpio/pch_gpio.c
@@ -283,8 +283,10 @@ static int pch_gpio_resume(struct pci_dev *pdev)
 #define pch_gpio_resume NULL
 #endif
 
+#define PCI_VENDOR_ID_ROHM             0x10DB
 static DEFINE_PCI_DEVICE_TABLE(pch_gpio_pcidev_id) = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x8803) },
+        { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x8014) },
         { 0, }
 };
 MODULE_DEVICE_TABLE(pci, pch_gpio_pcidev_id);
diff --git a/drivers/ide/ide-cd.c b/drivers/ide/ide-cd.c
index 6e5123b1d341..144d27261e43 100644
--- a/drivers/ide/ide-cd.c
+++ b/drivers/ide/ide-cd.c
@@ -1782,7 +1782,6 @@ static int ide_cd_probe(ide_drive_t *drive)
         ide_cd_read_toc(drive, &sense);
         g->fops = &idecd_ops;
         g->flags |= GENHD_FL_REMOVABLE | GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE;
-        g->events = DISK_EVENT_MEDIA_CHANGE;
         add_disk(g);
         return 0;
 
diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
index 76a5af00a26b..2067288f61f9 100644
--- a/drivers/md/dm-io.c
+++ b/drivers/md/dm-io.c
@@ -19,6 +19,8 @@
 #define DM_MSG_PREFIX "io"
 
 #define DM_IO_MAX_REGIONS       BITS_PER_LONG
+#define MIN_IOS         16
+#define MIN_BIOS        16
 
 struct dm_io_client {
         mempool_t *pool;
@@ -41,33 +43,21 @@ struct io {
 static struct kmem_cache *_dm_io_cache;
 
 /*
- * io contexts are only dynamically allocated for asynchronous
- * io.  Since async io is likely to be the majority of io we'll
- * have the same number of io contexts as bios! (FIXME: must reduce this).
- */
-
-static unsigned int pages_to_ios(unsigned int pages)
-{
-        return 4 * pages;       /* too many ? */
-}
-
-/*
  * Create a client with mempool and bioset.
  */
-struct dm_io_client *dm_io_client_create(unsigned num_pages)
+struct dm_io_client *dm_io_client_create(void)
 {
-        unsigned ios = pages_to_ios(num_pages);
         struct dm_io_client *client;
 
         client = kmalloc(sizeof(*client), GFP_KERNEL);
         if (!client)
                 return ERR_PTR(-ENOMEM);
 
-        client->pool = mempool_create_slab_pool(ios, _dm_io_cache);
+        client->pool = mempool_create_slab_pool(MIN_IOS, _dm_io_cache);
         if (!client->pool)
                 goto bad;
 
-        client->bios = bioset_create(16, 0);
+        client->bios = bioset_create(MIN_BIOS, 0);
         if (!client->bios)
                 goto bad;
 
@@ -81,13 +71,6 @@ struct dm_io_client *dm_io_client_create(unsigned num_pages)
 }
 EXPORT_SYMBOL(dm_io_client_create);
 
-int dm_io_client_resize(unsigned num_pages, struct dm_io_client *client)
-{
-        return mempool_resize(client->pool, pages_to_ios(num_pages),
-                              GFP_KERNEL);
-}
-EXPORT_SYMBOL(dm_io_client_resize);
-
 void dm_io_client_destroy(struct dm_io_client *client)
 {
         mempool_destroy(client->pool);
diff --git a/drivers/md/dm-kcopyd.c b/drivers/md/dm-kcopyd.c
index 1bb73a13ca40..819e37eaaeba 100644
--- a/drivers/md/dm-kcopyd.c
+++ b/drivers/md/dm-kcopyd.c
@@ -27,15 +27,19 @@
 
 #include "dm.h"
 
+#define SUB_JOB_SIZE    128
+#define SPLIT_COUNT     8
+#define MIN_JOBS        8
+#define RESERVE_PAGES   (DIV_ROUND_UP(SUB_JOB_SIZE << SECTOR_SHIFT, PAGE_SIZE))
+
 /*-----------------------------------------------------------------
  * Each kcopyd client has its own little pool of preallocated
  * pages for kcopyd io.
  *---------------------------------------------------------------*/
 struct dm_kcopyd_client {
-        spinlock_t lock;
         struct page_list *pages;
-        unsigned int nr_pages;
-        unsigned int nr_free_pages;
+        unsigned nr_reserved_pages;
+        unsigned nr_free_pages;
 
         struct dm_io_client *io_client;
 
@@ -67,15 +71,18 @@ static void wake(struct dm_kcopyd_client *kc)
         queue_work(kc->kcopyd_wq, &kc->kcopyd_work);
 }
 
-static struct page_list *alloc_pl(void)
+/*
+ * Obtain one page for the use of kcopyd.
+ */
+static struct page_list *alloc_pl(gfp_t gfp)
 {
         struct page_list *pl;
 
-        pl = kmalloc(sizeof(*pl), GFP_KERNEL);
+        pl = kmalloc(sizeof(*pl), gfp);
         if (!pl)
                 return NULL;
 
-        pl->page = alloc_page(GFP_KERNEL);
+        pl->page = alloc_page(gfp);
         if (!pl->page) {
                 kfree(pl);
                 return NULL;
@@ -90,41 +97,56 @@ static void free_pl(struct page_list *pl)
         kfree(pl);
 }
 
-static int kcopyd_get_pages(struct dm_kcopyd_client *kc,
-                            unsigned int nr, struct page_list **pages)
+/*
+ * Add the provided pages to a client's free page list, releasing
+ * back to the system any beyond the reserved_pages limit.
+ */
+static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl)
 {
-        struct page_list *pl;
-
-        spin_lock(&kc->lock);
-        if (kc->nr_free_pages < nr) {
-                spin_unlock(&kc->lock);
-                return -ENOMEM;
-        }
-
-        kc->nr_free_pages -= nr;
-        for (*pages = pl = kc->pages; --nr; pl = pl->next)
-                ;
+        struct page_list *next;
 
-        kc->pages = pl->next;
-        pl->next = NULL;
+        do {
+                next = pl->next;
 
-        spin_unlock(&kc->lock);
+                if (kc->nr_free_pages >= kc->nr_reserved_pages)
+                        free_pl(pl);
+                else {
+                        pl->next = kc->pages;
+                        kc->pages = pl;
+                        kc->nr_free_pages++;
+                }
 
-        return 0;
+                pl = next;
+        } while (pl);
 }
 
-static void kcopyd_put_pages(struct dm_kcopyd_client *kc, struct page_list *pl)
+static int kcopyd_get_pages(struct dm_kcopyd_client *kc,
+                            unsigned int nr, struct page_list **pages)
 {
-        struct page_list *cursor;
+        struct page_list *pl;
+
+        *pages = NULL;
+
+        do {
+                pl = alloc_pl(__GFP_NOWARN | __GFP_NORETRY);
+                if (unlikely(!pl)) {
+                        /* Use reserved pages */
+                        pl = kc->pages;
+                        if (unlikely(!pl))
+                                goto out_of_memory;
+                        kc->pages = pl->next;
+                        kc->nr_free_pages--;
+                }
+                pl->next = *pages;
+                *pages = pl;
+        } while (--nr);
 
-        spin_lock(&kc->lock);
-        for (cursor = pl; cursor->next; cursor = cursor->next)
-                kc->nr_free_pages++;
+        return 0;
 
-        kc->nr_free_pages++;
-        cursor->next = kc->pages;
-        kc->pages = pl;
-        spin_unlock(&kc->lock);
+out_of_memory:
+        if (*pages)
+                kcopyd_put_pages(kc, *pages);
+        return -ENOMEM;
 }
 
 /*
@@ -141,13 +163,16 @@ static void drop_pages(struct page_list *pl)
         }
 }
 
-static int client_alloc_pages(struct dm_kcopyd_client *kc, unsigned int nr)
+/*
+ * Allocate and reserve nr_pages for the use of a specific client.
+ */
+static int client_reserve_pages(struct dm_kcopyd_client *kc, unsigned nr_pages)
 {
-        unsigned int i;
+        unsigned i;
         struct page_list *pl = NULL, *next;
 
-        for (i = 0; i < nr; i++) {
-                next = alloc_pl();
+        for (i = 0; i < nr_pages; i++) {
+                next = alloc_pl(GFP_KERNEL);
                 if (!next) {
                         if (pl)
                                 drop_pages(pl);
@@ -157,17 +182,18 @@ static int client_alloc_pages(struct dm_kcopyd_client *kc, unsigned int nr)
                 pl = next;
         }
 
+        kc->nr_reserved_pages += nr_pages;
         kcopyd_put_pages(kc, pl);
-        kc->nr_pages += nr;
+
         return 0;
 }
 
 static void client_free_pages(struct dm_kcopyd_client *kc)
 {
-        BUG_ON(kc->nr_free_pages != kc->nr_pages);
+        BUG_ON(kc->nr_free_pages != kc->nr_reserved_pages);
         drop_pages(kc->pages);
         kc->pages = NULL;
-        kc->nr_free_pages = kc->nr_pages = 0;
+        kc->nr_free_pages = kc->nr_reserved_pages = 0;
 }
 
 /*-----------------------------------------------------------------
@@ -216,16 +242,17 @@ struct kcopyd_job {
         struct mutex lock;
         atomic_t sub_jobs;
         sector_t progress;
-};
 
-/* FIXME: this should scale with the number of pages */
-#define MIN_JOBS 512
+        struct kcopyd_job *master_job;
+};
 
 static struct kmem_cache *_job_cache;
 
 int __init dm_kcopyd_init(void)
 {
-        _job_cache = KMEM_CACHE(kcopyd_job, 0);
+        _job_cache = kmem_cache_create("kcopyd_job",
+                                sizeof(struct kcopyd_job) * (SPLIT_COUNT + 1),
+                                __alignof__(struct kcopyd_job), 0, NULL);
         if (!_job_cache)
                 return -ENOMEM;
 
@@ -299,7 +326,12 @@ static int run_complete_job(struct kcopyd_job *job)
 
         if (job->pages)
                 kcopyd_put_pages(kc, job->pages);
-        mempool_free(job, kc->job_pool);
+        /*
+         * If this is the master job, the sub jobs have already
+         * completed so we can free everything.
+         */
+        if (job->master_job == job)
+                mempool_free(job, kc->job_pool);
         fn(read_err, write_err, context);
 
         if (atomic_dec_and_test(&kc->nr_jobs))
@@ -460,14 +492,14 @@ static void dispatch_job(struct kcopyd_job *job)
         wake(kc);
 }
 
-#define SUB_JOB_SIZE 128
 static void segment_complete(int read_err, unsigned long write_err,
                              void *context)
 {
         /* FIXME: tidy this function */
         sector_t progress = 0;
         sector_t count = 0;
-        struct kcopyd_job *job = (struct kcopyd_job *) context;
+        struct kcopyd_job *sub_job = (struct kcopyd_job *) context;
+        struct kcopyd_job *job = sub_job->master_job;
         struct dm_kcopyd_client *kc = job->kc;
 
         mutex_lock(&job->lock);
@@ -498,8 +530,6 @@ static void segment_complete(int read_err, unsigned long write_err,
 
         if (count) {
                 int i;
-                struct kcopyd_job *sub_job = mempool_alloc(kc->job_pool,
-                                                           GFP_NOIO);
 
                 *sub_job = *job;
                 sub_job->source.sector += progress;
@@ -511,7 +541,7 @@ static void segment_complete(int read_err, unsigned long write_err,
                 }
 
                 sub_job->fn = segment_complete;
-                sub_job->context = job;
+                sub_job->context = sub_job;
                 dispatch_job(sub_job);
 
         } else if (atomic_dec_and_test(&job->sub_jobs)) {
@@ -531,19 +561,19 @@ static void segment_complete(int read_err, unsigned long write_err,
 }
 
 /*
- * Create some little jobs that will do the move between
- * them.
+ * Create some sub jobs to share the work between them.
  */
-#define SPLIT_COUNT 8
-static void split_job(struct kcopyd_job *job)
+static void split_job(struct kcopyd_job *master_job)
 {
         int i;
 
-        atomic_inc(&job->kc->nr_jobs);
+        atomic_inc(&master_job->kc->nr_jobs);
 
-        atomic_set(&job->sub_jobs, SPLIT_COUNT);
-        for (i = 0; i < SPLIT_COUNT; i++)
-                segment_complete(0, 0u, job);
+        atomic_set(&master_job->sub_jobs, SPLIT_COUNT);
+        for (i = 0; i < SPLIT_COUNT; i++) {
+                master_job[i + 1].master_job = master_job;
+                segment_complete(0, 0u, &master_job[i + 1]);
+        }
 }
 
 int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
@@ -553,7 +583,8 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
         struct kcopyd_job *job;
 
         /*
-         * Allocate a new job.
+         * Allocate an array of jobs consisting of one master job
+         * followed by SPLIT_COUNT sub jobs.
          */
         job = mempool_alloc(kc->job_pool, GFP_NOIO);
 
@@ -577,10 +608,10 @@ int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
 
         job->fn = fn;
         job->context = context;
+        job->master_job = job;
 
-        if (job->source.count < SUB_JOB_SIZE)
+        if (job->source.count <= SUB_JOB_SIZE)
                 dispatch_job(job);
-
         else {
                 mutex_init(&job->lock);
                 job->progress = 0;
@@ -606,17 +637,15 @@ int kcopyd_cancel(struct kcopyd_job *job, int block)
 /*-----------------------------------------------------------------
  * Client setup
  *---------------------------------------------------------------*/
-int dm_kcopyd_client_create(unsigned int nr_pages,
-                            struct dm_kcopyd_client **result)
+struct dm_kcopyd_client *dm_kcopyd_client_create(void)
 {
         int r = -ENOMEM;
         struct dm_kcopyd_client *kc;
 
         kc = kmalloc(sizeof(*kc), GFP_KERNEL);
         if (!kc)
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
-        spin_lock_init(&kc->lock);
         spin_lock_init(&kc->job_lock);
         INIT_LIST_HEAD(&kc->complete_jobs);
         INIT_LIST_HEAD(&kc->io_jobs);
@@ -633,12 +662,12 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
                 goto bad_workqueue;
 
         kc->pages = NULL;
-        kc->nr_pages = kc->nr_free_pages = 0;
-        r = client_alloc_pages(kc, nr_pages);
+        kc->nr_reserved_pages = kc->nr_free_pages = 0;
+        r = client_reserve_pages(kc, RESERVE_PAGES);
         if (r)
                 goto bad_client_pages;
 
-        kc->io_client = dm_io_client_create(nr_pages);
+        kc->io_client = dm_io_client_create();
         if (IS_ERR(kc->io_client)) {
                 r = PTR_ERR(kc->io_client);
                 goto bad_io_client;
@@ -647,8 +676,7 @@ int dm_kcopyd_client_create(unsigned int nr_pages,
         init_waitqueue_head(&kc->destroyq);
         atomic_set(&kc->nr_jobs, 0);
 
-        *result = kc;
-        return 0;
+        return kc;
 
 bad_io_client:
         client_free_pages(kc);
@@ -659,7 +687,7 @@ bad_workqueue:
 bad_slab:
         kfree(kc);
 
-        return r;
+        return ERR_PTR(r);
 }
 EXPORT_SYMBOL(dm_kcopyd_client_create);
 
diff --git a/drivers/md/dm-log.c b/drivers/md/dm-log.c
index a1f321889676..948e3f4925bf 100644
--- a/drivers/md/dm-log.c
+++ b/drivers/md/dm-log.c
@@ -449,8 +449,7 @@ static int create_log_context(struct dm_dirty_log *log, struct dm_target *ti,
 
                 lc->io_req.mem.type = DM_IO_VMA;
                 lc->io_req.notify.fn = NULL;
-                lc->io_req.client = dm_io_client_create(dm_div_up(buf_size,
-                                                                   PAGE_SIZE));
+                lc->io_req.client = dm_io_client_create();
                 if (IS_ERR(lc->io_req.client)) {
                         r = PTR_ERR(lc->io_req.client);
                         DMWARN("couldn't allocate disk io client");
diff --git a/drivers/md/dm-mpath.c b/drivers/md/dm-mpath.c
index a550a057d991..aa4e570c2cb5 100644
--- a/drivers/md/dm-mpath.c
+++ b/drivers/md/dm-mpath.c
@@ -1290,7 +1290,7 @@ static int do_end_io(struct multipath *m, struct request *clone,
         if (!error && !clone->errors)
                 return 0;       /* I/O complete */
 
-        if (error == -EOPNOTSUPP || error == -EREMOTEIO)
+        if (error == -EOPNOTSUPP || error == -EREMOTEIO || error == -EILSEQ)
                 return error;
 
         if (mpio->pgpath)
diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
index 976ad4688afc..9bfd057be686 100644
--- a/drivers/md/dm-raid1.c
+++ b/drivers/md/dm-raid1.c
@@ -22,8 +22,6 @@
 #define DM_MSG_PREFIX "raid1"
 
 #define MAX_RECOVERY 1  /* Maximum number of regions recovered in parallel. */
-#define DM_IO_PAGES 64
-#define DM_KCOPYD_PAGES 64
 
 #define DM_RAID1_HANDLE_ERRORS 0x01
 #define errors_handled(p)       ((p)->features & DM_RAID1_HANDLE_ERRORS)
@@ -887,7 +885,7 @@ static struct mirror_set *alloc_context(unsigned int nr_mirrors,
                 return NULL;
         }
 
-        ms->io_client = dm_io_client_create(DM_IO_PAGES);
+        ms->io_client = dm_io_client_create();
         if (IS_ERR(ms->io_client)) {
                 ti->error = "Error creating dm_io client";
                 mempool_destroy(ms->read_record_pool);
@@ -1117,9 +1115,11 @@ static int mirror_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto err_destroy_wq;
         }
 
-        r = dm_kcopyd_client_create(DM_KCOPYD_PAGES, &ms->kcopyd_client);
-        if (r)
+        ms->kcopyd_client = dm_kcopyd_client_create();
+        if (IS_ERR(ms->kcopyd_client)) {
+                r = PTR_ERR(ms->kcopyd_client);
                 goto err_destroy_wq;
+        }
 
         wakeup_mirrord(ms);
         return 0;
diff --git a/drivers/md/dm-snap-persistent.c b/drivers/md/dm-snap-persistent.c
index 95891dfcbca0..135c2f1fdbfc 100644
--- a/drivers/md/dm-snap-persistent.c
+++ b/drivers/md/dm-snap-persistent.c
@@ -154,11 +154,6 @@ struct pstore {
         struct workqueue_struct *metadata_wq;
 };
 
-static unsigned sectors_to_pages(unsigned sectors)
-{
-        return DIV_ROUND_UP(sectors, PAGE_SIZE >> 9);
-}
-
 static int alloc_area(struct pstore *ps)
 {
         int r = -ENOMEM;
@@ -318,8 +313,7 @@ static int read_header(struct pstore *ps, int *new_snapshot)
                 chunk_size_supplied = 0;
         }
 
-        ps->io_client = dm_io_client_create(sectors_to_pages(ps->store->
-                                                             chunk_size));
+        ps->io_client = dm_io_client_create();
         if (IS_ERR(ps->io_client))
                 return PTR_ERR(ps->io_client);
 
@@ -368,11 +362,6 @@ static int read_header(struct pstore *ps, int *new_snapshot)
                 return r;
         }
 
-        r = dm_io_client_resize(sectors_to_pages(ps->store->chunk_size),
-                                ps->io_client);
-        if (r)
-                return r;
-
         r = alloc_area(ps);
         return r;
 
diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
index a2d330942cb2..9ecff5f3023a 100644
--- a/drivers/md/dm-snap.c
+++ b/drivers/md/dm-snap.c
@@ -40,11 +40,6 @@ static const char dm_snapshot_merge_target_name[] = "snapshot-merge";
 #define SNAPSHOT_COPY_PRIORITY 2
 
 /*
- * Reserve 1MB for each snapshot initially (with minimum of 1 page).
- */
-#define SNAPSHOT_PAGES (((1UL << 20) >> PAGE_SHIFT) ? : 1)
-
-/*
  * The size of the mempool used to track chunks in use.
  */
 #define MIN_IOS 256
@@ -1116,8 +1111,9 @@ static int snapshot_ctr(struct dm_target *ti, unsigned int argc, char **argv)
                 goto bad_hash_tables;
         }
 
-        r = dm_kcopyd_client_create(SNAPSHOT_PAGES, &s->kcopyd_client);
-        if (r) {
+        s->kcopyd_client = dm_kcopyd_client_create();
+        if (IS_ERR(s->kcopyd_client)) {
+                r = PTR_ERR(s->kcopyd_client);
                 ti->error = "Could not create kcopyd client";
                 goto bad_kcopyd;
         }
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index cb8380c9767f..451c3bb176d2 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -362,6 +362,7 @@ static void close_dev(struct dm_dev_internal *d, struct mapped_device *md)
 static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
                                   sector_t start, sector_t len, void *data)
 {
+        struct request_queue *q;
         struct queue_limits *limits = data;
         struct block_device *bdev = dev->bdev;
         sector_t dev_size =
@@ -370,6 +371,22 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
                 limits->logical_block_size >> SECTOR_SHIFT;
         char b[BDEVNAME_SIZE];
 
+        /*
+         * Some devices exist without request functions,
+         * such as loop devices not yet bound to backing files.
+         * Forbid the use of such devices.
+         */
+        q = bdev_get_queue(bdev);
+        if (!q || !q->make_request_fn) {
+                DMWARN("%s: %s is not yet initialised: "
+                       "start=%llu, len=%llu, dev_size=%llu",
+                       dm_device_name(ti->table->md), bdevname(bdev, b),
+                       (unsigned long long)start,
+                       (unsigned long long)len,
+                       (unsigned long long)dev_size);
+                return 1;
+        }
+
         if (!dev_size)
                 return 0;
 
@@ -1346,7 +1363,8 @@ bool dm_table_supports_discards(struct dm_table *t)
                 return 0;
 
         /*
-         * Ensure that at least one underlying device supports discards.
+         * Unless any target used by the table set discards_supported,
+         * require at least one underlying device to support discards.
          * t->devices includes internal dm devices such as mirror logs
          * so we need to use iterate_devices here, which targets
          * supporting discard must provide.
@@ -1354,6 +1372,9 @@ bool dm_table_supports_discards(struct dm_table *t)
         while (i < dm_table_get_num_targets(t)) {
                 ti = dm_table_get_target(t, i++);
 
+                if (ti->discards_supported)
+                        return 1;
+
                 if (ti->type->iterate_devices &&
                     ti->type->iterate_devices(ti, device_discard_capable, NULL))
                         return 1;
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index b6c267724e14..0f09c057e796 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -721,7 +721,7 @@ config MFD_PM8XXX_IRQ
 
 config MFD_TPS65910
         bool "TPS65910 Power Management chip"
-        depends on I2C=y
+        depends on I2C=y && GPIOLIB
         select MFD_CORE
         select GPIO_TPS65910
         help
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index e63782107e2f..02a15d7cb3b0 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -2005,7 +2005,8 @@ static struct regulator_init_data db8500_regulators[DB8500_NUM_REGULATORS] = {
 static struct mfd_cell db8500_prcmu_devs[] = {
         {
                 .name = "db8500-prcmu-regulators",
-                .mfd_data = &db8500_regulators,
+                .platform_data = &db8500_regulators,
+                .pdata_size = sizeof(db8500_regulators),
         },
         {
                 .name = "cpufreq-u8500",
diff --git a/drivers/misc/kgdbts.c b/drivers/misc/kgdbts.c
index b0c56313dbbb..8cebec5e85ee 100644
--- a/drivers/misc/kgdbts.c
+++ b/drivers/misc/kgdbts.c
@@ -304,7 +304,10 @@ static int check_and_rewind_pc(char *put_str, char *arg)
                 return 1;
         }
         /* Readjust the instruction pointer if needed */
-        instruction_pointer_set(&kgdbts_regs, ip + offset);
+        ip += offset;
+#ifdef GDB_ADJUSTS_BREAK_OFFSET
+        instruction_pointer_set(&kgdbts_regs, ip);
+#endif
         return 0;
 }
 
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 4941e06fe2e1..5da5bea0f9f0 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -51,6 +51,7 @@ static unsigned int fmax = 515633;
  *                is asserted (likewise for RX)
  * @sdio: variant supports SDIO
  * @st_clkdiv: true if using a ST-specific clock divider algorithm
+ * @blksz_datactrl16: true if Block size is at b16..b30 position in datactrl register
  */
 struct variant_data {
         unsigned int            clkreg;
@@ -60,6 +61,7 @@ struct variant_data {
         unsigned int            fifohalfsize;
         bool                    sdio;
         bool                    st_clkdiv;
+        bool                    blksz_datactrl16;
 };
 
 static struct variant_data variant_arm = {
@@ -92,6 +94,17 @@ static struct variant_data variant_ux500 = {
         .st_clkdiv              = true,
 };
 
+static struct variant_data variant_ux500v2 = {
+        .fifosize               = 30 * 4,
+        .fifohalfsize           = 8 * 4,
+        .clkreg                 = MCI_CLK_ENABLE,
+        .clkreg_enable          = MCI_ST_UX500_HWFCEN,
+        .datalength_bits        = 24,
+        .sdio                   = true,
+        .st_clkdiv              = true,
+        .blksz_datactrl16       = true,
+};
+
 /*
  * This must be called with host->lock held
  */
@@ -465,7 +478,10 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
         blksz_bits = ffs(data->blksz) - 1;
         BUG_ON(1 << blksz_bits != data->blksz);
 
-        datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
+        if (variant->blksz_datactrl16)
+                datactrl = MCI_DPSM_ENABLE | (data->blksz << 16);
+        else
+                datactrl = MCI_DPSM_ENABLE | blksz_bits << 4;
 
         if (data->flags & MMC_DATA_READ)
                 datactrl |= MCI_DPSM_DIRECTION;
@@ -1311,9 +1327,14 @@ static struct amba_id mmci_ids[] = {
         },
         {
                 .id     = 0x00480180,
-                .mask   = 0x00ffffff,
+                .mask   = 0xf0ffffff,
                 .data   = &variant_ux500,
         },
+        {
+                .id     = 0x10480180,
+                .mask   = 0xf0ffffff,
+                .data   = &variant_ux500v2,
+        },
         { 0, 0 },
 };
 
diff --git a/drivers/mtd/Kconfig b/drivers/mtd/Kconfig
index bc50d5ea5534..4be8373d43e5 100644
--- a/drivers/mtd/Kconfig
+++ b/drivers/mtd/Kconfig
@@ -33,20 +33,6 @@ config MTD_TESTS
           should normally be compiled as kernel modules. The modules perform
           various checks and verifications when loaded.
 
-config MTD_PARTITIONS
-        bool "MTD partitioning support"
-        help
-          If you have a device which needs to divide its flash chip(s) up
-          into multiple 'partitions', each of which appears to the user as
-          a separate MTD device, you require this option to be enabled. If
-          unsure, say 'Y'.
-
-          Note, however, that you don't need this option for the DiskOnChip
-          devices. Partitioning on NFTL 'devices' is a different - that's the
-          'normal' form of partitioning used on a block device.
-
-if MTD_PARTITIONS
-
 config MTD_REDBOOT_PARTS
         tristate "RedBoot partition table parsing"
         ---help---
@@ -99,7 +85,7 @@ endif # MTD_REDBOOT_PARTS
 
 config MTD_CMDLINE_PARTS
         bool "Command line partition table parsing"
-        depends on MTD_PARTITIONS = "y" && MTD = "y"
+        depends on MTD = "y"
         ---help---
           Allow generic configuration of the MTD partition tables via the kernel
           command line. Multiple flash resources are supported for hardware where
@@ -163,8 +149,6 @@ config MTD_AR7_PARTS
         ---help---
           TI AR7 partitioning support
 
-endif # MTD_PARTITIONS
-
 comment "User Modules And Translation Layers"
 
 config MTD_CHAR
diff --git a/drivers/mtd/Makefile b/drivers/mtd/Makefile
index d578095fb255..39664c4229ff 100644
--- a/drivers/mtd/Makefile
+++ b/drivers/mtd/Makefile
@@ -4,8 +4,7 @@
 
 # Core functionality.
 obj-$(CONFIG_MTD)               += mtd.o
-mtd-y                           := mtdcore.o mtdsuper.o mtdconcat.o
-mtd-$(CONFIG_MTD_PARTITIONS)    += mtdpart.o
+mtd-y                           := mtdcore.o mtdsuper.o mtdconcat.o mtdpart.o
 mtd-$(CONFIG_MTD_OF_PARTS)      += ofpart.o
 
 obj-$(CONFIG_MTD_REDBOOT_PARTS) += redboot.o
diff --git a/drivers/mtd/chips/cfi_cmdset_0001.c b/drivers/mtd/chips/cfi_cmdset_0001.c
index 09cb7c8d93b4..e1e122f2f929 100644
--- a/drivers/mtd/chips/cfi_cmdset_0001.c
+++ b/drivers/mtd/chips/cfi_cmdset_0001.c
@@ -812,12 +812,9 @@ static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long
                                 break;
 
                         if (time_after(jiffies, timeo)) {
-                                /* Urgh. Resume and pretend we weren't here.  */
-                                map_write(map, CMD(0xd0), adr);
-                                /* Make sure we're in 'read status' mode if it had finished */
-                                map_write(map, CMD(0x70), adr);
-                                chip->state = FL_ERASING;
-                                chip->oldstate = FL_READY;
+                                /* Urgh. Resume and pretend we weren't here.
+                                 * Make sure we're in 'read status' mode if it had finished */
+                                put_chip(map, chip, adr);
                                 printk(KERN_ERR "%s: Chip not ready after erase "
                                        "suspended: status = 0x%lx\n", map->name, status.x[0]);
                                 return -EIO;
@@ -997,7 +994,6 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
 
         switch(chip->oldstate) {
         case FL_ERASING:
-                chip->state = chip->oldstate;
                 /* What if one interleaved chip has finished and the
                    other hasn't? The old code would leave the finished
                    one in READY mode. That's bad, and caused -EROFS
diff --git a/drivers/mtd/chips/cfi_cmdset_0002.c b/drivers/mtd/chips/cfi_cmdset_0002.c
index 0b49266840b9..23175edd5634 100644
--- a/drivers/mtd/chips/cfi_cmdset_0002.c
+++ b/drivers/mtd/chips/cfi_cmdset_0002.c
@@ -462,13 +462,14 @@ struct mtd_info *cfi_cmdset_0002(struct map_info *map, int primary)
                         cfi_fixup_major_minor(cfi, extp);
 
                         /*
-                         * Valid primary extension versions are: 1.0, 1.1, 1.2, 1.3, 1.4
+                         * Valid primary extension versions are: 1.0, 1.1, 1.2, 1.3, 1.4, 1.5
                          * see: http://cs.ozerki.net/zap/pub/axim-x5/docs/cfi_r20.pdf, page 19 
                          *      http://www.spansion.com/Support/AppNotes/cfi_100_20011201.pdf
                          *      http://www.spansion.com/Support/Datasheets/s29ws-p_00_a12_e.pdf
+                         *      http://www.spansion.com/Support/Datasheets/S29GL_128S_01GS_00_02_e.pdf
                          */
                         if (extp->MajorVersion != '1' ||
-                            (extp->MajorVersion == '1' && (extp->MinorVersion < '0' || extp->MinorVersion > '4'))) {
+                            (extp->MajorVersion == '1' && (extp->MinorVersion < '0' || extp->MinorVersion > '5'))) {
                                 printk(KERN_ERR "  Unknown Amd/Fujitsu Extended Query "
                                        "version %c.%c (%#02x/%#02x).\n",
                                        extp->MajorVersion, extp->MinorVersion,
@@ -710,9 +711,7 @@ static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr
                                  * there was an error (so leave the erase
                                  * routine to recover from it) or we trying to
                                  * use the erase-in-progress sector. */
-                                map_write(map, cfi->sector_erase_cmd, chip->in_progress_block_addr);
-                                chip->state = FL_ERASING;
-                                chip->oldstate = FL_READY;
+                                put_chip(map, chip, adr);
                                 printk(KERN_ERR "MTD %s(): chip not ready after erase suspend\n", __func__);
                                 return -EIO;
                         }
@@ -762,7 +761,6 @@ static void put_chip(struct map_info *map, struct flchip *chip, unsigned long ad
 
         switch(chip->oldstate) {
         case FL_ERASING:
-                chip->state = chip->oldstate;
                 map_write(map, cfi->sector_erase_cmd, chip->in_progress_block_addr);
                 chip->oldstate = FL_READY;
                 chip->state = FL_ERASING;
diff --git a/drivers/mtd/chips/cfi_cmdset_0020.c b/drivers/mtd/chips/cfi_cmdset_0020.c
index ed56ad3884fb..179814a95f3a 100644
--- a/drivers/mtd/chips/cfi_cmdset_0020.c
+++ b/drivers/mtd/chips/cfi_cmdset_0020.c
@@ -296,6 +296,7 @@ static inline int do_read_onechip(struct map_info *map, struct flchip *chip, lof
                                 /* make sure we're in 'read status' mode */
                                 map_write(map, CMD(0x70), cmd_addr);
                                 chip->state = FL_ERASING;
+                                wake_up(&chip->wq);
                                 mutex_unlock(&chip->mutex);
                                 printk(KERN_ERR "Chip not ready after erase "
                                        "suspended: status = 0x%lx\n", status.x[0]);
diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
index 97183c8c9e33..b78f23169d4e 100644
--- a/drivers/mtd/devices/block2mtd.c
+++ b/drivers/mtd/devices/block2mtd.c
@@ -294,7 +294,7 @@ static struct block2mtd_dev *add_device(char *devname, int erase_size)
         dev->mtd.priv = dev;
         dev->mtd.owner = THIS_MODULE;
 
-        if (add_mtd_device(&dev->mtd)) {
+        if (mtd_device_register(&dev->mtd, NULL, 0)) {
                 /* Device didn't get added, so free the entry */
                 goto devinit_err;
         }
@@ -465,7 +465,7 @@ static void __devexit block2mtd_exit(void)
         list_for_each_safe(pos, next, &blkmtd_device_list) {
                 struct block2mtd_dev *dev = list_entry(pos, typeof(*dev), list);
                 block2mtd_sync(&dev->mtd);
-                del_mtd_device(&dev->mtd);
+                mtd_device_unregister(&dev->mtd);
                 INFO("mtd%d: [%s] removed", dev->mtd.index,
                                 dev->mtd.name + strlen("block2mtd: "));
                 list_del(&dev->list);
diff --git a/drivers/mtd/devices/doc2000.c b/drivers/mtd/devices/doc2000.c
index 5bf5f460e132..f7fbf6025ef2 100644
--- a/drivers/mtd/devices/doc2000.c
+++ b/drivers/mtd/devices/doc2000.c
@@ -597,7 +597,7 @@ void DoC2k_init(struct mtd_info *mtd)
                 doc2klist = mtd;
                 mtd->size = this->totlen;
                 mtd->erasesize = this->erasesize;
-                add_mtd_device(mtd);
+                mtd_device_register(mtd, NULL, 0);
                 return;
         }
 }
@@ -1185,7 +1185,7 @@ static void __exit cleanup_doc2000(void)
                 this = mtd->priv;
                 doc2klist = this->nextdoc;
 
-                del_mtd_device(mtd);
+                mtd_device_unregister(mtd);
 
                 iounmap(this->virtadr);
                 kfree(this->chips);
diff --git a/drivers/mtd/devices/doc2001.c b/drivers/mtd/devices/doc2001.c
index 0990f7803628..241192f05bc8 100644
--- a/drivers/mtd/devices/doc2001.c
+++ b/drivers/mtd/devices/doc2001.c
@@ -376,7 +376,7 @@ void DoCMil_init(struct mtd_info *mtd)
                 this->nextdoc = docmillist;
                 docmillist = mtd;
                 mtd->size  = this->totlen;
-                add_mtd_device(mtd);
+                mtd_device_register(mtd, NULL, 0);
                 return;
         }
 }
@@ -826,7 +826,7 @@ static void __exit cleanup_doc2001(void)
                 this = mtd->priv;
                 docmillist = this->nextdoc;
 
-                del_mtd_device(mtd);
+                mtd_device_unregister(mtd);
 
                 iounmap(this->virtadr);
                 kfree(this->chips);
diff --git a/drivers/mtd/devices/doc2001plus.c b/drivers/mtd/devices/doc2001plus.c
index 8b36fa77a195..09ae0adc3ad0 100644
--- a/drivers/mtd/devices/doc2001plus.c
+++ b/drivers/mtd/devices/doc2001plus.c
@@ -499,7 +499,7 @@ void DoCMilPlus_init(struct mtd_info *mtd)
                 docmilpluslist = mtd;
                 mtd->size  = this->totlen;
                 mtd->erasesize = this->erasesize;
-                add_mtd_device(mtd);
+                mtd_device_register(mtd, NULL, 0);
                 return;
         }
 }
@@ -1091,7 +1091,7 @@ static void __exit cleanup_doc2001plus(void)
                 this = mtd->priv;
                 docmilpluslist = this->nextdoc;
 
-                del_mtd_device(mtd);
+                mtd_device_unregister(mtd);
 
                 iounmap(this->virtadr);
                 kfree(this->chips);
diff --git a/drivers/mtd/devices/lart.c b/drivers/mtd/devices/lart.c
index 4b829f97d56c..772a0ff89e0f 100644
--- a/drivers/mtd/devices/lart.c
+++ b/drivers/mtd/devices/lart.c
@@ -684,9 +684,10 @@ static int __init lart_flash_init (void)
 #endif
 
 #ifndef HAVE_PARTITIONS
-   result = add_mtd_device (&mtd);
+   result = mtd_device_register(&mtd, NULL, 0);
 #else
-   result = add_mtd_partitions (&mtd,lart_partitions, ARRAY_SIZE(lart_partitions));
+   result = mtd_device_register(&mtd, lart_partitions,
+                                ARRAY_SIZE(lart_partitions));
 #endif
 
    return (result);
@@ -695,9 +696,9 @@ static int __init lart_flash_init (void)
 static void __exit lart_flash_exit (void)
 {
 #ifndef HAVE_PARTITIONS
-   del_mtd_device (&mtd);
+   mtd_device_unregister(&mtd);
 #else
-   del_mtd_partitions (&mtd);
+   mtd_device_unregister(&mtd);
 #endif
 }
 
diff --git a/drivers/mtd/devices/m25p80.c b/drivers/mtd/devices/m25p80.c
index 3fb981d4bb51..35180e475c4c 100644
--- a/drivers/mtd/devices/m25p80.c
+++ b/drivers/mtd/devices/m25p80.c
@@ -27,6 +27,7 @@
 #include <linux/sched.h>
 #include <linux/mod_devicetable.h>
 
+#include <linux/mtd/cfi.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
 
@@ -55,6 +56,9 @@
 #define OPCODE_EN4B             0xb7    /* Enter 4-byte mode */
 #define OPCODE_EX4B             0xe9    /* Exit 4-byte mode */
 
+/* Used for Spansion flashes only. */
+#define OPCODE_BRWR             0x17    /* Bank register write */
+
 /* Status Register bits. */
 #define SR_WIP                  1       /* Write in progress */
 #define SR_WEL                  2       /* Write enable latch */
@@ -76,6 +80,8 @@
 #define FAST_READ_DUMMY_BYTE 0
 #endif
 
+#define JEDEC_MFR(_jedec_id)    ((_jedec_id) >> 16)
+
 /****************************************************************************/
 
 struct m25p {
@@ -158,11 +164,18 @@ static inline int write_disable(struct m25p *flash)
 /*
  * Enable/disable 4-byte addressing mode.
  */
-static inline int set_4byte(struct m25p *flash, int enable)
+static inline int set_4byte(struct m25p *flash, u32 jedec_id, int enable)
 {
-        u8      code = enable ? OPCODE_EN4B : OPCODE_EX4B;
-
-        return spi_write_then_read(flash->spi, &code, 1, NULL, 0);
+        switch (JEDEC_MFR(jedec_id)) {
+        case CFI_MFR_MACRONIX:
+                flash->command[0] = enable ? OPCODE_EN4B : OPCODE_EX4B;
+                return spi_write(flash->spi, flash->command, 1);
+        default:
+                /* Spansion style */
+                flash->command[0] = OPCODE_BRWR;
+                flash->command[1] = enable << 7;
+                return spi_write(flash->spi, flash->command, 2);
+        }
 }
 
 /*
@@ -668,6 +681,7 @@ static const struct spi_device_id m25p_ids[] = {
         /* Macronix */
         { "mx25l4005a",  INFO(0xc22013, 0, 64 * 1024,   8, SECT_4K) },
         { "mx25l8005",   INFO(0xc22014, 0, 64 * 1024,  16, 0) },
+        { "mx25l1606e",  INFO(0xc22015, 0, 64 * 1024,  32, SECT_4K) },
         { "mx25l3205d",  INFO(0xc22016, 0, 64 * 1024,  64, 0) },
         { "mx25l6405d",  INFO(0xc22017, 0, 64 * 1024, 128, 0) },
         { "mx25l12805d", INFO(0xc22018, 0, 64 * 1024, 256, 0) },
@@ -684,6 +698,10 @@ static const struct spi_device_id m25p_ids[] = {
         { "s25sl032a",  INFO(0x010215,      0,  64 * 1024,  64, 0) },
         { "s25sl032p",  INFO(0x010215, 0x4d00,  64 * 1024,  64, SECT_4K) },
         { "s25sl064a",  INFO(0x010216,      0,  64 * 1024, 128, 0) },
+        { "s25fl256s0", INFO(0x010219, 0x4d00, 256 * 1024, 128, 0) },
+        { "s25fl256s1", INFO(0x010219, 0x4d01,  64 * 1024, 512, 0) },
+        { "s25fl512s",  INFO(0x010220, 0x4d00, 256 * 1024, 256, 0) },
+        { "s70fl01gs",  INFO(0x010221, 0x4d00, 256 * 1024, 256, 0) },
         { "s25sl12800", INFO(0x012018, 0x0300, 256 * 1024,  64, 0) },
         { "s25sl12801", INFO(0x012018, 0x0301,  64 * 1024, 256, 0) },
         { "s25fl129p0", INFO(0x012018, 0x4d00, 256 * 1024,  64, 0) },
@@ -729,7 +747,10 @@ static const struct spi_device_id m25p_ids[] = {
         { "m25pe80", INFO(0x208014,  0, 64 * 1024, 16,       0) },
         { "m25pe16", INFO(0x208015,  0, 64 * 1024, 32, SECT_4K) },
 
-        { "m25px64", INFO(0x207117,  0, 64 * 1024, 128, 0) },
+        { "m25px32",    INFO(0x207116,  0, 64 * 1024, 64, SECT_4K) },
+        { "m25px32-s0", INFO(0x207316,  0, 64 * 1024, 64, SECT_4K) },
+        { "m25px32-s1", INFO(0x206316,  0, 64 * 1024, 64, SECT_4K) },
+        { "m25px64",    INFO(0x207117,  0, 64 * 1024, 128, 0) },
 
         /* Winbond -- w25x "blocks" are 64K, "sectors" are 4KiB */
         { "w25x10", INFO(0xef3011, 0, 64 * 1024,  2,  SECT_4K) },
@@ -804,6 +825,8 @@ static int __devinit m25p_probe(struct spi_device *spi)
         struct m25p                     *flash;
         struct flash_info               *info;
         unsigned                        i;
+        struct mtd_partition            *parts = NULL;
+        int                             nr_parts = 0;
 
         /* Platform data helps sort out which chip type we have, as
          * well as how this board partitions it.  If we don't have
@@ -868,9 +891,9 @@ static int __devinit m25p_probe(struct spi_device *spi)
          * up with the software protection bits set
          */
 
-        if (info->jedec_id >> 16 == 0x1f ||
-            info->jedec_id >> 16 == 0x89 ||
-            info->jedec_id >> 16 == 0xbf) {
+        if (JEDEC_MFR(info->jedec_id) == CFI_MFR_ATMEL ||
+            JEDEC_MFR(info->jedec_id) == CFI_MFR_INTEL ||
+            JEDEC_MFR(info->jedec_id) == CFI_MFR_SST) {
                 write_enable(flash);
                 write_sr(flash, 0);
         }
@@ -888,7 +911,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
         flash->mtd.read = m25p80_read;
 
         /* sst flash chips use AAI word program */
-        if (info->jedec_id >> 16 == 0xbf)
+        if (JEDEC_MFR(info->jedec_id) == CFI_MFR_SST)
                 flash->mtd.write = sst_write;
         else
                 flash->mtd.write = m25p80_write;
@@ -914,7 +937,7 @@ static int __devinit m25p_probe(struct spi_device *spi)
                 /* enable 4-byte addressing if the device exceeds 16MiB */
                 if (flash->mtd.size > 0x1000000) {
                         flash->addr_width = 4;
-                        set_4byte(flash, 1);
+                        set_4byte(flash, info->jedec_id, 1);
                 } else
                         flash->addr_width = 3;
         }
@@ -945,48 +968,41 @@ static int __devinit m25p_probe(struct spi_device *spi)
         /* partitions should match sector boundaries; and it may be good to
          * use readonly partitions for writeprotected sectors (BP2..BP0).
          */
-        if (mtd_has_partitions()) {
-                struct mtd_partition    *parts = NULL;
-                int                     nr_parts = 0;
-
-                if (mtd_has_cmdlinepart()) {
-                        static const char *part_probes[]
-                                        = { "cmdlinepart", NULL, };
+        if (mtd_has_cmdlinepart()) {
+                static const char *part_probes[]
+                        = { "cmdlinepart", NULL, };
 
-                        nr_parts = parse_mtd_partitions(&flash->mtd,
-                                        part_probes, &parts, 0);
-                }
+                nr_parts = parse_mtd_partitions(&flash->mtd,
+                                                part_probes, &parts, 0);
+        }
 
-                if (nr_parts <= 0 && data && data->parts) {
-                        parts = data->parts;
-                        nr_parts = data->nr_parts;
-                }
+        if (nr_parts <= 0 && data && data->parts) {
+                parts = data->parts;
+                nr_parts = data->nr_parts;
+        }
 
 #ifdef CONFIG_MTD_OF_PARTS
-                if (nr_parts <= 0 && spi->dev.of_node) {
-                        nr_parts = of_mtd_parse_partitions(&spi->dev,
-                                        spi->dev.of_node, &parts);
-                }
+        if (nr_parts <= 0 && spi->dev.of_node) {
+                nr_parts = of_mtd_parse_partitions(&spi->dev,
+                                                   spi->dev.of_node, &parts);
+        }
 #endif
 
-                if (nr_parts > 0) {
-                        for (i = 0; i < nr_parts; i++) {
-                                DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
-                                        "{.name = %s, .offset = 0x%llx, "
-                                                ".size = 0x%llx (%lldKiB) }\n",
-                                        i, parts[i].name,
-                                        (long long)parts[i].offset,
-                                        (long long)parts[i].size,
-                                        (long long)(parts[i].size >> 10));
-                        }
-                        flash->partitioned = 1;
-                        return add_mtd_partitions(&flash->mtd, parts, nr_parts);
+        if (nr_parts > 0) {
+                for (i = 0; i < nr_parts; i++) {
+                        DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
+                              "{.name = %s, .offset = 0x%llx, "
+                              ".size = 0x%llx (%lldKiB) }\n",
+                              i, parts[i].name,
+                              (long long)parts[i].offset,
+                              (long long)parts[i].size,
+                              (long long)(parts[i].size >> 10));
                 }
-        } else if (data && data->nr_parts)
-                dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
-                                data->nr_parts, data->name);
+                flash->partitioned = 1;
+        }
 
-        return add_mtd_device(&flash->mtd) == 1 ? -ENODEV : 0;
+        return mtd_device_register(&flash->mtd, parts, nr_parts) == 1 ?
+                -ENODEV : 0;
 }
 
 
@@ -996,10 +1012,7 @@ static int __devexit m25p_remove(struct spi_device *spi)
         int             status;
 
         /* Clean up MTD stuff. */
-        if (mtd_has_partitions() && flash->partitioned)
-                status = del_mtd_partitions(&flash->mtd);
-        else
-                status = del_mtd_device(&flash->mtd);
+        status = mtd_device_unregister(&flash->mtd);
         if (status == 0) {
                 kfree(flash->command);
                 kfree(flash);
diff --git a/drivers/mtd/devices/ms02-nv.c b/drivers/mtd/devices/ms02-nv.c
index 6a9a24a80a6d..8423fb6d4f26 100644
--- a/drivers/mtd/devices/ms02-nv.c
+++ b/drivers/mtd/devices/ms02-nv.c
@@ -220,7 +220,7 @@ static int __init ms02nv_init_one(ulong addr)
         mtd->writesize = 1;
 
         ret = -EIO;
-        if (add_mtd_device(mtd)) {
+        if (mtd_device_register(mtd, NULL, 0)) {
                 printk(KERN_ERR
                         "ms02-nv: Unable to register MTD device, aborting!\n");
                 goto err_out_csr_res;
@@ -262,7 +262,7 @@ static void __exit ms02nv_remove_one(void)
 
         root_ms02nv_mtd = mp->next;
 
-        del_mtd_device(mtd);
+        mtd_device_unregister(mtd);
 
         release_resource(mp->resource.csr);
         kfree(mp->resource.csr);
diff --git a/drivers/mtd/devices/mtd_dataflash.c b/drivers/mtd/devices/mtd_dataflash.c
index c5015cc721d5..13749d458a31 100644
--- a/drivers/mtd/devices/mtd_dataflash.c
+++ b/drivers/mtd/devices/mtd_dataflash.c
@@ -637,6 +637,8 @@ add_dataflash_otp(struct spi_device *spi, char *name,
         struct flash_platform_data      *pdata = spi->dev.platform_data;
         char                            *otp_tag = "";
         int                             err = 0;
+        struct mtd_partition            *parts;
+        int                             nr_parts = 0;
 
         priv = kzalloc(sizeof *priv, GFP_KERNEL);
         if (!priv)
@@ -675,33 +677,25 @@ add_dataflash_otp(struct spi_device *spi, char *name,
                         pagesize, otp_tag);
         dev_set_drvdata(&spi->dev, priv);
 
-        if (mtd_has_partitions()) {
-                struct mtd_partition    *parts;
-                int                     nr_parts = 0;
+        if (mtd_has_cmdlinepart()) {
+                static const char *part_probes[] = { "cmdlinepart", NULL, };
 
-                if (mtd_has_cmdlinepart()) {
-                        static const char *part_probes[]
-                                        = { "cmdlinepart", NULL, };
-
-                        nr_parts = parse_mtd_partitions(device,
-                                        part_probes, &parts, 0);
-                }
+                nr_parts = parse_mtd_partitions(device, part_probes, &parts,
+                                                0);
+        }
 
-                if (nr_parts <= 0 && pdata && pdata->parts) {
-                        parts = pdata->parts;
-                        nr_parts = pdata->nr_parts;
-                }
+        if (nr_parts <= 0 && pdata && pdata->parts) {
+                parts = pdata->parts;
+                nr_parts = pdata->nr_parts;
+        }
 
-                if (nr_parts > 0) {
-                        priv->partitioned = 1;
-                        err = add_mtd_partitions(device, parts, nr_parts);
-                        goto out;
-                }
-        } else if (pdata && pdata->nr_parts)
-                dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
-                                pdata->nr_parts, device->name);
+        if (nr_parts > 0) {
+                priv->partitioned = 1;
+                err = mtd_device_register(device, parts, nr_parts);
+                goto out;
+        }
 
-        if (add_mtd_device(device) == 1)
+        if (mtd_device_register(device, NULL, 0) == 1)
                 err = -ENODEV;
 
 out:
@@ -939,10 +933,7 @@ static int __devexit dataflash_remove(struct spi_device *spi)
 
         DEBUG(MTD_DEBUG_LEVEL1, "%s: remove\n", dev_name(&spi->dev));
 
-        if (mtd_has_partitions() && flash->partitioned)
-                status = del_mtd_partitions(&flash->mtd);
-        else
-                status = del_mtd_device(&flash->mtd);
+        status = mtd_device_unregister(&flash->mtd);
         if (status == 0) {
                 dev_set_drvdata(&spi->dev, NULL);
                 kfree(flash);
diff --git a/drivers/mtd/devices/mtdram.c b/drivers/mtd/devices/mtdram.c
index 1483e18971ce..2562689ba6b4 100644
--- a/drivers/mtd/devices/mtdram.c
+++ b/drivers/mtd/devices/mtdram.c
@@ -104,7 +104,7 @@ static int ram_write(struct mtd_info *mtd, loff_t to, size_t len,
 static void __exit cleanup_mtdram(void)
 {
         if (mtd_info) {
-                del_mtd_device(mtd_info);
+                mtd_device_unregister(mtd_info);
                 vfree(mtd_info->priv);
                 kfree(mtd_info);
         }
@@ -133,9 +133,8 @@ int mtdram_init_device(struct mtd_info *mtd, void *mapped_address,
         mtd->read = ram_read;
         mtd->write = ram_write;
 
-        if (add_mtd_device(mtd)) {
+        if (mtd_device_register(mtd, NULL, 0))
                 return -EIO;
-        }
 
         return 0;
 }
diff --git a/drivers/mtd/devices/phram.c b/drivers/mtd/devices/phram.c
index 8d28fa02a5a2..23423bd00b06 100644
--- a/drivers/mtd/devices/phram.c
+++ b/drivers/mtd/devices/phram.c
@@ -115,7 +115,7 @@ static void unregister_devices(void)
         struct phram_mtd_list *this, *safe;
 
         list_for_each_entry_safe(this, safe, &phram_list, list) {
-                del_mtd_device(&this->mtd);
+                mtd_device_unregister(&this->mtd);
                 iounmap(this->mtd.priv);
                 kfree(this->mtd.name);
                 kfree(this);
@@ -153,7 +153,7 @@ static int register_device(char *name, unsigned long start, unsigned long len)
         new->mtd.writesize = 1;
 
         ret = -EAGAIN;
-        if (add_mtd_device(&new->mtd)) {
+        if (mtd_device_register(&new->mtd, NULL, 0)) {
                 pr_err("Failed to register new device\n");
                 goto out2;
         }
diff --git a/drivers/mtd/devices/pmc551.c b/drivers/mtd/devices/pmc551.c
index 41b8cdcc64cb..ecff765579dd 100644
--- a/drivers/mtd/devices/pmc551.c
+++ b/drivers/mtd/devices/pmc551.c
@@ -798,7 +798,7 @@ static int __init init_pmc551(void)
                 mtd->writesize = 1;
                 mtd->owner = THIS_MODULE;
 
-                if (add_mtd_device(mtd)) {
+                if (mtd_device_register(mtd, NULL, 0)) {
                         printk(KERN_NOTICE "pmc551: Failed to register new device\n");
                         pci_iounmap(PCI_Device, priv->start);
                         kfree(mtd->priv);
@@ -806,7 +806,7 @@ static int __init init_pmc551(void)
                         break;
                 }
 
-                /* Keep a reference as the add_mtd_device worked */
+                /* Keep a reference as the mtd_device_register worked */
                 pci_dev_get(PCI_Device);
 
                 printk(KERN_NOTICE "Registered pmc551 memory device.\n");
@@ -856,7 +856,7 @@ static void __exit cleanup_pmc551(void)
                 pci_dev_put(priv->dev);
 
                 kfree(mtd->priv);
-                del_mtd_device(mtd);
+                mtd_device_unregister(mtd);
                 kfree(mtd);
                 found++;
         }
diff --git a/drivers/mtd/devices/slram.c b/drivers/mtd/devices/slram.c
index 592016a0668f..e585263161b9 100644
--- a/drivers/mtd/devices/slram.c
+++ b/drivers/mtd/devices/slram.c
@@ -210,7 +210,7 @@ static int register_device(char *name, unsigned long start, unsigned long length
         (*curmtd)->mtdinfo->erasesize = SLRAM_BLK_SZ;
         (*curmtd)->mtdinfo->writesize = 1;
 
-        if (add_mtd_device((*curmtd)->mtdinfo)) {
+        if (mtd_device_register((*curmtd)->mtdinfo, NULL, 0))   {
                 E("slram: Failed to register new device\n");
                 iounmap(((slram_priv_t *)(*curmtd)->mtdinfo->priv)->start);
                 kfree((*curmtd)->mtdinfo->priv);
@@ -231,7 +231,7 @@ static void unregister_devices(void)
 
         while (slram_mtdlist) {
                 nextitem = slram_mtdlist->next;
-                del_mtd_device(slram_mtdlist->mtdinfo);
+                mtd_device_unregister(slram_mtdlist->mtdinfo);
                 iounmap(((slram_priv_t *)slram_mtdlist->mtdinfo->priv)->start);
                 kfree(slram_mtdlist->mtdinfo->priv);
                 kfree(slram_mtdlist->mtdinfo);
diff --git a/drivers/mtd/devices/sst25l.c b/drivers/mtd/devices/sst25l.c
index c163e619abc9..1e2c430aaad2 100644
--- a/drivers/mtd/devices/sst25l.c
+++ b/drivers/mtd/devices/sst25l.c
@@ -66,7 +66,7 @@ struct flash_info {
 
 #define to_sst25l_flash(x) container_of(x, struct sst25l_flash, mtd)
 
-static struct flash_info __initdata sst25l_flash_info[] = {
+static struct flash_info __devinitdata sst25l_flash_info[] = {
         {"sst25lf020a", 0xbf43, 256, 1024, 4096},
         {"sst25lf040a", 0xbf44, 256, 2048, 4096},
 };
@@ -381,6 +381,8 @@ static int __devinit sst25l_probe(struct spi_device *spi)
         struct sst25l_flash *flash;
         struct flash_platform_data *data;
         int ret, i;
+        struct mtd_partition *parts = NULL;
+        int nr_parts = 0;
 
         flash_info = sst25l_match_device(spi);
         if (!flash_info)
@@ -420,46 +422,37 @@ static int __devinit sst25l_probe(struct spi_device *spi)
               flash->mtd.erasesize, flash->mtd.erasesize / 1024,
               flash->mtd.numeraseregions);
 
-        if (mtd_has_partitions()) {
-                struct mtd_partition *parts = NULL;
-                int nr_parts = 0;
 
-                if (mtd_has_cmdlinepart()) {
-                        static const char *part_probes[] =
-                                {"cmdlinepart", NULL};
+        if (mtd_has_cmdlinepart()) {
+                static const char *part_probes[] = {"cmdlinepart", NULL};
 
-                        nr_parts = parse_mtd_partitions(&flash->mtd,
-                                                        part_probes,
-                                                        &parts, 0);
-                }
+                nr_parts = parse_mtd_partitions(&flash->mtd,
+                                                part_probes,
+                                                &parts, 0);
+        }
 
-                if (nr_parts <= 0 && data && data->parts) {
-                        parts = data->parts;
-                        nr_parts = data->nr_parts;
-                }
+        if (nr_parts <= 0 && data && data->parts) {
+                parts = data->parts;
+                nr_parts = data->nr_parts;
+        }
 
-                if (nr_parts > 0) {
-                        for (i = 0; i < nr_parts; i++) {
-                                DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
-                                      "{.name = %s, .offset = 0x%llx, "
-                                      ".size = 0x%llx (%lldKiB) }\n",
-                                      i, parts[i].name,
-                                      (long long)parts[i].offset,
-                                      (long long)parts[i].size,
-                                      (long long)(parts[i].size >> 10));
-                        }
-
-                        flash->partitioned = 1;
-                        return add_mtd_partitions(&flash->mtd,
-                                                  parts, nr_parts);
+        if (nr_parts > 0) {
+                for (i = 0; i < nr_parts; i++) {
+                        DEBUG(MTD_DEBUG_LEVEL2, "partitions[%d] = "
+                              "{.name = %s, .offset = 0x%llx, "
+                              ".size = 0x%llx (%lldKiB) }\n",
+                              i, parts[i].name,
+                              (long long)parts[i].offset,
+                              (long long)parts[i].size,
+                              (long long)(parts[i].size >> 10));
                 }
 
-        } else if (data && data->nr_parts) {
-                dev_warn(&spi->dev, "ignoring %d default partitions on %s\n",
-                         data->nr_parts, data->name);
+                flash->partitioned = 1;
+                return mtd_device_register(&flash->mtd, parts,
+                                           nr_parts);
         }
 
-        ret = add_mtd_device(&flash->mtd);
+        ret = mtd_device_register(&flash->mtd, NULL, 0);
         if (ret == 1) {
                 kfree(flash);
                 dev_set_drvdata(&spi->dev, NULL);
@@ -469,15 +462,12 @@ static int __devinit sst25l_probe(struct spi_device *spi)
         return 0;
 }
 
-static int __exit sst25l_remove(struct spi_device *spi)
+static int __devexit sst25l_remove(struct spi_device *spi)
 {
         struct sst25l_flash *flash = dev_get_drvdata(&spi->dev);
         int ret;
 
-        if (mtd_has_partitions() && flash->partitioned)
-                ret = del_mtd_partitions(&flash->mtd);
-        else
-                ret = del_mtd_device(&flash->mtd);
+        ret = mtd_device_unregister(&flash->mtd);
         if (ret == 0)
                 kfree(flash);
         return ret;
@@ -490,7 +480,7 @@ static struct spi_driver sst25l_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = sst25l_probe,
-        .remove         = __exit_p(sst25l_remove),
+        .remove         = __devexit_p(sst25l_remove),
 };
 
 static int __init sst25l_init(void)
diff --git a/drivers/mtd/lpddr/lpddr_cmds.c b/drivers/mtd/lpddr/lpddr_cmds.c
index 12679925b420..65655dd59e1f 100644
--- a/drivers/mtd/lpddr/lpddr_cmds.c
+++ b/drivers/mtd/lpddr/lpddr_cmds.c
@@ -313,12 +313,7 @@ static int chip_ready(struct map_info *map, struct flchip *chip, int mode)
                 if (ret) {
                         /* Oops. something got wrong. */
                         /* Resume and pretend we weren't here.  */
-                        map_write(map, CMD(LPDDR_RESUME),
-                                map->pfow_base + PFOW_COMMAND_CODE);
-                        map_write(map, CMD(LPDDR_START_EXECUTION),
-                                map->pfow_base + PFOW_COMMAND_EXECUTE);
-                        chip->state = FL_ERASING;
-                        chip->oldstate = FL_READY;
+                        put_chip(map, chip);
                         printk(KERN_ERR "%s: suspend operation failed."
                                         "State may be wrong \n", map->name);
                         return -EIO;
@@ -383,7 +378,6 @@ static void put_chip(struct map_info *map, struct flchip *chip)
 
         switch (chip->oldstate) {
         case FL_ERASING:
-                chip->state = chip->oldstate;
                 map_write(map, CMD(LPDDR_RESUME),
                                 map->pfow_base + PFOW_COMMAND_CODE);
                 map_write(map, CMD(LPDDR_START_EXECUTION),
diff --git a/drivers/mtd/maps/Kconfig b/drivers/mtd/maps/Kconfig
index 5069111c81cc..c0c328c5b133 100644
--- a/drivers/mtd/maps/Kconfig
+++ b/drivers/mtd/maps/Kconfig
@@ -82,7 +82,6 @@ config MTD_PHYSMAP_OF
 config MTD_PMC_MSP_EVM
         tristate "CFI Flash device mapped on PMC-Sierra MSP"
         depends on PMC_MSP && MTD_CFI
-        select MTD_PARTITIONS
         help
           This provides a 'mapping' driver which supports the way
           in which user-programmable flash chips are connected on the
@@ -122,7 +121,7 @@ config MTD_SC520CDP
 
 config MTD_NETSC520
         tristate "CFI Flash device mapped on AMD NetSc520"
-        depends on X86 && MTD_CFI && MTD_PARTITIONS
+        depends on X86 && MTD_CFI
         help
           This enables access routines for the flash chips on the AMD NetSc520
           demonstration board. If you have one of these boards and would like
@@ -131,7 +130,6 @@ config MTD_NETSC520
 config MTD_TS5500
         tristate "JEDEC Flash device mapped on Technologic Systems TS-5500"
         depends on X86
-        select MTD_PARTITIONS
         select MTD_JEDECPROBE
         select MTD_CFI_AMDSTD
         help
@@ -149,7 +147,7 @@ config MTD_TS5500
 
 config MTD_SBC_GXX
         tristate "CFI Flash device mapped on Arcom SBC-GXx boards"
-        depends on X86 && MTD_CFI_INTELEXT && MTD_PARTITIONS && MTD_COMPLEX_MAPPINGS
+        depends on X86 && MTD_CFI_INTELEXT && MTD_COMPLEX_MAPPINGS
         help
           This provides a driver for the on-board flash of Arcom Control
           Systems' SBC-GXn family of boards, formerly known as SBC-MediaGX.
@@ -161,7 +159,6 @@ config MTD_SBC_GXX
 config MTD_PXA2XX
         tristate "CFI Flash device mapped on Intel XScale PXA2xx based boards"
         depends on (PXA25x || PXA27x) && MTD_CFI_INTELEXT
-        select MTD_PARTITIONS
         help
           This provides a driver for the NOR flash attached to a PXA2xx chip.
 
@@ -185,7 +182,7 @@ config MTD_VMAX
 
 config MTD_SCx200_DOCFLASH
         tristate "Flash device mapped with DOCCS on NatSemi SCx200"
-        depends on SCx200 && MTD_CFI && MTD_PARTITIONS
+        depends on SCx200 && MTD_CFI
         help
           Enable support for a flash chip mapped using the DOCCS signal on a
           National Semiconductor SCx200 processor.
@@ -247,7 +244,7 @@ config MTD_TSUNAMI
 
 config MTD_NETtel
         tristate "CFI flash device on SnapGear/SecureEdge"
-        depends on X86 && MTD_PARTITIONS && MTD_JEDECPROBE
+        depends on X86 && MTD_JEDECPROBE
         help
           Support for flash chips on NETtel/SecureEdge/SnapGear boards.
 
@@ -269,7 +266,7 @@ config MTD_LANTIQ
 
 config MTD_DILNETPC
         tristate "CFI Flash device mapped on DIL/Net PC"
-        depends on X86 && MTD_PARTITIONS && MTD_CFI_INTELEXT && BROKEN
+        depends on X86 && MTD_CFI_INTELEXT && BROKEN
         help
           MTD map driver for SSV DIL/Net PC Boards "DNP" and "ADNP".
           For details, see <http://www.ssv-embedded.de/ssv/pc104/p169.htm>
@@ -355,7 +352,7 @@ config MTD_CDB89712
 
 config MTD_SA1100
         tristate "CFI Flash device mapped on StrongARM SA11x0"
-        depends on MTD_CFI && ARCH_SA1100 && MTD_PARTITIONS
+        depends on MTD_CFI && ARCH_SA1100
         help
           This enables access to the flash chips on most platforms based on
           the SA1100 and SA1110, including the Assabet and the Compaq iPAQ.
@@ -389,7 +386,7 @@ config MTD_IXP2000
 
 config MTD_FORTUNET
         tristate "CFI Flash device mapped on the FortuNet board"
-        depends on MTD_CFI && MTD_PARTITIONS && SA1100_FORTUNET
+        depends on MTD_CFI && SA1100_FORTUNET
         help
           This enables access to the Flash on the FortuNet board.  If you
           have such a board, say 'Y'.
@@ -461,7 +458,6 @@ config MTD_PCMCIA_ANONYMOUS
 config MTD_BFIN_ASYNC
         tristate "Blackfin BF533-STAMP Flash Chip Support"
         depends on BFIN533_STAMP && MTD_CFI && MTD_COMPLEX_MAPPINGS
-        select MTD_PARTITIONS
         default y
         help
           Map driver which allows for simultaneous utilization of
@@ -473,7 +469,6 @@ config MTD_GPIO_ADDR
         tristate "GPIO-assisted Flash Chip Support"
         depends on GENERIC_GPIO || GPIOLIB
         depends on MTD_COMPLEX_MAPPINGS
-        select MTD_PARTITIONS
         help
           Map driver which allows flashes to be partially physically addressed
           and assisted by GPIOs.
@@ -482,14 +477,13 @@ config MTD_GPIO_ADDR
 
 config MTD_UCLINUX
         bool "Generic uClinux RAM/ROM filesystem support"
-        depends on MTD_PARTITIONS && MTD_RAM=y && !MMU
+        depends on MTD_RAM=y && !MMU
         help
           Map driver to support image based filesystems for uClinux.
 
 config MTD_WRSBC8260
         tristate "Map driver for WindRiver PowerQUICC II MPC82xx board"
         depends on (SBC82xx || SBC8560)
-        select MTD_PARTITIONS
         select MTD_MAP_BANK_WIDTH_4
         select MTD_MAP_BANK_WIDTH_1
         select MTD_CFI_I1
@@ -502,7 +496,6 @@ config MTD_WRSBC8260
 config MTD_DMV182
         tristate "Map driver for Dy-4 SVME/DMV-182 board."
         depends on DMV182
-        select MTD_PARTITIONS
         select MTD_MAP_BANK_WIDTH_32
         select MTD_CFI_I8
         select MTD_CFI_AMDSTD
diff --git a/drivers/mtd/maps/amd76xrom.c b/drivers/mtd/maps/amd76xrom.c
index 92de7e3a49a5..e2875d6fe129 100644
--- a/drivers/mtd/maps/amd76xrom.c
+++ b/drivers/mtd/maps/amd76xrom.c
@@ -82,7 +82,7 @@ static void amd76xrom_cleanup(struct amd76xrom_window *window)
                 if (map->rsrc.parent) {
                         release_resource(&map->rsrc);
                 }
-                del_mtd_device(map->mtd);
+                mtd_device_unregister(map->mtd);
                 map_destroy(map->mtd);
                 list_del(&map->list);
                 kfree(map);
@@ -262,7 +262,7 @@ static int __devinit amd76xrom_init_one (struct pci_dev *pdev,
 
                 /* Now that the mtd devices is complete claim and export it */
                 map->mtd->owner = THIS_MODULE;
-                if (add_mtd_device(map->mtd)) {
+                if (mtd_device_register(map->mtd, NULL, 0)) {
                         map_destroy(map->mtd);
                         map->mtd = NULL;
                         goto out;
diff --git a/drivers/mtd/maps/autcpu12-nvram.c b/drivers/mtd/maps/autcpu12-nvram.c
index 53664188fc47..e5bfd0e093bb 100644
--- a/drivers/mtd/maps/autcpu12-nvram.c
+++ b/drivers/mtd/maps/autcpu12-nvram.c
@@ -88,7 +88,7 @@ map:
         sram_mtd->owner = THIS_MODULE;
         sram_mtd->erasesize = 16;
 
-        if (add_mtd_device(sram_mtd)) {
+        if (mtd_device_register(sram_mtd, NULL, 0)) {
                 printk("NV-RAM device addition failed\n");
                 err = -ENOMEM;
                 goto out_probe;
@@ -111,7 +111,7 @@ out:
 static void __exit cleanup_autcpu12_maps(void)
 {
         if (sram_mtd) {
-                del_mtd_device(sram_mtd);
+                mtd_device_unregister(sram_mtd);
                 map_destroy(sram_mtd);
                 iounmap((void *)autcpu12_sram_map.virt);
         }
diff --git a/drivers/mtd/maps/bcm963xx-flash.c b/drivers/mtd/maps/bcm963xx-flash.c
index 1f3049590d9e..608967fe74c6 100644
--- a/drivers/mtd/maps/bcm963xx-flash.c
+++ b/drivers/mtd/maps/bcm963xx-flash.c
@@ -224,8 +224,8 @@ probe_ok:
                 goto err_probe;
         }
 
-        return add_mtd_partitions(bcm963xx_mtd_info, parsed_parts,
-                                                parsed_nr_parts);
+        return mtd_device_register(bcm963xx_mtd_info, parsed_parts,
+                                   parsed_nr_parts);
 
 err_probe:
         iounmap(bcm963xx_map.virt);
@@ -235,7 +235,7 @@ err_probe:
 static int bcm963xx_remove(struct platform_device *pdev)
 {
         if (bcm963xx_mtd_info) {
-                del_mtd_partitions(bcm963xx_mtd_info);
+                mtd_device_unregister(bcm963xx_mtd_info);
                 map_destroy(bcm963xx_mtd_info);
         }
 
diff --git a/drivers/mtd/maps/bfin-async-flash.c b/drivers/mtd/maps/bfin-async-flash.c
index 85dd18193cf2..d4297a97e100 100644
--- a/drivers/mtd/maps/bfin-async-flash.c
+++ b/drivers/mtd/maps/bfin-async-flash.c
@@ -41,9 +41,7 @@ struct async_state {
         uint32_t flash_ambctl0, flash_ambctl1;
         uint32_t save_ambctl0, save_ambctl1;
         unsigned long irq_flags;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
-#endif
 };
 
 static void switch_to_flash(struct async_state *state)
@@ -124,9 +122,7 @@ static void bfin_flash_copy_to(struct map_info *map, unsigned long to, const voi
         switch_back(state);
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL };
-#endif
 
 static int __devinit bfin_flash_probe(struct platform_device *pdev)
 {
@@ -169,22 +165,17 @@ static int __devinit bfin_flash_probe(struct platform_device *pdev)
                 return -ENXIO;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(state->mtd, part_probe_types, &pdata->parts, 0);
         if (ret > 0) {
                 pr_devinit(KERN_NOTICE DRIVER_NAME ": Using commandline partition definition\n");
-                add_mtd_partitions(state->mtd, pdata->parts, ret);
+                mtd_device_register(state->mtd, pdata->parts, ret);
                 state->parts = pdata->parts;
-
         } else if (pdata->nr_parts) {
                 pr_devinit(KERN_NOTICE DRIVER_NAME ": Using board partition definition\n");
-                add_mtd_partitions(state->mtd, pdata->parts, pdata->nr_parts);
-
-        } else
-#endif
-        {
+                mtd_device_register(state->mtd, pdata->parts, pdata->nr_parts);
+        } else {
                 pr_devinit(KERN_NOTICE DRIVER_NAME ": no partition info available, registering whole flash at once\n");
-                add_mtd_device(state->mtd);
+                mtd_device_register(state->mtd, NULL, 0);
         }
 
         platform_set_drvdata(pdev, state);
@@ -196,10 +187,8 @@ static int __devexit bfin_flash_remove(struct platform_device *pdev)
 {
         struct async_state *state = platform_get_drvdata(pdev);
         gpio_free(state->enet_flash_pin);
-#ifdef CONFIG_MTD_PARTITIONS
-        del_mtd_partitions(state->mtd);
+        mtd_device_unregister(state->mtd);
         kfree(state->parts);
-#endif
         map_destroy(state->mtd);
         kfree(state);
         return 0;
diff --git a/drivers/mtd/maps/cdb89712.c b/drivers/mtd/maps/cdb89712.c
index 8d92d8db9a98..c29cbf87ea0c 100644
--- a/drivers/mtd/maps/cdb89712.c
+++ b/drivers/mtd/maps/cdb89712.c
@@ -75,7 +75,7 @@ static int __init init_cdb89712_flash (void)
 
         flash_mtd->owner = THIS_MODULE;
 
-        if (add_mtd_device(flash_mtd)) {
+        if (mtd_device_register(flash_mtd, NULL, 0)) {
                 printk("FLASH device addition failed\n");
                 err = -ENOMEM;
                 goto out_probe;
@@ -141,7 +141,7 @@ static int __init init_cdb89712_sram (void)
         sram_mtd->owner = THIS_MODULE;
         sram_mtd->erasesize = 16;
 
-        if (add_mtd_device(sram_mtd)) {
+        if (mtd_device_register(sram_mtd, NULL, 0)) {
                 printk("SRAM device addition failed\n");
                 err = -ENOMEM;
                 goto out_probe;
@@ -209,7 +209,7 @@ static int __init init_cdb89712_bootrom (void)
         bootrom_mtd->owner = THIS_MODULE;
         bootrom_mtd->erasesize = 0x10000;
 
-        if (add_mtd_device(bootrom_mtd)) {
+        if (mtd_device_register(bootrom_mtd, NULL, 0)) {
                 printk("BootROM device addition failed\n");
                 err = -ENOMEM;
                 goto out_probe;
@@ -249,21 +249,21 @@ static int __init init_cdb89712_maps(void)
 static void __exit cleanup_cdb89712_maps(void)
 {
         if (sram_mtd) {
-                del_mtd_device(sram_mtd);
+                mtd_device_unregister(sram_mtd);
                 map_destroy(sram_mtd);
                 iounmap((void *)cdb89712_sram_map.virt);
                 release_resource (&cdb89712_sram_resource);
         }
 
         if (flash_mtd) {
-                del_mtd_device(flash_mtd);
+                mtd_device_unregister(flash_mtd);
                 map_destroy(flash_mtd);
                 iounmap((void *)cdb89712_flash_map.virt);
                 release_resource (&cdb89712_flash_resource);
         }
 
         if (bootrom_mtd) {
-                del_mtd_device(bootrom_mtd);
+                mtd_device_unregister(bootrom_mtd);
                 map_destroy(bootrom_mtd);
                 iounmap((void *)cdb89712_bootrom_map.virt);
                 release_resource (&cdb89712_bootrom_resource);
diff --git a/drivers/mtd/maps/ceiva.c b/drivers/mtd/maps/ceiva.c
index 23f551dc8ca8..06f9c9815720 100644
--- a/drivers/mtd/maps/ceiva.c
+++ b/drivers/mtd/maps/ceiva.c
@@ -224,7 +224,7 @@ static void __exit clps_destroy_mtd(struct clps_info *clps, struct mtd_info *mtd
 {
         int i;
 
-        del_mtd_partitions(mtd);
+        mtd_device_unregister(mtd);
 
         if (mtd != clps[0].mtd)
                 mtd_concat_destroy(mtd);
@@ -292,11 +292,11 @@ static void __init clps_locate_partitions(struct mtd_info *mtd)
         if (nr_parts == 0) {
                 printk(KERN_NOTICE "clps flash: no partition info "
                         "available, registering whole flash\n");
-                add_mtd_device(mtd);
+                mtd_device_register(mtd, NULL, 0);
         } else {
                 printk(KERN_NOTICE "clps flash: using %s partition "
                         "definition\n", part_type);
-                add_mtd_partitions(mtd, parsed_parts, nr_parts);
+                mtd_device_register(mtd, parsed_parts, nr_parts);
         }
 
         /* Always succeeds. */
diff --git a/drivers/mtd/maps/cfi_flagadm.c b/drivers/mtd/maps/cfi_flagadm.c
index f71343cd77cc..d16fc9d3b8cd 100644
--- a/drivers/mtd/maps/cfi_flagadm.c
+++ b/drivers/mtd/maps/cfi_flagadm.c
@@ -107,7 +107,7 @@ static int __init init_flagadm(void)
         mymtd = do_map_probe("cfi_probe", &flagadm_map);
         if (mymtd) {
                 mymtd->owner = THIS_MODULE;
-                add_mtd_partitions(mymtd, flagadm_parts, PARTITION_COUNT);
+                mtd_device_register(mymtd, flagadm_parts, PARTITION_COUNT);
                 printk(KERN_NOTICE "FlagaDM flash device initialized\n");
                 return 0;
         }
@@ -119,7 +119,7 @@ static int __init init_flagadm(void)
 static void __exit cleanup_flagadm(void)
 {
         if (mymtd) {
-                del_mtd_partitions(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (flagadm_map.virt) {
diff --git a/drivers/mtd/maps/ck804xrom.c b/drivers/mtd/maps/ck804xrom.c
index 5fdb7b26cea3..3d0e762fa5f2 100644
--- a/drivers/mtd/maps/ck804xrom.c
+++ b/drivers/mtd/maps/ck804xrom.c
@@ -94,7 +94,7 @@ static void ck804xrom_cleanup(struct ck804xrom_window *window)
                 if (map->rsrc.parent)
                         release_resource(&map->rsrc);
 
-                del_mtd_device(map->mtd);
+                mtd_device_unregister(map->mtd);
                 map_destroy(map->mtd);
                 list_del(&map->list);
                 kfree(map);
@@ -291,7 +291,7 @@ static int __devinit ck804xrom_init_one (struct pci_dev *pdev,
 
                 /* Now that the mtd devices is complete claim and export it */
                 map->mtd->owner = THIS_MODULE;
-                if (add_mtd_device(map->mtd)) {
+                if (mtd_device_register(map->mtd, NULL, 0)) {
                         map_destroy(map->mtd);
                         map->mtd = NULL;
                         goto out;
diff --git a/drivers/mtd/maps/dbox2-flash.c b/drivers/mtd/maps/dbox2-flash.c
index cfacfa6f45dd..85bdece6ab3f 100644
--- a/drivers/mtd/maps/dbox2-flash.c
+++ b/drivers/mtd/maps/dbox2-flash.c
@@ -93,7 +93,7 @@ static int __init init_dbox2_flash(void)
                 mymtd->owner = THIS_MODULE;
 
                 /* Create MTD devices for each partition. */
-                add_mtd_partitions(mymtd, partition_info, NUM_PARTITIONS);
+                mtd_device_register(mymtd, partition_info, NUM_PARTITIONS);
 
                 return 0;
         }
@@ -105,7 +105,7 @@ static int __init init_dbox2_flash(void)
 static void __exit cleanup_dbox2_flash(void)
 {
         if (mymtd) {
-                del_mtd_partitions(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (dbox2_flash_map.virt) {
diff --git a/drivers/mtd/maps/dc21285.c b/drivers/mtd/maps/dc21285.c
index b3cb3a183809..7a9e1989c977 100644
--- a/drivers/mtd/maps/dc21285.c
+++ b/drivers/mtd/maps/dc21285.c
@@ -145,17 +145,13 @@ static struct map_info dc21285_map = {
 
 
 /* Partition stuff */
-#ifdef CONFIG_MTD_PARTITIONS
 static struct mtd_partition *dc21285_parts;
 static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
-#endif
 
 static int __init init_dc21285(void)
 {
 
-#ifdef CONFIG_MTD_PARTITIONS
         int nrparts;
-#endif
 
         /* Determine bankwidth */
         switch (*CSR_SA110_CNTL & (3<<14)) {
@@ -204,13 +200,8 @@ static int __init init_dc21285(void)
 
         dc21285_mtd->owner = THIS_MODULE;
 
-#ifdef CONFIG_MTD_PARTITIONS
         nrparts = parse_mtd_partitions(dc21285_mtd, probes, &dc21285_parts, 0);
-        if (nrparts > 0)
-                add_mtd_partitions(dc21285_mtd, dc21285_parts, nrparts);
-        else
-#endif
-                add_mtd_device(dc21285_mtd);
+        mtd_device_register(dc21285_mtd, dc21285_parts, nrparts);
 
         if(machine_is_ebsa285()) {
                 /*
@@ -232,14 +223,9 @@ static int __init init_dc21285(void)
 
 static void __exit cleanup_dc21285(void)
 {
-#ifdef CONFIG_MTD_PARTITIONS
-        if (dc21285_parts) {
-                del_mtd_partitions(dc21285_mtd);
+        mtd_device_unregister(dc21285_mtd);
+        if (dc21285_parts)
                 kfree(dc21285_parts);
-        } else
-#endif
-                del_mtd_device(dc21285_mtd);
-
         map_destroy(dc21285_mtd);
         iounmap(dc21285_map.virt);
 }
diff --git a/drivers/mtd/maps/dilnetpc.c b/drivers/mtd/maps/dilnetpc.c
index 0713e3a5a22c..3e393f0da823 100644
--- a/drivers/mtd/maps/dilnetpc.c
+++ b/drivers/mtd/maps/dilnetpc.c
@@ -450,7 +450,7 @@ static int __init init_dnpc(void)
         partition_info[2].mtdp = &lowlvl_parts[1];
         partition_info[3].mtdp = &lowlvl_parts[3];
 
-        add_mtd_partitions(mymtd, partition_info, NUM_PARTITIONS);
+        mtd_device_register(mymtd, partition_info, NUM_PARTITIONS);
 
         /*
         ** now create a virtual MTD device by concatenating the for partitions
@@ -463,7 +463,8 @@ static int __init init_dnpc(void)
                 ** we do not supply mtd pointers in higlvl_partition_info, so
                 ** add_mtd_partitions() will register the devices.
                 */
-                add_mtd_partitions(merged_mtd, higlvl_partition_info, NUM_HIGHLVL_PARTITIONS);
+                mtd_device_register(merged_mtd, higlvl_partition_info,
+                                    NUM_HIGHLVL_PARTITIONS);
         }
 
         return 0;
@@ -472,12 +473,12 @@ static int __init init_dnpc(void)
 static void __exit cleanup_dnpc(void)
 {
         if(merged_mtd) {
-                del_mtd_partitions(merged_mtd);
+                mtd_device_unregister(merged_mtd);
                 mtd_concat_destroy(merged_mtd);
         }
 
         if (mymtd) {
-                del_mtd_partitions(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (dnpc_map.virt) {
diff --git a/drivers/mtd/maps/dmv182.c b/drivers/mtd/maps/dmv182.c
index d171674eb2ed..6538ac675e00 100644
--- a/drivers/mtd/maps/dmv182.c
+++ b/drivers/mtd/maps/dmv182.c
@@ -120,7 +120,7 @@ static int __init init_svme182(void)
                    this_mtd->size >> 20, FLASH_BASE_ADDR);
 
         this_mtd->owner = THIS_MODULE;
-        add_mtd_partitions(this_mtd, partitions, num_parts);
+        mtd_device_register(this_mtd, partitions, num_parts);
 
         return 0;
 }
@@ -129,7 +129,7 @@ static void __exit cleanup_svme182(void)
 {
         if (this_mtd)
         {
-                del_mtd_partitions(this_mtd);
+                mtd_device_unregister(this_mtd);
                 map_destroy(this_mtd);
         }
 
diff --git a/drivers/mtd/maps/edb7312.c b/drivers/mtd/maps/edb7312.c
index be9e90b44587..fe42a212bb3e 100644
--- a/drivers/mtd/maps/edb7312.c
+++ b/drivers/mtd/maps/edb7312.c
@@ -15,10 +15,7 @@
 #include <asm/io.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
-
-#ifdef CONFIG_MTD_PARTITIONS
 #include <linux/mtd/partitions.h>
-#endif
 
 #define WINDOW_ADDR 0x00000000      /* physical properties of flash */
 #define WINDOW_SIZE 0x01000000
@@ -40,8 +37,6 @@ struct map_info edb7312nor_map = {
         .phys = WINDOW_ADDR,
 };
 
-#ifdef CONFIG_MTD_PARTITIONS
-
 /*
  * MTD partitioning stuff
  */
@@ -66,8 +61,6 @@ static struct mtd_partition static_partitions[3] =
 
 static const char *probes[] = { "RedBoot", "cmdlinepart", NULL };
 
-#endif
-
 static int                   mtd_parts_nb = 0;
 static struct mtd_partition *mtd_parts    = 0;
 
@@ -96,27 +89,24 @@ static int __init init_edb7312nor(void)
         if (mymtd) {
                 mymtd->owner = THIS_MODULE;
 
-#ifdef CONFIG_MTD_PARTITIONS
                 mtd_parts_nb = parse_mtd_partitions(mymtd, probes, &mtd_parts, MTDID);
                 if (mtd_parts_nb > 0)
-                  part_type = "detected";
+                        part_type = "detected";
 
-                if (mtd_parts_nb == 0)
-                {
+                if (mtd_parts_nb == 0) {
                         mtd_parts = static_partitions;
                         mtd_parts_nb = ARRAY_SIZE(static_partitions);
                         part_type = "static";
                 }
-#endif
-                add_mtd_device(mymtd);
+
                 if (mtd_parts_nb == 0)
-                  printk(KERN_NOTICE MSG_PREFIX "no partition info available\n");
+                        printk(KERN_NOTICE MSG_PREFIX "no partition info available\n");
                 else
-                {
                         printk(KERN_NOTICE MSG_PREFIX
                                "using %s partition definition\n", part_type);
-                        add_mtd_partitions(mymtd, mtd_parts, mtd_parts_nb);
-                }
+                /* Register the whole device first. */
+                mtd_device_register(mymtd, NULL, 0);
+                mtd_device_register(mymtd, mtd_parts, mtd_parts_nb);
                 return 0;
         }
 
@@ -127,7 +117,7 @@ static int __init init_edb7312nor(void)
 static void __exit cleanup_edb7312nor(void)
 {
         if (mymtd) {
-                del_mtd_device(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (edb7312nor_map.virt) {
diff --git a/drivers/mtd/maps/esb2rom.c b/drivers/mtd/maps/esb2rom.c
index 4feb7507ab7c..08322b1c3e81 100644
--- a/drivers/mtd/maps/esb2rom.c
+++ b/drivers/mtd/maps/esb2rom.c
@@ -128,7 +128,7 @@ static void esb2rom_cleanup(struct esb2rom_window *window)
         list_for_each_entry_safe(map, scratch, &window->maps, list) {
                 if (map->rsrc.parent)
                         release_resource(&map->rsrc);
-                del_mtd_device(map->mtd);
+                mtd_device_unregister(map->mtd);
                 map_destroy(map->mtd);
                 list_del(&map->list);
                 kfree(map);
@@ -352,7 +352,7 @@ static int __devinit esb2rom_init_one(struct pci_dev *pdev,
 
                 /* Now that the mtd devices is complete claim and export it */
                 map->mtd->owner = THIS_MODULE;
-                if (add_mtd_device(map->mtd)) {
+                if (mtd_device_register(map->mtd, NULL, 0)) {
                         map_destroy(map->mtd);
                         map->mtd = NULL;
                         goto out;
diff --git a/drivers/mtd/maps/fortunet.c b/drivers/mtd/maps/fortunet.c
index 1e43124d498b..956e2e4f30ea 100644
--- a/drivers/mtd/maps/fortunet.c
+++ b/drivers/mtd/maps/fortunet.c
@@ -243,8 +243,9 @@ static int __init init_fortunet(void)
                                         &map_regions[ix].map_info);
                         }
                         map_regions[ix].mymtd->owner = THIS_MODULE;
-                        add_mtd_partitions(map_regions[ix].mymtd,
-                                map_regions[ix].parts,map_regions_parts[ix]);
+                        mtd_device_register(map_regions[ix].mymtd,
+                                            map_regions[ix].parts,
+                                            map_regions_parts[ix]);
                 }
         }
         if(iy)
@@ -261,7 +262,7 @@ static void __exit cleanup_fortunet(void)
                 {
                         if( map_regions[ix].mymtd )
                         {
-                                del_mtd_partitions( map_regions[ix].mymtd );
+                                mtd_device_unregister(map_regions[ix].mymtd);
                                 map_destroy( map_regions[ix].mymtd );
                         }
                         iounmap((void *)map_regions[ix].map_info.virt);
diff --git a/drivers/mtd/maps/gpio-addr-flash.c b/drivers/mtd/maps/gpio-addr-flash.c
index af5707a80205..7568c5f8b8ae 100644
--- a/drivers/mtd/maps/gpio-addr-flash.c
+++ b/drivers/mtd/maps/gpio-addr-flash.c
@@ -155,9 +155,7 @@ static void gf_copy_to(struct map_info *map, unsigned long to, const void *from,
         memcpy_toio(map->virt + (to % state->win_size), from, len);
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL };
-#endif
 
 /**
  * gpio_flash_probe() - setup a mapping for a GPIO assisted flash
@@ -189,7 +187,7 @@ static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", NULL };
  */
 static int __devinit gpio_flash_probe(struct platform_device *pdev)
 {
-        int ret;
+        int nr_parts;
         size_t i, arr_size;
         struct physmap_flash_data *pdata;
         struct resource *memory;
@@ -254,24 +252,21 @@ static int __devinit gpio_flash_probe(struct platform_device *pdev)
                 return -ENXIO;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
-        ret = parse_mtd_partitions(state->mtd, part_probe_types, &pdata->parts, 0);
-        if (ret > 0) {
+        nr_parts = parse_mtd_partitions(state->mtd, part_probe_types,
+                                        &pdata->parts, 0);
+        if (nr_parts > 0) {
                 pr_devinit(KERN_NOTICE PFX "Using commandline partition definition\n");
-                add_mtd_partitions(state->mtd, pdata->parts, ret);
                 kfree(pdata->parts);
-
         } else if (pdata->nr_parts) {
                 pr_devinit(KERN_NOTICE PFX "Using board partition definition\n");
-                add_mtd_partitions(state->mtd, pdata->parts, pdata->nr_parts);
-
-        } else
-#endif
-        {
+                nr_parts = pdata->nr_parts;
+        } else {
                 pr_devinit(KERN_NOTICE PFX "no partition info available, registering whole flash at once\n");
-                add_mtd_device(state->mtd);
+                nr_parts = 0;
         }
 
+        mtd_device_register(state->mtd, pdata->parts, nr_parts);
+
         return 0;
 }
 
@@ -282,9 +277,7 @@ static int __devexit gpio_flash_remove(struct platform_device *pdev)
         do {
                 gpio_free(state->gpio_addrs[i]);
         } while (++i < state->gpio_count);
-#ifdef CONFIG_MTD_PARTITIONS
-        del_mtd_partitions(state->mtd);
-#endif
+        mtd_device_unregister(state->mtd);
         map_destroy(state->mtd);
         kfree(state);
         return 0;
diff --git a/drivers/mtd/maps/h720x-flash.c b/drivers/mtd/maps/h720x-flash.c
index 72c724fa8c27..7f035860a36b 100644
--- a/drivers/mtd/maps/h720x-flash.c
+++ b/drivers/mtd/maps/h720x-flash.c
@@ -92,18 +92,16 @@ static int __init h720x_mtd_init(void)
         if (mymtd) {
                 mymtd->owner = THIS_MODULE;
 
-#ifdef CONFIG_MTD_PARTITIONS
                 nr_mtd_parts = parse_mtd_partitions(mymtd, probes, &mtd_parts, 0);
                 if (nr_mtd_parts > 0)
                         part_type = "command line";
-#endif
                 if (nr_mtd_parts <= 0) {
                         mtd_parts = h720x_partitions;
                         nr_mtd_parts = NUM_PARTITIONS;
                         part_type = "builtin";
                 }
                 printk(KERN_INFO "Using %s partition table\n", part_type);
-                add_mtd_partitions(mymtd, mtd_parts, nr_mtd_parts);
+                mtd_device_register(mymtd, mtd_parts, nr_mtd_parts);
                 return 0;
         }
 
@@ -118,7 +116,7 @@ static void __exit h720x_mtd_cleanup(void)
 {
 
         if (mymtd) {
-                del_mtd_partitions(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
 
diff --git a/drivers/mtd/maps/ichxrom.c b/drivers/mtd/maps/ichxrom.c
index 1337a4191a0c..6689dcb3124d 100644
--- a/drivers/mtd/maps/ichxrom.c
+++ b/drivers/mtd/maps/ichxrom.c
@@ -67,7 +67,7 @@ static void ichxrom_cleanup(struct ichxrom_window *window)
         list_for_each_entry_safe(map, scratch, &window->maps, list) {
                 if (map->rsrc.parent)
                         release_resource(&map->rsrc);
-                del_mtd_device(map->mtd);
+                mtd_device_unregister(map->mtd);
                 map_destroy(map->mtd);
                 list_del(&map->list);
                 kfree(map);
@@ -287,7 +287,7 @@ static int __devinit ichxrom_init_one (struct pci_dev *pdev,
 
                 /* Now that the mtd devices is complete claim and export it */
                 map->mtd->owner = THIS_MODULE;
-                if (add_mtd_device(map->mtd)) {
+                if (mtd_device_register(map->mtd, NULL, 0)) {
                         map_destroy(map->mtd);
                         map->mtd = NULL;
                         goto out;
diff --git a/drivers/mtd/maps/impa7.c b/drivers/mtd/maps/impa7.c
index 998a27da97f3..404a50cbafa0 100644
--- a/drivers/mtd/maps/impa7.c
+++ b/drivers/mtd/maps/impa7.c
@@ -15,10 +15,7 @@
 #include <asm/io.h>
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/map.h>
-
-#ifdef CONFIG_MTD_PARTITIONS
 #include <linux/mtd/partitions.h>
-#endif
 
 #define WINDOW_ADDR0 0x00000000      /* physical properties of flash */
 #define WINDOW_SIZE0 0x00800000
@@ -49,8 +46,6 @@ static struct map_info impa7_map[NUM_FLASHBANKS] = {
         },
 };
 
-#ifdef CONFIG_MTD_PARTITIONS
-
 /*
  * MTD partitioning stuff
  */
@@ -66,8 +61,6 @@ static struct mtd_partition static_partitions[] =
 static int mtd_parts_nb[NUM_FLASHBANKS];
 static struct mtd_partition *mtd_parts[NUM_FLASHBANKS];
 
-#endif
-
 static const char *probes[] = { "cmdlinepart", NULL };
 
 static int __init init_impa7(void)
@@ -104,7 +97,6 @@ static int __init init_impa7(void)
                 if (impa7_mtd[i]) {
                         impa7_mtd[i]->owner = THIS_MODULE;
                         devicesfound++;
-#ifdef CONFIG_MTD_PARTITIONS
                         mtd_parts_nb[i] = parse_mtd_partitions(impa7_mtd[i],
                                                                probes,
                                                                &mtd_parts[i],
@@ -120,12 +112,8 @@ static int __init init_impa7(void)
                         printk(KERN_NOTICE MSG_PREFIX
                                "using %s partition definition\n",
                                part_type);
-                        add_mtd_partitions(impa7_mtd[i],
-                                           mtd_parts[i], mtd_parts_nb[i]);
-#else
-                        add_mtd_device(impa7_mtd[i]);
-
-#endif
+                        mtd_device_register(impa7_mtd[i],
+                                            mtd_parts[i], mtd_parts_nb[i]);
                 }
                 else
                         iounmap((void *)impa7_map[i].virt);
@@ -138,11 +126,7 @@ static void __exit cleanup_impa7(void)
         int i;
         for (i=0; i<NUM_FLASHBANKS; i++) {
                 if (impa7_mtd[i]) {
-#ifdef CONFIG_MTD_PARTITIONS
-                        del_mtd_partitions(impa7_mtd[i]);
-#else
-                        del_mtd_device(impa7_mtd[i]);
-#endif
+                        mtd_device_unregister(impa7_mtd[i]);
                         map_destroy(impa7_mtd[i]);
                         iounmap((void *)impa7_map[i].virt);
                         impa7_map[i].virt = 0;
diff --git a/drivers/mtd/maps/intel_vr_nor.c b/drivers/mtd/maps/intel_vr_nor.c
index fc1998512eb4..d2f47be8754b 100644
--- a/drivers/mtd/maps/intel_vr_nor.c
+++ b/drivers/mtd/maps/intel_vr_nor.c
@@ -66,33 +66,18 @@ struct vr_nor_mtd {
 
 static void __devexit vr_nor_destroy_partitions(struct vr_nor_mtd *p)
 {
-        if (p->nr_parts > 0) {
-#if defined(CONFIG_MTD_PARTITIONS) || defined(CONFIG_MTD_PARTITIONS_MODULE)
-                del_mtd_partitions(p->info);
-#endif
-        } else
-                del_mtd_device(p->info);
+        mtd_device_unregister(p->info);
 }
 
 static int __devinit vr_nor_init_partitions(struct vr_nor_mtd *p)
 {
-        int err = 0;
-#if defined(CONFIG_MTD_PARTITIONS) || defined(CONFIG_MTD_PARTITIONS_MODULE)
         struct mtd_partition *parts;
         static const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
         /* register the flash bank */
-#if defined(CONFIG_MTD_PARTITIONS) || defined(CONFIG_MTD_PARTITIONS_MODULE)
         /* partition the flash bank */
         p->nr_parts = parse_mtd_partitions(p->info, part_probes, &parts, 0);
-        if (p->nr_parts > 0)
-                err = add_mtd_partitions(p->info, parts, p->nr_parts);
-#endif
-        if (p->nr_parts <= 0)
-                err = add_mtd_device(p->info);
-
-        return err;
+        return mtd_device_register(p->info, parts, p->nr_parts);
 }
 
 static void __devexit vr_nor_destroy_mtd_setup(struct vr_nor_mtd *p)
diff --git a/drivers/mtd/maps/ixp2000.c b/drivers/mtd/maps/ixp2000.c
index 9639d83a9d6c..c00b9175ba9e 100644
--- a/drivers/mtd/maps/ixp2000.c
+++ b/drivers/mtd/maps/ixp2000.c
@@ -119,7 +119,7 @@ static int ixp2000_flash_remove(struct platform_device *dev)
                 return 0;
 
         if (info->mtd) {
-                del_mtd_partitions(info->mtd);
+                mtd_device_unregister(info->mtd);
                 map_destroy(info->mtd);
         }
         if (info->map.map_priv_1)
@@ -230,7 +230,7 @@ static int ixp2000_flash_probe(struct platform_device *dev)
 
         err = parse_mtd_partitions(info->mtd, probes, &info->partitions, 0);
         if (err > 0) {
-                err = add_mtd_partitions(info->mtd, info->partitions, err);
+                err = mtd_device_register(info->mtd, info->partitions, err);
                 if(err)
                         dev_err(&dev->dev, "Could not parse partitions\n");
         }
diff --git a/drivers/mtd/maps/ixp4xx.c b/drivers/mtd/maps/ixp4xx.c
index 1f9fde0dad35..155b21942f47 100644
--- a/drivers/mtd/maps/ixp4xx.c
+++ b/drivers/mtd/maps/ixp4xx.c
@@ -162,7 +162,7 @@ static int ixp4xx_flash_remove(struct platform_device *dev)
                 return 0;
 
         if (info->mtd) {
-                del_mtd_partitions(info->mtd);
+                mtd_device_unregister(info->mtd);
                 map_destroy(info->mtd);
         }
         if (info->map.virt)
@@ -252,10 +252,8 @@ static int ixp4xx_flash_probe(struct platform_device *dev)
         /* Use the fast version */
         info->map.write = ixp4xx_write16;
 
-#ifdef CONFIG_MTD_PARTITIONS
         nr_parts = parse_mtd_partitions(info->mtd, probes, &info->partitions,
                                         dev->resource->start);
-#endif
         if (nr_parts > 0) {
                 part_type = "dynamic";
         } else {
@@ -263,18 +261,16 @@ static int ixp4xx_flash_probe(struct platform_device *dev)
                 nr_parts = plat->nr_parts;
                 part_type = "static";
         }
-        if (nr_parts == 0) {
+        if (nr_parts == 0)
                 printk(KERN_NOTICE "IXP4xx flash: no partition info "
                         "available, registering whole flash\n");
-                err = add_mtd_device(info->mtd);
-        } else {
+        else
                 printk(KERN_NOTICE "IXP4xx flash: using %s partition "
                         "definition\n", part_type);
-                err = add_mtd_partitions(info->mtd, info->partitions, nr_parts);
 
-                if(err)
-                        printk(KERN_ERR "Could not parse partitions\n");
-        }
+        err = mtd_device_register(info->mtd, info->partitions, nr_parts);
+        if (err)
+                printk(KERN_ERR "Could not parse partitions\n");
 
         if (err)
                 goto Error;
diff --git a/drivers/mtd/maps/l440gx.c b/drivers/mtd/maps/l440gx.c
index 9e054503c4cf..dd0360ba2412 100644
--- a/drivers/mtd/maps/l440gx.c
+++ b/drivers/mtd/maps/l440gx.c
@@ -138,7 +138,7 @@ static int __init init_l440gx(void)
         if (mymtd) {
                 mymtd->owner = THIS_MODULE;
 
-                add_mtd_device(mymtd);
+                mtd_device_register(mymtd, NULL, 0);
                 return 0;
         }
 
@@ -148,7 +148,7 @@ static int __init init_l440gx(void)
 
 static void __exit cleanup_l440gx(void)
 {
-        del_mtd_device(mymtd);
+        mtd_device_unregister(mymtd);
         map_destroy(mymtd);
 
         iounmap(l440gx_map.virt);
diff --git a/drivers/mtd/maps/latch-addr-flash.c b/drivers/mtd/maps/latch-addr-flash.c
index ee2548085334..5936c466e901 100644
--- a/drivers/mtd/maps/latch-addr-flash.c
+++ b/drivers/mtd/maps/latch-addr-flash.c
@@ -112,18 +112,9 @@ static int latch_addr_flash_remove(struct platform_device *dev)
         latch_addr_data = dev->dev.platform_data;
 
         if (info->mtd != NULL) {
-                if (mtd_has_partitions()) {
-                        if (info->nr_parts) {
-                                del_mtd_partitions(info->mtd);
-                                kfree(info->parts);
-                        } else if (latch_addr_data->nr_parts) {
-                                del_mtd_partitions(info->mtd);
-                        } else {
-                                del_mtd_device(info->mtd);
-                        }
-                } else {
-                        del_mtd_device(info->mtd);
-                }
+                if (info->nr_parts)
+                        kfree(info->parts);
+                mtd_device_unregister(info->mtd);
                 map_destroy(info->mtd);
         }
 
@@ -215,23 +206,21 @@ static int __devinit latch_addr_flash_probe(struct platform_device *dev)
         }
         info->mtd->owner = THIS_MODULE;
 
-        if (mtd_has_partitions()) {
-
-                err = parse_mtd_partitions(info->mtd,
-                                           (const char **)part_probe_types,
-                                           &info->parts, 0);
-                if (err > 0) {
-                        add_mtd_partitions(info->mtd, info->parts, err);
-                        return 0;
-                }
-                if (latch_addr_data->nr_parts) {
-                        pr_notice("Using latch-addr-flash partition information\n");
-                        add_mtd_partitions(info->mtd, latch_addr_data->parts,
-                                        latch_addr_data->nr_parts);
-                        return 0;
-                }
+        err = parse_mtd_partitions(info->mtd, (const char **)part_probe_types,
+                                   &info->parts, 0);
+        if (err > 0) {
+                mtd_device_register(info->mtd, info->parts, err);
+                return 0;
+        }
+        if (latch_addr_data->nr_parts) {
+                pr_notice("Using latch-addr-flash partition information\n");
+                mtd_device_register(info->mtd,
+                                    latch_addr_data->parts,
+                                    latch_addr_data->nr_parts);
+                return 0;
         }
-        add_mtd_device(info->mtd);
+
+        mtd_device_register(info->mtd, NULL, 0);
         return 0;
 
 iounmap:
diff --git a/drivers/mtd/maps/mbx860.c b/drivers/mtd/maps/mbx860.c
index 0eb5a7c85380..93fa56c33003 100644
--- a/drivers/mtd/maps/mbx860.c
+++ b/drivers/mtd/maps/mbx860.c
@@ -69,8 +69,8 @@ static int __init init_mbx(void)
         mymtd = do_map_probe("jedec_probe", &mbx_map);
         if (mymtd) {
                 mymtd->owner = THIS_MODULE;
-                add_mtd_device(mymtd);
-                add_mtd_partitions(mymtd, partition_info, NUM_PARTITIONS);
+                mtd_device_register(mymtd, NULL, 0);
+                mtd_device_register(mymtd, partition_info, NUM_PARTITIONS);
                 return 0;
         }
 
@@ -81,7 +81,7 @@ static int __init init_mbx(void)
 static void __exit cleanup_mbx(void)
 {
         if (mymtd) {
-                del_mtd_device(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (mbx_map.virt) {
diff --git a/drivers/mtd/maps/netsc520.c b/drivers/mtd/maps/netsc520.c
index c0cb319b2b70..81dc2598bc0a 100644
--- a/drivers/mtd/maps/netsc520.c
+++ b/drivers/mtd/maps/netsc520.c
@@ -116,14 +116,14 @@ static int __init init_netsc520(void)
         }
 
         mymtd->owner = THIS_MODULE;
-        add_mtd_partitions( mymtd, partition_info, NUM_PARTITIONS );
+        mtd_device_register(mymtd, partition_info, NUM_PARTITIONS);
         return 0;
 }
 
 static void __exit cleanup_netsc520(void)
 {
         if (mymtd) {
-                del_mtd_partitions(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (netsc520_map.virt) {
diff --git a/drivers/mtd/maps/nettel.c b/drivers/mtd/maps/nettel.c
index a97133eb9d70..eadcfffc4f9c 100644
--- a/drivers/mtd/maps/nettel.c
+++ b/drivers/mtd/maps/nettel.c
@@ -383,13 +383,13 @@ static int __init nettel_init(void)
                 /* No BIOS regions when AMD boot */
                 num_intel_partitions -= 2;
         }
-        rc = add_mtd_partitions(intel_mtd, nettel_intel_partitions,
-                num_intel_partitions);
+        rc = mtd_device_register(intel_mtd, nettel_intel_partitions,
+                                 num_intel_partitions);
 #endif
 
         if (amd_mtd) {
-                rc = add_mtd_partitions(amd_mtd, nettel_amd_partitions,
-                        num_amd_partitions);
+                rc = mtd_device_register(amd_mtd, nettel_amd_partitions,
+                                         num_amd_partitions);
         }
 
 #ifdef CONFIG_MTD_CFI_INTELEXT
@@ -419,7 +419,7 @@ static void __exit nettel_cleanup(void)
         unregister_reboot_notifier(&nettel_notifier_block);
 #endif
         if (amd_mtd) {
-                del_mtd_partitions(amd_mtd);
+                mtd_device_unregister(amd_mtd);
                 map_destroy(amd_mtd);
         }
         if (nettel_mmcrp) {
@@ -432,7 +432,7 @@ static void __exit nettel_cleanup(void)
         }
 #ifdef CONFIG_MTD_CFI_INTELEXT
         if (intel_mtd) {
-                del_mtd_partitions(intel_mtd);
+                mtd_device_unregister(intel_mtd);
                 map_destroy(intel_mtd);
         }
         if (nettel_intel_map.virt) {
diff --git a/drivers/mtd/maps/octagon-5066.c b/drivers/mtd/maps/octagon-5066.c
index 23fe1786770f..807ac2a2e686 100644
--- a/drivers/mtd/maps/octagon-5066.c
+++ b/drivers/mtd/maps/octagon-5066.c
@@ -175,7 +175,7 @@ void cleanup_oct5066(void)
         int i;
         for (i=0; i<2; i++) {
                 if (oct5066_mtd[i]) {
-                        del_mtd_device(oct5066_mtd[i]);
+                        mtd_device_unregister(oct5066_mtd[i]);
                         map_destroy(oct5066_mtd[i]);
                 }
         }
@@ -220,7 +220,7 @@ static int __init init_oct5066(void)
                         oct5066_mtd[i] = do_map_probe("map_rom", &oct5066_map[i]);
                 if (oct5066_mtd[i]) {
                         oct5066_mtd[i]->owner = THIS_MODULE;
-                        add_mtd_device(oct5066_mtd[i]);
+                        mtd_device_register(oct5066_mtd[i], NULL, 0);
                 }
         }
 
diff --git a/drivers/mtd/maps/pci.c b/drivers/mtd/maps/pci.c
index 48f4cf5cb9d1..1d005a3e9b41 100644
--- a/drivers/mtd/maps/pci.c
+++ b/drivers/mtd/maps/pci.c
@@ -313,7 +313,7 @@ mtd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 goto release;
 
         mtd->owner = THIS_MODULE;
-        add_mtd_device(mtd);
+        mtd_device_register(mtd, NULL, 0);
 
         pci_set_drvdata(dev, mtd);
 
@@ -336,7 +336,7 @@ mtd_pci_remove(struct pci_dev *dev)
         struct mtd_info *mtd = pci_get_drvdata(dev);
         struct map_pci_info *map = mtd->priv;
 
-        del_mtd_device(mtd);
+        mtd_device_unregister(mtd);
         map_destroy(mtd);
         map->exit(dev, map);
         kfree(map);
diff --git a/drivers/mtd/maps/pcmciamtd.c b/drivers/mtd/maps/pcmciamtd.c
index 33dc2829b01b..bbe168b65c26 100644
--- a/drivers/mtd/maps/pcmciamtd.c
+++ b/drivers/mtd/maps/pcmciamtd.c
@@ -630,7 +630,7 @@ static int pcmciamtd_config(struct pcmcia_device *link)
                 dev->pcmcia_map.copy_to = pcmcia_copy_to;
         }
 
-        if(add_mtd_device(mtd)) {
+        if (mtd_device_register(mtd, NULL, 0)) {
                 map_destroy(mtd);
                 dev->mtd_info = NULL;
                 dev_err(&dev->p_dev->dev,
@@ -669,7 +669,7 @@ static void pcmciamtd_detach(struct pcmcia_device *link)
         DEBUG(3, "link=0x%p", link);
 
         if(dev->mtd_info) {
-                del_mtd_device(dev->mtd_info);
+                mtd_device_unregister(dev->mtd_info);
                 dev_info(&dev->p_dev->dev, "mtd%d: Removing\n",
                          dev->mtd_info->index);
                 map_destroy(dev->mtd_info);
diff --git a/drivers/mtd/maps/physmap.c b/drivers/mtd/maps/physmap.c
index 1a9b94f0ee54..f64cee4a3bfb 100644
--- a/drivers/mtd/maps/physmap.c
+++ b/drivers/mtd/maps/physmap.c
@@ -27,10 +27,8 @@ struct physmap_flash_info {
         struct mtd_info         *mtd[MAX_RESOURCES];
         struct mtd_info         *cmtd;
         struct map_info         map[MAX_RESOURCES];
-#ifdef CONFIG_MTD_PARTITIONS
         int                     nr_parts;
         struct mtd_partition    *parts;
-#endif
 };
 
 static int physmap_flash_remove(struct platform_device *dev)
@@ -47,18 +45,9 @@ static int physmap_flash_remove(struct platform_device *dev)
         physmap_data = dev->dev.platform_data;
 
         if (info->cmtd) {
-#ifdef CONFIG_MTD_PARTITIONS
-                if (info->nr_parts || physmap_data->nr_parts) {
-                        del_mtd_partitions(info->cmtd);
-
-                        if (info->nr_parts)
-                                kfree(info->parts);
-                } else {
-                        del_mtd_device(info->cmtd);
-                }
-#else
-                del_mtd_device(info->cmtd);
-#endif
+                mtd_device_unregister(info->cmtd);
+                if (info->nr_parts)
+                        kfree(info->parts);
                 if (info->cmtd != info->mtd[0])
                         mtd_concat_destroy(info->cmtd);
         }
@@ -92,10 +81,8 @@ static const char *rom_probe_types[] = {
                                         "qinfo_probe",
                                         "map_rom",
                                         NULL };
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probe_types[] = { "cmdlinepart", "RedBoot", "afs",
                                           NULL };
-#endif
 
 static int physmap_flash_probe(struct platform_device *dev)
 {
@@ -188,24 +175,23 @@ static int physmap_flash_probe(struct platform_device *dev)
         if (err)
                 goto err_out;
 
-#ifdef CONFIG_MTD_PARTITIONS
         err = parse_mtd_partitions(info->cmtd, part_probe_types,
-                                &info->parts, 0);
+                                   &info->parts, 0);
         if (err > 0) {
-                add_mtd_partitions(info->cmtd, info->parts, err);
+                mtd_device_register(info->cmtd, info->parts, err);
                 info->nr_parts = err;
                 return 0;
         }
 
         if (physmap_data->nr_parts) {
                 printk(KERN_NOTICE "Using physmap partition information\n");
-                add_mtd_partitions(info->cmtd, physmap_data->parts,
-                                   physmap_data->nr_parts);
+                mtd_device_register(info->cmtd, physmap_data->parts,
+                                    physmap_data->nr_parts);
                 return 0;
         }
-#endif
 
-        add_mtd_device(info->cmtd);
+        mtd_device_register(info->cmtd, NULL, 0);
+
         return 0;
 
 err_out:
@@ -269,14 +255,12 @@ void physmap_configure(unsigned long addr, unsigned long size,
         physmap_flash_data.set_vpp = set_vpp;
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 void physmap_set_partitions(struct mtd_partition *parts, int num_parts)
 {
         physmap_flash_data.nr_parts = num_parts;
         physmap_flash_data.parts = parts;
 }
 #endif
-#endif
 
 static int __init physmap_init(void)
 {
diff --git a/drivers/mtd/maps/physmap_of.c b/drivers/mtd/maps/physmap_of.c
index c1d33464aee8..d251d1db129b 100644
--- a/drivers/mtd/maps/physmap_of.c
+++ b/drivers/mtd/maps/physmap_of.c
@@ -34,16 +34,12 @@ struct of_flash_list {
 
 struct of_flash {
         struct mtd_info         *cmtd;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition    *parts;
-#endif
         int list_size; /* number of elements in of_flash_list */
         struct of_flash_list    list[0];
 };
 
-#ifdef CONFIG_MTD_PARTITIONS
 #define OF_FLASH_PARTS(info)    ((info)->parts)
-
 static int parse_obsolete_partitions(struct platform_device *dev,
                                      struct of_flash *info,
                                      struct device_node *dp)
@@ -89,10 +85,6 @@ static int parse_obsolete_partitions(struct platform_device *dev,
 
         return nr_parts;
 }
-#else /* MTD_PARTITIONS */
-#define OF_FLASH_PARTS(info)            (0)
-#define parse_partitions(info, dev)     (0)
-#endif /* MTD_PARTITIONS */
 
 static int of_flash_remove(struct platform_device *dev)
 {
@@ -105,17 +97,14 @@ static int of_flash_remove(struct platform_device *dev)
         dev_set_drvdata(&dev->dev, NULL);
 
         if (info->cmtd != info->list[0].mtd) {
-                del_mtd_device(info->cmtd);
+                mtd_device_unregister(info->cmtd);
                 mtd_concat_destroy(info->cmtd);
         }
 
         if (info->cmtd) {
-                if (OF_FLASH_PARTS(info)) {
-                        del_mtd_partitions(info->cmtd);
+                if (OF_FLASH_PARTS(info))
                         kfree(OF_FLASH_PARTS(info));
-                } else {
-                        del_mtd_device(info->cmtd);
-                }
+                mtd_device_unregister(info->cmtd);
         }
 
         for (i = 0; i < info->list_size; i++) {
@@ -172,7 +161,6 @@ static struct mtd_info * __devinit obsolete_probe(struct platform_device *dev,
         }
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 /* When partitions are set we look for a linux,part-probe property which
    specifies the list of partition probers to use. If none is given then the
    default is use. These take precedence over other device tree
@@ -212,14 +200,11 @@ static void __devinit of_free_probes(const char **probes)
         if (probes != part_probe_types_def)
                 kfree(probes);
 }
-#endif
 
 static struct of_device_id of_flash_match[];
 static int __devinit of_flash_probe(struct platform_device *dev)
 {
-#ifdef CONFIG_MTD_PARTITIONS
         const char **part_probe_types;
-#endif
         const struct of_device_id *match;
         struct device_node *dp = dev->dev.of_node;
         struct resource res;
@@ -346,7 +331,6 @@ static int __devinit of_flash_probe(struct platform_device *dev)
         if (err)
                 goto err_out;
 
-#ifdef CONFIG_MTD_PARTITIONS
         part_probe_types = of_get_probes(dp);
         err = parse_mtd_partitions(info->cmtd, part_probe_types,
                                    &info->parts, 0);
@@ -356,13 +340,11 @@ static int __devinit of_flash_probe(struct platform_device *dev)
         }
         of_free_probes(part_probe_types);
 
-#ifdef CONFIG_MTD_OF_PARTS
         if (err == 0) {
                 err = of_mtd_parse_partitions(&dev->dev, dp, &info->parts);
                 if (err < 0)
                         goto err_out;
         }
-#endif
 
         if (err == 0) {
                 err = parse_obsolete_partitions(dev, info, dp);
@@ -370,11 +352,7 @@ static int __devinit of_flash_probe(struct platform_device *dev)
                         goto err_out;
         }
 
-        if (err > 0)
-                add_mtd_partitions(info->cmtd, info->parts, err);
-        else
-#endif
-                add_mtd_device(info->cmtd);
+        mtd_device_register(info->cmtd, info->parts, err);
 
         kfree(mtd_list);
 
diff --git a/drivers/mtd/maps/plat-ram.c b/drivers/mtd/maps/plat-ram.c
index 76a76be5a7bd..9ca1eccba4bc 100644
--- a/drivers/mtd/maps/plat-ram.c
+++ b/drivers/mtd/maps/plat-ram.c
@@ -94,14 +94,11 @@ static int platram_remove(struct platform_device *pdev)
                 return 0;
 
         if (info->mtd) {
-#ifdef CONFIG_MTD_PARTITIONS
+                mtd_device_unregister(info->mtd);
                 if (info->partitions) {
-                        del_mtd_partitions(info->mtd);
                         if (info->free_partitions)
                                 kfree(info->partitions);
                 }
-#endif
-                del_mtd_device(info->mtd);
                 map_destroy(info->mtd);
         }
 
@@ -231,7 +228,6 @@ static int platram_probe(struct platform_device *pdev)
         /* check to see if there are any available partitions, or wether
          * to add this device whole */
 
-#ifdef CONFIG_MTD_PARTITIONS
         if (!pdata->nr_partitions) {
                 /* try to probe using the supplied probe type */
                 if (pdata->probes) {
@@ -239,24 +235,22 @@ static int platram_probe(struct platform_device *pdev)
                                            &info->partitions, 0);
                         info->free_partitions = 1;
                         if (err > 0)
-                                err = add_mtd_partitions(info->mtd,
+                                err = mtd_device_register(info->mtd,
                                         info->partitions, err);
                 }
         }
         /* use the static mapping */
         else
-                err = add_mtd_partitions(info->mtd, pdata->partitions,
-                                pdata->nr_partitions);
-#endif /* CONFIG_MTD_PARTITIONS */
-
-        if (add_mtd_device(info->mtd)) {
-                dev_err(&pdev->dev, "add_mtd_device() failed\n");
-                err = -ENOMEM;
-        }
-
+                err = mtd_device_register(info->mtd, pdata->partitions,
+                                          pdata->nr_partitions);
         if (!err)
                 dev_info(&pdev->dev, "registered mtd device\n");
 
+        /* add the whole device. */
+        err = mtd_device_register(info->mtd, NULL, 0);
+        if (err)
+                dev_err(&pdev->dev, "failed to register the entire device\n");
+
         return err;
 
  exit_free:
diff --git a/drivers/mtd/maps/pmcmsp-flash.c b/drivers/mtd/maps/pmcmsp-flash.c
index 64aea6acd48e..744ca5cacc9b 100644
--- a/drivers/mtd/maps/pmcmsp-flash.c
+++ b/drivers/mtd/maps/pmcmsp-flash.c
@@ -173,7 +173,7 @@ static int __init init_msp_flash(void)
                 msp_flash[i] = do_map_probe("cfi_probe", &msp_maps[i]);
                 if (msp_flash[i]) {
                         msp_flash[i]->owner = THIS_MODULE;
-                        add_mtd_partitions(msp_flash[i], msp_parts[i], pcnt);
+                        mtd_device_register(msp_flash[i], msp_parts[i], pcnt);
                 } else {
                         printk(KERN_ERR "map probe failed for flash\n");
                         ret = -ENXIO;
@@ -188,7 +188,7 @@ static int __init init_msp_flash(void)
 
 cleanup_loop:
         while (i--) {
-                del_mtd_partitions(msp_flash[i]);
+                mtd_device_unregister(msp_flash[i]);
                 map_destroy(msp_flash[i]);
                 kfree(msp_maps[i].name);
                 iounmap(msp_maps[i].virt);
@@ -207,7 +207,7 @@ static void __exit cleanup_msp_flash(void)
         int i;
 
         for (i = 0; i < fcnt; i++) {
-                del_mtd_partitions(msp_flash[i]);
+                mtd_device_unregister(msp_flash[i]);
                 map_destroy(msp_flash[i]);
                 iounmap((void *)msp_maps[i].virt);
 
diff --git a/drivers/mtd/maps/pxa2xx-flash.c b/drivers/mtd/maps/pxa2xx-flash.c
index d8ae634d347e..f59d62f74d44 100644
--- a/drivers/mtd/maps/pxa2xx-flash.c
+++ b/drivers/mtd/maps/pxa2xx-flash.c
@@ -104,23 +104,18 @@ static int __devinit pxa2xx_flash_probe(struct platform_device *pdev)
         }
         info->mtd->owner = THIS_MODULE;
 
-#ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(info->mtd, probes, &parts, 0);
 
         if (ret > 0) {
                 info->nr_parts = ret;
                 info->parts = parts;
         }
-#endif
 
-        if (info->nr_parts) {
-                add_mtd_partitions(info->mtd, info->parts,
-                                   info->nr_parts);
-        } else {
+        if (!info->nr_parts)
                 printk("Registering %s as whole device\n",
                        info->map.name);
-                add_mtd_device(info->mtd);
-        }
+
+        mtd_device_register(info->mtd, info->parts, info->nr_parts);
 
         platform_set_drvdata(pdev, info);
         return 0;
@@ -132,12 +127,7 @@ static int __devexit pxa2xx_flash_remove(struct platform_device *dev)
 
         platform_set_drvdata(dev, NULL);
 
-#ifdef CONFIG_MTD_PARTITIONS
-        if (info->nr_parts)
-                del_mtd_partitions(info->mtd);
-        else
-#endif
-                del_mtd_device(info->mtd);
+        mtd_device_unregister(info->mtd);
 
         map_destroy(info->mtd);
         iounmap(info->map.virt);
diff --git a/drivers/mtd/maps/rbtx4939-flash.c b/drivers/mtd/maps/rbtx4939-flash.c
index 83ed64512c5e..761fb459d2c7 100644
--- a/drivers/mtd/maps/rbtx4939-flash.c
+++ b/drivers/mtd/maps/rbtx4939-flash.c
@@ -25,10 +25,8 @@
 struct rbtx4939_flash_info {
         struct mtd_info *mtd;
         struct map_info map;
-#ifdef CONFIG_MTD_PARTITIONS
         int nr_parts;
         struct mtd_partition *parts;
-#endif
 };
 
 static int rbtx4939_flash_remove(struct platform_device *dev)
@@ -41,28 +39,18 @@ static int rbtx4939_flash_remove(struct platform_device *dev)
         platform_set_drvdata(dev, NULL);
 
         if (info->mtd) {
-#ifdef CONFIG_MTD_PARTITIONS
                 struct rbtx4939_flash_data *pdata = dev->dev.platform_data;
 
-                if (info->nr_parts) {
-                        del_mtd_partitions(info->mtd);
+                if (info->nr_parts)
                         kfree(info->parts);
-                } else if (pdata->nr_parts)
-                        del_mtd_partitions(info->mtd);
-                else
-                        del_mtd_device(info->mtd);
-#else
-                del_mtd_device(info->mtd);
-#endif
+                mtd_device_unregister(info->mtd);
                 map_destroy(info->mtd);
         }
         return 0;
 }
 
 static const char *rom_probe_types[] = { "cfi_probe", "jedec_probe", NULL };
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probe_types[] = { "cmdlinepart", NULL };
-#endif
 
 static int rbtx4939_flash_probe(struct platform_device *dev)
 {
@@ -120,23 +108,21 @@ static int rbtx4939_flash_probe(struct platform_device *dev)
         if (err)
                 goto err_out;
 
-#ifdef CONFIG_MTD_PARTITIONS
         err = parse_mtd_partitions(info->mtd, part_probe_types,
                                 &info->parts, 0);
         if (err > 0) {
-                add_mtd_partitions(info->mtd, info->parts, err);
+                mtd_device_register(info->mtd, info->parts, err);
                 info->nr_parts = err;
                 return 0;
         }
 
         if (pdata->nr_parts) {
                 pr_notice("Using rbtx4939 partition information\n");
-                add_mtd_partitions(info->mtd, pdata->parts, pdata->nr_parts);
+                mtd_device_register(info->mtd, pdata->parts, pdata->nr_parts);
                 return 0;
         }
-#endif
 
-        add_mtd_device(info->mtd);
+        mtd_device_register(info->mtd, NULL, 0);
         return 0;
 
 err_out:
diff --git a/drivers/mtd/maps/rpxlite.c b/drivers/mtd/maps/rpxlite.c
index 3e3ef53d4fd4..ed88225bf667 100644
--- a/drivers/mtd/maps/rpxlite.c
+++ b/drivers/mtd/maps/rpxlite.c
@@ -36,7 +36,7 @@ static int __init init_rpxlite(void)
         mymtd = do_map_probe("cfi_probe", &rpxlite_map);
         if (mymtd) {
                 mymtd->owner = THIS_MODULE;
-                add_mtd_device(mymtd);
+                mtd_device_register(mymtd, NULL, 0);
                 return 0;
         }
 
@@ -47,7 +47,7 @@ static int __init init_rpxlite(void)
 static void __exit cleanup_rpxlite(void)
 {
         if (mymtd) {
-                del_mtd_device(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (rpxlite_map.virt) {
diff --git a/drivers/mtd/maps/sa1100-flash.c b/drivers/mtd/maps/sa1100-flash.c
index da875908ea8e..a9b5e0e5c4c5 100644
--- a/drivers/mtd/maps/sa1100-flash.c
+++ b/drivers/mtd/maps/sa1100-flash.c
@@ -226,12 +226,7 @@ static void sa1100_destroy(struct sa_info *info, struct flash_platform_data *pla
         int i;
 
         if (info->mtd) {
-                if (info->nr_parts == 0)
-                        del_mtd_device(info->mtd);
-#ifdef CONFIG_MTD_PARTITIONS
-                else
-                        del_mtd_partitions(info->mtd);
-#endif
+                mtd_device_unregister(info->mtd);
                 if (info->mtd != info->subdev[0].mtd)
                         mtd_concat_destroy(info->mtd);
         }
@@ -363,28 +358,24 @@ static int __devinit sa1100_mtd_probe(struct platform_device *pdev)
         /*
          * Partition selection stuff.
          */
-#ifdef CONFIG_MTD_PARTITIONS
         nr_parts = parse_mtd_partitions(info->mtd, part_probes, &parts, 0);
         if (nr_parts > 0) {
                 info->parts = parts;
                 part_type = "dynamic";
-        } else
-#endif
-        {
+        } else {
                 parts = plat->parts;
                 nr_parts = plat->nr_parts;
                 part_type = "static";
         }
 
-        if (nr_parts == 0) {
+        if (nr_parts == 0)
                 printk(KERN_NOTICE "SA1100 flash: no partition info "
                         "available, registering whole flash\n");
-                add_mtd_device(info->mtd);
-        } else {
+        else
                 printk(KERN_NOTICE "SA1100 flash: using %s partition "
                         "definition\n", part_type);
-                add_mtd_partitions(info->mtd, parts, nr_parts);
-        }
+
+        mtd_device_register(info->mtd, parts, nr_parts);
 
         info->nr_parts = nr_parts;
 
diff --git a/drivers/mtd/maps/sbc_gxx.c b/drivers/mtd/maps/sbc_gxx.c
index 04b2781fc627..556a2dfe94c5 100644
--- a/drivers/mtd/maps/sbc_gxx.c
+++ b/drivers/mtd/maps/sbc_gxx.c
@@ -182,7 +182,7 @@ static struct mtd_info *all_mtd;
 static void cleanup_sbc_gxx(void)
 {
         if( all_mtd ) {
-                del_mtd_partitions( all_mtd );
+                mtd_device_unregister(all_mtd);
                 map_destroy( all_mtd );
         }
 
@@ -223,7 +223,7 @@ static int __init init_sbc_gxx(void)
         all_mtd->owner = THIS_MODULE;
 
         /* Create MTD devices for each partition. */
-        add_mtd_partitions(all_mtd, partition_info, NUM_PARTITIONS );
+        mtd_device_register(all_mtd, partition_info, NUM_PARTITIONS);
 
         return 0;
 }
diff --git a/drivers/mtd/maps/sc520cdp.c b/drivers/mtd/maps/sc520cdp.c
index 4d8aaaf4bb76..8fead8e46bce 100644
--- a/drivers/mtd/maps/sc520cdp.c
+++ b/drivers/mtd/maps/sc520cdp.c
@@ -266,10 +266,10 @@ static int __init init_sc520cdp(void)
                 /* Combine the two flash banks into a single MTD device & register it: */
                 merged_mtd = mtd_concat_create(mymtd, 2, "SC520CDP Flash Banks #0 and #1");
                 if(merged_mtd)
-                        add_mtd_device(merged_mtd);
+                        mtd_device_register(merged_mtd, NULL, 0);
         }
         if(devices_found == 3) /* register the third (DIL-Flash) device */
-                add_mtd_device(mymtd[2]);
+                mtd_device_register(mymtd[2], NULL, 0);
         return(devices_found ? 0 : -ENXIO);
 }
 
@@ -278,11 +278,11 @@ static void __exit cleanup_sc520cdp(void)
         int i;
 
         if (merged_mtd) {
-                del_mtd_device(merged_mtd);
+                mtd_device_unregister(merged_mtd);
                 mtd_concat_destroy(merged_mtd);
         }
         if (mymtd[2])
-                del_mtd_device(mymtd[2]);
+                mtd_device_unregister(mymtd[2]);
 
         for (i = 0; i < NUM_FLASH_BANKS; i++) {
                 if (mymtd[i])
diff --git a/drivers/mtd/maps/scb2_flash.c b/drivers/mtd/maps/scb2_flash.c
index 7e329f09a548..d88c8426bb0f 100644
--- a/drivers/mtd/maps/scb2_flash.c
+++ b/drivers/mtd/maps/scb2_flash.c
@@ -180,7 +180,7 @@ scb2_flash_probe(struct pci_dev *dev, const struct pci_device_id *ent)
 
         scb2_mtd->owner = THIS_MODULE;
         if (scb2_fixup_mtd(scb2_mtd) < 0) {
-                del_mtd_device(scb2_mtd);
+                mtd_device_unregister(scb2_mtd);
                 map_destroy(scb2_mtd);
                 iounmap(scb2_ioaddr);
                 if (!region_fail)
@@ -192,7 +192,7 @@ scb2_flash_probe(struct pci_dev *dev, const struct pci_device_id *ent)
                (unsigned long long)scb2_mtd->size,
                (unsigned long long)(SCB2_WINDOW - scb2_mtd->size));
 
-        add_mtd_device(scb2_mtd);
+        mtd_device_register(scb2_mtd, NULL, 0);
 
         return 0;
 }
@@ -207,7 +207,7 @@ scb2_flash_remove(struct pci_dev *dev)
         if (scb2_mtd->lock)
                 scb2_mtd->lock(scb2_mtd, 0, scb2_mtd->size);
 
-        del_mtd_device(scb2_mtd);
+        mtd_device_unregister(scb2_mtd);
         map_destroy(scb2_mtd);
 
         iounmap(scb2_ioaddr);
diff --git a/drivers/mtd/maps/scx200_docflash.c b/drivers/mtd/maps/scx200_docflash.c
index 027e628a4f1d..f1c1f737d0d7 100644
--- a/drivers/mtd/maps/scx200_docflash.c
+++ b/drivers/mtd/maps/scx200_docflash.c
@@ -44,7 +44,6 @@ static struct resource docmem = {
 
 static struct mtd_info *mymtd;
 
-#ifdef CONFIG_MTD_PARTITIONS
 static struct mtd_partition partition_info[] = {
         {
                 .name   = "DOCCS Boot kernel",
@@ -68,8 +67,6 @@ static struct mtd_partition partition_info[] = {
         },
 };
 #define NUM_PARTITIONS ARRAY_SIZE(partition_info)
-#endif
-
 
 static struct map_info scx200_docflash_map = {
         .name      = "NatSemi SCx200 DOCCS Flash",
@@ -198,24 +195,17 @@ static int __init init_scx200_docflash(void)
 
         mymtd->owner = THIS_MODULE;
 
-#ifdef CONFIG_MTD_PARTITIONS
         partition_info[3].offset = mymtd->size-partition_info[3].size;
         partition_info[2].size = partition_info[3].offset-partition_info[2].offset;
-        add_mtd_partitions(mymtd, partition_info, NUM_PARTITIONS);
-#else
-        add_mtd_device(mymtd);
-#endif
+        mtd_device_register(mymtd, partition_info, NUM_PARTITIONS);
+
         return 0;
 }
 
 static void __exit cleanup_scx200_docflash(void)
 {
         if (mymtd) {
-#ifdef CONFIG_MTD_PARTITIONS
-                del_mtd_partitions(mymtd);
-#else
-                del_mtd_device(mymtd);
-#endif
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
         if (scx200_docflash_map.virt) {
diff --git a/drivers/mtd/maps/solutionengine.c b/drivers/mtd/maps/solutionengine.c
index 0eb41d9c6786..cbf6bade9354 100644
--- a/drivers/mtd/maps/solutionengine.c
+++ b/drivers/mtd/maps/solutionengine.c
@@ -89,7 +89,7 @@ static int __init init_soleng_maps(void)
         eprom_mtd = do_map_probe("map_rom", &soleng_eprom_map);
         if (eprom_mtd) {
                 eprom_mtd->owner = THIS_MODULE;
-                add_mtd_device(eprom_mtd);
+                mtd_device_register(eprom_mtd, NULL, 0);
         }
 
         nr_parts = parse_mtd_partitions(flash_mtd, probes, &parsed_parts, 0);
@@ -104,9 +104,9 @@ static int __init init_soleng_maps(void)
 #endif /* CONFIG_MTD_SUPERH_RESERVE */
 
         if (nr_parts > 0)
-                add_mtd_partitions(flash_mtd, parsed_parts, nr_parts);
+                mtd_device_register(flash_mtd, parsed_parts, nr_parts);
         else
-                add_mtd_device(flash_mtd);
+                mtd_device_register(flash_mtd, NULL, 0);
 
         return 0;
 }
@@ -114,14 +114,14 @@ static int __init init_soleng_maps(void)
 static void __exit cleanup_soleng_maps(void)
 {
         if (eprom_mtd) {
-                del_mtd_device(eprom_mtd);
+                mtd_device_unregister(eprom_mtd);
                 map_destroy(eprom_mtd);
         }
 
         if (parsed_parts)
-                del_mtd_partitions(flash_mtd);
+                mtd_device_unregister(flash_mtd);
         else
-                del_mtd_device(flash_mtd);
+                mtd_device_unregister(flash_mtd);
         map_destroy(flash_mtd);
 }
 
diff --git a/drivers/mtd/maps/sun_uflash.c b/drivers/mtd/maps/sun_uflash.c
index 3f1cb328a574..2d66234f57cb 100644
--- a/drivers/mtd/maps/sun_uflash.c
+++ b/drivers/mtd/maps/sun_uflash.c
@@ -101,7 +101,7 @@ int uflash_devinit(struct platform_device *op, struct device_node *dp)
 
         up->mtd->owner = THIS_MODULE;
 
-        add_mtd_device(up->mtd);
+        mtd_device_register(up->mtd, NULL, 0);
 
         dev_set_drvdata(&op->dev, up);
 
@@ -126,7 +126,7 @@ static int __devexit uflash_remove(struct platform_device *op)
         struct uflash_dev *up = dev_get_drvdata(&op->dev);
 
         if (up->mtd) {
-                del_mtd_device(up->mtd);
+                mtd_device_unregister(up->mtd);
                 map_destroy(up->mtd);
         }
         if (up->map.virt) {
diff --git a/drivers/mtd/maps/tqm8xxl.c b/drivers/mtd/maps/tqm8xxl.c
index 0718dfb3ee64..d78587990e7e 100644
--- a/drivers/mtd/maps/tqm8xxl.c
+++ b/drivers/mtd/maps/tqm8xxl.c
@@ -62,7 +62,6 @@ static void __iomem *start_scan_addr;
  * "struct map_desc *_io_desc" for the corresponding machine.
  */
 
-#ifdef CONFIG_MTD_PARTITIONS
 /* Currently, TQM8xxL has up to 8MiB flash */
 static unsigned long tqm8xxl_max_flash_size = 0x00800000;
 
@@ -107,7 +106,6 @@ static struct mtd_partition tqm8xxl_fs_partitions[] = {
           //.size = MTDPART_SIZ_FULL,
         }
 };
-#endif
 
 static int __init init_tqm_mtd(void)
 {
@@ -188,7 +186,6 @@ static int __init init_tqm_mtd(void)
                 goto error_mem;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
         /*
          * Select Static partition definitions
          */
@@ -201,21 +198,14 @@ static int __init init_tqm_mtd(void)
         part_banks[1].nums = ARRAY_SIZE(tqm8xxl_fs_partitions);
 
         for(idx = 0; idx < num_banks ; idx++) {
-                if (part_banks[idx].nums == 0) {
+                if (part_banks[idx].nums == 0)
                         printk(KERN_NOTICE "TQM flash%d: no partition info available, registering whole flash at once\n", idx);
-                        add_mtd_device(mtd_banks[idx]);
-                } else {
+                else
                         printk(KERN_NOTICE "TQM flash%d: Using %s partition definition\n",
                                         idx, part_banks[idx].type);
-                        add_mtd_partitions(mtd_banks[idx], part_banks[idx].mtd_part,
-                                                                part_banks[idx].nums);
-                }
+                mtd_device_register(mtd_banks[idx], part_banks[idx].mtd_part,
+                part_banks[idx].nums);
         }
-#else
-        printk(KERN_NOTICE "TQM flash: registering %d whole flash banks at once\n", num_banks);
-        for(idx = 0 ; idx < num_banks ; idx++)
-                add_mtd_device(mtd_banks[idx]);
-#endif
         return 0;
 error_mem:
         for(idx = 0 ; idx < FLASH_BANK_MAX ; idx++) {
@@ -237,7 +227,7 @@ static void __exit cleanup_tqm_mtd(void)
         for(idx = 0 ; idx < num_banks ; idx++) {
                 /* destroy mtd_info previously allocated */
                 if (mtd_banks[idx]) {
-                        del_mtd_partitions(mtd_banks[idx]);
+                        mtd_device_unregister(mtd_banks[idx]);
                         map_destroy(mtd_banks[idx]);
                 }
                 /* release map_info not used anymore */
diff --git a/drivers/mtd/maps/ts5500_flash.c b/drivers/mtd/maps/ts5500_flash.c
index e02dfa9d4ddd..d1d671daf235 100644
--- a/drivers/mtd/maps/ts5500_flash.c
+++ b/drivers/mtd/maps/ts5500_flash.c
@@ -89,7 +89,7 @@ static int __init init_ts5500_map(void)
         }
 
         mymtd->owner = THIS_MODULE;
-        add_mtd_partitions(mymtd, ts5500_partitions, NUM_PARTITIONS);
+        mtd_device_register(mymtd, ts5500_partitions, NUM_PARTITIONS);
 
         return 0;
 
@@ -102,7 +102,7 @@ err2:
 static void __exit cleanup_ts5500_map(void)
 {
         if (mymtd) {
-                del_mtd_partitions(mymtd);
+                mtd_device_unregister(mymtd);
                 map_destroy(mymtd);
         }
 
diff --git a/drivers/mtd/maps/tsunami_flash.c b/drivers/mtd/maps/tsunami_flash.c
index 77a8bfc02577..1de390e1c2fb 100644
--- a/drivers/mtd/maps/tsunami_flash.c
+++ b/drivers/mtd/maps/tsunami_flash.c
@@ -76,7 +76,7 @@ static void __exit  cleanup_tsunami_flash(void)
         struct mtd_info *mtd;
         mtd = tsunami_flash_mtd;
         if (mtd) {
-                del_mtd_device(mtd);
+                mtd_device_unregister(mtd);
                 map_destroy(mtd);
         }
         tsunami_flash_mtd = 0;
@@ -97,7 +97,7 @@ static int __init init_tsunami_flash(void)
         }
         if (tsunami_flash_mtd) {
                 tsunami_flash_mtd->owner = THIS_MODULE;
-                add_mtd_device(tsunami_flash_mtd);
+                mtd_device_register(tsunami_flash_mtd, NULL, 0);
                 return 0;
         }
         return -ENXIO;
diff --git a/drivers/mtd/maps/uclinux.c b/drivers/mtd/maps/uclinux.c
index 35009294b435..6793074f3f40 100644
--- a/drivers/mtd/maps/uclinux.c
+++ b/drivers/mtd/maps/uclinux.c
@@ -89,11 +89,7 @@ static int __init uclinux_mtd_init(void)
         mtd->priv = mapp;
 
         uclinux_ram_mtdinfo = mtd;
-#ifdef CONFIG_MTD_PARTITIONS
-        add_mtd_partitions(mtd, uclinux_romfs, NUM_PARTITIONS);
-#else
-        add_mtd_device(mtd);
-#endif
+        mtd_device_register(mtd, uclinux_romfs, NUM_PARTITIONS);
 
         return(0);
 }
@@ -103,11 +99,7 @@ static int __init uclinux_mtd_init(void)
 static void __exit uclinux_mtd_cleanup(void)
 {
         if (uclinux_ram_mtdinfo) {
-#ifdef CONFIG_MTD_PARTITIONS
-                del_mtd_partitions(uclinux_ram_mtdinfo);
-#else
-                del_mtd_device(uclinux_ram_mtdinfo);
-#endif
+                mtd_device_unregister(uclinux_ram_mtdinfo);
                 map_destroy(uclinux_ram_mtdinfo);
                 uclinux_ram_mtdinfo = NULL;
         }
diff --git a/drivers/mtd/maps/vmax301.c b/drivers/mtd/maps/vmax301.c
index 6adaa6acc193..5e68de73eabc 100644
--- a/drivers/mtd/maps/vmax301.c
+++ b/drivers/mtd/maps/vmax301.c
@@ -138,7 +138,7 @@ static void __exit cleanup_vmax301(void)
 
         for (i=0; i<2; i++) {
                 if (vmax_mtd[i]) {
-                        del_mtd_device(vmax_mtd[i]);
+                        mtd_device_unregister(vmax_mtd[i]);
                         map_destroy(vmax_mtd[i]);
                 }
         }
@@ -176,7 +176,7 @@ static int __init init_vmax301(void)
                         vmax_mtd[i] = do_map_probe("map_rom", &vmax_map[i]);
                 if (vmax_mtd[i]) {
                         vmax_mtd[i]->owner = THIS_MODULE;
-                        add_mtd_device(vmax_mtd[i]);
+                        mtd_device_register(vmax_mtd[i], NULL, 0);
                 }
         }
 
diff --git a/drivers/mtd/maps/vmu-flash.c b/drivers/mtd/maps/vmu-flash.c
index 4afc167731ef..3a04b078576a 100644
--- a/drivers/mtd/maps/vmu-flash.c
+++ b/drivers/mtd/maps/vmu-flash.c
@@ -563,7 +563,7 @@ static void vmu_queryblocks(struct mapleq *mq)
                 goto fail_cache_create;
         part_cur->pcache = pcache;
 
-        error = add_mtd_device(mtd_cur);
+        error = mtd_device_register(mtd_cur, NULL, 0);
         if (error)
                 goto fail_mtd_register;
 
@@ -709,7 +709,7 @@ static void __devexit vmu_disconnect(struct maple_device *mdev)
         for (x = 0; x < card->partitions; x++) {
                 mpart = ((card->mtd)[x]).priv;
                 mpart->mdev = NULL;
-                del_mtd_device(&((card->mtd)[x]));
+                mtd_device_unregister(&((card->mtd)[x]));
                 kfree(((card->parts)[x]).name);
         }
         kfree(card->parts);
diff --git a/drivers/mtd/maps/wr_sbc82xx_flash.c b/drivers/mtd/maps/wr_sbc82xx_flash.c
index 933a2b6598b4..901ce968efae 100644
--- a/drivers/mtd/maps/wr_sbc82xx_flash.c
+++ b/drivers/mtd/maps/wr_sbc82xx_flash.c
@@ -132,17 +132,20 @@ static int __init init_sbc82xx_flash(void)
                 nr_parts = parse_mtd_partitions(sbcmtd[i], part_probes,
                                                 &sbcmtd_parts[i], 0);
                 if (nr_parts > 0) {
-                        add_mtd_partitions (sbcmtd[i], sbcmtd_parts[i], nr_parts);
+                        mtd_device_register(sbcmtd[i], sbcmtd_parts[i],
+                                            nr_parts);
                         continue;
                 }
 
                 /* No partitioning detected. Use default */
                 if (i == 2) {
-                        add_mtd_device(sbcmtd[i]);
+                        mtd_device_register(sbcmtd[i], NULL, 0);
                 } else if (i == bigflash) {
-                        add_mtd_partitions (sbcmtd[i], bigflash_parts, ARRAY_SIZE(bigflash_parts));
+                        mtd_device_register(sbcmtd[i], bigflash_parts,
+                                            ARRAY_SIZE(bigflash_parts));
                 } else {
-                        add_mtd_partitions (sbcmtd[i], smallflash_parts, ARRAY_SIZE(smallflash_parts));
+                        mtd_device_register(sbcmtd[i], smallflash_parts,
+                                            ARRAY_SIZE(smallflash_parts));
                 }
         }
         return 0;
@@ -157,9 +160,9 @@ static void __exit cleanup_sbc82xx_flash(void)
                         continue;
 
                 if (i<2 || sbcmtd_parts[i])
-                        del_mtd_partitions(sbcmtd[i]);
+                        mtd_device_unregister(sbcmtd[i]);
                 else
-                        del_mtd_device(sbcmtd[i]);
+                        mtd_device_unregister(sbcmtd[i]);
 
                 kfree(sbcmtd_parts[i]);
                 map_destroy(sbcmtd[i]);
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index a534e1f0c348..ca385697446e 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -221,15 +221,33 @@ static int blktrans_open(struct block_device *bdev, fmode_t mode)
         kref_get(&dev->ref);
         __module_get(dev->tr->owner);
 
-        if (dev->mtd) {
-                ret = dev->tr->open ? dev->tr->open(dev) : 0;
-                __get_mtd_device(dev->mtd);
+        if (!dev->mtd)
+                goto unlock;
+
+        if (dev->tr->open) {
+                ret = dev->tr->open(dev);
+                if (ret)
+                        goto error_put;
         }
 
+        ret = __get_mtd_device(dev->mtd);
+        if (ret)
+                goto error_release;
+
 unlock:
         mutex_unlock(&dev->lock);
         blktrans_dev_put(dev);
         return ret;
+
+error_release:
+        if (dev->tr->release)
+                dev->tr->release(dev);
+error_put:
+        module_put(dev->tr->owner);
+        kref_put(&dev->ref, blktrans_dev_release);
+        mutex_unlock(&dev->lock);
+        blktrans_dev_put(dev);
+        return ret;
 }
 
 static int blktrans_release(struct gendisk *disk, fmode_t mode)
diff --git a/drivers/mtd/mtdchar.c b/drivers/mtd/mtdchar.c
index 4c36ef66a46b..3f92731a5b9e 100644
--- a/drivers/mtd/mtdchar.c
+++ b/drivers/mtd/mtdchar.c
@@ -166,10 +166,23 @@ static int mtd_close(struct inode *inode, struct file *file)
         return 0;
 } /* mtd_close */
 
-/* FIXME: This _really_ needs to die. In 2.5, we should lock the
-   userspace buffer down and use it directly with readv/writev.
-*/
-#define MAX_KMALLOC_SIZE 0x20000
+/* Back in June 2001, dwmw2 wrote:
+ *
+ *   FIXME: This _really_ needs to die. In 2.5, we should lock the
+ *   userspace buffer down and use it directly with readv/writev.
+ *
+ * The implementation below, using mtd_kmalloc_up_to, mitigates
+ * allocation failures when the system is under low-memory situations
+ * or if memory is highly fragmented at the cost of reducing the
+ * performance of the requested transfer due to a smaller buffer size.
+ *
+ * A more complex but more memory-efficient implementation based on
+ * get_user_pages and iovecs to cover extents of those pages is a
+ * longer-term goal, as intimated by dwmw2 above. However, for the
+ * write case, this requires yet more complex head and tail transfer
+ * handling when those head and tail offsets and sizes are such that
+ * alignment requirements are not met in the NAND subdriver.
+ */
 
 static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
 {
@@ -179,6 +192,7 @@ static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t
         size_t total_retlen=0;
         int ret=0;
         int len;
+        size_t size = count;
         char *kbuf;
 
         DEBUG(MTD_DEBUG_LEVEL0,"MTD_read\n");
@@ -189,23 +203,12 @@ static ssize_t mtd_read(struct file *file, char __user *buf, size_t count,loff_t
         if (!count)
                 return 0;
 
-        /* FIXME: Use kiovec in 2.5 to lock down the user's buffers
-           and pass them directly to the MTD functions */
-
-        if (count > MAX_KMALLOC_SIZE)
-                kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
-        else
-                kbuf=kmalloc(count, GFP_KERNEL);
-
+        kbuf = mtd_kmalloc_up_to(mtd, &size);
         if (!kbuf)
                 return -ENOMEM;
 
         while (count) {
-
-                if (count > MAX_KMALLOC_SIZE)
-                        len = MAX_KMALLOC_SIZE;
-                else
-                        len = count;
+                len = min_t(size_t, count, size);
 
                 switch (mfi->mode) {
                 case MTD_MODE_OTP_FACTORY:
@@ -268,6 +271,7 @@ static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count
 {
         struct mtd_file_info *mfi = file->private_data;
         struct mtd_info *mtd = mfi->mtd;
+        size_t size = count;
         char *kbuf;
         size_t retlen;
         size_t total_retlen=0;
@@ -285,20 +289,12 @@ static ssize_t mtd_write(struct file *file, const char __user *buf, size_t count
         if (!count)
                 return 0;
 
-        if (count > MAX_KMALLOC_SIZE)
-                kbuf=kmalloc(MAX_KMALLOC_SIZE, GFP_KERNEL);
-        else
-                kbuf=kmalloc(count, GFP_KERNEL);
-
+        kbuf = mtd_kmalloc_up_to(mtd, &size);
         if (!kbuf)
                 return -ENOMEM;
 
         while (count) {
-
-                if (count > MAX_KMALLOC_SIZE)
-                        len = MAX_KMALLOC_SIZE;
-                else
-                        len = count;
+                len = min_t(size_t, count, size);
 
                 if (copy_from_user(kbuf, buf, len)) {
                         kfree(kbuf);
@@ -512,7 +508,6 @@ static int shrink_ecclayout(const struct nand_ecclayout *from,
         return 0;
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 static int mtd_blkpg_ioctl(struct mtd_info *mtd,
                            struct blkpg_ioctl_arg __user *arg)
 {
@@ -548,8 +543,6 @@ static int mtd_blkpg_ioctl(struct mtd_info *mtd,
                 return -EINVAL;
         }
 }
-#endif
-
 
 static int mtd_ioctl(struct file *file, u_int cmd, u_long arg)
 {
@@ -941,7 +934,6 @@ static int mtd_ioctl(struct file *file, u_int cmd, u_long arg)
                 break;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
         case BLKPG:
         {
                 ret = mtd_blkpg_ioctl(mtd,
@@ -955,7 +947,6 @@ static int mtd_ioctl(struct file *file, u_int cmd, u_long arg)
                 ret = 0;
                 break;
         }
-#endif
 
         default:
                 ret = -ENOTTY;
diff --git a/drivers/mtd/mtdconcat.c b/drivers/mtd/mtdconcat.c
index 5060e608ea5d..e601672a5305 100644
--- a/drivers/mtd/mtdconcat.c
+++ b/drivers/mtd/mtdconcat.c
@@ -319,7 +319,7 @@ concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
         if (!(mtd->flags & MTD_WRITEABLE))
                 return -EROFS;
 
-        ops->retlen = 0;
+        ops->retlen = ops->oobretlen = 0;
 
         for (i = 0; i < concat->num_subdev; i++) {
                 struct mtd_info *subdev = concat->subdev[i];
@@ -334,7 +334,7 @@ concat_write_oob(struct mtd_info *mtd, loff_t to, struct mtd_oob_ops *ops)
                         devops.len = subdev->size - to;
 
                 err = subdev->write_oob(subdev, to, &devops);
-                ops->retlen += devops.retlen;
+                ops->retlen += devops.oobretlen;
                 if (err)
                         return err;
 
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index da69bc8a5a7d..c510aff289a8 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -24,6 +24,7 @@
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/ptrace.h>
+#include <linux/seq_file.h>
 #include <linux/string.h>
 #include <linux/timer.h>
 #include <linux/major.h>
@@ -37,6 +38,7 @@
 #include <linux/gfp.h>
 
 #include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
 
 #include "mtdcore.h"
 /*
@@ -391,7 +393,7 @@ fail_locked:
  *      if the requested device does not appear to be present in the list.
  */
 
-int del_mtd_device (struct mtd_info *mtd)
+int del_mtd_device(struct mtd_info *mtd)
 {
         int ret;
         struct mtd_notifier *not;
@@ -427,6 +429,50 @@ out_error:
 }
 
 /**
+ * mtd_device_register - register an MTD device.
+ *
+ * @master: the MTD device to register
+ * @parts: the partitions to register - only valid if nr_parts > 0
+ * @nr_parts: the number of partitions in parts.  If zero then the full MTD
+ *            device is registered
+ *
+ * Register an MTD device with the system and optionally, a number of
+ * partitions.  If nr_parts is 0 then the whole device is registered, otherwise
+ * only the partitions are registered.  To register both the full device *and*
+ * the partitions, call mtd_device_register() twice, once with nr_parts == 0
+ * and once equal to the number of partitions.
+ */
+int mtd_device_register(struct mtd_info *master,
+                        const struct mtd_partition *parts,
+                        int nr_parts)
+{
+        return parts ? add_mtd_partitions(master, parts, nr_parts) :
+                add_mtd_device(master);
+}
+EXPORT_SYMBOL_GPL(mtd_device_register);
+
+/**
+ * mtd_device_unregister - unregister an existing MTD device.
+ *
+ * @master: the MTD device to unregister.  This will unregister both the master
+ *          and any partitions if registered.
+ */
+int mtd_device_unregister(struct mtd_info *master)
+{
+        int err;
+
+        err = del_mtd_partitions(master);
+        if (err)
+                return err;
+
+        if (!device_is_registered(&master->dev))
+                return 0;
+
+        return del_mtd_device(master);
+}
+EXPORT_SYMBOL_GPL(mtd_device_unregister);
+
+/**
  *      register_mtd_user - register a 'user' of MTD devices.
  *      @new: pointer to notifier info structure
  *
@@ -443,7 +489,7 @@ void register_mtd_user (struct mtd_notifier *new)
 
         list_add(&new->list, &mtd_notifiers);
 
-        __module_get(THIS_MODULE);
+        __module_get(THIS_MODULE);
 
         mtd_for_each_device(mtd)
                 new->add(mtd);
@@ -532,7 +578,6 @@ int __get_mtd_device(struct mtd_info *mtd)
                 return -ENODEV;
 
         if (mtd->get_device) {
-
                 err = mtd->get_device(mtd);
 
                 if (err) {
@@ -570,21 +615,13 @@ struct mtd_info *get_mtd_device_nm(const char *name)
         if (!mtd)
                 goto out_unlock;
 
-        if (!try_module_get(mtd->owner))
+        err = __get_mtd_device(mtd);
+        if (err)
                 goto out_unlock;
 
-        if (mtd->get_device) {
-                err = mtd->get_device(mtd);
-                if (err)
-                        goto out_put;
-        }
-
-        mtd->usecount++;
         mutex_unlock(&mtd_table_mutex);
         return mtd;
 
-out_put:
-        module_put(mtd->owner);
 out_unlock:
         mutex_unlock(&mtd_table_mutex);
         return ERR_PTR(err);
@@ -638,8 +675,54 @@ int default_mtd_writev(struct mtd_info *mtd, const struct kvec *vecs,
         return ret;
 }
 
-EXPORT_SYMBOL_GPL(add_mtd_device);
-EXPORT_SYMBOL_GPL(del_mtd_device);
+/**
+ * mtd_kmalloc_up_to - allocate a contiguous buffer up to the specified size
+ * @size: A pointer to the ideal or maximum size of the allocation. Points
+ *        to the actual allocation size on success.
+ *
+ * This routine attempts to allocate a contiguous kernel buffer up to
+ * the specified size, backing off the size of the request exponentially
+ * until the request succeeds or until the allocation size falls below
+ * the system page size. This attempts to make sure it does not adversely
+ * impact system performance, so when allocating more than one page, we
+ * ask the memory allocator to avoid re-trying, swapping, writing back
+ * or performing I/O.
+ *
+ * Note, this function also makes sure that the allocated buffer is aligned to
+ * the MTD device's min. I/O unit, i.e. the "mtd->writesize" value.
+ *
+ * This is called, for example by mtd_{read,write} and jffs2_scan_medium,
+ * to handle smaller (i.e. degraded) buffer allocations under low- or
+ * fragmented-memory situations where such reduced allocations, from a
+ * requested ideal, are allowed.
+ *
+ * Returns a pointer to the allocated buffer on success; otherwise, NULL.
+ */
+void *mtd_kmalloc_up_to(const struct mtd_info *mtd, size_t *size)
+{
+        gfp_t flags = __GFP_NOWARN | __GFP_WAIT |
+                       __GFP_NORETRY | __GFP_NO_KSWAPD;
+        size_t min_alloc = max_t(size_t, mtd->writesize, PAGE_SIZE);
+        void *kbuf;
+
+        *size = min_t(size_t, *size, KMALLOC_MAX_SIZE);
+
+        while (*size > min_alloc) {
+                kbuf = kmalloc(*size, flags);
+                if (kbuf)
+                        return kbuf;
+
+                *size >>= 1;
+                *size = ALIGN(*size, mtd->writesize);
+        }
+
+        /*
+         * For the last resort allocation allow 'kmalloc()' to do all sorts of
+         * things (write-back, dropping caches, etc) by using GFP_KERNEL.
+         */
+        return kmalloc(*size, GFP_KERNEL);
+}
+
 EXPORT_SYMBOL_GPL(get_mtd_device);
 EXPORT_SYMBOL_GPL(get_mtd_device_nm);
 EXPORT_SYMBOL_GPL(__get_mtd_device);
@@ -648,6 +731,7 @@ EXPORT_SYMBOL_GPL(__put_mtd_device);
 EXPORT_SYMBOL_GPL(register_mtd_user);
 EXPORT_SYMBOL_GPL(unregister_mtd_user);
 EXPORT_SYMBOL_GPL(default_mtd_writev);
+EXPORT_SYMBOL_GPL(mtd_kmalloc_up_to);
 
 #ifdef CONFIG_PROC_FS
 
@@ -656,44 +740,32 @@ EXPORT_SYMBOL_GPL(default_mtd_writev);
 
 static struct proc_dir_entry *proc_mtd;
 
-static inline int mtd_proc_info(char *buf, struct mtd_info *this)
-{
-        return sprintf(buf, "mtd%d: %8.8llx %8.8x \"%s\"\n", this->index,
-                       (unsigned long long)this->size,
-                       this->erasesize, this->name);
-}
-
-static int mtd_read_proc (char *page, char **start, off_t off, int count,
-                          int *eof, void *data_unused)
+static int mtd_proc_show(struct seq_file *m, void *v)
 {
         struct mtd_info *mtd;
-        int len, l;
-        off_t   begin = 0;
 
+        seq_puts(m, "dev:    size   erasesize  name\n");
         mutex_lock(&mtd_table_mutex);
-
-        len = sprintf(page, "dev:    size   erasesize  name\n");
         mtd_for_each_device(mtd) {
-                l = mtd_proc_info(page + len, mtd);
-                len += l;
-                if (len+begin > off+count)
-                        goto done;
-                if (len+begin < off) {
-                        begin += len;
-                        len = 0;
-                }
-        }
-
-        *eof = 1;
-
-done:
+                seq_printf(m, "mtd%d: %8.8llx %8.8x \"%s\"\n",
+                           mtd->index, (unsigned long long)mtd->size,
+                           mtd->erasesize, mtd->name);
+        }
         mutex_unlock(&mtd_table_mutex);
-        if (off >= len+begin)
-                return 0;
-        *start = page + (off-begin);
-        return ((count < begin+len-off) ? count : begin+len-off);
+        return 0;
+}
+
+static int mtd_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, mtd_proc_show, NULL);
 }
 
+static const struct file_operations mtd_proc_ops = {
+        .open           = mtd_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 #endif /* CONFIG_PROC_FS */
 
 /*====================================================================*/
@@ -734,8 +806,7 @@ static int __init init_mtd(void)
                 goto err_bdi3;
 
 #ifdef CONFIG_PROC_FS
-        if ((proc_mtd = create_proc_entry( "mtd", 0, NULL )))
-                proc_mtd->read_proc = mtd_read_proc;
+        proc_mtd = proc_create("mtd", 0, NULL, &mtd_proc_ops);
 #endif /* CONFIG_PROC_FS */
         return 0;
 
@@ -753,7 +824,7 @@ err_reg:
 static void __exit cleanup_mtd(void)
 {
 #ifdef CONFIG_PROC_FS
-        if (proc_mtd)
+        if (proc_mtd)
                 remove_proc_entry( "mtd", NULL);
 #endif /* CONFIG_PROC_FS */
         class_unregister(&mtd_class);
diff --git a/drivers/mtd/mtdcore.h b/drivers/mtd/mtdcore.h
index 6a64fdebc898..0ed6126b4c1f 100644
--- a/drivers/mtd/mtdcore.h
+++ b/drivers/mtd/mtdcore.h
@@ -10,6 +10,12 @@
 extern struct mutex mtd_table_mutex;
 extern struct mtd_info *__mtd_next_device(int i);
 
+extern int add_mtd_device(struct mtd_info *mtd);
+extern int del_mtd_device(struct mtd_info *mtd);
+extern int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *,
+                              int);
+extern int del_mtd_partitions(struct mtd_info *);
+
 #define mtd_for_each_device(mtd)                        \
         for ((mtd) = __mtd_next_device(0);              \
              (mtd) != NULL;                             \
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index 0a4760174782..630be3e7da04 100644
--- a/drivers/mtd/mtdpart.c
+++ b/drivers/mtd/mtdpart.c
@@ -31,6 +31,8 @@
 #include <linux/mtd/partitions.h>
 #include <linux/err.h>
 
+#include "mtdcore.h"
+
 /* Our partition linked list */
 static LIST_HEAD(mtd_partitions);
 static DEFINE_MUTEX(mtd_partitions_mutex);
@@ -376,7 +378,6 @@ int del_mtd_partitions(struct mtd_info *master)
 
         return err;
 }
-EXPORT_SYMBOL(del_mtd_partitions);
 
 static struct mtd_part *allocate_partition(struct mtd_info *master,
                         const struct mtd_partition *part, int partno,
@@ -671,7 +672,6 @@ int add_mtd_partitions(struct mtd_info *master,
 
         return 0;
 }
-EXPORT_SYMBOL(add_mtd_partitions);
 
 static DEFINE_SPINLOCK(part_parser_lock);
 static LIST_HEAD(part_parsers);
@@ -722,11 +722,8 @@ int parse_mtd_partitions(struct mtd_info *master, const char **types,
                 parser = get_partition_parser(*types);
                 if (!parser && !request_module("%s", *types))
                                 parser = get_partition_parser(*types);
-                if (!parser) {
-                        printk(KERN_NOTICE "%s partition parsing not available\n",
-                               *types);
+                if (!parser)
                         continue;
-                }
                 ret = (*parser->parse_fn)(master, pparts, origin);
                 if (ret > 0) {
                         printk(KERN_NOTICE "%d %s partitions found on MTD device %s\n",
diff --git a/drivers/mtd/mtdswap.c b/drivers/mtd/mtdswap.c
index fed215c4cfa1..fd7885327611 100644
--- a/drivers/mtd/mtdswap.c
+++ b/drivers/mtd/mtdswap.c
@@ -1450,7 +1450,13 @@ static void mtdswap_add_mtd(struct mtd_blktrans_ops *tr, struct mtd_info *mtd)
         }
 
         oinfo = mtd->ecclayout;
-        if (!mtd->oobsize || !oinfo || oinfo->oobavail < MTDSWAP_OOBSIZE) {
+        if (!oinfo) {
+                printk(KERN_ERR "%s: mtd%d does not have OOB\n",
+                        MTDSWAP_PREFIX, mtd->index);
+                return;
+        }
+
+        if (!mtd->oobsize || oinfo->oobavail < MTDSWAP_OOBSIZE) {
                 printk(KERN_ERR "%s: Not enough free bytes in OOB, "
                         "%d available, %zu needed.\n",
                         MTDSWAP_PREFIX, oinfo->oobavail, MTDSWAP_OOBSIZE);
diff --git a/drivers/mtd/nand/Kconfig b/drivers/mtd/nand/Kconfig
index edec457d361d..4c3425235adc 100644
--- a/drivers/mtd/nand/Kconfig
+++ b/drivers/mtd/nand/Kconfig
@@ -92,7 +92,7 @@ config MTD_NAND_EDB7312
 
 config MTD_NAND_H1900
         tristate "iPAQ H1900 flash"
-        depends on ARCH_PXA && MTD_PARTITIONS
+        depends on ARCH_PXA
         help
           This enables the driver for the iPAQ h1900 flash.
 
@@ -419,7 +419,6 @@ config MTD_NAND_TMIO
 
 config MTD_NAND_NANDSIM
         tristate "Support for NAND Flash Simulator"
-        depends on MTD_PARTITIONS
         help
           The simulator may simulate various NAND flash chips for the
           MTD nand layer.
@@ -513,7 +512,7 @@ config MTD_NAND_SOCRATES
 
 config MTD_NAND_NUC900
         tristate "Support for NAND on Nuvoton NUC9xx/w90p910 evaluation boards."
-        depends on ARCH_W90X900 && MTD_PARTITIONS
+        depends on ARCH_W90X900
         help
           This enables the driver for the NAND Flash on evaluation board based
           on w90p910 / NUC9xx.
diff --git a/drivers/mtd/nand/alauda.c b/drivers/mtd/nand/alauda.c
index 8691e0482ed2..eb40ea829ab2 100644
--- a/drivers/mtd/nand/alauda.c
+++ b/drivers/mtd/nand/alauda.c
@@ -120,7 +120,7 @@ static void alauda_delete(struct kref *kref)
         struct alauda *al = container_of(kref, struct alauda, kref);
 
         if (al->mtd) {
-                del_mtd_device(al->mtd);
+                mtd_device_unregister(al->mtd);
                 kfree(al->mtd);
         }
         usb_put_dev(al->dev);
@@ -592,7 +592,7 @@ static int alauda_init_media(struct alauda *al)
         mtd->priv = al;
         mtd->owner = THIS_MODULE;
 
-        err = add_mtd_device(mtd);
+        err = mtd_device_register(mtd, NULL, 0);
         if (err) {
                 err = -ENFILE;
                 goto error;
diff --git a/drivers/mtd/nand/ams-delta.c b/drivers/mtd/nand/ams-delta.c
index bc65bf71e1a2..78017eb9318e 100644
--- a/drivers/mtd/nand/ams-delta.c
+++ b/drivers/mtd/nand/ams-delta.c
@@ -235,8 +235,8 @@ static int __devinit ams_delta_init(struct platform_device *pdev)
         }
 
         /* Register the partitions */
-        add_mtd_partitions(ams_delta_mtd, partition_info,
-                           ARRAY_SIZE(partition_info));
+        mtd_device_register(ams_delta_mtd, partition_info,
+                            ARRAY_SIZE(partition_info));
 
         goto out;
 
diff --git a/drivers/mtd/nand/atmel_nand.c b/drivers/mtd/nand/atmel_nand.c
index 950646aa4c4b..b300705d41cb 100644
--- a/drivers/mtd/nand/atmel_nand.c
+++ b/drivers/mtd/nand/atmel_nand.c
@@ -30,6 +30,7 @@
 #include <linux/mtd/nand.h>
 #include <linux/mtd/partitions.h>
 
+#include <linux/dmaengine.h>
 #include <linux/gpio.h>
 #include <linux/io.h>
 
@@ -494,11 +495,8 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
         struct resource *regs;
         struct resource *mem;
         int res;
-
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *partitions = NULL;
         int num_partitions = 0;
-#endif
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!mem) {
@@ -656,7 +654,6 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                 goto err_scan_tail;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         mtd->name = "atmel_nand";
         num_partitions = parse_mtd_partitions(mtd, part_probes,
@@ -672,17 +669,11 @@ static int __init atmel_nand_probe(struct platform_device *pdev)
                 goto err_no_partitions;
         }
 
-        res = add_mtd_partitions(mtd, partitions, num_partitions);
-#else
-        res = add_mtd_device(mtd);
-#endif
-
+        res = mtd_device_register(mtd, partitions, num_partitions);
         if (!res)
                 return res;
 
-#ifdef CONFIG_MTD_PARTITIONS
 err_no_partitions:
-#endif
         nand_release(mtd);
 err_scan_tail:
 err_scan_ident:
diff --git a/drivers/mtd/nand/au1550nd.c b/drivers/mtd/nand/au1550nd.c
index 5d513b54a7d7..e7767eef4505 100644
--- a/drivers/mtd/nand/au1550nd.c
+++ b/drivers/mtd/nand/au1550nd.c
@@ -581,7 +581,8 @@ static int __init au1xxx_nand_init(void)
         }
 
         /* Register the partitions */
-        add_mtd_partitions(au1550_mtd, partition_info, ARRAY_SIZE(partition_info));
+        mtd_device_register(au1550_mtd, partition_info,
+                            ARRAY_SIZE(partition_info));
 
         return 0;
 
diff --git a/drivers/mtd/nand/autcpu12.c b/drivers/mtd/nand/autcpu12.c
index 0911cf03db80..eddc9a224985 100644
--- a/drivers/mtd/nand/autcpu12.c
+++ b/drivers/mtd/nand/autcpu12.c
@@ -185,20 +185,20 @@ static int __init autcpu12_init(void)
         /* Register the partitions */
         switch (autcpu12_mtd->size) {
                 case SZ_16M:
-                        add_mtd_partitions(autcpu12_mtd, partition_info16k,
-                                           NUM_PARTITIONS16K);
+                        mtd_device_register(autcpu12_mtd, partition_info16k,
+                                            NUM_PARTITIONS16K);
                         break;
                 case SZ_32M:
-                        add_mtd_partitions(autcpu12_mtd, partition_info32k,
-                                           NUM_PARTITIONS32K);
+                        mtd_device_register(autcpu12_mtd, partition_info32k,
+                                            NUM_PARTITIONS32K);
                         break;
                 case SZ_64M:
-                        add_mtd_partitions(autcpu12_mtd, partition_info64k,
-                                           NUM_PARTITIONS64K);
+                        mtd_device_register(autcpu12_mtd, partition_info64k,
+                                            NUM_PARTITIONS64K);
                         break;
                 case SZ_128M:
-                        add_mtd_partitions(autcpu12_mtd, partition_info128k,
-                                           NUM_PARTITIONS128K);
+                        mtd_device_register(autcpu12_mtd, partition_info128k,
+                                            NUM_PARTITIONS128K);
                         break;
                 default:
                         printk("Unsupported SmartMedia device\n");
diff --git a/drivers/mtd/nand/bcm_umi_nand.c b/drivers/mtd/nand/bcm_umi_nand.c
index dfe262c726fb..9ec280738a9a 100644
--- a/drivers/mtd/nand/bcm_umi_nand.c
+++ b/drivers/mtd/nand/bcm_umi_nand.c
@@ -52,9 +52,7 @@
 static const __devinitconst char gBanner[] = KERN_INFO \
         "BCM UMI MTD NAND Driver: 1.00\n";
 
-#ifdef CONFIG_MTD_PARTITIONS
 const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
 #if NAND_ECC_BCH
 static uint8_t scan_ff_pattern[] = { 0xff };
@@ -509,7 +507,7 @@ static int __devinit bcm_umi_nand_probe(struct platform_device *pdev)
                         kfree(board_mtd);
                         return -EIO;
                 }
-                add_mtd_partitions(board_mtd, partition_info, nr_partitions);
+                mtd_device_register(board_mtd, partition_info, nr_partitions);
         }
 
         /* Return happy */
diff --git a/drivers/mtd/nand/bf5xx_nand.c b/drivers/mtd/nand/bf5xx_nand.c
index 79947bea4d57..dd899cb5d366 100644
--- a/drivers/mtd/nand/bf5xx_nand.c
+++ b/drivers/mtd/nand/bf5xx_nand.c
@@ -659,15 +659,10 @@ static int bf5xx_nand_hw_init(struct bf5xx_nand_info *info)
 static int __devinit bf5xx_nand_add_partition(struct bf5xx_nand_info *info)
 {
         struct mtd_info *mtd = &info->mtd;
-
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts = info->platform->partitions;
         int nr = info->platform->nr_partitions;
 
-        return add_mtd_partitions(mtd, parts, nr);
-#else
-        return add_mtd_device(mtd);
-#endif
+        return mtd_device_register(mtd, parts, nr);
 }
 
 static int __devexit bf5xx_nand_remove(struct platform_device *pdev)
diff --git a/drivers/mtd/nand/cafe_nand.c b/drivers/mtd/nand/cafe_nand.c
index e06c8983978e..87ebb4e5b0c3 100644
--- a/drivers/mtd/nand/cafe_nand.c
+++ b/drivers/mtd/nand/cafe_nand.c
@@ -90,9 +90,7 @@ static unsigned int numtimings;
 static int timing[3];
 module_param_array(timing, int, &numtimings, 0644);
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", "RedBoot", NULL };
-#endif
 
 /* Hrm. Why isn't this already conditional on something in the struct device? */
 #define cafe_dev_dbg(dev, args...) do { if (debug) dev_dbg(dev, ##args); } while(0)
@@ -632,10 +630,8 @@ static int __devinit cafe_nand_probe(struct pci_dev *pdev,
         struct cafe_priv *cafe;
         uint32_t ctrl;
         int err = 0;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
         int nr_parts;
-#endif
 
         /* Very old versions shared the same PCI ident for all three
            functions on the chip. Verify the class too... */
@@ -804,9 +800,8 @@ static int __devinit cafe_nand_probe(struct pci_dev *pdev,
         pci_set_drvdata(pdev, mtd);
 
         /* We register the whole device first, separate from the partitions */
-        add_mtd_device(mtd);
+        mtd_device_register(mtd, NULL, 0);
 
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         mtd->name = "cafe_nand";
 #endif
@@ -814,9 +809,8 @@ static int __devinit cafe_nand_probe(struct pci_dev *pdev,
         if (nr_parts > 0) {
                 cafe->parts = parts;
                 dev_info(&cafe->pdev->dev, "%d partitions found\n", nr_parts);
-                add_mtd_partitions(mtd, parts, nr_parts);
+                mtd_device_register(mtd, parts, nr_parts);
         }
-#endif
         goto out;
 
  out_irq:
@@ -838,7 +832,6 @@ static void __devexit cafe_nand_remove(struct pci_dev *pdev)
         struct mtd_info *mtd = pci_get_drvdata(pdev);
         struct cafe_priv *cafe = mtd->priv;
 
-        del_mtd_device(mtd);
         /* Disable NAND IRQ in global IRQ mask register */
         cafe_writel(cafe, ~1 & cafe_readl(cafe, GLOBAL_IRQ_MASK), GLOBAL_IRQ_MASK);
         free_irq(pdev->irq, mtd);
diff --git a/drivers/mtd/nand/cmx270_nand.c b/drivers/mtd/nand/cmx270_nand.c
index 6e6495278258..6fc043a30d1e 100644
--- a/drivers/mtd/nand/cmx270_nand.c
+++ b/drivers/mtd/nand/cmx270_nand.c
@@ -238,7 +238,7 @@ static int __init cmx270_init(void)
 
         /* Register the partitions */
         pr_notice("Using %s partition definition\n", part_type);
-        ret = add_mtd_partitions(cmx270_nand_mtd, mtd_parts, mtd_parts_nb);
+        ret = mtd_device_register(cmx270_nand_mtd, mtd_parts, mtd_parts_nb);
         if (ret)
                 goto err_scan;
 
diff --git a/drivers/mtd/nand/cs553x_nand.c b/drivers/mtd/nand/cs553x_nand.c
index 71c35a0b9826..f59ad1f2d5db 100644
--- a/drivers/mtd/nand/cs553x_nand.c
+++ b/drivers/mtd/nand/cs553x_nand.c
@@ -277,22 +277,15 @@ static int is_geode(void)
         return 0;
 }
 
-
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
-
 
 static int __init cs553x_init(void)
 {
         int err = -ENXIO;
         int i;
         uint64_t val;
-
-#ifdef CONFIG_MTD_PARTITIONS
         int mtd_parts_nb = 0;
         struct mtd_partition *mtd_parts = NULL;
-#endif
 
         /* If the CPU isn't a Geode GX or LX, abort */
         if (!is_geode())
@@ -324,17 +317,11 @@ static int __init cs553x_init(void)
                 if (cs553x_mtd[i]) {
 
                         /* If any devices registered, return success. Else the last error. */
-#ifdef CONFIG_MTD_PARTITIONS
                         mtd_parts_nb = parse_mtd_partitions(cs553x_mtd[i], part_probes, &mtd_parts, 0);
-                        if (mtd_parts_nb > 0) {
+                        if (mtd_parts_nb > 0)
                                 printk(KERN_NOTICE "Using command line partition definition\n");
-                                add_mtd_partitions(cs553x_mtd[i], mtd_parts, mtd_parts_nb);
-                        } else {
-                                add_mtd_device(cs553x_mtd[i]);
-                        }
-#else
-                        add_mtd_device(cs553x_mtd[i]);
-#endif
+                        mtd_device_register(cs553x_mtd[i], mtd_parts,
+                                            mtd_parts_nb);
                         err = 0;
                 }
         }
diff --git a/drivers/mtd/nand/davinci_nand.c b/drivers/mtd/nand/davinci_nand.c
index aff3468867ac..1f34951ae1a7 100644
--- a/drivers/mtd/nand/davinci_nand.c
+++ b/drivers/mtd/nand/davinci_nand.c
@@ -530,6 +530,8 @@ static int __init nand_davinci_probe(struct platform_device *pdev)
         int                             ret;
         uint32_t                        val;
         nand_ecc_modes_t                ecc_mode;
+        struct mtd_partition            *mtd_parts = NULL;
+        int                             mtd_parts_nb = 0;
 
         /* insist on board-specific configuration */
         if (!pdata)
@@ -749,41 +751,33 @@ syndrome_done:
         if (ret < 0)
                 goto err_scan;
 
-        if (mtd_has_partitions()) {
-                struct mtd_partition    *mtd_parts = NULL;
-                int                     mtd_parts_nb = 0;
+        if (mtd_has_cmdlinepart()) {
+                static const char *probes[] __initconst = {
+                        "cmdlinepart", NULL
+                };
 
-                if (mtd_has_cmdlinepart()) {
-                        static const char *probes[] __initconst =
-                                { "cmdlinepart", NULL };
-
-                        mtd_parts_nb = parse_mtd_partitions(&info->mtd, probes,
-                                                            &mtd_parts, 0);
-                }
-
-                if (mtd_parts_nb <= 0) {
-                        mtd_parts = pdata->parts;
-                        mtd_parts_nb = pdata->nr_parts;
-                }
+                mtd_parts_nb = parse_mtd_partitions(&info->mtd, probes,
+                                                    &mtd_parts, 0);
+        }
 
-                /* Register any partitions */
-                if (mtd_parts_nb > 0) {
-                        ret = add_mtd_partitions(&info->mtd,
-                                        mtd_parts, mtd_parts_nb);
-                        if (ret == 0)
-                                info->partitioned = true;
-                }
+        if (mtd_parts_nb <= 0) {
+                mtd_parts = pdata->parts;
+                mtd_parts_nb = pdata->nr_parts;
+        }
 
-        } else if (pdata->nr_parts) {
-                dev_warn(&pdev->dev, "ignoring %d default partitions on %s\n",
-                                pdata->nr_parts, info->mtd.name);
+        /* Register any partitions */
+        if (mtd_parts_nb > 0) {
+                ret = mtd_device_register(&info->mtd, mtd_parts,
+                                          mtd_parts_nb);
+                if (ret == 0)
+                        info->partitioned = true;
         }
 
         /* If there's no partition info, just package the whole chip
          * as a single MTD device.
          */
         if (!info->partitioned)
-                ret = add_mtd_device(&info->mtd) ? -ENODEV : 0;
+                ret = mtd_device_register(&info->mtd, NULL, 0) ? -ENODEV : 0;
 
         if (ret < 0)
                 goto err_scan;
@@ -824,10 +818,7 @@ static int __exit nand_davinci_remove(struct platform_device *pdev)
         struct davinci_nand_info *info = platform_get_drvdata(pdev);
         int status;
 
-        if (mtd_has_partitions() && info->partitioned)
-                status = del_mtd_partitions(&info->mtd);
-        else
-                status = del_mtd_device(&info->mtd);
+        status = mtd_device_unregister(&info->mtd);
 
         spin_lock_irq(&davinci_nand_lock);
         if (info->chip.ecc.mode == NAND_ECC_HW_SYNDROME)
diff --git a/drivers/mtd/nand/denali.c b/drivers/mtd/nand/denali.c
index 4633f094c510..d5276218945f 100644
--- a/drivers/mtd/nand/denali.c
+++ b/drivers/mtd/nand/denali.c
@@ -19,6 +19,7 @@
 
 #include <linux/interrupt.h>
 #include <linux/delay.h>
+#include <linux/dma-mapping.h>
 #include <linux/wait.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
@@ -44,16 +45,16 @@ MODULE_PARM_DESC(onfi_timing_mode, "Overrides default ONFI setting."
 
 /* We define a macro here that combines all interrupts this driver uses into
  * a single constant value, for convenience. */
-#define DENALI_IRQ_ALL  (INTR_STATUS0__DMA_CMD_COMP | \
-                        INTR_STATUS0__ECC_TRANSACTION_DONE | \
-                        INTR_STATUS0__ECC_ERR | \
-                        INTR_STATUS0__PROGRAM_FAIL | \
-                        INTR_STATUS0__LOAD_COMP | \
-                        INTR_STATUS0__PROGRAM_COMP | \
-                        INTR_STATUS0__TIME_OUT | \
-                        INTR_STATUS0__ERASE_FAIL | \
-                        INTR_STATUS0__RST_COMP | \
-                        INTR_STATUS0__ERASE_COMP)
+#define DENALI_IRQ_ALL  (INTR_STATUS__DMA_CMD_COMP | \
+                        INTR_STATUS__ECC_TRANSACTION_DONE | \
+                        INTR_STATUS__ECC_ERR | \
+                        INTR_STATUS__PROGRAM_FAIL | \
+                        INTR_STATUS__LOAD_COMP | \
+                        INTR_STATUS__PROGRAM_COMP | \
+                        INTR_STATUS__TIME_OUT | \
+                        INTR_STATUS__ERASE_FAIL | \
+                        INTR_STATUS__RST_COMP | \
+                        INTR_STATUS__ERASE_COMP)
 
 /* indicates whether or not the internal value for the flash bank is
  * valid or not */
@@ -95,30 +96,6 @@ static const struct pci_device_id denali_pci_ids[] = {
         { /* end: all zeroes */ }
 };
 
-
-/* these are static lookup tables that give us easy access to
- * registers in the NAND controller.
- */
-static const uint32_t intr_status_addresses[4] = {INTR_STATUS0,
-                                                  INTR_STATUS1,
-                                                  INTR_STATUS2,
-                                                  INTR_STATUS3};
-
-static const uint32_t device_reset_banks[4] = {DEVICE_RESET__BANK0,
-                                                        DEVICE_RESET__BANK1,
-                                                        DEVICE_RESET__BANK2,
-                                                        DEVICE_RESET__BANK3};
-
-static const uint32_t operation_timeout[4] = {INTR_STATUS0__TIME_OUT,
-                                                        INTR_STATUS1__TIME_OUT,
-                                                        INTR_STATUS2__TIME_OUT,
-                                                        INTR_STATUS3__TIME_OUT};
-
-static const uint32_t reset_complete[4] = {INTR_STATUS0__RST_COMP,
-                                                        INTR_STATUS1__RST_COMP,
-                                                        INTR_STATUS2__RST_COMP,
-                                                        INTR_STATUS3__RST_COMP};
-
 /* forward declarations */
 static void clear_interrupts(struct denali_nand_info *denali);
 static uint32_t wait_for_irq(struct denali_nand_info *denali,
@@ -180,19 +157,17 @@ static void read_status(struct denali_nand_info *denali)
 static void reset_bank(struct denali_nand_info *denali)
 {
         uint32_t irq_status = 0;
-        uint32_t irq_mask = reset_complete[denali->flash_bank] |
-                            operation_timeout[denali->flash_bank];
-        int bank = 0;
+        uint32_t irq_mask = INTR_STATUS__RST_COMP |
+                            INTR_STATUS__TIME_OUT;
 
         clear_interrupts(denali);
 
-        bank = device_reset_banks[denali->flash_bank];
-        iowrite32(bank, denali->flash_reg + DEVICE_RESET);
+        iowrite32(1 << denali->flash_bank, denali->flash_reg + DEVICE_RESET);
 
         irq_status = wait_for_irq(denali, irq_mask);
 
-        if (irq_status & operation_timeout[denali->flash_bank])
-                dev_err(&denali->dev->dev, "reset bank failed.\n");
+        if (irq_status & INTR_STATUS__TIME_OUT)
+                dev_err(denali->dev, "reset bank failed.\n");
 }
 
 /* Reset the flash controller */
@@ -200,29 +175,28 @@ static uint16_t denali_nand_reset(struct denali_nand_info *denali)
 {
         uint32_t i;
 
-        dev_dbg(&denali->dev->dev, "%s, Line %d, Function: %s\n",
+        dev_dbg(denali->dev, "%s, Line %d, Function: %s\n",
                        __FILE__, __LINE__, __func__);
 
-        for (i = 0 ; i < LLD_MAX_FLASH_BANKS; i++)
-                iowrite32(reset_complete[i] | operation_timeout[i],
-                denali->flash_reg + intr_status_addresses[i]);
+        for (i = 0 ; i < denali->max_banks; i++)
+                iowrite32(INTR_STATUS__RST_COMP | INTR_STATUS__TIME_OUT,
+                denali->flash_reg + INTR_STATUS(i));
 
-        for (i = 0 ; i < LLD_MAX_FLASH_BANKS; i++) {
-                iowrite32(device_reset_banks[i],
-                                denali->flash_reg + DEVICE_RESET);
+        for (i = 0 ; i < denali->max_banks; i++) {
+                iowrite32(1 << i, denali->flash_reg + DEVICE_RESET);
                 while (!(ioread32(denali->flash_reg +
-                                intr_status_addresses[i]) &
-                        (reset_complete[i] | operation_timeout[i])))
+                                INTR_STATUS(i)) &
+                        (INTR_STATUS__RST_COMP | INTR_STATUS__TIME_OUT)))
                         cpu_relax();
-                if (ioread32(denali->flash_reg + intr_status_addresses[i]) &
-                        operation_timeout[i])
-                        dev_dbg(&denali->dev->dev,
+                if (ioread32(denali->flash_reg + INTR_STATUS(i)) &
+                        INTR_STATUS__TIME_OUT)
+                        dev_dbg(denali->dev,
                         "NAND Reset operation timed out on bank %d\n", i);
         }
 
-        for (i = 0; i < LLD_MAX_FLASH_BANKS; i++)
-                iowrite32(reset_complete[i] | operation_timeout[i],
-                        denali->flash_reg + intr_status_addresses[i]);
+        for (i = 0; i < denali->max_banks; i++)
+                iowrite32(INTR_STATUS__RST_COMP | INTR_STATUS__TIME_OUT,
+                        denali->flash_reg + INTR_STATUS(i));
 
         return PASS;
 }
@@ -254,7 +228,7 @@ static void nand_onfi_timing_set(struct denali_nand_info *denali,
         uint16_t acc_clks;
         uint16_t addr_2_data, re_2_we, re_2_re, we_2_re, cs_cnt;
 
-        dev_dbg(&denali->dev->dev, "%s, Line %d, Function: %s\n",
+        dev_dbg(denali->dev, "%s, Line %d, Function: %s\n",
                        __FILE__, __LINE__, __func__);
 
         en_lo = CEIL_DIV(Trp[mode], CLK_X);
@@ -291,7 +265,7 @@ static void nand_onfi_timing_set(struct denali_nand_info *denali,
                 acc_clks++;
 
         if ((data_invalid - acc_clks * CLK_X) < 2)
-                dev_warn(&denali->dev->dev, "%s, Line %d: Warning!\n",
+                dev_warn(denali->dev, "%s, Line %d: Warning!\n",
                         __FILE__, __LINE__);
 
         addr_2_data = CEIL_DIV(Tadl[mode], CLK_X);
@@ -419,7 +393,7 @@ static void get_hynix_nand_para(struct denali_nand_info *denali,
 #endif
                 break;
         default:
-                dev_warn(&denali->dev->dev,
+                dev_warn(denali->dev,
                         "Spectra: Unknown Hynix NAND (Device ID: 0x%x)."
                         "Will use default parameter values instead.\n",
                         device_id);
@@ -431,17 +405,17 @@ static void get_hynix_nand_para(struct denali_nand_info *denali,
  */
 static void find_valid_banks(struct denali_nand_info *denali)
 {
-        uint32_t id[LLD_MAX_FLASH_BANKS];
+        uint32_t id[denali->max_banks];
         int i;
 
         denali->total_used_banks = 1;
-        for (i = 0; i < LLD_MAX_FLASH_BANKS; i++) {
+        for (i = 0; i < denali->max_banks; i++) {
                 index_addr(denali, (uint32_t)(MODE_11 | (i << 24) | 0), 0x90);
                 index_addr(denali, (uint32_t)(MODE_11 | (i << 24) | 1), 0);
                 index_addr_read_data(denali,
                                 (uint32_t)(MODE_11 | (i << 24) | 2), &id[i]);
 
-                dev_dbg(&denali->dev->dev,
+                dev_dbg(denali->dev,
                         "Return 1st ID for bank[%d]: %x\n", i, id[i]);
 
                 if (i == 0) {
@@ -461,16 +435,27 @@ static void find_valid_banks(struct denali_nand_info *denali)
                  * Multichip support is not enabled.
                  */
                 if (denali->total_used_banks != 1) {
-                        dev_err(&denali->dev->dev,
+                        dev_err(denali->dev,
                                         "Sorry, Intel CE4100 only supports "
                                         "a single NAND device.\n");
                         BUG();
                 }
         }
-        dev_dbg(&denali->dev->dev,
+        dev_dbg(denali->dev,
                 "denali->total_used_banks: %d\n", denali->total_used_banks);
 }
 
+/*
+ * Use the configuration feature register to determine the maximum number of
+ * banks that the hardware supports.
+ */
+static void detect_max_banks(struct denali_nand_info *denali)
+{
+        uint32_t features = ioread32(denali->flash_reg + FEATURES);
+
+        denali->max_banks = 2 << (features & FEATURES__N_BANKS);
+}
+
 static void detect_partition_feature(struct denali_nand_info *denali)
 {
         /* For MRST platform, denali->fwblks represent the
@@ -480,15 +465,15 @@ static void detect_partition_feature(struct denali_nand_info *denali)
          * blocks it can't touch.
          * */
         if (ioread32(denali->flash_reg + FEATURES) & FEATURES__PARTITION) {
-                if ((ioread32(denali->flash_reg + PERM_SRC_ID_1) &
-                        PERM_SRC_ID_1__SRCID) == SPECTRA_PARTITION_ID) {
+                if ((ioread32(denali->flash_reg + PERM_SRC_ID(1)) &
+                        PERM_SRC_ID__SRCID) == SPECTRA_PARTITION_ID) {
                         denali->fwblks =
-                            ((ioread32(denali->flash_reg + MIN_MAX_BANK_1) &
-                              MIN_MAX_BANK_1__MIN_VALUE) *
+                            ((ioread32(denali->flash_reg + MIN_MAX_BANK(1)) &
+                              MIN_MAX_BANK__MIN_VALUE) *
                              denali->blksperchip)
                             +
-                            (ioread32(denali->flash_reg + MIN_BLK_ADDR_1) &
-                            MIN_BLK_ADDR_1__VALUE);
+                            (ioread32(denali->flash_reg + MIN_BLK_ADDR(1)) &
+                            MIN_BLK_ADDR__VALUE);
                 } else
                         denali->fwblks = SPECTRA_START_BLOCK;
         } else
@@ -501,7 +486,7 @@ static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
         uint32_t id_bytes[5], addr;
         uint8_t i, maf_id, device_id;
 
-        dev_dbg(&denali->dev->dev,
+        dev_dbg(denali->dev,
                         "%s, Line %d, Function: %s\n",
                         __FILE__, __LINE__, __func__);
 
@@ -530,7 +515,7 @@ static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
                 get_hynix_nand_para(denali, device_id);
         }
 
-        dev_info(&denali->dev->dev,
+        dev_info(denali->dev,
                         "Dump timing register values:"
                         "acc_clks: %d, re_2_we: %d, re_2_re: %d\n"
                         "we_2_re: %d, addr_2_data: %d, rdwr_en_lo_cnt: %d\n"
@@ -560,7 +545,7 @@ static uint16_t denali_nand_timing_set(struct denali_nand_info *denali)
 static void denali_set_intr_modes(struct denali_nand_info *denali,
                                         uint16_t INT_ENABLE)
 {
-        dev_dbg(&denali->dev->dev, "%s, Line %d, Function: %s\n",
+        dev_dbg(denali->dev, "%s, Line %d, Function: %s\n",
                        __FILE__, __LINE__, __func__);
 
         if (INT_ENABLE)
@@ -580,6 +565,7 @@ static inline bool is_flash_bank_valid(int flash_bank)
 static void denali_irq_init(struct denali_nand_info *denali)
 {
         uint32_t int_mask = 0;
+        int i;
 
         /* Disable global interrupts */
         denali_set_intr_modes(denali, false);
@@ -587,10 +573,8 @@ static void denali_irq_init(struct denali_nand_info *denali)
         int_mask = DENALI_IRQ_ALL;
 
         /* Clear all status bits */
-        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS0);
-        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS1);
-        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS2);
-        iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS3);
+        for (i = 0; i < denali->max_banks; ++i)
+                iowrite32(0xFFFF, denali->flash_reg + INTR_STATUS(i));
 
         denali_irq_enable(denali, int_mask);
 }
@@ -604,10 +588,10 @@ static void denali_irq_cleanup(int irqnum, struct denali_nand_info *denali)
 static void denali_irq_enable(struct denali_nand_info *denali,
                                                         uint32_t int_mask)
 {
-        iowrite32(int_mask, denali->flash_reg + INTR_EN0);
-        iowrite32(int_mask, denali->flash_reg + INTR_EN1);
-        iowrite32(int_mask, denali->flash_reg + INTR_EN2);
-        iowrite32(int_mask, denali->flash_reg + INTR_EN3);
+        int i;
+
+        for (i = 0; i < denali->max_banks; ++i)
+                iowrite32(int_mask, denali->flash_reg + INTR_EN(i));
 }
 
 /* This function only returns when an interrupt that this driver cares about
@@ -624,7 +608,7 @@ static inline void clear_interrupt(struct denali_nand_info *denali,
 {
         uint32_t intr_status_reg = 0;
 
-        intr_status_reg = intr_status_addresses[denali->flash_bank];
+        intr_status_reg = INTR_STATUS(denali->flash_bank);
 
         iowrite32(irq_mask, denali->flash_reg + intr_status_reg);
 }
@@ -645,7 +629,7 @@ static uint32_t read_interrupt_status(struct denali_nand_info *denali)
 {
         uint32_t intr_status_reg = 0;
 
-        intr_status_reg = intr_status_addresses[denali->flash_bank];
+        intr_status_reg = INTR_STATUS(denali->flash_bank);
 
         return ioread32(denali->flash_reg + intr_status_reg);
 }
@@ -754,7 +738,7 @@ static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
                  irq_mask = 0;
 
         if (op == DENALI_READ)
-                irq_mask = INTR_STATUS0__LOAD_COMP;
+                irq_mask = INTR_STATUS__LOAD_COMP;
         else if (op == DENALI_WRITE)
                 irq_mask = 0;
         else
@@ -800,7 +784,7 @@ static int denali_send_pipeline_cmd(struct denali_nand_info *denali,
                         irq_status = wait_for_irq(denali, irq_mask);
 
                         if (irq_status == 0) {
-                                dev_err(&denali->dev->dev,
+                                dev_err(denali->dev,
                                                 "cmd, page, addr on timeout "
                                                 "(0x%x, 0x%x, 0x%x)\n",
                                                 cmd, denali->page, addr);
@@ -861,8 +845,8 @@ static int write_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
         uint32_t irq_status = 0;
-        uint32_t irq_mask = INTR_STATUS0__PROGRAM_COMP |
-                                                INTR_STATUS0__PROGRAM_FAIL;
+        uint32_t irq_mask = INTR_STATUS__PROGRAM_COMP |
+                                                INTR_STATUS__PROGRAM_FAIL;
         int status = 0;
 
         denali->page = page;
@@ -875,11 +859,11 @@ static int write_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
                 irq_status = wait_for_irq(denali, irq_mask);
 
                 if (irq_status == 0) {
-                        dev_err(&denali->dev->dev, "OOB write failed\n");
+                        dev_err(denali->dev, "OOB write failed\n");
                         status = -EIO;
                 }
         } else {
-                dev_err(&denali->dev->dev, "unable to send pipeline command\n");
+                dev_err(denali->dev, "unable to send pipeline command\n");
                 status = -EIO;
         }
         return status;
@@ -889,7 +873,7 @@ static int write_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
 static void read_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        uint32_t irq_mask = INTR_STATUS0__LOAD_COMP,
+        uint32_t irq_mask = INTR_STATUS__LOAD_COMP,
                          irq_status = 0, addr = 0x0, cmd = 0x0;
 
         denali->page = page;
@@ -904,7 +888,7 @@ static void read_oob_data(struct mtd_info *mtd, uint8_t *buf, int page)
                 irq_status = wait_for_irq(denali, irq_mask);
 
                 if (irq_status == 0)
-                        dev_err(&denali->dev->dev, "page on OOB timeout %d\n",
+                        dev_err(denali->dev, "page on OOB timeout %d\n",
                                         denali->page);
 
                 /* We set the device back to MAIN_ACCESS here as I observed
@@ -944,7 +928,7 @@ static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
 {
         bool check_erased_page = false;
 
-        if (irq_status & INTR_STATUS0__ECC_ERR) {
+        if (irq_status & INTR_STATUS__ECC_ERR) {
                 /* read the ECC errors. we'll ignore them for now */
                 uint32_t err_address = 0, err_correction_info = 0;
                 uint32_t err_byte = 0, err_sector = 0, err_device = 0;
@@ -995,7 +979,7 @@ static bool handle_ecc(struct denali_nand_info *denali, uint8_t *buf,
                  * for a while for this interrupt
                  * */
                 while (!(read_interrupt_status(denali) &
-                                INTR_STATUS0__ECC_TRANSACTION_DONE))
+                                INTR_STATUS__ECC_TRANSACTION_DONE))
                         cpu_relax();
                 clear_interrupts(denali);
                 denali_set_intr_modes(denali, true);
@@ -1045,14 +1029,13 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, bool raw_xfer)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        struct pci_dev *pci_dev = denali->dev;
 
         dma_addr_t addr = denali->buf.dma_buf;
         size_t size = denali->mtd.writesize + denali->mtd.oobsize;
 
         uint32_t irq_status = 0;
-        uint32_t irq_mask = INTR_STATUS0__DMA_CMD_COMP |
-                                                INTR_STATUS0__PROGRAM_FAIL;
+        uint32_t irq_mask = INTR_STATUS__DMA_CMD_COMP |
+                                                INTR_STATUS__PROGRAM_FAIL;
 
         /* if it is a raw xfer, we want to disable ecc, and send
          * the spare area.
@@ -1071,7 +1054,7 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
                         mtd->oobsize);
         }
 
-        pci_dma_sync_single_for_device(pci_dev, addr, size, PCI_DMA_TODEVICE);
+        dma_sync_single_for_device(denali->dev, addr, size, DMA_TO_DEVICE);
 
         clear_interrupts(denali);
         denali_enable_dma(denali, true);
@@ -1082,16 +1065,16 @@ static void write_page(struct mtd_info *mtd, struct nand_chip *chip,
         irq_status = wait_for_irq(denali, irq_mask);
 
         if (irq_status == 0) {
-                dev_err(&denali->dev->dev,
+                dev_err(denali->dev,
                                 "timeout on write_page (type = %d)\n",
                                 raw_xfer);
                 denali->status =
-                        (irq_status & INTR_STATUS0__PROGRAM_FAIL) ?
+                        (irq_status & INTR_STATUS__PROGRAM_FAIL) ?
                         NAND_STATUS_FAIL : PASS;
         }
 
         denali_enable_dma(denali, false);
-        pci_dma_sync_single_for_cpu(pci_dev, addr, size, PCI_DMA_TODEVICE);
+        dma_sync_single_for_cpu(denali->dev, addr, size, DMA_TO_DEVICE);
 }
 
 /* NAND core entry points */
@@ -1139,18 +1122,17 @@ static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
                             uint8_t *buf, int page)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        struct pci_dev *pci_dev = denali->dev;
 
         dma_addr_t addr = denali->buf.dma_buf;
         size_t size = denali->mtd.writesize + denali->mtd.oobsize;
 
         uint32_t irq_status = 0;
-        uint32_t irq_mask = INTR_STATUS0__ECC_TRANSACTION_DONE |
-                            INTR_STATUS0__ECC_ERR;
+        uint32_t irq_mask = INTR_STATUS__ECC_TRANSACTION_DONE |
+                            INTR_STATUS__ECC_ERR;
         bool check_erased_page = false;
 
         if (page != denali->page) {
-                dev_err(&denali->dev->dev, "IN %s: page %d is not"
+                dev_err(denali->dev, "IN %s: page %d is not"
                                 " equal to denali->page %d, investigate!!",
                                 __func__, page, denali->page);
                 BUG();
@@ -1159,7 +1141,7 @@ static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
         setup_ecc_for_xfer(denali, true, false);
 
         denali_enable_dma(denali, true);
-        pci_dma_sync_single_for_device(pci_dev, addr, size, PCI_DMA_FROMDEVICE);
+        dma_sync_single_for_device(denali->dev, addr, size, DMA_FROM_DEVICE);
 
         clear_interrupts(denali);
         denali_setup_dma(denali, DENALI_READ);
@@ -1167,7 +1149,7 @@ static int denali_read_page(struct mtd_info *mtd, struct nand_chip *chip,
         /* wait for operation to complete */
         irq_status = wait_for_irq(denali, irq_mask);
 
-        pci_dma_sync_single_for_cpu(pci_dev, addr, size, PCI_DMA_FROMDEVICE);
+        dma_sync_single_for_cpu(denali->dev, addr, size, DMA_FROM_DEVICE);
 
         memcpy(buf, denali->buf.buf, mtd->writesize);
 
@@ -1192,16 +1174,15 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                                 uint8_t *buf, int page)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        struct pci_dev *pci_dev = denali->dev;
 
         dma_addr_t addr = denali->buf.dma_buf;
         size_t size = denali->mtd.writesize + denali->mtd.oobsize;
 
         uint32_t irq_status = 0;
-        uint32_t irq_mask = INTR_STATUS0__DMA_CMD_COMP;
+        uint32_t irq_mask = INTR_STATUS__DMA_CMD_COMP;
 
         if (page != denali->page) {
-                dev_err(&denali->dev->dev, "IN %s: page %d is not"
+                dev_err(denali->dev, "IN %s: page %d is not"
                                 " equal to denali->page %d, investigate!!",
                                 __func__, page, denali->page);
                 BUG();
@@ -1210,7 +1191,7 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
         setup_ecc_for_xfer(denali, false, true);
         denali_enable_dma(denali, true);
 
-        pci_dma_sync_single_for_device(pci_dev, addr, size, PCI_DMA_FROMDEVICE);
+        dma_sync_single_for_device(denali->dev, addr, size, DMA_FROM_DEVICE);
 
         clear_interrupts(denali);
         denali_setup_dma(denali, DENALI_READ);
@@ -1218,7 +1199,7 @@ static int denali_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
         /* wait for operation to complete */
         irq_status = wait_for_irq(denali, irq_mask);
 
-        pci_dma_sync_single_for_cpu(pci_dev, addr, size, PCI_DMA_FROMDEVICE);
+        dma_sync_single_for_cpu(denali->dev, addr, size, DMA_FROM_DEVICE);
 
         denali_enable_dma(denali, false);
 
@@ -1271,10 +1252,10 @@ static void denali_erase(struct mtd_info *mtd, int page)
         index_addr(denali, (uint32_t)cmd, 0x1);
 
         /* wait for erase to complete or failure to occur */
-        irq_status = wait_for_irq(denali, INTR_STATUS0__ERASE_COMP |
-                                        INTR_STATUS0__ERASE_FAIL);
+        irq_status = wait_for_irq(denali, INTR_STATUS__ERASE_COMP |
+                                        INTR_STATUS__ERASE_FAIL);
 
-        denali->status = (irq_status & INTR_STATUS0__ERASE_FAIL) ?
+        denali->status = (irq_status & INTR_STATUS__ERASE_FAIL) ?
                                                 NAND_STATUS_FAIL : PASS;
 }
 
@@ -1330,7 +1311,7 @@ static int denali_ecc_calculate(struct mtd_info *mtd, const uint8_t *data,
                                 uint8_t *ecc_code)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        dev_err(&denali->dev->dev,
+        dev_err(denali->dev,
                         "denali_ecc_calculate called unexpectedly\n");
         BUG();
         return -EIO;
@@ -1340,7 +1321,7 @@ static int denali_ecc_correct(struct mtd_info *mtd, uint8_t *data,
                                 uint8_t *read_ecc, uint8_t *calc_ecc)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        dev_err(&denali->dev->dev,
+        dev_err(denali->dev,
                         "denali_ecc_correct called unexpectedly\n");
         BUG();
         return -EIO;
@@ -1349,7 +1330,7 @@ static int denali_ecc_correct(struct mtd_info *mtd, uint8_t *data,
 static void denali_ecc_hwctl(struct mtd_info *mtd, int mode)
 {
         struct denali_nand_info *denali = mtd_to_denali(mtd);
-        dev_err(&denali->dev->dev,
+        dev_err(denali->dev,
                         "denali_ecc_hwctl called unexpectedly\n");
         BUG();
 }
@@ -1375,6 +1356,7 @@ static void denali_hw_init(struct denali_nand_info *denali)
         /* Should set value for these registers when init */
         iowrite32(0, denali->flash_reg + TWO_ROW_ADDR_CYCLES);
         iowrite32(1, denali->flash_reg + ECC_ENABLE);
+        detect_max_banks(denali);
         denali_nand_timing_set(denali);
         denali_irq_init(denali);
 }
@@ -1484,24 +1466,22 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         }
 
         /* Is 32-bit DMA supported? */
-        ret = pci_set_dma_mask(dev, DMA_BIT_MASK(32));
-
+        ret = dma_set_mask(&dev->dev, DMA_BIT_MASK(32));
         if (ret) {
                 printk(KERN_ERR "Spectra: no usable DMA configuration\n");
                 goto failed_enable_dev;
         }
-        denali->buf.dma_buf =
-                pci_map_single(dev, denali->buf.buf,
-                                                DENALI_BUF_SIZE,
-                                                PCI_DMA_BIDIRECTIONAL);
+        denali->buf.dma_buf = dma_map_single(&dev->dev, denali->buf.buf,
+                                             DENALI_BUF_SIZE,
+                                             DMA_BIDIRECTIONAL);
 
-        if (pci_dma_mapping_error(dev, denali->buf.dma_buf)) {
+        if (dma_mapping_error(&dev->dev, denali->buf.dma_buf)) {
                 dev_err(&dev->dev, "Spectra: failed to map DMA buffer\n");
                 goto failed_enable_dev;
         }
 
         pci_set_master(dev);
-        denali->dev = dev;
+        denali->dev = &dev->dev;
         denali->mtd.dev.parent = &dev->dev;
 
         ret = pci_request_regions(dev, DENALI_NAND_NAME);
@@ -1554,7 +1534,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
         /* scan for NAND devices attached to the controller
          * this is the first stage in a two step process to register
          * with the nand subsystem */
-        if (nand_scan_ident(&denali->mtd, LLD_MAX_FLASH_BANKS, NULL)) {
+        if (nand_scan_ident(&denali->mtd, denali->max_banks, NULL)) {
                 ret = -ENXIO;
                 goto failed_req_irq;
         }
@@ -1664,7 +1644,7 @@ static int denali_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
                 goto failed_req_irq;
         }
 
-        ret = add_mtd_device(&denali->mtd);
+        ret = mtd_device_register(&denali->mtd, NULL, 0);
         if (ret) {
                 dev_err(&dev->dev, "Spectra: Failed to register MTD: %d\n",
                                 ret);
@@ -1681,8 +1661,8 @@ failed_remap_reg:
 failed_req_regions:
         pci_release_regions(dev);
 failed_dma_map:
-        pci_unmap_single(dev, denali->buf.dma_buf, DENALI_BUF_SIZE,
-                                                        PCI_DMA_BIDIRECTIONAL);
+        dma_unmap_single(&dev->dev, denali->buf.dma_buf, DENALI_BUF_SIZE,
+                         DMA_BIDIRECTIONAL);
 failed_enable_dev:
         pci_disable_device(dev);
 failed_alloc_memery:
@@ -1696,7 +1676,7 @@ static void denali_pci_remove(struct pci_dev *dev)
         struct denali_nand_info *denali = pci_get_drvdata(dev);
 
         nand_release(&denali->mtd);
-        del_mtd_device(&denali->mtd);
+        mtd_device_unregister(&denali->mtd);
 
         denali_irq_cleanup(dev->irq, denali);
 
@@ -1704,8 +1684,8 @@ static void denali_pci_remove(struct pci_dev *dev)
         iounmap(denali->flash_mem);
         pci_release_regions(dev);
         pci_disable_device(dev);
-        pci_unmap_single(dev, denali->buf.dma_buf, DENALI_BUF_SIZE,
-                                                        PCI_DMA_BIDIRECTIONAL);
+        dma_unmap_single(&dev->dev, denali->buf.dma_buf, DENALI_BUF_SIZE,
+                         DMA_BIDIRECTIONAL);
         pci_set_drvdata(dev, NULL);
         kfree(denali);
 }
@@ -1721,8 +1701,7 @@ static struct pci_driver denali_pci_driver = {
 
 static int __devinit denali_init(void)
 {
-        printk(KERN_INFO "Spectra MTD driver built on %s @ %s\n",
-                        __DATE__, __TIME__);
+        printk(KERN_INFO "Spectra MTD driver\n");
         return pci_register_driver(&denali_pci_driver);
 }
 
diff --git a/drivers/mtd/nand/denali.h b/drivers/mtd/nand/denali.h
index 3918bcb1561e..fabb9d56b39e 100644
--- a/drivers/mtd/nand/denali.h
+++ b/drivers/mtd/nand/denali.h
@@ -211,185 +211,46 @@
 #define TRANSFER_MODE                           0x400
 #define     TRANSFER_MODE__VALUE                        0x0003
 
-#define INTR_STATUS0                            0x410
-#define     INTR_STATUS0__ECC_TRANSACTION_DONE          0x0001
-#define     INTR_STATUS0__ECC_ERR                       0x0002
-#define     INTR_STATUS0__DMA_CMD_COMP                  0x0004
-#define     INTR_STATUS0__TIME_OUT                      0x0008
-#define     INTR_STATUS0__PROGRAM_FAIL                  0x0010
-#define     INTR_STATUS0__ERASE_FAIL                    0x0020
-#define     INTR_STATUS0__LOAD_COMP                     0x0040
-#define     INTR_STATUS0__PROGRAM_COMP                  0x0080
-#define     INTR_STATUS0__ERASE_COMP                    0x0100
-#define     INTR_STATUS0__PIPE_CPYBCK_CMD_COMP          0x0200
-#define     INTR_STATUS0__LOCKED_BLK                    0x0400
-#define     INTR_STATUS0__UNSUP_CMD                     0x0800
-#define     INTR_STATUS0__INT_ACT                       0x1000
-#define     INTR_STATUS0__RST_COMP                      0x2000
-#define     INTR_STATUS0__PIPE_CMD_ERR                  0x4000
-#define     INTR_STATUS0__PAGE_XFER_INC                 0x8000
-
-#define INTR_EN0                                        0x420
-#define     INTR_EN0__ECC_TRANSACTION_DONE              0x0001
-#define     INTR_EN0__ECC_ERR                           0x0002
-#define     INTR_EN0__DMA_CMD_COMP                      0x0004
-#define     INTR_EN0__TIME_OUT                          0x0008
-#define     INTR_EN0__PROGRAM_FAIL                      0x0010
-#define     INTR_EN0__ERASE_FAIL                        0x0020
-#define     INTR_EN0__LOAD_COMP                         0x0040
-#define     INTR_EN0__PROGRAM_COMP                      0x0080
-#define     INTR_EN0__ERASE_COMP                        0x0100
-#define     INTR_EN0__PIPE_CPYBCK_CMD_COMP              0x0200
-#define     INTR_EN0__LOCKED_BLK                        0x0400
-#define     INTR_EN0__UNSUP_CMD                         0x0800
-#define     INTR_EN0__INT_ACT                           0x1000
-#define     INTR_EN0__RST_COMP                          0x2000
-#define     INTR_EN0__PIPE_CMD_ERR                      0x4000
-#define     INTR_EN0__PAGE_XFER_INC                     0x8000
-
-#define PAGE_CNT0                               0x430
-#define     PAGE_CNT0__VALUE                            0x00ff
-
-#define ERR_PAGE_ADDR0                          0x440
-#define     ERR_PAGE_ADDR0__VALUE                       0xffff
-
-#define ERR_BLOCK_ADDR0                         0x450
-#define     ERR_BLOCK_ADDR0__VALUE                      0xffff
-
-#define INTR_STATUS1                            0x460
-#define     INTR_STATUS1__ECC_TRANSACTION_DONE          0x0001
-#define     INTR_STATUS1__ECC_ERR                       0x0002
-#define     INTR_STATUS1__DMA_CMD_COMP                  0x0004
-#define     INTR_STATUS1__TIME_OUT                      0x0008
-#define     INTR_STATUS1__PROGRAM_FAIL                  0x0010
-#define     INTR_STATUS1__ERASE_FAIL                    0x0020
-#define     INTR_STATUS1__LOAD_COMP                     0x0040
-#define     INTR_STATUS1__PROGRAM_COMP                  0x0080
-#define     INTR_STATUS1__ERASE_COMP                    0x0100
-#define     INTR_STATUS1__PIPE_CPYBCK_CMD_COMP          0x0200
-#define     INTR_STATUS1__LOCKED_BLK                    0x0400
-#define     INTR_STATUS1__UNSUP_CMD                     0x0800
-#define     INTR_STATUS1__INT_ACT                       0x1000
-#define     INTR_STATUS1__RST_COMP                      0x2000
-#define     INTR_STATUS1__PIPE_CMD_ERR                  0x4000
-#define     INTR_STATUS1__PAGE_XFER_INC                 0x8000
-
-#define INTR_EN1                                        0x470
-#define     INTR_EN1__ECC_TRANSACTION_DONE              0x0001
-#define     INTR_EN1__ECC_ERR                           0x0002
-#define     INTR_EN1__DMA_CMD_COMP                      0x0004
-#define     INTR_EN1__TIME_OUT                          0x0008
-#define     INTR_EN1__PROGRAM_FAIL                      0x0010
-#define     INTR_EN1__ERASE_FAIL                        0x0020
-#define     INTR_EN1__LOAD_COMP                         0x0040
-#define     INTR_EN1__PROGRAM_COMP                      0x0080
-#define     INTR_EN1__ERASE_COMP                        0x0100
-#define     INTR_EN1__PIPE_CPYBCK_CMD_COMP              0x0200
-#define     INTR_EN1__LOCKED_BLK                        0x0400
-#define     INTR_EN1__UNSUP_CMD                         0x0800
-#define     INTR_EN1__INT_ACT                           0x1000
-#define     INTR_EN1__RST_COMP                          0x2000
-#define     INTR_EN1__PIPE_CMD_ERR                      0x4000
-#define     INTR_EN1__PAGE_XFER_INC                     0x8000
-
-#define PAGE_CNT1                               0x480
-#define     PAGE_CNT1__VALUE                            0x00ff
-
-#define ERR_PAGE_ADDR1                          0x490
-#define     ERR_PAGE_ADDR1__VALUE                       0xffff
-
-#define ERR_BLOCK_ADDR1                         0x4a0
-#define     ERR_BLOCK_ADDR1__VALUE                      0xffff
-
-#define INTR_STATUS2                            0x4b0
-#define     INTR_STATUS2__ECC_TRANSACTION_DONE          0x0001
-#define     INTR_STATUS2__ECC_ERR                       0x0002
-#define     INTR_STATUS2__DMA_CMD_COMP                  0x0004
-#define     INTR_STATUS2__TIME_OUT                      0x0008
-#define     INTR_STATUS2__PROGRAM_FAIL                  0x0010
-#define     INTR_STATUS2__ERASE_FAIL                    0x0020
-#define     INTR_STATUS2__LOAD_COMP                     0x0040
-#define     INTR_STATUS2__PROGRAM_COMP                  0x0080
-#define     INTR_STATUS2__ERASE_COMP                    0x0100
-#define     INTR_STATUS2__PIPE_CPYBCK_CMD_COMP          0x0200
-#define     INTR_STATUS2__LOCKED_BLK                    0x0400
-#define     INTR_STATUS2__UNSUP_CMD                     0x0800
-#define     INTR_STATUS2__INT_ACT                       0x1000
-#define     INTR_STATUS2__RST_COMP                      0x2000
-#define     INTR_STATUS2__PIPE_CMD_ERR                  0x4000
-#define     INTR_STATUS2__PAGE_XFER_INC                 0x8000
-
-#define INTR_EN2                                        0x4c0
-#define     INTR_EN2__ECC_TRANSACTION_DONE              0x0001
-#define     INTR_EN2__ECC_ERR                           0x0002
-#define     INTR_EN2__DMA_CMD_COMP                      0x0004
-#define     INTR_EN2__TIME_OUT                          0x0008
-#define     INTR_EN2__PROGRAM_FAIL                      0x0010
-#define     INTR_EN2__ERASE_FAIL                        0x0020
-#define     INTR_EN2__LOAD_COMP                         0x0040
-#define     INTR_EN2__PROGRAM_COMP                      0x0080
-#define     INTR_EN2__ERASE_COMP                        0x0100
-#define     INTR_EN2__PIPE_CPYBCK_CMD_COMP              0x0200
-#define     INTR_EN2__LOCKED_BLK                        0x0400
-#define     INTR_EN2__UNSUP_CMD                         0x0800
-#define     INTR_EN2__INT_ACT                           0x1000
-#define     INTR_EN2__RST_COMP                          0x2000
-#define     INTR_EN2__PIPE_CMD_ERR                      0x4000
-#define     INTR_EN2__PAGE_XFER_INC                     0x8000
-
-#define PAGE_CNT2                               0x4d0
-#define     PAGE_CNT2__VALUE                            0x00ff
-
-#define ERR_PAGE_ADDR2                          0x4e0
-#define     ERR_PAGE_ADDR2__VALUE                       0xffff
-
-#define ERR_BLOCK_ADDR2                         0x4f0
-#define     ERR_BLOCK_ADDR2__VALUE                      0xffff
-
-#define INTR_STATUS3                            0x500
-#define     INTR_STATUS3__ECC_TRANSACTION_DONE          0x0001
-#define     INTR_STATUS3__ECC_ERR                       0x0002
-#define     INTR_STATUS3__DMA_CMD_COMP                  0x0004
-#define     INTR_STATUS3__TIME_OUT                      0x0008
-#define     INTR_STATUS3__PROGRAM_FAIL                  0x0010
-#define     INTR_STATUS3__ERASE_FAIL                    0x0020
-#define     INTR_STATUS3__LOAD_COMP                     0x0040
-#define     INTR_STATUS3__PROGRAM_COMP                  0x0080
-#define     INTR_STATUS3__ERASE_COMP                    0x0100
-#define     INTR_STATUS3__PIPE_CPYBCK_CMD_COMP          0x0200
-#define     INTR_STATUS3__LOCKED_BLK                    0x0400
-#define     INTR_STATUS3__UNSUP_CMD                     0x0800
-#define     INTR_STATUS3__INT_ACT                       0x1000
-#define     INTR_STATUS3__RST_COMP                      0x2000
-#define     INTR_STATUS3__PIPE_CMD_ERR                  0x4000
-#define     INTR_STATUS3__PAGE_XFER_INC                 0x8000
-
-#define INTR_EN3                                        0x510
-#define     INTR_EN3__ECC_TRANSACTION_DONE              0x0001
-#define     INTR_EN3__ECC_ERR                           0x0002
-#define     INTR_EN3__DMA_CMD_COMP                      0x0004
-#define     INTR_EN3__TIME_OUT                          0x0008
-#define     INTR_EN3__PROGRAM_FAIL                      0x0010
-#define     INTR_EN3__ERASE_FAIL                        0x0020
-#define     INTR_EN3__LOAD_COMP                         0x0040
-#define     INTR_EN3__PROGRAM_COMP                      0x0080
-#define     INTR_EN3__ERASE_COMP                        0x0100
-#define     INTR_EN3__PIPE_CPYBCK_CMD_COMP              0x0200
-#define     INTR_EN3__LOCKED_BLK                        0x0400
-#define     INTR_EN3__UNSUP_CMD                         0x0800
-#define     INTR_EN3__INT_ACT                           0x1000
-#define     INTR_EN3__RST_COMP                          0x2000
-#define     INTR_EN3__PIPE_CMD_ERR                      0x4000
-#define     INTR_EN3__PAGE_XFER_INC                     0x8000
-
-#define PAGE_CNT3                               0x520
-#define     PAGE_CNT3__VALUE                            0x00ff
-
-#define ERR_PAGE_ADDR3                          0x530
-#define     ERR_PAGE_ADDR3__VALUE                       0xffff
-
-#define ERR_BLOCK_ADDR3                         0x540
-#define     ERR_BLOCK_ADDR3__VALUE                      0xffff
+#define INTR_STATUS(__bank)     (0x410 + ((__bank) * 0x50))
+#define INTR_EN(__bank)         (0x420 + ((__bank) * 0x50))
+
+#define     INTR_STATUS__ECC_TRANSACTION_DONE           0x0001
+#define     INTR_STATUS__ECC_ERR                        0x0002
+#define     INTR_STATUS__DMA_CMD_COMP                   0x0004
+#define     INTR_STATUS__TIME_OUT                       0x0008
+#define     INTR_STATUS__PROGRAM_FAIL                   0x0010
+#define     INTR_STATUS__ERASE_FAIL                     0x0020
+#define     INTR_STATUS__LOAD_COMP                      0x0040
+#define     INTR_STATUS__PROGRAM_COMP                   0x0080
+#define     INTR_STATUS__ERASE_COMP                     0x0100
+#define     INTR_STATUS__PIPE_CPYBCK_CMD_COMP           0x0200
+#define     INTR_STATUS__LOCKED_BLK                     0x0400
+#define     INTR_STATUS__UNSUP_CMD                      0x0800
+#define     INTR_STATUS__INT_ACT                        0x1000
+#define     INTR_STATUS__RST_COMP                       0x2000
+#define     INTR_STATUS__PIPE_CMD_ERR                   0x4000
+#define     INTR_STATUS__PAGE_XFER_INC                  0x8000
+
+#define     INTR_EN__ECC_TRANSACTION_DONE               0x0001
+#define     INTR_EN__ECC_ERR                            0x0002
+#define     INTR_EN__DMA_CMD_COMP                       0x0004
+#define     INTR_EN__TIME_OUT                           0x0008
+#define     INTR_EN__PROGRAM_FAIL                       0x0010
+#define     INTR_EN__ERASE_FAIL                         0x0020
+#define     INTR_EN__LOAD_COMP                          0x0040
+#define     INTR_EN__PROGRAM_COMP                       0x0080
+#define     INTR_EN__ERASE_COMP                         0x0100
+#define     INTR_EN__PIPE_CPYBCK_CMD_COMP               0x0200
+#define     INTR_EN__LOCKED_BLK                         0x0400
+#define     INTR_EN__UNSUP_CMD                          0x0800
+#define     INTR_EN__INT_ACT                            0x1000
+#define     INTR_EN__RST_COMP                           0x2000
+#define     INTR_EN__PIPE_CMD_ERR                       0x4000
+#define     INTR_EN__PAGE_XFER_INC                      0x8000
+
+#define PAGE_CNT(__bank)        (0x430 + ((__bank) * 0x50))
+#define ERR_PAGE_ADDR(__bank)   (0x440 + ((__bank) * 0x50))
+#define ERR_BLOCK_ADDR(__bank)  (0x450 + ((__bank) * 0x50))
 
 #define DATA_INTR                               0x550
 #define     DATA_INTR__WRITE_SPACE_AV                   0x0001
@@ -484,141 +345,23 @@
 #define     PTN_INTR_EN__ACCESS_ERROR_BANK3             0x0010
 #define     PTN_INTR_EN__REG_ACCESS_ERROR               0x0020
 
-#define PERM_SRC_ID_0                           0x830
-#define     PERM_SRC_ID_0__SRCID                        0x00ff
-#define     PERM_SRC_ID_0__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_0__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_0__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_0__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_0                          0x840
-#define     MIN_BLK_ADDR_0__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_0                          0x850
-#define     MAX_BLK_ADDR_0__VALUE                       0xffff
-
-#define MIN_MAX_BANK_0                          0x860
-#define     MIN_MAX_BANK_0__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_0__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_1                           0x870
-#define     PERM_SRC_ID_1__SRCID                        0x00ff
-#define     PERM_SRC_ID_1__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_1__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_1__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_1__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_1                          0x880
-#define     MIN_BLK_ADDR_1__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_1                          0x890
-#define     MAX_BLK_ADDR_1__VALUE                       0xffff
-
-#define MIN_MAX_BANK_1                          0x8a0
-#define     MIN_MAX_BANK_1__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_1__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_2                           0x8b0
-#define     PERM_SRC_ID_2__SRCID                        0x00ff
-#define     PERM_SRC_ID_2__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_2__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_2__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_2__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_2                          0x8c0
-#define     MIN_BLK_ADDR_2__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_2                          0x8d0
-#define     MAX_BLK_ADDR_2__VALUE                       0xffff
-
-#define MIN_MAX_BANK_2                          0x8e0
-#define     MIN_MAX_BANK_2__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_2__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_3                           0x8f0
-#define     PERM_SRC_ID_3__SRCID                        0x00ff
-#define     PERM_SRC_ID_3__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_3__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_3__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_3__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_3                          0x900
-#define     MIN_BLK_ADDR_3__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_3                          0x910
-#define     MAX_BLK_ADDR_3__VALUE                       0xffff
-
-#define MIN_MAX_BANK_3                          0x920
-#define     MIN_MAX_BANK_3__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_3__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_4                           0x930
-#define     PERM_SRC_ID_4__SRCID                        0x00ff
-#define     PERM_SRC_ID_4__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_4__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_4__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_4__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_4                          0x940
-#define     MIN_BLK_ADDR_4__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_4                          0x950
-#define     MAX_BLK_ADDR_4__VALUE                       0xffff
-
-#define MIN_MAX_BANK_4                          0x960
-#define     MIN_MAX_BANK_4__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_4__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_5                           0x970
-#define     PERM_SRC_ID_5__SRCID                        0x00ff
-#define     PERM_SRC_ID_5__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_5__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_5__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_5__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_5                          0x980
-#define     MIN_BLK_ADDR_5__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_5                          0x990
-#define     MAX_BLK_ADDR_5__VALUE                       0xffff
-
-#define MIN_MAX_BANK_5                          0x9a0
-#define     MIN_MAX_BANK_5__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_5__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_6                           0x9b0
-#define     PERM_SRC_ID_6__SRCID                        0x00ff
-#define     PERM_SRC_ID_6__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_6__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_6__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_6__PARTITION_VALID              0x8000
-
-#define MIN_BLK_ADDR_6                          0x9c0
-#define     MIN_BLK_ADDR_6__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_6                          0x9d0
-#define     MAX_BLK_ADDR_6__VALUE                       0xffff
-
-#define MIN_MAX_BANK_6                          0x9e0
-#define     MIN_MAX_BANK_6__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_6__MAX_VALUE                   0x000c
-
-#define PERM_SRC_ID_7                           0x9f0
-#define     PERM_SRC_ID_7__SRCID                        0x00ff
-#define     PERM_SRC_ID_7__DIRECT_ACCESS_ACTIVE         0x0800
-#define     PERM_SRC_ID_7__WRITE_ACTIVE                 0x2000
-#define     PERM_SRC_ID_7__READ_ACTIVE                  0x4000
-#define     PERM_SRC_ID_7__PARTITION_VALID              0x8000
+#define PERM_SRC_ID(__bank)     (0x830 + ((__bank) * 0x40))
+#define     PERM_SRC_ID__SRCID                          0x00ff
+#define     PERM_SRC_ID__DIRECT_ACCESS_ACTIVE           0x0800
+#define     PERM_SRC_ID__WRITE_ACTIVE                   0x2000
+#define     PERM_SRC_ID__READ_ACTIVE                    0x4000
+#define     PERM_SRC_ID__PARTITION_VALID                0x8000
+
+#define MIN_BLK_ADDR(__bank)    (0x840 + ((__bank) * 0x40))
+#define     MIN_BLK_ADDR__VALUE                         0xffff
+
+#define MAX_BLK_ADDR(__bank)    (0x850 + ((__bank) * 0x40))
+#define     MAX_BLK_ADDR__VALUE                         0xffff
+
+#define MIN_MAX_BANK(__bank)    (0x860 + ((__bank) * 0x40))
+#define     MIN_MAX_BANK__MIN_VALUE                     0x0003
+#define     MIN_MAX_BANK__MAX_VALUE                     0x000c
 
-#define MIN_BLK_ADDR_7                          0xa00
-#define     MIN_BLK_ADDR_7__VALUE                       0xffff
-
-#define MAX_BLK_ADDR_7                          0xa10
-#define     MAX_BLK_ADDR_7__VALUE                       0xffff
-
-#define MIN_MAX_BANK_7                          0xa20
-#define     MIN_MAX_BANK_7__MIN_VALUE                   0x0003
-#define     MIN_MAX_BANK_7__MAX_VALUE                   0x000c
 
 /* ffsdefs.h */
 #define CLEAR 0                 /*use this to clear a field instead of "fail"*/
@@ -711,7 +454,6 @@
 #define READ_WRITE_ENABLE_HIGH_COUNT    22
 
 #define ECC_SECTOR_SIZE     512
-#define LLD_MAX_FLASH_BANKS     4
 
 #define DENALI_BUF_SIZE         (NAND_MAX_PAGESIZE + NAND_MAX_OOBSIZE)
 
@@ -732,7 +474,7 @@ struct denali_nand_info {
         int status;
         int platform;
         struct nand_buf buf;
-        struct pci_dev *dev;
+        struct device *dev;
         int total_used_banks;
         uint32_t block;  /* stored for future use */
         uint16_t page;
@@ -751,6 +493,7 @@ struct denali_nand_info {
         uint32_t totalblks;
         uint32_t blksperchip;
         uint32_t bbtskipbytes;
+        uint32_t max_banks;
 };
 
 #endif /*_LLD_NAND_*/
diff --git a/drivers/mtd/nand/diskonchip.c b/drivers/mtd/nand/diskonchip.c
index 657b9f4b6f9b..7837728d02ff 100644
--- a/drivers/mtd/nand/diskonchip.c
+++ b/drivers/mtd/nand/diskonchip.c
@@ -1360,11 +1360,9 @@ static int __init nftl_scan_bbt(struct mtd_info *mtd)
            At least as nand_bbt.c is currently written. */
         if ((ret = nand_scan_bbt(mtd, NULL)))
                 return ret;
-        add_mtd_device(mtd);
-#ifdef CONFIG_MTD_PARTITIONS
+        mtd_device_register(mtd, NULL, 0);
         if (!no_autopart)
-                add_mtd_partitions(mtd, parts, numparts);
-#endif
+                mtd_device_register(mtd, parts, numparts);
         return 0;
 }
 
@@ -1419,11 +1417,9 @@ static int __init inftl_scan_bbt(struct mtd_info *mtd)
            autopartitioning, but I want to give it more thought. */
         if (!numparts)
                 return -EIO;
-        add_mtd_device(mtd);
-#ifdef CONFIG_MTD_PARTITIONS
+        mtd_device_register(mtd, NULL, 0);
         if (!no_autopart)
-                add_mtd_partitions(mtd, parts, numparts);
-#endif
+                mtd_device_register(mtd, parts, numparts);
         return 0;
 }
 
@@ -1678,9 +1674,9 @@ static int __init doc_probe(unsigned long physadr)
                 /* DBB note: i believe nand_release is necessary here, as
                    buffers may have been allocated in nand_base.  Check with
                    Thomas. FIX ME! */
-                /* nand_release will call del_mtd_device, but we haven't yet
-                   added it.  This is handled without incident by
-                   del_mtd_device, as far as I can tell. */
+                /* nand_release will call mtd_device_unregister, but we
+                   haven't yet added it.  This is handled without incident by
+                   mtd_device_unregister, as far as I can tell. */
                 nand_release(mtd);
                 kfree(mtd);
                 goto fail;
diff --git a/drivers/mtd/nand/edb7312.c b/drivers/mtd/nand/edb7312.c
index 86366bfba9f8..8400d0f6dada 100644
--- a/drivers/mtd/nand/edb7312.c
+++ b/drivers/mtd/nand/edb7312.c
@@ -55,7 +55,6 @@ static unsigned long ep7312_fio_pbase = EP7312_FIO_PBASE;
 static void __iomem *ep7312_pxdr = (void __iomem *)EP7312_PXDR;
 static void __iomem *ep7312_pxddr = (void __iomem *)EP7312_PXDDR;
 
-#ifdef CONFIG_MTD_PARTITIONS
 /*
  * Define static partitions for flash device
  */
@@ -67,8 +66,6 @@ static struct mtd_partition partition_info[] = {
 
 #define NUM_PARTITIONS 1
 
-#endif
-
 /*
  *      hardware specific access to control-lines
  *
@@ -101,9 +98,7 @@ static int ep7312_device_ready(struct mtd_info *mtd)
         return 1;
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
 /*
  * Main initialization routine
@@ -162,14 +157,12 @@ static int __init ep7312_init(void)
                 kfree(ep7312_mtd);
                 return -ENXIO;
         }
-#ifdef CONFIG_MTD_PARTITIONS
         ep7312_mtd->name = "edb7312-nand";
         mtd_parts_nb = parse_mtd_partitions(ep7312_mtd, part_probes, &mtd_parts, 0);
         if (mtd_parts_nb > 0)
                 part_type = "command line";
         else
                 mtd_parts_nb = 0;
-#endif
         if (mtd_parts_nb == 0) {
                 mtd_parts = partition_info;
                 mtd_parts_nb = NUM_PARTITIONS;
@@ -178,7 +171,7 @@ static int __init ep7312_init(void)
 
         /* Register the partitions */
         printk(KERN_NOTICE "Using %s partition definition\n", part_type);
-        add_mtd_partitions(ep7312_mtd, mtd_parts, mtd_parts_nb);
+        mtd_device_register(ep7312_mtd, mtd_parts, mtd_parts_nb);
 
         /* Return happy */
         return 0;
diff --git a/drivers/mtd/nand/fsl_elbc_nand.c b/drivers/mtd/nand/fsl_elbc_nand.c
index 537e380b8dcb..0bb254c7d2b1 100644
--- a/drivers/mtd/nand/fsl_elbc_nand.c
+++ b/drivers/mtd/nand/fsl_elbc_nand.c
@@ -841,12 +841,9 @@ static int __devinit fsl_elbc_nand_probe(struct platform_device *pdev)
         struct fsl_elbc_mtd *priv;
         struct resource res;
         struct fsl_elbc_fcm_ctrl *elbc_fcm_ctrl;
-
-#ifdef CONFIG_MTD_PARTITIONS
         static const char *part_probe_types[]
                 = { "cmdlinepart", "RedBoot", NULL };
         struct mtd_partition *parts;
-#endif
         int ret;
         int bank;
         struct device *dev;
@@ -935,26 +932,19 @@ static int __devinit fsl_elbc_nand_probe(struct platform_device *pdev)
         if (ret)
                 goto err;
 
-#ifdef CONFIG_MTD_PARTITIONS
         /* First look for RedBoot table or partitions on the command
          * line, these take precedence over device tree information */
         ret = parse_mtd_partitions(&priv->mtd, part_probe_types, &parts, 0);
         if (ret < 0)
                 goto err;
 
-#ifdef CONFIG_MTD_OF_PARTS
         if (ret == 0) {
                 ret = of_mtd_parse_partitions(priv->dev, node, &parts);
                 if (ret < 0)
                         goto err;
         }
-#endif
 
-        if (ret > 0)
-                add_mtd_partitions(&priv->mtd, parts, ret);
-        else
-#endif
-                add_mtd_device(&priv->mtd);
+        mtd_device_register(&priv->mtd, parts, ret);
 
         printk(KERN_INFO "eLBC NAND device at 0x%llx, bank %d\n",
                (unsigned long long)res.start, priv->bank);
diff --git a/drivers/mtd/nand/fsl_upm.c b/drivers/mtd/nand/fsl_upm.c
index 073ee026a17c..23752fd5bc59 100644
--- a/drivers/mtd/nand/fsl_upm.c
+++ b/drivers/mtd/nand/fsl_upm.c
@@ -33,10 +33,7 @@ struct fsl_upm_nand {
         struct mtd_info mtd;
         struct nand_chip chip;
         int last_ctrl;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
-#endif
-
         struct fsl_upm upm;
         uint8_t upm_addr_offset;
         uint8_t upm_cmd_offset;
@@ -161,9 +158,7 @@ static int __devinit fun_chip_init(struct fsl_upm_nand *fun,
 {
         int ret;
         struct device_node *flash_np;
-#ifdef CONFIG_MTD_PARTITIONS
         static const char *part_types[] = { "cmdlinepart", NULL, };
-#endif
 
         fun->chip.IO_ADDR_R = fun->io_base;
         fun->chip.IO_ADDR_W = fun->io_base;
@@ -197,7 +192,6 @@ static int __devinit fun_chip_init(struct fsl_upm_nand *fun,
         if (ret)
                 goto err;
 
-#ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(&fun->mtd, part_types, &fun->parts, 0);
 
 #ifdef CONFIG_MTD_OF_PARTS
@@ -207,11 +201,7 @@ static int __devinit fun_chip_init(struct fsl_upm_nand *fun,
                         goto err;
         }
 #endif
-        if (ret > 0)
-                ret = add_mtd_partitions(&fun->mtd, fun->parts, ret);
-        else
-#endif
-                ret = add_mtd_device(&fun->mtd);
+        ret = mtd_device_register(&fun->mtd, fun->parts, ret);
 err:
         of_node_put(flash_np);
         return ret;
diff --git a/drivers/mtd/nand/fsmc_nand.c b/drivers/mtd/nand/fsmc_nand.c
index 0d45ef3883e8..e9b275ac381c 100644
--- a/drivers/mtd/nand/fsmc_nand.c
+++ b/drivers/mtd/nand/fsmc_nand.c
@@ -120,8 +120,6 @@ static struct fsmc_eccplace fsmc_ecc4_sp_place = {
         }
 };
 
-
-#ifdef CONFIG_MTD_PARTITIONS
 /*
  * Default partition tables to be used if the partition information not
  * provided through platform data.
@@ -182,7 +180,6 @@ static struct mtd_partition partition_info_128KB_blk[] = {
 #ifdef CONFIG_MTD_CMDLINE_PARTS
 const char *part_probes[] = { "cmdlinepart", NULL };
 #endif
-#endif
 
 /**
  * struct fsmc_nand_data - structure for FSMC NAND device state
@@ -719,7 +716,6 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
          * platform data,
          * default partition information present in driver.
          */
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         /*
          * Check if partition info passed via command line
@@ -777,19 +773,10 @@ static int __init fsmc_nand_probe(struct platform_device *pdev)
         }
 #endif
 
-        if (host->partitions) {
-                ret = add_mtd_partitions(&host->mtd, host->partitions,
-                                host->nr_partitions);
-                if (ret)
-                        goto err_probe;
-        }
-#else
-        dev_info(&pdev->dev, "Registering %s as whole device\n", mtd->name);
-        if (!add_mtd_device(mtd)) {
-                ret = -ENXIO;
+        ret = mtd_device_register(&host->mtd, host->partitions,
+                                  host->nr_partitions);
+        if (ret)
                 goto err_probe;
-        }
-#endif
 
         platform_set_drvdata(pdev, host);
         dev_info(&pdev->dev, "FSMC NAND driver registration successful\n");
@@ -835,11 +822,7 @@ static int fsmc_nand_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
 
         if (host) {
-#ifdef CONFIG_MTD_PARTITIONS
-                del_mtd_partitions(&host->mtd);
-#else
-                del_mtd_device(&host->mtd);
-#endif
+                mtd_device_unregister(&host->mtd);
                 clk_disable(host->clk);
                 clk_put(host->clk);
 
diff --git a/drivers/mtd/nand/gpio.c b/drivers/mtd/nand/gpio.c
index 0cde618bcc1e..2c2060b2800e 100644
--- a/drivers/mtd/nand/gpio.c
+++ b/drivers/mtd/nand/gpio.c
@@ -316,8 +316,8 @@ static int __devinit gpio_nand_probe(struct platform_device *dev)
                 gpiomtd->plat.adjust_parts(&gpiomtd->plat,
                                            gpiomtd->mtd_info.size);
 
-        add_mtd_partitions(&gpiomtd->mtd_info, gpiomtd->plat.parts,
-                           gpiomtd->plat.num_parts);
+        mtd_device_register(&gpiomtd->mtd_info, gpiomtd->plat.parts,
+                            gpiomtd->plat.num_parts);
         platform_set_drvdata(dev, gpiomtd);
 
         return 0;
diff --git a/drivers/mtd/nand/h1910.c b/drivers/mtd/nand/h1910.c
index f8ce79b446ed..02a03e67109c 100644
--- a/drivers/mtd/nand/h1910.c
+++ b/drivers/mtd/nand/h1910.c
@@ -38,7 +38,6 @@ static struct mtd_info *h1910_nand_mtd = NULL;
  * Module stuff
  */
 
-#ifdef CONFIG_MTD_PARTITIONS
 /*
  * Define static partitions for flash device
  */
@@ -50,8 +49,6 @@ static struct mtd_partition partition_info[] = {
 
 #define NUM_PARTITIONS 1
 
-#endif
-
 /*
  *      hardware specific access to control-lines
  *
@@ -154,7 +151,7 @@ static int __init h1910_init(void)
 
         /* Register the partitions */
         printk(KERN_NOTICE "Using %s partition definition\n", part_type);
-        add_mtd_partitions(h1910_nand_mtd, mtd_parts, mtd_parts_nb);
+        mtd_device_register(h1910_nand_mtd, mtd_parts, mtd_parts_nb);
 
         /* Return happy */
         return 0;
diff --git a/drivers/mtd/nand/jz4740_nand.c b/drivers/mtd/nand/jz4740_nand.c
index cea38a5d4ac5..6e813daed068 100644
--- a/drivers/mtd/nand/jz4740_nand.c
+++ b/drivers/mtd/nand/jz4740_nand.c
@@ -299,10 +299,8 @@ static int __devinit jz_nand_probe(struct platform_device *pdev)
         struct nand_chip *chip;
         struct mtd_info *mtd;
         struct jz_nand_platform_data *pdata = pdev->dev.platform_data;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *partition_info;
         int num_partitions = 0;
-#endif
 
         nand = kzalloc(sizeof(*nand), GFP_KERNEL);
         if (!nand) {
@@ -375,7 +373,6 @@ static int __devinit jz_nand_probe(struct platform_device *pdev)
                 goto err_gpio_free;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         num_partitions = parse_mtd_partitions(mtd, part_probes,
                                                 &partition_info, 0);
@@ -384,12 +381,7 @@ static int __devinit jz_nand_probe(struct platform_device *pdev)
                 num_partitions = pdata->num_partitions;
                 partition_info = pdata->partitions;
         }
-
-        if (num_partitions > 0)
-                ret = add_mtd_partitions(mtd, partition_info, num_partitions);
-        else
-#endif
-        ret = add_mtd_device(mtd);
+        ret = mtd_device_register(mtd, partition_info, num_partitions);
 
         if (ret) {
                 dev_err(&pdev->dev, "Failed to add mtd device\n");
diff --git a/drivers/mtd/nand/mpc5121_nfc.c b/drivers/mtd/nand/mpc5121_nfc.c
index 0b81b5b499d1..2f7c930872f9 100644
--- a/drivers/mtd/nand/mpc5121_nfc.c
+++ b/drivers/mtd/nand/mpc5121_nfc.c
@@ -131,9 +131,7 @@ struct mpc5121_nfc_prv {
 
 static void mpc5121_nfc_done(struct mtd_info *mtd);
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *mpc5121_nfc_pprobes[] = { "cmdlinepart", NULL };
-#endif
 
 /* Read NFC register */
 static inline u16 nfc_read(struct mtd_info *mtd, uint reg)
@@ -658,9 +656,7 @@ static int __devinit mpc5121_nfc_probe(struct platform_device *op)
         struct mpc5121_nfc_prv *prv;
         struct resource res;
         struct mtd_info *mtd;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
-#endif
         struct nand_chip *chip;
         unsigned long regs_paddr, regs_size;
         const __be32 *chips_no;
@@ -841,7 +837,6 @@ static int __devinit mpc5121_nfc_probe(struct platform_device *op)
         dev_set_drvdata(dev, mtd);
 
         /* Register device in MTD */
-#ifdef CONFIG_MTD_PARTITIONS
         retval = parse_mtd_partitions(mtd, mpc5121_nfc_pprobes, &parts, 0);
 #ifdef CONFIG_MTD_OF_PARTS
         if (retval == 0)
@@ -854,12 +849,7 @@ static int __devinit mpc5121_nfc_probe(struct platform_device *op)
                 goto error;
         }
 
-        if (retval > 0)
-                retval = add_mtd_partitions(mtd, parts, retval);
-        else
-#endif
-                retval = add_mtd_device(mtd);
-
+        retval = mtd_device_register(mtd, parts, retval);
         if (retval) {
                 dev_err(dev, "Error adding MTD device!\n");
                 devm_free_irq(dev, prv->irq, mtd);
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index 42a95fb41504..90df34c4d26c 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -56,8 +56,14 @@
 #define NFC_V1_V2_WRPROT                (host->regs + 0x12)
 #define NFC_V1_UNLOCKSTART_BLKADDR      (host->regs + 0x14)
 #define NFC_V1_UNLOCKEND_BLKADDR        (host->regs + 0x16)
-#define NFC_V21_UNLOCKSTART_BLKADDR     (host->regs + 0x20)
-#define NFC_V21_UNLOCKEND_BLKADDR       (host->regs + 0x22)
+#define NFC_V21_UNLOCKSTART_BLKADDR0    (host->regs + 0x20)
+#define NFC_V21_UNLOCKSTART_BLKADDR1    (host->regs + 0x24)
+#define NFC_V21_UNLOCKSTART_BLKADDR2    (host->regs + 0x28)
+#define NFC_V21_UNLOCKSTART_BLKADDR3    (host->regs + 0x2c)
+#define NFC_V21_UNLOCKEND_BLKADDR0      (host->regs + 0x22)
+#define NFC_V21_UNLOCKEND_BLKADDR1      (host->regs + 0x26)
+#define NFC_V21_UNLOCKEND_BLKADDR2      (host->regs + 0x2a)
+#define NFC_V21_UNLOCKEND_BLKADDR3      (host->regs + 0x2e)
 #define NFC_V1_V2_NF_WRPRST             (host->regs + 0x18)
 #define NFC_V1_V2_CONFIG1               (host->regs + 0x1a)
 #define NFC_V1_V2_CONFIG2               (host->regs + 0x1c)
@@ -152,6 +158,7 @@ struct mxc_nand_host {
         int                     clk_act;
         int                     irq;
         int                     eccsize;
+        int                     active_cs;
 
         struct completion       op_completion;
 
@@ -236,9 +243,7 @@ static struct nand_ecclayout nandv2_hw_eccoob_4k = {
         }
 };
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "RedBoot", "cmdlinepart", NULL };
-#endif
 
 static irqreturn_t mxc_nfc_irq(int irq, void *dev_id)
 {
@@ -445,7 +450,7 @@ static void send_page_v1_v2(struct mtd_info *mtd, unsigned int ops)
         for (i = 0; i < bufs; i++) {
 
                 /* NANDFC buffer 0 is used for page read/write */
-                writew(i, NFC_V1_V2_BUF_ADDR);
+                writew((host->active_cs << 4) | i, NFC_V1_V2_BUF_ADDR);
 
                 writew(ops, NFC_V1_V2_CONFIG2);
 
@@ -470,7 +475,7 @@ static void send_read_id_v1_v2(struct mxc_nand_host *host)
         struct nand_chip *this = &host->nand;
 
         /* NANDFC buffer 0 is used for device ID output */
-        writew(0x0, NFC_V1_V2_BUF_ADDR);
+        writew(host->active_cs << 4, NFC_V1_V2_BUF_ADDR);
 
         writew(NFC_ID, NFC_V1_V2_CONFIG2);
 
@@ -505,7 +510,7 @@ static uint16_t get_dev_status_v1_v2(struct mxc_nand_host *host)
         uint32_t store;
         uint16_t ret;
 
-        writew(0x0, NFC_V1_V2_BUF_ADDR);
+        writew(host->active_cs << 4, NFC_V1_V2_BUF_ADDR);
 
         /*
          * The device status is stored in main_area0. To
@@ -686,24 +691,24 @@ static void mxc_nand_select_chip(struct mtd_info *mtd, int chip)
         struct nand_chip *nand_chip = mtd->priv;
         struct mxc_nand_host *host = nand_chip->priv;
 
-        switch (chip) {
-        case -1:
+        if (chip == -1) {
                 /* Disable the NFC clock */
                 if (host->clk_act) {
                         clk_disable(host->clk);
                         host->clk_act = 0;
                 }
-                break;
-        case 0:
+                return;
+        }
+
+        if (!host->clk_act) {
                 /* Enable the NFC clock */
-                if (!host->clk_act) {
-                        clk_enable(host->clk);
-                        host->clk_act = 1;
-                }
-                break;
+                clk_enable(host->clk);
+                host->clk_act = 1;
+        }
 
-        default:
-                break;
+        if (nfc_is_v21()) {
+                host->active_cs = chip;
+                writew(host->active_cs << 4, NFC_V1_V2_BUF_ADDR);
         }
 }
 
@@ -834,8 +839,14 @@ static void preset_v1_v2(struct mtd_info *mtd)
 
         /* Blocks to be unlocked */
         if (nfc_is_v21()) {
-                writew(0x0, NFC_V21_UNLOCKSTART_BLKADDR);
-                writew(0xffff, NFC_V21_UNLOCKEND_BLKADDR);
+                writew(0x0, NFC_V21_UNLOCKSTART_BLKADDR0);
+                writew(0x0, NFC_V21_UNLOCKSTART_BLKADDR1);
+                writew(0x0, NFC_V21_UNLOCKSTART_BLKADDR2);
+                writew(0x0, NFC_V21_UNLOCKSTART_BLKADDR3);
+                writew(0xffff, NFC_V21_UNLOCKEND_BLKADDR0);
+                writew(0xffff, NFC_V21_UNLOCKEND_BLKADDR1);
+                writew(0xffff, NFC_V21_UNLOCKEND_BLKADDR2);
+                writew(0xffff, NFC_V21_UNLOCKEND_BLKADDR3);
         } else if (nfc_is_v1()) {
                 writew(0x0, NFC_V1_UNLOCKSTART_BLKADDR);
                 writew(0x4000, NFC_V1_UNLOCKEND_BLKADDR);
@@ -1200,7 +1211,7 @@ static int __init mxcnd_probe(struct platform_device *pdev)
                 irq_control_v1_v2(host, 1);
 
         /* first scan to find the device and get the page size */
-        if (nand_scan_ident(mtd, 1, NULL)) {
+        if (nand_scan_ident(mtd, nfc_is_v21() ? 4 : 1, NULL)) {
                 err = -ENXIO;
                 goto escan;
         }
@@ -1220,18 +1231,15 @@ static int __init mxcnd_probe(struct platform_device *pdev)
         }
 
         /* Register the partitions */
-#ifdef CONFIG_MTD_PARTITIONS
         nr_parts =
             parse_mtd_partitions(mtd, part_probes, &host->parts, 0);
         if (nr_parts > 0)
-                add_mtd_partitions(mtd, host->parts, nr_parts);
+                mtd_device_register(mtd, host->parts, nr_parts);
         else if (pdata->parts)
-                add_mtd_partitions(mtd, pdata->parts, pdata->nr_parts);
-        else
-#endif
-        {
+                mtd_device_register(mtd, pdata->parts, pdata->nr_parts);
+        else {
                 pr_info("Registering %s as whole device\n", mtd->name);
-                add_mtd_device(mtd);
+                mtd_device_register(mtd, NULL, 0);
         }
 
         platform_set_drvdata(pdev, host);
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index c54a4cbac6bc..a46e9bb847bd 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -47,10 +47,7 @@
 #include <linux/bitops.h>
 #include <linux/leds.h>
 #include <linux/io.h>
-
-#ifdef CONFIG_MTD_PARTITIONS
 #include <linux/mtd/partitions.h>
-#endif
 
 /* Define default oob placement schemes for large and small page devices */
 static struct nand_ecclayout nand_oob_8 = {
@@ -976,9 +973,6 @@ int nand_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
         ret = __nand_unlock(mtd, ofs, len, 0);
 
 out:
-        /* de-select the NAND device */
-        chip->select_chip(mtd, -1);
-
         nand_release_device(mtd);
 
         return ret;
@@ -1046,9 +1040,6 @@ int nand_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
         ret = __nand_unlock(mtd, ofs, len, 0x1);
 
 out:
-        /* de-select the NAND device */
-        chip->select_chip(mtd, -1);
-
         nand_release_device(mtd);
 
         return ret;
@@ -3112,6 +3103,8 @@ ident_done:
                 chip->chip_shift += 32 - 1;
         }
 
+        chip->badblockbits = 8;
+
         /* Set the bad block position */
         if (mtd->writesize > 512 || (busw & NAND_BUSWIDTH_16))
                 chip->badblockpos = NAND_LARGE_BADBLOCK_POS;
@@ -3539,12 +3532,7 @@ void nand_release(struct mtd_info *mtd)
         if (chip->ecc.mode == NAND_ECC_SOFT_BCH)
                 nand_bch_free((struct nand_bch_control *)chip->ecc.priv);
 
-#ifdef CONFIG_MTD_PARTITIONS
-        /* Deregister partitions */
-        del_mtd_partitions(mtd);
-#endif
-        /* Deregister the device */
-        del_mtd_device(mtd);
+        mtd_device_unregister(mtd);
 
         /* Free bad block table memory */
         kfree(chip->bbt);
diff --git a/drivers/mtd/nand/nand_bbt.c b/drivers/mtd/nand/nand_bbt.c
index af46428286fe..ccbeaa1e4a8e 100644
--- a/drivers/mtd/nand/nand_bbt.c
+++ b/drivers/mtd/nand/nand_bbt.c
@@ -1276,20 +1276,6 @@ int nand_update_bbt(struct mtd_info *mtd, loff_t offs)
  * while scanning a device for factory marked good / bad blocks. */
 static uint8_t scan_ff_pattern[] = { 0xff, 0xff };
 
-static struct nand_bbt_descr smallpage_flashbased = {
-        .options = NAND_BBT_SCAN2NDPAGE,
-        .offs = NAND_SMALL_BADBLOCK_POS,
-        .len = 1,
-        .pattern = scan_ff_pattern
-};
-
-static struct nand_bbt_descr largepage_flashbased = {
-        .options = NAND_BBT_SCAN2NDPAGE,
-        .offs = NAND_LARGE_BADBLOCK_POS,
-        .len = 2,
-        .pattern = scan_ff_pattern
-};
-
 static uint8_t scan_agand_pattern[] = { 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7 };
 
 static struct nand_bbt_descr agand_flashbased = {
@@ -1355,10 +1341,6 @@ static struct nand_bbt_descr bbt_mirror_no_bbt_descr = {
  * this->badblock_pattern. Thus, this->badblock_pattern should be NULL when
  * passed to this function.
  *
- * TODO: Handle other flags, replace other static structs
- *        (e.g. handle NAND_BBT_FLASH for flash-based BBT,
- *             replace smallpage_flashbased)
- *
  */
 static int nand_create_default_bbt_descr(struct nand_chip *this)
 {
@@ -1422,15 +1404,14 @@ int nand_default_bbt(struct mtd_info *mtd)
                                 this->bbt_md = &bbt_mirror_descr;
                         }
                 }
-                if (!this->badblock_pattern) {
-                        this->badblock_pattern = (mtd->writesize > 512) ? &largepage_flashbased : &smallpage_flashbased;
-                }
         } else {
                 this->bbt_td = NULL;
                 this->bbt_md = NULL;
-                if (!this->badblock_pattern)
-                        nand_create_default_bbt_descr(this);
         }
+
+        if (!this->badblock_pattern)
+                nand_create_default_bbt_descr(this);
+
         return nand_scan_bbt(mtd, this->badblock_pattern);
 }
 
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 893d95bfea48..357e8c5252a8 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -2383,7 +2383,9 @@ static int __init ns_init_module(void)
                 goto err_exit;
 
         /* Register NAND partitions */
-        if ((retval = add_mtd_partitions(nsmtd, &nand->partitions[0], nand->nbparts)) != 0)
+        retval = mtd_device_register(nsmtd, &nand->partitions[0],
+                                     nand->nbparts);
+        if (retval != 0)
                 goto err_exit;
 
         return 0;
diff --git a/drivers/mtd/nand/ndfc.c b/drivers/mtd/nand/ndfc.c
index bbe6d451290d..ea2dea8a9c88 100644
--- a/drivers/mtd/nand/ndfc.c
+++ b/drivers/mtd/nand/ndfc.c
@@ -33,6 +33,7 @@
 #include <linux/of_platform.h>
 #include <asm/io.h>
 
+#define NDFC_MAX_CS    4
 
 struct ndfc_controller {
         struct platform_device *ofdev;
@@ -41,17 +42,16 @@ struct ndfc_controller {
         struct nand_chip chip;
         int chip_select;
         struct nand_hw_control ndfc_control;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
-#endif
 };
 
-static struct ndfc_controller ndfc_ctrl;
+static struct ndfc_controller ndfc_ctrl[NDFC_MAX_CS];
 
 static void ndfc_select_chip(struct mtd_info *mtd, int chip)
 {
         uint32_t ccr;
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *nchip = mtd->priv;
+        struct ndfc_controller *ndfc = nchip->priv;
 
         ccr = in_be32(ndfc->ndfcbase + NDFC_CCR);
         if (chip >= 0) {
@@ -64,7 +64,8 @@ static void ndfc_select_chip(struct mtd_info *mtd, int chip)
 
 static void ndfc_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
 
         if (cmd == NAND_CMD_NONE)
                 return;
@@ -77,7 +78,8 @@ static void ndfc_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 
 static int ndfc_ready(struct mtd_info *mtd)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
 
         return in_be32(ndfc->ndfcbase + NDFC_STAT) & NDFC_STAT_IS_READY;
 }
@@ -85,7 +87,8 @@ static int ndfc_ready(struct mtd_info *mtd)
 static void ndfc_enable_hwecc(struct mtd_info *mtd, int mode)
 {
         uint32_t ccr;
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
 
         ccr = in_be32(ndfc->ndfcbase + NDFC_CCR);
         ccr |= NDFC_CCR_RESET_ECC;
@@ -96,7 +99,8 @@ static void ndfc_enable_hwecc(struct mtd_info *mtd, int mode)
 static int ndfc_calculate_ecc(struct mtd_info *mtd,
                               const u_char *dat, u_char *ecc_code)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
         uint32_t ecc;
         uint8_t *p = (uint8_t *)&ecc;
 
@@ -119,7 +123,8 @@ static int ndfc_calculate_ecc(struct mtd_info *mtd,
  */
 static void ndfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
         uint32_t *p = (uint32_t *) buf;
 
         for(;len > 0; len -= 4)
@@ -128,7 +133,8 @@ static void ndfc_read_buf(struct mtd_info *mtd, uint8_t *buf, int len)
 
 static void ndfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
         uint32_t *p = (uint32_t *) buf;
 
         for(;len > 0; len -= 4)
@@ -137,7 +143,8 @@ static void ndfc_write_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 
 static int ndfc_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct nand_chip *chip = mtd->priv;
+        struct ndfc_controller *ndfc = chip->priv;
         uint32_t *p = (uint32_t *) buf;
 
         for(;len > 0; len -= 4)
@@ -152,13 +159,11 @@ static int ndfc_verify_buf(struct mtd_info *mtd, const uint8_t *buf, int len)
 static int ndfc_chip_init(struct ndfc_controller *ndfc,
                           struct device_node *node)
 {
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         static const char *part_types[] = { "cmdlinepart", NULL };
 #else
         static const char *part_types[] = { NULL };
 #endif
-#endif
         struct device_node *flash_np;
         struct nand_chip *chip = &ndfc->chip;
         int ret;
@@ -179,6 +184,7 @@ static int ndfc_chip_init(struct ndfc_controller *ndfc,
         chip->ecc.mode = NAND_ECC_HW;
         chip->ecc.size = 256;
         chip->ecc.bytes = 3;
+        chip->priv = ndfc;
 
         ndfc->mtd.priv = chip;
         ndfc->mtd.owner = THIS_MODULE;
@@ -198,25 +204,18 @@ static int ndfc_chip_init(struct ndfc_controller *ndfc,
         if (ret)
                 goto err;
 
-#ifdef CONFIG_MTD_PARTITIONS
         ret = parse_mtd_partitions(&ndfc->mtd, part_types, &ndfc->parts, 0);
         if (ret < 0)
                 goto err;
 
-#ifdef CONFIG_MTD_OF_PARTS
         if (ret == 0) {
                 ret = of_mtd_parse_partitions(&ndfc->ofdev->dev, flash_np,
                                               &ndfc->parts);
                 if (ret < 0)
                         goto err;
         }
-#endif
 
-        if (ret > 0)
-                ret = add_mtd_partitions(&ndfc->mtd, ndfc->parts, ret);
-        else
-#endif
-                ret = add_mtd_device(&ndfc->mtd);
+        ret = mtd_device_register(&ndfc->mtd, ndfc->parts, ret);
 
 err:
         of_node_put(flash_np);
@@ -227,15 +226,10 @@ err:
 
 static int __devinit ndfc_probe(struct platform_device *ofdev)
 {
-        struct ndfc_controller *ndfc = &ndfc_ctrl;
+        struct ndfc_controller *ndfc;
         const __be32 *reg;
         u32 ccr;
-        int err, len;
-
-        spin_lock_init(&ndfc->ndfc_control.lock);
-        init_waitqueue_head(&ndfc->ndfc_control.wq);
-        ndfc->ofdev = ofdev;
-        dev_set_drvdata(&ofdev->dev, ndfc);
+        int err, len, cs;
 
         /* Read the reg property to get the chip select */
         reg = of_get_property(ofdev->dev.of_node, "reg", &len);
@@ -243,7 +237,20 @@ static int __devinit ndfc_probe(struct platform_device *ofdev)
                 dev_err(&ofdev->dev, "unable read reg property (%d)\n", len);
                 return -ENOENT;
         }
-        ndfc->chip_select = be32_to_cpu(reg[0]);
+
+        cs = be32_to_cpu(reg[0]);
+        if (cs >= NDFC_MAX_CS) {
+                dev_err(&ofdev->dev, "invalid CS number (%d)\n", cs);
+                return -EINVAL;
+        }
+
+        ndfc = &ndfc_ctrl[cs];
+        ndfc->chip_select = cs;
+
+        spin_lock_init(&ndfc->ndfc_control.lock);
+        init_waitqueue_head(&ndfc->ndfc_control.wq);
+        ndfc->ofdev = ofdev;
+        dev_set_drvdata(&ofdev->dev, ndfc);
 
         ndfc->ndfcbase = of_iomap(ofdev->dev.of_node, 0);
         if (!ndfc->ndfcbase) {
diff --git a/drivers/mtd/nand/nomadik_nand.c b/drivers/mtd/nand/nomadik_nand.c
index a045a4a581b6..b6a5c86ab31e 100644
--- a/drivers/mtd/nand/nomadik_nand.c
+++ b/drivers/mtd/nand/nomadik_nand.c
@@ -158,12 +158,7 @@ static int nomadik_nand_probe(struct platform_device *pdev)
                 goto err_unmap;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
-        add_mtd_partitions(&host->mtd, pdata->parts, pdata->nparts);
-#else
-        pr_info("Registering %s as whole device\n", mtd->name);
-        add_mtd_device(mtd);
-#endif
+        mtd_device_register(&host->mtd, pdata->parts, pdata->nparts);
 
         platform_set_drvdata(pdev, host);
         return 0;
diff --git a/drivers/mtd/nand/nuc900_nand.c b/drivers/mtd/nand/nuc900_nand.c
index 6eddf7361ed7..9c30a0b03171 100644
--- a/drivers/mtd/nand/nuc900_nand.c
+++ b/drivers/mtd/nand/nuc900_nand.c
@@ -321,8 +321,8 @@ static int __devinit nuc900_nand_probe(struct platform_device *pdev)
                 goto fail3;
         }
 
-        add_mtd_partitions(&(nuc900_nand->mtd), partitions,
-                                                ARRAY_SIZE(partitions));
+        mtd_device_register(&(nuc900_nand->mtd), partitions,
+                            ARRAY_SIZE(partitions));
 
         platform_set_drvdata(pdev, nuc900_nand);
 
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index da9a351c9d79..0db2c0e7656a 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -94,9 +94,7 @@
 #define P4e_s(a)        (TF(a & NAND_Ecc_P4e)           << 0)
 #define P4o_s(a)        (TF(a & NAND_Ecc_P4o)           << 1)
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
 /* oob info generated runtime depending on ecc algorithm and layout selected */
 static struct nand_ecclayout omap_oobinfo;
@@ -263,11 +261,10 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
         if (ret) {
                 /* PFPW engine is busy, use cpu copy method */
                 if (info->nand.options & NAND_BUSWIDTH_16)
-                        omap_read_buf16(mtd, buf, len);
+                        omap_read_buf16(mtd, (u_char *)p, len);
                 else
-                        omap_read_buf8(mtd, buf, len);
+                        omap_read_buf8(mtd, (u_char *)p, len);
         } else {
-                p = (u32 *) buf;
                 do {
                         r_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
                         r_count = r_count >> 2;
@@ -293,7 +290,7 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
                                                 struct omap_nand_info, mtd);
         uint32_t w_count = 0;
         int i = 0, ret = 0;
-        u16 *p;
+        u16 *p = (u16 *)buf;
         unsigned long tim, limit;
 
         /* take care of subpage writes */
@@ -309,11 +306,10 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
         if (ret) {
                 /* PFPW engine is busy, use cpu copy method */
                 if (info->nand.options & NAND_BUSWIDTH_16)
-                        omap_write_buf16(mtd, buf, len);
+                        omap_write_buf16(mtd, (u_char *)p, len);
                 else
-                        omap_write_buf8(mtd, buf, len);
+                        omap_write_buf8(mtd, (u_char *)p, len);
         } else {
-                p = (u16 *) buf;
                 while (len) {
                         w_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
                         w_count = w_count >> 1;
@@ -1073,9 +1069,9 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
         /* DIP switches on some boards change between 8 and 16 bit
          * bus widths for flash.  Try the other width if the first try fails.
          */
-        if (nand_scan(&info->mtd, 1)) {
+        if (nand_scan_ident(&info->mtd, 1, NULL)) {
                 info->nand.options ^= NAND_BUSWIDTH_16;
-                if (nand_scan(&info->mtd, 1)) {
+                if (nand_scan_ident(&info->mtd, 1, NULL)) {
                         err = -ENXIO;
                         goto out_release_mem_region;
                 }
@@ -1101,15 +1097,19 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
                 info->nand.ecc.layout = &omap_oobinfo;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
+        /* second phase scan */
+        if (nand_scan_tail(&info->mtd)) {
+                err = -ENXIO;
+                goto out_release_mem_region;
+        }
+
         err = parse_mtd_partitions(&info->mtd, part_probes, &info->parts, 0);
         if (err > 0)
-                add_mtd_partitions(&info->mtd, info->parts, err);
+                mtd_device_register(&info->mtd, info->parts, err);
         else if (pdata->parts)
-                add_mtd_partitions(&info->mtd, pdata->parts, pdata->nr_parts);
+                mtd_device_register(&info->mtd, pdata->parts, pdata->nr_parts);
         else
-#endif
-                add_mtd_device(&info->mtd);
+                mtd_device_register(&info->mtd, NULL, 0);
 
         platform_set_drvdata(pdev, &info->mtd);
 
diff --git a/drivers/mtd/nand/orion_nand.c b/drivers/mtd/nand/orion_nand.c
index da6e75343052..7794d0680f91 100644
--- a/drivers/mtd/nand/orion_nand.c
+++ b/drivers/mtd/nand/orion_nand.c
@@ -21,9 +21,7 @@
 #include <mach/hardware.h>
 #include <plat/orion_nand.h>
 
-#ifdef CONFIG_MTD_CMDLINE_PARTS
 static const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
 static void orion_nand_cmd_ctrl(struct mtd_info *mtd, int cmd, unsigned int ctrl)
 {
@@ -83,10 +81,8 @@ static int __init orion_nand_probe(struct platform_device *pdev)
         struct resource *res;
         void __iomem *io_base;
         int ret = 0;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *partitions = NULL;
         int num_part = 0;
-#endif
 
         nc = kzalloc(sizeof(struct nand_chip) + sizeof(struct mtd_info), GFP_KERNEL);
         if (!nc) {
@@ -136,7 +132,6 @@ static int __init orion_nand_probe(struct platform_device *pdev)
                 goto no_dev;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         mtd->name = "orion_nand";
         num_part = parse_mtd_partitions(mtd, part_probes, &partitions, 0);
@@ -147,14 +142,7 @@ static int __init orion_nand_probe(struct platform_device *pdev)
                 partitions = board->parts;
         }
 
-        if (partitions && num_part > 0)
-                ret = add_mtd_partitions(mtd, partitions, num_part);
-        else
-                ret = add_mtd_device(mtd);
-#else
-        ret = add_mtd_device(mtd);
-#endif
-
+        ret = mtd_device_register(mtd, partitions, num_part);
         if (ret) {
                 nand_release(mtd);
                 goto no_dev;
diff --git a/drivers/mtd/nand/pasemi_nand.c b/drivers/mtd/nand/pasemi_nand.c
index 20bfe5f15afd..b1aa41b8a4eb 100644
--- a/drivers/mtd/nand/pasemi_nand.c
+++ b/drivers/mtd/nand/pasemi_nand.c
@@ -163,7 +163,7 @@ static int __devinit pasemi_nand_probe(struct platform_device *ofdev)
                 goto out_lpc;
         }
 
-        if (add_mtd_device(pasemi_nand_mtd)) {
+        if (mtd_device_register(pasemi_nand_mtd, NULL, 0)) {
                 printk(KERN_ERR "pasemi_nand: Unable to register MTD device\n");
                 err = -ENODEV;
                 goto out_lpc;
diff --git a/drivers/mtd/nand/plat_nand.c b/drivers/mtd/nand/plat_nand.c
index caf5a736340a..633c04bf76f6 100644
--- a/drivers/mtd/nand/plat_nand.c
+++ b/drivers/mtd/nand/plat_nand.c
@@ -21,10 +21,8 @@ struct plat_nand_data {
         struct nand_chip        chip;
         struct mtd_info         mtd;
         void __iomem            *io_base;
-#ifdef CONFIG_MTD_PARTITIONS
         int                     nr_parts;
         struct mtd_partition    *parts;
-#endif
 };
 
 /*
@@ -101,13 +99,12 @@ static int __devinit plat_nand_probe(struct platform_device *pdev)
                 goto out;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
         if (pdata->chip.part_probe_types) {
                 err = parse_mtd_partitions(&data->mtd,
                                         pdata->chip.part_probe_types,
                                         &data->parts, 0);
                 if (err > 0) {
-                        add_mtd_partitions(&data->mtd, data->parts, err);
+                        mtd_device_register(&data->mtd, data->parts, err);
                         return 0;
                 }
         }
@@ -115,11 +112,10 @@ static int __devinit plat_nand_probe(struct platform_device *pdev)
                 pdata->chip.set_parts(data->mtd.size, &pdata->chip);
         if (pdata->chip.partitions) {
                 data->parts = pdata->chip.partitions;
-                err = add_mtd_partitions(&data->mtd, data->parts,
+                err = mtd_device_register(&data->mtd, data->parts,
                         pdata->chip.nr_partitions);
         } else
-#endif
-        err = add_mtd_device(&data->mtd);
+                err = mtd_device_register(&data->mtd, NULL, 0);
 
         if (!err)
                 return err;
@@ -149,10 +145,8 @@ static int __devexit plat_nand_remove(struct platform_device *pdev)
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
         nand_release(&data->mtd);
-#ifdef CONFIG_MTD_PARTITIONS
         if (data->parts && data->parts != pdata->chip.partitions)
                 kfree(data->parts);
-#endif
         if (pdata->ctrl.remove)
                 pdata->ctrl.remove(pdev);
         iounmap(data->io_base);
diff --git a/drivers/mtd/nand/ppchameleonevb.c b/drivers/mtd/nand/ppchameleonevb.c
index cc8658431851..3bbb796b451c 100644
--- a/drivers/mtd/nand/ppchameleonevb.c
+++ b/drivers/mtd/nand/ppchameleonevb.c
@@ -73,7 +73,6 @@ __setup("ppchameleon_fio_pbase=", ppchameleon_fio_pbase);
 __setup("ppchameleonevb_fio_pbase=", ppchameleonevb_fio_pbase);
 #endif
 
-#ifdef CONFIG_MTD_PARTITIONS
 /*
  * Define static partitions for flash devices
  */
@@ -101,7 +100,6 @@ static struct mtd_partition partition_info_evb[] = {
 #define NUM_PARTITIONS 1
 
 extern int parse_cmdline_partitions(struct mtd_info *master, struct mtd_partition **pparts, const char *mtd_id);
-#endif
 
 /*
  *      hardware specific access to control-lines
@@ -189,10 +187,8 @@ static int ppchameleonevb_device_ready(struct mtd_info *minfo)
 }
 #endif
 
-#ifdef CONFIG_MTD_PARTITIONS
 const char *part_probes[] = { "cmdlinepart", NULL };
 const char *part_probes_evb[] = { "cmdlinepart", NULL };
-#endif
 
 /*
  * Main initialization routine
@@ -284,14 +280,13 @@ static int __init ppchameleonevb_init(void)
                 this->chip_delay = NAND_SMALL_DELAY_US;
 #endif
 
-#ifdef CONFIG_MTD_PARTITIONS
         ppchameleon_mtd->name = "ppchameleon-nand";
         mtd_parts_nb = parse_mtd_partitions(ppchameleon_mtd, part_probes, &mtd_parts, 0);
         if (mtd_parts_nb > 0)
                 part_type = "command line";
         else
                 mtd_parts_nb = 0;
-#endif
+
         if (mtd_parts_nb == 0) {
                 if (ppchameleon_mtd->size == NAND_SMALL_SIZE)
                         mtd_parts = partition_info_me;
@@ -303,7 +298,7 @@ static int __init ppchameleonevb_init(void)
 
         /* Register the partitions */
         printk(KERN_NOTICE "Using %s partition definition\n", part_type);
-        add_mtd_partitions(ppchameleon_mtd, mtd_parts, mtd_parts_nb);
+        mtd_device_register(ppchameleon_mtd, mtd_parts, mtd_parts_nb);
 
  nand_evb_init:
         /****************************
@@ -385,14 +380,14 @@ static int __init ppchameleonevb_init(void)
                         iounmap(ppchameleon_fio_base);
                 return -ENXIO;
         }
-#ifdef CONFIG_MTD_PARTITIONS
+
         ppchameleonevb_mtd->name = NAND_EVB_MTD_NAME;
         mtd_parts_nb = parse_mtd_partitions(ppchameleonevb_mtd, part_probes_evb, &mtd_parts, 0);
         if (mtd_parts_nb > 0)
                 part_type = "command line";
         else
                 mtd_parts_nb = 0;
-#endif
+
         if (mtd_parts_nb == 0) {
                 mtd_parts = partition_info_evb;
                 mtd_parts_nb = NUM_PARTITIONS;
@@ -401,7 +396,7 @@ static int __init ppchameleonevb_init(void)
 
         /* Register the partitions */
         printk(KERN_NOTICE "Using %s partition definition\n", part_type);
-        add_mtd_partitions(ppchameleonevb_mtd, mtd_parts, mtd_parts_nb);
+        mtd_device_register(ppchameleonevb_mtd, mtd_parts, mtd_parts_nb);
 
         /* Return happy */
         return 0;
diff --git a/drivers/mtd/nand/pxa3xx_nand.c b/drivers/mtd/nand/pxa3xx_nand.c
index ff0701276d65..1fb3b3a80581 100644
--- a/drivers/mtd/nand/pxa3xx_nand.c
+++ b/drivers/mtd/nand/pxa3xx_nand.c
@@ -1119,10 +1119,7 @@ static int pxa3xx_nand_remove(struct platform_device *pdev)
         clk_put(info->clk);
 
         if (mtd) {
-                del_mtd_device(mtd);
-#ifdef CONFIG_MTD_PARTITIONS
-                del_mtd_partitions(mtd);
-#endif
+                mtd_device_unregister(mtd);
                 kfree(mtd);
         }
         return 0;
@@ -1149,7 +1146,6 @@ static int pxa3xx_nand_probe(struct platform_device *pdev)
                 return -ENODEV;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
         if (mtd_has_cmdlinepart()) {
                 const char *probes[] = { "cmdlinepart", NULL };
                 struct mtd_partition *parts;
@@ -1158,13 +1154,10 @@ static int pxa3xx_nand_probe(struct platform_device *pdev)
                 nr_parts = parse_mtd_partitions(info->mtd, probes, &parts, 0);
 
                 if (nr_parts)
-                        return add_mtd_partitions(info->mtd, parts, nr_parts);
+                        return mtd_device_register(info->mtd, parts, nr_parts);
         }
 
-        return add_mtd_partitions(info->mtd, pdata->parts, pdata->nr_parts);
-#else
-        return 0;
-#endif
+        return mtd_device_register(info->mtd, pdata->parts, pdata->nr_parts);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/mtd/nand/rtc_from4.c b/drivers/mtd/nand/rtc_from4.c
index 67440b5beef8..c9f9127ff770 100644
--- a/drivers/mtd/nand/rtc_from4.c
+++ b/drivers/mtd/nand/rtc_from4.c
@@ -580,7 +580,8 @@ static int __init rtc_from4_init(void)
 #endif
 
         /* Register the partitions */
-        ret = add_mtd_partitions(rtc_from4_mtd, partition_info, NUM_PARTITIONS);
+        ret = mtd_device_register(rtc_from4_mtd, partition_info,
+                                  NUM_PARTITIONS);
         if (ret)
                 goto err_3;
 
diff --git a/drivers/mtd/nand/s3c2410.c b/drivers/mtd/nand/s3c2410.c
index 33d832dddfdd..4405468f196b 100644
--- a/drivers/mtd/nand/s3c2410.c
+++ b/drivers/mtd/nand/s3c2410.c
@@ -55,7 +55,7 @@ static int hardware_ecc = 0;
 #endif
 
 #ifdef CONFIG_MTD_NAND_S3C2410_CLKSTOP
-static int clock_stop = 1;
+static const int clock_stop = 1;
 #else
 static const int clock_stop = 0;
 #endif
@@ -96,6 +96,12 @@ enum s3c_cpu_type {
         TYPE_S3C2440,
 };
 
+enum s3c_nand_clk_state {
+        CLOCK_DISABLE   = 0,
+        CLOCK_ENABLE,
+        CLOCK_SUSPEND,
+};
+
 /* overview of the s3c2410 nand state */
 
 /**
@@ -111,6 +117,7 @@ enum s3c_cpu_type {
  * @mtd_count: The number of MTDs created from this controller.
  * @save_sel: The contents of @sel_reg to be saved over suspend.
  * @clk_rate: The clock rate from @clk.
+ * @clk_state: The current clock state.
  * @cpu_type: The exact type of this controller.
  */
 struct s3c2410_nand_info {
@@ -129,6 +136,7 @@ struct s3c2410_nand_info {
         int                             mtd_count;
         unsigned long                   save_sel;
         unsigned long                   clk_rate;
+        enum s3c_nand_clk_state         clk_state;
 
         enum s3c_cpu_type               cpu_type;
 
@@ -159,11 +167,33 @@ static struct s3c2410_platform_nand *to_nand_plat(struct platform_device *dev)
         return dev->dev.platform_data;
 }
 
-static inline int allow_clk_stop(struct s3c2410_nand_info *info)
+static inline int allow_clk_suspend(struct s3c2410_nand_info *info)
 {
         return clock_stop;
 }
 
+/**
+ * s3c2410_nand_clk_set_state - Enable, disable or suspend NAND clock.
+ * @info: The controller instance.
+ * @new_state: State to which clock should be set.
+ */
+static void s3c2410_nand_clk_set_state(struct s3c2410_nand_info *info,
+                enum s3c_nand_clk_state new_state)
+{
+        if (!allow_clk_suspend(info) && new_state == CLOCK_SUSPEND)
+                return;
+
+        if (info->clk_state == CLOCK_ENABLE) {
+                if (new_state != CLOCK_ENABLE)
+                        clk_disable(info->clk);
+        } else {
+                if (new_state == CLOCK_ENABLE)
+                        clk_enable(info->clk);
+        }
+
+        info->clk_state = new_state;
+}
+
 /* timing calculations */
 
 #define NS_IN_KHZ 1000000
@@ -333,8 +363,8 @@ static void s3c2410_nand_select_chip(struct mtd_info *mtd, int chip)
         nmtd = this->priv;
         info = nmtd->info;
 
-        if (chip != -1 && allow_clk_stop(info))
-                clk_enable(info->clk);
+        if (chip != -1)
+                s3c2410_nand_clk_set_state(info, CLOCK_ENABLE);
 
         cur = readl(info->sel_reg);
 
@@ -356,8 +386,8 @@ static void s3c2410_nand_select_chip(struct mtd_info *mtd, int chip)
 
         writel(cur, info->sel_reg);
 
-        if (chip == -1 && allow_clk_stop(info))
-                clk_disable(info->clk);
+        if (chip == -1)
+                s3c2410_nand_clk_set_state(info, CLOCK_SUSPEND);
 }
 
 /* s3c2410_nand_hwcontrol
@@ -694,8 +724,7 @@ static int s3c24xx_nand_remove(struct platform_device *pdev)
         /* free the common resources */
 
         if (info->clk != NULL && !IS_ERR(info->clk)) {
-                if (!allow_clk_stop(info))
-                        clk_disable(info->clk);
+                s3c2410_nand_clk_set_state(info, CLOCK_DISABLE);
                 clk_put(info->clk);
         }
 
@@ -715,7 +744,6 @@ static int s3c24xx_nand_remove(struct platform_device *pdev)
         return 0;
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 const char *part_probes[] = { "cmdlinepart", NULL };
 static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,
                                       struct s3c2410_nand_mtd *mtd,
@@ -725,7 +753,7 @@ static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,
         int nr_part = 0;
 
         if (set == NULL)
-                return add_mtd_device(&mtd->mtd);
+                return mtd_device_register(&mtd->mtd, NULL, 0);
 
         mtd->mtd.name = set->name;
         nr_part = parse_mtd_partitions(&mtd->mtd, part_probes, &part_info, 0);
@@ -735,19 +763,8 @@ static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,
                 part_info = set->partitions;
         }
 
-        if (nr_part > 0 && part_info)
-                return add_mtd_partitions(&mtd->mtd, part_info, nr_part);
-
-        return add_mtd_device(&mtd->mtd);
-}
-#else
-static int s3c2410_nand_add_partition(struct s3c2410_nand_info *info,
-                                      struct s3c2410_nand_mtd *mtd,
-                                      struct s3c2410_nand_set *set)
-{
-        return add_mtd_device(&mtd->mtd);
+        return mtd_device_register(&mtd->mtd, part_info, nr_part);
 }
-#endif
 
 /**
  * s3c2410_nand_init_chip - initialise a single instance of an chip
@@ -947,7 +964,7 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
                 goto exit_error;
         }
 
-        clk_enable(info->clk);
+        s3c2410_nand_clk_set_state(info, CLOCK_ENABLE);
 
         /* allocate and map the resource */
 
@@ -1026,9 +1043,9 @@ static int s3c24xx_nand_probe(struct platform_device *pdev)
                 goto exit_error;
         }
 
-        if (allow_clk_stop(info)) {
+        if (allow_clk_suspend(info)) {
                 dev_info(&pdev->dev, "clock idle support enabled\n");
-                clk_disable(info->clk);
+                s3c2410_nand_clk_set_state(info, CLOCK_SUSPEND);
         }
 
         pr_debug("initialised ok\n");
@@ -1059,8 +1076,7 @@ static int s3c24xx_nand_suspend(struct platform_device *dev, pm_message_t pm)
 
                 writel(info->save_sel | info->sel_bit, info->sel_reg);
 
-                if (!allow_clk_stop(info))
-                        clk_disable(info->clk);
+                s3c2410_nand_clk_set_state(info, CLOCK_DISABLE);
         }
 
         return 0;
@@ -1072,7 +1088,7 @@ static int s3c24xx_nand_resume(struct platform_device *dev)
         unsigned long sel;
 
         if (info) {
-                clk_enable(info->clk);
+                s3c2410_nand_clk_set_state(info, CLOCK_ENABLE);
                 s3c2410_nand_inithw(info);
 
                 /* Restore the state of the nFCE line. */
@@ -1082,8 +1098,7 @@ static int s3c24xx_nand_resume(struct platform_device *dev)
                 sel |= info->save_sel & info->sel_bit;
                 writel(sel, info->sel_reg);
 
-                if (allow_clk_stop(info))
-                        clk_disable(info->clk);
+                s3c2410_nand_clk_set_state(info, CLOCK_SUSPEND);
         }
 
         return 0;
diff --git a/drivers/mtd/nand/sh_flctl.c b/drivers/mtd/nand/sh_flctl.c
index 81bbb5ee148d..93b1f74321c2 100644
--- a/drivers/mtd/nand/sh_flctl.c
+++ b/drivers/mtd/nand/sh_flctl.c
@@ -867,7 +867,7 @@ static int __devinit flctl_probe(struct platform_device *pdev)
         if (ret)
                 goto err;
 
-        add_mtd_partitions(flctl_mtd, pdata->parts, pdata->nr_parts);
+        mtd_device_register(flctl_mtd, pdata->parts, pdata->nr_parts);
 
         return 0;
 
diff --git a/drivers/mtd/nand/sharpsl.c b/drivers/mtd/nand/sharpsl.c
index 54ec7542a7b7..19e24ed089ea 100644
--- a/drivers/mtd/nand/sharpsl.c
+++ b/drivers/mtd/nand/sharpsl.c
@@ -103,9 +103,7 @@ static int sharpsl_nand_calculate_ecc(struct mtd_info *mtd, const u_char * dat,
         return readb(sharpsl->io + ECCCNTR) != 0;
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
 /*
  * Main initialization routine
@@ -113,10 +111,8 @@ static const char *part_probes[] = { "cmdlinepart", NULL };
 static int __devinit sharpsl_nand_probe(struct platform_device *pdev)
 {
         struct nand_chip *this;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *sharpsl_partition_info;
         int nr_partitions;
-#endif
         struct resource *r;
         int err = 0;
         struct sharpsl_nand *sharpsl;
@@ -188,18 +184,14 @@ static int __devinit sharpsl_nand_probe(struct platform_device *pdev)
 
         /* Register the partitions */
         sharpsl->mtd.name = "sharpsl-nand";
-#ifdef CONFIG_MTD_PARTITIONS
         nr_partitions = parse_mtd_partitions(&sharpsl->mtd, part_probes, &sharpsl_partition_info, 0);
         if (nr_partitions <= 0) {
                 nr_partitions = data->nr_partitions;
                 sharpsl_partition_info = data->partitions;
         }
 
-        if (nr_partitions > 0)
-                err = add_mtd_partitions(&sharpsl->mtd, sharpsl_partition_info, nr_partitions);
-        else
-#endif
-        err = add_mtd_device(&sharpsl->mtd);
+        err = mtd_device_register(&sharpsl->mtd, sharpsl_partition_info,
+                                  nr_partitions);
         if (err)
                 goto err_add;
 
diff --git a/drivers/mtd/nand/sm_common.c b/drivers/mtd/nand/sm_common.c
index 57cc80cd01a3..b6332e83b289 100644
--- a/drivers/mtd/nand/sm_common.c
+++ b/drivers/mtd/nand/sm_common.c
@@ -139,7 +139,7 @@ int sm_register_device(struct mtd_info *mtd, int smartmedia)
         if (ret)
                 return ret;
 
-        return add_mtd_device(mtd);
+        return mtd_device_register(mtd, NULL, 0);
 }
 EXPORT_SYMBOL_GPL(sm_register_device);
 
diff --git a/drivers/mtd/nand/socrates_nand.c b/drivers/mtd/nand/socrates_nand.c
index a853548986f0..ca2d0555729e 100644
--- a/drivers/mtd/nand/socrates_nand.c
+++ b/drivers/mtd/nand/socrates_nand.c
@@ -155,9 +155,7 @@ static int socrates_nand_device_ready(struct mtd_info *mtd)
         return 1;
 }
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL };
-#endif
 
 /*
  * Probe for the NAND device.
@@ -168,11 +166,8 @@ static int __devinit socrates_nand_probe(struct platform_device *ofdev)
         struct mtd_info *mtd;
         struct nand_chip *nand_chip;
         int res;
-
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *partitions = NULL;
         int num_partitions = 0;
-#endif
 
         /* Allocate memory for the device structure (and zero it) */
         host = kzalloc(sizeof(struct socrates_nand_host), GFP_KERNEL);
@@ -230,7 +225,6 @@ static int __devinit socrates_nand_probe(struct platform_device *ofdev)
                 goto out;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         num_partitions = parse_mtd_partitions(mtd, part_probes,
                                               &partitions, 0);
@@ -240,7 +234,6 @@ static int __devinit socrates_nand_probe(struct platform_device *ofdev)
         }
 #endif
 
-#ifdef CONFIG_MTD_OF_PARTS
         if (num_partitions == 0) {
                 num_partitions = of_mtd_parse_partitions(&ofdev->dev,
                                                          ofdev->dev.of_node,
@@ -250,19 +243,12 @@ static int __devinit socrates_nand_probe(struct platform_device *ofdev)
                         goto release;
                 }
         }
-#endif
-        if (partitions && (num_partitions > 0))
-                res = add_mtd_partitions(mtd, partitions, num_partitions);
-        else
-#endif
-                res = add_mtd_device(mtd);
 
+        res = mtd_device_register(mtd, partitions, num_partitions);
         if (!res)
                 return res;
 
-#ifdef CONFIG_MTD_PARTITIONS
 release:
-#endif
         nand_release(mtd);
 
 out:
diff --git a/drivers/mtd/nand/spia.c b/drivers/mtd/nand/spia.c
index 0cc6d0acb8fe..bef76cd7c24c 100644
--- a/drivers/mtd/nand/spia.c
+++ b/drivers/mtd/nand/spia.c
@@ -149,7 +149,7 @@ static int __init spia_init(void)
         }
 
         /* Register the partitions */
-        add_mtd_partitions(spia_mtd, partition_info, NUM_PARTITIONS);
+        mtd_device_register(spia_mtd, partition_info, NUM_PARTITIONS);
 
         /* Return happy */
         return 0;
diff --git a/drivers/mtd/nand/tmio_nand.c b/drivers/mtd/nand/tmio_nand.c
index c004e474631b..11e8371b5683 100644
--- a/drivers/mtd/nand/tmio_nand.c
+++ b/drivers/mtd/nand/tmio_nand.c
@@ -381,10 +381,8 @@ static int tmio_probe(struct platform_device *dev)
         struct tmio_nand *tmio;
         struct mtd_info *mtd;
         struct nand_chip *nand_chip;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
         int nbparts = 0;
-#endif
         int retval;
 
         if (data == NULL)
@@ -463,7 +461,6 @@ static int tmio_probe(struct platform_device *dev)
                 goto err_scan;
         }
         /* Register the partitions */
-#ifdef CONFIG_MTD_PARTITIONS
 #ifdef CONFIG_MTD_CMDLINE_PARTS
         nbparts = parse_mtd_partitions(mtd, part_probes, &parts, 0);
 #endif
@@ -472,12 +469,7 @@ static int tmio_probe(struct platform_device *dev)
                 nbparts = data->num_partitions;
         }
 
-        if (nbparts)
-                retval = add_mtd_partitions(mtd, parts, nbparts);
-        else
-#endif
-        retval = add_mtd_device(mtd);
-
+        retval = mtd_device_register(mtd, parts, nbparts);
         if (!retval)
                 return retval;
 
diff --git a/drivers/mtd/nand/txx9ndfmc.c b/drivers/mtd/nand/txx9ndfmc.c
index ca270a4881a4..bfba4e39a6c5 100644
--- a/drivers/mtd/nand/txx9ndfmc.c
+++ b/drivers/mtd/nand/txx9ndfmc.c
@@ -74,9 +74,7 @@ struct txx9ndfmc_drvdata {
         unsigned char hold;     /* in gbusclock */
         unsigned char spw;      /* in gbusclock */
         struct nand_hw_control hw_control;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts[MAX_TXX9NDFMC_DEV];
-#endif
 };
 
 static struct platform_device *mtd_to_platdev(struct mtd_info *mtd)
@@ -289,9 +287,7 @@ static int txx9ndfmc_nand_scan(struct mtd_info *mtd)
 static int __init txx9ndfmc_probe(struct platform_device *dev)
 {
         struct txx9ndfmc_platform_data *plat = dev->dev.platform_data;
-#ifdef CONFIG_MTD_PARTITIONS
         static const char *probes[] = { "cmdlinepart", NULL };
-#endif
         int hold, spw;
         int i;
         struct txx9ndfmc_drvdata *drvdata;
@@ -337,9 +333,7 @@ static int __init txx9ndfmc_probe(struct platform_device *dev)
                 struct txx9ndfmc_priv *txx9_priv;
                 struct nand_chip *chip;
                 struct mtd_info *mtd;
-#ifdef CONFIG_MTD_PARTITIONS
                 int nr_parts;
-#endif
 
                 if (!(plat->ch_mask & (1 << i)))
                         continue;
@@ -399,13 +393,9 @@ static int __init txx9ndfmc_probe(struct platform_device *dev)
                 }
                 mtd->name = txx9_priv->mtdname;
 
-#ifdef CONFIG_MTD_PARTITIONS
                 nr_parts = parse_mtd_partitions(mtd, probes,
                                                 &drvdata->parts[i], 0);
-                if (nr_parts > 0)
-                        add_mtd_partitions(mtd, drvdata->parts[i], nr_parts);
-#endif
-                add_mtd_device(mtd);
+                mtd_device_register(mtd, drvdata->parts[i], nr_parts);
                 drvdata->mtds[i] = mtd;
         }
 
@@ -431,9 +421,7 @@ static int __exit txx9ndfmc_remove(struct platform_device *dev)
                 txx9_priv = chip->priv;
 
                 nand_release(mtd);
-#ifdef CONFIG_MTD_PARTITIONS
                 kfree(drvdata->parts[i]);
-#endif
                 kfree(txx9_priv->mtdname);
                 kfree(txx9_priv);
         }
diff --git a/drivers/mtd/onenand/Kconfig b/drivers/mtd/onenand/Kconfig
index 4f426195f8db..772ad2966619 100644
--- a/drivers/mtd/onenand/Kconfig
+++ b/drivers/mtd/onenand/Kconfig
@@ -1,7 +1,6 @@
 menuconfig MTD_ONENAND
         tristate "OneNAND Device Support"
         depends on MTD
-        select MTD_PARTITIONS
         help
           This enables support for accessing all type of OneNAND flash
           devices. For further information see
diff --git a/drivers/mtd/onenand/generic.c b/drivers/mtd/onenand/generic.c
index ac08750748a3..2d70d354d846 100644
--- a/drivers/mtd/onenand/generic.c
+++ b/drivers/mtd/onenand/generic.c
@@ -30,9 +30,7 @@
  */
 #define DRIVER_NAME     "onenand-flash"
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL,  };
-#endif
 
 struct onenand_info {
         struct mtd_info         mtd;
@@ -75,15 +73,13 @@ static int __devinit generic_onenand_probe(struct platform_device *pdev)
                 goto out_iounmap;
         }
 
-#ifdef CONFIG_MTD_PARTITIONS
         err = parse_mtd_partitions(&info->mtd, part_probes, &info->parts, 0);
         if (err > 0)
-                add_mtd_partitions(&info->mtd, info->parts, err);
+                mtd_device_register(&info->mtd, info->parts, err);
         else if (err <= 0 && pdata && pdata->parts)
-                add_mtd_partitions(&info->mtd, pdata->parts, pdata->nr_parts);
+                mtd_device_register(&info->mtd, pdata->parts, pdata->nr_parts);
         else
-#endif
-                err = add_mtd_device(&info->mtd);
+                err = mtd_device_register(&info->mtd, NULL, 0);
 
         platform_set_drvdata(pdev, info);
 
@@ -108,11 +104,7 @@ static int __devexit generic_onenand_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
 
         if (info) {
-                if (info->parts)
-                        del_mtd_partitions(&info->mtd);
-                else
-                        del_mtd_device(&info->mtd);
-
+                mtd_device_unregister(&info->mtd);
                 onenand_release(&info->mtd);
                 release_mem_region(res->start, size);
                 iounmap(info->onenand.base);
diff --git a/drivers/mtd/onenand/omap2.c b/drivers/mtd/onenand/omap2.c
index 1fcb41adab07..a916dec29215 100644
--- a/drivers/mtd/onenand/omap2.c
+++ b/drivers/mtd/onenand/omap2.c
@@ -67,9 +67,7 @@ struct omap2_onenand {
         struct regulator *regulator;
 };
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL,  };
-#endif
 
 static void omap2_onenand_dma_cb(int lch, u16 ch_status, void *data)
 {
@@ -755,15 +753,13 @@ static int __devinit omap2_onenand_probe(struct platform_device *pdev)
         if ((r = onenand_scan(&c->mtd, 1)) < 0)
                 goto err_release_regulator;
 
-#ifdef CONFIG_MTD_PARTITIONS
         r = parse_mtd_partitions(&c->mtd, part_probes, &c->parts, 0);
         if (r > 0)
-                r = add_mtd_partitions(&c->mtd, c->parts, r);
+                r = mtd_device_register(&c->mtd, c->parts, r);
         else if (pdata->parts != NULL)
-                r = add_mtd_partitions(&c->mtd, pdata->parts, pdata->nr_parts);
+                r = mtd_device_register(&c->mtd, pdata->parts, pdata->nr_parts);
         else
-#endif
-                r = add_mtd_device(&c->mtd);
+                r = mtd_device_register(&c->mtd, NULL, 0);
         if (r)
                 goto err_release_onenand;
 
diff --git a/drivers/mtd/onenand/onenand_base.c b/drivers/mtd/onenand/onenand_base.c
index 56a8b2005bda..ac9e959802a7 100644
--- a/drivers/mtd/onenand/onenand_base.c
+++ b/drivers/mtd/onenand/onenand_base.c
@@ -65,11 +65,11 @@ MODULE_PARM_DESC(otp,	"Corresponding behaviour of OneNAND in OTP"
                         "          : 2 -> 1st Block lock"
                         "          : 3 -> BOTH OTP Block and 1st Block lock");
 
-/**
- *  onenand_oob_128 - oob info for Flex-Onenand with 4KB page
- *  For now, we expose only 64 out of 80 ecc bytes
+/*
+ * flexonenand_oob_128 - oob info for Flex-Onenand with 4KB page
+ * For now, we expose only 64 out of 80 ecc bytes
  */
-static struct nand_ecclayout onenand_oob_128 = {
+static struct nand_ecclayout flexonenand_oob_128 = {
         .eccbytes       = 64,
         .eccpos         = {
                 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
@@ -86,6 +86,35 @@ static struct nand_ecclayout onenand_oob_128 = {
         }
 };
 
+/*
+ * onenand_oob_128 - oob info for OneNAND with 4KB page
+ *
+ * Based on specification:
+ * 4Gb M-die OneNAND Flash (KFM4G16Q4M, KFN8G16Q4M). Rev. 1.3, Apr. 2010
+ *
+ * For eccpos we expose only 64 bytes out of 72 (see struct nand_ecclayout)
+ *
+ * oobfree uses the spare area fields marked as
+ * "Managed by internal ECC logic for Logical Sector Number area"
+ */
+static struct nand_ecclayout onenand_oob_128 = {
+        .eccbytes       = 64,
+        .eccpos         = {
+                7, 8, 9, 10, 11, 12, 13, 14, 15,
+                23, 24, 25, 26, 27, 28, 29, 30, 31,
+                39, 40, 41, 42, 43, 44, 45, 46, 47,
+                55, 56, 57, 58, 59, 60, 61, 62, 63,
+                71, 72, 73, 74, 75, 76, 77, 78, 79,
+                87, 88, 89, 90, 91, 92, 93, 94, 95,
+                103, 104, 105, 106, 107, 108, 109, 110, 111,
+                119
+        },
+        .oobfree        = {
+                {2, 3}, {18, 3}, {34, 3}, {50, 3},
+                {66, 3}, {82, 3}, {98, 3}, {114, 3}
+        }
+};
+
 /**
  * onenand_oob_64 - oob info for large (2KB) page
  */
@@ -2424,7 +2453,7 @@ static int onenand_block_by_block_erase(struct mtd_info *mtd,
                 len -= block_size;
                 addr += block_size;
 
-                if (addr == region_end) {
+                if (region && addr == region_end) {
                         if (!len)
                                 break;
                         region++;
@@ -4018,8 +4047,13 @@ int onenand_scan(struct mtd_info *mtd, int maxchips)
          */
         switch (mtd->oobsize) {
         case 128:
-                this->ecclayout = &onenand_oob_128;
-                mtd->subpage_sft = 0;
+                if (FLEXONENAND(this)) {
+                        this->ecclayout = &flexonenand_oob_128;
+                        mtd->subpage_sft = 0;
+                } else {
+                        this->ecclayout = &onenand_oob_128;
+                        mtd->subpage_sft = 2;
+                }
                 break;
         case 64:
                 this->ecclayout = &onenand_oob_64;
@@ -4108,12 +4142,8 @@ void onenand_release(struct mtd_info *mtd)
 {
         struct onenand_chip *this = mtd->priv;
 
-#ifdef CONFIG_MTD_PARTITIONS
         /* Deregister partitions */
-        del_mtd_partitions (mtd);
-#endif
-        /* Deregister the device */
-        del_mtd_device (mtd);
+        mtd_device_unregister(mtd);
 
         /* Free bad block table memory, if allocated */
         if (this->bbm) {
diff --git a/drivers/mtd/onenand/onenand_sim.c b/drivers/mtd/onenand/onenand_sim.c
index 5ef3bd547772..85399e3accda 100644
--- a/drivers/mtd/onenand/onenand_sim.c
+++ b/drivers/mtd/onenand/onenand_sim.c
@@ -539,7 +539,8 @@ static int __init onenand_sim_init(void)
                 return -ENXIO;
         }
 
-        add_mtd_partitions(&info->mtd, info->parts, ARRAY_SIZE(os_partitions));
+        mtd_device_register(&info->mtd, info->parts,
+                            ARRAY_SIZE(os_partitions));
 
         return 0;
 }
diff --git a/drivers/mtd/onenand/samsung.c b/drivers/mtd/onenand/samsung.c
index a4c74a9ba430..3306b5b3c736 100644
--- a/drivers/mtd/onenand/samsung.c
+++ b/drivers/mtd/onenand/samsung.c
@@ -147,9 +147,7 @@ struct s3c_onenand {
         struct resource *dma_res;
         unsigned long   phys_base;
         struct completion       complete;
-#ifdef CONFIG_MTD_PARTITIONS
         struct mtd_partition *parts;
-#endif
 };
 
 #define CMD_MAP_00(dev, addr)           (dev->cmd_map(MAP_00, ((addr) << 1)))
@@ -159,9 +157,7 @@ struct s3c_onenand {
 
 static struct s3c_onenand *onenand;
 
-#ifdef CONFIG_MTD_PARTITIONS
 static const char *part_probes[] = { "cmdlinepart", NULL, };
-#endif
 
 static inline int s3c_read_reg(int offset)
 {
@@ -1021,15 +1017,13 @@ static int s3c_onenand_probe(struct platform_device *pdev)
         if (s3c_read_reg(MEM_CFG_OFFSET) & ONENAND_SYS_CFG1_SYNC_READ)
                 dev_info(&onenand->pdev->dev, "OneNAND Sync. Burst Read enabled\n");
 
-#ifdef CONFIG_MTD_PARTITIONS
         err = parse_mtd_partitions(mtd, part_probes, &onenand->parts, 0);
         if (err > 0)
-                add_mtd_partitions(mtd, onenand->parts, err);
+                mtd_device_register(mtd, onenand->parts, err);
         else if (err <= 0 && pdata && pdata->parts)
-                add_mtd_partitions(mtd, pdata->parts, pdata->nr_parts);
+                mtd_device_register(mtd, pdata->parts, pdata->nr_parts);
         else
-#endif
-                err = add_mtd_device(mtd);
+                err = mtd_device_register(mtd, NULL, 0);
 
         platform_set_drvdata(pdev, mtd);
 
diff --git a/drivers/mtd/ubi/gluebi.c b/drivers/mtd/ubi/gluebi.c
index 9aa81584c8a2..941bc3c05d6e 100644
--- a/drivers/mtd/ubi/gluebi.c
+++ b/drivers/mtd/ubi/gluebi.c
@@ -365,7 +365,7 @@ static int gluebi_create(struct ubi_device_info *di,
                         vi->vol_id);
         mutex_unlock(&devices_mutex);
 
-        if (add_mtd_device(mtd)) {
+        if (mtd_device_register(mtd, NULL, 0)) {
                 err_msg("cannot add MTD device");
                 kfree(mtd->name);
                 kfree(gluebi);
@@ -407,7 +407,7 @@ static int gluebi_remove(struct ubi_volume_info *vi)
                 return err;
 
         mtd = &gluebi->mtd;
-        err = del_mtd_device(mtd);
+        err = mtd_device_unregister(mtd);
         if (err) {
                 err_msg("cannot remove fake MTD device %d, UBI device %d, "
                         "volume %d, error %d", mtd->index, gluebi->ubi_num,
@@ -524,7 +524,7 @@ static void __exit ubi_gluebi_exit(void)
                 int err;
                 struct mtd_info *mtd = &gluebi->mtd;
 
-                err = del_mtd_device(mtd);
+                err = mtd_device_unregister(mtd);
                 if (err)
                         err_msg("error %d while removing gluebi MTD device %d, "
                                 "UBI device %d, volume %d - ignoring", err,
diff --git a/drivers/net/sfc/mtd.c b/drivers/net/sfc/mtd.c
index e646bfce2d84..b6304486f244 100644
--- a/drivers/net/sfc/mtd.c
+++ b/drivers/net/sfc/mtd.c
@@ -216,7 +216,7 @@ static void efx_mtd_remove_partition(struct efx_mtd_partition *part)
         int rc;
 
         for (;;) {
-                rc = del_mtd_device(&part->mtd);
+                rc = mtd_device_unregister(&part->mtd);
                 if (rc != -EBUSY)
                         break;
                 ssleep(1);
@@ -268,7 +268,7 @@ static int efx_mtd_probe_device(struct efx_nic *efx, struct efx_mtd *efx_mtd)
                 part->mtd.write = efx_mtd->ops->write;
                 part->mtd.sync = efx_mtd_sync;
 
-                if (add_mtd_device(&part->mtd))
+                if (mtd_device_register(&part->mtd, NULL, 0))
                         goto fail;
         }
 
@@ -280,7 +280,7 @@ fail:
                 --part;
                 efx_mtd_remove_partition(part);
         }
-        /* add_mtd_device() returns 1 if the MTD table is full */
+        /* mtd_device_register() returns 1 if the MTD table is full */
         return -ENOMEM;
 }
 
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 0cb0b0632672..f6853247a620 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -609,7 +609,7 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
          * before it gets out of hand.  Naturally, this wastes entries. */
         if (capacity < 2+MAX_SKB_FRAGS) {
                 netif_stop_queue(dev);
-                if (unlikely(!virtqueue_enable_cb(vi->svq))) {
+                if (unlikely(!virtqueue_enable_cb_delayed(vi->svq))) {
                         /* More just got used, free them then recheck. */
                         capacity += free_old_xmit_skbs(vi);
                         if (capacity >= 2+MAX_SKB_FRAGS) {
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index 8b63a691a9ed..65200af29c52 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -670,7 +670,7 @@ int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
 
         pr_debug("search \"chosen\", depth: %d, uname: %s\n", depth, uname);
 
-        if (depth != 1 ||
+        if (depth != 1 || !data ||
             (strcmp(uname, "chosen") != 0 && strcmp(uname, "chosen@0") != 0))
                 return 0;
 
@@ -679,16 +679,16 @@ int __init early_init_dt_scan_chosen(unsigned long node, const char *uname,
         /* Retrieve 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));
+                strlcpy(data, 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);
+                strlcpy(data, CONFIG_CMDLINE, COMMAND_LINE_SIZE);
 #endif /* CONFIG_CMDLINE */
 
-        pr_debug("Command line is: %s\n", cmd_line);
+        pr_debug("Command line is: %s\n", (char*)data);
 
         /* break now */
         return 1;
diff --git a/drivers/oprofile/event_buffer.h b/drivers/oprofile/event_buffer.h
index 4e70749f8d16..a8d5bb3cba89 100644
--- a/drivers/oprofile/event_buffer.h
+++ b/drivers/oprofile/event_buffer.h
@@ -11,7 +11,7 @@
 #define EVENT_BUFFER_H
 
 #include <linux/types.h>
-#include <asm/mutex.h>
+#include <linux/mutex.h>
 
 int alloc_event_buffer(void);
 
diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
index f9bda64fcd1b..dccd8636095c 100644
--- a/drivers/oprofile/oprof.c
+++ b/drivers/oprofile/oprof.c
@@ -14,7 +14,7 @@
 #include <linux/moduleparam.h>
 #include <linux/workqueue.h>
 #include <linux/time.h>
-#include <asm/mutex.h>
+#include <linux/mutex.h>
 
 #include "oprof.h"
 #include "event_buffer.h"
diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c
index 12e02bf92c4a..3dc9befa5aec 100644
--- a/drivers/pci/dmar.c
+++ b/drivers/pci/dmar.c
@@ -698,12 +698,7 @@ int __init detect_intel_iommu(void)
         {
 #ifdef CONFIG_INTR_REMAP
                 struct acpi_table_dmar *dmar;
-                /*
-                 * for now we will disable dma-remapping when interrupt
-                 * remapping is enabled.
-                 * When support for queued invalidation for IOTLB invalidation
-                 * is added, we will not need this any more.
-                 */
+
                 dmar = (struct acpi_table_dmar *) dmar_tbl;
                 if (ret && cpu_has_x2apic && dmar->flags & 0x1)
                         printk(KERN_INFO
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index 6af6b628175b..59f17acf7f68 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -47,6 +47,8 @@
 #define ROOT_SIZE               VTD_PAGE_SIZE
 #define CONTEXT_SIZE            VTD_PAGE_SIZE
 
+#define IS_BRIDGE_HOST_DEVICE(pdev) \
+                            ((pdev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
 #define IS_GFX_DEVICE(pdev) ((pdev->class >> 16) == PCI_BASE_CLASS_DISPLAY)
 #define IS_ISA_DEVICE(pdev) ((pdev->class >> 8) == PCI_CLASS_BRIDGE_ISA)
 #define IS_AZALIA(pdev) ((pdev)->vendor == 0x8086 && (pdev)->device == 0x3a3e)
@@ -116,6 +118,11 @@ static inline unsigned long align_to_level(unsigned long pfn, int level)
         return (pfn + level_size(level) - 1) & level_mask(level);
 }
 
+static inline unsigned long lvl_to_nr_pages(unsigned int lvl)
+{
+        return  1 << ((lvl - 1) * LEVEL_STRIDE);
+}
+
 /* VT-d pages must always be _smaller_ than MM pages. Otherwise things
    are never going to work. */
 static inline unsigned long dma_to_mm_pfn(unsigned long dma_pfn)
@@ -143,6 +150,12 @@ static void __init check_tylersburg_isoch(void);
 static int rwbf_quirk;
 
 /*
+ * set to 1 to panic kernel if can't successfully enable VT-d
+ * (used when kernel is launched w/ TXT)
+ */
+static int force_on = 0;
+
+/*
  * 0: Present
  * 1-11: Reserved
  * 12-63: Context Ptr (12 - (haw-1))
@@ -338,6 +351,9 @@ struct dmar_domain {
         int             iommu_coherency;/* indicate coherency of iommu access */
         int             iommu_snooping; /* indicate snooping control feature*/
         int             iommu_count;    /* reference count of iommu */
+        int             iommu_superpage;/* Level of superpages supported:
+                                           0 == 4KiB (no superpages), 1 == 2MiB,
+                                           2 == 1GiB, 3 == 512GiB, 4 == 1TiB */
         spinlock_t      iommu_lock;     /* protect iommu set in domain */
         u64             max_addr;       /* maximum mapped address */
 };
@@ -387,6 +403,7 @@ int dmar_disabled = 1;
 static int dmar_map_gfx = 1;
 static int dmar_forcedac;
 static int intel_iommu_strict;
+static int intel_iommu_superpage = 1;
 
 #define DUMMY_DEVICE_DOMAIN_INFO ((struct device_domain_info *)(-1))
 static DEFINE_SPINLOCK(device_domain_lock);
@@ -417,6 +434,10 @@ static int __init intel_iommu_setup(char *str)
                         printk(KERN_INFO
                                 "Intel-IOMMU: disable batched IOTLB flush\n");
                         intel_iommu_strict = 1;
+                } else if (!strncmp(str, "sp_off", 6)) {
+                        printk(KERN_INFO
+                                "Intel-IOMMU: disable supported super page\n");
+                        intel_iommu_superpage = 0;
                 }
 
                 str += strcspn(str, ",");
@@ -555,11 +576,32 @@ static void domain_update_iommu_snooping(struct dmar_domain *domain)
         }
 }
 
+static void domain_update_iommu_superpage(struct dmar_domain *domain)
+{
+        int i, mask = 0xf;
+
+        if (!intel_iommu_superpage) {
+                domain->iommu_superpage = 0;
+                return;
+        }
+
+        domain->iommu_superpage = 4; /* 1TiB */
+
+        for_each_set_bit(i, &domain->iommu_bmp, g_num_of_iommus) {
+                mask |= cap_super_page_val(g_iommus[i]->cap);
+                if (!mask) {
+                        break;
+                }
+        }
+        domain->iommu_superpage = fls(mask);
+}
+
 /* Some capabilities may be different across iommus */
 static void domain_update_iommu_cap(struct dmar_domain *domain)
 {
         domain_update_iommu_coherency(domain);
         domain_update_iommu_snooping(domain);
+        domain_update_iommu_superpage(domain);
 }
 
 static struct intel_iommu *device_to_iommu(int segment, u8 bus, u8 devfn)
@@ -689,23 +731,31 @@ out:
 }
 
 static struct dma_pte *pfn_to_dma_pte(struct dmar_domain *domain,
-                                      unsigned long pfn)
+                                      unsigned long pfn, int large_level)
 {
         int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
         struct dma_pte *parent, *pte = NULL;
         int level = agaw_to_level(domain->agaw);
-        int offset;
+        int offset, target_level;
 
         BUG_ON(!domain->pgd);
         BUG_ON(addr_width < BITS_PER_LONG && pfn >> addr_width);
         parent = domain->pgd;
 
+        /* Search pte */
+        if (!large_level)
+                target_level = 1;
+        else
+                target_level = large_level;
+
         while (level > 0) {
                 void *tmp_page;
 
                 offset = pfn_level_offset(pfn, level);
                 pte = &parent[offset];
-                if (level == 1)
+                if (!large_level && (pte->val & DMA_PTE_LARGE_PAGE))
+                        break;
+                if (level == target_level)
                         break;
 
                 if (!dma_pte_present(pte)) {
@@ -733,10 +783,11 @@ static struct dma_pte *pfn_to_dma_pte(struct dmar_domain *domain,
         return pte;
 }
 
+
 /* return address's pte at specific level */
 static struct dma_pte *dma_pfn_level_pte(struct dmar_domain *domain,
                                          unsigned long pfn,
-                                         int level)
+                                         int level, int *large_page)
 {
         struct dma_pte *parent, *pte = NULL;
         int total = agaw_to_level(domain->agaw);
@@ -749,8 +800,16 @@ static struct dma_pte *dma_pfn_level_pte(struct dmar_domain *domain,
                 if (level == total)
                         return pte;
 
-                if (!dma_pte_present(pte))
+                if (!dma_pte_present(pte)) {
+                        *large_page = total;
                         break;
+                }
+
+                if (pte->val & DMA_PTE_LARGE_PAGE) {
+                        *large_page = total;
+                        return pte;
+                }
+
                 parent = phys_to_virt(dma_pte_addr(pte));
                 total--;
         }
@@ -763,6 +822,7 @@ static void dma_pte_clear_range(struct dmar_domain *domain,
                                 unsigned long last_pfn)
 {
         int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
+        unsigned int large_page = 1;
         struct dma_pte *first_pte, *pte;
 
         BUG_ON(addr_width < BITS_PER_LONG && start_pfn >> addr_width);
@@ -771,14 +831,15 @@ static void dma_pte_clear_range(struct dmar_domain *domain,
 
         /* we don't need lock here; nobody else touches the iova range */
         do {
-                first_pte = pte = dma_pfn_level_pte(domain, start_pfn, 1);
+                large_page = 1;
+                first_pte = pte = dma_pfn_level_pte(domain, start_pfn, 1, &large_page);
                 if (!pte) {
-                        start_pfn = align_to_level(start_pfn + 1, 2);
+                        start_pfn = align_to_level(start_pfn + 1, large_page + 1);
                         continue;
                 }
-                do { 
+                do {
                         dma_clear_pte(pte);
-                        start_pfn++;
+                        start_pfn += lvl_to_nr_pages(large_page);
                         pte++;
                 } while (start_pfn <= last_pfn && !first_pte_in_page(pte));
 
@@ -798,6 +859,7 @@ static void dma_pte_free_pagetable(struct dmar_domain *domain,
         int total = agaw_to_level(domain->agaw);
         int level;
         unsigned long tmp;
+        int large_page = 2;
 
         BUG_ON(addr_width < BITS_PER_LONG && start_pfn >> addr_width);
         BUG_ON(addr_width < BITS_PER_LONG && last_pfn >> addr_width);
@@ -813,7 +875,10 @@ static void dma_pte_free_pagetable(struct dmar_domain *domain,
                         return;
 
                 do {
-                        first_pte = pte = dma_pfn_level_pte(domain, tmp, level);
+                        large_page = level;
+                        first_pte = pte = dma_pfn_level_pte(domain, tmp, level, &large_page);
+                        if (large_page > level)
+                                level = large_page + 1;
                         if (!pte) {
                                 tmp = align_to_level(tmp + 1, level + 1);
                                 continue;
@@ -1397,6 +1462,7 @@ static int domain_init(struct dmar_domain *domain, int guest_width)
         else
                 domain->iommu_snooping = 0;
 
+        domain->iommu_superpage = fls(cap_super_page_val(iommu->cap));
         domain->iommu_count = 1;
         domain->nid = iommu->node;
 
@@ -1417,6 +1483,10 @@ static void domain_exit(struct dmar_domain *domain)
         if (!domain)
                 return;
 
+        /* Flush any lazy unmaps that may reference this domain */
+        if (!intel_iommu_strict)
+                flush_unmaps_timeout(0);
+
         domain_remove_dev_info(domain);
         /* destroy iovas */
         put_iova_domain(&domain->iovad);
@@ -1648,6 +1718,34 @@ static inline unsigned long aligned_nrpages(unsigned long host_addr,
         return PAGE_ALIGN(host_addr + size) >> VTD_PAGE_SHIFT;
 }
 
+/* Return largest possible superpage level for a given mapping */
+static inline int hardware_largepage_caps(struct dmar_domain *domain,
+                                          unsigned long iov_pfn,
+                                          unsigned long phy_pfn,
+                                          unsigned long pages)
+{
+        int support, level = 1;
+        unsigned long pfnmerge;
+
+        support = domain->iommu_superpage;
+
+        /* To use a large page, the virtual *and* physical addresses
+           must be aligned to 2MiB/1GiB/etc. Lower bits set in either
+           of them will mean we have to use smaller pages. So just
+           merge them and check both at once. */
+        pfnmerge = iov_pfn | phy_pfn;
+
+        while (support && !(pfnmerge & ~VTD_STRIDE_MASK)) {
+                pages >>= VTD_STRIDE_SHIFT;
+                if (!pages)
+                        break;
+                pfnmerge >>= VTD_STRIDE_SHIFT;
+                level++;
+                support--;
+        }
+        return level;
+}
+
 static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
                             struct scatterlist *sg, unsigned long phys_pfn,
                             unsigned long nr_pages, int prot)
@@ -1656,6 +1754,8 @@ static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
         phys_addr_t uninitialized_var(pteval);
         int addr_width = agaw_to_width(domain->agaw) - VTD_PAGE_SHIFT;
         unsigned long sg_res;
+        unsigned int largepage_lvl = 0;
+        unsigned long lvl_pages = 0;
 
         BUG_ON(addr_width < BITS_PER_LONG && (iov_pfn + nr_pages - 1) >> addr_width);
 
@@ -1671,7 +1771,7 @@ static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
                 pteval = ((phys_addr_t)phys_pfn << VTD_PAGE_SHIFT) | prot;
         }
 
-        while (nr_pages--) {
+        while (nr_pages > 0) {
                 uint64_t tmp;
 
                 if (!sg_res) {
@@ -1679,11 +1779,21 @@ static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
                         sg->dma_address = ((dma_addr_t)iov_pfn << VTD_PAGE_SHIFT) + sg->offset;
                         sg->dma_length = sg->length;
                         pteval = page_to_phys(sg_page(sg)) | prot;
+                        phys_pfn = pteval >> VTD_PAGE_SHIFT;
                 }
+
                 if (!pte) {
-                        first_pte = pte = pfn_to_dma_pte(domain, iov_pfn);
+                        largepage_lvl = hardware_largepage_caps(domain, iov_pfn, phys_pfn, sg_res);
+
+                        first_pte = pte = pfn_to_dma_pte(domain, iov_pfn, largepage_lvl);
                         if (!pte)
                                 return -ENOMEM;
+                        /* It is large page*/
+                        if (largepage_lvl > 1)
+                                pteval |= DMA_PTE_LARGE_PAGE;
+                        else
+                                pteval &= ~(uint64_t)DMA_PTE_LARGE_PAGE;
+
                 }
                 /* We don't need lock here, nobody else
                  * touches the iova range
@@ -1699,16 +1809,38 @@ static int __domain_mapping(struct dmar_domain *domain, unsigned long iov_pfn,
                         }
                         WARN_ON(1);
                 }
+
+                lvl_pages = lvl_to_nr_pages(largepage_lvl);
+
+                BUG_ON(nr_pages < lvl_pages);
+                BUG_ON(sg_res < lvl_pages);
+
+                nr_pages -= lvl_pages;
+                iov_pfn += lvl_pages;
+                phys_pfn += lvl_pages;
+                pteval += lvl_pages * VTD_PAGE_SIZE;
+                sg_res -= lvl_pages;
+
+                /* If the next PTE would be the first in a new page, then we
+                   need to flush the cache on the entries we've just written.
+                   And then we'll need to recalculate 'pte', so clear it and
+                   let it get set again in the if (!pte) block above.
+
+                   If we're done (!nr_pages) we need to flush the cache too.
+
+                   Also if we've been setting superpages, we may need to
+                   recalculate 'pte' and switch back to smaller pages for the
+                   end of the mapping, if the trailing size is not enough to
+                   use another superpage (i.e. sg_res < lvl_pages). */
                 pte++;
-                if (!nr_pages || first_pte_in_page(pte)) {
+                if (!nr_pages || first_pte_in_page(pte) ||
+                    (largepage_lvl > 1 && sg_res < lvl_pages)) {
                         domain_flush_cache(domain, first_pte,
                                            (void *)pte - (void *)first_pte);
                         pte = NULL;
                 }
-                iov_pfn++;
-                pteval += VTD_PAGE_SIZE;
-                sg_res--;
-                if (!sg_res)
+
+                if (!sg_res && nr_pages)
                         sg = sg_next(sg);
         }
         return 0;
@@ -2016,7 +2148,7 @@ static inline int iommu_prepare_rmrr_dev(struct dmar_rmrr_unit *rmrr,
         if (pdev->dev.archdata.iommu == DUMMY_DEVICE_DOMAIN_INFO)
                 return 0;
         return iommu_prepare_identity_map(pdev, rmrr->base_address,
-                rmrr->end_address + 1);
+                rmrr->end_address);
 }
 
 #ifdef CONFIG_DMAR_FLOPPY_WA
@@ -2030,7 +2162,7 @@ static inline void iommu_prepare_isa(void)
                 return;
 
         printk(KERN_INFO "IOMMU: Prepare 0-16MiB unity mapping for LPC\n");
-        ret = iommu_prepare_identity_map(pdev, 0, 16*1024*1024);
+        ret = iommu_prepare_identity_map(pdev, 0, 16*1024*1024 - 1);
 
         if (ret)
                 printk(KERN_ERR "IOMMU: Failed to create 0-16MiB identity map; "
@@ -2106,10 +2238,10 @@ static int identity_mapping(struct pci_dev *pdev)
         if (likely(!iommu_identity_mapping))
                 return 0;
 
+        info = pdev->dev.archdata.iommu;
+        if (info && info != DUMMY_DEVICE_DOMAIN_INFO)
+                return (info->domain == si_domain);
 
-        list_for_each_entry(info, &si_domain->devices, link)
-                if (info->dev == pdev)
-                        return 1;
         return 0;
 }
 
@@ -2187,8 +2319,19 @@ static int iommu_should_identity_map(struct pci_dev *pdev, int startup)
          * Assume that they will -- if they turn out not to be, then we can 
          * take them out of the 1:1 domain later.
          */
-        if (!startup)
-                return pdev->dma_mask > DMA_BIT_MASK(32);
+        if (!startup) {
+                /*
+                 * If the device's dma_mask is less than the system's memory
+                 * size then this is not a candidate for identity mapping.
+                 */
+                u64 dma_mask = pdev->dma_mask;
+
+                if (pdev->dev.coherent_dma_mask &&
+                    pdev->dev.coherent_dma_mask < dma_mask)
+                        dma_mask = pdev->dev.coherent_dma_mask;
+
+                return dma_mask >= dma_get_required_mask(&pdev->dev);
+        }
 
         return 1;
 }
@@ -2203,6 +2346,9 @@ static int __init iommu_prepare_static_identity_mapping(int hw)
                 return -EFAULT;
 
         for_each_pci_dev(pdev) {
+                /* Skip Host/PCI Bridge devices */
+                if (IS_BRIDGE_HOST_DEVICE(pdev))
+                        continue;
                 if (iommu_should_identity_map(pdev, 1)) {
                         printk(KERN_INFO "IOMMU: %s identity mapping for device %s\n",
                                hw ? "hardware" : "software", pci_name(pdev));
@@ -2218,7 +2364,7 @@ static int __init iommu_prepare_static_identity_mapping(int hw)
         return 0;
 }
 
-static int __init init_dmars(int force_on)
+static int __init init_dmars(void)
 {
         struct dmar_drhd_unit *drhd;
         struct dmar_rmrr_unit *rmrr;
@@ -2592,8 +2738,7 @@ static dma_addr_t __intel_map_single(struct device *hwdev, phys_addr_t paddr,
         iommu = domain_get_iommu(domain);
         size = aligned_nrpages(paddr, size);
 
-        iova = intel_alloc_iova(hwdev, domain, dma_to_mm_pfn(size),
-                                pdev->dma_mask);
+        iova = intel_alloc_iova(hwdev, domain, dma_to_mm_pfn(size), dma_mask);
         if (!iova)
                 goto error;
 
@@ -3118,7 +3263,17 @@ static int init_iommu_hw(void)
                 if (iommu->qi)
                         dmar_reenable_qi(iommu);
 
-        for_each_active_iommu(iommu, drhd) {
+        for_each_iommu(iommu, drhd) {
+                if (drhd->ignored) {
+                        /*
+                         * we always have to disable PMRs or DMA may fail on
+                         * this device
+                         */
+                        if (force_on)
+                                iommu_disable_protect_mem_regions(iommu);
+                        continue;
+                }
+        
                 iommu_flush_write_buffer(iommu);
 
                 iommu_set_root_entry(iommu);
@@ -3127,7 +3282,8 @@ static int init_iommu_hw(void)
                                            DMA_CCMD_GLOBAL_INVL);
                 iommu->flush.flush_iotlb(iommu, 0, 0, 0,
                                          DMA_TLB_GLOBAL_FLUSH);
-                iommu_enable_translation(iommu);
+                if (iommu_enable_translation(iommu))
+                        return 1;
                 iommu_disable_protect_mem_regions(iommu);
         }
 
@@ -3194,7 +3350,10 @@ static void iommu_resume(void)
         unsigned long flag;
 
         if (init_iommu_hw()) {
-                WARN(1, "IOMMU setup failed, DMAR can not resume!\n");
+                if (force_on)
+                        panic("tboot: IOMMU setup failed, DMAR can not resume!\n");
+                else
+                        WARN(1, "IOMMU setup failed, DMAR can not resume!\n");
                 return;
         }
 
@@ -3271,7 +3430,6 @@ static struct notifier_block device_nb = {
 int __init intel_iommu_init(void)
 {
         int ret = 0;
-        int force_on = 0;
 
         /* VT-d is required for a TXT/tboot launch, so enforce that */
         force_on = tboot_force_iommu();
@@ -3309,7 +3467,7 @@ int __init intel_iommu_init(void)
 
         init_no_remapping_devices();
 
-        ret = init_dmars(force_on);
+        ret = init_dmars();
         if (ret) {
                 if (force_on)
                         panic("tboot: Failed to initialize DMARs\n");
@@ -3380,8 +3538,8 @@ static void domain_remove_one_dev_info(struct dmar_domain *domain,
         spin_lock_irqsave(&device_domain_lock, flags);
         list_for_each_safe(entry, tmp, &domain->devices) {
                 info = list_entry(entry, struct device_domain_info, link);
-                /* No need to compare PCI domain; it has to be the same */
-                if (info->bus == pdev->bus->number &&
+                if (info->segment == pci_domain_nr(pdev->bus) &&
+                    info->bus == pdev->bus->number &&
                     info->devfn == pdev->devfn) {
                         list_del(&info->link);
                         list_del(&info->global);
@@ -3419,10 +3577,13 @@ static void domain_remove_one_dev_info(struct dmar_domain *domain,
                 domain_update_iommu_cap(domain);
                 spin_unlock_irqrestore(&domain->iommu_lock, tmp_flags);
 
-                spin_lock_irqsave(&iommu->lock, tmp_flags);
-                clear_bit(domain->id, iommu->domain_ids);
-                iommu->domains[domain->id] = NULL;
-                spin_unlock_irqrestore(&iommu->lock, tmp_flags);
+                if (!(domain->flags & DOMAIN_FLAG_VIRTUAL_MACHINE) &&
+                    !(domain->flags & DOMAIN_FLAG_STATIC_IDENTITY)) {
+                        spin_lock_irqsave(&iommu->lock, tmp_flags);
+                        clear_bit(domain->id, iommu->domain_ids);
+                        iommu->domains[domain->id] = NULL;
+                        spin_unlock_irqrestore(&iommu->lock, tmp_flags);
+                }
         }
 
         spin_unlock_irqrestore(&device_domain_lock, flags);
@@ -3505,6 +3666,7 @@ static int md_domain_init(struct dmar_domain *domain, int guest_width)
         domain->iommu_count = 0;
         domain->iommu_coherency = 0;
         domain->iommu_snooping = 0;
+        domain->iommu_superpage = 0;
         domain->max_addr = 0;
         domain->nid = -1;
 
@@ -3720,7 +3882,7 @@ static phys_addr_t intel_iommu_iova_to_phys(struct iommu_domain *domain,
         struct dma_pte *pte;
         u64 phys = 0;
 
-        pte = pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT);
+        pte = pfn_to_dma_pte(dmar_domain, iova >> VTD_PAGE_SHIFT, 0);
         if (pte)
                 phys = dma_pte_addr(pte);
 
diff --git a/drivers/pci/iova.c b/drivers/pci/iova.c
index 9606e599a475..c5c274ab5c5a 100644
--- a/drivers/pci/iova.c
+++ b/drivers/pci/iova.c
@@ -63,8 +63,16 @@ __cached_rbnode_delete_update(struct iova_domain *iovad, struct iova *free)
         curr = iovad->cached32_node;
         cached_iova = container_of(curr, struct iova, node);
 
-        if (free->pfn_lo >= cached_iova->pfn_lo)
-                iovad->cached32_node = rb_next(&free->node);
+        if (free->pfn_lo >= cached_iova->pfn_lo) {
+                struct rb_node *node = rb_next(&free->node);
+                struct iova *iova = container_of(node, struct iova, node);
+
+                /* only cache if it's below 32bit pfn */
+                if (node && iova->pfn_lo < iovad->dma_32bit_pfn)
+                        iovad->cached32_node = node;
+                else
+                        iovad->cached32_node = NULL;
+        }
 }
 
 /* Computes the padding size required, to make the
diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c
index 7c3b18e78cee..d36f41ea8cbf 100644
--- a/drivers/pci/pci-acpi.c
+++ b/drivers/pci/pci-acpi.c
@@ -195,6 +195,8 @@ static pci_power_t acpi_pci_choose_state(struct pci_dev *pdev)
                 return PCI_D2;
         case ACPI_STATE_D3:
                 return PCI_D3hot;
+        case ACPI_STATE_D3_COLD:
+                return PCI_D3cold;
         }
         return PCI_POWER_ERROR;
 }
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index 5cb999b50f95..45e0191c35dd 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -39,7 +39,7 @@ config ACER_WMI
 
 config ACERHDF
         tristate "Acer Aspire One temperature and fan driver"
-        depends on THERMAL && THERMAL_HWMON && ACPI
+        depends on THERMAL && ACPI
         ---help---
           This is a driver for Acer Aspire One netbooks. It allows to access
           the temperature sensor and to control the fan.
@@ -760,4 +760,13 @@ config MXM_WMI
           MXM is a standard for laptop graphics cards, the WMI interface
           is required for switchable nvidia graphics machines
 
+config INTEL_OAKTRAIL
+        tristate "Intel Oaktrail Platform Extras"
+        depends on ACPI
+        depends on RFKILL && BACKLIGHT_CLASS_DEVICE && ACPI
+        ---help---
+          Intel Oaktrail platform need this driver to provide interfaces to
+          enable/disable the Camera, WiFi, BT etc. devices. If in doubt, say Y
+          here; it will only load on supported platforms.
+
 endif # X86_PLATFORM_DEVICES
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index a7ab3bc7b3a1..afc1f832aa67 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -41,5 +41,6 @@ obj-$(CONFIG_XO1_RFKILL)	+= xo1-rfkill.o
 obj-$(CONFIG_XO15_EBOOK)        += xo15-ebook.o
 obj-$(CONFIG_IBM_RTL)           += ibm_rtl.o
 obj-$(CONFIG_SAMSUNG_LAPTOP)    += samsung-laptop.o
-obj-$(CONFIG_INTEL_MFLD_THERMAL)        += intel_mid_thermal.o
 obj-$(CONFIG_MXM_WMI)           += mxm-wmi.o
+obj-$(CONFIG_INTEL_MID_POWER_BUTTON)    += intel_mid_powerbtn.o
+obj-$(CONFIG_INTEL_OAKTRAIL)    += intel_oaktrail.o
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index ac4e7f83ce6c..005417bd429e 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -98,13 +98,26 @@ enum acer_wmi_event_ids {
 
 static const struct key_entry acer_wmi_keymap[] = {
         {KE_KEY, 0x01, {KEY_WLAN} },     /* WiFi */
+        {KE_KEY, 0x03, {KEY_WLAN} },     /* WiFi */
         {KE_KEY, 0x12, {KEY_BLUETOOTH} },       /* BT */
         {KE_KEY, 0x21, {KEY_PROG1} },    /* Backup */
         {KE_KEY, 0x22, {KEY_PROG2} },    /* Arcade */
         {KE_KEY, 0x23, {KEY_PROG3} },    /* P_Key */
         {KE_KEY, 0x24, {KEY_PROG4} },    /* Social networking_Key */
+        {KE_IGNORE, 0x41, {KEY_MUTE} },
+        {KE_IGNORE, 0x42, {KEY_PREVIOUSSONG} },
+        {KE_IGNORE, 0x43, {KEY_NEXTSONG} },
+        {KE_IGNORE, 0x44, {KEY_PLAYPAUSE} },
+        {KE_IGNORE, 0x45, {KEY_STOP} },
+        {KE_IGNORE, 0x48, {KEY_VOLUMEUP} },
+        {KE_IGNORE, 0x49, {KEY_VOLUMEDOWN} },
+        {KE_IGNORE, 0x61, {KEY_SWITCHVIDEOMODE} },
+        {KE_IGNORE, 0x62, {KEY_BRIGHTNESSUP} },
+        {KE_IGNORE, 0x63, {KEY_BRIGHTNESSDOWN} },
         {KE_KEY, 0x64, {KEY_SWITCHVIDEOMODE} }, /* Display Switch */
+        {KE_IGNORE, 0x81, {KEY_SLEEP} },
         {KE_KEY, 0x82, {KEY_TOUCHPAD_TOGGLE} }, /* Touch Pad On/Off */
+        {KE_IGNORE, 0x83, {KEY_TOUCHPAD_TOGGLE} },
         {KE_END, 0}
 };
 
@@ -122,6 +135,7 @@ struct event_return_value {
  */
 #define ACER_WMID3_GDS_WIRELESS         (1<<0)  /* WiFi */
 #define ACER_WMID3_GDS_THREEG           (1<<6)  /* 3G */
+#define ACER_WMID3_GDS_WIMAX            (1<<7)  /* WiMAX */
 #define ACER_WMID3_GDS_BLUETOOTH        (1<<11) /* BT */
 
 struct lm_input_params {
@@ -737,8 +751,11 @@ WMI_execute_u32(u32 method_id, u32 in, u32 *out)
 
         obj = (union acpi_object *) result.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 tmp = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                tmp = (u32) obj->integer.value;
         } else {
                 tmp = 0;
         }
@@ -866,8 +883,11 @@ static acpi_status WMID_set_capabilities(void)
 
         obj = (union acpi_object *) out.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 devices = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                devices = (u32) obj->integer.value;
         } else {
                 kfree(out.pointer);
                 return AE_ERROR;
@@ -876,7 +896,8 @@ static acpi_status WMID_set_capabilities(void)
         dmi_walk(type_aa_dmi_decode, NULL);
         if (!has_type_aa) {
                 interface->capability |= ACER_CAP_WIRELESS;
-                interface->capability |= ACER_CAP_THREEG;
+                if (devices & 0x40)
+                        interface->capability |= ACER_CAP_THREEG;
                 if (devices & 0x10)
                         interface->capability |= ACER_CAP_BLUETOOTH;
         }
@@ -961,10 +982,12 @@ static void __init acer_commandline_init(void)
          * These will all fail silently if the value given is invalid, or the
          * capability isn't available on the given interface
          */
-        set_u32(mailled, ACER_CAP_MAILLED);
-        if (!has_type_aa)
+        if (mailled >= 0)
+                set_u32(mailled, ACER_CAP_MAILLED);
+        if (!has_type_aa && threeg >= 0)
                 set_u32(threeg, ACER_CAP_THREEG);
-        set_u32(brightness, ACER_CAP_BRIGHTNESS);
+        if (brightness >= 0)
+                set_u32(brightness, ACER_CAP_BRIGHTNESS);
 }
 
 /*
@@ -1081,7 +1104,7 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
                 return AE_ERROR;
         }
         if (obj->buffer.length != 8) {
-                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1090,8 +1113,8 @@ static acpi_status wmid3_get_device_status(u32 *value, u16 device)
         kfree(obj);
 
         if (return_value.error_code || return_value.ec_return_value)
-                pr_warning("Get Device Status failed: "
-                        "0x%x - 0x%x\n", return_value.error_code,
+                pr_warn("Get Device Status failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
                         return_value.ec_return_value);
         else
                 *value = !!(return_value.devices & device);
@@ -1124,6 +1147,114 @@ static acpi_status get_device_status(u32 *value, u32 cap)
         }
 }
 
+static acpi_status wmid3_set_device_status(u32 value, u16 device)
+{
+        struct wmid3_gds_return_value return_value;
+        acpi_status status;
+        union acpi_object *obj;
+        u16 devices;
+        struct wmid3_gds_input_param params = {
+                .function_num = 0x1,
+                .hotkey_number = 0x01,
+                .devices = ACER_WMID3_GDS_WIRELESS &
+                                ACER_WMID3_GDS_THREEG &
+                                ACER_WMID3_GDS_WIMAX &
+                                ACER_WMID3_GDS_BLUETOOTH,
+        };
+        struct acpi_buffer input = {
+                sizeof(struct wmid3_gds_input_param),
+                &params
+        };
+        struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer output2 = { ACPI_ALLOCATE_BUFFER, NULL };
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x2, &input, &output);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 8) {
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value) {
+                pr_warning("Get Current Device Status failed: "
+                        "0x%x - 0x%x\n", return_value.error_code,
+                        return_value.ec_return_value);
+                return status;
+        }
+
+        devices = return_value.devices;
+        params.function_num = 0x2;
+        params.hotkey_number = 0x01;
+        params.devices = (value) ? (devices | device) : (devices & ~device);
+
+        status = wmi_evaluate_method(WMID_GUID3, 0, 0x1, &input, &output2);
+        if (ACPI_FAILURE(status))
+                return status;
+
+        obj = output2.pointer;
+
+        if (!obj)
+                return AE_ERROR;
+        else if (obj->type != ACPI_TYPE_BUFFER) {
+                kfree(obj);
+                return AE_ERROR;
+        }
+        if (obj->buffer.length != 4) {
+                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                kfree(obj);
+                return AE_ERROR;
+        }
+
+        return_value = *((struct wmid3_gds_return_value *)obj->buffer.pointer);
+        kfree(obj);
+
+        if (return_value.error_code || return_value.ec_return_value)
+                pr_warning("Set Device Status failed: "
+                        "0x%x - 0x%x\n", return_value.error_code,
+                        return_value.ec_return_value);
+
+        return status;
+}
+
+static acpi_status set_device_status(u32 value, u32 cap)
+{
+        if (wmi_has_guid(WMID_GUID3)) {
+                u16 device;
+
+                switch (cap) {
+                case ACER_CAP_WIRELESS:
+                        device = ACER_WMID3_GDS_WIRELESS;
+                        break;
+                case ACER_CAP_BLUETOOTH:
+                        device = ACER_WMID3_GDS_BLUETOOTH;
+                        break;
+                case ACER_CAP_THREEG:
+                        device = ACER_WMID3_GDS_THREEG;
+                        break;
+                default:
+                        return AE_ERROR;
+                }
+                return wmid3_set_device_status(value, device);
+
+        } else {
+                return set_u32(value, cap);
+        }
+}
+
 /*
  * Rfkill devices
  */
@@ -1160,7 +1291,7 @@ static int acer_rfkill_set(void *data, bool blocked)
         u32 cap = (unsigned long)data;
 
         if (rfkill_inited) {
-                status = set_u32(!blocked, cap);
+                status = set_device_status(!blocked, cap);
                 if (ACPI_FAILURE(status))
                         return -ENODEV;
         }
@@ -1317,7 +1448,7 @@ static void acer_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                pr_warning("bad event status 0x%x\n", status);
+                pr_warn("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -1326,12 +1457,12 @@ static void acer_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                pr_warning("Unknown response received %d\n", obj->type);
+                pr_warn("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
         if (obj->buffer.length != 8) {
-                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -1343,7 +1474,7 @@ static void acer_wmi_notify(u32 value, void *context)
         case WMID_HOTKEY_EVENT:
                 if (return_value.device_state) {
                         u16 device_state = return_value.device_state;
-                        pr_debug("deivces states: 0x%x\n", device_state);
+                        pr_debug("device state: 0x%x\n", device_state);
                         if (has_cap(ACER_CAP_WIRELESS))
                                 rfkill_set_sw_state(wireless_rfkill,
                                 !(device_state & ACER_WMID3_GDS_WIRELESS));
@@ -1356,11 +1487,11 @@ static void acer_wmi_notify(u32 value, void *context)
                 }
                 if (!sparse_keymap_report_event(acer_wmi_input_dev,
                                 return_value.key_num, 1, true))
-                        pr_warning("Unknown key number - 0x%x\n",
+                        pr_warn("Unknown key number - 0x%x\n",
                                 return_value.key_num);
                 break;
         default:
-                pr_warning("Unknown function number - %d - %d\n",
+                pr_warn("Unknown function number - %d - %d\n",
                         return_value.function, return_value.key_num);
                 break;
         }
@@ -1389,7 +1520,7 @@ wmid3_set_lm_mode(struct lm_input_params *params,
                 return AE_ERROR;
         }
         if (obj->buffer.length != 4) {
-                pr_warning("Unknown buffer length %d\n", obj->buffer.length);
+                pr_warn("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return AE_ERROR;
         }
@@ -1414,11 +1545,11 @@ static int acer_wmi_enable_ec_raw(void)
         status = wmid3_set_lm_mode(&params, &return_value);
 
         if (return_value.error_code || return_value.ec_return_value)
-                pr_warning("Enabling EC raw mode failed: "
-                       "0x%x - 0x%x\n", return_value.error_code,
-                       return_value.ec_return_value);
+                pr_warn("Enabling EC raw mode failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
         else
-                pr_info("Enabled EC raw mode");
+                pr_info("Enabled EC raw mode\n");
 
         return status;
 }
@@ -1437,9 +1568,9 @@ static int acer_wmi_enable_lm(void)
         status = wmid3_set_lm_mode(&params, &return_value);
 
         if (return_value.error_code || return_value.ec_return_value)
-                pr_warning("Enabling Launch Manager failed: "
-                       "0x%x - 0x%x\n", return_value.error_code,
-                       return_value.ec_return_value);
+                pr_warn("Enabling Launch Manager failed: 0x%x - 0x%x\n",
+                        return_value.error_code,
+                        return_value.ec_return_value);
 
         return status;
 }
@@ -1506,8 +1637,11 @@ static u32 get_wmid_devices(void)
 
         obj = (union acpi_object *) out.pointer;
         if (obj && obj->type == ACPI_TYPE_BUFFER &&
-                obj->buffer.length == sizeof(u32)) {
+                (obj->buffer.length == sizeof(u32) ||
+                obj->buffer.length == sizeof(u64))) {
                 devices = *((u32 *) obj->buffer.pointer);
+        } else if (obj->type == ACPI_TYPE_INTEGER) {
+                devices = (u32) obj->integer.value;
         }
 
         kfree(out.pointer);
diff --git a/drivers/platform/x86/acerhdf.c b/drivers/platform/x86/acerhdf.c
index 60f9cfcac93f..fca3489218b7 100644
--- a/drivers/platform/x86/acerhdf.c
+++ b/drivers/platform/x86/acerhdf.c
@@ -35,10 +35,8 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/fs.h>
 #include <linux/dmi.h>
-#include <acpi/acpi_drivers.h>
-#include <linux/sched.h>
+#include <linux/acpi.h>
 #include <linux/thermal.h>
 #include <linux/platform_device.h>
 
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index c53b3ff7978a..d65df92e2acc 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -318,7 +318,7 @@ static int acpi_check_handle(acpi_handle handle, const char *method,
 
         if (status != AE_OK) {
                 if (ret)
-                        pr_warning("Error finding %s\n", method);
+                        pr_warn("Error finding %s\n", method);
                 return -ENODEV;
         }
         return 0;
@@ -383,7 +383,7 @@ static int asus_kled_lvl(struct asus_laptop *asus)
         rv = acpi_evaluate_integer(asus->handle, METHOD_KBD_LIGHT_GET,
                                    &params, &kblv);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading kled level\n");
+                pr_warn("Error reading kled level\n");
                 return -ENODEV;
         }
         return kblv;
@@ -397,7 +397,7 @@ static int asus_kled_set(struct asus_laptop *asus, int kblv)
                 kblv = 0;
 
         if (write_acpi_int(asus->handle, METHOD_KBD_LIGHT_SET, kblv)) {
-                pr_warning("Keyboard LED display write failed\n");
+                pr_warn("Keyboard LED display write failed\n");
                 return -EINVAL;
         }
         return 0;
@@ -531,7 +531,7 @@ static int asus_read_brightness(struct backlight_device *bd)
         rv = acpi_evaluate_integer(asus->handle, METHOD_BRIGHTNESS_GET,
                                    NULL, &value);
         if (ACPI_FAILURE(rv))
-                pr_warning("Error reading brightness\n");
+                pr_warn("Error reading brightness\n");
 
         return value;
 }
@@ -541,7 +541,7 @@ static int asus_set_brightness(struct backlight_device *bd, int value)
         struct asus_laptop *asus = bl_get_data(bd);
 
         if (write_acpi_int(asus->handle, METHOD_BRIGHTNESS_SET, value)) {
-                pr_warning("Error changing brightness\n");
+                pr_warn("Error changing brightness\n");
                 return -EIO;
         }
         return 0;
@@ -730,7 +730,7 @@ static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
         rv = parse_arg(buf, count, &value);
         if (rv > 0) {
                 if (write_acpi_int(asus->handle, METHOD_LEDD, value)) {
-                        pr_warning("LED display write failed\n");
+                        pr_warn("LED display write failed\n");
                         return -ENODEV;
                 }
                 asus->ledd_status = (u32) value;
@@ -752,7 +752,7 @@ static int asus_wireless_status(struct asus_laptop *asus, int mask)
         rv = acpi_evaluate_integer(asus->handle, METHOD_WL_STATUS,
                                    NULL, &status);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading Wireless status\n");
+                pr_warn("Error reading Wireless status\n");
                 return -EINVAL;
         }
         return !!(status & mask);
@@ -764,7 +764,7 @@ static int asus_wireless_status(struct asus_laptop *asus, int mask)
 static int asus_wlan_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WLAN, !!status)) {
-                pr_warning("Error setting wlan status to %d", status);
+                pr_warn("Error setting wlan status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -792,7 +792,7 @@ static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
 static int asus_bluetooth_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_BLUETOOTH, !!status)) {
-                pr_warning("Error setting bluetooth status to %d", status);
+                pr_warn("Error setting bluetooth status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -821,7 +821,7 @@ static ssize_t store_bluetooth(struct device *dev,
 static int asus_wimax_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WIMAX, !!status)) {
-                pr_warning("Error setting wimax status to %d", status);
+                pr_warn("Error setting wimax status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -850,7 +850,7 @@ static ssize_t store_wimax(struct device *dev,
 static int asus_wwan_set(struct asus_laptop *asus, int status)
 {
         if (write_acpi_int(asus->handle, METHOD_WWAN, !!status)) {
-                pr_warning("Error setting wwan status to %d", status);
+                pr_warn("Error setting wwan status to %d\n", status);
                 return -EIO;
         }
         return 0;
@@ -880,7 +880,7 @@ static void asus_set_display(struct asus_laptop *asus, int value)
 {
         /* no sanity check needed for now */
         if (write_acpi_int(asus->handle, METHOD_SWITCH_DISPLAY, value))
-                pr_warning("Error setting display\n");
+                pr_warn("Error setting display\n");
         return;
 }
 
@@ -909,7 +909,7 @@ static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
 static void asus_als_switch(struct asus_laptop *asus, int value)
 {
         if (write_acpi_int(asus->handle, METHOD_ALS_CONTROL, value))
-                pr_warning("Error setting light sensor switch\n");
+                pr_warn("Error setting light sensor switch\n");
         asus->light_switch = value;
 }
 
@@ -937,7 +937,7 @@ static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
 static void asus_als_level(struct asus_laptop *asus, int value)
 {
         if (write_acpi_int(asus->handle, METHOD_ALS_LEVEL, value))
-                pr_warning("Error setting light sensor level\n");
+                pr_warn("Error setting light sensor level\n");
         asus->light_level = value;
 }
 
@@ -976,7 +976,7 @@ static int asus_gps_status(struct asus_laptop *asus)
         rv = acpi_evaluate_integer(asus->handle, METHOD_GPS_STATUS,
                                    NULL, &status);
         if (ACPI_FAILURE(rv)) {
-                pr_warning("Error reading GPS status\n");
+                pr_warn("Error reading GPS status\n");
                 return -ENODEV;
         }
         return !!status;
@@ -1284,7 +1284,7 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus->dsdt_info);
         if (ACPI_FAILURE(status))
-                pr_warning("Couldn't get the DSDT table header\n");
+                pr_warn("Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (write_acpi_int_ret(asus->handle, "INIT", 0, &buffer)) {
@@ -1296,7 +1296,7 @@ static int asus_laptop_get_info(struct asus_laptop *asus)
         status =
             acpi_evaluate_integer(asus->handle, "BSTS", NULL, &bsts_result);
         if (ACPI_FAILURE(status))
-                pr_warning("Error calling BSTS\n");
+                pr_warn("Error calling BSTS\n");
         else if (bsts_result)
                 pr_notice("BSTS called, 0x%02x returned\n",
                        (uint) bsts_result);
diff --git a/drivers/platform/x86/asus-wmi.c b/drivers/platform/x86/asus-wmi.c
index 832a3fd7c1c8..00460cb9587b 100644
--- a/drivers/platform/x86/asus-wmi.c
+++ b/drivers/platform/x86/asus-wmi.c
@@ -425,7 +425,7 @@ static void asus_rfkill_hotplug(struct asus_wmi *asus)
         if (asus->hotplug_slot) {
                 bus = pci_find_bus(0, 1);
                 if (!bus) {
-                        pr_warning("Unable to find PCI bus 1?\n");
+                        pr_warn("Unable to find PCI bus 1?\n");
                         goto out_unlock;
                 }
 
@@ -436,12 +436,12 @@ static void asus_rfkill_hotplug(struct asus_wmi *asus)
                 absent = (l == 0xffffffff);
 
                 if (blocked != absent) {
-                        pr_warning("BIOS says wireless lan is %s, "
-                                   "but the pci device is %s\n",
-                                   blocked ? "blocked" : "unblocked",
-                                   absent ? "absent" : "present");
-                        pr_warning("skipped wireless hotplug as probably "
-                                   "inappropriate for this model\n");
+                        pr_warn("BIOS says wireless lan is %s, "
+                                "but the pci device is %s\n",
+                                blocked ? "blocked" : "unblocked",
+                                absent ? "absent" : "present");
+                        pr_warn("skipped wireless hotplug as probably "
+                                "inappropriate for this model\n");
                         goto out_unlock;
                 }
 
@@ -500,7 +500,7 @@ static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
                                                      ACPI_SYSTEM_NOTIFY,
                                                      asus_rfkill_notify, asus);
                 if (ACPI_FAILURE(status))
-                        pr_warning("Failed to register notify on %s\n", node);
+                        pr_warn("Failed to register notify on %s\n", node);
         } else
                 return -ENODEV;
 
@@ -1223,7 +1223,7 @@ static int asus_wmi_sysfs_init(struct platform_device *device)
 /*
  * Platform device
  */
-static int __init asus_wmi_platform_init(struct asus_wmi *asus)
+static int asus_wmi_platform_init(struct asus_wmi *asus)
 {
         int rv;
 
@@ -1583,12 +1583,12 @@ static int asus_wmi_probe(struct platform_device *pdev)
         int ret;
 
         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
-                pr_warning("Management GUID not found\n");
+                pr_warn("Management GUID not found\n");
                 return -ENODEV;
         }
 
         if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
-                pr_warning("Event GUID not found\n");
+                pr_warn("Event GUID not found\n");
                 return -ENODEV;
         }
 
diff --git a/drivers/platform/x86/asus_acpi.c b/drivers/platform/x86/asus_acpi.c
index f503607c0645..d9312b3073e5 100644
--- a/drivers/platform/x86/asus_acpi.c
+++ b/drivers/platform/x86/asus_acpi.c
@@ -30,6 +30,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -581,8 +583,7 @@ static int read_led(const char *ledname, int ledmask)
                 if (read_acpi_int(NULL, ledname, &led_status))
                         return led_status;
                 else
-                        printk(KERN_WARNING "Asus ACPI: Error reading LED "
-                               "status\n");
+                        pr_warn("Error reading LED status\n");
         }
         return (hotk->status & ledmask) ? 1 : 0;
 }
@@ -621,8 +622,7 @@ write_led(const char __user *buffer, unsigned long count,
                 led_out = !led_out;
 
         if (!write_acpi_int(hotk->handle, ledname, led_out, NULL))
-                printk(KERN_WARNING "Asus ACPI: LED (%s) write failed\n",
-                       ledname);
+                pr_warn("LED (%s) write failed\n", ledname);
 
         return rv;
 }
@@ -679,8 +679,7 @@ static ssize_t ledd_proc_write(struct file *file, const char __user *buffer,
         if (rv > 0) {
                 if (!write_acpi_int
                     (hotk->handle, hotk->methods->mt_ledd, value, NULL))
-                        printk(KERN_WARNING
-                               "Asus ACPI: LED display write failed\n");
+                        pr_warn("LED display write failed\n");
                 else
                         hotk->ledd_status = (u32) value;
         }
@@ -838,8 +837,7 @@ static int get_lcd_state(void)
         } else {
                 /* We don't have to check anything if we are here */
                 if (!read_acpi_int(NULL, hotk->methods->lcd_status, &lcd))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading LCD status\n");
+                        pr_warn("Error reading LCD status\n");
 
                 if (hotk->model == L2D)
                         lcd = ~lcd;
@@ -871,7 +869,7 @@ static int set_lcd_state(int value)
                            the exact behaviour is simulated here */
                 }
                 if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING "Asus ACPI: Error switching LCD\n");
+                        pr_warn("Error switching LCD\n");
         }
         return 0;
 
@@ -915,13 +913,11 @@ static int read_brightness(struct backlight_device *bd)
         if (hotk->methods->brightness_get) {    /* SPLV/GPLV laptop */
                 if (!read_acpi_int(hotk->handle, hotk->methods->brightness_get,
                                    &value))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading brightness\n");
+                        pr_warn("Error reading brightness\n");
         } else if (hotk->methods->brightness_status) {  /* For D1 for example */
                 if (!read_acpi_int(NULL, hotk->methods->brightness_status,
                                    &value))
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error reading brightness\n");
+                        pr_warn("Error reading brightness\n");
         } else                  /* No GPLV method */
                 value = hotk->brightness;
         return value;
@@ -939,8 +935,7 @@ static int set_brightness(int value)
         if (hotk->methods->brightness_set) {
                 if (!write_acpi_int(hotk->handle, hotk->methods->brightness_set,
                                     value, NULL)) {
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error changing brightness\n");
+                        pr_warn("Error changing brightness\n");
                         ret = -EIO;
                 }
                 goto out;
@@ -955,8 +950,7 @@ static int set_brightness(int value)
                                               NULL, NULL);
                 (value > 0) ? value-- : value++;
                 if (ACPI_FAILURE(status)) {
-                        printk(KERN_WARNING
-                               "Asus ACPI: Error changing brightness\n");
+                        pr_warn("Error changing brightness\n");
                         ret = -EIO;
                 }
         }
@@ -1008,7 +1002,7 @@ static void set_display(int value)
         /* no sanity check needed for now */
         if (!write_acpi_int(hotk->handle, hotk->methods->display_set,
                             value, NULL))
-                printk(KERN_WARNING "Asus ACPI: Error setting display\n");
+                pr_warn("Error setting display\n");
         return;
 }
 
@@ -1021,8 +1015,7 @@ static int disp_proc_show(struct seq_file *m, void *v)
         int value = 0;
 
         if (!read_acpi_int(hotk->handle, hotk->methods->display_get, &value))
-                printk(KERN_WARNING
-                       "Asus ACPI: Error reading display status\n");
+                pr_warn("Error reading display status\n");
         value &= 0x07;  /* needed for some models, shouldn't hurt others */
         seq_printf(m, "%d\n", value);
         return 0;
@@ -1068,7 +1061,7 @@ asus_proc_add(char *name, const struct file_operations *proc_fops, mode_t mode,
         proc = proc_create_data(name, mode, acpi_device_dir(device),
                                 proc_fops, acpi_driver_data(device));
         if (!proc) {
-                printk(KERN_WARNING "  Unable to create %s fs entry\n", name);
+                pr_warn("  Unable to create %s fs entry\n", name);
                 return -1;
         }
         proc->uid = asus_uid;
@@ -1085,8 +1078,8 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                 mode = S_IFREG | S_IRUGO | S_IWUSR | S_IWGRP;
         } else {
                 mode = S_IFREG | S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
-                printk(KERN_WARNING "  asus_uid and asus_gid parameters are "
-                       "deprecated, use chown and chmod instead!\n");
+                pr_warn("  asus_uid and asus_gid parameters are "
+                        "deprecated, use chown and chmod instead!\n");
         }
 
         acpi_device_dir(device) = asus_proc_dir;
@@ -1099,8 +1092,7 @@ static int asus_hotk_add_fs(struct acpi_device *device)
                 proc->uid = asus_uid;
                 proc->gid = asus_gid;
         } else {
-                printk(KERN_WARNING "  Unable to create " PROC_INFO
-                       " fs entry\n");
+                pr_warn("  Unable to create " PROC_INFO " fs entry\n");
         }
 
         if (hotk->methods->mt_wled) {
@@ -1283,20 +1275,19 @@ static int asus_hotk_get_info(void)
          */
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
         if (ACPI_FAILURE(status))
-                printk(KERN_WARNING "  Couldn't get the DSDT table header\n");
+                pr_warn("  Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
         if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
-                printk(KERN_ERR "  Hotkey initialization failed\n");
+                pr_err("  Hotkey initialization failed\n");
                 return -ENODEV;
         }
 
         /* This needs to be called for some laptops to init properly */
         if (!read_acpi_int(hotk->handle, "BSTS", &bsts_result))
-                printk(KERN_WARNING "  Error calling BSTS\n");
+                pr_warn("  Error calling BSTS\n");
         else if (bsts_result)
-                printk(KERN_NOTICE "  BSTS called, 0x%02x returned\n",
-                       bsts_result);
+                pr_notice("  BSTS called, 0x%02x returned\n", bsts_result);
 
         /*
          * Try to match the object returned by INIT to the specific model.
@@ -1324,23 +1315,21 @@ static int asus_hotk_get_info(void)
                 if (asus_info &&
                     strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
                         hotk->model = P30;
-                        printk(KERN_NOTICE
-                               "  Samsung P30 detected, supported\n");
+                        pr_notice("  Samsung P30 detected, supported\n");
                         hotk->methods = &model_conf[hotk->model];
                         kfree(model);
                         return 0;
                 } else {
                         hotk->model = M2E;
-                        printk(KERN_NOTICE "  unsupported model %s, trying "
-                               "default values\n", string);
-                        printk(KERN_NOTICE
-                               "  send /proc/acpi/dsdt to the developers\n");
+                        pr_notice("  unsupported model %s, trying default values\n",
+                                  string);
+                        pr_notice("  send /proc/acpi/dsdt to the developers\n");
                         kfree(model);
                         return -ENODEV;
                 }
         }
         hotk->methods = &model_conf[hotk->model];
-        printk(KERN_NOTICE "  %s model detected, supported\n", string);
+        pr_notice("  %s model detected, supported\n", string);
 
         /* Sort of per-model blacklist */
         if (strncmp(string, "L2B", 3) == 0)
@@ -1385,7 +1374,7 @@ static int asus_hotk_check(void)
         if (hotk->device->status.present) {
                 result = asus_hotk_get_info();
         } else {
-                printk(KERN_ERR "  Hotkey device not present, aborting\n");
+                pr_err("  Hotkey device not present, aborting\n");
                 return -EINVAL;
         }
 
@@ -1399,8 +1388,7 @@ static int asus_hotk_add(struct acpi_device *device)
         acpi_status status = AE_OK;
         int result;
 
-        printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
-               ASUS_ACPI_VERSION);
+        pr_notice("Asus Laptop ACPI Extras version %s\n", ASUS_ACPI_VERSION);
 
         hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
         if (!hotk)
@@ -1428,15 +1416,14 @@ static int asus_hotk_add(struct acpi_device *device)
                     acpi_evaluate_object(NULL, hotk->methods->brightness_down,
                                          NULL, NULL);
                 if (ACPI_FAILURE(status))
-                        printk(KERN_WARNING "  Error changing brightness\n");
+                        pr_warn("  Error changing brightness\n");
                 else {
                         status =
                             acpi_evaluate_object(NULL,
                                                  hotk->methods->brightness_up,
                                                  NULL, NULL);
                         if (ACPI_FAILURE(status))
-                                printk(KERN_WARNING "  Strange, error changing"
-                                       " brightness\n");
+                                pr_warn("  Strange, error changing brightness\n");
                 }
         }
 
@@ -1488,7 +1475,7 @@ static int __init asus_acpi_init(void)
 
         asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir);
         if (!asus_proc_dir) {
-                printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n");
+                pr_err("Unable to create /proc entry\n");
                 acpi_bus_unregister_driver(&asus_hotk_driver);
                 return -ENODEV;
         }
@@ -1513,7 +1500,7 @@ static int __init asus_acpi_init(void)
                                                           &asus_backlight_data,
                                                           &props);
         if (IS_ERR(asus_backlight_device)) {
-                printk(KERN_ERR "Could not register asus backlight device\n");
+                pr_err("Could not register asus backlight device\n");
                 asus_backlight_device = NULL;
                 asus_acpi_exit();
                 return -ENODEV;
diff --git a/drivers/platform/x86/compal-laptop.c b/drivers/platform/x86/compal-laptop.c
index c16a27641ced..3f204fde1b02 100644
--- a/drivers/platform/x86/compal-laptop.c
+++ b/drivers/platform/x86/compal-laptop.c
@@ -68,6 +68,8 @@
  * only enabled on a JHL90 board until it is verified that they work on the
  * other boards too.  See the extra_features variable. */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -200,8 +202,8 @@ static bool extra_features;
  * watching the output of address 0x4F (do an ec_transaction writing 0x33
  * into 0x4F and read a few bytes from the output, like so:
  *      u8 writeData = 0x33;
- *      ec_transaction(0x4F, &writeData, 1, buffer, 32, 0);
- * That address is labelled "fan1 table information" in the service manual.
+ *      ec_transaction(0x4F, &writeData, 1, buffer, 32);
+ * That address is labeled "fan1 table information" in the service manual.
  * It should be clear which value in 'buffer' changes). This seems to be
  * related to fan speed. It isn't a proper 'realtime' fan speed value
  * though, because physically stopping or speeding up the fan doesn't
@@ -286,7 +288,7 @@ static int get_backlight_level(void)
 static void set_backlight_state(bool on)
 {
         u8 data = on ? BACKLIGHT_STATE_ON_DATA : BACKLIGHT_STATE_OFF_DATA;
-        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0, 0);
+        ec_transaction(BACKLIGHT_STATE_ADDR, &data, 1, NULL, 0);
 }
 
 
@@ -294,24 +296,24 @@ static void set_backlight_state(bool on)
 static void pwm_enable_control(void)
 {
         unsigned char writeData = PWM_ENABLE_DATA;
-        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0, 0);
+        ec_transaction(PWM_ENABLE_ADDR, &writeData, 1, NULL, 0);
 }
 
 static void pwm_disable_control(void)
 {
         unsigned char writeData = PWM_DISABLE_DATA;
-        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0, 0);
+        ec_transaction(PWM_DISABLE_ADDR, &writeData, 1, NULL, 0);
 }
 
 static void set_pwm(int pwm)
 {
-        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0, 0);
+        ec_transaction(PWM_ADDRESS, &pwm_lookup_table[pwm], 1, NULL, 0);
 }
 
 static int get_fan_rpm(void)
 {
         u8 value, data = FAN_DATA;
-        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1, 0);
+        ec_transaction(FAN_ADDRESS, &data, 1, &value, 1);
         return 100 * (int)value;
 }
 
@@ -760,16 +762,14 @@ static struct rfkill *bt_rfkill;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s'\n",
-                id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         extra_features = false;
         return 1;
 }
 
 static int dmi_check_cb_extra(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO DRIVER_NAME": Identified laptop model '%s', "
-                "enabling extra features\n",
+        pr_info("Identified laptop model '%s', enabling extra features\n",
                 id->ident);
         extra_features = true;
         return 1;
@@ -956,14 +956,12 @@ static int __init compal_init(void)
         int ret;
 
         if (acpi_disabled) {
-                printk(KERN_ERR DRIVER_NAME": ACPI needs to be enabled for "
-                                                "this driver to work!\n");
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
                 return -ENODEV;
         }
 
         if (!force && !dmi_check_system(compal_dmi_table)) {
-                printk(KERN_ERR DRIVER_NAME": Motherboard not recognized (You "
-                                "could try the module's force-parameter)");
+                pr_err("Motherboard not recognized (You could try the module's force-parameter)\n");
                 return -ENODEV;
         }
 
@@ -998,8 +996,7 @@ static int __init compal_init(void)
         if (ret)
                 goto err_rfkill;
 
-        printk(KERN_INFO DRIVER_NAME": Driver "DRIVER_VERSION
-                                                " successfully loaded\n");
+        pr_info("Driver " DRIVER_VERSION " successfully loaded\n");
         return 0;
 
 err_rfkill:
@@ -1064,7 +1061,7 @@ static void __exit compal_cleanup(void)
         rfkill_destroy(wifi_rfkill);
         rfkill_destroy(bt_rfkill);
 
-        printk(KERN_INFO DRIVER_NAME": Driver unloaded\n");
+        pr_info("Driver unloaded\n");
 }
 
 static int __devexit compal_remove(struct platform_device *pdev)
@@ -1074,8 +1071,7 @@ static int __devexit compal_remove(struct platform_device *pdev)
         if (!extra_features)
                 return 0;
 
-        printk(KERN_INFO DRIVER_NAME": Unloading: resetting fan control "
-                                                        "to motherboard\n");
+        pr_info("Unloading: resetting fan control to motherboard\n");
         pwm_disable_control();
 
         data = platform_get_drvdata(pdev);
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index de301aa8e5c3..d3841de6a8cf 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -11,6 +11,8 @@
  *  published by the Free Software Foundation.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -434,8 +436,7 @@ static int __init dell_setup_rfkill(void)
         int ret;
 
         if (dmi_check_system(dell_blacklist)) {
-                printk(KERN_INFO "dell-laptop: Blacklisted hardware detected - "
-                                "not enabling rfkill\n");
+                pr_info("Blacklisted hardware detected - not enabling rfkill\n");
                 return 0;
         }
 
@@ -606,7 +607,7 @@ static int __init dell_init(void)
         dmi_walk(find_tokens, NULL);
 
         if (!da_tokens)  {
-                printk(KERN_INFO "dell-laptop: Unable to find dmi tokens\n");
+                pr_info("Unable to find dmi tokens\n");
                 return -ENODEV;
         }
 
@@ -636,14 +637,13 @@ static int __init dell_init(void)
         ret = dell_setup_rfkill();
 
         if (ret) {
-                printk(KERN_WARNING "dell-laptop: Unable to setup rfkill\n");
+                pr_warn("Unable to setup rfkill\n");
                 goto fail_rfkill;
         }
 
         ret = i8042_install_filter(dell_laptop_i8042_filter);
         if (ret) {
-                printk(KERN_WARNING
-                       "dell-laptop: Unable to install key filter\n");
+                pr_warn("Unable to install key filter\n");
                 goto fail_filter;
         }
 
diff --git a/drivers/platform/x86/dell-wmi-aio.c b/drivers/platform/x86/dell-wmi-aio.c
index 0ed84573ae1f..3f945457f71c 100644
--- a/drivers/platform/x86/dell-wmi-aio.c
+++ b/drivers/platform/x86/dell-wmi-aio.c
@@ -15,6 +15,7 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
+
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
@@ -138,7 +139,7 @@ static int __init dell_wmi_aio_init(void)
 
         guid = dell_wmi_aio_find();
         if (!guid) {
-                pr_warning("No known WMI GUID found\n");
+                pr_warn("No known WMI GUID found\n");
                 return -ENXIO;
         }
 
diff --git a/drivers/platform/x86/dell-wmi.c b/drivers/platform/x86/dell-wmi.c
index 77f1d55414c6..ce790827e199 100644
--- a/drivers/platform/x86/dell-wmi.c
+++ b/drivers/platform/x86/dell-wmi.c
@@ -23,6 +23,8 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -141,7 +143,7 @@ static void dell_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO "dell-wmi: bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -153,8 +155,8 @@ static void dell_wmi_notify(u32 value, void *context)
                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
 
                 if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
-                        printk(KERN_INFO "dell-wmi: Received unknown WMI event"
-                                         " (0x%x)\n", buffer_entry[1]);
+                        pr_info("Received unknown WMI event (0x%x)\n",
+                                buffer_entry[1]);
                         kfree(obj);
                         return;
                 }
@@ -167,8 +169,7 @@ static void dell_wmi_notify(u32 value, void *context)
                 key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
                                                         reported_key);
                 if (!key) {
-                        printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
-                                reported_key);
+                        pr_info("Unknown key %x pressed\n", reported_key);
                 } else if ((key->keycode == KEY_BRIGHTNESSUP ||
                             key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
                         /* Don't report brightness notifications that will also
@@ -275,7 +276,7 @@ static int __init dell_wmi_init(void)
         acpi_status status;
 
         if (!wmi_has_guid(DELL_EVENT_GUID)) {
-                printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
+                pr_warn("No known WMI GUID found\n");
                 return -ENODEV;
         }
 
@@ -290,9 +291,7 @@ static int __init dell_wmi_init(void)
                                          dell_wmi_notify, NULL);
         if (ACPI_FAILURE(status)) {
                 dell_wmi_input_destroy();
-                printk(KERN_ERR
-                        "dell-wmi: Unable to register notify handler - %d\n",
-                        status);
+                pr_err("Unable to register notify handler - %d\n", status);
                 return -ENODEV;
         }
 
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 2c1abf63957f..1c45d92e2163 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -228,7 +228,7 @@ static int set_acpi(struct eeepc_laptop *eeepc, int cm, int value)
                 return -ENODEV;
 
         if (write_acpi_int(eeepc->handle, method, value))
-                pr_warning("Error writing %s\n", method);
+                pr_warn("Error writing %s\n", method);
         return 0;
 }
 
@@ -243,7 +243,7 @@ static int get_acpi(struct eeepc_laptop *eeepc, int cm)
                 return -ENODEV;
 
         if (read_acpi_int(eeepc->handle, method, &value))
-                pr_warning("Error reading %s\n", method);
+                pr_warn("Error reading %s\n", method);
         return value;
 }
 
@@ -261,7 +261,7 @@ static int acpi_setter_handle(struct eeepc_laptop *eeepc, int cm,
         status = acpi_get_handle(eeepc->handle, (char *)method,
                                  handle);
         if (status != AE_OK) {
-                pr_warning("Error finding %s\n", method);
+                pr_warn("Error finding %s\n", method);
                 return -ENODEV;
         }
         return 0;
@@ -417,7 +417,7 @@ static ssize_t store_cpufv_disabled(struct device *dev,
         switch (value) {
         case 0:
                 if (eeepc->cpufv_disabled)
-                        pr_warning("cpufv enabled (not officially supported "
+                        pr_warn("cpufv enabled (not officially supported "
                                 "on this model)\n");
                 eeepc->cpufv_disabled = false;
                 return rv;
@@ -609,7 +609,7 @@ static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
                 bus = port->subordinate;
 
                 if (!bus) {
-                        pr_warning("Unable to find PCI bus?\n");
+                        pr_warn("Unable to find PCI bus 1?\n");
                         goto out_unlock;
                 }
 
@@ -621,12 +621,12 @@ static void eeepc_rfkill_hotplug(struct eeepc_laptop *eeepc, acpi_handle handle)
                 absent = (l == 0xffffffff);
 
                 if (blocked != absent) {
-                        pr_warning("BIOS says wireless lan is %s, "
-                                        "but the pci device is %s\n",
+                        pr_warn("BIOS says wireless lan is %s, "
+                                "but the pci device is %s\n",
                                 blocked ? "blocked" : "unblocked",
                                 absent ? "absent" : "present");
-                        pr_warning("skipped wireless hotplug as probably "
-                                        "inappropriate for this model\n");
+                        pr_warn("skipped wireless hotplug as probably "
+                                "inappropriate for this model\n");
                         goto out_unlock;
                 }
 
@@ -691,7 +691,8 @@ static int eeepc_register_rfkill_notifier(struct eeepc_laptop *eeepc,
                                                      eeepc_rfkill_notify,
                                                      eeepc);
                 if (ACPI_FAILURE(status))
-                        pr_warning("Failed to register notify on %s\n", node);
+                        pr_warn("Failed to register notify on %s\n", node);
+
                 /*
                  * Refresh pci hotplug in case the rfkill state was
                  * changed during setup.
diff --git a/drivers/platform/x86/eeepc-wmi.c b/drivers/platform/x86/eeepc-wmi.c
index 649dcadd8ea3..4aa867a9b88b 100644
--- a/drivers/platform/x86/eeepc-wmi.c
+++ b/drivers/platform/x86/eeepc-wmi.c
@@ -84,7 +84,7 @@ static const struct key_entry eeepc_wmi_keymap[] = {
 static acpi_status eeepc_wmi_parse_device(acpi_handle handle, u32 level,
                                                  void *context, void **retval)
 {
-        pr_warning("Found legacy ATKD device (%s)", EEEPC_ACPI_HID);
+        pr_warn("Found legacy ATKD device (%s)\n", EEEPC_ACPI_HID);
         *(bool *)context = true;
         return AE_CTRL_TERMINATE;
 }
@@ -105,12 +105,12 @@ static int eeepc_wmi_check_atkd(void)
 static int eeepc_wmi_probe(struct platform_device *pdev)
 {
         if (eeepc_wmi_check_atkd()) {
-                pr_warning("WMI device present, but legacy ATKD device is also "
-                           "present and enabled.");
-                pr_warning("You probably booted with acpi_osi=\"Linux\" or "
-                           "acpi_osi=\"!Windows 2009\"");
-                pr_warning("Can't load eeepc-wmi, use default acpi_osi "
-                           "(preferred) or eeepc-laptop");
+                pr_warn("WMI device present, but legacy ATKD device is also "
+                        "present and enabled\n");
+                pr_warn("You probably booted with acpi_osi=\"Linux\" or "
+                        "acpi_osi=\"!Windows 2009\"\n");
+                pr_warn("Can't load eeepc-wmi, use default acpi_osi "
+                        "(preferred) or eeepc-laptop\n");
                 return -EBUSY;
         }
         return 0;
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index 493054c2dbe1..6b26666b37f2 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -56,6 +56,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -585,8 +587,7 @@ static struct platform_driver fujitsupf_driver = {
 static void dmi_check_cb_common(const struct dmi_system_id *id)
 {
         acpi_handle handle;
-        printk(KERN_INFO "fujitsu-laptop: Identified laptop model '%s'.\n",
-               id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         if (use_alt_lcd_levels == -1) {
                 if (ACPI_SUCCESS(acpi_get_handle(NULL,
                                 "\\_SB.PCI0.LPCB.FJEX.SBL2", &handle)))
@@ -691,11 +692,11 @@ static int acpi_fujitsu_add(struct acpi_device *device)
 
         result = acpi_bus_update_power(fujitsu->acpi_handle, &state);
         if (result) {
-                printk(KERN_ERR "Error reading power state\n");
+                pr_err("Error reading power state\n");
                 goto err_unregister_input_dev;
         }
 
-        printk(KERN_INFO "ACPI: %s [%s] (%s)\n",
+        pr_info("ACPI: %s [%s] (%s)\n",
                acpi_device_name(device), acpi_device_bid(device),
                !device->power.state ? "on" : "off");
 
@@ -707,7 +708,7 @@ static int acpi_fujitsu_add(struct acpi_device *device)
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
-                        printk(KERN_ERR "_INI Method failed\n");
+                        pr_err("_INI Method failed\n");
         }
 
         /* do config (detect defaults) */
@@ -827,7 +828,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
         error = kfifo_alloc(&fujitsu_hotkey->fifo, RINGBUFFERSIZE * sizeof(int),
                         GFP_KERNEL);
         if (error) {
-                printk(KERN_ERR "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 goto err_stop;
         }
 
@@ -859,13 +860,13 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
 
         result = acpi_bus_update_power(fujitsu_hotkey->acpi_handle, &state);
         if (result) {
-                printk(KERN_ERR "Error reading power state\n");
+                pr_err("Error reading power state\n");
                 goto err_unregister_input_dev;
         }
 
-        printk(KERN_INFO "ACPI: %s [%s] (%s)\n",
-               acpi_device_name(device), acpi_device_bid(device),
-               !device->power.state ? "on" : "off");
+        pr_info("ACPI: %s [%s] (%s)\n",
+                acpi_device_name(device), acpi_device_bid(device),
+                !device->power.state ? "on" : "off");
 
         fujitsu_hotkey->dev = device;
 
@@ -875,7 +876,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (ACPI_FAILURE
                     (acpi_evaluate_object
                      (device->handle, METHOD_NAME__INI, NULL, NULL)))
-                        printk(KERN_ERR "_INI Method failed\n");
+                        pr_err("_INI Method failed\n");
         }
 
         i = 0;
@@ -897,8 +898,7 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                         call_fext_func(FUNC_RFKILL, 0x4, 0x0, 0x0);
 
         /* Suspect this is a keymap of the application panel, print it */
-        printk(KERN_INFO "fujitsu-laptop: BTNI: [0x%x]\n",
-                call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0));
+        pr_info("BTNI: [0x%x]\n", call_fext_func(FUNC_BUTTONS, 0x0, 0x0, 0x0));
 
 #if defined(CONFIG_LEDS_CLASS) || defined(CONFIG_LEDS_CLASS_MODULE)
         if (call_fext_func(FUNC_LEDS, 0x0, 0x0, 0x0) & LOGOLAMP_POWERON) {
@@ -907,8 +907,8 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (result == 0) {
                         fujitsu_hotkey->logolamp_registered = 1;
                 } else {
-                        printk(KERN_ERR "fujitsu-laptop: Could not register "
-                        "LED handler for logo lamp, error %i\n", result);
+                        pr_err("Could not register LED handler for logo lamp, error %i\n",
+                               result);
                 }
         }
 
@@ -919,8 +919,8 @@ static int acpi_fujitsu_hotkey_add(struct acpi_device *device)
                 if (result == 0) {
                         fujitsu_hotkey->kblamps_registered = 1;
                 } else {
-                        printk(KERN_ERR "fujitsu-laptop: Could not register "
-                        "LED handler for keyboard lamps, error %i\n", result);
+                        pr_err("Could not register LED handler for keyboard lamps, error %i\n",
+                               result);
                 }
         }
 #endif
@@ -1169,8 +1169,7 @@ static int __init fujitsu_init(void)
                         fujitsu->bl_device->props.power = 0;
         }
 
-        printk(KERN_INFO "fujitsu-laptop: driver " FUJITSU_DRIVER_VERSION
-               " successfully loaded.\n");
+        pr_info("driver " FUJITSU_DRIVER_VERSION " successfully loaded\n");
 
         return 0;
 
@@ -1216,7 +1215,7 @@ static void __exit fujitsu_cleanup(void)
 
         kfree(fujitsu);
 
-        printk(KERN_INFO "fujitsu-laptop: driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(fujitsu_init);
diff --git a/drivers/platform/x86/hdaps.c b/drivers/platform/x86/hdaps.c
index 067bf36d32f3..5a34973dc164 100644
--- a/drivers/platform/x86/hdaps.c
+++ b/drivers/platform/x86/hdaps.c
@@ -26,6 +26,8 @@
  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/input-polldev.h>
@@ -238,7 +240,7 @@ static int hdaps_device_init(void)
                      __check_latch(0x1611, 0x01))
                 goto out;
 
-        printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x).\n",
+        printk(KERN_DEBUG "hdaps: initial latch check good (0x%02x)\n",
                __get_latch(0x1611));
 
         outb(0x17, 0x1610);
@@ -299,7 +301,7 @@ static int hdaps_probe(struct platform_device *dev)
         if (ret)
                 return ret;
 
-        printk(KERN_INFO "hdaps: device successfully initialized.\n");
+        pr_info("device successfully initialized\n");
         return 0;
 }
 
@@ -480,7 +482,7 @@ static struct attribute_group hdaps_attribute_group = {
 /* hdaps_dmi_match - found a match.  return one, short-circuiting the hunt. */
 static int __init hdaps_dmi_match(const struct dmi_system_id *id)
 {
-        printk(KERN_INFO "hdaps: %s detected.\n", id->ident);
+        pr_info("%s detected\n", id->ident);
         return 1;
 }
 
@@ -488,8 +490,7 @@ static int __init hdaps_dmi_match(const struct dmi_system_id *id)
 static int __init hdaps_dmi_match_invert(const struct dmi_system_id *id)
 {
         hdaps_invert = (unsigned long)id->driver_data;
-        printk(KERN_INFO "hdaps: inverting axis (%u) readings.\n",
-               hdaps_invert);
+        pr_info("inverting axis (%u) readings\n", hdaps_invert);
         return hdaps_dmi_match(id);
 }
 
@@ -543,7 +544,7 @@ static int __init hdaps_init(void)
         int ret;
 
         if (!dmi_check_system(hdaps_whitelist)) {
-                printk(KERN_WARNING "hdaps: supported laptop not found!\n");
+                pr_warn("supported laptop not found!\n");
                 ret = -ENODEV;
                 goto out;
         }
@@ -595,7 +596,7 @@ static int __init hdaps_init(void)
         if (ret)
                 goto out_idev;
 
-        printk(KERN_INFO "hdaps: driver successfully loaded.\n");
+        pr_info("driver successfully loaded\n");
         return 0;
 
 out_idev:
@@ -609,7 +610,7 @@ out_driver:
 out_region:
         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 out:
-        printk(KERN_WARNING "hdaps: driver init failed (ret=%d)!\n", ret);
+        pr_warn("driver init failed (ret=%d)!\n", ret);
         return ret;
 }
 
@@ -622,7 +623,7 @@ static void __exit hdaps_exit(void)
         platform_driver_unregister(&hdaps_driver);
         release_region(HDAPS_LOW_PORT, HDAPS_NR_PORTS);
 
-        printk(KERN_INFO "hdaps: driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(hdaps_init);
diff --git a/drivers/platform/x86/hp-wmi.c b/drivers/platform/x86/hp-wmi.c
index 1bc4a7539ba9..f94017bcdd6e 100644
--- a/drivers/platform/x86/hp-wmi.c
+++ b/drivers/platform/x86/hp-wmi.c
@@ -24,6 +24,8 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -54,9 +56,6 @@ MODULE_ALIAS("wmi:5FB7F034-2C63-45e9-BE91-3D44E2C707E4");
 #define HPWMI_HOTKEY_QUERY 0xc
 #define HPWMI_WIRELESS2_QUERY 0x1b
 
-#define PREFIX "HP WMI: "
-#define UNIMP "Unimplemented "
-
 enum hp_wmi_radio {
         HPWMI_WIFI = 0,
         HPWMI_BLUETOOTH = 1,
@@ -228,9 +227,8 @@ static int hp_wmi_perform_query(int query, int write, void *buffer,
 
         if (bios_return->return_code) {
                 if (bios_return->return_code != HPWMI_RET_UNKNOWN_CMDTYPE)
-                        printk(KERN_WARNING PREFIX "query 0x%x returned "
-                                                   "error 0x%x\n",
-                               query, bios_return->return_code);
+                        pr_warn("query 0x%x returned error 0x%x\n",
+                                query, bios_return->return_code);
                 kfree(obj);
                 return bios_return->return_code;
         }
@@ -384,8 +382,7 @@ static int hp_wmi_rfkill2_refresh(void)
 
                 if (num >= state.count ||
                     devstate->rfkill_id != rfkill2[i].id) {
-                        printk(KERN_WARNING PREFIX "power configuration of "
-                               "the wireless devices unexpectedly changed\n");
+                        pr_warn("power configuration of the wireless devices unexpectedly changed\n");
                         continue;
                 }
 
@@ -471,7 +468,7 @@ static void hp_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO PREFIX "bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -480,8 +477,7 @@ static void hp_wmi_notify(u32 value, void *context)
         if (!obj)
                 return;
         if (obj->type != ACPI_TYPE_BUFFER) {
-                printk(KERN_INFO "hp-wmi: Unknown response received %d\n",
-                       obj->type);
+                pr_info("Unknown response received %d\n", obj->type);
                 kfree(obj);
                 return;
         }
@@ -498,8 +494,7 @@ static void hp_wmi_notify(u32 value, void *context)
                 event_id = *location;
                 event_data = *(location + 2);
         } else {
-                printk(KERN_INFO "hp-wmi: Unknown buffer length %d\n",
-                       obj->buffer.length);
+                pr_info("Unknown buffer length %d\n", obj->buffer.length);
                 kfree(obj);
                 return;
         }
@@ -527,8 +522,7 @@ static void hp_wmi_notify(u32 value, void *context)
 
                 if (!sparse_keymap_report_event(hp_wmi_input_dev,
                                                 key_code, 1, true))
-                        printk(KERN_INFO PREFIX "Unknown key code - 0x%x\n",
-                               key_code);
+                        pr_info("Unknown key code - 0x%x\n", key_code);
                 break;
         case HPWMI_WIRELESS:
                 if (rfkill2_count) {
@@ -550,14 +544,12 @@ static void hp_wmi_notify(u32 value, void *context)
                                           hp_wmi_get_hw_state(HPWMI_WWAN));
                 break;
         case HPWMI_CPU_BATTERY_THROTTLE:
-                printk(KERN_INFO PREFIX UNIMP "CPU throttle because of 3 Cell"
-                       " battery event detected\n");
+                pr_info("Unimplemented CPU throttle because of 3 Cell battery event detected\n");
                 break;
         case HPWMI_LOCK_SWITCH:
                 break;
         default:
-                printk(KERN_INFO PREFIX "Unknown event_id - %d - 0x%x\n",
-                       event_id, event_data);
+                pr_info("Unknown event_id - %d - 0x%x\n", event_id, event_data);
                 break;
         }
 }
@@ -705,7 +697,7 @@ static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
                 return err;
 
         if (state.count > HPWMI_MAX_RFKILL2_DEVICES) {
-                printk(KERN_WARNING PREFIX "unable to parse 0x1b query output\n");
+                pr_warn("unable to parse 0x1b query output\n");
                 return -EINVAL;
         }
 
@@ -727,14 +719,14 @@ static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
                         name = "hp-wwan";
                         break;
                 default:
-                        printk(KERN_WARNING PREFIX "unknown device type 0x%x\n",
-                                 state.device[i].radio_type);
+                        pr_warn("unknown device type 0x%x\n",
+                                state.device[i].radio_type);
                         continue;
                 }
 
                 if (!state.device[i].vendor_id) {
-                        printk(KERN_WARNING PREFIX "zero device %d while %d "
-                               "reported\n", i, state.count);
+                        pr_warn("zero device %d while %d reported\n",
+                                i, state.count);
                         continue;
                 }
 
@@ -755,8 +747,7 @@ static int __devinit hp_wmi_rfkill2_setup(struct platform_device *device)
                                     IS_HWBLOCKED(state.device[i].power));
 
                 if (!(state.device[i].power & HPWMI_POWER_BIOS))
-                        printk(KERN_INFO PREFIX "device %s blocked by BIOS\n",
-                               name);
+                        pr_info("device %s blocked by BIOS\n", name);
 
                 err = rfkill_register(rfkill);
                 if (err) {
diff --git a/drivers/platform/x86/ibm_rtl.c b/drivers/platform/x86/ibm_rtl.c
index b1396e5b2953..811d436cd677 100644
--- a/drivers/platform/x86/ibm_rtl.c
+++ b/drivers/platform/x86/ibm_rtl.c
@@ -22,6 +22,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/delay.h>
 #include <linux/module.h>
@@ -69,9 +71,10 @@ struct ibm_rtl_table {
 #define RTL_SIGNATURE 0x0000005f4c54525fULL
 #define RTL_MASK      0x000000ffffffffffULL
 
-#define RTL_DEBUG(A, ...) do { \
-        if (debug) \
-                pr_info("ibm-rtl: " A, ##__VA_ARGS__ ); \
+#define RTL_DEBUG(fmt, ...)                             \
+do {                                                    \
+        if (debug)                                      \
+                pr_info(fmt, ##__VA_ARGS__);            \
 } while (0)
 
 static DEFINE_MUTEX(rtl_lock);
@@ -114,7 +117,7 @@ static int ibm_rtl_write(u8 value)
         int ret = 0, count = 0;
         static u32 cmd_port_val;
 
-        RTL_DEBUG("%s(%d)\n", __FUNCTION__, value);
+        RTL_DEBUG("%s(%d)\n", __func__, value);
 
         value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM;
 
@@ -144,8 +147,8 @@ static int ibm_rtl_write(u8 value)
                 while (ioread8(&rtl_table->command)) {
                         msleep(10);
                         if (count++ > 500) {
-                                pr_err("ibm-rtl: Hardware not responding to "
-                                        "mode switch request\n");
+                                pr_err("Hardware not responding to "
+                                       "mode switch request\n");
                                 ret = -EIO;
                                 break;
                         }
@@ -250,7 +253,7 @@ static int __init ibm_rtl_init(void) {
         int ret = -ENODEV, i;
 
         if (force)
-                pr_warning("ibm-rtl: module loaded by force\n");
+                pr_warn("module loaded by force\n");
         /* first ensure that we are running on IBM HW */
         else if (efi_enabled || !dmi_check_system(ibm_rtl_dmi_table))
                 return -ENODEV;
@@ -288,19 +291,19 @@ static int __init ibm_rtl_init(void) {
                 if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) {
                         phys_addr_t addr;
                         unsigned int plen;
-                        RTL_DEBUG("found RTL_SIGNATURE at %#llx\n", (u64)tmp);
+                        RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
                         rtl_table = tmp;
                         /* The address, value, width and offset are platform
                          * dependent and found in the ibm_rtl_table */
                         rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);
                         rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);
                         RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n",
-                              rtl_cmd_width, rtl_cmd_type);
+                                  rtl_cmd_width, rtl_cmd_type);
                         addr = ioread32(&rtl_table->cmd_port_address);
                         RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
                         plen = rtl_cmd_width/sizeof(char);
                         rtl_cmd_addr = rtl_port_map(addr, plen);
-                        RTL_DEBUG("rtl_cmd_addr = %#llx\n", (u64)rtl_cmd_addr);
+                        RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
                         if (!rtl_cmd_addr) {
                                 ret = -ENOMEM;
                                 break;
diff --git a/drivers/platform/x86/ideapad-laptop.c b/drivers/platform/x86/ideapad-laptop.c
index 21b101899bae..bfdda33feb26 100644
--- a/drivers/platform/x86/ideapad-laptop.c
+++ b/drivers/platform/x86/ideapad-laptop.c
@@ -20,6 +20,8 @@
  *  02110-1301, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
diff --git a/drivers/platform/x86/intel_menlow.c b/drivers/platform/x86/intel_menlow.c
index eacd5da7dd24..809adea4965f 100644
--- a/drivers/platform/x86/intel_menlow.c
+++ b/drivers/platform/x86/intel_menlow.c
@@ -27,6 +27,8 @@
  *  to get/set bandwidth.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -135,8 +137,7 @@ static int memory_set_cur_bandwidth(struct thermal_cooling_device *cdev,
             acpi_evaluate_integer(handle, MEMORY_SET_BANDWIDTH, &arg_list,
                                   &temp);
 
-        printk(KERN_INFO
-               "Bandwidth value was %ld: status is %d\n", state, status);
+        pr_info("Bandwidth value was %ld: status is %d\n", state, status);
         if (ACPI_FAILURE(status))
                 return -EFAULT;
 
diff --git a/drivers/platform/x86/intel_mid_powerbtn.c b/drivers/platform/x86/intel_mid_powerbtn.c
index 213e79ba68d5..f1ae5078b7ec 100644
--- a/drivers/platform/x86/intel_mid_powerbtn.c
+++ b/drivers/platform/x86/intel_mid_powerbtn.c
@@ -23,58 +23,48 @@
 #include <linux/slab.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
+
 #include <asm/intel_scu_ipc.h>
 
 #define DRIVER_NAME "msic_power_btn"
 
-#define MSIC_IRQ_STAT   0x02
-  #define MSIC_IRQ_PB   (1 << 0)
-#define MSIC_PB_CONFIG  0x3e
 #define MSIC_PB_STATUS  0x3f
-  #define MSIC_PB_LEVEL (1 << 3) /* 1 - release, 0 - press */
-
-struct mfld_pb_priv {
-        struct input_dev *input;
-        unsigned int irq;
-};
+#define MSIC_PB_LEVEL   (1 << 3) /* 1 - release, 0 - press */
 
 static irqreturn_t mfld_pb_isr(int irq, void *dev_id)
 {
-        struct mfld_pb_priv *priv = dev_id;
+        struct input_dev *input = dev_id;
         int ret;
         u8 pbstat;
 
         ret = intel_scu_ipc_ioread8(MSIC_PB_STATUS, &pbstat);
-        if (ret < 0)
-                return IRQ_HANDLED;
-
-        input_event(priv->input, EV_KEY, KEY_POWER, !(pbstat & MSIC_PB_LEVEL));
-        input_sync(priv->input);
+        if (ret < 0) {
+                dev_err(input->dev.parent, "Read error %d while reading"
+                               " MSIC_PB_STATUS\n", ret);
+        } else {
+                input_event(input, EV_KEY, KEY_POWER,
+                               !(pbstat & MSIC_PB_LEVEL));
+                input_sync(input);
+        }
 
         return IRQ_HANDLED;
 }
 
 static int __devinit mfld_pb_probe(struct platform_device *pdev)
 {
-        struct mfld_pb_priv *priv;
         struct input_dev *input;
-        int irq;
+        int irq = platform_get_irq(pdev, 0);
         int error;
 
-        irq = platform_get_irq(pdev, 0);
         if (irq < 0)
                 return -EINVAL;
 
-        priv = kzalloc(sizeof(struct mfld_pb_priv), GFP_KERNEL);
         input = input_allocate_device();
-        if (!priv || !input) {
-                error = -ENOMEM;
-                goto err_free_mem;
+        if (!input) {
+                dev_err(&pdev->dev, "Input device allocation error\n");
+                return -ENOMEM;
         }
 
-        priv->input = input;
-        priv->irq = irq;
-
         input->name = pdev->name;
         input->phys = "power-button/input0";
         input->id.bustype = BUS_HOST;
@@ -82,42 +72,40 @@ static int __devinit mfld_pb_probe(struct platform_device *pdev)
 
         input_set_capability(input, EV_KEY, KEY_POWER);
 
-        error = request_threaded_irq(priv->irq, NULL, mfld_pb_isr,
-                                     0, DRIVER_NAME, priv);
+        error = request_threaded_irq(irq, NULL, mfld_pb_isr, 0,
+                        DRIVER_NAME, input);
         if (error) {
-                dev_err(&pdev->dev,
-                        "unable to request irq %d for mfld power button\n",
-                        irq);
-                goto err_free_mem;
+                dev_err(&pdev->dev, "Unable to request irq %d for mfld power"
+                                "button\n", irq);
+                goto err_free_input;
         }
 
         error = input_register_device(input);
         if (error) {
-                dev_err(&pdev->dev,
-                        "unable to register input dev, error %d\n", error);
+                dev_err(&pdev->dev, "Unable to register input dev, error "
+                                "%d\n", error);
                 goto err_free_irq;
         }
 
-        platform_set_drvdata(pdev, priv);
+        platform_set_drvdata(pdev, input);
         return 0;
 
 err_free_irq:
-        free_irq(priv->irq, priv);
-err_free_mem:
+        free_irq(irq, input);
+err_free_input:
         input_free_device(input);
-        kfree(priv);
         return error;
 }
 
 static int __devexit mfld_pb_remove(struct platform_device *pdev)
 {
-        struct mfld_pb_priv *priv = platform_get_drvdata(pdev);
-
-        free_irq(priv->irq, priv);
-        input_unregister_device(priv->input);
-        kfree(priv);
+        struct input_dev *input = platform_get_drvdata(pdev);
+        int irq = platform_get_irq(pdev, 0);
 
+        free_irq(irq, input);
+        input_unregister_device(input);
         platform_set_drvdata(pdev, NULL);
+
         return 0;
 }
 
diff --git a/drivers/platform/x86/intel_mid_thermal.c b/drivers/platform/x86/intel_mid_thermal.c
index c2f4bd8013b5..3a578323122b 100644
--- a/drivers/platform/x86/intel_mid_thermal.c
+++ b/drivers/platform/x86/intel_mid_thermal.c
@@ -37,49 +37,50 @@
 #include <asm/intel_scu_ipc.h>
 
 /* Number of thermal sensors */
-#define MSIC_THERMAL_SENSORS   4
+#define MSIC_THERMAL_SENSORS    4
 
 /* ADC1 - thermal registers */
-#define MSIC_THERM_ADC1CNTL1   0x1C0
-#define MSIC_ADC_ENBL          0x10
-#define MSIC_ADC_START         0x08
+#define MSIC_THERM_ADC1CNTL1    0x1C0
+#define MSIC_ADC_ENBL           0x10
+#define MSIC_ADC_START          0x08
 
-#define MSIC_THERM_ADC1CNTL3   0x1C2
-#define MSIC_ADCTHERM_ENBL     0x04
-#define MSIC_ADCRRDATA_ENBL    0x05
-#define MSIC_CHANL_MASK_VAL    0x0F
+#define MSIC_THERM_ADC1CNTL3    0x1C2
+#define MSIC_ADCTHERM_ENBL      0x04
+#define MSIC_ADCRRDATA_ENBL     0x05
+#define MSIC_CHANL_MASK_VAL     0x0F
 
-#define MSIC_STOPBIT_MASK      16
-#define MSIC_ADCTHERM_MASK     4
-#define ADC_CHANLS_MAX         15 /* Number of ADC channels */
-#define ADC_LOOP_MAX           (ADC_CHANLS_MAX - MSIC_THERMAL_SENSORS)
+#define MSIC_STOPBIT_MASK       16
+#define MSIC_ADCTHERM_MASK      4
+/* Number of ADC channels */
+#define ADC_CHANLS_MAX          15
+#define ADC_LOOP_MAX            (ADC_CHANLS_MAX - MSIC_THERMAL_SENSORS)
 
 /* ADC channel code values */
-#define SKIN_SENSOR0_CODE      0x08
-#define SKIN_SENSOR1_CODE      0x09
-#define SYS_SENSOR_CODE                0x0A
-#define MSIC_DIE_SENSOR_CODE   0x03
+#define SKIN_SENSOR0_CODE       0x08
+#define SKIN_SENSOR1_CODE       0x09
+#define SYS_SENSOR_CODE         0x0A
+#define MSIC_DIE_SENSOR_CODE    0x03
 
-#define SKIN_THERM_SENSOR0     0
-#define SKIN_THERM_SENSOR1     1
-#define SYS_THERM_SENSOR2      2
-#define MSIC_DIE_THERM_SENSOR3 3
+#define SKIN_THERM_SENSOR0      0
+#define SKIN_THERM_SENSOR1      1
+#define SYS_THERM_SENSOR2       2
+#define MSIC_DIE_THERM_SENSOR3  3
 
 /* ADC code range */
-#define ADC_MAX                        977
-#define ADC_MIN                        162
-#define ADC_VAL0C              887
-#define ADC_VAL20C             720
-#define ADC_VAL40C             508
-#define ADC_VAL60C             315
+#define ADC_MAX                 977
+#define ADC_MIN                 162
+#define ADC_VAL0C               887
+#define ADC_VAL20C              720
+#define ADC_VAL40C              508
+#define ADC_VAL60C              315
 
 /* ADC base addresses */
-#define ADC_CHNL_START_ADDR    0x1C5   /* increments by 1 */
-#define ADC_DATA_START_ADDR     0x1D4   /* increments by 2 */
+#define ADC_CHNL_START_ADDR     0x1C5   /* increments by 1 */
+#define ADC_DATA_START_ADDR     0x1D4   /* increments by 2 */
 
 /* MSIC die attributes */
-#define MSIC_DIE_ADC_MIN       488
-#define MSIC_DIE_ADC_MAX       1004
+#define MSIC_DIE_ADC_MIN        488
+#define MSIC_DIE_ADC_MAX        1004
 
 /* This holds the address of the first free ADC channel,
  * among the 15 channels
@@ -87,15 +88,15 @@
 static int channel_index;
 
 struct platform_info {
-       struct platform_device *pdev;
-       struct thermal_zone_device *tzd[MSIC_THERMAL_SENSORS];
+        struct platform_device *pdev;
+        struct thermal_zone_device *tzd[MSIC_THERMAL_SENSORS];
 };
 
 struct thermal_device_info {
-       unsigned int chnl_addr;
-       int direct;
-       /* This holds the current temperature in millidegree celsius */
-       long curr_temp;
+        unsigned int chnl_addr;
+        int direct;
+        /* This holds the current temperature in millidegree celsius */
+        long curr_temp;
 };
 
 /**
@@ -106,7 +107,7 @@ struct thermal_device_info {
  */
 static int to_msic_die_temp(uint16_t adc_val)
 {
-       return (368 * (adc_val) / 1000) - 220;
+        return (368 * (adc_val) / 1000) - 220;
 }
 
 /**
@@ -118,7 +119,7 @@ static int to_msic_die_temp(uint16_t adc_val)
  */
 static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
 {
-       return (adc_val >= min) && (adc_val <= max);
+        return (adc_val >= min) && (adc_val <= max);
 }
 
 /**
@@ -136,35 +137,35 @@ static int is_valid_adc(uint16_t adc_val, uint16_t min, uint16_t max)
  */
 static int adc_to_temp(int direct, uint16_t adc_val, unsigned long *tp)
 {
-       int temp;
-
-       /* Direct conversion for die temperature */
-       if (direct) {
-               if (is_valid_adc(adc_val, MSIC_DIE_ADC_MIN, MSIC_DIE_ADC_MAX)) {
-                       *tp = to_msic_die_temp(adc_val) * 1000;
-                       return 0;
-               }
-               return -ERANGE;
-       }
-
-       if (!is_valid_adc(adc_val, ADC_MIN, ADC_MAX))
-               return -ERANGE;
-
-       /* Linear approximation for skin temperature */
-       if (adc_val > ADC_VAL0C)
-               temp = 177 - (adc_val/5);
-       else if ((adc_val <= ADC_VAL0C) && (adc_val > ADC_VAL20C))
-               temp = 111 - (adc_val/8);
-       else if ((adc_val <= ADC_VAL20C) && (adc_val > ADC_VAL40C))
-               temp = 92 - (adc_val/10);
-       else if ((adc_val <= ADC_VAL40C) && (adc_val > ADC_VAL60C))
-               temp = 91 - (adc_val/10);
-       else
-               temp = 112 - (adc_val/6);
-
-       /* Convert temperature in celsius to milli degree celsius */
-       *tp = temp * 1000;
-       return 0;
+        int temp;
+
+        /* Direct conversion for die temperature */
+        if (direct) {
+                if (is_valid_adc(adc_val, MSIC_DIE_ADC_MIN, MSIC_DIE_ADC_MAX)) {
+                        *tp = to_msic_die_temp(adc_val) * 1000;
+                        return 0;
+                }
+                return -ERANGE;
+        }
+
+        if (!is_valid_adc(adc_val, ADC_MIN, ADC_MAX))
+                return -ERANGE;
+
+        /* Linear approximation for skin temperature */
+        if (adc_val > ADC_VAL0C)
+                temp = 177 - (adc_val/5);
+        else if ((adc_val <= ADC_VAL0C) && (adc_val > ADC_VAL20C))
+                temp = 111 - (adc_val/8);
+        else if ((adc_val <= ADC_VAL20C) && (adc_val > ADC_VAL40C))
+                temp = 92 - (adc_val/10);
+        else if ((adc_val <= ADC_VAL40C) && (adc_val > ADC_VAL60C))
+                temp = 91 - (adc_val/10);
+        else
+                temp = 112 - (adc_val/6);
+
+        /* Convert temperature in celsius to milli degree celsius */
+        *tp = temp * 1000;
+        return 0;
 }
 
 /**
@@ -178,47 +179,47 @@ static int adc_to_temp(int direct, uint16_t adc_val, unsigned long *tp)
  */
 static int mid_read_temp(struct thermal_zone_device *tzd, unsigned long *temp)
 {
-       struct thermal_device_info *td_info = tzd->devdata;
-       uint16_t adc_val, addr;
-       uint8_t data = 0;
-       int ret;
-       unsigned long curr_temp;
-
-
-       addr = td_info->chnl_addr;
-
-       /* Enable the msic for conversion before reading */
-       ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCRRDATA_ENBL);
-       if (ret)
-               return ret;
-
-       /* Re-toggle the RRDATARD bit (temporary workaround) */
-       ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCTHERM_ENBL);
-       if (ret)
-               return ret;
-
-       /* Read the higher bits of data */
-       ret = intel_scu_ipc_ioread8(addr, &data);
-       if (ret)
-               return ret;
-
-       /* Shift bits to accommodate the lower two data bits */
-       adc_val = (data << 2);
-       addr++;
-
-       ret = intel_scu_ipc_ioread8(addr, &data);/* Read lower bits */
-       if (ret)
-               return ret;
-
-       /* Adding lower two bits to the higher bits */
-       data &= 03;
-       adc_val += data;
-
-       /* Convert ADC value to temperature */
-       ret = adc_to_temp(td_info->direct, adc_val, &curr_temp);
-       if (ret == 0)
-               *temp = td_info->curr_temp = curr_temp;
-       return ret;
+        struct thermal_device_info *td_info = tzd->devdata;
+        uint16_t adc_val, addr;
+        uint8_t data = 0;
+        int ret;
+        unsigned long curr_temp;
+
+
+        addr = td_info->chnl_addr;
+
+        /* Enable the msic for conversion before reading */
+        ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCRRDATA_ENBL);
+        if (ret)
+                return ret;
+
+        /* Re-toggle the RRDATARD bit (temporary workaround) */
+        ret = intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL3, MSIC_ADCTHERM_ENBL);
+        if (ret)
+                return ret;
+
+        /* Read the higher bits of data */
+        ret = intel_scu_ipc_ioread8(addr, &data);
+        if (ret)
+                return ret;
+
+        /* Shift bits to accommodate the lower two data bits */
+        adc_val = (data << 2);
+        addr++;
+
+        ret = intel_scu_ipc_ioread8(addr, &data);/* Read lower bits */
+        if (ret)
+                return ret;
+
+        /* Adding lower two bits to the higher bits */
+        data &= 03;
+        adc_val += data;
+
+        /* Convert ADC value to temperature */
+        ret = adc_to_temp(td_info->direct, adc_val, &curr_temp);
+        if (ret == 0)
+                *temp = td_info->curr_temp = curr_temp;
+        return ret;
 }
 
 /**
@@ -231,22 +232,21 @@ static int mid_read_temp(struct thermal_zone_device *tzd, unsigned long *temp)
  */
 static int configure_adc(int val)
 {
-       int ret;
-       uint8_t data;
-
-       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
-       if (ret)
-               return ret;
-
-       if (val) {
-               /* Enable and start the ADC */
-               data |= (MSIC_ADC_ENBL | MSIC_ADC_START);
-       } else {
-               /* Just stop the ADC */
-               data &= (~MSIC_ADC_START);
-       }
-
-       return intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL1, data);
+        int ret;
+        uint8_t data;
+
+        ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+        if (ret)
+                return ret;
+
+        if (val) {
+                /* Enable and start the ADC */
+                data |= (MSIC_ADC_ENBL | MSIC_ADC_START);
+        } else {
+                /* Just stop the ADC */
+                data &= (~MSIC_ADC_START);
+        }
+        return intel_scu_ipc_iowrite8(MSIC_THERM_ADC1CNTL1, data);
 }
 
 /**
@@ -259,30 +259,30 @@ static int configure_adc(int val)
  */
 static int set_up_therm_channel(u16 base_addr)
 {
-       int ret;
-
-       /* Enable all the sensor channels */
-       ret = intel_scu_ipc_iowrite8(base_addr, SKIN_SENSOR0_CODE);
-       if (ret)
-               return ret;
-
-       ret = intel_scu_ipc_iowrite8(base_addr + 1, SKIN_SENSOR1_CODE);
-       if (ret)
-               return ret;
-
-       ret = intel_scu_ipc_iowrite8(base_addr + 2, SYS_SENSOR_CODE);
-       if (ret)
-               return ret;
-
-       /* Since this is the last channel, set the stop bit
-          to 1 by ORing the DIE_SENSOR_CODE with 0x10 */
-       ret = intel_scu_ipc_iowrite8(base_addr + 3,
-                                       (MSIC_DIE_SENSOR_CODE | 0x10));
-       if (ret)
-               return ret;
-
-       /* Enable ADC and start it */
-       return configure_adc(1);
+        int ret;
+
+        /* Enable all the sensor channels */
+        ret = intel_scu_ipc_iowrite8(base_addr, SKIN_SENSOR0_CODE);
+        if (ret)
+                return ret;
+
+        ret = intel_scu_ipc_iowrite8(base_addr + 1, SKIN_SENSOR1_CODE);
+        if (ret)
+                return ret;
+
+        ret = intel_scu_ipc_iowrite8(base_addr + 2, SYS_SENSOR_CODE);
+        if (ret)
+                return ret;
+
+        /* Since this is the last channel, set the stop bit
+         * to 1 by ORing the DIE_SENSOR_CODE with 0x10 */
+        ret = intel_scu_ipc_iowrite8(base_addr + 3,
+                        (MSIC_DIE_SENSOR_CODE | 0x10));
+        if (ret)
+                return ret;
+
+        /* Enable ADC and start it */
+        return configure_adc(1);
 }
 
 /**
@@ -293,13 +293,13 @@ static int set_up_therm_channel(u16 base_addr)
  */
 static int reset_stopbit(uint16_t addr)
 {
-       int ret;
-       uint8_t data;
-       ret = intel_scu_ipc_ioread8(addr, &data);
-       if (ret)
-               return ret;
-       /* Set the stop bit to zero */
-       return intel_scu_ipc_iowrite8(addr, (data & 0xEF));
+        int ret;
+        uint8_t data;
+        ret = intel_scu_ipc_ioread8(addr, &data);
+        if (ret)
+                return ret;
+        /* Set the stop bit to zero */
+        return intel_scu_ipc_iowrite8(addr, (data & 0xEF));
 }
 
 /**
@@ -317,30 +317,30 @@ static int reset_stopbit(uint16_t addr)
  */
 static int find_free_channel(void)
 {
-       int ret;
-       int i;
-       uint8_t data;
-
-       /* check whether ADC is enabled */
-       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
-       if (ret)
-               return ret;
-
-       if ((data & MSIC_ADC_ENBL) == 0)
-               return 0;
-
-       /* ADC is already enabled; Looking for an empty channel */
-       for (i = 0; i < ADC_CHANLS_MAX; i++) {
-               ret = intel_scu_ipc_ioread8(ADC_CHNL_START_ADDR + i, &data);
-               if (ret)
-                       return ret;
-
-               if (data & MSIC_STOPBIT_MASK) {
-                       ret = i;
-                       break;
-               }
-       }
-       return (ret > ADC_LOOP_MAX) ? (-EINVAL) : ret;
+        int ret;
+        int i;
+        uint8_t data;
+
+        /* check whether ADC is enabled */
+        ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL1, &data);
+        if (ret)
+                return ret;
+
+        if ((data & MSIC_ADC_ENBL) == 0)
+                return 0;
+
+        /* ADC is already enabled; Looking for an empty channel */
+        for (i = 0; i < ADC_CHANLS_MAX; i++) {
+                ret = intel_scu_ipc_ioread8(ADC_CHNL_START_ADDR + i, &data);
+                if (ret)
+                        return ret;
+
+                if (data & MSIC_STOPBIT_MASK) {
+                        ret = i;
+                        break;
+                }
+        }
+        return (ret > ADC_LOOP_MAX) ? (-EINVAL) : ret;
 }
 
 /**
@@ -351,48 +351,48 @@ static int find_free_channel(void)
  */
 static int mid_initialize_adc(struct device *dev)
 {
-       u8  data;
-       u16 base_addr;
-       int ret;
-
-       /*
-        * Ensure that adctherm is disabled before we
-        * initialize the ADC
-        */
-       ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL3, &data);
-       if (ret)
-               return ret;
-
-       if (data & MSIC_ADCTHERM_MASK)
-               dev_warn(dev, "ADCTHERM already set");
-
-       /* Index of the first channel in which the stop bit is set */
-       channel_index = find_free_channel();
-       if (channel_index < 0) {
-               dev_err(dev, "No free ADC channels");
-               return channel_index;
-       }
-
-       base_addr = ADC_CHNL_START_ADDR + channel_index;
-
-       if (!(channel_index == 0 || channel_index == ADC_LOOP_MAX)) {
-               /* Reset stop bit for channels other than 0 and 12 */
-               ret = reset_stopbit(base_addr);
-               if (ret)
-                       return ret;
-
-               /* Index of the first free channel */
-               base_addr++;
-               channel_index++;
-       }
-
-       ret = set_up_therm_channel(base_addr);
-       if (ret) {
-               dev_err(dev, "unable to enable ADC");
-               return ret;
-       }
-       dev_dbg(dev, "ADC initialization successful");
-       return ret;
+        u8  data;
+        u16 base_addr;
+        int ret;
+
+        /*
+         * Ensure that adctherm is disabled before we
+         * initialize the ADC
+         */
+        ret = intel_scu_ipc_ioread8(MSIC_THERM_ADC1CNTL3, &data);
+        if (ret)
+                return ret;
+
+        if (data & MSIC_ADCTHERM_MASK)
+                dev_warn(dev, "ADCTHERM already set");
+
+        /* Index of the first channel in which the stop bit is set */
+        channel_index = find_free_channel();
+        if (channel_index < 0) {
+                dev_err(dev, "No free ADC channels");
+                return channel_index;
+        }
+
+        base_addr = ADC_CHNL_START_ADDR + channel_index;
+
+        if (!(channel_index == 0 || channel_index == ADC_LOOP_MAX)) {
+                /* Reset stop bit for channels other than 0 and 12 */
+                ret = reset_stopbit(base_addr);
+                if (ret)
+                        return ret;
+
+                /* Index of the first free channel */
+                base_addr++;
+                channel_index++;
+        }
+
+        ret = set_up_therm_channel(base_addr);
+        if (ret) {
+                dev_err(dev, "unable to enable ADC");
+                return ret;
+        }
+        dev_dbg(dev, "ADC initialization successful");
+        return ret;
 }
 
 /**
@@ -403,18 +403,18 @@ static int mid_initialize_adc(struct device *dev)
  */
 static struct thermal_device_info *initialize_sensor(int index)
 {
-       struct thermal_device_info *td_info =
-               kzalloc(sizeof(struct thermal_device_info), GFP_KERNEL);
-
-       if (!td_info)
-               return NULL;
-
-       /* Set the base addr of the channel for this sensor */
-       td_info->chnl_addr = ADC_DATA_START_ADDR + 2 * (channel_index + index);
-       /* Sensor 3 is direct conversion */
-       if (index == 3)
-               td_info->direct = 1;
-       return td_info;
+        struct thermal_device_info *td_info =
+                kzalloc(sizeof(struct thermal_device_info), GFP_KERNEL);
+
+        if (!td_info)
+                return NULL;
+
+        /* Set the base addr of the channel for this sensor */
+        td_info->chnl_addr = ADC_DATA_START_ADDR + 2 * (channel_index + index);
+        /* Sensor 3 is direct conversion */
+        if (index == 3)
+                td_info->direct = 1;
+        return td_info;
 }
 
 /**
@@ -425,7 +425,7 @@ static struct thermal_device_info *initialize_sensor(int index)
  */
 static int mid_thermal_resume(struct platform_device *pdev)
 {
-       return mid_initialize_adc(&pdev->dev);
+        return mid_initialize_adc(&pdev->dev);
 }
 
 /**
@@ -437,12 +437,12 @@ static int mid_thermal_resume(struct platform_device *pdev)
  */
 static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
 {
-       /*
-        * This just stops the ADC and does not disable it.
-        * temporary workaround until we have a generic ADC driver.
-        * If 0 is passed, it disables the ADC.
-        */
-       return configure_adc(0);
+        /*
+         * This just stops the ADC and does not disable it.
+         * temporary workaround until we have a generic ADC driver.
+         * If 0 is passed, it disables the ADC.
+         */
+        return configure_adc(0);
 }
 
 /**
@@ -453,16 +453,15 @@ static int mid_thermal_suspend(struct platform_device *pdev, pm_message_t mesg)
  */
 static int read_curr_temp(struct thermal_zone_device *tzd, unsigned long *temp)
 {
-       WARN_ON(tzd == NULL);
-       return mid_read_temp(tzd, temp);
+        WARN_ON(tzd == NULL);
+        return mid_read_temp(tzd, temp);
 }
 
 /* Can't be const */
 static struct thermal_zone_device_ops tzd_ops = {
-       .get_temp = read_curr_temp,
+        .get_temp = read_curr_temp,
 };
 
-
 /**
  * mid_thermal_probe - mfld thermal initialize
  * @pdev: platform device structure
@@ -472,46 +471,45 @@ static struct thermal_zone_device_ops tzd_ops = {
  */
 static int mid_thermal_probe(struct platform_device *pdev)
 {
-       static char *name[MSIC_THERMAL_SENSORS] = {
-               "skin0", "skin1", "sys", "msicdie"
-       };
-
-       int ret;
-       int i;
-       struct platform_info *pinfo;
-
-       pinfo = kzalloc(sizeof(struct platform_info), GFP_KERNEL);
-       if (!pinfo)
-               return -ENOMEM;
-
-       /* Initializing the hardware */
-       ret = mid_initialize_adc(&pdev->dev);
-       if (ret) {
-               dev_err(&pdev->dev, "ADC init failed");
-               kfree(pinfo);
-               return ret;
-       }
-
-       /* Register each sensor with the generic thermal framework*/
-       for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
-               pinfo->tzd[i] = thermal_zone_device_register(name[i],
-                                       0, initialize_sensor(i),
-                                       &tzd_ops, 0, 0, 0, 0);
-               if (IS_ERR(pinfo->tzd[i]))
-                       goto reg_fail;
-       }
-
-       pinfo->pdev = pdev;
-       platform_set_drvdata(pdev, pinfo);
-       return 0;
+        static char *name[MSIC_THERMAL_SENSORS] = {
+                "skin0", "skin1", "sys", "msicdie"
+        };
+
+        int ret;
+        int i;
+        struct platform_info *pinfo;
+
+        pinfo = kzalloc(sizeof(struct platform_info), GFP_KERNEL);
+        if (!pinfo)
+                return -ENOMEM;
+
+        /* Initializing the hardware */
+        ret = mid_initialize_adc(&pdev->dev);
+        if (ret) {
+                dev_err(&pdev->dev, "ADC init failed");
+                kfree(pinfo);
+                return ret;
+        }
+
+        /* Register each sensor with the generic thermal framework*/
+        for (i = 0; i < MSIC_THERMAL_SENSORS; i++) {
+                pinfo->tzd[i] = thermal_zone_device_register(name[i],
+                                0, initialize_sensor(i), &tzd_ops, 0, 0, 0, 0);
+                if (IS_ERR(pinfo->tzd[i]))
+                        goto reg_fail;
+        }
+
+        pinfo->pdev = pdev;
+        platform_set_drvdata(pdev, pinfo);
+        return 0;
 
 reg_fail:
-       ret = PTR_ERR(pinfo->tzd[i]);
-       while (--i >= 0)
-               thermal_zone_device_unregister(pinfo->tzd[i]);
-       configure_adc(0);
-       kfree(pinfo);
-       return ret;
+        ret = PTR_ERR(pinfo->tzd[i]);
+        while (--i >= 0)
+                thermal_zone_device_unregister(pinfo->tzd[i]);
+        configure_adc(0);
+        kfree(pinfo);
+        return ret;
 }
 
 /**
@@ -523,49 +521,46 @@ reg_fail:
  */
 static int mid_thermal_remove(struct platform_device *pdev)
 {
-       int i;
-       struct platform_info *pinfo = platform_get_drvdata(pdev);
+        int i;
+        struct platform_info *pinfo = platform_get_drvdata(pdev);
 
-       for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
-               thermal_zone_device_unregister(pinfo->tzd[i]);
+        for (i = 0; i < MSIC_THERMAL_SENSORS; i++)
+                thermal_zone_device_unregister(pinfo->tzd[i]);
 
-       platform_set_drvdata(pdev, NULL);
+        kfree(pinfo);
+        platform_set_drvdata(pdev, NULL);
 
-       /* Stop the ADC */
-       return configure_adc(0);
+        /* Stop the ADC */
+        return configure_adc(0);
 }
 
-/*********************************************************************
- *             Driver initialisation and finalization
- *********************************************************************/
-
 #define DRIVER_NAME "msic_sensor"
 
 static const struct platform_device_id therm_id_table[] = {
-       { DRIVER_NAME, 1 },
-       { }
+        { DRIVER_NAME, 1 },
+        { }
 };
 
 static struct platform_driver mid_thermal_driver = {
-       .driver = {
-               .name = DRIVER_NAME,
-               .owner = THIS_MODULE,
-       },
-       .probe = mid_thermal_probe,
-       .suspend = mid_thermal_suspend,
-       .resume = mid_thermal_resume,
-       .remove = __devexit_p(mid_thermal_remove),
-       .id_table = therm_id_table,
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe = mid_thermal_probe,
+        .suspend = mid_thermal_suspend,
+        .resume = mid_thermal_resume,
+        .remove = __devexit_p(mid_thermal_remove),
+        .id_table = therm_id_table,
 };
 
 static int __init mid_thermal_module_init(void)
 {
-       return platform_driver_register(&mid_thermal_driver);
+        return platform_driver_register(&mid_thermal_driver);
 }
 
 static void __exit mid_thermal_module_exit(void)
 {
-       platform_driver_unregister(&mid_thermal_driver);
+        platform_driver_unregister(&mid_thermal_driver);
 }
 
 module_init(mid_thermal_module_init);
diff --git a/drivers/platform/x86/intel_oaktrail.c b/drivers/platform/x86/intel_oaktrail.c
new file mode 100644
index 000000000000..e936364a609d
--- /dev/null
+++ b/drivers/platform/x86/intel_oaktrail.c
@@ -0,0 +1,396 @@
+/*
+ * intel_oaktrail.c - Intel OakTrail Platform support.
+ *
+ * Copyright (C) 2010-2011 Intel Corporation
+ * Author: Yin Kangkai (kangkai.yin@intel.com)
+ *
+ * based on Compal driver, Copyright (C) 2008 Cezary Jackiewicz
+ * <cezary.jackiewicz (at) gmail.com>, based on MSI driver
+ * Copyright (C) 2006 Lennart Poettering <mzxreary (at) 0pointer (dot) de>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful, but
+ *  WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ *  General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ *  02110-1301, USA.
+ *
+ * This driver does below things:
+ * 1. registers itself in the Linux backlight control in
+ *    /sys/class/backlight/intel_oaktrail/
+ *
+ * 2. registers in the rfkill subsystem here: /sys/class/rfkill/rfkillX/
+ *    for these components: wifi, bluetooth, wwan (3g), gps
+ *
+ * This driver might work on other products based on Oaktrail. If you
+ * want to try it you can pass force=1 as argument to the module which
+ * will force it to load even when the DMI data doesn't identify the
+ * product as compatible.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/acpi.h>
+#include <linux/fb.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/i2c.h>
+#include <linux/backlight.h>
+#include <linux/platform_device.h>
+#include <linux/dmi.h>
+#include <linux/rfkill.h>
+#include <acpi/acpi_bus.h>
+#include <acpi/acpi_drivers.h>
+
+
+#define DRIVER_NAME     "intel_oaktrail"
+#define DRIVER_VERSION  "0.4ac1"
+
+/*
+ * This is the devices status address in EC space, and the control bits
+ * definition:
+ *
+ * (1 << 0):    Camera enable/disable, RW.
+ * (1 << 1):    Bluetooth enable/disable, RW.
+ * (1 << 2):    GPS enable/disable, RW.
+ * (1 << 3):    WiFi enable/disable, RW.
+ * (1 << 4):    WWAN (3G) enable/disalbe, RW.
+ * (1 << 5):    Touchscreen enable/disable, Read Only.
+ */
+#define OT_EC_DEVICE_STATE_ADDRESS      0xD6
+
+#define OT_EC_CAMERA_MASK       (1 << 0)
+#define OT_EC_BT_MASK           (1 << 1)
+#define OT_EC_GPS_MASK          (1 << 2)
+#define OT_EC_WIFI_MASK         (1 << 3)
+#define OT_EC_WWAN_MASK         (1 << 4)
+#define OT_EC_TS_MASK           (1 << 5)
+
+/*
+ * This is the address in EC space and commands used to control LCD backlight:
+ *
+ * Two steps needed to change the LCD backlight:
+ *   1. write the backlight percentage into OT_EC_BL_BRIGHTNESS_ADDRESS;
+ *   2. write OT_EC_BL_CONTROL_ON_DATA into OT_EC_BL_CONTROL_ADDRESS.
+ *
+ * To read the LCD back light, just read out the value from
+ * OT_EC_BL_BRIGHTNESS_ADDRESS.
+ *
+ * LCD backlight brightness range: 0 - 100 (OT_EC_BL_BRIGHTNESS_MAX)
+ */
+#define OT_EC_BL_BRIGHTNESS_ADDRESS     0x44
+#define OT_EC_BL_BRIGHTNESS_MAX         100
+#define OT_EC_BL_CONTROL_ADDRESS        0x3A
+#define OT_EC_BL_CONTROL_ON_DATA        0x1A
+
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
+
+static struct platform_device *oaktrail_device;
+static struct backlight_device *oaktrail_bl_device;
+static struct rfkill *bt_rfkill;
+static struct rfkill *gps_rfkill;
+static struct rfkill *wifi_rfkill;
+static struct rfkill *wwan_rfkill;
+
+
+/* rfkill */
+static int oaktrail_rfkill_set(void *data, bool blocked)
+{
+        u8 value;
+        u8 result;
+        unsigned long radio = (unsigned long) data;
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &result);
+
+        if (!blocked)
+                value = (u8) (result | radio);
+        else
+                value = (u8) (result & ~radio);
+
+        ec_write(OT_EC_DEVICE_STATE_ADDRESS, value);
+
+        return 0;
+}
+
+static const struct rfkill_ops oaktrail_rfkill_ops = {
+        .set_block = oaktrail_rfkill_set,
+};
+
+static struct rfkill *oaktrail_rfkill_new(char *name, enum rfkill_type type,
+                                          unsigned long mask)
+{
+        struct rfkill *rfkill_dev;
+        u8 value;
+        int err;
+
+        rfkill_dev = rfkill_alloc(name, &oaktrail_device->dev, type,
+                                  &oaktrail_rfkill_ops, (void *)mask);
+        if (!rfkill_dev)
+                return ERR_PTR(-ENOMEM);
+
+        ec_read(OT_EC_DEVICE_STATE_ADDRESS, &value);
+        rfkill_init_sw_state(rfkill_dev, (value & mask) != 1);
+
+        err = rfkill_register(rfkill_dev);
+        if (err) {
+                rfkill_destroy(rfkill_dev);
+                return ERR_PTR(err);
+        }
+
+        return rfkill_dev;
+}
+
+static inline void __oaktrail_rfkill_cleanup(struct rfkill *rf)
+{
+        if (rf) {
+                rfkill_unregister(rf);
+                rfkill_destroy(rf);
+        }
+}
+
+static void oaktrail_rfkill_cleanup(void)
+{
+        __oaktrail_rfkill_cleanup(wifi_rfkill);
+        __oaktrail_rfkill_cleanup(bt_rfkill);
+        __oaktrail_rfkill_cleanup(gps_rfkill);
+        __oaktrail_rfkill_cleanup(wwan_rfkill);
+}
+
+static int oaktrail_rfkill_init(void)
+{
+        int ret;
+
+        wifi_rfkill = oaktrail_rfkill_new("oaktrail-wifi",
+                                          RFKILL_TYPE_WLAN,
+                                          OT_EC_WIFI_MASK);
+        if (IS_ERR(wifi_rfkill)) {
+                ret = PTR_ERR(wifi_rfkill);
+                wifi_rfkill = NULL;
+                goto cleanup;
+        }
+
+        bt_rfkill = oaktrail_rfkill_new("oaktrail-bluetooth",
+                                        RFKILL_TYPE_BLUETOOTH,
+                                        OT_EC_BT_MASK);
+        if (IS_ERR(bt_rfkill)) {
+                ret = PTR_ERR(bt_rfkill);
+                bt_rfkill = NULL;
+                goto cleanup;
+        }
+
+        gps_rfkill = oaktrail_rfkill_new("oaktrail-gps",
+                                         RFKILL_TYPE_GPS,
+                                         OT_EC_GPS_MASK);
+        if (IS_ERR(gps_rfkill)) {
+                ret = PTR_ERR(gps_rfkill);
+                gps_rfkill = NULL;
+                goto cleanup;
+        }
+
+        wwan_rfkill = oaktrail_rfkill_new("oaktrail-wwan",
+                                          RFKILL_TYPE_WWAN,
+                                          OT_EC_WWAN_MASK);
+        if (IS_ERR(wwan_rfkill)) {
+                ret = PTR_ERR(wwan_rfkill);
+                wwan_rfkill = NULL;
+                goto cleanup;
+        }
+
+        return 0;
+
+cleanup:
+        oaktrail_rfkill_cleanup();
+        return ret;
+}
+
+
+/* backlight */
+static int get_backlight_brightness(struct backlight_device *b)
+{
+        u8 value;
+        ec_read(OT_EC_BL_BRIGHTNESS_ADDRESS, &value);
+
+        return value;
+}
+
+static int set_backlight_brightness(struct backlight_device *b)
+{
+        u8 percent = (u8) b->props.brightness;
+        if (percent < 0 || percent > OT_EC_BL_BRIGHTNESS_MAX)
+                return -EINVAL;
+
+        ec_write(OT_EC_BL_BRIGHTNESS_ADDRESS, percent);
+        ec_write(OT_EC_BL_CONTROL_ADDRESS, OT_EC_BL_CONTROL_ON_DATA);
+
+        return 0;
+}
+
+static const struct backlight_ops oaktrail_bl_ops = {
+        .get_brightness = get_backlight_brightness,
+        .update_status  = set_backlight_brightness,
+};
+
+static int oaktrail_backlight_init(void)
+{
+        struct backlight_device *bd;
+        struct backlight_properties props;
+
+        memset(&props, 0, sizeof(struct backlight_properties));
+        props.max_brightness = OT_EC_BL_BRIGHTNESS_MAX;
+        bd = backlight_device_register(DRIVER_NAME,
+                                       &oaktrail_device->dev, NULL,
+                                       &oaktrail_bl_ops,
+                                       &props);
+
+        if (IS_ERR(bd)) {
+                oaktrail_bl_device = NULL;
+                pr_warning("Unable to register backlight device\n");
+                return PTR_ERR(bd);
+        }
+
+        oaktrail_bl_device = bd;
+
+        bd->props.brightness = get_backlight_brightness(bd);
+        bd->props.power = FB_BLANK_UNBLANK;
+        backlight_update_status(bd);
+
+        return 0;
+}
+
+static void oaktrail_backlight_exit(void)
+{
+        if (oaktrail_bl_device)
+                backlight_device_unregister(oaktrail_bl_device);
+}
+
+static int __devinit oaktrail_probe(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static int __devexit oaktrail_remove(struct platform_device *pdev)
+{
+        return 0;
+}
+
+static struct platform_driver oaktrail_driver = {
+        .driver = {
+                .name = DRIVER_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe  = oaktrail_probe,
+        .remove = __devexit_p(oaktrail_remove)
+};
+
+static int dmi_check_cb(const struct dmi_system_id *id)
+{
+        pr_info("Identified model '%s'\n", id->ident);
+        return 0;
+}
+
+static struct dmi_system_id __initdata oaktrail_dmi_table[] = {
+        {
+                .ident = "OakTrail platform",
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OakTrail platform"),
+                },
+                .callback = dmi_check_cb
+        },
+        { }
+};
+
+static int __init oaktrail_init(void)
+{
+        int ret;
+
+        if (acpi_disabled) {
+                pr_err("ACPI needs to be enabled for this driver to work!\n");
+                return -ENODEV;
+        }
+
+        if (!force && !dmi_check_system(oaktrail_dmi_table)) {
+                pr_err("Platform not recognized (You could try the module's force-parameter)");
+                return -ENODEV;
+        }
+
+        ret = platform_driver_register(&oaktrail_driver);
+        if (ret) {
+                pr_warning("Unable to register platform driver\n");
+                goto err_driver_reg;
+        }
+
+        oaktrail_device = platform_device_alloc(DRIVER_NAME, -1);
+        if (!oaktrail_device) {
+                pr_warning("Unable to allocate platform device\n");
+                ret = -ENOMEM;
+                goto err_device_alloc;
+        }
+
+        ret = platform_device_add(oaktrail_device);
+        if (ret) {
+                pr_warning("Unable to add platform device\n");
+                goto err_device_add;
+        }
+
+        if (!acpi_video_backlight_support()) {
+                ret = oaktrail_backlight_init();
+                if (ret)
+                        goto err_backlight;
+
+        } else
+                pr_info("Backlight controlled by ACPI video driver\n");
+
+        ret = oaktrail_rfkill_init();
+        if (ret) {
+                pr_warning("Setup rfkill failed\n");
+                goto err_rfkill;
+        }
+
+        pr_info("Driver "DRIVER_VERSION" successfully loaded\n");
+        return 0;
+
+err_rfkill:
+        oaktrail_backlight_exit();
+err_backlight:
+        platform_device_del(oaktrail_device);
+err_device_add:
+        platform_device_put(oaktrail_device);
+err_device_alloc:
+        platform_driver_unregister(&oaktrail_driver);
+err_driver_reg:
+
+        return ret;
+}
+
+static void __exit oaktrail_cleanup(void)
+{
+        oaktrail_backlight_exit();
+        oaktrail_rfkill_cleanup();
+        platform_device_unregister(oaktrail_device);
+        platform_driver_unregister(&oaktrail_driver);
+
+        pr_info("Driver unloaded\n");
+}
+
+module_init(oaktrail_init);
+module_exit(oaktrail_cleanup);
+
+MODULE_AUTHOR("Yin Kangkai (kangkai.yin@intel.com)");
+MODULE_DESCRIPTION("Intel Oaktrail Platform ACPI Extras");
+MODULE_VERSION(DRIVER_VERSION);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("dmi:*:svnIntelCorporation:pnOakTrailplatform:*");
diff --git a/drivers/platform/x86/intel_pmic_gpio.c b/drivers/platform/x86/intel_pmic_gpio.c
index 464bb3fc4d88..1686c1e07d5d 100644
--- a/drivers/platform/x86/intel_pmic_gpio.c
+++ b/drivers/platform/x86/intel_pmic_gpio.c
@@ -19,6 +19,8 @@
  * Moorestown platform PMIC chip
  */
 
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/interrupt.h>
@@ -90,8 +92,7 @@ static void pmic_program_irqtype(int gpio, int type)
 static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 {
         if (offset > 8) {
-                printk(KERN_ERR
-                        "%s: only pin 0-7 support input\n", __func__);
+                pr_err("only pin 0-7 support input\n");
                 return -1;/* we only have 8 GPIO can use as input */
         }
         return intel_scu_ipc_update_register(GPIO0 + offset,
@@ -116,8 +117,7 @@ static int pmic_gpio_direction_output(struct gpio_chip *chip,
                                 value ? 1 << (offset - 16) : 0,
                                 1 << (offset - 16));
         else {
-                printk(KERN_ERR
-                        "%s: invalid PMIC GPIO pin %d!\n", __func__, offset);
+                pr_err("invalid PMIC GPIO pin %d!\n", offset);
                 WARN_ON(1);
         }
 
@@ -260,7 +260,7 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         /* setting up SRAM mapping for GPIOINT register */
         pg->gpiointr = ioremap_nocache(pdata->gpiointr, 8);
         if (!pg->gpiointr) {
-                printk(KERN_ERR "%s: Can not map GPIOINT.\n", __func__);
+                pr_err("Can not map GPIOINT\n");
                 retval = -EINVAL;
                 goto err2;
         }
@@ -281,13 +281,13 @@ static int __devinit platform_pmic_gpio_probe(struct platform_device *pdev)
         pg->chip.dev = dev;
         retval = gpiochip_add(&pg->chip);
         if (retval) {
-                printk(KERN_ERR "%s: Can not add pmic gpio chip.\n", __func__);
+                pr_err("Can not add pmic gpio chip\n");
                 goto err;
         }
 
         retval = request_irq(pg->irq, pmic_irq_handler, 0, "pmic", pg);
         if (retval) {
-                printk(KERN_WARNING "pmic: Interrupt request failed\n");
+                pr_warn("Interrupt request failed\n");
                 goto err;
         }
 
diff --git a/drivers/platform/x86/msi-laptop.c b/drivers/platform/x86/msi-laptop.c
index 23fb2afda00b..3ff629df9f01 100644
--- a/drivers/platform/x86/msi-laptop.c
+++ b/drivers/platform/x86/msi-laptop.c
@@ -135,7 +135,7 @@ static int set_lcd_level(int level)
         buf[1] = (u8) (level*31);
 
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, buf, sizeof(buf),
-                              NULL, 0, 1);
+                              NULL, 0);
 }
 
 static int get_lcd_level(void)
@@ -144,7 +144,7 @@ static int get_lcd_level(void)
         int result;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -157,7 +157,7 @@ static int get_auto_brightness(void)
         int result;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, &wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -172,7 +172,7 @@ static int set_auto_brightness(int enable)
         wdata[0] = 4;
 
         result = ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 1,
-                                &rdata, 1, 1);
+                                &rdata, 1);
         if (result < 0)
                 return result;
 
@@ -180,7 +180,7 @@ static int set_auto_brightness(int enable)
         wdata[1] = (rdata & 0xF7) | (enable ? 8 : 0);
 
         return ec_transaction(MSI_EC_COMMAND_LCD_LEVEL, wdata, 2,
-                              NULL, 0, 1);
+                              NULL, 0);
 }
 
 static ssize_t set_device_state(const char *buf, size_t count, u8 mask)
@@ -217,7 +217,7 @@ static int get_wireless_state(int *wlan, int *bluetooth)
         u8 wdata = 0, rdata;
         int result;
 
-        result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1, 1);
+        result = ec_transaction(MSI_EC_COMMAND_WIRELESS, &wdata, 1, &rdata, 1);
         if (result < 0)
                 return -1;
 
@@ -447,7 +447,7 @@ static struct platform_device *msipf_device;
 
 static int dmi_check_cb(const struct dmi_system_id *id)
 {
-        pr_info("Identified laptop model '%s'.\n", id->ident);
+        pr_info("Identified laptop model '%s'\n", id->ident);
         return 1;
 }
 
@@ -800,7 +800,7 @@ static void msi_laptop_input_destroy(void)
         input_unregister_device(msi_laptop_input_dev);
 }
 
-static int load_scm_model_init(struct platform_device *sdev)
+static int __init load_scm_model_init(struct platform_device *sdev)
 {
         u8 data;
         int result;
@@ -875,8 +875,7 @@ static int __init msi_init(void)
         /* Register backlight stuff */
 
         if (acpi_video_backlight_support()) {
-                pr_info("Brightness ignored, must be controlled "
-                       "by ACPI video driver\n");
+                pr_info("Brightness ignored, must be controlled by ACPI video driver\n");
         } else {
                 struct backlight_properties props;
                 memset(&props, 0, sizeof(struct backlight_properties));
@@ -930,7 +929,7 @@ static int __init msi_init(void)
         if (auto_brightness != 2)
                 set_auto_brightness(auto_brightness);
 
-        pr_info("driver "MSI_DRIVER_VERSION" successfully loaded.\n");
+        pr_info("driver " MSI_DRIVER_VERSION " successfully loaded\n");
 
         return 0;
 
@@ -978,7 +977,7 @@ static void __exit msi_cleanup(void)
         if (auto_brightness != 2)
                 set_auto_brightness(1);
 
-        pr_info("driver unloaded.\n");
+        pr_info("driver unloaded\n");
 }
 
 module_init(msi_init);
diff --git a/drivers/platform/x86/msi-wmi.c b/drivers/platform/x86/msi-wmi.c
index d5419c9ec07a..c832e3356cd6 100644
--- a/drivers/platform/x86/msi-wmi.c
+++ b/drivers/platform/x86/msi-wmi.c
@@ -20,6 +20,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/input.h>
@@ -36,13 +37,10 @@ MODULE_ALIAS("wmi:551A1F84-FBDD-4125-91DB-3EA8F44F1D45");
 MODULE_ALIAS("wmi:B6F3EEF2-3D2F-49DC-9DE3-85BCE18C62F2");
 
 #define DRV_NAME "msi-wmi"
-#define DRV_PFX DRV_NAME ": "
 
 #define MSIWMI_BIOS_GUID "551A1F84-FBDD-4125-91DB-3EA8F44F1D45"
 #define MSIWMI_EVENT_GUID "B6F3EEF2-3D2F-49DC-9DE3-85BCE18C62F2"
 
-#define dprintk(msg...) pr_debug(DRV_PFX msg)
-
 #define SCANCODE_BASE 0xD0
 #define MSI_WMI_BRIGHTNESSUP   SCANCODE_BASE
 #define MSI_WMI_BRIGHTNESSDOWN (SCANCODE_BASE + 1)
@@ -78,7 +76,7 @@ static int msi_wmi_query_block(int instance, int *ret)
 
         if (!obj || obj->type != ACPI_TYPE_INTEGER) {
                 if (obj) {
-                        printk(KERN_ERR DRV_PFX "query block returned object "
+                        pr_err("query block returned object "
                                "type: %d - buffer length:%d\n", obj->type,
                                obj->type == ACPI_TYPE_BUFFER ?
                                obj->buffer.length : 0);
@@ -97,8 +95,8 @@ static int msi_wmi_set_block(int instance, int value)
 
         struct acpi_buffer input = { sizeof(int), &value };
 
-        dprintk("Going to set block of instance: %d - value: %d\n",
-                instance, value);
+        pr_debug("Going to set block of instance: %d - value: %d\n",
+                 instance, value);
 
         status = wmi_set_block(MSIWMI_BIOS_GUID, instance, &input);
 
@@ -112,20 +110,19 @@ static int bl_get(struct backlight_device *bd)
         /* Instance 1 is "get backlight", cmp with DSDT */
         err = msi_wmi_query_block(1, &ret);
         if (err) {
-                printk(KERN_ERR DRV_PFX "Could not query backlight: %d\n", err);
+                pr_err("Could not query backlight: %d\n", err);
                 return -EINVAL;
         }
-        dprintk("Get: Query block returned: %d\n", ret);
+        pr_debug("Get: Query block returned: %d\n", ret);
         for (level = 0; level < ARRAY_SIZE(backlight_map); level++) {
                 if (backlight_map[level] == ret) {
-                        dprintk("Current backlight level: 0x%X - index: %d\n",
-                                backlight_map[level], level);
+                        pr_debug("Current backlight level: 0x%X - index: %d\n",
+                                 backlight_map[level], level);
                         break;
                 }
         }
         if (level == ARRAY_SIZE(backlight_map)) {
-                printk(KERN_ERR DRV_PFX "get: Invalid brightness value: 0x%X\n",
-                       ret);
+                pr_err("get: Invalid brightness value: 0x%X\n", ret);
                 return -EINVAL;
         }
         return level;
@@ -156,7 +153,7 @@ static void msi_wmi_notify(u32 value, void *context)
 
         status = wmi_get_event_data(value, &response);
         if (status != AE_OK) {
-                printk(KERN_INFO DRV_PFX "bad event status 0x%x\n", status);
+                pr_info("bad event status 0x%x\n", status);
                 return;
         }
 
@@ -164,7 +161,7 @@ static void msi_wmi_notify(u32 value, void *context)
 
         if (obj && obj->type == ACPI_TYPE_INTEGER) {
                 int eventcode = obj->integer.value;
-                dprintk("Eventcode: 0x%x\n", eventcode);
+                pr_debug("Eventcode: 0x%x\n", eventcode);
                 key = sparse_keymap_entry_from_scancode(msi_wmi_input_dev,
                                 eventcode);
                 if (key) {
@@ -175,8 +172,8 @@ static void msi_wmi_notify(u32 value, void *context)
                         /* Ignore event if the same event happened in a 50 ms
                            timeframe -> Key press may result in 10-20 GPEs */
                         if (ktime_to_us(diff) < 1000 * 50) {
-                                dprintk("Suppressed key event 0x%X - "
-                                        "Last press was %lld us ago\n",
+                                pr_debug("Suppressed key event 0x%X - "
+                                         "Last press was %lld us ago\n",
                                          key->code, ktime_to_us(diff));
                                 return;
                         }
@@ -187,17 +184,16 @@ static void msi_wmi_notify(u32 value, void *context)
                         (!acpi_video_backlight_support() ||
                         (key->code != MSI_WMI_BRIGHTNESSUP &&
                         key->code != MSI_WMI_BRIGHTNESSDOWN))) {
-                                dprintk("Send key: 0x%X - "
-                                        "Input layer keycode: %d\n", key->code,
-                                         key->keycode);
+                                pr_debug("Send key: 0x%X - "
+                                         "Input layer keycode: %d\n",
+                                         key->code, key->keycode);
                                 sparse_keymap_report_entry(msi_wmi_input_dev,
                                                 key, 1, true);
                         }
                 } else
-                        printk(KERN_INFO "Unknown key pressed - %x\n",
-                               eventcode);
+                        pr_info("Unknown key pressed - %x\n", eventcode);
         } else
-                printk(KERN_INFO DRV_PFX "Unknown event received\n");
+                pr_info("Unknown event received\n");
         kfree(response.pointer);
 }
 
@@ -238,8 +234,7 @@ static int __init msi_wmi_init(void)
         int err;
 
         if (!wmi_has_guid(MSIWMI_EVENT_GUID)) {
-                printk(KERN_ERR
-                       "This machine doesn't have MSI-hotkeys through WMI\n");
+                pr_err("This machine doesn't have MSI-hotkeys through WMI\n");
                 return -ENODEV;
         }
         err = wmi_install_notify_handler(MSIWMI_EVENT_GUID,
@@ -270,7 +265,7 @@ static int __init msi_wmi_init(void)
 
                 backlight->props.brightness = err;
         }
-        dprintk("Event handler installed\n");
+        pr_debug("Event handler installed\n");
 
         return 0;
 
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index 6fe8cd6e23b5..bbd182e178cb 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -42,6 +42,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -70,10 +72,10 @@
 #include <linux/miscdevice.h>
 #endif
 
-#define DRV_PFX                 "sony-laptop: "
-#define dprintk(msg...)         do {    \
-        if (debug)                      \
-                pr_warn(DRV_PFX msg);   \
+#define dprintk(fmt, ...)                       \
+do {                                            \
+        if (debug)                              \
+                pr_warn(fmt, ##__VA_ARGS__);    \
 } while (0)
 
 #define SONY_LAPTOP_DRIVER_VERSION      "0.6"
@@ -418,7 +420,7 @@ static int sony_laptop_setup_input(struct acpi_device *acpi_device)
         error = kfifo_alloc(&sony_laptop_input.fifo,
                             SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                pr_err(DRV_PFX "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 goto err_dec_users;
         }
 
@@ -702,7 +704,7 @@ static int acpi_callgetfunc(acpi_handle handle, char *name, int *result)
                 return 0;
         }
 
-        pr_warn(DRV_PFX "acpi_callreadfunc failed\n");
+        pr_warn("acpi_callreadfunc failed\n");
 
         return -1;
 }
@@ -728,8 +730,7 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
         if (status == AE_OK) {
                 if (result != NULL) {
                         if (out_obj.type != ACPI_TYPE_INTEGER) {
-                                pr_warn(DRV_PFX "acpi_evaluate_object bad "
-                                       "return type\n");
+                                pr_warn("acpi_evaluate_object bad return type\n");
                                 return -1;
                         }
                         *result = out_obj.integer.value;
@@ -737,7 +738,7 @@ static int acpi_callsetfunc(acpi_handle handle, char *name, int value,
                 return 0;
         }
 
-        pr_warn(DRV_PFX "acpi_evaluate_object failed\n");
+        pr_warn("acpi_evaluate_object failed\n");
 
         return -1;
 }
@@ -961,7 +962,6 @@ static int sony_backlight_get_brightness(struct backlight_device *bd)
 static int sony_nc_get_brightness_ng(struct backlight_device *bd)
 {
         int result;
-        int *handle = (int *)bl_get_data(bd);
         struct sony_backlight_props *sdev =
                 (struct sony_backlight_props *)bl_get_data(bd);
 
@@ -973,7 +973,6 @@ static int sony_nc_get_brightness_ng(struct backlight_device *bd)
 static int sony_nc_update_status_ng(struct backlight_device *bd)
 {
         int value, result;
-        int *handle = (int *)bl_get_data(bd);
         struct sony_backlight_props *sdev =
                 (struct sony_backlight_props *)bl_get_data(bd);
 
@@ -1104,10 +1103,8 @@ static void sony_nc_notify(struct acpi_device *device, u32 event)
                                 }
 
                                 if (!key_event->data)
-                                        pr_info(DRV_PFX
-                                                        "Unknown event: 0x%x 0x%x\n",
-                                                        key_handle,
-                                                        ev);
+                                        pr_info("Unknown event: 0x%x 0x%x\n",
+                                                key_handle, ev);
                                 else
                                         sony_laptop_report_input_event(ev);
                         }
@@ -1128,7 +1125,7 @@ static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
         struct acpi_device_info *info;
 
         if (ACPI_SUCCESS(acpi_get_object_info(handle, &info))) {
-                pr_warn(DRV_PFX "method: name: %4.4s, args %X\n",
+                pr_warn("method: name: %4.4s, args %X\n",
                         (char *)&info->name, info->param_count);
 
                 kfree(info);
@@ -1169,7 +1166,7 @@ static int sony_nc_resume(struct acpi_device *device)
                 ret = acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset,
                                        item->value, NULL);
                 if (ret < 0) {
-                        pr_err(DRV_PFX "%s: %d\n", __func__, ret);
+                        pr_err("%s: %d\n", __func__, ret);
                         break;
                 }
         }
@@ -1336,12 +1333,12 @@ static void sony_nc_rfkill_setup(struct acpi_device *device)
 
         device_enum = (union acpi_object *) buffer.pointer;
         if (!device_enum) {
-                pr_err(DRV_PFX "No SN06 return object.");
+                pr_err("No SN06 return object\n");
                 goto out_no_enum;
         }
         if (device_enum->type != ACPI_TYPE_BUFFER) {
-                pr_err(DRV_PFX "Invalid SN06 return object 0x%.2x\n",
-                                device_enum->type);
+                pr_err("Invalid SN06 return object 0x%.2x\n",
+                       device_enum->type);
                 goto out_no_enum;
         }
 
@@ -1662,7 +1659,7 @@ static void sony_nc_backlight_setup(void)
                                                       ops, &props);
 
         if (IS_ERR(sony_bl_props.dev)) {
-                pr_warn(DRV_PFX "unable to register backlight device\n");
+                pr_warn("unable to register backlight device\n");
                 sony_bl_props.dev = NULL;
         } else
                 sony_bl_props.dev->props.brightness =
@@ -1682,8 +1679,7 @@ static int sony_nc_add(struct acpi_device *device)
         acpi_handle handle;
         struct sony_nc_value *item;
 
-        pr_info(DRV_PFX "%s v%s.\n", SONY_NC_DRIVER_NAME,
-                        SONY_LAPTOP_DRIVER_VERSION);
+        pr_info("%s v%s\n", SONY_NC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
 
         sony_nc_acpi_device = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -1708,7 +1704,7 @@ static int sony_nc_add(struct acpi_device *device)
                                 sony_nc_acpi_handle, 1, sony_walk_callback,
                                 NULL, NULL, NULL);
                 if (ACPI_FAILURE(status)) {
-                        pr_warn(DRV_PFX "unable to walk acpi resources\n");
+                        pr_warn("unable to walk acpi resources\n");
                         result = -ENODEV;
                         goto outpresent;
                 }
@@ -1736,13 +1732,12 @@ static int sony_nc_add(struct acpi_device *device)
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                pr_err(DRV_PFX "Unable to create input devices.\n");
+                pr_err("Unable to create input devices\n");
                 goto outkbdbacklight;
         }
 
         if (acpi_video_backlight_support()) {
-                pr_info(DRV_PFX "brightness ignored, must be "
-                       "controlled by ACPI video driver\n");
+                pr_info("brightness ignored, must be controlled by ACPI video driver\n");
         } else {
                 sony_nc_backlight_setup();
         }
@@ -2265,9 +2260,9 @@ out:
         if (pcidev)
                 pci_dev_put(pcidev);
 
-        pr_info(DRV_PFX "detected Type%d model\n",
-                        dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
-                        dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
+        pr_info("detected Type%d model\n",
+                dev->model == SONYPI_DEVICE_TYPE1 ? 1 :
+                dev->model == SONYPI_DEVICE_TYPE2 ? 2 : 3);
 }
 
 /* camera tests and poweron/poweroff */
@@ -2313,7 +2308,7 @@ static int __sony_pic_camera_ready(void)
 static int __sony_pic_camera_off(void)
 {
         if (!camera) {
-                pr_warn(DRV_PFX "camera control not enabled\n");
+                pr_warn("camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -2333,7 +2328,7 @@ static int __sony_pic_camera_on(void)
         int i, j, x;
 
         if (!camera) {
-                pr_warn(DRV_PFX "camera control not enabled\n");
+                pr_warn("camera control not enabled\n");
                 return -ENODEV;
         }
 
@@ -2356,7 +2351,7 @@ static int __sony_pic_camera_on(void)
         }
 
         if (j == 0) {
-                pr_warn(DRV_PFX "failed to power on camera\n");
+                pr_warn("failed to power on camera\n");
                 return -ENODEV;
         }
 
@@ -2412,8 +2407,7 @@ int sony_pic_camera_command(int command, u8 value)
                                 ITERATIONS_SHORT);
                 break;
         default:
-                pr_err(DRV_PFX "sony_pic_camera_command invalid: %d\n",
-                       command);
+                pr_err("sony_pic_camera_command invalid: %d\n", command);
                 break;
         }
         mutex_unlock(&spic_dev.lock);
@@ -2819,7 +2813,7 @@ static int sonypi_compat_init(void)
         error =
          kfifo_alloc(&sonypi_compat.fifo, SONY_LAPTOP_BUF_SIZE, GFP_KERNEL);
         if (error) {
-                pr_err(DRV_PFX "kfifo_alloc failed\n");
+                pr_err("kfifo_alloc failed\n");
                 return error;
         }
 
@@ -2829,12 +2823,12 @@ static int sonypi_compat_init(void)
                 sonypi_misc_device.minor = minor;
         error = misc_register(&sonypi_misc_device);
         if (error) {
-                pr_err(DRV_PFX "misc_register failed\n");
+                pr_err("misc_register failed\n");
                 goto err_free_kfifo;
         }
         if (minor == -1)
-                pr_info(DRV_PFX "device allocated minor is %d\n",
-                       sonypi_misc_device.minor);
+                pr_info("device allocated minor is %d\n",
+                        sonypi_misc_device.minor);
 
         return 0;
 
@@ -2893,8 +2887,8 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                         }
                         for (i = 0; i < p->interrupt_count; i++) {
                                 if (!p->interrupts[i]) {
-                                        pr_warn(DRV_PFX "Invalid IRQ %d\n",
-                                                        p->interrupts[i]);
+                                        pr_warn("Invalid IRQ %d\n",
+                                                p->interrupts[i]);
                                         continue;
                                 }
                                 interrupt = kzalloc(sizeof(*interrupt),
@@ -2932,14 +2926,14 @@ sony_pic_read_possible_resource(struct acpi_resource *resource, void *context)
                                                 ioport->io2.address_length);
                         }
                         else {
-                                pr_err(DRV_PFX "Unknown SPIC Type, more than 2 IO Ports\n");
+                                pr_err("Unknown SPIC Type, more than 2 IO Ports\n");
                                 return AE_ERROR;
                         }
                         return AE_OK;
                 }
         default:
                 dprintk("Resource %d isn't an IRQ nor an IO port\n",
-                                resource->type);
+                        resource->type);
 
         case ACPI_RESOURCE_TYPE_END_TAG:
                 return AE_OK;
@@ -2960,7 +2954,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         dprintk("Evaluating _STA\n");
         result = acpi_bus_get_status(device);
         if (result) {
-                pr_warn(DRV_PFX "Unable to read status\n");
+                pr_warn("Unable to read status\n");
                 goto end;
         }
 
@@ -2976,8 +2970,7 @@ static int sony_pic_possible_resources(struct acpi_device *device)
         status = acpi_walk_resources(device->handle, METHOD_NAME__PRS,
                         sony_pic_read_possible_resource, &spic_dev);
         if (ACPI_FAILURE(status)) {
-                pr_warn(DRV_PFX "Failure evaluating %s\n",
-                                METHOD_NAME__PRS);
+                pr_warn("Failure evaluating %s\n", METHOD_NAME__PRS);
                 result = -ENODEV;
         }
 end:
@@ -3090,7 +3083,7 @@ static int sony_pic_enable(struct acpi_device *device,
 
         /* check for total failure */
         if (ACPI_FAILURE(status)) {
-                pr_err(DRV_PFX "Error evaluating _SRS\n");
+                pr_err("Error evaluating _SRS\n");
                 result = -ENODEV;
                 goto end;
         }
@@ -3182,7 +3175,7 @@ static int sony_pic_remove(struct acpi_device *device, int type)
         struct sony_pic_irq *irq, *tmp_irq;
 
         if (sony_pic_disable(device)) {
-                pr_err(DRV_PFX "Couldn't disable device.\n");
+                pr_err("Couldn't disable device\n");
                 return -ENXIO;
         }
 
@@ -3222,8 +3215,7 @@ static int sony_pic_add(struct acpi_device *device)
         struct sony_pic_ioport *io, *tmp_io;
         struct sony_pic_irq *irq, *tmp_irq;
 
-        pr_info(DRV_PFX "%s v%s.\n", SONY_PIC_DRIVER_NAME,
-                        SONY_LAPTOP_DRIVER_VERSION);
+        pr_info("%s v%s\n", SONY_PIC_DRIVER_NAME, SONY_LAPTOP_DRIVER_VERSION);
 
         spic_dev.acpi_dev = device;
         strcpy(acpi_device_class(device), "sony/hotkey");
@@ -3233,14 +3225,14 @@ static int sony_pic_add(struct acpi_device *device)
         /* read _PRS resources */
         result = sony_pic_possible_resources(device);
         if (result) {
-                pr_err(DRV_PFX "Unable to read possible resources.\n");
+                pr_err("Unable to read possible resources\n");
                 goto err_free_resources;
         }
 
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input(device);
         if (result) {
-                pr_err(DRV_PFX "Unable to create input devices.\n");
+                pr_err("Unable to create input devices\n");
                 goto err_free_resources;
         }
 
@@ -3281,7 +3273,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_ioport) {
-                pr_err(DRV_PFX "Failed to request_region.\n");
+                pr_err("Failed to request_region\n");
                 result = -ENODEV;
                 goto err_remove_compat;
         }
@@ -3301,7 +3293,7 @@ static int sony_pic_add(struct acpi_device *device)
                 }
         }
         if (!spic_dev.cur_irq) {
-                pr_err(DRV_PFX "Failed to request_irq.\n");
+                pr_err("Failed to request_irq\n");
                 result = -ENODEV;
                 goto err_release_region;
         }
@@ -3309,7 +3301,7 @@ static int sony_pic_add(struct acpi_device *device)
         /* set resource status _SRS */
         result = sony_pic_enable(device, spic_dev.cur_ioport, spic_dev.cur_irq);
         if (result) {
-                pr_err(DRV_PFX "Couldn't enable device.\n");
+                pr_err("Couldn't enable device\n");
                 goto err_free_irq;
         }
 
@@ -3418,7 +3410,7 @@ static int __init sony_laptop_init(void)
         if (!no_spic && dmi_check_system(sonypi_dmi_table)) {
                 result = acpi_bus_register_driver(&sony_pic_driver);
                 if (result) {
-                        pr_err(DRV_PFX "Unable to register SPIC driver.");
+                        pr_err("Unable to register SPIC driver\n");
                         goto out;
                 }
                 spic_drv_registered = 1;
@@ -3426,7 +3418,7 @@ static int __init sony_laptop_init(void)
 
         result = acpi_bus_register_driver(&sony_nc_driver);
         if (result) {
-                pr_err(DRV_PFX "Unable to register SNC driver.");
+                pr_err("Unable to register SNC driver\n");
                 goto out_unregister_pic;
         }
 
diff --git a/drivers/platform/x86/tc1100-wmi.c b/drivers/platform/x86/tc1100-wmi.c
index 865ef78d6f1a..e24f5ae475af 100644
--- a/drivers/platform/x86/tc1100-wmi.c
+++ b/drivers/platform/x86/tc1100-wmi.c
@@ -25,6 +25,8 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -40,9 +42,6 @@
 #define TC1100_INSTANCE_WIRELESS                1
 #define TC1100_INSTANCE_JOGDIAL         2
 
-#define TC1100_LOGPREFIX "tc1100-wmi: "
-#define TC1100_INFO KERN_INFO TC1100_LOGPREFIX
-
 MODULE_AUTHOR("Jamey Hicks, Carlos Corbacho");
 MODULE_DESCRIPTION("HP Compaq TC1100 Tablet WMI Extras");
 MODULE_LICENSE("GPL");
@@ -264,7 +263,7 @@ static int __init tc1100_init(void)
         if (error)
                 goto err_device_del;
 
-        printk(TC1100_INFO "HP Compaq TC1100 Tablet WMI Extras loaded\n");
+        pr_info("HP Compaq TC1100 Tablet WMI Extras loaded\n");
         return 0;
 
  err_device_del:
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 562fcf0dd2b5..77f6e707a2a9 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -21,6 +21,8 @@
  *  02110-1301, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define TPACPI_VERSION "0.24"
 #define TPACPI_SYSFS_VERSION 0x020700
 
@@ -224,17 +226,6 @@ enum tpacpi_hkey_event_t {
 
 #define TPACPI_MAX_ACPI_ARGS 3
 
-/* printk headers */
-#define TPACPI_LOG TPACPI_FILE ": "
-#define TPACPI_EMERG    KERN_EMERG      TPACPI_LOG
-#define TPACPI_ALERT    KERN_ALERT      TPACPI_LOG
-#define TPACPI_CRIT     KERN_CRIT       TPACPI_LOG
-#define TPACPI_ERR      KERN_ERR        TPACPI_LOG
-#define TPACPI_WARN     KERN_WARNING    TPACPI_LOG
-#define TPACPI_NOTICE   KERN_NOTICE     TPACPI_LOG
-#define TPACPI_INFO     KERN_INFO       TPACPI_LOG
-#define TPACPI_DEBUG    KERN_DEBUG      TPACPI_LOG
-
 /* Debugging printk groups */
 #define TPACPI_DBG_ALL          0xffff
 #define TPACPI_DBG_DISCLOSETASK 0x8000
@@ -389,34 +380,36 @@ static int tpacpi_uwb_emulstate;
  *  Debugging helpers
  */
 
-#define dbg_printk(a_dbg_level, format, arg...) \
-        do { if (dbg_level & (a_dbg_level)) \
-                printk(TPACPI_DEBUG "%s: " format, __func__ , ## arg); \
-        } while (0)
+#define dbg_printk(a_dbg_level, format, arg...)                         \
+do {                                                                    \
+        if (dbg_level & (a_dbg_level))                                  \
+                printk(KERN_DEBUG pr_fmt("%s: " format),                \
+                       __func__, ##arg);                                \
+} while (0)
 
 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
 #define vdbg_printk dbg_printk
 static const char *str_supported(int is_supported);
 #else
-#define vdbg_printk(a_dbg_level, format, arg...) \
-        do { } while (0)
+static inline const char *str_supported(int is_supported) { return ""; }
+#define vdbg_printk(a_dbg_level, format, arg...)        \
+        no_printk(format, ##arg)
 #endif
 
 static void tpacpi_log_usertask(const char * const what)
 {
-        printk(TPACPI_DEBUG "%s: access by process with PID %d\n",
-                what, task_tgid_vnr(current));
+        printk(KERN_DEBUG pr_fmt("%s: access by process with PID %d\n"),
+               what, task_tgid_vnr(current));
 }
 
-#define tpacpi_disclose_usertask(what, format, arg...) \
-        do { \
-                if (unlikely( \
-                    (dbg_level & TPACPI_DBG_DISCLOSETASK) && \
-                    (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) { \
-                        printk(TPACPI_DEBUG "%s: PID %d: " format, \
-                                what, task_tgid_vnr(current), ## arg); \
-                } \
-        } while (0)
+#define tpacpi_disclose_usertask(what, format, arg...)                  \
+do {                                                                    \
+        if (unlikely((dbg_level & TPACPI_DBG_DISCLOSETASK) &&           \
+                     (tpacpi_lifecycle == TPACPI_LIFE_RUNNING))) {      \
+                printk(KERN_DEBUG pr_fmt("%s: PID %d: " format),        \
+                       what, task_tgid_vnr(current), ## arg);           \
+        }                                                               \
+} while (0)
 
 /*
  * Quirk handling helpers
@@ -535,15 +528,6 @@ TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",	/* 600e/x, 770e, 770x */
            "HKEY",              /* all others */
            );                   /* 570 */
 
-TPACPI_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA",   /* 570 */
-           "\\_SB.PCI0.AGP0.VID0",      /* 600e/x, 770x */
-           "\\_SB.PCI0.VID0",   /* 770e */
-           "\\_SB.PCI0.VID",    /* A21e, G4x, R50e, X30, X40 */
-           "\\_SB.PCI0.AGP.VGA",        /* X100e and a few others */
-           "\\_SB.PCI0.AGP.VID",        /* all others */
-           );                           /* R30, R31 */
-
-
 /*************************************************************************
  * ACPI helpers
  */
@@ -563,7 +547,7 @@ static int acpi_evalf(acpi_handle handle,
         int quiet;
 
         if (!*fmt) {
-                printk(TPACPI_ERR "acpi_evalf() called with empty format\n");
+                pr_err("acpi_evalf() called with empty format\n");
                 return 0;
         }
 
@@ -588,7 +572,7 @@ static int acpi_evalf(acpi_handle handle,
                         break;
                         /* add more types as needed */
                 default:
-                        printk(TPACPI_ERR "acpi_evalf() called "
+                        pr_err("acpi_evalf() called "
                                "with invalid format character '%c'\n", c);
                         va_end(ap);
                         return 0;
@@ -617,13 +601,13 @@ static int acpi_evalf(acpi_handle handle,
                 break;
                 /* add more types as needed */
         default:
-                printk(TPACPI_ERR "acpi_evalf() called "
+                pr_err("acpi_evalf() called "
                        "with invalid format character '%c'\n", res_type);
                 return 0;
         }
 
         if (!success && !quiet)
-                printk(TPACPI_ERR "acpi_evalf(%s, %s, ...) failed: %s\n",
+                pr_err("acpi_evalf(%s, %s, ...) failed: %s\n",
                        method, fmt0, acpi_format_exception(status));
 
         return success;
@@ -767,8 +751,7 @@ static int __init setup_acpi_notify(struct ibm_struct *ibm)
 
         rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
         if (rc < 0) {
-                printk(TPACPI_ERR "acpi_bus_get_device(%s) failed: %d\n",
-                        ibm->name, rc);
+                pr_err("acpi_bus_get_device(%s) failed: %d\n", ibm->name, rc);
                 return -ENODEV;
         }
 
@@ -781,12 +764,10 @@ static int __init setup_acpi_notify(struct ibm_struct *ibm)
                         ibm->acpi->type, dispatch_acpi_notify, ibm);
         if (ACPI_FAILURE(status)) {
                 if (status == AE_ALREADY_EXISTS) {
-                        printk(TPACPI_NOTICE
-                               "another device driver is already "
-                               "handling %s events\n", ibm->name);
+                        pr_notice("another device driver is already "
+                                  "handling %s events\n", ibm->name);
                 } else {
-                        printk(TPACPI_ERR
-                               "acpi_install_notify_handler(%s) failed: %s\n",
+                        pr_err("acpi_install_notify_handler(%s) failed: %s\n",
                                ibm->name, acpi_format_exception(status));
                 }
                 return -ENODEV;
@@ -811,8 +792,7 @@ static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 
         ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
         if (!ibm->acpi->driver) {
-                printk(TPACPI_ERR
-                       "failed to allocate memory for ibm->acpi->driver\n");
+                pr_err("failed to allocate memory for ibm->acpi->driver\n");
                 return -ENOMEM;
         }
 
@@ -823,7 +803,7 @@ static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 
         rc = acpi_bus_register_driver(ibm->acpi->driver);
         if (rc < 0) {
-                printk(TPACPI_ERR "acpi_bus_register_driver(%s) failed: %d\n",
+                pr_err("acpi_bus_register_driver(%s) failed: %d\n",
                        ibm->name, rc);
                 kfree(ibm->acpi->driver);
                 ibm->acpi->driver = NULL;
@@ -1081,15 +1061,14 @@ static int parse_strtoul(const char *buf,
 static void tpacpi_disable_brightness_delay(void)
 {
         if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
-                printk(TPACPI_NOTICE
-                        "ACPI backlight control delay disabled\n");
+                pr_notice("ACPI backlight control delay disabled\n");
 }
 
 static void printk_deprecated_attribute(const char * const what,
                                         const char * const details)
 {
         tpacpi_log_usertask("deprecated sysfs attribute");
-        printk(TPACPI_WARN "WARNING: sysfs attribute %s is deprecated and "
+        pr_warn("WARNING: sysfs attribute %s is deprecated and "
                 "will be removed. %s\n",
                 what, details);
 }
@@ -1264,8 +1243,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
                                                 &tpacpi_rfk_rfkill_ops,
                                                 atp_rfk);
         if (!atp_rfk || !atp_rfk->rfkill) {
-                printk(TPACPI_ERR
-                        "failed to allocate memory for rfkill class\n");
+                pr_err("failed to allocate memory for rfkill class\n");
                 kfree(atp_rfk);
                 return -ENOMEM;
         }
@@ -1275,9 +1253,8 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         sw_status = (tp_rfkops->get_status)();
         if (sw_status < 0) {
-                printk(TPACPI_ERR
-                        "failed to read initial state for %s, error %d\n",
-                        name, sw_status);
+                pr_err("failed to read initial state for %s, error %d\n",
+                       name, sw_status);
         } else {
                 sw_state = (sw_status == TPACPI_RFK_RADIO_OFF);
                 if (set_default) {
@@ -1291,9 +1268,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         res = rfkill_register(atp_rfk->rfkill);
         if (res < 0) {
-                printk(TPACPI_ERR
-                        "failed to register %s rfkill switch: %d\n",
-                        name, res);
+                pr_err("failed to register %s rfkill switch: %d\n", name, res);
                 rfkill_destroy(atp_rfk->rfkill);
                 kfree(atp_rfk);
                 return res;
@@ -1301,7 +1276,7 @@ static int __init tpacpi_new_rfkill(const enum tpacpi_rfk_id id,
 
         tpacpi_rfkill_switches[id] = atp_rfk;
 
-        printk(TPACPI_INFO "rfkill switch %s: radio is %sblocked\n",
+        pr_info("rfkill switch %s: radio is %sblocked\n",
                 name, (sw_state || hw_state) ? "" : "un");
         return 0;
 }
@@ -1825,10 +1800,8 @@ static void __init tpacpi_check_outdated_fw(void)
                  * broken, or really stable to begin with, so it is
                  * best if the user upgrades the firmware anyway.
                  */
-                printk(TPACPI_WARN
-                        "WARNING: Outdated ThinkPad BIOS/EC firmware\n");
-                printk(TPACPI_WARN
-                        "WARNING: This firmware may be missing critical bug "
+                pr_warn("WARNING: Outdated ThinkPad BIOS/EC firmware\n");
+                pr_warn("WARNING: This firmware may be missing critical bug "
                         "fixes and/or important features\n");
         }
 }
@@ -2117,9 +2090,7 @@ void static hotkey_mask_warn_incomplete_mask(void)
                 (hotkey_all_mask | TPACPI_HKEY_NVRAM_KNOWN_MASK);
 
         if (wantedmask)
-                printk(TPACPI_NOTICE
-                        "required events 0x%08x not enabled!\n",
-                        wantedmask);
+                pr_notice("required events 0x%08x not enabled!\n", wantedmask);
 }
 
 /*
@@ -2157,10 +2128,9 @@ static int hotkey_mask_set(u32 mask)
          * a given event.
          */
         if (!hotkey_mask_get() && !rc && (fwmask & ~hotkey_acpi_mask)) {
-                printk(TPACPI_NOTICE
-                       "asked for hotkey mask 0x%08x, but "
-                       "firmware forced it to 0x%08x\n",
-                       fwmask, hotkey_acpi_mask);
+                pr_notice("asked for hotkey mask 0x%08x, but "
+                          "firmware forced it to 0x%08x\n",
+                          fwmask, hotkey_acpi_mask);
         }
 
         if (tpacpi_lifecycle != TPACPI_LIFE_EXITING)
@@ -2184,13 +2154,11 @@ static int hotkey_user_mask_set(const u32 mask)
             (mask == 0xffff || mask == 0xffffff ||
              mask == 0xffffffff)) {
                 tp_warned.hotkey_mask_ff = 1;
-                printk(TPACPI_NOTICE
-                       "setting the hotkey mask to 0x%08x is likely "
-                       "not the best way to go about it\n", mask);
-                printk(TPACPI_NOTICE
-                       "please consider using the driver defaults, "
-                       "and refer to up-to-date thinkpad-acpi "
-                       "documentation\n");
+                pr_notice("setting the hotkey mask to 0x%08x is likely "
+                          "not the best way to go about it\n", mask);
+                pr_notice("please consider using the driver defaults, "
+                          "and refer to up-to-date thinkpad-acpi "
+                          "documentation\n");
         }
 
         /* Try to enable what the user asked for, plus whatever we need.
@@ -2574,8 +2542,7 @@ static void hotkey_poll_setup(const bool may_warn)
                                         NULL, TPACPI_NVRAM_KTHREAD_NAME);
                         if (IS_ERR(tpacpi_hotkey_task)) {
                                 tpacpi_hotkey_task = NULL;
-                                printk(TPACPI_ERR
-                                       "could not create kernel thread "
+                                pr_err("could not create kernel thread "
                                        "for hotkey polling\n");
                         }
                 }
@@ -2583,11 +2550,10 @@ static void hotkey_poll_setup(const bool may_warn)
                 hotkey_poll_stop_sync();
                 if (may_warn && (poll_driver_mask || poll_user_mask) &&
                     hotkey_poll_freq == 0) {
-                        printk(TPACPI_NOTICE
-                                "hot keys 0x%08x and/or events 0x%08x "
-                                "require polling, which is currently "
-                                "disabled\n",
-                                poll_user_mask, poll_driver_mask);
+                        pr_notice("hot keys 0x%08x and/or events 0x%08x "
+                                  "require polling, which is currently "
+                                  "disabled\n",
+                                  poll_user_mask, poll_driver_mask);
                 }
         }
 }
@@ -2811,13 +2777,13 @@ static ssize_t hotkey_source_mask_store(struct device *dev,
         mutex_unlock(&hotkey_mutex);
 
         if (rc < 0)
-                printk(TPACPI_ERR "hotkey_source_mask: failed to update the"
-                        "firmware event mask!\n");
+                pr_err("hotkey_source_mask: "
+                       "failed to update the firmware event mask!\n");
 
         if (r_ev)
-                printk(TPACPI_NOTICE "hotkey_source_mask: "
-                        "some important events were disabled: "
-                        "0x%04x\n", r_ev);
+                pr_notice("hotkey_source_mask: "
+                          "some important events were disabled: 0x%04x\n",
+                          r_ev);
 
         tpacpi_disclose_usertask("hotkey_source_mask", "set to 0x%08lx\n", t);
 
@@ -3048,8 +3014,7 @@ static void hotkey_exit(void)
         if (((tp_features.hotkey_mask &&
               hotkey_mask_set(hotkey_orig_mask)) |
              hotkey_status_set(false)) != 0)
-                printk(TPACPI_ERR
-                       "failed to restore hot key mask "
+                pr_err("failed to restore hot key mask "
                        "to BIOS defaults\n");
 }
 
@@ -3288,10 +3253,9 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
            for HKEY interface version 0x100 */
         if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
                 if ((hkeyv >> 8) != 1) {
-                        printk(TPACPI_ERR "unknown version of the "
-                               "HKEY interface: 0x%x\n", hkeyv);
-                        printk(TPACPI_ERR "please report this to %s\n",
-                               TPACPI_MAIL);
+                        pr_err("unknown version of the HKEY interface: 0x%x\n",
+                               hkeyv);
+                        pr_err("please report this to %s\n", TPACPI_MAIL);
                 } else {
                         /*
                          * MHKV 0x100 in A31, R40, R40e,
@@ -3304,8 +3268,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                         /* Paranoia check AND init hotkey_all_mask */
                         if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
                                         "MHKA", "qd")) {
-                                printk(TPACPI_ERR
-                                       "missing MHKA handler, "
+                                pr_err("missing MHKA handler, "
                                        "please report this to %s\n",
                                        TPACPI_MAIL);
                                 /* Fallback: pre-init for FN+F3,F4,F12 */
@@ -3343,16 +3306,14 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         if (dbg_wlswemul) {
                 tp_features.hotkey_wlsw = 1;
                 radiosw_state = !!tpacpi_wlsw_emulstate;
-                printk(TPACPI_INFO
-                        "radio switch emulation enabled\n");
+                pr_info("radio switch emulation enabled\n");
         } else
 #endif
         /* Not all thinkpads have a hardware radio switch */
         if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
                 tp_features.hotkey_wlsw = 1;
                 radiosw_state = !!status;
-                printk(TPACPI_INFO
-                        "radio switch found; radios are %s\n",
+                pr_info("radio switch found; radios are %s\n",
                         enabled(status, 0));
         }
         if (tp_features.hotkey_wlsw)
@@ -3363,8 +3324,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         if (!res && acpi_evalf(hkey_handle, &status, "MHKG", "qd")) {
                 tp_features.hotkey_tablet = 1;
                 tabletsw_state = !!(status & TP_HOTKEY_TABLET_MASK);
-                printk(TPACPI_INFO
-                        "possible tablet mode switch found; "
+                pr_info("possible tablet mode switch found; "
                         "ThinkPad in %s mode\n",
                         (tabletsw_state) ? "tablet" : "laptop");
                 res = add_to_attr_set(hotkey_dev_attributes,
@@ -3382,8 +3342,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
         hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
                                         GFP_KERNEL);
         if (!hotkey_keycode_map) {
-                printk(TPACPI_ERR
-                        "failed to allocate memory for key map\n");
+                pr_err("failed to allocate memory for key map\n");
                 res = -ENOMEM;
                 goto err_exit;
         }
@@ -3426,13 +3385,11 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
          * userspace. tpacpi_detect_brightness_capabilities() must have
          * been called before this point  */
         if (tp_features.bright_acpimode && acpi_video_backlight_support()) {
-                printk(TPACPI_INFO
-                       "This ThinkPad has standard ACPI backlight "
-                       "brightness control, supported by the ACPI "
-                       "video driver\n");
-                printk(TPACPI_NOTICE
-                       "Disabling thinkpad-acpi brightness events "
-                       "by default...\n");
+                pr_info("This ThinkPad has standard ACPI backlight "
+                        "brightness control, supported by the ACPI "
+                        "video driver\n");
+                pr_notice("Disabling thinkpad-acpi brightness events "
+                          "by default...\n");
 
                 /* Disable brightness up/down on Lenovo thinkpads when
                  * ACPI is handling them, otherwise it is plain impossible
@@ -3539,8 +3496,7 @@ static bool hotkey_notify_wakeup(const u32 hkey,
 
         case TP_HKEY_EV_WKUP_S3_BATLOW: /* Battery on critical low level/S3 */
         case TP_HKEY_EV_WKUP_S4_BATLOW: /* Battery on critical low level/S4 */
-                printk(TPACPI_ALERT
-                        "EMERGENCY WAKEUP: battery almost empty\n");
+                pr_alert("EMERGENCY WAKEUP: battery almost empty\n");
                 /* how to auto-heal: */
                 /* 2313: woke up from S3, go to S4/S5 */
                 /* 2413: woke up from S4, go to S5 */
@@ -3551,9 +3507,7 @@ static bool hotkey_notify_wakeup(const u32 hkey,
         }
 
         if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
-                printk(TPACPI_INFO
-                       "woke up due to a hot-unplug "
-                       "request...\n");
+                pr_info("woke up due to a hot-unplug request...\n");
                 hotkey_wakeup_reason_notify_change();
         }
         return true;
@@ -3605,37 +3559,31 @@ static bool hotkey_notify_thermal(const u32 hkey,
 
         switch (hkey) {
         case TP_HKEY_EV_THM_TABLE_CHANGED:
-                printk(TPACPI_INFO
-                        "EC reports that Thermal Table has changed\n");
+                pr_info("EC reports that Thermal Table has changed\n");
                 /* recommended action: do nothing, we don't have
                  * Lenovo ATM information */
                 return true;
         case TP_HKEY_EV_ALARM_BAT_HOT:
-                printk(TPACPI_CRIT
-                        "THERMAL ALARM: battery is too hot!\n");
+                pr_crit("THERMAL ALARM: battery is too hot!\n");
                 /* recommended action: warn user through gui */
                 break;
         case TP_HKEY_EV_ALARM_BAT_XHOT:
-                printk(TPACPI_ALERT
-                        "THERMAL EMERGENCY: battery is extremely hot!\n");
+                pr_alert("THERMAL EMERGENCY: battery is extremely hot!\n");
                 /* recommended action: immediate sleep/hibernate */
                 break;
         case TP_HKEY_EV_ALARM_SENSOR_HOT:
-                printk(TPACPI_CRIT
-                        "THERMAL ALARM: "
+                pr_crit("THERMAL ALARM: "
                         "a sensor reports something is too hot!\n");
                 /* recommended action: warn user through gui, that */
                 /* some internal component is too hot */
                 break;
         case TP_HKEY_EV_ALARM_SENSOR_XHOT:
-                printk(TPACPI_ALERT
-                        "THERMAL EMERGENCY: "
-                        "a sensor reports something is extremely hot!\n");
+                pr_alert("THERMAL EMERGENCY: "
+                         "a sensor reports something is extremely hot!\n");
                 /* recommended action: immediate sleep/hibernate */
                 break;
         default:
-                printk(TPACPI_ALERT
-                         "THERMAL ALERT: unknown thermal alarm received\n");
+                pr_alert("THERMAL ALERT: unknown thermal alarm received\n");
                 known = false;
         }
 
@@ -3652,8 +3600,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
         bool known_ev;
 
         if (event != 0x80) {
-                printk(TPACPI_ERR
-                       "unknown HKEY notification event %d\n", event);
+                pr_err("unknown HKEY notification event %d\n", event);
                 /* forward it to userspace, maybe it knows how to handle it */
                 acpi_bus_generate_netlink_event(
                                         ibm->acpi->device->pnp.device_class,
@@ -3664,7 +3611,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
 
         while (1) {
                 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
-                        printk(TPACPI_ERR "failed to retrieve HKEY event\n");
+                        pr_err("failed to retrieve HKEY event\n");
                         return;
                 }
 
@@ -3692,8 +3639,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         switch (hkey) {
                         case TP_HKEY_EV_BAYEJ_ACK:
                                 hotkey_autosleep_ack = 1;
-                                printk(TPACPI_INFO
-                                       "bay ejected\n");
+                                pr_info("bay ejected\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
                                 known_ev = true;
                                 break;
@@ -3709,8 +3655,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         /* 0x4000-0x4FFF: dock-related wakeups */
                         if (hkey == TP_HKEY_EV_UNDOCK_ACK) {
                                 hotkey_autosleep_ack = 1;
-                                printk(TPACPI_INFO
-                                       "undocked\n");
+                                pr_info("undocked\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
                                 known_ev = true;
                         } else {
@@ -3741,11 +3686,9 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         known_ev = false;
                 }
                 if (!known_ev) {
-                        printk(TPACPI_NOTICE
-                               "unhandled HKEY event 0x%04x\n", hkey);
-                        printk(TPACPI_NOTICE
-                               "please report the conditions when this "
-                               "event happened to %s\n", TPACPI_MAIL);
+                        pr_notice("unhandled HKEY event 0x%04x\n", hkey);
+                        pr_notice("please report the conditions when this "
+                                  "event happened to %s\n", TPACPI_MAIL);
                 }
 
                 /* Legacy events */
@@ -3778,8 +3721,7 @@ static void hotkey_resume(void)
 
         if (hotkey_status_set(true) < 0 ||
             hotkey_mask_set(hotkey_acpi_mask) < 0)
-                printk(TPACPI_ERR
-                       "error while attempting to reset the event "
+                pr_err("error while attempting to reset the event "
                        "firmware interface\n");
 
         tpacpi_send_radiosw_update();
@@ -3824,14 +3766,12 @@ static void hotkey_enabledisable_warn(bool enable)
 {
         tpacpi_log_usertask("procfs hotkey enable/disable");
         if (!WARN((tpacpi_lifecycle == TPACPI_LIFE_RUNNING || !enable),
-                        TPACPI_WARN
-                        "hotkey enable/disable functionality has been "
-                        "removed from the driver.  Hotkeys are always "
-                        "enabled\n"))
-                printk(TPACPI_ERR
-                        "Please remove the hotkey=enable module "
-                        "parameter, it is deprecated.  Hotkeys are always "
-                        "enabled\n");
+                  pr_fmt("hotkey enable/disable functionality has been "
+                         "removed from the driver.  "
+                         "Hotkeys are always enabled.\n")))
+                pr_err("Please remove the hotkey=enable module "
+                       "parameter, it is deprecated.  "
+                       "Hotkeys are always enabled.\n");
 }
 
 static int hotkey_write(char *buf)
@@ -4011,8 +3951,7 @@ static void bluetooth_shutdown(void)
         /* Order firmware to save current state to NVRAM */
         if (!acpi_evalf(NULL, NULL, "\\BLTH", "vd",
                         TP_ACPI_BLTH_SAVE_STATE))
-                printk(TPACPI_NOTICE
-                        "failed to save bluetooth state to NVRAM\n");
+                pr_notice("failed to save bluetooth state to NVRAM\n");
         else
                 vdbg_printk(TPACPI_DBG_RFKILL,
                         "bluestooth state saved to NVRAM\n");
@@ -4051,8 +3990,7 @@ static int __init bluetooth_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_bluetoothemul) {
                 tp_features.bluetooth = 1;
-                printk(TPACPI_INFO
-                        "bluetooth switch emulation enabled\n");
+                pr_info("bluetooth switch emulation enabled\n");
         } else
 #endif
         if (tp_features.bluetooth &&
@@ -4203,8 +4141,7 @@ static void wan_shutdown(void)
         /* Order firmware to save current state to NVRAM */
         if (!acpi_evalf(NULL, NULL, "\\WGSV", "vd",
                         TP_ACPI_WGSV_SAVE_STATE))
-                printk(TPACPI_NOTICE
-                        "failed to save WWAN state to NVRAM\n");
+                pr_notice("failed to save WWAN state to NVRAM\n");
         else
                 vdbg_printk(TPACPI_DBG_RFKILL,
                         "WWAN state saved to NVRAM\n");
@@ -4241,8 +4178,7 @@ static int __init wan_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_wwanemul) {
                 tp_features.wan = 1;
-                printk(TPACPI_INFO
-                        "wwan switch emulation enabled\n");
+                pr_info("wwan switch emulation enabled\n");
         } else
 #endif
         if (tp_features.wan &&
@@ -4382,8 +4318,7 @@ static int __init uwb_init(struct ibm_init_struct *iibm)
 #ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
         if (dbg_uwbemul) {
                 tp_features.uwb = 1;
-                printk(TPACPI_INFO
-                        "uwb switch emulation enabled\n");
+                pr_info("uwb switch emulation enabled\n");
         } else
 #endif
         if (tp_features.uwb &&
@@ -4444,6 +4379,15 @@ static int video_orig_autosw;
 static int video_autosw_get(void);
 static int video_autosw_set(int enable);
 
+TPACPI_HANDLE(vid, root,
+              "\\_SB.PCI.AGP.VGA",      /* 570 */
+              "\\_SB.PCI0.AGP0.VID0",   /* 600e/x, 770x */
+              "\\_SB.PCI0.VID0",        /* 770e */
+              "\\_SB.PCI0.VID",         /* A21e, G4x, R50e, X30, X40 */
+              "\\_SB.PCI0.AGP.VGA",     /* X100e and a few others */
+              "\\_SB.PCI0.AGP.VID",     /* all others */
+        );                              /* R30, R31 */
+
 TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID");       /* G41 */
 
 static int __init video_init(struct ibm_init_struct *iibm)
@@ -4487,7 +4431,7 @@ static void video_exit(void)
         dbg_printk(TPACPI_DBG_EXIT,
                    "restoring original video autoswitch mode\n");
         if (video_autosw_set(video_orig_autosw))
-                printk(TPACPI_ERR "error while trying to restore original "
+                pr_err("error while trying to restore original "
                         "video autoswitch mode\n");
 }
 
@@ -4560,8 +4504,7 @@ static int video_outputsw_set(int status)
                 res = acpi_evalf(vid_handle, NULL,
                                  "ASWT", "vdd", status * 0x100, 0);
                 if (!autosw && video_autosw_set(autosw)) {
-                        printk(TPACPI_ERR
-                               "video auto-switch left enabled due to error\n");
+                        pr_err("video auto-switch left enabled due to error\n");
                         return -EIO;
                 }
                 break;
@@ -4630,8 +4573,7 @@ static int video_outputsw_cycle(void)
                 return -ENOSYS;
         }
         if (!autosw && video_autosw_set(autosw)) {
-                printk(TPACPI_ERR
-                       "video auto-switch left enabled due to error\n");
+                pr_err("video auto-switch left enabled due to error\n");
                 return -EIO;
         }
 
@@ -5348,7 +5290,7 @@ static int __init led_init(struct ibm_init_struct *iibm)
         tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS,
                               GFP_KERNEL);
         if (!tpacpi_leds) {
-                printk(TPACPI_ERR "Out of memory for LED data\n");
+                pr_err("Out of memory for LED data\n");
                 return -ENOMEM;
         }
 
@@ -5367,9 +5309,8 @@ static int __init led_init(struct ibm_init_struct *iibm)
         }
 
 #ifdef CONFIG_THINKPAD_ACPI_UNSAFE_LEDS
-        printk(TPACPI_NOTICE
-                "warning: userspace override of important "
-                "firmware LEDs is enabled\n");
+        pr_notice("warning: userspace override of important "
+                  "firmware LEDs is enabled\n");
 #endif
         return 0;
 }
@@ -5639,17 +5580,16 @@ static void thermal_dump_all_sensors(void)
         if (n <= 0)
                 return;
 
-        printk(TPACPI_NOTICE
-                "temperatures (Celsius):");
+        pr_notice("temperatures (Celsius):");
 
         for (i = 0; i < n; i++) {
                 if (t.temp[i] != TPACPI_THERMAL_SENSOR_NA)
-                        printk(KERN_CONT " %d", (int)(t.temp[i] / 1000));
+                        pr_cont(" %d", (int)(t.temp[i] / 1000));
                 else
-                        printk(KERN_CONT " N/A");
+                        pr_cont(" N/A");
         }
 
-        printk(KERN_CONT "\n");
+        pr_cont("\n");
 }
 
 /* sysfs temp##_input -------------------------------------------------- */
@@ -5769,14 +5709,12 @@ static int __init thermal_init(struct ibm_init_struct *iibm)
                 if (ta1 == 0) {
                         /* This is sheer paranoia, but we handle it anyway */
                         if (acpi_tmp7) {
-                                printk(TPACPI_ERR
-                                       "ThinkPad ACPI EC access misbehaving, "
+                                pr_err("ThinkPad ACPI EC access misbehaving, "
                                        "falling back to ACPI TMPx access "
                                        "mode\n");
                                 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
                         } else {
-                                printk(TPACPI_ERR
-                                       "ThinkPad ACPI EC access misbehaving, "
+                                pr_err("ThinkPad ACPI EC access misbehaving, "
                                        "disabling thermal sensors access\n");
                                 thermal_read_mode = TPACPI_THERMAL_NONE;
                         }
@@ -6129,8 +6067,8 @@ static int __init tpacpi_query_bcl_levels(acpi_handle handle)
         if (ACPI_SUCCESS(acpi_evaluate_object(handle, "_BCL", NULL, &buffer))) {
                 obj = (union acpi_object *)buffer.pointer;
                 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
-                        printk(TPACPI_ERR "Unknown _BCL data, "
-                               "please report this to %s\n", TPACPI_MAIL);
+                        pr_err("Unknown _BCL data, please report this to %s\n",
+                               TPACPI_MAIL);
                         rc = 0;
                 } else {
                         rc = obj->package.count;
@@ -6214,18 +6152,15 @@ static void __init tpacpi_detect_brightness_capabilities(void)
         switch (b) {
         case 16:
                 bright_maxlvl = 15;
-                printk(TPACPI_INFO
-                       "detected a 16-level brightness capable ThinkPad\n");
+                pr_info("detected a 16-level brightness capable ThinkPad\n");
                 break;
         case 8:
         case 0:
                 bright_maxlvl = 7;
-                printk(TPACPI_INFO
-                       "detected a 8-level brightness capable ThinkPad\n");
+                pr_info("detected a 8-level brightness capable ThinkPad\n");
                 break;
         default:
-                printk(TPACPI_ERR
-                       "Unsupported brightness interface, "
+                pr_err("Unsupported brightness interface, "
                        "please contact %s\n", TPACPI_MAIL);
                 tp_features.bright_unkfw = 1;
                 bright_maxlvl = b - 1;
@@ -6260,22 +6195,19 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
 
         if (acpi_video_backlight_support()) {
                 if (brightness_enable > 1) {
-                        printk(TPACPI_INFO
-                               "Standard ACPI backlight interface "
-                               "available, not loading native one.\n");
+                        pr_info("Standard ACPI backlight interface "
+                                "available, not loading native one\n");
                         return 1;
                 } else if (brightness_enable == 1) {
-                        printk(TPACPI_WARN
-                                "Cannot enable backlight brightness support, "
+                        pr_warn("Cannot enable backlight brightness support, "
                                 "ACPI is already handling it.  Refer to the "
-                                "acpi_backlight kernel parameter\n");
+                                "acpi_backlight kernel parameter.\n");
                         return 1;
                 }
         } else if (tp_features.bright_acpimode && brightness_enable > 1) {
-                printk(TPACPI_NOTICE
-                        "Standard ACPI backlight interface not "
-                        "available, thinkpad_acpi native "
-                        "brightness control enabled\n");
+                pr_notice("Standard ACPI backlight interface not "
+                          "available, thinkpad_acpi native "
+                          "brightness control enabled\n");
         }
 
         /*
@@ -6319,19 +6251,17 @@ static int __init brightness_init(struct ibm_init_struct *iibm)
         if (IS_ERR(ibm_backlight_device)) {
                 int rc = PTR_ERR(ibm_backlight_device);
                 ibm_backlight_device = NULL;
-                printk(TPACPI_ERR "Could not register backlight device\n");
+                pr_err("Could not register backlight device\n");
                 return rc;
         }
         vdbg_printk(TPACPI_DBG_INIT | TPACPI_DBG_BRGHT,
                         "brightness is supported\n");
 
         if (quirks & TPACPI_BRGHT_Q_ASK) {
-                printk(TPACPI_NOTICE
-                        "brightness: will use unverified default: "
-                        "brightness_mode=%d\n", brightness_mode);
-                printk(TPACPI_NOTICE
-                        "brightness: please report to %s whether it works well "
-                        "or not on your ThinkPad\n", TPACPI_MAIL);
+                pr_notice("brightness: will use unverified default: "
+                          "brightness_mode=%d\n", brightness_mode);
+                pr_notice("brightness: please report to %s whether it works well "
+                          "or not on your ThinkPad\n", TPACPI_MAIL);
         }
 
         /* Added by mistake in early 2007.  Probably useless, but it could
@@ -6804,8 +6734,7 @@ static int __init volume_create_alsa_mixer(void)
         rc = snd_card_create(alsa_index, alsa_id, THIS_MODULE,
                             sizeof(struct tpacpi_alsa_data), &card);
         if (rc < 0 || !card) {
-                printk(TPACPI_ERR
-                        "Failed to create ALSA card structures: %d\n", rc);
+                pr_err("Failed to create ALSA card structures: %d\n", rc);
                 return 1;
         }
 
@@ -6839,9 +6768,8 @@ static int __init volume_create_alsa_mixer(void)
                 ctl_vol = snd_ctl_new1(&volume_alsa_control_vol, NULL);
                 rc = snd_ctl_add(card, ctl_vol);
                 if (rc < 0) {
-                        printk(TPACPI_ERR
-                                "Failed to create ALSA volume control: %d\n",
-                                rc);
+                        pr_err("Failed to create ALSA volume control: %d\n",
+                               rc);
                         goto err_exit;
                 }
                 data->ctl_vol_id = &ctl_vol->id;
@@ -6850,8 +6778,7 @@ static int __init volume_create_alsa_mixer(void)
         ctl_mute = snd_ctl_new1(&volume_alsa_control_mute, NULL);
         rc = snd_ctl_add(card, ctl_mute);
         if (rc < 0) {
-                printk(TPACPI_ERR "Failed to create ALSA mute control: %d\n",
-                        rc);
+                pr_err("Failed to create ALSA mute control: %d\n", rc);
                 goto err_exit;
         }
         data->ctl_mute_id = &ctl_mute->id;
@@ -6859,7 +6786,7 @@ static int __init volume_create_alsa_mixer(void)
         snd_card_set_dev(card, &tpacpi_pdev->dev);
         rc = snd_card_register(card);
         if (rc < 0) {
-                printk(TPACPI_ERR "Failed to register ALSA card: %d\n", rc);
+                pr_err("Failed to register ALSA card: %d\n", rc);
                 goto err_exit;
         }
 
@@ -6915,9 +6842,8 @@ static int __init volume_init(struct ibm_init_struct *iibm)
                 return -EINVAL;
 
         if (volume_mode == TPACPI_VOL_MODE_UCMS_STEP) {
-                printk(TPACPI_ERR
-                        "UCMS step volume mode not implemented, "
-                        "please contact %s\n", TPACPI_MAIL);
+                pr_err("UCMS step volume mode not implemented, "
+                       "please contact %s\n", TPACPI_MAIL);
                 return 1;
         }
 
@@ -6981,13 +6907,11 @@ static int __init volume_init(struct ibm_init_struct *iibm)
 
         rc = volume_create_alsa_mixer();
         if (rc) {
-                printk(TPACPI_ERR
-                        "Could not create the ALSA mixer interface\n");
+                pr_err("Could not create the ALSA mixer interface\n");
                 return rc;
         }
 
-        printk(TPACPI_INFO
-                "Console audio control enabled, mode: %s\n",
+        pr_info("Console audio control enabled, mode: %s\n",
                 (volume_control_allowed) ?
                         "override (read/write)" :
                         "monitor (read only)");
@@ -7049,12 +6973,10 @@ static int volume_write(char *buf)
         if (!volume_control_allowed && tpacpi_lifecycle != TPACPI_LIFE_INIT) {
                 if (unlikely(!tp_warned.volume_ctrl_forbidden)) {
                         tp_warned.volume_ctrl_forbidden = 1;
-                        printk(TPACPI_NOTICE
-                                "Console audio control in monitor mode, "
-                                "changes are not allowed.\n");
-                        printk(TPACPI_NOTICE
-                                "Use the volume_control=1 module parameter "
-                                "to enable volume control\n");
+                        pr_notice("Console audio control in monitor mode, "
+                                  "changes are not allowed\n");
+                        pr_notice("Use the volume_control=1 module parameter "
+                                  "to enable volume control\n");
                 }
                 return -EPERM;
         }
@@ -7129,8 +7051,7 @@ static void inline volume_alsa_notify_change(void)
 
 static int __init volume_init(struct ibm_init_struct *iibm)
 {
-        printk(TPACPI_INFO
-                "volume: disabled as there is no ALSA support in this kernel\n");
+        pr_info("volume: disabled as there is no ALSA support in this kernel\n");
 
         return 1;
 }
@@ -7337,9 +7258,8 @@ TPACPI_HANDLE(sfan, ec, "SFAN",	/* 570 */
 static void fan_quirk1_setup(void)
 {
         if (fan_control_initial_status == 0x07) {
-                printk(TPACPI_NOTICE
-                       "fan_init: initial fan status is unknown, "
-                       "assuming it is in auto mode\n");
+                pr_notice("fan_init: initial fan status is unknown, "
+                          "assuming it is in auto mode\n");
                 tp_features.fan_ctrl_status_undef = 1;
         }
 }
@@ -7726,8 +7646,7 @@ static void fan_watchdog_reset(void)
                 if (!queue_delayed_work(tpacpi_wq, &fan_watchdog_task,
                                 msecs_to_jiffies(fan_watchdog_maxinterval
                                                  * 1000))) {
-                        printk(TPACPI_ERR
-                               "failed to queue the fan watchdog, "
+                        pr_err("failed to queue the fan watchdog, "
                                "watchdog will not trigger\n");
                 }
         } else
@@ -7741,11 +7660,11 @@ static void fan_watchdog_fire(struct work_struct *ignored)
         if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
                 return;
 
-        printk(TPACPI_NOTICE "fan watchdog: enabling fan\n");
+        pr_notice("fan watchdog: enabling fan\n");
         rc = fan_set_enable();
         if (rc < 0) {
-                printk(TPACPI_ERR "fan watchdog: error %d while enabling fan, "
-                        "will try again later...\n", -rc);
+                pr_err("fan watchdog: error %d while enabling fan, "
+                       "will try again later...\n", -rc);
                 /* reschedule for later */
                 fan_watchdog_reset();
         }
@@ -8049,8 +7968,7 @@ static int __init fan_init(struct ibm_init_struct *iibm)
                                         "secondary fan support enabled\n");
                         }
                 } else {
-                        printk(TPACPI_ERR
-                               "ThinkPad ACPI EC access misbehaving, "
+                        pr_err("ThinkPad ACPI EC access misbehaving, "
                                "fan status and control unavailable\n");
                         return 1;
                 }
@@ -8150,9 +8068,8 @@ static void fan_suspend(pm_message_t state)
         fan_control_resume_level = 0;
         rc = fan_get_status_safe(&fan_control_resume_level);
         if (rc < 0)
-                printk(TPACPI_NOTICE
-                        "failed to read fan level for later "
-                        "restore during resume: %d\n", rc);
+                pr_notice("failed to read fan level for later "
+                          "restore during resume: %d\n", rc);
 
         /* if it is undefined, don't attempt to restore it.
          * KEEP THIS LAST */
@@ -8207,13 +8124,11 @@ static void fan_resume(void)
                 return;
         }
         if (do_set) {
-                printk(TPACPI_NOTICE
-                        "restoring fan level to 0x%02x\n",
-                        fan_control_resume_level);
+                pr_notice("restoring fan level to 0x%02x\n",
+                          fan_control_resume_level);
                 rc = fan_set_level_safe(fan_control_resume_level);
                 if (rc < 0)
-                        printk(TPACPI_NOTICE
-                                "failed to restore fan level: %d\n", rc);
+                        pr_notice("failed to restore fan level: %d\n", rc);
         }
 }
 
@@ -8305,8 +8220,8 @@ static int fan_write_cmd_level(const char *cmd, int *rc)
 
         *rc = fan_set_level_safe(level);
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "level command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("level command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan",
                         "set level to %d\n", level);
@@ -8321,8 +8236,8 @@ static int fan_write_cmd_enable(const char *cmd, int *rc)
 
         *rc = fan_set_enable();
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "enable command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("enable command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan", "enable\n");
 
@@ -8336,8 +8251,8 @@ static int fan_write_cmd_disable(const char *cmd, int *rc)
 
         *rc = fan_set_disable();
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "disable command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("disable command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan", "disable\n");
 
@@ -8356,8 +8271,8 @@ static int fan_write_cmd_speed(const char *cmd, int *rc)
 
         *rc = fan_set_speed(speed);
         if (*rc == -ENXIO)
-                printk(TPACPI_ERR "speed command accepted for unsupported "
-                       "access mode %d", fan_control_access_mode);
+                pr_err("speed command accepted for unsupported access mode %d\n",
+                       fan_control_access_mode);
         else if (!*rc)
                 tpacpi_disclose_usertask("procfs fan",
                         "set speed to %d\n", speed);
@@ -8560,8 +8475,8 @@ static int __init ibm_init(struct ibm_init_struct *iibm)
                 if (ibm->acpi->notify) {
                         ret = setup_acpi_notify(ibm);
                         if (ret == -ENODEV) {
-                                printk(TPACPI_NOTICE "disabling subdriver %s\n",
-                                        ibm->name);
+                                pr_notice("disabling subdriver %s\n",
+                                          ibm->name);
                                 ret = 0;
                                 goto err_out;
                         }
@@ -8583,8 +8498,7 @@ static int __init ibm_init(struct ibm_init_struct *iibm)
                 entry = proc_create_data(ibm->name, mode, proc_dir,
                                          &dispatch_proc_fops, ibm);
                 if (!entry) {
-                        printk(TPACPI_ERR "unable to create proc entry %s\n",
-                               ibm->name);
+                        pr_err("unable to create proc entry %s\n", ibm->name);
                         ret = -ENODEV;
                         goto err_out;
                 }
@@ -8683,13 +8597,11 @@ static int __must_check __init get_thinkpad_model_data(
                                 tp->ec_release = (ec_fw_string[4] << 8)
                                                 | ec_fw_string[5];
                         } else {
-                                printk(TPACPI_NOTICE
-                                        "ThinkPad firmware release %s "
-                                        "doesn't match the known patterns\n",
-                                        ec_fw_string);
-                                printk(TPACPI_NOTICE
-                                        "please report this to %s\n",
-                                        TPACPI_MAIL);
+                                pr_notice("ThinkPad firmware release %s "
+                                          "doesn't match the known patterns\n",
+                                          ec_fw_string);
+                                pr_notice("please report this to %s\n",
+                                          TPACPI_MAIL);
                         }
                         break;
                 }
@@ -8733,8 +8645,7 @@ static int __init probe_for_thinkpad(void)
         tpacpi_acpi_handle_locate("ec", TPACPI_ACPI_EC_HID, &ec_handle);
         if (!ec_handle) {
                 if (is_thinkpad)
-                        printk(TPACPI_ERR
-                                "Not yet supported ThinkPad detected!\n");
+                        pr_err("Not yet supported ThinkPad detected!\n");
                 return -ENODEV;
         }
 
@@ -8746,10 +8657,10 @@ static int __init probe_for_thinkpad(void)
 
 static void __init thinkpad_acpi_init_banner(void)
 {
-        printk(TPACPI_INFO "%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
-        printk(TPACPI_INFO "%s\n", TPACPI_URL);
+        pr_info("%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
+        pr_info("%s\n", TPACPI_URL);
 
-        printk(TPACPI_INFO "ThinkPad BIOS %s, EC %s\n",
+        pr_info("ThinkPad BIOS %s, EC %s\n",
                 (thinkpad_id.bios_version_str) ?
                         thinkpad_id.bios_version_str : "unknown",
                 (thinkpad_id.ec_version_str) ?
@@ -8758,7 +8669,7 @@ static void __init thinkpad_acpi_init_banner(void)
         BUG_ON(!thinkpad_id.vendor);
 
         if (thinkpad_id.model_str)
-                printk(TPACPI_INFO "%s %s, model %s\n",
+                pr_info("%s %s, model %s\n",
                         (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
                                 "IBM" : ((thinkpad_id.vendor ==
                                                 PCI_VENDOR_ID_LENOVO) ?
@@ -9024,8 +8935,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = get_thinkpad_model_data(&thinkpad_id);
         if (ret) {
-                printk(TPACPI_ERR
-                        "unable to get DMI data: %d\n", ret);
+                pr_err("unable to get DMI data: %d\n", ret);
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9051,16 +8961,14 @@ static int __init thinkpad_acpi_module_init(void)
 
         proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir);
         if (!proc_dir) {
-                printk(TPACPI_ERR
-                       "unable to create proc dir " TPACPI_PROC_DIR);
+                pr_err("unable to create proc dir " TPACPI_PROC_DIR "\n");
                 thinkpad_acpi_module_exit();
                 return -ENODEV;
         }
 
         ret = platform_driver_register(&tpacpi_pdriver);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to register main platform driver\n");
+                pr_err("unable to register main platform driver\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9068,8 +8976,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = platform_driver_register(&tpacpi_hwmon_pdriver);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to register hwmon platform driver\n");
+                pr_err("unable to register hwmon platform driver\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9082,8 +8989,7 @@ static int __init thinkpad_acpi_module_init(void)
                                         &tpacpi_hwmon_pdriver.driver);
         }
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to create sysfs driver attributes\n");
+                pr_err("unable to create sysfs driver attributes\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9096,7 +9002,7 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_pdev)) {
                 ret = PTR_ERR(tpacpi_pdev);
                 tpacpi_pdev = NULL;
-                printk(TPACPI_ERR "unable to register platform device\n");
+                pr_err("unable to register platform device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9106,16 +9012,14 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_sensors_pdev)) {
                 ret = PTR_ERR(tpacpi_sensors_pdev);
                 tpacpi_sensors_pdev = NULL;
-                printk(TPACPI_ERR
-                       "unable to register hwmon platform device\n");
+                pr_err("unable to register hwmon platform device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
         ret = device_create_file(&tpacpi_sensors_pdev->dev,
                                  &dev_attr_thinkpad_acpi_pdev_name);
         if (ret) {
-                printk(TPACPI_ERR
-                       "unable to create sysfs hwmon device attributes\n");
+                pr_err("unable to create sysfs hwmon device attributes\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
@@ -9124,14 +9028,14 @@ static int __init thinkpad_acpi_module_init(void)
         if (IS_ERR(tpacpi_hwmon)) {
                 ret = PTR_ERR(tpacpi_hwmon);
                 tpacpi_hwmon = NULL;
-                printk(TPACPI_ERR "unable to register hwmon device\n");
+                pr_err("unable to register hwmon device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         }
         mutex_init(&tpacpi_inputdev_send_mutex);
         tpacpi_inputdev = input_allocate_device();
         if (!tpacpi_inputdev) {
-                printk(TPACPI_ERR "unable to allocate input device\n");
+                pr_err("unable to allocate input device\n");
                 thinkpad_acpi_module_exit();
                 return -ENOMEM;
         } else {
@@ -9163,7 +9067,7 @@ static int __init thinkpad_acpi_module_init(void)
 
         ret = input_register_device(tpacpi_inputdev);
         if (ret < 0) {
-                printk(TPACPI_ERR "unable to register input device\n");
+                pr_err("unable to register input device\n");
                 thinkpad_acpi_module_exit();
                 return ret;
         } else {
diff --git a/drivers/platform/x86/topstar-laptop.c b/drivers/platform/x86/topstar-laptop.c
index 1d07d6d09f27..4c20447ddbb7 100644
--- a/drivers/platform/x86/topstar-laptop.c
+++ b/drivers/platform/x86/topstar-laptop.c
@@ -194,7 +194,7 @@ static int __init topstar_laptop_init(void)
         if (ret < 0)
                 return ret;
 
-        printk(KERN_INFO "Topstar Laptop ACPI extras driver loaded\n");
+        pr_info("ACPI extras driver loaded\n");
 
         return 0;
 }
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index 63f42a22e102..cb009b2629ee 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -35,6 +35,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #define TOSHIBA_ACPI_VERSION    "0.19"
 #define PROC_INTERFACE_VERSION  1
 
@@ -60,11 +62,6 @@ MODULE_AUTHOR("John Belmonte");
 MODULE_DESCRIPTION("Toshiba Laptop ACPI Extras Driver");
 MODULE_LICENSE("GPL");
 
-#define MY_LOGPREFIX "toshiba_acpi: "
-#define MY_ERR KERN_ERR MY_LOGPREFIX
-#define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
-#define MY_INFO KERN_INFO MY_LOGPREFIX
-
 /* Toshiba ACPI method paths */
 #define METHOD_LCD_BRIGHTNESS   "\\_SB_.PCI0.VGA_.LCD_._BCM"
 #define TOSH_INTERFACE_1        "\\_SB_.VALD"
@@ -301,7 +298,7 @@ static int toshiba_illumination_available(void)
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return 0;
         }
         in[0] = 0xf400;
@@ -320,7 +317,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return;
         }
 
@@ -331,7 +328,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
                 in[2] = 1;
                 status = hci_raw(in, out);
                 if (ACPI_FAILURE(status)) {
-                        printk(MY_INFO "ACPI call for illumination failed.\n");
+                        pr_info("ACPI call for illumination failed\n");
                         return;
                 }
         } else {
@@ -341,7 +338,7 @@ static void toshiba_illumination_set(struct led_classdev *cdev,
                 in[2] = 0;
                 status = hci_raw(in, out);
                 if (ACPI_FAILURE(status)) {
-                        printk(MY_INFO "ACPI call for illumination failed.\n");
+                        pr_info("ACPI call for illumination failed.\n");
                         return;
                 }
         }
@@ -364,7 +361,7 @@ static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
         in[0] = 0xf100;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Illumination device not available\n");
+                pr_info("Illumination device not available\n");
                 return LED_OFF;
         }
 
@@ -373,7 +370,7 @@ static enum led_brightness toshiba_illumination_get(struct led_classdev *cdev)
         in[1] = 0x14e;
         status = hci_raw(in, out);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "ACPI call for illumination failed.\n");
+                pr_info("ACPI call for illumination failed.\n");
                 return LED_OFF;
         }
 
@@ -517,7 +514,7 @@ static int lcd_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "brightness_levels:       %d\n",
                              HCI_LCD_BRIGHTNESS_LEVELS);
         } else {
-                printk(MY_ERR "Error reading LCD brightness\n");
+                pr_err("Error reading LCD brightness\n");
         }
 
         return 0;
@@ -592,7 +589,7 @@ static int video_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "crt_out:                 %d\n", is_crt);
                 seq_printf(m, "tv_out:                  %d\n", is_tv);
         } else {
-                printk(MY_ERR "Error reading video out status\n");
+                pr_err("Error reading video out status\n");
         }
 
         return 0;
@@ -686,7 +683,7 @@ static int fan_proc_show(struct seq_file *m, void *v)
                 seq_printf(m, "running:                 %d\n", (value > 0));
                 seq_printf(m, "force_on:                %d\n", force_fan);
         } else {
-                printk(MY_ERR "Error reading fan status\n");
+                pr_err("Error reading fan status\n");
         }
 
         return 0;
@@ -750,9 +747,9 @@ static int keys_proc_show(struct seq_file *m, void *v)
                          * some machines where system events sporadically
                          * become disabled. */
                         hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
-                        printk(MY_NOTICE "Re-enabled hotkeys\n");
+                        pr_notice("Re-enabled hotkeys\n");
                 } else {
-                        printk(MY_ERR "Error reading hotkey status\n");
+                        pr_err("Error reading hotkey status\n");
                         goto end;
                 }
         }
@@ -863,7 +860,7 @@ static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
 
                         if (!sparse_keymap_report_event(toshiba_acpi.hotkey_dev,
                                                         value, 1, true)) {
-                                printk(MY_INFO "Unknown key %x\n",
+                                pr_info("Unknown key %x\n",
                                        value);
                         }
                 } else if (hci_result == HCI_NOT_SUPPORTED) {
@@ -871,7 +868,7 @@ static void toshiba_acpi_notify(acpi_handle handle, u32 event, void *context)
                          * some machines where system events sporadically
                          * become disabled. */
                         hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
-                        printk(MY_NOTICE "Re-enabled hotkeys\n");
+                        pr_notice("Re-enabled hotkeys\n");
                 }
         } while (hci_result != HCI_EMPTY);
 }
@@ -883,13 +880,13 @@ static int __init toshiba_acpi_setup_keyboard(char *device)
 
         status = acpi_get_handle(NULL, device, &toshiba_acpi.handle);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to get notification device\n");
+                pr_info("Unable to get notification device\n");
                 return -ENODEV;
         }
 
         toshiba_acpi.hotkey_dev = input_allocate_device();
         if (!toshiba_acpi.hotkey_dev) {
-                printk(MY_INFO "Unable to register input device\n");
+                pr_info("Unable to register input device\n");
                 return -ENOMEM;
         }
 
@@ -905,21 +902,21 @@ static int __init toshiba_acpi_setup_keyboard(char *device)
         status = acpi_install_notify_handler(toshiba_acpi.handle,
                                 ACPI_DEVICE_NOTIFY, toshiba_acpi_notify, NULL);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to install hotkey notification\n");
+                pr_info("Unable to install hotkey notification\n");
                 error = -ENODEV;
                 goto err_free_keymap;
         }
 
         status = acpi_evaluate_object(toshiba_acpi.handle, "ENAB", NULL, NULL);
         if (ACPI_FAILURE(status)) {
-                printk(MY_INFO "Unable to enable hotkeys\n");
+                pr_info("Unable to enable hotkeys\n");
                 error = -ENODEV;
                 goto err_remove_notify;
         }
 
         error = input_register_device(toshiba_acpi.hotkey_dev);
         if (error) {
-                printk(MY_INFO "Unable to register input device\n");
+                pr_info("Unable to register input device\n");
                 goto err_remove_notify;
         }
 
@@ -980,17 +977,17 @@ static int __init toshiba_acpi_init(void)
         if (is_valid_acpi_path(TOSH_INTERFACE_1 GHCI_METHOD)) {
                 method_hci = TOSH_INTERFACE_1 GHCI_METHOD;
                 if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_1))
-                        printk(MY_INFO "Unable to activate hotkeys\n");
+                        pr_info("Unable to activate hotkeys\n");
         } else if (is_valid_acpi_path(TOSH_INTERFACE_2 GHCI_METHOD)) {
                 method_hci = TOSH_INTERFACE_2 GHCI_METHOD;
                 if (toshiba_acpi_setup_keyboard(TOSH_INTERFACE_2))
-                        printk(MY_INFO "Unable to activate hotkeys\n");
+                        pr_info("Unable to activate hotkeys\n");
         } else
                 return -ENODEV;
 
-        printk(MY_INFO "Toshiba Laptop ACPI Extras version %s\n",
+        pr_info("Toshiba Laptop ACPI Extras version %s\n",
                TOSHIBA_ACPI_VERSION);
-        printk(MY_INFO "    HCI method: %s\n", method_hci);
+        pr_info("    HCI method: %s\n", method_hci);
 
         mutex_init(&toshiba_acpi.mutex);
 
@@ -998,7 +995,7 @@ static int __init toshiba_acpi_init(void)
                                                               -1, NULL, 0);
         if (IS_ERR(toshiba_acpi.p_dev)) {
                 ret = PTR_ERR(toshiba_acpi.p_dev);
-                printk(MY_ERR "unable to register platform device\n");
+                pr_err("unable to register platform device\n");
                 toshiba_acpi.p_dev = NULL;
                 toshiba_acpi_exit();
                 return ret;
@@ -1028,7 +1025,7 @@ static int __init toshiba_acpi_init(void)
         if (IS_ERR(toshiba_backlight_device)) {
                 ret = PTR_ERR(toshiba_backlight_device);
 
-                printk(KERN_ERR "Could not register toshiba backlight device\n");
+                pr_err("Could not register toshiba backlight device\n");
                 toshiba_backlight_device = NULL;
                 toshiba_acpi_exit();
                 return ret;
@@ -1042,14 +1039,14 @@ static int __init toshiba_acpi_init(void)
                                                    &toshiba_rfk_ops,
                                                    &toshiba_acpi);
                 if (!toshiba_acpi.bt_rfk) {
-                        printk(MY_ERR "unable to allocate rfkill device\n");
+                        pr_err("unable to allocate rfkill device\n");
                         toshiba_acpi_exit();
                         return -ENOMEM;
                 }
 
                 ret = rfkill_register(toshiba_acpi.bt_rfk);
                 if (ret) {
-                        printk(MY_ERR "unable to register rfkill device\n");
+                        pr_err("unable to register rfkill device\n");
                         rfkill_destroy(toshiba_acpi.bt_rfk);
                         toshiba_acpi_exit();
                         return ret;
diff --git a/drivers/platform/x86/toshiba_bluetooth.c b/drivers/platform/x86/toshiba_bluetooth.c
index 944068611919..5fb7186694df 100644
--- a/drivers/platform/x86/toshiba_bluetooth.c
+++ b/drivers/platform/x86/toshiba_bluetooth.c
@@ -17,6 +17,8 @@
  * delivered.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -70,14 +72,13 @@ static int toshiba_bluetooth_enable(acpi_handle handle)
         if (!(result & 0x01))
                 return 0;
 
-        printk(KERN_INFO "toshiba_bluetooth: Re-enabling Toshiba Bluetooth\n");
+        pr_info("Re-enabling Toshiba Bluetooth\n");
         res1 = acpi_evaluate_object(handle, "AUSB", NULL, NULL);
         res2 = acpi_evaluate_object(handle, "BTPO", NULL, NULL);
         if (!ACPI_FAILURE(res1) || !ACPI_FAILURE(res2))
                 return 0;
 
-        printk(KERN_WARNING "toshiba_bluetooth: Failed to re-enable "
-               "Toshiba Bluetooth\n");
+        pr_warn("Failed to re-enable Toshiba Bluetooth\n");
 
         return -ENODEV;
 }
@@ -107,8 +108,8 @@ static int toshiba_bt_rfkill_add(struct acpi_device *device)
                                        &bt_present);
 
         if (!ACPI_FAILURE(status) && bt_present) {
-                printk(KERN_INFO "Detected Toshiba ACPI Bluetooth device - "
-                      "installing RFKill handler\n");
+                pr_info("Detected Toshiba ACPI Bluetooth device - "
+                        "installing RFKill handler\n");
                 result = toshiba_bluetooth_enable(device->handle);
         }
 
diff --git a/drivers/platform/x86/wmi.c b/drivers/platform/x86/wmi.c
index 05cc79672a8b..f23d5a84e7b1 100644
--- a/drivers/platform/x86/wmi.c
+++ b/drivers/platform/x86/wmi.c
@@ -486,16 +486,16 @@ static void wmi_dump_wdg(const struct guid_block *g)
         pr_info("\tnotify_id: %02X\n", g->notify_id);
         pr_info("\treserved: %02X\n", g->reserved);
         pr_info("\tinstance_count: %d\n", g->instance_count);
-        pr_info("\tflags: %#x ", g->flags);
+        pr_info("\tflags: %#x", g->flags);
         if (g->flags) {
                 if (g->flags & ACPI_WMI_EXPENSIVE)
-                        pr_cont("ACPI_WMI_EXPENSIVE ");
+                        pr_cont(" ACPI_WMI_EXPENSIVE");
                 if (g->flags & ACPI_WMI_METHOD)
-                        pr_cont("ACPI_WMI_METHOD ");
+                        pr_cont(" ACPI_WMI_METHOD");
                 if (g->flags & ACPI_WMI_STRING)
-                        pr_cont("ACPI_WMI_STRING ");
+                        pr_cont(" ACPI_WMI_STRING");
                 if (g->flags & ACPI_WMI_EVENT)
-                        pr_cont("ACPI_WMI_EVENT ");
+                        pr_cont(" ACPI_WMI_EVENT");
         }
         pr_cont("\n");
 
diff --git a/drivers/platform/x86/xo15-ebook.c b/drivers/platform/x86/xo15-ebook.c
index c1372ed9d2e9..fad153dc0355 100644
--- a/drivers/platform/x86/xo15-ebook.c
+++ b/drivers/platform/x86/xo15-ebook.c
@@ -11,6 +11,8 @@
  *  your option) any later version.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -20,7 +22,6 @@
 #include <acpi/acpi_drivers.h>
 
 #define MODULE_NAME "xo15-ebook"
-#define PREFIX MODULE_NAME ": "
 
 #define XO15_EBOOK_CLASS                MODULE_NAME
 #define XO15_EBOOK_TYPE_UNKNOWN 0x00
@@ -105,7 +106,7 @@ static int ebook_switch_add(struct acpi_device *device)
         class = acpi_device_class(device);
 
         if (strcmp(hid, XO15_EBOOK_HID)) {
-                printk(KERN_ERR PREFIX "Unsupported hid [%s]\n", hid);
+                pr_err("Unsupported hid [%s]\n", hid);
                 error = -ENODEV;
                 goto err_free_input;
         }
diff --git a/drivers/scsi/aic94xx/aic94xx_init.c b/drivers/scsi/aic94xx/aic94xx_init.c
index 3b7e83d2dab4..d5ff142c93a2 100644
--- a/drivers/scsi/aic94xx/aic94xx_init.c
+++ b/drivers/scsi/aic94xx/aic94xx_init.c
@@ -486,7 +486,7 @@ static ssize_t asd_show_update_bios(struct device *dev,
                         flash_error_table[i].reason);
 }
 
-static DEVICE_ATTR(update_bios, S_IRUGO|S_IWUGO,
+static DEVICE_ATTR(update_bios, S_IRUGO|S_IWUSR,
         asd_show_update_bios, asd_store_update_bios);
 
 static int asd_create_dev_attrs(struct asd_ha_struct *asd_ha)
diff --git a/drivers/scsi/bfa/bfa_ioc.c b/drivers/scsi/bfa/bfa_ioc.c
index c1f72c49196f..6c7e0339dda4 100644
--- a/drivers/scsi/bfa/bfa_ioc.c
+++ b/drivers/scsi/bfa/bfa_ioc.c
@@ -56,6 +56,8 @@ BFA_TRC_FILE(CNA, IOC);
 #define bfa_ioc_map_port(__ioc) ((__ioc)->ioc_hwif->ioc_map_port(__ioc))
 #define bfa_ioc_notify_fail(__ioc)              \
                         ((__ioc)->ioc_hwif->ioc_notify_fail(__ioc))
+#define bfa_ioc_sync_start(__ioc)               \
+                        ((__ioc)->ioc_hwif->ioc_sync_start(__ioc))
 #define bfa_ioc_sync_join(__ioc)                \
                         ((__ioc)->ioc_hwif->ioc_sync_join(__ioc))
 #define bfa_ioc_sync_leave(__ioc)               \
@@ -647,7 +649,7 @@ bfa_iocpf_sm_fwcheck(struct bfa_iocpf_s *iocpf, enum iocpf_event event)
         switch (event) {
         case IOCPF_E_SEMLOCKED:
                 if (bfa_ioc_firmware_lock(ioc)) {
-                        if (bfa_ioc_sync_complete(ioc)) {
+                        if (bfa_ioc_sync_start(ioc)) {
                                 iocpf->retry_count = 0;
                                 bfa_ioc_sync_join(ioc);
                                 bfa_fsm_set_state(iocpf, bfa_iocpf_sm_hwinit);
diff --git a/drivers/scsi/bfa/bfa_ioc.h b/drivers/scsi/bfa/bfa_ioc.h
index ec9cf08b0e7f..c85182a704fb 100644
--- a/drivers/scsi/bfa/bfa_ioc.h
+++ b/drivers/scsi/bfa/bfa_ioc.h
@@ -263,6 +263,7 @@ struct bfa_ioc_hwif_s {
                                         bfa_boolean_t msix);
         void            (*ioc_notify_fail)      (struct bfa_ioc_s *ioc);
         void            (*ioc_ownership_reset)  (struct bfa_ioc_s *ioc);
+        bfa_boolean_t   (*ioc_sync_start)       (struct bfa_ioc_s *ioc);
         void            (*ioc_sync_join)        (struct bfa_ioc_s *ioc);
         void            (*ioc_sync_leave)       (struct bfa_ioc_s *ioc);
         void            (*ioc_sync_ack)         (struct bfa_ioc_s *ioc);
diff --git a/drivers/scsi/bfa/bfa_ioc_cb.c b/drivers/scsi/bfa/bfa_ioc_cb.c
index e4a0713185b6..89ae4c8f95a2 100644
--- a/drivers/scsi/bfa/bfa_ioc_cb.c
+++ b/drivers/scsi/bfa/bfa_ioc_cb.c
@@ -32,6 +32,7 @@ static void bfa_ioc_cb_map_port(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
 static void bfa_ioc_cb_notify_fail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_ownership_reset(struct bfa_ioc_s *ioc);
+static bfa_boolean_t bfa_ioc_cb_sync_start(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_sync_join(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_sync_leave(struct bfa_ioc_s *ioc);
 static void bfa_ioc_cb_sync_ack(struct bfa_ioc_s *ioc);
@@ -53,6 +54,7 @@ bfa_ioc_set_cb_hwif(struct bfa_ioc_s *ioc)
         hwif_cb.ioc_isr_mode_set = bfa_ioc_cb_isr_mode_set;
         hwif_cb.ioc_notify_fail = bfa_ioc_cb_notify_fail;
         hwif_cb.ioc_ownership_reset = bfa_ioc_cb_ownership_reset;
+        hwif_cb.ioc_sync_start = bfa_ioc_cb_sync_start;
         hwif_cb.ioc_sync_join = bfa_ioc_cb_sync_join;
         hwif_cb.ioc_sync_leave = bfa_ioc_cb_sync_leave;
         hwif_cb.ioc_sync_ack = bfa_ioc_cb_sync_ack;
@@ -195,6 +197,15 @@ bfa_ioc_cb_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix)
 }
 
 /*
+ * Synchronized IOC failure processing routines
+ */
+static bfa_boolean_t
+bfa_ioc_cb_sync_start(struct bfa_ioc_s *ioc)
+{
+        return bfa_ioc_cb_sync_complete(ioc);
+}
+
+/*
  * Cleanup hw semaphore and usecnt registers
  */
 static void
diff --git a/drivers/scsi/bfa/bfa_ioc_ct.c b/drivers/scsi/bfa/bfa_ioc_ct.c
index 008d129ddfcd..93612520f0d2 100644
--- a/drivers/scsi/bfa/bfa_ioc_ct.c
+++ b/drivers/scsi/bfa/bfa_ioc_ct.c
@@ -41,6 +41,7 @@ static void bfa_ioc_ct_map_port(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_isr_mode_set(struct bfa_ioc_s *ioc, bfa_boolean_t msix);
 static void bfa_ioc_ct_notify_fail(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc);
+static bfa_boolean_t bfa_ioc_ct_sync_start(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_sync_join(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_sync_leave(struct bfa_ioc_s *ioc);
 static void bfa_ioc_ct_sync_ack(struct bfa_ioc_s *ioc);
@@ -62,6 +63,7 @@ bfa_ioc_set_ct_hwif(struct bfa_ioc_s *ioc)
         hwif_ct.ioc_isr_mode_set = bfa_ioc_ct_isr_mode_set;
         hwif_ct.ioc_notify_fail = bfa_ioc_ct_notify_fail;
         hwif_ct.ioc_ownership_reset = bfa_ioc_ct_ownership_reset;
+        hwif_ct.ioc_sync_start = bfa_ioc_ct_sync_start;
         hwif_ct.ioc_sync_join = bfa_ioc_ct_sync_join;
         hwif_ct.ioc_sync_leave = bfa_ioc_ct_sync_leave;
         hwif_ct.ioc_sync_ack = bfa_ioc_ct_sync_ack;
@@ -351,6 +353,30 @@ bfa_ioc_ct_ownership_reset(struct bfa_ioc_s *ioc)
         writel(1, ioc->ioc_regs.ioc_sem_reg);
 }
 
+static bfa_boolean_t
+bfa_ioc_ct_sync_start(struct bfa_ioc_s *ioc)
+{
+        uint32_t r32 = readl(ioc->ioc_regs.ioc_fail_sync);
+        uint32_t sync_reqd = bfa_ioc_ct_get_sync_reqd(r32);
+
+        /*
+         * Driver load time.  If the sync required bit for this PCI fn
+         * is set, it is due to an unclean exit by the driver for this
+         * PCI fn in the previous incarnation. Whoever comes here first
+         * should clean it up, no matter which PCI fn.
+         */
+
+        if (sync_reqd & bfa_ioc_ct_sync_pos(ioc)) {
+                writel(0, ioc->ioc_regs.ioc_fail_sync);
+                writel(1, ioc->ioc_regs.ioc_usage_reg);
+                writel(BFI_IOC_UNINIT, ioc->ioc_regs.ioc_fwstate);
+                writel(BFI_IOC_UNINIT, ioc->ioc_regs.alt_ioc_fwstate);
+                return BFA_TRUE;
+        }
+
+        return bfa_ioc_ct_sync_complete(ioc);
+}
+
 /*
  * Synchronized IOC failure processing routines
  */
diff --git a/drivers/scsi/bnx2i/bnx2i.h b/drivers/scsi/bnx2i/bnx2i.h
index cfd59023227b..6bdd25a93db9 100644
--- a/drivers/scsi/bnx2i/bnx2i.h
+++ b/drivers/scsi/bnx2i/bnx2i.h
@@ -66,11 +66,11 @@
 #define BD_SPLIT_SIZE                   32768
 
 /* min, max & default values for SQ/RQ/CQ size, configurable via' modparam */
-#define BNX2I_SQ_WQES_MIN               16
-#define BNX2I_570X_SQ_WQES_MAX          128
-#define BNX2I_5770X_SQ_WQES_MAX         512
-#define BNX2I_570X_SQ_WQES_DEFAULT      128
-#define BNX2I_5770X_SQ_WQES_DEFAULT     256
+#define BNX2I_SQ_WQES_MIN               16
+#define BNX2I_570X_SQ_WQES_MAX          128
+#define BNX2I_5770X_SQ_WQES_MAX         512
+#define BNX2I_570X_SQ_WQES_DEFAULT      128
+#define BNX2I_5770X_SQ_WQES_DEFAULT     128
 
 #define BNX2I_570X_CQ_WQES_MAX          128
 #define BNX2I_5770X_CQ_WQES_MAX         512
@@ -115,6 +115,7 @@
 #define BNX2X_MAX_CQS                   8
 
 #define CNIC_ARM_CQE                    1
+#define CNIC_ARM_CQE_FP                 2
 #define CNIC_DISARM_CQE                 0
 
 #define REG_RD(__hba, offset)                           \
@@ -666,7 +667,9 @@ enum {
  *                      after HBA reset is completed by bnx2i/cnic/bnx2
  *                      modules
  * @state:              tracks offload connection state machine
- * @teardown_mode:      indicates if conn teardown is abortive or orderly
+ * @timestamp:          tracks the start time when the ep begins to connect
+ * @num_active_cmds:    tracks the number of outstanding commands for this ep
+ * @ec_shift:           the amount of shift as part of the event coal calc
  * @qp:                 QP information
  * @ids:                contains chip allocated *context id* & driver assigned
  *                      *iscsi cid*
@@ -685,6 +688,7 @@ struct bnx2i_endpoint {
         u32 state;
         unsigned long timestamp;
         int num_active_cmds;
+        u32 ec_shift;
 
         struct qp_info qp;
         struct ep_handles ids;
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index f0b89513faed..5c54a2d9b834 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -138,7 +138,6 @@ void bnx2i_arm_cq_event_coalescing(struct bnx2i_endpoint *ep, u8 action)
         u16 next_index;
         u32 num_active_cmds;
 
-
         /* Coalesce CQ entries only on 10G devices */
         if (!test_bit(BNX2I_NX2_DEV_57710, &ep->hba->cnic_dev_type))
                 return;
@@ -148,16 +147,19 @@ void bnx2i_arm_cq_event_coalescing(struct bnx2i_endpoint *ep, u8 action)
          * interrupts and other unwanted results
          */
         cq_db = (struct bnx2i_5771x_cq_db *) ep->qp.cq_pgtbl_virt;
-        if (cq_db->sqn[0] && cq_db->sqn[0] != 0xFFFF)
-                return;
 
-        if (action == CNIC_ARM_CQE) {
+        if (action != CNIC_ARM_CQE_FP)
+                if (cq_db->sqn[0] && cq_db->sqn[0] != 0xFFFF)
+                        return;
+
+        if (action == CNIC_ARM_CQE || action == CNIC_ARM_CQE_FP) {
                 num_active_cmds = ep->num_active_cmds;
                 if (num_active_cmds <= event_coal_min)
                         next_index = 1;
                 else
                         next_index = event_coal_min +
-                                (num_active_cmds - event_coal_min) / event_coal_div;
+                                     ((num_active_cmds - event_coal_min) >>
+                                     ep->ec_shift);
                 if (!next_index)
                         next_index = 1;
                 cq_index = ep->qp.cqe_exp_seq_sn + next_index - 1;
@@ -1274,6 +1276,7 @@ int bnx2i_send_fw_iscsi_init_msg(struct bnx2i_hba *hba)
         iscsi_init.dummy_buffer_addr_hi =
                 (u32) ((u64) hba->dummy_buf_dma >> 32);
 
+        hba->num_ccell = hba->max_sqes >> 1;
         hba->ctx_ccell_tasks =
                         ((hba->num_ccell & 0xFFFF) | (hba->max_sqes << 16));
         iscsi_init.num_ccells_per_conn = hba->num_ccell;
@@ -1934,7 +1937,6 @@ cqe_out:
                         qp->cq_cons_idx++;
                 }
         }
-        bnx2i_arm_cq_event_coalescing(bnx2i_conn->ep, CNIC_ARM_CQE);
 }
 
 /**
@@ -1948,22 +1950,23 @@ cqe_out:
 static void bnx2i_fastpath_notification(struct bnx2i_hba *hba,
                                         struct iscsi_kcqe *new_cqe_kcqe)
 {
-        struct bnx2i_conn *conn;
+        struct bnx2i_conn *bnx2i_conn;
         u32 iscsi_cid;
 
         iscsi_cid = new_cqe_kcqe->iscsi_conn_id;
-        conn = bnx2i_get_conn_from_id(hba, iscsi_cid);
+        bnx2i_conn = bnx2i_get_conn_from_id(hba, iscsi_cid);
 
-        if (!conn) {
+        if (!bnx2i_conn) {
                 printk(KERN_ALERT "cid #%x not valid\n", iscsi_cid);
                 return;
         }
-        if (!conn->ep) {
+        if (!bnx2i_conn->ep) {
                 printk(KERN_ALERT "cid #%x - ep not bound\n", iscsi_cid);
                 return;
         }
-
-        bnx2i_process_new_cqes(conn);
+        bnx2i_process_new_cqes(bnx2i_conn);
+        bnx2i_arm_cq_event_coalescing(bnx2i_conn->ep, CNIC_ARM_CQE_FP);
+        bnx2i_process_new_cqes(bnx2i_conn);
 }
 
 
diff --git a/drivers/scsi/bnx2i/bnx2i_init.c b/drivers/scsi/bnx2i/bnx2i_init.c
index 1d24a2819736..6adbdc34a9a5 100644
--- a/drivers/scsi/bnx2i/bnx2i_init.c
+++ b/drivers/scsi/bnx2i/bnx2i_init.c
@@ -244,7 +244,7 @@ void bnx2i_stop(void *handle)
         wait_event_interruptible_timeout(hba->eh_wait,
                                          (list_empty(&hba->ep_ofld_list) &&
                                          list_empty(&hba->ep_destroy_list)),
-                                         10 * HZ);
+                                         2 * HZ);
         /* Wait for all endpoints to be torn down, Chip will be reset once
          *  control returns to network driver. So it is required to cleanup and
          * release all connection resources before returning from this routine.
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index 1809f9ccc4ce..041928b23cb0 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -379,6 +379,7 @@ static struct iscsi_endpoint *bnx2i_alloc_ep(struct bnx2i_hba *hba)
 {
         struct iscsi_endpoint *ep;
         struct bnx2i_endpoint *bnx2i_ep;
+        u32 ec_div;
 
         ep = iscsi_create_endpoint(sizeof(*bnx2i_ep));
         if (!ep) {
@@ -393,6 +394,11 @@ static struct iscsi_endpoint *bnx2i_alloc_ep(struct bnx2i_hba *hba)
         bnx2i_ep->ep_iscsi_cid = (u16) -1;
         bnx2i_ep->hba = hba;
         bnx2i_ep->hba_age = hba->age;
+
+        ec_div = event_coal_div;
+        while (ec_div >>= 1)
+                bnx2i_ep->ec_shift += 1;
+
         hba->ofld_conns_active++;
         init_waitqueue_head(&bnx2i_ep->ofld_wait);
         return ep;
@@ -858,7 +864,7 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic)
         mutex_init(&hba->net_dev_lock);
         init_waitqueue_head(&hba->eh_wait);
         if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
-                hba->hba_shutdown_tmo = 20 * HZ;
+                hba->hba_shutdown_tmo = 30 * HZ;
                 hba->conn_teardown_tmo = 20 * HZ;
                 hba->conn_ctx_destroy_tmo = 6 * HZ;
         } else {        /* 5706/5708/5709 */
@@ -1208,6 +1214,9 @@ static int bnx2i_task_xmit(struct iscsi_task *task)
         struct bnx2i_cmd *cmd = task->dd_data;
         struct iscsi_cmd *hdr = (struct iscsi_cmd *) task->hdr;
 
+        if (bnx2i_conn->ep->num_active_cmds + 1 > hba->max_sqes)
+                return -ENOMEM;
+
         /*
          * If there is no scsi_cmnd this must be a mgmt task
          */
@@ -2156,7 +2165,7 @@ static struct scsi_host_template bnx2i_host_template = {
         .change_queue_depth     = iscsi_change_queue_depth,
         .can_queue              = 1024,
         .max_sectors            = 127,
-        .cmd_per_lun            = 32,
+        .cmd_per_lun            = 24,
         .this_id                = -1,
         .use_clustering         = ENABLE_CLUSTERING,
         .sg_tablesize           = ISCSI_MAX_BDS_PER_CMD,
diff --git a/drivers/scsi/fcoe/fcoe.c b/drivers/scsi/fcoe/fcoe.c
index cc23bd9480b2..155d7b9bdeae 100644
--- a/drivers/scsi/fcoe/fcoe.c
+++ b/drivers/scsi/fcoe/fcoe.c
@@ -137,6 +137,7 @@ static int fcoe_vport_create(struct fc_vport *, bool disabled);
 static int fcoe_vport_disable(struct fc_vport *, bool disable);
 static void fcoe_set_vport_symbolic_name(struct fc_vport *);
 static void fcoe_set_port_id(struct fc_lport *, u32, struct fc_frame *);
+static int fcoe_validate_vport_create(struct fc_vport *);
 
 static struct libfc_function_template fcoe_libfc_fcn_templ = {
         .frame_send = fcoe_xmit,
@@ -2351,6 +2352,17 @@ static int fcoe_vport_create(struct fc_vport *vport, bool disabled)
         struct fcoe_interface *fcoe = port->priv;
         struct net_device *netdev = fcoe->netdev;
         struct fc_lport *vn_port;
+        int rc;
+        char buf[32];
+
+        rc = fcoe_validate_vport_create(vport);
+        if (rc) {
+                wwn_to_str(vport->port_name, buf, sizeof(buf));
+                printk(KERN_ERR "fcoe: Failed to create vport, "
+                        "WWPN (0x%s) already exists\n",
+                        buf);
+                return rc;
+        }
 
         mutex_lock(&fcoe_config_mutex);
         vn_port = fcoe_if_create(fcoe, &vport->dev, 1);
@@ -2497,3 +2509,49 @@ static void fcoe_set_port_id(struct fc_lport *lport,
         if (fp && fc_frame_payload_op(fp) == ELS_FLOGI)
                 fcoe_ctlr_recv_flogi(&fcoe->ctlr, lport, fp);
 }
+
+/**
+ * fcoe_validate_vport_create() - Validate a vport before creating it
+ * @vport: NPIV port to be created
+ *
+ * This routine is meant to add validation for a vport before creating it
+ * via fcoe_vport_create().
+ * Current validations are:
+ *      - WWPN supplied is unique for given lport
+ *
+ *
+*/
+static int fcoe_validate_vport_create(struct fc_vport *vport)
+{
+        struct Scsi_Host *shost = vport_to_shost(vport);
+        struct fc_lport *n_port = shost_priv(shost);
+        struct fc_lport *vn_port;
+        int rc = 0;
+        char buf[32];
+
+        mutex_lock(&n_port->lp_mutex);
+
+        wwn_to_str(vport->port_name, buf, sizeof(buf));
+        /* Check if the wwpn is not same as that of the lport */
+        if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) {
+                FCOE_DBG("vport WWPN 0x%s is same as that of the "
+                        "base port WWPN\n", buf);
+                rc = -EINVAL;
+                goto out;
+        }
+
+        /* Check if there is any existing vport with same wwpn */
+        list_for_each_entry(vn_port, &n_port->vports, list) {
+                if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) {
+                        FCOE_DBG("vport with given WWPN 0x%s already "
+                        "exists\n", buf);
+                        rc = -EINVAL;
+                        break;
+                }
+        }
+
+out:
+        mutex_unlock(&n_port->lp_mutex);
+
+        return rc;
+}
diff --git a/drivers/scsi/fcoe/fcoe.h b/drivers/scsi/fcoe/fcoe.h
index 408a6fd78fb4..c4a93993c0cf 100644
--- a/drivers/scsi/fcoe/fcoe.h
+++ b/drivers/scsi/fcoe/fcoe.h
@@ -99,4 +99,14 @@ static inline struct net_device *fcoe_netdev(const struct fc_lport *lport)
                         ((struct fcoe_port *)lport_priv(lport))->priv)->netdev;
 }
 
+static inline void wwn_to_str(u64 wwn, char *buf, int len)
+{
+        u8 wwpn[8];
+
+        u64_to_wwn(wwn, wwpn);
+        snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x",
+                wwpn[0], wwpn[1], wwpn[2], wwpn[3],
+                wwpn[4], wwpn[5], wwpn[6], wwpn[7]);
+}
+
 #endif /* _FCOE_H_ */
diff --git a/drivers/scsi/fcoe/fcoe_ctlr.c b/drivers/scsi/fcoe/fcoe_ctlr.c
index 229e4af5508a..c74c4b8e71ef 100644
--- a/drivers/scsi/fcoe/fcoe_ctlr.c
+++ b/drivers/scsi/fcoe/fcoe_ctlr.c
@@ -1173,7 +1173,9 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
         struct fc_lport *lport = fip->lp;
         struct fc_lport *vn_port = NULL;
         u32 desc_mask;
-        int is_vn_port = 0;
+        int num_vlink_desc;
+        int reset_phys_port = 0;
+        struct fip_vn_desc **vlink_desc_arr = NULL;
 
         LIBFCOE_FIP_DBG(fip, "Clear Virtual Link received\n");
 
@@ -1183,70 +1185,73 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
         /*
          * mask of required descriptors.  Validating each one clears its bit.
          */
-        desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) | BIT(FIP_DT_VN_ID);
+        desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME);
 
         rlen = ntohs(fh->fip_dl_len) * FIP_BPW;
         desc = (struct fip_desc *)(fh + 1);
+
+        /*
+         * Actually need to subtract 'sizeof(*mp) - sizeof(*wp)' from 'rlen'
+         * before determining max Vx_Port descriptor but a buggy FCF could have
+         * omited either or both MAC Address and Name Identifier descriptors
+         */
+        num_vlink_desc = rlen / sizeof(*vp);
+        if (num_vlink_desc)
+                vlink_desc_arr = kmalloc(sizeof(vp) * num_vlink_desc,
+                                         GFP_ATOMIC);
+        if (!vlink_desc_arr)
+                return;
+        num_vlink_desc = 0;
+
         while (rlen >= sizeof(*desc)) {
                 dlen = desc->fip_dlen * FIP_BPW;
                 if (dlen > rlen)
-                        return;
+                        goto err;
                 /* Drop CVL if there are duplicate critical descriptors */
                 if ((desc->fip_dtype < 32) &&
+                    (desc->fip_dtype != FIP_DT_VN_ID) &&
                     !(desc_mask & 1U << desc->fip_dtype)) {
                         LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
                                         "Descriptors in FIP CVL\n");
-                        return;
+                        goto err;
                 }
                 switch (desc->fip_dtype) {
                 case FIP_DT_MAC:
                         mp = (struct fip_mac_desc *)desc;
                         if (dlen < sizeof(*mp))
-                                return;
+                                goto err;
                         if (compare_ether_addr(mp->fd_mac, fcf->fcf_mac))
-                                return;
+                                goto err;
                         desc_mask &= ~BIT(FIP_DT_MAC);
                         break;
                 case FIP_DT_NAME:
                         wp = (struct fip_wwn_desc *)desc;
                         if (dlen < sizeof(*wp))
-                                return;
+                                goto err;
                         if (get_unaligned_be64(&wp->fd_wwn) != fcf->switch_name)
-                                return;
+                                goto err;
                         desc_mask &= ~BIT(FIP_DT_NAME);
                         break;
                 case FIP_DT_VN_ID:
                         vp = (struct fip_vn_desc *)desc;
                         if (dlen < sizeof(*vp))
-                                return;
-                        if (compare_ether_addr(vp->fd_mac,
-                                               fip->get_src_addr(lport)) == 0 &&
-                            get_unaligned_be64(&vp->fd_wwpn) == lport->wwpn &&
-                            ntoh24(vp->fd_fc_id) == lport->port_id) {
-                                desc_mask &= ~BIT(FIP_DT_VN_ID);
-                                break;
+                                goto err;
+                        vlink_desc_arr[num_vlink_desc++] = vp;
+                        vn_port = fc_vport_id_lookup(lport,
+                                                      ntoh24(vp->fd_fc_id));
+                        if (vn_port && (vn_port == lport)) {
+                                mutex_lock(&fip->ctlr_mutex);
+                                per_cpu_ptr(lport->dev_stats,
+                                            get_cpu())->VLinkFailureCount++;
+                                put_cpu();
+                                fcoe_ctlr_reset(fip);
+                                mutex_unlock(&fip->ctlr_mutex);
                         }
-                        /* check if clr_vlink is for NPIV port */
-                        mutex_lock(&lport->lp_mutex);
-                        list_for_each_entry(vn_port, &lport->vports, list) {
-                                if (compare_ether_addr(vp->fd_mac,
-                                    fip->get_src_addr(vn_port)) == 0 &&
-                                    (get_unaligned_be64(&vp->fd_wwpn)
-                                                        == vn_port->wwpn) &&
-                                    (ntoh24(vp->fd_fc_id) ==
-                                            fc_host_port_id(vn_port->host))) {
-                                        desc_mask &= ~BIT(FIP_DT_VN_ID);
-                                        is_vn_port = 1;
-                                        break;
-                                }
-                        }
-                        mutex_unlock(&lport->lp_mutex);
-
                         break;
                 default:
                         /* standard says ignore unknown descriptors >= 128 */
                         if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
-                                return;
+                                goto err;
                         break;
                 }
                 desc = (struct fip_desc *)((char *)desc + dlen);
@@ -1256,26 +1261,68 @@ static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
         /*
          * reset only if all required descriptors were present and valid.
          */
-        if (desc_mask) {
+        if (desc_mask)
                 LIBFCOE_FIP_DBG(fip, "missing descriptors mask %x\n",
                                 desc_mask);
+        else if (!num_vlink_desc) {
+                LIBFCOE_FIP_DBG(fip, "CVL: no Vx_Port descriptor found\n");
+                /*
+                 * No Vx_Port description. Clear all NPIV ports,
+                 * followed by physical port
+                 */
+                mutex_lock(&lport->lp_mutex);
+                list_for_each_entry(vn_port, &lport->vports, list)
+                        fc_lport_reset(vn_port);
+                mutex_unlock(&lport->lp_mutex);
+
+                mutex_lock(&fip->ctlr_mutex);
+                per_cpu_ptr(lport->dev_stats,
+                            get_cpu())->VLinkFailureCount++;
+                put_cpu();
+                fcoe_ctlr_reset(fip);
+                mutex_unlock(&fip->ctlr_mutex);
+
+                fc_lport_reset(fip->lp);
+                fcoe_ctlr_solicit(fip, NULL);
         } else {
-                LIBFCOE_FIP_DBG(fip, "performing Clear Virtual Link\n");
+                int i;
 
-                if (is_vn_port)
-                        fc_lport_reset(vn_port);
-                else {
-                        mutex_lock(&fip->ctlr_mutex);
-                        per_cpu_ptr(lport->dev_stats,
-                                    get_cpu())->VLinkFailureCount++;
-                        put_cpu();
-                        fcoe_ctlr_reset(fip);
-                        mutex_unlock(&fip->ctlr_mutex);
+                LIBFCOE_FIP_DBG(fip, "performing Clear Virtual Link\n");
+                for (i = 0; i < num_vlink_desc; i++) {
+                        vp = vlink_desc_arr[i];
+                        vn_port = fc_vport_id_lookup(lport,
+                                                     ntoh24(vp->fd_fc_id));
+                        if (!vn_port)
+                                continue;
+
+                        /*
+                         * 'port_id' is already validated, check MAC address and
+                         * wwpn
+                         */
+                        if (compare_ether_addr(fip->get_src_addr(vn_port),
+                                                vp->fd_mac) != 0 ||
+                                get_unaligned_be64(&vp->fd_wwpn) !=
+                                                        vn_port->wwpn)
+                                continue;
+
+                        if (vn_port == lport)
+                                /*
+                                 * Physical port, defer processing till all
+                                 * listed NPIV ports are cleared
+                                 */
+                                reset_phys_port = 1;
+                        else    /* NPIV port */
+                                fc_lport_reset(vn_port);
+                }
 
+                if (reset_phys_port) {
                         fc_lport_reset(fip->lp);
                         fcoe_ctlr_solicit(fip, NULL);
                 }
         }
+
+err:
+        kfree(vlink_desc_arr);
 }
 
 /**
diff --git a/drivers/scsi/fcoe/fcoe_transport.c b/drivers/scsi/fcoe/fcoe_transport.c
index f81f77c8569e..41068e8748e7 100644
--- a/drivers/scsi/fcoe/fcoe_transport.c
+++ b/drivers/scsi/fcoe/fcoe_transport.c
@@ -544,16 +544,6 @@ static int fcoe_transport_create(const char *buffer, struct kernel_param *kp)
         struct fcoe_transport *ft = NULL;
         enum fip_state fip_mode = (enum fip_state)(long)kp->arg;
 
-#ifdef CONFIG_LIBFCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module parameter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE)
-                goto out_nodev;
-#endif
-
         mutex_lock(&ft_mutex);
 
         netdev = fcoe_if_to_netdev(buffer);
@@ -618,16 +608,6 @@ static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-#ifdef CONFIG_LIBFCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module parameter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE)
-                goto out_nodev;
-#endif
-
         mutex_lock(&ft_mutex);
 
         netdev = fcoe_if_to_netdev(buffer);
@@ -672,16 +652,6 @@ static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-#ifdef CONFIG_LIBFCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module parameter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE)
-                goto out_nodev;
-#endif
-
         mutex_lock(&ft_mutex);
 
         netdev = fcoe_if_to_netdev(buffer);
@@ -720,16 +690,6 @@ static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp)
         struct net_device *netdev = NULL;
         struct fcoe_transport *ft = NULL;
 
-#ifdef CONFIG_LIBFCOE_MODULE
-        /*
-         * Make sure the module has been initialized, and is not about to be
-         * removed.  Module parameter sysfs files are writable before the
-         * module_init function is called and after module_exit.
-         */
-        if (THIS_MODULE->state != MODULE_STATE_LIVE)
-                goto out_nodev;
-#endif
-
         mutex_lock(&ft_mutex);
 
         netdev = fcoe_if_to_netdev(buffer);
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 12868ca46110..888086c4e709 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -5149,21 +5149,21 @@ static irqreturn_t ipr_isr(int irq, void *devp)
 
                 if (ipr_cmd != NULL) {
                         /* Clear the PCI interrupt */
+                        num_hrrq = 0;
                         do {
                                 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
                                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
                                         num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
 
-                        if (int_reg & IPR_PCII_HRRQ_UPDATED) {
-                                ipr_isr_eh(ioa_cfg, "Error clearing HRRQ");
-                                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
-                                return IRQ_HANDLED;
-                        }
-
                 } else if (rc == IRQ_NONE && irq_none == 0) {
                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
                         irq_none++;
+                } else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
+                           int_reg & IPR_PCII_HRRQ_UPDATED) {
+                        ipr_isr_eh(ioa_cfg, "Error clearing HRRQ");
+                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
+                        return IRQ_HANDLED;
                 } else
                         break;
         }
diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
index 911b2736cafa..b9cb8140b398 100644
--- a/drivers/scsi/libfc/fc_disc.c
+++ b/drivers/scsi/libfc/fc_disc.c
@@ -205,6 +205,7 @@ static void fc_disc_recv_req(struct fc_lport *lport, struct fc_frame *fp)
         default:
                 FC_DISC_DBG(disc, "Received an unsupported request, "
                             "the opcode is (%x)\n", op);
+                fc_frame_free(fp);
                 break;
         }
 }
diff --git a/drivers/scsi/libfc/fc_exch.c b/drivers/scsi/libfc/fc_exch.c
index 77035a746f60..3b8a6451ea28 100644
--- a/drivers/scsi/libfc/fc_exch.c
+++ b/drivers/scsi/libfc/fc_exch.c
@@ -1434,6 +1434,7 @@ static void fc_exch_recv_seq_resp(struct fc_exch_mgr *mp, struct fc_frame *fp)
             (f_ctl & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
             (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
                 spin_lock_bh(&ep->ex_lock);
+                resp = ep->resp;
                 rc = fc_exch_done_locked(ep);
                 WARN_ON(fc_seq_exch(sp) != ep);
                 spin_unlock_bh(&ep->ex_lock);
@@ -1978,6 +1979,7 @@ static struct fc_seq *fc_exch_seq_send(struct fc_lport *lport,
         spin_unlock_bh(&ep->ex_lock);
         return sp;
 err:
+        fc_fcp_ddp_done(fr_fsp(fp));
         rc = fc_exch_done_locked(ep);
         spin_unlock_bh(&ep->ex_lock);
         if (!rc)
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 2a3a4720a771..9cd2149519ac 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -312,7 +312,7 @@ void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid)
  *                     DDP related resources for a fcp_pkt
  * @fsp: The FCP packet that DDP had been used on
  */
-static void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
+void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp)
 {
         struct fc_lport *lport;
 
@@ -681,8 +681,7 @@ static int fc_fcp_send_data(struct fc_fcp_pkt *fsp, struct fc_seq *seq,
                 error = lport->tt.seq_send(lport, seq, fp);
                 if (error) {
                         WARN_ON(1);             /* send error should be rare */
-                        fc_fcp_retry_cmd(fsp);
-                        return 0;
+                        return error;
                 }
                 fp = NULL;
         }
@@ -1673,7 +1672,8 @@ static void fc_fcp_srr(struct fc_fcp_pkt *fsp, enum fc_rctl r_ctl, u32 offset)
                        FC_FCTL_REQ, 0);
 
         rec_tov = get_fsp_rec_tov(fsp);
-        seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp, NULL,
+        seq = lport->tt.exch_seq_send(lport, fp, fc_fcp_srr_resp,
+                                      fc_fcp_pkt_destroy,
                                       fsp, jiffies_to_msecs(rec_tov));
         if (!seq)
                 goto retry;
@@ -1720,7 +1720,6 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                 return;
         }
 
-        fsp->recov_seq = NULL;
         switch (fc_frame_payload_op(fp)) {
         case ELS_LS_ACC:
                 fsp->recov_retry = 0;
@@ -1732,10 +1731,9 @@ static void fc_fcp_srr_resp(struct fc_seq *seq, struct fc_frame *fp, void *arg)
                 break;
         }
         fc_fcp_unlock_pkt(fsp);
-        fsp->lp->tt.exch_done(seq);
 out:
+        fsp->lp->tt.exch_done(seq);
         fc_frame_free(fp);
-        fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
 }
 
 /**
@@ -1747,8 +1745,6 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
 {
         if (fc_fcp_lock_pkt(fsp))
                 goto out;
-        fsp->lp->tt.exch_done(fsp->recov_seq);
-        fsp->recov_seq = NULL;
         switch (PTR_ERR(fp)) {
         case -FC_EX_TIMEOUT:
                 if (fsp->recov_retry++ < FC_MAX_RECOV_RETRY)
@@ -1764,7 +1760,7 @@ static void fc_fcp_srr_error(struct fc_fcp_pkt *fsp, struct fc_frame *fp)
         }
         fc_fcp_unlock_pkt(fsp);
 out:
-        fc_fcp_pkt_release(fsp);        /* drop hold for outstanding SRR */
+        fsp->lp->tt.exch_done(fsp->recov_seq);
 }
 
 /**
diff --git a/drivers/scsi/libfc/fc_libfc.h b/drivers/scsi/libfc/fc_libfc.h
index fedc819d70c0..c7d071289af5 100644
--- a/drivers/scsi/libfc/fc_libfc.h
+++ b/drivers/scsi/libfc/fc_libfc.h
@@ -108,6 +108,7 @@ extern struct fc4_prov fc_rport_fcp_init;	/* FCP initiator provider */
  * Set up direct-data placement for this I/O request
  */
 void fc_fcp_ddp_setup(struct fc_fcp_pkt *fsp, u16 xid);
+void fc_fcp_ddp_done(struct fc_fcp_pkt *fsp);
 
 /*
  * Module setup functions
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 31fc21f4d831..db9238f2ecb8 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -99,19 +99,29 @@ static void sas_ata_task_done(struct sas_task *task)
         struct sas_ha_struct *sas_ha;
         enum ata_completion_errors ac;
         unsigned long flags;
+        struct ata_link *link;
 
         if (!qc)
                 goto qc_already_gone;
 
         dev = qc->ap->private_data;
         sas_ha = dev->port->ha;
+        link = &dev->sata_dev.ap->link;
 
         spin_lock_irqsave(dev->sata_dev.ap->lock, flags);
         if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD ||
             ((stat->stat == SAM_STAT_CHECK_CONDITION &&
               dev->sata_dev.command_set == ATAPI_COMMAND_SET))) {
                 ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf);
-                qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+
+                if (!link->sactive) {
+                        qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+                } else {
+                        link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+                        if (unlikely(link->eh_info.err_mask))
+                                qc->flags |= ATA_QCFLAG_FAILED;
+                }
+
                 dev->sata_dev.sstatus = resp->sstatus;
                 dev->sata_dev.serror = resp->serror;
                 dev->sata_dev.scontrol = resp->scontrol;
@@ -121,7 +131,13 @@ static void sas_ata_task_done(struct sas_task *task)
                         SAS_DPRINTK("%s: SAS error %x\n", __func__,
                                     stat->stat);
                         /* We saw a SAS error. Send a vague error. */
-                        qc->err_mask = ac;
+                        if (!link->sactive) {
+                                qc->err_mask = ac;
+                        } else {
+                                link->eh_info.err_mask |= AC_ERR_DEV;
+                                qc->flags |= ATA_QCFLAG_FAILED;
+                        }
+
                         dev->sata_dev.tf.feature = 0x04; /* status err */
                         dev->sata_dev.tf.command = ATA_ERR;
                 }
@@ -279,6 +295,44 @@ static int sas_ata_hard_reset(struct ata_link *link, unsigned int *class,
         return ret;
 }
 
+static int sas_ata_soft_reset(struct ata_link *link, unsigned int *class,
+                               unsigned long deadline)
+{
+        struct ata_port *ap = link->ap;
+        struct domain_device *dev = ap->private_data;
+        struct sas_internal *i =
+                to_sas_internal(dev->port->ha->core.shost->transportt);
+        int res = TMF_RESP_FUNC_FAILED;
+        int ret = 0;
+
+        if (i->dft->lldd_ata_soft_reset)
+                res = i->dft->lldd_ata_soft_reset(dev);
+
+        if (res != TMF_RESP_FUNC_COMPLETE) {
+                SAS_DPRINTK("%s: Unable to soft reset\n", __func__);
+                ret = -EAGAIN;
+        }
+
+        switch (dev->sata_dev.command_set) {
+        case ATA_COMMAND_SET:
+                SAS_DPRINTK("%s: Found ATA device.\n", __func__);
+                *class = ATA_DEV_ATA;
+                break;
+        case ATAPI_COMMAND_SET:
+                SAS_DPRINTK("%s: Found ATAPI device.\n", __func__);
+                *class = ATA_DEV_ATAPI;
+                break;
+        default:
+                SAS_DPRINTK("%s: Unknown SATA command set: %d.\n",
+                            __func__, dev->sata_dev.command_set);
+                *class = ATA_DEV_UNKNOWN;
+                break;
+        }
+
+        ap->cbl = ATA_CBL_SATA;
+        return ret;
+}
+
 static void sas_ata_post_internal(struct ata_queued_cmd *qc)
 {
         if (qc->flags & ATA_QCFLAG_FAILED)
@@ -309,7 +363,7 @@ static void sas_ata_post_internal(struct ata_queued_cmd *qc)
 
 static struct ata_port_operations sas_sata_ops = {
         .prereset               = ata_std_prereset,
-        .softreset              = NULL,
+        .softreset              = sas_ata_soft_reset,
         .hardreset              = sas_ata_hard_reset,
         .postreset              = ata_std_postreset,
         .error_handler          = ata_std_error_handler,
diff --git a/drivers/scsi/libsas/sas_internal.h b/drivers/scsi/libsas/sas_internal.h
index 8b538bd1ff2b..14e21b5fb8ba 100644
--- a/drivers/scsi/libsas/sas_internal.h
+++ b/drivers/scsi/libsas/sas_internal.h
@@ -57,7 +57,7 @@ int  sas_init_queue(struct sas_ha_struct *sas_ha);
 int  sas_init_events(struct sas_ha_struct *sas_ha);
 void sas_shutdown_queue(struct sas_ha_struct *sas_ha);
 
-void sas_deform_port(struct asd_sas_phy *phy);
+void sas_deform_port(struct asd_sas_phy *phy, int gone);
 
 void sas_porte_bytes_dmaed(struct work_struct *work);
 void sas_porte_broadcast_rcvd(struct work_struct *work);
diff --git a/drivers/scsi/libsas/sas_phy.c b/drivers/scsi/libsas/sas_phy.c
index b459c4b635b1..e0f5018e9071 100644
--- a/drivers/scsi/libsas/sas_phy.c
+++ b/drivers/scsi/libsas/sas_phy.c
@@ -39,7 +39,7 @@ static void sas_phye_loss_of_signal(struct work_struct *work)
         sas_begin_event(PHYE_LOSS_OF_SIGNAL, &phy->ha->event_lock,
                         &phy->phy_events_pending);
         phy->error = 0;
-        sas_deform_port(phy);
+        sas_deform_port(phy, 1);
 }
 
 static void sas_phye_oob_done(struct work_struct *work)
@@ -66,7 +66,7 @@ static void sas_phye_oob_error(struct work_struct *work)
         sas_begin_event(PHYE_OOB_ERROR, &phy->ha->event_lock,
                         &phy->phy_events_pending);
 
-        sas_deform_port(phy);
+        sas_deform_port(phy, 1);
 
         if (!port && phy->enabled && i->dft->lldd_control_phy) {
                 phy->error++;
diff --git a/drivers/scsi/libsas/sas_port.c b/drivers/scsi/libsas/sas_port.c
index 5257fdfe699a..42fd1f25b664 100644
--- a/drivers/scsi/libsas/sas_port.c
+++ b/drivers/scsi/libsas/sas_port.c
@@ -57,7 +57,7 @@ static void sas_form_port(struct asd_sas_phy *phy)
 
         if (port) {
                 if (!phy_is_wideport_member(port, phy))
-                        sas_deform_port(phy);
+                        sas_deform_port(phy, 0);
                 else {
                         SAS_DPRINTK("%s: phy%d belongs to port%d already(%d)!\n",
                                     __func__, phy->id, phy->port->id,
@@ -153,28 +153,31 @@ static void sas_form_port(struct asd_sas_phy *phy)
  * This is called when the physical link to the other phy has been
  * lost (on this phy), in Event thread context. We cannot delay here.
  */
-void sas_deform_port(struct asd_sas_phy *phy)
+void sas_deform_port(struct asd_sas_phy *phy, int gone)
 {
         struct sas_ha_struct *sas_ha = phy->ha;
         struct asd_sas_port *port = phy->port;
         struct sas_internal *si =
                 to_sas_internal(sas_ha->core.shost->transportt);
+        struct domain_device *dev;
         unsigned long flags;
 
         if (!port)
                 return;           /* done by a phy event */
 
-        if (port->port_dev)
-                port->port_dev->pathways--;
+        dev = port->port_dev;
+        if (dev)
+                dev->pathways--;
 
         if (port->num_phys == 1) {
+                if (dev && gone)
+                        dev->gone = 1;
                 sas_unregister_domain_devices(port);
                 sas_port_delete(port->port);
                 port->port = NULL;
         } else
                 sas_port_delete_phy(port->port, phy->phy);
 
-
         if (si->dft->lldd_port_deformed)
                 si->dft->lldd_port_deformed(phy);
 
@@ -244,7 +247,7 @@ void sas_porte_link_reset_err(struct work_struct *work)
         sas_begin_event(PORTE_LINK_RESET_ERR, &phy->ha->event_lock,
                         &phy->port_events_pending);
 
-        sas_deform_port(phy);
+        sas_deform_port(phy, 1);
 }
 
 void sas_porte_timer_event(struct work_struct *work)
@@ -256,7 +259,7 @@ void sas_porte_timer_event(struct work_struct *work)
         sas_begin_event(PORTE_TIMER_EVENT, &phy->ha->event_lock,
                         &phy->port_events_pending);
 
-        sas_deform_port(phy);
+        sas_deform_port(phy, 1);
 }
 
 void sas_porte_hard_reset(struct work_struct *work)
@@ -268,7 +271,7 @@ void sas_porte_hard_reset(struct work_struct *work)
         sas_begin_event(PORTE_HARD_RESET, &phy->ha->event_lock,
                         &phy->port_events_pending);
 
-        sas_deform_port(phy);
+        sas_deform_port(phy, 1);
 }
 
 /* ---------- SAS port registration ---------- */
@@ -306,6 +309,6 @@ void sas_unregister_ports(struct sas_ha_struct *sas_ha)
 
         for (i = 0; i < sas_ha->num_phys; i++)
                 if (sas_ha->sas_phy[i]->port)
-                        sas_deform_port(sas_ha->sas_phy[i]);
+                        sas_deform_port(sas_ha->sas_phy[i], 0);
 
 }
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index f6e189f40917..eeba76cdf774 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -207,6 +207,13 @@ static int sas_queuecommand_lck(struct scsi_cmnd *cmd,
                 struct sas_ha_struct *sas_ha = dev->port->ha;
                 struct sas_task *task;
 
+                /* If the device fell off, no sense in issuing commands */
+                if (dev->gone) {
+                        cmd->result = DID_BAD_TARGET << 16;
+                        scsi_done(cmd);
+                        goto out;
+                }
+
                 if (dev_is_sata(dev)) {
                         unsigned long flags;
 
@@ -216,13 +223,6 @@ static int sas_queuecommand_lck(struct scsi_cmnd *cmd,
                         goto out;
                 }
 
-                /* If the device fell off, no sense in issuing commands */
-                if (dev->gone) {
-                        cmd->result = DID_BAD_TARGET << 16;
-                        scsi_done(cmd);
-                        goto out;
-                }
-
                 res = -ENOMEM;
                 task = sas_create_task(cmd, dev, GFP_ATOMIC);
                 if (!task)
diff --git a/drivers/scsi/lpfc/lpfc.h b/drivers/scsi/lpfc/lpfc.h
index 02d53d89534f..8ec2c86a49d4 100644
--- a/drivers/scsi/lpfc/lpfc.h
+++ b/drivers/scsi/lpfc/lpfc.h
@@ -41,6 +41,7 @@ struct lpfc_sli2_slim;
                 downloads using bsg */
 #define LPFC_DEFAULT_PROT_SG_SEG_CNT 4096 /* sg protection elements count */
 #define LPFC_MAX_SG_SEG_CNT     4096    /* sg element count per scsi cmnd */
+#define LPFC_MAX_SGE_SIZE       0x80000000 /* Maximum data allowed in a SGE */
 #define LPFC_MAX_PROT_SG_SEG_CNT 4096   /* prot sg element count per scsi cmd*/
 #define LPFC_IOCB_LIST_CNT      2250    /* list of IOCBs for fast-path usage. */
 #define LPFC_Q_RAMP_UP_INTERVAL 120     /* lun q_depth ramp up interval */
@@ -486,6 +487,42 @@ struct unsol_rcv_ct_ctx {
                                      (1 << LPFC_USER_LINK_SPEED_AUTO))
 #define LPFC_LINK_SPEED_STRING "0, 1, 2, 4, 8, 10, 16"
 
+enum nemb_type {
+        nemb_mse = 1,
+        nemb_hbd
+};
+
+enum mbox_type {
+        mbox_rd = 1,
+        mbox_wr
+};
+
+enum dma_type {
+        dma_mbox = 1,
+        dma_ebuf
+};
+
+enum sta_type {
+        sta_pre_addr = 1,
+        sta_pos_addr
+};
+
+struct lpfc_mbox_ext_buf_ctx {
+        uint32_t state;
+#define LPFC_BSG_MBOX_IDLE              0
+#define LPFC_BSG_MBOX_HOST              1
+#define LPFC_BSG_MBOX_PORT              2
+#define LPFC_BSG_MBOX_DONE              3
+#define LPFC_BSG_MBOX_ABTS              4
+        enum nemb_type nembType;
+        enum mbox_type mboxType;
+        uint32_t numBuf;
+        uint32_t mbxTag;
+        uint32_t seqNum;
+        struct lpfc_dmabuf *mbx_dmabuf;
+        struct list_head ext_dmabuf_list;
+};
+
 struct lpfc_hba {
         /* SCSI interface function jump table entries */
         int (*lpfc_new_scsi_buf)
@@ -589,6 +626,7 @@ struct lpfc_hba {
 
         MAILBOX_t *mbox;
         uint32_t *mbox_ext;
+        struct lpfc_mbox_ext_buf_ctx mbox_ext_buf_ctx;
         uint32_t ha_copy;
         struct _PCB *pcb;
         struct _IOCB *IOCBs;
@@ -659,6 +697,7 @@ struct lpfc_hba {
         uint32_t cfg_hostmem_hgp;
         uint32_t cfg_log_verbose;
         uint32_t cfg_aer_support;
+        uint32_t cfg_sriov_nr_virtfn;
         uint32_t cfg_iocb_cnt;
         uint32_t cfg_suppress_link_up;
 #define LPFC_INITIALIZE_LINK              0     /* do normal init_link mbox */
@@ -706,7 +745,6 @@ struct lpfc_hba {
         uint32_t          *hbq_get;     /* Host mem address of HBQ get ptrs */
 
         int brd_no;                     /* FC board number */
-
         char SerialNumber[32];          /* adapter Serial Number */
         char OptionROMVersion[32];      /* adapter BIOS / Fcode version */
         char ModelDesc[256];            /* Model Description */
@@ -778,6 +816,9 @@ struct lpfc_hba {
         uint16_t vpi_base;
         uint16_t vfi_base;
         unsigned long *vpi_bmask;       /* vpi allocation table */
+        uint16_t *vpi_ids;
+        uint16_t vpi_count;
+        struct list_head lpfc_vpi_blk_list;
 
         /* Data structure used by fabric iocb scheduler */
         struct list_head fabric_iocb_list;
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index 8dcbf8fff673..135a53baa735 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -755,6 +755,73 @@ lpfc_issue_reset(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * lpfc_sli4_pdev_reg_request - Request physical dev to perform a register acc
+ * @phba: lpfc_hba pointer.
+ *
+ * Description:
+ * Request SLI4 interface type-2 device to perform a physical register set
+ * access.
+ *
+ * Returns:
+ * zero for success
+ **/
+static ssize_t
+lpfc_sli4_pdev_reg_request(struct lpfc_hba *phba, uint32_t opcode)
+{
+        struct completion online_compl;
+        uint32_t reg_val;
+        int status = 0;
+        int rc;
+
+        if (!phba->cfg_enable_hba_reset)
+                return -EIO;
+
+        if ((phba->sli_rev < LPFC_SLI_REV4) ||
+            (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+             LPFC_SLI_INTF_IF_TYPE_2))
+                return -EPERM;
+
+        status = lpfc_do_offline(phba, LPFC_EVT_OFFLINE);
+
+        if (status != 0)
+                return status;
+
+        /* wait for the device to be quiesced before firmware reset */
+        msleep(100);
+
+        reg_val = readl(phba->sli4_hba.conf_regs_memmap_p +
+                        LPFC_CTL_PDEV_CTL_OFFSET);
+
+        if (opcode == LPFC_FW_DUMP)
+                reg_val |= LPFC_FW_DUMP_REQUEST;
+        else if (opcode == LPFC_FW_RESET)
+                reg_val |= LPFC_CTL_PDEV_CTL_FRST;
+        else if (opcode == LPFC_DV_RESET)
+                reg_val |= LPFC_CTL_PDEV_CTL_DRST;
+
+        writel(reg_val, phba->sli4_hba.conf_regs_memmap_p +
+               LPFC_CTL_PDEV_CTL_OFFSET);
+        /* flush */
+        readl(phba->sli4_hba.conf_regs_memmap_p + LPFC_CTL_PDEV_CTL_OFFSET);
+
+        /* delay driver action following IF_TYPE_2 reset */
+        msleep(100);
+
+        init_completion(&online_compl);
+        rc = lpfc_workq_post_event(phba, &status, &online_compl,
+                                   LPFC_EVT_ONLINE);
+        if (rc == 0)
+                return -ENOMEM;
+
+        wait_for_completion(&online_compl);
+
+        if (status != 0)
+                return -EIO;
+
+        return 0;
+}
+
+/**
  * lpfc_nport_evt_cnt_show - Return the number of nport events
  * @dev: class device that is converted into a Scsi_host.
  * @attr: device attribute, not used.
@@ -848,6 +915,12 @@ lpfc_board_mode_store(struct device *dev, struct device_attribute *attr,
                         return -EINVAL;
                 else
                         status = lpfc_do_offline(phba, LPFC_EVT_KILL);
+        else if (strncmp(buf, "dump", sizeof("dump") - 1) == 0)
+                status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_DUMP);
+        else if (strncmp(buf, "fw_reset", sizeof("fw_reset") - 1) == 0)
+                status = lpfc_sli4_pdev_reg_request(phba, LPFC_FW_RESET);
+        else if (strncmp(buf, "dv_reset", sizeof("dv_reset") - 1) == 0)
+                status = lpfc_sli4_pdev_reg_request(phba, LPFC_DV_RESET);
         else
                 return -EINVAL;
 
@@ -1322,6 +1395,102 @@ lpfc_dss_show(struct device *dev, struct device_attribute *attr,
 }
 
 /**
+ * lpfc_sriov_hw_max_virtfn_show - Return maximum number of virtual functions
+ * @dev: class converted to a Scsi_host structure.
+ * @attr: device attribute, not used.
+ * @buf: on return contains the formatted support level.
+ *
+ * Description:
+ * Returns the maximum number of virtual functions a physical function can
+ * support, 0 will be returned if called on virtual function.
+ *
+ * Returns: size of formatted string.
+ **/
+static ssize_t
+lpfc_sriov_hw_max_virtfn_show(struct device *dev,
+                              struct device_attribute *attr,
+                              char *buf)
+{
+        struct Scsi_Host *shost = class_to_shost(dev);
+        struct lpfc_vport *vport = (struct lpfc_vport *) shost->hostdata;
+        struct lpfc_hba *phba = vport->phba;
+        struct pci_dev *pdev = phba->pcidev;
+        union  lpfc_sli4_cfg_shdr *shdr;
+        uint32_t shdr_status, shdr_add_status;
+        LPFC_MBOXQ_t *mboxq;
+        struct lpfc_mbx_get_prof_cfg *get_prof_cfg;
+        struct lpfc_rsrc_desc_pcie *desc;
+        uint32_t max_nr_virtfn;
+        uint32_t desc_count;
+        int length, rc, i;
+
+        if ((phba->sli_rev < LPFC_SLI_REV4) ||
+            (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+             LPFC_SLI_INTF_IF_TYPE_2))
+                return -EPERM;
+
+        if (!pdev->is_physfn)
+                return snprintf(buf, PAGE_SIZE, "%d\n", 0);
+
+        mboxq = (LPFC_MBOXQ_t *)mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mboxq)
+                return -ENOMEM;
+
+        /* get the maximum number of virtfn support by physfn */
+        length = (sizeof(struct lpfc_mbx_get_prof_cfg) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_COMMON,
+                         LPFC_MBOX_OPCODE_GET_PROFILE_CONFIG,
+                         length, LPFC_SLI4_MBX_EMBED);
+        shdr = (union lpfc_sli4_cfg_shdr *)
+                &mboxq->u.mqe.un.sli4_config.header.cfg_shdr;
+        bf_set(lpfc_mbox_hdr_pf_num, &shdr->request,
+               phba->sli4_hba.iov.pf_number + 1);
+
+        get_prof_cfg = &mboxq->u.mqe.un.get_prof_cfg;
+        bf_set(lpfc_mbx_get_prof_cfg_prof_tp, &get_prof_cfg->u.request,
+               LPFC_CFG_TYPE_CURRENT_ACTIVE);
+
+        rc = lpfc_sli_issue_mbox_wait(phba, mboxq,
+                                lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG));
+
+        if (rc != MBX_TIMEOUT) {
+                /* check return status */
+                shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                                         &shdr->response);
+                if (shdr_status || shdr_add_status || rc)
+                        goto error_out;
+
+        } else
+                goto error_out;
+
+        desc_count = get_prof_cfg->u.response.prof_cfg.rsrc_desc_count;
+
+        for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
+                desc = (struct lpfc_rsrc_desc_pcie *)
+                        &get_prof_cfg->u.response.prof_cfg.desc[i];
+                if (LPFC_RSRC_DESC_TYPE_PCIE ==
+                    bf_get(lpfc_rsrc_desc_pcie_type, desc)) {
+                        max_nr_virtfn = bf_get(lpfc_rsrc_desc_pcie_nr_virtfn,
+                                               desc);
+                        break;
+                }
+        }
+
+        if (i < LPFC_RSRC_DESC_MAX_NUM) {
+                if (rc != MBX_TIMEOUT)
+                        mempool_free(mboxq, phba->mbox_mem_pool);
+                return snprintf(buf, PAGE_SIZE, "%d\n", max_nr_virtfn);
+        }
+
+error_out:
+        if (rc != MBX_TIMEOUT)
+                mempool_free(mboxq, phba->mbox_mem_pool);
+        return -EIO;
+}
+
+/**
  * lpfc_param_show - Return a cfg attribute value in decimal
  *
  * Description:
@@ -1762,6 +1931,8 @@ static DEVICE_ATTR(lpfc_temp_sensor, S_IRUGO, lpfc_temp_sensor_show, NULL);
 static DEVICE_ATTR(lpfc_fips_level, S_IRUGO, lpfc_fips_level_show, NULL);
 static DEVICE_ATTR(lpfc_fips_rev, S_IRUGO, lpfc_fips_rev_show, NULL);
 static DEVICE_ATTR(lpfc_dss, S_IRUGO, lpfc_dss_show, NULL);
+static DEVICE_ATTR(lpfc_sriov_hw_max_virtfn, S_IRUGO,
+                   lpfc_sriov_hw_max_virtfn_show, NULL);
 
 static char *lpfc_soft_wwn_key = "C99G71SL8032A";
 
@@ -3014,7 +3185,7 @@ static DEVICE_ATTR(lpfc_link_speed, S_IRUGO | S_IWUSR,
  *
  * @dev: class device that is converted into a Scsi_host.
  * @attr: device attribute, not used.
- * @buf: containing the string "selective".
+ * @buf: containing enable or disable aer flag.
  * @count: unused variable.
  *
  * Description:
@@ -3098,7 +3269,7 @@ lpfc_param_show(aer_support)
 /**
  * lpfc_aer_support_init - Set the initial adapters aer support flag
  * @phba: lpfc_hba pointer.
- * @val: link speed value.
+ * @val: enable aer or disable aer flag.
  *
  * Description:
  * If val is in a valid range [0,1], then set the adapter's initial
@@ -3137,7 +3308,7 @@ static DEVICE_ATTR(lpfc_aer_support, S_IRUGO | S_IWUSR,
  * lpfc_aer_cleanup_state - Clean up aer state to the aer enabled device
  * @dev: class device that is converted into a Scsi_host.
  * @attr: device attribute, not used.
- * @buf: containing the string "selective".
+ * @buf: containing flag 1 for aer cleanup state.
  * @count: unused variable.
  *
  * Description:
@@ -3180,6 +3351,136 @@ lpfc_aer_cleanup_state(struct device *dev, struct device_attribute *attr,
 static DEVICE_ATTR(lpfc_aer_state_cleanup, S_IWUSR, NULL,
                    lpfc_aer_cleanup_state);
 
+/**
+ * lpfc_sriov_nr_virtfn_store - Enable the adapter for sr-iov virtual functions
+ *
+ * @dev: class device that is converted into a Scsi_host.
+ * @attr: device attribute, not used.
+ * @buf: containing the string the number of vfs to be enabled.
+ * @count: unused variable.
+ *
+ * Description:
+ * When this api is called either through user sysfs, the driver shall
+ * try to enable or disable SR-IOV virtual functions according to the
+ * following:
+ *
+ * If zero virtual function has been enabled to the physical function,
+ * the driver shall invoke the pci enable virtual function api trying
+ * to enable the virtual functions. If the nr_vfn provided is greater
+ * than the maximum supported, the maximum virtual function number will
+ * be used for invoking the api; otherwise, the nr_vfn provided shall
+ * be used for invoking the api. If the api call returned success, the
+ * actual number of virtual functions enabled will be set to the driver
+ * cfg_sriov_nr_virtfn; otherwise, -EINVAL shall be returned and driver
+ * cfg_sriov_nr_virtfn remains zero.
+ *
+ * If none-zero virtual functions have already been enabled to the
+ * physical function, as reflected by the driver's cfg_sriov_nr_virtfn,
+ * -EINVAL will be returned and the driver does nothing;
+ *
+ * If the nr_vfn provided is zero and none-zero virtual functions have
+ * been enabled, as indicated by the driver's cfg_sriov_nr_virtfn, the
+ * disabling virtual function api shall be invoded to disable all the
+ * virtual functions and driver's cfg_sriov_nr_virtfn shall be set to
+ * zero. Otherwise, if zero virtual function has been enabled, do
+ * nothing.
+ *
+ * Returns:
+ * length of the buf on success if val is in range the intended mode
+ * is supported.
+ * -EINVAL if val out of range or intended mode is not supported.
+ **/
+static ssize_t
+lpfc_sriov_nr_virtfn_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;
+        struct pci_dev *pdev = phba->pcidev;
+        int val = 0, rc = -EINVAL;
+
+        /* Sanity check on user data */
+        if (!isdigit(buf[0]))
+                return -EINVAL;
+        if (sscanf(buf, "%i", &val) != 1)
+                return -EINVAL;
+        if (val < 0)
+                return -EINVAL;
+
+        /* Request disabling virtual functions */
+        if (val == 0) {
+                if (phba->cfg_sriov_nr_virtfn > 0) {
+                        pci_disable_sriov(pdev);
+                        phba->cfg_sriov_nr_virtfn = 0;
+                }
+                return strlen(buf);
+        }
+
+        /* Request enabling virtual functions */
+        if (phba->cfg_sriov_nr_virtfn > 0) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3018 There are %d virtual functions "
+                                "enabled on physical function.\n",
+                                phba->cfg_sriov_nr_virtfn);
+                return -EEXIST;
+        }
+
+        if (val <= LPFC_MAX_VFN_PER_PFN)
+                phba->cfg_sriov_nr_virtfn = val;
+        else {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3019 Enabling %d virtual functions is not "
+                                "allowed.\n", val);
+                return -EINVAL;
+        }
+
+        rc = lpfc_sli_probe_sriov_nr_virtfn(phba, phba->cfg_sriov_nr_virtfn);
+        if (rc) {
+                phba->cfg_sriov_nr_virtfn = 0;
+                rc = -EPERM;
+        } else
+                rc = strlen(buf);
+
+        return rc;
+}
+
+static int lpfc_sriov_nr_virtfn = LPFC_DEF_VFN_PER_PFN;
+module_param(lpfc_sriov_nr_virtfn, int, S_IRUGO|S_IWUSR);
+MODULE_PARM_DESC(lpfc_sriov_nr_virtfn, "Enable PCIe device SR-IOV virtual fn");
+lpfc_param_show(sriov_nr_virtfn)
+
+/**
+ * lpfc_sriov_nr_virtfn_init - Set the initial sr-iov virtual function enable
+ * @phba: lpfc_hba pointer.
+ * @val: link speed value.
+ *
+ * Description:
+ * If val is in a valid range [0,255], then set the adapter's initial
+ * cfg_sriov_nr_virtfn field. If it's greater than the maximum, the maximum
+ * number shall be used instead. It will be up to the driver's probe_one
+ * routine to determine whether the device's SR-IOV is supported or not.
+ *
+ * Returns:
+ * zero if val saved.
+ * -EINVAL val out of range
+ **/
+static int
+lpfc_sriov_nr_virtfn_init(struct lpfc_hba *phba, int val)
+{
+        if (val >= 0 && val <= LPFC_MAX_VFN_PER_PFN) {
+                phba->cfg_sriov_nr_virtfn = val;
+                return 0;
+        }
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "3017 Enabling %d virtual functions is not "
+                        "allowed.\n", val);
+        return -EINVAL;
+}
+static DEVICE_ATTR(lpfc_sriov_nr_virtfn, S_IRUGO | S_IWUSR,
+                   lpfc_sriov_nr_virtfn_show, lpfc_sriov_nr_virtfn_store);
+
 /*
 # lpfc_fcp_class:  Determines FC class to use for the FCP protocol.
 # Value range is [2,3]. Default value is 3.
@@ -3497,6 +3798,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_sriov_nr_virtfn,
         &dev_attr_lpfc_suppress_link_up,
         &dev_attr_lpfc_iocb_cnt,
         &dev_attr_iocb_hw,
@@ -3505,6 +3807,7 @@ struct device_attribute *lpfc_hba_attrs[] = {
         &dev_attr_lpfc_fips_level,
         &dev_attr_lpfc_fips_rev,
         &dev_attr_lpfc_dss,
+        &dev_attr_lpfc_sriov_hw_max_virtfn,
         NULL,
 };
 
@@ -3961,7 +4264,7 @@ static struct bin_attribute sysfs_mbox_attr = {
                 .name = "mbox",
                 .mode = S_IRUSR | S_IWUSR,
         },
-        .size = MAILBOX_CMD_SIZE,
+        .size = MAILBOX_SYSFS_MAX,
         .read = sysfs_mbox_read,
         .write = sysfs_mbox_write,
 };
@@ -4705,6 +5008,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_sriov_nr_virtfn_init(phba, lpfc_sriov_nr_virtfn);
         lpfc_suppress_link_up_init(phba, lpfc_suppress_link_up);
         lpfc_iocb_cnt_init(phba, lpfc_iocb_cnt);
         phba->cfg_enable_dss = 1;
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 853e5042f39c..7fb0ba4cbfa7 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -23,6 +23,7 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
+#include <linux/list.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
@@ -79,8 +80,7 @@ struct lpfc_bsg_iocb {
 struct lpfc_bsg_mbox {
         LPFC_MBOXQ_t *pmboxq;
         MAILBOX_t *mb;
-        struct lpfc_dmabuf *rxbmp; /* for BIU diags */
-        struct lpfc_dmabufext *dmp; /* for BIU diags */
+        struct lpfc_dmabuf *dmabuffers; /* for BIU diags */
         uint8_t *ext; /* extended mailbox data */
         uint32_t mbOffset; /* from app */
         uint32_t inExtWLen; /* from app */
@@ -332,6 +332,8 @@ lpfc_bsg_send_mgmt_cmd(struct fc_bsg_job *job)
         cmd->ulpLe = 1;
         cmd->ulpClass = CLASS3;
         cmd->ulpContext = ndlp->nlp_rpi;
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                cmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
         cmd->ulpOwner = OWN_CHIP;
         cmdiocbq->vport = phba->pport;
         cmdiocbq->context3 = bmp;
@@ -1336,6 +1338,10 @@ lpfc_issue_ct_rsp(struct lpfc_hba *phba, struct fc_bsg_job *job, uint32_t tag,
                 }
 
                 icmd->un.ulpWord[3] = ndlp->nlp_rpi;
+                if (phba->sli_rev == LPFC_SLI_REV4)
+                        icmd->ulpContext =
+                                phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
+
                 /* The exchange is done, mark the entry as invalid */
                 phba->ct_ctx[tag].flags &= ~UNSOL_VALID;
         } else
@@ -1463,11 +1469,91 @@ send_mgmt_rsp_exit:
 }
 
 /**
- * lpfc_bsg_diag_mode - process a LPFC_BSG_VENDOR_DIAG_MODE bsg vendor command
+ * lpfc_bsg_diag_mode_enter - process preparing into device diag loopback mode
+ * @phba: Pointer to HBA context object.
  * @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.
+ * This function is responsible for preparing driver for diag loopback
+ * on device.
+ */
+static int
+lpfc_bsg_diag_mode_enter(struct lpfc_hba *phba, struct fc_bsg_job *job)
+{
+        struct lpfc_vport **vports;
+        struct Scsi_Host *shost;
+        struct lpfc_sli *psli;
+        struct lpfc_sli_ring *pring;
+        int i = 0;
+
+        psli = &phba->sli;
+        if (!psli)
+                return -ENODEV;
+
+        pring = &psli->ring[LPFC_FCP_RING];
+        if (!pring)
+                return -ENODEV;
+
+        if ((phba->link_state == LPFC_HBA_ERROR) ||
+            (psli->sli_flag & LPFC_BLOCK_MGMT_IO) ||
+            (!(psli->sli_flag & LPFC_SLI_ACTIVE)))
+                return -EACCES;
+
+        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);
+        }
+        return 0;
+}
+
+/**
+ * lpfc_bsg_diag_mode_exit - exit process from device diag loopback mode
+ * @phba: Pointer to HBA context object.
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE
+ *
+ * This function is responsible for driver exit processing of setting up
+ * diag loopback mode on device.
+ */
+static void
+lpfc_bsg_diag_mode_exit(struct lpfc_hba *phba)
+{
+        struct Scsi_Host *shost;
+        struct lpfc_vport **vports;
+        int i;
+
+        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);
+        }
+        return;
+}
+
+/**
+ * lpfc_sli3_bsg_diag_loopback_mode - process an sli3 bsg vendor command
+ * @phba: Pointer to HBA context object.
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE
+ *
+ * This function is responsible for placing an sli3  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
@@ -1475,17 +1561,11 @@ send_mgmt_rsp_exit:
  * All of this is done in-line.
  */
 static int
-lpfc_bsg_diag_mode(struct fc_bsg_job *job)
+lpfc_sli3_bsg_diag_loopback_mode(struct lpfc_hba *phba, 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;
@@ -1494,53 +1574,33 @@ lpfc_bsg_diag_mode(struct fc_bsg_job *job)
         /* 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)) {
+        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");
+                                "2738 Received DIAG MODE request size:%d "
+                                "below the minimum size:%d\n",
+                                job->request_len,
+                                (int)(sizeof(struct fc_bsg_request) +
+                                sizeof(struct diag_mode_set)));
                 rc = -EINVAL;
                 goto job_error;
         }
 
+        rc = lpfc_bsg_diag_mode_enter(phba, job);
+        if (rc)
+                goto job_error;
+
+        /* bring the link to diagnostic mode */
         loopback_mode = (struct diag_mode_set *)
                 job->request->rqst_data.h_vendor.vendor_cmd;
         link_flags = loopback_mode->type;
         timeout = loopback_mode->timeout * 100;
 
-        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);
+                goto loopback_mode_exit;
         }
-
-        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;
@@ -1594,22 +1654,186 @@ lpfc_bsg_diag_mode(struct fc_bsg_job *job)
                 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_bsg_diag_mode_exit(phba);
+
+        /*
+         * 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;
+}
+
+/**
+ * lpfc_sli4_bsg_set_link_diag_state - set sli4 link diag state
+ * @phba: Pointer to HBA context object.
+ * @diag: Flag for set link to diag or nomral operation state.
+ *
+ * This function is responsible for issuing a sli4 mailbox command for setting
+ * link to either diag state or normal operation state.
+ */
+static int
+lpfc_sli4_bsg_set_link_diag_state(struct lpfc_hba *phba, uint32_t diag)
+{
+        LPFC_MBOXQ_t *pmboxq;
+        struct lpfc_mbx_set_link_diag_state *link_diag_state;
+        uint32_t req_len, alloc_len;
+        int mbxstatus = MBX_SUCCESS, rc;
+
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq)
+                return -ENOMEM;
+
+        req_len = (sizeof(struct lpfc_mbx_set_link_diag_state) -
+                   sizeof(struct lpfc_sli4_cfg_mhdr));
+        alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
+                                LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
+                                req_len, LPFC_SLI4_MBX_EMBED);
+        if (alloc_len != req_len) {
+                rc = -ENOMEM;
+                goto link_diag_state_set_out;
+        }
+        link_diag_state = &pmboxq->u.mqe.un.link_diag_state;
+        bf_set(lpfc_mbx_set_diag_state_link_num, &link_diag_state->u.req,
+               phba->sli4_hba.link_state.number);
+        bf_set(lpfc_mbx_set_diag_state_link_type, &link_diag_state->u.req,
+               phba->sli4_hba.link_state.type);
+        if (diag)
+                bf_set(lpfc_mbx_set_diag_state_diag,
+                       &link_diag_state->u.req, 1);
+        else
+                bf_set(lpfc_mbx_set_diag_state_diag,
+                       &link_diag_state->u.req, 0);
+
+        mbxstatus = lpfc_sli_issue_mbox_wait(phba, pmboxq, LPFC_MBOX_TMO);
+
+        if ((mbxstatus == MBX_SUCCESS) && (pmboxq->u.mb.mbxStatus == 0))
+                rc = 0;
+        else
+                rc = -ENODEV;
+
+link_diag_state_set_out:
+        if (pmboxq && (mbxstatus != MBX_TIMEOUT))
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+
+        return rc;
+}
+
+/**
+ * lpfc_sli4_bsg_diag_loopback_mode - process an sli4 bsg vendor command
+ * @phba: Pointer to HBA context object.
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE
+ *
+ * This function is responsible for placing an sli4 port into diagnostic
+ * loopback mode in order to perform a diagnostic loopback test.
+ */
+static int
+lpfc_sli4_bsg_diag_loopback_mode(struct lpfc_hba *phba, struct fc_bsg_job *job)
+{
+        struct diag_mode_set *loopback_mode;
+        uint32_t link_flags, timeout, req_len, alloc_len;
+        struct lpfc_mbx_set_link_diag_loopback *link_diag_loopback;
+        LPFC_MBOXQ_t *pmboxq = NULL;
+        int mbxstatus, i, 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,
+                                "3011 Received DIAG MODE request size:%d "
+                                "below the minimum size:%d\n",
+                                job->request_len,
+                                (int)(sizeof(struct fc_bsg_request) +
+                                sizeof(struct diag_mode_set)));
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        rc = lpfc_bsg_diag_mode_enter(phba, job);
+        if (rc)
+                goto job_error;
+
+        /* bring the link to diagnostic mode */
+        loopback_mode = (struct diag_mode_set *)
+                job->request->rqst_data.h_vendor.vendor_cmd;
+        link_flags = loopback_mode->type;
+        timeout = loopback_mode->timeout * 100;
+
+        rc = lpfc_sli4_bsg_set_link_diag_state(phba, 1);
+        if (rc)
+                goto loopback_mode_exit;
+
+        /* 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);
+        }
+        /* set up loopback mode */
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                rc = -ENOMEM;
+                goto loopback_mode_exit;
+        }
+        req_len = (sizeof(struct lpfc_mbx_set_link_diag_loopback) -
+                   sizeof(struct lpfc_sli4_cfg_mhdr));
+        alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
+                                LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_LOOPBACK,
+                                req_len, LPFC_SLI4_MBX_EMBED);
+        if (alloc_len != req_len) {
+                rc = -ENOMEM;
+                goto loopback_mode_exit;
+        }
+        link_diag_loopback = &pmboxq->u.mqe.un.link_diag_loopback;
+        bf_set(lpfc_mbx_set_diag_state_link_num,
+               &link_diag_loopback->u.req, phba->sli4_hba.link_state.number);
+        bf_set(lpfc_mbx_set_diag_state_link_type,
+               &link_diag_loopback->u.req, phba->sli4_hba.link_state.type);
+        if (link_flags == INTERNAL_LOOP_BACK)
+                bf_set(lpfc_mbx_set_diag_lpbk_type,
+                       &link_diag_loopback->u.req,
+                       LPFC_DIAG_LOOPBACK_TYPE_INTERNAL);
+        else
+                bf_set(lpfc_mbx_set_diag_lpbk_type,
+                       &link_diag_loopback->u.req,
+                       LPFC_DIAG_LOOPBACK_TYPE_EXTERNAL);
+
+        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);
                 }
-                lpfc_destroy_vport_work_array(phba, vports);
-        } else {
-                shost = lpfc_shost_from_vport(phba->pport);
-                scsi_unblock_requests(shost);
         }
 
+loopback_mode_exit:
+        lpfc_bsg_diag_mode_exit(phba);
+
         /*
          * Let SLI layer release mboxq if mbox command completed after timeout.
          */
-        if (mbxstatus != MBX_TIMEOUT)
+        if (pmboxq && (mbxstatus != MBX_TIMEOUT))
                 mempool_free(pmboxq, phba->mbox_mem_pool);
 
 job_error:
@@ -1622,6 +1846,234 @@ job_error:
 }
 
 /**
+ * lpfc_bsg_diag_loopback_mode - bsg vendor command for diag loopback mode
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE
+ *
+ * This function is responsible for responding to check and dispatch bsg diag
+ * command from the user to proper driver action routines.
+ */
+static int
+lpfc_bsg_diag_loopback_mode(struct fc_bsg_job *job)
+{
+        struct Scsi_Host *shost;
+        struct lpfc_vport *vport;
+        struct lpfc_hba *phba;
+        int rc;
+
+        shost = job->shost;
+        if (!shost)
+                return -ENODEV;
+        vport = (struct lpfc_vport *)job->shost->hostdata;
+        if (!vport)
+                return -ENODEV;
+        phba = vport->phba;
+        if (!phba)
+                return -ENODEV;
+
+        if (phba->sli_rev < LPFC_SLI_REV4)
+                rc = lpfc_sli3_bsg_diag_loopback_mode(phba, job);
+        else if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) ==
+                 LPFC_SLI_INTF_IF_TYPE_2)
+                rc = lpfc_sli4_bsg_diag_loopback_mode(phba, job);
+        else
+                rc = -ENODEV;
+
+        return rc;
+
+}
+
+/**
+ * lpfc_sli4_bsg_diag_mode_end - sli4 bsg vendor command for ending diag mode
+ * @job: LPFC_BSG_VENDOR_DIAG_MODE_END
+ *
+ * This function is responsible for responding to check and dispatch bsg diag
+ * command from the user to proper driver action routines.
+ */
+static int
+lpfc_sli4_bsg_diag_mode_end(struct fc_bsg_job *job)
+{
+        struct Scsi_Host *shost;
+        struct lpfc_vport *vport;
+        struct lpfc_hba *phba;
+        int rc;
+
+        shost = job->shost;
+        if (!shost)
+                return -ENODEV;
+        vport = (struct lpfc_vport *)job->shost->hostdata;
+        if (!vport)
+                return -ENODEV;
+        phba = vport->phba;
+        if (!phba)
+                return -ENODEV;
+
+        if (phba->sli_rev < LPFC_SLI_REV4)
+                return -ENODEV;
+        if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+            LPFC_SLI_INTF_IF_TYPE_2)
+                return -ENODEV;
+
+        rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
+
+        if (!rc)
+                rc = phba->lpfc_hba_init_link(phba, MBX_NOWAIT);
+
+        return rc;
+}
+
+/**
+ * lpfc_sli4_bsg_link_diag_test - sli4 bsg vendor command for diag link test
+ * @job: LPFC_BSG_VENDOR_DIAG_LINK_TEST
+ *
+ * This function is to perform SLI4 diag link test request from the user
+ * applicaiton.
+ */
+static int
+lpfc_sli4_bsg_link_diag_test(struct fc_bsg_job *job)
+{
+        struct Scsi_Host *shost;
+        struct lpfc_vport *vport;
+        struct lpfc_hba *phba;
+        LPFC_MBOXQ_t *pmboxq;
+        struct sli4_link_diag *link_diag_test_cmd;
+        uint32_t req_len, alloc_len;
+        uint32_t timeout;
+        struct lpfc_mbx_run_link_diag_test *run_link_diag_test;
+        union lpfc_sli4_cfg_shdr *shdr;
+        uint32_t shdr_status, shdr_add_status;
+        struct diag_status *diag_status_reply;
+        int mbxstatus, rc = 0;
+
+        shost = job->shost;
+        if (!shost) {
+                rc = -ENODEV;
+                goto job_error;
+        }
+        vport = (struct lpfc_vport *)job->shost->hostdata;
+        if (!vport) {
+                rc = -ENODEV;
+                goto job_error;
+        }
+        phba = vport->phba;
+        if (!phba) {
+                rc = -ENODEV;
+                goto job_error;
+        }
+
+        if (phba->sli_rev < LPFC_SLI_REV4) {
+                rc = -ENODEV;
+                goto job_error;
+        }
+        if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+            LPFC_SLI_INTF_IF_TYPE_2) {
+                rc = -ENODEV;
+                goto job_error;
+        }
+
+        if (job->request_len < sizeof(struct fc_bsg_request) +
+            sizeof(struct sli4_link_diag)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "3013 Received LINK DIAG TEST request "
+                                " size:%d below the minimum size:%d\n",
+                                job->request_len,
+                                (int)(sizeof(struct fc_bsg_request) +
+                                sizeof(struct sli4_link_diag)));
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        rc = lpfc_bsg_diag_mode_enter(phba, job);
+        if (rc)
+                goto job_error;
+
+        link_diag_test_cmd = (struct sli4_link_diag *)
+                         job->request->rqst_data.h_vendor.vendor_cmd;
+        timeout = link_diag_test_cmd->timeout * 100;
+
+        rc = lpfc_sli4_bsg_set_link_diag_state(phba, 1);
+
+        if (rc)
+                goto job_error;
+
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                rc = -ENOMEM;
+                goto link_diag_test_exit;
+        }
+
+        req_len = (sizeof(struct lpfc_mbx_set_link_diag_state) -
+                   sizeof(struct lpfc_sli4_cfg_mhdr));
+        alloc_len = lpfc_sli4_config(phba, pmboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
+                                     LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE,
+                                     req_len, LPFC_SLI4_MBX_EMBED);
+        if (alloc_len != req_len) {
+                rc = -ENOMEM;
+                goto link_diag_test_exit;
+        }
+        run_link_diag_test = &pmboxq->u.mqe.un.link_diag_test;
+        bf_set(lpfc_mbx_run_diag_test_link_num, &run_link_diag_test->u.req,
+               phba->sli4_hba.link_state.number);
+        bf_set(lpfc_mbx_run_diag_test_link_type, &run_link_diag_test->u.req,
+               phba->sli4_hba.link_state.type);
+        bf_set(lpfc_mbx_run_diag_test_test_id, &run_link_diag_test->u.req,
+               link_diag_test_cmd->test_id);
+        bf_set(lpfc_mbx_run_diag_test_loops, &run_link_diag_test->u.req,
+               link_diag_test_cmd->loops);
+        bf_set(lpfc_mbx_run_diag_test_test_ver, &run_link_diag_test->u.req,
+               link_diag_test_cmd->test_version);
+        bf_set(lpfc_mbx_run_diag_test_err_act, &run_link_diag_test->u.req,
+               link_diag_test_cmd->error_action);
+
+        mbxstatus = lpfc_sli_issue_mbox(phba, pmboxq, MBX_POLL);
+
+        shdr = (union lpfc_sli4_cfg_shdr *)
+                &pmboxq->u.mqe.un.sli4_config.header.cfg_shdr;
+        shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
+        if (shdr_status || shdr_add_status || mbxstatus) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                "3010 Run link diag test mailbox failed with "
+                                "mbx_status x%x status x%x, add_status x%x\n",
+                                mbxstatus, shdr_status, shdr_add_status);
+        }
+
+        diag_status_reply = (struct diag_status *)
+                            job->reply->reply_data.vendor_reply.vendor_rsp;
+
+        if (job->reply_len <
+            sizeof(struct fc_bsg_request) + sizeof(struct diag_status)) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_LIBDFC,
+                                "3012 Received Run link diag test reply "
+                                "below minimum size (%d): reply_len:%d\n",
+                                (int)(sizeof(struct fc_bsg_request) +
+                                sizeof(struct diag_status)),
+                                job->reply_len);
+                rc = -EINVAL;
+                goto job_error;
+        }
+
+        diag_status_reply->mbox_status = mbxstatus;
+        diag_status_reply->shdr_status = shdr_status;
+        diag_status_reply->shdr_add_status = shdr_add_status;
+
+link_diag_test_exit:
+        rc = lpfc_sli4_bsg_set_link_diag_state(phba, 0);
+
+        if (pmboxq)
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+
+        lpfc_bsg_diag_mode_exit(phba);
+
+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
@@ -1851,6 +2303,86 @@ err_get_xri_exit:
 }
 
 /**
+ * lpfc_bsg_dma_page_alloc - allocate a bsg mbox page sized dma buffers
+ * @phba: Pointer to HBA context object
+ *
+ * This function allocates BSG_MBOX_SIZE (4KB) page size dma buffer and.
+ * retruns the pointer to the buffer.
+ **/
+static struct lpfc_dmabuf *
+lpfc_bsg_dma_page_alloc(struct lpfc_hba *phba)
+{
+        struct lpfc_dmabuf *dmabuf;
+        struct pci_dev *pcidev = phba->pcidev;
+
+        /* allocate dma buffer struct */
+        dmabuf = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
+        if (!dmabuf)
+                return NULL;
+
+        INIT_LIST_HEAD(&dmabuf->list);
+
+        /* now, allocate dma buffer */
+        dmabuf->virt = dma_alloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
+                                          &(dmabuf->phys), GFP_KERNEL);
+
+        if (!dmabuf->virt) {
+                kfree(dmabuf);
+                return NULL;
+        }
+        memset((uint8_t *)dmabuf->virt, 0, BSG_MBOX_SIZE);
+
+        return dmabuf;
+}
+
+/**
+ * lpfc_bsg_dma_page_free - free a bsg mbox page sized dma buffer
+ * @phba: Pointer to HBA context object.
+ * @dmabuf: Pointer to the bsg mbox page sized dma buffer descriptor.
+ *
+ * This routine just simply frees a dma buffer and its associated buffer
+ * descriptor referred by @dmabuf.
+ **/
+static void
+lpfc_bsg_dma_page_free(struct lpfc_hba *phba, struct lpfc_dmabuf *dmabuf)
+{
+        struct pci_dev *pcidev = phba->pcidev;
+
+        if (!dmabuf)
+                return;
+
+        if (dmabuf->virt)
+                dma_free_coherent(&pcidev->dev, BSG_MBOX_SIZE,
+                                  dmabuf->virt, dmabuf->phys);
+        kfree(dmabuf);
+        return;
+}
+
+/**
+ * lpfc_bsg_dma_page_list_free - free a list of bsg mbox page sized dma buffers
+ * @phba: Pointer to HBA context object.
+ * @dmabuf_list: Pointer to a list of bsg mbox page sized dma buffer descs.
+ *
+ * This routine just simply frees all dma buffers and their associated buffer
+ * descriptors referred by @dmabuf_list.
+ **/
+static void
+lpfc_bsg_dma_page_list_free(struct lpfc_hba *phba,
+                            struct list_head *dmabuf_list)
+{
+        struct lpfc_dmabuf *dmabuf, *next_dmabuf;
+
+        if (list_empty(dmabuf_list))
+                return;
+
+        list_for_each_entry_safe(dmabuf, next_dmabuf, dmabuf_list, list) {
+                list_del_init(&dmabuf->list);
+                lpfc_bsg_dma_page_free(phba, dmabuf);
+        }
+        return;
+}
+
+/**
  * 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
@@ -2067,7 +2599,7 @@ err_post_rxbufs_exit:
 }
 
 /**
- * lpfc_bsg_diag_test - with a port in loopback issues a Ct cmd to itself
+ * lpfc_bsg_diag_loopback_run - run loopback on a port by issue 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
@@ -2086,7 +2618,7 @@ err_post_rxbufs_exit:
  * of loopback mode.
  **/
 static int
-lpfc_bsg_diag_test(struct fc_bsg_job *job)
+lpfc_bsg_diag_loopback_run(struct fc_bsg_job *job)
 {
         struct lpfc_vport *vport = (struct lpfc_vport *)job->shost->hostdata;
         struct lpfc_hba *phba = vport->phba;
@@ -2411,7 +2943,7 @@ job_error:
 }
 
 /**
- * lpfc_bsg_wake_mbox_wait - lpfc_bsg_issue_mbox mbox completion handler
+ * lpfc_bsg_issue_mbox_cmpl - lpfc_bsg_issue_mbox mbox completion handler
  * @phba: Pointer to HBA context object.
  * @pmboxq: Pointer to mailbox command.
  *
@@ -2422,15 +2954,13 @@ job_error:
  * of the mailbox.
  **/
 void
-lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
+lpfc_bsg_issue_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
 {
         struct bsg_job_data *dd_data;
         struct fc_bsg_job *job;
-        struct lpfc_mbx_nembed_cmd *nembed_sge;
         uint32_t size;
         unsigned long flags;
-        uint8_t *to;
-        uint8_t *from;
+        uint8_t *pmb, *pmb_buf;
 
         spin_lock_irqsave(&phba->ct_ev_lock, flags);
         dd_data = pmboxq->context1;
@@ -2440,62 +2970,21 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                 return;
         }
 
-        /* build the outgoing buffer to do an sg copy
-         * the format is the response mailbox followed by any extended
-         * mailbox data
+        /*
+         * The outgoing buffer is readily referred from the dma buffer,
+         * just need to get header part from mailboxq structure.
          */
-        from = (uint8_t *)&pmboxq->u.mb;
-        to = (uint8_t *)dd_data->context_un.mbox.mb;
-        memcpy(to, from, sizeof(MAILBOX_t));
-        if (pmboxq->u.mb.mbxStatus == MBX_SUCCESS) {
-                /* copy the extended data if any, count is in words */
-                if (dd_data->context_un.mbox.outExtWLen) {
-                        from = (uint8_t *)dd_data->context_un.mbox.ext;
-                        to += sizeof(MAILBOX_t);
-                        size = dd_data->context_un.mbox.outExtWLen *
-                                        sizeof(uint32_t);
-                        memcpy(to, from, size);
-                } else if (pmboxq->u.mb.mbxCommand == MBX_RUN_BIU_DIAG64) {
-                        from = (uint8_t *)dd_data->context_un.mbox.
-                                                dmp->dma.virt;
-                        to += sizeof(MAILBOX_t);
-                        size = dd_data->context_un.mbox.dmp->size;
-                        memcpy(to, from, size);
-                } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
-                        (pmboxq->u.mb.mbxCommand == MBX_DUMP_MEMORY)) {
-                        from = (uint8_t *)dd_data->context_un.mbox.dmp->dma.
-                                                virt;
-                        to += sizeof(MAILBOX_t);
-                        size = pmboxq->u.mb.un.varWords[5];
-                        memcpy(to, from, size);
-                } else if ((phba->sli_rev == LPFC_SLI_REV4) &&
-                        (pmboxq->u.mb.mbxCommand == MBX_SLI4_CONFIG)) {
-                        nembed_sge = (struct lpfc_mbx_nembed_cmd *)
-                                        &pmboxq->u.mb.un.varWords[0];
-
-                        from = (uint8_t *)dd_data->context_un.mbox.dmp->dma.
-                                                virt;
-                        to += sizeof(MAILBOX_t);
-                        size = nembed_sge->sge[0].length;
-                        memcpy(to, from, size);
-                } else if (pmboxq->u.mb.mbxCommand == MBX_READ_EVENT_LOG) {
-                        from = (uint8_t *)dd_data->context_un.
-                                                mbox.dmp->dma.virt;
-                        to += sizeof(MAILBOX_t);
-                        size = dd_data->context_un.mbox.dmp->size;
-                        memcpy(to, from, size);
-                }
-        }
+        pmb = (uint8_t *)&pmboxq->u.mb;
+        pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
+        memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
 
-        from = (uint8_t *)dd_data->context_un.mbox.mb;
         job = dd_data->context_un.mbox.set_job;
         if (job) {
                 size = job->reply_payload.payload_len;
                 job->reply->reply_payload_rcv_len =
                         sg_copy_from_buffer(job->reply_payload.sg_list,
-                                        job->reply_payload.sg_cnt,
-                                        from, size);
-                job->reply->result = 0;
+                                            job->reply_payload.sg_cnt,
+                                            pmb_buf, size);
                 /* need to hold the lock until we set job->dd_data to NULL
                  * to hold off the timeout handler returning to the mid-layer
                  * while we are still processing the job.
@@ -2503,28 +2992,19 @@ lpfc_bsg_wake_mbox_wait(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
                 job->dd_data = NULL;
                 dd_data->context_un.mbox.set_job = NULL;
                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
-                job->job_done(job);
         } else {
                 dd_data->context_un.mbox.set_job = NULL;
                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
         }
 
-        kfree(dd_data->context_un.mbox.mb);
         mempool_free(dd_data->context_un.mbox.pmboxq, phba->mbox_mem_pool);
-        kfree(dd_data->context_un.mbox.ext);
-        if (dd_data->context_un.mbox.dmp) {
-                dma_free_coherent(&phba->pcidev->dev,
-                        dd_data->context_un.mbox.dmp->size,
-                        dd_data->context_un.mbox.dmp->dma.virt,
-                        dd_data->context_un.mbox.dmp->dma.phys);
-                kfree(dd_data->context_un.mbox.dmp);
-        }
-        if (dd_data->context_un.mbox.rxbmp) {
-                lpfc_mbuf_free(phba, dd_data->context_un.mbox.rxbmp->virt,
-                        dd_data->context_un.mbox.rxbmp->phys);
-                kfree(dd_data->context_un.mbox.rxbmp);
-        }
+        lpfc_bsg_dma_page_free(phba, dd_data->context_un.mbox.dmabuffers);
         kfree(dd_data);
+
+        if (job) {
+                job->reply->result = 0;
+                job->job_done(job);
+        }
         return;
 }
 
@@ -2619,6 +3099,1006 @@ static int lpfc_bsg_check_cmd_access(struct lpfc_hba *phba,
 }
 
 /**
+ * lpfc_bsg_mbox_ext_cleanup - clean up context of multi-buffer mbox session
+ * @phba: Pointer to HBA context object.
+ *
+ * This is routine clean up and reset BSG handling of multi-buffer mbox
+ * command session.
+ **/
+static void
+lpfc_bsg_mbox_ext_session_reset(struct lpfc_hba *phba)
+{
+        if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE)
+                return;
+
+        /* free all memory, including dma buffers */
+        lpfc_bsg_dma_page_list_free(phba,
+                                    &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
+        lpfc_bsg_dma_page_free(phba, phba->mbox_ext_buf_ctx.mbx_dmabuf);
+        /* multi-buffer write mailbox command pass-through complete */
+        memset((char *)&phba->mbox_ext_buf_ctx, 0,
+               sizeof(struct lpfc_mbox_ext_buf_ctx));
+        INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
+
+        return;
+}
+
+/**
+ * lpfc_bsg_issue_mbox_ext_handle_job - job handler for multi-buffer mbox cmpl
+ * @phba: Pointer to HBA context object.
+ * @pmboxq: Pointer to mailbox command.
+ *
+ * This is routine handles BSG job for mailbox commands completions with
+ * multiple external buffers.
+ **/
+static struct fc_bsg_job *
+lpfc_bsg_issue_mbox_ext_handle_job(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
+{
+        struct bsg_job_data *dd_data;
+        struct fc_bsg_job *job;
+        uint8_t *pmb, *pmb_buf;
+        unsigned long flags;
+        uint32_t size;
+        int rc = 0;
+
+        spin_lock_irqsave(&phba->ct_ev_lock, flags);
+        dd_data = pmboxq->context1;
+        /* has the job already timed out? */
+        if (!dd_data) {
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                job = NULL;
+                goto job_done_out;
+        }
+
+        /*
+         * The outgoing buffer is readily referred from the dma buffer,
+         * just need to get header part from mailboxq structure.
+         */
+        pmb = (uint8_t *)&pmboxq->u.mb;
+        pmb_buf = (uint8_t *)dd_data->context_un.mbox.mb;
+        memcpy(pmb_buf, pmb, sizeof(MAILBOX_t));
+
+        job = dd_data->context_un.mbox.set_job;
+        if (job) {
+                size = job->reply_payload.payload_len;
+                job->reply->reply_payload_rcv_len =
+                        sg_copy_from_buffer(job->reply_payload.sg_list,
+                                            job->reply_payload.sg_cnt,
+                                            pmb_buf, size);
+                /* result for successful */
+                job->reply->result = 0;
+                job->dd_data = NULL;
+                /* need to hold the lock util we set job->dd_data to NULL
+                 * to hold off the timeout handler from midlayer to take
+                 * any action.
+                 */
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2937 SLI_CONFIG ext-buffer maibox command "
+                                "(x%x/x%x) complete bsg job done, bsize:%d\n",
+                                phba->mbox_ext_buf_ctx.nembType,
+                                phba->mbox_ext_buf_ctx.mboxType, size);
+        } else
+                spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
+
+job_done_out:
+        if (!job)
+                lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                "2938 SLI_CONFIG ext-buffer maibox "
+                                "command (x%x/x%x) failure, rc:x%x\n",
+                                phba->mbox_ext_buf_ctx.nembType,
+                                phba->mbox_ext_buf_ctx.mboxType, rc);
+        /* state change */
+        phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_DONE;
+        kfree(dd_data);
+
+        return job;
+}
+
+/**
+ * lpfc_bsg_issue_read_mbox_ext_cmpl - compl handler for multi-buffer read mbox
+ * @phba: Pointer to HBA context object.
+ * @pmboxq: Pointer to mailbox command.
+ *
+ * This is completion handler function for mailbox read commands with multiple
+ * external buffers.
+ **/
+static void
+lpfc_bsg_issue_read_mbox_ext_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
+{
+        struct fc_bsg_job *job;
+
+        /* handle the BSG job with mailbox command */
+        if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_ABTS)
+                pmboxq->u.mb.mbxStatus = MBXERR_ERROR;
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                        "2939 SLI_CONFIG ext-buffer rd maibox command "
+                        "complete, ctxState:x%x, mbxStatus:x%x\n",
+                        phba->mbox_ext_buf_ctx.state, pmboxq->u.mb.mbxStatus);
+
+        job = lpfc_bsg_issue_mbox_ext_handle_job(phba, pmboxq);
+
+        if (pmboxq->u.mb.mbxStatus || phba->mbox_ext_buf_ctx.numBuf == 1)
+                lpfc_bsg_mbox_ext_session_reset(phba);
+
+        /* free base driver mailbox structure memory */
+        mempool_free(pmboxq, phba->mbox_mem_pool);
+
+        /* complete the bsg job if we have it */
+        if (job)
+                job->job_done(job);
+
+        return;
+}
+
+/**
+ * lpfc_bsg_issue_write_mbox_ext_cmpl - cmpl handler for multi-buffer write mbox
+ * @phba: Pointer to HBA context object.
+ * @pmboxq: Pointer to mailbox command.
+ *
+ * This is completion handler function for mailbox write commands with multiple
+ * external buffers.
+ **/
+static void
+lpfc_bsg_issue_write_mbox_ext_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
+{
+        struct fc_bsg_job *job;
+
+        /* handle the BSG job with the mailbox command */
+        if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_ABTS)
+                pmboxq->u.mb.mbxStatus = MBXERR_ERROR;
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                        "2940 SLI_CONFIG ext-buffer wr maibox command "
+                        "complete, ctxState:x%x, mbxStatus:x%x\n",
+                        phba->mbox_ext_buf_ctx.state, pmboxq->u.mb.mbxStatus);
+
+        job = lpfc_bsg_issue_mbox_ext_handle_job(phba, pmboxq);
+
+        /* free all memory, including dma buffers */
+        mempool_free(pmboxq, phba->mbox_mem_pool);
+        lpfc_bsg_mbox_ext_session_reset(phba);
+
+        /* complete the bsg job if we have it */
+        if (job)
+                job->job_done(job);
+
+        return;
+}
+
+static void
+lpfc_bsg_sli_cfg_dma_desc_setup(struct lpfc_hba *phba, enum nemb_type nemb_tp,
+                                uint32_t index, struct lpfc_dmabuf *mbx_dmabuf,
+                                struct lpfc_dmabuf *ext_dmabuf)
+{
+        struct lpfc_sli_config_mbox *sli_cfg_mbx;
+
+        /* pointer to the start of mailbox command */
+        sli_cfg_mbx = (struct lpfc_sli_config_mbox *)mbx_dmabuf->virt;
+
+        if (nemb_tp == nemb_mse) {
+                if (index == 0) {
+                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                mse[index].pa_hi =
+                                putPaddrHigh(mbx_dmabuf->phys +
+                                             sizeof(MAILBOX_t));
+                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                mse[index].pa_lo =
+                                putPaddrLow(mbx_dmabuf->phys +
+                                            sizeof(MAILBOX_t));
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2943 SLI_CONFIG(mse)[%d], "
+                                        "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
+                                        index,
+                                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                        mse[index].buf_len,
+                                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                        mse[index].pa_hi,
+                                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                        mse[index].pa_lo);
+                } else {
+                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                mse[index].pa_hi =
+                                putPaddrHigh(ext_dmabuf->phys);
+                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                mse[index].pa_lo =
+                                putPaddrLow(ext_dmabuf->phys);
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2944 SLI_CONFIG(mse)[%d], "
+                                        "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
+                                        index,
+                                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                        mse[index].buf_len,
+                                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                        mse[index].pa_hi,
+                                        sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                        mse[index].pa_lo);
+                }
+        } else {
+                if (index == 0) {
+                        sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_hi =
+                                putPaddrHigh(mbx_dmabuf->phys +
+                                             sizeof(MAILBOX_t));
+                        sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_lo =
+                                putPaddrLow(mbx_dmabuf->phys +
+                                            sizeof(MAILBOX_t));
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "3007 SLI_CONFIG(hbd)[%d], "
+                                        "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
+                                index,
+                                bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
+                                &sli_cfg_mbx->un.
+                                sli_config_emb1_subsys.hbd[index]),
+                                sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_hi,
+                                sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_lo);
+
+                } else {
+                        sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_hi =
+                                putPaddrHigh(ext_dmabuf->phys);
+                        sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_lo =
+                                putPaddrLow(ext_dmabuf->phys);
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "3008 SLI_CONFIG(hbd)[%d], "
+                                        "bufLen:%d, addrHi:x%x, addrLo:x%x\n",
+                                index,
+                                bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
+                                &sli_cfg_mbx->un.
+                                sli_config_emb1_subsys.hbd[index]),
+                                sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_hi,
+                                sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[index].pa_lo);
+                }
+        }
+        return;
+}
+
+/**
+ * lpfc_bsg_sli_cfg_mse_read_cmd_ext - sli_config non-embedded mailbox cmd read
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a BSG mailbox object.
+ * @nemb_tp: Enumerate of non-embedded mailbox command type.
+ * @dmabuff: Pointer to a DMA buffer descriptor.
+ *
+ * This routine performs SLI_CONFIG (0x9B) read mailbox command operation with
+ * non-embedded external bufffers.
+ **/
+static int
+lpfc_bsg_sli_cfg_read_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
+                              enum nemb_type nemb_tp,
+                              struct lpfc_dmabuf *dmabuf)
+{
+        struct lpfc_sli_config_mbox *sli_cfg_mbx;
+        struct dfc_mbox_req *mbox_req;
+        struct lpfc_dmabuf *curr_dmabuf, *next_dmabuf;
+        uint32_t ext_buf_cnt, ext_buf_index;
+        struct lpfc_dmabuf *ext_dmabuf = NULL;
+        struct bsg_job_data *dd_data = NULL;
+        LPFC_MBOXQ_t *pmboxq = NULL;
+        MAILBOX_t *pmb;
+        uint8_t *pmbx;
+        int rc, i;
+
+        mbox_req =
+           (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
+
+        /* pointer to the start of mailbox command */
+        sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
+
+        if (nemb_tp == nemb_mse) {
+                ext_buf_cnt = bsg_bf_get(lpfc_mbox_hdr_mse_cnt,
+                        &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
+                if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                        "2945 Handled SLI_CONFIG(mse) rd, "
+                                        "ext_buf_cnt(%d) out of range(%d)\n",
+                                        ext_buf_cnt,
+                                        LPFC_MBX_SLI_CONFIG_MAX_MSE);
+                        rc = -ERANGE;
+                        goto job_error;
+                }
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2941 Handled SLI_CONFIG(mse) rd, "
+                                "ext_buf_cnt:%d\n", ext_buf_cnt);
+        } else {
+                /* sanity check on interface type for support */
+                if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+                    LPFC_SLI_INTF_IF_TYPE_2) {
+                        rc = -ENODEV;
+                        goto job_error;
+                }
+                /* nemb_tp == nemb_hbd */
+                ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
+                if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                        "2946 Handled SLI_CONFIG(hbd) rd, "
+                                        "ext_buf_cnt(%d) out of range(%d)\n",
+                                        ext_buf_cnt,
+                                        LPFC_MBX_SLI_CONFIG_MAX_HBD);
+                        rc = -ERANGE;
+                        goto job_error;
+                }
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2942 Handled SLI_CONFIG(hbd) rd, "
+                                "ext_buf_cnt:%d\n", ext_buf_cnt);
+        }
+
+        /* reject non-embedded mailbox command with none external buffer */
+        if (ext_buf_cnt == 0) {
+                rc = -EPERM;
+                goto job_error;
+        } else if (ext_buf_cnt > 1) {
+                /* additional external read buffers */
+                for (i = 1; i < ext_buf_cnt; i++) {
+                        ext_dmabuf = lpfc_bsg_dma_page_alloc(phba);
+                        if (!ext_dmabuf) {
+                                rc = -ENOMEM;
+                                goto job_error;
+                        }
+                        list_add_tail(&ext_dmabuf->list,
+                                      &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
+                }
+        }
+
+        /* bsg tracking structure */
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                rc = -ENOMEM;
+                goto job_error;
+        }
+
+        /* mailbox command structure for base driver */
+        pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!pmboxq) {
+                rc = -ENOMEM;
+                goto job_error;
+        }
+        memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+
+        /* for the first external buffer */
+        lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
+
+        /* for the rest of external buffer descriptors if any */
+        if (ext_buf_cnt > 1) {
+                ext_buf_index = 1;
+                list_for_each_entry_safe(curr_dmabuf, next_dmabuf,
+                                &phba->mbox_ext_buf_ctx.ext_dmabuf_list, list) {
+                        lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp,
+                                                ext_buf_index, dmabuf,
+                                                curr_dmabuf);
+                        ext_buf_index++;
+                }
+        }
+
+        /* construct base driver mbox command */
+        pmb = &pmboxq->u.mb;
+        pmbx = (uint8_t *)dmabuf->virt;
+        memcpy(pmb, pmbx, sizeof(*pmb));
+        pmb->mbxOwner = OWN_HOST;
+        pmboxq->vport = phba->pport;
+
+        /* multi-buffer handling context */
+        phba->mbox_ext_buf_ctx.nembType = nemb_tp;
+        phba->mbox_ext_buf_ctx.mboxType = mbox_rd;
+        phba->mbox_ext_buf_ctx.numBuf = ext_buf_cnt;
+        phba->mbox_ext_buf_ctx.mbxTag = mbox_req->extMboxTag;
+        phba->mbox_ext_buf_ctx.seqNum = mbox_req->extSeqNum;
+        phba->mbox_ext_buf_ctx.mbx_dmabuf = dmabuf;
+
+        /* callback for multi-buffer read mailbox command */
+        pmboxq->mbox_cmpl = lpfc_bsg_issue_read_mbox_ext_cmpl;
+
+        /* context fields to callback function */
+        pmboxq->context1 = dd_data;
+        dd_data->type = TYPE_MBOX;
+        dd_data->context_un.mbox.pmboxq = pmboxq;
+        dd_data->context_un.mbox.mb = (MAILBOX_t *)pmbx;
+        dd_data->context_un.mbox.set_job = job;
+        job->dd_data = dd_data;
+
+        /* state change */
+        phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
+
+        rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
+        if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2947 Issued SLI_CONFIG ext-buffer "
+                                "maibox command, rc:x%x\n", rc);
+                return 1;
+        }
+        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                        "2948 Failed to issue SLI_CONFIG ext-buffer "
+                        "maibox command, rc:x%x\n", rc);
+        rc = -EPIPE;
+
+job_error:
+        if (pmboxq)
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+        lpfc_bsg_dma_page_list_free(phba,
+                                    &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
+        kfree(dd_data);
+        phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_IDLE;
+        return rc;
+}
+
+/**
+ * lpfc_bsg_sli_cfg_write_cmd_ext - sli_config non-embedded mailbox cmd write
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a BSG mailbox object.
+ * @dmabuff: Pointer to a DMA buffer descriptor.
+ *
+ * This routine performs SLI_CONFIG (0x9B) write mailbox command operation with
+ * non-embedded external bufffers.
+ **/
+static int
+lpfc_bsg_sli_cfg_write_cmd_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
+                               enum nemb_type nemb_tp,
+                               struct lpfc_dmabuf *dmabuf)
+{
+        struct dfc_mbox_req *mbox_req;
+        struct lpfc_sli_config_mbox *sli_cfg_mbx;
+        uint32_t ext_buf_cnt;
+        struct bsg_job_data *dd_data = NULL;
+        LPFC_MBOXQ_t *pmboxq = NULL;
+        MAILBOX_t *pmb;
+        uint8_t *mbx;
+        int rc = 0, i;
+
+        mbox_req =
+           (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
+
+        /* pointer to the start of mailbox command */
+        sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
+
+        if (nemb_tp == nemb_mse) {
+                ext_buf_cnt = bsg_bf_get(lpfc_mbox_hdr_mse_cnt,
+                        &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr);
+                if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_MSE) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                        "2953 Handled SLI_CONFIG(mse) wr, "
+                                        "ext_buf_cnt(%d) out of range(%d)\n",
+                                        ext_buf_cnt,
+                                        LPFC_MBX_SLI_CONFIG_MAX_MSE);
+                        return -ERANGE;
+                }
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2949 Handled SLI_CONFIG(mse) wr, "
+                                "ext_buf_cnt:%d\n", ext_buf_cnt);
+        } else {
+                /* sanity check on interface type for support */
+                if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+                    LPFC_SLI_INTF_IF_TYPE_2)
+                        return -ENODEV;
+                /* nemb_tp == nemb_hbd */
+                ext_buf_cnt = sli_cfg_mbx->un.sli_config_emb1_subsys.hbd_count;
+                if (ext_buf_cnt > LPFC_MBX_SLI_CONFIG_MAX_HBD) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                        "2954 Handled SLI_CONFIG(hbd) wr, "
+                                        "ext_buf_cnt(%d) out of range(%d)\n",
+                                        ext_buf_cnt,
+                                        LPFC_MBX_SLI_CONFIG_MAX_HBD);
+                        return -ERANGE;
+                }
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2950 Handled SLI_CONFIG(hbd) wr, "
+                                "ext_buf_cnt:%d\n", ext_buf_cnt);
+        }
+
+        if (ext_buf_cnt == 0)
+                return -EPERM;
+
+        /* for the first external buffer */
+        lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, 0, dmabuf, dmabuf);
+
+        /* log for looking forward */
+        for (i = 1; i < ext_buf_cnt; i++) {
+                if (nemb_tp == nemb_mse)
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2951 SLI_CONFIG(mse), buf[%d]-length:%d\n",
+                                i, sli_cfg_mbx->un.sli_config_emb0_subsys.
+                                mse[i].buf_len);
+                else
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2952 SLI_CONFIG(hbd), buf[%d]-length:%d\n",
+                                i, bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
+                                &sli_cfg_mbx->un.sli_config_emb1_subsys.
+                                hbd[i]));
+        }
+
+        /* multi-buffer handling context */
+        phba->mbox_ext_buf_ctx.nembType = nemb_tp;
+        phba->mbox_ext_buf_ctx.mboxType = mbox_wr;
+        phba->mbox_ext_buf_ctx.numBuf = ext_buf_cnt;
+        phba->mbox_ext_buf_ctx.mbxTag = mbox_req->extMboxTag;
+        phba->mbox_ext_buf_ctx.seqNum = mbox_req->extSeqNum;
+        phba->mbox_ext_buf_ctx.mbx_dmabuf = dmabuf;
+
+        if (ext_buf_cnt == 1) {
+                /* bsg tracking structure */
+                dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+                if (!dd_data) {
+                        rc = -ENOMEM;
+                        goto job_error;
+                }
+
+                /* mailbox command structure for base driver */
+                pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+                if (!pmboxq) {
+                        rc = -ENOMEM;
+                        goto job_error;
+                }
+                memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+                pmb = &pmboxq->u.mb;
+                mbx = (uint8_t *)dmabuf->virt;
+                memcpy(pmb, mbx, sizeof(*pmb));
+                pmb->mbxOwner = OWN_HOST;
+                pmboxq->vport = phba->pport;
+
+                /* callback for multi-buffer read mailbox command */
+                pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
+
+                /* context fields to callback function */
+                pmboxq->context1 = dd_data;
+                dd_data->type = TYPE_MBOX;
+                dd_data->context_un.mbox.pmboxq = pmboxq;
+                dd_data->context_un.mbox.mb = (MAILBOX_t *)mbx;
+                dd_data->context_un.mbox.set_job = job;
+                job->dd_data = dd_data;
+
+                /* state change */
+                phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
+
+                rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
+                if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2955 Issued SLI_CONFIG ext-buffer "
+                                        "maibox command, rc:x%x\n", rc);
+                        return 1;
+                }
+                lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                "2956 Failed to issue SLI_CONFIG ext-buffer "
+                                "maibox command, rc:x%x\n", rc);
+                rc = -EPIPE;
+        }
+
+job_error:
+        if (pmboxq)
+                mempool_free(pmboxq, phba->mbox_mem_pool);
+        kfree(dd_data);
+
+        return rc;
+}
+
+/**
+ * lpfc_bsg_handle_sli_cfg_mbox - handle sli-cfg mailbox cmd with ext buffer
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a BSG mailbox object.
+ * @dmabuff: Pointer to a DMA buffer descriptor.
+ *
+ * This routine handles SLI_CONFIG (0x9B) mailbox command with non-embedded
+ * external bufffers, including both 0x9B with non-embedded MSEs and 0x9B
+ * with embedded sussystem 0x1 and opcodes with external HBDs.
+ **/
+static int
+lpfc_bsg_handle_sli_cfg_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
+                             struct lpfc_dmabuf *dmabuf)
+{
+        struct lpfc_sli_config_mbox *sli_cfg_mbx;
+        uint32_t subsys;
+        uint32_t opcode;
+        int rc = SLI_CONFIG_NOT_HANDLED;
+
+        /* state change */
+        phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_HOST;
+
+        sli_cfg_mbx = (struct lpfc_sli_config_mbox *)dmabuf->virt;
+
+        if (!bsg_bf_get(lpfc_mbox_hdr_emb,
+            &sli_cfg_mbx->un.sli_config_emb0_subsys.sli_config_hdr)) {
+                subsys = bsg_bf_get(lpfc_emb0_subcmnd_subsys,
+                                    &sli_cfg_mbx->un.sli_config_emb0_subsys);
+                opcode = bsg_bf_get(lpfc_emb0_subcmnd_opcode,
+                                    &sli_cfg_mbx->un.sli_config_emb0_subsys);
+                if (subsys == SLI_CONFIG_SUBSYS_FCOE) {
+                        switch (opcode) {
+                        case FCOE_OPCODE_READ_FCF:
+                                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                                "2957 Handled SLI_CONFIG "
+                                                "subsys_fcoe, opcode:x%x\n",
+                                                opcode);
+                                rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
+                                                        nemb_mse, dmabuf);
+                                break;
+                        case FCOE_OPCODE_ADD_FCF:
+                                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                                "2958 Handled SLI_CONFIG "
+                                                "subsys_fcoe, opcode:x%x\n",
+                                                opcode);
+                                rc = lpfc_bsg_sli_cfg_write_cmd_ext(phba, job,
+                                                        nemb_mse, dmabuf);
+                                break;
+                        default:
+                                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                                "2959 Not handled SLI_CONFIG "
+                                                "subsys_fcoe, opcode:x%x\n",
+                                                opcode);
+                                rc = SLI_CONFIG_NOT_HANDLED;
+                                break;
+                        }
+                } else {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2977 Handled SLI_CONFIG "
+                                        "subsys:x%d, opcode:x%x\n",
+                                        subsys, opcode);
+                        rc = SLI_CONFIG_NOT_HANDLED;
+                }
+        } else {
+                subsys = bsg_bf_get(lpfc_emb1_subcmnd_subsys,
+                                    &sli_cfg_mbx->un.sli_config_emb1_subsys);
+                opcode = bsg_bf_get(lpfc_emb1_subcmnd_opcode,
+                                    &sli_cfg_mbx->un.sli_config_emb1_subsys);
+                if (subsys == SLI_CONFIG_SUBSYS_COMN) {
+                        switch (opcode) {
+                        case COMN_OPCODE_READ_OBJECT:
+                        case COMN_OPCODE_READ_OBJECT_LIST:
+                                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                                "2960 Handled SLI_CONFIG "
+                                                "subsys_comn, opcode:x%x\n",
+                                                opcode);
+                                rc = lpfc_bsg_sli_cfg_read_cmd_ext(phba, job,
+                                                        nemb_hbd, dmabuf);
+                                break;
+                        case COMN_OPCODE_WRITE_OBJECT:
+                                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                                "2961 Handled SLI_CONFIG "
+                                                "subsys_comn, opcode:x%x\n",
+                                                opcode);
+                                rc = lpfc_bsg_sli_cfg_write_cmd_ext(phba, job,
+                                                        nemb_hbd, dmabuf);
+                                break;
+                        default:
+                                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                                "2962 Not handled SLI_CONFIG "
+                                                "subsys_comn, opcode:x%x\n",
+                                                opcode);
+                                rc = SLI_CONFIG_NOT_HANDLED;
+                                break;
+                        }
+                } else {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2978 Handled SLI_CONFIG "
+                                        "subsys:x%d, opcode:x%x\n",
+                                        subsys, opcode);
+                        rc = SLI_CONFIG_NOT_HANDLED;
+                }
+        }
+        return rc;
+}
+
+/**
+ * lpfc_bsg_mbox_ext_abort_req - request to abort mbox command with ext buffers
+ * @phba: Pointer to HBA context object.
+ *
+ * This routine is for requesting to abort a pass-through mailbox command with
+ * multiple external buffers due to error condition.
+ **/
+static void
+lpfc_bsg_mbox_ext_abort(struct lpfc_hba *phba)
+{
+        if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_PORT)
+                phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_ABTS;
+        else
+                lpfc_bsg_mbox_ext_session_reset(phba);
+        return;
+}
+
+/**
+ * lpfc_bsg_read_ebuf_get - get the next mailbox read external buffer
+ * @phba: Pointer to HBA context object.
+ * @dmabuf: Pointer to a DMA buffer descriptor.
+ *
+ * This routine extracts the next mailbox read external buffer back to
+ * user space through BSG.
+ **/
+static int
+lpfc_bsg_read_ebuf_get(struct lpfc_hba *phba, struct fc_bsg_job *job)
+{
+        struct lpfc_sli_config_mbox *sli_cfg_mbx;
+        struct lpfc_dmabuf *dmabuf;
+        uint8_t *pbuf;
+        uint32_t size;
+        uint32_t index;
+
+        index = phba->mbox_ext_buf_ctx.seqNum;
+        phba->mbox_ext_buf_ctx.seqNum++;
+
+        sli_cfg_mbx = (struct lpfc_sli_config_mbox *)
+                        phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
+
+        if (phba->mbox_ext_buf_ctx.nembType == nemb_mse) {
+                size = bsg_bf_get(lpfc_mbox_sli_config_mse_len,
+                        &sli_cfg_mbx->un.sli_config_emb0_subsys.mse[index]);
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2963 SLI_CONFIG (mse) ext-buffer rd get "
+                                "buffer[%d], size:%d\n", index, size);
+        } else {
+                size = bsg_bf_get(lpfc_mbox_sli_config_ecmn_hbd_len,
+                        &sli_cfg_mbx->un.sli_config_emb1_subsys.hbd[index]);
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2964 SLI_CONFIG (hbd) ext-buffer rd get "
+                                "buffer[%d], size:%d\n", index, size);
+        }
+        if (list_empty(&phba->mbox_ext_buf_ctx.ext_dmabuf_list))
+                return -EPIPE;
+        dmabuf = list_first_entry(&phba->mbox_ext_buf_ctx.ext_dmabuf_list,
+                                  struct lpfc_dmabuf, list);
+        list_del_init(&dmabuf->list);
+        pbuf = (uint8_t *)dmabuf->virt;
+        job->reply->reply_payload_rcv_len =
+                sg_copy_from_buffer(job->reply_payload.sg_list,
+                                    job->reply_payload.sg_cnt,
+                                    pbuf, size);
+
+        lpfc_bsg_dma_page_free(phba, dmabuf);
+
+        if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2965 SLI_CONFIG (hbd) ext-buffer rd mbox "
+                                "command session done\n");
+                lpfc_bsg_mbox_ext_session_reset(phba);
+        }
+
+        job->reply->result = 0;
+        job->job_done(job);
+
+        return SLI_CONFIG_HANDLED;
+}
+
+/**
+ * lpfc_bsg_write_ebuf_set - set the next mailbox write external buffer
+ * @phba: Pointer to HBA context object.
+ * @dmabuf: Pointer to a DMA buffer descriptor.
+ *
+ * This routine sets up the next mailbox read external buffer obtained
+ * from user space through BSG.
+ **/
+static int
+lpfc_bsg_write_ebuf_set(struct lpfc_hba *phba, struct fc_bsg_job *job,
+                        struct lpfc_dmabuf *dmabuf)
+{
+        struct lpfc_sli_config_mbox *sli_cfg_mbx;
+        struct bsg_job_data *dd_data = NULL;
+        LPFC_MBOXQ_t *pmboxq = NULL;
+        MAILBOX_t *pmb;
+        enum nemb_type nemb_tp;
+        uint8_t *pbuf;
+        uint32_t size;
+        uint32_t index;
+        int rc;
+
+        index = phba->mbox_ext_buf_ctx.seqNum;
+        phba->mbox_ext_buf_ctx.seqNum++;
+        nemb_tp = phba->mbox_ext_buf_ctx.nembType;
+
+        sli_cfg_mbx = (struct lpfc_sli_config_mbox *)
+                        phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
+
+        dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
+        if (!dd_data) {
+                rc = -ENOMEM;
+                goto job_error;
+        }
+
+        pbuf = (uint8_t *)dmabuf->virt;
+        size = job->request_payload.payload_len;
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                          job->request_payload.sg_cnt,
+                          pbuf, size);
+
+        if (phba->mbox_ext_buf_ctx.nembType == nemb_mse) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2966 SLI_CONFIG (mse) ext-buffer wr set "
+                                "buffer[%d], size:%d\n",
+                                phba->mbox_ext_buf_ctx.seqNum, size);
+
+        } else {
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2967 SLI_CONFIG (hbd) ext-buffer wr set "
+                                "buffer[%d], size:%d\n",
+                                phba->mbox_ext_buf_ctx.seqNum, size);
+
+        }
+
+        /* set up external buffer descriptor and add to external buffer list */
+        lpfc_bsg_sli_cfg_dma_desc_setup(phba, nemb_tp, index,
+                                        phba->mbox_ext_buf_ctx.mbx_dmabuf,
+                                        dmabuf);
+        list_add_tail(&dmabuf->list, &phba->mbox_ext_buf_ctx.ext_dmabuf_list);
+
+        if (phba->mbox_ext_buf_ctx.seqNum == phba->mbox_ext_buf_ctx.numBuf) {
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2968 SLI_CONFIG ext-buffer wr all %d "
+                                "ebuffers received\n",
+                                phba->mbox_ext_buf_ctx.numBuf);
+                /* mailbox command structure for base driver */
+                pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+                if (!pmboxq) {
+                        rc = -ENOMEM;
+                        goto job_error;
+                }
+                memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
+                pbuf = (uint8_t *)phba->mbox_ext_buf_ctx.mbx_dmabuf->virt;
+                pmb = &pmboxq->u.mb;
+                memcpy(pmb, pbuf, sizeof(*pmb));
+                pmb->mbxOwner = OWN_HOST;
+                pmboxq->vport = phba->pport;
+
+                /* callback for multi-buffer write mailbox command */
+                pmboxq->mbox_cmpl = lpfc_bsg_issue_write_mbox_ext_cmpl;
+
+                /* context fields to callback function */
+                pmboxq->context1 = dd_data;
+                dd_data->type = TYPE_MBOX;
+                dd_data->context_un.mbox.pmboxq = pmboxq;
+                dd_data->context_un.mbox.mb = (MAILBOX_t *)pbuf;
+                dd_data->context_un.mbox.set_job = job;
+                job->dd_data = dd_data;
+
+                /* state change */
+                phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_PORT;
+
+                rc = lpfc_sli_issue_mbox(phba, pmboxq, MBX_NOWAIT);
+                if ((rc == MBX_SUCCESS) || (rc == MBX_BUSY)) {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2969 Issued SLI_CONFIG ext-buffer "
+                                        "maibox command, rc:x%x\n", rc);
+                        return 1;
+                }
+                lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                "2970 Failed to issue SLI_CONFIG ext-buffer "
+                                "maibox command, rc:x%x\n", rc);
+                rc = -EPIPE;
+                goto job_error;
+        }
+
+        /* wait for additoinal external buffers */
+        job->reply->result = 0;
+        job->job_done(job);
+        return SLI_CONFIG_HANDLED;
+
+job_error:
+        lpfc_bsg_dma_page_free(phba, dmabuf);
+        kfree(dd_data);
+
+        return rc;
+}
+
+/**
+ * lpfc_bsg_handle_sli_cfg_ebuf - handle ext buffer with sli-cfg mailbox cmd
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a BSG mailbox object.
+ * @dmabuff: Pointer to a DMA buffer descriptor.
+ *
+ * This routine handles the external buffer with SLI_CONFIG (0x9B) mailbox
+ * command with multiple non-embedded external buffers.
+ **/
+static int
+lpfc_bsg_handle_sli_cfg_ebuf(struct lpfc_hba *phba, struct fc_bsg_job *job,
+                             struct lpfc_dmabuf *dmabuf)
+{
+        int rc;
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                        "2971 SLI_CONFIG buffer (type:x%x)\n",
+                        phba->mbox_ext_buf_ctx.mboxType);
+
+        if (phba->mbox_ext_buf_ctx.mboxType == mbox_rd) {
+                if (phba->mbox_ext_buf_ctx.state != LPFC_BSG_MBOX_DONE) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                        "2972 SLI_CONFIG rd buffer state "
+                                        "mismatch:x%x\n",
+                                        phba->mbox_ext_buf_ctx.state);
+                        lpfc_bsg_mbox_ext_abort(phba);
+                        return -EPIPE;
+                }
+                rc = lpfc_bsg_read_ebuf_get(phba, job);
+                if (rc == SLI_CONFIG_HANDLED)
+                        lpfc_bsg_dma_page_free(phba, dmabuf);
+        } else { /* phba->mbox_ext_buf_ctx.mboxType == mbox_wr */
+                if (phba->mbox_ext_buf_ctx.state != LPFC_BSG_MBOX_HOST) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                                        "2973 SLI_CONFIG wr buffer state "
+                                        "mismatch:x%x\n",
+                                        phba->mbox_ext_buf_ctx.state);
+                        lpfc_bsg_mbox_ext_abort(phba);
+                        return -EPIPE;
+                }
+                rc = lpfc_bsg_write_ebuf_set(phba, job, dmabuf);
+        }
+        return rc;
+}
+
+/**
+ * lpfc_bsg_handle_sli_cfg_ext - handle sli-cfg mailbox with external buffer
+ * @phba: Pointer to HBA context object.
+ * @mb: Pointer to a BSG mailbox object.
+ * @dmabuff: Pointer to a DMA buffer descriptor.
+ *
+ * This routine checkes and handles non-embedded multi-buffer SLI_CONFIG
+ * (0x9B) mailbox commands and external buffers.
+ **/
+static int
+lpfc_bsg_handle_sli_cfg_ext(struct lpfc_hba *phba, struct fc_bsg_job *job,
+                            struct lpfc_dmabuf *dmabuf)
+{
+        struct dfc_mbox_req *mbox_req;
+        int rc;
+
+        mbox_req =
+           (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
+
+        /* mbox command with/without single external buffer */
+        if (mbox_req->extMboxTag == 0 && mbox_req->extSeqNum == 0)
+                return SLI_CONFIG_NOT_HANDLED;
+
+        /* mbox command and first external buffer */
+        if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_IDLE) {
+                if (mbox_req->extSeqNum == 1) {
+                        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                        "2974 SLI_CONFIG mailbox: tag:%d, "
+                                        "seq:%d\n", mbox_req->extMboxTag,
+                                        mbox_req->extSeqNum);
+                        rc = lpfc_bsg_handle_sli_cfg_mbox(phba, job, dmabuf);
+                        return rc;
+                } else
+                        goto sli_cfg_ext_error;
+        }
+
+        /*
+         * handle additional external buffers
+         */
+
+        /* check broken pipe conditions */
+        if (mbox_req->extMboxTag != phba->mbox_ext_buf_ctx.mbxTag)
+                goto sli_cfg_ext_error;
+        if (mbox_req->extSeqNum > phba->mbox_ext_buf_ctx.numBuf)
+                goto sli_cfg_ext_error;
+        if (mbox_req->extSeqNum != phba->mbox_ext_buf_ctx.seqNum + 1)
+                goto sli_cfg_ext_error;
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                        "2975 SLI_CONFIG mailbox external buffer: "
+                        "extSta:x%x, tag:%d, seq:%d\n",
+                        phba->mbox_ext_buf_ctx.state, mbox_req->extMboxTag,
+                        mbox_req->extSeqNum);
+        rc = lpfc_bsg_handle_sli_cfg_ebuf(phba, job, dmabuf);
+        return rc;
+
+sli_cfg_ext_error:
+        /* all other cases, broken pipe */
+        lpfc_printf_log(phba, KERN_ERR, LOG_LIBDFC,
+                        "2976 SLI_CONFIG mailbox broken pipe: "
+                        "ctxSta:x%x, ctxNumBuf:%d "
+                        "ctxTag:%d, ctxSeq:%d, tag:%d, seq:%d\n",
+                        phba->mbox_ext_buf_ctx.state,
+                        phba->mbox_ext_buf_ctx.numBuf,
+                        phba->mbox_ext_buf_ctx.mbxTag,
+                        phba->mbox_ext_buf_ctx.seqNum,
+                        mbox_req->extMboxTag, mbox_req->extSeqNum);
+
+        lpfc_bsg_mbox_ext_session_reset(phba);
+
+        return -EPIPE;
+}
+
+/**
  * 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.
@@ -2638,22 +4118,21 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
         LPFC_MBOXQ_t *pmboxq = NULL; /* internal mailbox queue */
         MAILBOX_t *pmb; /* shortcut to the pmboxq mailbox */
         /* a 4k buffer to hold the mb and extended data from/to the bsg */
-        MAILBOX_t *mb = NULL;
+        uint8_t *pmbx = NULL;
         struct bsg_job_data *dd_data = NULL; /* bsg data tracking structure */
-        uint32_t size;
-        struct lpfc_dmabuf *rxbmp = NULL; /* for biu diag */
-        struct lpfc_dmabufext *dmp = NULL; /* for biu diag */
-        struct ulp_bde64 *rxbpl = NULL;
-        struct dfc_mbox_req *mbox_req = (struct dfc_mbox_req *)
-                job->request->rqst_data.h_vendor.vendor_cmd;
+        struct lpfc_dmabuf *dmabuf = NULL;
+        struct dfc_mbox_req *mbox_req;
         struct READ_EVENT_LOG_VAR *rdEventLog;
         uint32_t transmit_length, receive_length, mode;
+        struct lpfc_mbx_sli4_config *sli4_config;
         struct lpfc_mbx_nembed_cmd *nembed_sge;
         struct mbox_header *header;
         struct ulp_bde64 *bde;
         uint8_t *ext = NULL;
         int rc = 0;
         uint8_t *from;
+        uint32_t size;
+
 
         /* in case no data is transferred */
         job->reply->reply_payload_rcv_len = 0;
@@ -2665,6 +4144,18 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 goto job_done;
         }
 
+        /*
+         * Don't allow mailbox commands to be sent when blocked or when in
+         * the middle of discovery
+         */
+         if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
+                rc = -EAGAIN;
+                goto job_done;
+        }
+
+        mbox_req =
+            (struct dfc_mbox_req *)job->request->rqst_data.h_vendor.vendor_cmd;
+
         /* check if requested extended data lengths are valid */
         if ((mbox_req->inExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t)) ||
             (mbox_req->outExtWLen > BSG_MBOX_SIZE/sizeof(uint32_t))) {
@@ -2672,6 +4163,32 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 goto job_done;
         }
 
+        dmabuf = lpfc_bsg_dma_page_alloc(phba);
+        if (!dmabuf || !dmabuf->virt) {
+                rc = -ENOMEM;
+                goto job_done;
+        }
+
+        /* Get the mailbox command or external buffer from BSG */
+        pmbx = (uint8_t *)dmabuf->virt;
+        size = job->request_payload.payload_len;
+        sg_copy_to_buffer(job->request_payload.sg_list,
+                          job->request_payload.sg_cnt, pmbx, size);
+
+        /* Handle possible SLI_CONFIG with non-embedded payloads */
+        if (phba->sli_rev == LPFC_SLI_REV4) {
+                rc = lpfc_bsg_handle_sli_cfg_ext(phba, job, dmabuf);
+                if (rc == SLI_CONFIG_HANDLED)
+                        goto job_cont;
+                if (rc)
+                        goto job_done;
+                /* SLI_CONFIG_NOT_HANDLED for other mailbox commands */
+        }
+
+        rc = lpfc_bsg_check_cmd_access(phba, (MAILBOX_t *)pmbx, vport);
+        if (rc != 0)
+                goto job_done; /* must be negative */
+
         /* allocate our bsg tracking structure */
         dd_data = kmalloc(sizeof(struct bsg_job_data), GFP_KERNEL);
         if (!dd_data) {
@@ -2681,12 +4198,6 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 goto job_done;
         }
 
-        mb = kzalloc(BSG_MBOX_SIZE, GFP_KERNEL);
-        if (!mb) {
-                rc = -ENOMEM;
-                goto job_done;
-        }
-
         pmboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!pmboxq) {
                 rc = -ENOMEM;
@@ -2694,17 +4205,8 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
         }
         memset(pmboxq, 0, sizeof(LPFC_MBOXQ_t));
 
-        size = job->request_payload.payload_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)
-                goto job_done; /* must be negative */
-
         pmb = &pmboxq->u.mb;
-        memcpy(pmb, mb, sizeof(*pmb));
+        memcpy(pmb, pmbx, sizeof(*pmb));
         pmb->mbxOwner = OWN_HOST;
         pmboxq->vport = vport;
 
@@ -2721,30 +4223,13 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                                 "0x%x while in stopped state.\n",
                                 pmb->mbxCommand);
 
-        /* Don't allow mailbox commands to be sent when blocked
-         * or when in the middle of discovery
-         */
-        if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
-                rc = -EAGAIN;
-                goto job_done;
-        }
-
         /* extended mailbox commands will need an extended buffer */
         if (mbox_req->inExtWLen || mbox_req->outExtWLen) {
-                ext = kzalloc(MAILBOX_EXT_SIZE, GFP_KERNEL);
-                if (!ext) {
-                        rc = -ENOMEM;
-                        goto job_done;
-                }
-
                 /* any data for the device? */
                 if (mbox_req->inExtWLen) {
-                        from = (uint8_t *)mb;
-                        from += sizeof(MAILBOX_t);
-                        memcpy((uint8_t *)ext, from,
-                                mbox_req->inExtWLen * sizeof(uint32_t));
+                        from = pmbx;
+                        ext = from + sizeof(MAILBOX_t);
                 }
-
                 pmboxq->context2 = ext;
                 pmboxq->in_ext_byte_len =
                         mbox_req->inExtWLen * sizeof(uint32_t);
@@ -2768,46 +4253,17 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         rc = -ERANGE;
                         goto job_done;
                 }
-
-                rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-                if (!rxbmp) {
-                        rc = -ENOMEM;
-                        goto job_done;
-                }
-
-                rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
-                if (!rxbmp->virt) {
-                        rc = -ENOMEM;
-                        goto job_done;
-                }
-
-                INIT_LIST_HEAD(&rxbmp->list);
-                rxbpl = (struct ulp_bde64 *) rxbmp->virt;
-                dmp = diag_cmd_data_alloc(phba, rxbpl, transmit_length, 0);
-                if (!dmp) {
-                        rc = -ENOMEM;
-                        goto job_done;
-                }
-
-                INIT_LIST_HEAD(&dmp->dma.list);
                 pmb->un.varBIUdiag.un.s2.xmit_bde64.addrHigh =
-                        putPaddrHigh(dmp->dma.phys);
+                        putPaddrHigh(dmabuf->phys + sizeof(MAILBOX_t));
                 pmb->un.varBIUdiag.un.s2.xmit_bde64.addrLow =
-                        putPaddrLow(dmp->dma.phys);
+                        putPaddrLow(dmabuf->phys + sizeof(MAILBOX_t));
 
                 pmb->un.varBIUdiag.un.s2.rcv_bde64.addrHigh =
-                        putPaddrHigh(dmp->dma.phys +
-                                pmb->un.varBIUdiag.un.s2.
-                                        xmit_bde64.tus.f.bdeSize);
+                        putPaddrHigh(dmabuf->phys + sizeof(MAILBOX_t)
+                          + pmb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize);
                 pmb->un.varBIUdiag.un.s2.rcv_bde64.addrLow =
-                        putPaddrLow(dmp->dma.phys +
-                                pmb->un.varBIUdiag.un.s2.
-                                        xmit_bde64.tus.f.bdeSize);
-
-                /* copy the transmit data found in the mailbox extension area */
-                from = (uint8_t *)mb;
-                from += sizeof(MAILBOX_t);
-                memcpy((uint8_t *)dmp->dma.virt, from, transmit_length);
+                        putPaddrLow(dmabuf->phys + sizeof(MAILBOX_t)
+                          + pmb->un.varBIUdiag.un.s2.xmit_bde64.tus.f.bdeSize);
         } else if (pmb->mbxCommand == MBX_READ_EVENT_LOG) {
                 rdEventLog = &pmb->un.varRdEventLog;
                 receive_length = rdEventLog->rcv_bde64.tus.f.bdeSize;
@@ -2823,33 +4279,10 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
 
                 /* mode zero uses a bde like biu diags command */
                 if (mode == 0) {
-
-                        /* rebuild the command for sli4 using our own buffers
-                        * like we do for biu diags
-                        */
-
-                        rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-                        if (!rxbmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
-                        rxbpl = (struct ulp_bde64 *) rxbmp->virt;
-                        if (rxbpl) {
-                                INIT_LIST_HEAD(&rxbmp->list);
-                                dmp = diag_cmd_data_alloc(phba, rxbpl,
-                                        receive_length, 0);
-                        }
-
-                        if (!dmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        INIT_LIST_HEAD(&dmp->dma.list);
-                        pmb->un.varWords[3] = putPaddrLow(dmp->dma.phys);
-                        pmb->un.varWords[4] = putPaddrHigh(dmp->dma.phys);
+                        pmb->un.varWords[3] = putPaddrLow(dmabuf->phys
+                                                        + sizeof(MAILBOX_t));
+                        pmb->un.varWords[4] = putPaddrHigh(dmabuf->phys
+                                                        + sizeof(MAILBOX_t));
                 }
         } else if (phba->sli_rev == LPFC_SLI_REV4) {
                 if (pmb->mbxCommand == MBX_DUMP_MEMORY) {
@@ -2860,36 +4293,14 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                         /* receive length cannot be greater than mailbox
                          * extension size
                          */
-                        if ((receive_length == 0) ||
-                                (receive_length > MAILBOX_EXT_SIZE)) {
+                        if (receive_length == 0) {
                                 rc = -ERANGE;
                                 goto job_done;
                         }
-
-                        rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-                        if (!rxbmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
-                        if (!rxbmp->virt) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        INIT_LIST_HEAD(&rxbmp->list);
-                        rxbpl = (struct ulp_bde64 *) rxbmp->virt;
-                        dmp = diag_cmd_data_alloc(phba, rxbpl, receive_length,
-                                                0);
-                        if (!dmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        INIT_LIST_HEAD(&dmp->dma.list);
-                        pmb->un.varWords[3] = putPaddrLow(dmp->dma.phys);
-                        pmb->un.varWords[4] = putPaddrHigh(dmp->dma.phys);
+                        pmb->un.varWords[3] = putPaddrLow(dmabuf->phys
+                                                + sizeof(MAILBOX_t));
+                        pmb->un.varWords[4] = putPaddrHigh(dmabuf->phys
+                                                + sizeof(MAILBOX_t));
                 } else if ((pmb->mbxCommand == MBX_UPDATE_CFG) &&
                         pmb->un.varUpdateCfg.co) {
                         bde = (struct ulp_bde64 *)&pmb->un.varWords[4];
@@ -2899,102 +4310,53 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                                 rc = -ERANGE;
                                 goto job_done;
                         }
-
-                        rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-                        if (!rxbmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
-                        if (!rxbmp->virt) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        INIT_LIST_HEAD(&rxbmp->list);
-                        rxbpl = (struct ulp_bde64 *) rxbmp->virt;
-                        dmp = diag_cmd_data_alloc(phba, rxbpl,
-                                        bde->tus.f.bdeSize, 0);
-                        if (!dmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        INIT_LIST_HEAD(&dmp->dma.list);
-                        bde->addrHigh = putPaddrHigh(dmp->dma.phys);
-                        bde->addrLow = putPaddrLow(dmp->dma.phys);
-
-                        /* copy the transmit data found in the mailbox
-                         * extension area
-                         */
-                        from = (uint8_t *)mb;
-                        from += sizeof(MAILBOX_t);
-                        memcpy((uint8_t *)dmp->dma.virt, from,
-                                bde->tus.f.bdeSize);
+                        bde->addrHigh = putPaddrHigh(dmabuf->phys
+                                                + sizeof(MAILBOX_t));
+                        bde->addrLow = putPaddrLow(dmabuf->phys
+                                                + sizeof(MAILBOX_t));
                 } else if (pmb->mbxCommand == MBX_SLI4_CONFIG) {
-                        /* rebuild the command for sli4 using our own buffers
-                        * like we do for biu diags
-                        */
-                        header = (struct mbox_header *)&pmb->un.varWords[0];
-                        nembed_sge = (struct lpfc_mbx_nembed_cmd *)
-                                &pmb->un.varWords[0];
-                        receive_length = nembed_sge->sge[0].length;
-
-                        /* receive length cannot be greater than mailbox
-                         * extension size
-                         */
-                        if ((receive_length == 0) ||
-                                (receive_length > MAILBOX_EXT_SIZE)) {
-                                rc = -ERANGE;
-                                goto job_done;
-                        }
-
-                        rxbmp = kmalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
-                        if (!rxbmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
-
-                        rxbmp->virt = lpfc_mbuf_alloc(phba, 0, &rxbmp->phys);
-                        if (!rxbmp->virt) {
-                                rc = -ENOMEM;
-                                goto job_done;
-                        }
+                        /* Handling non-embedded SLI_CONFIG mailbox command */
+                        sli4_config = &pmboxq->u.mqe.un.sli4_config;
+                        if (!bf_get(lpfc_mbox_hdr_emb,
+                            &sli4_config->header.cfg_mhdr)) {
+                                /* rebuild the command for sli4 using our
+                                 * own buffers like we do for biu diags
+                                 */
+                                header = (struct mbox_header *)
+                                                &pmb->un.varWords[0];
+                                nembed_sge = (struct lpfc_mbx_nembed_cmd *)
+                                                &pmb->un.varWords[0];
+                                receive_length = nembed_sge->sge[0].length;
+
+                                /* receive length cannot be greater than
+                                 * mailbox extension size
+                                 */
+                                if ((receive_length == 0) ||
+                                    (receive_length > MAILBOX_EXT_SIZE)) {
+                                        rc = -ERANGE;
+                                        goto job_done;
+                                }
 
-                        INIT_LIST_HEAD(&rxbmp->list);
-                        rxbpl = (struct ulp_bde64 *) rxbmp->virt;
-                        dmp = diag_cmd_data_alloc(phba, rxbpl, receive_length,
-                                                0);
-                        if (!dmp) {
-                                rc = -ENOMEM;
-                                goto job_done;
+                                nembed_sge->sge[0].pa_hi =
+                                                putPaddrHigh(dmabuf->phys
+                                                   + sizeof(MAILBOX_t));
+                                nembed_sge->sge[0].pa_lo =
+                                                putPaddrLow(dmabuf->phys
+                                                   + sizeof(MAILBOX_t));
                         }
-
-                        INIT_LIST_HEAD(&dmp->dma.list);
-                        nembed_sge->sge[0].pa_hi = putPaddrHigh(dmp->dma.phys);
-                        nembed_sge->sge[0].pa_lo = putPaddrLow(dmp->dma.phys);
-                        /* copy the transmit data found in the mailbox
-                         * extension area
-                         */
-                        from = (uint8_t *)mb;
-                        from += sizeof(MAILBOX_t);
-                        memcpy((uint8_t *)dmp->dma.virt, from,
-                                header->cfg_mhdr.payload_length);
                 }
         }
 
-        dd_data->context_un.mbox.rxbmp = rxbmp;
-        dd_data->context_un.mbox.dmp = dmp;
+        dd_data->context_un.mbox.dmabuffers = dmabuf;
 
         /* setup wake call as IOCB callback */
-        pmboxq->mbox_cmpl = lpfc_bsg_wake_mbox_wait;
+        pmboxq->mbox_cmpl = lpfc_bsg_issue_mbox_cmpl;
 
         /* 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.mb = (MAILBOX_t *)pmbx;
         dd_data->context_un.mbox.set_job = job;
         dd_data->context_un.mbox.ext = ext;
         dd_data->context_un.mbox.mbOffset = mbox_req->mbOffset;
@@ -3011,11 +4373,11 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
                 }
 
                 /* job finished, copy the data */
-                memcpy(mb, pmb, sizeof(*pmb));
+                memcpy(pmbx, 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);
+                                            job->reply_payload.sg_cnt,
+                                            pmbx, size);
                 /* not waiting mbox already done */
                 rc = 0;
                 goto job_done;
@@ -3027,22 +4389,12 @@ lpfc_bsg_issue_mbox(struct lpfc_hba *phba, struct fc_bsg_job *job,
 
 job_done:
         /* common exit for error or job completed inline */
-        kfree(mb);
         if (pmboxq)
                 mempool_free(pmboxq, phba->mbox_mem_pool);
-        kfree(ext);
-        if (dmp) {
-                dma_free_coherent(&phba->pcidev->dev,
-                        dmp->size, dmp->dma.virt,
-                                dmp->dma.phys);
-                kfree(dmp);
-        }
-        if (rxbmp) {
-                lpfc_mbuf_free(phba, rxbmp->virt, rxbmp->phys);
-                kfree(rxbmp);
-        }
+        lpfc_bsg_dma_page_free(phba, dmabuf);
         kfree(dd_data);
 
+job_cont:
         return rc;
 }
 
@@ -3055,37 +4407,28 @@ 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;
+        struct dfc_mbox_req *mbox_req;
         int rc = 0;
 
-        /* in case no data is transferred */
+        /* mix-and-match backward compatibility */
         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 != BSG_MBOX_SIZE) {
-                rc = -EINVAL;
-                goto job_error;
-        }
-
-        if (job->reply_payload.payload_len != BSG_MBOX_SIZE) {
-                rc = -EINVAL;
-                goto job_error;
-        }
-
-        if (phba->sli.sli_flag & LPFC_BLOCK_MGMT_IO) {
-                rc = -EAGAIN;
-                goto job_error;
+                lpfc_printf_log(phba, KERN_INFO, LOG_LIBDFC,
+                                "2737 Mix-and-match backward compability "
+                                "between MBOX_REQ old size:%d and "
+                                "new request size:%d\n",
+                                (int)(job->request_len -
+                                      sizeof(struct fc_bsg_request)),
+                                (int)sizeof(struct dfc_mbox_req));
+                mbox_req = (struct dfc_mbox_req *)
+                                job->request->rqst_data.h_vendor.vendor_cmd;
+                mbox_req->extMboxTag = 0;
+                mbox_req->extSeqNum = 0;
         }
 
         rc = lpfc_bsg_issue_mbox(phba, job, vport);
 
-job_error:
         if (rc == 0) {
                 /* job done */
                 job->reply->result = 0;
@@ -3416,10 +4759,16 @@ lpfc_bsg_hst_vendor(struct fc_bsg_job *job)
                 rc = lpfc_bsg_send_mgmt_rsp(job);
                 break;
         case LPFC_BSG_VENDOR_DIAG_MODE:
-                rc = lpfc_bsg_diag_mode(job);
+                rc = lpfc_bsg_diag_loopback_mode(job);
+                break;
+        case LPFC_BSG_VENDOR_DIAG_MODE_END:
+                rc = lpfc_sli4_bsg_diag_mode_end(job);
+                break;
+        case LPFC_BSG_VENDOR_DIAG_RUN_LOOPBACK:
+                rc = lpfc_bsg_diag_loopback_run(job);
                 break;
-        case LPFC_BSG_VENDOR_DIAG_TEST:
-                rc = lpfc_bsg_diag_test(job);
+        case LPFC_BSG_VENDOR_LINK_DIAG_TEST:
+                rc = lpfc_sli4_bsg_link_diag_test(job);
                 break;
         case LPFC_BSG_VENDOR_GET_MGMT_REV:
                 rc = lpfc_bsg_get_dfc_rev(job);
@@ -3538,6 +4887,8 @@ lpfc_bsg_timeout(struct fc_bsg_job *job)
                 /* the mbox completion handler can now be run */
                 spin_unlock_irqrestore(&phba->ct_ev_lock, flags);
                 job->job_done(job);
+                if (phba->mbox_ext_buf_ctx.state == LPFC_BSG_MBOX_PORT)
+                        phba->mbox_ext_buf_ctx.state = LPFC_BSG_MBOX_ABTS;
                 break;
         case TYPE_MENLO:
                 menlo = &dd_data->context_un.menlo;
diff --git a/drivers/scsi/lpfc/lpfc_bsg.h b/drivers/scsi/lpfc/lpfc_bsg.h
index b542aca6f5ae..c8c2b47ea886 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.h
+++ b/drivers/scsi/lpfc/lpfc_bsg.h
@@ -24,15 +24,17 @@
  * 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
-#define LPFC_BSG_VENDOR_MENLO_CMD       8
-#define LPFC_BSG_VENDOR_MENLO_DATA      9
+#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_RUN_LOOPBACK       5
+#define LPFC_BSG_VENDOR_GET_MGMT_REV            6
+#define LPFC_BSG_VENDOR_MBOX                    7
+#define LPFC_BSG_VENDOR_MENLO_CMD               8
+#define LPFC_BSG_VENDOR_MENLO_DATA              9
+#define LPFC_BSG_VENDOR_DIAG_MODE_END           10
+#define LPFC_BSG_VENDOR_LINK_DIAG_TEST          11
 
 struct set_ct_event {
         uint32_t command;
@@ -67,10 +69,25 @@ struct diag_mode_set {
         uint32_t timeout;
 };
 
+struct sli4_link_diag {
+        uint32_t command;
+        uint32_t timeout;
+        uint32_t test_id;
+        uint32_t loops;
+        uint32_t test_version;
+        uint32_t error_action;
+};
+
 struct diag_mode_test {
         uint32_t command;
 };
 
+struct diag_status {
+        uint32_t mbox_status;
+        uint32_t shdr_status;
+        uint32_t shdr_add_status;
+};
+
 #define LPFC_WWNN_TYPE          0
 #define LPFC_WWPN_TYPE          1
 
@@ -92,11 +109,15 @@ struct get_mgmt_rev_reply {
 };
 
 #define BSG_MBOX_SIZE 4096 /* mailbox command plus extended data */
+
+/* BSG mailbox request header */
 struct dfc_mbox_req {
         uint32_t command;
         uint32_t mbOffset;
         uint32_t inExtWLen;
         uint32_t outExtWLen;
+        uint32_t extMboxTag;
+        uint32_t extSeqNum;
 };
 
 /* Used for menlo command or menlo data. The xri is only used for menlo data */
@@ -171,7 +192,7 @@ struct lpfc_sli_config_mse {
 #define lpfc_mbox_sli_config_mse_len_WORD       buf_len
 };
 
-struct lpfc_sli_config_subcmd_hbd {
+struct lpfc_sli_config_hbd {
         uint32_t buf_len;
 #define lpfc_mbox_sli_config_ecmn_hbd_len_SHIFT 0
 #define lpfc_mbox_sli_config_ecmn_hbd_len_MASK  0xffffff
@@ -194,21 +215,39 @@ struct lpfc_sli_config_hdr {
         uint32_t reserved5;
 };
 
-struct lpfc_sli_config_generic {
+struct lpfc_sli_config_emb0_subsys {
         struct lpfc_sli_config_hdr      sli_config_hdr;
 #define LPFC_MBX_SLI_CONFIG_MAX_MSE     19
         struct lpfc_sli_config_mse      mse[LPFC_MBX_SLI_CONFIG_MAX_MSE];
+        uint32_t padding;
+        uint32_t word64;
+#define lpfc_emb0_subcmnd_opcode_SHIFT  0
+#define lpfc_emb0_subcmnd_opcode_MASK   0xff
+#define lpfc_emb0_subcmnd_opcode_WORD   word64
+#define lpfc_emb0_subcmnd_subsys_SHIFT  8
+#define lpfc_emb0_subcmnd_subsys_MASK   0xff
+#define lpfc_emb0_subcmnd_subsys_WORD   word64
+/* Subsystem FCOE (0x0C) OpCodes */
+#define SLI_CONFIG_SUBSYS_FCOE          0x0C
+#define FCOE_OPCODE_READ_FCF            0x08
+#define FCOE_OPCODE_ADD_FCF             0x09
 };
 
-struct lpfc_sli_config_subcmnd {
+struct lpfc_sli_config_emb1_subsys {
         struct lpfc_sli_config_hdr      sli_config_hdr;
         uint32_t word6;
-#define lpfc_subcmnd_opcode_SHIFT       0
-#define lpfc_subcmnd_opcode_MASK        0xff
-#define lpfc_subcmnd_opcode_WORD        word6
-#define lpfc_subcmnd_subsys_SHIFT       8
-#define lpfc_subcmnd_subsys_MASK        0xff
-#define lpfc_subcmnd_subsys_WORD        word6
+#define lpfc_emb1_subcmnd_opcode_SHIFT  0
+#define lpfc_emb1_subcmnd_opcode_MASK   0xff
+#define lpfc_emb1_subcmnd_opcode_WORD   word6
+#define lpfc_emb1_subcmnd_subsys_SHIFT  8
+#define lpfc_emb1_subcmnd_subsys_MASK   0xff
+#define lpfc_emb1_subcmnd_subsys_WORD   word6
+/* Subsystem COMN (0x01) OpCodes */
+#define SLI_CONFIG_SUBSYS_COMN          0x01
+#define COMN_OPCODE_READ_OBJECT         0xAB
+#define COMN_OPCODE_WRITE_OBJECT        0xAC
+#define COMN_OPCODE_READ_OBJECT_LIST    0xAD
+#define COMN_OPCODE_DELETE_OBJECT       0xAE
         uint32_t timeout;
         uint32_t request_length;
         uint32_t word9;
@@ -222,8 +261,8 @@ struct lpfc_sli_config_subcmnd {
         uint32_t rd_offset;
         uint32_t obj_name[26];
         uint32_t hbd_count;
-#define LPFC_MBX_SLI_CONFIG_MAX_HBD     10
-        struct lpfc_sli_config_subcmd_hbd   hbd[LPFC_MBX_SLI_CONFIG_MAX_HBD];
+#define LPFC_MBX_SLI_CONFIG_MAX_HBD     8
+        struct lpfc_sli_config_hbd      hbd[LPFC_MBX_SLI_CONFIG_MAX_HBD];
 };
 
 struct lpfc_sli_config_mbox {
@@ -235,7 +274,11 @@ struct lpfc_sli_config_mbox {
 #define lpfc_mqe_command_MASK           0x000000FF
 #define lpfc_mqe_command_WORD           word0
         union {
-                struct lpfc_sli_config_generic  sli_config_generic;
-                struct lpfc_sli_config_subcmnd  sli_config_subcmnd;
+                struct lpfc_sli_config_emb0_subsys sli_config_emb0_subsys;
+                struct lpfc_sli_config_emb1_subsys sli_config_emb1_subsys;
         } un;
 };
+
+/* driver only */
+#define SLI_CONFIG_NOT_HANDLED          0
+#define SLI_CONFIG_HANDLED              1
diff --git a/drivers/scsi/lpfc/lpfc_crtn.h b/drivers/scsi/lpfc/lpfc_crtn.h
index f0b332f4eedb..fc20c247f36b 100644
--- a/drivers/scsi/lpfc/lpfc_crtn.h
+++ b/drivers/scsi/lpfc/lpfc_crtn.h
@@ -55,6 +55,8 @@ void lpfc_request_features(struct lpfc_hba *, struct lpfcMboxq *);
 void lpfc_supported_pages(struct lpfcMboxq *);
 void lpfc_pc_sli4_params(struct lpfcMboxq *);
 int lpfc_pc_sli4_params_get(struct lpfc_hba *, LPFC_MBOXQ_t *);
+int lpfc_sli4_mbox_rsrc_extent(struct lpfc_hba *, struct lpfcMboxq *,
+                           uint16_t, uint16_t, bool);
 int lpfc_get_sli4_parameters(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 *);
@@ -171,6 +173,7 @@ void lpfc_delayed_disc_tmo(unsigned long);
 void lpfc_delayed_disc_timeout_handler(struct lpfc_vport *);
 
 int lpfc_config_port_prep(struct lpfc_hba *);
+void lpfc_update_vport_wwn(struct lpfc_vport *vport);
 int lpfc_config_port_post(struct lpfc_hba *);
 int lpfc_hba_down_prep(struct lpfc_hba *);
 int lpfc_hba_down_post(struct lpfc_hba *);
@@ -365,6 +368,10 @@ extern void lpfc_debugfs_slow_ring_trc(struct lpfc_hba *, char *, uint32_t,
         uint32_t, uint32_t);
 extern struct lpfc_hbq_init *lpfc_hbq_defs[];
 
+/* SLI4 if_type 2 externs. */
+int lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *);
+int lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *);
+
 /* externs BlockGuard */
 extern char *_dump_buf_data;
 extern unsigned long _dump_buf_data_order;
@@ -429,3 +436,6 @@ void lpfc_cleanup_wt_rrqs(struct lpfc_hba *);
 void lpfc_cleanup_vports_rrqs(struct lpfc_vport *, struct lpfc_nodelist *);
 struct lpfc_node_rrq *lpfc_get_active_rrq(struct lpfc_vport *, uint16_t,
         uint32_t);
+int lpfc_wr_object(struct lpfc_hba *, struct list_head *, uint32_t, uint32_t *);
+/* functions to support SR-IOV */
+int lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *, int);
diff --git a/drivers/scsi/lpfc/lpfc_ct.c b/drivers/scsi/lpfc/lpfc_ct.c
index d9edfd90d7ff..779b88e1469d 100644
--- a/drivers/scsi/lpfc/lpfc_ct.c
+++ b/drivers/scsi/lpfc/lpfc_ct.c
@@ -352,6 +352,8 @@ lpfc_gen_req(struct lpfc_vport *vport, struct lpfc_dmabuf *bmp,
         icmd->ulpLe = 1;
         icmd->ulpClass = CLASS3;
         icmd->ulpContext = ndlp->nlp_rpi;
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                icmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
 
         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) {
                 /* For GEN_REQUEST64_CR, use the RPI */
diff --git a/drivers/scsi/lpfc/lpfc_debugfs.c b/drivers/scsi/lpfc/lpfc_debugfs.c
index c93fca058603..ffe82d169b40 100644
--- a/drivers/scsi/lpfc/lpfc_debugfs.c
+++ b/drivers/scsi/lpfc/lpfc_debugfs.c
@@ -1665,7 +1665,8 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
         /* Get fast-path complete queue information */
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
                         "Fast-path FCP CQ information:\n");
-        for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++) {
+        fcp_qidx = 0;
+        do {
                 len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len,
                                 "Associated EQID[%02d]:\n",
                                 phba->sli4_hba.fcp_cq[fcp_qidx]->assoc_qid);
@@ -1678,7 +1679,7 @@ lpfc_idiag_queinfo_read(struct file *file, char __user *buf, size_t nbytes,
                                 phba->sli4_hba.fcp_cq[fcp_qidx]->entry_size,
                                 phba->sli4_hba.fcp_cq[fcp_qidx]->host_index,
                                 phba->sli4_hba.fcp_cq[fcp_qidx]->hba_index);
-        }
+        } while (++fcp_qidx < phba->cfg_fcp_eq_count);
         len += snprintf(pbuffer+len, LPFC_QUE_INFO_GET_BUF_SIZE-len, "\n");
 
         /* Get mailbox queue information */
@@ -2012,7 +2013,8 @@ lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
                         goto pass_check;
                 }
                 /* FCP complete queue */
-                for (qidx = 0; qidx < phba->cfg_fcp_eq_count; qidx++) {
+                qidx = 0;
+                do {
                         if (phba->sli4_hba.fcp_cq[qidx]->queue_id == queid) {
                                 /* Sanity check */
                                 rc = lpfc_idiag_que_param_check(
@@ -2024,7 +2026,7 @@ lpfc_idiag_queacc_write(struct file *file, const char __user *buf,
                                                 phba->sli4_hba.fcp_cq[qidx];
                                 goto pass_check;
                         }
-                }
+                } while (++qidx < phba->cfg_fcp_eq_count);
                 goto error_out;
                 break;
         case LPFC_IDIAG_MQ:
diff --git a/drivers/scsi/lpfc/lpfc_els.c b/drivers/scsi/lpfc/lpfc_els.c
index e2c452467c8b..32a084534f3e 100644
--- a/drivers/scsi/lpfc/lpfc_els.c
+++ b/drivers/scsi/lpfc/lpfc_els.c
@@ -250,7 +250,7 @@ lpfc_prep_els_iocb(struct lpfc_vport *vport, uint8_t expectRsp,
                 icmd->un.elsreq64.myID = vport->fc_myDID;
 
                 /* For ELS_REQUEST64_CR, use the VPI by default */
-                icmd->ulpContext = vport->vpi + phba->vpi_base;
+                icmd->ulpContext = phba->vpi_ids[vport->vpi];
                 icmd->ulpCt_h = 0;
                 /* The CT field must be 0=INVALID_RPI for the ECHO cmd */
                 if (elscmd == ELS_CMD_ECHO)
@@ -454,6 +454,7 @@ lpfc_issue_reg_vfi(struct lpfc_vport *vport)
                 rc = -ENOMEM;
                 goto fail_free_dmabuf;
         }
+
         mboxq = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mboxq) {
                 rc = -ENOMEM;
@@ -6585,6 +6586,26 @@ lpfc_find_vport_by_vpid(struct lpfc_hba *phba, uint16_t vpi)
 {
         struct lpfc_vport *vport;
         unsigned long flags;
+        int i;
+
+        /* The physical ports are always vpi 0 - translate is unnecessary. */
+        if (vpi > 0) {
+                /*
+                 * Translate the physical vpi to the logical vpi.  The
+                 * vport stores the logical vpi.
+                 */
+                for (i = 0; i < phba->max_vpi; i++) {
+                        if (vpi == phba->vpi_ids[i])
+                                break;
+                }
+
+                if (i >= phba->max_vpi) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_ELS,
+                                         "2936 Could not find Vport mapped "
+                                         "to vpi %d\n", vpi);
+                        return NULL;
+                }
+        }
 
         spin_lock_irqsave(&phba->hbalock, flags);
         list_for_each_entry(vport, &phba->port_list, listentry) {
@@ -6641,8 +6662,9 @@ lpfc_els_unsol_event(struct lpfc_hba *phba, struct lpfc_sli_ring *pring,
                         vport = phba->pport;
                 else
                         vport = lpfc_find_vport_by_vpid(phba,
-                                icmd->unsli3.rcvsli3.vpi - phba->vpi_base);
+                                                icmd->unsli3.rcvsli3.vpi);
         }
+
         /* If there are no BDEs associated
          * with this IOCB, there is nothing to do.
          */
@@ -7222,7 +7244,7 @@ lpfc_issue_els_fdisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
                 elsiocb->iocb.ulpCt_h = (SLI4_CT_VPI >> 1) & 1;
                 elsiocb->iocb.ulpCt_l = SLI4_CT_VPI & 1 ;
                 /* Set the ulpContext to the vpi */
-                elsiocb->iocb.ulpContext = vport->vpi + phba->vpi_base;
+                elsiocb->iocb.ulpContext = phba->vpi_ids[vport->vpi];
         } else {
                 /* For FDISC, Let FDISC rsp set the NPortID for this VPI */
                 icmd->ulpCt_h = 1;
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index 7a35df5e2038..18d0dbfda2bc 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -881,7 +881,7 @@ lpfc_linkdown(struct lpfc_hba *phba)
         /* Clean up any firmware default rpi's */
         mb = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (mb) {
-                lpfc_unreg_did(phba, 0xffff, 0xffffffff, mb);
+                lpfc_unreg_did(phba, 0xffff, LPFC_UNREG_ALL_DFLT_RPIS, mb);
                 mb->vport = vport;
                 mb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                 if (lpfc_sli_issue_mbox(phba, mb, MBX_NOWAIT)
@@ -2690,16 +2690,7 @@ lpfc_mbx_cmpl_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
 
         memcpy((uint8_t *) &vport->fc_sparam, (uint8_t *) mp->virt,
                sizeof (struct serv_parm));
-        if (phba->cfg_soft_wwnn)
-                u64_to_wwn(phba->cfg_soft_wwnn,
-                           vport->fc_sparam.nodeName.u.wwn);
-        if (phba->cfg_soft_wwpn)
-                u64_to_wwn(phba->cfg_soft_wwpn,
-                           vport->fc_sparam.portName.u.wwn);
-        memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
-               sizeof(vport->fc_nodename));
-        memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
-               sizeof(vport->fc_portname));
+        lpfc_update_vport_wwn(vport);
         if (vport->port_type == LPFC_PHYSICAL_PORT) {
                 memcpy(&phba->wwnn, &vport->fc_nodename, sizeof(phba->wwnn));
                 memcpy(&phba->wwpn, &vport->fc_portname, sizeof(phba->wwnn));
@@ -3430,7 +3421,8 @@ lpfc_mbx_cmpl_fabric_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
                 return;
         }
 
-        ndlp->nlp_rpi = mb->un.varWords[0];
+        if (phba->sli_rev < LPFC_SLI_REV4)
+                ndlp->nlp_rpi = mb->un.varWords[0];
         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         ndlp->nlp_type |= NLP_FABRIC;
         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
@@ -3504,7 +3496,8 @@ out:
                 return;
         }
 
-        ndlp->nlp_rpi = mb->un.varWords[0];
+        if (phba->sli_rev < LPFC_SLI_REV4)
+                ndlp->nlp_rpi = mb->un.varWords[0];
         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         ndlp->nlp_type |= NLP_FABRIC;
         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
@@ -3591,7 +3584,6 @@ lpfc_register_remote_port(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
         if (ndlp->nlp_type & NLP_FCP_INITIATOR)
                 rport_ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 
-
         if (rport_ids.roles !=  FC_RPORT_ROLE_UNKNOWN)
                 fc_remote_port_rolechg(rport, rport_ids.roles);
 
@@ -4106,11 +4098,16 @@ lpfc_unreg_rpi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
         struct lpfc_hba *phba = vport->phba;
         LPFC_MBOXQ_t    *mbox;
         int rc;
+        uint16_t rpi;
 
         if (ndlp->nlp_flag & NLP_RPI_REGISTERED) {
                 mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
                 if (mbox) {
-                        lpfc_unreg_login(phba, vport->vpi, ndlp->nlp_rpi, mbox);
+                        /* SLI4 ports require the physical rpi value. */
+                        rpi = ndlp->nlp_rpi;
+                        if (phba->sli_rev == LPFC_SLI_REV4)
+                                rpi = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
+                        lpfc_unreg_login(phba, vport->vpi, rpi, mbox);
                         mbox->vport = vport;
                         mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                         rc = lpfc_sli_issue_mbox(phba, mbox, MBX_NOWAIT);
@@ -4179,7 +4176,8 @@ lpfc_unreg_all_rpis(struct lpfc_vport *vport)
 
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (mbox) {
-                lpfc_unreg_login(phba, vport->vpi, 0xffff, mbox);
+                lpfc_unreg_login(phba, vport->vpi, LPFC_UNREG_ALL_RPIS_VPORT,
+                                 mbox);
                 mbox->vport = vport;
                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                 mbox->context1 = NULL;
@@ -4203,7 +4201,8 @@ lpfc_unreg_default_rpis(struct lpfc_vport *vport)
 
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (mbox) {
-                lpfc_unreg_did(phba, vport->vpi, 0xffffffff, mbox);
+                lpfc_unreg_did(phba, vport->vpi, LPFC_UNREG_ALL_DFLT_RPIS,
+                               mbox);
                 mbox->vport = vport;
                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                 mbox->context1 = NULL;
@@ -4653,10 +4652,7 @@ lpfc_disc_start(struct lpfc_vport *vport)
         if (num_sent)
                 return;
 
-        /*
-         * For SLI3, cmpl_reg_vpi will set port_state to READY, and
-         * continue discovery.
-         */
+        /* Register the VPI for SLI3, NON-NPIV only. */
         if ((phba->sli3_options & LPFC_SLI3_NPIV_ENABLED) &&
             !(vport->fc_flag & FC_PT2PT) &&
             !(vport->fc_flag & FC_RSCN_MODE) &&
@@ -4943,7 +4939,7 @@ restart_disc:
                 if (phba->sli_rev < LPFC_SLI_REV4) {
                         if (phba->sli3_options & LPFC_SLI3_NPIV_ENABLED)
                                 lpfc_issue_reg_vpi(phba, vport);
-                        else  { /* NPIV Not enabled */
+                        else  {
                                 lpfc_issue_clear_la(phba, vport);
                                 vport->port_state = LPFC_VPORT_READY;
                         }
@@ -5069,7 +5065,8 @@ lpfc_mbx_cmpl_fdmi_reg_login(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
         pmb->context1 = NULL;
         pmb->context2 = NULL;
 
-        ndlp->nlp_rpi = mb->un.varWords[0];
+        if (phba->sli_rev < LPFC_SLI_REV4)
+                ndlp->nlp_rpi = mb->un.varWords[0];
         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         ndlp->nlp_type |= NLP_FABRIC;
         lpfc_nlp_set_state(vport, ndlp, NLP_STE_UNMAPPED_NODE);
@@ -5354,6 +5351,17 @@ lpfc_fcf_inuse(struct lpfc_hba *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);
+                /*
+                 * IF the CVL_RCVD bit is not set then we have sent the
+                 * flogi.
+                 * If dev_loss fires while we are waiting we do not want to
+                 * unreg the fcf.
+                 */
+                if (!(vports[i]->fc_flag & FC_VPORT_CVL_RCVD)) {
+                        spin_unlock_irq(shost->host_lock);
+                        ret =  1;
+                        goto out;
+                }
                 list_for_each_entry(ndlp, &vports[i]->fc_nodes, nlp_listp) {
                         if (NLP_CHK_NODE_ACT(ndlp) && ndlp->rport &&
                           (ndlp->rport->roles & FC_RPORT_ROLE_FCP_TARGET)) {
diff --git a/drivers/scsi/lpfc/lpfc_hw.h b/drivers/scsi/lpfc/lpfc_hw.h
index 86b6f7e6686a..9059524cf225 100644
--- a/drivers/scsi/lpfc/lpfc_hw.h
+++ b/drivers/scsi/lpfc/lpfc_hw.h
@@ -64,6 +64,8 @@
 #define SLI3_IOCB_CMD_SIZE      128
 #define SLI3_IOCB_RSP_SIZE      64
 
+#define LPFC_UNREG_ALL_RPIS_VPORT       0xffff
+#define LPFC_UNREG_ALL_DFLT_RPIS        0xffffffff
 
 /* vendor ID used in SCSI netlink calls */
 #define LPFC_NL_VENDOR_ID (SCSI_NL_VID_TYPE_PCI | PCI_VENDOR_ID_EMULEX)
@@ -903,6 +905,8 @@ struct RRQ {			/* Structure is in Big Endian format */
 #define rrq_rxid_WORD           rrq_exchg
 };
 
+#define LPFC_MAX_VFN_PER_PFN    255 /* Maximum VFs allowed per ARI */
+#define LPFC_DEF_VFN_PER_PFN    0   /* Default VFs due to platform limitation*/
 
 struct RTV_RSP {                /* Structure is in Big Endian format */
         uint32_t ratov;
@@ -1199,7 +1203,9 @@ typedef struct {
 #define PCI_DEVICE_ID_BALIUS        0xe131
 #define PCI_DEVICE_ID_PROTEUS_PF    0xe180
 #define PCI_DEVICE_ID_LANCER_FC     0xe200
+#define PCI_DEVICE_ID_LANCER_FC_VF  0xe208
 #define PCI_DEVICE_ID_LANCER_FCOE   0xe260
+#define PCI_DEVICE_ID_LANCER_FCOE_VF 0xe268
 #define PCI_DEVICE_ID_SAT_SMB       0xf011
 #define PCI_DEVICE_ID_SAT_MID       0xf015
 #define PCI_DEVICE_ID_RFLY          0xf095
@@ -3021,7 +3027,7 @@ typedef struct {
 #define MAILBOX_EXT_SIZE        (MAILBOX_EXT_WSIZE * sizeof(uint32_t))
 #define MAILBOX_HBA_EXT_OFFSET  0x100
 /* max mbox xmit size is a page size for sysfs IO operations */
-#define MAILBOX_MAX_XMIT_SIZE   PAGE_SIZE
+#define MAILBOX_SYSFS_MAX       4096
 
 typedef union {
         uint32_t varWords[MAILBOX_CMD_WSIZE - 1]; /* first word is type/
diff --git a/drivers/scsi/lpfc/lpfc_hw4.h b/drivers/scsi/lpfc/lpfc_hw4.h
index 4dff668ebdad..11e26a26b5d1 100644
--- a/drivers/scsi/lpfc/lpfc_hw4.h
+++ b/drivers/scsi/lpfc/lpfc_hw4.h
@@ -170,6 +170,25 @@ struct lpfc_sli_intf {
 #define LPFC_PCI_FUNC3          3
 #define LPFC_PCI_FUNC4          4
 
+/* SLI4 interface type-2 control register offsets */
+#define LPFC_CTL_PORT_SEM_OFFSET        0x400
+#define LPFC_CTL_PORT_STA_OFFSET        0x404
+#define LPFC_CTL_PORT_CTL_OFFSET        0x408
+#define LPFC_CTL_PORT_ER1_OFFSET        0x40C
+#define LPFC_CTL_PORT_ER2_OFFSET        0x410
+#define LPFC_CTL_PDEV_CTL_OFFSET        0x414
+
+/* Some SLI4 interface type-2 PDEV_CTL register bits */
+#define LPFC_CTL_PDEV_CTL_DRST          0x00000001
+#define LPFC_CTL_PDEV_CTL_FRST          0x00000002
+#define LPFC_CTL_PDEV_CTL_DD            0x00000004
+#define LPFC_CTL_PDEV_CTL_LC            0x00000008
+#define LPFC_CTL_PDEV_CTL_FRL_ALL       0x00
+#define LPFC_CTL_PDEV_CTL_FRL_FC_FCOE   0x10
+#define LPFC_CTL_PDEV_CTL_FRL_NIC       0x20
+
+#define LPFC_FW_DUMP_REQUEST    (LPFC_CTL_PDEV_CTL_DD | LPFC_CTL_PDEV_CTL_FRST)
+
 /* Active interrupt test count */
 #define LPFC_ACT_INTR_CNT       4
 
@@ -210,9 +229,26 @@ struct ulp_bde64 {
 
 struct lpfc_sli4_flags {
         uint32_t word0;
-#define lpfc_fip_flag_SHIFT 0
-#define lpfc_fip_flag_MASK 0x00000001
-#define lpfc_fip_flag_WORD word0
+#define lpfc_idx_rsrc_rdy_SHIFT         0
+#define lpfc_idx_rsrc_rdy_MASK          0x00000001
+#define lpfc_idx_rsrc_rdy_WORD          word0
+#define LPFC_IDX_RSRC_RDY               1
+#define lpfc_xri_rsrc_rdy_SHIFT         1
+#define lpfc_xri_rsrc_rdy_MASK          0x00000001
+#define lpfc_xri_rsrc_rdy_WORD          word0
+#define LPFC_XRI_RSRC_RDY               1
+#define lpfc_rpi_rsrc_rdy_SHIFT         2
+#define lpfc_rpi_rsrc_rdy_MASK          0x00000001
+#define lpfc_rpi_rsrc_rdy_WORD          word0
+#define LPFC_RPI_RSRC_RDY               1
+#define lpfc_vpi_rsrc_rdy_SHIFT         3
+#define lpfc_vpi_rsrc_rdy_MASK          0x00000001
+#define lpfc_vpi_rsrc_rdy_WORD          word0
+#define LPFC_VPI_RSRC_RDY               1
+#define lpfc_vfi_rsrc_rdy_SHIFT         4
+#define lpfc_vfi_rsrc_rdy_MASK          0x00000001
+#define lpfc_vfi_rsrc_rdy_WORD          word0
+#define LPFC_VFI_RSRC_RDY               1
 };
 
 struct sli4_bls_rsp {
@@ -739,6 +775,12 @@ union lpfc_sli4_cfg_shdr {
 #define lpfc_mbox_hdr_version_SHIFT     0
 #define lpfc_mbox_hdr_version_MASK      0x000000FF
 #define lpfc_mbox_hdr_version_WORD      word9
+#define lpfc_mbox_hdr_pf_num_SHIFT      16
+#define lpfc_mbox_hdr_pf_num_MASK       0x000000FF
+#define lpfc_mbox_hdr_pf_num_WORD       word9
+#define lpfc_mbox_hdr_vh_num_SHIFT      24
+#define lpfc_mbox_hdr_vh_num_MASK       0x000000FF
+#define lpfc_mbox_hdr_vh_num_WORD       word9
 #define LPFC_Q_CREATE_VERSION_2 2
 #define LPFC_Q_CREATE_VERSION_1 1
 #define LPFC_Q_CREATE_VERSION_0 0
@@ -766,12 +808,22 @@ union lpfc_sli4_cfg_shdr {
         } response;
 };
 
-/* Mailbox structures */
+/* Mailbox Header structures.
+ * struct mbox_header is defined for first generation SLI4_CFG mailbox
+ * calls deployed for BE-based ports.
+ *
+ * struct sli4_mbox_header is defined for second generation SLI4
+ * ports that don't deploy the SLI4_CFG mechanism.
+ */
 struct mbox_header {
         struct lpfc_sli4_cfg_mhdr cfg_mhdr;
         union  lpfc_sli4_cfg_shdr cfg_shdr;
 };
 
+#define LPFC_EXTENT_LOCAL               0
+#define LPFC_TIMEOUT_DEFAULT            0
+#define LPFC_EXTENT_VERSION_DEFAULT     0
+
 /* Subsystem Definitions */
 #define LPFC_MBOX_SUBSYSTEM_COMMON      0x1
 #define LPFC_MBOX_SUBSYSTEM_FCOE        0xC
@@ -794,6 +846,13 @@ struct mbox_header {
 #define LPFC_MBOX_OPCODE_QUERY_FW_CFG           0x3A
 #define LPFC_MBOX_OPCODE_FUNCTION_RESET         0x3D
 #define LPFC_MBOX_OPCODE_MQ_CREATE_EXT          0x5A
+#define LPFC_MBOX_OPCODE_GET_RSRC_EXTENT_INFO   0x9A
+#define LPFC_MBOX_OPCODE_GET_ALLOC_RSRC_EXTENT  0x9B
+#define LPFC_MBOX_OPCODE_ALLOC_RSRC_EXTENT      0x9C
+#define LPFC_MBOX_OPCODE_DEALLOC_RSRC_EXTENT    0x9D
+#define LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG    0xA0
+#define LPFC_MBOX_OPCODE_GET_PROFILE_CONFIG     0xA4
+#define LPFC_MBOX_OPCODE_WRITE_OBJECT           0xAC
 #define LPFC_MBOX_OPCODE_GET_SLI4_PARAMETERS    0xB5
 
 /* FCoE Opcodes */
@@ -808,6 +867,8 @@ struct mbox_header {
 #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
+#define LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_STATE           0x22
+#define LPFC_MBOX_OPCODE_FCOE_LINK_DIAG_LOOPBACK        0x23
 
 /* Mailbox command structures */
 struct eq_context {
@@ -1210,6 +1271,187 @@ struct lpfc_mbx_mq_destroy {
         } u;
 };
 
+/* Start Gen 2 SLI4 Mailbox definitions: */
+
+/* Define allocate-ready Gen 2 SLI4 FCoE Resource Extent Types. */
+#define LPFC_RSC_TYPE_FCOE_VFI  0x20
+#define LPFC_RSC_TYPE_FCOE_VPI  0x21
+#define LPFC_RSC_TYPE_FCOE_RPI  0x22
+#define LPFC_RSC_TYPE_FCOE_XRI  0x23
+
+struct lpfc_mbx_get_rsrc_extent_info {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t word4;
+#define lpfc_mbx_get_rsrc_extent_info_type_SHIFT        0
+#define lpfc_mbx_get_rsrc_extent_info_type_MASK         0x0000FFFF
+#define lpfc_mbx_get_rsrc_extent_info_type_WORD         word4
+                } req;
+                struct {
+                        uint32_t word4;
+#define lpfc_mbx_get_rsrc_extent_info_cnt_SHIFT         0
+#define lpfc_mbx_get_rsrc_extent_info_cnt_MASK          0x0000FFFF
+#define lpfc_mbx_get_rsrc_extent_info_cnt_WORD          word4
+#define lpfc_mbx_get_rsrc_extent_info_size_SHIFT        16
+#define lpfc_mbx_get_rsrc_extent_info_size_MASK         0x0000FFFF
+#define lpfc_mbx_get_rsrc_extent_info_size_WORD         word4
+                } rsp;
+        } u;
+};
+
+struct lpfc_id_range {
+        uint32_t word5;
+#define lpfc_mbx_rsrc_id_word4_0_SHIFT  0
+#define lpfc_mbx_rsrc_id_word4_0_MASK   0x0000FFFF
+#define lpfc_mbx_rsrc_id_word4_0_WORD   word5
+#define lpfc_mbx_rsrc_id_word4_1_SHIFT  16
+#define lpfc_mbx_rsrc_id_word4_1_MASK   0x0000FFFF
+#define lpfc_mbx_rsrc_id_word4_1_WORD   word5
+};
+
+struct lpfc_mbx_set_link_diag_state {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t word0;
+#define lpfc_mbx_set_diag_state_diag_SHIFT      0
+#define lpfc_mbx_set_diag_state_diag_MASK       0x00000001
+#define lpfc_mbx_set_diag_state_diag_WORD       word0
+#define lpfc_mbx_set_diag_state_link_num_SHIFT  16
+#define lpfc_mbx_set_diag_state_link_num_MASK   0x0000003F
+#define lpfc_mbx_set_diag_state_link_num_WORD   word0
+#define lpfc_mbx_set_diag_state_link_type_SHIFT 22
+#define lpfc_mbx_set_diag_state_link_type_MASK  0x00000003
+#define lpfc_mbx_set_diag_state_link_type_WORD  word0
+                } req;
+                struct {
+                        uint32_t word0;
+                } rsp;
+        } u;
+};
+
+struct lpfc_mbx_set_link_diag_loopback {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t word0;
+#define lpfc_mbx_set_diag_lpbk_type_SHIFT       0
+#define lpfc_mbx_set_diag_lpbk_type_MASK        0x00000001
+#define lpfc_mbx_set_diag_lpbk_type_WORD        word0
+#define LPFC_DIAG_LOOPBACK_TYPE_DISABLE         0x0
+#define LPFC_DIAG_LOOPBACK_TYPE_INTERNAL        0x1
+#define LPFC_DIAG_LOOPBACK_TYPE_EXTERNAL        0x2
+#define lpfc_mbx_set_diag_lpbk_link_num_SHIFT   16
+#define lpfc_mbx_set_diag_lpbk_link_num_MASK    0x0000003F
+#define lpfc_mbx_set_diag_lpbk_link_num_WORD    word0
+#define lpfc_mbx_set_diag_lpbk_link_type_SHIFT  22
+#define lpfc_mbx_set_diag_lpbk_link_type_MASK   0x00000003
+#define lpfc_mbx_set_diag_lpbk_link_type_WORD   word0
+                } req;
+                struct {
+                        uint32_t word0;
+                } rsp;
+        } u;
+};
+
+struct lpfc_mbx_run_link_diag_test {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t word0;
+#define lpfc_mbx_run_diag_test_link_num_SHIFT   16
+#define lpfc_mbx_run_diag_test_link_num_MASK    0x0000003F
+#define lpfc_mbx_run_diag_test_link_num_WORD    word0
+#define lpfc_mbx_run_diag_test_link_type_SHIFT  22
+#define lpfc_mbx_run_diag_test_link_type_MASK   0x00000003
+#define lpfc_mbx_run_diag_test_link_type_WORD   word0
+                        uint32_t word1;
+#define lpfc_mbx_run_diag_test_test_id_SHIFT    0
+#define lpfc_mbx_run_diag_test_test_id_MASK     0x0000FFFF
+#define lpfc_mbx_run_diag_test_test_id_WORD     word1
+#define lpfc_mbx_run_diag_test_loops_SHIFT      16
+#define lpfc_mbx_run_diag_test_loops_MASK       0x0000FFFF
+#define lpfc_mbx_run_diag_test_loops_WORD       word1
+                        uint32_t word2;
+#define lpfc_mbx_run_diag_test_test_ver_SHIFT   0
+#define lpfc_mbx_run_diag_test_test_ver_MASK    0x0000FFFF
+#define lpfc_mbx_run_diag_test_test_ver_WORD    word2
+#define lpfc_mbx_run_diag_test_err_act_SHIFT    16
+#define lpfc_mbx_run_diag_test_err_act_MASK     0x000000FF
+#define lpfc_mbx_run_diag_test_err_act_WORD     word2
+                } req;
+                struct {
+                        uint32_t word0;
+                } rsp;
+        } u;
+};
+
+/*
+ * struct lpfc_mbx_alloc_rsrc_extents:
+ * A mbox is generically 256 bytes long. An SLI4_CONFIG mailbox requires
+ * 6 words of header + 4 words of shared subcommand header +
+ * 1 words of Extent-Opcode-specific header = 11 words or 44 bytes total.
+ *
+ * An embedded version of SLI4_CONFIG therefore has 256 - 44 = 212 bytes
+ * for extents payload.
+ *
+ * 212/2 (bytes per extent) = 106 extents.
+ * 106/2 (extents per word) = 53 words.
+ * lpfc_id_range id is statically size to 53.
+ *
+ * This mailbox definition is used for ALLOC or GET_ALLOCATED
+ * extent ranges.  For ALLOC, the type and cnt are required.
+ * For GET_ALLOCATED, only the type is required.
+ */
+struct lpfc_mbx_alloc_rsrc_extents {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t word4;
+#define lpfc_mbx_alloc_rsrc_extents_type_SHIFT  0
+#define lpfc_mbx_alloc_rsrc_extents_type_MASK   0x0000FFFF
+#define lpfc_mbx_alloc_rsrc_extents_type_WORD   word4
+#define lpfc_mbx_alloc_rsrc_extents_cnt_SHIFT   16
+#define lpfc_mbx_alloc_rsrc_extents_cnt_MASK    0x0000FFFF
+#define lpfc_mbx_alloc_rsrc_extents_cnt_WORD    word4
+                } req;
+                struct {
+                        uint32_t word4;
+#define lpfc_mbx_rsrc_cnt_SHIFT 0
+#define lpfc_mbx_rsrc_cnt_MASK  0x0000FFFF
+#define lpfc_mbx_rsrc_cnt_WORD  word4
+                        struct lpfc_id_range id[53];
+                } rsp;
+        } u;
+};
+
+/*
+ * This is the non-embedded version of ALLOC or GET RSRC_EXTENTS. Word4 in this
+ * structure shares the same SHIFT/MASK/WORD defines provided in the
+ * mbx_alloc_rsrc_extents and mbx_get_alloc_rsrc_extents, word4, provided in
+ * the structures defined above.  This non-embedded structure provides for the
+ * maximum number of extents supported by the port.
+ */
+struct lpfc_mbx_nembed_rsrc_extent {
+        union  lpfc_sli4_cfg_shdr cfg_shdr;
+        uint32_t word4;
+        struct lpfc_id_range id;
+};
+
+struct lpfc_mbx_dealloc_rsrc_extents {
+        struct mbox_header header;
+        struct {
+                uint32_t word4;
+#define lpfc_mbx_dealloc_rsrc_extents_type_SHIFT        0
+#define lpfc_mbx_dealloc_rsrc_extents_type_MASK         0x0000FFFF
+#define lpfc_mbx_dealloc_rsrc_extents_type_WORD         word4
+        } req;
+
+};
+
+/* Start SLI4 FCoE specific mbox structures. */
+
 struct lpfc_mbx_post_hdr_tmpl {
         struct mbox_header header;
         uint32_t word10;
@@ -1229,7 +1471,7 @@ struct sli4_sge {	/* SLI-4 */
 
         uint32_t word2;
 #define lpfc_sli4_sge_offset_SHIFT      0 /* Offset of buffer - Not used*/
-#define lpfc_sli4_sge_offset_MASK       0x00FFFFFF
+#define lpfc_sli4_sge_offset_MASK       0x1FFFFFFF
 #define lpfc_sli4_sge_offset_WORD       word2
 #define lpfc_sli4_sge_last_SHIFT        31 /* Last SEG in the SGL sets
                                                 this  flag !! */
@@ -1773,61 +2015,31 @@ struct lpfc_mbx_read_rev {
 
 struct lpfc_mbx_read_config {
         uint32_t word1;
-#define lpfc_mbx_rd_conf_max_bbc_SHIFT          0
-#define lpfc_mbx_rd_conf_max_bbc_MASK           0x000000FF
-#define lpfc_mbx_rd_conf_max_bbc_WORD           word1
-#define lpfc_mbx_rd_conf_init_bbc_SHIFT         8
-#define lpfc_mbx_rd_conf_init_bbc_MASK          0x000000FF
-#define lpfc_mbx_rd_conf_init_bbc_WORD          word1
+#define lpfc_mbx_rd_conf_extnts_inuse_SHIFT     31
+#define lpfc_mbx_rd_conf_extnts_inuse_MASK      0x00000001
+#define lpfc_mbx_rd_conf_extnts_inuse_WORD      word1
         uint32_t word2;
-#define lpfc_mbx_rd_conf_nport_did_SHIFT        0
-#define lpfc_mbx_rd_conf_nport_did_MASK         0x00FFFFFF
-#define lpfc_mbx_rd_conf_nport_did_WORD         word2
 #define lpfc_mbx_rd_conf_topology_SHIFT         24
 #define lpfc_mbx_rd_conf_topology_MASK          0x000000FF
 #define lpfc_mbx_rd_conf_topology_WORD          word2
-        uint32_t word3;
-#define lpfc_mbx_rd_conf_ao_SHIFT               0
-#define lpfc_mbx_rd_conf_ao_MASK                0x00000001
-#define lpfc_mbx_rd_conf_ao_WORD                word3
-#define lpfc_mbx_rd_conf_bb_scn_SHIFT           8
-#define lpfc_mbx_rd_conf_bb_scn_MASK            0x0000000F
-#define lpfc_mbx_rd_conf_bb_scn_WORD            word3
-#define lpfc_mbx_rd_conf_cbb_scn_SHIFT          12
-#define lpfc_mbx_rd_conf_cbb_scn_MASK           0x0000000F
-#define lpfc_mbx_rd_conf_cbb_scn_WORD           word3
-#define lpfc_mbx_rd_conf_mc_SHIFT               29
-#define lpfc_mbx_rd_conf_mc_MASK                0x00000001
-#define lpfc_mbx_rd_conf_mc_WORD                word3
+        uint32_t rsvd_3;
         uint32_t word4;
 #define lpfc_mbx_rd_conf_e_d_tov_SHIFT          0
 #define lpfc_mbx_rd_conf_e_d_tov_MASK           0x0000FFFF
 #define lpfc_mbx_rd_conf_e_d_tov_WORD           word4
-        uint32_t word5;
-#define lpfc_mbx_rd_conf_lp_tov_SHIFT           0
-#define lpfc_mbx_rd_conf_lp_tov_MASK            0x0000FFFF
-#define lpfc_mbx_rd_conf_lp_tov_WORD            word5
+        uint32_t rsvd_5;
         uint32_t word6;
 #define lpfc_mbx_rd_conf_r_a_tov_SHIFT          0
 #define lpfc_mbx_rd_conf_r_a_tov_MASK           0x0000FFFF
 #define lpfc_mbx_rd_conf_r_a_tov_WORD           word6
-        uint32_t word7;
-#define lpfc_mbx_rd_conf_r_t_tov_SHIFT          0
-#define lpfc_mbx_rd_conf_r_t_tov_MASK           0x000000FF
-#define lpfc_mbx_rd_conf_r_t_tov_WORD           word7
-        uint32_t word8;
-#define lpfc_mbx_rd_conf_al_tov_SHIFT           0
-#define lpfc_mbx_rd_conf_al_tov_MASK            0x0000000F
-#define lpfc_mbx_rd_conf_al_tov_WORD            word8
+        uint32_t rsvd_7;
+        uint32_t rsvd_8;
         uint32_t word9;
 #define lpfc_mbx_rd_conf_lmt_SHIFT              0
 #define lpfc_mbx_rd_conf_lmt_MASK               0x0000FFFF
 #define lpfc_mbx_rd_conf_lmt_WORD               word9
-        uint32_t word10;
-#define lpfc_mbx_rd_conf_max_alpa_SHIFT         0
-#define lpfc_mbx_rd_conf_max_alpa_MASK          0x000000FF
-#define lpfc_mbx_rd_conf_max_alpa_WORD          word10
-        uint32_t word11_rsvd;
+        uint32_t rsvd_10;
+        uint32_t rsvd_11;
         uint32_t word12;
 #define lpfc_mbx_rd_conf_xri_base_SHIFT         0
 #define lpfc_mbx_rd_conf_xri_base_MASK          0x0000FFFF
@@ -1857,9 +2069,6 @@ struct lpfc_mbx_read_config {
 #define lpfc_mbx_rd_conf_vfi_count_MASK         0x0000FFFF
 #define lpfc_mbx_rd_conf_vfi_count_WORD         word15
         uint32_t word16;
-#define lpfc_mbx_rd_conf_fcfi_base_SHIFT        0
-#define lpfc_mbx_rd_conf_fcfi_base_MASK         0x0000FFFF
-#define lpfc_mbx_rd_conf_fcfi_base_WORD         word16
 #define lpfc_mbx_rd_conf_fcfi_count_SHIFT       16
 #define lpfc_mbx_rd_conf_fcfi_count_MASK        0x0000FFFF
 #define lpfc_mbx_rd_conf_fcfi_count_WORD        word16
@@ -2169,6 +2378,12 @@ struct lpfc_sli4_parameters {
 #define cfg_fcoe_SHIFT                          0
 #define cfg_fcoe_MASK                           0x00000001
 #define cfg_fcoe_WORD                           word12
+#define cfg_ext_SHIFT                           1
+#define cfg_ext_MASK                            0x00000001
+#define cfg_ext_WORD                            word12
+#define cfg_hdrr_SHIFT                          2
+#define cfg_hdrr_MASK                           0x00000001
+#define cfg_hdrr_WORD                           word12
 #define cfg_phwq_SHIFT                          15
 #define cfg_phwq_MASK                           0x00000001
 #define cfg_phwq_WORD                           word12
@@ -2198,6 +2413,145 @@ struct lpfc_mbx_get_sli4_parameters {
         struct lpfc_sli4_parameters sli4_parameters;
 };
 
+struct lpfc_rscr_desc_generic {
+#define LPFC_RSRC_DESC_WSIZE                    18
+        uint32_t desc[LPFC_RSRC_DESC_WSIZE];
+};
+
+struct lpfc_rsrc_desc_pcie {
+        uint32_t word0;
+#define lpfc_rsrc_desc_pcie_type_SHIFT          0
+#define lpfc_rsrc_desc_pcie_type_MASK           0x000000ff
+#define lpfc_rsrc_desc_pcie_type_WORD           word0
+#define LPFC_RSRC_DESC_TYPE_PCIE                0x40
+        uint32_t word1;
+#define lpfc_rsrc_desc_pcie_pfnum_SHIFT         0
+#define lpfc_rsrc_desc_pcie_pfnum_MASK          0x000000ff
+#define lpfc_rsrc_desc_pcie_pfnum_WORD          word1
+        uint32_t reserved;
+        uint32_t word3;
+#define lpfc_rsrc_desc_pcie_sriov_sta_SHIFT     0
+#define lpfc_rsrc_desc_pcie_sriov_sta_MASK      0x000000ff
+#define lpfc_rsrc_desc_pcie_sriov_sta_WORD      word3
+#define lpfc_rsrc_desc_pcie_pf_sta_SHIFT        8
+#define lpfc_rsrc_desc_pcie_pf_sta_MASK         0x000000ff
+#define lpfc_rsrc_desc_pcie_pf_sta_WORD         word3
+#define lpfc_rsrc_desc_pcie_pf_type_SHIFT       16
+#define lpfc_rsrc_desc_pcie_pf_type_MASK        0x000000ff
+#define lpfc_rsrc_desc_pcie_pf_type_WORD        word3
+        uint32_t word4;
+#define lpfc_rsrc_desc_pcie_nr_virtfn_SHIFT     0
+#define lpfc_rsrc_desc_pcie_nr_virtfn_MASK      0x0000ffff
+#define lpfc_rsrc_desc_pcie_nr_virtfn_WORD      word4
+};
+
+struct lpfc_rsrc_desc_fcfcoe {
+        uint32_t word0;
+#define lpfc_rsrc_desc_fcfcoe_type_SHIFT        0
+#define lpfc_rsrc_desc_fcfcoe_type_MASK         0x000000ff
+#define lpfc_rsrc_desc_fcfcoe_type_WORD         word0
+#define LPFC_RSRC_DESC_TYPE_FCFCOE              0x43
+        uint32_t word1;
+#define lpfc_rsrc_desc_fcfcoe_vfnum_SHIFT       0
+#define lpfc_rsrc_desc_fcfcoe_vfnum_MASK        0x000000ff
+#define lpfc_rsrc_desc_fcfcoe_vfnum_WORD        word1
+#define lpfc_rsrc_desc_fcfcoe_pfnum_SHIFT       16
+#define lpfc_rsrc_desc_fcfcoe_pfnum_MASK        0x000007ff
+#define lpfc_rsrc_desc_fcfcoe_pfnum_WORD        word1
+        uint32_t word2;
+#define lpfc_rsrc_desc_fcfcoe_rpi_cnt_SHIFT     0
+#define lpfc_rsrc_desc_fcfcoe_rpi_cnt_MASK      0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_rpi_cnt_WORD      word2
+#define lpfc_rsrc_desc_fcfcoe_xri_cnt_SHIFT     16
+#define lpfc_rsrc_desc_fcfcoe_xri_cnt_MASK      0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_xri_cnt_WORD      word2
+        uint32_t word3;
+#define lpfc_rsrc_desc_fcfcoe_wq_cnt_SHIFT      0
+#define lpfc_rsrc_desc_fcfcoe_wq_cnt_MASK       0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_wq_cnt_WORD       word3
+#define lpfc_rsrc_desc_fcfcoe_rq_cnt_SHIFT      16
+#define lpfc_rsrc_desc_fcfcoe_rq_cnt_MASK       0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_rq_cnt_WORD       word3
+        uint32_t word4;
+#define lpfc_rsrc_desc_fcfcoe_cq_cnt_SHIFT      0
+#define lpfc_rsrc_desc_fcfcoe_cq_cnt_MASK       0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_cq_cnt_WORD       word4
+#define lpfc_rsrc_desc_fcfcoe_vpi_cnt_SHIFT     16
+#define lpfc_rsrc_desc_fcfcoe_vpi_cnt_MASK      0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_vpi_cnt_WORD      word4
+        uint32_t word5;
+#define lpfc_rsrc_desc_fcfcoe_fcfi_cnt_SHIFT    0
+#define lpfc_rsrc_desc_fcfcoe_fcfi_cnt_MASK     0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_fcfi_cnt_WORD     word5
+#define lpfc_rsrc_desc_fcfcoe_vfi_cnt_SHIFT     16
+#define lpfc_rsrc_desc_fcfcoe_vfi_cnt_MASK      0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_vfi_cnt_WORD      word5
+        uint32_t word6;
+        uint32_t word7;
+        uint32_t word8;
+        uint32_t word9;
+        uint32_t word10;
+        uint32_t word11;
+        uint32_t word12;
+        uint32_t word13;
+#define lpfc_rsrc_desc_fcfcoe_lnk_nr_SHIFT      0
+#define lpfc_rsrc_desc_fcfcoe_lnk_nr_MASK       0x0000003f
+#define lpfc_rsrc_desc_fcfcoe_lnk_nr_WORD       word13
+#define lpfc_rsrc_desc_fcfcoe_lnk_tp_SHIFT      6
+#define lpfc_rsrc_desc_fcfcoe_lnk_tp_MASK       0x00000003
+#define lpfc_rsrc_desc_fcfcoe_lnk_tp_WORD       word13
+#define lpfc_rsrc_desc_fcfcoe_lmc_SHIFT         8
+#define lpfc_rsrc_desc_fcfcoe_lmc_MASK          0x00000001
+#define lpfc_rsrc_desc_fcfcoe_lmc_WORD          word13
+#define lpfc_rsrc_desc_fcfcoe_lld_SHIFT         9
+#define lpfc_rsrc_desc_fcfcoe_lld_MASK          0x00000001
+#define lpfc_rsrc_desc_fcfcoe_lld_WORD          word13
+#define lpfc_rsrc_desc_fcfcoe_eq_cnt_SHIFT      16
+#define lpfc_rsrc_desc_fcfcoe_eq_cnt_MASK       0x0000ffff
+#define lpfc_rsrc_desc_fcfcoe_eq_cnt_WORD       word13
+};
+
+struct lpfc_func_cfg {
+#define LPFC_RSRC_DESC_MAX_NUM                  2
+        uint32_t rsrc_desc_count;
+        struct lpfc_rscr_desc_generic desc[LPFC_RSRC_DESC_MAX_NUM];
+};
+
+struct lpfc_mbx_get_func_cfg {
+        struct mbox_header header;
+#define LPFC_CFG_TYPE_PERSISTENT_OVERRIDE       0x0
+#define LPFC_CFG_TYPE_FACTURY_DEFAULT           0x1
+#define LPFC_CFG_TYPE_CURRENT_ACTIVE            0x2
+        struct lpfc_func_cfg func_cfg;
+};
+
+struct lpfc_prof_cfg {
+#define LPFC_RSRC_DESC_MAX_NUM                  2
+        uint32_t rsrc_desc_count;
+        struct lpfc_rscr_desc_generic desc[LPFC_RSRC_DESC_MAX_NUM];
+};
+
+struct lpfc_mbx_get_prof_cfg {
+        struct mbox_header header;
+#define LPFC_CFG_TYPE_PERSISTENT_OVERRIDE       0x0
+#define LPFC_CFG_TYPE_FACTURY_DEFAULT           0x1
+#define LPFC_CFG_TYPE_CURRENT_ACTIVE            0x2
+        union {
+                struct {
+                        uint32_t word10;
+#define lpfc_mbx_get_prof_cfg_prof_id_SHIFT     0
+#define lpfc_mbx_get_prof_cfg_prof_id_MASK      0x000000ff
+#define lpfc_mbx_get_prof_cfg_prof_id_WORD      word10
+#define lpfc_mbx_get_prof_cfg_prof_tp_SHIFT     8
+#define lpfc_mbx_get_prof_cfg_prof_tp_MASK      0x00000003
+#define lpfc_mbx_get_prof_cfg_prof_tp_WORD      word10
+                } request;
+                struct {
+                        struct lpfc_prof_cfg prof_cfg;
+                } response;
+        } u;
+};
+
 /* Mailbox Completion Queue Error Messages */
 #define MB_CQE_STATUS_SUCCESS                   0x0
 #define MB_CQE_STATUS_INSUFFICIENT_PRIVILEGES   0x1
@@ -2206,6 +2560,29 @@ struct lpfc_mbx_get_sli4_parameters {
 #define MB_CEQ_STATUS_QUEUE_FLUSHING            0x4
 #define MB_CQE_STATUS_DMA_FAILED                0x5
 
+#define LPFC_MBX_WR_CONFIG_MAX_BDE              8
+struct lpfc_mbx_wr_object {
+        struct mbox_header header;
+        union {
+                struct {
+                        uint32_t word4;
+#define lpfc_wr_object_eof_SHIFT                31
+#define lpfc_wr_object_eof_MASK                 0x00000001
+#define lpfc_wr_object_eof_WORD                 word4
+#define lpfc_wr_object_write_length_SHIFT       0
+#define lpfc_wr_object_write_length_MASK        0x00FFFFFF
+#define lpfc_wr_object_write_length_WORD        word4
+                        uint32_t write_offset;
+                        uint32_t object_name[26];
+                        uint32_t bde_count;
+                        struct ulp_bde64 bde[LPFC_MBX_WR_CONFIG_MAX_BDE];
+                } request;
+                struct {
+                        uint32_t actual_write_length;
+                } response;
+        } u;
+};
+
 /* mailbox queue entry structure */
 struct lpfc_mqe {
         uint32_t word0;
@@ -2241,6 +2618,9 @@ struct lpfc_mqe {
                 struct lpfc_mbx_cq_destroy cq_destroy;
                 struct lpfc_mbx_wq_destroy wq_destroy;
                 struct lpfc_mbx_rq_destroy rq_destroy;
+                struct lpfc_mbx_get_rsrc_extent_info rsrc_extent_info;
+                struct lpfc_mbx_alloc_rsrc_extents alloc_rsrc_extents;
+                struct lpfc_mbx_dealloc_rsrc_extents dealloc_rsrc_extents;
                 struct lpfc_mbx_post_sgl_pages post_sgl_pages;
                 struct lpfc_mbx_nembed_cmd nembed_cmd;
                 struct lpfc_mbx_read_rev read_rev;
@@ -2252,7 +2632,13 @@ struct lpfc_mqe {
                 struct lpfc_mbx_supp_pages supp_pages;
                 struct lpfc_mbx_pc_sli4_params sli4_params;
                 struct lpfc_mbx_get_sli4_parameters get_sli4_parameters;
+                struct lpfc_mbx_set_link_diag_state link_diag_state;
+                struct lpfc_mbx_set_link_diag_loopback link_diag_loopback;
+                struct lpfc_mbx_run_link_diag_test link_diag_test;
+                struct lpfc_mbx_get_func_cfg get_func_cfg;
+                struct lpfc_mbx_get_prof_cfg get_prof_cfg;
                 struct lpfc_mbx_nop nop;
+                struct lpfc_mbx_wr_object wr_object;
         } un;
 };
 
@@ -2458,7 +2844,7 @@ struct lpfc_bmbx_create {
 #define SGL_ALIGN_SZ 64
 #define SGL_PAGE_SIZE 4096
 /* align SGL addr on a size boundary - adjust address up */
-#define NO_XRI  ((uint16_t)-1)
+#define NO_XRI  0xffff
 
 struct wqe_common {
         uint32_t word6;
@@ -2798,9 +3184,28 @@ union lpfc_wqe {
         struct gen_req64_wqe gen_req;
 };
 
+#define LPFC_GROUP_OJECT_MAGIC_NUM              0xfeaa0001
+#define LPFC_FILE_TYPE_GROUP                    0xf7
+#define LPFC_FILE_ID_GROUP                      0xa2
+struct lpfc_grp_hdr {
+        uint32_t size;
+        uint32_t magic_number;
+        uint32_t word2;
+#define lpfc_grp_hdr_file_type_SHIFT    24
+#define lpfc_grp_hdr_file_type_MASK     0x000000FF
+#define lpfc_grp_hdr_file_type_WORD     word2
+#define lpfc_grp_hdr_id_SHIFT           16
+#define lpfc_grp_hdr_id_MASK            0x000000FF
+#define lpfc_grp_hdr_id_WORD            word2
+        uint8_t rev_name[128];
+};
+
 #define FCP_COMMAND 0x0
 #define FCP_COMMAND_DATA_OUT 0x1
 #define ELS_COMMAND_NON_FIP 0xC
 #define ELS_COMMAND_FIP 0xD
 #define OTHER_COMMAND 0x8
 
+#define LPFC_FW_DUMP    1
+#define LPFC_FW_RESET   2
+#define LPFC_DV_RESET   3
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 7dda036a1af3..148b98ddbb1d 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -30,6 +30,7 @@
 #include <linux/ctype.h>
 #include <linux/aer.h>
 #include <linux/slab.h>
+#include <linux/firmware.h>
 
 #include <scsi/scsi.h>
 #include <scsi/scsi_device.h>
@@ -211,7 +212,6 @@ lpfc_config_port_prep(struct lpfc_hba *phba)
         lpfc_vpd_data = kmalloc(DMP_VPD_SIZE, GFP_KERNEL);
         if (!lpfc_vpd_data)
                 goto out_free_mbox;
-
         do {
                 lpfc_dump_mem(phba, pmb, offset, DMP_REGION_VPD);
                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
@@ -309,6 +309,45 @@ lpfc_dump_wakeup_param_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmboxq)
 }
 
 /**
+ * lpfc_update_vport_wwn - Updates the fc_nodename, fc_portname,
+ *      cfg_soft_wwnn, cfg_soft_wwpn
+ * @vport: pointer to lpfc vport data structure.
+ *
+ *
+ * Return codes
+ *   None.
+ **/
+void
+lpfc_update_vport_wwn(struct lpfc_vport *vport)
+{
+        /* If the soft name exists then update it using the service params */
+        if (vport->phba->cfg_soft_wwnn)
+                u64_to_wwn(vport->phba->cfg_soft_wwnn,
+                           vport->fc_sparam.nodeName.u.wwn);
+        if (vport->phba->cfg_soft_wwpn)
+                u64_to_wwn(vport->phba->cfg_soft_wwpn,
+                           vport->fc_sparam.portName.u.wwn);
+
+        /*
+         * If the name is empty or there exists a soft name
+         * then copy the service params name, otherwise use the fc name
+         */
+        if (vport->fc_nodename.u.wwn[0] == 0 || vport->phba->cfg_soft_wwnn)
+                memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
+                        sizeof(struct lpfc_name));
+        else
+                memcpy(&vport->fc_sparam.nodeName, &vport->fc_nodename,
+                        sizeof(struct lpfc_name));
+
+        if (vport->fc_portname.u.wwn[0] == 0 || vport->phba->cfg_soft_wwpn)
+                memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
+                        sizeof(struct lpfc_name));
+        else
+                memcpy(&vport->fc_sparam.portName, &vport->fc_portname,
+                        sizeof(struct lpfc_name));
+}
+
+/**
  * lpfc_config_port_post - Perform lpfc initialization after config port
  * @phba: pointer to lpfc hba data structure.
  *
@@ -377,17 +416,7 @@ lpfc_config_port_post(struct lpfc_hba *phba)
         lpfc_mbuf_free(phba, mp->virt, mp->phys);
         kfree(mp);
         pmb->context1 = NULL;
-
-        if (phba->cfg_soft_wwnn)
-                u64_to_wwn(phba->cfg_soft_wwnn,
-                           vport->fc_sparam.nodeName.u.wwn);
-        if (phba->cfg_soft_wwpn)
-                u64_to_wwn(phba->cfg_soft_wwpn,
-                           vport->fc_sparam.portName.u.wwn);
-        memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
-               sizeof (struct lpfc_name));
-        memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
-               sizeof (struct lpfc_name));
+        lpfc_update_vport_wwn(vport);
 
         /* Update the fc_host data structures with new wwn. */
         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
@@ -573,7 +602,6 @@ lpfc_config_port_post(struct lpfc_hba *phba)
                         /* 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);
@@ -1755,7 +1783,9 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
                 && descp && descp[0] != '\0')
                 return;
 
-        if (phba->lmt & LMT_10Gb)
+        if (phba->lmt & LMT_16Gb)
+                max_speed = 16;
+        else if (phba->lmt & LMT_10Gb)
                 max_speed = 10;
         else if (phba->lmt & LMT_8Gb)
                 max_speed = 8;
@@ -1922,12 +1952,13 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
                                 "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_LANCER_FC:
-                oneConnect = 1;
-                m = (typeof(m)){"Undefined", "PCIe", "Fibre Channel Adapter"};
+        case PCI_DEVICE_ID_LANCER_FC_VF:
+                m = (typeof(m)){"LPe16000", "PCIe", "Fibre Channel Adapter"};
                 break;
         case PCI_DEVICE_ID_LANCER_FCOE:
+        case PCI_DEVICE_ID_LANCER_FCOE_VF:
                 oneConnect = 1;
-                m = (typeof(m)){"Undefined", "PCIe", "FCoE"};
+                m = (typeof(m)){"OCe50100", "PCIe", "FCoE"};
                 break;
         default:
                 m = (typeof(m)){"Unknown", "", ""};
@@ -1936,7 +1967,8 @@ lpfc_get_hba_model_desc(struct lpfc_hba *phba, uint8_t *mdp, uint8_t *descp)
 
         if (mdp && mdp[0] == '\0')
                 snprintf(mdp, 79,"%s", m.name);
-        /* oneConnect hba requires special processing, they are all initiators
+        /*
+         * oneConnect hba requires special processing, they are all initiators
          * and we put the port number on the end
          */
         if (descp && descp[0] == '\0') {
@@ -2656,6 +2688,7 @@ lpfc_scsi_free(struct lpfc_hba *phba)
                 kfree(io);
                 phba->total_iocbq_bufs--;
         }
+
         spin_unlock_irq(&phba->hbalock);
         return 0;
 }
@@ -3612,6 +3645,7 @@ lpfc_sli4_async_fip_evt(struct lpfc_hba *phba,
                 lpfc_printf_log(phba, KERN_ERR, LOG_FIP | LOG_DISCOVERY,
                         "2718 Clear Virtual Link Received for VPI 0x%x"
                         " tag 0x%x\n", acqe_fip->index, acqe_fip->event_tag);
+
                 vport = lpfc_find_vport_by_vpid(phba,
                                 acqe_fip->index - phba->vpi_base);
                 ndlp = lpfc_sli4_perform_vport_cvl(vport);
@@ -3935,6 +3969,10 @@ lpfc_enable_pci_dev(struct lpfc_hba *phba)
         pci_try_set_mwi(pdev);
         pci_save_state(pdev);
 
+        /* PCIe EEH recovery on powerpc platforms needs fundamental reset */
+        if (pci_find_capability(pdev, PCI_CAP_ID_EXP))
+                pdev->needs_freset = 1;
+
         return 0;
 
 out_disable_device:
@@ -3997,6 +4035,36 @@ lpfc_reset_hba(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli_probe_sriov_nr_virtfn - Enable a number of sr-iov virtual functions
+ * @phba: pointer to lpfc hba data structure.
+ * @nr_vfn: number of virtual functions to be enabled.
+ *
+ * This function enables the PCI SR-IOV virtual functions to a physical
+ * function. It invokes the PCI SR-IOV api with the @nr_vfn provided to
+ * enable the number of virtual functions to the physical function. As
+ * not all devices support SR-IOV, the return code from the pci_enable_sriov()
+ * API call does not considered as an error condition for most of the device.
+ **/
+int
+lpfc_sli_probe_sriov_nr_virtfn(struct lpfc_hba *phba, int nr_vfn)
+{
+        struct pci_dev *pdev = phba->pcidev;
+        int rc;
+
+        rc = pci_enable_sriov(pdev, nr_vfn);
+        if (rc) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
+                                "2806 Failed to enable sriov on this device "
+                                "with vfn number nr_vf:%d, rc:%d\n",
+                                nr_vfn, rc);
+        } else
+                lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
+                                "2807 Successful enable sriov on this device "
+                                "with vfn number nr_vf:%d\n", nr_vfn);
+        return rc;
+}
+
+/**
  * lpfc_sli_driver_resource_setup - Setup driver internal resources for SLI3 dev.
  * @phba: pointer to lpfc hba data structure.
  *
@@ -4011,6 +4079,7 @@ static int
 lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
 {
         struct lpfc_sli *psli;
+        int rc;
 
         /*
          * Initialize timers used by driver
@@ -4085,6 +4154,23 @@ lpfc_sli_driver_resource_setup(struct lpfc_hba *phba)
         if (lpfc_mem_alloc(phba, BPL_ALIGN_SZ))
                 return -ENOMEM;
 
+        /*
+         * Enable sr-iov virtual functions if supported and configured
+         * through the module parameter.
+         */
+        if (phba->cfg_sriov_nr_virtfn > 0) {
+                rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
+                                                 phba->cfg_sriov_nr_virtfn);
+                if (rc) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
+                                        "2808 Requested number of SR-IOV "
+                                        "virtual functions (%d) is not "
+                                        "supported\n",
+                                        phba->cfg_sriov_nr_virtfn);
+                        phba->cfg_sriov_nr_virtfn = 0;
+                }
+        }
+
         return 0;
 }
 
@@ -4161,6 +4247,14 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         phba->fcf.redisc_wait.data = (unsigned long)phba;
 
         /*
+         * Control structure for handling external multi-buffer mailbox
+         * command pass-through.
+         */
+        memset((uint8_t *)&phba->mbox_ext_buf_ctx, 0,
+                sizeof(struct lpfc_mbox_ext_buf_ctx));
+        INIT_LIST_HEAD(&phba->mbox_ext_buf_ctx.ext_dmabuf_list);
+
+        /*
          * We need to do a READ_CONFIG mailbox command here before
          * calling lpfc_get_cfgparam. For VFs this will report the
          * MAX_XRI, MAX_VPI, MAX_RPI, MAX_IOCB, and MAX_VFI settings.
@@ -4233,7 +4327,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         spin_lock_init(&phba->sli4_hba.abts_sgl_list_lock);
 
         /*
-         * Initialize dirver internal slow-path work queues
+         * Initialize driver internal slow-path work queues
          */
 
         /* Driver internel slow-path CQ Event pool */
@@ -4249,6 +4343,12 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         /* Receive queue CQ Event work queue list */
         INIT_LIST_HEAD(&phba->sli4_hba.sp_unsol_work_queue);
 
+        /* Initialize extent block lists. */
+        INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_blk_list);
+        INIT_LIST_HEAD(&phba->sli4_hba.lpfc_xri_blk_list);
+        INIT_LIST_HEAD(&phba->sli4_hba.lpfc_vfi_blk_list);
+        INIT_LIST_HEAD(&phba->lpfc_vpi_blk_list);
+
         /* Initialize the driver internal SLI layer lists. */
         lpfc_sli_setup(phba);
         lpfc_sli_queue_setup(phba);
@@ -4323,9 +4423,19 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
         }
         /*
          * Get sli4 parameters that override parameters from Port capabilities.
-         * If this call fails it is not a critical error so continue loading.
+         * If this call fails, it isn't critical unless the SLI4 parameters come
+         * back in conflict.
          */
-        lpfc_get_sli4_parameters(phba, mboxq);
+        rc = lpfc_get_sli4_parameters(phba, mboxq);
+        if (rc) {
+                if (phba->sli4_hba.extents_in_use &&
+                    phba->sli4_hba.rpi_hdrs_in_use) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "2999 Unsupported SLI4 Parameters "
+                                "Extents and RPI headers enabled.\n");
+                        goto out_free_bsmbx;
+                }
+        }
         mempool_free(mboxq, phba->mbox_mem_pool);
         /* Create all the SLI4 queues */
         rc = lpfc_sli4_queue_create(phba);
@@ -4350,7 +4460,6 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                                 "1430 Failed to initialize sgl list.\n");
                 goto out_free_sgl_list;
         }
-
         rc = lpfc_sli4_init_rpi_hdrs(phba);
         if (rc) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -4366,6 +4475,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "2759 Failed allocate memory for FCF round "
                                 "robin failover bmask\n");
+                rc = -ENOMEM;
                 goto out_remove_rpi_hdrs;
         }
 
@@ -4375,6 +4485,7 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "2572 Failed allocate memory for fast-path "
                                 "per-EQ handle array\n");
+                rc = -ENOMEM;
                 goto out_free_fcf_rr_bmask;
         }
 
@@ -4384,9 +4495,27 @@ lpfc_sli4_driver_resource_setup(struct lpfc_hba *phba)
                 lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                 "2573 Failed allocate memory for msi-x "
                                 "interrupt vector entries\n");
+                rc = -ENOMEM;
                 goto out_free_fcp_eq_hdl;
         }
 
+        /*
+         * Enable sr-iov virtual functions if supported and configured
+         * through the module parameter.
+         */
+        if (phba->cfg_sriov_nr_virtfn > 0) {
+                rc = lpfc_sli_probe_sriov_nr_virtfn(phba,
+                                                 phba->cfg_sriov_nr_virtfn);
+                if (rc) {
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
+                                        "3020 Requested number of SR-IOV "
+                                        "virtual functions (%d) is not "
+                                        "supported\n",
+                                        phba->cfg_sriov_nr_virtfn);
+                        phba->cfg_sriov_nr_virtfn = 0;
+                }
+        }
+
         return rc;
 
 out_free_fcp_eq_hdl:
@@ -4449,6 +4578,9 @@ lpfc_sli4_driver_resource_unset(struct lpfc_hba *phba)
         lpfc_sli4_cq_event_release_all(phba);
         lpfc_sli4_cq_event_pool_destroy(phba);
 
+        /* Release resource identifiers. */
+        lpfc_sli4_dealloc_resource_identifiers(phba);
+
         /* Free the bsmbx region. */
         lpfc_destroy_bootstrap_mbox(phba);
 
@@ -4649,6 +4781,7 @@ lpfc_init_iocb_list(struct lpfc_hba *phba, int iocb_count)
                                 "Unloading driver.\n", __func__);
                         goto out_free_iocbq;
                 }
+                iocbq_entry->sli4_lxritag = NO_XRI;
                 iocbq_entry->sli4_xritag = NO_XRI;
 
                 spin_lock_irq(&phba->hbalock);
@@ -4746,7 +4879,7 @@ lpfc_init_sgl_list(struct lpfc_hba *phba)
 
         els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
         lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                                "2400 lpfc_init_sgl_list els %d.\n",
+                                "2400 ELS XRI count %d.\n",
                                 els_xri_cnt);
         /* Initialize and populate the sglq list per host/VF. */
         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_sgl_list);
@@ -4779,7 +4912,6 @@ lpfc_init_sgl_list(struct lpfc_hba *phba)
         phba->sli4_hba.scsi_xri_max =
                         phba->sli4_hba.max_cfg_param.max_xri - els_xri_cnt;
         phba->sli4_hba.scsi_xri_cnt = 0;
-
         phba->sli4_hba.lpfc_scsi_psb_array =
                         kzalloc((sizeof(struct lpfc_scsi_buf *) *
                         phba->sli4_hba.scsi_xri_max), GFP_KERNEL);
@@ -4802,13 +4934,6 @@ lpfc_init_sgl_list(struct lpfc_hba *phba)
                         goto out_free_mem;
                 }
 
-                sglq_entry->sli4_xritag = lpfc_sli4_next_xritag(phba);
-                if (sglq_entry->sli4_xritag == NO_XRI) {
-                        kfree(sglq_entry);
-                        printk(KERN_ERR "%s: failed to allocate XRI.\n"
-                                "Unloading driver.\n", __func__);
-                        goto out_free_mem;
-                }
                 sglq_entry->buff_type = GEN_BUFF_TYPE;
                 sglq_entry->virt = lpfc_mbuf_alloc(phba, 0, &sglq_entry->phys);
                 if (sglq_entry->virt == NULL) {
@@ -4857,24 +4982,20 @@ int
 lpfc_sli4_init_rpi_hdrs(struct lpfc_hba *phba)
 {
         int rc = 0;
-        int longs;
-        uint16_t rpi_count;
         struct lpfc_rpi_hdr *rpi_hdr;
 
         INIT_LIST_HEAD(&phba->sli4_hba.lpfc_rpi_hdr_list);
-
         /*
-         * Provision an rpi bitmask range for discovery. The total count
-         * is the difference between max and base + 1.
+         * If the SLI4 port supports extents, posting the rpi header isn't
+         * required.  Set the expected maximum count and let the actual value
+         * get set when extents are fully allocated.
          */
-        rpi_count = phba->sli4_hba.max_cfg_param.rpi_base +
-                    phba->sli4_hba.max_cfg_param.max_rpi - 1;
-
-        longs = ((rpi_count) + BITS_PER_LONG - 1) / BITS_PER_LONG;
-        phba->sli4_hba.rpi_bmask = kzalloc(longs * sizeof(unsigned long),
-                                           GFP_KERNEL);
-        if (!phba->sli4_hba.rpi_bmask)
-                return -ENOMEM;
+        if (!phba->sli4_hba.rpi_hdrs_in_use) {
+                phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.max_rpi;
+                return rc;
+        }
+        if (phba->sli4_hba.extents_in_use)
+                return -EIO;
 
         rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
         if (!rpi_hdr) {
@@ -4908,11 +5029,28 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         struct lpfc_rpi_hdr *rpi_hdr;
         uint32_t rpi_count;
 
+        /*
+         * If the SLI4 port supports extents, posting the rpi header isn't
+         * required.  Set the expected maximum count and let the actual value
+         * get set when extents are fully allocated.
+         */
+        if (!phba->sli4_hba.rpi_hdrs_in_use)
+                return NULL;
+        if (phba->sli4_hba.extents_in_use)
+                return NULL;
+
+        /* The limit on the logical index is just the max_rpi count. */
         rpi_limit = phba->sli4_hba.max_cfg_param.rpi_base +
-                    phba->sli4_hba.max_cfg_param.max_rpi - 1;
+        phba->sli4_hba.max_cfg_param.max_rpi - 1;
 
         spin_lock_irq(&phba->hbalock);
-        curr_rpi_range = phba->sli4_hba.next_rpi;
+        /*
+         * Establish the starting RPI in this header block.  The starting
+         * rpi is normalized to a zero base because the physical rpi is
+         * port based.
+         */
+        curr_rpi_range = phba->sli4_hba.next_rpi -
+                phba->sli4_hba.max_cfg_param.rpi_base;
         spin_unlock_irq(&phba->hbalock);
 
         /*
@@ -4925,6 +5063,8 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         else
                 rpi_count = LPFC_RPI_HDR_COUNT;
 
+        if (!rpi_count)
+                return NULL;
         /*
          * First allocate the protocol header region for the port.  The
          * port expects a 4KB DMA-mapped memory region that is 4K aligned.
@@ -4957,12 +5097,14 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         rpi_hdr->len = LPFC_HDR_TEMPLATE_SIZE;
         rpi_hdr->page_count = 1;
         spin_lock_irq(&phba->hbalock);
-        rpi_hdr->start_rpi = phba->sli4_hba.next_rpi;
+
+        /* The rpi_hdr stores the logical index only. */
+        rpi_hdr->start_rpi = curr_rpi_range;
         list_add_tail(&rpi_hdr->list, &phba->sli4_hba.lpfc_rpi_hdr_list);
 
         /*
-         * The next_rpi stores the next module-64 rpi value to post
-         * in any subsequent rpi memory region postings.
+         * The next_rpi stores the next logical module-64 rpi value used
+         * to post physical rpis in subsequent rpi postings.
          */
         phba->sli4_hba.next_rpi += rpi_count;
         spin_unlock_irq(&phba->hbalock);
@@ -4981,15 +5123,18 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
  * @phba: pointer to lpfc hba data structure.
  *
  * This routine is invoked to remove all memory resources allocated
- * to support rpis. This routine presumes the caller has released all
- * rpis consumed by fabric or port logins and is prepared to have
- * the header pages removed.
+ * to support rpis for SLI4 ports not supporting extents. This routine
+ * presumes the caller has released all rpis consumed by fabric or port
+ * logins and is prepared to have the header pages removed.
  **/
 void
 lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
 {
         struct lpfc_rpi_hdr *rpi_hdr, *next_rpi_hdr;
 
+        if (!phba->sli4_hba.rpi_hdrs_in_use)
+                goto exit;
+
         list_for_each_entry_safe(rpi_hdr, next_rpi_hdr,
                                  &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
                 list_del(&rpi_hdr->list);
@@ -4998,9 +5143,9 @@ lpfc_sli4_remove_rpi_hdrs(struct lpfc_hba *phba)
                 kfree(rpi_hdr->dmabuf);
                 kfree(rpi_hdr);
         }
-
-        phba->sli4_hba.next_rpi = phba->sli4_hba.max_cfg_param.rpi_base;
-        memset(phba->sli4_hba.rpi_bmask, 0, sizeof(*phba->sli4_hba.rpi_bmask));
+ exit:
+        /* There are no rpis available to the port now. */
+        phba->sli4_hba.next_rpi = 0;
 }
 
 /**
@@ -5487,7 +5632,8 @@ lpfc_sli4_post_status_check(struct lpfc_hba *phba)
                         /* Final checks.  The port status should be clean. */
                         if (lpfc_readl(phba->sli4_hba.u.if_type2.STATUSregaddr,
                                 &reg_data.word0) ||
-                                bf_get(lpfc_sliport_status_err, &reg_data)) {
+                                (bf_get(lpfc_sliport_status_err, &reg_data) &&
+                                 !bf_get(lpfc_sliport_status_rn, &reg_data))) {
                                 phba->work_status[0] =
                                         readl(phba->sli4_hba.u.if_type2.
                                               ERR1regaddr);
@@ -5741,7 +5887,12 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
 {
         LPFC_MBOXQ_t *pmb;
         struct lpfc_mbx_read_config *rd_config;
-        uint32_t rc = 0;
+        union  lpfc_sli4_cfg_shdr *shdr;
+        uint32_t shdr_status, shdr_add_status;
+        struct lpfc_mbx_get_func_cfg *get_func_cfg;
+        struct lpfc_rsrc_desc_fcfcoe *desc;
+        uint32_t desc_count;
+        int length, i, rc = 0;
 
         pmb = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!pmb) {
@@ -5763,6 +5914,8 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
                 rc = -EIO;
         } else {
                 rd_config = &pmb->u.mqe.un.rd_config;
+                phba->sli4_hba.extents_in_use =
+                        bf_get(lpfc_mbx_rd_conf_extnts_inuse, rd_config);
                 phba->sli4_hba.max_cfg_param.max_xri =
                         bf_get(lpfc_mbx_rd_conf_xri_count, rd_config);
                 phba->sli4_hba.max_cfg_param.xri_base =
@@ -5781,8 +5934,6 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
                         bf_get(lpfc_mbx_rd_conf_vfi_base, rd_config);
                 phba->sli4_hba.max_cfg_param.max_fcfi =
                         bf_get(lpfc_mbx_rd_conf_fcfi_count, rd_config);
-                phba->sli4_hba.max_cfg_param.fcfi_base =
-                        bf_get(lpfc_mbx_rd_conf_fcfi_base, rd_config);
                 phba->sli4_hba.max_cfg_param.max_eq =
                         bf_get(lpfc_mbx_rd_conf_eq_count, rd_config);
                 phba->sli4_hba.max_cfg_param.max_rq =
@@ -5800,11 +5951,13 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
                                 (phba->sli4_hba.max_cfg_param.max_vpi - 1) : 0;
                 phba->max_vports = phba->max_vpi;
                 lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
-                                "2003 cfg params XRI(B:%d M:%d), "
+                                "2003 cfg params Extents? %d "
+                                "XRI(B:%d M:%d), "
                                 "VPI(B:%d M:%d) "
                                 "VFI(B:%d M:%d) "
                                 "RPI(B:%d M:%d) "
-                                "FCFI(B:%d M:%d)\n",
+                                "FCFI(Count:%d)\n",
+                                phba->sli4_hba.extents_in_use,
                                 phba->sli4_hba.max_cfg_param.xri_base,
                                 phba->sli4_hba.max_cfg_param.max_xri,
                                 phba->sli4_hba.max_cfg_param.vpi_base,
@@ -5813,10 +5966,11 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
                                 phba->sli4_hba.max_cfg_param.max_vfi,
                                 phba->sli4_hba.max_cfg_param.rpi_base,
                                 phba->sli4_hba.max_cfg_param.max_rpi,
-                                phba->sli4_hba.max_cfg_param.fcfi_base,
                                 phba->sli4_hba.max_cfg_param.max_fcfi);
         }
-        mempool_free(pmb, phba->mbox_mem_pool);
+
+        if (rc)
+                goto read_cfg_out;
 
         /* Reset the DFT_HBA_Q_DEPTH to the max xri  */
         if (phba->cfg_hba_queue_depth >
@@ -5825,6 +5979,65 @@ lpfc_sli4_read_config(struct lpfc_hba *phba)
                 phba->cfg_hba_queue_depth =
                         phba->sli4_hba.max_cfg_param.max_xri -
                                 lpfc_sli4_get_els_iocb_cnt(phba);
+
+        if (bf_get(lpfc_sli_intf_if_type, &phba->sli4_hba.sli_intf) !=
+            LPFC_SLI_INTF_IF_TYPE_2)
+                goto read_cfg_out;
+
+        /* get the pf# and vf# for SLI4 if_type 2 port */
+        length = (sizeof(struct lpfc_mbx_get_func_cfg) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, pmb, LPFC_MBOX_SUBSYSTEM_COMMON,
+                         LPFC_MBOX_OPCODE_GET_FUNCTION_CONFIG,
+                         length, LPFC_SLI4_MBX_EMBED);
+
+        rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
+        shdr = (union lpfc_sli4_cfg_shdr *)
+                                &pmb->u.mqe.un.sli4_config.header.cfg_shdr;
+        shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
+        if (rc || shdr_status || shdr_add_status) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "3026 Mailbox failed , mbxCmd x%x "
+                                "GET_FUNCTION_CONFIG, mbxStatus x%x\n",
+                                bf_get(lpfc_mqe_command, &pmb->u.mqe),
+                                bf_get(lpfc_mqe_status, &pmb->u.mqe));
+                rc = -EIO;
+                goto read_cfg_out;
+        }
+
+        /* search for fc_fcoe resrouce descriptor */
+        get_func_cfg = &pmb->u.mqe.un.get_func_cfg;
+        desc_count = get_func_cfg->func_cfg.rsrc_desc_count;
+
+        for (i = 0; i < LPFC_RSRC_DESC_MAX_NUM; i++) {
+                desc = (struct lpfc_rsrc_desc_fcfcoe *)
+                        &get_func_cfg->func_cfg.desc[i];
+                if (LPFC_RSRC_DESC_TYPE_FCFCOE ==
+                    bf_get(lpfc_rsrc_desc_pcie_type, desc)) {
+                        phba->sli4_hba.iov.pf_number =
+                                bf_get(lpfc_rsrc_desc_fcfcoe_pfnum, desc);
+                        phba->sli4_hba.iov.vf_number =
+                                bf_get(lpfc_rsrc_desc_fcfcoe_vfnum, desc);
+                        break;
+                }
+        }
+
+        if (i < LPFC_RSRC_DESC_MAX_NUM)
+                lpfc_printf_log(phba, KERN_INFO, LOG_SLI,
+                                "3027 GET_FUNCTION_CONFIG: pf_number:%d, "
+                                "vf_number:%d\n", phba->sli4_hba.iov.pf_number,
+                                phba->sli4_hba.iov.vf_number);
+        else {
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                "3028 GET_FUNCTION_CONFIG: failed to find "
+                                "Resrouce Descriptor:x%x\n",
+                                LPFC_RSRC_DESC_TYPE_FCFCOE);
+                rc = -EIO;
+        }
+
+read_cfg_out:
+        mempool_free(pmb, phba->mbox_mem_pool);
         return rc;
 }
 
@@ -6229,8 +6442,10 @@ lpfc_sli4_queue_destroy(struct lpfc_hba *phba)
         phba->sli4_hba.mbx_cq = NULL;
 
         /* Release FCP response complete queue */
-        for (fcp_qidx = 0; fcp_qidx < phba->cfg_fcp_eq_count; fcp_qidx++)
+        fcp_qidx = 0;
+        do
                 lpfc_sli4_queue_free(phba->sli4_hba.fcp_cq[fcp_qidx]);
+        while (++fcp_qidx < phba->cfg_fcp_eq_count);
         kfree(phba->sli4_hba.fcp_cq);
         phba->sli4_hba.fcp_cq = NULL;
 
@@ -6353,16 +6568,24 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                         phba->sli4_hba.sp_eq->queue_id);
 
         /* Set up fast-path FCP Response Complete Queue */
-        for (fcp_cqidx = 0; fcp_cqidx < phba->cfg_fcp_eq_count; fcp_cqidx++) {
+        fcp_cqidx = 0;
+        do {
                 if (!phba->sli4_hba.fcp_cq[fcp_cqidx]) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                         "0526 Fast-path FCP CQ (%d) not "
                                         "allocated\n", fcp_cqidx);
                         goto out_destroy_fcp_cq;
                 }
-                rc = lpfc_cq_create(phba, phba->sli4_hba.fcp_cq[fcp_cqidx],
-                                    phba->sli4_hba.fp_eq[fcp_cqidx],
-                                    LPFC_WCQ, LPFC_FCP);
+                if (phba->cfg_fcp_eq_count)
+                        rc = lpfc_cq_create(phba,
+                                            phba->sli4_hba.fcp_cq[fcp_cqidx],
+                                            phba->sli4_hba.fp_eq[fcp_cqidx],
+                                            LPFC_WCQ, LPFC_FCP);
+                else
+                        rc = lpfc_cq_create(phba,
+                                            phba->sli4_hba.fcp_cq[fcp_cqidx],
+                                            phba->sli4_hba.sp_eq,
+                                            LPFC_WCQ, LPFC_FCP);
                 if (rc) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
                                         "0527 Failed setup of fast-path FCP "
@@ -6371,12 +6594,15 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                 }
                 lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
                                 "2588 FCP CQ setup: cq[%d]-id=%d, "
-                                "parent eq[%d]-id=%d\n",
+                                "parent %seq[%d]-id=%d\n",
                                 fcp_cqidx,
                                 phba->sli4_hba.fcp_cq[fcp_cqidx]->queue_id,
+                                (phba->cfg_fcp_eq_count) ? "" : "sp_",
                                 fcp_cqidx,
-                                phba->sli4_hba.fp_eq[fcp_cqidx]->queue_id);
-        }
+                                (phba->cfg_fcp_eq_count) ?
+                                   phba->sli4_hba.fp_eq[fcp_cqidx]->queue_id :
+                                   phba->sli4_hba.sp_eq->queue_id);
+        } while (++fcp_cqidx < phba->cfg_fcp_eq_count);
 
         /*
          * Set up all the Work Queues (WQs)
@@ -6445,7 +6671,9 @@ lpfc_sli4_queue_setup(struct lpfc_hba *phba)
                                 fcp_cq_index,
                                 phba->sli4_hba.fcp_cq[fcp_cq_index]->queue_id);
                 /* Round robin FCP Work Queue's Completion Queue assignment */
-                fcp_cq_index = ((fcp_cq_index + 1) % phba->cfg_fcp_eq_count);
+                if (phba->cfg_fcp_eq_count)
+                        fcp_cq_index = ((fcp_cq_index + 1) %
+                                        phba->cfg_fcp_eq_count);
         }
 
         /*
@@ -6827,6 +7055,8 @@ lpfc_pci_function_reset(struct lpfc_hba *phba)
                         if (rdy_chk < 1000)
                                 break;
                 }
+                /* delay driver action following IF_TYPE_2 function reset */
+                msleep(100);
                 break;
         case LPFC_SLI_INTF_IF_TYPE_1:
         default:
@@ -7419,11 +7649,15 @@ enable_msix_vectors:
         /*
          * Assign MSI-X vectors to interrupt handlers
          */
-
-        /* The first vector must associated to slow-path handler for MQ */
-        rc = request_irq(phba->sli4_hba.msix_entries[0].vector,
-                         &lpfc_sli4_sp_intr_handler, IRQF_SHARED,
-                         LPFC_SP_DRIVER_HANDLER_NAME, phba);
+        if (vectors > 1)
+                rc = request_irq(phba->sli4_hba.msix_entries[0].vector,
+                                 &lpfc_sli4_sp_intr_handler, IRQF_SHARED,
+                                 LPFC_SP_DRIVER_HANDLER_NAME, phba);
+        else
+                /* All Interrupts need to be handled by one EQ */
+                rc = request_irq(phba->sli4_hba.msix_entries[0].vector,
+                                 &lpfc_sli4_intr_handler, IRQF_SHARED,
+                                 LPFC_DRIVER_NAME, phba);
         if (rc) {
                 lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
                                 "0485 MSI-X slow-path request_irq failed "
@@ -7765,6 +7999,7 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba)
 {
         int wait_cnt = 0;
         LPFC_MBOXQ_t *mboxq;
+        struct pci_dev *pdev = phba->pcidev;
 
         lpfc_stop_hba_timers(phba);
         phba->sli4_hba.intr_enable = 0;
@@ -7804,6 +8039,10 @@ lpfc_sli4_hba_unset(struct lpfc_hba *phba)
         /* Disable PCI subsystem interrupt */
         lpfc_sli4_disable_intr(phba);
 
+        /* Disable SR-IOV if enabled */
+        if (phba->cfg_sriov_nr_virtfn)
+                pci_disable_sriov(pdev);
+
         /* Stop kthread signal shall trigger work_done one more time */
         kthread_stop(phba->worker_thread);
 
@@ -7878,6 +8117,11 @@ lpfc_pc_sli4_params_get(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         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);
+
+        /* Make sure that sge_supp_len can be handled by the driver */
+        if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE)
+                sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE;
+
         return rc;
 }
 
@@ -7902,6 +8146,13 @@ lpfc_get_sli4_parameters(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         int length;
         struct lpfc_sli4_parameters *mbx_sli4_parameters;
 
+        /*
+         * By default, the driver assumes the SLI4 port requires RPI
+         * header postings.  The SLI4_PARAM response will correct this
+         * assumption.
+         */
+        phba->sli4_hba.rpi_hdrs_in_use = 1;
+
         /* Read the port's SLI4 Config Parameters */
         length = (sizeof(struct lpfc_mbx_get_sli4_parameters) -
                   sizeof(struct lpfc_sli4_cfg_mhdr));
@@ -7938,6 +8189,13 @@ lpfc_get_sli4_parameters(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
                                             mbx_sli4_parameters);
         sli4_params->sgl_pp_align = bf_get(cfg_sgl_pp_align,
                                            mbx_sli4_parameters);
+        phba->sli4_hba.extents_in_use = bf_get(cfg_ext, mbx_sli4_parameters);
+        phba->sli4_hba.rpi_hdrs_in_use = bf_get(cfg_hdrr, mbx_sli4_parameters);
+
+        /* Make sure that sge_supp_len can be handled by the driver */
+        if (sli4_params->sge_supp_len > LPFC_MAX_SGE_SIZE)
+                sli4_params->sge_supp_len = LPFC_MAX_SGE_SIZE;
+
         return 0;
 }
 
@@ -8173,6 +8431,10 @@ lpfc_pci_remove_one_s3(struct pci_dev *pdev)
 
         lpfc_debugfs_terminate(vport);
 
+        /* Disable SR-IOV if enabled */
+        if (phba->cfg_sriov_nr_virtfn)
+                pci_disable_sriov(pdev);
+
         /* Disable interrupt */
         lpfc_sli_disable_intr(phba);
 
@@ -8565,6 +8827,97 @@ lpfc_sli4_get_els_iocb_cnt(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_write_firmware - attempt to write a firmware image to the port
+ * @phba: pointer to lpfc hba data structure.
+ * @fw: pointer to firmware image returned from request_firmware.
+ *
+ * returns the number of bytes written if write is successful.
+ * returns a negative error value if there were errors.
+ * returns 0 if firmware matches currently active firmware on port.
+ **/
+int
+lpfc_write_firmware(struct lpfc_hba *phba, const struct firmware *fw)
+{
+        char fwrev[32];
+        struct lpfc_grp_hdr *image = (struct lpfc_grp_hdr *)fw->data;
+        struct list_head dma_buffer_list;
+        int i, rc = 0;
+        struct lpfc_dmabuf *dmabuf, *next;
+        uint32_t offset = 0, temp_offset = 0;
+
+        INIT_LIST_HEAD(&dma_buffer_list);
+        if ((image->magic_number != LPFC_GROUP_OJECT_MAGIC_NUM) ||
+            (bf_get(lpfc_grp_hdr_file_type, image) != LPFC_FILE_TYPE_GROUP) ||
+            (bf_get(lpfc_grp_hdr_id, image) != LPFC_FILE_ID_GROUP) ||
+            (image->size != fw->size)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3022 Invalid FW image found. "
+                                "Magic:%d Type:%x ID:%x\n",
+                                image->magic_number,
+                                bf_get(lpfc_grp_hdr_file_type, image),
+                                bf_get(lpfc_grp_hdr_id, image));
+                return -EINVAL;
+        }
+        lpfc_decode_firmware_rev(phba, fwrev, 1);
+        if (strncmp(fwrev, image->rev_name, strnlen(fwrev, 16))) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3023 Updating Firmware. Current Version:%s "
+                                "New Version:%s\n",
+                                fwrev, image->rev_name);
+                for (i = 0; i < LPFC_MBX_WR_CONFIG_MAX_BDE; i++) {
+                        dmabuf = kzalloc(sizeof(struct lpfc_dmabuf),
+                                         GFP_KERNEL);
+                        if (!dmabuf) {
+                                rc = -ENOMEM;
+                                goto out;
+                        }
+                        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
+                                                          SLI4_PAGE_SIZE,
+                                                          &dmabuf->phys,
+                                                          GFP_KERNEL);
+                        if (!dmabuf->virt) {
+                                kfree(dmabuf);
+                                rc = -ENOMEM;
+                                goto out;
+                        }
+                        list_add_tail(&dmabuf->list, &dma_buffer_list);
+                }
+                while (offset < fw->size) {
+                        temp_offset = offset;
+                        list_for_each_entry(dmabuf, &dma_buffer_list, list) {
+                                if (offset + SLI4_PAGE_SIZE > fw->size) {
+                                        temp_offset += fw->size - offset;
+                                        memcpy(dmabuf->virt,
+                                               fw->data + temp_offset,
+                                               fw->size - offset);
+                                        break;
+                                }
+                                temp_offset += SLI4_PAGE_SIZE;
+                                memcpy(dmabuf->virt, fw->data + temp_offset,
+                                       SLI4_PAGE_SIZE);
+                        }
+                        rc = lpfc_wr_object(phba, &dma_buffer_list,
+                                    (fw->size - offset), &offset);
+                        if (rc) {
+                                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                                "3024 Firmware update failed. "
+                                                "%d\n", rc);
+                                goto out;
+                        }
+                }
+                rc = offset;
+        }
+out:
+        list_for_each_entry_safe(dmabuf, next, &dma_buffer_list, list) {
+                list_del(&dmabuf->list);
+                dma_free_coherent(&phba->pcidev->dev, SLI4_PAGE_SIZE,
+                                  dmabuf->virt, dmabuf->phys);
+                kfree(dmabuf);
+        }
+        return rc;
+}
+
+/**
  * lpfc_pci_probe_one_s4 - PCI probe func to reg SLI-4 device to PCI subsys
  * @pdev: pointer to PCI device
  * @pid: pointer to PCI device identifier
@@ -8591,6 +8944,10 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
         int error;
         uint32_t cfg_mode, intr_mode;
         int mcnt;
+        int adjusted_fcp_eq_count;
+        int fcp_qidx;
+        const struct firmware *fw;
+        uint8_t file_name[16];
 
         /* Allocate memory for HBA structure */
         phba = lpfc_hba_alloc(pdev);
@@ -8688,11 +9045,25 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
                         error = -ENODEV;
                         goto out_free_sysfs_attr;
                 }
-                /* Default to single FCP EQ for non-MSI-X */
+                /* Default to single EQ for non-MSI-X */
                 if (phba->intr_type != MSIX)
-                        phba->cfg_fcp_eq_count = 1;
-                else if (phba->sli4_hba.msix_vec_nr < phba->cfg_fcp_eq_count)
-                        phba->cfg_fcp_eq_count = phba->sli4_hba.msix_vec_nr - 1;
+                        adjusted_fcp_eq_count = 0;
+                else if (phba->sli4_hba.msix_vec_nr <
+                                        phba->cfg_fcp_eq_count + 1)
+                        adjusted_fcp_eq_count = phba->sli4_hba.msix_vec_nr - 1;
+                else
+                        adjusted_fcp_eq_count = phba->cfg_fcp_eq_count;
+                /* Free unused EQs */
+                for (fcp_qidx = adjusted_fcp_eq_count;
+                     fcp_qidx < phba->cfg_fcp_eq_count;
+                     fcp_qidx++) {
+                        lpfc_sli4_queue_free(phba->sli4_hba.fp_eq[fcp_qidx]);
+                        /* do not delete the first fcp_cq */
+                        if (fcp_qidx)
+                                lpfc_sli4_queue_free(
+                                        phba->sli4_hba.fcp_cq[fcp_qidx]);
+                }
+                phba->cfg_fcp_eq_count = adjusted_fcp_eq_count;
                 /* Set up SLI-4 HBA */
                 if (lpfc_sli4_hba_setup(phba)) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
@@ -8731,6 +9102,14 @@ lpfc_pci_probe_one_s4(struct pci_dev *pdev, const struct pci_device_id *pid)
         /* Perform post initialization setup */
         lpfc_post_init_setup(phba);
 
+        /* check for firmware upgrade or downgrade */
+        snprintf(file_name, 16, "%s.grp", phba->ModelName);
+        error = request_firmware(&fw, file_name, &phba->pcidev->dev);
+        if (!error) {
+                lpfc_write_firmware(phba, fw);
+                release_firmware(fw);
+        }
+
         /* Check if there are static vports to be created. */
         lpfc_create_static_vport(phba);
 
@@ -9498,6 +9877,10 @@ static struct pci_device_id lpfc_id_table[] = {
                 PCI_ANY_ID, PCI_ANY_ID, },
         {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FCOE,
                 PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FC_VF,
+                PCI_ANY_ID, PCI_ANY_ID, },
+        {PCI_VENDOR_ID_EMULEX, PCI_DEVICE_ID_LANCER_FCOE_VF,
+                PCI_ANY_ID, PCI_ANY_ID, },
         { 0 }
 };
 
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index e6ce9033f85e..556767028353 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -610,7 +610,8 @@ lpfc_read_sparam(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb, int vpi)
         mb->un.varRdSparm.un.sp64.tus.f.bdeSize = sizeof (struct serv_parm);
         mb->un.varRdSparm.un.sp64.addrHigh = putPaddrHigh(mp->phys);
         mb->un.varRdSparm.un.sp64.addrLow = putPaddrLow(mp->phys);
-        mb->un.varRdSparm.vpi = vpi + phba->vpi_base;
+        if (phba->sli_rev >= LPFC_SLI_REV3)
+                mb->un.varRdSparm.vpi = phba->vpi_ids[vpi];
 
         /* save address for completion */
         pmb->context1 = mp;
@@ -643,9 +644,10 @@ lpfc_unreg_did(struct lpfc_hba * phba, uint16_t vpi, uint32_t did,
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 
         mb->un.varUnregDID.did = did;
-        if (vpi != 0xffff)
-                vpi += phba->vpi_base;
         mb->un.varUnregDID.vpi = vpi;
+        if ((vpi != 0xffff) &&
+            (phba->sli_rev == LPFC_SLI_REV4))
+                mb->un.varUnregDID.vpi = phba->vpi_ids[vpi];
 
         mb->mbxCommand = MBX_UNREG_D_ID;
         mb->mbxOwner = OWN_HOST;
@@ -738,12 +740,10 @@ lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 
         mb->un.varRegLogin.rpi = 0;
-        if (phba->sli_rev == LPFC_SLI_REV4) {
-                mb->un.varRegLogin.rpi = rpi;
-                if (mb->un.varRegLogin.rpi == LPFC_RPI_ALLOC_ERROR)
-                        return 1;
-        }
-        mb->un.varRegLogin.vpi = vpi + phba->vpi_base;
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                mb->un.varRegLogin.rpi = phba->sli4_hba.rpi_ids[rpi];
+        if (phba->sli_rev >= LPFC_SLI_REV3)
+                mb->un.varRegLogin.vpi = phba->vpi_ids[vpi];
         mb->un.varRegLogin.did = did;
         mb->mbxOwner = OWN_HOST;
         /* Get a buffer to hold NPorts Service Parameters */
@@ -757,7 +757,7 @@ lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
                 lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX,
                                 "0302 REG_LOGIN: no buffers, VPI:%d DID:x%x, "
                                 "rpi x%x\n", vpi, did, rpi);
-                return (1);
+                return 1;
         }
         INIT_LIST_HEAD(&mp->list);
         sparam = mp->virt;
@@ -773,7 +773,7 @@ lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
         mb->un.varRegLogin.un.sp64.addrHigh = putPaddrHigh(mp->phys);
         mb->un.varRegLogin.un.sp64.addrLow = putPaddrLow(mp->phys);
 
-        return (0);
+        return 0;
 }
 
 /**
@@ -789,6 +789,9 @@ lpfc_reg_rpi(struct lpfc_hba *phba, uint16_t vpi, uint32_t did,
  *
  * This routine prepares the mailbox command for unregistering remote port
  * login.
+ *
+ * For SLI4 ports, the rpi passed to this function must be the physical
+ * rpi value, not the logical index.
  **/
 void
 lpfc_unreg_login(struct lpfc_hba *phba, uint16_t vpi, uint32_t rpi,
@@ -799,9 +802,10 @@ lpfc_unreg_login(struct lpfc_hba *phba, uint16_t vpi, uint32_t rpi,
         mb = &pmb->u.mb;
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 
-        mb->un.varUnregLogin.rpi = (uint16_t) rpi;
+        mb->un.varUnregLogin.rpi = rpi;
         mb->un.varUnregLogin.rsvd1 = 0;
-        mb->un.varUnregLogin.vpi = vpi + phba->vpi_base;
+        if (phba->sli_rev >= LPFC_SLI_REV3)
+                mb->un.varUnregLogin.vpi = phba->vpi_ids[vpi];
 
         mb->mbxCommand = MBX_UNREG_LOGIN;
         mb->mbxOwner = OWN_HOST;
@@ -825,9 +829,16 @@ lpfc_sli4_unreg_all_rpis(struct lpfc_vport *vport)
 
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (mbox) {
-                lpfc_unreg_login(phba, vport->vpi,
-                        vport->vpi + phba->vpi_base, mbox);
-                mbox->u.mb.un.varUnregLogin.rsvd1 = 0x4000 ;
+                /*
+                 * For SLI4 functions, the rpi field is overloaded for
+                 * the vport context unreg all.  This routine passes
+                 * 0 for the rpi field in lpfc_unreg_login for compatibility
+                 * with SLI3 and then overrides the rpi field with the
+                 * expected value for SLI4.
+                 */
+                lpfc_unreg_login(phba, vport->vpi, phba->vpi_ids[vport->vpi],
+                                 mbox);
+                mbox->u.mb.un.varUnregLogin.rsvd1 = 0x4000;
                 mbox->vport = vport;
                 mbox->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                 mbox->context1 = NULL;
@@ -865,9 +876,13 @@ lpfc_reg_vpi(struct lpfc_vport *vport, LPFC_MBOXQ_t *pmb)
         if ((phba->sli_rev == LPFC_SLI_REV4) &&
                 !(vport->fc_flag & FC_VPORT_NEEDS_REG_VPI))
                 mb->un.varRegVpi.upd = 1;
-        mb->un.varRegVpi.vpi = vport->vpi + vport->phba->vpi_base;
+
+        mb->un.varRegVpi.vpi = phba->vpi_ids[vport->vpi];
         mb->un.varRegVpi.sid = vport->fc_myDID;
-        mb->un.varRegVpi.vfi = vport->vfi + vport->phba->vfi_base;
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                mb->un.varRegVpi.vfi = phba->sli4_hba.vfi_ids[vport->vfi];
+        else
+                mb->un.varRegVpi.vfi = vport->vfi + vport->phba->vfi_base;
         memcpy(mb->un.varRegVpi.wwn, &vport->fc_portname,
                sizeof(struct lpfc_name));
         mb->un.varRegVpi.wwn[0] = cpu_to_le32(mb->un.varRegVpi.wwn[0]);
@@ -901,10 +916,10 @@ lpfc_unreg_vpi(struct lpfc_hba *phba, uint16_t vpi, LPFC_MBOXQ_t *pmb)
         MAILBOX_t *mb = &pmb->u.mb;
         memset(pmb, 0, sizeof (LPFC_MBOXQ_t));
 
-        if (phba->sli_rev < LPFC_SLI_REV4)
-                mb->un.varUnregVpi.vpi = vpi + phba->vpi_base;
-        else
-                mb->un.varUnregVpi.sli4_vpi = vpi + phba->vpi_base;
+        if (phba->sli_rev == LPFC_SLI_REV3)
+                mb->un.varUnregVpi.vpi = phba->vpi_ids[vpi];
+        else if (phba->sli_rev >= LPFC_SLI_REV4)
+                mb->un.varUnregVpi.sli4_vpi = phba->vpi_ids[vpi];
 
         mb->mbxCommand = MBX_UNREG_VPI;
         mb->mbxOwner = OWN_HOST;
@@ -1735,12 +1750,12 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
                 return length;
         }
 
-        /* Setup for the none-embedded mbox command */
+        /* Setup for the non-embedded mbox command */
         pcount = (SLI4_PAGE_ALIGN(length))/SLI4_PAGE_SIZE;
         pcount = (pcount > LPFC_SLI4_MBX_SGE_MAX_PAGES) ?
                                 LPFC_SLI4_MBX_SGE_MAX_PAGES : pcount;
         /* Allocate record for keeping SGE virtual addresses */
-        mbox->sge_array = kmalloc(sizeof(struct lpfc_mbx_nembed_sge_virt),
+        mbox->sge_array = kzalloc(sizeof(struct lpfc_mbx_nembed_sge_virt),
                                   GFP_KERNEL);
         if (!mbox->sge_array) {
                 lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
@@ -1790,12 +1805,87 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
         /* The sub-header is in DMA memory, which needs endian converstion */
         if (cfg_shdr)
                 lpfc_sli_pcimem_bcopy(cfg_shdr, cfg_shdr,
-                              sizeof(union  lpfc_sli4_cfg_shdr));
-
+                                      sizeof(union  lpfc_sli4_cfg_shdr));
         return alloc_len;
 }
 
 /**
+ * lpfc_sli4_mbox_rsrc_extent - Initialize the opcode resource extent.
+ * @phba: pointer to lpfc hba data structure.
+ * @mbox: pointer to an allocated lpfc mbox resource.
+ * @exts_count: the number of extents, if required, to allocate.
+ * @rsrc_type: the resource extent type.
+ * @emb: true if LPFC_SLI4_MBX_EMBED. false if LPFC_SLI4_MBX_NEMBED.
+ *
+ * This routine completes the subcommand header for SLI4 resource extent
+ * mailbox commands.  It is called after lpfc_sli4_config.  The caller must
+ * pass an allocated mailbox and the attributes required to initialize the
+ * mailbox correctly.
+ *
+ * Return: the actual length of the mbox command allocated.
+ **/
+int
+lpfc_sli4_mbox_rsrc_extent(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
+                           uint16_t exts_count, uint16_t rsrc_type, bool emb)
+{
+        uint8_t opcode = 0;
+        struct lpfc_mbx_nembed_rsrc_extent *n_rsrc_extnt = NULL;
+        void *virtaddr = NULL;
+
+        /* Set up SLI4 ioctl command header fields */
+        if (emb == LPFC_SLI4_MBX_NEMBED) {
+                /* Get the first SGE entry from the non-embedded DMA memory */
+                virtaddr = mbox->sge_array->addr[0];
+                if (virtaddr == NULL)
+                        return 1;
+                n_rsrc_extnt = (struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;
+        }
+
+        /*
+         * The resource type is common to all extent Opcodes and resides in the
+         * same position.
+         */
+        if (emb == LPFC_SLI4_MBX_EMBED)
+                bf_set(lpfc_mbx_alloc_rsrc_extents_type,
+                       &mbox->u.mqe.un.alloc_rsrc_extents.u.req,
+                       rsrc_type);
+        else {
+                /* This is DMA data.  Byteswap is required. */
+                bf_set(lpfc_mbx_alloc_rsrc_extents_type,
+                       n_rsrc_extnt, rsrc_type);
+                lpfc_sli_pcimem_bcopy(&n_rsrc_extnt->word4,
+                                      &n_rsrc_extnt->word4,
+                                      sizeof(uint32_t));
+        }
+
+        /* Complete the initialization for the particular Opcode. */
+        opcode = lpfc_sli4_mbox_opcode_get(phba, mbox);
+        switch (opcode) {
+        case LPFC_MBOX_OPCODE_ALLOC_RSRC_EXTENT:
+                if (emb == LPFC_SLI4_MBX_EMBED)
+                        bf_set(lpfc_mbx_alloc_rsrc_extents_cnt,
+                               &mbox->u.mqe.un.alloc_rsrc_extents.u.req,
+                               exts_count);
+                else
+                        bf_set(lpfc_mbx_alloc_rsrc_extents_cnt,
+                               n_rsrc_extnt, exts_count);
+                break;
+        case LPFC_MBOX_OPCODE_GET_ALLOC_RSRC_EXTENT:
+        case LPFC_MBOX_OPCODE_GET_RSRC_EXTENT_INFO:
+        case LPFC_MBOX_OPCODE_DEALLOC_RSRC_EXTENT:
+                /* Initialization is complete.*/
+                break;
+        default:
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX,
+                                "2929 Resource Extent Opcode x%x is "
+                                "unsupported\n", opcode);
+                return 1;
+        }
+
+        return 0;
+}
+
+/**
  * lpfc_sli4_mbox_opcode_get - Get the opcode from a sli4 mailbox command
  * @phba: pointer to lpfc hba data structure.
  * @mbox: pointer to lpfc mbox command.
@@ -1939,9 +2029,12 @@ lpfc_init_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport)
         bf_set(lpfc_init_vfi_vr, init_vfi, 1);
         bf_set(lpfc_init_vfi_vt, init_vfi, 1);
         bf_set(lpfc_init_vfi_vp, init_vfi, 1);
-        bf_set(lpfc_init_vfi_vfi, init_vfi, vport->vfi + vport->phba->vfi_base);
-        bf_set(lpfc_init_vpi_vpi, init_vfi, vport->vpi + vport->phba->vpi_base);
-        bf_set(lpfc_init_vfi_fcfi, init_vfi, vport->phba->fcf.fcfi);
+        bf_set(lpfc_init_vfi_vfi, init_vfi,
+               vport->phba->sli4_hba.vfi_ids[vport->vfi]);
+        bf_set(lpfc_init_vpi_vpi, init_vfi,
+               vport->phba->vpi_ids[vport->vpi]);
+        bf_set(lpfc_init_vfi_fcfi, init_vfi,
+               vport->phba->fcf.fcfi);
 }
 
 /**
@@ -1964,9 +2057,10 @@ lpfc_reg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport, dma_addr_t phys)
         reg_vfi = &mbox->u.mqe.un.reg_vfi;
         bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_REG_VFI);
         bf_set(lpfc_reg_vfi_vp, reg_vfi, 1);
-        bf_set(lpfc_reg_vfi_vfi, reg_vfi, vport->vfi + vport->phba->vfi_base);
+        bf_set(lpfc_reg_vfi_vfi, reg_vfi,
+               vport->phba->sli4_hba.vfi_ids[vport->vfi]);
         bf_set(lpfc_reg_vfi_fcfi, reg_vfi, vport->phba->fcf.fcfi);
-        bf_set(lpfc_reg_vfi_vpi, reg_vfi, vport->vpi + vport->phba->vpi_base);
+        bf_set(lpfc_reg_vfi_vpi, reg_vfi, vport->phba->vpi_ids[vport->vpi]);
         memcpy(reg_vfi->wwn, &vport->fc_portname, sizeof(struct lpfc_name));
         reg_vfi->wwn[0] = cpu_to_le32(reg_vfi->wwn[0]);
         reg_vfi->wwn[1] = cpu_to_le32(reg_vfi->wwn[1]);
@@ -1997,9 +2091,9 @@ lpfc_init_vpi(struct lpfc_hba *phba, struct lpfcMboxq *mbox, uint16_t vpi)
         memset(mbox, 0, sizeof(*mbox));
         bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_INIT_VPI);
         bf_set(lpfc_init_vpi_vpi, &mbox->u.mqe.un.init_vpi,
-               vpi + phba->vpi_base);
+               phba->vpi_ids[vpi]);
         bf_set(lpfc_init_vpi_vfi, &mbox->u.mqe.un.init_vpi,
-               phba->pport->vfi + phba->vfi_base);
+               phba->sli4_hba.vfi_ids[phba->pport->vfi]);
 }
 
 /**
@@ -2019,7 +2113,7 @@ lpfc_unreg_vfi(struct lpfcMboxq *mbox, struct lpfc_vport *vport)
         memset(mbox, 0, sizeof(*mbox));
         bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_UNREG_VFI);
         bf_set(lpfc_unreg_vfi_vfi, &mbox->u.mqe.un.unreg_vfi,
-               vport->vfi + vport->phba->vfi_base);
+               vport->phba->sli4_hba.vfi_ids[vport->vfi]);
 }
 
 /**
@@ -2131,12 +2225,14 @@ lpfc_unreg_fcfi(struct lpfcMboxq *mbox, uint16_t fcfi)
 void
 lpfc_resume_rpi(struct lpfcMboxq *mbox, struct lpfc_nodelist *ndlp)
 {
+        struct lpfc_hba *phba = ndlp->phba;
         struct lpfc_mbx_resume_rpi *resume_rpi;
 
         memset(mbox, 0, sizeof(*mbox));
         resume_rpi = &mbox->u.mqe.un.resume_rpi;
         bf_set(lpfc_mqe_command, &mbox->u.mqe, MBX_RESUME_RPI);
-        bf_set(lpfc_resume_rpi_index, resume_rpi, ndlp->nlp_rpi);
+        bf_set(lpfc_resume_rpi_index, resume_rpi,
+               phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
         bf_set(lpfc_resume_rpi_ii, resume_rpi, RESUME_INDEX_RPI);
         resume_rpi->event_tag = ndlp->phba->fc_eventTag;
 }
diff --git a/drivers/scsi/lpfc/lpfc_mem.c b/drivers/scsi/lpfc/lpfc_mem.c
index cbb48ee8b0bb..10d5b5e41499 100644
--- a/drivers/scsi/lpfc/lpfc_mem.c
+++ b/drivers/scsi/lpfc/lpfc_mem.c
@@ -62,7 +62,6 @@ int
 lpfc_mem_alloc(struct lpfc_hba *phba, int align)
 {
         struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
-        int longs;
         int i;
 
         if (phba->sli_rev == LPFC_SLI_REV4)
@@ -138,17 +137,8 @@ lpfc_mem_alloc(struct lpfc_hba *phba, int align)
                 phba->lpfc_hrb_pool = NULL;
                 phba->lpfc_drb_pool = NULL;
         }
-        /* vpi zero is reserved for the physical port so add 1 to max */
-        longs = ((phba->max_vpi + 1) + BITS_PER_LONG - 1) / BITS_PER_LONG;
-        phba->vpi_bmask = kzalloc(longs * sizeof(unsigned long), GFP_KERNEL);
-        if (!phba->vpi_bmask)
-                goto fail_free_dbq_pool;
 
         return 0;
-
- fail_free_dbq_pool:
-        pci_pool_destroy(phba->lpfc_drb_pool);
-        phba->lpfc_drb_pool = NULL;
  fail_free_hrb_pool:
         pci_pool_destroy(phba->lpfc_hrb_pool);
         phba->lpfc_hrb_pool = NULL;
@@ -191,9 +181,6 @@ lpfc_mem_free(struct lpfc_hba *phba)
         int i;
         struct lpfc_dma_pool *pool = &phba->lpfc_mbuf_safety_pool;
 
-        /* Free VPI bitmask memory */
-        kfree(phba->vpi_bmask);
-
         /* Free HBQ pools */
         lpfc_sli_hbqbuf_free_all(phba);
         if (phba->lpfc_drb_pool)
diff --git a/drivers/scsi/lpfc/lpfc_nportdisc.c b/drivers/scsi/lpfc/lpfc_nportdisc.c
index 0d92d4205ea6..2ddd02f7c603 100644
--- a/drivers/scsi/lpfc/lpfc_nportdisc.c
+++ b/drivers/scsi/lpfc/lpfc_nportdisc.c
@@ -350,11 +350,7 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         ndlp->nlp_maxframe =
                 ((sp->cmn.bbRcvSizeMsb & 0x0F) << 8) | sp->cmn.bbRcvSizeLsb;
 
-        /*
-         * Need to unreg_login if we are already in one of these states and
-         * change to NPR state. This will block the port until after the ACC
-         * completes and the reg_login is issued and completed.
-         */
+        /* no need to reg_login if we are already in one of these states */
         switch (ndlp->nlp_state) {
         case  NLP_STE_NPR_NODE:
                 if (!(ndlp->nlp_flag & NLP_NPR_ADISC))
@@ -363,9 +359,8 @@ lpfc_rcv_plogi(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp,
         case  NLP_STE_PRLI_ISSUE:
         case  NLP_STE_UNMAPPED_NODE:
         case  NLP_STE_MAPPED_NODE:
-                lpfc_unreg_rpi(vport, ndlp);
-                ndlp->nlp_prev_state = ndlp->nlp_state;
-                lpfc_nlp_set_state(vport, ndlp, NLP_STE_NPR_NODE);
+                lpfc_els_rsp_acc(vport, ELS_CMD_PLOGI, cmdiocb, ndlp, NULL);
+                return 1;
         }
 
         if ((vport->fc_flag & FC_PT2PT) &&
@@ -657,6 +652,7 @@ lpfc_disc_set_adisc(struct lpfc_vport *vport, struct lpfc_nodelist *ndlp)
         lpfc_unreg_rpi(vport, ndlp);
         return 0;
 }
+
 /**
  * lpfc_release_rpi - Release a RPI by issuing unreg_login mailbox cmd.
  * @phba : Pointer to lpfc_hba structure.
@@ -1399,8 +1395,11 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport,
         if (mb->mbxStatus) {
                 /* RegLogin failed */
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_DISCOVERY,
-                                "0246 RegLogin failed Data: x%x x%x x%x\n",
-                                did, mb->mbxStatus, vport->port_state);
+                                "0246 RegLogin failed Data: x%x x%x x%x x%x "
+                                 "x%x\n",
+                                 did, mb->mbxStatus, vport->port_state,
+                                 mb->un.varRegLogin.vpi,
+                                 mb->un.varRegLogin.rpi);
                 /*
                  * If RegLogin failed due to lack of HBA resources do not
                  * retry discovery.
@@ -1424,7 +1423,10 @@ lpfc_cmpl_reglogin_reglogin_issue(struct lpfc_vport *vport,
                 return ndlp->nlp_state;
         }
 
-        ndlp->nlp_rpi = mb->un.varWords[0];
+        /* SLI4 ports have preallocated logical rpis. */
+        if (vport->phba->sli_rev < LPFC_SLI_REV4)
+                ndlp->nlp_rpi = mb->un.varWords[0];
+
         ndlp->nlp_flag |= NLP_RPI_REGISTERED;
 
         /* Only if we are not a fabric nport do we issue PRLI */
@@ -2025,7 +2027,9 @@ lpfc_cmpl_reglogin_npr_node(struct lpfc_vport *vport,
         MAILBOX_t    *mb = &pmb->u.mb;
 
         if (!mb->mbxStatus) {
-                ndlp->nlp_rpi = mb->un.varWords[0];
+                /* SLI4 ports have preallocated logical rpis. */
+                if (vport->phba->sli_rev < LPFC_SLI_REV4)
+                        ndlp->nlp_rpi = mb->un.varWords[0];
                 ndlp->nlp_flag |= NLP_RPI_REGISTERED;
         } else {
                 if (ndlp->nlp_flag & NLP_NODEV_REMOVE) {
diff --git a/drivers/scsi/lpfc/lpfc_scsi.c b/drivers/scsi/lpfc/lpfc_scsi.c
index 84e4481b2406..3ccc97496ebf 100644
--- a/drivers/scsi/lpfc/lpfc_scsi.c
+++ b/drivers/scsi/lpfc/lpfc_scsi.c
@@ -743,7 +743,14 @@ lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *phba)
                 if (bcnt == 0)
                         continue;
                 /* Now, post the SCSI buffer list sgls as a block */
-                status = lpfc_sli4_post_scsi_sgl_block(phba, &sblist, bcnt);
+                if (!phba->sli4_hba.extents_in_use)
+                        status = lpfc_sli4_post_scsi_sgl_block(phba,
+                                                        &sblist,
+                                                        bcnt);
+                else
+                        status = lpfc_sli4_post_scsi_sgl_blk_ext(phba,
+                                                        &sblist,
+                                                        bcnt);
                 /* Reset SCSI buffer count for next round of posting */
                 bcnt = 0;
                 while (!list_empty(&sblist)) {
@@ -787,7 +794,7 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
         dma_addr_t pdma_phys_fcp_cmd;
         dma_addr_t pdma_phys_fcp_rsp;
         dma_addr_t pdma_phys_bpl, pdma_phys_bpl1;
-        uint16_t iotag, last_xritag = NO_XRI;
+        uint16_t iotag, last_xritag = NO_XRI, lxri = 0;
         int status = 0, index;
         int bcnt;
         int non_sequential_xri = 0;
@@ -823,13 +830,15 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                         break;
                 }
 
-                psb->cur_iocbq.sli4_xritag = lpfc_sli4_next_xritag(phba);
-                if (psb->cur_iocbq.sli4_xritag == NO_XRI) {
+                lxri = lpfc_sli4_next_xritag(phba);
+                if (lxri == NO_XRI) {
                         pci_pool_free(phba->lpfc_scsi_dma_buf_pool,
                               psb->data, psb->dma_handle);
                         kfree(psb);
                         break;
                 }
+                psb->cur_iocbq.sli4_lxritag = lxri;
+                psb->cur_iocbq.sli4_xritag = phba->sli4_hba.xri_ids[lxri];
                 if (last_xritag != NO_XRI
                         && psb->cur_iocbq.sli4_xritag != (last_xritag+1)) {
                         non_sequential_xri = 1;
@@ -861,6 +870,7 @@ 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));
+                sgl->word2 = le32_to_cpu(sgl->word2);
                 bf_set(lpfc_sli4_sge_last, sgl, 0);
                 sgl->word2 = cpu_to_le32(sgl->word2);
                 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_cmnd));
@@ -869,6 +879,7 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 /* 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));
+                sgl->word2 = le32_to_cpu(sgl->word2);
                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                 sgl->word2 = cpu_to_le32(sgl->word2);
                 sgl->sge_len = cpu_to_le32(sizeof(struct fcp_rsp));
@@ -914,7 +925,21 @@ lpfc_new_scsi_buf_s4(struct lpfc_vport *vport, int num_to_alloc)
                 }
         }
         if (bcnt) {
-                status = lpfc_sli4_post_scsi_sgl_block(phba, &sblist, bcnt);
+                if (!phba->sli4_hba.extents_in_use)
+                        status = lpfc_sli4_post_scsi_sgl_block(phba,
+                                                                &sblist,
+                                                                bcnt);
+                else
+                        status = lpfc_sli4_post_scsi_sgl_blk_ext(phba,
+                                                                &sblist,
+                                                                bcnt);
+
+                if (status) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                                        "3021 SCSI SGL post error %d\n",
+                                        status);
+                        bcnt = 0;
+                }
                 /* Reset SCSI buffer count for next round of posting */
                 while (!list_empty(&sblist)) {
                         list_remove_head(&sblist, psb, struct lpfc_scsi_buf,
@@ -2081,6 +2106,7 @@ lpfc_scsi_prep_dma_buf_s4(struct lpfc_hba *phba, struct lpfc_scsi_buf *lpfc_cmd)
                         dma_len = sg_dma_len(sgel);
                         sgl->addr_lo = cpu_to_le32(putPaddrLow(physaddr));
                         sgl->addr_hi = cpu_to_le32(putPaddrHigh(physaddr));
+                        sgl->word2 = le32_to_cpu(sgl->word2);
                         if ((num_bde + 1) == nseg)
                                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                         else
@@ -2794,6 +2820,9 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
          * of the scsi_cmnd request_buffer
          */
         piocbq->iocb.ulpContext = pnode->nlp_rpi;
+        if (phba->sli_rev == LPFC_SLI_REV4)
+                piocbq->iocb.ulpContext =
+                  phba->sli4_hba.rpi_ids[pnode->nlp_rpi];
         if (pnode->nlp_fcp_info & NLP_FCP_2_DEVICE)
                 piocbq->iocb.ulpFCP2Rcvy = 1;
         else
@@ -2807,7 +2836,7 @@ lpfc_scsi_prep_cmnd(struct lpfc_vport *vport, struct lpfc_scsi_buf *lpfc_cmd,
 }
 
 /**
- * lpfc_scsi_prep_task_mgmt_cmnd - Convert SLI3 scsi TM cmd to FCP info unit
+ * lpfc_scsi_prep_task_mgmt_cmd - Convert SLI3 scsi TM cmd to FCP info unit
  * @vport: The virtual port for which this call is being executed.
  * @lpfc_cmd: Pointer to lpfc_scsi_buf data structure.
  * @lun: Logical unit number.
@@ -2851,6 +2880,10 @@ lpfc_scsi_prep_task_mgmt_cmd(struct lpfc_vport *vport,
                 lpfc_fcpcmd_to_iocb(piocb->unsli3.fcp_ext.icd, fcp_cmnd);
         piocb->ulpCommand = CMD_FCP_ICMND64_CR;
         piocb->ulpContext = ndlp->nlp_rpi;
+        if (vport->phba->sli_rev == LPFC_SLI_REV4) {
+                piocb->ulpContext =
+                  vport->phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
+        }
         if (ndlp->nlp_fcp_info & NLP_FCP_2_DEVICE) {
                 piocb->ulpFCP2Rcvy = 1;
         }
@@ -3405,9 +3438,10 @@ lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
 
         lpfc_printf_vlog(vport, KERN_INFO, LOG_FCP,
                          "0702 Issue %s to TGT %d LUN %d "
-                         "rpi x%x nlp_flag x%x\n",
+                         "rpi x%x nlp_flag x%x Data: x%x x%x\n",
                          lpfc_taskmgmt_name(task_mgmt_cmd), tgt_id, lun_id,
-                         pnode->nlp_rpi, pnode->nlp_flag);
+                         pnode->nlp_rpi, pnode->nlp_flag, iocbq->sli4_xritag,
+                         iocbq->iocb_flag);
 
         status = lpfc_sli_issue_iocb_wait(phba, LPFC_FCP_RING,
                                           iocbq, iocbqrsp, lpfc_cmd->timeout);
@@ -3419,10 +3453,12 @@ lpfc_send_taskmgmt(struct lpfc_vport *vport, struct lpfc_rport_data *rdata,
                         ret = FAILED;
                 lpfc_cmd->status = IOSTAT_DRIVER_REJECT;
                 lpfc_printf_vlog(vport, KERN_ERR, LOG_FCP,
-                         "0727 TMF %s to TGT %d LUN %d failed (%d, %d)\n",
+                         "0727 TMF %s to TGT %d LUN %d failed (%d, %d) "
+                         "iocb_flag x%x\n",
                          lpfc_taskmgmt_name(task_mgmt_cmd),
                          tgt_id, lun_id, iocbqrsp->iocb.ulpStatus,
-                         iocbqrsp->iocb.un.ulpWord[4]);
+                         iocbqrsp->iocb.un.ulpWord[4],
+                         iocbq->iocb_flag);
         } else if (status == IOCB_BUSY)
                 ret = FAILED;
         else
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index fd5835e1c039..98999bbd8cbf 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -65,6 +65,9 @@ static struct lpfc_iocbq *lpfc_sli4_els_wcqe_to_rspiocbq(struct lpfc_hba *,
                                                          struct lpfc_iocbq *);
 static void lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *,
                                       struct hbq_dmabuf *);
+static int lpfc_sli4_fp_handle_wcqe(struct lpfc_hba *, struct lpfc_queue *,
+                                    struct lpfc_cqe *);
+
 static IOCB_t *
 lpfc_get_iocb_from_iocbq(struct lpfc_iocbq *iocbq)
 {
@@ -456,7 +459,6 @@ __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
         struct lpfc_iocbq * iocbq = NULL;
 
         list_remove_head(lpfc_iocb_list, iocbq, struct lpfc_iocbq, list);
-
         if (iocbq)
                 phba->iocb_cnt++;
         if (phba->iocb_cnt > phba->iocb_max)
@@ -479,13 +481,10 @@ __lpfc_sli_get_iocbq(struct lpfc_hba *phba)
 static struct lpfc_sglq *
 __lpfc_clear_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
 {
-        uint16_t adj_xri;
         struct lpfc_sglq *sglq;
-        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
-        if (adj_xri > phba->sli4_hba.max_cfg_param.max_xri)
-                return NULL;
-        sglq = phba->sli4_hba.lpfc_sglq_active_list[adj_xri];
-        phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = NULL;
+
+        sglq = phba->sli4_hba.lpfc_sglq_active_list[xritag];
+        phba->sli4_hba.lpfc_sglq_active_list[xritag] = NULL;
         return sglq;
 }
 
@@ -504,12 +503,9 @@ __lpfc_clear_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
 struct lpfc_sglq *
 __lpfc_get_active_sglq(struct lpfc_hba *phba, uint16_t xritag)
 {
-        uint16_t adj_xri;
         struct lpfc_sglq *sglq;
-        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
-        if (adj_xri > phba->sli4_hba.max_cfg_param.max_xri)
-                return NULL;
-        sglq =  phba->sli4_hba.lpfc_sglq_active_list[adj_xri];
+
+        sglq =  phba->sli4_hba.lpfc_sglq_active_list[xritag];
         return sglq;
 }
 
@@ -532,7 +528,6 @@ static int
 __lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
                 uint16_t xritag, uint16_t rxid, uint16_t send_rrq)
 {
-        uint16_t adj_xri;
         struct lpfc_node_rrq *rrq;
         int empty;
         uint32_t did = 0;
@@ -553,21 +548,19 @@ __lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
         /*
          * set the active bit even if there is no mem available.
          */
-        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
-
         if (NLP_CHK_FREE_REQ(ndlp))
                 goto out;
 
         if (ndlp->vport && (ndlp->vport->load_flag & FC_UNLOADING))
                 goto out;
 
-        if (test_and_set_bit(adj_xri, ndlp->active_rrqs.xri_bitmap))
+        if (test_and_set_bit(xritag, ndlp->active_rrqs.xri_bitmap))
                 goto out;
 
         rrq = mempool_alloc(phba->rrq_pool, GFP_KERNEL);
         if (rrq) {
                 rrq->send_rrq = send_rrq;
-                rrq->xritag = xritag;
+                rrq->xritag = phba->sli4_hba.xri_ids[xritag];
                 rrq->rrq_stop_time = jiffies + HZ * (phba->fc_ratov + 1);
                 rrq->ndlp = ndlp;
                 rrq->nlp_DID = ndlp->nlp_DID;
@@ -603,7 +596,6 @@ lpfc_clr_rrq_active(struct lpfc_hba *phba,
                     uint16_t xritag,
                     struct lpfc_node_rrq *rrq)
 {
-        uint16_t adj_xri;
         struct lpfc_nodelist *ndlp = NULL;
 
         if ((rrq->vport) && NLP_CHK_NODE_ACT(rrq->ndlp))
@@ -619,8 +611,7 @@ lpfc_clr_rrq_active(struct lpfc_hba *phba,
         if (!ndlp)
                 goto out;
 
-        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
-        if (test_and_clear_bit(adj_xri, ndlp->active_rrqs.xri_bitmap)) {
+        if (test_and_clear_bit(xritag, ndlp->active_rrqs.xri_bitmap)) {
                 rrq->send_rrq = 0;
                 rrq->xritag = 0;
                 rrq->rrq_stop_time = 0;
@@ -796,12 +787,9 @@ int
 lpfc_test_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
                         uint16_t  xritag)
 {
-        uint16_t adj_xri;
-
-        adj_xri = xritag - phba->sli4_hba.max_cfg_param.xri_base;
         if (!ndlp)
                 return 0;
-        if (test_bit(adj_xri, ndlp->active_rrqs.xri_bitmap))
+        if (test_bit(xritag, ndlp->active_rrqs.xri_bitmap))
                         return 1;
         else
                 return 0;
@@ -841,7 +829,7 @@ lpfc_set_rrq_active(struct lpfc_hba *phba, struct lpfc_nodelist *ndlp,
  * @piocb: Pointer to the iocbq.
  *
  * This function is called with hbalock held. This function
- * Gets a new driver sglq object from the sglq list. If the
+ * gets a new driver sglq object from the sglq list. If the
  * list is not empty then it is successful, it returns pointer to the newly
  * allocated sglq object else it returns NULL.
  **/
@@ -851,7 +839,6 @@ __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
         struct list_head *lpfc_sgl_list = &phba->sli4_hba.lpfc_sgl_list;
         struct lpfc_sglq *sglq = NULL;
         struct lpfc_sglq *start_sglq = NULL;
-        uint16_t adj_xri;
         struct lpfc_scsi_buf *lpfc_cmd;
         struct lpfc_nodelist *ndlp;
         int found = 0;
@@ -870,8 +857,6 @@ __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
         while (!found) {
                 if (!sglq)
                         return NULL;
-                adj_xri = sglq->sli4_xritag -
-                                phba->sli4_hba.max_cfg_param.xri_base;
                 if (lpfc_test_rrq_active(phba, ndlp, sglq->sli4_xritag)) {
                         /* This xri has an rrq outstanding for this DID.
                          * put it back in the list and get another xri.
@@ -888,7 +873,7 @@ __lpfc_sli_get_sglq(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq)
                 }
                 sglq->ndlp = ndlp;
                 found = 1;
-                phba->sli4_hba.lpfc_sglq_active_list[adj_xri] = sglq;
+                phba->sli4_hba.lpfc_sglq_active_list[sglq->sli4_lxritag] = sglq;
                 sglq->state = SGL_ALLOCATED;
         }
         return sglq;
@@ -944,7 +929,8 @@ __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
         if (iocbq->sli4_xritag == NO_XRI)
                 sglq = NULL;
         else
-                sglq = __lpfc_clear_active_sglq(phba, iocbq->sli4_xritag);
+                sglq = __lpfc_clear_active_sglq(phba, iocbq->sli4_lxritag);
+
         if (sglq)  {
                 if ((iocbq->iocb_flag & LPFC_EXCHANGE_BUSY) &&
                         (sglq->state != SGL_XRI_ABORTED)) {
@@ -971,6 +957,7 @@ __lpfc_sli_release_iocbq_s4(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq)
          * Clean all volatile data fields, preserve iotag and node struct.
          */
         memset((char *)iocbq + start_clean, 0, sizeof(*iocbq) - start_clean);
+        iocbq->sli4_lxritag = NO_XRI;
         iocbq->sli4_xritag = NO_XRI;
         list_add_tail(&iocbq->list, &phba->lpfc_iocb_list);
 }
@@ -2113,7 +2100,7 @@ lpfc_sli_def_mbox_cmpl(struct lpfc_hba *phba, LPFC_MBOXQ_t *pmb)
             pmb->u.mb.mbxCommand == MBX_REG_LOGIN64 &&
             !pmb->u.mb.mbxStatus) {
                 rpi = pmb->u.mb.un.varWords[0];
-                vpi = pmb->u.mb.un.varRegLogin.vpi - phba->vpi_base;
+                vpi = pmb->u.mb.un.varRegLogin.vpi;
                 lpfc_unreg_login(phba, vpi, rpi, pmb);
                 pmb->mbox_cmpl = lpfc_sli_def_mbox_cmpl;
                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_NOWAIT);
@@ -3881,8 +3868,10 @@ lpfc_sli4_brdreset(struct lpfc_hba *phba)
         list_del_init(&phba->sli4_hba.els_cq->list);
         for (qindx = 0; qindx < phba->cfg_fcp_wq_count; qindx++)
                 list_del_init(&phba->sli4_hba.fcp_wq[qindx]->list);
-        for (qindx = 0; qindx < phba->cfg_fcp_eq_count; qindx++)
+        qindx = 0;
+        do
                 list_del_init(&phba->sli4_hba.fcp_cq[qindx]->list);
+        while (++qindx < phba->cfg_fcp_eq_count);
         spin_unlock_irq(&phba->hbalock);
 
         /* Now physically reset the device */
@@ -4318,6 +4307,7 @@ lpfc_sli_config_port(struct lpfc_hba *phba, int sli_mode)
                         continue;
                 } else if (rc)
                         break;
+
                 phba->link_state = LPFC_INIT_MBX_CMDS;
                 lpfc_config_port(phba, pmb);
                 rc = lpfc_sli_issue_mbox(phba, pmb, MBX_POLL);
@@ -4421,7 +4411,8 @@ int
 lpfc_sli_hba_setup(struct lpfc_hba *phba)
 {
         uint32_t rc;
-        int  mode = 3;
+        int  mode = 3, i;
+        int longs;
 
         switch (lpfc_sli_mode) {
         case 2:
@@ -4491,6 +4482,35 @@ lpfc_sli_hba_setup(struct lpfc_hba *phba)
         if (rc)
                 goto lpfc_sli_hba_setup_error;
 
+        /* Initialize VPIs. */
+        if (phba->sli_rev == LPFC_SLI_REV3) {
+                /*
+                 * The VPI bitmask and physical ID array are allocated
+                 * and initialized once only - at driver load.  A port
+                 * reset doesn't need to reinitialize this memory.
+                 */
+                if ((phba->vpi_bmask == NULL) && (phba->vpi_ids == NULL)) {
+                        longs = (phba->max_vpi + BITS_PER_LONG) / BITS_PER_LONG;
+                        phba->vpi_bmask = kzalloc(longs * sizeof(unsigned long),
+                                                  GFP_KERNEL);
+                        if (!phba->vpi_bmask) {
+                                rc = -ENOMEM;
+                                goto lpfc_sli_hba_setup_error;
+                        }
+
+                        phba->vpi_ids = kzalloc(
+                                        (phba->max_vpi+1) * sizeof(uint16_t),
+                                        GFP_KERNEL);
+                        if (!phba->vpi_ids) {
+                                kfree(phba->vpi_bmask);
+                                rc = -ENOMEM;
+                                goto lpfc_sli_hba_setup_error;
+                        }
+                        for (i = 0; i < phba->max_vpi; i++)
+                                phba->vpi_ids[i] = i;
+                }
+        }
+
         /* Init HBQs */
         if (phba->sli3_options & LPFC_SLI3_HBQ_ENABLED) {
                 rc = lpfc_sli_hbq_setup(phba);
@@ -4677,9 +4697,11 @@ lpfc_sli4_arm_cqeq_intr(struct lpfc_hba *phba)
 
         lpfc_sli4_cq_release(phba->sli4_hba.mbx_cq, LPFC_QUEUE_REARM);
         lpfc_sli4_cq_release(phba->sli4_hba.els_cq, LPFC_QUEUE_REARM);
-        for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++)
+        fcp_eqidx = 0;
+        do
                 lpfc_sli4_cq_release(phba->sli4_hba.fcp_cq[fcp_eqidx],
                                      LPFC_QUEUE_REARM);
+        while (++fcp_eqidx < phba->cfg_fcp_eq_count);
         lpfc_sli4_eq_release(phba->sli4_hba.sp_eq, LPFC_QUEUE_REARM);
         for (fcp_eqidx = 0; fcp_eqidx < phba->cfg_fcp_eq_count; fcp_eqidx++)
                 lpfc_sli4_eq_release(phba->sli4_hba.fp_eq[fcp_eqidx],
@@ -4687,6 +4709,803 @@ lpfc_sli4_arm_cqeq_intr(struct lpfc_hba *phba)
 }
 
 /**
+ * lpfc_sli4_get_avail_extnt_rsrc - Get available resource extent count.
+ * @phba: Pointer to HBA context object.
+ * @type: The resource extent type.
+ *
+ * This function allocates all SLI4 resource identifiers.
+ **/
+static int
+lpfc_sli4_get_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type,
+                               uint16_t *extnt_count, uint16_t *extnt_size)
+{
+        int rc = 0;
+        uint32_t length;
+        uint32_t mbox_tmo;
+        struct lpfc_mbx_get_rsrc_extent_info *rsrc_info;
+        LPFC_MBOXQ_t *mbox;
+
+        mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return -ENOMEM;
+
+        /* Find out how many extents are available for this resource type */
+        length = (sizeof(struct lpfc_mbx_get_rsrc_extent_info) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
+                         LPFC_MBOX_OPCODE_GET_RSRC_EXTENT_INFO,
+                         length, LPFC_SLI4_MBX_EMBED);
+
+        /* Send an extents count of 0 - the GET doesn't use it. */
+        rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, 0, type,
+                                        LPFC_SLI4_MBX_EMBED);
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto err_exit;
+        }
+
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+        }
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto err_exit;
+        }
+
+        rsrc_info = &mbox->u.mqe.un.rsrc_extent_info;
+        if (bf_get(lpfc_mbox_hdr_status,
+                   &rsrc_info->header.cfg_shdr.response)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+                                "2930 Failed to get resource extents "
+                                "Status 0x%x Add'l Status 0x%x\n",
+                                bf_get(lpfc_mbox_hdr_status,
+                                       &rsrc_info->header.cfg_shdr.response),
+                                bf_get(lpfc_mbox_hdr_add_status,
+                                       &rsrc_info->header.cfg_shdr.response));
+                rc = -EIO;
+                goto err_exit;
+        }
+
+        *extnt_count = bf_get(lpfc_mbx_get_rsrc_extent_info_cnt,
+                              &rsrc_info->u.rsp);
+        *extnt_size = bf_get(lpfc_mbx_get_rsrc_extent_info_size,
+                             &rsrc_info->u.rsp);
+ err_exit:
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return rc;
+}
+
+/**
+ * lpfc_sli4_chk_avail_extnt_rsrc - Check for available SLI4 resource extents.
+ * @phba: Pointer to HBA context object.
+ * @type: The extent type to check.
+ *
+ * This function reads the current available extents from the port and checks
+ * if the extent count or extent size has changed since the last access.
+ * Callers use this routine post port reset to understand if there is a
+ * extent reprovisioning requirement.
+ *
+ * Returns:
+ *   -Error: error indicates problem.
+ *   1: Extent count or size has changed.
+ *   0: No changes.
+ **/
+static int
+lpfc_sli4_chk_avail_extnt_rsrc(struct lpfc_hba *phba, uint16_t type)
+{
+        uint16_t curr_ext_cnt, rsrc_ext_cnt;
+        uint16_t size_diff, rsrc_ext_size;
+        int rc = 0;
+        struct lpfc_rsrc_blks *rsrc_entry;
+        struct list_head *rsrc_blk_list = NULL;
+
+        size_diff = 0;
+        curr_ext_cnt = 0;
+        rc = lpfc_sli4_get_avail_extnt_rsrc(phba, type,
+                                            &rsrc_ext_cnt,
+                                            &rsrc_ext_size);
+        if (unlikely(rc))
+                return -EIO;
+
+        switch (type) {
+        case LPFC_RSC_TYPE_FCOE_RPI:
+                rsrc_blk_list = &phba->sli4_hba.lpfc_rpi_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_VPI:
+                rsrc_blk_list = &phba->lpfc_vpi_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_XRI:
+                rsrc_blk_list = &phba->sli4_hba.lpfc_xri_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_VFI:
+                rsrc_blk_list = &phba->sli4_hba.lpfc_vfi_blk_list;
+                break;
+        default:
+                break;
+        }
+
+        list_for_each_entry(rsrc_entry, rsrc_blk_list, list) {
+                curr_ext_cnt++;
+                if (rsrc_entry->rsrc_size != rsrc_ext_size)
+                        size_diff++;
+        }
+
+        if (curr_ext_cnt != rsrc_ext_cnt || size_diff != 0)
+                rc = 1;
+
+        return rc;
+}
+
+/**
+ * lpfc_sli4_cfg_post_extnts -
+ * @phba: Pointer to HBA context object.
+ * @extnt_cnt - number of available extents.
+ * @type - the extent type (rpi, xri, vfi, vpi).
+ * @emb - buffer to hold either MBX_EMBED or MBX_NEMBED operation.
+ * @mbox - pointer to the caller's allocated mailbox structure.
+ *
+ * This function executes the extents allocation request.  It also
+ * takes care of the amount of memory needed to allocate or get the
+ * allocated extents. It is the caller's responsibility to evaluate
+ * the response.
+ *
+ * Returns:
+ *   -Error:  Error value describes the condition found.
+ *   0: if successful
+ **/
+static int
+lpfc_sli4_cfg_post_extnts(struct lpfc_hba *phba, uint16_t *extnt_cnt,
+                          uint16_t type, bool *emb, LPFC_MBOXQ_t *mbox)
+{
+        int rc = 0;
+        uint32_t req_len;
+        uint32_t emb_len;
+        uint32_t alloc_len, mbox_tmo;
+
+        /* Calculate the total requested length of the dma memory */
+        req_len = *extnt_cnt * sizeof(uint16_t);
+
+        /*
+         * Calculate the size of an embedded mailbox.  The uint32_t
+         * accounts for extents-specific word.
+         */
+        emb_len = sizeof(MAILBOX_t) - sizeof(struct mbox_header) -
+                sizeof(uint32_t);
+
+        /*
+         * Presume the allocation and response will fit into an embedded
+         * mailbox.  If not true, reconfigure to a non-embedded mailbox.
+         */
+        *emb = LPFC_SLI4_MBX_EMBED;
+        if (req_len > emb_len) {
+                req_len = *extnt_cnt * sizeof(uint16_t) +
+                        sizeof(union lpfc_sli4_cfg_shdr) +
+                        sizeof(uint32_t);
+                *emb = LPFC_SLI4_MBX_NEMBED;
+        }
+
+        alloc_len = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
+                                     LPFC_MBOX_OPCODE_ALLOC_RSRC_EXTENT,
+                                     req_len, *emb);
+        if (alloc_len < req_len) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                        "9000 Allocated DMA memory size (x%x) is "
+                        "less than the requested DMA memory "
+                        "size (x%x)\n", alloc_len, req_len);
+                return -ENOMEM;
+        }
+        rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, *extnt_cnt, type, *emb);
+        if (unlikely(rc))
+                return -EIO;
+
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+        }
+
+        if (unlikely(rc))
+                rc = -EIO;
+        return rc;
+}
+
+/**
+ * lpfc_sli4_alloc_extent - Allocate an SLI4 resource extent.
+ * @phba: Pointer to HBA context object.
+ * @type:  The resource extent type to allocate.
+ *
+ * This function allocates the number of elements for the specified
+ * resource type.
+ **/
+static int
+lpfc_sli4_alloc_extent(struct lpfc_hba *phba, uint16_t type)
+{
+        bool emb = false;
+        uint16_t rsrc_id_cnt, rsrc_cnt, rsrc_size;
+        uint16_t rsrc_id, rsrc_start, j, k;
+        uint16_t *ids;
+        int i, rc;
+        unsigned long longs;
+        unsigned long *bmask;
+        struct lpfc_rsrc_blks *rsrc_blks;
+        LPFC_MBOXQ_t *mbox;
+        uint32_t length;
+        struct lpfc_id_range *id_array = NULL;
+        void *virtaddr = NULL;
+        struct lpfc_mbx_nembed_rsrc_extent *n_rsrc;
+        struct lpfc_mbx_alloc_rsrc_extents *rsrc_ext;
+        struct list_head *ext_blk_list;
+
+        rc = lpfc_sli4_get_avail_extnt_rsrc(phba, type,
+                                            &rsrc_cnt,
+                                            &rsrc_size);
+        if (unlikely(rc))
+                return -EIO;
+
+        if ((rsrc_cnt == 0) || (rsrc_size == 0)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+                        "3009 No available Resource Extents "
+                        "for resource type 0x%x: Count: 0x%x, "
+                        "Size 0x%x\n", type, rsrc_cnt,
+                        rsrc_size);
+                return -ENOMEM;
+        }
+
+        lpfc_printf_log(phba, KERN_INFO, LOG_MBOX | LOG_INIT,
+                        "2903 Available Resource Extents "
+                        "for resource type 0x%x: Count: 0x%x, "
+                        "Size 0x%x\n", type, rsrc_cnt,
+                        rsrc_size);
+
+        mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return -ENOMEM;
+
+        rc = lpfc_sli4_cfg_post_extnts(phba, &rsrc_cnt, type, &emb, mbox);
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto err_exit;
+        }
+
+        /*
+         * Figure out where the response is located.  Then get local pointers
+         * to the response data.  The port does not guarantee to respond to
+         * all extents counts request so update the local variable with the
+         * allocated count from the port.
+         */
+        if (emb == LPFC_SLI4_MBX_EMBED) {
+                rsrc_ext = &mbox->u.mqe.un.alloc_rsrc_extents;
+                id_array = &rsrc_ext->u.rsp.id[0];
+                rsrc_cnt = bf_get(lpfc_mbx_rsrc_cnt, &rsrc_ext->u.rsp);
+        } else {
+                virtaddr = mbox->sge_array->addr[0];
+                n_rsrc = (struct lpfc_mbx_nembed_rsrc_extent *) virtaddr;
+                rsrc_cnt = bf_get(lpfc_mbx_rsrc_cnt, n_rsrc);
+                id_array = &n_rsrc->id;
+        }
+
+        longs = ((rsrc_cnt * rsrc_size) + BITS_PER_LONG - 1) / BITS_PER_LONG;
+        rsrc_id_cnt = rsrc_cnt * rsrc_size;
+
+        /*
+         * Based on the resource size and count, correct the base and max
+         * resource values.
+         */
+        length = sizeof(struct lpfc_rsrc_blks);
+        switch (type) {
+        case LPFC_RSC_TYPE_FCOE_RPI:
+                phba->sli4_hba.rpi_bmask = kzalloc(longs *
+                                                   sizeof(unsigned long),
+                                                   GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.rpi_bmask)) {
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+                phba->sli4_hba.rpi_ids = kzalloc(rsrc_id_cnt *
+                                                 sizeof(uint16_t),
+                                                 GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.rpi_ids)) {
+                        kfree(phba->sli4_hba.rpi_bmask);
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+
+                /*
+                 * The next_rpi was initialized with the maximum available
+                 * count but the port may allocate a smaller number.  Catch
+                 * that case and update the next_rpi.
+                 */
+                phba->sli4_hba.next_rpi = rsrc_id_cnt;
+
+                /* Initialize local ptrs for common extent processing later. */
+                bmask = phba->sli4_hba.rpi_bmask;
+                ids = phba->sli4_hba.rpi_ids;
+                ext_blk_list = &phba->sli4_hba.lpfc_rpi_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_VPI:
+                phba->vpi_bmask = kzalloc(longs *
+                                          sizeof(unsigned long),
+                                          GFP_KERNEL);
+                if (unlikely(!phba->vpi_bmask)) {
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+                phba->vpi_ids = kzalloc(rsrc_id_cnt *
+                                         sizeof(uint16_t),
+                                         GFP_KERNEL);
+                if (unlikely(!phba->vpi_ids)) {
+                        kfree(phba->vpi_bmask);
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+
+                /* Initialize local ptrs for common extent processing later. */
+                bmask = phba->vpi_bmask;
+                ids = phba->vpi_ids;
+                ext_blk_list = &phba->lpfc_vpi_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_XRI:
+                phba->sli4_hba.xri_bmask = kzalloc(longs *
+                                                   sizeof(unsigned long),
+                                                   GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.xri_bmask)) {
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+                phba->sli4_hba.xri_ids = kzalloc(rsrc_id_cnt *
+                                                 sizeof(uint16_t),
+                                                 GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.xri_ids)) {
+                        kfree(phba->sli4_hba.xri_bmask);
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+
+                /* Initialize local ptrs for common extent processing later. */
+                bmask = phba->sli4_hba.xri_bmask;
+                ids = phba->sli4_hba.xri_ids;
+                ext_blk_list = &phba->sli4_hba.lpfc_xri_blk_list;
+                break;
+        case LPFC_RSC_TYPE_FCOE_VFI:
+                phba->sli4_hba.vfi_bmask = kzalloc(longs *
+                                                   sizeof(unsigned long),
+                                                   GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.vfi_bmask)) {
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+                phba->sli4_hba.vfi_ids = kzalloc(rsrc_id_cnt *
+                                                 sizeof(uint16_t),
+                                                 GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.vfi_ids)) {
+                        kfree(phba->sli4_hba.vfi_bmask);
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+
+                /* Initialize local ptrs for common extent processing later. */
+                bmask = phba->sli4_hba.vfi_bmask;
+                ids = phba->sli4_hba.vfi_ids;
+                ext_blk_list = &phba->sli4_hba.lpfc_vfi_blk_list;
+                break;
+        default:
+                /* Unsupported Opcode.  Fail call. */
+                id_array = NULL;
+                bmask = NULL;
+                ids = NULL;
+                ext_blk_list = NULL;
+                goto err_exit;
+        }
+
+        /*
+         * Complete initializing the extent configuration with the
+         * allocated ids assigned to this function.  The bitmask serves
+         * as an index into the array and manages the available ids.  The
+         * array just stores the ids communicated to the port via the wqes.
+         */
+        for (i = 0, j = 0, k = 0; i < rsrc_cnt; i++) {
+                if ((i % 2) == 0)
+                        rsrc_id = bf_get(lpfc_mbx_rsrc_id_word4_0,
+                                         &id_array[k]);
+                else
+                        rsrc_id = bf_get(lpfc_mbx_rsrc_id_word4_1,
+                                         &id_array[k]);
+
+                rsrc_blks = kzalloc(length, GFP_KERNEL);
+                if (unlikely(!rsrc_blks)) {
+                        rc = -ENOMEM;
+                        kfree(bmask);
+                        kfree(ids);
+                        goto err_exit;
+                }
+                rsrc_blks->rsrc_start = rsrc_id;
+                rsrc_blks->rsrc_size = rsrc_size;
+                list_add_tail(&rsrc_blks->list, ext_blk_list);
+                rsrc_start = rsrc_id;
+                if ((type == LPFC_RSC_TYPE_FCOE_XRI) && (j == 0))
+                        phba->sli4_hba.scsi_xri_start = rsrc_start +
+                                lpfc_sli4_get_els_iocb_cnt(phba);
+
+                while (rsrc_id < (rsrc_start + rsrc_size)) {
+                        ids[j] = rsrc_id;
+                        rsrc_id++;
+                        j++;
+                }
+                /* Entire word processed.  Get next word.*/
+                if ((i % 2) == 1)
+                        k++;
+        }
+ err_exit:
+        lpfc_sli4_mbox_cmd_free(phba, mbox);
+        return rc;
+}
+
+/**
+ * lpfc_sli4_dealloc_extent - Deallocate an SLI4 resource extent.
+ * @phba: Pointer to HBA context object.
+ * @type: the extent's type.
+ *
+ * This function deallocates all extents of a particular resource type.
+ * SLI4 does not allow for deallocating a particular extent range.  It
+ * is the caller's responsibility to release all kernel memory resources.
+ **/
+static int
+lpfc_sli4_dealloc_extent(struct lpfc_hba *phba, uint16_t type)
+{
+        int rc;
+        uint32_t length, mbox_tmo = 0;
+        LPFC_MBOXQ_t *mbox;
+        struct lpfc_mbx_dealloc_rsrc_extents *dealloc_rsrc;
+        struct lpfc_rsrc_blks *rsrc_blk, *rsrc_blk_next;
+
+        mbox = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return -ENOMEM;
+
+        /*
+         * This function sends an embedded mailbox because it only sends the
+         * the resource type.  All extents of this type are released by the
+         * port.
+         */
+        length = (sizeof(struct lpfc_mbx_dealloc_rsrc_extents) -
+                  sizeof(struct lpfc_sli4_cfg_mhdr));
+        lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
+                         LPFC_MBOX_OPCODE_DEALLOC_RSRC_EXTENT,
+                         length, LPFC_SLI4_MBX_EMBED);
+
+        /* Send an extents count of 0 - the dealloc doesn't use it. */
+        rc = lpfc_sli4_mbox_rsrc_extent(phba, mbox, 0, type,
+                                        LPFC_SLI4_MBX_EMBED);
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto out_free_mbox;
+        }
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, mbox_tmo);
+                rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+        }
+        if (unlikely(rc)) {
+                rc = -EIO;
+                goto out_free_mbox;
+        }
+
+        dealloc_rsrc = &mbox->u.mqe.un.dealloc_rsrc_extents;
+        if (bf_get(lpfc_mbox_hdr_status,
+                   &dealloc_rsrc->header.cfg_shdr.response)) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+                                "2919 Failed to release resource extents "
+                                "for type %d - Status 0x%x Add'l Status 0x%x. "
+                                "Resource memory not released.\n",
+                                type,
+                                bf_get(lpfc_mbox_hdr_status,
+                                    &dealloc_rsrc->header.cfg_shdr.response),
+                                bf_get(lpfc_mbox_hdr_add_status,
+                                    &dealloc_rsrc->header.cfg_shdr.response));
+                rc = -EIO;
+                goto out_free_mbox;
+        }
+
+        /* Release kernel memory resources for the specific type. */
+        switch (type) {
+        case LPFC_RSC_TYPE_FCOE_VPI:
+                kfree(phba->vpi_bmask);
+                kfree(phba->vpi_ids);
+                bf_set(lpfc_vpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+                list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
+                                    &phba->lpfc_vpi_blk_list, list) {
+                        list_del_init(&rsrc_blk->list);
+                        kfree(rsrc_blk);
+                }
+                break;
+        case LPFC_RSC_TYPE_FCOE_XRI:
+                kfree(phba->sli4_hba.xri_bmask);
+                kfree(phba->sli4_hba.xri_ids);
+                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+                list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
+                                    &phba->sli4_hba.lpfc_xri_blk_list, list) {
+                        list_del_init(&rsrc_blk->list);
+                        kfree(rsrc_blk);
+                }
+                break;
+        case LPFC_RSC_TYPE_FCOE_VFI:
+                kfree(phba->sli4_hba.vfi_bmask);
+                kfree(phba->sli4_hba.vfi_ids);
+                bf_set(lpfc_vfi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+                list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
+                                    &phba->sli4_hba.lpfc_vfi_blk_list, list) {
+                        list_del_init(&rsrc_blk->list);
+                        kfree(rsrc_blk);
+                }
+                break;
+        case LPFC_RSC_TYPE_FCOE_RPI:
+                /* RPI bitmask and physical id array are cleaned up earlier. */
+                list_for_each_entry_safe(rsrc_blk, rsrc_blk_next,
+                                    &phba->sli4_hba.lpfc_rpi_blk_list, list) {
+                        list_del_init(&rsrc_blk->list);
+                        kfree(rsrc_blk);
+                }
+                break;
+        default:
+                break;
+        }
+
+        bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+
+ out_free_mbox:
+        mempool_free(mbox, phba->mbox_mem_pool);
+        return rc;
+}
+
+/**
+ * lpfc_sli4_alloc_resource_identifiers - Allocate all SLI4 resource extents.
+ * @phba: Pointer to HBA context object.
+ *
+ * This function allocates all SLI4 resource identifiers.
+ **/
+int
+lpfc_sli4_alloc_resource_identifiers(struct lpfc_hba *phba)
+{
+        int i, rc, error = 0;
+        uint16_t count, base;
+        unsigned long longs;
+
+        if (phba->sli4_hba.extents_in_use) {
+                /*
+                 * The port supports resource extents. The XRI, VPI, VFI, RPI
+                 * resource extent count must be read and allocated before
+                 * provisioning the resource id arrays.
+                 */
+                if (bf_get(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags) ==
+                    LPFC_IDX_RSRC_RDY) {
+                        /*
+                         * Extent-based resources are set - the driver could
+                         * be in a port reset. Figure out if any corrective
+                         * actions need to be taken.
+                         */
+                        rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
+                                                 LPFC_RSC_TYPE_FCOE_VFI);
+                        if (rc != 0)
+                                error++;
+                        rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
+                                                 LPFC_RSC_TYPE_FCOE_VPI);
+                        if (rc != 0)
+                                error++;
+                        rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
+                                                 LPFC_RSC_TYPE_FCOE_XRI);
+                        if (rc != 0)
+                                error++;
+                        rc = lpfc_sli4_chk_avail_extnt_rsrc(phba,
+                                                 LPFC_RSC_TYPE_FCOE_RPI);
+                        if (rc != 0)
+                                error++;
+
+                        /*
+                         * It's possible that the number of resources
+                         * provided to this port instance changed between
+                         * resets.  Detect this condition and reallocate
+                         * resources.  Otherwise, there is no action.
+                         */
+                        if (error) {
+                                lpfc_printf_log(phba, KERN_INFO,
+                                                LOG_MBOX | LOG_INIT,
+                                                "2931 Detected extent resource "
+                                                "change.  Reallocating all "
+                                                "extents.\n");
+                                rc = lpfc_sli4_dealloc_extent(phba,
+                                                 LPFC_RSC_TYPE_FCOE_VFI);
+                                rc = lpfc_sli4_dealloc_extent(phba,
+                                                 LPFC_RSC_TYPE_FCOE_VPI);
+                                rc = lpfc_sli4_dealloc_extent(phba,
+                                                 LPFC_RSC_TYPE_FCOE_XRI);
+                                rc = lpfc_sli4_dealloc_extent(phba,
+                                                 LPFC_RSC_TYPE_FCOE_RPI);
+                        } else
+                                return 0;
+                }
+
+                rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_VFI);
+                if (unlikely(rc))
+                        goto err_exit;
+
+                rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_VPI);
+                if (unlikely(rc))
+                        goto err_exit;
+
+                rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_RPI);
+                if (unlikely(rc))
+                        goto err_exit;
+
+                rc = lpfc_sli4_alloc_extent(phba, LPFC_RSC_TYPE_FCOE_XRI);
+                if (unlikely(rc))
+                        goto err_exit;
+                bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags,
+                       LPFC_IDX_RSRC_RDY);
+                return rc;
+        } else {
+                /*
+                 * The port does not support resource extents.  The XRI, VPI,
+                 * VFI, RPI resource ids were determined from READ_CONFIG.
+                 * Just allocate the bitmasks and provision the resource id
+                 * arrays.  If a port reset is active, the resources don't
+                 * need any action - just exit.
+                 */
+                if (bf_get(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags) ==
+                    LPFC_IDX_RSRC_RDY)
+                        return 0;
+
+                /* RPIs. */
+                count = phba->sli4_hba.max_cfg_param.max_rpi;
+                base = phba->sli4_hba.max_cfg_param.rpi_base;
+                longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
+                phba->sli4_hba.rpi_bmask = kzalloc(longs *
+                                                   sizeof(unsigned long),
+                                                   GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.rpi_bmask)) {
+                        rc = -ENOMEM;
+                        goto err_exit;
+                }
+                phba->sli4_hba.rpi_ids = kzalloc(count *
+                                                 sizeof(uint16_t),
+                                                 GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.rpi_ids)) {
+                        rc = -ENOMEM;
+                        goto free_rpi_bmask;
+                }
+
+                for (i = 0; i < count; i++)
+                        phba->sli4_hba.rpi_ids[i] = base + i;
+
+                /* VPIs. */
+                count = phba->sli4_hba.max_cfg_param.max_vpi;
+                base = phba->sli4_hba.max_cfg_param.vpi_base;
+                longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
+                phba->vpi_bmask = kzalloc(longs *
+                                          sizeof(unsigned long),
+                                          GFP_KERNEL);
+                if (unlikely(!phba->vpi_bmask)) {
+                        rc = -ENOMEM;
+                        goto free_rpi_ids;
+                }
+                phba->vpi_ids = kzalloc(count *
+                                        sizeof(uint16_t),
+                                        GFP_KERNEL);
+                if (unlikely(!phba->vpi_ids)) {
+                        rc = -ENOMEM;
+                        goto free_vpi_bmask;
+                }
+
+                for (i = 0; i < count; i++)
+                        phba->vpi_ids[i] = base + i;
+
+                /* XRIs. */
+                count = phba->sli4_hba.max_cfg_param.max_xri;
+                base = phba->sli4_hba.max_cfg_param.xri_base;
+                longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
+                phba->sli4_hba.xri_bmask = kzalloc(longs *
+                                                   sizeof(unsigned long),
+                                                   GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.xri_bmask)) {
+                        rc = -ENOMEM;
+                        goto free_vpi_ids;
+                }
+                phba->sli4_hba.xri_ids = kzalloc(count *
+                                                 sizeof(uint16_t),
+                                                 GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.xri_ids)) {
+                        rc = -ENOMEM;
+                        goto free_xri_bmask;
+                }
+
+                for (i = 0; i < count; i++)
+                        phba->sli4_hba.xri_ids[i] = base + i;
+
+                /* VFIs. */
+                count = phba->sli4_hba.max_cfg_param.max_vfi;
+                base = phba->sli4_hba.max_cfg_param.vfi_base;
+                longs = (count + BITS_PER_LONG - 1) / BITS_PER_LONG;
+                phba->sli4_hba.vfi_bmask = kzalloc(longs *
+                                                   sizeof(unsigned long),
+                                                   GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.vfi_bmask)) {
+                        rc = -ENOMEM;
+                        goto free_xri_ids;
+                }
+                phba->sli4_hba.vfi_ids = kzalloc(count *
+                                                 sizeof(uint16_t),
+                                                 GFP_KERNEL);
+                if (unlikely(!phba->sli4_hba.vfi_ids)) {
+                        rc = -ENOMEM;
+                        goto free_vfi_bmask;
+                }
+
+                for (i = 0; i < count; i++)
+                        phba->sli4_hba.vfi_ids[i] = base + i;
+
+                /*
+                 * Mark all resources ready.  An HBA reset doesn't need
+                 * to reset the initialization.
+                 */
+                bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags,
+                       LPFC_IDX_RSRC_RDY);
+                return 0;
+        }
+
+ free_vfi_bmask:
+        kfree(phba->sli4_hba.vfi_bmask);
+ free_xri_ids:
+        kfree(phba->sli4_hba.xri_ids);
+ free_xri_bmask:
+        kfree(phba->sli4_hba.xri_bmask);
+ free_vpi_ids:
+        kfree(phba->vpi_ids);
+ free_vpi_bmask:
+        kfree(phba->vpi_bmask);
+ free_rpi_ids:
+        kfree(phba->sli4_hba.rpi_ids);
+ free_rpi_bmask:
+        kfree(phba->sli4_hba.rpi_bmask);
+ err_exit:
+        return rc;
+}
+
+/**
+ * lpfc_sli4_dealloc_resource_identifiers - Deallocate all SLI4 resource extents.
+ * @phba: Pointer to HBA context object.
+ *
+ * This function allocates the number of elements for the specified
+ * resource type.
+ **/
+int
+lpfc_sli4_dealloc_resource_identifiers(struct lpfc_hba *phba)
+{
+        if (phba->sli4_hba.extents_in_use) {
+                lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_VPI);
+                lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_RPI);
+                lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_XRI);
+                lpfc_sli4_dealloc_extent(phba, LPFC_RSC_TYPE_FCOE_VFI);
+        } else {
+                kfree(phba->vpi_bmask);
+                kfree(phba->vpi_ids);
+                bf_set(lpfc_vpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+                kfree(phba->sli4_hba.xri_bmask);
+                kfree(phba->sli4_hba.xri_ids);
+                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+                kfree(phba->sli4_hba.vfi_bmask);
+                kfree(phba->sli4_hba.vfi_ids);
+                bf_set(lpfc_vfi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+                bf_set(lpfc_idx_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
+        }
+
+        return 0;
+}
+
+/**
  * lpfc_sli4_hba_setup - SLI4 device intialization PCI function
  * @phba: Pointer to HBA context object.
  *
@@ -4708,10 +5527,6 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         struct lpfc_vport *vport = phba->pport;
         struct lpfc_dmabuf *mp;
 
-        /*
-         * TODO:  Why does this routine execute these task in a different
-         * order from probe?
-         */
         /* Perform a PCI function reset to start from clean */
         rc = lpfc_pci_function_reset(phba);
         if (unlikely(rc))
@@ -4740,7 +5555,7 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
          * to read FCoE param config regions
          */
         if (lpfc_sli4_read_fcoe_params(phba, mboxq))
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_INIT,
+                lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_INIT,
                         "2570 Failed to read FCoE parameters\n");
 
         /* Issue READ_REV to collect vpd and FW information. */
@@ -4873,6 +5688,18 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
         phba->sli3_options |= (LPFC_SLI3_NPIV_ENABLED | LPFC_SLI3_HBQ_ENABLED);
         spin_unlock_irq(&phba->hbalock);
 
+        /*
+         * Allocate all resources (xri,rpi,vpi,vfi) now.  Subsequent
+         * calls depends on these resources to complete port setup.
+         */
+        rc = lpfc_sli4_alloc_resource_identifiers(phba);
+        if (rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                                "2920 Failed to alloc Resource IDs "
+                                "rc = x%x\n", rc);
+                goto out_free_mbox;
+        }
+
         /* Read the port's service parameters. */
         rc = lpfc_read_sparam(phba, mboxq, vport->vpi);
         if (rc) {
@@ -4906,35 +5733,37 @@ lpfc_sli4_hba_setup(struct lpfc_hba *phba)
                 goto out_free_mbox;
         }
 
-        if (phba->cfg_soft_wwnn)
-                u64_to_wwn(phba->cfg_soft_wwnn,
-                           vport->fc_sparam.nodeName.u.wwn);
-        if (phba->cfg_soft_wwpn)
-                u64_to_wwn(phba->cfg_soft_wwpn,
-                           vport->fc_sparam.portName.u.wwn);
-        memcpy(&vport->fc_nodename, &vport->fc_sparam.nodeName,
-               sizeof(struct lpfc_name));
-        memcpy(&vport->fc_portname, &vport->fc_sparam.portName,
-               sizeof(struct lpfc_name));
+        lpfc_update_vport_wwn(vport);
 
         /* Update the fc_host data structures with new wwn. */
         fc_host_node_name(shost) = wwn_to_u64(vport->fc_nodename.u.wwn);
         fc_host_port_name(shost) = wwn_to_u64(vport->fc_portname.u.wwn);
 
         /* Register SGL pool to the device using non-embedded mailbox command */
-        rc = lpfc_sli4_post_sgl_list(phba);
-        if (unlikely(rc)) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
-                                "0582 Error %d during sgl post operation\n",
-                                        rc);
-                rc = -ENODEV;
-                goto out_free_mbox;
+        if (!phba->sli4_hba.extents_in_use) {
+                rc = lpfc_sli4_post_els_sgl_list(phba);
+                if (unlikely(rc)) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                                        "0582 Error %d during els sgl post "
+                                        "operation\n", rc);
+                        rc = -ENODEV;
+                        goto out_free_mbox;
+                }
+        } else {
+                rc = lpfc_sli4_post_els_sgl_list_ext(phba);
+                if (unlikely(rc)) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                                        "2560 Error %d during els sgl post "
+                                        "operation\n", rc);
+                        rc = -ENODEV;
+                        goto out_free_mbox;
+                }
         }
 
         /* Register SCSI SGL pool to the device */
         rc = lpfc_sli4_repost_scsi_sgl_list(phba);
         if (unlikely(rc)) {
-                lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
+                lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
                                 "0383 Error %d during scsi sgl post "
                                 "operation\n", rc);
                 /* Some Scsi buffers were moved to the abort scsi list */
@@ -5747,10 +6576,15 @@ lpfc_sli4_post_sync_mbox(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq)
         lpfc_sli_pcimem_bcopy(&mbox_rgn->mcqe, &mboxq->mcqe,
                               sizeof(struct lpfc_mcqe));
         mcqe_status = bf_get(lpfc_mcqe_status, &mbox_rgn->mcqe);
-
-        /* Prefix the mailbox status with range x4000 to note SLI4 status. */
+        /*
+         * When the CQE status indicates a failure and the mailbox status
+         * indicates success then copy the CQE status into the mailbox status
+         * (and prefix it with x4000).
+         */
         if (mcqe_status != MB_CQE_STATUS_SUCCESS) {
-                bf_set(lpfc_mqe_status, mb, LPFC_MBX_ERROR_RANGE | mcqe_status);
+                if (bf_get(lpfc_mqe_status, mb) == MBX_SUCCESS)
+                        bf_set(lpfc_mqe_status, mb,
+                               (LPFC_MBX_ERROR_RANGE | mcqe_status));
                 rc = MBXERR_ERROR;
         } else
                 lpfc_sli4_swap_str(phba, mboxq);
@@ -5819,7 +6653,7 @@ lpfc_sli_issue_mbox_s4(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
                 else
                         rc = -EIO;
                 if (rc != MBX_SUCCESS)
-                        lpfc_printf_log(phba, KERN_ERR, LOG_MBOX | LOG_SLI,
+                        lpfc_printf_log(phba, KERN_WARNING, LOG_MBOX | LOG_SLI,
                                         "(%d):2541 Mailbox command x%x "
                                         "(x%x) cannot issue Data: x%x x%x\n",
                                         mboxq->vport ? mboxq->vport->vpi : 0,
@@ -6307,6 +7141,7 @@ lpfc_sli4_bpl2sgl(struct lpfc_hba *phba, struct lpfc_iocbq *piocbq,
                         sgl->addr_hi = bpl->addrHigh;
                         sgl->addr_lo = bpl->addrLow;
 
+                        sgl->word2 = le32_to_cpu(sgl->word2);
                         if ((i+1) == numBdes)
                                 bf_set(lpfc_sli4_sge_last, sgl, 1);
                         else
@@ -6343,6 +7178,7 @@ 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);
+                        sgl->word2 = le32_to_cpu(sgl->word2);
                         bf_set(lpfc_sli4_sge_last, sgl, 1);
                         sgl->word2 = cpu_to_le32(sgl->word2);
                         sgl->sge_len =
@@ -6474,7 +7310,8 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                         els_id = ((iocbq->iocb_flag & LPFC_FIP_ELS_ID_MASK)
                                         >> LPFC_FIP_ELS_ID_SHIFT);
                 }
-                bf_set(wqe_temp_rpi, &wqe->els_req.wqe_com, ndlp->nlp_rpi);
+                bf_set(wqe_temp_rpi, &wqe->els_req.wqe_com,
+                       phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
                 bf_set(wqe_els_id, &wqe->els_req.wqe_com, els_id);
                 bf_set(wqe_dbde, &wqe->els_req.wqe_com, 1);
                 bf_set(wqe_iod, &wqe->els_req.wqe_com, LPFC_WQE_IOD_READ);
@@ -6623,14 +7460,15 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                        iocbq->iocb.ulpContext);
                 if (!iocbq->iocb.ulpCt_h && iocbq->iocb.ulpCt_l)
                         bf_set(wqe_ctxt_tag, &wqe->xmit_els_rsp.wqe_com,
-                               iocbq->vport->vpi + phba->vpi_base);
+                               phba->vpi_ids[iocbq->vport->vpi]);
                 bf_set(wqe_dbde, &wqe->xmit_els_rsp.wqe_com, 1);
                 bf_set(wqe_iod, &wqe->xmit_els_rsp.wqe_com, LPFC_WQE_IOD_WRITE);
                 bf_set(wqe_qosd, &wqe->xmit_els_rsp.wqe_com, 1);
                 bf_set(wqe_lenloc, &wqe->xmit_els_rsp.wqe_com,
                        LPFC_WQE_LENLOC_WORD3);
                 bf_set(wqe_ebde_cnt, &wqe->xmit_els_rsp.wqe_com, 0);
-                bf_set(wqe_rsp_temp_rpi, &wqe->xmit_els_rsp, ndlp->nlp_rpi);
+                bf_set(wqe_rsp_temp_rpi, &wqe->xmit_els_rsp,
+                       phba->sli4_hba.rpi_ids[ndlp->nlp_rpi]);
                 command_type = OTHER_COMMAND;
         break;
         case CMD_CLOSE_XRI_CN:
@@ -6729,6 +7567,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 return IOCB_ERROR;
         break;
         }
+
         bf_set(wqe_xri_tag, &wqe->generic.wqe_com, xritag);
         bf_set(wqe_reqtag, &wqe->generic.wqe_com, iocbq->iotag);
         wqe->generic.wqe_com.abort_tag = abort_tag;
@@ -6776,7 +7615,7 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
                                         return IOCB_BUSY;
                                 }
                         } else {
-                        sglq = __lpfc_sli_get_sglq(phba, piocb);
+                                sglq = __lpfc_sli_get_sglq(phba, piocb);
                                 if (!sglq) {
                                         if (!(flag & SLI_IOCB_RET_IOCB)) {
                                                 __lpfc_sli_ringtx_put(phba,
@@ -6789,11 +7628,11 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
                         }
                 }
         } else if (piocb->iocb_flag &  LPFC_IO_FCP) {
-                sglq = NULL; /* These IO's already have an XRI and
-                              * a mapped sgl.
-                              */
+                /* These IO's already have an XRI and a mapped sgl. */
+                sglq = NULL;
         } else {
-                /* This is a continuation of a commandi,(CX) so this
+                /*
+                 * This is a continuation of a commandi,(CX) so this
                  * sglq is on the active list
                  */
                 sglq = __lpfc_get_active_sglq(phba, piocb->sli4_xritag);
@@ -6802,8 +7641,8 @@ __lpfc_sli_issue_iocb_s4(struct lpfc_hba *phba, uint32_t ring_number,
         }
 
         if (sglq) {
+                piocb->sli4_lxritag = sglq->sli4_lxritag;
                 piocb->sli4_xritag = sglq->sli4_xritag;
-
                 if (NO_XRI == lpfc_sli4_bpl2sgl(phba, piocb, sglq))
                         return IOCB_ERROR;
         }
@@ -9799,7 +10638,12 @@ lpfc_sli4_sp_handle_eqe(struct lpfc_hba *phba, struct lpfc_eqe *eqe)
                 break;
         case LPFC_WCQ:
                 while ((cqe = lpfc_sli4_cq_get(cq))) {
-                        workposted |= lpfc_sli4_sp_handle_cqe(phba, cq, cqe);
+                        if (cq->subtype == LPFC_FCP)
+                                workposted |= lpfc_sli4_fp_handle_wcqe(phba, cq,
+                                                                       cqe);
+                        else
+                                workposted |= lpfc_sli4_sp_handle_cqe(phba, cq,
+                                                                      cqe);
                         if (!(++ecount % LPFC_GET_QE_REL_INT))
                                 lpfc_sli4_cq_release(cq, LPFC_QUEUE_NOARM);
                 }
@@ -11446,6 +12290,7 @@ lpfc_sli4_post_sgl(struct lpfc_hba *phba,
         LPFC_MBOXQ_t *mbox;
         int rc;
         uint32_t shdr_status, shdr_add_status;
+        uint32_t mbox_tmo;
         union lpfc_sli4_cfg_shdr *shdr;
 
         if (xritag == NO_XRI) {
@@ -11479,8 +12324,10 @@ lpfc_sli4_post_sgl(struct lpfc_hba *phba,
                                 cpu_to_le32(putPaddrHigh(pdma_phys_addr1));
         if (!phba->sli4_hba.intr_enable)
                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
-        else
-                rc = lpfc_sli_issue_mbox_wait(phba, mbox, LPFC_MBOX_TMO);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+        }
         /* The IOCTL status is embedded in the mailbox subheader. */
         shdr = (union lpfc_sli4_cfg_shdr *) &post_sgl_pages->header.cfg_shdr;
         shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
@@ -11498,6 +12345,76 @@ lpfc_sli4_post_sgl(struct lpfc_hba *phba,
 }
 
 /**
+ * lpfc_sli4_init_rpi_hdrs - Post the rpi header memory region to the port
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to post rpi header templates to the
+ * port for those SLI4 ports that do not support extents.  This routine
+ * posts a PAGE_SIZE memory region to the port to hold up to
+ * PAGE_SIZE modulo 64 rpi context headers.  This is an initialization routine
+ * and should be called only when interrupts are disabled.
+ *
+ * Return codes
+ *      0 - successful
+ *      -ERROR - otherwise.
+ */
+uint16_t
+lpfc_sli4_alloc_xri(struct lpfc_hba *phba)
+{
+        unsigned long xri;
+
+        /*
+         * Fetch the next logical xri.  Because this index is logical,
+         * the driver starts at 0 each time.
+         */
+        spin_lock_irq(&phba->hbalock);
+        xri = find_next_zero_bit(phba->sli4_hba.xri_bmask,
+                                 phba->sli4_hba.max_cfg_param.max_xri, 0);
+        if (xri >= phba->sli4_hba.max_cfg_param.max_xri) {
+                spin_unlock_irq(&phba->hbalock);
+                return NO_XRI;
+        } else {
+                set_bit(xri, phba->sli4_hba.xri_bmask);
+                phba->sli4_hba.max_cfg_param.xri_used++;
+                phba->sli4_hba.xri_count++;
+        }
+
+        spin_unlock_irq(&phba->hbalock);
+        return xri;
+}
+
+/**
+ * lpfc_sli4_free_xri - Release an xri for reuse.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to release an xri to the pool of
+ * available rpis maintained by the driver.
+ **/
+void
+__lpfc_sli4_free_xri(struct lpfc_hba *phba, int xri)
+{
+        if (test_and_clear_bit(xri, phba->sli4_hba.xri_bmask)) {
+                phba->sli4_hba.xri_count--;
+                phba->sli4_hba.max_cfg_param.xri_used--;
+        }
+}
+
+/**
+ * lpfc_sli4_free_xri - Release an xri for reuse.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to release an xri to the pool of
+ * available rpis maintained by the driver.
+ **/
+void
+lpfc_sli4_free_xri(struct lpfc_hba *phba, int xri)
+{
+        spin_lock_irq(&phba->hbalock);
+        __lpfc_sli4_free_xri(phba, xri);
+        spin_unlock_irq(&phba->hbalock);
+}
+
+/**
  * lpfc_sli4_next_xritag - Get an xritag for the io
  * @phba: Pointer to HBA context object.
  *
@@ -11510,30 +12427,23 @@ lpfc_sli4_post_sgl(struct lpfc_hba *phba,
 uint16_t
 lpfc_sli4_next_xritag(struct lpfc_hba *phba)
 {
-        uint16_t xritag;
+        uint16_t xri_index;
 
-        spin_lock_irq(&phba->hbalock);
-        xritag = phba->sli4_hba.next_xri;
-        if ((xritag != (uint16_t) -1) && xritag <
-                (phba->sli4_hba.max_cfg_param.max_xri
-                        + phba->sli4_hba.max_cfg_param.xri_base)) {
-                phba->sli4_hba.next_xri++;
-                phba->sli4_hba.max_cfg_param.xri_used++;
-                spin_unlock_irq(&phba->hbalock);
-                return xritag;
-        }
-        spin_unlock_irq(&phba->hbalock);
-        lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+        xri_index = lpfc_sli4_alloc_xri(phba);
+        if (xri_index != NO_XRI)
+                return xri_index;
+
+        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                         "2004 Failed to allocate XRI.last XRITAG is %d"
                         " Max XRI is %d, Used XRI is %d\n",
-                        phba->sli4_hba.next_xri,
+                        xri_index,
                         phba->sli4_hba.max_cfg_param.max_xri,
                         phba->sli4_hba.max_cfg_param.xri_used);
-        return -1;
+        return NO_XRI;
 }
 
 /**
- * lpfc_sli4_post_sgl_list - post a block of sgl list to the firmware.
+ * lpfc_sli4_post_els_sgl_list - post a block of ELS sgls to the port.
  * @phba: pointer to lpfc hba data structure.
  *
  * This routine is invoked to post a block of driver's sgl pages to the
@@ -11542,7 +12452,7 @@ lpfc_sli4_next_xritag(struct lpfc_hba *phba)
  * stopped.
  **/
 int
-lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
+lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba)
 {
         struct lpfc_sglq *sglq_entry;
         struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
@@ -11551,7 +12461,7 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
         LPFC_MBOXQ_t *mbox;
         uint32_t reqlen, alloclen, pg_pairs;
         uint32_t mbox_tmo;
-        uint16_t xritag_start = 0;
+        uint16_t xritag_start = 0, lxri = 0;
         int els_xri_cnt, rc = 0;
         uint32_t shdr_status, shdr_add_status;
         union lpfc_sli4_cfg_shdr *shdr;
@@ -11568,11 +12478,8 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
                 return -ENOMEM;
         }
         mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
-        if (!mbox) {
-                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
-                                "2560 Failed to allocate mbox cmd memory\n");
+        if (!mbox)
                 return -ENOMEM;
-        }
 
         /* Allocate DMA memory and set up the non-embedded mailbox command */
         alloclen = lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_FCOE,
@@ -11587,15 +12494,30 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
                 lpfc_sli4_mbox_cmd_free(phba, mbox);
                 return -ENOMEM;
         }
-        /* Get the first SGE entry from the non-embedded DMA memory */
-        viraddr = mbox->sge_array->addr[0];
-
         /* Set up the SGL pages in the non-embedded DMA pages */
+        viraddr = mbox->sge_array->addr[0];
         sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
         sgl_pg_pairs = &sgl->sgl_pg_pairs;
 
         for (pg_pairs = 0; pg_pairs < els_xri_cnt; pg_pairs++) {
                 sglq_entry = phba->sli4_hba.lpfc_els_sgl_array[pg_pairs];
+
+                /*
+                 * Assign the sglq a physical xri only if the driver has not
+                 * initialized those resources.  A port reset only needs
+                 * the sglq's posted.
+                 */
+                if (bf_get(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags) !=
+                    LPFC_XRI_RSRC_RDY) {
+                        lxri = lpfc_sli4_next_xritag(phba);
+                        if (lxri == NO_XRI) {
+                                lpfc_sli4_mbox_cmd_free(phba, mbox);
+                                return -ENOMEM;
+                        }
+                        sglq_entry->sli4_lxritag = lxri;
+                        sglq_entry->sli4_xritag = phba->sli4_hba.xri_ids[lxri];
+                }
+
                 /* Set up the sge entry */
                 sgl_pg_pairs->sgl_pg0_addr_lo =
                                 cpu_to_le32(putPaddrLow(sglq_entry->phys));
@@ -11605,16 +12527,17 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
                                 cpu_to_le32(putPaddrLow(0));
                 sgl_pg_pairs->sgl_pg1_addr_hi =
                                 cpu_to_le32(putPaddrHigh(0));
+
                 /* Keep the first xritag on the list */
                 if (pg_pairs == 0)
                         xritag_start = sglq_entry->sli4_xritag;
                 sgl_pg_pairs++;
         }
+
+        /* Complete initialization and perform endian conversion. */
         bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
         bf_set(lpfc_post_sgl_pages_xricnt, sgl, els_xri_cnt);
-        /* Perform endian conversion if necessary */
         sgl->word0 = cpu_to_le32(sgl->word0);
-
         if (!phba->sli4_hba.intr_enable)
                 rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
         else {
@@ -11633,6 +12556,181 @@ lpfc_sli4_post_sgl_list(struct lpfc_hba *phba)
                                 shdr_status, shdr_add_status, rc);
                 rc = -ENXIO;
         }
+
+        if (rc == 0)
+                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags,
+                       LPFC_XRI_RSRC_RDY);
+        return rc;
+}
+
+/**
+ * lpfc_sli4_post_els_sgl_list_ext - post a block of ELS sgls to the port.
+ * @phba: pointer to lpfc hba data structure.
+ *
+ * This routine is invoked to post a block of driver's sgl pages to the
+ * HBA using non-embedded mailbox command. No Lock is held. This routine
+ * is only called when the driver is loading and after all IO has been
+ * stopped.
+ **/
+int
+lpfc_sli4_post_els_sgl_list_ext(struct lpfc_hba *phba)
+{
+        struct lpfc_sglq *sglq_entry;
+        struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
+        struct sgl_page_pairs *sgl_pg_pairs;
+        void *viraddr;
+        LPFC_MBOXQ_t *mbox;
+        uint32_t reqlen, alloclen, index;
+        uint32_t mbox_tmo;
+        uint16_t rsrc_start, rsrc_size, els_xri_cnt;
+        uint16_t xritag_start = 0, lxri = 0;
+        struct lpfc_rsrc_blks *rsrc_blk;
+        int cnt, ttl_cnt, rc = 0;
+        int loop_cnt;
+        uint32_t shdr_status, shdr_add_status;
+        union lpfc_sli4_cfg_shdr *shdr;
+
+        /* The number of sgls to be posted */
+        els_xri_cnt = lpfc_sli4_get_els_iocb_cnt(phba);
+
+        reqlen = els_xri_cnt * sizeof(struct sgl_page_pairs) +
+                 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
+        if (reqlen > SLI4_PAGE_SIZE) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
+                                "2989 Block sgl registration required DMA "
+                                "size (%d) great than a page\n", reqlen);
+                return -ENOMEM;
+        }
+
+        cnt = 0;
+        ttl_cnt = 0;
+        list_for_each_entry(rsrc_blk, &phba->sli4_hba.lpfc_xri_blk_list,
+                            list) {
+                rsrc_start = rsrc_blk->rsrc_start;
+                rsrc_size = rsrc_blk->rsrc_size;
+
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "3014 Working ELS Extent start %d, cnt %d\n",
+                                rsrc_start, rsrc_size);
+
+                loop_cnt = min(els_xri_cnt, rsrc_size);
+                if (ttl_cnt + loop_cnt >= els_xri_cnt) {
+                        loop_cnt = els_xri_cnt - ttl_cnt;
+                        ttl_cnt = els_xri_cnt;
+                }
+
+                mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+                if (!mbox)
+                        return -ENOMEM;
+                /*
+                 * Allocate DMA memory and set up the non-embedded mailbox
+                 * command.
+                 */
+                alloclen = lpfc_sli4_config(phba, mbox,
+                                        LPFC_MBOX_SUBSYSTEM_FCOE,
+                                        LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES,
+                                        reqlen, LPFC_SLI4_MBX_NEMBED);
+                if (alloclen < reqlen) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2987 Allocated DMA memory size (%d) "
+                                        "is less than the requested DMA memory "
+                                        "size (%d)\n", alloclen, reqlen);
+                        lpfc_sli4_mbox_cmd_free(phba, mbox);
+                        return -ENOMEM;
+                }
+
+                /* Set up the SGL pages in the non-embedded DMA pages */
+                viraddr = mbox->sge_array->addr[0];
+                sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
+                sgl_pg_pairs = &sgl->sgl_pg_pairs;
+
+                /*
+                 * The starting resource may not begin at zero. Control
+                 * the loop variants via the block resource parameters,
+                 * but handle the sge pointers with a zero-based index
+                 * that doesn't get reset per loop pass.
+                 */
+                for (index = rsrc_start;
+                     index < rsrc_start + loop_cnt;
+                     index++) {
+                        sglq_entry = phba->sli4_hba.lpfc_els_sgl_array[cnt];
+
+                        /*
+                         * Assign the sglq a physical xri only if the driver
+                         * has not initialized those resources.  A port reset
+                         * only needs the sglq's posted.
+                         */
+                        if (bf_get(lpfc_xri_rsrc_rdy,
+                                   &phba->sli4_hba.sli4_flags) !=
+                                   LPFC_XRI_RSRC_RDY) {
+                                lxri = lpfc_sli4_next_xritag(phba);
+                                if (lxri == NO_XRI) {
+                                        lpfc_sli4_mbox_cmd_free(phba, mbox);
+                                        rc = -ENOMEM;
+                                        goto err_exit;
+                                }
+                                sglq_entry->sli4_lxritag = lxri;
+                                sglq_entry->sli4_xritag =
+                                                phba->sli4_hba.xri_ids[lxri];
+                        }
+
+                        /* Set up the sge entry */
+                        sgl_pg_pairs->sgl_pg0_addr_lo =
+                                cpu_to_le32(putPaddrLow(sglq_entry->phys));
+                        sgl_pg_pairs->sgl_pg0_addr_hi =
+                                cpu_to_le32(putPaddrHigh(sglq_entry->phys));
+                        sgl_pg_pairs->sgl_pg1_addr_lo =
+                                cpu_to_le32(putPaddrLow(0));
+                        sgl_pg_pairs->sgl_pg1_addr_hi =
+                                cpu_to_le32(putPaddrHigh(0));
+
+                        /* Track the starting physical XRI for the mailbox. */
+                        if (index == rsrc_start)
+                                xritag_start = sglq_entry->sli4_xritag;
+                        sgl_pg_pairs++;
+                        cnt++;
+                }
+
+                /* Complete initialization and perform endian conversion. */
+                rsrc_blk->rsrc_used += loop_cnt;
+                bf_set(lpfc_post_sgl_pages_xri, sgl, xritag_start);
+                bf_set(lpfc_post_sgl_pages_xricnt, sgl, loop_cnt);
+                sgl->word0 = cpu_to_le32(sgl->word0);
+
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "3015 Post ELS Extent SGL, start %d, "
+                                "cnt %d, used %d\n",
+                                xritag_start, loop_cnt, rsrc_blk->rsrc_used);
+                if (!phba->sli4_hba.intr_enable)
+                        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+                else {
+                        mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                        rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+                }
+                shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr;
+                shdr_status = bf_get(lpfc_mbox_hdr_status,
+                                     &shdr->response);
+                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                                         &shdr->response);
+                if (rc != MBX_TIMEOUT)
+                        lpfc_sli4_mbox_cmd_free(phba, mbox);
+                if (shdr_status || shdr_add_status || rc) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                        "2988 POST_SGL_BLOCK mailbox "
+                                        "command failed status x%x "
+                                        "add_status x%x mbx status x%x\n",
+                                        shdr_status, shdr_add_status, rc);
+                        rc = -ENXIO;
+                        goto err_exit;
+                }
+                if (ttl_cnt >= els_xri_cnt)
+                        break;
+        }
+
+ err_exit:
+        if (rc == 0)
+                bf_set(lpfc_xri_rsrc_rdy, &phba->sli4_hba.sli4_flags,
+                       LPFC_XRI_RSRC_RDY);
         return rc;
 }
 
@@ -11693,6 +12791,7 @@ lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
                 lpfc_sli4_mbox_cmd_free(phba, mbox);
                 return -ENOMEM;
         }
+
         /* Get the first SGE entry from the non-embedded DMA memory */
         viraddr = mbox->sge_array->addr[0];
 
@@ -11748,6 +12847,169 @@ lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *phba, struct list_head *sblist,
 }
 
 /**
+ * lpfc_sli4_post_scsi_sgl_blk_ext - post a block of scsi sgls to the port.
+ * @phba: pointer to lpfc hba data structure.
+ * @sblist: pointer to scsi buffer list.
+ * @count: number of scsi buffers on the list.
+ *
+ * This routine is invoked to post a block of @count scsi sgl pages from a
+ * SCSI buffer list @sblist to the HBA using non-embedded mailbox command.
+ * No Lock is held.
+ *
+ **/
+int
+lpfc_sli4_post_scsi_sgl_blk_ext(struct lpfc_hba *phba, struct list_head *sblist,
+                                int cnt)
+{
+        struct lpfc_scsi_buf *psb = NULL;
+        struct lpfc_mbx_post_uembed_sgl_page1 *sgl;
+        struct sgl_page_pairs *sgl_pg_pairs;
+        void *viraddr;
+        LPFC_MBOXQ_t *mbox;
+        uint32_t reqlen, alloclen, pg_pairs;
+        uint32_t mbox_tmo;
+        uint16_t xri_start = 0, scsi_xri_start;
+        uint16_t rsrc_range;
+        int rc = 0, avail_cnt;
+        uint32_t shdr_status, shdr_add_status;
+        dma_addr_t pdma_phys_bpl1;
+        union lpfc_sli4_cfg_shdr *shdr;
+        struct lpfc_rsrc_blks *rsrc_blk;
+        uint32_t xri_cnt = 0;
+
+        /* Calculate the total requested length of the dma memory */
+        reqlen = cnt * sizeof(struct sgl_page_pairs) +
+                 sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
+        if (reqlen > SLI4_PAGE_SIZE) {
+                lpfc_printf_log(phba, KERN_WARNING, LOG_INIT,
+                                "2932 Block sgl registration required DMA "
+                                "size (%d) great than a page\n", reqlen);
+                return -ENOMEM;
+        }
+
+        /*
+         * The use of extents requires the driver to post the sgl headers
+         * in multiple postings to meet the contiguous resource assignment.
+         */
+        psb = list_prepare_entry(psb, sblist, list);
+        scsi_xri_start = phba->sli4_hba.scsi_xri_start;
+        list_for_each_entry(rsrc_blk, &phba->sli4_hba.lpfc_xri_blk_list,
+                            list) {
+                rsrc_range = rsrc_blk->rsrc_start + rsrc_blk->rsrc_size;
+                if (rsrc_range < scsi_xri_start)
+                        continue;
+                else if (rsrc_blk->rsrc_used >= rsrc_blk->rsrc_size)
+                        continue;
+                else
+                        avail_cnt = rsrc_blk->rsrc_size - rsrc_blk->rsrc_used;
+
+                reqlen = (avail_cnt * sizeof(struct sgl_page_pairs)) +
+                        sizeof(union lpfc_sli4_cfg_shdr) + sizeof(uint32_t);
+                /*
+                 * Allocate DMA memory and set up the non-embedded mailbox
+                 * command. The mbox is used to post an SGL page per loop
+                 * but the DMA memory has a use-once semantic so the mailbox
+                 * is used and freed per loop pass.
+                 */
+                mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+                if (!mbox) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2933 Failed to allocate mbox cmd "
+                                        "memory\n");
+                        return -ENOMEM;
+                }
+                alloclen = lpfc_sli4_config(phba, mbox,
+                                        LPFC_MBOX_SUBSYSTEM_FCOE,
+                                        LPFC_MBOX_OPCODE_FCOE_POST_SGL_PAGES,
+                                        reqlen,
+                                        LPFC_SLI4_MBX_NEMBED);
+                if (alloclen < reqlen) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                        "2934 Allocated DMA memory size (%d) "
+                                        "is less than the requested DMA memory "
+                                        "size (%d)\n", alloclen, reqlen);
+                        lpfc_sli4_mbox_cmd_free(phba, mbox);
+                        return -ENOMEM;
+                }
+
+                /* Get the first SGE entry from the non-embedded DMA memory */
+                viraddr = mbox->sge_array->addr[0];
+
+                /* Set up the SGL pages in the non-embedded DMA pages */
+                sgl = (struct lpfc_mbx_post_uembed_sgl_page1 *)viraddr;
+                sgl_pg_pairs = &sgl->sgl_pg_pairs;
+
+                /* pg_pairs tracks posted SGEs per loop iteration. */
+                pg_pairs = 0;
+                list_for_each_entry_continue(psb, sblist, list) {
+                        /* Set up the sge entry */
+                        sgl_pg_pairs->sgl_pg0_addr_lo =
+                                cpu_to_le32(putPaddrLow(psb->dma_phys_bpl));
+                        sgl_pg_pairs->sgl_pg0_addr_hi =
+                                cpu_to_le32(putPaddrHigh(psb->dma_phys_bpl));
+                        if (phba->cfg_sg_dma_buf_size > SGL_PAGE_SIZE)
+                                pdma_phys_bpl1 = psb->dma_phys_bpl +
+                                        SGL_PAGE_SIZE;
+                        else
+                                pdma_phys_bpl1 = 0;
+                        sgl_pg_pairs->sgl_pg1_addr_lo =
+                                cpu_to_le32(putPaddrLow(pdma_phys_bpl1));
+                        sgl_pg_pairs->sgl_pg1_addr_hi =
+                                cpu_to_le32(putPaddrHigh(pdma_phys_bpl1));
+                        /* Keep the first xri for this extent. */
+                        if (pg_pairs == 0)
+                                xri_start = psb->cur_iocbq.sli4_xritag;
+                        sgl_pg_pairs++;
+                        pg_pairs++;
+                        xri_cnt++;
+
+                        /*
+                         * Track two exit conditions - the loop has constructed
+                         * all of the caller's SGE pairs or all available
+                         * resource IDs in this extent are consumed.
+                         */
+                        if ((xri_cnt == cnt) || (pg_pairs >= avail_cnt))
+                                break;
+                }
+                rsrc_blk->rsrc_used += pg_pairs;
+                bf_set(lpfc_post_sgl_pages_xri, sgl, xri_start);
+                bf_set(lpfc_post_sgl_pages_xricnt, sgl, pg_pairs);
+
+                lpfc_printf_log(phba, KERN_INFO, LOG_INIT,
+                                "3016 Post SCSI Extent SGL, start %d, cnt %d "
+                                "blk use %d\n",
+                                xri_start, pg_pairs, rsrc_blk->rsrc_used);
+                /* Perform endian conversion if necessary */
+                sgl->word0 = cpu_to_le32(sgl->word0);
+                if (!phba->sli4_hba.intr_enable)
+                        rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+                else {
+                        mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                        rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+                }
+                shdr = (union lpfc_sli4_cfg_shdr *) &sgl->cfg_shdr;
+                shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+                shdr_add_status = bf_get(lpfc_mbox_hdr_add_status,
+                                         &shdr->response);
+                if (rc != MBX_TIMEOUT)
+                        lpfc_sli4_mbox_cmd_free(phba, mbox);
+                if (shdr_status || shdr_add_status || rc) {
+                        lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
+                                        "2935 POST_SGL_BLOCK mailbox command "
+                                        "failed status x%x add_status x%x "
+                                        "mbx status x%x\n",
+                                        shdr_status, shdr_add_status, rc);
+                        return -ENXIO;
+                }
+
+                /* Post only what is requested. */
+                if (xri_cnt >= cnt)
+                        break;
+        }
+        return rc;
+}
+
+/**
  * lpfc_fc_frame_check - Check that this frame is a valid frame to handle
  * @phba: pointer to lpfc_hba struct that the frame was received on
  * @fc_hdr: A pointer to the FC Header data (In Big Endian Format)
@@ -12137,6 +13399,28 @@ lpfc_sli4_seq_abort_rsp_cmpl(struct lpfc_hba *phba,
 }
 
 /**
+ * lpfc_sli4_xri_inrange - check xri is in range of xris owned by driver.
+ * @phba: Pointer to HBA context object.
+ * @xri: xri id in transaction.
+ *
+ * This function validates the xri maps to the known range of XRIs allocated an
+ * used by the driver.
+ **/
+static uint16_t
+lpfc_sli4_xri_inrange(struct lpfc_hba *phba,
+                      uint16_t xri)
+{
+        int i;
+
+        for (i = 0; i < phba->sli4_hba.max_cfg_param.max_xri; i++) {
+                if (xri == phba->sli4_hba.xri_ids[i])
+                        return i;
+        }
+        return NO_XRI;
+}
+
+
+/**
  * lpfc_sli4_seq_abort_rsp - bls rsp to sequence abort
  * @phba: Pointer to HBA context object.
  * @fc_hdr: pointer to a FC frame header.
@@ -12169,9 +13453,7 @@ lpfc_sli4_seq_abort_rsp(struct lpfc_hba *phba,
                                 "SID:x%x\n", oxid, sid);
                 return;
         }
-        if (rxid >= phba->sli4_hba.max_cfg_param.xri_base
-                && rxid <= (phba->sli4_hba.max_cfg_param.max_xri
-                + phba->sli4_hba.max_cfg_param.xri_base))
+        if (lpfc_sli4_xri_inrange(phba, rxid))
                 lpfc_set_rrq_active(phba, ndlp, rxid, oxid, 0);
 
         /* Allocate buffer for rsp iocb */
@@ -12194,12 +13476,13 @@ lpfc_sli4_seq_abort_rsp(struct lpfc_hba *phba,
         icmd->ulpBdeCount = 0;
         icmd->ulpLe = 1;
         icmd->ulpClass = CLASS3;
-        icmd->ulpContext = ndlp->nlp_rpi;
+        icmd->ulpContext = phba->sli4_hba.rpi_ids[ndlp->nlp_rpi];
         ctiocb->context1 = ndlp;
 
         ctiocb->iocb_cmpl = NULL;
         ctiocb->vport = phba->pport;
         ctiocb->iocb_cmpl = lpfc_sli4_seq_abort_rsp_cmpl;
+        ctiocb->sli4_lxritag = NO_XRI;
         ctiocb->sli4_xritag = NO_XRI;
 
         /* If the oxid maps to the FCP XRI range or if it is out of range,
@@ -12380,8 +13663,8 @@ lpfc_prep_seq(struct lpfc_vport *vport, struct hbq_dmabuf *seq_dmabuf)
                 first_iocbq->iocb.ulpStatus = IOSTAT_SUCCESS;
                 first_iocbq->iocb.ulpCommand = CMD_IOCB_RCV_SEQ64_CX;
                 first_iocbq->iocb.ulpContext = be16_to_cpu(fc_hdr->fh_ox_id);
-                first_iocbq->iocb.unsli3.rcvsli3.vpi =
-                                        vport->vpi + vport->phba->vpi_base;
+                /* iocbq is prepped for internal consumption.  Logical vpi. */
+                first_iocbq->iocb.unsli3.rcvsli3.vpi = vport->vpi;
                 /* put the first buffer into the first IOCBq */
                 first_iocbq->context2 = &seq_dmabuf->dbuf;
                 first_iocbq->context3 = NULL;
@@ -12461,7 +13744,7 @@ lpfc_sli4_send_seq_to_ulp(struct lpfc_vport *vport,
                                       &phba->sli.ring[LPFC_ELS_RING],
                                       iocbq, fc_hdr->fh_r_ctl,
                                       fc_hdr->fh_type))
-                lpfc_printf_log(phba, KERN_WARNING, LOG_SLI,
+                lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2540 Ring %d handler: unexpected Rctl "
                                 "x%x Type x%x received\n",
                                 LPFC_ELS_RING,
@@ -12558,9 +13841,24 @@ lpfc_sli4_post_all_rpi_hdrs(struct lpfc_hba *phba)
 {
         struct lpfc_rpi_hdr *rpi_page;
         uint32_t rc = 0;
+        uint16_t lrpi = 0;
+
+        /* SLI4 ports that support extents do not require RPI headers. */
+        if (!phba->sli4_hba.rpi_hdrs_in_use)
+                goto exit;
+        if (phba->sli4_hba.extents_in_use)
+                return -EIO;
 
-        /* Post all rpi memory regions to the port. */
         list_for_each_entry(rpi_page, &phba->sli4_hba.lpfc_rpi_hdr_list, list) {
+                /*
+                 * Assign the rpi headers a physical rpi only if the driver
+                 * has not initialized those resources.  A port reset only
+                 * needs the headers posted.
+                 */
+                if (bf_get(lpfc_rpi_rsrc_rdy, &phba->sli4_hba.sli4_flags) !=
+                    LPFC_RPI_RSRC_RDY)
+                        rpi_page->start_rpi = phba->sli4_hba.rpi_ids[lrpi];
+
                 rc = lpfc_sli4_post_rpi_hdr(phba, rpi_page);
                 if (rc != MBX_SUCCESS) {
                         lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
@@ -12571,6 +13869,9 @@ lpfc_sli4_post_all_rpi_hdrs(struct lpfc_hba *phba)
                 }
         }
 
+ exit:
+        bf_set(lpfc_rpi_rsrc_rdy, &phba->sli4_hba.sli4_flags,
+               LPFC_RPI_RSRC_RDY);
         return rc;
 }
 
@@ -12594,10 +13895,15 @@ lpfc_sli4_post_rpi_hdr(struct lpfc_hba *phba, struct lpfc_rpi_hdr *rpi_page)
         LPFC_MBOXQ_t *mboxq;
         struct lpfc_mbx_post_hdr_tmpl *hdr_tmpl;
         uint32_t rc = 0;
-        uint32_t mbox_tmo;
         uint32_t shdr_status, shdr_add_status;
         union lpfc_sli4_cfg_shdr *shdr;
 
+        /* SLI4 ports that support extents do not require RPI headers. */
+        if (!phba->sli4_hba.rpi_hdrs_in_use)
+                return rc;
+        if (phba->sli4_hba.extents_in_use)
+                return -EIO;
+
         /* The port is notified of the header region via a mailbox command. */
         mboxq = (LPFC_MBOXQ_t *) mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
         if (!mboxq) {
@@ -12609,16 +13915,19 @@ lpfc_sli4_post_rpi_hdr(struct lpfc_hba *phba, struct lpfc_rpi_hdr *rpi_page)
 
         /* Post all rpi memory regions to the port. */
         hdr_tmpl = &mboxq->u.mqe.un.hdr_tmpl;
-        mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
         lpfc_sli4_config(phba, mboxq, LPFC_MBOX_SUBSYSTEM_FCOE,
                          LPFC_MBOX_OPCODE_FCOE_POST_HDR_TEMPLATE,
                          sizeof(struct lpfc_mbx_post_hdr_tmpl) -
                          sizeof(struct lpfc_sli4_cfg_mhdr),
                          LPFC_SLI4_MBX_EMBED);
-        bf_set(lpfc_mbx_post_hdr_tmpl_page_cnt,
-               hdr_tmpl, rpi_page->page_count);
+
+
+        /* Post the physical rpi to the port for this rpi header. */
         bf_set(lpfc_mbx_post_hdr_tmpl_rpi_offset, hdr_tmpl,
                rpi_page->start_rpi);
+        bf_set(lpfc_mbx_post_hdr_tmpl_page_cnt,
+               hdr_tmpl, rpi_page->page_count);
+
         hdr_tmpl->rpi_paddr_lo = putPaddrLow(rpi_page->dmabuf->phys);
         hdr_tmpl->rpi_paddr_hi = putPaddrHigh(rpi_page->dmabuf->phys);
         rc = lpfc_sli_issue_mbox(phba, mboxq, MBX_POLL);
@@ -12653,22 +13962,21 @@ lpfc_sli4_post_rpi_hdr(struct lpfc_hba *phba, struct lpfc_rpi_hdr *rpi_page)
 int
 lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
 {
-        int rpi;
-        uint16_t max_rpi, rpi_base, rpi_limit;
-        uint16_t rpi_remaining;
+        unsigned long rpi;
+        uint16_t max_rpi, rpi_limit;
+        uint16_t rpi_remaining, lrpi = 0;
         struct lpfc_rpi_hdr *rpi_hdr;
 
         max_rpi = phba->sli4_hba.max_cfg_param.max_rpi;
-        rpi_base = phba->sli4_hba.max_cfg_param.rpi_base;
         rpi_limit = phba->sli4_hba.next_rpi;
 
         /*
-         * The valid rpi range is not guaranteed to be zero-based.  Start
-         * the search at the rpi_base as reported by the port.
+         * Fetch the next logical rpi.  Because this index is logical,
+         * the  driver starts at 0 each time.
          */
         spin_lock_irq(&phba->hbalock);
-        rpi = find_next_zero_bit(phba->sli4_hba.rpi_bmask, rpi_limit, rpi_base);
-        if (rpi >= rpi_limit || rpi < rpi_base)
+        rpi = find_next_zero_bit(phba->sli4_hba.rpi_bmask, rpi_limit, 0);
+        if (rpi >= rpi_limit)
                 rpi = LPFC_RPI_ALLOC_ERROR;
         else {
                 set_bit(rpi, phba->sli4_hba.rpi_bmask);
@@ -12678,7 +13986,7 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
 
         /*
          * Don't try to allocate more rpi header regions if the device limit
-         * on available rpis max has been exhausted.
+         * has been exhausted.
          */
         if ((rpi == LPFC_RPI_ALLOC_ERROR) &&
             (phba->sli4_hba.rpi_count >= max_rpi)) {
@@ -12687,13 +13995,21 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
         }
 
         /*
+         * RPI header postings are not required for SLI4 ports capable of
+         * extents.
+         */
+        if (!phba->sli4_hba.rpi_hdrs_in_use) {
+                spin_unlock_irq(&phba->hbalock);
+                return rpi;
+        }
+
+        /*
          * If the driver is running low on rpi resources, allocate another
          * page now.  Note that the next_rpi value is used because
          * it represents how many are actually in use whereas max_rpi notes
          * how many are supported max by the device.
          */
-        rpi_remaining = phba->sli4_hba.next_rpi - rpi_base -
-                phba->sli4_hba.rpi_count;
+        rpi_remaining = phba->sli4_hba.next_rpi - phba->sli4_hba.rpi_count;
         spin_unlock_irq(&phba->hbalock);
         if (rpi_remaining < LPFC_RPI_LOW_WATER_MARK) {
                 rpi_hdr = lpfc_sli4_create_rpi_hdr(phba);
@@ -12702,6 +14018,8 @@ lpfc_sli4_alloc_rpi(struct lpfc_hba *phba)
                                         "2002 Error Could not grow rpi "
                                         "count\n");
                 } else {
+                        lrpi = rpi_hdr->start_rpi;
+                        rpi_hdr->start_rpi = phba->sli4_hba.rpi_ids[lrpi];
                         lpfc_sli4_post_rpi_hdr(phba, rpi_hdr);
                 }
         }
@@ -12751,6 +14069,8 @@ void
 lpfc_sli4_remove_rpis(struct lpfc_hba *phba)
 {
         kfree(phba->sli4_hba.rpi_bmask);
+        kfree(phba->sli4_hba.rpi_ids);
+        bf_set(lpfc_rpi_rsrc_rdy, &phba->sli4_hba.sli4_flags, 0);
 }
 
 /**
@@ -13490,6 +14810,96 @@ out:
 }
 
 /**
+ * lpfc_wr_object - write an object to the firmware
+ * @phba: HBA structure that indicates port to create a queue on.
+ * @dmabuf_list: list of dmabufs to write to the port.
+ * @size: the total byte value of the objects to write to the port.
+ * @offset: the current offset to be used to start the transfer.
+ *
+ * This routine will create a wr_object mailbox command to send to the port.
+ * the mailbox command will be constructed using the dma buffers described in
+ * @dmabuf_list to create a list of BDEs. This routine will fill in as many
+ * BDEs that the imbedded mailbox can support. The @offset variable will be
+ * used to indicate the starting offset of the transfer and will also return
+ * the offset after the write object mailbox has completed. @size is used to
+ * determine the end of the object and whether the eof bit should be set.
+ *
+ * Return 0 is successful and offset will contain the the new offset to use
+ * for the next write.
+ * Return negative value for error cases.
+ **/
+int
+lpfc_wr_object(struct lpfc_hba *phba, struct list_head *dmabuf_list,
+               uint32_t size, uint32_t *offset)
+{
+        struct lpfc_mbx_wr_object *wr_object;
+        LPFC_MBOXQ_t *mbox;
+        int rc = 0, i = 0;
+        uint32_t shdr_status, shdr_add_status;
+        uint32_t mbox_tmo;
+        union lpfc_sli4_cfg_shdr *shdr;
+        struct lpfc_dmabuf *dmabuf;
+        uint32_t written = 0;
+
+        mbox = mempool_alloc(phba->mbox_mem_pool, GFP_KERNEL);
+        if (!mbox)
+                return -ENOMEM;
+
+        lpfc_sli4_config(phba, mbox, LPFC_MBOX_SUBSYSTEM_COMMON,
+                        LPFC_MBOX_OPCODE_WRITE_OBJECT,
+                        sizeof(struct lpfc_mbx_wr_object) -
+                        sizeof(struct lpfc_sli4_cfg_mhdr), LPFC_SLI4_MBX_EMBED);
+
+        wr_object = (struct lpfc_mbx_wr_object *)&mbox->u.mqe.un.wr_object;
+        wr_object->u.request.write_offset = *offset;
+        sprintf((uint8_t *)wr_object->u.request.object_name, "/");
+        wr_object->u.request.object_name[0] =
+                cpu_to_le32(wr_object->u.request.object_name[0]);
+        bf_set(lpfc_wr_object_eof, &wr_object->u.request, 0);
+        list_for_each_entry(dmabuf, dmabuf_list, list) {
+                if (i >= LPFC_MBX_WR_CONFIG_MAX_BDE || written >= size)
+                        break;
+                wr_object->u.request.bde[i].addrLow = putPaddrLow(dmabuf->phys);
+                wr_object->u.request.bde[i].addrHigh =
+                        putPaddrHigh(dmabuf->phys);
+                if (written + SLI4_PAGE_SIZE >= size) {
+                        wr_object->u.request.bde[i].tus.f.bdeSize =
+                                (size - written);
+                        written += (size - written);
+                        bf_set(lpfc_wr_object_eof, &wr_object->u.request, 1);
+                } else {
+                        wr_object->u.request.bde[i].tus.f.bdeSize =
+                                SLI4_PAGE_SIZE;
+                        written += SLI4_PAGE_SIZE;
+                }
+                i++;
+        }
+        wr_object->u.request.bde_count = i;
+        bf_set(lpfc_wr_object_write_length, &wr_object->u.request, written);
+        if (!phba->sli4_hba.intr_enable)
+                rc = lpfc_sli_issue_mbox(phba, mbox, MBX_POLL);
+        else {
+                mbox_tmo = lpfc_mbox_tmo_val(phba, MBX_SLI4_CONFIG);
+                rc = lpfc_sli_issue_mbox_wait(phba, mbox, mbox_tmo);
+        }
+        /* The IOCTL status is embedded in the mailbox subheader. */
+        shdr = (union lpfc_sli4_cfg_shdr *) &wr_object->header.cfg_shdr;
+        shdr_status = bf_get(lpfc_mbox_hdr_status, &shdr->response);
+        shdr_add_status = bf_get(lpfc_mbox_hdr_add_status, &shdr->response);
+        if (rc != MBX_TIMEOUT)
+                mempool_free(mbox, phba->mbox_mem_pool);
+        if (shdr_status || shdr_add_status || rc) {
+                lpfc_printf_log(phba, KERN_ERR, LOG_INIT,
+                                "3025 Write Object mailbox failed with "
+                                "status x%x add_status x%x, mbx status x%x\n",
+                                shdr_status, shdr_add_status, rc);
+                rc = -ENXIO;
+        } else
+                *offset += wr_object->u.response.actual_write_length;
+        return rc;
+}
+
+/**
  * lpfc_cleanup_pending_mbox - Free up vport discovery mailbox commands.
  * @vport: pointer to vport data structure.
  *
@@ -13644,7 +15054,7 @@ lpfc_drain_txq(struct lpfc_hba *phba)
                                  * never happen
                                  */
                                 sglq = __lpfc_clear_active_sglq(phba,
-                                                 sglq->sli4_xritag);
+                                                 sglq->sli4_lxritag);
                                 spin_unlock_irqrestore(&phba->hbalock, iflags);
                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                         "2823 txq empty and txq_cnt is %d\n ",
@@ -13656,6 +15066,7 @@ lpfc_drain_txq(struct lpfc_hba *phba)
                 /* The xri and iocb resources secured,
                  * attempt to issue request
                  */
+                piocbq->sli4_lxritag = sglq->sli4_lxritag;
                 piocbq->sli4_xritag = sglq->sli4_xritag;
                 if (NO_XRI == lpfc_sli4_bpl2sgl(phba, piocbq, sglq))
                         fail_msg = "to convert bpl to sgl";
diff --git a/drivers/scsi/lpfc/lpfc_sli.h b/drivers/scsi/lpfc/lpfc_sli.h
index 453577c21c14..a0075b0af142 100644
--- a/drivers/scsi/lpfc/lpfc_sli.h
+++ b/drivers/scsi/lpfc/lpfc_sli.h
@@ -52,6 +52,7 @@ struct lpfc_iocbq {
         struct list_head clist;
         struct list_head dlist;
         uint16_t iotag;         /* pre-assigned IO tag */
+        uint16_t sli4_lxritag;  /* logical pre-assigned XRI. */
         uint16_t sli4_xritag;   /* pre-assigned XRI, (OXID) tag. */
         struct lpfc_cq_event cq_event;
 
diff --git a/drivers/scsi/lpfc/lpfc_sli4.h b/drivers/scsi/lpfc/lpfc_sli4.h
index 1a3cbf88f2ce..4b1703554a26 100644
--- a/drivers/scsi/lpfc/lpfc_sli4.h
+++ b/drivers/scsi/lpfc/lpfc_sli4.h
@@ -310,7 +310,6 @@ struct lpfc_max_cfg_param {
         uint16_t vfi_base;
         uint16_t vfi_used;
         uint16_t max_fcfi;
-        uint16_t fcfi_base;
         uint16_t fcfi_used;
         uint16_t max_eq;
         uint16_t max_rq;
@@ -365,6 +364,11 @@ struct lpfc_pc_sli4_params {
         uint8_t rqv;
 };
 
+struct lpfc_iov {
+        uint32_t pf_number;
+        uint32_t vf_number;
+};
+
 /* SLI4 HBA data structure entries */
 struct lpfc_sli4_hba {
         void __iomem *conf_regs_memmap_p; /* Kernel memory mapped address for
@@ -444,10 +448,13 @@ struct lpfc_sli4_hba {
         uint32_t intr_enable;
         struct lpfc_bmbx bmbx;
         struct lpfc_max_cfg_param max_cfg_param;
+        uint16_t extents_in_use; /* must allocate resource extents. */
+        uint16_t rpi_hdrs_in_use; /* must post rpi hdrs if set. */
         uint16_t next_xri; /* last_xri - max_cfg_param.xri_base = used */
         uint16_t next_rpi;
         uint16_t scsi_xri_max;
         uint16_t scsi_xri_cnt;
+        uint16_t scsi_xri_start;
         struct list_head lpfc_free_sgl_list;
         struct list_head lpfc_sgl_list;
         struct lpfc_sglq **lpfc_els_sgl_array;
@@ -458,7 +465,17 @@ struct lpfc_sli4_hba {
         struct lpfc_sglq **lpfc_sglq_active_list;
         struct list_head lpfc_rpi_hdr_list;
         unsigned long *rpi_bmask;
+        uint16_t *rpi_ids;
         uint16_t rpi_count;
+        struct list_head lpfc_rpi_blk_list;
+        unsigned long *xri_bmask;
+        uint16_t *xri_ids;
+        uint16_t xri_count;
+        struct list_head lpfc_xri_blk_list;
+        unsigned long *vfi_bmask;
+        uint16_t *vfi_ids;
+        uint16_t vfi_count;
+        struct list_head lpfc_vfi_blk_list;
         struct lpfc_sli4_flags sli4_flags;
         struct list_head sp_queue_event;
         struct list_head sp_cqe_event_pool;
@@ -467,6 +484,7 @@ struct lpfc_sli4_hba {
         struct list_head sp_els_xri_aborted_work_queue;
         struct list_head sp_unsol_work_queue;
         struct lpfc_sli4_link link_state;
+        struct lpfc_iov iov;
         spinlock_t abts_scsi_buf_list_lock; /* list of aborted SCSI IOs */
         spinlock_t abts_sgl_list_lock; /* list of aborted els IOs */
 };
@@ -490,6 +508,7 @@ struct lpfc_sglq {
         enum lpfc_sgl_state state;
         struct lpfc_nodelist *ndlp; /* ndlp associated with IO */
         uint16_t iotag;         /* pre-assigned IO tag */
+        uint16_t sli4_lxritag;  /* logical pre-assigned xri. */
         uint16_t sli4_xritag;   /* pre-assigned XRI, (OXID) tag. */
         struct sli4_sge *sgl;   /* pre-assigned SGL */
         void *virt;             /* virtual address. */
@@ -504,6 +523,13 @@ struct lpfc_rpi_hdr {
         uint32_t start_rpi;
 };
 
+struct lpfc_rsrc_blks {
+        struct list_head list;
+        uint16_t rsrc_start;
+        uint16_t rsrc_size;
+        uint16_t rsrc_used;
+};
+
 /*
  * SLI4 specific function prototypes
  */
@@ -543,8 +569,11 @@ int lpfc_sli4_post_sgl(struct lpfc_hba *, dma_addr_t, dma_addr_t, uint16_t);
 int lpfc_sli4_repost_scsi_sgl_list(struct lpfc_hba *);
 uint16_t lpfc_sli4_next_xritag(struct lpfc_hba *);
 int lpfc_sli4_post_async_mbox(struct lpfc_hba *);
-int lpfc_sli4_post_sgl_list(struct lpfc_hba *phba);
+int lpfc_sli4_post_els_sgl_list(struct lpfc_hba *phba);
+int lpfc_sli4_post_els_sgl_list_ext(struct lpfc_hba *phba);
 int lpfc_sli4_post_scsi_sgl_block(struct lpfc_hba *, struct list_head *, int);
+int lpfc_sli4_post_scsi_sgl_blk_ext(struct lpfc_hba *, struct list_head *,
+                                    int);
 struct lpfc_cq_event *__lpfc_sli4_cq_event_alloc(struct lpfc_hba *);
 struct lpfc_cq_event *lpfc_sli4_cq_event_alloc(struct lpfc_hba *);
 void __lpfc_sli4_cq_event_release(struct lpfc_hba *, struct lpfc_cq_event *);
diff --git a/drivers/scsi/lpfc/lpfc_vport.c b/drivers/scsi/lpfc/lpfc_vport.c
index 30ba5440c67a..1feb551a57bc 100644
--- a/drivers/scsi/lpfc/lpfc_vport.c
+++ b/drivers/scsi/lpfc/lpfc_vport.c
@@ -83,7 +83,7 @@ inline void lpfc_vport_set_state(struct lpfc_vport *vport,
 static int
 lpfc_alloc_vpi(struct lpfc_hba *phba)
 {
-        int  vpi;
+        unsigned long vpi;
 
         spin_lock_irq(&phba->hbalock);
         /* Start at bit 1 because vpi zero is reserved for the physical port */
diff --git a/drivers/scsi/megaraid/megaraid_sas.h b/drivers/scsi/megaraid/megaraid_sas.h
index 046dcc672ec1..7370c084b178 100644
--- a/drivers/scsi/megaraid/megaraid_sas.h
+++ b/drivers/scsi/megaraid/megaraid_sas.h
@@ -33,9 +33,9 @@
 /*
  * MegaRAID SAS Driver meta data
  */
-#define MEGASAS_VERSION                         "00.00.05.34-rc1"
-#define MEGASAS_RELDATE                         "Feb. 24, 2011"
-#define MEGASAS_EXT_VERSION                     "Thu. Feb. 24 17:00:00 PDT 2011"
+#define MEGASAS_VERSION                         "00.00.05.38-rc1"
+#define MEGASAS_RELDATE                         "May. 11, 2011"
+#define MEGASAS_EXT_VERSION                     "Wed. May. 11 17:00:00 PDT 2011"
 
 /*
  * Device IDs
@@ -76,8 +76,8 @@
 #define MFI_STATE_READY                         0xB0000000
 #define MFI_STATE_OPERATIONAL                   0xC0000000
 #define MFI_STATE_FAULT                         0xF0000000
-#define  MFI_RESET_REQUIRED                     0x00000001
-
+#define MFI_RESET_REQUIRED                      0x00000001
+#define MFI_RESET_ADAPTER                       0x00000002
 #define MEGAMFI_FRAME_SIZE                      64
 
 /*
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index 89c623ebadbc..2d8cdce7b2f5 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -18,7 +18,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  *  FILE: megaraid_sas_base.c
- *  Version : v00.00.05.34-rc1
+ *  Version : v00.00.05.38-rc1
  *
  *  Authors: LSI Corporation
  *           Sreenivas Bagalkote
@@ -437,15 +437,18 @@ megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
 static int
 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
 {
-        u32 status;
+        u32 status, mfiStatus = 0;
+
         /*
          * Check if it is our interrupt
          */
         status = readl(&regs->outbound_intr_status);
 
-        if (!(status & MFI_REPLY_1078_MESSAGE_INTERRUPT)) {
-                return 0;
-        }
+        if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
+                mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
+
+        if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
+                mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 
         /*
          * Clear the interrupt by writing back the same value
@@ -455,8 +458,9 @@ megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
         /* Dummy readl to force pci flush */
         readl(&regs->outbound_doorbell_clear);
 
-        return 1;
+        return mfiStatus;
 }
+
 /**
  * megasas_fire_cmd_ppc -       Sends command to the FW
  * @frame_phys_addr :           Physical address of cmd
@@ -477,17 +481,6 @@ megasas_fire_cmd_ppc(struct megasas_instance *instance,
 }
 
 /**
- * megasas_adp_reset_ppc -      For controller reset
- * @regs:                               MFI register set
- */
-static int
-megasas_adp_reset_ppc(struct megasas_instance *instance,
-                        struct megasas_register_set __iomem *regs)
-{
-        return 0;
-}
-
-/**
  * megasas_check_reset_ppc -    For controller reset check
  * @regs:                               MFI register set
  */
@@ -495,8 +488,12 @@ static int
 megasas_check_reset_ppc(struct megasas_instance *instance,
                         struct megasas_register_set __iomem *regs)
 {
+        if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
+                return 1;
+
         return 0;
 }
+
 static struct megasas_instance_template megasas_instance_template_ppc = {
 
         .fire_cmd = megasas_fire_cmd_ppc,
@@ -504,7 +501,7 @@ static struct megasas_instance_template megasas_instance_template_ppc = {
         .disable_intr = megasas_disable_intr_ppc,
         .clear_intr = megasas_clear_intr_ppc,
         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
-        .adp_reset = megasas_adp_reset_ppc,
+        .adp_reset = megasas_adp_reset_xscale,
         .check_reset = megasas_check_reset_ppc,
         .service_isr = megasas_isr,
         .tasklet = megasas_complete_cmd_dpc,
@@ -620,6 +617,9 @@ static int
 megasas_check_reset_skinny(struct megasas_instance *instance,
                                 struct megasas_register_set __iomem *regs)
 {
+        if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
+                return 1;
+
         return 0;
 }
 
@@ -3454,7 +3454,7 @@ static int megasas_init_fw(struct megasas_instance *instance)
 {
         u32 max_sectors_1;
         u32 max_sectors_2;
-        u32 tmp_sectors;
+        u32 tmp_sectors, msix_enable;
         struct megasas_register_set __iomem *reg_set;
         struct megasas_ctrl_info *ctrl_info;
         unsigned long bar_list;
@@ -3507,6 +3507,13 @@ static int megasas_init_fw(struct megasas_instance *instance)
         if (megasas_transition_to_ready(instance))
                 goto fail_ready_state;
 
+        /* Check if MSI-X is supported while in ready state */
+        msix_enable = (instance->instancet->read_fw_status_reg(reg_set) &
+                       0x4000000) >> 0x1a;
+        if (msix_enable && !msix_disable &&
+            !pci_enable_msix(instance->pdev, &instance->msixentry, 1))
+                instance->msi_flag = 1;
+
         /* Get operational params, sge flags, send init cmd to controller */
         if (instance->instancet->init_adapter(instance))
                 goto fail_init_adapter;
@@ -4076,14 +4083,6 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         else
                 INIT_WORK(&instance->work_init, process_fw_state_change_wq);
 
-        /* Try to enable MSI-X */
-        if ((instance->pdev->device != PCI_DEVICE_ID_LSI_SAS1078R) &&
-            (instance->pdev->device != PCI_DEVICE_ID_LSI_SAS1078DE) &&
-            (instance->pdev->device != PCI_DEVICE_ID_LSI_VERDE_ZCR) &&
-            !msix_disable && !pci_enable_msix(instance->pdev,
-                                              &instance->msixentry, 1))
-                instance->msi_flag = 1;
-
         /*
          * Initialize MFI Firmware
          */
@@ -4116,6 +4115,14 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         megasas_mgmt_info.max_index++;
 
         /*
+         * Register with SCSI mid-layer
+         */
+        if (megasas_io_attach(instance))
+                goto fail_io_attach;
+
+        instance->unload = 0;
+
+        /*
          * Initiate AEN (Asynchronous Event Notification)
          */
         if (megasas_start_aen(instance)) {
@@ -4123,13 +4130,6 @@ megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 goto fail_start_aen;
         }
 
-        /*
-         * Register with SCSI mid-layer
-         */
-        if (megasas_io_attach(instance))
-                goto fail_io_attach;
-
-        instance->unload = 0;
         return 0;
 
       fail_start_aen:
@@ -4332,10 +4332,6 @@ megasas_resume(struct pci_dev *pdev)
         if (megasas_set_dma_mask(pdev))
                 goto fail_set_dma_mask;
 
-        /* Now re-enable MSI-X */
-        if (instance->msi_flag)
-                pci_enable_msix(instance->pdev, &instance->msixentry, 1);
-
         /*
          * Initialize MFI Firmware
          */
@@ -4348,6 +4344,10 @@ megasas_resume(struct pci_dev *pdev)
         if (megasas_transition_to_ready(instance))
                 goto fail_ready_state;
 
+        /* Now re-enable MSI-X */
+        if (instance->msi_flag)
+                pci_enable_msix(instance->pdev, &instance->msixentry, 1);
+
         switch (instance->pdev->device) {
         case PCI_DEVICE_ID_LSI_FUSION:
         {
@@ -4384,12 +4384,6 @@ megasas_resume(struct pci_dev *pdev)
 
         instance->instancet->enable_intr(instance->reg_set);
 
-        /*
-         * Initiate AEN (Asynchronous Event Notification)
-         */
-        if (megasas_start_aen(instance))
-                printk(KERN_ERR "megasas: Start AEN failed\n");
-
         /* Initialize the cmd completion timer */
         if (poll_mode_io)
                 megasas_start_timer(instance, &instance->io_completion_timer,
@@ -4397,6 +4391,12 @@ megasas_resume(struct pci_dev *pdev)
                                 MEGASAS_COMPLETION_TIMER_INTERVAL);
         instance->unload = 0;
 
+        /*
+         * Initiate AEN (Asynchronous Event Notification)
+         */
+        if (megasas_start_aen(instance))
+                printk(KERN_ERR "megasas: Start AEN failed\n");
+
         return 0;
 
 fail_irq:
@@ -4527,6 +4527,11 @@ static void megasas_shutdown(struct pci_dev *pdev)
         instance->unload = 1;
         megasas_flush_cache(instance);
         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
+        instance->instancet->disable_intr(instance->reg_set);
+        free_irq(instance->msi_flag ? instance->msixentry.vector :
+                 instance->pdev->irq, instance);
+        if (instance->msi_flag)
+                pci_disable_msix(instance->pdev);
 }
 
 /**
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 145a8cffb1fa..f13e7abd345a 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -696,22 +696,6 @@ fail_get_cmd:
 }
 
 /*
- * megasas_return_cmd_for_smid -        Returns a cmd_fusion for a SMID
- * @instance:                           Adapter soft state
- *
- */
-void
-megasas_return_cmd_for_smid(struct megasas_instance *instance, u16 smid)
-{
-        struct fusion_context *fusion;
-        struct megasas_cmd_fusion *cmd;
-
-        fusion = instance->ctrl_context;
-        cmd = fusion->cmd_list[smid - 1];
-        megasas_return_cmd_fusion(instance, cmd);
-}
-
-/*
  * megasas_get_ld_map_info -    Returns FW's ld_map structure
  * @instance:                           Adapter soft state
  * @pend:                               Pend the command or not
@@ -1153,7 +1137,7 @@ megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
         u64 start_blk = io_info->pdBlock;
         u8 *cdb = io_request->CDB.CDB32;
         u32 num_blocks = io_info->numBlocks;
-        u8 opcode, flagvals, groupnum, control;
+        u8 opcode = 0, flagvals = 0, groupnum = 0, control = 0;
 
         /* Check if T10 PI (DIF) is enabled for this LD */
         ld = MR_TargetIdToLdGet(io_info->ldTgtId, local_map_ptr);
@@ -1235,7 +1219,46 @@ megasas_set_pd_lba(struct MPI2_RAID_SCSI_IO_REQUEST *io_request, u8 cdb_len,
                         cdb[8] = (u8)(num_blocks & 0xff);
                         cdb[7] = (u8)((num_blocks >> 8) & 0xff);
 
+                        io_request->IoFlags = 10; /* Specify 10-byte cdb */
                         cdb_len = 10;
+                } else if ((cdb_len < 16) && (start_blk > 0xffffffff)) {
+                        /* Convert to 16 byte CDB for large LBA's */
+                        switch (cdb_len) {
+                        case 6:
+                                opcode = cdb[0] == READ_6 ? READ_16 : WRITE_16;
+                                control = cdb[5];
+                                break;
+                        case 10:
+                                opcode =
+                                        cdb[0] == READ_10 ? READ_16 : WRITE_16;
+                                flagvals = cdb[1];
+                                groupnum = cdb[6];
+                                control = cdb[9];
+                                break;
+                        case 12:
+                                opcode =
+                                        cdb[0] == READ_12 ? READ_16 : WRITE_16;
+                                flagvals = cdb[1];
+                                groupnum = cdb[10];
+                                control = cdb[11];
+                                break;
+                        }
+
+                        memset(cdb, 0, sizeof(io_request->CDB.CDB32));
+
+                        cdb[0] = opcode;
+                        cdb[1] = flagvals;
+                        cdb[14] = groupnum;
+                        cdb[15] = control;
+
+                        /* Transfer length */
+                        cdb[13] = (u8)(num_blocks & 0xff);
+                        cdb[12] = (u8)((num_blocks >> 8) & 0xff);
+                        cdb[11] = (u8)((num_blocks >> 16) & 0xff);
+                        cdb[10] = (u8)((num_blocks >> 24) & 0xff);
+
+                        io_request->IoFlags = 16; /* Specify 16-byte cdb */
+                        cdb_len = 16;
                 }
 
                 /* Normal case, just load LBA here */
@@ -2026,17 +2049,11 @@ int megasas_reset_fusion(struct Scsi_Host *shost)
         struct fusion_context *fusion;
         struct megasas_cmd *cmd_mfi;
         union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
-        u32 host_diag, abs_state;
+        u32 host_diag, abs_state, status_reg, reset_adapter;
 
         instance = (struct megasas_instance *)shost->hostdata;
         fusion = instance->ctrl_context;
 
-        mutex_lock(&instance->reset_mutex);
-        set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
-        instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
-        instance->instancet->disable_intr(instance->reg_set);
-        msleep(1000);
-
         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
                 printk(KERN_WARNING "megaraid_sas: Hardware critical error, "
                        "returning FAILED.\n");
@@ -2044,6 +2061,12 @@ int megasas_reset_fusion(struct Scsi_Host *shost)
                 goto out;
         }
 
+        mutex_lock(&instance->reset_mutex);
+        set_bit(MEGASAS_FUSION_IN_RESET, &instance->reset_flags);
+        instance->adprecovery = MEGASAS_ADPRESET_SM_INFAULT;
+        instance->instancet->disable_intr(instance->reg_set);
+        msleep(1000);
+
         /* First try waiting for commands to complete */
         if (megasas_wait_for_outstanding_fusion(instance)) {
                 printk(KERN_WARNING "megaraid_sas: resetting fusion "
@@ -2060,7 +2083,12 @@ int megasas_reset_fusion(struct Scsi_Host *shost)
                         }
                 }
 
-                if (instance->disableOnlineCtrlReset == 1) {
+                status_reg = instance->instancet->read_fw_status_reg(
+                        instance->reg_set);
+                abs_state = status_reg & MFI_STATE_MASK;
+                reset_adapter = status_reg & MFI_RESET_ADAPTER;
+                if (instance->disableOnlineCtrlReset ||
+                    (abs_state == MFI_STATE_FAULT && !reset_adapter)) {
                         /* Reset not supported, kill adapter */
                         printk(KERN_WARNING "megaraid_sas: Reset not supported"
                                ", killing adapter.\n");
@@ -2089,6 +2117,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost)
 
                         /* Check that the diag write enable (DRWE) bit is on */
                         host_diag = readl(&instance->reg_set->fusion_host_diag);
+                        retry = 0;
                         while (!(host_diag & HOST_DIAG_WRITE_ENABLE)) {
                                 msleep(100);
                                 host_diag =
@@ -2126,7 +2155,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost)
 
                         abs_state =
                                 instance->instancet->read_fw_status_reg(
-                                        instance->reg_set);
+                                        instance->reg_set) & MFI_STATE_MASK;
                         retry = 0;
 
                         while ((abs_state <= MFI_STATE_FW_INIT) &&
@@ -2134,7 +2163,7 @@ int megasas_reset_fusion(struct Scsi_Host *shost)
                                 msleep(100);
                                 abs_state =
                                 instance->instancet->read_fw_status_reg(
-                                        instance->reg_set);
+                                        instance->reg_set) & MFI_STATE_MASK;
                         }
                         if (abs_state <= MFI_STATE_FW_INIT) {
                                 printk(KERN_WARNING "megaraid_sas: firmware "
diff --git a/drivers/scsi/mpt2sas/mpt2sas_base.h b/drivers/scsi/mpt2sas/mpt2sas_base.h
index 2a3c05f6db8b..dcc289c25459 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_base.h
+++ b/drivers/scsi/mpt2sas/mpt2sas_base.h
@@ -69,11 +69,11 @@
 #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          "08.100.00.01"
+#define MPT2SAS_DRIVER_VERSION          "08.100.00.02"
 #define MPT2SAS_MAJOR_VERSION           08
 #define MPT2SAS_MINOR_VERSION           100
 #define MPT2SAS_BUILD_VERSION           00
-#define MPT2SAS_RELEASE_VERSION         01
+#define MPT2SAS_RELEASE_VERSION         02
 
 /*
  * Set MPT2SAS_SG_DEPTH value based on user input.
diff --git a/drivers/scsi/mpt2sas/mpt2sas_scsih.c b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
index f12e02358d6d..a7dbc6825f5f 100644
--- a/drivers/scsi/mpt2sas/mpt2sas_scsih.c
+++ b/drivers/scsi/mpt2sas/mpt2sas_scsih.c
@@ -113,6 +113,7 @@ struct sense_info {
 };
 
 
+#define MPT2SAS_TURN_ON_FAULT_LED (0xFFFC)
 #define MPT2SAS_RESCAN_AFTER_HOST_RESET (0xFFFF)
 
 /**
@@ -121,6 +122,7 @@ struct sense_info {
  * @work: work object (ioc->fault_reset_work_q)
  * @cancel_pending_work: flag set during reset handling
  * @ioc: per adapter object
+ * @device_handle: device handle
  * @VF_ID: virtual function id
  * @VP_ID: virtual port id
  * @ignore: flag meaning this event has been marked to ignore
@@ -134,6 +136,7 @@ struct fw_event_work {
         u8                      cancel_pending_work;
         struct delayed_work     delayed_work;
         struct MPT2SAS_ADAPTER *ioc;
+        u16                     device_handle;
         u8                      VF_ID;
         u8                      VP_ID;
         u8                      ignore;
@@ -3499,6 +3502,7 @@ _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
 
         switch (prot_type) {
         case SCSI_PROT_DIF_TYPE1:
+        case SCSI_PROT_DIF_TYPE2:
 
                 /*
                 * enable ref/guard checking
@@ -3511,13 +3515,6 @@ _scsih_setup_eedp(struct scsi_cmnd *scmd, Mpi2SCSIIORequest_t *mpi_request)
                     cpu_to_be32(scsi_get_lba(scmd));
                 break;
 
-        case SCSI_PROT_DIF_TYPE2:
-
-                eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG |
-                    MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG |
-                    MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD;
-                break;
-
         case SCSI_PROT_DIF_TYPE3:
 
                 /*
@@ -4047,17 +4044,75 @@ _scsih_scsi_ioc_info(struct MPT2SAS_ADAPTER *ioc, struct scsi_cmnd *scmd,
 #endif
 
 /**
- * _scsih_smart_predicted_fault - illuminate Fault LED
+ * _scsih_turn_on_fault_led - illuminate Fault LED
  * @ioc: per adapter object
  * @handle: device handle
+ * Context: process
  *
  * Return nothing.
  */
 static void
-_scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+_scsih_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
 {
         Mpi2SepReply_t mpi_reply;
         Mpi2SepRequest_t mpi_request;
+
+        memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
+        mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
+        mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
+        mpi_request.SlotStatus =
+            cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
+        mpi_request.DevHandle = cpu_to_le16(handle);
+        mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
+        if ((mpt2sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
+            &mpi_request)) != 0) {
+                printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n", ioc->name,
+                __FILE__, __LINE__, __func__);
+                return;
+        }
+
+        if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
+                dewtprintk(ioc, printk(MPT2SAS_INFO_FMT "enclosure_processor: "
+                    "ioc_status (0x%04x), loginfo(0x%08x)\n", ioc->name,
+                    le16_to_cpu(mpi_reply.IOCStatus),
+                    le32_to_cpu(mpi_reply.IOCLogInfo)));
+                return;
+        }
+}
+
+/**
+ * _scsih_send_event_to_turn_on_fault_led - fire delayed event
+ * @ioc: per adapter object
+ * @handle: device handle
+ * Context: interrupt.
+ *
+ * Return nothing.
+ */
+static void
+_scsih_send_event_to_turn_on_fault_led(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+{
+        struct fw_event_work *fw_event;
+
+        fw_event = kzalloc(sizeof(struct fw_event_work), GFP_ATOMIC);
+        if (!fw_event)
+                return;
+        fw_event->event = MPT2SAS_TURN_ON_FAULT_LED;
+        fw_event->device_handle = handle;
+        fw_event->ioc = ioc;
+        _scsih_fw_event_add(ioc, fw_event);
+}
+
+/**
+ * _scsih_smart_predicted_fault - process smart errors
+ * @ioc: per adapter object
+ * @handle: device handle
+ * Context: interrupt.
+ *
+ * Return nothing.
+ */
+static void
+_scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
+{
         struct scsi_target *starget;
         struct MPT2SAS_TARGET *sas_target_priv_data;
         Mpi2EventNotificationReply_t *event_reply;
@@ -4084,30 +4139,8 @@ _scsih_smart_predicted_fault(struct MPT2SAS_ADAPTER *ioc, u16 handle)
         starget_printk(KERN_WARNING, starget, "predicted fault\n");
         spin_unlock_irqrestore(&ioc->sas_device_lock, flags);
 
-        if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) {
-                memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t));
-                mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR;
-                mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS;
-                mpi_request.SlotStatus =
-                    cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT);
-                mpi_request.DevHandle = cpu_to_le16(handle);
-                mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS;
-                if ((mpt2sas_base_scsi_enclosure_processor(ioc, &mpi_reply,
-                    &mpi_request)) != 0) {
-                        printk(MPT2SAS_ERR_FMT "failure at %s:%d/%s()!\n",
-                            ioc->name, __FILE__, __LINE__, __func__);
-                        return;
-                }
-
-                if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) {
-                        dewtprintk(ioc, printk(MPT2SAS_INFO_FMT
-                            "enclosure_processor: ioc_status (0x%04x), "
-                            "loginfo(0x%08x)\n", ioc->name,
-                            le16_to_cpu(mpi_reply.IOCStatus),
-                            le32_to_cpu(mpi_reply.IOCLogInfo)));
-                        return;
-                }
-        }
+        if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM)
+                _scsih_send_event_to_turn_on_fault_led(ioc, handle);
 
         /* insert into event log */
         sz = offsetof(Mpi2EventNotificationReply_t, EventData) +
@@ -6753,6 +6786,9 @@ _firmware_event_work(struct work_struct *work)
         }
 
         switch (fw_event->event) {
+        case MPT2SAS_TURN_ON_FAULT_LED:
+                _scsih_turn_on_fault_led(ioc, fw_event->device_handle);
+                break;
         case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST:
                 _scsih_sas_topology_change_event(ioc, fw_event);
                 break;
diff --git a/drivers/scsi/osst.c b/drivers/scsi/osst.c
index 58f5be4740e9..de0b1a704fb5 100644
--- a/drivers/scsi/osst.c
+++ b/drivers/scsi/osst.c
@@ -4698,12 +4698,14 @@ static int __os_scsi_tape_open(struct inode * inode, struct file * filp)
                         break;
 
                         if ((SRpnt->sense[2] & 0x0f) == UNIT_ATTENTION) {
+                                int j;
+
                                 STp->pos_unknown = 0;
                                 STp->partition = STp->new_partition = 0;
                                 if (STp->can_partitions)
                                         STp->nbr_partitions = 1;  /* This guess will be updated later if necessary */
-                                for (i=0; i < ST_NBR_PARTITIONS; i++) {
-                                        STps = &(STp->ps[i]);
+                                for (j = 0; j < ST_NBR_PARTITIONS; j++) {
+                                        STps = &(STp->ps[j]);
                                         STps->rw = ST_IDLE;
                                         STps->eof = ST_NOEOF;
                                         STps->at_sm = 0;
diff --git a/drivers/scsi/qla4xxx/Makefile b/drivers/scsi/qla4xxx/Makefile
index 0339ff03a535..252523d7847e 100644
--- a/drivers/scsi/qla4xxx/Makefile
+++ b/drivers/scsi/qla4xxx/Makefile
@@ -1,5 +1,5 @@
 qla4xxx-y := ql4_os.o ql4_init.o ql4_mbx.o ql4_iocb.o ql4_isr.o \
-                ql4_nx.o ql4_nvram.o ql4_dbg.o
+                ql4_nx.o ql4_nvram.o ql4_dbg.o ql4_attr.o
 
 obj-$(CONFIG_SCSI_QLA_ISCSI) += qla4xxx.o
 
diff --git a/drivers/scsi/qla4xxx/ql4_attr.c b/drivers/scsi/qla4xxx/ql4_attr.c
new file mode 100644
index 000000000000..864d018631c0
--- /dev/null
+++ b/drivers/scsi/qla4xxx/ql4_attr.c
@@ -0,0 +1,69 @@
+/*
+ * QLogic iSCSI HBA Driver
+ * Copyright (c)  2003-2011 QLogic Corporation
+ *
+ * See LICENSE.qla4xxx for copyright and licensing details.
+ */
+
+#include "ql4_def.h"
+#include "ql4_glbl.h"
+#include "ql4_dbg.h"
+
+/* Scsi_Host attributes. */
+static ssize_t
+qla4xxx_fw_version_show(struct device *dev,
+                        struct device_attribute *attr, char *buf)
+{
+        struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
+
+        if (is_qla8022(ha))
+                return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d (%x)\n",
+                                ha->firmware_version[0],
+                                ha->firmware_version[1],
+                                ha->patch_number, ha->build_number);
+        else
+                return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
+                                ha->firmware_version[0],
+                                ha->firmware_version[1],
+                                ha->patch_number, ha->build_number);
+}
+
+static ssize_t
+qla4xxx_serial_num_show(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
+        return snprintf(buf, PAGE_SIZE, "%s\n", ha->serial_number);
+}
+
+static ssize_t
+qla4xxx_iscsi_version_show(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
+        return snprintf(buf, PAGE_SIZE, "%d.%02d\n", ha->iscsi_major,
+                        ha->iscsi_minor);
+}
+
+static ssize_t
+qla4xxx_optrom_version_show(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct scsi_qla_host *ha = to_qla_host(class_to_shost(dev));
+        return snprintf(buf, PAGE_SIZE, "%d.%02d.%02d.%02d\n",
+                        ha->bootload_major, ha->bootload_minor,
+                        ha->bootload_patch, ha->bootload_build);
+}
+
+static DEVICE_ATTR(fw_version, S_IRUGO, qla4xxx_fw_version_show, NULL);
+static DEVICE_ATTR(serial_num, S_IRUGO, qla4xxx_serial_num_show, NULL);
+static DEVICE_ATTR(iscsi_version, S_IRUGO, qla4xxx_iscsi_version_show, NULL);
+static DEVICE_ATTR(optrom_version, S_IRUGO, qla4xxx_optrom_version_show, NULL);
+
+struct device_attribute *qla4xxx_host_attrs[] = {
+        &dev_attr_fw_version,
+        &dev_attr_serial_num,
+        &dev_attr_iscsi_version,
+        &dev_attr_optrom_version,
+        NULL,
+};
diff --git a/drivers/scsi/qla4xxx/ql4_def.h b/drivers/scsi/qla4xxx/ql4_def.h
index 4757878d59dd..473c5c872b39 100644
--- a/drivers/scsi/qla4xxx/ql4_def.h
+++ b/drivers/scsi/qla4xxx/ql4_def.h
@@ -115,7 +115,7 @@
 #define INVALID_ENTRY           0xFFFF
 #define MAX_CMDS_TO_RISC        1024
 #define MAX_SRBS                MAX_CMDS_TO_RISC
-#define MBOX_AEN_REG_COUNT      5
+#define MBOX_AEN_REG_COUNT      8
 #define MAX_INIT_RETRIES        5
 
 /*
@@ -368,7 +368,6 @@ struct scsi_qla_host {
 #define AF_INIT_DONE                    1 /* 0x00000002 */
 #define AF_MBOX_COMMAND                 2 /* 0x00000004 */
 #define AF_MBOX_COMMAND_DONE            3 /* 0x00000008 */
-#define AF_DPC_SCHEDULED                5 /* 0x00000020 */
 #define AF_INTERRUPTS_ON                6 /* 0x00000040 */
 #define AF_GET_CRASH_RECORD             7 /* 0x00000080 */
 #define AF_LINK_UP                      8 /* 0x00000100 */
@@ -584,6 +583,14 @@ struct scsi_qla_host {
         uint32_t nx_reset_timeout;
 
         struct completion mbx_intr_comp;
+
+        /* --- From About Firmware --- */
+        uint16_t iscsi_major;
+        uint16_t iscsi_minor;
+        uint16_t bootload_major;
+        uint16_t bootload_minor;
+        uint16_t bootload_patch;
+        uint16_t bootload_build;
 };
 
 static inline int is_ipv4_enabled(struct scsi_qla_host *ha)
diff --git a/drivers/scsi/qla4xxx/ql4_fw.h b/drivers/scsi/qla4xxx/ql4_fw.h
index 31e2bf97198c..01082aa77098 100644
--- a/drivers/scsi/qla4xxx/ql4_fw.h
+++ b/drivers/scsi/qla4xxx/ql4_fw.h
@@ -690,6 +690,29 @@ struct mbx_sys_info {
         uint8_t reserved[12];             /* 34-3f */
 };
 
+struct about_fw_info {
+        uint16_t fw_major;              /* 00 - 01 */
+        uint16_t fw_minor;              /* 02 - 03 */
+        uint16_t fw_patch;              /* 04 - 05 */
+        uint16_t fw_build;              /* 06 - 07 */
+        uint8_t fw_build_date[16];      /* 08 - 17 ASCII String */
+        uint8_t fw_build_time[16];      /* 18 - 27 ASCII String */
+        uint8_t fw_build_user[16];      /* 28 - 37 ASCII String */
+        uint16_t fw_load_source;        /* 38 - 39 */
+                                        /* 1 = Flash Primary,
+                                           2 = Flash Secondary,
+                                           3 = Host Download
+                                        */
+        uint8_t reserved1[6];           /* 3A - 3F */
+        uint16_t iscsi_major;           /* 40 - 41 */
+        uint16_t iscsi_minor;           /* 42 - 43 */
+        uint16_t bootload_major;        /* 44 - 45 */
+        uint16_t bootload_minor;        /* 46 - 47 */
+        uint16_t bootload_patch;        /* 48 - 49 */
+        uint16_t bootload_build;        /* 4A - 4B */
+        uint8_t reserved2[180];         /* 4C - FF */
+};
+
 struct crash_record {
         uint16_t fw_major_version;      /* 00 - 01 */
         uint16_t fw_minor_version;      /* 02 - 03 */
diff --git a/drivers/scsi/qla4xxx/ql4_glbl.h b/drivers/scsi/qla4xxx/ql4_glbl.h
index cc53e3fbd78c..a53a256c1f8d 100644
--- a/drivers/scsi/qla4xxx/ql4_glbl.h
+++ b/drivers/scsi/qla4xxx/ql4_glbl.h
@@ -61,7 +61,7 @@ struct ddb_entry *qla4xxx_alloc_sess(struct scsi_qla_host *ha);
 int qla4xxx_add_sess(struct ddb_entry *);
 void qla4xxx_destroy_sess(struct ddb_entry *ddb_entry);
 int qla4xxx_is_nvram_configuration_valid(struct scsi_qla_host *ha);
-int qla4xxx_get_fw_version(struct scsi_qla_host * ha);
+int qla4xxx_about_firmware(struct scsi_qla_host *ha);
 void qla4xxx_interrupt_service_routine(struct scsi_qla_host *ha,
                                        uint32_t intr_status);
 int qla4xxx_init_rings(struct scsi_qla_host *ha);
@@ -139,4 +139,5 @@ extern int ql4xextended_error_logging;
 extern int ql4xdontresethba;
 extern int ql4xenablemsix;
 
+extern struct device_attribute *qla4xxx_host_attrs[];
 #endif /* _QLA4x_GBL_H */
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index 48e2241ddaf4..42ed5db2d530 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -1275,7 +1275,7 @@ int qla4xxx_initialize_adapter(struct scsi_qla_host *ha,
         if (ha->isp_ops->start_firmware(ha) == QLA_ERROR)
                 goto exit_init_hba;
 
-        if (qla4xxx_get_fw_version(ha) == QLA_ERROR)
+        if (qla4xxx_about_firmware(ha) == QLA_ERROR)
                 goto exit_init_hba;
 
         if (ha->isp_ops->get_sys_info(ha) == QLA_ERROR)
diff --git a/drivers/scsi/qla4xxx/ql4_isr.c b/drivers/scsi/qla4xxx/ql4_isr.c
index 2f40ac761cd4..0e72921c752d 100644
--- a/drivers/scsi/qla4xxx/ql4_isr.c
+++ b/drivers/scsi/qla4xxx/ql4_isr.c
@@ -25,9 +25,14 @@ static void qla4xxx_copy_sense(struct scsi_qla_host *ha,
 
         memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
         sense_len = le16_to_cpu(sts_entry->senseDataByteCnt);
-        if (sense_len == 0)
+        if (sense_len == 0) {
+                DEBUG2(ql4_printk(KERN_INFO, ha, "scsi%ld:%d:%d:%d: %s:"
+                                  " sense len 0\n", ha->host_no,
+                                  cmd->device->channel, cmd->device->id,
+                                  cmd->device->lun, __func__));
+                ha->status_srb = NULL;
                 return;
-
+        }
         /* Save total available sense length,
          * not to exceed cmd's sense buffer size */
         sense_len = min_t(uint16_t, sense_len, SCSI_SENSE_BUFFERSIZE);
@@ -541,6 +546,7 @@ static void qla4xxx_isr_decode_mailbox(struct scsi_qla_host * ha,
                 case MBOX_ASTS_UNSOLICITED_PDU_RECEIVED:  /* Connection mode */
                 case MBOX_ASTS_IPSEC_SYSTEM_FATAL_ERROR:
                 case MBOX_ASTS_SUBNET_STATE_CHANGE:
+                case MBOX_ASTS_DUPLICATE_IP:
                         /* No action */
                         DEBUG2(printk("scsi%ld: AEN %04x\n", ha->host_no,
                                       mbox_status));
@@ -593,11 +599,13 @@ static void qla4xxx_isr_decode_mailbox(struct scsi_qla_host * ha,
                                             mbox_sts[i];
 
                                 /* print debug message */
-                                DEBUG2(printk("scsi%ld: AEN[%d] %04x queued"
-                                    " mb1:0x%x mb2:0x%x mb3:0x%x mb4:0x%x\n",
-                                    ha->host_no, ha->aen_in, mbox_sts[0],
-                                    mbox_sts[1], mbox_sts[2],  mbox_sts[3],
-                                    mbox_sts[4]));
+                                DEBUG2(printk("scsi%ld: AEN[%d] %04x queued "
+                                              "mb1:0x%x mb2:0x%x mb3:0x%x "
+                                              "mb4:0x%x mb5:0x%x\n",
+                                              ha->host_no, ha->aen_in,
+                                              mbox_sts[0], mbox_sts[1],
+                                              mbox_sts[2], mbox_sts[3],
+                                              mbox_sts[4], mbox_sts[5]));
 
                                 /* advance pointer */
                                 ha->aen_in++;
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index d78b58dc5011..fce8289e9752 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -86,22 +86,8 @@ int qla4xxx_mailbox_command(struct scsi_qla_host *ha, uint8_t inCount,
                 msleep(10);
         }
 
-        /* To prevent overwriting mailbox registers for a command that has
-         * not yet been serviced, check to see if an active command
-         * (AEN, IOCB, etc.) is interrupting, then service it.
-         * -----------------------------------------------------------------
-         */
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
-        if (!is_qla8022(ha)) {
-                intr_status = readl(&ha->reg->ctrl_status);
-                if (intr_status & CSR_SCSI_PROCESSOR_INTR) {
-                        /* Service existing interrupt */
-                        ha->isp_ops->interrupt_service_routine(ha, intr_status);
-                        clear_bit(AF_MBOX_COMMAND_DONE, &ha->flags);
-                }
-        }
-
         ha->mbox_status_count = outCount;
         for (i = 0; i < outCount; i++)
                 ha->mbox_status[i] = 0;
@@ -1057,38 +1043,65 @@ int qla4xxx_get_flash(struct scsi_qla_host * ha, dma_addr_t dma_addr,
 }
 
 /**
- * qla4xxx_get_fw_version - gets firmware version
+ * qla4xxx_about_firmware - gets FW, iscsi draft and boot loader version
  * @ha: Pointer to host adapter structure.
  *
- * Retrieves the firmware version on HBA. In QLA4010, mailboxes 2 & 3 may
- * hold an address for data.  Make sure that we write 0 to those mailboxes,
- * if unused.
+ * Retrieves the FW version, iSCSI draft version & bootloader version of HBA.
+ * Mailboxes 2 & 3 may hold an address for data. Make sure that we write 0 to
+ * those mailboxes, if unused.
  **/
-int qla4xxx_get_fw_version(struct scsi_qla_host * ha)
+int qla4xxx_about_firmware(struct scsi_qla_host *ha)
 {
+        struct about_fw_info *about_fw = NULL;
+        dma_addr_t about_fw_dma;
         uint32_t mbox_cmd[MBOX_REG_COUNT];
         uint32_t mbox_sts[MBOX_REG_COUNT];
+        int status = QLA_ERROR;
+
+        about_fw = dma_alloc_coherent(&ha->pdev->dev,
+                                      sizeof(struct about_fw_info),
+                                      &about_fw_dma, GFP_KERNEL);
+        if (!about_fw) {
+                DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Unable to alloc memory "
+                                  "for about_fw\n", __func__));
+                return status;
+        }
 
-        /* Get firmware version. */
+        memset(about_fw, 0, sizeof(struct about_fw_info));
         memset(&mbox_cmd, 0, sizeof(mbox_cmd));
         memset(&mbox_sts, 0, sizeof(mbox_sts));
 
         mbox_cmd[0] = MBOX_CMD_ABOUT_FW;
-
-        if (qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, 5, &mbox_cmd[0], &mbox_sts[0]) !=
-            QLA_SUCCESS) {
-                DEBUG2(printk("scsi%ld: %s: MBOX_CMD_ABOUT_FW failed w/ "
-                    "status %04X\n", ha->host_no, __func__, mbox_sts[0]));
-                return QLA_ERROR;
+        mbox_cmd[2] = LSDW(about_fw_dma);
+        mbox_cmd[3] = MSDW(about_fw_dma);
+        mbox_cmd[4] = sizeof(struct about_fw_info);
+
+        status = qla4xxx_mailbox_command(ha, MBOX_REG_COUNT, MBOX_REG_COUNT,
+                                         &mbox_cmd[0], &mbox_sts[0]);
+        if (status != QLA_SUCCESS) {
+                DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: MBOX_CMD_ABOUT_FW "
+                                  "failed w/ status %04X\n", __func__,
+                                  mbox_sts[0]));
+                goto exit_about_fw;
         }
 
-        /* Save firmware version information. */
-        ha->firmware_version[0] = mbox_sts[1];
-        ha->firmware_version[1] = mbox_sts[2];
-        ha->patch_number = mbox_sts[3];
-        ha->build_number = mbox_sts[4];
+        /* Save version information. */
+        ha->firmware_version[0] = le16_to_cpu(about_fw->fw_major);
+        ha->firmware_version[1] = le16_to_cpu(about_fw->fw_minor);
+        ha->patch_number = le16_to_cpu(about_fw->fw_patch);
+        ha->build_number = le16_to_cpu(about_fw->fw_build);
+        ha->iscsi_major = le16_to_cpu(about_fw->iscsi_major);
+        ha->iscsi_minor = le16_to_cpu(about_fw->iscsi_minor);
+        ha->bootload_major = le16_to_cpu(about_fw->bootload_major);
+        ha->bootload_minor = le16_to_cpu(about_fw->bootload_minor);
+        ha->bootload_patch = le16_to_cpu(about_fw->bootload_patch);
+        ha->bootload_build = le16_to_cpu(about_fw->bootload_build);
+        status = QLA_SUCCESS;
 
-        return QLA_SUCCESS;
+exit_about_fw:
+        dma_free_coherent(&ha->pdev->dev, sizeof(struct about_fw_info),
+                          about_fw, about_fw_dma);
+        return status;
 }
 
 static int qla4xxx_get_default_ddb(struct scsi_qla_host *ha,
diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
index 03e522b2fe0b..fdfe27b38698 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.c
+++ b/drivers/scsi/qla4xxx/ql4_nx.c
@@ -964,12 +964,26 @@ qla4_8xxx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
         /* Halt all the indiviual PEGs and other blocks of the ISP */
         qla4_8xxx_rom_lock(ha);
 
-        /* mask all niu interrupts */
+        /* disable all I2Q */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_I2Q + 0x10, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_I2Q + 0x14, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_I2Q + 0x18, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_I2Q + 0x1c, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_I2Q + 0x20, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_I2Q + 0x24, 0x0);
+
+        /* disable all niu interrupts */
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x40, 0xff);
         /* disable xge rx/tx */
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x70000, 0x00);
         /* disable xg1 rx/tx */
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x80000, 0x00);
+        /* disable sideband mac */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0x90000, 0x00);
+        /* disable ap0 mac */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0xa0000, 0x00);
+        /* disable ap1 mac */
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_NIU + 0xb0000, 0x00);
 
         /* halt sre */
         val = qla4_8xxx_rd_32(ha, QLA82XX_CRB_SRE + 0x1000);
@@ -984,6 +998,7 @@ qla4_8xxx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x10, 0x0);
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x18, 0x0);
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x100, 0x0);
+        qla4_8xxx_wr_32(ha, QLA82XX_CRB_TIMER + 0x200, 0x0);
 
         /* halt pegs */
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_0 + 0x3c, 1);
@@ -991,9 +1006,9 @@ qla4_8xxx_pinit_from_rom(struct scsi_qla_host *ha, int verbose)
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_2 + 0x3c, 1);
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_3 + 0x3c, 1);
         qla4_8xxx_wr_32(ha, QLA82XX_CRB_PEG_NET_4 + 0x3c, 1);
+        msleep(5);
 
         /* big hammer */
-        msleep(1000);
         if (test_bit(DPC_RESET_HA, &ha->dpc_flags))
                 /* don't reset CAM block on reset */
                 qla4_8xxx_wr_32(ha, QLA82XX_ROMUSB_GLB_SW_RESET, 0xfeffffff);
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index c22f2a764d9d..f2364ec59f03 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -124,6 +124,7 @@ static struct scsi_host_template qla4xxx_driver_template = {
         .sg_tablesize           = SG_ALL,
 
         .max_sectors            = 0xFFFF,
+        .shost_attrs            = qla4xxx_host_attrs,
 };
 
 static struct iscsi_transport qla4xxx_iscsi_transport = {
@@ -412,8 +413,7 @@ void qla4xxx_mark_all_devices_missing(struct scsi_qla_host *ha)
 
 static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha,
                                        struct ddb_entry *ddb_entry,
-                                       struct scsi_cmnd *cmd,
-                                       void (*done)(struct scsi_cmnd *))
+                                       struct scsi_cmnd *cmd)
 {
         struct srb *srb;
 
@@ -427,7 +427,6 @@ static struct srb* qla4xxx_get_new_srb(struct scsi_qla_host *ha,
         srb->cmd = cmd;
         srb->flags = 0;
         CMD_SP(cmd) = (void *)srb;
-        cmd->scsi_done = done;
 
         return srb;
 }
@@ -458,9 +457,8 @@ void qla4xxx_srb_compl(struct kref *ref)
 
 /**
  * qla4xxx_queuecommand - scsi layer issues scsi command to driver.
+ * @host: scsi host
  * @cmd: Pointer to Linux's SCSI command structure
- * @done_fn: Function that the driver calls to notify the SCSI mid-layer
- *      that the command has been processed.
  *
  * Remarks:
  * This routine is invoked by Linux to send a SCSI command to the driver.
@@ -470,10 +468,9 @@ void qla4xxx_srb_compl(struct kref *ref)
  * completion handling).   Unfortunely, it sometimes calls the scheduler
  * in interrupt context which is a big NO! NO!.
  **/
-static int qla4xxx_queuecommand_lck(struct scsi_cmnd *cmd,
-                                void (*done)(struct scsi_cmnd *))
+static int qla4xxx_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 {
-        struct scsi_qla_host *ha = to_qla_host(cmd->device->host);
+        struct scsi_qla_host *ha = to_qla_host(host);
         struct ddb_entry *ddb_entry = cmd->device->hostdata;
         struct iscsi_cls_session *sess = ddb_entry->sess;
         struct srb *srb;
@@ -515,37 +512,29 @@ static int qla4xxx_queuecommand_lck(struct scsi_cmnd *cmd,
             test_bit(DPC_RESET_HA_FW_CONTEXT, &ha->dpc_flags))
                 goto qc_host_busy;
 
-        spin_unlock_irq(ha->host->host_lock);
-
-        srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd, done);
+        srb = qla4xxx_get_new_srb(ha, ddb_entry, cmd);
         if (!srb)
-                goto qc_host_busy_lock;
+                goto qc_host_busy;
 
         rval = qla4xxx_send_command_to_isp(ha, srb);
         if (rval != QLA_SUCCESS)
                 goto qc_host_busy_free_sp;
 
-        spin_lock_irq(ha->host->host_lock);
         return 0;
 
 qc_host_busy_free_sp:
         qla4xxx_srb_free_dma(ha, srb);
         mempool_free(srb, ha->srb_mempool);
 
-qc_host_busy_lock:
-        spin_lock_irq(ha->host->host_lock);
-
 qc_host_busy:
         return SCSI_MLQUEUE_HOST_BUSY;
 
 qc_fail_command:
-        done(cmd);
+        cmd->scsi_done(cmd);
 
         return 0;
 }
 
-static DEF_SCSI_QCMD(qla4xxx_queuecommand)
-
 /**
  * qla4xxx_mem_free - frees memory allocated to adapter
  * @ha: Pointer to host adapter structure.
@@ -679,7 +668,27 @@ static void qla4_8xxx_check_fw_alive(struct scsi_qla_host *ha)
                 if (ha->seconds_since_last_heartbeat == 2) {
                         ha->seconds_since_last_heartbeat = 0;
                         halt_status = qla4_8xxx_rd_32(ha,
-                            QLA82XX_PEG_HALT_STATUS1);
+                                                      QLA82XX_PEG_HALT_STATUS1);
+
+                        ql4_printk(KERN_INFO, ha,
+                                   "scsi(%ld): %s, Dumping hw/fw registers:\n "
+                                   " PEG_HALT_STATUS1: 0x%x, PEG_HALT_STATUS2:"
+                                   " 0x%x,\n PEG_NET_0_PC: 0x%x, PEG_NET_1_PC:"
+                                   " 0x%x,\n PEG_NET_2_PC: 0x%x, PEG_NET_3_PC:"
+                                   " 0x%x,\n PEG_NET_4_PC: 0x%x\n",
+                                   ha->host_no, __func__, halt_status,
+                                   qla4_8xxx_rd_32(ha,
+                                                   QLA82XX_PEG_HALT_STATUS2),
+                                   qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_0 +
+                                                   0x3c),
+                                   qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_1 +
+                                                   0x3c),
+                                   qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_2 +
+                                                   0x3c),
+                                   qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_3 +
+                                                   0x3c),
+                                   qla4_8xxx_rd_32(ha, QLA82XX_CRB_PEG_NET_4 +
+                                                   0x3c));
 
                         /* Since we cannot change dev_state in interrupt
                          * context, set appropriate DPC flag then wakeup
@@ -715,7 +724,7 @@ void qla4_8xxx_watchdog(struct scsi_qla_host *ha)
         /* don't poll if reset is going on */
         if (!(test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags) ||
             test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
-            test_bit(DPC_RESET_ACTIVE, &ha->dpc_flags))) {
+            test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags))) {
                 if (dev_state == QLA82XX_DEV_NEED_RESET &&
                     !test_bit(DPC_RESET_HA, &ha->dpc_flags)) {
                         if (!ql4xdontresethba) {
@@ -839,7 +848,7 @@ static void qla4xxx_timer(struct scsi_qla_host *ha)
         }
 
         /* Wakeup the dpc routine for this adapter, if needed. */
-        if ((start_dpc ||
+        if (start_dpc ||
              test_bit(DPC_RESET_HA, &ha->dpc_flags) ||
              test_bit(DPC_RETRY_RESET_HA, &ha->dpc_flags) ||
              test_bit(DPC_RELOGIN_DEVICE, &ha->dpc_flags) ||
@@ -849,9 +858,7 @@ static void qla4xxx_timer(struct scsi_qla_host *ha)
              test_bit(DPC_LINK_CHANGED, &ha->dpc_flags) ||
              test_bit(DPC_HA_UNRECOVERABLE, &ha->dpc_flags) ||
              test_bit(DPC_HA_NEED_QUIESCENT, &ha->dpc_flags) ||
-             test_bit(DPC_AEN, &ha->dpc_flags)) &&
-             !test_bit(AF_DPC_SCHEDULED, &ha->flags) &&
-             ha->dpc_thread) {
+             test_bit(DPC_AEN, &ha->dpc_flags)) {
                 DEBUG2(printk("scsi%ld: %s: scheduling dpc routine"
                               " - dpc flags = 0x%lx\n",
                               ha->host_no, __func__, ha->dpc_flags));
@@ -1241,11 +1248,8 @@ static void qla4xxx_relogin_all_devices(struct scsi_qla_host *ha)
 
 void qla4xxx_wake_dpc(struct scsi_qla_host *ha)
 {
-        if (ha->dpc_thread &&
-            !test_bit(AF_DPC_SCHEDULED, &ha->flags)) {
-                set_bit(AF_DPC_SCHEDULED, &ha->flags);
+        if (ha->dpc_thread)
                 queue_work(ha->dpc_thread, &ha->dpc_work);
-        }
 }
 
 /**
@@ -1272,12 +1276,12 @@ static void qla4xxx_do_dpc(struct work_struct *work)
 
         /* Initialization not yet finished. Don't do anything yet. */
         if (!test_bit(AF_INIT_DONE, &ha->flags))
-                goto do_dpc_exit;
+                return;
 
         if (test_bit(AF_EEH_BUSY, &ha->flags)) {
                 DEBUG2(printk(KERN_INFO "scsi%ld: %s: flags = %lx\n",
                     ha->host_no, __func__, ha->flags));
-                goto do_dpc_exit;
+                return;
         }
 
         if (is_qla8022(ha)) {
@@ -1384,8 +1388,6 @@ dpc_post_reset_ha:
                 }
         }
 
-do_dpc_exit:
-        clear_bit(AF_DPC_SCHEDULED, &ha->flags);
 }
 
 /**
diff --git a/drivers/scsi/qla4xxx/ql4_version.h b/drivers/scsi/qla4xxx/ql4_version.h
index 603155769407..610492877253 100644
--- a/drivers/scsi/qla4xxx/ql4_version.h
+++ b/drivers/scsi/qla4xxx/ql4_version.h
@@ -5,4 +5,4 @@
  * See LICENSE.qla4xxx for copyright and licensing details.
  */
 
-#define QLA4XXX_DRIVER_VERSION  "5.02.00-k6"
+#define QLA4XXX_DRIVER_VERSION  "5.02.00-k7"
diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
index abea2cf05c2e..a4b9cdbaaa0b 100644
--- a/drivers/scsi/scsi_error.c
+++ b/drivers/scsi/scsi_error.c
@@ -50,6 +50,8 @@
 #define BUS_RESET_SETTLE_TIME   (10)
 #define HOST_RESET_SETTLE_TIME  (10)
 
+static int scsi_eh_try_stu(struct scsi_cmnd *scmd);
+
 /* called with shost->host_lock held */
 void scsi_eh_wakeup(struct Scsi_Host *shost)
 {
@@ -947,6 +949,48 @@ retry_tur:
 }
 
 /**
+ * scsi_eh_test_devices - check if devices are responding from error recovery.
+ * @cmd_list:   scsi commands in error recovery.
+ * @work_q:     queue for commands which still need more error recovery
+ * @done_q:     queue for commands which are finished
+ * @try_stu:    boolean on if a STU command should be tried in addition to TUR.
+ *
+ * Decription:
+ *    Tests if devices are in a working state.  Commands to devices now in
+ *    a working state are sent to the done_q while commands to devices which
+ *    are still failing to respond are returned to the work_q for more
+ *    processing.
+ **/
+static int scsi_eh_test_devices(struct list_head *cmd_list,
+                                struct list_head *work_q,
+                                struct list_head *done_q, int try_stu)
+{
+        struct scsi_cmnd *scmd, *next;
+        struct scsi_device *sdev;
+        int finish_cmds;
+
+        while (!list_empty(cmd_list)) {
+                scmd = list_entry(cmd_list->next, struct scsi_cmnd, eh_entry);
+                sdev = scmd->device;
+
+                finish_cmds = !scsi_device_online(scmd->device) ||
+                        (try_stu && !scsi_eh_try_stu(scmd) &&
+                         !scsi_eh_tur(scmd)) ||
+                        !scsi_eh_tur(scmd);
+
+                list_for_each_entry_safe(scmd, next, cmd_list, eh_entry)
+                        if (scmd->device == sdev) {
+                                if (finish_cmds)
+                                        scsi_eh_finish_cmd(scmd, done_q);
+                                else
+                                        list_move_tail(&scmd->eh_entry, work_q);
+                        }
+        }
+        return list_empty(work_q);
+}
+
+
+/**
  * scsi_eh_abort_cmds - abort pending commands.
  * @work_q:     &list_head for pending commands.
  * @done_q:     &list_head for processed commands.
@@ -962,6 +1006,7 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
                               struct list_head *done_q)
 {
         struct scsi_cmnd *scmd, *next;
+        LIST_HEAD(check_list);
         int rtn;
 
         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
@@ -973,11 +1018,10 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
                 rtn = scsi_try_to_abort_cmd(scmd->device->host->hostt, scmd);
                 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
                         scmd->eh_eflags &= ~SCSI_EH_CANCEL_CMD;
-                        if (!scsi_device_online(scmd->device) ||
-                            rtn == FAST_IO_FAIL ||
-                            !scsi_eh_tur(scmd)) {
+                        if (rtn == FAST_IO_FAIL)
                                 scsi_eh_finish_cmd(scmd, done_q);
-                        }
+                        else
+                                list_move_tail(&scmd->eh_entry, &check_list);
                 } else
                         SCSI_LOG_ERROR_RECOVERY(3, printk("%s: aborting"
                                                           " cmd failed:"
@@ -986,7 +1030,7 @@ static int scsi_eh_abort_cmds(struct list_head *work_q,
                                                           scmd));
         }
 
-        return list_empty(work_q);
+        return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
 }
 
 /**
@@ -1137,6 +1181,7 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
                                 struct list_head *done_q)
 {
         LIST_HEAD(tmp_list);
+        LIST_HEAD(check_list);
 
         list_splice_init(work_q, &tmp_list);
 
@@ -1161,9 +1206,9 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
                         if (scmd_id(scmd) != id)
                                 continue;
 
-                        if ((rtn == SUCCESS || rtn == FAST_IO_FAIL)
-                            && (!scsi_device_online(scmd->device) ||
-                                 rtn == FAST_IO_FAIL || !scsi_eh_tur(scmd)))
+                        if (rtn == SUCCESS)
+                                list_move_tail(&scmd->eh_entry, &check_list);
+                        else if (rtn == FAST_IO_FAIL)
                                 scsi_eh_finish_cmd(scmd, done_q);
                         else
                                 /* push back on work queue for further processing */
@@ -1171,7 +1216,7 @@ static int scsi_eh_target_reset(struct Scsi_Host *shost,
                 }
         }
 
-        return list_empty(work_q);
+        return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
 }
 
 /**
@@ -1185,6 +1230,7 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
                              struct list_head *done_q)
 {
         struct scsi_cmnd *scmd, *chan_scmd, *next;
+        LIST_HEAD(check_list);
         unsigned int channel;
         int rtn;
 
@@ -1216,12 +1262,14 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
                 rtn = scsi_try_bus_reset(chan_scmd);
                 if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
                         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
-                                if (channel == scmd_channel(scmd))
-                                        if (!scsi_device_online(scmd->device) ||
-                                            rtn == FAST_IO_FAIL ||
-                                            !scsi_eh_tur(scmd))
+                                if (channel == scmd_channel(scmd)) {
+                                        if (rtn == FAST_IO_FAIL)
                                                 scsi_eh_finish_cmd(scmd,
                                                                    done_q);
+                                        else
+                                                list_move_tail(&scmd->eh_entry,
+                                                               &check_list);
+                                }
                         }
                 } else {
                         SCSI_LOG_ERROR_RECOVERY(3, printk("%s: BRST"
@@ -1230,7 +1278,7 @@ static int scsi_eh_bus_reset(struct Scsi_Host *shost,
                                                           channel));
                 }
         }
-        return list_empty(work_q);
+        return scsi_eh_test_devices(&check_list, work_q, done_q, 0);
 }
 
 /**
@@ -1242,6 +1290,7 @@ static int scsi_eh_host_reset(struct list_head *work_q,
                               struct list_head *done_q)
 {
         struct scsi_cmnd *scmd, *next;
+        LIST_HEAD(check_list);
         int rtn;
 
         if (!list_empty(work_q)) {
@@ -1252,12 +1301,10 @@ static int scsi_eh_host_reset(struct list_head *work_q,
                                                   , current->comm));
 
                 rtn = scsi_try_host_reset(scmd);
-                if (rtn == SUCCESS || rtn == FAST_IO_FAIL) {
+                if (rtn == SUCCESS) {
+                        list_splice_init(work_q, &check_list);
+                } else if (rtn == FAST_IO_FAIL) {
                         list_for_each_entry_safe(scmd, next, work_q, eh_entry) {
-                                if (!scsi_device_online(scmd->device) ||
-                                    rtn == FAST_IO_FAIL ||
-                                    (!scsi_eh_try_stu(scmd) && !scsi_eh_tur(scmd)) ||
-                                    !scsi_eh_tur(scmd))
                                         scsi_eh_finish_cmd(scmd, done_q);
                         }
                 } else {
@@ -1266,7 +1313,7 @@ static int scsi_eh_host_reset(struct list_head *work_q,
                                                           current->comm));
                 }
         }
-        return list_empty(work_q);
+        return scsi_eh_test_devices(&check_list, work_q, done_q, 1);
 }
 
 /**
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index f46855cd853d..ad747dc337da 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -381,11 +381,6 @@ static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
         return err;
 }
 
-/**
- * proc_scsi_show - show contents of /proc/scsi/scsi (attached devices)
- * @s: output goes here
- * @p: not used
- */
 static int always_match(struct device *dev, void *data)
 {
         return 1;
diff --git a/drivers/scsi/scsi_trace.c b/drivers/scsi/scsi_trace.c
index b587289cfacb..2bea4f0b684a 100644
--- a/drivers/scsi/scsi_trace.c
+++ b/drivers/scsi/scsi_trace.c
@@ -59,6 +59,10 @@ scsi_trace_rw10(struct trace_seq *p, unsigned char *cdb, int len)
         trace_seq_printf(p, "lba=%llu txlen=%llu protect=%u",
                          (unsigned long long)lba, (unsigned long long)txlen,
                          cdb[1] >> 5);
+
+        if (cdb[0] == WRITE_SAME)
+                trace_seq_printf(p, " unmap=%u", cdb[1] >> 3 & 1);
+
         trace_seq_putc(p, 0);
 
         return ret;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index bd0806e64e85..953773cb26d9 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -490,7 +490,8 @@ static void sd_config_discard(struct scsi_disk *sdkp, unsigned int mode)
         unsigned int max_blocks = 0;
 
         q->limits.discard_zeroes_data = sdkp->lbprz;
-        q->limits.discard_alignment = sdkp->unmap_alignment;
+        q->limits.discard_alignment = sdkp->unmap_alignment *
+                logical_block_size;
         q->limits.discard_granularity =
                 max(sdkp->physical_block_size,
                     sdkp->unmap_granularity * logical_block_size);
@@ -2021,16 +2022,26 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
 
         int dbd;
         int modepage;
+        int first_len;
         struct scsi_mode_data data;
         struct scsi_sense_hdr sshdr;
         int old_wce = sdkp->WCE;
         int old_rcd = sdkp->RCD;
         int old_dpofua = sdkp->DPOFUA;
 
-        if (sdp->skip_ms_page_8)
-                goto defaults;
-
-        if (sdp->type == TYPE_RBC) {
+        first_len = 4;
+        if (sdp->skip_ms_page_8) {
+                if (sdp->type == TYPE_RBC)
+                        goto defaults;
+                else {
+                        if (sdp->skip_ms_page_3f)
+                                goto defaults;
+                        modepage = 0x3F;
+                        if (sdp->use_192_bytes_for_3f)
+                                first_len = 192;
+                        dbd = 0;
+                }
+        } else if (sdp->type == TYPE_RBC) {
                 modepage = 6;
                 dbd = 8;
         } else {
@@ -2039,13 +2050,15 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
         }
 
         /* cautiously ask */
-        res = sd_do_mode_sense(sdp, dbd, modepage, buffer, 4, &data, &sshdr);
+        res = sd_do_mode_sense(sdp, dbd, modepage, buffer, first_len,
+                        &data, &sshdr);
 
         if (!scsi_status_is_good(res))
                 goto bad_sense;
 
         if (!data.header_length) {
                 modepage = 6;
+                first_len = 0;
                 sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n");
         }
 
@@ -2058,30 +2071,61 @@ sd_read_cache_type(struct scsi_disk *sdkp, unsigned char *buffer)
          */
         if (len < 3)
                 goto bad_sense;
-        if (len > 20)
-                len = 20;
-
-        /* Take headers and block descriptors into account */
-        len += data.header_length + data.block_descriptor_length;
-        if (len > SD_BUF_SIZE)
-                goto bad_sense;
+        else if (len > SD_BUF_SIZE) {
+                sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter "
+                          "data from %d to %d bytes\n", len, SD_BUF_SIZE);
+                len = SD_BUF_SIZE;
+        }
+        if (modepage == 0x3F && sdp->use_192_bytes_for_3f)
+                len = 192;
 
         /* Get the data */
-        res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr);
+        if (len > first_len)
+                res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len,
+                                &data, &sshdr);
 
         if (scsi_status_is_good(res)) {
                 int offset = data.header_length + data.block_descriptor_length;
 
-                if (offset >= SD_BUF_SIZE - 2) {
-                        sd_printk(KERN_ERR, sdkp, "Malformed MODE SENSE response\n");
-                        goto defaults;
+                while (offset < len) {
+                        u8 page_code = buffer[offset] & 0x3F;
+                        u8 spf       = buffer[offset] & 0x40;
+
+                        if (page_code == 8 || page_code == 6) {
+                                /* We're interested only in the first 3 bytes.
+                                 */
+                                if (len - offset <= 2) {
+                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
+                                                  "mode parameter data\n");
+                                        goto defaults;
+                                } else {
+                                        modepage = page_code;
+                                        goto Page_found;
+                                }
+                        } else {
+                                /* Go to the next page */
+                                if (spf && len - offset > 3)
+                                        offset += 4 + (buffer[offset+2] << 8) +
+                                                buffer[offset+3];
+                                else if (!spf && len - offset > 1)
+                                        offset += 2 + buffer[offset+1];
+                                else {
+                                        sd_printk(KERN_ERR, sdkp, "Incomplete "
+                                                  "mode parameter data\n");
+                                        goto defaults;
+                                }
+                        }
                 }
 
-                if ((buffer[offset] & 0x3f) != modepage) {
+                if (modepage == 0x3F) {
+                        sd_printk(KERN_ERR, sdkp, "No Caching mode page "
+                                  "present\n");
+                        goto defaults;
+                } else if ((buffer[offset] & 0x3f) != modepage) {
                         sd_printk(KERN_ERR, sdkp, "Got wrong page\n");
                         goto defaults;
                 }
-
+        Page_found:
                 if (modepage == 8) {
                         sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0);
                         sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0);
diff --git a/drivers/scsi/ultrastor.c b/drivers/scsi/ultrastor.c
index 9f4b58b7daad..7e22b737dfd8 100644
--- a/drivers/scsi/ultrastor.c
+++ b/drivers/scsi/ultrastor.c
@@ -307,7 +307,7 @@ static inline int find_and_clear_bit_16(unsigned long *field)
         "0: bsfw %1,%w0\n\t"
         "btr %0,%1\n\t"
         "jnc 0b"
-        : "=&r" (rv), "=m" (*field) :);
+        : "=&r" (rv), "+m" (*field) :);
 
   return rv;
 }
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index fbd96b29530d..de35c3ad8a69 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -80,6 +80,15 @@ config SPI_BFIN
         help
           This is the SPI controller master driver for Blackfin 5xx processor.
 
+config SPI_BFIN_SPORT
+        tristate "SPI bus via Blackfin SPORT"
+        depends on BLACKFIN
+        help
+          Enable support for a SPI bus via the Blackfin SPORT peripheral.
+
+          This driver can also be built as a module.  If so, the module
+          will be called spi_bfin_sport.
+
 config SPI_AU1550
         tristate "Au1550/Au12x0 SPI Controller"
         depends on (SOC_AU1550 || SOC_AU1200) && EXPERIMENTAL
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index fd2fc5f6505f..0f8c69b6b19e 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -13,6 +13,7 @@ obj-$(CONFIG_SPI_ALTERA)		+= spi_altera.o
 obj-$(CONFIG_SPI_ATMEL)                 += atmel_spi.o
 obj-$(CONFIG_SPI_ATH79)                 += ath79_spi.o
 obj-$(CONFIG_SPI_BFIN)                  += spi_bfin5xx.o
+obj-$(CONFIG_SPI_BFIN_SPORT)            += spi_bfin_sport.o
 obj-$(CONFIG_SPI_BITBANG)               += spi_bitbang.o
 obj-$(CONFIG_SPI_AU1550)                += au1550_spi.o
 obj-$(CONFIG_SPI_BUTTERFLY)             += spi_butterfly.o
diff --git a/drivers/spi/spi_bfin_sport.c b/drivers/spi/spi_bfin_sport.c
new file mode 100644
index 000000000000..e557ff617b11
--- /dev/null
+++ b/drivers/spi/spi_bfin_sport.c
@@ -0,0 +1,952 @@
+/*
+ * SPI bus via the Blackfin SPORT peripheral
+ *
+ * Enter bugs at http://blackfin.uclinux.org/
+ *
+ * Copyright 2009-2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/gpio.h>
+#include <linux/io.h>
+#include <linux/ioport.h>
+#include <linux/irq.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/spi/spi.h>
+#include <linux/workqueue.h>
+
+#include <asm/portmux.h>
+#include <asm/bfin5xx_spi.h>
+#include <asm/blackfin.h>
+#include <asm/bfin_sport.h>
+#include <asm/cacheflush.h>
+
+#define DRV_NAME        "bfin-sport-spi"
+#define DRV_DESC        "SPI bus via the Blackfin SPORT"
+
+MODULE_AUTHOR("Cliff Cai");
+MODULE_DESCRIPTION(DRV_DESC);
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:bfin-sport-spi");
+
+enum bfin_sport_spi_state {
+        START_STATE,
+        RUNNING_STATE,
+        DONE_STATE,
+        ERROR_STATE,
+};
+
+struct bfin_sport_spi_master_data;
+
+struct bfin_sport_transfer_ops {
+        void (*write) (struct bfin_sport_spi_master_data *);
+        void (*read) (struct bfin_sport_spi_master_data *);
+        void (*duplex) (struct bfin_sport_spi_master_data *);
+};
+
+struct bfin_sport_spi_master_data {
+        /* Driver model hookup */
+        struct device *dev;
+
+        /* SPI framework hookup */
+        struct spi_master *master;
+
+        /* Regs base of SPI controller */
+        struct sport_register __iomem *regs;
+        int err_irq;
+
+        /* Pin request list */
+        u16 *pin_req;
+
+        /* Driver message queue */
+        struct workqueue_struct *workqueue;
+        struct work_struct pump_messages;
+        spinlock_t lock;
+        struct list_head queue;
+        int busy;
+        bool run;
+
+        /* Message Transfer pump */
+        struct tasklet_struct pump_transfers;
+
+        /* Current message transfer state info */
+        enum bfin_sport_spi_state state;
+        struct spi_message *cur_msg;
+        struct spi_transfer *cur_transfer;
+        struct bfin_sport_spi_slave_data *cur_chip;
+        union {
+                void *tx;
+                u8 *tx8;
+                u16 *tx16;
+        };
+        void *tx_end;
+        union {
+                void *rx;
+                u8 *rx8;
+                u16 *rx16;
+        };
+        void *rx_end;
+
+        int cs_change;
+        struct bfin_sport_transfer_ops *ops;
+};
+
+struct bfin_sport_spi_slave_data {
+        u16 ctl_reg;
+        u16 baud;
+        u16 cs_chg_udelay;      /* Some devices require > 255usec delay */
+        u32 cs_gpio;
+        u16 idle_tx_val;
+        struct bfin_sport_transfer_ops *ops;
+};
+
+static void
+bfin_sport_spi_enable(struct bfin_sport_spi_master_data *drv_data)
+{
+        bfin_write_or(&drv_data->regs->tcr1, TSPEN);
+        bfin_write_or(&drv_data->regs->rcr1, TSPEN);
+        SSYNC();
+}
+
+static void
+bfin_sport_spi_disable(struct bfin_sport_spi_master_data *drv_data)
+{
+        bfin_write_and(&drv_data->regs->tcr1, ~TSPEN);
+        bfin_write_and(&drv_data->regs->rcr1, ~TSPEN);
+        SSYNC();
+}
+
+/* Caculate the SPI_BAUD register value based on input HZ */
+static u16
+bfin_sport_hz_to_spi_baud(u32 speed_hz)
+{
+        u_long clk, sclk = get_sclk();
+        int div = (sclk / (2 * speed_hz)) - 1;
+
+        if (div < 0)
+                div = 0;
+
+        clk = sclk / (2 * (div + 1));
+
+        if (clk > speed_hz)
+                div++;
+
+        return div;
+}
+
+/* Chip select operation functions for cs_change flag */
+static void
+bfin_sport_spi_cs_active(struct bfin_sport_spi_slave_data *chip)
+{
+        gpio_direction_output(chip->cs_gpio, 0);
+}
+
+static void
+bfin_sport_spi_cs_deactive(struct bfin_sport_spi_slave_data *chip)
+{
+        gpio_direction_output(chip->cs_gpio, 1);
+        /* Move delay here for consistency */
+        if (chip->cs_chg_udelay)
+                udelay(chip->cs_chg_udelay);
+}
+
+static void
+bfin_sport_spi_stat_poll_complete(struct bfin_sport_spi_master_data *drv_data)
+{
+        unsigned long timeout = jiffies + HZ;
+        while (!(bfin_read(&drv_data->regs->stat) & RXNE)) {
+                if (!time_before(jiffies, timeout))
+                        break;
+        }
+}
+
+static void
+bfin_sport_spi_u8_writer(struct bfin_sport_spi_master_data *drv_data)
+{
+        u16 dummy;
+
+        while (drv_data->tx < drv_data->tx_end) {
+                bfin_write(&drv_data->regs->tx16, *drv_data->tx8++);
+                bfin_sport_spi_stat_poll_complete(drv_data);
+                dummy = bfin_read(&drv_data->regs->rx16);
+        }
+}
+
+static void
+bfin_sport_spi_u8_reader(struct bfin_sport_spi_master_data *drv_data)
+{
+        u16 tx_val = drv_data->cur_chip->idle_tx_val;
+
+        while (drv_data->rx < drv_data->rx_end) {
+                bfin_write(&drv_data->regs->tx16, tx_val);
+                bfin_sport_spi_stat_poll_complete(drv_data);
+                *drv_data->rx8++ = bfin_read(&drv_data->regs->rx16);
+        }
+}
+
+static void
+bfin_sport_spi_u8_duplex(struct bfin_sport_spi_master_data *drv_data)
+{
+        while (drv_data->rx < drv_data->rx_end) {
+                bfin_write(&drv_data->regs->tx16, *drv_data->tx8++);
+                bfin_sport_spi_stat_poll_complete(drv_data);
+                *drv_data->rx8++ = bfin_read(&drv_data->regs->rx16);
+        }
+}
+
+static struct bfin_sport_transfer_ops bfin_sport_transfer_ops_u8 = {
+        .write  = bfin_sport_spi_u8_writer,
+        .read   = bfin_sport_spi_u8_reader,
+        .duplex = bfin_sport_spi_u8_duplex,
+};
+
+static void
+bfin_sport_spi_u16_writer(struct bfin_sport_spi_master_data *drv_data)
+{
+        u16 dummy;
+
+        while (drv_data->tx < drv_data->tx_end) {
+                bfin_write(&drv_data->regs->tx16, *drv_data->tx16++);
+                bfin_sport_spi_stat_poll_complete(drv_data);
+                dummy = bfin_read(&drv_data->regs->rx16);
+        }
+}
+
+static void
+bfin_sport_spi_u16_reader(struct bfin_sport_spi_master_data *drv_data)
+{
+        u16 tx_val = drv_data->cur_chip->idle_tx_val;
+
+        while (drv_data->rx < drv_data->rx_end) {
+                bfin_write(&drv_data->regs->tx16, tx_val);
+                bfin_sport_spi_stat_poll_complete(drv_data);
+                *drv_data->rx16++ = bfin_read(&drv_data->regs->rx16);
+        }
+}
+
+static void
+bfin_sport_spi_u16_duplex(struct bfin_sport_spi_master_data *drv_data)
+{
+        while (drv_data->rx < drv_data->rx_end) {
+                bfin_write(&drv_data->regs->tx16, *drv_data->tx16++);
+                bfin_sport_spi_stat_poll_complete(drv_data);
+                *drv_data->rx16++ = bfin_read(&drv_data->regs->rx16);
+        }
+}
+
+static struct bfin_sport_transfer_ops bfin_sport_transfer_ops_u16 = {
+        .write  = bfin_sport_spi_u16_writer,
+        .read   = bfin_sport_spi_u16_reader,
+        .duplex = bfin_sport_spi_u16_duplex,
+};
+
+/* stop controller and re-config current chip */
+static void
+bfin_sport_spi_restore_state(struct bfin_sport_spi_master_data *drv_data)
+{
+        struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
+        unsigned int bits = (drv_data->ops == &bfin_sport_transfer_ops_u8 ? 7 : 15);
+
+        bfin_sport_spi_disable(drv_data);
+        dev_dbg(drv_data->dev, "restoring spi ctl state\n");
+
+        bfin_write(&drv_data->regs->tcr1, chip->ctl_reg);
+        bfin_write(&drv_data->regs->tcr2, bits);
+        bfin_write(&drv_data->regs->tclkdiv, chip->baud);
+        bfin_write(&drv_data->regs->tfsdiv, bits);
+        SSYNC();
+
+        bfin_write(&drv_data->regs->rcr1, chip->ctl_reg & ~(ITCLK | ITFS));
+        bfin_write(&drv_data->regs->rcr2, bits);
+        SSYNC();
+
+        bfin_sport_spi_cs_active(chip);
+}
+
+/* test if there is more transfer to be done */
+static enum bfin_sport_spi_state
+bfin_sport_spi_next_transfer(struct bfin_sport_spi_master_data *drv_data)
+{
+        struct spi_message *msg = drv_data->cur_msg;
+        struct spi_transfer *trans = drv_data->cur_transfer;
+
+        /* Move to next transfer */
+        if (trans->transfer_list.next != &msg->transfers) {
+                drv_data->cur_transfer =
+                    list_entry(trans->transfer_list.next,
+                               struct spi_transfer, transfer_list);
+                return RUNNING_STATE;
+        }
+
+        return DONE_STATE;
+}
+
+/*
+ * caller already set message->status;
+ * dma and pio irqs are blocked give finished message back
+ */
+static void
+bfin_sport_spi_giveback(struct bfin_sport_spi_master_data *drv_data)
+{
+        struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
+        unsigned long flags;
+        struct spi_message *msg;
+
+        spin_lock_irqsave(&drv_data->lock, flags);
+        msg = drv_data->cur_msg;
+        drv_data->state = START_STATE;
+        drv_data->cur_msg = NULL;
+        drv_data->cur_transfer = NULL;
+        drv_data->cur_chip = NULL;
+        queue_work(drv_data->workqueue, &drv_data->pump_messages);
+        spin_unlock_irqrestore(&drv_data->lock, flags);
+
+        if (!drv_data->cs_change)
+                bfin_sport_spi_cs_deactive(chip);
+
+        if (msg->complete)
+                msg->complete(msg->context);
+}
+
+static irqreturn_t
+sport_err_handler(int irq, void *dev_id)
+{
+        struct bfin_sport_spi_master_data *drv_data = dev_id;
+        u16 status;
+
+        dev_dbg(drv_data->dev, "%s enter\n", __func__);
+        status = bfin_read(&drv_data->regs->stat) & (TOVF | TUVF | ROVF | RUVF);
+
+        if (status) {
+                bfin_write(&drv_data->regs->stat, status);
+                SSYNC();
+
+                bfin_sport_spi_disable(drv_data);
+                dev_err(drv_data->dev, "status error:%s%s%s%s\n",
+                        status & TOVF ? " TOVF" : "",
+                        status & TUVF ? " TUVF" : "",
+                        status & ROVF ? " ROVF" : "",
+                        status & RUVF ? " RUVF" : "");
+        }
+
+        return IRQ_HANDLED;
+}
+
+static void
+bfin_sport_spi_pump_transfers(unsigned long data)
+{
+        struct bfin_sport_spi_master_data *drv_data = (void *)data;
+        struct spi_message *message = NULL;
+        struct spi_transfer *transfer = NULL;
+        struct spi_transfer *previous = NULL;
+        struct bfin_sport_spi_slave_data *chip = NULL;
+        unsigned int bits_per_word;
+        u32 tranf_success = 1;
+        u32 transfer_speed;
+        u8 full_duplex = 0;
+
+        /* Get current state information */
+        message = drv_data->cur_msg;
+        transfer = drv_data->cur_transfer;
+        chip = drv_data->cur_chip;
+
+        if (transfer->speed_hz)
+                transfer_speed = bfin_sport_hz_to_spi_baud(transfer->speed_hz);
+        else
+                transfer_speed = chip->baud;
+        bfin_write(&drv_data->regs->tclkdiv, transfer_speed);
+        SSYNC();
+
+        /*
+         * if msg is error or done, report it back using complete() callback
+         */
+
+         /* Handle for abort */
+        if (drv_data->state == ERROR_STATE) {
+                dev_dbg(drv_data->dev, "transfer: we've hit an error\n");
+                message->status = -EIO;
+                bfin_sport_spi_giveback(drv_data);
+                return;
+        }
+
+        /* Handle end of message */
+        if (drv_data->state == DONE_STATE) {
+                dev_dbg(drv_data->dev, "transfer: all done!\n");
+                message->status = 0;
+                bfin_sport_spi_giveback(drv_data);
+                return;
+        }
+
+        /* Delay if requested at end of transfer */
+        if (drv_data->state == RUNNING_STATE) {
+                dev_dbg(drv_data->dev, "transfer: still running ...\n");
+                previous = list_entry(transfer->transfer_list.prev,
+                                      struct spi_transfer, transfer_list);
+                if (previous->delay_usecs)
+                        udelay(previous->delay_usecs);
+        }
+
+        if (transfer->len == 0) {
+                /* Move to next transfer of this msg */
+                drv_data->state = bfin_sport_spi_next_transfer(drv_data);
+                /* Schedule next transfer tasklet */
+                tasklet_schedule(&drv_data->pump_transfers);
+        }
+
+        if (transfer->tx_buf != NULL) {
+                drv_data->tx = (void *)transfer->tx_buf;
+                drv_data->tx_end = drv_data->tx + transfer->len;
+                dev_dbg(drv_data->dev, "tx_buf is %p, tx_end is %p\n",
+                        transfer->tx_buf, drv_data->tx_end);
+        } else
+                drv_data->tx = NULL;
+
+        if (transfer->rx_buf != NULL) {
+                full_duplex = transfer->tx_buf != NULL;
+                drv_data->rx = transfer->rx_buf;
+                drv_data->rx_end = drv_data->rx + transfer->len;
+                dev_dbg(drv_data->dev, "rx_buf is %p, rx_end is %p\n",
+                        transfer->rx_buf, drv_data->rx_end);
+        } else
+                drv_data->rx = NULL;
+
+        drv_data->cs_change = transfer->cs_change;
+
+        /* Bits per word setup */
+        bits_per_word = transfer->bits_per_word ? : message->spi->bits_per_word;
+        if (bits_per_word == 8)
+                drv_data->ops = &bfin_sport_transfer_ops_u8;
+        else
+                drv_data->ops = &bfin_sport_transfer_ops_u16;
+
+        drv_data->state = RUNNING_STATE;
+
+        if (drv_data->cs_change)
+                bfin_sport_spi_cs_active(chip);
+
+        dev_dbg(drv_data->dev,
+                "now pumping a transfer: width is %d, len is %d\n",
+                bits_per_word, transfer->len);
+
+        /* PIO mode write then read */
+        dev_dbg(drv_data->dev, "doing IO transfer\n");
+
+        bfin_sport_spi_enable(drv_data);
+        if (full_duplex) {
+                /* full duplex mode */
+                BUG_ON((drv_data->tx_end - drv_data->tx) !=
+                       (drv_data->rx_end - drv_data->rx));
+                drv_data->ops->duplex(drv_data);
+
+                if (drv_data->tx != drv_data->tx_end)
+                        tranf_success = 0;
+        } else if (drv_data->tx != NULL) {
+                /* write only half duplex */
+
+                drv_data->ops->write(drv_data);
+
+                if (drv_data->tx != drv_data->tx_end)
+                        tranf_success = 0;
+        } else if (drv_data->rx != NULL) {
+                /* read only half duplex */
+
+                drv_data->ops->read(drv_data);
+                if (drv_data->rx != drv_data->rx_end)
+                        tranf_success = 0;
+        }
+        bfin_sport_spi_disable(drv_data);
+
+        if (!tranf_success) {
+                dev_dbg(drv_data->dev, "IO write error!\n");
+                drv_data->state = ERROR_STATE;
+        } else {
+                /* Update total byte transfered */
+                message->actual_length += transfer->len;
+                /* Move to next transfer of this msg */
+                drv_data->state = bfin_sport_spi_next_transfer(drv_data);
+                if (drv_data->cs_change)
+                        bfin_sport_spi_cs_deactive(chip);
+        }
+
+        /* Schedule next transfer tasklet */
+        tasklet_schedule(&drv_data->pump_transfers);
+}
+
+/* pop a msg from queue and kick off real transfer */
+static void
+bfin_sport_spi_pump_messages(struct work_struct *work)
+{
+        struct bfin_sport_spi_master_data *drv_data;
+        unsigned long flags;
+        struct spi_message *next_msg;
+
+        drv_data = container_of(work, struct bfin_sport_spi_master_data, pump_messages);
+
+        /* Lock queue and check for queue work */
+        spin_lock_irqsave(&drv_data->lock, flags);
+        if (list_empty(&drv_data->queue) || !drv_data->run) {
+                /* pumper kicked off but no work to do */
+                drv_data->busy = 0;
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+                return;
+        }
+
+        /* Make sure we are not already running a message */
+        if (drv_data->cur_msg) {
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+                return;
+        }
+
+        /* Extract head of queue */
+        next_msg = list_entry(drv_data->queue.next,
+                struct spi_message, queue);
+
+        drv_data->cur_msg = next_msg;
+
+        /* Setup the SSP using the per chip configuration */
+        drv_data->cur_chip = spi_get_ctldata(drv_data->cur_msg->spi);
+
+        list_del_init(&drv_data->cur_msg->queue);
+
+        /* Initialize message state */
+        drv_data->cur_msg->state = START_STATE;
+        drv_data->cur_transfer = list_entry(drv_data->cur_msg->transfers.next,
+                                            struct spi_transfer, transfer_list);
+        bfin_sport_spi_restore_state(drv_data);
+        dev_dbg(drv_data->dev, "got a message to pump, "
+                "state is set to: baud %d, cs_gpio %i, ctl 0x%x\n",
+                drv_data->cur_chip->baud, drv_data->cur_chip->cs_gpio,
+                drv_data->cur_chip->ctl_reg);
+
+        dev_dbg(drv_data->dev,
+                "the first transfer len is %d\n",
+                drv_data->cur_transfer->len);
+
+        /* Mark as busy and launch transfers */
+        tasklet_schedule(&drv_data->pump_transfers);
+
+        drv_data->busy = 1;
+        spin_unlock_irqrestore(&drv_data->lock, flags);
+}
+
+/*
+ * got a msg to transfer, queue it in drv_data->queue.
+ * And kick off message pumper
+ */
+static int
+bfin_sport_spi_transfer(struct spi_device *spi, struct spi_message *msg)
+{
+        struct bfin_sport_spi_master_data *drv_data = spi_master_get_devdata(spi->master);
+        unsigned long flags;
+
+        spin_lock_irqsave(&drv_data->lock, flags);
+
+        if (!drv_data->run) {
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+                return -ESHUTDOWN;
+        }
+
+        msg->actual_length = 0;
+        msg->status = -EINPROGRESS;
+        msg->state = START_STATE;
+
+        dev_dbg(&spi->dev, "adding an msg in transfer()\n");
+        list_add_tail(&msg->queue, &drv_data->queue);
+
+        if (drv_data->run && !drv_data->busy)
+                queue_work(drv_data->workqueue, &drv_data->pump_messages);
+
+        spin_unlock_irqrestore(&drv_data->lock, flags);
+
+        return 0;
+}
+
+/* Called every time common spi devices change state */
+static int
+bfin_sport_spi_setup(struct spi_device *spi)
+{
+        struct bfin_sport_spi_slave_data *chip, *first = NULL;
+        int ret;
+
+        /* Only alloc (or use chip_info) on first setup */
+        chip = spi_get_ctldata(spi);
+        if (chip == NULL) {
+                struct bfin5xx_spi_chip *chip_info;
+
+                chip = first = kzalloc(sizeof(*chip), GFP_KERNEL);
+                if (!chip)
+                        return -ENOMEM;
+
+                /* platform chip_info isn't required */
+                chip_info = spi->controller_data;
+                if (chip_info) {
+                        /*
+                         * DITFS and TDTYPE are only thing we don't set, but
+                         * they probably shouldn't be changed by people.
+                         */
+                        if (chip_info->ctl_reg || chip_info->enable_dma) {
+                                ret = -EINVAL;
+                                dev_err(&spi->dev, "don't set ctl_reg/enable_dma fields");
+                                goto error;
+                        }
+                        chip->cs_chg_udelay = chip_info->cs_chg_udelay;
+                        chip->idle_tx_val = chip_info->idle_tx_val;
+                        spi->bits_per_word = chip_info->bits_per_word;
+                }
+        }
+
+        if (spi->bits_per_word != 8 && spi->bits_per_word != 16) {
+                ret = -EINVAL;
+                goto error;
+        }
+
+        /* translate common spi framework into our register
+         * following configure contents are same for tx and rx.
+         */
+
+        if (spi->mode & SPI_CPHA)
+                chip->ctl_reg &= ~TCKFE;
+        else
+                chip->ctl_reg |= TCKFE;
+
+        if (spi->mode & SPI_LSB_FIRST)
+                chip->ctl_reg |= TLSBIT;
+        else
+                chip->ctl_reg &= ~TLSBIT;
+
+        /* Sport in master mode */
+        chip->ctl_reg |= ITCLK | ITFS | TFSR | LATFS | LTFS;
+
+        chip->baud = bfin_sport_hz_to_spi_baud(spi->max_speed_hz);
+
+        chip->cs_gpio = spi->chip_select;
+        ret = gpio_request(chip->cs_gpio, spi->modalias);
+        if (ret)
+                goto error;
+
+        dev_dbg(&spi->dev, "setup spi chip %s, width is %d\n",
+                        spi->modalias, spi->bits_per_word);
+        dev_dbg(&spi->dev, "ctl_reg is 0x%x, GPIO is %i\n",
+                        chip->ctl_reg, spi->chip_select);
+
+        spi_set_ctldata(spi, chip);
+
+        bfin_sport_spi_cs_deactive(chip);
+
+        return ret;
+
+ error:
+        kfree(first);
+        return ret;
+}
+
+/*
+ * callback for spi framework.
+ * clean driver specific data
+ */
+static void
+bfin_sport_spi_cleanup(struct spi_device *spi)
+{
+        struct bfin_sport_spi_slave_data *chip = spi_get_ctldata(spi);
+
+        if (!chip)
+                return;
+
+        gpio_free(chip->cs_gpio);
+
+        kfree(chip);
+}
+
+static int
+bfin_sport_spi_init_queue(struct bfin_sport_spi_master_data *drv_data)
+{
+        INIT_LIST_HEAD(&drv_data->queue);
+        spin_lock_init(&drv_data->lock);
+
+        drv_data->run = false;
+        drv_data->busy = 0;
+
+        /* init transfer tasklet */
+        tasklet_init(&drv_data->pump_transfers,
+                     bfin_sport_spi_pump_transfers, (unsigned long)drv_data);
+
+        /* init messages workqueue */
+        INIT_WORK(&drv_data->pump_messages, bfin_sport_spi_pump_messages);
+        drv_data->workqueue =
+            create_singlethread_workqueue(dev_name(drv_data->master->dev.parent));
+        if (drv_data->workqueue == NULL)
+                return -EBUSY;
+
+        return 0;
+}
+
+static int
+bfin_sport_spi_start_queue(struct bfin_sport_spi_master_data *drv_data)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&drv_data->lock, flags);
+
+        if (drv_data->run || drv_data->busy) {
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+                return -EBUSY;
+        }
+
+        drv_data->run = true;
+        drv_data->cur_msg = NULL;
+        drv_data->cur_transfer = NULL;
+        drv_data->cur_chip = NULL;
+        spin_unlock_irqrestore(&drv_data->lock, flags);
+
+        queue_work(drv_data->workqueue, &drv_data->pump_messages);
+
+        return 0;
+}
+
+static inline int
+bfin_sport_spi_stop_queue(struct bfin_sport_spi_master_data *drv_data)
+{
+        unsigned long flags;
+        unsigned limit = 500;
+        int status = 0;
+
+        spin_lock_irqsave(&drv_data->lock, flags);
+
+        /*
+         * This is a bit lame, but is optimized for the common execution path.
+         * A wait_queue on the drv_data->busy could be used, but then the common
+         * execution path (pump_messages) would be required to call wake_up or
+         * friends on every SPI message. Do this instead
+         */
+        drv_data->run = false;
+        while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+                msleep(10);
+                spin_lock_irqsave(&drv_data->lock, flags);
+        }
+
+        if (!list_empty(&drv_data->queue) || drv_data->busy)
+                status = -EBUSY;
+
+        spin_unlock_irqrestore(&drv_data->lock, flags);
+
+        return status;
+}
+
+static inline int
+bfin_sport_spi_destroy_queue(struct bfin_sport_spi_master_data *drv_data)
+{
+        int status;
+
+        status = bfin_sport_spi_stop_queue(drv_data);
+        if (status)
+                return status;
+
+        destroy_workqueue(drv_data->workqueue);
+
+        return 0;
+}
+
+static int __devinit
+bfin_sport_spi_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct bfin5xx_spi_master *platform_info;
+        struct spi_master *master;
+        struct resource *res, *ires;
+        struct bfin_sport_spi_master_data *drv_data;
+        int status;
+
+        platform_info = dev->platform_data;
+
+        /* Allocate master with space for drv_data */
+        master = spi_alloc_master(dev, sizeof(*master) + 16);
+        if (!master) {
+                dev_err(dev, "cannot alloc spi_master\n");
+                return -ENOMEM;
+        }
+
+        drv_data = spi_master_get_devdata(master);
+        drv_data->master = master;
+        drv_data->dev = dev;
+        drv_data->pin_req = platform_info->pin_req;
+
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
+        master->bus_num = pdev->id;
+        master->num_chipselect = platform_info->num_chipselect;
+        master->cleanup = bfin_sport_spi_cleanup;
+        master->setup = bfin_sport_spi_setup;
+        master->transfer = bfin_sport_spi_transfer;
+
+        /* Find and map our resources */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (res == NULL) {
+                dev_err(dev, "cannot get IORESOURCE_MEM\n");
+                status = -ENOENT;
+                goto out_error_get_res;
+        }
+
+        drv_data->regs = ioremap(res->start, resource_size(res));
+        if (drv_data->regs == NULL) {
+                dev_err(dev, "cannot map registers\n");
+                status = -ENXIO;
+                goto out_error_ioremap;
+        }
+
+        ires = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+        if (!ires) {
+                dev_err(dev, "cannot get IORESOURCE_IRQ\n");
+                status = -ENODEV;
+                goto out_error_get_ires;
+        }
+        drv_data->err_irq = ires->start;
+
+        /* Initial and start queue */
+        status = bfin_sport_spi_init_queue(drv_data);
+        if (status) {
+                dev_err(dev, "problem initializing queue\n");
+                goto out_error_queue_alloc;
+        }
+
+        status = bfin_sport_spi_start_queue(drv_data);
+        if (status) {
+                dev_err(dev, "problem starting queue\n");
+                goto out_error_queue_alloc;
+        }
+
+        status = request_irq(drv_data->err_irq, sport_err_handler,
+                0, "sport_spi_err", drv_data);
+        if (status) {
+                dev_err(dev, "unable to request sport err irq\n");
+                goto out_error_irq;
+        }
+
+        status = peripheral_request_list(drv_data->pin_req, DRV_NAME);
+        if (status) {
+                dev_err(dev, "requesting peripherals failed\n");
+                goto out_error_peripheral;
+        }
+
+        /* Register with the SPI framework */
+        platform_set_drvdata(pdev, drv_data);
+        status = spi_register_master(master);
+        if (status) {
+                dev_err(dev, "problem registering spi master\n");
+                goto out_error_master;
+        }
+
+        dev_info(dev, "%s, regs_base@%p\n", DRV_DESC, drv_data->regs);
+        return 0;
+
+ out_error_master:
+        peripheral_free_list(drv_data->pin_req);
+ out_error_peripheral:
+        free_irq(drv_data->err_irq, drv_data);
+ out_error_irq:
+ out_error_queue_alloc:
+        bfin_sport_spi_destroy_queue(drv_data);
+ out_error_get_ires:
+        iounmap(drv_data->regs);
+ out_error_ioremap:
+ out_error_get_res:
+        spi_master_put(master);
+
+        return status;
+}
+
+/* stop hardware and remove the driver */
+static int __devexit
+bfin_sport_spi_remove(struct platform_device *pdev)
+{
+        struct bfin_sport_spi_master_data *drv_data = platform_get_drvdata(pdev);
+        int status = 0;
+
+        if (!drv_data)
+                return 0;
+
+        /* Remove the queue */
+        status = bfin_sport_spi_destroy_queue(drv_data);
+        if (status)
+                return status;
+
+        /* Disable the SSP at the peripheral and SOC level */
+        bfin_sport_spi_disable(drv_data);
+
+        /* Disconnect from the SPI framework */
+        spi_unregister_master(drv_data->master);
+
+        peripheral_free_list(drv_data->pin_req);
+
+        /* Prevent double remove */
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int
+bfin_sport_spi_suspend(struct platform_device *pdev, pm_message_t state)
+{
+        struct bfin_sport_spi_master_data *drv_data = platform_get_drvdata(pdev);
+        int status;
+
+        status = bfin_sport_spi_stop_queue(drv_data);
+        if (status)
+                return status;
+
+        /* stop hardware */
+        bfin_sport_spi_disable(drv_data);
+
+        return status;
+}
+
+static int
+bfin_sport_spi_resume(struct platform_device *pdev)
+{
+        struct bfin_sport_spi_master_data *drv_data = platform_get_drvdata(pdev);
+        int status;
+
+        /* Enable the SPI interface */
+        bfin_sport_spi_enable(drv_data);
+
+        /* Start the queue running */
+        status = bfin_sport_spi_start_queue(drv_data);
+        if (status)
+                dev_err(drv_data->dev, "problem resuming queue\n");
+
+        return status;
+}
+#else
+# define bfin_sport_spi_suspend NULL
+# define bfin_sport_spi_resume  NULL
+#endif
+
+static struct platform_driver bfin_sport_spi_driver = {
+        .driver = {
+                .name = DRV_NAME,
+                .owner = THIS_MODULE,
+        },
+        .probe   = bfin_sport_spi_probe,
+        .remove  = __devexit_p(bfin_sport_spi_remove),
+        .suspend = bfin_sport_spi_suspend,
+        .resume  = bfin_sport_spi_resume,
+};
+
+static int __init bfin_sport_spi_init(void)
+{
+        return platform_driver_register(&bfin_sport_spi_driver);
+}
+module_init(bfin_sport_spi_init);
+
+static void __exit bfin_sport_spi_exit(void)
+{
+        platform_driver_unregister(&bfin_sport_spi_driver);
+}
+module_exit(bfin_sport_spi_exit);
diff --git a/drivers/spi/tle62x0.c b/drivers/spi/tle62x0.c
index a3938958147c..32a40876532f 100644
--- a/drivers/spi/tle62x0.c
+++ b/drivers/spi/tle62x0.c
@@ -283,7 +283,7 @@ static int __devinit tle62x0_probe(struct spi_device *spi)
         return 0;
 
  err_gpios:
-        for (; ptr > 0; ptr--)
+        while (--ptr >= 0)
                 device_remove_file(&spi->dev, gpio_attrs[ptr]);
 
         device_remove_file(&spi->dev, &dev_attr_status_show);
@@ -301,6 +301,7 @@ static int __devexit tle62x0_remove(struct spi_device *spi)
         for (ptr = 0; ptr < st->nr_gpio; ptr++)
                 device_remove_file(&spi->dev, gpio_attrs[ptr]);
 
+        device_remove_file(&spi->dev, &dev_attr_status_show);
         kfree(st);
         return 0;
 }
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index aed4e464d31c..dee2a2c909f5 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -31,7 +31,7 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
-#include <scsi/libsas.h> /* For TASK_ATTR_* */
+#include <scsi/scsi_tcq.h>
 
 #include <target/target_core_base.h>
 #include <target/target_core_transport.h>
@@ -95,17 +95,17 @@ static struct se_cmd *tcm_loop_allocate_core_cmd(
         if (sc->device->tagged_supported) {
                 switch (sc->tag) {
                 case HEAD_OF_QUEUE_TAG:
-                        sam_task_attr = TASK_ATTR_HOQ;
+                        sam_task_attr = MSG_HEAD_TAG;
                         break;
                 case ORDERED_QUEUE_TAG:
-                        sam_task_attr = TASK_ATTR_ORDERED;
+                        sam_task_attr = MSG_ORDERED_TAG;
                         break;
                 default:
-                        sam_task_attr = TASK_ATTR_SIMPLE;
+                        sam_task_attr = MSG_SIMPLE_TAG;
                         break;
                 }
         } else
-                sam_task_attr = TASK_ATTR_SIMPLE;
+                sam_task_attr = MSG_SIMPLE_TAG;
 
         /*
          * Initialize struct se_cmd descriptor from target_core_mod infrastructure
@@ -379,7 +379,7 @@ static int tcm_loop_device_reset(struct scsi_cmnd *sc)
          * Initialize struct se_cmd descriptor from target_core_mod infrastructure
          */
         transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 0,
-                                DMA_NONE, TASK_ATTR_SIMPLE,
+                                DMA_NONE, MSG_SIMPLE_TAG,
                                 &tl_cmd->tl_sense_buf[0]);
         /*
          * Allocate the LUN_RESET TMR
@@ -939,18 +939,6 @@ static u16 tcm_loop_get_fabric_sense_len(void)
         return 0;
 }
 
-static u64 tcm_loop_pack_lun(unsigned int lun)
-{
-        u64 result;
-
-        /* LSB of lun into byte 1 big-endian */
-        result = ((lun & 0xff) << 8);
-        /* use flat space addressing method */
-        result |= 0x40 | ((lun >> 8) & 0x3f);
-
-        return cpu_to_le64(result);
-}
-
 static char *tcm_loop_dump_proto_id(struct tcm_loop_hba *tl_hba)
 {
         switch (tl_hba->tl_proto_id) {
@@ -1481,7 +1469,6 @@ static int tcm_loop_register_configfs(void)
         fabric->tf_ops.set_fabric_sense_len = &tcm_loop_set_fabric_sense_len;
         fabric->tf_ops.get_fabric_sense_len = &tcm_loop_get_fabric_sense_len;
         fabric->tf_ops.is_state_remove = &tcm_loop_is_state_remove;
-        fabric->tf_ops.pack_lun = &tcm_loop_pack_lun;
 
         tf_cg = &fabric->tf_group;
         /*
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index a5f44a6e6e1d..ee6fad979b50 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -497,10 +497,6 @@ static int target_fabric_tf_ops_check(
                 printk(KERN_ERR "Missing tfo->is_state_remove()\n");
                 return -EINVAL;
         }
-        if (!(tfo->pack_lun)) {
-                printk(KERN_ERR "Missing tfo->pack_lun()\n");
-                return -EINVAL;
-        }
         /*
          * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn()
          * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index d25e20829012..8407f9ca2b31 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -38,6 +38,7 @@
 #include <net/sock.h>
 #include <net/tcp.h>
 #include <scsi/scsi.h>
+#include <scsi/scsi_device.h>
 
 #include <target/target_core_base.h>
 #include <target/target_core_device.h>
@@ -150,13 +151,13 @@ out:
 
         {
         struct se_device *dev = se_lun->lun_se_dev;
-        spin_lock(&dev->stats_lock);
+        spin_lock_irq(&dev->stats_lock);
         dev->num_cmds++;
         if (se_cmd->data_direction == DMA_TO_DEVICE)
                 dev->write_bytes += se_cmd->data_length;
         else if (se_cmd->data_direction == DMA_FROM_DEVICE)
                 dev->read_bytes += se_cmd->data_length;
-        spin_unlock(&dev->stats_lock);
+        spin_unlock_irq(&dev->stats_lock);
         }
 
         /*
@@ -658,8 +659,7 @@ int transport_core_report_lun_response(struct se_cmd *se_cmd)
         struct se_session *se_sess = SE_SESS(se_cmd);
         struct se_task *se_task;
         unsigned char *buf = (unsigned char *)T_TASK(se_cmd)->t_task_buf;
-        u32 cdb_offset = 0, lun_count = 0, offset = 8;
-        u64 i, lun;
+        u32 cdb_offset = 0, lun_count = 0, offset = 8, i;
 
         list_for_each_entry(se_task, &T_TASK(se_cmd)->t_task_list, t_list)
                 break;
@@ -675,15 +675,7 @@ int transport_core_report_lun_response(struct se_cmd *se_cmd)
          * a $FABRIC_MOD.  In that case, report LUN=0 only.
          */
         if (!(se_sess)) {
-                lun = 0;
-                buf[offset++] = ((lun >> 56) & 0xff);
-                buf[offset++] = ((lun >> 48) & 0xff);
-                buf[offset++] = ((lun >> 40) & 0xff);
-                buf[offset++] = ((lun >> 32) & 0xff);
-                buf[offset++] = ((lun >> 24) & 0xff);
-                buf[offset++] = ((lun >> 16) & 0xff);
-                buf[offset++] = ((lun >> 8) & 0xff);
-                buf[offset++] = (lun & 0xff);
+                int_to_scsilun(0, (struct scsi_lun *)&buf[offset]);
                 lun_count = 1;
                 goto done;
         }
@@ -703,15 +695,8 @@ int transport_core_report_lun_response(struct se_cmd *se_cmd)
                 if ((cdb_offset + 8) >= se_cmd->data_length)
                         continue;
 
-                lun = cpu_to_be64(CMD_TFO(se_cmd)->pack_lun(deve->mapped_lun));
-                buf[offset++] = ((lun >> 56) & 0xff);
-                buf[offset++] = ((lun >> 48) & 0xff);
-                buf[offset++] = ((lun >> 40) & 0xff);
-                buf[offset++] = ((lun >> 32) & 0xff);
-                buf[offset++] = ((lun >> 24) & 0xff);
-                buf[offset++] = ((lun >> 16) & 0xff);
-                buf[offset++] = ((lun >> 8) & 0xff);
-                buf[offset++] = (lun & 0xff);
+                int_to_scsilun(deve->mapped_lun, (struct scsi_lun *)&buf[offset]);
+                offset += 8;
                 cdb_offset += 8;
         }
         spin_unlock_irq(&SE_NODE_ACL(se_sess)->device_list_lock);
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 7ff6a35f26ac..331d423fd0e0 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -41,7 +41,7 @@
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
 #include <scsi/scsi_host.h>
-#include <scsi/libsas.h> /* For TASK_ATTR_* */
+#include <scsi/scsi_tcq.h>
 
 #include <target/target_core_base.h>
 #include <target/target_core_device.h>
@@ -911,7 +911,7 @@ static int pscsi_do_task(struct se_task *task)
          * descriptor
          */
         blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, pt->pscsi_req,
-                        (task->task_se_cmd->sam_task_attr == TASK_ATTR_HOQ),
+                        (task->task_se_cmd->sam_task_attr == MSG_HEAD_TAG),
                         pscsi_req_done);
 
         return PYX_TRANSPORT_SENT_TO_TRANSPORT;
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index 4a109835e420..59b8b9c5ad72 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -55,7 +55,8 @@ struct se_tmr_req *core_tmr_alloc_req(
 {
         struct se_tmr_req *tmr;
 
-        tmr = kmem_cache_zalloc(se_tmr_req_cache, GFP_KERNEL);
+        tmr = kmem_cache_zalloc(se_tmr_req_cache, (in_interrupt()) ?
+                                        GFP_ATOMIC : GFP_KERNEL);
         if (!(tmr)) {
                 printk(KERN_ERR "Unable to allocate struct se_tmr_req\n");
                 return ERR_PTR(-ENOMEM);
@@ -398,9 +399,9 @@ int core_tmr_lun_reset(
                 printk(KERN_INFO "LUN_RESET: SCSI-2 Released reservation\n");
         }
 
-        spin_lock(&dev->stats_lock);
+        spin_lock_irq(&dev->stats_lock);
         dev->num_resets++;
-        spin_unlock(&dev->stats_lock);
+        spin_unlock_irq(&dev->stats_lock);
 
         DEBUG_LR("LUN_RESET: %s for [%s] Complete\n",
                         (preempt_and_abort_list) ? "Preempt" : "TMR",
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index b9d3501bdd91..4dafeb8b5638 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -42,7 +42,7 @@
 #include <net/tcp.h>
 #include <scsi/scsi.h>
 #include <scsi/scsi_cmnd.h>
-#include <scsi/libsas.h> /* For TASK_ATTR_* */
+#include <scsi/scsi_tcq.h>
 
 #include <target/target_core_base.h>
 #include <target/target_core_device.h>
@@ -762,7 +762,6 @@ static void transport_lun_remove_cmd(struct se_cmd *cmd)
         transport_all_task_dev_remove_state(cmd);
         spin_unlock_irqrestore(&T_TASK(cmd)->t_state_lock, flags);
 
-        transport_free_dev_tasks(cmd);
 
 check_lun:
         spin_lock_irqsave(&lun->lun_cmd_lock, flags);
@@ -1075,7 +1074,7 @@ static inline int transport_add_task_check_sam_attr(
          * head of the struct se_device->execute_task_list, and task_prev
          * after that for each subsequent task
          */
-        if (task->task_se_cmd->sam_task_attr == TASK_ATTR_HOQ) {
+        if (task->task_se_cmd->sam_task_attr == MSG_HEAD_TAG) {
                 list_add(&task->t_execute_list,
                                 (task_prev != NULL) ?
                                 &task_prev->t_execute_list :
@@ -1195,6 +1194,7 @@ transport_get_task_from_execute_queue(struct se_device *dev)
                 break;
 
         list_del(&task->t_execute_list);
+        atomic_set(&task->task_execute_queue, 0);
         atomic_dec(&dev->execute_tasks);
 
         return task;
@@ -1210,8 +1210,14 @@ void transport_remove_task_from_execute_queue(
 {
         unsigned long flags;
 
+        if (atomic_read(&task->task_execute_queue) == 0) {
+                dump_stack();
+                return;
+        }
+
         spin_lock_irqsave(&dev->execute_task_lock, flags);
         list_del(&task->t_execute_list);
+        atomic_set(&task->task_execute_queue, 0);
         atomic_dec(&dev->execute_tasks);
         spin_unlock_irqrestore(&dev->execute_task_lock, flags);
 }
@@ -1867,7 +1873,7 @@ static int transport_check_alloc_task_attr(struct se_cmd *cmd)
         if (SE_DEV(cmd)->dev_task_attr_type != SAM_TASK_ATTR_EMULATED)
                 return 0;
 
-        if (cmd->sam_task_attr == TASK_ATTR_ACA) {
+        if (cmd->sam_task_attr == MSG_ACA_TAG) {
                 DEBUG_STA("SAM Task Attribute ACA"
                         " emulation is not supported\n");
                 return -1;
@@ -2058,6 +2064,13 @@ int transport_generic_handle_tmr(
 }
 EXPORT_SYMBOL(transport_generic_handle_tmr);
 
+void transport_generic_free_cmd_intr(
+        struct se_cmd *cmd)
+{
+        transport_add_cmd_to_queue(cmd, TRANSPORT_FREE_CMD_INTR);
+}
+EXPORT_SYMBOL(transport_generic_free_cmd_intr);
+
 static int transport_stop_tasks_for_cmd(struct se_cmd *cmd)
 {
         struct se_task *task, *task_tmp;
@@ -2504,7 +2517,7 @@ static inline int transport_execute_task_attr(struct se_cmd *cmd)
          * Check for the existence of HEAD_OF_QUEUE, and if true return 1
          * to allow the passed struct se_cmd list of tasks to the front of the list.
          */
-         if (cmd->sam_task_attr == TASK_ATTR_HOQ) {
+         if (cmd->sam_task_attr == MSG_HEAD_TAG) {
                 atomic_inc(&SE_DEV(cmd)->dev_hoq_count);
                 smp_mb__after_atomic_inc();
                 DEBUG_STA("Added HEAD_OF_QUEUE for CDB:"
@@ -2512,7 +2525,7 @@ static inline int transport_execute_task_attr(struct se_cmd *cmd)
                         T_TASK(cmd)->t_task_cdb[0],
                         cmd->se_ordered_id);
                 return 1;
-        } else if (cmd->sam_task_attr == TASK_ATTR_ORDERED) {
+        } else if (cmd->sam_task_attr == MSG_ORDERED_TAG) {
                 spin_lock(&SE_DEV(cmd)->ordered_cmd_lock);
                 list_add_tail(&cmd->se_ordered_list,
                                 &SE_DEV(cmd)->ordered_cmd_list);
@@ -3411,7 +3424,7 @@ static int transport_generic_cmd_sequencer(
                  * See spc4r17 section 5.3
                  */
                 if (SE_DEV(cmd)->dev_task_attr_type == SAM_TASK_ATTR_EMULATED)
-                        cmd->sam_task_attr = TASK_ATTR_HOQ;
+                        cmd->sam_task_attr = MSG_HEAD_TAG;
                 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_NONSG_IO_CDB;
                 break;
         case READ_BUFFER:
@@ -3619,7 +3632,7 @@ static int transport_generic_cmd_sequencer(
                  * See spc4r17 section 5.3
                  */
                 if (SE_DEV(cmd)->dev_task_attr_type == SAM_TASK_ATTR_EMULATED)
-                        cmd->sam_task_attr = TASK_ATTR_HOQ;
+                        cmd->sam_task_attr = MSG_HEAD_TAG;
                 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_NONSG_IO_CDB;
                 break;
         default:
@@ -3777,21 +3790,21 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
         struct se_cmd *cmd_p, *cmd_tmp;
         int new_active_tasks = 0;
 
-        if (cmd->sam_task_attr == TASK_ATTR_SIMPLE) {
+        if (cmd->sam_task_attr == MSG_SIMPLE_TAG) {
                 atomic_dec(&dev->simple_cmds);
                 smp_mb__after_atomic_dec();
                 dev->dev_cur_ordered_id++;
                 DEBUG_STA("Incremented dev->dev_cur_ordered_id: %u for"
                         " SIMPLE: %u\n", dev->dev_cur_ordered_id,
                         cmd->se_ordered_id);
-        } else if (cmd->sam_task_attr == TASK_ATTR_HOQ) {
+        } else if (cmd->sam_task_attr == MSG_HEAD_TAG) {
                 atomic_dec(&dev->dev_hoq_count);
                 smp_mb__after_atomic_dec();
                 dev->dev_cur_ordered_id++;
                 DEBUG_STA("Incremented dev_cur_ordered_id: %u for"
                         " HEAD_OF_QUEUE: %u\n", dev->dev_cur_ordered_id,
                         cmd->se_ordered_id);
-        } else if (cmd->sam_task_attr == TASK_ATTR_ORDERED) {
+        } else if (cmd->sam_task_attr == MSG_ORDERED_TAG) {
                 spin_lock(&dev->ordered_cmd_lock);
                 list_del(&cmd->se_ordered_list);
                 atomic_dec(&dev->dev_ordered_sync);
@@ -3824,7 +3837,7 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
                 new_active_tasks++;
 
                 spin_lock(&dev->delayed_cmd_lock);
-                if (cmd_p->sam_task_attr == TASK_ATTR_ORDERED)
+                if (cmd_p->sam_task_attr == MSG_ORDERED_TAG)
                         break;
         }
         spin_unlock(&dev->delayed_cmd_lock);
@@ -4776,18 +4789,20 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
                                 sg_end_cur->page_link &= ~0x02;
 
                                 sg_chain(sg_head, task_sg_num, sg_head_cur);
-                                sg_count += (task->task_sg_num + 1);
-                        } else
                                 sg_count += task->task_sg_num;
+                                task_sg_num = (task->task_sg_num + 1);
+                        } else {
+                                sg_chain(sg_head, task_sg_num, sg_head_cur);
+                                sg_count += task->task_sg_num;
+                                task_sg_num = task->task_sg_num;
+                        }
 
                         sg_head = sg_head_cur;
                         sg_link = sg_link_cur;
-                        task_sg_num = task->task_sg_num;
                         continue;
                 }
                 sg_head = sg_first = &task->task_sg[0];
                 sg_link = &task->task_sg[task->task_sg_num];
-                task_sg_num = task->task_sg_num;
                 /*
                  * Check for single task..
                  */
@@ -4798,9 +4813,12 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
                          */
                         sg_end = &task->task_sg[task->task_sg_num - 1];
                         sg_end->page_link &= ~0x02;
-                        sg_count += (task->task_sg_num + 1);
-                } else
                         sg_count += task->task_sg_num;
+                        task_sg_num = (task->task_sg_num + 1);
+                } else {
+                        sg_count += task->task_sg_num;
+                        task_sg_num = task->task_sg_num;
+                }
         }
         /*
          * Setup the starting pointer and total t_tasks_sg_linked_no including
@@ -4809,21 +4827,20 @@ void transport_do_task_sg_chain(struct se_cmd *cmd)
         T_TASK(cmd)->t_tasks_sg_chained = sg_first;
         T_TASK(cmd)->t_tasks_sg_chained_no = sg_count;
 
-        DEBUG_CMD_M("Setup T_TASK(cmd)->t_tasks_sg_chained: %p and"
-                " t_tasks_sg_chained_no: %u\n", T_TASK(cmd)->t_tasks_sg_chained,
+        DEBUG_CMD_M("Setup cmd: %p T_TASK(cmd)->t_tasks_sg_chained: %p and"
+                " t_tasks_sg_chained_no: %u\n", cmd, T_TASK(cmd)->t_tasks_sg_chained,
                 T_TASK(cmd)->t_tasks_sg_chained_no);
 
         for_each_sg(T_TASK(cmd)->t_tasks_sg_chained, sg,
                         T_TASK(cmd)->t_tasks_sg_chained_no, i) {
 
-                DEBUG_CMD_M("SG: %p page: %p length: %d offset: %d\n",
-                        sg, sg_page(sg), sg->length, sg->offset);
+                DEBUG_CMD_M("SG[%d]: %p page: %p length: %d offset: %d, magic: 0x%08x\n",
+                        i, sg, sg_page(sg), sg->length, sg->offset, sg->sg_magic);
                 if (sg_is_chain(sg))
                         DEBUG_CMD_M("SG: %p sg_is_chain=1\n", sg);
                 if (sg_is_last(sg))
                         DEBUG_CMD_M("SG: %p sg_is_last=1\n", sg);
         }
-
 }
 EXPORT_SYMBOL(transport_do_task_sg_chain);
 
@@ -5297,6 +5314,8 @@ void transport_generic_free_cmd(
                 if (wait_for_tasks && cmd->transport_wait_for_tasks)
                         cmd->transport_wait_for_tasks(cmd, 0, 0);
 
+                transport_free_dev_tasks(cmd);
+
                 transport_generic_remove(cmd, release_to_pool,
                                 session_reinstatement);
         }
@@ -6132,6 +6151,9 @@ get_cmd:
                 case TRANSPORT_REMOVE:
                         transport_generic_remove(cmd, 1, 0);
                         break;
+                case TRANSPORT_FREE_CMD_INTR:
+                        transport_generic_free_cmd(cmd, 0, 1, 0);
+                        break;
                 case TRANSPORT_PROCESS_TMR:
                         transport_generic_do_tmr(cmd);
                         break;
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 49e51778f733..c056a1132ae1 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -35,6 +35,7 @@
 #include <scsi/scsi_host.h>
 #include <scsi/scsi_device.h>
 #include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_tcq.h>
 #include <scsi/libfc.h>
 #include <scsi/fc_encode.h>
 
@@ -592,8 +593,25 @@ static void ft_send_cmd(struct ft_cmd *cmd)
                 case FCP_CFL_WRDATA | FCP_CFL_RDDATA:
                         goto err;       /* TBD not supported by tcm_fc yet */
                 }
+                /*
+                 * Locate the SAM Task Attr from fc_pri_ta
+                 */
+                switch (fcp->fc_pri_ta & FCP_PTA_MASK) {
+                case FCP_PTA_HEADQ:
+                        task_attr = MSG_HEAD_TAG;
+                        break;
+                case FCP_PTA_ORDERED:
+                        task_attr = MSG_ORDERED_TAG;
+                        break;
+                case FCP_PTA_ACA:
+                        task_attr = MSG_ACA_TAG;
+                        break;
+                case FCP_PTA_SIMPLE: /* Fallthrough */
+                default:
+                        task_attr = MSG_SIMPLE_TAG;
+                }
+
 
-                /* FCP_PTA_ maps 1:1 to TASK_ATTR_ */
                 task_attr = fcp->fc_pri_ta & FCP_PTA_MASK;
                 data_len = ntohl(fcp->fc_dl);
                 cmd->cdb = fcp->fc_cdb;
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index fcdbbffe88cc..84e868c255dd 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -519,13 +519,6 @@ static u32 ft_tpg_get_inst_index(struct se_portal_group *se_tpg)
         return tpg->index;
 }
 
-static u64 ft_pack_lun(unsigned int index)
-{
-        WARN_ON(index >= 256);
-        /* Caller wants this byte-swapped */
-        return cpu_to_le64((index & 0xff) << 8);
-}
-
 static struct target_core_fabric_ops ft_fabric_ops = {
         .get_fabric_name =              ft_get_fabric_name,
         .get_fabric_proto_ident =       fc_get_fabric_proto_ident,
@@ -564,7 +557,6 @@ static struct target_core_fabric_ops ft_fabric_ops = {
         .get_fabric_sense_len =         ft_get_fabric_sense_len,
         .set_fabric_sense_len =         ft_set_fabric_sense_len,
         .is_state_remove =              ft_is_state_remove,
-        .pack_lun =                     ft_pack_lun,
         /*
          * Setup function pointers for generic logic in
          * target_core_fabric_configfs.c
diff --git a/drivers/thermal/thermal_sys.c b/drivers/thermal/thermal_sys.c
index fc6f2a5bde01..0b1c82ad6805 100644
--- a/drivers/thermal/thermal_sys.c
+++ b/drivers/thermal/thermal_sys.c
@@ -499,7 +499,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
         dev_set_drvdata(hwmon->device, hwmon);
         result = device_create_file(hwmon->device, &dev_attr_name);
         if (result)
-                goto unregister_hwmon_device;
+                goto free_mem;
 
  register_sys_interface:
         tz->hwmon = hwmon;
@@ -513,7 +513,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
         sysfs_attr_init(&tz->temp_input.attr.attr);
         result = device_create_file(hwmon->device, &tz->temp_input.attr);
         if (result)
-                goto unregister_hwmon_device;
+                goto unregister_name;
 
         if (tz->ops->get_crit_temp) {
                 unsigned long temperature;
@@ -527,7 +527,7 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
                         result = device_create_file(hwmon->device,
                                                     &tz->temp_crit.attr);
                         if (result)
-                                goto unregister_hwmon_device;
+                                goto unregister_input;
                 }
         }
 
@@ -539,9 +539,9 @@ thermal_add_hwmon_sysfs(struct thermal_zone_device *tz)
 
         return 0;
 
- unregister_hwmon_device:
-        device_remove_file(hwmon->device, &tz->temp_crit.attr);
+ unregister_input:
         device_remove_file(hwmon->device, &tz->temp_input.attr);
+ unregister_name:
         if (new_hwmon_device) {
                 device_remove_file(hwmon->device, &dev_attr_name);
                 hwmon_device_unregister(hwmon->device);
diff --git a/drivers/tty/serial/atmel_serial.c b/drivers/tty/serial/atmel_serial.c
index 652bdac8ce8e..6d5d6e679fc7 100644
--- a/drivers/tty/serial/atmel_serial.c
+++ b/drivers/tty/serial/atmel_serial.c
@@ -1420,7 +1420,7 @@ static void __devinit atmel_init_port(struct atmel_uart_port *atmel_port,
         port->flags             = UPF_BOOT_AUTOCONF;
         port->ops               = &atmel_pops;
         port->fifosize          = 1;
-        port->line              = pdev->id;
+        port->line              = data->num;
         port->dev               = &pdev->dev;
         port->mapbase   = pdev->resource[0].start;
         port->irq       = pdev->resource[1].start;
diff --git a/drivers/usb/host/ehci-pci.c b/drivers/usb/host/ehci-pci.c
index 660b80a75cac..1102ce65a3a9 100644
--- a/drivers/usb/host/ehci-pci.c
+++ b/drivers/usb/host/ehci-pci.c
@@ -348,11 +348,50 @@ static int ehci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
         return rc;
 }
 
+static bool usb_is_intel_switchable_ehci(struct pci_dev *pdev)
+{
+        return pdev->class == PCI_CLASS_SERIAL_USB_EHCI &&
+                pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == 0x1E26;
+}
+
+static void ehci_enable_xhci_companion(void)
+{
+        struct pci_dev          *companion = NULL;
+
+        /* The xHCI and EHCI controllers are not on the same PCI slot */
+        for_each_pci_dev(companion) {
+                if (!usb_is_intel_switchable_xhci(companion))
+                        continue;
+                usb_enable_xhci_ports(companion);
+                return;
+        }
+}
+
 static int ehci_pci_resume(struct usb_hcd *hcd, bool hibernated)
 {
         struct ehci_hcd         *ehci = hcd_to_ehci(hcd);
         struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
 
+        /* The BIOS on systems with the Intel Panther Point chipset may or may
+         * not support xHCI natively.  That means that during system resume, it
+         * may switch the ports back to EHCI so that users can use their
+         * keyboard to select a kernel from GRUB after resume from hibernate.
+         *
+         * The BIOS is supposed to remember whether the OS had xHCI ports
+         * enabled before resume, and switch the ports back to xHCI when the
+         * BIOS/OS semaphore is written, but we all know we can't trust BIOS
+         * writers.
+         *
+         * Unconditionally switch the ports back to xHCI after a system resume.
+         * We can't tell whether the EHCI or xHCI controller will be resumed
+         * first, so we have to do the port switchover in both drivers.  Writing
+         * a '1' to the port switchover registers should have no effect if the
+         * port was already switched over.
+         */
+        if (usb_is_intel_switchable_ehci(pdev))
+                ehci_enable_xhci_companion();
+
         // maybe restore FLADJ
 
         if (time_before(jiffies, ehci->next_statechange))
diff --git a/drivers/usb/host/pci-quirks.c b/drivers/usb/host/pci-quirks.c
index f16c59d5f487..fd930618c28f 100644
--- a/drivers/usb/host/pci-quirks.c
+++ b/drivers/usb/host/pci-quirks.c
@@ -69,6 +69,9 @@
 #define NB_PIF0_PWRDOWN_0       0x01100012
 #define NB_PIF0_PWRDOWN_1       0x01100013
 
+#define USB_INTEL_XUSB2PR      0xD0
+#define USB_INTEL_USB3_PSSEN   0xD8
+
 static struct amd_chipset_info {
         struct pci_dev  *nb_dev;
         struct pci_dev  *smbus_dev;
@@ -673,6 +676,64 @@ static int handshake(void __iomem *ptr, u32 mask, u32 done,
         return -ETIMEDOUT;
 }
 
+bool usb_is_intel_switchable_xhci(struct pci_dev *pdev)
+{
+        return pdev->class == PCI_CLASS_SERIAL_USB_XHCI &&
+                pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI;
+}
+EXPORT_SYMBOL_GPL(usb_is_intel_switchable_xhci);
+
+/*
+ * Intel's Panther Point chipset has two host controllers (EHCI and xHCI) that
+ * share some number of ports.  These ports can be switched between either
+ * controller.  Not all of the ports under the EHCI host controller may be
+ * switchable.
+ *
+ * The ports should be switched over to xHCI before PCI probes for any device
+ * start.  This avoids active devices under EHCI being disconnected during the
+ * port switchover, which could cause loss of data on USB storage devices, or
+ * failed boot when the root file system is on a USB mass storage device and is
+ * enumerated under EHCI first.
+ *
+ * We write into the xHC's PCI configuration space in some Intel-specific
+ * registers to switch the ports over.  The USB 3.0 terminations and the USB
+ * 2.0 data wires are switched separately.  We want to enable the SuperSpeed
+ * terminations before switching the USB 2.0 wires over, so that USB 3.0
+ * devices connect at SuperSpeed, rather than at USB 2.0 speeds.
+ */
+void usb_enable_xhci_ports(struct pci_dev *xhci_pdev)
+{
+        u32             ports_available;
+
+        ports_available = 0xffffffff;
+        /* Write USB3_PSSEN, the USB 3.0 Port SuperSpeed Enable
+         * Register, to turn on SuperSpeed terminations for all
+         * available ports.
+         */
+        pci_write_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
+                        cpu_to_le32(ports_available));
+
+        pci_read_config_dword(xhci_pdev, USB_INTEL_USB3_PSSEN,
+                        &ports_available);
+        dev_dbg(&xhci_pdev->dev, "USB 3.0 ports that are now enabled "
+                        "under xHCI: 0x%x\n", ports_available);
+
+        ports_available = 0xffffffff;
+        /* Write XUSB2PR, the xHC USB 2.0 Port Routing Register, to
+         * switch the USB 2.0 power and data lines over to the xHCI
+         * host.
+         */
+        pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
+                        cpu_to_le32(ports_available));
+
+        pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
+                        &ports_available);
+        dev_dbg(&xhci_pdev->dev, "USB 2.0 ports that are now switched over "
+                        "to xHCI: 0x%x\n", ports_available);
+}
+EXPORT_SYMBOL_GPL(usb_enable_xhci_ports);
+
 /**
  * PCI Quirks for xHCI.
  *
@@ -732,6 +793,8 @@ static void __devinit quirk_usb_handoff_xhci(struct pci_dev *pdev)
         writel(XHCI_LEGACY_DISABLE_SMI,
                         base + ext_cap_offset + XHCI_LEGACY_CONTROL_OFFSET);
 
+        if (usb_is_intel_switchable_xhci(pdev))
+                usb_enable_xhci_ports(pdev);
 hc_init:
         op_reg_base = base + XHCI_HC_LENGTH(readl(base));
 
diff --git a/drivers/usb/host/pci-quirks.h b/drivers/usb/host/pci-quirks.h
index 6ae9f78e9938..b1002a8ef96f 100644
--- a/drivers/usb/host/pci-quirks.h
+++ b/drivers/usb/host/pci-quirks.h
@@ -8,6 +8,8 @@ int usb_amd_find_chipset_info(void);
 void usb_amd_dev_put(void);
 void usb_amd_quirk_pll_disable(void);
 void usb_amd_quirk_pll_enable(void);
+bool usb_is_intel_switchable_xhci(struct pci_dev *pdev);
+void usb_enable_xhci_ports(struct pci_dev *xhci_pdev);
 #else
 static inline void usb_amd_quirk_pll_disable(void) {}
 static inline void usb_amd_quirk_pll_enable(void) {}
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index cbc4d491e626..c408e9f6a707 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -118,6 +118,12 @@ static int xhci_pci_setup(struct usb_hcd *hcd)
         /* AMD PLL quirk */
         if (pdev->vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info())
                 xhci->quirks |= XHCI_AMD_PLL_FIX;
+        if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
+                        pdev->device == PCI_DEVICE_ID_INTEL_PANTHERPOINT_XHCI) {
+                xhci->quirks |= XHCI_SPURIOUS_SUCCESS;
+                xhci->quirks |= XHCI_EP_LIMIT_QUIRK;
+                xhci->limit_active_eps = 64;
+        }
 
         /* Make sure the HC is halted. */
         retval = xhci_halt(xhci);
@@ -242,8 +248,28 @@ static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
 {
         struct xhci_hcd         *xhci = hcd_to_xhci(hcd);
+        struct pci_dev          *pdev = to_pci_dev(hcd->self.controller);
         int                     retval = 0;
 
+        /* The BIOS on systems with the Intel Panther Point chipset may or may
+         * not support xHCI natively.  That means that during system resume, it
+         * may switch the ports back to EHCI so that users can use their
+         * keyboard to select a kernel from GRUB after resume from hibernate.
+         *
+         * The BIOS is supposed to remember whether the OS had xHCI ports
+         * enabled before resume, and switch the ports back to xHCI when the
+         * BIOS/OS semaphore is written, but we all know we can't trust BIOS
+         * writers.
+         *
+         * Unconditionally switch the ports back to xHCI after a system resume.
+         * We can't tell whether the EHCI or xHCI controller will be resumed
+         * first, so we have to do the port switchover in both drivers.  Writing
+         * a '1' to the port switchover registers should have no effect if the
+         * port was already switched over.
+         */
+        if (usb_is_intel_switchable_xhci(pdev))
+                usb_enable_xhci_ports(pdev);
+
         retval = xhci_resume(xhci, hibernated);
         return retval;
 }
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 237a765f8d18..cc1485bfed38 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -167,12 +167,6 @@ static void inc_deq(struct xhci_hcd *xhci, struct xhci_ring *ring, bool consumer
                 next = ring->dequeue;
         }
         addr = (unsigned long long) xhci_trb_virt_to_dma(ring->deq_seg, ring->dequeue);
-        if (ring == xhci->event_ring)
-                xhci_dbg(xhci, "Event ring deq = 0x%llx (DMA)\n", addr);
-        else if (ring == xhci->cmd_ring)
-                xhci_dbg(xhci, "Command ring deq = 0x%llx (DMA)\n", addr);
-        else
-                xhci_dbg(xhci, "Ring deq = 0x%llx (DMA)\n", addr);
 }
 
 /*
@@ -248,12 +242,6 @@ static void inc_enq(struct xhci_hcd *xhci, struct xhci_ring *ring,
                 next = ring->enqueue;
         }
         addr = (unsigned long long) xhci_trb_virt_to_dma(ring->enq_seg, ring->enqueue);
-        if (ring == xhci->event_ring)
-                xhci_dbg(xhci, "Event ring enq = 0x%llx (DMA)\n", addr);
-        else if (ring == xhci->cmd_ring)
-                xhci_dbg(xhci, "Command ring enq = 0x%llx (DMA)\n", addr);
-        else
-                xhci_dbg(xhci, "Ring enq = 0x%llx (DMA)\n", addr);
 }
 
 /*
@@ -636,13 +624,11 @@ static void xhci_giveback_urb_in_irq(struct xhci_hcd *xhci,
                         }
                 }
                 usb_hcd_unlink_urb_from_ep(hcd, urb);
-                xhci_dbg(xhci, "Giveback %s URB %p\n", adjective, urb);
 
                 spin_unlock(&xhci->lock);
                 usb_hcd_giveback_urb(hcd, urb, status);
                 xhci_urb_free_priv(xhci, urb_priv);
                 spin_lock(&xhci->lock);
-                xhci_dbg(xhci, "%s URB given back\n", adjective);
         }
 }
 
@@ -692,6 +678,8 @@ static void handle_stopped_endpoint(struct xhci_hcd *xhci,
 
         if (list_empty(&ep->cancelled_td_list)) {
                 xhci_stop_watchdog_timer_in_irq(xhci, ep);
+                ep->stopped_td = NULL;
+                ep->stopped_trb = NULL;
                 ring_doorbell_for_active_rings(xhci, slot_id, ep_index);
                 return;
         }
@@ -1093,8 +1081,13 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 complete(&xhci->addr_dev);
                 break;
         case TRB_TYPE(TRB_DISABLE_SLOT):
-                if (xhci->devs[slot_id])
+                if (xhci->devs[slot_id]) {
+                        if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)
+                                /* Delete default control endpoint resources */
+                                xhci_free_device_endpoint_resources(xhci,
+                                                xhci->devs[slot_id], true);
                         xhci_free_virt_device(xhci, slot_id);
+                }
                 break;
         case TRB_TYPE(TRB_CONFIG_EP):
                 virt_dev = xhci->devs[slot_id];
@@ -1630,7 +1623,6 @@ static int process_ctrl_td(struct xhci_hcd *xhci, struct xhci_td *td,
                                         "without IOC set??\n");
                         *status = -ESHUTDOWN;
                 } else {
-                        xhci_dbg(xhci, "Successful control transfer!\n");
                         *status = 0;
                 }
                 break;
@@ -1727,7 +1719,6 @@ static int process_isoc_td(struct xhci_hcd *xhci, struct xhci_td *td,
         switch (trb_comp_code) {
         case COMP_SUCCESS:
                 frame->status = 0;
-                xhci_dbg(xhci, "Successful isoc transfer!\n");
                 break;
         case COMP_SHORT_TX:
                 frame->status = td->urb->transfer_flags & URB_SHORT_NOT_OK ?
@@ -1837,12 +1828,6 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                         else
                                 *status = 0;
                 } else {
-                        if (usb_endpoint_xfer_bulk(&td->urb->ep->desc))
-                                xhci_dbg(xhci, "Successful bulk "
-                                                "transfer!\n");
-                        else
-                                xhci_dbg(xhci, "Successful interrupt "
-                                                "transfer!\n");
                         *status = 0;
                 }
                 break;
@@ -1856,11 +1841,12 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
                 /* Others already handled above */
                 break;
         }
-        xhci_dbg(xhci, "ep %#x - asked for %d bytes, "
-                        "%d bytes untransferred\n",
-                        td->urb->ep->desc.bEndpointAddress,
-                        td->urb->transfer_buffer_length,
-                 TRB_LEN(le32_to_cpu(event->transfer_len)));
+        if (trb_comp_code == COMP_SHORT_TX)
+                xhci_dbg(xhci, "ep %#x - asked for %d bytes, "
+                                "%d bytes untransferred\n",
+                                td->urb->ep->desc.bEndpointAddress,
+                                td->urb->transfer_buffer_length,
+                                TRB_LEN(le32_to_cpu(event->transfer_len)));
         /* Fast path - was this the last TRB in the TD for this URB? */
         if (event_trb == td->last_trb) {
                 if (TRB_LEN(le32_to_cpu(event->transfer_len)) != 0) {
@@ -1954,7 +1940,6 @@ static int handle_tx_event(struct xhci_hcd *xhci,
 
         /* Endpoint ID is 1 based, our index is zero based */
         ep_index = TRB_TO_EP_ID(le32_to_cpu(event->flags)) - 1;
-        xhci_dbg(xhci, "%s - ep index = %d\n", __func__, ep_index);
         ep = &xdev->eps[ep_index];
         ep_ring = xhci_dma_to_transfer_ring(ep, le64_to_cpu(event->buffer));
         ep_ctx = xhci_get_ep_ctx(xhci, xdev->out_ctx, ep_index);
@@ -2081,6 +2066,16 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                 if (!event_seg) {
                         if (!ep->skip ||
                             !usb_endpoint_xfer_isoc(&td->urb->ep->desc)) {
+                                /* Some host controllers give a spurious
+                                 * successful event after a short transfer.
+                                 * Ignore it.
+                                 */
+                                if ((xhci->quirks & XHCI_SPURIOUS_SUCCESS) && 
+                                                ep_ring->last_td_was_short) {
+                                        ep_ring->last_td_was_short = false;
+                                        ret = 0;
+                                        goto cleanup;
+                                }
                                 /* HC is busted, give up! */
                                 xhci_err(xhci,
                                         "ERROR Transfer event TRB DMA ptr not "
@@ -2091,6 +2086,10 @@ static int handle_tx_event(struct xhci_hcd *xhci,
                         ret = skip_isoc_td(xhci, td, event, ep, &status);
                         goto cleanup;
                 }
+                if (trb_comp_code == COMP_SHORT_TX)
+                        ep_ring->last_td_was_short = true;
+                else
+                        ep_ring->last_td_was_short = false;
 
                 if (ep->skip) {
                         xhci_dbg(xhci, "Found td. Clear skip flag.\n");
@@ -2149,9 +2148,15 @@ cleanup:
                                 xhci_urb_free_priv(xhci, urb_priv);
 
                         usb_hcd_unlink_urb_from_ep(bus_to_hcd(urb->dev->bus), urb);
-                        xhci_dbg(xhci, "Giveback URB %p, len = %d, "
-                                        "status = %d\n",
-                                        urb, urb->actual_length, status);
+                        if ((urb->actual_length != urb->transfer_buffer_length &&
+                                                (urb->transfer_flags &
+                                                 URB_SHORT_NOT_OK)) ||
+                                        status != 0)
+                                xhci_dbg(xhci, "Giveback URB %p, len = %d, "
+                                                "expected = %x, status = %d\n",
+                                                urb, urb->actual_length,
+                                                urb->transfer_buffer_length,
+                                                status);
                         spin_unlock(&xhci->lock);
                         usb_hcd_giveback_urb(bus_to_hcd(urb->dev->bus), urb, status);
                         spin_lock(&xhci->lock);
@@ -2180,7 +2185,6 @@ static int xhci_handle_event(struct xhci_hcd *xhci)
         int update_ptrs = 1;
         int ret;
 
-        xhci_dbg(xhci, "In %s\n", __func__);
         if (!xhci->event_ring || !xhci->event_ring->dequeue) {
                 xhci->error_bitmask |= 1 << 1;
                 return 0;
@@ -2193,7 +2197,6 @@ static int xhci_handle_event(struct xhci_hcd *xhci)
                 xhci->error_bitmask |= 1 << 2;
                 return 0;
         }
-        xhci_dbg(xhci, "%s - OS owns TRB\n", __func__);
 
         /*
          * Barrier between reading the TRB_CYCLE (valid) flag above and any
@@ -2203,20 +2206,14 @@ static int xhci_handle_event(struct xhci_hcd *xhci)
         /* FIXME: Handle more event types. */
         switch ((le32_to_cpu(event->event_cmd.flags) & TRB_TYPE_BITMASK)) {
         case TRB_TYPE(TRB_COMPLETION):
-                xhci_dbg(xhci, "%s - calling handle_cmd_completion\n", __func__);
                 handle_cmd_completion(xhci, &event->event_cmd);
-                xhci_dbg(xhci, "%s - returned from handle_cmd_completion\n", __func__);
                 break;
         case TRB_TYPE(TRB_PORT_STATUS):
-                xhci_dbg(xhci, "%s - calling handle_port_status\n", __func__);
                 handle_port_status(xhci, event);
-                xhci_dbg(xhci, "%s - returned from handle_port_status\n", __func__);
                 update_ptrs = 0;
                 break;
         case TRB_TYPE(TRB_TRANSFER):
-                xhci_dbg(xhci, "%s - calling handle_tx_event\n", __func__);
                 ret = handle_tx_event(xhci, &event->trans_event);
-                xhci_dbg(xhci, "%s - returned from handle_tx_event\n", __func__);
                 if (ret < 0)
                         xhci->error_bitmask |= 1 << 9;
                 else
@@ -2273,16 +2270,6 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
                 spin_unlock(&xhci->lock);
                 return IRQ_NONE;
         }
-        xhci_dbg(xhci, "op reg status = %08x\n", status);
-        xhci_dbg(xhci, "Event ring dequeue ptr:\n");
-        xhci_dbg(xhci, "@%llx %08x %08x %08x %08x\n",
-                 (unsigned long long)
-                 xhci_trb_virt_to_dma(xhci->event_ring->deq_seg, trb),
-                 lower_32_bits(le64_to_cpu(trb->link.segment_ptr)),
-                 upper_32_bits(le64_to_cpu(trb->link.segment_ptr)),
-                 (unsigned int) le32_to_cpu(trb->link.intr_target),
-                 (unsigned int) le32_to_cpu(trb->link.control));
-
         if (status & STS_FATAL) {
                 xhci_warn(xhci, "WARNING: Host System Error\n");
                 xhci_halt(xhci);
@@ -2397,7 +2384,6 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 u32 ep_state, unsigned int num_trbs, gfp_t mem_flags)
 {
         /* Make sure the endpoint has been added to xHC schedule */
-        xhci_dbg(xhci, "Endpoint state = 0x%x\n", ep_state);
         switch (ep_state) {
         case EP_STATE_DISABLED:
                 /*
@@ -2434,7 +2420,6 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                 struct xhci_ring *ring = ep_ring;
                 union xhci_trb *next;
 
-                xhci_dbg(xhci, "prepare_ring: pointing to link trb\n");
                 next = ring->enqueue;
 
                 while (last_trb(xhci, ring, ring->enq_seg, next)) {
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 8f2a56ece44f..d9660eb97eb9 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -1314,8 +1314,10 @@ int xhci_drop_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
         if (ret <= 0)
                 return ret;
         xhci = hcd_to_xhci(hcd);
-        xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ENODEV;
 
+        xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         drop_flag = xhci_get_endpoint_flag(&ep->desc);
         if (drop_flag == SLOT_FLAG || drop_flag == EP0_FLAG) {
                 xhci_dbg(xhci, "xHCI %s - can't drop slot or ep 0 %#x\n",
@@ -1401,6 +1403,8 @@ int xhci_add_endpoint(struct usb_hcd *hcd, struct usb_device *udev,
                 return ret;
         }
         xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ENODEV;
 
         added_ctxs = xhci_get_endpoint_flag(&ep->desc);
         last_ctx = xhci_last_valid_endpoint(added_ctxs);
@@ -1578,6 +1582,113 @@ static int xhci_evaluate_context_result(struct xhci_hcd *xhci,
         return ret;
 }
 
+static u32 xhci_count_num_new_endpoints(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        struct xhci_input_control_ctx *ctrl_ctx;
+        u32 valid_add_flags;
+        u32 valid_drop_flags;
+
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        /* Ignore the slot flag (bit 0), and the default control endpoint flag
+         * (bit 1).  The default control endpoint is added during the Address
+         * Device command and is never removed until the slot is disabled.
+         */
+        valid_add_flags = ctrl_ctx->add_flags >> 2;
+        valid_drop_flags = ctrl_ctx->drop_flags >> 2;
+
+        /* Use hweight32 to count the number of ones in the add flags, or
+         * number of endpoints added.  Don't count endpoints that are changed
+         * (both added and dropped).
+         */
+        return hweight32(valid_add_flags) -
+                hweight32(valid_add_flags & valid_drop_flags);
+}
+
+static unsigned int xhci_count_num_dropped_endpoints(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        struct xhci_input_control_ctx *ctrl_ctx;
+        u32 valid_add_flags;
+        u32 valid_drop_flags;
+
+        ctrl_ctx = xhci_get_input_control_ctx(xhci, in_ctx);
+        valid_add_flags = ctrl_ctx->add_flags >> 2;
+        valid_drop_flags = ctrl_ctx->drop_flags >> 2;
+
+        return hweight32(valid_drop_flags) -
+                hweight32(valid_add_flags & valid_drop_flags);
+}
+
+/*
+ * We need to reserve the new number of endpoints before the configure endpoint
+ * command completes.  We can't subtract the dropped endpoints from the number
+ * of active endpoints until the command completes because we can oversubscribe
+ * the host in this case:
+ *
+ *  - the first configure endpoint command drops more endpoints than it adds
+ *  - a second configure endpoint command that adds more endpoints is queued
+ *  - the first configure endpoint command fails, so the config is unchanged
+ *  - the second command may succeed, even though there isn't enough resources
+ *
+ * Must be called with xhci->lock held.
+ */
+static int xhci_reserve_host_resources(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        u32 added_eps;
+
+        added_eps = xhci_count_num_new_endpoints(xhci, in_ctx);
+        if (xhci->num_active_eps + added_eps > xhci->limit_active_eps) {
+                xhci_dbg(xhci, "Not enough ep ctxs: "
+                                "%u active, need to add %u, limit is %u.\n",
+                                xhci->num_active_eps, added_eps,
+                                xhci->limit_active_eps);
+                return -ENOMEM;
+        }
+        xhci->num_active_eps += added_eps;
+        xhci_dbg(xhci, "Adding %u ep ctxs, %u now active.\n", added_eps,
+                        xhci->num_active_eps);
+        return 0;
+}
+
+/*
+ * The configure endpoint was failed by the xHC for some other reason, so we
+ * need to revert the resources that failed configuration would have used.
+ *
+ * Must be called with xhci->lock held.
+ */
+static void xhci_free_host_resources(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        u32 num_failed_eps;
+
+        num_failed_eps = xhci_count_num_new_endpoints(xhci, in_ctx);
+        xhci->num_active_eps -= num_failed_eps;
+        xhci_dbg(xhci, "Removing %u failed ep ctxs, %u now active.\n",
+                        num_failed_eps,
+                        xhci->num_active_eps);
+}
+
+/*
+ * Now that the command has completed, clean up the active endpoint count by
+ * subtracting out the endpoints that were dropped (but not changed).
+ *
+ * Must be called with xhci->lock held.
+ */
+static void xhci_finish_resource_reservation(struct xhci_hcd *xhci,
+                struct xhci_container_ctx *in_ctx)
+{
+        u32 num_dropped_eps;
+
+        num_dropped_eps = xhci_count_num_dropped_endpoints(xhci, in_ctx);
+        xhci->num_active_eps -= num_dropped_eps;
+        if (num_dropped_eps)
+                xhci_dbg(xhci, "Removing %u dropped ep ctxs, %u now active.\n",
+                                num_dropped_eps,
+                                xhci->num_active_eps);
+}
+
 /* Issue a configure endpoint command or evaluate context command
  * and wait for it to finish.
  */
@@ -1598,6 +1709,15 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         virt_dev = xhci->devs[udev->slot_id];
         if (command) {
                 in_ctx = command->in_ctx;
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
+                                xhci_reserve_host_resources(xhci, in_ctx)) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_warn(xhci, "Not enough host resources, "
+                                        "active endpoint contexts = %u\n",
+                                        xhci->num_active_eps);
+                        return -ENOMEM;
+                }
+
                 cmd_completion = command->completion;
                 cmd_status = &command->status;
                 command->command_trb = xhci->cmd_ring->enqueue;
@@ -1613,6 +1733,14 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
                 list_add_tail(&command->cmd_list, &virt_dev->cmd_list);
         } else {
                 in_ctx = virt_dev->in_ctx;
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK) &&
+                                xhci_reserve_host_resources(xhci, in_ctx)) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_warn(xhci, "Not enough host resources, "
+                                        "active endpoint contexts = %u\n",
+                                        xhci->num_active_eps);
+                        return -ENOMEM;
+                }
                 cmd_completion = &virt_dev->cmd_completion;
                 cmd_status = &virt_dev->cmd_status;
         }
@@ -1627,6 +1755,8 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         if (ret < 0) {
                 if (command)
                         list_del(&command->cmd_list);
+                if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK))
+                        xhci_free_host_resources(xhci, in_ctx);
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg(xhci, "FIXME allocate a new ring segment\n");
                 return -ENOMEM;
@@ -1649,8 +1779,22 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         }
 
         if (!ctx_change)
-                return xhci_configure_endpoint_result(xhci, udev, cmd_status);
-        return xhci_evaluate_context_result(xhci, udev, cmd_status);
+                ret = xhci_configure_endpoint_result(xhci, udev, cmd_status);
+        else
+                ret = xhci_evaluate_context_result(xhci, udev, cmd_status);
+
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                /* If the command failed, remove the reserved resources.
+                 * Otherwise, clean up the estimate to include dropped eps.
+                 */
+                if (ret)
+                        xhci_free_host_resources(xhci, in_ctx);
+                else
+                        xhci_finish_resource_reservation(xhci, in_ctx);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        }
+        return ret;
 }
 
 /* Called after one or more calls to xhci_add_endpoint() or
@@ -1676,6 +1820,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         if (ret <= 0)
                 return ret;
         xhci = hcd_to_xhci(hcd);
+        if (xhci->xhc_state & XHCI_STATE_DYING)
+                return -ENODEV;
 
         xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
         virt_dev = xhci->devs[udev->slot_id];
@@ -2266,6 +2412,34 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
 }
 
 /*
+ * Deletes endpoint resources for endpoints that were active before a Reset
+ * Device command, or a Disable Slot command.  The Reset Device command leaves
+ * the control endpoint intact, whereas the Disable Slot command deletes it.
+ *
+ * Must be called with xhci->lock held.
+ */
+void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci,
+        struct xhci_virt_device *virt_dev, bool drop_control_ep)
+{
+        int i;
+        unsigned int num_dropped_eps = 0;
+        unsigned int drop_flags = 0;
+
+        for (i = (drop_control_ep ? 0 : 1); i < 31; i++) {
+                if (virt_dev->eps[i].ring) {
+                        drop_flags |= 1 << i;
+                        num_dropped_eps++;
+                }
+        }
+        xhci->num_active_eps -= num_dropped_eps;
+        if (num_dropped_eps)
+                xhci_dbg(xhci, "Dropped %u ep ctxs, flags = 0x%x, "
+                                "%u now active.\n",
+                                num_dropped_eps, drop_flags,
+                                xhci->num_active_eps);
+}
+
+/*
  * This submits a Reset Device Command, which will set the device state to 0,
  * set the device address to 0, and disable all the endpoints except the default
  * control endpoint.  The USB core should come back and call
@@ -2406,6 +2580,14 @@ int xhci_discover_or_reset_device(struct usb_hcd *hcd, struct usb_device *udev)
                 goto command_cleanup;
         }
 
+        /* Free up host controller endpoint resources */
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                /* Don't delete the default control endpoint resources */
+                xhci_free_device_endpoint_resources(xhci, virt_dev, false);
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        }
+
         /* Everything but endpoint 0 is disabled, so free or cache the rings. */
         last_freed_endpoint = 1;
         for (i = 1; i < 31; ++i) {
@@ -2479,6 +2661,27 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
 }
 
 /*
+ * Checks if we have enough host controller resources for the default control
+ * endpoint.
+ *
+ * Must be called with xhci->lock held.
+ */
+static int xhci_reserve_host_control_ep_resources(struct xhci_hcd *xhci)
+{
+        if (xhci->num_active_eps + 1 > xhci->limit_active_eps) {
+                xhci_dbg(xhci, "Not enough ep ctxs: "
+                                "%u active, need to add 1, limit is %u.\n",
+                                xhci->num_active_eps, xhci->limit_active_eps);
+                return -ENOMEM;
+        }
+        xhci->num_active_eps += 1;
+        xhci_dbg(xhci, "Adding 1 ep ctx, %u now active.\n",
+                        xhci->num_active_eps);
+        return 0;
+}
+
+
+/*
  * Returns 0 if the xHC ran out of device slots, the Enable Slot command
  * timed out, or allocating memory failed.  Returns 1 on success.
  */
@@ -2513,24 +2716,39 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
                 xhci_err(xhci, "Error while assigning device slot ID\n");
                 return 0;
         }
-        /* xhci_alloc_virt_device() does not touch rings; no need to lock.
-         * Use GFP_NOIO, since this function can be called from
+
+        if ((xhci->quirks & XHCI_EP_LIMIT_QUIRK)) {
+                spin_lock_irqsave(&xhci->lock, flags);
+                ret = xhci_reserve_host_control_ep_resources(xhci);
+                if (ret) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        xhci_warn(xhci, "Not enough host resources, "
+                                        "active endpoint contexts = %u\n",
+                                        xhci->num_active_eps);
+                        goto disable_slot;
+                }
+                spin_unlock_irqrestore(&xhci->lock, flags);
+        }
+        /* Use GFP_NOIO, since this function can be called from
          * xhci_discover_or_reset_device(), which may be called as part of
          * mass storage driver error handling.
          */
         if (!xhci_alloc_virt_device(xhci, xhci->slot_id, udev, GFP_NOIO)) {
-                /* Disable slot, if we can do it without mem alloc */
                 xhci_warn(xhci, "Could not allocate xHCI USB device data structures\n");
-                spin_lock_irqsave(&xhci->lock, flags);
-                if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id))
-                        xhci_ring_cmd_db(xhci);
-                spin_unlock_irqrestore(&xhci->lock, flags);
-                return 0;
+                goto disable_slot;
         }
         udev->slot_id = xhci->slot_id;
         /* Is this a LS or FS device under a HS hub? */
         /* Hub or peripherial? */
         return 1;
+
+disable_slot:
+        /* Disable slot, if we can do it without mem alloc */
+        spin_lock_irqsave(&xhci->lock, flags);
+        if (!xhci_queue_slot_control(xhci, TRB_DISABLE_SLOT, udev->slot_id))
+                xhci_ring_cmd_db(xhci);
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return 0;
 }
 
 /*
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index e12db7cfb9bb..ac0196e7fcf1 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1123,6 +1123,7 @@ struct xhci_ring {
          */
         u32                     cycle_state;
         unsigned int            stream_id;
+        bool                    last_td_was_short;
 };
 
 struct xhci_erst_entry {
@@ -1290,6 +1291,19 @@ struct xhci_hcd {
 #define XHCI_RESET_EP_QUIRK     (1 << 1)
 #define XHCI_NEC_HOST           (1 << 2)
 #define XHCI_AMD_PLL_FIX        (1 << 3)
+#define XHCI_SPURIOUS_SUCCESS   (1 << 4)
+/*
+ * Certain Intel host controllers have a limit to the number of endpoint
+ * contexts they can handle.  Ideally, they would signal that they can't handle
+ * anymore endpoint contexts by returning a Resource Error for the Configure
+ * Endpoint command, but they don't.  Instead they expect software to keep track
+ * of the number of active endpoints for them, across configure endpoint
+ * commands, reset device commands, disable slot commands, and address device
+ * commands.
+ */
+#define XHCI_EP_LIMIT_QUIRK     (1 << 5)
+        unsigned int            num_active_eps;
+        unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
         struct xhci_bus_state   bus_state[2];
         /* Is each xHCI roothub port a USB 3.0, USB 2.0, or USB 1.1 port? */
@@ -1338,9 +1352,6 @@ static inline unsigned int xhci_readl(const struct xhci_hcd *xhci,
 static inline void xhci_writel(struct xhci_hcd *xhci,
                 const unsigned int val, __le32 __iomem *regs)
 {
-        xhci_dbg(xhci,
-                        "`MEM_WRITE_DWORD(3'b000, 32'h%p, 32'h%0x, 4'hf);\n",
-                        regs, val);
         writel(val, regs);
 }
 
@@ -1368,9 +1379,6 @@ static inline void xhci_write_64(struct xhci_hcd *xhci,
         u32 val_lo = lower_32_bits(val);
         u32 val_hi = upper_32_bits(val);
 
-        xhci_dbg(xhci,
-                        "`MEM_WRITE_DWORD(3'b000, 64'h%p, 64'h%0lx, 4'hf);\n",
-                        regs, (long unsigned int) val);
         writel(val_lo, ptr);
         writel(val_hi, ptr + 1);
 }
@@ -1439,6 +1447,8 @@ void xhci_setup_streams_ep_input_ctx(struct xhci_hcd *xhci,
 void xhci_setup_no_streams_ep_input_ctx(struct xhci_hcd *xhci,
                 struct xhci_ep_ctx *ep_ctx,
                 struct xhci_virt_ep *ep);
+void xhci_free_device_endpoint_resources(struct xhci_hcd *xhci,
+        struct xhci_virt_device *virt_dev, bool drop_control_ep);
 struct xhci_ring *xhci_dma_to_transfer_ring(
                 struct xhci_virt_ep *ep,
                 u64 address);
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 2f7c76a85e53..e224a92baa16 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -144,7 +144,7 @@ static void handle_tx(struct vhost_net *net)
         }
 
         mutex_lock(&vq->mutex);
-        vhost_disable_notify(vq);
+        vhost_disable_notify(&net->dev, vq);
 
         if (wmem < sock->sk->sk_sndbuf / 2)
                 tx_poll_stop(net);
@@ -166,8 +166,8 @@ static void handle_tx(struct vhost_net *net)
                                 set_bit(SOCK_ASYNC_NOSPACE, &sock->flags);
                                 break;
                         }
-                        if (unlikely(vhost_enable_notify(vq))) {
-                                vhost_disable_notify(vq);
+                        if (unlikely(vhost_enable_notify(&net->dev, vq))) {
+                                vhost_disable_notify(&net->dev, vq);
                                 continue;
                         }
                         break;
@@ -315,7 +315,7 @@ static void handle_rx(struct vhost_net *net)
                 return;
 
         mutex_lock(&vq->mutex);
-        vhost_disable_notify(vq);
+        vhost_disable_notify(&net->dev, vq);
         vhost_hlen = vq->vhost_hlen;
         sock_hlen = vq->sock_hlen;
 
@@ -334,10 +334,10 @@ static void handle_rx(struct vhost_net *net)
                         break;
                 /* OK, now we need to know about added descriptors. */
                 if (!headcount) {
-                        if (unlikely(vhost_enable_notify(vq))) {
+                        if (unlikely(vhost_enable_notify(&net->dev, vq))) {
                                 /* They have slipped one in as we were
                                  * doing that: check again. */
-                                vhost_disable_notify(vq);
+                                vhost_disable_notify(&net->dev, vq);
                                 continue;
                         }
                         /* Nothing new?  Wait for eventfd to tell us
diff --git a/drivers/vhost/test.c b/drivers/vhost/test.c
index 099f30230d06..734e1d74ad80 100644
--- a/drivers/vhost/test.c
+++ b/drivers/vhost/test.c
@@ -49,7 +49,7 @@ static void handle_vq(struct vhost_test *n)
                 return;
 
         mutex_lock(&vq->mutex);
-        vhost_disable_notify(vq);
+        vhost_disable_notify(&n->dev, vq);
 
         for (;;) {
                 head = vhost_get_vq_desc(&n->dev, vq, vq->iov,
@@ -61,8 +61,8 @@ static void handle_vq(struct vhost_test *n)
                         break;
                 /* Nothing new?  Wait for eventfd to tell us they refilled. */
                 if (head == vq->num) {
-                        if (unlikely(vhost_enable_notify(vq))) {
-                                vhost_disable_notify(vq);
+                        if (unlikely(vhost_enable_notify(&n->dev, vq))) {
+                                vhost_disable_notify(&n->dev, vq);
                                 continue;
                         }
                         break;
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index 7aa4eea930f1..ea966b356352 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -37,6 +37,9 @@ enum {
         VHOST_MEMORY_F_LOG = 0x1,
 };
 
+#define vhost_used_event(vq) ((u16 __user *)&vq->avail->ring[vq->num])
+#define vhost_avail_event(vq) ((u16 __user *)&vq->used->ring[vq->num])
+
 static void vhost_poll_func(struct file *file, wait_queue_head_t *wqh,
                             poll_table *pt)
 {
@@ -161,6 +164,8 @@ static void vhost_vq_reset(struct vhost_dev *dev,
         vq->last_avail_idx = 0;
         vq->avail_idx = 0;
         vq->last_used_idx = 0;
+        vq->signalled_used = 0;
+        vq->signalled_used_valid = false;
         vq->used_flags = 0;
         vq->log_used = false;
         vq->log_addr = -1ull;
@@ -489,16 +494,17 @@ static int memory_access_ok(struct vhost_dev *d, struct vhost_memory *mem,
         return 1;
 }
 
-static int vq_access_ok(unsigned int num,
+static int vq_access_ok(struct vhost_dev *d, unsigned int num,
                         struct vring_desc __user *desc,
                         struct vring_avail __user *avail,
                         struct vring_used __user *used)
 {
+        size_t s = vhost_has_feature(d, VIRTIO_RING_F_EVENT_IDX) ? 2 : 0;
         return access_ok(VERIFY_READ, desc, num * sizeof *desc) &&
                access_ok(VERIFY_READ, avail,
-                         sizeof *avail + num * sizeof *avail->ring) &&
+                         sizeof *avail + num * sizeof *avail->ring + s) &&
                access_ok(VERIFY_WRITE, used,
-                        sizeof *used + num * sizeof *used->ring);
+                        sizeof *used + num * sizeof *used->ring + s);
 }
 
 /* Can we log writes? */
@@ -514,9 +520,11 @@ int vhost_log_access_ok(struct vhost_dev *dev)
 
 /* Verify access for write logging. */
 /* Caller should have vq mutex and device mutex */
-static int vq_log_access_ok(struct vhost_virtqueue *vq, void __user *log_base)
+static int vq_log_access_ok(struct vhost_dev *d, struct vhost_virtqueue *vq,
+                            void __user *log_base)
 {
         struct vhost_memory *mp;
+        size_t s = vhost_has_feature(d, VIRTIO_RING_F_EVENT_IDX) ? 2 : 0;
 
         mp = rcu_dereference_protected(vq->dev->memory,
                                        lockdep_is_held(&vq->mutex));
@@ -524,15 +532,15 @@ static int vq_log_access_ok(struct vhost_virtqueue *vq, void __user *log_base)
                             vhost_has_feature(vq->dev, VHOST_F_LOG_ALL)) &&
                 (!vq->log_used || log_access_ok(log_base, vq->log_addr,
                                         sizeof *vq->used +
-                                        vq->num * sizeof *vq->used->ring));
+                                        vq->num * sizeof *vq->used->ring + s));
 }
 
 /* Can we start vq? */
 /* Caller should have vq mutex and device mutex */
 int vhost_vq_access_ok(struct vhost_virtqueue *vq)
 {
-        return vq_access_ok(vq->num, vq->desc, vq->avail, vq->used) &&
-                vq_log_access_ok(vq, vq->log_base);
+        return vq_access_ok(vq->dev, vq->num, vq->desc, vq->avail, vq->used) &&
+                vq_log_access_ok(vq->dev, vq, vq->log_base);
 }
 
 static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m)
@@ -577,6 +585,7 @@ static int init_used(struct vhost_virtqueue *vq,
 
         if (r)
                 return r;
+        vq->signalled_used_valid = false;
         return get_user(vq->last_used_idx, &used->idx);
 }
 
@@ -674,7 +683,7 @@ static long vhost_set_vring(struct vhost_dev *d, int ioctl, void __user *argp)
                  * If it is not, we don't as size might not have been setup.
                  * We will verify when backend is configured. */
                 if (vq->private_data) {
-                        if (!vq_access_ok(vq->num,
+                        if (!vq_access_ok(d, vq->num,
                                 (void __user *)(unsigned long)a.desc_user_addr,
                                 (void __user *)(unsigned long)a.avail_user_addr,
                                 (void __user *)(unsigned long)a.used_user_addr)) {
@@ -818,7 +827,7 @@ long vhost_dev_ioctl(struct vhost_dev *d, unsigned int ioctl, unsigned long arg)
                         vq = d->vqs + i;
                         mutex_lock(&vq->mutex);
                         /* If ring is inactive, will check when it's enabled. */
-                        if (vq->private_data && !vq_log_access_ok(vq, base))
+                        if (vq->private_data && !vq_log_access_ok(d, vq, base))
                                 r = -EFAULT;
                         else
                                 vq->log_base = base;
@@ -1219,6 +1228,10 @@ int vhost_get_vq_desc(struct vhost_dev *dev, struct vhost_virtqueue *vq,
 
         /* On success, increment avail index. */
         vq->last_avail_idx++;
+
+        /* Assume notifications from guest are disabled at this point,
+         * if they aren't we would need to update avail_event index. */
+        BUG_ON(!(vq->used_flags & VRING_USED_F_NO_NOTIFY));
         return head;
 }
 
@@ -1267,6 +1280,12 @@ int vhost_add_used(struct vhost_virtqueue *vq, unsigned int head, int len)
                         eventfd_signal(vq->log_ctx, 1);
         }
         vq->last_used_idx++;
+        /* If the driver never bothers to signal in a very long while,
+         * used index might wrap around. If that happens, invalidate
+         * signalled_used index we stored. TODO: make sure driver
+         * signals at least once in 2^16 and remove this. */
+        if (unlikely(vq->last_used_idx == vq->signalled_used))
+                vq->signalled_used_valid = false;
         return 0;
 }
 
@@ -1275,6 +1294,7 @@ static int __vhost_add_used_n(struct vhost_virtqueue *vq,
                             unsigned count)
 {
         struct vring_used_elem __user *used;
+        u16 old, new;
         int start;
 
         start = vq->last_used_idx % vq->num;
@@ -1292,7 +1312,14 @@ static int __vhost_add_used_n(struct vhost_virtqueue *vq,
                            ((void __user *)used - (void __user *)vq->used),
                           count * sizeof *used);
         }
-        vq->last_used_idx += count;
+        old = vq->last_used_idx;
+        new = (vq->last_used_idx += count);
+        /* If the driver never bothers to signal in a very long while,
+         * used index might wrap around. If that happens, invalidate
+         * signalled_used index we stored. TODO: make sure driver
+         * signals at least once in 2^16 and remove this. */
+        if (unlikely((u16)(new - vq->signalled_used) < (u16)(new - old)))
+                vq->signalled_used_valid = false;
         return 0;
 }
 
@@ -1331,29 +1358,47 @@ int vhost_add_used_n(struct vhost_virtqueue *vq, struct vring_used_elem *heads,
         return r;
 }
 
-/* This actually signals the guest, using eventfd. */
-void vhost_signal(struct vhost_dev *dev, struct vhost_virtqueue *vq)
+static bool vhost_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
 {
-        __u16 flags;
-
+        __u16 old, new, event;
+        bool v;
         /* Flush out used index updates. This is paired
          * with the barrier that the Guest executes when enabling
          * interrupts. */
         smp_mb();
 
-        if (__get_user(flags, &vq->avail->flags)) {
-                vq_err(vq, "Failed to get flags");
-                return;
+        if (vhost_has_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
+            unlikely(vq->avail_idx == vq->last_avail_idx))
+                return true;
+
+        if (!vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
+                __u16 flags;
+                if (__get_user(flags, &vq->avail->flags)) {
+                        vq_err(vq, "Failed to get flags");
+                        return true;
+                }
+                return !(flags & VRING_AVAIL_F_NO_INTERRUPT);
         }
+        old = vq->signalled_used;
+        v = vq->signalled_used_valid;
+        new = vq->signalled_used = vq->last_used_idx;
+        vq->signalled_used_valid = true;
 
-        /* If they don't want an interrupt, don't signal, unless empty. */
-        if ((flags & VRING_AVAIL_F_NO_INTERRUPT) &&
-            (vq->avail_idx != vq->last_avail_idx ||
-             !vhost_has_feature(dev, VIRTIO_F_NOTIFY_ON_EMPTY)))
-                return;
+        if (unlikely(!v))
+                return true;
 
+        if (get_user(event, vhost_used_event(vq))) {
+                vq_err(vq, "Failed to get used event idx");
+                return true;
+        }
+        return vring_need_event(event, new, old);
+}
+
+/* This actually signals the guest, using eventfd. */
+void vhost_signal(struct vhost_dev *dev, struct vhost_virtqueue *vq)
+{
         /* Signal the Guest tell them we used something up. */
-        if (vq->call_ctx)
+        if (vq->call_ctx && vhost_notify(dev, vq))
                 eventfd_signal(vq->call_ctx, 1);
 }
 
@@ -1376,7 +1421,7 @@ void vhost_add_used_and_signal_n(struct vhost_dev *dev,
 }
 
 /* OK, now we need to know about added descriptors. */
-bool vhost_enable_notify(struct vhost_virtqueue *vq)
+bool vhost_enable_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
 {
         u16 avail_idx;
         int r;
@@ -1384,11 +1429,34 @@ bool vhost_enable_notify(struct vhost_virtqueue *vq)
         if (!(vq->used_flags & VRING_USED_F_NO_NOTIFY))
                 return false;
         vq->used_flags &= ~VRING_USED_F_NO_NOTIFY;
-        r = put_user(vq->used_flags, &vq->used->flags);
-        if (r) {
-                vq_err(vq, "Failed to enable notification at %p: %d\n",
-                       &vq->used->flags, r);
-                return false;
+        if (!vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
+                r = put_user(vq->used_flags, &vq->used->flags);
+                if (r) {
+                        vq_err(vq, "Failed to enable notification at %p: %d\n",
+                               &vq->used->flags, r);
+                        return false;
+                }
+        } else {
+                r = put_user(vq->avail_idx, vhost_avail_event(vq));
+                if (r) {
+                        vq_err(vq, "Failed to update avail event index at %p: %d\n",
+                               vhost_avail_event(vq), r);
+                        return false;
+                }
+        }
+        if (unlikely(vq->log_used)) {
+                void __user *used;
+                /* Make sure data is seen before log. */
+                smp_wmb();
+                used = vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX) ?
+                        &vq->used->flags : vhost_avail_event(vq);
+                /* Log used flags or event index entry write. Both are 16 bit
+                 * fields. */
+                log_write(vq->log_base, vq->log_addr +
+                           (used - (void __user *)vq->used),
+                          sizeof(u16));
+                if (vq->log_ctx)
+                        eventfd_signal(vq->log_ctx, 1);
         }
         /* They could have slipped one in as we were doing that: make
          * sure it's written, then check again. */
@@ -1404,15 +1472,17 @@ bool vhost_enable_notify(struct vhost_virtqueue *vq)
 }
 
 /* We don't need to be notified again. */
-void vhost_disable_notify(struct vhost_virtqueue *vq)
+void vhost_disable_notify(struct vhost_dev *dev, struct vhost_virtqueue *vq)
 {
         int r;
 
         if (vq->used_flags & VRING_USED_F_NO_NOTIFY)
                 return;
         vq->used_flags |= VRING_USED_F_NO_NOTIFY;
-        r = put_user(vq->used_flags, &vq->used->flags);
-        if (r)
-                vq_err(vq, "Failed to enable notification at %p: %d\n",
-                       &vq->used->flags, r);
+        if (!vhost_has_feature(dev, VIRTIO_RING_F_EVENT_IDX)) {
+                r = put_user(vq->used_flags, &vq->used->flags);
+                if (r)
+                        vq_err(vq, "Failed to enable notification at %p: %d\n",
+                               &vq->used->flags, r);
+        }
 }
diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h
index b3363ae38518..8e03379dd30f 100644
--- a/drivers/vhost/vhost.h
+++ b/drivers/vhost/vhost.h
@@ -84,6 +84,12 @@ struct vhost_virtqueue {
         /* Used flags */
         u16 used_flags;
 
+        /* Last used index value we have signalled on */
+        u16 signalled_used;
+
+        /* Last used index value we have signalled on */
+        bool signalled_used_valid;
+
         /* Log writes to used structure. */
         bool log_used;
         u64 log_addr;
@@ -149,8 +155,8 @@ void vhost_add_used_and_signal(struct vhost_dev *, struct vhost_virtqueue *,
 void vhost_add_used_and_signal_n(struct vhost_dev *, struct vhost_virtqueue *,
                                struct vring_used_elem *heads, unsigned count);
 void vhost_signal(struct vhost_dev *, struct vhost_virtqueue *);
-void vhost_disable_notify(struct vhost_virtqueue *);
-bool vhost_enable_notify(struct vhost_virtqueue *);
+void vhost_disable_notify(struct vhost_dev *, struct vhost_virtqueue *);
+bool vhost_enable_notify(struct vhost_dev *, struct vhost_virtqueue *);
 
 int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log,
                     unsigned int log_num, u64 len);
@@ -162,11 +168,12 @@ int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log,
         } while (0)
 
 enum {
-        VHOST_FEATURES = (1 << VIRTIO_F_NOTIFY_ON_EMPTY) |
-                         (1 << VIRTIO_RING_F_INDIRECT_DESC) |
-                         (1 << VHOST_F_LOG_ALL) |
-                         (1 << VHOST_NET_F_VIRTIO_NET_HDR) |
-                         (1 << VIRTIO_NET_F_MRG_RXBUF),
+        VHOST_FEATURES = (1ULL << VIRTIO_F_NOTIFY_ON_EMPTY) |
+                         (1ULL << VIRTIO_RING_F_INDIRECT_DESC) |
+                         (1ULL << VIRTIO_RING_F_EVENT_IDX) |
+                         (1ULL << VHOST_F_LOG_ALL) |
+                         (1ULL << VHOST_NET_F_VIRTIO_NET_HDR) |
+                         (1ULL << VIRTIO_NET_F_MRG_RXBUF),
 };
 
 static inline int vhost_has_feature(struct vhost_dev *dev, int bit)
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 0f1da45ba47d..e058ace2a4ad 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -40,9 +40,6 @@ struct virtio_balloon
         /* Waiting for host to ack the pages we released. */
         struct completion acked;
 
-        /* Do we have to tell Host *before* we reuse pages? */
-        bool tell_host_first;
-
         /* The pages we've told the Host we're not using. */
         unsigned int num_pages;
         struct list_head pages;
@@ -151,13 +148,14 @@ static void leak_balloon(struct virtio_balloon *vb, size_t num)
                 vb->num_pages--;
         }
 
-        if (vb->tell_host_first) {
-                tell_host(vb, vb->deflate_vq);
-                release_pages_by_pfn(vb->pfns, vb->num_pfns);
-        } else {
-                release_pages_by_pfn(vb->pfns, vb->num_pfns);
-                tell_host(vb, vb->deflate_vq);
-        }
+
+        /*
+         * Note that if
+         * virtio_has_feature(vdev, VIRTIO_BALLOON_F_MUST_TELL_HOST);
+         * is true, we *have* to do it in this order
+         */
+        tell_host(vb, vb->deflate_vq);
+        release_pages_by_pfn(vb->pfns, vb->num_pfns);
 }
 
 static inline void update_stat(struct virtio_balloon *vb, int idx,
@@ -325,9 +323,6 @@ static int virtballoon_probe(struct virtio_device *vdev)
                 goto out_del_vqs;
         }
 
-        vb->tell_host_first
-                = virtio_has_feature(vdev, VIRTIO_BALLOON_F_MUST_TELL_HOST);
-
         return 0;
 
 out_del_vqs:
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index b0043fb26a4d..68b9136847af 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -82,6 +82,9 @@ struct vring_virtqueue
         /* Host supports indirect buffers */
         bool indirect;
 
+        /* Host publishes avail event idx */
+        bool event;
+
         /* Number of free buffers */
         unsigned int num_free;
         /* Head of free buffer list. */
@@ -237,18 +240,22 @@ EXPORT_SYMBOL_GPL(virtqueue_add_buf_gfp);
 void virtqueue_kick(struct virtqueue *_vq)
 {
         struct vring_virtqueue *vq = to_vvq(_vq);
+        u16 new, old;
         START_USE(vq);
         /* Descriptors and available array need to be set before we expose the
          * new available array entries. */
         virtio_wmb();
 
-        vq->vring.avail->idx += vq->num_added;
+        old = vq->vring.avail->idx;
+        new = vq->vring.avail->idx = old + vq->num_added;
         vq->num_added = 0;
 
         /* Need to update avail index before checking if we should notify */
         virtio_mb();
 
-        if (!(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY))
+        if (vq->event ?
+            vring_need_event(vring_avail_event(&vq->vring), new, old) :
+            !(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY))
                 /* Prod other side to tell it about changes. */
                 vq->notify(&vq->vq);
 
@@ -324,6 +331,14 @@ void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
         ret = vq->data[i];
         detach_buf(vq, i);
         vq->last_used_idx++;
+        /* If we expect an interrupt for the next entry, tell host
+         * by writing event index and flush out the write before
+         * the read in the next get_buf call. */
+        if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
+                vring_used_event(&vq->vring) = vq->last_used_idx;
+                virtio_mb();
+        }
+
         END_USE(vq);
         return ret;
 }
@@ -345,7 +360,11 @@ bool virtqueue_enable_cb(struct virtqueue *_vq)
 
         /* We optimistically turn back on interrupts, then check if there was
          * more to do. */
+        /* Depending on the VIRTIO_RING_F_EVENT_IDX feature, we need to
+         * either clear the flags bit or point the event index at the next
+         * entry. Always do both to keep code simple. */
         vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
+        vring_used_event(&vq->vring) = vq->last_used_idx;
         virtio_mb();
         if (unlikely(more_used(vq))) {
                 END_USE(vq);
@@ -357,6 +376,33 @@ bool virtqueue_enable_cb(struct virtqueue *_vq)
 }
 EXPORT_SYMBOL_GPL(virtqueue_enable_cb);
 
+bool virtqueue_enable_cb_delayed(struct virtqueue *_vq)
+{
+        struct vring_virtqueue *vq = to_vvq(_vq);
+        u16 bufs;
+
+        START_USE(vq);
+
+        /* We optimistically turn back on interrupts, then check if there was
+         * more to do. */
+        /* Depending on the VIRTIO_RING_F_USED_EVENT_IDX feature, we need to
+         * either clear the flags bit or point the event index at the next
+         * entry. Always do both to keep code simple. */
+        vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
+        /* TODO: tune this threshold */
+        bufs = (u16)(vq->vring.avail->idx - vq->last_used_idx) * 3 / 4;
+        vring_used_event(&vq->vring) = vq->last_used_idx + bufs;
+        virtio_mb();
+        if (unlikely((u16)(vq->vring.used->idx - vq->last_used_idx) > bufs)) {
+                END_USE(vq);
+                return false;
+        }
+
+        END_USE(vq);
+        return true;
+}
+EXPORT_SYMBOL_GPL(virtqueue_enable_cb_delayed);
+
 void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
 {
         struct vring_virtqueue *vq = to_vvq(_vq);
@@ -438,6 +484,7 @@ struct virtqueue *vring_new_virtqueue(unsigned int num,
 #endif
 
         vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC);
+        vq->event = virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
 
         /* No callback?  Tell other side not to bother us. */
         if (!callback)
@@ -472,6 +519,8 @@ void vring_transport_features(struct virtio_device *vdev)
                 switch (i) {
                 case VIRTIO_RING_F_INDIRECT_DESC:
                         break;
+                case VIRTIO_RING_F_EVENT_IDX:
+                        break;
                 default:
                         /* We don't understand this bit. */
                         clear_bit(i, vdev->features);