275 files changed, 9917 insertions, 2080 deletions

diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index d80f4cc2e0da..65d90c720b5a 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -19,7 +19,7 @@ obj-y				+= osl.o utils.o reboot.o\
 
 # sleep related files
 obj-y                           += wakeup.o
-obj-y                           += main.o
+obj-y                           += sleep.o
 obj-$(CONFIG_ACPI_SLEEP)        += proc.o
 
 
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 8dfcbb8aff73..a2b82c90a683 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -120,31 +120,6 @@ static struct acpi_ec {
         spinlock_t curr_lock;
 } *boot_ec, *first_ec;
 
-/* 
- * Some Asus system have exchanged ECDT data/command IO addresses.
- */
-static int print_ecdt_error(const struct dmi_system_id *id)
-{
-        printk(KERN_NOTICE PREFIX "%s detected - "
-                "ECDT has exchanged control/data I/O address\n",
-                id->ident);
-        return 0;
-}
-
-static struct dmi_system_id __cpuinitdata ec_dmi_table[] = {
-        {
-        print_ecdt_error, "Asus L4R", {
-        DMI_MATCH(DMI_BIOS_VERSION, "1008.006"),
-        DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),
-        DMI_MATCH(DMI_BOARD_NAME, "L4R") }, NULL},
-        {
-        print_ecdt_error, "Asus M6R", {
-        DMI_MATCH(DMI_BIOS_VERSION, "0207"),
-        DMI_MATCH(DMI_PRODUCT_NAME, "M6R"),
-        DMI_MATCH(DMI_BOARD_NAME, "M6R") }, NULL},
-        {},
-};
-
 /* --------------------------------------------------------------------------
                              Transaction Management
    -------------------------------------------------------------------------- */
@@ -983,8 +958,8 @@ static const struct acpi_device_id ec_device_ids[] = {
 int __init acpi_ec_ecdt_probe(void)
 {
         acpi_status status;
+        struct acpi_ec *saved_ec = NULL;
         struct acpi_table_ecdt *ecdt_ptr;
-        acpi_handle dummy;
 
         boot_ec = make_acpi_ec();
         if (!boot_ec)
@@ -998,21 +973,16 @@ int __init acpi_ec_ecdt_probe(void)
                 pr_info(PREFIX "EC description table is found, configuring boot EC\n");
                 boot_ec->command_addr = ecdt_ptr->control.address;
                 boot_ec->data_addr = ecdt_ptr->data.address;
-                if (dmi_check_system(ec_dmi_table)) {
-                        /*
-                         * If the board falls into ec_dmi_table, it means
-                         * that ECDT table gives the incorrect command/status
-                         * & data I/O address. Just fix it.
-                         */
-                        boot_ec->data_addr = ecdt_ptr->control.address;
-                        boot_ec->command_addr = ecdt_ptr->data.address;
-                }
                 boot_ec->gpe = ecdt_ptr->gpe;
                 boot_ec->handle = ACPI_ROOT_OBJECT;
                 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
-                /* Add some basic check against completely broken table */
-                if (boot_ec->data_addr != boot_ec->command_addr)
+                /* Don't trust ECDT, which comes from ASUSTek */
+                if (!dmi_name_in_vendors("ASUS"))
                         goto install;
+                saved_ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
+                if (!saved_ec)
+                        return -ENOMEM;
+                memcpy(&saved_ec, boot_ec, sizeof(saved_ec));
         /* fall through */
         }
         /* This workaround is needed only on some broken machines,
@@ -1023,12 +993,29 @@ int __init acpi_ec_ecdt_probe(void)
         /* Check that acpi_get_devices actually find something */
         if (ACPI_FAILURE(status) || !boot_ec->handle)
                 goto error;
-        /* We really need to limit this workaround, the only ASUS,
-         * which needs it, has fake EC._INI method, so use it as flag.
-         * Keep boot_ec struct as it will be needed soon.
-         */
-        if (ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI", &dummy)))
-                return -ENODEV;
+        if (saved_ec) {
+                /* try to find good ECDT from ASUSTek */
+                if (saved_ec->command_addr != boot_ec->command_addr ||
+                    saved_ec->data_addr != boot_ec->data_addr ||
+                    saved_ec->gpe != boot_ec->gpe ||
+                    saved_ec->handle != boot_ec->handle)
+                        pr_info(PREFIX "ASUSTek keeps feeding us with broken "
+                        "ECDT tables, which are very hard to workaround. "
+                        "Trying to use DSDT EC info instead. Please send "
+                        "output of acpidump to linux-acpi@vger.kernel.org\n");
+                kfree(saved_ec);
+                saved_ec = NULL;
+        } else {
+                /* We really need to limit this workaround, the only ASUS,
+                * which needs it, has fake EC._INI method, so use it as flag.
+                * Keep boot_ec struct as it will be needed soon.
+                */
+                acpi_handle dummy;
+                if (!dmi_name_in_vendors("ASUS") ||
+                    ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI",
+                                                        &dummy)))
+                        return -ENODEV;
+        }
 install:
         if (!ec_install_handlers(boot_ec)) {
                 first_ec = boot_ec;
diff --git a/drivers/acpi/main.c b/drivers/acpi/sleep.c
index 7e3c609cbef2..7e3c609cbef2 100644
--- a/drivers/acpi/main.c
+++ b/drivers/acpi/sleep.c
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 073ff09218a9..99e6f1f8ea45 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -416,7 +416,8 @@ static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
         }
 
         /* Passive (optional) */
-        if (flag & ACPI_TRIPS_PASSIVE) {
+        if (((flag & ACPI_TRIPS_PASSIVE) && tz->trips.passive.flags.valid) ||
+                (flag == ACPI_TRIPS_INIT)) {
                 valid = tz->trips.passive.flags.valid;
                 if (psv == -1) {
                         status = AE_SUPPORT;
@@ -462,8 +463,11 @@ static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
                 memset(&devices, 0, sizeof(struct acpi_handle_list));
                 status = acpi_evaluate_reference(tz->device->handle, "_PSL",
                                                         NULL, &devices);
-                if (ACPI_FAILURE(status))
+                if (ACPI_FAILURE(status)) {
+                        printk(KERN_WARNING PREFIX
+                                "Invalid passive threshold\n");
                         tz->trips.passive.flags.valid = 0;
+                }
                 else
                         tz->trips.passive.flags.valid = 1;
 
@@ -487,7 +491,8 @@ static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
                 if (act == -1)
                         break; /* disable all active trip points */
 
-                if (flag & ACPI_TRIPS_ACTIVE) {
+                if ((flag == ACPI_TRIPS_INIT) || ((flag & ACPI_TRIPS_ACTIVE) &&
+                        tz->trips.active[i].flags.valid)) {
                         status = acpi_evaluate_integer(tz->device->handle,
                                                         name, NULL, &tmp);
                         if (ACPI_FAILURE(status)) {
@@ -521,8 +526,11 @@ static int acpi_thermal_trips_update(struct acpi_thermal *tz, int flag)
                         memset(&devices, 0, sizeof(struct acpi_handle_list));
                         status = acpi_evaluate_reference(tz->device->handle,
                                                 name, NULL, &devices);
-                        if (ACPI_FAILURE(status))
+                        if (ACPI_FAILURE(status)) {
+                                printk(KERN_WARNING PREFIX
+                                        "Invalid active%d threshold\n", i);
                                 tz->trips.active[i].flags.valid = 0;
+                        }
                         else
                                 tz->trips.active[i].flags.valid = 1;
 
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 1a7be96d627b..503a908afc80 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -698,6 +698,15 @@ config PATA_IXP4XX_CF
 
           If unsure, say N.
 
+config PATA_OCTEON_CF
+        tristate "OCTEON Boot Bus Compact Flash support"
+        depends on CPU_CAVIUM_OCTEON
+        help
+          This option enables a polled compact flash driver for use with
+          compact flash cards attached to the OCTEON boot bus.
+
+          If unsure, say N.
+
 config PATA_SCC
         tristate "Toshiba's Cell Reference Set IDE support"
         depends on PCI && PPC_CELLEB
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 674965fa326d..7f1ecf99528c 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -69,6 +69,7 @@ obj-$(CONFIG_PATA_IXP4XX_CF)	+= pata_ixp4xx_cf.o
 obj-$(CONFIG_PATA_SCC)          += pata_scc.o
 obj-$(CONFIG_PATA_SCH)          += pata_sch.o
 obj-$(CONFIG_PATA_BF54X)        += pata_bf54x.o
+obj-$(CONFIG_PATA_OCTEON_CF)    += pata_octeon_cf.o
 obj-$(CONFIG_PATA_PLATFORM)     += pata_platform.o
 obj-$(CONFIG_PATA_OF_PLATFORM)  += pata_of_platform.o
 obj-$(CONFIG_PATA_ICSIDE)       += pata_icside.o
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 71218d76d75e..88c242856dae 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -3029,33 +3029,33 @@ int sata_set_spd(struct ata_link *link)
  */
 
 static const struct ata_timing ata_timing[] = {
-/*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 960,   0 }, */
-        { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 600,   0 },
-        { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 383,   0 },
-        { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 240,   0 },
-        { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 180,   0 },
-        { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 120,   0 },
-        { XFER_PIO_5,     15,  65,  25, 100,  65,  25, 100,   0 },
-        { XFER_PIO_6,     10,  55,  20,  80,  55,  20,  80,   0 },
-
-        { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 960,   0 },
-        { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 480,   0 },
-        { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 240,   0 },
-
-        { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 480,   0 },
-        { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 150,   0 },
-        { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 120,   0 },
-        { XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 100,   0 },
-        { XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20,  80,   0 },
-
-/*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0,   0, 150 }, */
-        { XFER_UDMA_0,     0,   0,   0,   0,   0,   0,   0, 120 },
-        { XFER_UDMA_1,     0,   0,   0,   0,   0,   0,   0,  80 },
-        { XFER_UDMA_2,     0,   0,   0,   0,   0,   0,   0,  60 },
-        { XFER_UDMA_3,     0,   0,   0,   0,   0,   0,   0,  45 },
-        { XFER_UDMA_4,     0,   0,   0,   0,   0,   0,   0,  30 },
-        { XFER_UDMA_5,     0,   0,   0,   0,   0,   0,   0,  20 },
-        { XFER_UDMA_6,     0,   0,   0,   0,   0,   0,   0,  15 },
+/*      { XFER_PIO_SLOW, 120, 290, 240, 960, 290, 240, 0,  960,   0 }, */
+        { XFER_PIO_0,     70, 290, 240, 600, 165, 150, 0,  600,   0 },
+        { XFER_PIO_1,     50, 290,  93, 383, 125, 100, 0,  383,   0 },
+        { XFER_PIO_2,     30, 290,  40, 330, 100,  90, 0,  240,   0 },
+        { XFER_PIO_3,     30,  80,  70, 180,  80,  70, 0,  180,   0 },
+        { XFER_PIO_4,     25,  70,  25, 120,  70,  25, 0,  120,   0 },
+        { XFER_PIO_5,     15,  65,  25, 100,  65,  25, 0,  100,   0 },
+        { XFER_PIO_6,     10,  55,  20,  80,  55,  20, 0,   80,   0 },
+
+        { XFER_SW_DMA_0, 120,   0,   0,   0, 480, 480, 50, 960,   0 },
+        { XFER_SW_DMA_1,  90,   0,   0,   0, 240, 240, 30, 480,   0 },
+        { XFER_SW_DMA_2,  60,   0,   0,   0, 120, 120, 20, 240,   0 },
+
+        { XFER_MW_DMA_0,  60,   0,   0,   0, 215, 215, 20, 480,   0 },
+        { XFER_MW_DMA_1,  45,   0,   0,   0,  80,  50, 5,  150,   0 },
+        { XFER_MW_DMA_2,  25,   0,   0,   0,  70,  25, 5,  120,   0 },
+        { XFER_MW_DMA_3,  25,   0,   0,   0,  65,  25, 5,  100,   0 },
+        { XFER_MW_DMA_4,  25,   0,   0,   0,  55,  20, 5,   80,   0 },
+
+/*      { XFER_UDMA_SLOW,  0,   0,   0,   0,   0,   0, 0,    0, 150 }, */
+        { XFER_UDMA_0,     0,   0,   0,   0,   0,   0, 0,    0, 120 },
+        { XFER_UDMA_1,     0,   0,   0,   0,   0,   0, 0,    0,  80 },
+        { XFER_UDMA_2,     0,   0,   0,   0,   0,   0, 0,    0,  60 },
+        { XFER_UDMA_3,     0,   0,   0,   0,   0,   0, 0,    0,  45 },
+        { XFER_UDMA_4,     0,   0,   0,   0,   0,   0, 0,    0,  30 },
+        { XFER_UDMA_5,     0,   0,   0,   0,   0,   0, 0,    0,  20 },
+        { XFER_UDMA_6,     0,   0,   0,   0,   0,   0, 0,    0,  15 },
 
         { 0xFF }
 };
@@ -3065,14 +3065,15 @@ static const struct ata_timing ata_timing[] = {
 
 static void ata_timing_quantize(const struct ata_timing *t, struct ata_timing *q, int T, int UT)
 {
-        q->setup   = EZ(t->setup   * 1000,  T);
-        q->act8b   = EZ(t->act8b   * 1000,  T);
-        q->rec8b   = EZ(t->rec8b   * 1000,  T);
-        q->cyc8b   = EZ(t->cyc8b   * 1000,  T);
-        q->active  = EZ(t->active  * 1000,  T);
-        q->recover = EZ(t->recover * 1000,  T);
-        q->cycle   = EZ(t->cycle   * 1000,  T);
-        q->udma    = EZ(t->udma    * 1000, UT);
+        q->setup        = EZ(t->setup      * 1000,  T);
+        q->act8b        = EZ(t->act8b      * 1000,  T);
+        q->rec8b        = EZ(t->rec8b      * 1000,  T);
+        q->cyc8b        = EZ(t->cyc8b      * 1000,  T);
+        q->active       = EZ(t->active     * 1000,  T);
+        q->recover      = EZ(t->recover    * 1000,  T);
+        q->dmack_hold   = EZ(t->dmack_hold * 1000,  T);
+        q->cycle        = EZ(t->cycle      * 1000,  T);
+        q->udma         = EZ(t->udma       * 1000, UT);
 }
 
 void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
@@ -3084,6 +3085,7 @@ void ata_timing_merge(const struct ata_timing *a, const struct ata_timing *b,
         if (what & ATA_TIMING_CYC8B  ) m->cyc8b   = max(a->cyc8b,   b->cyc8b);
         if (what & ATA_TIMING_ACTIVE ) m->active  = max(a->active,  b->active);
         if (what & ATA_TIMING_RECOVER) m->recover = max(a->recover, b->recover);
+        if (what & ATA_TIMING_DMACK_HOLD) m->dmack_hold = max(a->dmack_hold, b->dmack_hold);
         if (what & ATA_TIMING_CYCLE  ) m->cycle   = max(a->cycle,   b->cycle);
         if (what & ATA_TIMING_UDMA   ) m->udma    = max(a->udma,    b->udma);
 }
@@ -6638,7 +6640,6 @@ EXPORT_SYMBOL_GPL(ata_dev_pair);
 EXPORT_SYMBOL_GPL(ata_port_disable);
 EXPORT_SYMBOL_GPL(ata_ratelimit);
 EXPORT_SYMBOL_GPL(ata_wait_register);
-EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
 EXPORT_SYMBOL_GPL(ata_scsi_queuecmd);
 EXPORT_SYMBOL_GPL(ata_scsi_slave_config);
 EXPORT_SYMBOL_GPL(ata_scsi_slave_destroy);
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 9e92107691f2..a1a6e6298c33 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -423,9 +423,9 @@ int ata_std_bios_param(struct scsi_device *sdev, struct block_device *bdev,
  *      RETURNS:
  *      Zero on success, negative errno on error.
  */
-static int ata_get_identity(struct scsi_device *sdev, void __user *arg)
+static int ata_get_identity(struct ata_port *ap, struct scsi_device *sdev,
+                            void __user *arg)
 {
-        struct ata_port *ap = ata_shost_to_port(sdev->host);
         struct ata_device *dev = ata_scsi_find_dev(ap, sdev);
         u16 __user *dst = arg;
         char buf[40];
@@ -645,7 +645,8 @@ int ata_task_ioctl(struct scsi_device *scsidev, void __user *arg)
         return rc;
 }
 
-int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
+int ata_sas_scsi_ioctl(struct ata_port *ap, struct scsi_device *scsidev,
+                     int cmd, void __user *arg)
 {
         int val = -EINVAL, rc = -EINVAL;
 
@@ -663,7 +664,7 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
                 return 0;
 
         case HDIO_GET_IDENTITY:
-                return ata_get_identity(scsidev, arg);
+                return ata_get_identity(ap, scsidev, arg);
 
         case HDIO_DRIVE_CMD:
                 if (!capable(CAP_SYS_ADMIN) || !capable(CAP_SYS_RAWIO))
@@ -682,6 +683,14 @@ int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
 
         return rc;
 }
+EXPORT_SYMBOL_GPL(ata_sas_scsi_ioctl);
+
+int ata_scsi_ioctl(struct scsi_device *scsidev, int cmd, void __user *arg)
+{
+        return ata_sas_scsi_ioctl(ata_shost_to_port(scsidev->host),
+                                scsidev, cmd, arg);
+}
+EXPORT_SYMBOL_GPL(ata_scsi_ioctl);
 
 /**
  *      ata_scsi_qc_new - acquire new ata_queued_cmd reference
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index a7999c19f0c9..eb99dbe78081 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -41,7 +41,7 @@ static int ali_atapi_dma = 0;
 module_param_named(atapi_dma, ali_atapi_dma, int, 0644);
 MODULE_PARM_DESC(atapi_dma, "Enable ATAPI DMA (0=disable, 1=enable)");
 
-static struct pci_dev *isa_bridge;
+static struct pci_dev *ali_isa_bridge;
 
 /*
  *      Cable special cases
@@ -346,13 +346,13 @@ static void ali_c2_c3_postreset(struct ata_link *link, unsigned int *classes)
         int port_bit = 4 << link->ap->port_no;
 
         /* If our bridge is an ALI 1533 then do the extra work */
-        if (isa_bridge) {
+        if (ali_isa_bridge) {
                 /* Tristate and re-enable the bus signals */
-                pci_read_config_byte(isa_bridge, 0x58, &r);
+                pci_read_config_byte(ali_isa_bridge, 0x58, &r);
                 r &= ~port_bit;
-                pci_write_config_byte(isa_bridge, 0x58, r);
+                pci_write_config_byte(ali_isa_bridge, 0x58, r);
                 r |= port_bit;
-                pci_write_config_byte(isa_bridge, 0x58, r);
+                pci_write_config_byte(ali_isa_bridge, 0x58, r);
         }
         ata_sff_postreset(link, classes);
 }
@@ -467,14 +467,14 @@ static void ali_init_chipset(struct pci_dev *pdev)
                 pci_write_config_byte(pdev, 0x53, tmp);
         }
         north = pci_get_bus_and_slot(0, PCI_DEVFN(0,0));
-        if (north && north->vendor == PCI_VENDOR_ID_AL && isa_bridge) {
+        if (north && north->vendor == PCI_VENDOR_ID_AL && ali_isa_bridge) {
                 /* Configure the ALi bridge logic. For non ALi rely on BIOS.
                    Set the south bridge enable bit */
-                pci_read_config_byte(isa_bridge, 0x79, &tmp);
+                pci_read_config_byte(ali_isa_bridge, 0x79, &tmp);
                 if (pdev->revision == 0xC2)
-                        pci_write_config_byte(isa_bridge, 0x79, tmp | 0x04);
+                        pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x04);
                 else if (pdev->revision > 0xC2 && pdev->revision < 0xC5)
-                        pci_write_config_byte(isa_bridge, 0x79, tmp | 0x02);
+                        pci_write_config_byte(ali_isa_bridge, 0x79, tmp | 0x02);
         }
         pci_dev_put(north);
         ata_pci_bmdma_clear_simplex(pdev);
@@ -571,9 +571,9 @@ static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 
         ali_init_chipset(pdev);
 
-        if (isa_bridge && pdev->revision >= 0x20 && pdev->revision < 0xC2) {
+        if (ali_isa_bridge && pdev->revision >= 0x20 && pdev->revision < 0xC2) {
                 /* Are we paired with a UDMA capable chip */
-                pci_read_config_byte(isa_bridge, 0x5E, &tmp);
+                pci_read_config_byte(ali_isa_bridge, 0x5E, &tmp);
                 if ((tmp & 0x1E) == 0x12)
                         ppi[0] = &info_20_udma;
         }
@@ -617,11 +617,11 @@ static struct pci_driver ali_pci_driver = {
 static int __init ali_init(void)
 {
         int ret;
-        isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
+        ali_isa_bridge = pci_get_device(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M1533, NULL);
 
         ret = pci_register_driver(&ali_pci_driver);
         if (ret < 0)
-                pci_dev_put(isa_bridge);
+                pci_dev_put(ali_isa_bridge);
         return ret;
 }
 
@@ -629,7 +629,7 @@ static int __init ali_init(void)
 static void __exit ali_exit(void)
 {
         pci_unregister_driver(&ali_pci_driver);
-        pci_dev_put(isa_bridge);
+        pci_dev_put(ali_isa_bridge);
 }
 
 
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 0e2cde8f9973..506adde8ebb3 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -32,21 +32,6 @@ enum {
         ATIIXP_IDE_UDMA_MODE    = 0x56
 };
 
-static int atiixp_pre_reset(struct ata_link *link, unsigned long deadline)
-{
-        struct ata_port *ap = link->ap;
-        static const struct pci_bits atiixp_enable_bits[] = {
-                { 0x48, 1, 0x01, 0x00 },
-                { 0x48, 1, 0x08, 0x00 }
-        };
-        struct pci_dev *pdev = to_pci_dev(ap->host->dev);
-
-        if (!pci_test_config_bits(pdev, &atiixp_enable_bits[ap->port_no]))
-                return -ENOENT;
-
-        return ata_sff_prereset(link, deadline);
-}
-
 static int atiixp_cable_detect(struct ata_port *ap)
 {
         struct pci_dev *pdev = to_pci_dev(ap->host->dev);
@@ -229,10 +214,9 @@ static struct ata_port_operations atiixp_port_ops = {
         .cable_detect   = atiixp_cable_detect,
         .set_piomode    = atiixp_set_piomode,
         .set_dmamode    = atiixp_set_dmamode,
-        .prereset       = atiixp_pre_reset,
 };
 
-static int atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
+static int atiixp_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 {
         static const struct ata_port_info info = {
                 .flags = ATA_FLAG_SLAVE_POSS,
@@ -241,8 +225,18 @@ static int atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
                 .udma_mask = 0x3F,
                 .port_ops = &atiixp_port_ops
         };
-        const struct ata_port_info *ppi[] = { &info, NULL };
-        return ata_pci_sff_init_one(dev, ppi, &atiixp_sht, NULL);
+        static const struct pci_bits atiixp_enable_bits[] = {
+                { 0x48, 1, 0x01, 0x00 },
+                { 0x48, 1, 0x08, 0x00 }
+        };
+        const struct ata_port_info *ppi[] = { &info, &info };
+        int i;
+
+        for (i = 0; i < 2; i++)
+                if (!pci_test_config_bits(pdev, &atiixp_enable_bits[i]))
+                        ppi[i] = &ata_dummy_port_info;
+
+        return ata_pci_sff_init_one(pdev, ppi, &atiixp_sht, NULL);
 }
 
 static const struct pci_device_id atiixp[] = {
diff --git a/drivers/ata/pata_octeon_cf.c b/drivers/ata/pata_octeon_cf.c
new file mode 100644
index 000000000000..0fe4ef309c62
--- /dev/null
+++ b/drivers/ata/pata_octeon_cf.c
@@ -0,0 +1,965 @@
+/*
+ * Driver for the Octeon bootbus compact flash.
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License.  See the file "COPYING" in the main directory of this archive
+ * for more details.
+ *
+ * Copyright (C) 2005 - 2009 Cavium Networks
+ * Copyright (C) 2008 Wind River Systems
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/libata.h>
+#include <linux/irq.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+#include <scsi/scsi_host.h>
+
+#include <asm/octeon/octeon.h>
+
+/*
+ * The Octeon bootbus compact flash interface is connected in at least
+ * 3 different configurations on various evaluation boards:
+ *
+ * -- 8  bits no irq, no DMA
+ * -- 16 bits no irq, no DMA
+ * -- 16 bits True IDE mode with DMA, but no irq.
+ *
+ * In the last case the DMA engine can generate an interrupt when the
+ * transfer is complete.  For the first two cases only PIO is supported.
+ *
+ */
+
+#define DRV_NAME        "pata_octeon_cf"
+#define DRV_VERSION     "2.1"
+
+
+struct octeon_cf_port {
+        struct workqueue_struct *wq;
+        struct delayed_work delayed_finish;
+        struct ata_port *ap;
+        int dma_finished;
+};
+
+static struct scsi_host_template octeon_cf_sht = {
+        ATA_PIO_SHT(DRV_NAME),
+};
+
+/**
+ * Convert nanosecond based time to setting used in the
+ * boot bus timing register, based on timing multiple
+ */
+static unsigned int ns_to_tim_reg(unsigned int tim_mult, unsigned int nsecs)
+{
+        unsigned int val;
+
+        /*
+         * Compute # of eclock periods to get desired duration in
+         * nanoseconds.
+         */
+        val = DIV_ROUND_UP(nsecs * (octeon_get_clock_rate() / 1000000),
+                          1000 * tim_mult);
+
+        return val;
+}
+
+static void octeon_cf_set_boot_reg_cfg(int cs)
+{
+        union cvmx_mio_boot_reg_cfgx reg_cfg;
+        reg_cfg.u64 = cvmx_read_csr(CVMX_MIO_BOOT_REG_CFGX(cs));
+        reg_cfg.s.dmack = 0;    /* Don't assert DMACK on access */
+        reg_cfg.s.tim_mult = 2; /* Timing mutiplier 2x */
+        reg_cfg.s.rd_dly = 0;   /* Sample on falling edge of BOOT_OE */
+        reg_cfg.s.sam = 0;      /* Don't combine write and output enable */
+        reg_cfg.s.we_ext = 0;   /* No write enable extension */
+        reg_cfg.s.oe_ext = 0;   /* No read enable extension */
+        reg_cfg.s.en = 1;       /* Enable this region */
+        reg_cfg.s.orbit = 0;    /* Don't combine with previous region */
+        reg_cfg.s.ale = 0;      /* Don't do address multiplexing */
+        cvmx_write_csr(CVMX_MIO_BOOT_REG_CFGX(cs), reg_cfg.u64);
+}
+
+/**
+ * Called after libata determines the needed PIO mode. This
+ * function programs the Octeon bootbus regions to support the
+ * timing requirements of the PIO mode.
+ *
+ * @ap:     ATA port information
+ * @dev:    ATA device
+ */
+static void octeon_cf_set_piomode(struct ata_port *ap, struct ata_device *dev)
+{
+        struct octeon_cf_data *ocd = ap->dev->platform_data;
+        union cvmx_mio_boot_reg_timx reg_tim;
+        int cs = ocd->base_region;
+        int T;
+        struct ata_timing timing;
+
+        int use_iordy;
+        int trh;
+        int pause;
+        /* These names are timing parameters from the ATA spec */
+        int t1;
+        int t2;
+        int t2i;
+
+        T = (int)(2000000000000LL / octeon_get_clock_rate());
+
+        if (ata_timing_compute(dev, dev->pio_mode, &timing, T, T))
+                BUG();
+
+        t1 = timing.setup;
+        if (t1)
+                t1--;
+        t2 = timing.active;
+        if (t2)
+                t2--;
+        t2i = timing.act8b;
+        if (t2i)
+                t2i--;
+
+        trh = ns_to_tim_reg(2, 20);
+        if (trh)
+                trh--;
+
+        pause = timing.cycle - timing.active - timing.setup - trh;
+        if (pause)
+                pause--;
+
+        octeon_cf_set_boot_reg_cfg(cs);
+        if (ocd->dma_engine >= 0)
+                /* True IDE mode, program both chip selects.  */
+                octeon_cf_set_boot_reg_cfg(cs + 1);
+
+
+        use_iordy = ata_pio_need_iordy(dev);
+
+        reg_tim.u64 = cvmx_read_csr(CVMX_MIO_BOOT_REG_TIMX(cs));
+        /* Disable page mode */
+        reg_tim.s.pagem = 0;
+        /* Enable dynamic timing */
+        reg_tim.s.waitm = use_iordy;
+        /* Pages are disabled */
+        reg_tim.s.pages = 0;
+        /* We don't use multiplexed address mode */
+        reg_tim.s.ale = 0;
+        /* Not used */
+        reg_tim.s.page = 0;
+        /* Time after IORDY to coninue to assert the data */
+        reg_tim.s.wait = 0;
+        /* Time to wait to complete the cycle. */
+        reg_tim.s.pause = pause;
+        /* How long to hold after a write to de-assert CE. */
+        reg_tim.s.wr_hld = trh;
+        /* How long to wait after a read to de-assert CE. */
+        reg_tim.s.rd_hld = trh;
+        /* How long write enable is asserted */
+        reg_tim.s.we = t2;
+        /* How long read enable is asserted */
+        reg_tim.s.oe = t2;
+        /* Time after CE that read/write starts */
+        reg_tim.s.ce = ns_to_tim_reg(2, 5);
+        /* Time before CE that address is valid */
+        reg_tim.s.adr = 0;
+
+        /* Program the bootbus region timing for the data port chip select. */
+        cvmx_write_csr(CVMX_MIO_BOOT_REG_TIMX(cs), reg_tim.u64);
+        if (ocd->dma_engine >= 0)
+                /* True IDE mode, program both chip selects.  */
+                cvmx_write_csr(CVMX_MIO_BOOT_REG_TIMX(cs + 1), reg_tim.u64);
+}
+
+static void octeon_cf_set_dmamode(struct ata_port *ap, struct ata_device *dev)
+{
+        struct octeon_cf_data *ocd = dev->link->ap->dev->platform_data;
+        union cvmx_mio_boot_dma_timx dma_tim;
+        unsigned int oe_a;
+        unsigned int oe_n;
+        unsigned int dma_ackh;
+        unsigned int dma_arq;
+        unsigned int pause;
+        unsigned int T0, Tkr, Td;
+        unsigned int tim_mult;
+
+        const struct ata_timing *timing;
+
+        timing = ata_timing_find_mode(dev->dma_mode);
+        T0      = timing->cycle;
+        Td      = timing->active;
+        Tkr     = timing->recover;
+        dma_ackh = timing->dmack_hold;
+
+        dma_tim.u64 = 0;
+        /* dma_tim.s.tim_mult = 0 --> 4x */
+        tim_mult = 4;
+
+        /* not spec'ed, value in eclocks, not affected by tim_mult */
+        dma_arq = 8;
+        pause = 25 - dma_arq * 1000 /
+                (octeon_get_clock_rate() / 1000000); /* Tz */
+
+        oe_a = Td;
+        /* Tkr from cf spec, lengthened to meet T0 */
+        oe_n = max(T0 - oe_a, Tkr);
+
+        dma_tim.s.dmack_pi = 1;
+
+        dma_tim.s.oe_n = ns_to_tim_reg(tim_mult, oe_n);
+        dma_tim.s.oe_a = ns_to_tim_reg(tim_mult, oe_a);
+
+        /*
+         * This is tI, C.F. spec. says 0, but Sony CF card requires
+         * more, we use 20 nS.
+         */
+        dma_tim.s.dmack_s = ns_to_tim_reg(tim_mult, 20);;
+        dma_tim.s.dmack_h = ns_to_tim_reg(tim_mult, dma_ackh);
+
+        dma_tim.s.dmarq = dma_arq;
+        dma_tim.s.pause = ns_to_tim_reg(tim_mult, pause);
+
+        dma_tim.s.rd_dly = 0;   /* Sample right on edge */
+
+        /*  writes only */
+        dma_tim.s.we_n = ns_to_tim_reg(tim_mult, oe_n);
+        dma_tim.s.we_a = ns_to_tim_reg(tim_mult, oe_a);
+
+        pr_debug("ns to ticks (mult %d) of %d is: %d\n", tim_mult, 60,
+                 ns_to_tim_reg(tim_mult, 60));
+        pr_debug("oe_n: %d, oe_a: %d, dmack_s: %d, dmack_h: "
+                 "%d, dmarq: %d, pause: %d\n",
+                 dma_tim.s.oe_n, dma_tim.s.oe_a, dma_tim.s.dmack_s,
+                 dma_tim.s.dmack_h, dma_tim.s.dmarq, dma_tim.s.pause);
+
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_TIMX(ocd->dma_engine),
+                       dma_tim.u64);
+
+}
+
+/**
+ * Handle an 8 bit I/O request.
+ *
+ * @dev:        Device to access
+ * @buffer:     Data buffer
+ * @buflen:     Length of the buffer.
+ * @rw:         True to write.
+ */
+static unsigned int octeon_cf_data_xfer8(struct ata_device *dev,
+                                         unsigned char *buffer,
+                                         unsigned int buflen,
+                                         int rw)
+{
+        struct ata_port *ap             = dev->link->ap;
+        void __iomem *data_addr         = ap->ioaddr.data_addr;
+        unsigned long words;
+        int count;
+
+        words = buflen;
+        if (rw) {
+                count = 16;
+                while (words--) {
+                        iowrite8(*buffer, data_addr);
+                        buffer++;
+                        /*
+                         * Every 16 writes do a read so the bootbus
+                         * FIFO doesn't fill up.
+                         */
+                        if (--count == 0) {
+                                ioread8(ap->ioaddr.altstatus_addr);
+                                count = 16;
+                        }
+                }
+        } else {
+                ioread8_rep(data_addr, buffer, words);
+        }
+        return buflen;
+}
+
+/**
+ * Handle a 16 bit I/O request.
+ *
+ * @dev:        Device to access
+ * @buffer:     Data buffer
+ * @buflen:     Length of the buffer.
+ * @rw:         True to write.
+ */
+static unsigned int octeon_cf_data_xfer16(struct ata_device *dev,
+                                          unsigned char *buffer,
+                                          unsigned int buflen,
+                                          int rw)
+{
+        struct ata_port *ap             = dev->link->ap;
+        void __iomem *data_addr         = ap->ioaddr.data_addr;
+        unsigned long words;
+        int count;
+
+        words = buflen / 2;
+        if (rw) {
+                count = 16;
+                while (words--) {
+                        iowrite16(*(uint16_t *)buffer, data_addr);
+                        buffer += sizeof(uint16_t);
+                        /*
+                         * Every 16 writes do a read so the bootbus
+                         * FIFO doesn't fill up.
+                         */
+                        if (--count == 0) {
+                                ioread8(ap->ioaddr.altstatus_addr);
+                                count = 16;
+                        }
+                }
+        } else {
+                while (words--) {
+                        *(uint16_t *)buffer = ioread16(data_addr);
+                        buffer += sizeof(uint16_t);
+                }
+        }
+        /* Transfer trailing 1 byte, if any. */
+        if (unlikely(buflen & 0x01)) {
+                __le16 align_buf[1] = { 0 };
+
+                if (rw == READ) {
+                        align_buf[0] = cpu_to_le16(ioread16(data_addr));
+                        memcpy(buffer, align_buf, 1);
+                } else {
+                        memcpy(align_buf, buffer, 1);
+                        iowrite16(le16_to_cpu(align_buf[0]), data_addr);
+                }
+                words++;
+        }
+        return buflen;
+}
+
+/**
+ * Read the taskfile for 16bit non-True IDE only.
+ */
+static void octeon_cf_tf_read16(struct ata_port *ap, struct ata_taskfile *tf)
+{
+        u16 blob;
+        /* The base of the registers is at ioaddr.data_addr. */
+        void __iomem *base = ap->ioaddr.data_addr;
+
+        blob = __raw_readw(base + 0xc);
+        tf->feature = blob >> 8;
+
+        blob = __raw_readw(base + 2);
+        tf->nsect = blob & 0xff;
+        tf->lbal = blob >> 8;
+
+        blob = __raw_readw(base + 4);
+        tf->lbam = blob & 0xff;
+        tf->lbah = blob >> 8;
+
+        blob = __raw_readw(base + 6);
+        tf->device = blob & 0xff;
+        tf->command = blob >> 8;
+
+        if (tf->flags & ATA_TFLAG_LBA48) {
+                if (likely(ap->ioaddr.ctl_addr)) {
+                        iowrite8(tf->ctl | ATA_HOB, ap->ioaddr.ctl_addr);
+
+                        blob = __raw_readw(base + 0xc);
+                        tf->hob_feature = blob >> 8;
+
+                        blob = __raw_readw(base + 2);
+                        tf->hob_nsect = blob & 0xff;
+                        tf->hob_lbal = blob >> 8;
+
+                        blob = __raw_readw(base + 4);
+                        tf->hob_lbam = blob & 0xff;
+                        tf->hob_lbah = blob >> 8;
+
+                        iowrite8(tf->ctl, ap->ioaddr.ctl_addr);
+                        ap->last_ctl = tf->ctl;
+                } else {
+                        WARN_ON(1);
+                }
+        }
+}
+
+static u8 octeon_cf_check_status16(struct ata_port *ap)
+{
+        u16 blob;
+        void __iomem *base = ap->ioaddr.data_addr;
+
+        blob = __raw_readw(base + 6);
+        return blob >> 8;
+}
+
+static int octeon_cf_softreset16(struct ata_link *link, unsigned int *classes,
+                                 unsigned long deadline)
+{
+        struct ata_port *ap = link->ap;
+        void __iomem *base = ap->ioaddr.data_addr;
+        int rc;
+        u8 err;
+
+        DPRINTK("about to softreset\n");
+        __raw_writew(ap->ctl, base + 0xe);
+        udelay(20);
+        __raw_writew(ap->ctl | ATA_SRST, base + 0xe);
+        udelay(20);
+        __raw_writew(ap->ctl, base + 0xe);
+
+        rc = ata_sff_wait_after_reset(link, 1, deadline);
+        if (rc) {
+                ata_link_printk(link, KERN_ERR, "SRST failed (errno=%d)\n", rc);
+                return rc;
+        }
+
+        /* determine by signature whether we have ATA or ATAPI devices */
+        classes[0] = ata_sff_dev_classify(&link->device[0], 1, &err);
+        DPRINTK("EXIT, classes[0]=%u [1]=%u\n", classes[0], classes[1]);
+        return 0;
+}
+
+/**
+ * Load the taskfile for 16bit non-True IDE only.  The device_addr is
+ * not loaded, we do this as part of octeon_cf_exec_command16.
+ */
+static void octeon_cf_tf_load16(struct ata_port *ap,
+                                const struct ata_taskfile *tf)
+{
+        unsigned int is_addr = tf->flags & ATA_TFLAG_ISADDR;
+        /* The base of the registers is at ioaddr.data_addr. */
+        void __iomem *base = ap->ioaddr.data_addr;
+
+        if (tf->ctl != ap->last_ctl) {
+                iowrite8(tf->ctl, ap->ioaddr.ctl_addr);
+                ap->last_ctl = tf->ctl;
+                ata_wait_idle(ap);
+        }
+        if (is_addr && (tf->flags & ATA_TFLAG_LBA48)) {
+                __raw_writew(tf->hob_feature << 8, base + 0xc);
+                __raw_writew(tf->hob_nsect | tf->hob_lbal << 8, base + 2);
+                __raw_writew(tf->hob_lbam | tf->hob_lbah << 8, base + 4);
+                VPRINTK("hob: feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
+                        tf->hob_feature,
+                        tf->hob_nsect,
+                        tf->hob_lbal,
+                        tf->hob_lbam,
+                        tf->hob_lbah);
+        }
+        if (is_addr) {
+                __raw_writew(tf->feature << 8, base + 0xc);
+                __raw_writew(tf->nsect | tf->lbal << 8, base + 2);
+                __raw_writew(tf->lbam | tf->lbah << 8, base + 4);
+                VPRINTK("feat 0x%X nsect 0x%X, lba 0x%X 0x%X 0x%X\n",
+                        tf->feature,
+                        tf->nsect,
+                        tf->lbal,
+                        tf->lbam,
+                        tf->lbah);
+        }
+        ata_wait_idle(ap);
+}
+
+
+static void octeon_cf_dev_select(struct ata_port *ap, unsigned int device)
+{
+/*  There is only one device, do nothing. */
+        return;
+}
+
+/*
+ * Issue ATA command to host controller.  The device_addr is also sent
+ * as it must be written in a combined write with the command.
+ */
+static void octeon_cf_exec_command16(struct ata_port *ap,
+                                const struct ata_taskfile *tf)
+{
+        /* The base of the registers is at ioaddr.data_addr. */
+        void __iomem *base = ap->ioaddr.data_addr;
+        u16 blob;
+
+        if (tf->flags & ATA_TFLAG_DEVICE) {
+                VPRINTK("device 0x%X\n", tf->device);
+                blob = tf->device;
+        } else {
+                blob = 0;
+        }
+
+        DPRINTK("ata%u: cmd 0x%X\n", ap->print_id, tf->command);
+        blob |= (tf->command << 8);
+        __raw_writew(blob, base + 6);
+
+
+        ata_wait_idle(ap);
+}
+
+static u8 octeon_cf_irq_on(struct ata_port *ap)
+{
+        return 0;
+}
+
+static void octeon_cf_irq_clear(struct ata_port *ap)
+{
+        return;
+}
+
+static void octeon_cf_dma_setup(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+        struct octeon_cf_port *cf_port;
+
+        cf_port = (struct octeon_cf_port *)ap->private_data;
+        DPRINTK("ENTER\n");
+        /* issue r/w command */
+        qc->cursg = qc->sg;
+        cf_port->dma_finished = 0;
+        ap->ops->sff_exec_command(ap, &qc->tf);
+        DPRINTK("EXIT\n");
+}
+
+/**
+ * Start a DMA transfer that was already setup
+ *
+ * @qc:     Information about the DMA
+ */
+static void octeon_cf_dma_start(struct ata_queued_cmd *qc)
+{
+        struct octeon_cf_data *ocd = qc->ap->dev->platform_data;
+        union cvmx_mio_boot_dma_cfgx mio_boot_dma_cfg;
+        union cvmx_mio_boot_dma_intx mio_boot_dma_int;
+        struct scatterlist *sg;
+
+        VPRINTK("%d scatterlists\n", qc->n_elem);
+
+        /* Get the scatter list entry we need to DMA into */
+        sg = qc->cursg;
+        BUG_ON(!sg);
+
+        /*
+         * Clear the DMA complete status.
+         */
+        mio_boot_dma_int.u64 = 0;
+        mio_boot_dma_int.s.done = 1;
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_INTX(ocd->dma_engine),
+                       mio_boot_dma_int.u64);
+
+        /* Enable the interrupt.  */
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_INT_ENX(ocd->dma_engine),
+                       mio_boot_dma_int.u64);
+
+        /* Set the direction of the DMA */
+        mio_boot_dma_cfg.u64 = 0;
+        mio_boot_dma_cfg.s.en = 1;
+        mio_boot_dma_cfg.s.rw = ((qc->tf.flags & ATA_TFLAG_WRITE) != 0);
+
+        /*
+         * Don't stop the DMA if the device deasserts DMARQ. Many
+         * compact flashes deassert DMARQ for a short time between
+         * sectors. Instead of stopping and restarting the DMA, we'll
+         * let the hardware do it. If the DMA is really stopped early
+         * due to an error condition, a later timeout will force us to
+         * stop.
+         */
+        mio_boot_dma_cfg.s.clr = 0;
+
+        /* Size is specified in 16bit words and minus one notation */
+        mio_boot_dma_cfg.s.size = sg_dma_len(sg) / 2 - 1;
+
+        /* We need to swap the high and low bytes of every 16 bits */
+        mio_boot_dma_cfg.s.swap8 = 1;
+
+        mio_boot_dma_cfg.s.adr = sg_dma_address(sg);
+
+        VPRINTK("%s %d bytes address=%p\n",
+                (mio_boot_dma_cfg.s.rw) ? "write" : "read", sg->length,
+                (void *)(unsigned long)mio_boot_dma_cfg.s.adr);
+
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_CFGX(ocd->dma_engine),
+                       mio_boot_dma_cfg.u64);
+}
+
+/**
+ *
+ *      LOCKING:
+ *      spin_lock_irqsave(host lock)
+ *
+ */
+static unsigned int octeon_cf_dma_finished(struct ata_port *ap,
+                                        struct ata_queued_cmd *qc)
+{
+        struct ata_eh_info *ehi = &ap->link.eh_info;
+        struct octeon_cf_data *ocd = ap->dev->platform_data;
+        union cvmx_mio_boot_dma_cfgx dma_cfg;
+        union cvmx_mio_boot_dma_intx dma_int;
+        struct octeon_cf_port *cf_port;
+        u8 status;
+
+        VPRINTK("ata%u: protocol %d task_state %d\n",
+                ap->print_id, qc->tf.protocol, ap->hsm_task_state);
+
+
+        if (ap->hsm_task_state != HSM_ST_LAST)
+                return 0;
+
+        cf_port = (struct octeon_cf_port *)ap->private_data;
+
+        dma_cfg.u64 = cvmx_read_csr(CVMX_MIO_BOOT_DMA_CFGX(ocd->dma_engine));
+        if (dma_cfg.s.size != 0xfffff) {
+                /* Error, the transfer was not complete.  */
+                qc->err_mask |= AC_ERR_HOST_BUS;
+                ap->hsm_task_state = HSM_ST_ERR;
+        }
+
+        /* Stop and clear the dma engine.  */
+        dma_cfg.u64 = 0;
+        dma_cfg.s.size = -1;
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_CFGX(ocd->dma_engine), dma_cfg.u64);
+
+        /* Disable the interrupt.  */
+        dma_int.u64 = 0;
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_INT_ENX(ocd->dma_engine), dma_int.u64);
+
+        /* Clear the DMA complete status */
+        dma_int.s.done = 1;
+        cvmx_write_csr(CVMX_MIO_BOOT_DMA_INTX(ocd->dma_engine), dma_int.u64);
+
+        status = ap->ops->sff_check_status(ap);
+
+        ata_sff_hsm_move(ap, qc, status, 0);
+
+        if (unlikely(qc->err_mask) && (qc->tf.protocol == ATA_PROT_DMA))
+                ata_ehi_push_desc(ehi, "DMA stat 0x%x", status);
+
+        return 1;
+}
+
+/*
+ * Check if any queued commands have more DMAs, if so start the next
+ * transfer, else do end of transfer handling.
+ */
+static irqreturn_t octeon_cf_interrupt(int irq, void *dev_instance)
+{
+        struct ata_host *host = dev_instance;
+        struct octeon_cf_port *cf_port;
+        int i;
+        unsigned int handled = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        DPRINTK("ENTER\n");
+        for (i = 0; i < host->n_ports; i++) {
+                u8 status;
+                struct ata_port *ap;
+                struct ata_queued_cmd *qc;
+                union cvmx_mio_boot_dma_intx dma_int;
+                union cvmx_mio_boot_dma_cfgx dma_cfg;
+                struct octeon_cf_data *ocd;
+
+                ap = host->ports[i];
+                ocd = ap->dev->platform_data;
+                if (!ap || (ap->flags & ATA_FLAG_DISABLED))
+                        continue;
+
+                ocd = ap->dev->platform_data;
+                cf_port = (struct octeon_cf_port *)ap->private_data;
+                dma_int.u64 =
+                        cvmx_read_csr(CVMX_MIO_BOOT_DMA_INTX(ocd->dma_engine));
+                dma_cfg.u64 =
+                        cvmx_read_csr(CVMX_MIO_BOOT_DMA_CFGX(ocd->dma_engine));
+
+                qc = ata_qc_from_tag(ap, ap->link.active_tag);
+
+                if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
+                    (qc->flags & ATA_QCFLAG_ACTIVE)) {
+                        if (dma_int.s.done && !dma_cfg.s.en) {
+                                if (!sg_is_last(qc->cursg)) {
+                                        qc->cursg = sg_next(qc->cursg);
+                                        handled = 1;
+                                        octeon_cf_dma_start(qc);
+                                        continue;
+                                } else {
+                                        cf_port->dma_finished = 1;
+                                }
+                        }
+                        if (!cf_port->dma_finished)
+                                continue;
+                        status = ioread8(ap->ioaddr.altstatus_addr);
+                        if (status & (ATA_BUSY | ATA_DRQ)) {
+                                /*
+                                 * We are busy, try to handle it
+                                 * later.  This is the DMA finished
+                                 * interrupt, and it could take a
+                                 * little while for the card to be
+                                 * ready for more commands.
+                                 */
+                                /* Clear DMA irq. */
+                                dma_int.u64 = 0;
+                                dma_int.s.done = 1;
+                                cvmx_write_csr(CVMX_MIO_BOOT_DMA_INTX(ocd->dma_engine),
+                                               dma_int.u64);
+
+                                queue_delayed_work(cf_port->wq,
+                                                   &cf_port->delayed_finish, 1);
+                                handled = 1;
+                        } else {
+                                handled |= octeon_cf_dma_finished(ap, qc);
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&host->lock, flags);
+        DPRINTK("EXIT\n");
+        return IRQ_RETVAL(handled);
+}
+
+static void octeon_cf_delayed_finish(struct work_struct *work)
+{
+        struct octeon_cf_port *cf_port = container_of(work,
+                                                      struct octeon_cf_port,
+                                                      delayed_finish.work);
+        struct ata_port *ap = cf_port->ap;
+        struct ata_host *host = ap->host;
+        struct ata_queued_cmd *qc;
+        unsigned long flags;
+        u8 status;
+
+        spin_lock_irqsave(&host->lock, flags);
+
+        /*
+         * If the port is not waiting for completion, it must have
+         * handled it previously.  The hsm_task_state is
+         * protected by host->lock.
+         */
+        if (ap->hsm_task_state != HSM_ST_LAST || !cf_port->dma_finished)
+                goto out;
+
+        status = ioread8(ap->ioaddr.altstatus_addr);
+        if (status & (ATA_BUSY | ATA_DRQ)) {
+                /* Still busy, try again. */
+                queue_delayed_work(cf_port->wq,
+                                   &cf_port->delayed_finish, 1);
+                goto out;
+        }
+        qc = ata_qc_from_tag(ap, ap->link.active_tag);
+        if (qc && (!(qc->tf.flags & ATA_TFLAG_POLLING)) &&
+            (qc->flags & ATA_QCFLAG_ACTIVE))
+                octeon_cf_dma_finished(ap, qc);
+out:
+        spin_unlock_irqrestore(&host->lock, flags);
+}
+
+static void octeon_cf_dev_config(struct ata_device *dev)
+{
+        /*
+         * A maximum of 2^20 - 1 16 bit transfers are possible with
+         * the bootbus DMA.  So we need to throttle max_sectors to
+         * (2^12 - 1 == 4095) to assure that this can never happen.
+         */
+        dev->max_sectors = min(dev->max_sectors, 4095U);
+}
+
+/*
+ * Trap if driver tries to do standard bmdma commands.  They are not
+ * supported.
+ */
+static void unreachable_qc(struct ata_queued_cmd *qc)
+{
+        BUG();
+}
+
+static u8 unreachable_port(struct ata_port *ap)
+{
+        BUG();
+}
+
+/*
+ * We don't do ATAPI DMA so return 0.
+ */
+static int octeon_cf_check_atapi_dma(struct ata_queued_cmd *qc)
+{
+        return 0;
+}
+
+static unsigned int octeon_cf_qc_issue(struct ata_queued_cmd *qc)
+{
+        struct ata_port *ap = qc->ap;
+
+        switch (qc->tf.protocol) {
+        case ATA_PROT_DMA:
+                WARN_ON(qc->tf.flags & ATA_TFLAG_POLLING);
+
+                ap->ops->sff_tf_load(ap, &qc->tf);  /* load tf registers */
+                octeon_cf_dma_setup(qc);            /* set up dma */
+                octeon_cf_dma_start(qc);            /* initiate dma */
+                ap->hsm_task_state = HSM_ST_LAST;
+                break;
+
+        case ATAPI_PROT_DMA:
+                dev_err(ap->dev, "Error, ATAPI not supported\n");
+                BUG();
+
+        default:
+                return ata_sff_qc_issue(qc);
+        }
+
+        return 0;
+}
+
+static struct ata_port_operations octeon_cf_ops = {
+        .inherits               = &ata_sff_port_ops,
+        .check_atapi_dma        = octeon_cf_check_atapi_dma,
+        .qc_prep                = ata_noop_qc_prep,
+        .qc_issue               = octeon_cf_qc_issue,
+        .sff_dev_select         = octeon_cf_dev_select,
+        .sff_irq_on             = octeon_cf_irq_on,
+        .sff_irq_clear          = octeon_cf_irq_clear,
+        .bmdma_setup            = unreachable_qc,
+        .bmdma_start            = unreachable_qc,
+        .bmdma_stop             = unreachable_qc,
+        .bmdma_status           = unreachable_port,
+        .cable_detect           = ata_cable_40wire,
+        .set_piomode            = octeon_cf_set_piomode,
+        .set_dmamode            = octeon_cf_set_dmamode,
+        .dev_config             = octeon_cf_dev_config,
+};
+
+static int __devinit octeon_cf_probe(struct platform_device *pdev)
+{
+        struct resource *res_cs0, *res_cs1;
+
+        void __iomem *cs0;
+        void __iomem *cs1 = NULL;
+        struct ata_host *host;
+        struct ata_port *ap;
+        struct octeon_cf_data *ocd;
+        int irq = 0;
+        irq_handler_t irq_handler = NULL;
+        void __iomem *base;
+        struct octeon_cf_port *cf_port;
+
+        res_cs0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+
+        if (!res_cs0)
+                return -EINVAL;
+
+        ocd = pdev->dev.platform_data;
+
+        cs0 = devm_ioremap_nocache(&pdev->dev, res_cs0->start,
+                                   res_cs0->end - res_cs0->start + 1);
+
+        if (!cs0)
+                return -ENOMEM;
+
+        /* Determine from availability of DMA if True IDE mode or not */
+        if (ocd->dma_engine >= 0) {
+                res_cs1 = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+                if (!res_cs1)
+                        return -EINVAL;
+
+                cs1 = devm_ioremap_nocache(&pdev->dev, res_cs1->start,
+                                           res_cs0->end - res_cs1->start + 1);
+
+                if (!cs1)
+                        return -ENOMEM;
+        }
+
+        cf_port = kzalloc(sizeof(*cf_port), GFP_KERNEL);
+        if (!cf_port)
+                return -ENOMEM;
+
+        /* allocate host */
+        host = ata_host_alloc(&pdev->dev, 1);
+        if (!host)
+                goto free_cf_port;
+
+        ap = host->ports[0];
+        ap->private_data = cf_port;
+        cf_port->ap = ap;
+        ap->ops = &octeon_cf_ops;
+        ap->pio_mask = 0x7f; /* Support PIO 0-6 */
+        ap->flags |= ATA_FLAG_MMIO | ATA_FLAG_NO_LEGACY
+                  | ATA_FLAG_NO_ATAPI | ATA_FLAG_PIO_POLLING;
+
+        base = cs0 + ocd->base_region_bias;
+        if (!ocd->is16bit) {
+                ap->ioaddr.cmd_addr     = base;
+                ata_sff_std_ports(&ap->ioaddr);
+
+                ap->ioaddr.altstatus_addr = base + 0xe;
+                ap->ioaddr.ctl_addr     = base + 0xe;
+                octeon_cf_ops.sff_data_xfer = octeon_cf_data_xfer8;
+        } else if (cs1) {
+                /* Presence of cs1 indicates True IDE mode.  */
+                ap->ioaddr.cmd_addr     = base + (ATA_REG_CMD << 1) + 1;
+                ap->ioaddr.data_addr    = base + (ATA_REG_DATA << 1);
+                ap->ioaddr.error_addr   = base + (ATA_REG_ERR << 1) + 1;
+                ap->ioaddr.feature_addr = base + (ATA_REG_FEATURE << 1) + 1;
+                ap->ioaddr.nsect_addr   = base + (ATA_REG_NSECT << 1) + 1;
+                ap->ioaddr.lbal_addr    = base + (ATA_REG_LBAL << 1) + 1;
+                ap->ioaddr.lbam_addr    = base + (ATA_REG_LBAM << 1) + 1;
+                ap->ioaddr.lbah_addr    = base + (ATA_REG_LBAH << 1) + 1;
+                ap->ioaddr.device_addr  = base + (ATA_REG_DEVICE << 1) + 1;
+                ap->ioaddr.status_addr  = base + (ATA_REG_STATUS << 1) + 1;
+                ap->ioaddr.command_addr = base + (ATA_REG_CMD << 1) + 1;
+                ap->ioaddr.altstatus_addr = cs1 + (6 << 1) + 1;
+                ap->ioaddr.ctl_addr     = cs1 + (6 << 1) + 1;
+                octeon_cf_ops.sff_data_xfer = octeon_cf_data_xfer16;
+
+                ap->mwdma_mask  = 0x1f; /* Support MWDMA 0-4 */
+                irq = platform_get_irq(pdev, 0);
+                irq_handler = octeon_cf_interrupt;
+
+                /* True IDE mode needs delayed work to poll for not-busy.  */
+                cf_port->wq = create_singlethread_workqueue(DRV_NAME);
+                if (!cf_port->wq)
+                        goto free_cf_port;
+                INIT_DELAYED_WORK(&cf_port->delayed_finish,
+                                  octeon_cf_delayed_finish);
+
+        } else {
+                /* 16 bit but not True IDE */
+                octeon_cf_ops.sff_data_xfer     = octeon_cf_data_xfer16;
+                octeon_cf_ops.softreset         = octeon_cf_softreset16;
+                octeon_cf_ops.sff_check_status  = octeon_cf_check_status16;
+                octeon_cf_ops.sff_tf_read       = octeon_cf_tf_read16;
+                octeon_cf_ops.sff_tf_load       = octeon_cf_tf_load16;
+                octeon_cf_ops.sff_exec_command  = octeon_cf_exec_command16;
+
+                ap->ioaddr.data_addr    = base + ATA_REG_DATA;
+                ap->ioaddr.nsect_addr   = base + ATA_REG_NSECT;
+                ap->ioaddr.lbal_addr    = base + ATA_REG_LBAL;
+                ap->ioaddr.ctl_addr     = base + 0xe;
+                ap->ioaddr.altstatus_addr = base + 0xe;
+        }
+
+        ata_port_desc(ap, "cmd %p ctl %p", base, ap->ioaddr.ctl_addr);
+
+
+        dev_info(&pdev->dev, "version " DRV_VERSION" %d bit%s.\n",
+                 (ocd->is16bit) ? 16 : 8,
+                 (cs1) ? ", True IDE" : "");
+
+
+        return ata_host_activate(host, irq, irq_handler, 0, &octeon_cf_sht);
+
+free_cf_port:
+        kfree(cf_port);
+        return -ENOMEM;
+}
+
+static struct platform_driver octeon_cf_driver = {
+        .probe          = octeon_cf_probe,
+        .driver         = {
+                .name   = DRV_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init octeon_cf_init(void)
+{
+        return platform_driver_register(&octeon_cf_driver);
+}
+
+
+MODULE_AUTHOR("David Daney <ddaney@caviumnetworks.com>");
+MODULE_DESCRIPTION("low-level driver for Cavium OCTEON Compact Flash PATA");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
+MODULE_ALIAS("platform:" DRV_NAME);
+
+module_init(octeon_cf_init);
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 1a56db92ff7a..55bc88c1707b 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -1288,7 +1288,7 @@ static const struct ata_port_info sata_fsl_port_info[] = {
 static int sata_fsl_probe(struct of_device *ofdev,
                         const struct of_device_id *match)
 {
-        int retval = 0;
+        int retval = -ENXIO;
         void __iomem *hcr_base = NULL;
         void __iomem *ssr_base = NULL;
         void __iomem *csr_base = NULL;
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index c18935f0bda2..5c62da9cd491 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -92,6 +92,8 @@ static const struct pci_device_id svia_pci_tbl[] = {
         { PCI_VDEVICE(VIA, 0x5372), vt6420 },
         { PCI_VDEVICE(VIA, 0x7372), vt6420 },
         { PCI_VDEVICE(VIA, 0x5287), vt8251 }, /* 2 sata chnls (Master/Slave) */
+        { PCI_VDEVICE(VIA, 0x9000), vt8251 },
+        { PCI_VDEVICE(VIA, 0x9040), vt8251 },
 
         { }     /* terminate list */
 };
diff --git a/drivers/base/core.c b/drivers/base/core.c
index 8079afca4972..55e530942ab0 100644
--- a/drivers/base/core.c
+++ b/drivers/base/core.c
@@ -777,10 +777,16 @@ static void device_remove_class_symlinks(struct device *dev)
 int dev_set_name(struct device *dev, const char *fmt, ...)
 {
         va_list vargs;
+        char *s;
 
         va_start(vargs, fmt);
         vsnprintf(dev->bus_id, sizeof(dev->bus_id), fmt, vargs);
         va_end(vargs);
+
+        /* ewww... some of these buggers have / in the name... */
+        while ((s = strchr(dev->bus_id, '/')))
+                *s = '!';
+
         return 0;
 }
 EXPORT_SYMBOL_GPL(dev_set_name);
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 7bcc1d8bc967..34f80fa6fed1 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -406,6 +406,7 @@ static int nbd_do_it(struct nbd_device *lo)
         ret = sysfs_create_file(&disk_to_dev(lo->disk)->kobj, &pid_attr.attr);
         if (ret) {
                 printk(KERN_ERR "nbd: sysfs_create_file failed!");
+                lo->pid = 0;
                 return ret;
         }
 
@@ -413,6 +414,7 @@ static int nbd_do_it(struct nbd_device *lo)
                 nbd_end_request(req);
 
         sysfs_remove_file(&disk_to_dev(lo->disk)->kobj, &pid_attr.attr);
+        lo->pid = 0;
         return 0;
 }
 
@@ -648,6 +650,8 @@ static int nbd_ioctl(struct block_device *bdev, fmode_t mode,
                 set_capacity(lo->disk, lo->bytesize >> 9);
                 return 0;
         case NBD_DO_IT:
+                if (lo->pid)
+                        return -EBUSY;
                 if (!lo->file)
                         return -EINVAL;
                 thread = kthread_create(nbd_thread, lo, lo->disk->disk_name);
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 936466f62afd..bccc42bb9212 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -141,7 +141,7 @@ static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
 
         start_sector = req->sector * priv->blocking_factor;
         sectors = req->nr_sectors * priv->blocking_factor;
-        dev_dbg(&dev->sbd.core, "%s:%u: %s %lu sectors starting at %lu\n",
+        dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                 __func__, __LINE__, op, sectors, start_sector);
 
         if (write) {
@@ -178,7 +178,7 @@ static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
                                               LV1_STORAGE_ATA_HDDOUT, 0, 0, 0,
                                               0, &dev->tag);
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
                         __func__, __LINE__, res);
                 end_request(req, 0);
                 return 0;
@@ -238,11 +238,11 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
 
         if (tag != dev->tag)
                 dev_err(&dev->sbd.core,
-                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        "%s:%u: tag mismatch, got %llx, expected %llx\n",
                         __func__, __LINE__, tag, dev->tag);
 
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
                         __func__, __LINE__, res, status);
                 return IRQ_HANDLED;
         }
@@ -269,7 +269,7 @@ static irqreturn_t ps3disk_interrupt(int irq, void *data)
                 op = read ? "read" : "write";
         }
         if (status) {
-                dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
                         __LINE__, op, status);
                 error = -EIO;
         } else {
@@ -297,7 +297,7 @@ static int ps3disk_sync_cache(struct ps3_storage_device *dev)
 
         res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0);
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%llx\n",
                         __func__, __LINE__, res);
                 return -EIO;
         }
@@ -388,7 +388,7 @@ static int ps3disk_identify(struct ps3_storage_device *dev)
                                    sizeof(ata_cmnd), ata_cmnd.buffer,
                                    ata_cmnd.arglen);
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%lx\n",
+                dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%llx\n",
                         __func__, __LINE__, res);
                 return -EIO;
         }
@@ -426,7 +426,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
 
         if (dev->blk_size < 512) {
                 dev_err(&dev->sbd.core,
-                        "%s:%u: cannot handle block size %lu\n", __func__,
+                        "%s:%u: cannot handle block size %llu\n", __func__,
                         __LINE__, dev->blk_size);
                 return -EINVAL;
         }
@@ -512,7 +512,7 @@ static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
                      dev->regions[dev->region_idx].size*priv->blocking_factor);
 
         dev_info(&dev->sbd.core,
-                 "%s is a %s (%lu MiB total, %lu MiB for OtherOS)\n",
+                 "%s is a %s (%llu MiB total, %lu MiB for OtherOS)\n",
                  gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
                  get_capacity(gendisk) >> 11);
 
diff --git a/drivers/char/hvc_console.c b/drivers/char/hvc_console.c
index 09676b4e5d89..94e7e3c8c05a 100644
--- a/drivers/char/hvc_console.c
+++ b/drivers/char/hvc_console.c
@@ -318,8 +318,6 @@ static int hvc_open(struct tty_struct *tty, struct file * filp)
         } /* else count == 0 */
 
         tty->driver_data = hp;
-        if (!hp->irq_requested)
-                tty->low_latency = 1; /* Makes flushes to ldisc synchronous. */
 
         hp->tty = tty;
 
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 79b6f461be75..afbe45676d71 100644
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -44,7 +44,7 @@ static ssize_t ps3flash_read_write_sectors(struct ps3_storage_device *dev,
         u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors,
                                              write);
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
                         __LINE__, write ? "write" : "read", res);
                 return -EIO;
         }
@@ -59,7 +59,7 @@ static ssize_t ps3flash_read_sectors(struct ps3_storage_device *dev,
 
         max_sectors = dev->bounce_size / dev->blk_size;
         if (sectors > max_sectors) {
-                dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %lu\n",
+                dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %llu\n",
                         __func__, __LINE__, max_sectors);
                 sectors = max_sectors;
         }
@@ -144,7 +144,7 @@ static ssize_t ps3flash_read(struct file *file, char __user *buf, size_t count,
                         goto fail;
                 }
 
-                n = min(remaining, sectors_read*dev->blk_size-offset);
+                n = min_t(u64, remaining, sectors_read*dev->blk_size-offset);
                 dev_dbg(&dev->sbd.core,
                         "%s:%u: copy %lu bytes from 0x%p to user 0x%p\n",
                         __func__, __LINE__, n, dev->bounce_buf+offset, buf);
@@ -225,7 +225,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                 if (end_read_sector >= start_read_sector) {
                         /* Merge head and tail */
                         dev_dbg(&dev->sbd.core,
-                                "Merged head and tail: %lu sectors at %lu\n",
+                                "Merged head and tail: %llu sectors at %llu\n",
                                 chunk_sectors, start_write_sector);
                         res = ps3flash_read_sectors(dev, start_write_sector,
                                                     chunk_sectors, 0);
@@ -235,7 +235,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                         if (head) {
                                 /* Read head */
                                 dev_dbg(&dev->sbd.core,
-                                        "head: %lu sectors at %lu\n", head,
+                                        "head: %llu sectors at %llu\n", head,
                                         start_write_sector);
                                 res = ps3flash_read_sectors(dev,
                                                             start_write_sector,
@@ -247,7 +247,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                             start_write_sector+chunk_sectors) {
                                 /* Read tail */
                                 dev_dbg(&dev->sbd.core,
-                                        "tail: %lu sectors at %lu\n", tail,
+                                        "tail: %llu sectors at %llu\n", tail,
                                         start_read_sector);
                                 sec_off = start_read_sector-start_write_sector;
                                 res = ps3flash_read_sectors(dev,
@@ -258,7 +258,7 @@ static ssize_t ps3flash_write(struct file *file, const char __user *buf,
                         }
                 }
 
-                n = min(remaining, dev->bounce_size-offset);
+                n = min_t(u64, remaining, dev->bounce_size-offset);
                 dev_dbg(&dev->sbd.core,
                         "%s:%u: copy %lu bytes from user 0x%p to 0x%p\n",
                         __func__, __LINE__, n, buf, dev->bounce_buf+offset);
@@ -299,11 +299,11 @@ static irqreturn_t ps3flash_interrupt(int irq, void *data)
 
         if (tag != dev->tag)
                 dev_err(&dev->sbd.core,
-                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        "%s:%u: tag mismatch, got %llx, expected %llx\n",
                         __func__, __LINE__, tag, dev->tag);
 
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
                         __func__, __LINE__, res, status);
         } else {
                 dev->lv1_status = status;
diff --git a/drivers/char/synclink_gt.c b/drivers/char/synclink_gt.c
index 53544e21f191..f329f459817c 100644
--- a/drivers/char/synclink_gt.c
+++ b/drivers/char/synclink_gt.c
@@ -1,6 +1,4 @@
 /*
- * $Id: synclink_gt.c,v 4.50 2007/07/25 19:29:25 paulkf Exp $
- *
  * Device driver for Microgate SyncLink GT serial adapters.
  *
  * written by Paul Fulghum for Microgate Corporation
@@ -91,7 +89,6 @@
  * module identification
  */
 static char *driver_name     = "SyncLink GT";
-static char *driver_version  = "$Revision: 4.50 $";
 static char *tty_driver_name = "synclink_gt";
 static char *tty_dev_prefix  = "ttySLG";
 MODULE_LICENSE("GPL");
@@ -1309,7 +1306,7 @@ static int read_proc(char *page, char **start, off_t off, int count,
         off_t   begin = 0;
         struct slgt_info *info;
 
-        len += sprintf(page, "synclink_gt driver:%s\n", driver_version);
+        len += sprintf(page, "synclink_gt driver\n");
 
         info = slgt_device_list;
         while( info ) {
@@ -2441,7 +2438,7 @@ static void program_hw(struct slgt_info *info)
         info->ri_chkcount = 0;
         info->dsr_chkcount = 0;
 
-        slgt_irq_on(info, IRQ_DCD | IRQ_CTS | IRQ_DSR);
+        slgt_irq_on(info, IRQ_DCD | IRQ_CTS | IRQ_DSR | IRQ_RI);
         get_signals(info);
 
         if (info->netcount ||
@@ -3576,7 +3573,7 @@ static void slgt_cleanup(void)
         struct slgt_info *info;
         struct slgt_info *tmp;
 
-        printk("unload %s %s\n", driver_name, driver_version);
+        printk(KERN_INFO "unload %s\n", driver_name);
 
         if (serial_driver) {
                 for (info=slgt_device_list ; info != NULL ; info=info->next_device)
@@ -3619,7 +3616,7 @@ static int __init slgt_init(void)
 {
         int rc;
 
-        printk("%s %s\n", driver_name, driver_version);
+        printk(KERN_INFO "%s\n", driver_name);
 
         serial_driver = alloc_tty_driver(MAX_DEVICES);
         if (!serial_driver) {
@@ -3650,9 +3647,8 @@ static int __init slgt_init(void)
                 goto error;
         }
 
-        printk("%s %s, tty major#%d\n",
-                driver_name, driver_version,
-                serial_driver->major);
+        printk(KERN_INFO "%s, tty major#%d\n",
+               driver_name, serial_driver->major);
 
         slgt_device_count = 0;
         if ((rc = pci_register_driver(&pci_driver)) < 0) {
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index d41b9f6f7903..33a9351c896d 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -473,6 +473,12 @@ void __handle_sysrq(int key, struct tty_struct *tty, int check_mask)
         unsigned long flags;
 
         spin_lock_irqsave(&sysrq_key_table_lock, flags);
+        /*
+         * Raise the apparent loglevel to maximum so that the sysrq header
+         * is shown to provide the user with positive feedback.  We do not
+         * simply emit this at KERN_EMERG as that would change message
+         * routing in the consumers of /proc/kmsg.
+         */
         orig_log_level = console_loglevel;
         console_loglevel = 7;
         printk(KERN_INFO "SysRq : ");
diff --git a/drivers/char/tty_ioctl.c b/drivers/char/tty_ioctl.c
index a408c8e487ec..6f4c7d0a53bf 100644
--- a/drivers/char/tty_ioctl.c
+++ b/drivers/char/tty_ioctl.c
@@ -1057,7 +1057,7 @@ int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
         if (retval)
                 return retval;
 
-        ld = tty_ldisc_ref(tty);
+        ld = tty_ldisc_ref_wait(tty);
         switch (arg) {
         case TCIFLUSH:
                 if (ld && ld->ops->flush_buffer)
diff --git a/drivers/dma/Kconfig b/drivers/dma/Kconfig
index e34b06420816..48ea59e79672 100644
--- a/drivers/dma/Kconfig
+++ b/drivers/dma/Kconfig
@@ -62,6 +62,25 @@ config MV_XOR
         ---help---
           Enable support for the Marvell XOR engine.
 
+config MX3_IPU
+        bool "MX3x Image Processing Unit support"
+        depends on ARCH_MX3
+        select DMA_ENGINE
+        default y
+        help
+          If you plan to use the Image Processing unit in the i.MX3x, say
+          Y here. If unsure, select Y.
+
+config MX3_IPU_IRQS
+        int "Number of dynamically mapped interrupts for IPU"
+        depends on MX3_IPU
+        range 2 137
+        default 4
+        help
+          Out of 137 interrupt sources on i.MX31 IPU only very few are used.
+          To avoid bloating the irq_desc[] array we allocate a sufficient
+          number of IRQ slots and map them dynamically to specific sources.
+
 config DMA_ENGINE
         bool
 
diff --git a/drivers/dma/Makefile b/drivers/dma/Makefile
index 14f59527d4f6..2e5dc96700d2 100644
--- a/drivers/dma/Makefile
+++ b/drivers/dma/Makefile
@@ -7,3 +7,4 @@ obj-$(CONFIG_INTEL_IOP_ADMA) += iop-adma.o
 obj-$(CONFIG_FSL_DMA) += fsldma.o
 obj-$(CONFIG_MV_XOR) += mv_xor.o
 obj-$(CONFIG_DW_DMAC) += dw_dmac.o
+obj-$(CONFIG_MX3_IPU) += ipu/
diff --git a/drivers/dma/dmaengine.c b/drivers/dma/dmaengine.c
index 403dbe781122..a58993011edb 100644
--- a/drivers/dma/dmaengine.c
+++ b/drivers/dma/dmaengine.c
@@ -329,9 +329,6 @@ struct dma_chan *dma_find_channel(enum dma_transaction_type tx_type)
         struct dma_chan *chan;
         int cpu;
 
-        WARN_ONCE(dmaengine_ref_count == 0,
-                  "client called %s without a reference", __func__);
-
         cpu = get_cpu();
         chan = per_cpu_ptr(channel_table[tx_type], cpu)->chan;
         put_cpu();
@@ -348,9 +345,6 @@ void dma_issue_pending_all(void)
         struct dma_device *device;
         struct dma_chan *chan;
 
-        WARN_ONCE(dmaengine_ref_count == 0,
-                  "client called %s without a reference", __func__);
-
         rcu_read_lock();
         list_for_each_entry_rcu(device, &dma_device_list, global_node) {
                 if (dma_has_cap(DMA_PRIVATE, device->cap_mask))
@@ -961,6 +955,8 @@ void dma_run_dependencies(struct dma_async_tx_descriptor *tx)
         if (!dep)
                 return;
 
+        /* we'll submit tx->next now, so clear the link */
+        tx->next = NULL;
         chan = dep->chan;
 
         /* keep submitting up until a channel switch is detected
diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
index 3603f1ea5b28..732fa1ec36ab 100644
--- a/drivers/dma/dmatest.c
+++ b/drivers/dma/dmatest.c
@@ -217,6 +217,10 @@ static int dmatest_func(void *data)
         chan = thread->chan;
 
         while (!kthread_should_stop()) {
+                struct dma_device *dev = chan->device;
+                struct dma_async_tx_descriptor *tx;
+                dma_addr_t dma_src, dma_dest;
+
                 total_tests++;
 
                 len = dmatest_random() % test_buf_size + 1;
@@ -226,10 +230,30 @@ static int dmatest_func(void *data)
                 dmatest_init_srcbuf(thread->srcbuf, src_off, len);
                 dmatest_init_dstbuf(thread->dstbuf, dst_off, len);
 
-                cookie = dma_async_memcpy_buf_to_buf(chan,
-                                thread->dstbuf + dst_off,
-                                thread->srcbuf + src_off,
-                                len);
+                dma_src = dma_map_single(dev->dev, thread->srcbuf + src_off,
+                                len, DMA_TO_DEVICE);
+                /* map with DMA_BIDIRECTIONAL to force writeback/invalidate */
+                dma_dest = dma_map_single(dev->dev, thread->dstbuf,
+                                test_buf_size, DMA_BIDIRECTIONAL);
+
+                tx = dev->device_prep_dma_memcpy(chan, dma_dest + dst_off,
+                                dma_src, len,
+                                DMA_CTRL_ACK | DMA_COMPL_SKIP_DEST_UNMAP);
+                if (!tx) {
+                        dma_unmap_single(dev->dev, dma_src, len, DMA_TO_DEVICE);
+                        dma_unmap_single(dev->dev, dma_dest,
+                                        test_buf_size, DMA_BIDIRECTIONAL);
+                        pr_warning("%s: #%u: prep error with src_off=0x%x "
+                                        "dst_off=0x%x len=0x%x\n",
+                                        thread_name, total_tests - 1,
+                                        src_off, dst_off, len);
+                        msleep(100);
+                        failed_tests++;
+                        continue;
+                }
+                tx->callback = NULL;
+                cookie = tx->tx_submit(tx);
+
                 if (dma_submit_error(cookie)) {
                         pr_warning("%s: #%u: submit error %d with src_off=0x%x "
                                         "dst_off=0x%x len=0x%x\n",
@@ -253,6 +277,9 @@ static int dmatest_func(void *data)
                         failed_tests++;
                         continue;
                 }
+                /* Unmap by myself (see DMA_COMPL_SKIP_DEST_UNMAP above) */
+                dma_unmap_single(dev->dev, dma_dest,
+                                test_buf_size, DMA_BIDIRECTIONAL);
 
                 error_count = 0;
 
diff --git a/drivers/dma/fsldma.c b/drivers/dma/fsldma.c
index ca70a21afc68..70126a606239 100644
--- a/drivers/dma/fsldma.c
+++ b/drivers/dma/fsldma.c
@@ -822,7 +822,7 @@ static int __devinit fsl_dma_chan_probe(struct fsl_dma_device *fdev,
          */
         WARN_ON(fdev->feature != new_fsl_chan->feature);
 
-        new_fsl_chan->dev = &new_fsl_chan->common.dev->device;
+        new_fsl_chan->dev = fdev->dev;
         new_fsl_chan->reg_base = ioremap(new_fsl_chan->reg.start,
                         new_fsl_chan->reg.end - new_fsl_chan->reg.start + 1);
 
@@ -875,7 +875,8 @@ static int __devinit fsl_dma_chan_probe(struct fsl_dma_device *fdev,
         }
 
         dev_info(fdev->dev, "#%d (%s), irq %d\n", new_fsl_chan->id,
-                                compatible, new_fsl_chan->irq);
+                 compatible,
+                 new_fsl_chan->irq != NO_IRQ ? new_fsl_chan->irq : fdev->irq);
 
         return 0;
 
@@ -890,7 +891,8 @@ err_no_reg:
 
 static void fsl_dma_chan_remove(struct fsl_dma_chan *fchan)
 {
-        free_irq(fchan->irq, fchan);
+        if (fchan->irq != NO_IRQ)
+                free_irq(fchan->irq, fchan);
         list_del(&fchan->common.device_node);
         iounmap(fchan->reg_base);
         kfree(fchan);
diff --git a/drivers/dma/ipu/Makefile b/drivers/dma/ipu/Makefile
new file mode 100644
index 000000000000..6704cf48326d
--- /dev/null
+++ b/drivers/dma/ipu/Makefile
@@ -0,0 +1 @@
+obj-y   += ipu_irq.o ipu_idmac.o
diff --git a/drivers/dma/ipu/ipu_idmac.c b/drivers/dma/ipu/ipu_idmac.c
new file mode 100644
index 000000000000..1f154d08e98f
--- /dev/null
+++ b/drivers/dma/ipu/ipu_idmac.c
@@ -0,0 +1,1740 @@
+/*
+ * Copyright (C) 2008
+ * Guennadi Liakhovetski, DENX Software Engineering, <lg@denx.de>
+ *
+ * Copyright (C) 2005-2007 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/init.h>
+#include <linux/platform_device.h>
+#include <linux/err.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/list.h>
+#include <linux/clk.h>
+#include <linux/vmalloc.h>
+#include <linux/string.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+
+#include <mach/ipu.h>
+
+#include "ipu_intern.h"
+
+#define FS_VF_IN_VALID  0x00000002
+#define FS_ENC_IN_VALID 0x00000001
+
+/*
+ * There can be only one, we could allocate it dynamically, but then we'd have
+ * to add an extra parameter to some functions, and use something as ugly as
+ *      struct ipu *ipu = to_ipu(to_idmac(ichan->dma_chan.device));
+ * in the ISR
+ */
+static struct ipu ipu_data;
+
+#define to_ipu(id) container_of(id, struct ipu, idmac)
+
+static u32 __idmac_read_icreg(struct ipu *ipu, unsigned long reg)
+{
+        return __raw_readl(ipu->reg_ic + reg);
+}
+
+#define idmac_read_icreg(ipu, reg) __idmac_read_icreg(ipu, reg - IC_CONF)
+
+static void __idmac_write_icreg(struct ipu *ipu, u32 value, unsigned long reg)
+{
+        __raw_writel(value, ipu->reg_ic + reg);
+}
+
+#define idmac_write_icreg(ipu, v, reg) __idmac_write_icreg(ipu, v, reg - IC_CONF)
+
+static u32 idmac_read_ipureg(struct ipu *ipu, unsigned long reg)
+{
+        return __raw_readl(ipu->reg_ipu + reg);
+}
+
+static void idmac_write_ipureg(struct ipu *ipu, u32 value, unsigned long reg)
+{
+        __raw_writel(value, ipu->reg_ipu + reg);
+}
+
+/*****************************************************************************
+ * IPU / IC common functions
+ */
+static void dump_idmac_reg(struct ipu *ipu)
+{
+        dev_dbg(ipu->dev, "IDMAC_CONF 0x%x, IC_CONF 0x%x, IDMAC_CHA_EN 0x%x, "
+                "IDMAC_CHA_PRI 0x%x, IDMAC_CHA_BUSY 0x%x\n",
+                idmac_read_icreg(ipu, IDMAC_CONF),
+                idmac_read_icreg(ipu, IC_CONF),
+                idmac_read_icreg(ipu, IDMAC_CHA_EN),
+                idmac_read_icreg(ipu, IDMAC_CHA_PRI),
+                idmac_read_icreg(ipu, IDMAC_CHA_BUSY));
+        dev_dbg(ipu->dev, "BUF0_RDY 0x%x, BUF1_RDY 0x%x, CUR_BUF 0x%x, "
+                "DB_MODE 0x%x, TASKS_STAT 0x%x\n",
+                idmac_read_ipureg(ipu, IPU_CHA_BUF0_RDY),
+                idmac_read_ipureg(ipu, IPU_CHA_BUF1_RDY),
+                idmac_read_ipureg(ipu, IPU_CHA_CUR_BUF),
+                idmac_read_ipureg(ipu, IPU_CHA_DB_MODE_SEL),
+                idmac_read_ipureg(ipu, IPU_TASKS_STAT));
+}
+
+static uint32_t bytes_per_pixel(enum pixel_fmt fmt)
+{
+        switch (fmt) {
+        case IPU_PIX_FMT_GENERIC:       /* generic data */
+        case IPU_PIX_FMT_RGB332:
+        case IPU_PIX_FMT_YUV420P:
+        case IPU_PIX_FMT_YUV422P:
+        default:
+                return 1;
+        case IPU_PIX_FMT_RGB565:
+        case IPU_PIX_FMT_YUYV:
+        case IPU_PIX_FMT_UYVY:
+                return 2;
+        case IPU_PIX_FMT_BGR24:
+        case IPU_PIX_FMT_RGB24:
+                return 3;
+        case IPU_PIX_FMT_GENERIC_32:    /* generic data */
+        case IPU_PIX_FMT_BGR32:
+        case IPU_PIX_FMT_RGB32:
+        case IPU_PIX_FMT_ABGR32:
+                return 4;
+        }
+}
+
+/* Enable / disable direct write to memory by the Camera Sensor Interface */
+static void ipu_ic_enable_task(struct ipu *ipu, enum ipu_channel channel)
+{
+        uint32_t ic_conf, mask;
+
+        switch (channel) {
+        case IDMAC_IC_0:
+                mask = IC_CONF_PRPENC_EN;
+                break;
+        case IDMAC_IC_7:
+                mask = IC_CONF_RWS_EN | IC_CONF_PRPENC_EN;
+                break;
+        default:
+                return;
+        }
+        ic_conf = idmac_read_icreg(ipu, IC_CONF) | mask;
+        idmac_write_icreg(ipu, ic_conf, IC_CONF);
+}
+
+static void ipu_ic_disable_task(struct ipu *ipu, enum ipu_channel channel)
+{
+        uint32_t ic_conf, mask;
+
+        switch (channel) {
+        case IDMAC_IC_0:
+                mask = IC_CONF_PRPENC_EN;
+                break;
+        case IDMAC_IC_7:
+                mask = IC_CONF_RWS_EN | IC_CONF_PRPENC_EN;
+                break;
+        default:
+                return;
+        }
+        ic_conf = idmac_read_icreg(ipu, IC_CONF) & ~mask;
+        idmac_write_icreg(ipu, ic_conf, IC_CONF);
+}
+
+static uint32_t ipu_channel_status(struct ipu *ipu, enum ipu_channel channel)
+{
+        uint32_t stat = TASK_STAT_IDLE;
+        uint32_t task_stat_reg = idmac_read_ipureg(ipu, IPU_TASKS_STAT);
+
+        switch (channel) {
+        case IDMAC_IC_7:
+                stat = (task_stat_reg & TSTAT_CSI2MEM_MASK) >>
+                        TSTAT_CSI2MEM_OFFSET;
+                break;
+        case IDMAC_IC_0:
+        case IDMAC_SDC_0:
+        case IDMAC_SDC_1:
+        default:
+                break;
+        }
+        return stat;
+}
+
+struct chan_param_mem_planar {
+        /* Word 0 */
+        u32     xv:10;
+        u32     yv:10;
+        u32     xb:12;
+
+        u32     yb:12;
+        u32     res1:2;
+        u32     nsb:1;
+        u32     lnpb:6;
+        u32     ubo_l:11;
+
+        u32     ubo_h:15;
+        u32     vbo_l:17;
+
+        u32     vbo_h:9;
+        u32     res2:3;
+        u32     fw:12;
+        u32     fh_l:8;
+
+        u32     fh_h:4;
+        u32     res3:28;
+
+        /* Word 1 */
+        u32     eba0;
+
+        u32     eba1;
+
+        u32     bpp:3;
+        u32     sl:14;
+        u32     pfs:3;
+        u32     bam:3;
+        u32     res4:2;
+        u32     npb:6;
+        u32     res5:1;
+
+        u32     sat:2;
+        u32     res6:30;
+} __attribute__ ((packed));
+
+struct chan_param_mem_interleaved {
+        /* Word 0 */
+        u32     xv:10;
+        u32     yv:10;
+        u32     xb:12;
+
+        u32     yb:12;
+        u32     sce:1;
+        u32     res1:1;
+        u32     nsb:1;
+        u32     lnpb:6;
+        u32     sx:10;
+        u32     sy_l:1;
+
+        u32     sy_h:9;
+        u32     ns:10;
+        u32     sm:10;
+        u32     sdx_l:3;
+
+        u32     sdx_h:2;
+        u32     sdy:5;
+        u32     sdrx:1;
+        u32     sdry:1;
+        u32     sdr1:1;
+        u32     res2:2;
+        u32     fw:12;
+        u32     fh_l:8;
+
+        u32     fh_h:4;
+        u32     res3:28;
+
+        /* Word 1 */
+        u32     eba0;
+
+        u32     eba1;
+
+        u32     bpp:3;
+        u32     sl:14;
+        u32     pfs:3;
+        u32     bam:3;
+        u32     res4:2;
+        u32     npb:6;
+        u32     res5:1;
+
+        u32     sat:2;
+        u32     scc:1;
+        u32     ofs0:5;
+        u32     ofs1:5;
+        u32     ofs2:5;
+        u32     ofs3:5;
+        u32     wid0:3;
+        u32     wid1:3;
+        u32     wid2:3;
+
+        u32     wid3:3;
+        u32     dec_sel:1;
+        u32     res6:28;
+} __attribute__ ((packed));
+
+union chan_param_mem {
+        struct chan_param_mem_planar            pp;
+        struct chan_param_mem_interleaved       ip;
+};
+
+static void ipu_ch_param_set_plane_offset(union chan_param_mem *params,
+                                          u32 u_offset, u32 v_offset)
+{
+        params->pp.ubo_l = u_offset & 0x7ff;
+        params->pp.ubo_h = u_offset >> 11;
+        params->pp.vbo_l = v_offset & 0x1ffff;
+        params->pp.vbo_h = v_offset >> 17;
+}
+
+static void ipu_ch_param_set_size(union chan_param_mem *params,
+                                  uint32_t pixel_fmt, uint16_t width,
+                                  uint16_t height, uint16_t stride)
+{
+        u32 u_offset;
+        u32 v_offset;
+
+        params->pp.fw           = width - 1;
+        params->pp.fh_l         = height - 1;
+        params->pp.fh_h         = (height - 1) >> 8;
+        params->pp.sl           = stride - 1;
+
+        switch (pixel_fmt) {
+        case IPU_PIX_FMT_GENERIC:
+                /*Represents 8-bit Generic data */
+                params->pp.bpp  = 3;
+                params->pp.pfs  = 7;
+                params->pp.npb  = 31;
+                params->pp.sat  = 2;            /* SAT = use 32-bit access */
+                break;
+        case IPU_PIX_FMT_GENERIC_32:
+                /*Represents 32-bit Generic data */
+                params->pp.bpp  = 0;
+                params->pp.pfs  = 7;
+                params->pp.npb  = 7;
+                params->pp.sat  = 2;            /* SAT = use 32-bit access */
+                break;
+        case IPU_PIX_FMT_RGB565:
+                params->ip.bpp  = 2;
+                params->ip.pfs  = 4;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                params->ip.ofs0 = 0;            /* Red bit offset */
+                params->ip.ofs1 = 5;            /* Green bit offset */
+                params->ip.ofs2 = 11;           /* Blue bit offset */
+                params->ip.ofs3 = 16;           /* Alpha bit offset */
+                params->ip.wid0 = 4;            /* Red bit width - 1 */
+                params->ip.wid1 = 5;            /* Green bit width - 1 */
+                params->ip.wid2 = 4;            /* Blue bit width - 1 */
+                break;
+        case IPU_PIX_FMT_BGR24:
+                params->ip.bpp  = 1;            /* 24 BPP & RGB PFS */
+                params->ip.pfs  = 4;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                params->ip.ofs0 = 0;            /* Red bit offset */
+                params->ip.ofs1 = 8;            /* Green bit offset */
+                params->ip.ofs2 = 16;           /* Blue bit offset */
+                params->ip.ofs3 = 24;           /* Alpha bit offset */
+                params->ip.wid0 = 7;            /* Red bit width - 1 */
+                params->ip.wid1 = 7;            /* Green bit width - 1 */
+                params->ip.wid2 = 7;            /* Blue bit width - 1 */
+                break;
+        case IPU_PIX_FMT_RGB24:
+                params->ip.bpp  = 1;            /* 24 BPP & RGB PFS */
+                params->ip.pfs  = 4;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                params->ip.ofs0 = 16;           /* Red bit offset */
+                params->ip.ofs1 = 8;            /* Green bit offset */
+                params->ip.ofs2 = 0;            /* Blue bit offset */
+                params->ip.ofs3 = 24;           /* Alpha bit offset */
+                params->ip.wid0 = 7;            /* Red bit width - 1 */
+                params->ip.wid1 = 7;            /* Green bit width - 1 */
+                params->ip.wid2 = 7;            /* Blue bit width - 1 */
+                break;
+        case IPU_PIX_FMT_BGRA32:
+        case IPU_PIX_FMT_BGR32:
+                params->ip.bpp  = 0;
+                params->ip.pfs  = 4;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                params->ip.ofs0 = 8;            /* Red bit offset */
+                params->ip.ofs1 = 16;           /* Green bit offset */
+                params->ip.ofs2 = 24;           /* Blue bit offset */
+                params->ip.ofs3 = 0;            /* Alpha bit offset */
+                params->ip.wid0 = 7;            /* Red bit width - 1 */
+                params->ip.wid1 = 7;            /* Green bit width - 1 */
+                params->ip.wid2 = 7;            /* Blue bit width - 1 */
+                params->ip.wid3 = 7;            /* Alpha bit width - 1 */
+                break;
+        case IPU_PIX_FMT_RGBA32:
+        case IPU_PIX_FMT_RGB32:
+                params->ip.bpp  = 0;
+                params->ip.pfs  = 4;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                params->ip.ofs0 = 24;           /* Red bit offset */
+                params->ip.ofs1 = 16;           /* Green bit offset */
+                params->ip.ofs2 = 8;            /* Blue bit offset */
+                params->ip.ofs3 = 0;            /* Alpha bit offset */
+                params->ip.wid0 = 7;            /* Red bit width - 1 */
+                params->ip.wid1 = 7;            /* Green bit width - 1 */
+                params->ip.wid2 = 7;            /* Blue bit width - 1 */
+                params->ip.wid3 = 7;            /* Alpha bit width - 1 */
+                break;
+        case IPU_PIX_FMT_ABGR32:
+                params->ip.bpp  = 0;
+                params->ip.pfs  = 4;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                params->ip.ofs0 = 8;            /* Red bit offset */
+                params->ip.ofs1 = 16;           /* Green bit offset */
+                params->ip.ofs2 = 24;           /* Blue bit offset */
+                params->ip.ofs3 = 0;            /* Alpha bit offset */
+                params->ip.wid0 = 7;            /* Red bit width - 1 */
+                params->ip.wid1 = 7;            /* Green bit width - 1 */
+                params->ip.wid2 = 7;            /* Blue bit width - 1 */
+                params->ip.wid3 = 7;            /* Alpha bit width - 1 */
+                break;
+        case IPU_PIX_FMT_UYVY:
+                params->ip.bpp  = 2;
+                params->ip.pfs  = 6;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                break;
+        case IPU_PIX_FMT_YUV420P2:
+        case IPU_PIX_FMT_YUV420P:
+                params->ip.bpp  = 3;
+                params->ip.pfs  = 3;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                u_offset = stride * height;
+                v_offset = u_offset + u_offset / 4;
+                ipu_ch_param_set_plane_offset(params, u_offset, v_offset);
+                break;
+        case IPU_PIX_FMT_YVU422P:
+                params->ip.bpp  = 3;
+                params->ip.pfs  = 2;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                v_offset = stride * height;
+                u_offset = v_offset + v_offset / 2;
+                ipu_ch_param_set_plane_offset(params, u_offset, v_offset);
+                break;
+        case IPU_PIX_FMT_YUV422P:
+                params->ip.bpp  = 3;
+                params->ip.pfs  = 2;
+                params->ip.npb  = 7;
+                params->ip.sat  = 2;            /* SAT = 32-bit access */
+                u_offset = stride * height;
+                v_offset = u_offset + u_offset / 2;
+                ipu_ch_param_set_plane_offset(params, u_offset, v_offset);
+                break;
+        default:
+                dev_err(ipu_data.dev,
+                        "mxc ipu: unimplemented pixel format %d\n", pixel_fmt);
+                break;
+        }
+
+        params->pp.nsb = 1;
+}
+
+static void ipu_ch_param_set_burst_size(union chan_param_mem *params,
+                                        uint16_t burst_pixels)
+{
+        params->pp.npb = burst_pixels - 1;
+};
+
+static void ipu_ch_param_set_buffer(union chan_param_mem *params,
+                                    dma_addr_t buf0, dma_addr_t buf1)
+{
+        params->pp.eba0 = buf0;
+        params->pp.eba1 = buf1;
+};
+
+static void ipu_ch_param_set_rotation(union chan_param_mem *params,
+                                      enum ipu_rotate_mode rotate)
+{
+        params->pp.bam = rotate;
+};
+
+static void ipu_write_param_mem(uint32_t addr, uint32_t *data,
+                                uint32_t num_words)
+{
+        for (; num_words > 0; num_words--) {
+                dev_dbg(ipu_data.dev,
+                        "write param mem - addr = 0x%08X, data = 0x%08X\n",
+                        addr, *data);
+                idmac_write_ipureg(&ipu_data, addr, IPU_IMA_ADDR);
+                idmac_write_ipureg(&ipu_data, *data++, IPU_IMA_DATA);
+                addr++;
+                if ((addr & 0x7) == 5) {
+                        addr &= ~0x7;   /* set to word 0 */
+                        addr += 8;      /* increment to next row */
+                }
+        }
+}
+
+static int calc_resize_coeffs(uint32_t in_size, uint32_t out_size,
+                              uint32_t *resize_coeff,
+                              uint32_t *downsize_coeff)
+{
+        uint32_t temp_size;
+        uint32_t temp_downsize;
+
+        *resize_coeff   = 1 << 13;
+        *downsize_coeff = 1 << 13;
+
+        /* Cannot downsize more than 8:1 */
+        if (out_size << 3 < in_size)
+                return -EINVAL;
+
+        /* compute downsizing coefficient */
+        temp_downsize = 0;
+        temp_size = in_size;
+        while (temp_size >= out_size * 2 && temp_downsize < 2) {
+                temp_size >>= 1;
+                temp_downsize++;
+        }
+        *downsize_coeff = temp_downsize;
+
+        /*
+         * compute resizing coefficient using the following formula:
+         * resize_coeff = M*(SI -1)/(SO - 1)
+         * where M = 2^13, SI - input size, SO - output size
+         */
+        *resize_coeff = (8192L * (temp_size - 1)) / (out_size - 1);
+        if (*resize_coeff >= 16384L) {
+                dev_err(ipu_data.dev, "Warning! Overflow on resize coeff.\n");
+                *resize_coeff = 0x3FFF;
+        }
+
+        dev_dbg(ipu_data.dev, "resizing from %u -> %u pixels, "
+                "downsize=%u, resize=%u.%lu (reg=%u)\n", in_size, out_size,
+                *downsize_coeff, *resize_coeff >= 8192L ? 1 : 0,
+                ((*resize_coeff & 0x1FFF) * 10000L) / 8192L, *resize_coeff);
+
+        return 0;
+}
+
+static enum ipu_color_space format_to_colorspace(enum pixel_fmt fmt)
+{
+        switch (fmt) {
+        case IPU_PIX_FMT_RGB565:
+        case IPU_PIX_FMT_BGR24:
+        case IPU_PIX_FMT_RGB24:
+        case IPU_PIX_FMT_BGR32:
+        case IPU_PIX_FMT_RGB32:
+                return IPU_COLORSPACE_RGB;
+        default:
+                return IPU_COLORSPACE_YCBCR;
+        }
+}
+
+static int ipu_ic_init_prpenc(struct ipu *ipu,
+                              union ipu_channel_param *params, bool src_is_csi)
+{
+        uint32_t reg, ic_conf;
+        uint32_t downsize_coeff, resize_coeff;
+        enum ipu_color_space in_fmt, out_fmt;
+
+        /* Setup vertical resizing */
+        calc_resize_coeffs(params->video.in_height,
+                            params->video.out_height,
+                            &resize_coeff, &downsize_coeff);
+        reg = (downsize_coeff << 30) | (resize_coeff << 16);
+
+        /* Setup horizontal resizing */
+        calc_resize_coeffs(params->video.in_width,
+                            params->video.out_width,
+                            &resize_coeff, &downsize_coeff);
+        reg |= (downsize_coeff << 14) | resize_coeff;
+
+        /* Setup color space conversion */
+        in_fmt = format_to_colorspace(params->video.in_pixel_fmt);
+        out_fmt = format_to_colorspace(params->video.out_pixel_fmt);
+
+        /*
+         * Colourspace conversion unsupported yet - see _init_csc() in
+         * Freescale sources
+         */
+        if (in_fmt != out_fmt) {
+                dev_err(ipu->dev, "Colourspace conversion unsupported!\n");
+                return -EOPNOTSUPP;
+        }
+
+        idmac_write_icreg(ipu, reg, IC_PRP_ENC_RSC);
+
+        ic_conf = idmac_read_icreg(ipu, IC_CONF);
+
+        if (src_is_csi)
+                ic_conf &= ~IC_CONF_RWS_EN;
+        else
+                ic_conf |= IC_CONF_RWS_EN;
+
+        idmac_write_icreg(ipu, ic_conf, IC_CONF);
+
+        return 0;
+}
+
+static uint32_t dma_param_addr(uint32_t dma_ch)
+{
+        /* Channel Parameter Memory */
+        return 0x10000 | (dma_ch << 4);
+};
+
+static void ipu_channel_set_priority(struct ipu *ipu, enum ipu_channel channel,
+                                     bool prio)
+{
+        u32 reg = idmac_read_icreg(ipu, IDMAC_CHA_PRI);
+
+        if (prio)
+                reg |= 1UL << channel;
+        else
+                reg &= ~(1UL << channel);
+
+        idmac_write_icreg(ipu, reg, IDMAC_CHA_PRI);
+
+        dump_idmac_reg(ipu);
+}
+
+static uint32_t ipu_channel_conf_mask(enum ipu_channel channel)
+{
+        uint32_t mask;
+
+        switch (channel) {
+        case IDMAC_IC_0:
+        case IDMAC_IC_7:
+                mask = IPU_CONF_CSI_EN | IPU_CONF_IC_EN;
+                break;
+        case IDMAC_SDC_0:
+        case IDMAC_SDC_1:
+                mask = IPU_CONF_SDC_EN | IPU_CONF_DI_EN;
+                break;
+        default:
+                mask = 0;
+                break;
+        }
+
+        return mask;
+}
+
+/**
+ * ipu_enable_channel() - enable an IPU channel.
+ * @channel:    channel ID.
+ * @return:     0 on success or negative error code on failure.
+ */
+static int ipu_enable_channel(struct idmac *idmac, struct idmac_channel *ichan)
+{
+        struct ipu *ipu = to_ipu(idmac);
+        enum ipu_channel channel = ichan->dma_chan.chan_id;
+        uint32_t reg;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ipu->lock, flags);
+
+        /* Reset to buffer 0 */
+        idmac_write_ipureg(ipu, 1UL << channel, IPU_CHA_CUR_BUF);
+        ichan->active_buffer = 0;
+        ichan->status = IPU_CHANNEL_ENABLED;
+
+        switch (channel) {
+        case IDMAC_SDC_0:
+        case IDMAC_SDC_1:
+        case IDMAC_IC_7:
+                ipu_channel_set_priority(ipu, channel, true);
+        default:
+                break;
+        }
+
+        reg = idmac_read_icreg(ipu, IDMAC_CHA_EN);
+
+        idmac_write_icreg(ipu, reg | (1UL << channel), IDMAC_CHA_EN);
+
+        ipu_ic_enable_task(ipu, channel);
+
+        spin_unlock_irqrestore(&ipu->lock, flags);
+        return 0;
+}
+
+/**
+ * ipu_init_channel_buffer() - initialize a buffer for logical IPU channel.
+ * @channel:    channel ID.
+ * @pixel_fmt:  pixel format of buffer. Pixel format is a FOURCC ASCII code.
+ * @width:      width of buffer in pixels.
+ * @height:     height of buffer in pixels.
+ * @stride:     stride length of buffer in pixels.
+ * @rot_mode:   rotation mode of buffer. A rotation setting other than
+ *              IPU_ROTATE_VERT_FLIP should only be used for input buffers of
+ *              rotation channels.
+ * @phyaddr_0:  buffer 0 physical address.
+ * @phyaddr_1:  buffer 1 physical address. Setting this to a value other than
+ *              NULL enables double buffering mode.
+ * @return:     0 on success or negative error code on failure.
+ */
+static int ipu_init_channel_buffer(struct idmac_channel *ichan,
+                                   enum pixel_fmt pixel_fmt,
+                                   uint16_t width, uint16_t height,
+                                   uint32_t stride,
+                                   enum ipu_rotate_mode rot_mode,
+                                   dma_addr_t phyaddr_0, dma_addr_t phyaddr_1)
+{
+        enum ipu_channel channel = ichan->dma_chan.chan_id;
+        struct idmac *idmac = to_idmac(ichan->dma_chan.device);
+        struct ipu *ipu = to_ipu(idmac);
+        union chan_param_mem params = {};
+        unsigned long flags;
+        uint32_t reg;
+        uint32_t stride_bytes;
+
+        stride_bytes = stride * bytes_per_pixel(pixel_fmt);
+
+        if (stride_bytes % 4) {
+                dev_err(ipu->dev,
+                        "Stride length must be 32-bit aligned, stride = %d, bytes = %d\n",
+                        stride, stride_bytes);
+                return -EINVAL;
+        }
+
+        /* IC channel's stride must be a multiple of 8 pixels */
+        if ((channel <= 13) && (stride % 8)) {
+                dev_err(ipu->dev, "Stride must be 8 pixel multiple\n");
+                return -EINVAL;
+        }
+
+        /* Build parameter memory data for DMA channel */
+        ipu_ch_param_set_size(&params, pixel_fmt, width, height, stride_bytes);
+        ipu_ch_param_set_buffer(&params, phyaddr_0, phyaddr_1);
+        ipu_ch_param_set_rotation(&params, rot_mode);
+        /* Some channels (rotation) have restriction on burst length */
+        switch (channel) {
+        case IDMAC_IC_7:        /* Hangs with burst 8, 16, other values
+                                   invalid - Table 44-30 */
+/*
+                ipu_ch_param_set_burst_size(&params, 8);
+ */
+                break;
+        case IDMAC_SDC_0:
+        case IDMAC_SDC_1:
+                /* In original code only IPU_PIX_FMT_RGB565 was setting burst */
+                ipu_ch_param_set_burst_size(&params, 16);
+                break;
+        case IDMAC_IC_0:
+        default:
+                break;
+        }
+
+        spin_lock_irqsave(&ipu->lock, flags);
+
+        ipu_write_param_mem(dma_param_addr(channel), (uint32_t *)&params, 10);
+
+        reg = idmac_read_ipureg(ipu, IPU_CHA_DB_MODE_SEL);
+
+        if (phyaddr_1)
+                reg |= 1UL << channel;
+        else
+                reg &= ~(1UL << channel);
+
+        idmac_write_ipureg(ipu, reg, IPU_CHA_DB_MODE_SEL);
+
+        ichan->status = IPU_CHANNEL_READY;
+
+        spin_unlock_irqrestore(ipu->lock, flags);
+
+        return 0;
+}
+
+/**
+ * ipu_select_buffer() - mark a channel's buffer as ready.
+ * @channel:    channel ID.
+ * @buffer_n:   buffer number to mark ready.
+ */
+static void ipu_select_buffer(enum ipu_channel channel, int buffer_n)
+{
+        /* No locking - this is a write-one-to-set register, cleared by IPU */
+        if (buffer_n == 0)
+                /* Mark buffer 0 as ready. */
+                idmac_write_ipureg(&ipu_data, 1UL << channel, IPU_CHA_BUF0_RDY);
+        else
+                /* Mark buffer 1 as ready. */
+                idmac_write_ipureg(&ipu_data, 1UL << channel, IPU_CHA_BUF1_RDY);
+}
+
+/**
+ * ipu_update_channel_buffer() - update physical address of a channel buffer.
+ * @channel:    channel ID.
+ * @buffer_n:   buffer number to update.
+ *              0 or 1 are the only valid values.
+ * @phyaddr:    buffer physical address.
+ * @return:     Returns 0 on success or negative error code on failure. This
+ *              function will fail if the buffer is set to ready.
+ */
+/* Called under spin_lock(_irqsave)(&ichan->lock) */
+static int ipu_update_channel_buffer(enum ipu_channel channel,
+                                     int buffer_n, dma_addr_t phyaddr)
+{
+        uint32_t reg;
+        unsigned long flags;
+
+        spin_lock_irqsave(&ipu_data.lock, flags);
+
+        if (buffer_n == 0) {
+                reg = idmac_read_ipureg(&ipu_data, IPU_CHA_BUF0_RDY);
+                if (reg & (1UL << channel)) {
+                        spin_unlock_irqrestore(&ipu_data.lock, flags);
+                        return -EACCES;
+                }
+
+                /* 44.3.3.1.9 - Row Number 1 (WORD1, offset 0) */
+                idmac_write_ipureg(&ipu_data, dma_param_addr(channel) +
+                                   0x0008UL, IPU_IMA_ADDR);
+                idmac_write_ipureg(&ipu_data, phyaddr, IPU_IMA_DATA);
+        } else {
+                reg = idmac_read_ipureg(&ipu_data, IPU_CHA_BUF1_RDY);
+                if (reg & (1UL << channel)) {
+                        spin_unlock_irqrestore(&ipu_data.lock, flags);
+                        return -EACCES;
+                }
+
+                /* Check if double-buffering is already enabled */
+                reg = idmac_read_ipureg(&ipu_data, IPU_CHA_DB_MODE_SEL);
+
+                if (!(reg & (1UL << channel)))
+                        idmac_write_ipureg(&ipu_data, reg | (1UL << channel),
+                                           IPU_CHA_DB_MODE_SEL);
+
+                /* 44.3.3.1.9 - Row Number 1 (WORD1, offset 1) */
+                idmac_write_ipureg(&ipu_data, dma_param_addr(channel) +
+                                   0x0009UL, IPU_IMA_ADDR);
+                idmac_write_ipureg(&ipu_data, phyaddr, IPU_IMA_DATA);
+        }
+
+        spin_unlock_irqrestore(&ipu_data.lock, flags);
+
+        return 0;
+}
+
+/* Called under spin_lock_irqsave(&ichan->lock) */
+static int ipu_submit_channel_buffers(struct idmac_channel *ichan,
+                                      struct idmac_tx_desc *desc)
+{
+        struct scatterlist *sg;
+        int i, ret = 0;
+
+        for (i = 0, sg = desc->sg; i < 2 && sg; i++) {
+                if (!ichan->sg[i]) {
+                        ichan->sg[i] = sg;
+
+                        /*
+                         * On first invocation this shouldn't be necessary, the
+                         * call to ipu_init_channel_buffer() above will set
+                         * addresses for us, so we could make it conditional
+                         * on status >= IPU_CHANNEL_ENABLED, but doing it again
+                         * shouldn't hurt either.
+                         */
+                        ret = ipu_update_channel_buffer(ichan->dma_chan.chan_id, i,
+                                                        sg_dma_address(sg));
+                        if (ret < 0)
+                                return ret;
+
+                        ipu_select_buffer(ichan->dma_chan.chan_id, i);
+
+                        sg = sg_next(sg);
+                }
+        }
+
+        return ret;
+}
+
+static dma_cookie_t idmac_tx_submit(struct dma_async_tx_descriptor *tx)
+{
+        struct idmac_tx_desc *desc = to_tx_desc(tx);
+        struct idmac_channel *ichan = to_idmac_chan(tx->chan);
+        struct idmac *idmac = to_idmac(tx->chan->device);
+        struct ipu *ipu = to_ipu(idmac);
+        dma_cookie_t cookie;
+        unsigned long flags;
+
+        /* Sanity check */
+        if (!list_empty(&desc->list)) {
+                /* The descriptor doesn't belong to client */
+                dev_err(&ichan->dma_chan.dev->device,
+                        "Descriptor %p not prepared!\n", tx);
+                return -EBUSY;
+        }
+
+        mutex_lock(&ichan->chan_mutex);
+
+        if (ichan->status < IPU_CHANNEL_READY) {
+                struct idmac_video_param *video = &ichan->params.video;
+                /*
+                 * Initial buffer assignment - the first two sg-entries from
+                 * the descriptor will end up in the IDMAC buffers
+                 */
+                dma_addr_t dma_1 = sg_is_last(desc->sg) ? 0 :
+                        sg_dma_address(&desc->sg[1]);
+
+                WARN_ON(ichan->sg[0] || ichan->sg[1]);
+
+                cookie = ipu_init_channel_buffer(ichan,
+                                                 video->out_pixel_fmt,
+                                                 video->out_width,
+                                                 video->out_height,
+                                                 video->out_stride,
+                                                 IPU_ROTATE_NONE,
+                                                 sg_dma_address(&desc->sg[0]),
+                                                 dma_1);
+                if (cookie < 0)
+                        goto out;
+        }
+
+        /* ipu->lock can be taken under ichan->lock, but not v.v. */
+        spin_lock_irqsave(&ichan->lock, flags);
+
+        /* submit_buffers() atomically verifies and fills empty sg slots */
+        cookie = ipu_submit_channel_buffers(ichan, desc);
+
+        spin_unlock_irqrestore(&ichan->lock, flags);
+
+        if (cookie < 0)
+                goto out;
+
+        cookie = ichan->dma_chan.cookie;
+
+        if (++cookie < 0)
+                cookie = 1;
+
+        /* from dmaengine.h: "last cookie value returned to client" */
+        ichan->dma_chan.cookie = cookie;
+        tx->cookie = cookie;
+        spin_lock_irqsave(&ichan->lock, flags);
+        list_add_tail(&desc->list, &ichan->queue);
+        spin_unlock_irqrestore(&ichan->lock, flags);
+
+        if (ichan->status < IPU_CHANNEL_ENABLED) {
+                int ret = ipu_enable_channel(idmac, ichan);
+                if (ret < 0) {
+                        cookie = ret;
+                        spin_lock_irqsave(&ichan->lock, flags);
+                        list_del_init(&desc->list);
+                        spin_unlock_irqrestore(&ichan->lock, flags);
+                        tx->cookie = cookie;
+                        ichan->dma_chan.cookie = cookie;
+                }
+        }
+
+        dump_idmac_reg(ipu);
+
+out:
+        mutex_unlock(&ichan->chan_mutex);
+
+        return cookie;
+}
+
+/* Called with ichan->chan_mutex held */
+static int idmac_desc_alloc(struct idmac_channel *ichan, int n)
+{
+        struct idmac_tx_desc *desc = vmalloc(n * sizeof(struct idmac_tx_desc));
+        struct idmac *idmac = to_idmac(ichan->dma_chan.device);
+
+        if (!desc)
+                return -ENOMEM;
+
+        /* No interrupts, just disable the tasklet for a moment */
+        tasklet_disable(&to_ipu(idmac)->tasklet);
+
+        ichan->n_tx_desc = n;
+        ichan->desc = desc;
+        INIT_LIST_HEAD(&ichan->queue);
+        INIT_LIST_HEAD(&ichan->free_list);
+
+        while (n--) {
+                struct dma_async_tx_descriptor *txd = &desc->txd;
+
+                memset(txd, 0, sizeof(*txd));
+                dma_async_tx_descriptor_init(txd, &ichan->dma_chan);
+                txd->tx_submit          = idmac_tx_submit;
+                txd->chan               = &ichan->dma_chan;
+                INIT_LIST_HEAD(&txd->tx_list);
+
+                list_add(&desc->list, &ichan->free_list);
+
+                desc++;
+        }
+
+        tasklet_enable(&to_ipu(idmac)->tasklet);
+
+        return 0;
+}
+
+/**
+ * ipu_init_channel() - initialize an IPU channel.
+ * @idmac:      IPU DMAC context.
+ * @ichan:      pointer to the channel object.
+ * @return      0 on success or negative error code on failure.
+ */
+static int ipu_init_channel(struct idmac *idmac, struct idmac_channel *ichan)
+{
+        union ipu_channel_param *params = &ichan->params;
+        uint32_t ipu_conf;
+        enum ipu_channel channel = ichan->dma_chan.chan_id;
+        unsigned long flags;
+        uint32_t reg;
+        struct ipu *ipu = to_ipu(idmac);
+        int ret = 0, n_desc = 0;
+
+        dev_dbg(ipu->dev, "init channel = %d\n", channel);
+
+        if (channel != IDMAC_SDC_0 && channel != IDMAC_SDC_1 &&
+            channel != IDMAC_IC_7)
+                return -EINVAL;
+
+        spin_lock_irqsave(&ipu->lock, flags);
+
+        switch (channel) {
+        case IDMAC_IC_7:
+                n_desc = 16;
+                reg = idmac_read_icreg(ipu, IC_CONF);
+                idmac_write_icreg(ipu, reg & ~IC_CONF_CSI_MEM_WR_EN, IC_CONF);
+                break;
+        case IDMAC_IC_0:
+                n_desc = 16;
+                reg = idmac_read_ipureg(ipu, IPU_FS_PROC_FLOW);
+                idmac_write_ipureg(ipu, reg & ~FS_ENC_IN_VALID, IPU_FS_PROC_FLOW);
+                ret = ipu_ic_init_prpenc(ipu, params, true);
+                break;
+        case IDMAC_SDC_0:
+        case IDMAC_SDC_1:
+                n_desc = 4;
+        default:
+                break;
+        }
+
+        ipu->channel_init_mask |= 1L << channel;
+
+        /* Enable IPU sub module */
+        ipu_conf = idmac_read_ipureg(ipu, IPU_CONF) |
+                ipu_channel_conf_mask(channel);
+        idmac_write_ipureg(ipu, ipu_conf, IPU_CONF);
+
+        spin_unlock_irqrestore(&ipu->lock, flags);
+
+        if (n_desc && !ichan->desc)
+                ret = idmac_desc_alloc(ichan, n_desc);
+
+        dump_idmac_reg(ipu);
+
+        return ret;
+}
+
+/**
+ * ipu_uninit_channel() - uninitialize an IPU channel.
+ * @idmac:      IPU DMAC context.
+ * @ichan:      pointer to the channel object.
+ */
+static void ipu_uninit_channel(struct idmac *idmac, struct idmac_channel *ichan)
+{
+        enum ipu_channel channel = ichan->dma_chan.chan_id;
+        unsigned long flags;
+        uint32_t reg;
+        unsigned long chan_mask = 1UL << channel;
+        uint32_t ipu_conf;
+        struct ipu *ipu = to_ipu(idmac);
+
+        spin_lock_irqsave(&ipu->lock, flags);
+
+        if (!(ipu->channel_init_mask & chan_mask)) {
+                dev_err(ipu->dev, "Channel already uninitialized %d\n",
+                        channel);
+                spin_unlock_irqrestore(&ipu->lock, flags);
+                return;
+        }
+
+        /* Reset the double buffer */
+        reg = idmac_read_ipureg(ipu, IPU_CHA_DB_MODE_SEL);
+        idmac_write_ipureg(ipu, reg & ~chan_mask, IPU_CHA_DB_MODE_SEL);
+
+        ichan->sec_chan_en = false;
+
+        switch (channel) {
+        case IDMAC_IC_7:
+                reg = idmac_read_icreg(ipu, IC_CONF);
+                idmac_write_icreg(ipu, reg & ~(IC_CONF_RWS_EN | IC_CONF_PRPENC_EN),
+                             IC_CONF);
+                break;
+        case IDMAC_IC_0:
+                reg = idmac_read_icreg(ipu, IC_CONF);
+                idmac_write_icreg(ipu, reg & ~(IC_CONF_PRPENC_EN | IC_CONF_PRPENC_CSC1),
+                                  IC_CONF);
+                break;
+        case IDMAC_SDC_0:
+        case IDMAC_SDC_1:
+        default:
+                break;
+        }
+
+        ipu->channel_init_mask &= ~(1L << channel);
+
+        ipu_conf = idmac_read_ipureg(ipu, IPU_CONF) &
+                ~ipu_channel_conf_mask(channel);
+        idmac_write_ipureg(ipu, ipu_conf, IPU_CONF);
+
+        spin_unlock_irqrestore(&ipu->lock, flags);
+
+        ichan->n_tx_desc = 0;
+        vfree(ichan->desc);
+        ichan->desc = NULL;
+}
+
+/**
+ * ipu_disable_channel() - disable an IPU channel.
+ * @idmac:              IPU DMAC context.
+ * @ichan:              channel object pointer.
+ * @wait_for_stop:      flag to set whether to wait for channel end of frame or
+ *                      return immediately.
+ * @return:             0 on success or negative error code on failure.
+ */
+static int ipu_disable_channel(struct idmac *idmac, struct idmac_channel *ichan,
+                               bool wait_for_stop)
+{
+        enum ipu_channel channel = ichan->dma_chan.chan_id;
+        struct ipu *ipu = to_ipu(idmac);
+        uint32_t reg;
+        unsigned long flags;
+        unsigned long chan_mask = 1UL << channel;
+        unsigned int timeout;
+
+        if (wait_for_stop && channel != IDMAC_SDC_1 && channel != IDMAC_SDC_0) {
+                timeout = 40;
+                /* This waiting always fails. Related to spurious irq problem */
+                while ((idmac_read_icreg(ipu, IDMAC_CHA_BUSY) & chan_mask) ||
+                       (ipu_channel_status(ipu, channel) == TASK_STAT_ACTIVE)) {
+                        timeout--;
+                        msleep(10);
+
+                        if (!timeout) {
+                                dev_dbg(ipu->dev,
+                                        "Warning: timeout waiting for channel %u to "
+                                        "stop: buf0_rdy = 0x%08X, buf1_rdy = 0x%08X, "
+                                        "busy = 0x%08X, tstat = 0x%08X\n", channel,
+                                        idmac_read_ipureg(ipu, IPU_CHA_BUF0_RDY),
+                                        idmac_read_ipureg(ipu, IPU_CHA_BUF1_RDY),
+                                        idmac_read_icreg(ipu, IDMAC_CHA_BUSY),
+                                        idmac_read_ipureg(ipu, IPU_TASKS_STAT));
+                                break;
+                        }
+                }
+                dev_dbg(ipu->dev, "timeout = %d * 10ms\n", 40 - timeout);
+        }
+        /* SDC BG and FG must be disabled before DMA is disabled */
+        if (wait_for_stop && (channel == IDMAC_SDC_0 ||
+                              channel == IDMAC_SDC_1)) {
+                for (timeout = 5;
+                     timeout && !ipu_irq_status(ichan->eof_irq); timeout--)
+                        msleep(5);
+        }
+
+        spin_lock_irqsave(&ipu->lock, flags);
+
+        /* Disable IC task */
+        ipu_ic_disable_task(ipu, channel);
+
+        /* Disable DMA channel(s) */
+        reg = idmac_read_icreg(ipu, IDMAC_CHA_EN);
+        idmac_write_icreg(ipu, reg & ~chan_mask, IDMAC_CHA_EN);
+
+        /*
+         * Problem (observed with channel DMAIC_7): after enabling the channel
+         * and initialising buffers, there comes an interrupt with current still
+         * pointing at buffer 0, whereas it should use buffer 0 first and only
+         * generate an interrupt when it is done, then current should already
+         * point to buffer 1. This spurious interrupt also comes on channel
+         * DMASDC_0. With DMAIC_7 normally, is we just leave the ISR after the
+         * first interrupt, there comes the second with current correctly
+         * pointing to buffer 1 this time. But sometimes this second interrupt
+         * doesn't come and the channel hangs. Clearing BUFx_RDY when disabling
+         * the channel seems to prevent the channel from hanging, but it doesn't
+         * prevent the spurious interrupt. This might also be unsafe. Think
+         * about the IDMAC controller trying to switch to a buffer, when we
+         * clear the ready bit, and re-enable it a moment later.
+         */
+        reg = idmac_read_ipureg(ipu, IPU_CHA_BUF0_RDY);
+        idmac_write_ipureg(ipu, 0, IPU_CHA_BUF0_RDY);
+        idmac_write_ipureg(ipu, reg & ~(1UL << channel), IPU_CHA_BUF0_RDY);
+
+        reg = idmac_read_ipureg(ipu, IPU_CHA_BUF1_RDY);
+        idmac_write_ipureg(ipu, 0, IPU_CHA_BUF1_RDY);
+        idmac_write_ipureg(ipu, reg & ~(1UL << channel), IPU_CHA_BUF1_RDY);
+
+        spin_unlock_irqrestore(&ipu->lock, flags);
+
+        return 0;
+}
+
+/*
+ * We have several possibilities here:
+ * current BUF          next BUF
+ *
+ * not last sg          next not last sg
+ * not last sg          next last sg
+ * last sg              first sg from next descriptor
+ * last sg              NULL
+ *
+ * Besides, the descriptor queue might be empty or not. We process all these
+ * cases carefully.
+ */
+static irqreturn_t idmac_interrupt(int irq, void *dev_id)
+{
+        struct idmac_channel *ichan = dev_id;
+        unsigned int chan_id = ichan->dma_chan.chan_id;
+        struct scatterlist **sg, *sgnext, *sgnew = NULL;
+        /* Next transfer descriptor */
+        struct idmac_tx_desc *desc = NULL, *descnew;
+        dma_async_tx_callback callback;
+        void *callback_param;
+        bool done = false;
+        u32     ready0 = idmac_read_ipureg(&ipu_data, IPU_CHA_BUF0_RDY),
+                ready1 = idmac_read_ipureg(&ipu_data, IPU_CHA_BUF1_RDY),
+                curbuf = idmac_read_ipureg(&ipu_data, IPU_CHA_CUR_BUF);
+
+        /* IDMAC has cleared the respective BUFx_RDY bit, we manage the buffer */
+
+        pr_debug("IDMAC irq %d\n", irq);
+        /* Other interrupts do not interfere with this channel */
+        spin_lock(&ichan->lock);
+
+        if (unlikely(chan_id != IDMAC_SDC_0 && chan_id != IDMAC_SDC_1 &&
+                     ((curbuf >> chan_id) & 1) == ichan->active_buffer)) {
+                int i = 100;
+
+                /* This doesn't help. See comment in ipu_disable_channel() */
+                while (--i) {
+                        curbuf = idmac_read_ipureg(&ipu_data, IPU_CHA_CUR_BUF);
+                        if (((curbuf >> chan_id) & 1) != ichan->active_buffer)
+                                break;
+                        cpu_relax();
+                }
+
+                if (!i) {
+                        spin_unlock(&ichan->lock);
+                        dev_dbg(ichan->dma_chan.device->dev,
+                                "IRQ on active buffer on channel %x, active "
+                                "%d, ready %x, %x, current %x!\n", chan_id,
+                                ichan->active_buffer, ready0, ready1, curbuf);
+                        return IRQ_NONE;
+                }
+        }
+
+        if (unlikely((ichan->active_buffer && (ready1 >> chan_id) & 1) ||
+                     (!ichan->active_buffer && (ready0 >> chan_id) & 1)
+                     )) {
+                spin_unlock(&ichan->lock);
+                dev_dbg(ichan->dma_chan.device->dev,
+                        "IRQ with active buffer still ready on channel %x, "
+                        "active %d, ready %x, %x!\n", chan_id,
+                        ichan->active_buffer, ready0, ready1);
+                return IRQ_NONE;
+        }
+
+        if (unlikely(list_empty(&ichan->queue))) {
+                spin_unlock(&ichan->lock);
+                dev_err(ichan->dma_chan.device->dev,
+                        "IRQ without queued buffers on channel %x, active %d, "
+                        "ready %x, %x!\n", chan_id,
+                        ichan->active_buffer, ready0, ready1);
+                return IRQ_NONE;
+        }
+
+        /*
+         * active_buffer is a software flag, it shows which buffer we are
+         * currently expecting back from the hardware, IDMAC should be
+         * processing the other buffer already
+         */
+        sg = &ichan->sg[ichan->active_buffer];
+        sgnext = ichan->sg[!ichan->active_buffer];
+
+        /*
+         * if sgnext == NULL sg must be the last element in a scatterlist and
+         * queue must be empty
+         */
+        if (unlikely(!sgnext)) {
+                if (unlikely(sg_next(*sg))) {
+                        dev_err(ichan->dma_chan.device->dev,
+                                "Broken buffer-update locking on channel %x!\n",
+                                chan_id);
+                        /* We'll let the user catch up */
+                } else {
+                        /* Underrun */
+                        ipu_ic_disable_task(&ipu_data, chan_id);
+                        dev_dbg(ichan->dma_chan.device->dev,
+                                "Underrun on channel %x\n", chan_id);
+                        ichan->status = IPU_CHANNEL_READY;
+                        /* Continue to check for complete descriptor */
+                }
+        }
+
+        desc = list_entry(ichan->queue.next, struct idmac_tx_desc, list);
+
+        /* First calculate and submit the next sg element */
+        if (likely(sgnext))
+                sgnew = sg_next(sgnext);
+
+        if (unlikely(!sgnew)) {
+                /* Start a new scatterlist, if any queued */
+                if (likely(desc->list.next != &ichan->queue)) {
+                        descnew = list_entry(desc->list.next,
+                                             struct idmac_tx_desc, list);
+                        sgnew = &descnew->sg[0];
+                }
+        }
+
+        if (unlikely(!sg_next(*sg)) || !sgnext) {
+                /*
+                 * Last element in scatterlist done, remove from the queue,
+                 * _init for debugging
+                 */
+                list_del_init(&desc->list);
+                done = true;
+        }
+
+        *sg = sgnew;
+
+        if (likely(sgnew)) {
+                int ret;
+
+                ret = ipu_update_channel_buffer(chan_id, ichan->active_buffer,
+                                                sg_dma_address(*sg));
+                if (ret < 0)
+                        dev_err(ichan->dma_chan.device->dev,
+                                "Failed to update buffer on channel %x buffer %d!\n",
+                                chan_id, ichan->active_buffer);
+                else
+                        ipu_select_buffer(chan_id, ichan->active_buffer);
+        }
+
+        /* Flip the active buffer - even if update above failed */
+        ichan->active_buffer = !ichan->active_buffer;
+        if (done)
+                ichan->completed = desc->txd.cookie;
+
+        callback = desc->txd.callback;
+        callback_param = desc->txd.callback_param;
+
+        spin_unlock(&ichan->lock);
+
+        if (done && (desc->txd.flags & DMA_PREP_INTERRUPT) && callback)
+                callback(callback_param);
+
+        return IRQ_HANDLED;
+}
+
+static void ipu_gc_tasklet(unsigned long arg)
+{
+        struct ipu *ipu = (struct ipu *)arg;
+        int i;
+
+        for (i = 0; i < IPU_CHANNELS_NUM; i++) {
+                struct idmac_channel *ichan = ipu->channel + i;
+                struct idmac_tx_desc *desc;
+                unsigned long flags;
+                int j;
+
+                for (j = 0; j < ichan->n_tx_desc; j++) {
+                        desc = ichan->desc + j;
+                        spin_lock_irqsave(&ichan->lock, flags);
+                        if (async_tx_test_ack(&desc->txd)) {
+                                list_move(&desc->list, &ichan->free_list);
+                                async_tx_clear_ack(&desc->txd);
+                        }
+                        spin_unlock_irqrestore(&ichan->lock, flags);
+                }
+        }
+}
+
+/*
+ * At the time .device_alloc_chan_resources() method is called, we cannot know,
+ * whether the client will accept the channel. Thus we must only check, if we
+ * can satisfy client's request but the only real criterion to verify, whether
+ * the client has accepted our offer is the client_count. That's why we have to
+ * perform the rest of our allocation tasks on the first call to this function.
+ */
+static struct dma_async_tx_descriptor *idmac_prep_slave_sg(struct dma_chan *chan,
+                struct scatterlist *sgl, unsigned int sg_len,
+                enum dma_data_direction direction, unsigned long tx_flags)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+        struct idmac_tx_desc *desc = NULL;
+        struct dma_async_tx_descriptor *txd = NULL;
+        unsigned long flags;
+
+        /* We only can handle these three channels so far */
+        if (ichan->dma_chan.chan_id != IDMAC_SDC_0 && ichan->dma_chan.chan_id != IDMAC_SDC_1 &&
+            ichan->dma_chan.chan_id != IDMAC_IC_7)
+                return NULL;
+
+        if (direction != DMA_FROM_DEVICE && direction != DMA_TO_DEVICE) {
+                dev_err(chan->device->dev, "Invalid DMA direction %d!\n", direction);
+                return NULL;
+        }
+
+        mutex_lock(&ichan->chan_mutex);
+
+        spin_lock_irqsave(&ichan->lock, flags);
+        if (!list_empty(&ichan->free_list)) {
+                desc = list_entry(ichan->free_list.next,
+                                  struct idmac_tx_desc, list);
+
+                list_del_init(&desc->list);
+
+                desc->sg_len    = sg_len;
+                desc->sg        = sgl;
+                txd             = &desc->txd;
+                txd->flags      = tx_flags;
+        }
+        spin_unlock_irqrestore(&ichan->lock, flags);
+
+        mutex_unlock(&ichan->chan_mutex);
+
+        tasklet_schedule(&to_ipu(to_idmac(chan->device))->tasklet);
+
+        return txd;
+}
+
+/* Re-select the current buffer and re-activate the channel */
+static void idmac_issue_pending(struct dma_chan *chan)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+        struct idmac *idmac = to_idmac(chan->device);
+        struct ipu *ipu = to_ipu(idmac);
+        unsigned long flags;
+
+        /* This is not always needed, but doesn't hurt either */
+        spin_lock_irqsave(&ipu->lock, flags);
+        ipu_select_buffer(ichan->dma_chan.chan_id, ichan->active_buffer);
+        spin_unlock_irqrestore(&ipu->lock, flags);
+
+        /*
+         * Might need to perform some parts of initialisation from
+         * ipu_enable_channel(), but not all, we do not want to reset to buffer
+         * 0, don't need to set priority again either, but re-enabling the task
+         * and the channel might be a good idea.
+         */
+}
+
+static void __idmac_terminate_all(struct dma_chan *chan)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+        struct idmac *idmac = to_idmac(chan->device);
+        unsigned long flags;
+        int i;
+
+        ipu_disable_channel(idmac, ichan,
+                            ichan->status >= IPU_CHANNEL_ENABLED);
+
+        tasklet_disable(&to_ipu(idmac)->tasklet);
+
+        /* ichan->queue is modified in ISR, have to spinlock */
+        spin_lock_irqsave(&ichan->lock, flags);
+        list_splice_init(&ichan->queue, &ichan->free_list);
+
+        if (ichan->desc)
+                for (i = 0; i < ichan->n_tx_desc; i++) {
+                        struct idmac_tx_desc *desc = ichan->desc + i;
+                        if (list_empty(&desc->list))
+                                /* Descriptor was prepared, but not submitted */
+                                list_add(&desc->list,
+                                         &ichan->free_list);
+
+                        async_tx_clear_ack(&desc->txd);
+                }
+
+        ichan->sg[0] = NULL;
+        ichan->sg[1] = NULL;
+        spin_unlock_irqrestore(&ichan->lock, flags);
+
+        tasklet_enable(&to_ipu(idmac)->tasklet);
+
+        ichan->status = IPU_CHANNEL_INITIALIZED;
+}
+
+static void idmac_terminate_all(struct dma_chan *chan)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+
+        mutex_lock(&ichan->chan_mutex);
+
+        __idmac_terminate_all(chan);
+
+        mutex_unlock(&ichan->chan_mutex);
+}
+
+static int idmac_alloc_chan_resources(struct dma_chan *chan)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+        struct idmac *idmac = to_idmac(chan->device);
+        int ret;
+
+        /* dmaengine.c now guarantees to only offer free channels */
+        BUG_ON(chan->client_count > 1);
+        WARN_ON(ichan->status != IPU_CHANNEL_FREE);
+
+        chan->cookie            = 1;
+        ichan->completed        = -ENXIO;
+
+        ret = ipu_irq_map(ichan->dma_chan.chan_id);
+        if (ret < 0)
+                goto eimap;
+
+        ichan->eof_irq = ret;
+        ret = request_irq(ichan->eof_irq, idmac_interrupt, 0,
+                          ichan->eof_name, ichan);
+        if (ret < 0)
+                goto erirq;
+
+        ret = ipu_init_channel(idmac, ichan);
+        if (ret < 0)
+                goto eichan;
+
+        ichan->status = IPU_CHANNEL_INITIALIZED;
+
+        dev_dbg(&ichan->dma_chan.dev->device, "Found channel 0x%x, irq %d\n",
+                ichan->dma_chan.chan_id, ichan->eof_irq);
+
+        return ret;
+
+eichan:
+        free_irq(ichan->eof_irq, ichan);
+erirq:
+        ipu_irq_unmap(ichan->dma_chan.chan_id);
+eimap:
+        return ret;
+}
+
+static void idmac_free_chan_resources(struct dma_chan *chan)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+        struct idmac *idmac = to_idmac(chan->device);
+
+        mutex_lock(&ichan->chan_mutex);
+
+        __idmac_terminate_all(chan);
+
+        if (ichan->status > IPU_CHANNEL_FREE) {
+                free_irq(ichan->eof_irq, ichan);
+                ipu_irq_unmap(ichan->dma_chan.chan_id);
+        }
+
+        ichan->status = IPU_CHANNEL_FREE;
+
+        ipu_uninit_channel(idmac, ichan);
+
+        mutex_unlock(&ichan->chan_mutex);
+
+        tasklet_schedule(&to_ipu(idmac)->tasklet);
+}
+
+static enum dma_status idmac_is_tx_complete(struct dma_chan *chan,
+                dma_cookie_t cookie, dma_cookie_t *done, dma_cookie_t *used)
+{
+        struct idmac_channel *ichan = to_idmac_chan(chan);
+
+        if (done)
+                *done = ichan->completed;
+        if (used)
+                *used = chan->cookie;
+        if (cookie != chan->cookie)
+                return DMA_ERROR;
+        return DMA_SUCCESS;
+}
+
+static int __init ipu_idmac_init(struct ipu *ipu)
+{
+        struct idmac *idmac = &ipu->idmac;
+        struct dma_device *dma = &idmac->dma;
+        int i;
+
+        dma_cap_set(DMA_SLAVE, dma->cap_mask);
+        dma_cap_set(DMA_PRIVATE, dma->cap_mask);
+
+        /* Compulsory common fields */
+        dma->dev                                = ipu->dev;
+        dma->device_alloc_chan_resources        = idmac_alloc_chan_resources;
+        dma->device_free_chan_resources         = idmac_free_chan_resources;
+        dma->device_is_tx_complete              = idmac_is_tx_complete;
+        dma->device_issue_pending               = idmac_issue_pending;
+
+        /* Compulsory for DMA_SLAVE fields */
+        dma->device_prep_slave_sg               = idmac_prep_slave_sg;
+        dma->device_terminate_all               = idmac_terminate_all;
+
+        INIT_LIST_HEAD(&dma->channels);
+        for (i = 0; i < IPU_CHANNELS_NUM; i++) {
+                struct idmac_channel *ichan = ipu->channel + i;
+                struct dma_chan *dma_chan = &ichan->dma_chan;
+
+                spin_lock_init(&ichan->lock);
+                mutex_init(&ichan->chan_mutex);
+
+                ichan->status           = IPU_CHANNEL_FREE;
+                ichan->sec_chan_en      = false;
+                ichan->completed        = -ENXIO;
+                snprintf(ichan->eof_name, sizeof(ichan->eof_name), "IDMAC EOF %d", i);
+
+                dma_chan->device        = &idmac->dma;
+                dma_chan->cookie        = 1;
+                dma_chan->chan_id       = i;
+                list_add_tail(&ichan->dma_chan.device_node, &dma->channels);
+        }
+
+        idmac_write_icreg(ipu, 0x00000070, IDMAC_CONF);
+
+        return dma_async_device_register(&idmac->dma);
+}
+
+static void ipu_idmac_exit(struct ipu *ipu)
+{
+        int i;
+        struct idmac *idmac = &ipu->idmac;
+
+        for (i = 0; i < IPU_CHANNELS_NUM; i++) {
+                struct idmac_channel *ichan = ipu->channel + i;
+
+                idmac_terminate_all(&ichan->dma_chan);
+                idmac_prep_slave_sg(&ichan->dma_chan, NULL, 0, DMA_NONE, 0);
+        }
+
+        dma_async_device_unregister(&idmac->dma);
+}
+
+/*****************************************************************************
+ * IPU common probe / remove
+ */
+
+static int ipu_probe(struct platform_device *pdev)
+{
+        struct ipu_platform_data *pdata = pdev->dev.platform_data;
+        struct resource *mem_ipu, *mem_ic;
+        int ret;
+
+        spin_lock_init(&ipu_data.lock);
+
+        mem_ipu = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        mem_ic  = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!pdata || !mem_ipu || !mem_ic)
+                return -EINVAL;
+
+        ipu_data.dev = &pdev->dev;
+
+        platform_set_drvdata(pdev, &ipu_data);
+
+        ret = platform_get_irq(pdev, 0);
+        if (ret < 0)
+                goto err_noirq;
+
+        ipu_data.irq_fn = ret;
+        ret = platform_get_irq(pdev, 1);
+        if (ret < 0)
+                goto err_noirq;
+
+        ipu_data.irq_err = ret;
+        ipu_data.irq_base = pdata->irq_base;
+
+        dev_dbg(&pdev->dev, "fn irq %u, err irq %u, irq-base %u\n",
+                ipu_data.irq_fn, ipu_data.irq_err, ipu_data.irq_base);
+
+        /* Remap IPU common registers */
+        ipu_data.reg_ipu = ioremap(mem_ipu->start,
+                                   mem_ipu->end - mem_ipu->start + 1);
+        if (!ipu_data.reg_ipu) {
+                ret = -ENOMEM;
+                goto err_ioremap_ipu;
+        }
+
+        /* Remap Image Converter and Image DMA Controller registers */
+        ipu_data.reg_ic = ioremap(mem_ic->start,
+                                  mem_ic->end - mem_ic->start + 1);
+        if (!ipu_data.reg_ic) {
+                ret = -ENOMEM;
+                goto err_ioremap_ic;
+        }
+
+        /* Get IPU clock */
+        ipu_data.ipu_clk = clk_get(&pdev->dev, "ipu_clk");
+        if (IS_ERR(ipu_data.ipu_clk)) {
+                ret = PTR_ERR(ipu_data.ipu_clk);
+                goto err_clk_get;
+        }
+
+        /* Make sure IPU HSP clock is running */
+        clk_enable(ipu_data.ipu_clk);
+
+        /* Disable all interrupts */
+        idmac_write_ipureg(&ipu_data, 0, IPU_INT_CTRL_1);
+        idmac_write_ipureg(&ipu_data, 0, IPU_INT_CTRL_2);
+        idmac_write_ipureg(&ipu_data, 0, IPU_INT_CTRL_3);
+        idmac_write_ipureg(&ipu_data, 0, IPU_INT_CTRL_4);
+        idmac_write_ipureg(&ipu_data, 0, IPU_INT_CTRL_5);
+
+        dev_dbg(&pdev->dev, "%s @ 0x%08lx, fn irq %u, err irq %u\n", pdev->name,
+                (unsigned long)mem_ipu->start, ipu_data.irq_fn, ipu_data.irq_err);
+
+        ret = ipu_irq_attach_irq(&ipu_data, pdev);
+        if (ret < 0)
+                goto err_attach_irq;
+
+        /* Initialize DMA engine */
+        ret = ipu_idmac_init(&ipu_data);
+        if (ret < 0)
+                goto err_idmac_init;
+
+        tasklet_init(&ipu_data.tasklet, ipu_gc_tasklet, (unsigned long)&ipu_data);
+
+        ipu_data.dev = &pdev->dev;
+
+        dev_dbg(ipu_data.dev, "IPU initialized\n");
+
+        return 0;
+
+err_idmac_init:
+err_attach_irq:
+        ipu_irq_detach_irq(&ipu_data, pdev);
+        clk_disable(ipu_data.ipu_clk);
+        clk_put(ipu_data.ipu_clk);
+err_clk_get:
+        iounmap(ipu_data.reg_ic);
+err_ioremap_ic:
+        iounmap(ipu_data.reg_ipu);
+err_ioremap_ipu:
+err_noirq:
+        dev_err(&pdev->dev, "Failed to probe IPU: %d\n", ret);
+        return ret;
+}
+
+static int ipu_remove(struct platform_device *pdev)
+{
+        struct ipu *ipu = platform_get_drvdata(pdev);
+
+        ipu_idmac_exit(ipu);
+        ipu_irq_detach_irq(ipu, pdev);
+        clk_disable(ipu->ipu_clk);
+        clk_put(ipu->ipu_clk);
+        iounmap(ipu->reg_ic);
+        iounmap(ipu->reg_ipu);
+        tasklet_kill(&ipu->tasklet);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+/*
+ * We need two MEM resources - with IPU-common and Image Converter registers,
+ * including PF_CONF and IDMAC_* registers, and two IRQs - function and error
+ */
+static struct platform_driver ipu_platform_driver = {
+        .driver = {
+                .name   = "ipu-core",
+                .owner  = THIS_MODULE,
+        },
+        .remove         = ipu_remove,
+};
+
+static int __init ipu_init(void)
+{
+        return platform_driver_probe(&ipu_platform_driver, ipu_probe);
+}
+subsys_initcall(ipu_init);
+
+MODULE_DESCRIPTION("IPU core driver");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Guennadi Liakhovetski <lg@denx.de>");
+MODULE_ALIAS("platform:ipu-core");
diff --git a/drivers/dma/ipu/ipu_intern.h b/drivers/dma/ipu/ipu_intern.h
new file mode 100644
index 000000000000..545cf11a94ab
--- /dev/null
+++ b/drivers/dma/ipu/ipu_intern.h
@@ -0,0 +1,176 @@
+/*
+ * Copyright (C) 2008
+ * Guennadi Liakhovetski, DENX Software Engineering, <lg@denx.de>
+ *
+ * Copyright (C) 2005-2007 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _IPU_INTERN_H_
+#define _IPU_INTERN_H_
+
+#include <linux/dmaengine.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+
+/* IPU Common registers */
+#define IPU_CONF                0x00
+#define IPU_CHA_BUF0_RDY        0x04
+#define IPU_CHA_BUF1_RDY        0x08
+#define IPU_CHA_DB_MODE_SEL     0x0C
+#define IPU_CHA_CUR_BUF         0x10
+#define IPU_FS_PROC_FLOW        0x14
+#define IPU_FS_DISP_FLOW        0x18
+#define IPU_TASKS_STAT          0x1C
+#define IPU_IMA_ADDR            0x20
+#define IPU_IMA_DATA            0x24
+#define IPU_INT_CTRL_1          0x28
+#define IPU_INT_CTRL_2          0x2C
+#define IPU_INT_CTRL_3          0x30
+#define IPU_INT_CTRL_4          0x34
+#define IPU_INT_CTRL_5          0x38
+#define IPU_INT_STAT_1          0x3C
+#define IPU_INT_STAT_2          0x40
+#define IPU_INT_STAT_3          0x44
+#define IPU_INT_STAT_4          0x48
+#define IPU_INT_STAT_5          0x4C
+#define IPU_BRK_CTRL_1          0x50
+#define IPU_BRK_CTRL_2          0x54
+#define IPU_BRK_STAT            0x58
+#define IPU_DIAGB_CTRL          0x5C
+
+/* IPU_CONF Register bits */
+#define IPU_CONF_CSI_EN         0x00000001
+#define IPU_CONF_IC_EN          0x00000002
+#define IPU_CONF_ROT_EN         0x00000004
+#define IPU_CONF_PF_EN          0x00000008
+#define IPU_CONF_SDC_EN         0x00000010
+#define IPU_CONF_ADC_EN         0x00000020
+#define IPU_CONF_DI_EN          0x00000040
+#define IPU_CONF_DU_EN          0x00000080
+#define IPU_CONF_PXL_ENDIAN     0x00000100
+
+/* Image Converter Registers */
+#define IC_CONF                 0x88
+#define IC_PRP_ENC_RSC          0x8C
+#define IC_PRP_VF_RSC           0x90
+#define IC_PP_RSC               0x94
+#define IC_CMBP_1               0x98
+#define IC_CMBP_2               0x9C
+#define PF_CONF                 0xA0
+#define IDMAC_CONF              0xA4
+#define IDMAC_CHA_EN            0xA8
+#define IDMAC_CHA_PRI           0xAC
+#define IDMAC_CHA_BUSY          0xB0
+
+/* Image Converter Register bits */
+#define IC_CONF_PRPENC_EN       0x00000001
+#define IC_CONF_PRPENC_CSC1     0x00000002
+#define IC_CONF_PRPENC_ROT_EN   0x00000004
+#define IC_CONF_PRPVF_EN        0x00000100
+#define IC_CONF_PRPVF_CSC1      0x00000200
+#define IC_CONF_PRPVF_CSC2      0x00000400
+#define IC_CONF_PRPVF_CMB       0x00000800
+#define IC_CONF_PRPVF_ROT_EN    0x00001000
+#define IC_CONF_PP_EN           0x00010000
+#define IC_CONF_PP_CSC1         0x00020000
+#define IC_CONF_PP_CSC2         0x00040000
+#define IC_CONF_PP_CMB          0x00080000
+#define IC_CONF_PP_ROT_EN       0x00100000
+#define IC_CONF_IC_GLB_LOC_A    0x10000000
+#define IC_CONF_KEY_COLOR_EN    0x20000000
+#define IC_CONF_RWS_EN          0x40000000
+#define IC_CONF_CSI_MEM_WR_EN   0x80000000
+
+#define IDMA_CHAN_INVALID       0x000000FF
+#define IDMA_IC_0               0x00000001
+#define IDMA_IC_1               0x00000002
+#define IDMA_IC_2               0x00000004
+#define IDMA_IC_3               0x00000008
+#define IDMA_IC_4               0x00000010
+#define IDMA_IC_5               0x00000020
+#define IDMA_IC_6               0x00000040
+#define IDMA_IC_7               0x00000080
+#define IDMA_IC_8               0x00000100
+#define IDMA_IC_9               0x00000200
+#define IDMA_IC_10              0x00000400
+#define IDMA_IC_11              0x00000800
+#define IDMA_IC_12              0x00001000
+#define IDMA_IC_13              0x00002000
+#define IDMA_SDC_BG             0x00004000
+#define IDMA_SDC_FG             0x00008000
+#define IDMA_SDC_MASK           0x00010000
+#define IDMA_SDC_PARTIAL        0x00020000
+#define IDMA_ADC_SYS1_WR        0x00040000
+#define IDMA_ADC_SYS2_WR        0x00080000
+#define IDMA_ADC_SYS1_CMD       0x00100000
+#define IDMA_ADC_SYS2_CMD       0x00200000
+#define IDMA_ADC_SYS1_RD        0x00400000
+#define IDMA_ADC_SYS2_RD        0x00800000
+#define IDMA_PF_QP              0x01000000
+#define IDMA_PF_BSP             0x02000000
+#define IDMA_PF_Y_IN            0x04000000
+#define IDMA_PF_U_IN            0x08000000
+#define IDMA_PF_V_IN            0x10000000
+#define IDMA_PF_Y_OUT           0x20000000
+#define IDMA_PF_U_OUT           0x40000000
+#define IDMA_PF_V_OUT           0x80000000
+
+#define TSTAT_PF_H264_PAUSE     0x00000001
+#define TSTAT_CSI2MEM_MASK      0x0000000C
+#define TSTAT_CSI2MEM_OFFSET    2
+#define TSTAT_VF_MASK           0x00000600
+#define TSTAT_VF_OFFSET         9
+#define TSTAT_VF_ROT_MASK       0x000C0000
+#define TSTAT_VF_ROT_OFFSET     18
+#define TSTAT_ENC_MASK          0x00000180
+#define TSTAT_ENC_OFFSET        7
+#define TSTAT_ENC_ROT_MASK      0x00030000
+#define TSTAT_ENC_ROT_OFFSET    16
+#define TSTAT_PP_MASK           0x00001800
+#define TSTAT_PP_OFFSET         11
+#define TSTAT_PP_ROT_MASK       0x00300000
+#define TSTAT_PP_ROT_OFFSET     20
+#define TSTAT_PF_MASK           0x00C00000
+#define TSTAT_PF_OFFSET         22
+#define TSTAT_ADCSYS1_MASK      0x03000000
+#define TSTAT_ADCSYS1_OFFSET    24
+#define TSTAT_ADCSYS2_MASK      0x0C000000
+#define TSTAT_ADCSYS2_OFFSET    26
+
+#define TASK_STAT_IDLE          0
+#define TASK_STAT_ACTIVE        1
+#define TASK_STAT_WAIT4READY    2
+
+struct idmac {
+        struct dma_device       dma;
+};
+
+struct ipu {
+        void __iomem            *reg_ipu;
+        void __iomem            *reg_ic;
+        unsigned int            irq_fn;         /* IPU Function IRQ to the CPU */
+        unsigned int            irq_err;        /* IPU Error IRQ to the CPU */
+        unsigned int            irq_base;       /* Beginning of the IPU IRQ range */
+        unsigned long           channel_init_mask;
+        spinlock_t              lock;
+        struct clk              *ipu_clk;
+        struct device           *dev;
+        struct idmac            idmac;
+        struct idmac_channel    channel[IPU_CHANNELS_NUM];
+        struct tasklet_struct   tasklet;
+};
+
+#define to_idmac(d) container_of(d, struct idmac, dma)
+
+extern int ipu_irq_attach_irq(struct ipu *ipu, struct platform_device *dev);
+extern void ipu_irq_detach_irq(struct ipu *ipu, struct platform_device *dev);
+
+extern bool ipu_irq_status(uint32_t irq);
+extern int ipu_irq_map(unsigned int source);
+extern int ipu_irq_unmap(unsigned int source);
+
+#endif
diff --git a/drivers/dma/ipu/ipu_irq.c b/drivers/dma/ipu/ipu_irq.c
new file mode 100644
index 000000000000..83f532cc767f
--- /dev/null
+++ b/drivers/dma/ipu/ipu_irq.c
@@ -0,0 +1,413 @@
+/*
+ * Copyright (C) 2008
+ * Guennadi Liakhovetski, DENX Software Engineering, <lg@denx.de>
+ *
+ * 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/err.h>
+#include <linux/spinlock.h>
+#include <linux/delay.h>
+#include <linux/clk.h>
+#include <linux/irq.h>
+#include <linux/io.h>
+
+#include <mach/ipu.h>
+
+#include "ipu_intern.h"
+
+/*
+ * Register read / write - shall be inlined by the compiler
+ */
+static u32 ipu_read_reg(struct ipu *ipu, unsigned long reg)
+{
+        return __raw_readl(ipu->reg_ipu + reg);
+}
+
+static void ipu_write_reg(struct ipu *ipu, u32 value, unsigned long reg)
+{
+        __raw_writel(value, ipu->reg_ipu + reg);
+}
+
+
+/*
+ * IPU IRQ chip driver
+ */
+
+#define IPU_IRQ_NR_FN_BANKS 3
+#define IPU_IRQ_NR_ERR_BANKS 2
+#define IPU_IRQ_NR_BANKS (IPU_IRQ_NR_FN_BANKS + IPU_IRQ_NR_ERR_BANKS)
+
+struct ipu_irq_bank {
+        unsigned int    control;
+        unsigned int    status;
+        spinlock_t      lock;
+        struct ipu      *ipu;
+};
+
+static struct ipu_irq_bank irq_bank[IPU_IRQ_NR_BANKS] = {
+        /* 3 groups of functional interrupts */
+        {
+                .control        = IPU_INT_CTRL_1,
+                .status         = IPU_INT_STAT_1,
+        }, {
+                .control        = IPU_INT_CTRL_2,
+                .status         = IPU_INT_STAT_2,
+        }, {
+                .control        = IPU_INT_CTRL_3,
+                .status         = IPU_INT_STAT_3,
+        },
+        /* 2 groups of error interrupts */
+        {
+                .control        = IPU_INT_CTRL_4,
+                .status         = IPU_INT_STAT_4,
+        }, {
+                .control        = IPU_INT_CTRL_5,
+                .status         = IPU_INT_STAT_5,
+        },
+};
+
+struct ipu_irq_map {
+        unsigned int            irq;
+        int                     source;
+        struct ipu_irq_bank     *bank;
+        struct ipu              *ipu;
+};
+
+static struct ipu_irq_map irq_map[CONFIG_MX3_IPU_IRQS];
+/* Protects allocations from the above array of maps */
+static DEFINE_MUTEX(map_lock);
+/* Protects register accesses and individual mappings */
+static DEFINE_SPINLOCK(bank_lock);
+
+static struct ipu_irq_map *src2map(unsigned int src)
+{
+        int i;
+
+        for (i = 0; i < CONFIG_MX3_IPU_IRQS; i++)
+                if (irq_map[i].source == src)
+                        return irq_map + i;
+
+        return NULL;
+}
+
+static void ipu_irq_unmask(unsigned int irq)
+{
+        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_bank *bank;
+        uint32_t reg;
+        unsigned long lock_flags;
+
+        spin_lock_irqsave(&bank_lock, lock_flags);
+
+        bank = map->bank;
+        if (!bank) {
+                spin_unlock_irqrestore(&bank_lock, lock_flags);
+                pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+                return;
+        }
+
+        reg = ipu_read_reg(bank->ipu, bank->control);
+        reg |= (1UL << (map->source & 31));
+        ipu_write_reg(bank->ipu, reg, bank->control);
+
+        spin_unlock_irqrestore(&bank_lock, lock_flags);
+}
+
+static void ipu_irq_mask(unsigned int irq)
+{
+        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_bank *bank;
+        uint32_t reg;
+        unsigned long lock_flags;
+
+        spin_lock_irqsave(&bank_lock, lock_flags);
+
+        bank = map->bank;
+        if (!bank) {
+                spin_unlock_irqrestore(&bank_lock, lock_flags);
+                pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+                return;
+        }
+
+        reg = ipu_read_reg(bank->ipu, bank->control);
+        reg &= ~(1UL << (map->source & 31));
+        ipu_write_reg(bank->ipu, reg, bank->control);
+
+        spin_unlock_irqrestore(&bank_lock, lock_flags);
+}
+
+static void ipu_irq_ack(unsigned int irq)
+{
+        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_bank *bank;
+        unsigned long lock_flags;
+
+        spin_lock_irqsave(&bank_lock, lock_flags);
+
+        bank = map->bank;
+        if (!bank) {
+                spin_unlock_irqrestore(&bank_lock, lock_flags);
+                pr_err("IPU: %s(%u) - unmapped!\n", __func__, irq);
+                return;
+        }
+
+        ipu_write_reg(bank->ipu, 1UL << (map->source & 31), bank->status);
+        spin_unlock_irqrestore(&bank_lock, lock_flags);
+}
+
+/**
+ * ipu_irq_status() - returns the current interrupt status of the specified IRQ.
+ * @irq:        interrupt line to get status for.
+ * @return:     true if the interrupt is pending/asserted or false if the
+ *              interrupt is not pending.
+ */
+bool ipu_irq_status(unsigned int irq)
+{
+        struct ipu_irq_map *map = get_irq_chip_data(irq);
+        struct ipu_irq_bank *bank;
+        unsigned long lock_flags;
+        bool ret;
+
+        spin_lock_irqsave(&bank_lock, lock_flags);
+        bank = map->bank;
+        ret = bank && ipu_read_reg(bank->ipu, bank->status) &
+                (1UL << (map->source & 31));
+        spin_unlock_irqrestore(&bank_lock, lock_flags);
+
+        return ret;
+}
+
+/**
+ * ipu_irq_map() - map an IPU interrupt source to an IRQ number
+ * @source:     interrupt source bit position (see below)
+ * @return:     mapped IRQ number or negative error code
+ *
+ * The source parameter has to be explained further. On i.MX31 IPU has 137 IRQ
+ * sources, they are broken down in 5 32-bit registers, like 32, 32, 24, 32, 17.
+ * However, the source argument of this function is not the sequence number of
+ * the possible IRQ, but rather its bit position. So, first interrupt in fourth
+ * register has source number 96, and not 88. This makes calculations easier,
+ * and also provides forward compatibility with any future IPU implementations
+ * with any interrupt bit assignments.
+ */
+int ipu_irq_map(unsigned int source)
+{
+        int i, ret = -ENOMEM;
+        struct ipu_irq_map *map;
+
+        might_sleep();
+
+        mutex_lock(&map_lock);
+        map = src2map(source);
+        if (map) {
+                pr_err("IPU: Source %u already mapped to IRQ %u\n", source, map->irq);
+                ret = -EBUSY;
+                goto out;
+        }
+
+        for (i = 0; i < CONFIG_MX3_IPU_IRQS; i++) {
+                if (irq_map[i].source < 0) {
+                        unsigned long lock_flags;
+
+                        spin_lock_irqsave(&bank_lock, lock_flags);
+                        irq_map[i].source = source;
+                        irq_map[i].bank = irq_bank + source / 32;
+                        spin_unlock_irqrestore(&bank_lock, lock_flags);
+
+                        ret = irq_map[i].irq;
+                        pr_debug("IPU: mapped source %u to IRQ %u\n",
+                                 source, ret);
+                        break;
+                }
+        }
+out:
+        mutex_unlock(&map_lock);
+
+        if (ret < 0)
+                pr_err("IPU: couldn't map source %u: %d\n", source, ret);
+
+        return ret;
+}
+
+/**
+ * ipu_irq_map() - map an IPU interrupt source to an IRQ number
+ * @source:     interrupt source bit position (see ipu_irq_map())
+ * @return:     0 or negative error code
+ */
+int ipu_irq_unmap(unsigned int source)
+{
+        int i, ret = -EINVAL;
+
+        might_sleep();
+
+        mutex_lock(&map_lock);
+        for (i = 0; i < CONFIG_MX3_IPU_IRQS; i++) {
+                if (irq_map[i].source == source) {
+                        unsigned long lock_flags;
+
+                        pr_debug("IPU: unmapped source %u from IRQ %u\n",
+                                 source, irq_map[i].irq);
+
+                        spin_lock_irqsave(&bank_lock, lock_flags);
+                        irq_map[i].source = -EINVAL;
+                        irq_map[i].bank = NULL;
+                        spin_unlock_irqrestore(&bank_lock, lock_flags);
+
+                        ret = 0;
+                        break;
+                }
+        }
+        mutex_unlock(&map_lock);
+
+        return ret;
+}
+
+/* Chained IRQ handler for IPU error interrupt */
+static void ipu_irq_err(unsigned int irq, struct irq_desc *desc)
+{
+        struct ipu *ipu = get_irq_data(irq);
+        u32 status;
+        int i, line;
+
+        for (i = IPU_IRQ_NR_FN_BANKS; i < IPU_IRQ_NR_BANKS; i++) {
+                struct ipu_irq_bank *bank = irq_bank + i;
+
+                spin_lock(&bank_lock);
+                status = ipu_read_reg(ipu, bank->status);
+                /*
+                 * Don't think we have to clear all interrupts here, they will
+                 * be acked by ->handle_irq() (handle_level_irq). However, we
+                 * might want to clear unhandled interrupts after the loop...
+                 */
+                status &= ipu_read_reg(ipu, bank->control);
+                spin_unlock(&bank_lock);
+                while ((line = ffs(status))) {
+                        struct ipu_irq_map *map;
+
+                        line--;
+                        status &= ~(1UL << line);
+
+                        spin_lock(&bank_lock);
+                        map = src2map(32 * i + line);
+                        if (map)
+                                irq = map->irq;
+                        spin_unlock(&bank_lock);
+
+                        if (!map) {
+                                pr_err("IPU: Interrupt on unmapped source %u bank %d\n",
+                                       line, i);
+                                continue;
+                        }
+                        generic_handle_irq(irq);
+                }
+        }
+}
+
+/* Chained IRQ handler for IPU function interrupt */
+static void ipu_irq_fn(unsigned int irq, struct irq_desc *desc)
+{
+        struct ipu *ipu = get_irq_data(irq);
+        u32 status;
+        int i, line;
+
+        for (i = 0; i < IPU_IRQ_NR_FN_BANKS; i++) {
+                struct ipu_irq_bank *bank = irq_bank + i;
+
+                spin_lock(&bank_lock);
+                status = ipu_read_reg(ipu, bank->status);
+                /* Not clearing all interrupts, see above */
+                status &= ipu_read_reg(ipu, bank->control);
+                spin_unlock(&bank_lock);
+                while ((line = ffs(status))) {
+                        struct ipu_irq_map *map;
+
+                        line--;
+                        status &= ~(1UL << line);
+
+                        spin_lock(&bank_lock);
+                        map = src2map(32 * i + line);
+                        if (map)
+                                irq = map->irq;
+                        spin_unlock(&bank_lock);
+
+                        if (!map) {
+                                pr_err("IPU: Interrupt on unmapped source %u bank %d\n",
+                                       line, i);
+                                continue;
+                        }
+                        generic_handle_irq(irq);
+                }
+        }
+}
+
+static struct irq_chip ipu_irq_chip = {
+        .name   = "ipu_irq",
+        .ack    = ipu_irq_ack,
+        .mask   = ipu_irq_mask,
+        .unmask = ipu_irq_unmask,
+};
+
+/* Install the IRQ handler */
+int ipu_irq_attach_irq(struct ipu *ipu, struct platform_device *dev)
+{
+        struct ipu_platform_data *pdata = dev->dev.platform_data;
+        unsigned int irq, irq_base, i;
+
+        irq_base = pdata->irq_base;
+
+        for (i = 0; i < IPU_IRQ_NR_BANKS; i++)
+                irq_bank[i].ipu = ipu;
+
+        for (i = 0; i < CONFIG_MX3_IPU_IRQS; i++) {
+                int ret;
+
+                irq = irq_base + i;
+                ret = set_irq_chip(irq, &ipu_irq_chip);
+                if (ret < 0)
+                        return ret;
+                ret = set_irq_chip_data(irq, irq_map + i);
+                if (ret < 0)
+                        return ret;
+                irq_map[i].ipu = ipu;
+                irq_map[i].irq = irq;
+                irq_map[i].source = -EINVAL;
+                set_irq_handler(irq, handle_level_irq);
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
+#endif
+        }
+
+        set_irq_data(ipu->irq_fn, ipu);
+        set_irq_chained_handler(ipu->irq_fn, ipu_irq_fn);
+
+        set_irq_data(ipu->irq_err, ipu);
+        set_irq_chained_handler(ipu->irq_err, ipu_irq_err);
+
+        return 0;
+}
+
+void ipu_irq_detach_irq(struct ipu *ipu, struct platform_device *dev)
+{
+        struct ipu_platform_data *pdata = dev->dev.platform_data;
+        unsigned int irq, irq_base;
+
+        irq_base = pdata->irq_base;
+
+        set_irq_chained_handler(ipu->irq_fn, NULL);
+        set_irq_data(ipu->irq_fn, NULL);
+
+        set_irq_chained_handler(ipu->irq_err, NULL);
+        set_irq_data(ipu->irq_err, NULL);
+
+        for (irq = irq_base; irq < irq_base + CONFIG_MX3_IPU_IRQS; irq++) {
+#ifdef CONFIG_ARM
+                set_irq_flags(irq, 0);
+#endif
+                set_irq_chip(irq, NULL);
+                set_irq_chip_data(irq, NULL);
+        }
+}
diff --git a/drivers/firmware/dell_rbu.c b/drivers/firmware/dell_rbu.c
index 13946ebd77d6..b4704e150b28 100644
--- a/drivers/firmware/dell_rbu.c
+++ b/drivers/firmware/dell_rbu.c
@@ -576,7 +576,7 @@ static ssize_t read_rbu_image_type(struct kobject *kobj,
 {
         int size = 0;
         if (!pos)
-                size = sprintf(buffer, "%s\n", image_type);
+                size = scnprintf(buffer, count, "%s\n", image_type);
         return size;
 }
 
@@ -648,7 +648,7 @@ static ssize_t read_rbu_packet_size(struct kobject *kobj,
         int size = 0;
         if (!pos) {
                 spin_lock(&rbu_data.lock);
-                size = sprintf(buffer, "%lu\n", rbu_data.packetsize);
+                size = scnprintf(buffer, count, "%lu\n", rbu_data.packetsize);
                 spin_unlock(&rbu_data.lock);
         }
         return size;
diff --git a/drivers/gpio/max7301.c b/drivers/gpio/max7301.c
index 8b24d784db93..3e7f4e06386e 100644
--- a/drivers/gpio/max7301.c
+++ b/drivers/gpio/max7301.c
@@ -217,8 +217,10 @@ static int __devinit max7301_probe(struct spi_device *spi)
         int i, ret;
 
         pdata = spi->dev.platform_data;
-        if (!pdata || !pdata->base)
-                return -ENODEV;
+        if (!pdata || !pdata->base) {
+                dev_dbg(&spi->dev, "incorrect or missing platform data\n");
+                return -EINVAL;
+        }
 
         /*
          * bits_per_word cannot be configured in platform data
diff --git a/drivers/gpio/max732x.c b/drivers/gpio/max732x.c
index 55ae9a41897a..f7868243af89 100644
--- a/drivers/gpio/max732x.c
+++ b/drivers/gpio/max732x.c
@@ -267,8 +267,10 @@ static int __devinit max732x_probe(struct i2c_client *client,
         int ret, nr_port;
 
         pdata = client->dev.platform_data;
-        if (pdata == NULL)
-                return -ENODEV;
+        if (pdata == NULL) {
+                dev_dbg(&client->dev, "no platform data\n");
+                return -EINVAL;
+        }
 
         chip = kzalloc(sizeof(struct max732x_chip), GFP_KERNEL);
         if (chip == NULL)
diff --git a/drivers/gpio/mcp23s08.c b/drivers/gpio/mcp23s08.c
index 89c1d222e9d1..f6fae0e50e65 100644
--- a/drivers/gpio/mcp23s08.c
+++ b/drivers/gpio/mcp23s08.c
@@ -310,8 +310,10 @@ static int mcp23s08_probe(struct spi_device *spi)
         unsigned                        base;
 
         pdata = spi->dev.platform_data;
-        if (!pdata || !gpio_is_valid(pdata->base))
-                return -ENODEV;
+        if (!pdata || !gpio_is_valid(pdata->base)) {
+                dev_dbg(&spi->dev, "invalid or missing platform data\n");
+                return -EINVAL;
+        }
 
         for (addr = 0; addr < 4; addr++) {
                 if (!pdata->chip[addr].is_present)
diff --git a/drivers/gpio/pca953x.c b/drivers/gpio/pca953x.c
index 37f35388a2ae..8dc0164bd51e 100644
--- a/drivers/gpio/pca953x.c
+++ b/drivers/gpio/pca953x.c
@@ -202,8 +202,10 @@ static int __devinit pca953x_probe(struct i2c_client *client,
         int ret;
 
         pdata = client->dev.platform_data;
-        if (pdata == NULL)
-                return -ENODEV;
+        if (pdata == NULL) {
+                dev_dbg(&client->dev, "no platform data\n");
+                return -EINVAL;
+        }
 
         chip = kzalloc(sizeof(struct pca953x_chip), GFP_KERNEL);
         if (chip == NULL)
diff --git a/drivers/gpio/pcf857x.c b/drivers/gpio/pcf857x.c
index 4bc2070dd4a1..9525724be731 100644
--- a/drivers/gpio/pcf857x.c
+++ b/drivers/gpio/pcf857x.c
@@ -188,8 +188,10 @@ static int pcf857x_probe(struct i2c_client *client,
         int                             status;
 
         pdata = client->dev.platform_data;
-        if (!pdata)
-                return -ENODEV;
+        if (!pdata) {
+                dev_dbg(&client->dev, "no platform data\n");
+                return -EINVAL;
+        }
 
         /* Allocate, initialize, and register this gpio_chip. */
         gpio = kzalloc(sizeof *gpio, GFP_KERNEL);
@@ -248,8 +250,10 @@ static int pcf857x_probe(struct i2c_client *client,
                 else
                         status = i2c_read_le16(client);
 
-        } else
-                status = -ENODEV;
+        } else {
+                dev_dbg(&client->dev, "unsupported number of gpios\n");
+                status = -EINVAL;
+        }
 
         if (status < 0)
                 goto fail;
diff --git a/drivers/gpu/drm/drm_agpsupport.c b/drivers/gpu/drm/drm_agpsupport.c
index 3d33b8252b58..14796594e5d9 100644
--- a/drivers/gpu/drm/drm_agpsupport.c
+++ b/drivers/gpu/drm/drm_agpsupport.c
@@ -33,10 +33,11 @@
 
 #include "drmP.h"
 #include <linux/module.h>
-#include <asm/agp.h>
 
 #if __OS_HAS_AGP
 
+#include <asm/agp.h>
+
 /**
  * Get AGP information.
  *
diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index 5b2cbb778162..bfce0992fefb 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -194,7 +194,6 @@ char *drm_get_connector_status_name(enum drm_connector_status status)
  * @type: object type
  *
  * LOCKING:
- * Caller must hold DRM mode_config lock.
  *
  * Create a unique identifier based on @ptr in @dev's identifier space.  Used
  * for tracking modes, CRTCs and connectors.
@@ -209,15 +208,15 @@ static int drm_mode_object_get(struct drm_device *dev,
         int new_id = 0;
         int ret;
 
-        WARN(!mutex_is_locked(&dev->mode_config.mutex),
-             "%s called w/o mode_config lock\n", __func__);
 again:
         if (idr_pre_get(&dev->mode_config.crtc_idr, GFP_KERNEL) == 0) {
                 DRM_ERROR("Ran out memory getting a mode number\n");
                 return -EINVAL;
         }
 
+        mutex_lock(&dev->mode_config.idr_mutex);
         ret = idr_get_new_above(&dev->mode_config.crtc_idr, obj, 1, &new_id);
+        mutex_unlock(&dev->mode_config.idr_mutex);
         if (ret == -EAGAIN)
                 goto again;
 
@@ -239,16 +238,20 @@ again:
 static void drm_mode_object_put(struct drm_device *dev,
                                 struct drm_mode_object *object)
 {
+        mutex_lock(&dev->mode_config.idr_mutex);
         idr_remove(&dev->mode_config.crtc_idr, object->id);
+        mutex_unlock(&dev->mode_config.idr_mutex);
 }
 
 void *drm_mode_object_find(struct drm_device *dev, uint32_t id, uint32_t type)
 {
-        struct drm_mode_object *obj;
+        struct drm_mode_object *obj = NULL;
 
+        mutex_lock(&dev->mode_config.idr_mutex);
         obj = idr_find(&dev->mode_config.crtc_idr, id);
         if (!obj || (obj->type != type) || (obj->id != id))
-                return NULL;
+                obj = NULL;
+        mutex_unlock(&dev->mode_config.idr_mutex);
 
         return obj;
 }
@@ -786,6 +789,7 @@ EXPORT_SYMBOL(drm_mode_create_dithering_property);
 void drm_mode_config_init(struct drm_device *dev)
 {
         mutex_init(&dev->mode_config.mutex);
+        mutex_init(&dev->mode_config.idr_mutex);
         INIT_LIST_HEAD(&dev->mode_config.fb_list);
         INIT_LIST_HEAD(&dev->mode_config.fb_kernel_list);
         INIT_LIST_HEAD(&dev->mode_config.crtc_list);
diff --git a/drivers/gpu/drm/drm_crtc_helper.c b/drivers/gpu/drm/drm_crtc_helper.c
index d8a982b71296..964c5eb1fada 100644
--- a/drivers/gpu/drm/drm_crtc_helper.c
+++ b/drivers/gpu/drm/drm_crtc_helper.c
@@ -36,7 +36,7 @@
 /*
  * Detailed mode info for 800x600@60Hz
  */
-static struct drm_display_mode std_mode[] = {
+static struct drm_display_mode std_modes[] = {
         { DRM_MODE("800x600", DRM_MODE_TYPE_DEFAULT, 40000, 800, 840,
                    968, 1056, 0, 600, 601, 605, 628, 0,
                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
@@ -60,15 +60,18 @@ static struct drm_display_mode std_mode[] = {
  * changes have occurred.
  *
  * FIXME: take into account monitor limits
+ *
+ * RETURNS:
+ * Number of modes found on @connector.
  */
-void drm_helper_probe_single_connector_modes(struct drm_connector *connector,
-                                             uint32_t maxX, uint32_t maxY)
+int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
+                                            uint32_t maxX, uint32_t maxY)
 {
         struct drm_device *dev = connector->dev;
         struct drm_display_mode *mode, *t;
         struct drm_connector_helper_funcs *connector_funcs =
                 connector->helper_private;
-        int ret;
+        int count = 0;
 
         DRM_DEBUG("%s\n", drm_get_connector_name(connector));
         /* set all modes to the unverified state */
@@ -81,14 +84,14 @@ void drm_helper_probe_single_connector_modes(struct drm_connector *connector,
                 DRM_DEBUG("%s is disconnected\n",
                           drm_get_connector_name(connector));
                 /* TODO set EDID to NULL */
-                return;
+                return 0;
         }
 
-        ret = (*connector_funcs->get_modes)(connector);
+        count = (*connector_funcs->get_modes)(connector);
+        if (!count)
+                return 0;
 
-        if (ret) {
-                drm_mode_connector_list_update(connector);
-        }
+        drm_mode_connector_list_update(connector);
 
         if (maxX && maxY)
                 drm_mode_validate_size(dev, &connector->modes, maxX,
@@ -102,25 +105,8 @@ void drm_helper_probe_single_connector_modes(struct drm_connector *connector,
 
         drm_mode_prune_invalid(dev, &connector->modes, true);
 
-        if (list_empty(&connector->modes)) {
-                struct drm_display_mode *stdmode;
-
-                DRM_DEBUG("No valid modes on %s\n",
-                          drm_get_connector_name(connector));
-
-                /* Should we do this here ???
-                 * When no valid EDID modes are available we end up
-                 * here and bailed in the past, now we add a standard
-                 * 640x480@60Hz mode and carry on.
-                 */
-                stdmode = drm_mode_duplicate(dev, &std_mode[0]);
-                drm_mode_probed_add(connector, stdmode);
-                drm_mode_list_concat(&connector->probed_modes,
-                                     &connector->modes);
-
-                DRM_DEBUG("Adding standard 640x480 @ 60Hz to %s\n",
-                          drm_get_connector_name(connector));
-        }
+        if (list_empty(&connector->modes))
+                return 0;
 
         drm_mode_sort(&connector->modes);
 
@@ -131,20 +117,58 @@ void drm_helper_probe_single_connector_modes(struct drm_connector *connector,
                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
                 drm_mode_debug_printmodeline(mode);
         }
+
+        return count;
 }
 EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
 
-void drm_helper_probe_connector_modes(struct drm_device *dev, uint32_t maxX,
+int drm_helper_probe_connector_modes(struct drm_device *dev, uint32_t maxX,
                                       uint32_t maxY)
 {
         struct drm_connector *connector;
+        int count = 0;
 
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
-                drm_helper_probe_single_connector_modes(connector, maxX, maxY);
+                count += drm_helper_probe_single_connector_modes(connector,
+                                                                 maxX, maxY);
         }
+
+        return count;
 }
 EXPORT_SYMBOL(drm_helper_probe_connector_modes);
 
+static void drm_helper_add_std_modes(struct drm_device *dev,
+                                     struct drm_connector *connector)
+{
+        struct drm_display_mode *mode, *t;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(std_modes); i++) {
+                struct drm_display_mode *stdmode;
+
+                /*
+                 * When no valid EDID modes are available we end up
+                 * here and bailed in the past, now we add some standard
+                 * modes and move on.
+                 */
+                stdmode = drm_mode_duplicate(dev, &std_modes[i]);
+                drm_mode_probed_add(connector, stdmode);
+                drm_mode_list_concat(&connector->probed_modes,
+                                     &connector->modes);
+
+                DRM_DEBUG("Adding mode %s to %s\n", stdmode->name,
+                          drm_get_connector_name(connector));
+        }
+        drm_mode_sort(&connector->modes);
+
+        DRM_DEBUG("Added std modes on %s\n", drm_get_connector_name(connector));
+        list_for_each_entry_safe(mode, t, &connector->modes, head) {
+                mode->vrefresh = drm_mode_vrefresh(mode);
+
+                drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
+                drm_mode_debug_printmodeline(mode);
+        }
+}
 
 /**
  * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
@@ -237,6 +261,8 @@ static void drm_enable_connectors(struct drm_device *dev, bool *enabled)
 
         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                 enabled[i] = drm_connector_enabled(connector, true);
+                DRM_DEBUG("connector %d enabled? %s\n", connector->base.id,
+                          enabled[i] ? "yes" : "no");
                 any_enabled |= enabled[i];
                 i++;
         }
@@ -265,11 +291,17 @@ static bool drm_target_preferred(struct drm_device *dev,
                         continue;
                 }
 
+                DRM_DEBUG("looking for preferred mode on connector %d\n",
+                          connector->base.id);
+
                 modes[i] = drm_has_preferred_mode(connector, width, height);
-                if (!modes[i]) {
+                /* No preferred modes, pick one off the list */
+                if (!modes[i] && !list_empty(&connector->modes)) {
                         list_for_each_entry(modes[i], &connector->modes, head)
                                 break;
                 }
+                DRM_DEBUG("found mode %s\n", modes[i] ? modes[i]->name :
+                          "none");
                 i++;
         }
         return true;
@@ -369,6 +401,8 @@ static void drm_setup_crtcs(struct drm_device *dev)
         int width, height;
         int i, ret;
 
+        DRM_DEBUG("\n");
+
         width = dev->mode_config.max_width;
         height = dev->mode_config.max_height;
 
@@ -390,6 +424,8 @@ static void drm_setup_crtcs(struct drm_device *dev)
         if (!ret)
                 DRM_ERROR("Unable to find initial modes\n");
 
+        DRM_DEBUG("picking CRTCs for %dx%d config\n", width, height);
+
         drm_pick_crtcs(dev, crtcs, modes, 0, width, height);
 
         i = 0;
@@ -403,6 +439,8 @@ static void drm_setup_crtcs(struct drm_device *dev)
                 }
 
                 if (mode && crtc) {
+                        DRM_DEBUG("desired mode %s set on crtc %d\n",
+                                  mode->name, crtc->base.id);
                         crtc->desired_mode = mode;
                         connector->encoder->crtc = crtc;
                 } else
@@ -442,6 +480,7 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
         int saved_x, saved_y;
         struct drm_encoder *encoder;
         bool ret = true;
+        bool depth_changed, bpp_changed;
 
         adjusted_mode = drm_mode_duplicate(dev, mode);
 
@@ -450,6 +489,15 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
         if (!crtc->enabled)
                 return true;
 
+        if (old_fb && crtc->fb) {
+                depth_changed = (old_fb->depth != crtc->fb->depth);
+                bpp_changed = (old_fb->bits_per_pixel !=
+                               crtc->fb->bits_per_pixel);
+        } else {
+                depth_changed = true;
+                bpp_changed = true;
+        }
+
         saved_mode = crtc->mode;
         saved_x = crtc->x;
         saved_y = crtc->y;
@@ -462,7 +510,8 @@ bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
         crtc->y = y;
 
         if (drm_mode_equal(&saved_mode, &crtc->mode)) {
-                if (saved_x != crtc->x || saved_y != crtc->y) {
+                if (saved_x != crtc->x || saved_y != crtc->y ||
+                    depth_changed || bpp_changed) {
                         crtc_funcs->mode_set_base(crtc, crtc->x, crtc->y,
                                                   old_fb);
                         goto done;
@@ -568,8 +617,8 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
         struct drm_encoder **save_encoders, *new_encoder;
         struct drm_framebuffer *old_fb;
         bool save_enabled;
-        bool changed = false;
-        bool flip_or_move = false;
+        bool mode_changed = false;
+        bool fb_changed = false;
         struct drm_connector *connector;
         int count = 0, ro, fail = 0;
         struct drm_crtc_helper_funcs *crtc_funcs;
@@ -597,7 +646,10 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
         /* save previous config */
         save_enabled = set->crtc->enabled;
 
-        /* this is meant to be num_connector not num_crtc */
+        /*
+         * We do mode_config.num_connectors here since we'll look at the
+         * CRTC and encoder associated with each connector later.
+         */
         save_crtcs = kzalloc(dev->mode_config.num_connector *
                              sizeof(struct drm_crtc *), GFP_KERNEL);
         if (!save_crtcs)
@@ -613,21 +665,25 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
         /* We should be able to check here if the fb has the same properties
          * and then just flip_or_move it */
         if (set->crtc->fb != set->fb) {
-                /* if we have no fb then its a change not a flip */
+                /* If we have no fb then treat it as a full mode set */
                 if (set->crtc->fb == NULL)
-                        changed = true;
+                        mode_changed = true;
+                else if ((set->fb->bits_per_pixel !=
+                         set->crtc->fb->bits_per_pixel) ||
+                         set->fb->depth != set->crtc->fb->depth)
+                        fb_changed = true;
                 else
-                        flip_or_move = true;
+                        fb_changed = true;
         }
 
         if (set->x != set->crtc->x || set->y != set->crtc->y)
-                flip_or_move = true;
+                fb_changed = true;
 
         if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
                 DRM_DEBUG("modes are different\n");
                 drm_mode_debug_printmodeline(&set->crtc->mode);
                 drm_mode_debug_printmodeline(set->mode);
-                changed = true;
+                mode_changed = true;
         }
 
         /* a) traverse passed in connector list and get encoders for them */
@@ -650,7 +706,7 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
                 }
 
                 if (new_encoder != connector->encoder) {
-                        changed = true;
+                        mode_changed = true;
                         connector->encoder = new_encoder;
                 }
         }
@@ -677,16 +733,16 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
                                 new_crtc = set->crtc;
                 }
                 if (new_crtc != connector->encoder->crtc) {
-                        changed = true;
+                        mode_changed = true;
                         connector->encoder->crtc = new_crtc;
                 }
         }
 
         /* mode_set_base is not a required function */
-        if (flip_or_move && !crtc_funcs->mode_set_base)
-                changed = true;
+        if (fb_changed && !crtc_funcs->mode_set_base)
+                mode_changed = true;
 
-        if (changed) {
+        if (mode_changed) {
                 old_fb = set->crtc->fb;
                 set->crtc->fb = set->fb;
                 set->crtc->enabled = (set->mode != NULL);
@@ -705,7 +761,7 @@ int drm_crtc_helper_set_config(struct drm_mode_set *set)
                         set->crtc->desired_mode = set->mode;
                 }
                 drm_helper_disable_unused_functions(dev);
-        } else if (flip_or_move) {
+        } else if (fb_changed) {
                 old_fb = set->crtc->fb;
                 if (set->crtc->fb != set->fb)
                         set->crtc->fb = set->fb;
@@ -764,10 +820,31 @@ bool drm_helper_plugged_event(struct drm_device *dev)
  */
 bool drm_helper_initial_config(struct drm_device *dev, bool can_grow)
 {
-        int ret = false;
+        struct drm_connector *connector;
+        int count = 0;
 
-        drm_helper_plugged_event(dev);
-        return ret;
+        count = drm_helper_probe_connector_modes(dev,
+                                                 dev->mode_config.max_width,
+                                                 dev->mode_config.max_height);
+
+        /*
+         * None of the available connectors had any modes, so add some
+         * and try to light them up anyway
+         */
+        if (!count) {
+                DRM_ERROR("connectors have no modes, using standard modes\n");
+                list_for_each_entry(connector,
+                                    &dev->mode_config.connector_list,
+                                    head)
+                        drm_helper_add_std_modes(dev, connector);
+        }
+
+        drm_setup_crtcs(dev);
+
+        /* alert the driver fb layer */
+        dev->mode_config.funcs->fb_changed(dev);
+
+        return 0;
 }
 EXPORT_SYMBOL(drm_helper_initial_config);
 
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 5ff88d952226..14c7a23dc157 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -294,6 +294,7 @@ EXPORT_SYMBOL(drm_init);
  */
 static void drm_cleanup(struct drm_device * dev)
 {
+        struct drm_map_list *r_list, *list_temp;
         DRM_DEBUG("\n");
 
         if (!dev) {
@@ -325,6 +326,9 @@ static void drm_cleanup(struct drm_device * dev)
         drm_ht_remove(&dev->map_hash);
         drm_ctxbitmap_cleanup(dev);
 
+        list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
+                drm_rmmap(dev, r_list->map);
+
         if (drm_core_check_feature(dev, DRIVER_MODESET))
                 drm_put_minor(&dev->control);
 
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 0fbb0da342cb..5a4d3244758a 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -660,7 +660,7 @@ struct edid *drm_get_edid(struct drm_connector *connector,
 
         edid = (struct edid *)drm_ddc_read(adapter);
         if (!edid) {
-                dev_warn(&connector->dev->pdev->dev, "%s: no EDID data\n",
+                dev_info(&connector->dev->pdev->dev, "%s: no EDID data\n",
                          drm_get_connector_name(connector));
                 return NULL;
         }
diff --git a/drivers/gpu/drm/drm_irq.c b/drivers/gpu/drm/drm_irq.c
index 724e505873cf..477caa1b1e4b 100644
--- a/drivers/gpu/drm/drm_irq.c
+++ b/drivers/gpu/drm/drm_irq.c
@@ -267,7 +267,8 @@ EXPORT_SYMBOL(drm_irq_install);
  */
 int drm_irq_uninstall(struct drm_device * dev)
 {
-        int irq_enabled;
+        unsigned long irqflags;
+        int irq_enabled, i;
 
         if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ))
                 return -EINVAL;
@@ -277,6 +278,16 @@ int drm_irq_uninstall(struct drm_device * dev)
         dev->irq_enabled = 0;
         mutex_unlock(&dev->struct_mutex);
 
+        /*
+         * Wake up any waiters so they don't hang.
+         */
+        spin_lock_irqsave(&dev->vbl_lock, irqflags);
+        for (i = 0; i < dev->num_crtcs; i++) {
+                DRM_WAKEUP(&dev->vbl_queue[i]);
+                dev->vblank_enabled[i] = 0;
+        }
+        spin_unlock_irqrestore(&dev->vbl_lock, irqflags);
+
         if (!irq_enabled)
                 return -EINVAL;
 
@@ -652,8 +663,9 @@ int drm_wait_vblank(struct drm_device *dev, void *data,
                           vblwait->request.sequence, crtc);
                 dev->last_vblank_wait[crtc] = vblwait->request.sequence;
                 DRM_WAIT_ON(ret, dev->vbl_queue[crtc], 3 * DRM_HZ,
-                            ((drm_vblank_count(dev, crtc)
-                              - vblwait->request.sequence) <= (1 << 23)));
+                            (((drm_vblank_count(dev, crtc) -
+                               vblwait->request.sequence) <= (1 << 23)) ||
+                             !dev->irq_enabled));
 
                 if (ret != -EINTR) {
                         struct timeval now;
diff --git a/drivers/gpu/drm/drm_stub.c b/drivers/gpu/drm/drm_stub.c
index 5ca132afa4f2..46bb923b097c 100644
--- a/drivers/gpu/drm/drm_stub.c
+++ b/drivers/gpu/drm/drm_stub.c
@@ -118,12 +118,20 @@ static void drm_master_destroy(struct kref *kref)
         struct drm_master *master = container_of(kref, struct drm_master, refcount);
         struct drm_magic_entry *pt, *next;
         struct drm_device *dev = master->minor->dev;
+        struct drm_map_list *r_list, *list_temp;
 
         list_del(&master->head);
 
         if (dev->driver->master_destroy)
                 dev->driver->master_destroy(dev, master);
 
+        list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
+                if (r_list->master == master) {
+                        drm_rmmap_locked(dev, r_list->map);
+                        r_list = NULL;
+                }
+        }
+
         if (master->unique) {
                 drm_free(master->unique, master->unique_size, DRM_MEM_DRIVER);
                 master->unique = NULL;
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index 62a4bf7b49df..ee64b7301f67 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -177,6 +177,14 @@ static int i915_initialize(struct drm_device * dev, drm_i915_init_t * init)
         drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_master_private *master_priv = dev->primary->master->driver_priv;
 
+        master_priv->sarea = drm_getsarea(dev);
+        if (master_priv->sarea) {
+                master_priv->sarea_priv = (drm_i915_sarea_t *)
+                        ((u8 *)master_priv->sarea->handle + init->sarea_priv_offset);
+        } else {
+                DRM_DEBUG("sarea not found assuming DRI2 userspace\n");
+        }
+
         if (init->ring_size != 0) {
                 if (dev_priv->ring.ring_obj != NULL) {
                         i915_dma_cleanup(dev);
@@ -936,13 +944,14 @@ static int i915_load_modeset_init(struct drm_device *dev)
         dev->mode_config.fb_base = drm_get_resource_start(dev, fb_bar) &
                 0xff000000;
 
-        DRM_DEBUG("*** fb base 0x%08lx\n", dev->mode_config.fb_base);
-
-        if (IS_MOBILE(dev) || (IS_I9XX(dev) && !IS_I965G(dev) && !IS_G33(dev)))
+        if (IS_MOBILE(dev) || IS_I9XX(dev))
                 dev_priv->cursor_needs_physical = true;
         else
                 dev_priv->cursor_needs_physical = false;
 
+        if (IS_I965G(dev) || IS_G33(dev))
+                dev_priv->cursor_needs_physical = false;
+
         ret = i915_probe_agp(dev, &agp_size, &prealloc_size);
         if (ret)
                 goto kfree_devname;
@@ -1152,6 +1161,8 @@ int i915_driver_unload(struct drm_device *dev)
         if (drm_core_check_feature(dev, DRIVER_MODESET)) {
                 intel_modeset_cleanup(dev);
 
+                i915_gem_free_all_phys_object(dev);
+
                 mutex_lock(&dev->struct_mutex);
                 i915_gem_cleanup_ringbuffer(dev);
                 mutex_unlock(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 563de18063fd..e13518252007 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -72,6 +72,18 @@ enum pipe {
 #define WATCH_INACTIVE  0
 #define WATCH_PWRITE    0
 
+#define I915_GEM_PHYS_CURSOR_0 1
+#define I915_GEM_PHYS_CURSOR_1 2
+#define I915_GEM_PHYS_OVERLAY_REGS 3
+#define I915_MAX_PHYS_OBJECT (I915_GEM_PHYS_OVERLAY_REGS)
+
+struct drm_i915_gem_phys_object {
+        int id;
+        struct page **page_list;
+        drm_dma_handle_t *handle;
+        struct drm_gem_object *cur_obj;
+};
+
 typedef struct _drm_i915_ring_buffer {
         int tail_mask;
         unsigned long Size;
@@ -358,6 +370,9 @@ typedef struct drm_i915_private {
                 uint32_t bit_6_swizzle_x;
                 /** Bit 6 swizzling required for Y tiling */
                 uint32_t bit_6_swizzle_y;
+
+                /* storage for physical objects */
+                struct drm_i915_gem_phys_object *phys_objs[I915_MAX_PHYS_OBJECT];
         } mm;
 } drm_i915_private_t;
 
@@ -436,6 +451,9 @@ struct drm_i915_gem_object {
         /** User space pin count and filp owning the pin */
         uint32_t user_pin_count;
         struct drm_file *pin_filp;
+
+        /** for phy allocated objects */
+        struct drm_i915_gem_phys_object *phys_obj;
 };
 
 /**
@@ -598,6 +616,11 @@ int i915_gem_do_init(struct drm_device *dev, unsigned long start,
 int i915_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf);
 int i915_gem_object_set_to_gtt_domain(struct drm_gem_object *obj,
                                       int write);
+int i915_gem_attach_phys_object(struct drm_device *dev,
+                                struct drm_gem_object *obj, int id);
+void i915_gem_detach_phys_object(struct drm_device *dev,
+                                 struct drm_gem_object *obj);
+void i915_gem_free_all_phys_object(struct drm_device *dev);
 
 /* i915_gem_tiling.c */
 void i915_gem_detect_bit_6_swizzle(struct drm_device *dev);
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 1384d6686555..debad5c04cc0 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -55,6 +55,9 @@ static int i915_gem_object_bind_to_gtt(struct drm_gem_object *obj,
 static void i915_gem_object_get_fence_reg(struct drm_gem_object *obj);
 static void i915_gem_clear_fence_reg(struct drm_gem_object *obj);
 static int i915_gem_evict_something(struct drm_device *dev);
+static int i915_gem_phys_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
+                                struct drm_i915_gem_pwrite *args,
+                                struct drm_file *file_priv);
 
 int i915_gem_do_init(struct drm_device *dev, unsigned long start,
                      unsigned long end)
@@ -386,8 +389,10 @@ i915_gem_pwrite_ioctl(struct drm_device *dev, void *data,
          * pread/pwrite currently are reading and writing from the CPU
          * perspective, requiring manual detiling by the client.
          */
-        if (obj_priv->tiling_mode == I915_TILING_NONE &&
-            dev->gtt_total != 0)
+        if (obj_priv->phys_obj)
+                ret = i915_gem_phys_pwrite(dev, obj, args, file_priv);
+        else if (obj_priv->tiling_mode == I915_TILING_NONE &&
+                 dev->gtt_total != 0)
                 ret = i915_gem_gtt_pwrite(dev, obj, args, file_priv);
         else
                 ret = i915_gem_shmem_pwrite(dev, obj, args, file_priv);
@@ -2858,6 +2863,9 @@ void i915_gem_free_object(struct drm_gem_object *obj)
         while (obj_priv->pin_count > 0)
                 i915_gem_object_unpin(obj);
 
+        if (obj_priv->phys_obj)
+                i915_gem_detach_phys_object(dev, obj);
+
         i915_gem_object_unbind(obj);
 
         list = &obj->map_list;
@@ -3293,3 +3301,180 @@ i915_gem_load(struct drm_device *dev)
 
         i915_gem_detect_bit_6_swizzle(dev);
 }
+
+/*
+ * Create a physically contiguous memory object for this object
+ * e.g. for cursor + overlay regs
+ */
+int i915_gem_init_phys_object(struct drm_device *dev,
+                              int id, int size)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_i915_gem_phys_object *phys_obj;
+        int ret;
+
+        if (dev_priv->mm.phys_objs[id - 1] || !size)
+                return 0;
+
+        phys_obj = drm_calloc(1, sizeof(struct drm_i915_gem_phys_object), DRM_MEM_DRIVER);
+        if (!phys_obj)
+                return -ENOMEM;
+
+        phys_obj->id = id;
+
+        phys_obj->handle = drm_pci_alloc(dev, size, 0, 0xffffffff);
+        if (!phys_obj->handle) {
+                ret = -ENOMEM;
+                goto kfree_obj;
+        }
+#ifdef CONFIG_X86
+        set_memory_wc((unsigned long)phys_obj->handle->vaddr, phys_obj->handle->size / PAGE_SIZE);
+#endif
+
+        dev_priv->mm.phys_objs[id - 1] = phys_obj;
+
+        return 0;
+kfree_obj:
+        drm_free(phys_obj, sizeof(struct drm_i915_gem_phys_object), DRM_MEM_DRIVER);
+        return ret;
+}
+
+void i915_gem_free_phys_object(struct drm_device *dev, int id)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_i915_gem_phys_object *phys_obj;
+
+        if (!dev_priv->mm.phys_objs[id - 1])
+                return;
+
+        phys_obj = dev_priv->mm.phys_objs[id - 1];
+        if (phys_obj->cur_obj) {
+                i915_gem_detach_phys_object(dev, phys_obj->cur_obj);
+        }
+
+#ifdef CONFIG_X86
+        set_memory_wb((unsigned long)phys_obj->handle->vaddr, phys_obj->handle->size / PAGE_SIZE);
+#endif
+        drm_pci_free(dev, phys_obj->handle);
+        kfree(phys_obj);
+        dev_priv->mm.phys_objs[id - 1] = NULL;
+}
+
+void i915_gem_free_all_phys_object(struct drm_device *dev)
+{
+        int i;
+
+        for (i = I915_GEM_PHYS_CURSOR_0; i <= I915_MAX_PHYS_OBJECT; i++)
+                i915_gem_free_phys_object(dev, i);
+}
+
+void i915_gem_detach_phys_object(struct drm_device *dev,
+                                 struct drm_gem_object *obj)
+{
+        struct drm_i915_gem_object *obj_priv;
+        int i;
+        int ret;
+        int page_count;
+
+        obj_priv = obj->driver_private;
+        if (!obj_priv->phys_obj)
+                return;
+
+        ret = i915_gem_object_get_page_list(obj);
+        if (ret)
+                goto out;
+
+        page_count = obj->size / PAGE_SIZE;
+
+        for (i = 0; i < page_count; i++) {
+                char *dst = kmap_atomic(obj_priv->page_list[i], KM_USER0);
+                char *src = obj_priv->phys_obj->handle->vaddr + (i * PAGE_SIZE);
+
+                memcpy(dst, src, PAGE_SIZE);
+                kunmap_atomic(dst, KM_USER0);
+        }
+        drm_clflush_pages(obj_priv->page_list, page_count);
+        drm_agp_chipset_flush(dev);
+out:
+        obj_priv->phys_obj->cur_obj = NULL;
+        obj_priv->phys_obj = NULL;
+}
+
+int
+i915_gem_attach_phys_object(struct drm_device *dev,
+                            struct drm_gem_object *obj, int id)
+{
+        drm_i915_private_t *dev_priv = dev->dev_private;
+        struct drm_i915_gem_object *obj_priv;
+        int ret = 0;
+        int page_count;
+        int i;
+
+        if (id > I915_MAX_PHYS_OBJECT)
+                return -EINVAL;
+
+        obj_priv = obj->driver_private;
+
+        if (obj_priv->phys_obj) {
+                if (obj_priv->phys_obj->id == id)
+                        return 0;
+                i915_gem_detach_phys_object(dev, obj);
+        }
+
+
+        /* create a new object */
+        if (!dev_priv->mm.phys_objs[id - 1]) {
+                ret = i915_gem_init_phys_object(dev, id,
+                                                obj->size);
+                if (ret) {
+                        DRM_ERROR("failed to init phys object %d size: %zu\n", id, obj->size);
+                        goto out;
+                }
+        }
+
+        /* bind to the object */
+        obj_priv->phys_obj = dev_priv->mm.phys_objs[id - 1];
+        obj_priv->phys_obj->cur_obj = obj;
+
+        ret = i915_gem_object_get_page_list(obj);
+        if (ret) {
+                DRM_ERROR("failed to get page list\n");
+                goto out;
+        }
+
+        page_count = obj->size / PAGE_SIZE;
+
+        for (i = 0; i < page_count; i++) {
+                char *src = kmap_atomic(obj_priv->page_list[i], KM_USER0);
+                char *dst = obj_priv->phys_obj->handle->vaddr + (i * PAGE_SIZE);
+
+                memcpy(dst, src, PAGE_SIZE);
+                kunmap_atomic(src, KM_USER0);
+        }
+
+        return 0;
+out:
+        return ret;
+}
+
+static int
+i915_gem_phys_pwrite(struct drm_device *dev, struct drm_gem_object *obj,
+                     struct drm_i915_gem_pwrite *args,
+                     struct drm_file *file_priv)
+{
+        struct drm_i915_gem_object *obj_priv = obj->driver_private;
+        void *obj_addr;
+        int ret;
+        char __user *user_data;
+
+        user_data = (char __user *) (uintptr_t) args->data_ptr;
+        obj_addr = obj_priv->phys_obj->handle->vaddr + args->offset;
+
+        DRM_ERROR("obj_addr %p, %lld\n", obj_addr, args->size);
+        ret = copy_from_user(obj_addr, user_data, args->size);
+        if (ret)
+                return -EFAULT;
+
+        drm_agp_chipset_flush(dev);
+        return 0;
+}
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 0cadafbef411..6290219de6c8 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -411,6 +411,12 @@ int i915_enable_vblank(struct drm_device *dev, int pipe)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         unsigned long irqflags;
+        int pipeconf_reg = (pipe == 0) ? PIPEACONF : PIPEBCONF;
+        u32 pipeconf;
+
+        pipeconf = I915_READ(pipeconf_reg);
+        if (!(pipeconf & PIPEACONF_ENABLE))
+                return -EINVAL;
 
         spin_lock_irqsave(&dev_priv->user_irq_lock, irqflags);
         if (IS_I965G(dev))
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 8ccb9c3ab868..31c3732b7a69 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -401,6 +401,8 @@ intel_pipe_set_base(struct drm_crtc *crtc, int x, int y,
         I915_WRITE(dspstride, crtc->fb->pitch);
 
         dspcntr = I915_READ(dspcntr_reg);
+        /* Mask out pixel format bits in case we change it */
+        dspcntr &= ~DISPPLANE_PIXFORMAT_MASK;
         switch (crtc->fb->bits_per_pixel) {
         case 8:
                 dspcntr |= DISPPLANE_8BPP;
@@ -1014,21 +1016,25 @@ static int intel_crtc_cursor_set(struct drm_crtc *crtc,
 
         if (bo->size < width * height * 4) {
                 DRM_ERROR("buffer is to small\n");
-                drm_gem_object_unreference(bo);
-                return -ENOMEM;
+                ret = -ENOMEM;
+                goto fail;
         }
 
-        if (dev_priv->cursor_needs_physical) {
-                addr = dev->agp->base + obj_priv->gtt_offset;
-        } else {
+        /* we only need to pin inside GTT if cursor is non-phy */
+        if (!dev_priv->cursor_needs_physical) {
+                ret = i915_gem_object_pin(bo, PAGE_SIZE);
+                if (ret) {
+                        DRM_ERROR("failed to pin cursor bo\n");
+                        goto fail;
+                }
                 addr = obj_priv->gtt_offset;
-        }
-
-        ret = i915_gem_object_pin(bo, PAGE_SIZE);
-        if (ret) {
-                DRM_ERROR("failed to pin cursor bo\n");
-                drm_gem_object_unreference(bo);
-                return ret;
+        } else {
+                ret = i915_gem_attach_phys_object(dev, bo, (pipe == 0) ? I915_GEM_PHYS_CURSOR_0 : I915_GEM_PHYS_CURSOR_1);
+                if (ret) {
+                        DRM_ERROR("failed to attach phys object\n");
+                        goto fail;
+                }
+                addr = obj_priv->phys_obj->handle->busaddr;
         }
 
         temp = 0;
@@ -1041,14 +1047,25 @@ static int intel_crtc_cursor_set(struct drm_crtc *crtc,
         I915_WRITE(base, addr);
 
         if (intel_crtc->cursor_bo) {
-                i915_gem_object_unpin(intel_crtc->cursor_bo);
+                if (dev_priv->cursor_needs_physical) {
+                        if (intel_crtc->cursor_bo != bo)
+                                i915_gem_detach_phys_object(dev, intel_crtc->cursor_bo);
+                } else
+                        i915_gem_object_unpin(intel_crtc->cursor_bo);
+                mutex_lock(&dev->struct_mutex);
                 drm_gem_object_unreference(intel_crtc->cursor_bo);
+                mutex_unlock(&dev->struct_mutex);
         }
 
         intel_crtc->cursor_addr = addr;
         intel_crtc->cursor_bo = bo;
 
         return 0;
+fail:
+        mutex_lock(&dev->struct_mutex);
+        drm_gem_object_unreference(bo);
+        mutex_unlock(&dev->struct_mutex);
+        return ret;
 }
 
 static int intel_crtc_cursor_move(struct drm_crtc *crtc, int x, int y)
diff --git a/drivers/gpu/drm/i915/intel_i2c.c b/drivers/gpu/drm/i915/intel_i2c.c
index a5a2f5339e9e..5ee9d4c25753 100644
--- a/drivers/gpu/drm/i915/intel_i2c.c
+++ b/drivers/gpu/drm/i915/intel_i2c.c
@@ -137,10 +137,6 @@ struct intel_i2c_chan *intel_i2c_create(struct drm_device *dev, const u32 reg,
         chan->reg = reg;
         snprintf(chan->adapter.name, I2C_NAME_SIZE, "intel drm %s", name);
         chan->adapter.owner = THIS_MODULE;
-#ifndef I2C_HW_B_INTELFB
-#define I2C_HW_B_INTELFB I2C_HW_B_I810
-#endif
-        chan->adapter.id = I2C_HW_B_INTELFB;
         chan->adapter.algo_data = &chan->algo;
         chan->adapter.dev.parent = &dev->pdev->dev;
         chan->algo.setsda = set_data;
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index ccecfaf6307b..6b1148fc2cbe 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -340,6 +340,18 @@ static void intel_lvds_destroy(struct drm_connector *connector)
         kfree(connector);
 }
 
+static int intel_lvds_set_property(struct drm_connector *connector,
+                                   struct drm_property *property,
+                                   uint64_t value)
+{
+        struct drm_device *dev = connector->dev;
+
+        if (property == dev->mode_config.dpms_property && connector->encoder)
+                intel_lvds_dpms(connector->encoder, (uint32_t)(value & 0xf));
+
+        return 0;
+}
+
 static const struct drm_encoder_helper_funcs intel_lvds_helper_funcs = {
         .dpms = intel_lvds_dpms,
         .mode_fixup = intel_lvds_mode_fixup,
@@ -359,6 +371,7 @@ static const struct drm_connector_funcs intel_lvds_connector_funcs = {
         .restore = intel_lvds_restore,
         .detect = intel_lvds_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
+        .set_property = intel_lvds_set_property,
         .destroy = intel_lvds_destroy,
 };
 
@@ -456,6 +469,13 @@ void intel_lvds_init(struct drm_device *dev)
                 dev_priv->panel_fixed_mode =
                         drm_mode_duplicate(dev, dev_priv->vbt_mode);
                 mutex_unlock(&dev->mode_config.mutex);
+                if (dev_priv->panel_fixed_mode) {
+                        dev_priv->panel_fixed_mode->type |=
+                                DRM_MODE_TYPE_PREFERRED;
+                        drm_mode_probed_add(connector,
+                                            dev_priv->panel_fixed_mode);
+                        goto out;
+                }
         }
 
         /*
diff --git a/drivers/hwmon/Kconfig b/drivers/hwmon/Kconfig
index 4b33bc82cc24..b84bf066879b 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -189,6 +189,16 @@ config SENSORS_ADT7473
           This driver can also be built as a module. If so, the module
           will be called adt7473.
 
+config SENSORS_ADT7475
+        tristate "Analog Devices ADT7475"
+        depends on I2C && EXPERIMENTAL
+        help
+          If you say yes here you get support for the Analog Devices
+          ADT7475 hardware monitoring chips.
+
+          This driver can also be build as a module.  If so, the module
+          will be called adt7475.
+
 config SENSORS_K8TEMP
         tristate "AMD Athlon64/FX or Opteron temperature sensor"
         depends on X86 && PCI && EXPERIMENTAL
@@ -861,6 +871,8 @@ config SENSORS_HDAPS
 config SENSORS_LIS3LV02D
         tristate "STMicroeletronics LIS3LV02Dx three-axis digital accelerometer"
         depends on ACPI && INPUT
+        select NEW_LEDS
+        select LEDS_CLASS
         default n
         help
           This driver provides support for the LIS3LV02Dx accelerometer. In
@@ -872,10 +884,16 @@ config SENSORS_LIS3LV02D
           /sys/devices/platform/lis3lv02d.
 
           This driver also provides an absolute input class device, allowing
-          the laptop to act as a pinball machine-esque joystick.
+          the laptop to act as a pinball machine-esque joystick. On HP laptops,
+          if the led infrastructure is activated, support for a led indicating
+          disk protection will be provided as hp:red:hddprotection.
 
-          This driver can also be built as a module.  If so, the module
-          will be called lis3lv02d.
+          This driver can also be built as modules.  If so, the core module
+          will be called lis3lv02d and a specific module for HP laptops will be
+          called hp_accel.
+
+          Say Y here if you have an applicable laptop and want to experience
+          the awesome power of lis3lv02d.
 
 config SENSORS_APPLESMC
         tristate "Apple SMC (Motion sensor, light sensor, keyboard backlight)"
diff --git a/drivers/hwmon/Makefile b/drivers/hwmon/Makefile
index 19cb1ace3eb4..2e80f37f39eb 100644
--- a/drivers/hwmon/Makefile
+++ b/drivers/hwmon/Makefile
@@ -28,6 +28,8 @@ obj-$(CONFIG_SENSORS_ADS7828)	+= ads7828.o
 obj-$(CONFIG_SENSORS_ADT7462)   += adt7462.o
 obj-$(CONFIG_SENSORS_ADT7470)   += adt7470.o
 obj-$(CONFIG_SENSORS_ADT7473)   += adt7473.o
+obj-$(CONFIG_SENSORS_ADT7475)   += adt7475.o
+
 obj-$(CONFIG_SENSORS_APPLESMC)  += applesmc.o
 obj-$(CONFIG_SENSORS_AMS)       += ams/
 obj-$(CONFIG_SENSORS_ATXP1)     += atxp1.o
diff --git a/drivers/hwmon/abituguru3.c b/drivers/hwmon/abituguru3.c
index 70bb854086df..e52b38806d03 100644
--- a/drivers/hwmon/abituguru3.c
+++ b/drivers/hwmon/abituguru3.c
@@ -279,7 +279,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "OTES1 Fan",          36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0011, "AT8 32X(ATI RD580-ULI M1575)", {
+        { 0x0011, "AT8 32X", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR",                 1, 0, 20, 1, 0 },
                 { "DDR VTT",             2, 0, 10, 1, 0 },
@@ -402,7 +402,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0016, "AW9D-MAX       (Intel i975-ICH7)", {
+        { 0x0016, "AW9D-MAX", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -482,7 +482,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 Fan",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x0019, NULL /* Unknown, need DMI string */, {
+        { 0x0019, "IN9 32X MAX", {
                 { "CPU Core",            7, 0, 10, 1, 0 },
                 { "DDR2",               13, 0, 20, 1, 0 },
                 { "DDR2 VTT",           14, 0, 10, 1, 0 },
@@ -509,7 +509,7 @@ static const struct abituguru3_motherboard_info abituguru3_motherboards[] = {
                 { "AUX3 FAN",           36, 2, 60, 1, 0 },
                 { NULL, 0, 0, 0, 0, 0 } }
         },
-        { 0x001A, "IP35 Pro(Intel P35-ICH9R)", {
+        { 0x001A, "IP35 Pro", {
                 { "CPU Core",            0, 0, 10, 1, 0 },
                 { "DDR2",                1, 0, 20, 1, 0 },
                 { "DDR2 VTT",            2, 0, 10, 1, 0 },
@@ -1128,6 +1128,7 @@ static int __init abituguru3_dmi_detect(void)
 {
         const char *board_vendor, *board_name;
         int i, err = (force) ? 1 : -ENODEV;
+        size_t sublen;
 
         board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
         if (!board_vendor || strcmp(board_vendor, "http://www.abit.com.tw/"))
@@ -1137,9 +1138,20 @@ static int __init abituguru3_dmi_detect(void)
         if (!board_name)
                 return err;
 
+        /* At the moment, we don't care about the part of the vendor
+         * DMI string contained in brackets. Truncate the string at
+         * the first occurrence of a bracket. Trim any trailing space
+         * from the substring.
+         */
+        sublen = strcspn(board_name, "(");
+        while (sublen > 0 && board_name[sublen - 1] == ' ')
+                sublen--;
+
         for (i = 0; abituguru3_motherboards[i].id; i++) {
                 const char *dmi_name = abituguru3_motherboards[i].dmi_name;
-                if (dmi_name && !strcmp(dmi_name, board_name))
+                if (!dmi_name || strlen(dmi_name) != sublen)
+                        continue;
+                if (!strncasecmp(board_name, dmi_name, sublen))
                         break;
         }
 
@@ -1153,7 +1165,7 @@ static int __init abituguru3_dmi_detect(void)
 
 static inline int abituguru3_dmi_detect(void)
 {
-        return -ENODEV;
+        return 1;
 }
 
 #endif /* CONFIG_DMI */
diff --git a/drivers/hwmon/adt7475.c b/drivers/hwmon/adt7475.c
new file mode 100644
index 000000000000..d39877a7da63
--- /dev/null
+++ b/drivers/hwmon/adt7475.c
@@ -0,0 +1,1221 @@
+/*
+ * adt7475 - Thermal sensor driver for the ADT7475 chip and derivatives
+ * Copyright (C) 2007-2008, Advanced Micro Devices, Inc.
+ * Copyright (C) 2008 Jordan Crouse <jordan@cosmicpenguin.net>
+ * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
+
+ * Derived from the lm83 driver by Jean Delvare
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/hwmon.h>
+#include <linux/hwmon-sysfs.h>
+#include <linux/err.h>
+
+/* Indexes for the sysfs hooks */
+
+#define INPUT           0
+#define MIN             1
+#define MAX             2
+#define CONTROL         3
+#define OFFSET          3
+#define AUTOMIN         4
+#define THERM           5
+#define HYSTERSIS       6
+
+/* These are unique identifiers for the sysfs functions - unlike the
+   numbers above, these are not also indexes into an array
+*/
+
+#define ALARM           9
+#define FAULT           10
+
+/* 7475 Common Registers */
+
+#define REG_VOLTAGE_BASE        0x21
+#define REG_TEMP_BASE           0x25
+#define REG_TACH_BASE           0x28
+#define REG_PWM_BASE            0x30
+#define REG_PWM_MAX_BASE        0x38
+
+#define REG_DEVID               0x3D
+#define REG_VENDID              0x3E
+
+#define REG_STATUS1             0x41
+#define REG_STATUS2             0x42
+
+#define REG_VOLTAGE_MIN_BASE    0x46
+#define REG_VOLTAGE_MAX_BASE    0x47
+
+#define REG_TEMP_MIN_BASE       0x4E
+#define REG_TEMP_MAX_BASE       0x4F
+
+#define REG_TACH_MIN_BASE       0x54
+
+#define REG_PWM_CONFIG_BASE     0x5C
+
+#define REG_TEMP_TRANGE_BASE    0x5F
+
+#define REG_PWM_MIN_BASE        0x64
+
+#define REG_TEMP_TMIN_BASE      0x67
+#define REG_TEMP_THERM_BASE     0x6A
+
+#define REG_REMOTE1_HYSTERSIS   0x6D
+#define REG_REMOTE2_HYSTERSIS   0x6E
+
+#define REG_TEMP_OFFSET_BASE    0x70
+
+#define REG_EXTEND1             0x76
+#define REG_EXTEND2             0x77
+#define REG_CONFIG5             0x7C
+
+#define CONFIG5_TWOSCOMP        0x01
+#define CONFIG5_TEMPOFFSET      0x02
+
+/* ADT7475 Settings */
+
+#define ADT7475_VOLTAGE_COUNT   2
+#define ADT7475_TEMP_COUNT      3
+#define ADT7475_TACH_COUNT      4
+#define ADT7475_PWM_COUNT       3
+
+/* Macro to read the registers */
+
+#define adt7475_read(reg) i2c_smbus_read_byte_data(client, (reg))
+
+/* Macros to easily index the registers */
+
+#define TACH_REG(idx) (REG_TACH_BASE + ((idx) * 2))
+#define TACH_MIN_REG(idx) (REG_TACH_MIN_BASE + ((idx) * 2))
+
+#define PWM_REG(idx) (REG_PWM_BASE + (idx))
+#define PWM_MAX_REG(idx) (REG_PWM_MAX_BASE + (idx))
+#define PWM_MIN_REG(idx) (REG_PWM_MIN_BASE + (idx))
+#define PWM_CONFIG_REG(idx) (REG_PWM_CONFIG_BASE + (idx))
+
+#define VOLTAGE_REG(idx) (REG_VOLTAGE_BASE + (idx))
+#define VOLTAGE_MIN_REG(idx) (REG_VOLTAGE_MIN_BASE + ((idx) * 2))
+#define VOLTAGE_MAX_REG(idx) (REG_VOLTAGE_MAX_BASE + ((idx) * 2))
+
+#define TEMP_REG(idx) (REG_TEMP_BASE + (idx))
+#define TEMP_MIN_REG(idx) (REG_TEMP_MIN_BASE + ((idx) * 2))
+#define TEMP_MAX_REG(idx) (REG_TEMP_MAX_BASE + ((idx) * 2))
+#define TEMP_TMIN_REG(idx) (REG_TEMP_TMIN_BASE + (idx))
+#define TEMP_THERM_REG(idx) (REG_TEMP_THERM_BASE + (idx))
+#define TEMP_OFFSET_REG(idx) (REG_TEMP_OFFSET_BASE + (idx))
+#define TEMP_TRANGE_REG(idx) (REG_TEMP_TRANGE_BASE + (idx))
+
+static unsigned short normal_i2c[] = { 0x2e, I2C_CLIENT_END };
+
+I2C_CLIENT_INSMOD_1(adt7475);
+
+static const struct i2c_device_id adt7475_id[] = {
+        { "adt7475", adt7475 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, adt7475_id);
+
+struct adt7475_data {
+        struct device *hwmon_dev;
+        struct mutex lock;
+
+        unsigned long measure_updated;
+        unsigned long limits_updated;
+        char valid;
+
+        u8 config5;
+        u16 alarms;
+        u16 voltage[3][3];
+        u16 temp[7][3];
+        u16 tach[2][4];
+        u8 pwm[4][3];
+        u8 range[3];
+        u8 pwmctl[3];
+        u8 pwmchan[3];
+};
+
+static struct i2c_driver adt7475_driver;
+static struct adt7475_data *adt7475_update_device(struct device *dev);
+static void adt7475_read_hystersis(struct i2c_client *client);
+static void adt7475_read_pwm(struct i2c_client *client, int index);
+
+/* Given a temp value, convert it to register value */
+
+static inline u16 temp2reg(struct adt7475_data *data, long val)
+{
+        u16 ret;
+
+        if (!(data->config5 & CONFIG5_TWOSCOMP)) {
+                val = SENSORS_LIMIT(val, -64000, 191000);
+                ret = (val + 64500) / 1000;
+        } else {
+                val = SENSORS_LIMIT(val, -128000, 127000);
+                if (val < -500)
+                        ret = (256500 + val) / 1000;
+                else
+                        ret = (val + 500) / 1000;
+        }
+
+        return ret << 2;
+}
+
+/* Given a register value, convert it to a real temp value */
+
+static inline int reg2temp(struct adt7475_data *data, u16 reg)
+{
+        if (data->config5 & CONFIG5_TWOSCOMP) {
+                if (reg >= 512)
+                        return (reg - 1024) * 250;
+                else
+                        return reg * 250;
+        } else
+                return (reg - 256) * 250;
+}
+
+static inline int tach2rpm(u16 tach)
+{
+        if (tach == 0 || tach == 0xFFFF)
+                return 0;
+
+        return (90000 * 60) / tach;
+}
+
+static inline u16 rpm2tach(unsigned long rpm)
+{
+        if (rpm == 0)
+                return 0;
+
+        return SENSORS_LIMIT((90000 * 60) / rpm, 1, 0xFFFF);
+}
+
+static inline int reg2vcc(u16 reg)
+{
+        return (4296 * reg) / 1000;
+}
+
+static inline int reg2vccp(u16 reg)
+{
+        return (2929 * reg) / 1000;
+}
+
+static inline u16 vcc2reg(long vcc)
+{
+        vcc = SENSORS_LIMIT(vcc, 0, 4396);
+        return (vcc * 1000) / 4296;
+}
+
+static inline u16 vccp2reg(long vcc)
+{
+        vcc = SENSORS_LIMIT(vcc, 0, 2998);
+        return (vcc * 1000) / 2929;
+}
+
+static u16 adt7475_read_word(struct i2c_client *client, int reg)
+{
+        u16 val;
+
+        val = i2c_smbus_read_byte_data(client, reg);
+        val |= (i2c_smbus_read_byte_data(client, reg + 1) << 8);
+
+        return val;
+}
+
+static void adt7475_write_word(struct i2c_client *client, int reg, u16 val)
+{
+        i2c_smbus_write_byte_data(client, reg + 1, val >> 8);
+        i2c_smbus_write_byte_data(client, reg, val & 0xFF);
+}
+
+/* Find the nearest value in a table - used for pwm frequency and
+   auto temp range */
+static int find_nearest(long val, const int *array, int size)
+{
+        int i;
+
+        if (val < array[0])
+                return 0;
+
+        if (val > array[size - 1])
+                return size - 1;
+
+        for (i = 0; i < size - 1; i++) {
+                int a, b;
+
+                if (val > array[i + 1])
+                        continue;
+
+                a = val - array[i];
+                b = array[i + 1] - val;
+
+                return (a <= b) ? i : i + 1;
+        }
+
+        return 0;
+}
+
+static ssize_t show_voltage(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        unsigned short val;
+
+        switch (sattr->nr) {
+        case ALARM:
+                return sprintf(buf, "%d\n",
+                               (data->alarms >> (sattr->index + 1)) & 1);
+        default:
+                val = data->voltage[sattr->nr][sattr->index];
+                return sprintf(buf, "%d\n",
+                               sattr->index ==
+                               0 ? reg2vccp(val) : reg2vcc(val));
+        }
+}
+
+static ssize_t set_voltage(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        unsigned char reg;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+
+        data->voltage[sattr->nr][sattr->index] =
+                sattr->index ? vcc2reg(val) : vccp2reg(val);
+
+        if (sattr->nr == MIN)
+                reg = VOLTAGE_MIN_REG(sattr->index);
+        else
+                reg = VOLTAGE_MAX_REG(sattr->index);
+
+        i2c_smbus_write_byte_data(client, reg,
+                                  data->voltage[sattr->nr][sattr->index] >> 2);
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+static ssize_t show_temp(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        int out;
+
+        switch (sattr->nr) {
+        case HYSTERSIS:
+                mutex_lock(&data->lock);
+                out = data->temp[sattr->nr][sattr->index];
+                if (sattr->index != 1)
+                        out = (out >> 4) & 0xF;
+                else
+                        out = (out & 0xF);
+                /* Show the value as an absolute number tied to
+                 * THERM */
+                out = reg2temp(data, data->temp[THERM][sattr->index]) -
+                        out * 1000;
+                mutex_unlock(&data->lock);
+                break;
+
+        case OFFSET:
+                /* Offset is always 2's complement, regardless of the
+                 * setting in CONFIG5 */
+                mutex_lock(&data->lock);
+                out = (s8)data->temp[sattr->nr][sattr->index];
+                if (data->config5 & CONFIG5_TEMPOFFSET)
+                        out *= 1000;
+                else
+                        out *= 500;
+                mutex_unlock(&data->lock);
+                break;
+
+        case ALARM:
+                out = (data->alarms >> (sattr->index + 4)) & 1;
+                break;
+
+        case FAULT:
+                /* Note - only for remote1 and remote2 */
+                out = data->alarms & (sattr->index ? 0x8000 : 0x4000);
+                out = out ? 0 : 1;
+                break;
+
+        default:
+                /* All other temp values are in the configured format */
+                out = reg2temp(data, data->temp[sattr->nr][sattr->index]);
+        }
+
+        return sprintf(buf, "%d\n", out);
+}
+
+static ssize_t set_temp(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        unsigned char reg = 0;
+        u8 out;
+        int temp;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+
+        /* We need the config register in all cases for temp <-> reg conv. */
+        data->config5 = adt7475_read(REG_CONFIG5);
+
+        switch (sattr->nr) {
+        case OFFSET:
+                if (data->config5 & CONFIG5_TEMPOFFSET) {
+                        val = SENSORS_LIMIT(val, -63000, 127000);
+                        out = data->temp[OFFSET][sattr->index] = val / 1000;
+                } else {
+                        val = SENSORS_LIMIT(val, -63000, 64000);
+                        out = data->temp[OFFSET][sattr->index] = val / 500;
+                }
+                break;
+
+        case HYSTERSIS:
+                /* The value will be given as an absolute value, turn it
+                   into an offset based on THERM */
+
+                /* Read fresh THERM and HYSTERSIS values from the chip */
+                data->temp[THERM][sattr->index] =
+                        adt7475_read(TEMP_THERM_REG(sattr->index)) << 2;
+                adt7475_read_hystersis(client);
+
+                temp = reg2temp(data, data->temp[THERM][sattr->index]);
+                val = SENSORS_LIMIT(val, temp - 15000, temp);
+                val = (temp - val) / 1000;
+
+                if (sattr->index != 1) {
+                        data->temp[HYSTERSIS][sattr->index] &= 0xF0;
+                        data->temp[HYSTERSIS][sattr->index] |= (val & 0xF) << 4;
+                } else {
+                        data->temp[HYSTERSIS][sattr->index] &= 0x0F;
+                        data->temp[HYSTERSIS][sattr->index] |= (val & 0xF);
+                }
+
+                out = data->temp[HYSTERSIS][sattr->index];
+                break;
+
+        default:
+                data->temp[sattr->nr][sattr->index] = temp2reg(data, val);
+
+                /* We maintain an extra 2 digits of precision for simplicity
+                 * - shift those back off before writing the value */
+                out = (u8) (data->temp[sattr->nr][sattr->index] >> 2);
+        }
+
+        switch (sattr->nr) {
+        case MIN:
+                reg = TEMP_MIN_REG(sattr->index);
+                break;
+        case MAX:
+                reg = TEMP_MAX_REG(sattr->index);
+                break;
+        case OFFSET:
+                reg = TEMP_OFFSET_REG(sattr->index);
+                break;
+        case AUTOMIN:
+                reg = TEMP_TMIN_REG(sattr->index);
+                break;
+        case THERM:
+                reg = TEMP_THERM_REG(sattr->index);
+                break;
+        case HYSTERSIS:
+                if (sattr->index != 2)
+                        reg = REG_REMOTE1_HYSTERSIS;
+                else
+                        reg = REG_REMOTE2_HYSTERSIS;
+
+                break;
+        }
+
+        i2c_smbus_write_byte_data(client, reg, out);
+
+        mutex_unlock(&data->lock);
+        return count;
+}
+
+/* Table of autorange values - the user will write the value in millidegrees,
+   and we'll convert it */
+static const int autorange_table[] = {
+        2000, 2500, 3330, 4000, 5000, 6670, 8000,
+        10000, 13330, 16000, 20000, 26670, 32000, 40000,
+        53330, 80000
+};
+
+static ssize_t show_point2(struct device *dev, struct device_attribute *attr,
+                           char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        int out, val;
+
+        mutex_lock(&data->lock);
+        out = (data->range[sattr->index] >> 4) & 0x0F;
+        val = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
+        mutex_unlock(&data->lock);
+
+        return sprintf(buf, "%d\n", val + autorange_table[out]);
+}
+
+static ssize_t set_point2(struct device *dev, struct device_attribute *attr,
+                          const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        int temp;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+
+        /* Get a fresh copy of the needed registers */
+        data->config5 = adt7475_read(REG_CONFIG5);
+        data->temp[AUTOMIN][sattr->index] =
+                adt7475_read(TEMP_TMIN_REG(sattr->index)) << 2;
+        data->range[sattr->index] =
+                adt7475_read(TEMP_TRANGE_REG(sattr->index));
+
+        /* The user will write an absolute value, so subtract the start point
+           to figure the range */
+        temp = reg2temp(data, data->temp[AUTOMIN][sattr->index]);
+        val = SENSORS_LIMIT(val, temp + autorange_table[0],
+                temp + autorange_table[ARRAY_SIZE(autorange_table) - 1]);
+        val -= temp;
+
+        /* Find the nearest table entry to what the user wrote */
+        val = find_nearest(val, autorange_table, ARRAY_SIZE(autorange_table));
+
+        data->range[sattr->index] &= ~0xF0;
+        data->range[sattr->index] |= val << 4;
+
+        i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
+                                  data->range[sattr->index]);
+
+        mutex_unlock(&data->lock);
+        return count;
+}
+
+static ssize_t show_tach(struct device *dev, struct device_attribute *attr,
+                         char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        int out;
+
+        if (sattr->nr == ALARM)
+                out = (data->alarms >> (sattr->index + 10)) & 1;
+        else
+                out = tach2rpm(data->tach[sattr->nr][sattr->index]);
+
+        return sprintf(buf, "%d\n", out);
+}
+
+static ssize_t set_tach(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+
+        data->tach[MIN][sattr->index] = rpm2tach(val);
+
+        adt7475_write_word(client, TACH_MIN_REG(sattr->index),
+                           data->tach[MIN][sattr->index]);
+
+        mutex_unlock(&data->lock);
+        return count;
+}
+
+static ssize_t show_pwm(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+        return sprintf(buf, "%d\n", data->pwm[sattr->nr][sattr->index]);
+}
+
+static ssize_t show_pwmchan(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+        return sprintf(buf, "%d\n", data->pwmchan[sattr->index]);
+}
+
+static ssize_t show_pwmctrl(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+        return sprintf(buf, "%d\n", data->pwmctl[sattr->index]);
+}
+
+static ssize_t set_pwm(struct device *dev, struct device_attribute *attr,
+                       const char *buf, size_t count)
+{
+
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        unsigned char reg = 0;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+
+        switch (sattr->nr) {
+        case INPUT:
+                /* Get a fresh value for CONTROL */
+                data->pwm[CONTROL][sattr->index] =
+                        adt7475_read(PWM_CONFIG_REG(sattr->index));
+
+                /* If we are not in manual mode, then we shouldn't allow
+                 * the user to set the pwm speed */
+                if (((data->pwm[CONTROL][sattr->index] >> 5) & 7) != 7) {
+                        mutex_unlock(&data->lock);
+                        return count;
+                }
+
+                reg = PWM_REG(sattr->index);
+                break;
+
+        case MIN:
+                reg = PWM_MIN_REG(sattr->index);
+                break;
+
+        case MAX:
+                reg = PWM_MAX_REG(sattr->index);
+                break;
+        }
+
+        data->pwm[sattr->nr][sattr->index] = SENSORS_LIMIT(val, 0, 0xFF);
+        i2c_smbus_write_byte_data(client, reg,
+                                  data->pwm[sattr->nr][sattr->index]);
+
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+/* Called by set_pwmctrl and set_pwmchan */
+
+static int hw_set_pwm(struct i2c_client *client, int index,
+                      unsigned int pwmctl, unsigned int pwmchan)
+{
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        long val = 0;
+
+        switch (pwmctl) {
+        case 0:
+                val = 0x03;     /* Run at full speed */
+                break;
+        case 1:
+                val = 0x07;     /* Manual mode */
+                break;
+        case 2:
+                switch (pwmchan) {
+                case 1:
+                        /* Remote1 controls PWM */
+                        val = 0x00;
+                        break;
+                case 2:
+                        /* local controls PWM */
+                        val = 0x01;
+                        break;
+                case 4:
+                        /* remote2 controls PWM */
+                        val = 0x02;
+                        break;
+                case 6:
+                        /* local/remote2 control PWM */
+                        val = 0x05;
+                        break;
+                case 7:
+                        /* All three control PWM */
+                        val = 0x06;
+                        break;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        data->pwmctl[index] = pwmctl;
+        data->pwmchan[index] = pwmchan;
+
+        data->pwm[CONTROL][index] &= ~0xE0;
+        data->pwm[CONTROL][index] |= (val & 7) << 5;
+
+        i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
+                                  data->pwm[CONTROL][index]);
+
+        return 0;
+}
+
+static ssize_t set_pwmchan(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        int r;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+        /* Read Modify Write PWM values */
+        adt7475_read_pwm(client, sattr->index);
+        r = hw_set_pwm(client, sattr->index, data->pwmctl[sattr->index], val);
+        if (r)
+                count = r;
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+static ssize_t set_pwmctrl(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        int r;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        mutex_lock(&data->lock);
+        /* Read Modify Write PWM values */
+        adt7475_read_pwm(client, sattr->index);
+        r = hw_set_pwm(client, sattr->index, val, data->pwmchan[sattr->index]);
+        if (r)
+                count = r;
+        mutex_unlock(&data->lock);
+
+        return count;
+}
+
+/* List of frequencies for the PWM */
+static const int pwmfreq_table[] = {
+        11, 14, 22, 29, 35, 44, 58, 88
+};
+
+static ssize_t show_pwmfreq(struct device *dev, struct device_attribute *attr,
+                            char *buf)
+{
+        struct adt7475_data *data = adt7475_update_device(dev);
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+
+        return sprintf(buf, "%d\n",
+                       pwmfreq_table[data->range[sattr->index] & 7]);
+}
+
+static ssize_t set_pwmfreq(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
+{
+        struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr);
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        int out;
+        long val;
+
+        if (strict_strtol(buf, 10, &val))
+                return -EINVAL;
+
+        out = find_nearest(val, pwmfreq_table, ARRAY_SIZE(pwmfreq_table));
+
+        mutex_lock(&data->lock);
+
+        data->range[sattr->index] =
+                adt7475_read(TEMP_TRANGE_REG(sattr->index));
+        data->range[sattr->index] &= ~7;
+        data->range[sattr->index] |= out;
+
+        i2c_smbus_write_byte_data(client, TEMP_TRANGE_REG(sattr->index),
+                                  data->range[sattr->index]);
+
+        mutex_unlock(&data->lock);
+        return count;
+}
+
+static SENSOR_DEVICE_ATTR_2(in1_input, S_IRUGO, show_voltage, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(in1_max, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MAX, 0);
+static SENSOR_DEVICE_ATTR_2(in1_min, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MIN, 0);
+static SENSOR_DEVICE_ATTR_2(in1_alarm, S_IRUGO, show_voltage, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(in2_input, S_IRUGO, show_voltage, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(in2_max, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MAX, 1);
+static SENSOR_DEVICE_ATTR_2(in2_min, S_IRUGO | S_IWUSR, show_voltage,
+                            set_voltage, MIN, 1);
+static SENSOR_DEVICE_ATTR_2(in2_alarm, S_IRUGO, show_voltage, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_alarm, S_IRUGO, show_temp, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_fault, S_IRUGO, show_temp, NULL, FAULT, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            MAX, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_min, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            MIN, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_offset, S_IRUGO | S_IWUSR, show_temp,
+                            set_temp, OFFSET, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_point1_temp, S_IRUGO | S_IWUSR,
+                            show_temp, set_temp, AUTOMIN, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_auto_point2_temp, S_IRUGO | S_IWUSR,
+                            show_point2, set_point2, 0, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            THERM, 0);
+static SENSOR_DEVICE_ATTR_2(temp1_crit_hyst, S_IRUGO | S_IWUSR, show_temp,
+                            set_temp, HYSTERSIS, 0);
+static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_alarm, S_IRUGO, show_temp, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            MAX, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_min, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            MIN, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IRUGO | S_IWUSR, show_temp,
+                            set_temp, OFFSET, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_point1_temp, S_IRUGO | S_IWUSR,
+                            show_temp, set_temp, AUTOMIN, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_auto_point2_temp, S_IRUGO | S_IWUSR,
+                            show_point2, set_point2, 0, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            THERM, 1);
+static SENSOR_DEVICE_ATTR_2(temp2_crit_hyst, S_IRUGO | S_IWUSR, show_temp,
+                            set_temp, HYSTERSIS, 1);
+static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_alarm, S_IRUGO, show_temp, NULL, ALARM, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_temp, NULL, FAULT, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_max, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            MAX, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_min, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            MIN, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_offset, S_IRUGO | S_IWUSR, show_temp,
+                            set_temp, OFFSET, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_point1_temp, S_IRUGO | S_IWUSR,
+                            show_temp, set_temp, AUTOMIN, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_auto_point2_temp, S_IRUGO | S_IWUSR,
+                            show_point2, set_point2, 0, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IRUGO | S_IWUSR, show_temp, set_temp,
+                            THERM, 2);
+static SENSOR_DEVICE_ATTR_2(temp3_crit_hyst, S_IRUGO | S_IWUSR, show_temp,
+                            set_temp, HYSTERSIS, 2);
+static SENSOR_DEVICE_ATTR_2(fan1_input, S_IRUGO, show_tach, NULL, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(fan1_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
+                            MIN, 0);
+static SENSOR_DEVICE_ATTR_2(fan1_alarm, S_IRUGO, show_tach, NULL, ALARM, 0);
+static SENSOR_DEVICE_ATTR_2(fan2_input, S_IRUGO, show_tach, NULL, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(fan2_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
+                            MIN, 1);
+static SENSOR_DEVICE_ATTR_2(fan2_alarm, S_IRUGO, show_tach, NULL, ALARM, 1);
+static SENSOR_DEVICE_ATTR_2(fan3_input, S_IRUGO, show_tach, NULL, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(fan3_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
+                            MIN, 2);
+static SENSOR_DEVICE_ATTR_2(fan3_alarm, S_IRUGO, show_tach, NULL, ALARM, 2);
+static SENSOR_DEVICE_ATTR_2(fan4_input, S_IRUGO, show_tach, NULL, INPUT, 3);
+static SENSOR_DEVICE_ATTR_2(fan4_min, S_IRUGO | S_IWUSR, show_tach, set_tach,
+                            MIN, 3);
+static SENSOR_DEVICE_ATTR_2(fan4_alarm, S_IRUGO, show_tach, NULL, ALARM, 3);
+static SENSOR_DEVICE_ATTR_2(pwm1, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT,
+                            0);
+static SENSOR_DEVICE_ATTR_2(pwm1_freq, S_IRUGO | S_IWUSR, show_pwmfreq,
+                            set_pwmfreq, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_enable, S_IRUGO | S_IWUSR, show_pwmctrl,
+                            set_pwmctrl, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_channel_temp, S_IRUGO | S_IWUSR,
+                            show_pwmchan, set_pwmchan, INPUT, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
+                            set_pwm, MIN, 0);
+static SENSOR_DEVICE_ATTR_2(pwm1_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
+                            set_pwm, MAX, 0);
+static SENSOR_DEVICE_ATTR_2(pwm2, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT,
+                            1);
+static SENSOR_DEVICE_ATTR_2(pwm2_freq, S_IRUGO | S_IWUSR, show_pwmfreq,
+                            set_pwmfreq, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_enable, S_IRUGO | S_IWUSR, show_pwmctrl,
+                            set_pwmctrl, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_channel_temp, S_IRUGO | S_IWUSR,
+                            show_pwmchan, set_pwmchan, INPUT, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
+                            set_pwm, MIN, 1);
+static SENSOR_DEVICE_ATTR_2(pwm2_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
+                            set_pwm, MAX, 1);
+static SENSOR_DEVICE_ATTR_2(pwm3, S_IRUGO | S_IWUSR, show_pwm, set_pwm, INPUT,
+                            2);
+static SENSOR_DEVICE_ATTR_2(pwm3_freq, S_IRUGO | S_IWUSR, show_pwmfreq,
+                            set_pwmfreq, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_enable, S_IRUGO | S_IWUSR, show_pwmctrl,
+                            set_pwmctrl, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_channel_temp, S_IRUGO | S_IWUSR,
+                            show_pwmchan, set_pwmchan, INPUT, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point1_pwm, S_IRUGO | S_IWUSR, show_pwm,
+                            set_pwm, MIN, 2);
+static SENSOR_DEVICE_ATTR_2(pwm3_auto_point2_pwm, S_IRUGO | S_IWUSR, show_pwm,
+                            set_pwm, MAX, 2);
+
+static struct attribute *adt7475_attrs[] = {
+        &sensor_dev_attr_in1_input.dev_attr.attr,
+        &sensor_dev_attr_in1_max.dev_attr.attr,
+        &sensor_dev_attr_in1_min.dev_attr.attr,
+        &sensor_dev_attr_in1_alarm.dev_attr.attr,
+        &sensor_dev_attr_in2_input.dev_attr.attr,
+        &sensor_dev_attr_in2_max.dev_attr.attr,
+        &sensor_dev_attr_in2_min.dev_attr.attr,
+        &sensor_dev_attr_in2_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_input.dev_attr.attr,
+        &sensor_dev_attr_temp1_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp1_fault.dev_attr.attr,
+        &sensor_dev_attr_temp1_max.dev_attr.attr,
+        &sensor_dev_attr_temp1_min.dev_attr.attr,
+        &sensor_dev_attr_temp1_offset.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_temp1_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit.dev_attr.attr,
+        &sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp2_input.dev_attr.attr,
+        &sensor_dev_attr_temp2_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp2_max.dev_attr.attr,
+        &sensor_dev_attr_temp2_min.dev_attr.attr,
+        &sensor_dev_attr_temp2_offset.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_temp2_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit.dev_attr.attr,
+        &sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
+        &sensor_dev_attr_temp3_input.dev_attr.attr,
+        &sensor_dev_attr_temp3_fault.dev_attr.attr,
+        &sensor_dev_attr_temp3_alarm.dev_attr.attr,
+        &sensor_dev_attr_temp3_max.dev_attr.attr,
+        &sensor_dev_attr_temp3_min.dev_attr.attr,
+        &sensor_dev_attr_temp3_offset.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_point1_temp.dev_attr.attr,
+        &sensor_dev_attr_temp3_auto_point2_temp.dev_attr.attr,
+        &sensor_dev_attr_temp3_crit.dev_attr.attr,
+        &sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
+        &sensor_dev_attr_fan1_input.dev_attr.attr,
+        &sensor_dev_attr_fan1_min.dev_attr.attr,
+        &sensor_dev_attr_fan1_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan2_input.dev_attr.attr,
+        &sensor_dev_attr_fan2_min.dev_attr.attr,
+        &sensor_dev_attr_fan2_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan3_input.dev_attr.attr,
+        &sensor_dev_attr_fan3_min.dev_attr.attr,
+        &sensor_dev_attr_fan3_alarm.dev_attr.attr,
+        &sensor_dev_attr_fan4_input.dev_attr.attr,
+        &sensor_dev_attr_fan4_min.dev_attr.attr,
+        &sensor_dev_attr_fan4_alarm.dev_attr.attr,
+        &sensor_dev_attr_pwm1.dev_attr.attr,
+        &sensor_dev_attr_pwm1_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm1_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_channel_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm2.dev_attr.attr,
+        &sensor_dev_attr_pwm2_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm2_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_channel_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm3.dev_attr.attr,
+        &sensor_dev_attr_pwm3_freq.dev_attr.attr,
+        &sensor_dev_attr_pwm3_enable.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_channel_temp.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point1_pwm.dev_attr.attr,
+        &sensor_dev_attr_pwm3_auto_point2_pwm.dev_attr.attr,
+        NULL,
+};
+
+struct attribute_group adt7475_attr_group = { .attrs = adt7475_attrs };
+
+static int adt7475_detect(struct i2c_client *client, int kind,
+                          struct i2c_board_info *info)
+{
+        struct i2c_adapter *adapter = client->adapter;
+
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
+                return -ENODEV;
+
+        if (kind <= 0) {
+                if (adt7475_read(REG_VENDID) != 0x41 ||
+                    adt7475_read(REG_DEVID) != 0x75) {
+                        dev_err(&adapter->dev,
+                                "Couldn't detect a adt7475 part at 0x%02x\n",
+                                (unsigned int)client->addr);
+                        return -ENODEV;
+                }
+        }
+
+        strlcpy(info->type, adt7475_id[0].name, I2C_NAME_SIZE);
+
+        return 0;
+}
+
+static int adt7475_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct adt7475_data *data;
+        int i, ret = 0;
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (data == NULL)
+                return -ENOMEM;
+
+        mutex_init(&data->lock);
+        i2c_set_clientdata(client, data);
+
+        /* Call adt7475_read_pwm for all pwm's as this will reprogram any
+           pwm's which are disabled to manual mode with 0% duty cycle */
+        for (i = 0; i < ADT7475_PWM_COUNT; i++)
+                adt7475_read_pwm(client, i);
+
+        ret = sysfs_create_group(&client->dev.kobj, &adt7475_attr_group);
+        if (ret)
+                goto efree;
+
+        data->hwmon_dev = hwmon_device_register(&client->dev);
+        if (IS_ERR(data->hwmon_dev)) {
+                ret = PTR_ERR(data->hwmon_dev);
+                goto eremove;
+        }
+
+        return 0;
+
+eremove:
+        sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
+efree:
+        kfree(data);
+        return ret;
+}
+
+static int adt7475_remove(struct i2c_client *client)
+{
+        struct adt7475_data *data = i2c_get_clientdata(client);
+
+        hwmon_device_unregister(data->hwmon_dev);
+        sysfs_remove_group(&client->dev.kobj, &adt7475_attr_group);
+        kfree(data);
+
+        return 0;
+}
+
+static struct i2c_driver adt7475_driver = {
+        .class          = I2C_CLASS_HWMON,
+        .driver = {
+                .name   = "adt7475",
+        },
+        .probe          = adt7475_probe,
+        .remove         = adt7475_remove,
+        .id_table       = adt7475_id,
+        .detect         = adt7475_detect,
+        .address_data   = &addr_data,
+};
+
+static void adt7475_read_hystersis(struct i2c_client *client)
+{
+        struct adt7475_data *data = i2c_get_clientdata(client);
+
+        data->temp[HYSTERSIS][0] = (u16) adt7475_read(REG_REMOTE1_HYSTERSIS);
+        data->temp[HYSTERSIS][1] = data->temp[HYSTERSIS][0];
+        data->temp[HYSTERSIS][2] = (u16) adt7475_read(REG_REMOTE2_HYSTERSIS);
+}
+
+static void adt7475_read_pwm(struct i2c_client *client, int index)
+{
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        unsigned int v;
+
+        data->pwm[CONTROL][index] = adt7475_read(PWM_CONFIG_REG(index));
+
+        /* Figure out the internal value for pwmctrl and pwmchan
+           based on the current settings */
+        v = (data->pwm[CONTROL][index] >> 5) & 7;
+
+        if (v == 3)
+                data->pwmctl[index] = 0;
+        else if (v == 7)
+                data->pwmctl[index] = 1;
+        else if (v == 4) {
+                /* The fan is disabled - we don't want to
+                   support that, so change to manual mode and
+                   set the duty cycle to 0 instead
+                */
+                data->pwm[INPUT][index] = 0;
+                data->pwm[CONTROL][index] &= ~0xE0;
+                data->pwm[CONTROL][index] |= (7 << 5);
+
+                i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
+                                          data->pwm[INPUT][index]);
+
+                i2c_smbus_write_byte_data(client, PWM_CONFIG_REG(index),
+                                          data->pwm[CONTROL][index]);
+
+                data->pwmctl[index] = 1;
+        } else {
+                data->pwmctl[index] = 2;
+
+                switch (v) {
+                case 0:
+                        data->pwmchan[index] = 1;
+                        break;
+                case 1:
+                        data->pwmchan[index] = 2;
+                        break;
+                case 2:
+                        data->pwmchan[index] = 4;
+                        break;
+                case 5:
+                        data->pwmchan[index] = 6;
+                        break;
+                case 6:
+                        data->pwmchan[index] = 7;
+                        break;
+                }
+        }
+}
+
+static struct adt7475_data *adt7475_update_device(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adt7475_data *data = i2c_get_clientdata(client);
+        u8 ext;
+        int i;
+
+        mutex_lock(&data->lock);
+
+        /* Measurement values update every 2 seconds */
+        if (time_after(jiffies, data->measure_updated + HZ * 2) ||
+            !data->valid) {
+                data->alarms = adt7475_read(REG_STATUS2) << 8;
+                data->alarms |= adt7475_read(REG_STATUS1);
+
+                ext = adt7475_read(REG_EXTEND1);
+                for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++)
+                        data->voltage[INPUT][i] =
+                                (adt7475_read(VOLTAGE_REG(i)) << 2) |
+                                ((ext >> ((i + 1) * 2)) & 3);
+
+                ext = adt7475_read(REG_EXTEND2);
+                for (i = 0; i < ADT7475_TEMP_COUNT; i++)
+                        data->temp[INPUT][i] =
+                                (adt7475_read(TEMP_REG(i)) << 2) |
+                                ((ext >> ((i + 1) * 2)) & 3);
+
+                for (i = 0; i < ADT7475_TACH_COUNT; i++)
+                        data->tach[INPUT][i] =
+                                adt7475_read_word(client, TACH_REG(i));
+
+                /* Updated by hw when in auto mode */
+                for (i = 0; i < ADT7475_PWM_COUNT; i++)
+                        data->pwm[INPUT][i] = adt7475_read(PWM_REG(i));
+
+                data->measure_updated = jiffies;
+        }
+
+        /* Limits and settings, should never change update every 60 seconds */
+        if (time_after(jiffies, data->limits_updated + HZ * 2) ||
+            !data->valid) {
+                data->config5 = adt7475_read(REG_CONFIG5);
+
+                for (i = 0; i < ADT7475_VOLTAGE_COUNT; i++) {
+                        /* Adjust values so they match the input precision */
+                        data->voltage[MIN][i] =
+                                adt7475_read(VOLTAGE_MIN_REG(i)) << 2;
+                        data->voltage[MAX][i] =
+                                adt7475_read(VOLTAGE_MAX_REG(i)) << 2;
+                }
+
+                for (i = 0; i < ADT7475_TEMP_COUNT; i++) {
+                        /* Adjust values so they match the input precision */
+                        data->temp[MIN][i] =
+                                adt7475_read(TEMP_MIN_REG(i)) << 2;
+                        data->temp[MAX][i] =
+                                adt7475_read(TEMP_MAX_REG(i)) << 2;
+                        data->temp[AUTOMIN][i] =
+                                adt7475_read(TEMP_TMIN_REG(i)) << 2;
+                        data->temp[THERM][i] =
+                                adt7475_read(TEMP_THERM_REG(i)) << 2;
+                        data->temp[OFFSET][i] =
+                                adt7475_read(TEMP_OFFSET_REG(i));
+                }
+                adt7475_read_hystersis(client);
+
+                for (i = 0; i < ADT7475_TACH_COUNT; i++)
+                        data->tach[MIN][i] =
+                                adt7475_read_word(client, TACH_MIN_REG(i));
+
+                for (i = 0; i < ADT7475_PWM_COUNT; i++) {
+                        data->pwm[MAX][i] = adt7475_read(PWM_MAX_REG(i));
+                        data->pwm[MIN][i] = adt7475_read(PWM_MIN_REG(i));
+                        /* Set the channel and control information */
+                        adt7475_read_pwm(client, i);
+                }
+
+                data->range[0] = adt7475_read(TEMP_TRANGE_REG(0));
+                data->range[1] = adt7475_read(TEMP_TRANGE_REG(1));
+                data->range[2] = adt7475_read(TEMP_TRANGE_REG(2));
+
+                data->limits_updated = jiffies;
+                data->valid = 1;
+        }
+
+        mutex_unlock(&data->lock);
+
+        return data;
+}
+
+static int __init sensors_adt7475_init(void)
+{
+        return i2c_add_driver(&adt7475_driver);
+}
+
+static void __exit sensors_adt7475_exit(void)
+{
+        i2c_del_driver(&adt7475_driver);
+}
+
+MODULE_AUTHOR("Advanced Micro Devices, Inc");
+MODULE_DESCRIPTION("adt7475 driver");
+MODULE_LICENSE("GPL");
+
+module_init(sensors_adt7475_init);
+module_exit(sensors_adt7475_exit);
diff --git a/drivers/hwmon/applesmc.c b/drivers/hwmon/applesmc.c
index dca47a591baf..e30186236588 100644
--- a/drivers/hwmon/applesmc.c
+++ b/drivers/hwmon/applesmc.c
@@ -590,6 +590,11 @@ static ssize_t applesmc_light_show(struct device *dev,
         }
 
         ret = applesmc_read_key(LIGHT_SENSOR_LEFT_KEY, buffer, data_length);
+        /* newer macbooks report a single 10-bit bigendian value */
+        if (data_length == 10) {
+                left = be16_to_cpu(*(__be16 *)(buffer + 6)) >> 2;
+                goto out;
+        }
         left = buffer[2];
         if (ret)
                 goto out;
diff --git a/drivers/hwmon/hp_accel.c b/drivers/hwmon/hp_accel.c
index bf8d40580577..03705240000f 100644
--- a/drivers/hwmon/hp_accel.c
+++ b/drivers/hwmon/hp_accel.c
@@ -3,7 +3,7 @@
  *
  *  Copyright (C) 2007-2008 Yan Burman
  *  Copyright (C) 2008 Eric Piel
- *  Copyright (C) 2008 Pavel Machek
+ *  Copyright (C) 2008-2009 Pavel Machek
  *
  *  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
@@ -36,6 +36,7 @@
 #include <linux/freezer.h>
 #include <linux/version.h>
 #include <linux/uaccess.h>
+#include <linux/leds.h>
 #include <acpi/acpi_drivers.h>
 #include <asm/atomic.h>
 #include "lis3lv02d.h"
@@ -43,6 +44,36 @@
 #define DRIVER_NAME     "lis3lv02d"
 #define ACPI_MDPS_CLASS "accelerometer"
 
+/* Delayed LEDs infrastructure ------------------------------------ */
+
+/* Special LED class that can defer work */
+struct delayed_led_classdev {
+        struct led_classdev led_classdev;
+        struct work_struct work;
+        enum led_brightness new_brightness;
+
+        unsigned int led;               /* For driver */
+        void (*set_brightness)(struct delayed_led_classdev *data, enum led_brightness value);
+};
+
+static inline void delayed_set_status_worker(struct work_struct *work)
+{
+        struct delayed_led_classdev *data =
+                        container_of(work, struct delayed_led_classdev, work);
+
+        data->set_brightness(data, data->new_brightness);
+}
+
+static inline void delayed_sysfs_set(struct led_classdev *led_cdev,
+                              enum led_brightness brightness)
+{
+        struct delayed_led_classdev *data = container_of(led_cdev,
+                             struct delayed_led_classdev, led_classdev);
+        data->new_brightness = brightness;
+        schedule_work(&data->work);
+}
+
+/* HP-specific accelerometer driver ------------------------------------ */
 
 /* For automatic insertion of the module */
 static struct acpi_device_id lis3lv02d_device_ids[] = {
@@ -154,10 +185,33 @@ static struct dmi_system_id lis3lv02d_dmi_ids[] = {
  */
 };
 
+static void hpled_set(struct delayed_led_classdev *led_cdev, enum led_brightness value)
+{
+        acpi_handle handle = adev.device->handle;
+        unsigned long long ret; /* Not used when writing */
+        union acpi_object in_obj[1];
+        struct acpi_object_list args = { 1, in_obj };
+
+        in_obj[0].type          = ACPI_TYPE_INTEGER;
+        in_obj[0].integer.value = !!value;
+
+        acpi_evaluate_integer(handle, "ALED", &args, &ret);
+}
+
+static struct delayed_led_classdev hpled_led = {
+        .led_classdev = {
+                .name                   = "hp::hddprotect",
+                .default_trigger        = "none",
+                .brightness_set         = delayed_sysfs_set,
+                .flags                  = LED_CORE_SUSPENDRESUME,
+        },
+        .set_brightness = hpled_set,
+};
 
 static int lis3lv02d_add(struct acpi_device *device)
 {
         u8 val;
+        int ret;
 
         if (!device)
                 return -EINVAL;
@@ -183,7 +237,19 @@ static int lis3lv02d_add(struct acpi_device *device)
                 adev.ac = lis3lv02d_axis_normal;
         }
 
-        return lis3lv02d_init_device(&adev);
+        INIT_WORK(&hpled_led.work, delayed_set_status_worker);
+        ret = led_classdev_register(NULL, &hpled_led.led_classdev);
+        if (ret)
+                return ret;
+
+        ret = lis3lv02d_init_device(&adev);
+        if (ret) {
+                flush_work(&hpled_led.work);
+                led_classdev_unregister(&hpled_led.led_classdev);
+                return ret;
+        }
+
+        return ret;
 }
 
 static int lis3lv02d_remove(struct acpi_device *device, int type)
@@ -194,6 +260,9 @@ static int lis3lv02d_remove(struct acpi_device *device, int type)
         lis3lv02d_joystick_disable();
         lis3lv02d_poweroff(device->handle);
 
+        flush_work(&hpled_led.work);
+        led_classdev_unregister(&hpled_led.led_classdev);
+
         return lis3lv02d_remove_fs();
 }
 
@@ -256,7 +325,7 @@ static void __exit lis3lv02d_exit_module(void)
         acpi_bus_unregister_driver(&lis3lv02d_driver);
 }
 
-MODULE_DESCRIPTION("Glue between LIS3LV02Dx and HP ACPI BIOS");
+MODULE_DESCRIPTION("Glue between LIS3LV02Dx and HP ACPI BIOS and support for disk protection LED.");
 MODULE_AUTHOR("Yan Burman, Eric Piel, Pavel Machek");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/hwmon/k8temp.c b/drivers/hwmon/k8temp.c
index bd2bde0ef95e..1fe995111841 100644
--- a/drivers/hwmon/k8temp.c
+++ b/drivers/hwmon/k8temp.c
@@ -31,6 +31,7 @@
 #include <linux/hwmon-sysfs.h>
 #include <linux/err.h>
 #include <linux/mutex.h>
+#include <asm/processor.h>
 
 #define TEMP_FROM_REG(val)      (((((val) >> 16) & 0xff) - 49) * 1000)
 #define REG_TEMP        0xe4
@@ -47,6 +48,8 @@ struct k8temp_data {
         /* registers values */
         u8 sensorsp;            /* sensor presence bits - SEL_CORE & SEL_PLACE */
         u32 temp[2][2];         /* core, place */
+        u8 swap_core_select;    /* meaning of SEL_CORE is inverted */
+        u32 temp_offset;
 };
 
 static struct k8temp_data *k8temp_update_device(struct device *dev)
@@ -114,10 +117,15 @@ static ssize_t show_temp(struct device *dev,
             to_sensor_dev_attr_2(devattr);
         int core = attr->nr;
         int place = attr->index;
+        int temp;
         struct k8temp_data *data = k8temp_update_device(dev);
 
-        return sprintf(buf, "%d\n",
-                       TEMP_FROM_REG(data->temp[core][place]));
+        if (data->swap_core_select)
+                core = core ? 0 : 1;
+
+        temp = TEMP_FROM_REG(data->temp[core][place]) + data->temp_offset;
+
+        return sprintf(buf, "%d\n", temp);
 }
 
 /* core, place */
@@ -141,20 +149,49 @@ static int __devinit k8temp_probe(struct pci_dev *pdev,
         int err;
         u8 scfg;
         u32 temp;
+        u8 model, stepping;
         struct k8temp_data *data;
-        u32 cpuid = cpuid_eax(1);
-
-        /* this feature should be available since SH-C0 core */
-        if ((cpuid == 0xf40) || (cpuid == 0xf50) || (cpuid == 0xf51)) {
-                err = -ENODEV;
-                goto exit;
-        }
 
         if (!(data = kzalloc(sizeof(struct k8temp_data), GFP_KERNEL))) {
                 err = -ENOMEM;
                 goto exit;
         }
 
+        model = boot_cpu_data.x86_model;
+        stepping = boot_cpu_data.x86_mask;
+
+        switch (boot_cpu_data.x86) {
+        case 0xf:
+                /* feature available since SH-C0, exclude older revisions */
+                if (((model == 4) && (stepping == 0)) ||
+                    ((model == 5) && (stepping <= 1))) {
+                        err = -ENODEV;
+                        goto exit_free;
+                }
+
+                /*
+                 * AMD NPT family 0fh, i.e. RevF and RevG:
+                 * meaning of SEL_CORE bit is inverted
+                 */
+                if (model >= 0x40) {
+                        data->swap_core_select = 1;
+                        dev_warn(&pdev->dev, "Temperature readouts might be "
+                                 "wrong - check erratum #141\n");
+                }
+
+                if ((model >= 0x69) &&
+                    !(model == 0xc1 || model == 0x6c || model == 0x7c)) {
+                        /*
+                         * RevG desktop CPUs (i.e. no socket S1G1 parts)
+                         * need additional offset, otherwise reported
+                         * temperature is below ambient temperature
+                         */
+                        data->temp_offset = 21000;
+                }
+
+                break;
+        }
+
         pci_read_config_byte(pdev, REG_TEMP, &scfg);
         scfg &= ~(SEL_PLACE | SEL_CORE);                /* Select sensor 0, core0 */
         pci_write_config_byte(pdev, REG_TEMP, scfg);
diff --git a/drivers/i2c/busses/i2c-acorn.c b/drivers/i2c/busses/i2c-acorn.c
index 75089febbc13..9fee3ca17344 100644
--- a/drivers/i2c/busses/i2c-acorn.c
+++ b/drivers/i2c/busses/i2c-acorn.c
@@ -83,7 +83,6 @@ static struct i2c_algo_bit_data ioc_data = {
 };
 
 static struct i2c_adapter ioc_ops = {
-        .id                     = I2C_HW_B_IOC,
         .algo_data              = &ioc_data,
 };
 
diff --git a/drivers/i2c/busses/i2c-ali1535.c b/drivers/i2c/busses/i2c-ali1535.c
index 9cead9b9458e..981e080b32ae 100644
--- a/drivers/i2c/busses/i2c-ali1535.c
+++ b/drivers/i2c/busses/i2c-ali1535.c
@@ -476,7 +476,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter ali1535_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_ALI1535,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-ali1563.c b/drivers/i2c/busses/i2c-ali1563.c
index dd9e796fad69..f70f46582c6c 100644
--- a/drivers/i2c/busses/i2c-ali1563.c
+++ b/drivers/i2c/busses/i2c-ali1563.c
@@ -386,7 +386,6 @@ static const struct i2c_algorithm ali1563_algorithm = {
 
 static struct i2c_adapter ali1563_adapter = {
         .owner  = THIS_MODULE,
-        .id     = I2C_HW_SMBUS_ALI1563,
         .class  = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo   = &ali1563_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-ali15x3.c b/drivers/i2c/busses/i2c-ali15x3.c
index 234fdde7d40e..39066dee46e3 100644
--- a/drivers/i2c/busses/i2c-ali15x3.c
+++ b/drivers/i2c/busses/i2c-ali15x3.c
@@ -473,7 +473,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter ali15x3_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_ALI15X3,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-amd756.c b/drivers/i2c/busses/i2c-amd756.c
index 36bee5b9c952..220f4a1eee1d 100644
--- a/drivers/i2c/busses/i2c-amd756.c
+++ b/drivers/i2c/busses/i2c-amd756.c
@@ -298,7 +298,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 struct i2c_adapter amd756_smbus = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_AMD756,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-amd8111.c b/drivers/i2c/busses/i2c-amd8111.c
index 3972208876b3..edab51973bf5 100644
--- a/drivers/i2c/busses/i2c-amd8111.c
+++ b/drivers/i2c/busses/i2c-amd8111.c
@@ -387,7 +387,6 @@ static int __devinit amd8111_probe(struct pci_dev *dev,
         smbus->adapter.owner = THIS_MODULE;
         snprintf(smbus->adapter.name, sizeof(smbus->adapter.name),
                 "SMBus2 AMD8111 adapter at %04x", smbus->base);
-        smbus->adapter.id = I2C_HW_SMBUS_AMD8111;
         smbus->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         smbus->adapter.algo = &smbus_algorithm;
         smbus->adapter.algo_data = smbus;
diff --git a/drivers/i2c/busses/i2c-au1550.c b/drivers/i2c/busses/i2c-au1550.c
index 66a04c2c660f..f78ce523e3db 100644
--- a/drivers/i2c/busses/i2c-au1550.c
+++ b/drivers/i2c/busses/i2c-au1550.c
@@ -400,7 +400,6 @@ i2c_au1550_probe(struct platform_device *pdev)
         priv->xfer_timeout = 200;
         priv->ack_timeout = 200;
 
-        priv->adap.id = I2C_HW_AU1550_PSC;
         priv->adap.nr = pdev->id;
         priv->adap.algo = &au1550_algo;
         priv->adap.algo_data = priv;
diff --git a/drivers/i2c/busses/i2c-bfin-twi.c b/drivers/i2c/busses/i2c-bfin-twi.c
index 3fd2c417c1e0..fc548b3d002e 100644
--- a/drivers/i2c/busses/i2c-bfin-twi.c
+++ b/drivers/i2c/busses/i2c-bfin-twi.c
@@ -651,7 +651,6 @@ static int i2c_bfin_twi_probe(struct platform_device *pdev)
         iface->timeout_timer.data = (unsigned long)iface;
 
         p_adap = &iface->adap;
-        p_adap->id = I2C_HW_BLACKFIN;
         p_adap->nr = pdev->id;
         strlcpy(p_adap->name, pdev->name, sizeof(p_adap->name));
         p_adap->algo = &bfin_twi_algorithm;
diff --git a/drivers/i2c/busses/i2c-elektor.c b/drivers/i2c/busses/i2c-elektor.c
index 0ed3ccb81b63..448b4bf35eb7 100644
--- a/drivers/i2c/busses/i2c-elektor.c
+++ b/drivers/i2c/busses/i2c-elektor.c
@@ -202,7 +202,6 @@ static struct i2c_algo_pcf_data pcf_isa_data = {
 static struct i2c_adapter pcf_isa_ops = {
         .owner          = THIS_MODULE,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
-        .id             = I2C_HW_P_ELEK,
         .algo_data      = &pcf_isa_data,
         .name           = "i2c-elektor",
 };
diff --git a/drivers/i2c/busses/i2c-hydra.c b/drivers/i2c/busses/i2c-hydra.c
index 648aa7baff83..bec9b845dd16 100644
--- a/drivers/i2c/busses/i2c-hydra.c
+++ b/drivers/i2c/busses/i2c-hydra.c
@@ -102,7 +102,6 @@ static struct i2c_algo_bit_data hydra_bit_data = {
 static struct i2c_adapter hydra_adap = {
         .owner          = THIS_MODULE,
         .name           = "Hydra i2c",
-        .id             = I2C_HW_B_HYDRA,
         .algo_data      = &hydra_bit_data,
 };
 
diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
index 526625eaa84b..230238df56c4 100644
--- a/drivers/i2c/busses/i2c-i801.c
+++ b/drivers/i2c/busses/i2c-i801.c
@@ -556,7 +556,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter i801_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_I801,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-ibm_iic.c b/drivers/i2c/busses/i2c-ibm_iic.c
index 651f2f1ae5b7..88f0db73b364 100644
--- a/drivers/i2c/busses/i2c-ibm_iic.c
+++ b/drivers/i2c/busses/i2c-ibm_iic.c
@@ -746,7 +746,6 @@ static int __devinit iic_probe(struct of_device *ofdev,
         adap->dev.parent = &ofdev->dev;
         strlcpy(adap->name, "IBM IIC", sizeof(adap->name));
         i2c_set_adapdata(adap, dev);
-        adap->id = I2C_HW_OCP;
         adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         adap->algo = &iic_algo;
         adap->timeout = 1;
diff --git a/drivers/i2c/busses/i2c-iop3xx.c b/drivers/i2c/busses/i2c-iop3xx.c
index fc2714ac0c0f..3190690c26ce 100644
--- a/drivers/i2c/busses/i2c-iop3xx.c
+++ b/drivers/i2c/busses/i2c-iop3xx.c
@@ -480,7 +480,6 @@ iop3xx_i2c_probe(struct platform_device *pdev)
         }
 
         memcpy(new_adapter->name, pdev->name, strlen(pdev->name));
-        new_adapter->id = I2C_HW_IOP3XX;
         new_adapter->owner = THIS_MODULE;
         new_adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         new_adapter->dev.parent = &pdev->dev;
diff --git a/drivers/i2c/busses/i2c-ixp2000.c b/drivers/i2c/busses/i2c-ixp2000.c
index 05d72e981353..8e8467970481 100644
--- a/drivers/i2c/busses/i2c-ixp2000.c
+++ b/drivers/i2c/busses/i2c-ixp2000.c
@@ -116,7 +116,6 @@ static int ixp2000_i2c_probe(struct platform_device *plat_dev)
         drv_data->algo_data.udelay = 6;
         drv_data->algo_data.timeout = 100;
 
-        drv_data->adapter.id = I2C_HW_B_IXP2000,
         strlcpy(drv_data->adapter.name, plat_dev->dev.driver->name,
                 sizeof(drv_data->adapter.name));
         drv_data->adapter.algo_data = &drv_data->algo_data,
diff --git a/drivers/i2c/busses/i2c-mpc.c b/drivers/i2c/busses/i2c-mpc.c
index a9a45fcc8544..aedbbe6618db 100644
--- a/drivers/i2c/busses/i2c-mpc.c
+++ b/drivers/i2c/busses/i2c-mpc.c
@@ -310,7 +310,6 @@ static const struct i2c_algorithm mpc_algo = {
 static struct i2c_adapter mpc_ops = {
         .owner = THIS_MODULE,
         .name = "MPC adapter",
-        .id = I2C_HW_MPC107,
         .algo = &mpc_algo,
         .timeout = 1,
 };
diff --git a/drivers/i2c/busses/i2c-mv64xxx.c b/drivers/i2c/busses/i2c-mv64xxx.c
index 9e8118d2fe64..eeda276f8f16 100644
--- a/drivers/i2c/busses/i2c-mv64xxx.c
+++ b/drivers/i2c/busses/i2c-mv64xxx.c
@@ -527,7 +527,6 @@ mv64xxx_i2c_probe(struct platform_device *pd)
                 goto exit_unmap_regs;
         }
         drv_data->adapter.dev.parent = &pd->dev;
-        drv_data->adapter.id = I2C_HW_MV64XXX;
         drv_data->adapter.algo = &mv64xxx_i2c_algo;
         drv_data->adapter.owner = THIS_MODULE;
         drv_data->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
diff --git a/drivers/i2c/busses/i2c-nforce2.c b/drivers/i2c/busses/i2c-nforce2.c
index 3b19bc41a60b..05af6cd7f270 100644
--- a/drivers/i2c/busses/i2c-nforce2.c
+++ b/drivers/i2c/busses/i2c-nforce2.c
@@ -355,7 +355,6 @@ static int __devinit nforce2_probe_smb (struct pci_dev *dev, int bar,
                 return -EBUSY;
         }
         smbus->adapter.owner = THIS_MODULE;
-        smbus->adapter.id = I2C_HW_SMBUS_NFORCE2;
         smbus->adapter.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         smbus->adapter.algo = &smbus_algorithm;
         smbus->adapter.algo_data = smbus;
diff --git a/drivers/i2c/busses/i2c-parport-light.c b/drivers/i2c/busses/i2c-parport-light.c
index b2b8380f6602..322c5691e38e 100644
--- a/drivers/i2c/busses/i2c-parport-light.c
+++ b/drivers/i2c/busses/i2c-parport-light.c
@@ -115,7 +115,6 @@ static struct i2c_algo_bit_data parport_algo_data = {
 static struct i2c_adapter parport_adapter = {
         .owner          = THIS_MODULE,
         .class          = I2C_CLASS_HWMON,
-        .id             = I2C_HW_B_LP,
         .algo_data      = &parport_algo_data,
         .name           = "Parallel port adapter (light)",
 };
diff --git a/drivers/i2c/busses/i2c-parport.c b/drivers/i2c/busses/i2c-parport.c
index a257cd5cd134..0d8998610c74 100644
--- a/drivers/i2c/busses/i2c-parport.c
+++ b/drivers/i2c/busses/i2c-parport.c
@@ -164,7 +164,6 @@ static void i2c_parport_attach (struct parport *port)
         /* Fill the rest of the structure */
         adapter->adapter.owner = THIS_MODULE;
         adapter->adapter.class = I2C_CLASS_HWMON;
-        adapter->adapter.id = I2C_HW_B_LP;
         strlcpy(adapter->adapter.name, "Parallel port adapter",
                 sizeof(adapter->adapter.name));
         adapter->algo_data = parport_algo_data;
diff --git a/drivers/i2c/busses/i2c-pca-isa.c b/drivers/i2c/busses/i2c-pca-isa.c
index 9eb76268ec78..4aa8138cb0a9 100644
--- a/drivers/i2c/busses/i2c-pca-isa.c
+++ b/drivers/i2c/busses/i2c-pca-isa.c
@@ -101,7 +101,6 @@ static struct i2c_algo_pca_data pca_isa_data = {
 
 static struct i2c_adapter pca_isa_ops = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_A_ISA,
         .algo_data      = &pca_isa_data,
         .name           = "PCA9564 ISA Adapter",
         .timeout        = 100,
diff --git a/drivers/i2c/busses/i2c-piix4.c b/drivers/i2c/busses/i2c-piix4.c
index eaa9b387543e..761f9dd53620 100644
--- a/drivers/i2c/busses/i2c-piix4.c
+++ b/drivers/i2c/busses/i2c-piix4.c
@@ -403,7 +403,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter piix4_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_PIIX4,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-sibyte.c b/drivers/i2c/busses/i2c-sibyte.c
index 4ddefbf238e9..98b1ec489159 100644
--- a/drivers/i2c/busses/i2c-sibyte.c
+++ b/drivers/i2c/busses/i2c-sibyte.c
@@ -155,7 +155,6 @@ static struct i2c_algo_sibyte_data sibyte_board_data[2] = {
 static struct i2c_adapter sibyte_board_adapter[2] = {
         {
                 .owner          = THIS_MODULE,
-                .id             = I2C_HW_SIBYTE,
                 .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
                 .algo           = NULL,
                 .algo_data      = &sibyte_board_data[0],
@@ -164,7 +163,6 @@ static struct i2c_adapter sibyte_board_adapter[2] = {
         },
         {
                 .owner          = THIS_MODULE,
-                .id             = I2C_HW_SIBYTE,
                 .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
                 .algo           = NULL,
                 .algo_data      = &sibyte_board_data[1],
diff --git a/drivers/i2c/busses/i2c-sis5595.c b/drivers/i2c/busses/i2c-sis5595.c
index 8ce2daff985c..f320ab27da46 100644
--- a/drivers/i2c/busses/i2c-sis5595.c
+++ b/drivers/i2c/busses/i2c-sis5595.c
@@ -365,7 +365,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter sis5595_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_SIS5595,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-sis630.c b/drivers/i2c/busses/i2c-sis630.c
index 9c9c016ff2b5..50c3610e6028 100644
--- a/drivers/i2c/busses/i2c-sis630.c
+++ b/drivers/i2c/busses/i2c-sis630.c
@@ -464,7 +464,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter sis630_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_SIS630,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-sis96x.c b/drivers/i2c/busses/i2c-sis96x.c
index f1bba6396641..7e1594b40579 100644
--- a/drivers/i2c/busses/i2c-sis96x.c
+++ b/drivers/i2c/busses/i2c-sis96x.c
@@ -241,7 +241,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter sis96x_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_SIS96X,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-via.c b/drivers/i2c/busses/i2c-via.c
index 29cef0433f34..8b24f192103a 100644
--- a/drivers/i2c/busses/i2c-via.c
+++ b/drivers/i2c/busses/i2c-via.c
@@ -83,7 +83,6 @@ static struct i2c_algo_bit_data bit_data = {
 
 static struct i2c_adapter vt586b_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_B_VIA,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .name           = "VIA i2c",
         .algo_data      = &bit_data,
diff --git a/drivers/i2c/busses/i2c-viapro.c b/drivers/i2c/busses/i2c-viapro.c
index 9f194d9efd91..02e6f724b05f 100644
--- a/drivers/i2c/busses/i2c-viapro.c
+++ b/drivers/i2c/busses/i2c-viapro.c
@@ -321,7 +321,6 @@ static const struct i2c_algorithm smbus_algorithm = {
 
 static struct i2c_adapter vt596_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_SMBUS_VIA2,
         .class          = I2C_CLASS_HWMON | I2C_CLASS_SPD,
         .algo           = &smbus_algorithm,
 };
diff --git a/drivers/i2c/busses/i2c-voodoo3.c b/drivers/i2c/busses/i2c-voodoo3.c
index 1d4ae26ba73d..1a474acc0ddd 100644
--- a/drivers/i2c/busses/i2c-voodoo3.c
+++ b/drivers/i2c/busses/i2c-voodoo3.c
@@ -163,7 +163,6 @@ static struct i2c_algo_bit_data voo_i2c_bit_data = {
 
 static struct i2c_adapter voodoo3_i2c_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_B_VOO,
         .class          = I2C_CLASS_TV_ANALOG, 
         .name           = "I2C Voodoo3/Banshee adapter",
         .algo_data      = &voo_i2c_bit_data,
@@ -180,7 +179,6 @@ static struct i2c_algo_bit_data voo_ddc_bit_data = {
 
 static struct i2c_adapter voodoo3_ddc_adapter = {
         .owner          = THIS_MODULE,
-        .id             = I2C_HW_B_VOO,
         .class          = I2C_CLASS_DDC, 
         .name           = "DDC Voodoo3/Banshee adapter",
         .algo_data      = &voo_ddc_bit_data,
diff --git a/drivers/i2c/busses/scx200_acb.c b/drivers/i2c/busses/scx200_acb.c
index ed794b145a11..648ecc6f60e6 100644
--- a/drivers/i2c/busses/scx200_acb.c
+++ b/drivers/i2c/busses/scx200_acb.c
@@ -440,7 +440,6 @@ static __init struct scx200_acb_iface *scx200_create_iface(const char *text,
         i2c_set_adapdata(adapter, iface);
         snprintf(adapter->name, sizeof(adapter->name), "%s ACB%d", text, index);
         adapter->owner = THIS_MODULE;
-        adapter->id = I2C_HW_SMBUS_SCX200;
         adapter->algo = &scx200_acb_algorithm;
         adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
         adapter->dev.parent = dev;
diff --git a/drivers/i2c/busses/scx200_i2c.c b/drivers/i2c/busses/scx200_i2c.c
index e4c98539c517..162b74a04886 100644
--- a/drivers/i2c/busses/scx200_i2c.c
+++ b/drivers/i2c/busses/scx200_i2c.c
@@ -82,7 +82,6 @@ static struct i2c_algo_bit_data scx200_i2c_data = {
 static struct i2c_adapter scx200_i2c_ops = {
         .owner             = THIS_MODULE,
         .class             = I2C_CLASS_HWMON | I2C_CLASS_SPD,
-        .id                = I2C_HW_B_SCX200,
         .algo_data         = &scx200_i2c_data,
         .name   = "NatSemi SCx200 I2C",
 };
diff --git a/drivers/i2c/chips/Kconfig b/drivers/i2c/chips/Kconfig
index b9bef04b7be4..c80312c1f382 100644
--- a/drivers/i2c/chips/Kconfig
+++ b/drivers/i2c/chips/Kconfig
@@ -16,43 +16,6 @@ config DS1682
           This driver can also be built as a module.  If so, the module
           will be called ds1682.
 
-config AT24
-        tristate "EEPROMs from most vendors"
-        depends on SYSFS && EXPERIMENTAL
-        help
-          Enable this driver to get read/write support to most I2C EEPROMs,
-          after you configure the driver to know about each EEPROM on
-          your target board.  Use these generic chip names, instead of
-          vendor-specific ones like at24c64 or 24lc02:
-
-             24c00, 24c01, 24c02, spd (readonly 24c02), 24c04, 24c08,
-             24c16, 24c32, 24c64, 24c128, 24c256, 24c512, 24c1024
-
-          Unless you like data loss puzzles, always be sure that any chip
-          you configure as a 24c32 (32 kbit) or larger is NOT really a
-          24c16 (16 kbit) or smaller, and vice versa. Marking the chip
-          as read-only won't help recover from this. Also, if your chip
-          has any software write-protect mechanism you may want to review the
-          code to make sure this driver won't turn it on by accident.
-
-          If you use this with an SMBus adapter instead of an I2C adapter,
-          full functionality is not available.  Only smaller devices are
-          supported (24c16 and below, max 4 kByte).
-
-          This driver can also be built as a module.  If so, the module
-          will be called at24.
-
-config SENSORS_EEPROM
-        tristate "EEPROM reader"
-        depends on EXPERIMENTAL
-        help
-          If you say yes here you get read-only access to the EEPROM data
-          available on modern memory DIMMs and Sony Vaio laptops.  Such
-          EEPROMs could theoretically be available on other devices as well.
-
-          This driver can also be built as a module.  If so, the module
-          will be called eeprom.
-
 config SENSORS_PCF8574
         tristate "Philips PCF8574 and PCF8574A (DEPRECATED)"
         depends on EXPERIMENTAL && GPIO_PCF857X = "n"
diff --git a/drivers/i2c/chips/Makefile b/drivers/i2c/chips/Makefile
index 00fcb5193ac2..d142f238a2de 100644
--- a/drivers/i2c/chips/Makefile
+++ b/drivers/i2c/chips/Makefile
@@ -11,8 +11,6 @@
 #
 
 obj-$(CONFIG_DS1682)            += ds1682.o
-obj-$(CONFIG_AT24)              += at24.o
-obj-$(CONFIG_SENSORS_EEPROM)    += eeprom.o
 obj-$(CONFIG_SENSORS_MAX6875)   += max6875.o
 obj-$(CONFIG_SENSORS_PCA9539)   += pca9539.o
 obj-$(CONFIG_SENSORS_PCF8574)   += pcf8574.o
diff --git a/drivers/ide/falconide.c b/drivers/ide/falconide.c
index a5ba820d69bb..a638e952d67a 100644
--- a/drivers/ide/falconide.c
+++ b/drivers/ide/falconide.c
@@ -82,7 +82,7 @@ static const struct ide_tp_ops falconide_tp_ops = {
 
 static const struct ide_port_info falconide_port_info = {
         .tp_ops                 = &falconide_tp_ops,
-        .host_flags             = IDE_HFLAG_NO_DMA,
+        .host_flags             = IDE_HFLAG_NO_DMA | IDE_HFLAG_SERIALIZE,
 };
 
 static void __init falconide_setup_ports(hw_regs_t *hw)
diff --git a/drivers/ide/ide-probe.c b/drivers/ide/ide-probe.c
index 312127ea443a..0db1ed9f5fc2 100644
--- a/drivers/ide/ide-probe.c
+++ b/drivers/ide/ide-probe.c
@@ -649,7 +649,8 @@ static int ide_register_port(ide_hwif_t *hwif)
         /* register with global device tree */
         dev_set_name(&hwif->gendev, hwif->name);
         hwif->gendev.driver_data = hwif;
-        hwif->gendev.parent = hwif->dev;
+        if (hwif->gendev.parent == NULL)
+                hwif->gendev.parent = hwif->dev;
         hwif->gendev.release = hwif_release_dev;
 
         ret = device_register(&hwif->gendev);
diff --git a/drivers/ide/palm_bk3710.c b/drivers/ide/palm_bk3710.c
index a7ac490c9ae3..f38aac78044c 100644
--- a/drivers/ide/palm_bk3710.c
+++ b/drivers/ide/palm_bk3710.c
@@ -346,7 +346,8 @@ static int __init palm_bk3710_probe(struct platform_device *pdev)
 {
         struct clk *clk;
         struct resource *mem, *irq;
-        unsigned long base, rate;
+        void __iomem *base;
+        unsigned long rate;
         int i, rc;
         hw_regs_t hw, *hws[] = { &hw, NULL, NULL, NULL };
 
@@ -382,11 +383,13 @@ static int __init palm_bk3710_probe(struct platform_device *pdev)
         base = IO_ADDRESS(mem->start);
 
         /* Configure the Palm Chip controller */
-        palm_bk3710_chipinit((void __iomem *)base);
+        palm_bk3710_chipinit(base);
 
         for (i = 0; i < IDE_NR_PORTS - 2; i++)
-                hw.io_ports_array[i] = base + IDE_PALM_ATA_PRI_REG_OFFSET + i;
-        hw.io_ports.ctl_addr = base + IDE_PALM_ATA_PRI_CTL_OFFSET;
+                hw.io_ports_array[i] = (unsigned long)
+                                (base + IDE_PALM_ATA_PRI_REG_OFFSET + i);
+        hw.io_ports.ctl_addr = (unsigned long)
+                        (base + IDE_PALM_ATA_PRI_CTL_OFFSET);
         hw.irq = irq->start;
         hw.dev = &pdev->dev;
         hw.chipset = ide_palm3710;
diff --git a/drivers/ieee1394/pcilynx.c b/drivers/ieee1394/pcilynx.c
index dc15cadb06ef..38f712036201 100644
--- a/drivers/ieee1394/pcilynx.c
+++ b/drivers/ieee1394/pcilynx.c
@@ -1419,7 +1419,6 @@ static int __devinit add_card(struct pci_dev *dev,
                 i2c_ad = kzalloc(sizeof(*i2c_ad), GFP_KERNEL);
                 if (!i2c_ad) FAIL("failed to allocate I2C adapter memory");
 
-                i2c_ad->id = I2C_HW_B_PCILYNX;
                 strlcpy(i2c_ad->name, "PCILynx I2C", sizeof(i2c_ad->name));
                 i2c_adapter_data = bit_data;
                 i2c_ad->algo_data = &i2c_adapter_data;
diff --git a/drivers/infiniband/hw/ehca/ehca_cq.c b/drivers/infiniband/hw/ehca/ehca_cq.c
index 2f4c28a30271..97e4b231cdc4 100644
--- a/drivers/infiniband/hw/ehca/ehca_cq.c
+++ b/drivers/infiniband/hw/ehca/ehca_cq.c
@@ -196,7 +196,7 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
 
         if (h_ret != H_SUCCESS) {
                 ehca_err(device, "hipz_h_alloc_resource_cq() failed "
-                         "h_ret=%li device=%p", h_ret, device);
+                         "h_ret=%lli device=%p", h_ret, device);
                 cq = ERR_PTR(ehca2ib_return_code(h_ret));
                 goto create_cq_exit2;
         }
@@ -232,7 +232,7 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
 
                 if (h_ret < H_SUCCESS) {
                         ehca_err(device, "hipz_h_register_rpage_cq() failed "
-                                 "ehca_cq=%p cq_num=%x h_ret=%li counter=%i "
+                                 "ehca_cq=%p cq_num=%x h_ret=%lli counter=%i "
                                  "act_pages=%i", my_cq, my_cq->cq_number,
                                  h_ret, counter, param.act_pages);
                         cq = ERR_PTR(-EINVAL);
@@ -244,7 +244,7 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
                         if ((h_ret != H_SUCCESS) || vpage) {
                                 ehca_err(device, "Registration of pages not "
                                          "complete ehca_cq=%p cq_num=%x "
-                                         "h_ret=%li", my_cq, my_cq->cq_number,
+                                         "h_ret=%lli", my_cq, my_cq->cq_number,
                                          h_ret);
                                 cq = ERR_PTR(-EAGAIN);
                                 goto create_cq_exit4;
@@ -252,7 +252,7 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
                 } else {
                         if (h_ret != H_PAGE_REGISTERED) {
                                 ehca_err(device, "Registration of page failed "
-                                         "ehca_cq=%p cq_num=%x h_ret=%li "
+                                         "ehca_cq=%p cq_num=%x h_ret=%lli "
                                          "counter=%i act_pages=%i",
                                          my_cq, my_cq->cq_number,
                                          h_ret, counter, param.act_pages);
@@ -266,7 +266,7 @@ struct ib_cq *ehca_create_cq(struct ib_device *device, int cqe, int comp_vector,
 
         gal = my_cq->galpas.kernel;
         cqx_fec = hipz_galpa_load(gal, CQTEMM_OFFSET(cqx_fec));
-        ehca_dbg(device, "ehca_cq=%p cq_num=%x CQX_FEC=%lx",
+        ehca_dbg(device, "ehca_cq=%p cq_num=%x CQX_FEC=%llx",
                  my_cq, my_cq->cq_number, cqx_fec);
 
         my_cq->ib_cq.cqe = my_cq->nr_of_entries =
@@ -307,7 +307,7 @@ create_cq_exit3:
         h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 1);
         if (h_ret != H_SUCCESS)
                 ehca_err(device, "hipz_h_destroy_cq() failed ehca_cq=%p "
-                         "cq_num=%x h_ret=%li", my_cq, my_cq->cq_number, h_ret);
+                         "cq_num=%x h_ret=%lli", my_cq, my_cq->cq_number, h_ret);
 
 create_cq_exit2:
         write_lock_irqsave(&ehca_cq_idr_lock, flags);
@@ -355,7 +355,7 @@ int ehca_destroy_cq(struct ib_cq *cq)
         h_ret = hipz_h_destroy_cq(adapter_handle, my_cq, 0);
         if (h_ret == H_R_STATE) {
                 /* cq in err: read err data and destroy it forcibly */
-                ehca_dbg(device, "ehca_cq=%p cq_num=%x ressource=%lx in err "
+                ehca_dbg(device, "ehca_cq=%p cq_num=%x resource=%llx in err "
                          "state. Try to delete it forcibly.",
                          my_cq, cq_num, my_cq->ipz_cq_handle.handle);
                 ehca_error_data(shca, my_cq, my_cq->ipz_cq_handle.handle);
@@ -365,7 +365,7 @@ int ehca_destroy_cq(struct ib_cq *cq)
                                  cq_num);
         }
         if (h_ret != H_SUCCESS) {
-                ehca_err(device, "hipz_h_destroy_cq() failed h_ret=%li "
+                ehca_err(device, "hipz_h_destroy_cq() failed h_ret=%lli "
                          "ehca_cq=%p cq_num=%x", h_ret, my_cq, cq_num);
                 return ehca2ib_return_code(h_ret);
         }
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 46288220cfbb..9209c5332dfe 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -393,7 +393,7 @@ int ehca_modify_port(struct ib_device *ibdev,
         hret = hipz_h_modify_port(shca->ipz_hca_handle, port,
                                   cap, props->init_type, port_modify_mask);
         if (hret != H_SUCCESS) {
-                ehca_err(&shca->ib_device, "Modify port failed  h_ret=%li",
+                ehca_err(&shca->ib_device, "Modify port failed  h_ret=%lli",
                          hret);
                 ret = -EINVAL;
         }
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index 3128a5090dbd..99bcbd7ffb0a 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -99,7 +99,7 @@ static void print_error_data(struct ehca_shca *shca, void *data,
                         return;
 
                 ehca_err(&shca->ib_device,
-                         "QP 0x%x (resource=%lx) has errors.",
+                         "QP 0x%x (resource=%llx) has errors.",
                          qp->ib_qp.qp_num, resource);
                 break;
         }
@@ -108,21 +108,21 @@ static void print_error_data(struct ehca_shca *shca, void *data,
                 struct ehca_cq *cq = (struct ehca_cq *)data;
 
                 ehca_err(&shca->ib_device,
-                         "CQ 0x%x (resource=%lx) has errors.",
+                         "CQ 0x%x (resource=%llx) has errors.",
                          cq->cq_number, resource);
                 break;
         }
         default:
                 ehca_err(&shca->ib_device,
-                         "Unknown error type: %lx on %s.",
+                         "Unknown error type: %llx on %s.",
                          type, shca->ib_device.name);
                 break;
         }
 
-        ehca_err(&shca->ib_device, "Error data is available: %lx.", resource);
+        ehca_err(&shca->ib_device, "Error data is available: %llx.", resource);
         ehca_err(&shca->ib_device, "EHCA ----- error data begin "
                  "---------------------------------------------------");
-        ehca_dmp(rblock, length, "resource=%lx", resource);
+        ehca_dmp(rblock, length, "resource=%llx", resource);
         ehca_err(&shca->ib_device, "EHCA ----- error data end "
                  "----------------------------------------------------");
 
@@ -152,7 +152,7 @@ int ehca_error_data(struct ehca_shca *shca, void *data,
 
         if (ret == H_R_STATE)
                 ehca_err(&shca->ib_device,
-                         "No error data is available: %lx.", resource);
+                         "No error data is available: %llx.", resource);
         else if (ret == H_SUCCESS) {
                 int length;
 
@@ -164,7 +164,7 @@ int ehca_error_data(struct ehca_shca *shca, void *data,
                 print_error_data(shca, data, rblock, length);
         } else
                 ehca_err(&shca->ib_device,
-                         "Error data could not be fetched: %lx", resource);
+                         "Error data could not be fetched: %llx", resource);
 
         ehca_free_fw_ctrlblock(rblock);
 
@@ -514,7 +514,7 @@ static inline void process_eqe(struct ehca_shca *shca, struct ehca_eqe *eqe)
         struct ehca_cq *cq;
 
         eqe_value = eqe->entry;
-        ehca_dbg(&shca->ib_device, "eqe_value=%lx", eqe_value);
+        ehca_dbg(&shca->ib_device, "eqe_value=%llx", eqe_value);
         if (EHCA_BMASK_GET(EQE_COMPLETION_EVENT, eqe_value)) {
                 ehca_dbg(&shca->ib_device, "Got completion event");
                 token = EHCA_BMASK_GET(EQE_CQ_TOKEN, eqe_value);
@@ -603,7 +603,7 @@ void ehca_process_eq(struct ehca_shca *shca, int is_irq)
                 ret = hipz_h_eoi(eq->ist);
                 if (ret != H_SUCCESS)
                         ehca_err(&shca->ib_device,
-                                 "bad return code EOI -rc = %ld\n", ret);
+                                 "bad return code EOI -rc = %lld\n", ret);
                 ehca_dbg(&shca->ib_device, "deadman found %x eqe", eqe_cnt);
         }
         if (unlikely(eqe_cnt == EHCA_EQE_CACHE_SIZE))
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index c7b8a506af65..368311ce332b 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -304,7 +304,7 @@ static int ehca_sense_attributes(struct ehca_shca *shca)
 
         h_ret = hipz_h_query_hca(shca->ipz_hca_handle, rblock);
         if (h_ret != H_SUCCESS) {
-                ehca_gen_err("Cannot query device properties. h_ret=%li",
+                ehca_gen_err("Cannot query device properties. h_ret=%lli",
                              h_ret);
                 ret = -EPERM;
                 goto sense_attributes1;
@@ -391,7 +391,7 @@ static int ehca_sense_attributes(struct ehca_shca *shca)
         port = (struct hipz_query_port *)rblock;
         h_ret = hipz_h_query_port(shca->ipz_hca_handle, 1, port);
         if (h_ret != H_SUCCESS) {
-                ehca_gen_err("Cannot query port properties. h_ret=%li",
+                ehca_gen_err("Cannot query port properties. h_ret=%lli",
                              h_ret);
                 ret = -EPERM;
                 goto sense_attributes1;
@@ -682,7 +682,7 @@ static ssize_t ehca_show_adapter_handle(struct device *dev,
 {
         struct ehca_shca *shca = dev->driver_data;
 
-        return sprintf(buf, "%lx\n", shca->ipz_hca_handle.handle);
+        return sprintf(buf, "%llx\n", shca->ipz_hca_handle.handle);
 
 }
 static DEVICE_ATTR(adapter_handle, S_IRUGO, ehca_show_adapter_handle, NULL);
diff --git a/drivers/infiniband/hw/ehca/ehca_mcast.c b/drivers/infiniband/hw/ehca/ehca_mcast.c
index e3ef0264ccc6..120aedf9f989 100644
--- a/drivers/infiniband/hw/ehca/ehca_mcast.c
+++ b/drivers/infiniband/hw/ehca/ehca_mcast.c
@@ -88,7 +88,7 @@ int ehca_attach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
         if (h_ret != H_SUCCESS)
                 ehca_err(ibqp->device,
                          "ehca_qp=%p qp_num=%x hipz_h_attach_mcqp() failed "
-                         "h_ret=%li", my_qp, ibqp->qp_num, h_ret);
+                         "h_ret=%lli", my_qp, ibqp->qp_num, h_ret);
 
         return ehca2ib_return_code(h_ret);
 }
@@ -125,7 +125,7 @@ int ehca_detach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
         if (h_ret != H_SUCCESS)
                 ehca_err(ibqp->device,
                          "ehca_qp=%p qp_num=%x hipz_h_detach_mcqp() failed "
-                         "h_ret=%li", my_qp, ibqp->qp_num, h_ret);
+                         "h_ret=%lli", my_qp, ibqp->qp_num, h_ret);
 
         return ehca2ib_return_code(h_ret);
 }
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index f974367cad40..72f83f7df614 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -204,7 +204,7 @@ struct ib_mr *ehca_reg_phys_mr(struct ib_pd *pd,
         }
         if ((size == 0) ||
             (((u64)iova_start + size) < (u64)iova_start)) {
-                ehca_err(pd->device, "bad input values: size=%lx iova_start=%p",
+                ehca_err(pd->device, "bad input values: size=%llx iova_start=%p",
                          size, iova_start);
                 ib_mr = ERR_PTR(-EINVAL);
                 goto reg_phys_mr_exit0;
@@ -309,8 +309,8 @@ struct ib_mr *ehca_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         }
 
         if (length == 0 || virt + length < virt) {
-                ehca_err(pd->device, "bad input values: length=%lx "
-                         "virt_base=%lx", length, virt);
+                ehca_err(pd->device, "bad input values: length=%llx "
+                         "virt_base=%llx", length, virt);
                 ib_mr = ERR_PTR(-EINVAL);
                 goto reg_user_mr_exit0;
         }
@@ -373,7 +373,7 @@ reg_user_mr_fallback:
                           &e_mr->ib.ib_mr.rkey);
         if (ret == -EINVAL && pginfo.hwpage_size > PAGE_SIZE) {
                 ehca_warn(pd->device, "failed to register mr "
-                          "with hwpage_size=%lx", hwpage_size);
+                          "with hwpage_size=%llx", hwpage_size);
                 ehca_info(pd->device, "try to register mr with "
                           "kpage_size=%lx", PAGE_SIZE);
                 /*
@@ -509,7 +509,7 @@ int ehca_rereg_phys_mr(struct ib_mr *mr,
                         goto rereg_phys_mr_exit1;
                 if ((new_size == 0) ||
                     (((u64)iova_start + new_size) < (u64)iova_start)) {
-                        ehca_err(mr->device, "bad input values: new_size=%lx "
+                        ehca_err(mr->device, "bad input values: new_size=%llx "
                                  "iova_start=%p", new_size, iova_start);
                         ret = -EINVAL;
                         goto rereg_phys_mr_exit1;
@@ -580,8 +580,8 @@ int ehca_query_mr(struct ib_mr *mr, struct ib_mr_attr *mr_attr)
 
         h_ret = hipz_h_query_mr(shca->ipz_hca_handle, e_mr, &hipzout);
         if (h_ret != H_SUCCESS) {
-                ehca_err(mr->device, "hipz_mr_query failed, h_ret=%li mr=%p "
-                         "hca_hndl=%lx mr_hndl=%lx lkey=%x",
+                ehca_err(mr->device, "hipz_mr_query failed, h_ret=%lli mr=%p "
+                         "hca_hndl=%llx mr_hndl=%llx lkey=%x",
                          h_ret, mr, shca->ipz_hca_handle.handle,
                          e_mr->ipz_mr_handle.handle, mr->lkey);
                 ret = ehca2ib_return_code(h_ret);
@@ -630,8 +630,8 @@ int ehca_dereg_mr(struct ib_mr *mr)
         /* TODO: BUSY: MR still has bound window(s) */
         h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr);
         if (h_ret != H_SUCCESS) {
-                ehca_err(mr->device, "hipz_free_mr failed, h_ret=%li shca=%p "
-                         "e_mr=%p hca_hndl=%lx mr_hndl=%lx mr->lkey=%x",
+                ehca_err(mr->device, "hipz_free_mr failed, h_ret=%lli shca=%p "
+                         "e_mr=%p hca_hndl=%llx mr_hndl=%llx mr->lkey=%x",
                          h_ret, shca, e_mr, shca->ipz_hca_handle.handle,
                          e_mr->ipz_mr_handle.handle, mr->lkey);
                 ret = ehca2ib_return_code(h_ret);
@@ -671,8 +671,8 @@ struct ib_mw *ehca_alloc_mw(struct ib_pd *pd)
         h_ret = hipz_h_alloc_resource_mw(shca->ipz_hca_handle, e_mw,
                                          e_pd->fw_pd, &hipzout);
         if (h_ret != H_SUCCESS) {
-                ehca_err(pd->device, "hipz_mw_allocate failed, h_ret=%li "
-                         "shca=%p hca_hndl=%lx mw=%p",
+                ehca_err(pd->device, "hipz_mw_allocate failed, h_ret=%lli "
+                         "shca=%p hca_hndl=%llx mw=%p",
                          h_ret, shca, shca->ipz_hca_handle.handle, e_mw);
                 ib_mw = ERR_PTR(ehca2ib_return_code(h_ret));
                 goto alloc_mw_exit1;
@@ -713,8 +713,8 @@ int ehca_dealloc_mw(struct ib_mw *mw)
 
         h_ret = hipz_h_free_resource_mw(shca->ipz_hca_handle, e_mw);
         if (h_ret != H_SUCCESS) {
-                ehca_err(mw->device, "hipz_free_mw failed, h_ret=%li shca=%p "
-                         "mw=%p rkey=%x hca_hndl=%lx mw_hndl=%lx",
+                ehca_err(mw->device, "hipz_free_mw failed, h_ret=%lli shca=%p "
+                         "mw=%p rkey=%x hca_hndl=%llx mw_hndl=%llx",
                          h_ret, shca, mw, mw->rkey, shca->ipz_hca_handle.handle,
                          e_mw->ipz_mw_handle.handle);
                 return ehca2ib_return_code(h_ret);
@@ -840,7 +840,7 @@ int ehca_map_phys_fmr(struct ib_fmr *fmr,
                 goto map_phys_fmr_exit0;
         if (iova % e_fmr->fmr_page_size) {
                 /* only whole-numbered pages */
-                ehca_err(fmr->device, "bad iova, iova=%lx fmr_page_size=%x",
+                ehca_err(fmr->device, "bad iova, iova=%llx fmr_page_size=%x",
                          iova, e_fmr->fmr_page_size);
                 ret = -EINVAL;
                 goto map_phys_fmr_exit0;
@@ -878,7 +878,7 @@ int ehca_map_phys_fmr(struct ib_fmr *fmr,
 map_phys_fmr_exit0:
         if (ret)
                 ehca_err(fmr->device, "ret=%i fmr=%p page_list=%p list_len=%x "
-                         "iova=%lx", ret, fmr, page_list, list_len, iova);
+                         "iova=%llx", ret, fmr, page_list, list_len, iova);
         return ret;
 } /* end ehca_map_phys_fmr() */
 
@@ -964,8 +964,8 @@ int ehca_dealloc_fmr(struct ib_fmr *fmr)
 
         h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_fmr);
         if (h_ret != H_SUCCESS) {
-                ehca_err(fmr->device, "hipz_free_mr failed, h_ret=%li e_fmr=%p "
-                         "hca_hndl=%lx fmr_hndl=%lx fmr->lkey=%x",
+                ehca_err(fmr->device, "hipz_free_mr failed, h_ret=%lli e_fmr=%p "
+                         "hca_hndl=%llx fmr_hndl=%llx fmr->lkey=%x",
                          h_ret, e_fmr, shca->ipz_hca_handle.handle,
                          e_fmr->ipz_mr_handle.handle, fmr->lkey);
                 ret = ehca2ib_return_code(h_ret);
@@ -1007,8 +1007,8 @@ int ehca_reg_mr(struct ehca_shca *shca,
                                          (u64)iova_start, size, hipz_acl,
                                          e_pd->fw_pd, &hipzout);
         if (h_ret != H_SUCCESS) {
-                ehca_err(&shca->ib_device, "hipz_alloc_mr failed, h_ret=%li "
-                         "hca_hndl=%lx", h_ret, shca->ipz_hca_handle.handle);
+                ehca_err(&shca->ib_device, "hipz_alloc_mr failed, h_ret=%lli "
+                         "hca_hndl=%llx", h_ret, shca->ipz_hca_handle.handle);
                 ret = ehca2ib_return_code(h_ret);
                 goto ehca_reg_mr_exit0;
         }
@@ -1033,9 +1033,9 @@ int ehca_reg_mr(struct ehca_shca *shca,
 ehca_reg_mr_exit1:
         h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr);
         if (h_ret != H_SUCCESS) {
-                ehca_err(&shca->ib_device, "h_ret=%li shca=%p e_mr=%p "
-                         "iova_start=%p size=%lx acl=%x e_pd=%p lkey=%x "
-                         "pginfo=%p num_kpages=%lx num_hwpages=%lx ret=%i",
+                ehca_err(&shca->ib_device, "h_ret=%lli shca=%p e_mr=%p "
+                         "iova_start=%p size=%llx acl=%x e_pd=%p lkey=%x "
+                         "pginfo=%p num_kpages=%llx num_hwpages=%llx ret=%i",
                          h_ret, shca, e_mr, iova_start, size, acl, e_pd,
                          hipzout.lkey, pginfo, pginfo->num_kpages,
                          pginfo->num_hwpages, ret);
@@ -1045,8 +1045,8 @@ ehca_reg_mr_exit1:
 ehca_reg_mr_exit0:
         if (ret)
                 ehca_err(&shca->ib_device, "ret=%i shca=%p e_mr=%p "
-                         "iova_start=%p size=%lx acl=%x e_pd=%p pginfo=%p "
-                         "num_kpages=%lx num_hwpages=%lx",
+                         "iova_start=%p size=%llx acl=%x e_pd=%p pginfo=%p "
+                         "num_kpages=%llx num_hwpages=%llx",
                          ret, shca, e_mr, iova_start, size, acl, e_pd, pginfo,
                          pginfo->num_kpages, pginfo->num_hwpages);
         return ret;
@@ -1116,8 +1116,8 @@ int ehca_reg_mr_rpages(struct ehca_shca *shca,
                          */
                         if (h_ret != H_SUCCESS) {
                                 ehca_err(&shca->ib_device, "last "
-                                         "hipz_reg_rpage_mr failed, h_ret=%li "
-                                         "e_mr=%p i=%x hca_hndl=%lx mr_hndl=%lx"
+                                         "hipz_reg_rpage_mr failed, h_ret=%lli "
+                                         "e_mr=%p i=%x hca_hndl=%llx mr_hndl=%llx"
                                          " lkey=%x", h_ret, e_mr, i,
                                          shca->ipz_hca_handle.handle,
                                          e_mr->ipz_mr_handle.handle,
@@ -1128,8 +1128,8 @@ int ehca_reg_mr_rpages(struct ehca_shca *shca,
                                 ret = 0;
                 } else if (h_ret != H_PAGE_REGISTERED) {
                         ehca_err(&shca->ib_device, "hipz_reg_rpage_mr failed, "
-                                 "h_ret=%li e_mr=%p i=%x lkey=%x hca_hndl=%lx "
-                                 "mr_hndl=%lx", h_ret, e_mr, i,
+                                 "h_ret=%lli e_mr=%p i=%x lkey=%x hca_hndl=%llx "
+                                 "mr_hndl=%llx", h_ret, e_mr, i,
                                  e_mr->ib.ib_mr.lkey,
                                  shca->ipz_hca_handle.handle,
                                  e_mr->ipz_mr_handle.handle);
@@ -1145,7 +1145,7 @@ ehca_reg_mr_rpages_exit1:
 ehca_reg_mr_rpages_exit0:
         if (ret)
                 ehca_err(&shca->ib_device, "ret=%i shca=%p e_mr=%p pginfo=%p "
-                         "num_kpages=%lx num_hwpages=%lx", ret, shca, e_mr,
+                         "num_kpages=%llx num_hwpages=%llx", ret, shca, e_mr,
                          pginfo, pginfo->num_kpages, pginfo->num_hwpages);
         return ret;
 } /* end ehca_reg_mr_rpages() */
@@ -1184,7 +1184,7 @@ inline int ehca_rereg_mr_rereg1(struct ehca_shca *shca,
         ret = ehca_set_pagebuf(pginfo, pginfo->num_hwpages, kpage);
         if (ret) {
                 ehca_err(&shca->ib_device, "set pagebuf failed, e_mr=%p "
-                         "pginfo=%p type=%x num_kpages=%lx num_hwpages=%lx "
+                         "pginfo=%p type=%x num_kpages=%llx num_hwpages=%llx "
                          "kpage=%p", e_mr, pginfo, pginfo->type,
                          pginfo->num_kpages, pginfo->num_hwpages, kpage);
                 goto ehca_rereg_mr_rereg1_exit1;
@@ -1205,13 +1205,13 @@ inline int ehca_rereg_mr_rereg1(struct ehca_shca *shca,
                  * (MW bound or MR is shared)
                  */
                 ehca_warn(&shca->ib_device, "hipz_h_reregister_pmr failed "
-                          "(Rereg1), h_ret=%li e_mr=%p", h_ret, e_mr);
+                          "(Rereg1), h_ret=%lli e_mr=%p", h_ret, e_mr);
                 *pginfo = pginfo_save;
                 ret = -EAGAIN;
         } else if ((u64 *)hipzout.vaddr != iova_start) {
                 ehca_err(&shca->ib_device, "PHYP changed iova_start in "
-                         "rereg_pmr, iova_start=%p iova_start_out=%lx e_mr=%p "
-                         "mr_handle=%lx lkey=%x lkey_out=%x", iova_start,
+                         "rereg_pmr, iova_start=%p iova_start_out=%llx e_mr=%p "
+                         "mr_handle=%llx lkey=%x lkey_out=%x", iova_start,
                          hipzout.vaddr, e_mr, e_mr->ipz_mr_handle.handle,
                          e_mr->ib.ib_mr.lkey, hipzout.lkey);
                 ret = -EFAULT;
@@ -1235,7 +1235,7 @@ ehca_rereg_mr_rereg1_exit1:
 ehca_rereg_mr_rereg1_exit0:
         if ( ret && (ret != -EAGAIN) )
                 ehca_err(&shca->ib_device, "ret=%i lkey=%x rkey=%x "
-                         "pginfo=%p num_kpages=%lx num_hwpages=%lx",
+                         "pginfo=%p num_kpages=%llx num_hwpages=%llx",
                          ret, *lkey, *rkey, pginfo, pginfo->num_kpages,
                          pginfo->num_hwpages);
         return ret;
@@ -1263,7 +1263,7 @@ int ehca_rereg_mr(struct ehca_shca *shca,
             (e_mr->num_hwpages > MAX_RPAGES) ||
             (pginfo->num_hwpages > e_mr->num_hwpages)) {
                 ehca_dbg(&shca->ib_device, "Rereg3 case, "
-                         "pginfo->num_hwpages=%lx e_mr->num_hwpages=%x",
+                         "pginfo->num_hwpages=%llx e_mr->num_hwpages=%x",
                          pginfo->num_hwpages, e_mr->num_hwpages);
                 rereg_1_hcall = 0;
                 rereg_3_hcall = 1;
@@ -1295,7 +1295,7 @@ int ehca_rereg_mr(struct ehca_shca *shca,
                 h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_mr);
                 if (h_ret != H_SUCCESS) {
                         ehca_err(&shca->ib_device, "hipz_free_mr failed, "
-                                 "h_ret=%li e_mr=%p hca_hndl=%lx mr_hndl=%lx "
+                                 "h_ret=%lli e_mr=%p hca_hndl=%llx mr_hndl=%llx "
                                  "mr->lkey=%x",
                                  h_ret, e_mr, shca->ipz_hca_handle.handle,
                                  e_mr->ipz_mr_handle.handle,
@@ -1328,8 +1328,8 @@ int ehca_rereg_mr(struct ehca_shca *shca,
 ehca_rereg_mr_exit0:
         if (ret)
                 ehca_err(&shca->ib_device, "ret=%i shca=%p e_mr=%p "
-                         "iova_start=%p size=%lx acl=%x e_pd=%p pginfo=%p "
-                         "num_kpages=%lx lkey=%x rkey=%x rereg_1_hcall=%x "
+                         "iova_start=%p size=%llx acl=%x e_pd=%p pginfo=%p "
+                         "num_kpages=%llx lkey=%x rkey=%x rereg_1_hcall=%x "
                          "rereg_3_hcall=%x", ret, shca, e_mr, iova_start, size,
                          acl, e_pd, pginfo, pginfo->num_kpages, *lkey, *rkey,
                          rereg_1_hcall, rereg_3_hcall);
@@ -1371,8 +1371,8 @@ int ehca_unmap_one_fmr(struct ehca_shca *shca,
                  * FMRs are not shared and no MW bound to FMRs
                  */
                 ehca_err(&shca->ib_device, "hipz_reregister_pmr failed "
-                         "(Rereg1), h_ret=%li e_fmr=%p hca_hndl=%lx "
-                         "mr_hndl=%lx lkey=%x lkey_out=%x",
+                         "(Rereg1), h_ret=%lli e_fmr=%p hca_hndl=%llx "
+                         "mr_hndl=%llx lkey=%x lkey_out=%x",
                          h_ret, e_fmr, shca->ipz_hca_handle.handle,
                          e_fmr->ipz_mr_handle.handle,
                          e_fmr->ib.ib_fmr.lkey, hipzout.lkey);
@@ -1383,7 +1383,7 @@ int ehca_unmap_one_fmr(struct ehca_shca *shca,
         h_ret = hipz_h_free_resource_mr(shca->ipz_hca_handle, e_fmr);
         if (h_ret != H_SUCCESS) {
                 ehca_err(&shca->ib_device, "hipz_free_mr failed, "
-                         "h_ret=%li e_fmr=%p hca_hndl=%lx mr_hndl=%lx "
+                         "h_ret=%lli e_fmr=%p hca_hndl=%llx mr_hndl=%llx "
                          "lkey=%x",
                          h_ret, e_fmr, shca->ipz_hca_handle.handle,
                          e_fmr->ipz_mr_handle.handle,
@@ -1447,9 +1447,9 @@ int ehca_reg_smr(struct ehca_shca *shca,
                                     (u64)iova_start, hipz_acl, e_pd->fw_pd,
                                     &hipzout);
         if (h_ret != H_SUCCESS) {
-                ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%li "
+                ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%lli "
                          "shca=%p e_origmr=%p e_newmr=%p iova_start=%p acl=%x "
-                         "e_pd=%p hca_hndl=%lx mr_hndl=%lx lkey=%x",
+                         "e_pd=%p hca_hndl=%llx mr_hndl=%llx lkey=%x",
                          h_ret, shca, e_origmr, e_newmr, iova_start, acl, e_pd,
                          shca->ipz_hca_handle.handle,
                          e_origmr->ipz_mr_handle.handle,
@@ -1527,7 +1527,7 @@ int ehca_reg_internal_maxmr(
                           &e_mr->ib.ib_mr.rkey);
         if (ret) {
                 ehca_err(&shca->ib_device, "reg of internal max MR failed, "
-                         "e_mr=%p iova_start=%p size_maxmr=%lx num_kpages=%x "
+                         "e_mr=%p iova_start=%p size_maxmr=%llx num_kpages=%x "
                          "num_hwpages=%x", e_mr, iova_start, size_maxmr,
                          num_kpages, num_hwpages);
                 goto ehca_reg_internal_maxmr_exit1;
@@ -1573,8 +1573,8 @@ int ehca_reg_maxmr(struct ehca_shca *shca,
                                     (u64)iova_start, hipz_acl, e_pd->fw_pd,
                                     &hipzout);
         if (h_ret != H_SUCCESS) {
-                ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%li "
-                         "e_origmr=%p hca_hndl=%lx mr_hndl=%lx lkey=%x",
+                ehca_err(&shca->ib_device, "hipz_reg_smr failed, h_ret=%lli "
+                         "e_origmr=%p hca_hndl=%llx mr_hndl=%llx lkey=%x",
                          h_ret, e_origmr, shca->ipz_hca_handle.handle,
                          e_origmr->ipz_mr_handle.handle,
                          e_origmr->ib.ib_mr.lkey);
@@ -1651,28 +1651,28 @@ int ehca_mr_chk_buf_and_calc_size(struct ib_phys_buf *phys_buf_array,
         /* check first buffer */
         if (((u64)iova_start & ~PAGE_MASK) != (pbuf->addr & ~PAGE_MASK)) {
                 ehca_gen_err("iova_start/addr mismatch, iova_start=%p "
-                             "pbuf->addr=%lx pbuf->size=%lx",
+                             "pbuf->addr=%llx pbuf->size=%llx",
                              iova_start, pbuf->addr, pbuf->size);
                 return -EINVAL;
         }
         if (((pbuf->addr + pbuf->size) % PAGE_SIZE) &&
             (num_phys_buf > 1)) {
-                ehca_gen_err("addr/size mismatch in 1st buf, pbuf->addr=%lx "
-                             "pbuf->size=%lx", pbuf->addr, pbuf->size);
+                ehca_gen_err("addr/size mismatch in 1st buf, pbuf->addr=%llx "
+                             "pbuf->size=%llx", pbuf->addr, pbuf->size);
                 return -EINVAL;
         }
 
         for (i = 0; i < num_phys_buf; i++) {
                 if ((i > 0) && (pbuf->addr % PAGE_SIZE)) {
-                        ehca_gen_err("bad address, i=%x pbuf->addr=%lx "
-                                     "pbuf->size=%lx",
+                        ehca_gen_err("bad address, i=%x pbuf->addr=%llx "
+                                     "pbuf->size=%llx",
                                      i, pbuf->addr, pbuf->size);
                         return -EINVAL;
                 }
                 if (((i > 0) && /* not 1st */
                      (i < (num_phys_buf - 1)) &&        /* not last */
                      (pbuf->size % PAGE_SIZE)) || (pbuf->size == 0)) {
-                        ehca_gen_err("bad size, i=%x pbuf->size=%lx",
+                        ehca_gen_err("bad size, i=%x pbuf->size=%llx",
                                      i, pbuf->size);
                         return -EINVAL;
                 }
@@ -1705,7 +1705,7 @@ int ehca_fmr_check_page_list(struct ehca_mr *e_fmr,
         page = page_list;
         for (i = 0; i < list_len; i++) {
                 if (*page % e_fmr->fmr_page_size) {
-                        ehca_gen_err("bad page, i=%x *page=%lx page=%p fmr=%p "
+                        ehca_gen_err("bad page, i=%x *page=%llx page=%p fmr=%p "
                                      "fmr_page_size=%x", i, *page, page, e_fmr,
                                      e_fmr->fmr_page_size);
                         return -EINVAL;
@@ -1743,9 +1743,9 @@ static int ehca_set_pagebuf_user1(struct ehca_mr_pginfo *pginfo,
                                              (pginfo->next_hwpage *
                                               pginfo->hwpage_size));
                         if ( !(*kpage) ) {
-                                ehca_gen_err("pgaddr=%lx "
-                                             "chunk->page_list[i]=%lx "
-                                             "i=%x next_hwpage=%lx",
+                                ehca_gen_err("pgaddr=%llx "
+                                             "chunk->page_list[i]=%llx "
+                                             "i=%x next_hwpage=%llx",
                                              pgaddr, (u64)sg_dma_address(
                                                      &chunk->page_list[i]),
                                              i, pginfo->next_hwpage);
@@ -1795,11 +1795,11 @@ static int ehca_check_kpages_per_ate(struct scatterlist *page_list,
         for (t = start_idx; t <= end_idx; t++) {
                 u64 pgaddr = page_to_pfn(sg_page(&page_list[t])) << PAGE_SHIFT;
                 if (ehca_debug_level >= 3)
-                        ehca_gen_dbg("chunk_page=%lx value=%016lx", pgaddr,
+                        ehca_gen_dbg("chunk_page=%llx value=%016llx", pgaddr,
                                      *(u64 *)abs_to_virt(phys_to_abs(pgaddr)));
                 if (pgaddr - PAGE_SIZE != *prev_pgaddr) {
-                        ehca_gen_err("uncontiguous page found pgaddr=%lx "
-                                     "prev_pgaddr=%lx page_list_i=%x",
+                        ehca_gen_err("uncontiguous page found pgaddr=%llx "
+                                     "prev_pgaddr=%llx page_list_i=%x",
                                      pgaddr, *prev_pgaddr, t);
                         return -EINVAL;
                 }
@@ -1833,7 +1833,7 @@ static int ehca_set_pagebuf_user2(struct ehca_mr_pginfo *pginfo,
                                            << PAGE_SHIFT );
                                 *kpage = phys_to_abs(pgaddr);
                                 if ( !(*kpage) ) {
-                                        ehca_gen_err("pgaddr=%lx i=%x",
+                                        ehca_gen_err("pgaddr=%llx i=%x",
                                                      pgaddr, i);
                                         ret = -EFAULT;
                                         return ret;
@@ -1846,8 +1846,8 @@ static int ehca_set_pagebuf_user2(struct ehca_mr_pginfo *pginfo,
                                         if (pginfo->hwpage_cnt) {
                                                 ehca_gen_err(
                                                         "invalid alignment "
-                                                        "pgaddr=%lx i=%x "
-                                                        "mr_pgsize=%lx",
+                                                        "pgaddr=%llx i=%x "
+                                                        "mr_pgsize=%llx",
                                                         pgaddr, i,
                                                         pginfo->hwpage_size);
                                                 ret = -EFAULT;
@@ -1866,8 +1866,8 @@ static int ehca_set_pagebuf_user2(struct ehca_mr_pginfo *pginfo,
                                 if (ehca_debug_level >= 3) {
                                         u64 val = *(u64 *)abs_to_virt(
                                                 phys_to_abs(pgaddr));
-                                        ehca_gen_dbg("kpage=%lx chunk_page=%lx "
-                                                     "value=%016lx",
+                                        ehca_gen_dbg("kpage=%llx chunk_page=%llx "
+                                                     "value=%016llx",
                                                      *kpage, pgaddr, val);
                                 }
                                 prev_pgaddr = pgaddr;
@@ -1944,9 +1944,9 @@ static int ehca_set_pagebuf_phys(struct ehca_mr_pginfo *pginfo,
                         if ((pginfo->kpage_cnt >= pginfo->num_kpages) ||
                             (pginfo->hwpage_cnt >= pginfo->num_hwpages)) {
                                 ehca_gen_err("kpage_cnt >= num_kpages, "
-                                             "kpage_cnt=%lx num_kpages=%lx "
-                                             "hwpage_cnt=%lx "
-                                             "num_hwpages=%lx i=%x",
+                                             "kpage_cnt=%llx num_kpages=%llx "
+                                             "hwpage_cnt=%llx "
+                                             "num_hwpages=%llx i=%x",
                                              pginfo->kpage_cnt,
                                              pginfo->num_kpages,
                                              pginfo->hwpage_cnt,
@@ -1957,8 +1957,8 @@ static int ehca_set_pagebuf_phys(struct ehca_mr_pginfo *pginfo,
                                 (pbuf->addr & ~(pginfo->hwpage_size - 1)) +
                                 (pginfo->next_hwpage * pginfo->hwpage_size));
                         if ( !(*kpage) && pbuf->addr ) {
-                                ehca_gen_err("pbuf->addr=%lx pbuf->size=%lx "
-                                             "next_hwpage=%lx", pbuf->addr,
+                                ehca_gen_err("pbuf->addr=%llx pbuf->size=%llx "
+                                             "next_hwpage=%llx", pbuf->addr,
                                              pbuf->size, pginfo->next_hwpage);
                                 return -EFAULT;
                         }
@@ -1996,8 +1996,8 @@ static int ehca_set_pagebuf_fmr(struct ehca_mr_pginfo *pginfo,
                 *kpage = phys_to_abs((*fmrlist & ~(pginfo->hwpage_size - 1)) +
                                      pginfo->next_hwpage * pginfo->hwpage_size);
                 if ( !(*kpage) ) {
-                        ehca_gen_err("*fmrlist=%lx fmrlist=%p "
-                                     "next_listelem=%lx next_hwpage=%lx",
+                        ehca_gen_err("*fmrlist=%llx fmrlist=%p "
+                                     "next_listelem=%llx next_hwpage=%llx",
                                      *fmrlist, fmrlist,
                                      pginfo->u.fmr.next_listelem,
                                      pginfo->next_hwpage);
@@ -2025,7 +2025,7 @@ static int ehca_set_pagebuf_fmr(struct ehca_mr_pginfo *pginfo,
                                                     ~(pginfo->hwpage_size - 1));
                                 if (prev + pginfo->u.fmr.fmr_pgsize != p) {
                                         ehca_gen_err("uncontiguous fmr pages "
-                                                     "found prev=%lx p=%lx "
+                                                     "found prev=%llx p=%llx "
                                                      "idx=%x", prev, p, i + j);
                                         return -EINVAL;
                                 }
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index f161cf173dbe..00c108159714 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -331,7 +331,7 @@ static inline int init_qp_queue(struct ehca_shca *shca,
                 if (cnt == (nr_q_pages - 1)) {  /* last page! */
                         if (h_ret != expected_hret) {
                                 ehca_err(ib_dev, "hipz_qp_register_rpage() "
-                                         "h_ret=%li", h_ret);
+                                         "h_ret=%lli", h_ret);
                                 ret = ehca2ib_return_code(h_ret);
                                 goto init_qp_queue1;
                         }
@@ -345,7 +345,7 @@ static inline int init_qp_queue(struct ehca_shca *shca,
                 } else {
                         if (h_ret != H_PAGE_REGISTERED) {
                                 ehca_err(ib_dev, "hipz_qp_register_rpage() "
-                                         "h_ret=%li", h_ret);
+                                         "h_ret=%lli", h_ret);
                                 ret = ehca2ib_return_code(h_ret);
                                 goto init_qp_queue1;
                         }
@@ -709,7 +709,7 @@ static struct ehca_qp *internal_create_qp(
 
         h_ret = hipz_h_alloc_resource_qp(shca->ipz_hca_handle, &parms);
         if (h_ret != H_SUCCESS) {
-                ehca_err(pd->device, "h_alloc_resource_qp() failed h_ret=%li",
+                ehca_err(pd->device, "h_alloc_resource_qp() failed h_ret=%lli",
                          h_ret);
                 ret = ehca2ib_return_code(h_ret);
                 goto create_qp_exit1;
@@ -1010,7 +1010,7 @@ struct ib_srq *ehca_create_srq(struct ib_pd *pd,
                                 mqpcb, my_qp->galpas.kernel);
         if (hret != H_SUCCESS) {
                 ehca_err(pd->device, "Could not modify SRQ to INIT "
-                         "ehca_qp=%p qp_num=%x h_ret=%li",
+                         "ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, my_qp->real_qp_num, hret);
                 goto create_srq2;
         }
@@ -1024,7 +1024,7 @@ struct ib_srq *ehca_create_srq(struct ib_pd *pd,
                                 mqpcb, my_qp->galpas.kernel);
         if (hret != H_SUCCESS) {
                 ehca_err(pd->device, "Could not enable SRQ "
-                         "ehca_qp=%p qp_num=%x h_ret=%li",
+                         "ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, my_qp->real_qp_num, hret);
                 goto create_srq2;
         }
@@ -1038,7 +1038,7 @@ struct ib_srq *ehca_create_srq(struct ib_pd *pd,
                                 mqpcb, my_qp->galpas.kernel);
         if (hret != H_SUCCESS) {
                 ehca_err(pd->device, "Could not modify SRQ to RTR "
-                         "ehca_qp=%p qp_num=%x h_ret=%li",
+                         "ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, my_qp->real_qp_num, hret);
                 goto create_srq2;
         }
@@ -1078,7 +1078,7 @@ static int prepare_sqe_rts(struct ehca_qp *my_qp, struct ehca_shca *shca,
                                            &bad_send_wqe_p, NULL, 2);
         if (h_ret != H_SUCCESS) {
                 ehca_err(&shca->ib_device, "hipz_h_disable_and_get_wqe() failed"
-                         " ehca_qp=%p qp_num=%x h_ret=%li",
+                         " ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, qp_num, h_ret);
                 return ehca2ib_return_code(h_ret);
         }
@@ -1134,7 +1134,7 @@ static int calc_left_cqes(u64 wqe_p, struct ipz_queue *ipz_queue,
 
         if (ipz_queue_abs_to_offset(ipz_queue, wqe_p, &q_ofs)) {
                 ehca_gen_err("Invalid offset for calculating left cqes "
-                                "wqe_p=%#lx wqe_v=%p\n", wqe_p, wqe_v);
+                                "wqe_p=%#llx wqe_v=%p\n", wqe_p, wqe_v);
                 return -EFAULT;
         }
 
@@ -1168,7 +1168,7 @@ static int check_for_left_cqes(struct ehca_qp *my_qp, struct ehca_shca *shca)
                                 &send_wqe_p, &recv_wqe_p, 4);
                 if (h_ret != H_SUCCESS) {
                         ehca_err(&shca->ib_device, "disable_and_get_wqe() "
-                                 "failed ehca_qp=%p qp_num=%x h_ret=%li",
+                                 "failed ehca_qp=%p qp_num=%x h_ret=%lli",
                                  my_qp, qp_num, h_ret);
                         return ehca2ib_return_code(h_ret);
                 }
@@ -1261,7 +1261,7 @@ static int internal_modify_qp(struct ib_qp *ibqp,
                                 mqpcb, my_qp->galpas.kernel);
         if (h_ret != H_SUCCESS) {
                 ehca_err(ibqp->device, "hipz_h_query_qp() failed "
-                         "ehca_qp=%p qp_num=%x h_ret=%li",
+                         "ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, ibqp->qp_num, h_ret);
                 ret = ehca2ib_return_code(h_ret);
                 goto modify_qp_exit1;
@@ -1690,7 +1690,7 @@ static int internal_modify_qp(struct ib_qp *ibqp,
 
         if (h_ret != H_SUCCESS) {
                 ret = ehca2ib_return_code(h_ret);
-                ehca_err(ibqp->device, "hipz_h_modify_qp() failed h_ret=%li "
+                ehca_err(ibqp->device, "hipz_h_modify_qp() failed h_ret=%lli "
                          "ehca_qp=%p qp_num=%x", h_ret, my_qp, ibqp->qp_num);
                 goto modify_qp_exit2;
         }
@@ -1723,7 +1723,7 @@ static int internal_modify_qp(struct ib_qp *ibqp,
                         ret = ehca2ib_return_code(h_ret);
                         ehca_err(ibqp->device, "ENABLE in context of "
                                  "RESET_2_INIT failed! Maybe you didn't get "
-                                 "a LID h_ret=%li ehca_qp=%p qp_num=%x",
+                                 "a LID h_ret=%lli ehca_qp=%p qp_num=%x",
                                  h_ret, my_qp, ibqp->qp_num);
                         goto modify_qp_exit2;
                 }
@@ -1909,7 +1909,7 @@ int ehca_query_qp(struct ib_qp *qp,
         if (h_ret != H_SUCCESS) {
                 ret = ehca2ib_return_code(h_ret);
                 ehca_err(qp->device, "hipz_h_query_qp() failed "
-                         "ehca_qp=%p qp_num=%x h_ret=%li",
+                         "ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, qp->qp_num, h_ret);
                 goto query_qp_exit1;
         }
@@ -2074,7 +2074,7 @@ int ehca_modify_srq(struct ib_srq *ibsrq, struct ib_srq_attr *attr,
 
         if (h_ret != H_SUCCESS) {
                 ret = ehca2ib_return_code(h_ret);
-                ehca_err(ibsrq->device, "hipz_h_modify_qp() failed h_ret=%li "
+                ehca_err(ibsrq->device, "hipz_h_modify_qp() failed h_ret=%lli "
                          "ehca_qp=%p qp_num=%x",
                          h_ret, my_qp, my_qp->real_qp_num);
         }
@@ -2108,7 +2108,7 @@ int ehca_query_srq(struct ib_srq *srq, struct ib_srq_attr *srq_attr)
         if (h_ret != H_SUCCESS) {
                 ret = ehca2ib_return_code(h_ret);
                 ehca_err(srq->device, "hipz_h_query_qp() failed "
-                         "ehca_qp=%p qp_num=%x h_ret=%li",
+                         "ehca_qp=%p qp_num=%x h_ret=%lli",
                          my_qp, my_qp->real_qp_num, h_ret);
                 goto query_srq_exit1;
         }
@@ -2179,7 +2179,7 @@ static int internal_destroy_qp(struct ib_device *dev, struct ehca_qp *my_qp,
 
         h_ret = hipz_h_destroy_qp(shca->ipz_hca_handle, my_qp);
         if (h_ret != H_SUCCESS) {
-                ehca_err(dev, "hipz_h_destroy_qp() failed h_ret=%li "
+                ehca_err(dev, "hipz_h_destroy_qp() failed h_ret=%lli "
                          "ehca_qp=%p qp_num=%x", h_ret, my_qp, qp_num);
                 return ehca2ib_return_code(h_ret);
         }
diff --git a/drivers/infiniband/hw/ehca/ehca_reqs.c b/drivers/infiniband/hw/ehca/ehca_reqs.c
index c7112686782f..5a3d96f84c79 100644
--- a/drivers/infiniband/hw/ehca/ehca_reqs.c
+++ b/drivers/infiniband/hw/ehca/ehca_reqs.c
@@ -822,7 +822,7 @@ static int generate_flush_cqes(struct ehca_qp *my_qp, struct ib_cq *cq,
                 offset = qmap->next_wqe_idx * ipz_queue->qe_size;
                 wqe = (struct ehca_wqe *)ipz_qeit_calc(ipz_queue, offset);
                 if (!wqe) {
-                        ehca_err(cq->device, "Invalid wqe offset=%#lx on "
+                        ehca_err(cq->device, "Invalid wqe offset=%#llx on "
                                  "qp_num=%#x", offset, my_qp->real_qp_num);
                         return nr;
                 }
diff --git a/drivers/infiniband/hw/ehca/ehca_sqp.c b/drivers/infiniband/hw/ehca/ehca_sqp.c
index 706d97ad5555..44447aaa5501 100644
--- a/drivers/infiniband/hw/ehca/ehca_sqp.c
+++ b/drivers/infiniband/hw/ehca/ehca_sqp.c
@@ -85,7 +85,7 @@ u64 ehca_define_sqp(struct ehca_shca *shca,
 
                 if (ret != H_SUCCESS) {
                         ehca_err(&shca->ib_device,
-                                 "Can't define AQP1 for port %x. h_ret=%li",
+                                 "Can't define AQP1 for port %x. h_ret=%lli",
                                  port, ret);
                         return ret;
                 }
diff --git a/drivers/infiniband/hw/ehca/ehca_tools.h b/drivers/infiniband/hw/ehca/ehca_tools.h
index 21f7d06f14ad..f09914cccf53 100644
--- a/drivers/infiniband/hw/ehca/ehca_tools.h
+++ b/drivers/infiniband/hw/ehca/ehca_tools.h
@@ -116,7 +116,7 @@ extern int ehca_debug_level;
                 unsigned char *deb = (unsigned char *)(adr); \
                 for (x = 0; x < l; x += 16) { \
                         printk(KERN_INFO "EHCA_DMP:%s " format \
-                               " adr=%p ofs=%04x %016lx %016lx\n", \
+                               " adr=%p ofs=%04x %016llx %016llx\n", \
                                __func__, ##args, deb, x, \
                                *((u64 *)&deb[0]), *((u64 *)&deb[8])); \
                         deb += 16; \
diff --git a/drivers/infiniband/hw/ehca/ehca_uverbs.c b/drivers/infiniband/hw/ehca/ehca_uverbs.c
index e43ed8f8a0c8..3cb688d29131 100644
--- a/drivers/infiniband/hw/ehca/ehca_uverbs.c
+++ b/drivers/infiniband/hw/ehca/ehca_uverbs.c
@@ -114,7 +114,7 @@ static int ehca_mmap_fw(struct vm_area_struct *vma, struct h_galpas *galpas,
 
         physical = galpas->user.fw_handle;
         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
-        ehca_gen_dbg("vsize=%lx physical=%lx", vsize, physical);
+        ehca_gen_dbg("vsize=%llx physical=%llx", vsize, physical);
         /* VM_IO | VM_RESERVED are set by remap_pfn_range() */
         ret = remap_4k_pfn(vma, vma->vm_start, physical >> EHCA_PAGESHIFT,
                            vma->vm_page_prot);
diff --git a/drivers/infiniband/hw/ehca/hcp_if.c b/drivers/infiniband/hw/ehca/hcp_if.c
index 415d3a465de6..d0ab0c0d5e91 100644
--- a/drivers/infiniband/hw/ehca/hcp_if.c
+++ b/drivers/infiniband/hw/ehca/hcp_if.c
@@ -226,7 +226,7 @@ u64 hipz_h_alloc_resource_eq(const struct ipz_adapter_handle adapter_handle,
                              u32 *eq_ist)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
         u64 allocate_controls;
 
         /* resource type */
@@ -249,7 +249,7 @@ u64 hipz_h_alloc_resource_eq(const struct ipz_adapter_handle adapter_handle,
         *eq_ist = (u32)outs[5];
 
         if (ret == H_NOT_ENOUGH_RESOURCES)
-                ehca_gen_err("Not enough resource - ret=%li ", ret);
+                ehca_gen_err("Not enough resource - ret=%lli ", ret);
 
         return ret;
 }
@@ -270,7 +270,7 @@ u64 hipz_h_alloc_resource_cq(const struct ipz_adapter_handle adapter_handle,
                              struct ehca_alloc_cq_parms *param)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_ALLOC_RESOURCE, outs,
                                 adapter_handle.handle,   /* r4  */
@@ -287,7 +287,7 @@ u64 hipz_h_alloc_resource_cq(const struct ipz_adapter_handle adapter_handle,
                 hcp_galpas_ctor(&cq->galpas, outs[5], outs[6]);
 
         if (ret == H_NOT_ENOUGH_RESOURCES)
-                ehca_gen_err("Not enough resources. ret=%li", ret);
+                ehca_gen_err("Not enough resources. ret=%lli", ret);
 
         return ret;
 }
@@ -297,7 +297,7 @@ u64 hipz_h_alloc_resource_qp(const struct ipz_adapter_handle adapter_handle,
 {
         u64 ret;
         u64 allocate_controls, max_r10_reg, r11, r12;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         allocate_controls =
                 EHCA_BMASK_SET(H_ALL_RES_QP_ENHANCED_OPS, parms->ext_type)
@@ -362,7 +362,7 @@ u64 hipz_h_alloc_resource_qp(const struct ipz_adapter_handle adapter_handle,
                 hcp_galpas_ctor(&parms->galpas, outs[6], outs[6]);
 
         if (ret == H_NOT_ENOUGH_RESOURCES)
-                ehca_gen_err("Not enough resources. ret=%li", ret);
+                ehca_gen_err("Not enough resources. ret=%lli", ret);
 
         return ret;
 }
@@ -454,7 +454,7 @@ u64 hipz_h_register_rpage_eq(const struct ipz_adapter_handle adapter_handle,
                              const u64 count)
 {
         if (count != 1) {
-                ehca_gen_err("Ppage counter=%lx", count);
+                ehca_gen_err("Ppage counter=%llx", count);
                 return H_PARAMETER;
         }
         return hipz_h_register_rpage(adapter_handle,
@@ -489,7 +489,7 @@ u64 hipz_h_register_rpage_cq(const struct ipz_adapter_handle adapter_handle,
                              const struct h_galpa gal)
 {
         if (count != 1) {
-                ehca_gen_err("Page counter=%lx", count);
+                ehca_gen_err("Page counter=%llx", count);
                 return H_PARAMETER;
         }
 
@@ -508,7 +508,7 @@ u64 hipz_h_register_rpage_qp(const struct ipz_adapter_handle adapter_handle,
                              const struct h_galpa galpa)
 {
         if (count > 1) {
-                ehca_gen_err("Page counter=%lx", count);
+                ehca_gen_err("Page counter=%llx", count);
                 return H_PARAMETER;
         }
 
@@ -525,7 +525,7 @@ u64 hipz_h_disable_and_get_wqe(const struct ipz_adapter_handle adapter_handle,
                                int dis_and_get_function_code)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_DISABLE_AND_GETC, outs,
                                 adapter_handle.handle,     /* r4 */
@@ -548,7 +548,7 @@ u64 hipz_h_modify_qp(const struct ipz_adapter_handle adapter_handle,
                      struct h_galpa gal)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
         ret = ehca_plpar_hcall9(H_MODIFY_QP, outs,
                                 adapter_handle.handle, /* r4 */
                                 qp_handle.handle,      /* r5 */
@@ -557,7 +557,7 @@ u64 hipz_h_modify_qp(const struct ipz_adapter_handle adapter_handle,
                                 0, 0, 0, 0, 0);
 
         if (ret == H_NOT_ENOUGH_RESOURCES)
-                ehca_gen_err("Insufficient resources ret=%li", ret);
+                ehca_gen_err("Insufficient resources ret=%lli", ret);
 
         return ret;
 }
@@ -579,7 +579,7 @@ u64 hipz_h_destroy_qp(const struct ipz_adapter_handle adapter_handle,
                       struct ehca_qp *qp)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = hcp_galpas_dtor(&qp->galpas);
         if (ret) {
@@ -593,7 +593,7 @@ u64 hipz_h_destroy_qp(const struct ipz_adapter_handle adapter_handle,
                                 qp->ipz_qp_handle.handle,  /* r6 */
                                 0, 0, 0, 0, 0, 0);
         if (ret == H_HARDWARE)
-                ehca_gen_err("HCA not operational. ret=%li", ret);
+                ehca_gen_err("HCA not operational. ret=%lli", ret);
 
         ret = ehca_plpar_hcall_norets(H_FREE_RESOURCE,
                                       adapter_handle.handle,     /* r4 */
@@ -601,7 +601,7 @@ u64 hipz_h_destroy_qp(const struct ipz_adapter_handle adapter_handle,
                                       0, 0, 0, 0, 0);
 
         if (ret == H_RESOURCE)
-                ehca_gen_err("Resource still in use. ret=%li", ret);
+                ehca_gen_err("Resource still in use. ret=%lli", ret);
 
         return ret;
 }
@@ -625,7 +625,7 @@ u64 hipz_h_define_aqp1(const struct ipz_adapter_handle adapter_handle,
                        u32 * bma_qp_nr)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_DEFINE_AQP1, outs,
                                 adapter_handle.handle, /* r4 */
@@ -636,7 +636,7 @@ u64 hipz_h_define_aqp1(const struct ipz_adapter_handle adapter_handle,
         *bma_qp_nr = (u32)outs[1];
 
         if (ret == H_ALIAS_EXIST)
-                ehca_gen_err("AQP1 already exists. ret=%li", ret);
+                ehca_gen_err("AQP1 already exists. ret=%lli", ret);
 
         return ret;
 }
@@ -658,7 +658,7 @@ u64 hipz_h_attach_mcqp(const struct ipz_adapter_handle adapter_handle,
                                       0, 0);
 
         if (ret == H_NOT_ENOUGH_RESOURCES)
-                ehca_gen_err("Not enough resources. ret=%li", ret);
+                ehca_gen_err("Not enough resources. ret=%lli", ret);
 
         return ret;
 }
@@ -697,7 +697,7 @@ u64 hipz_h_destroy_cq(const struct ipz_adapter_handle adapter_handle,
                                       0, 0, 0, 0);
 
         if (ret == H_RESOURCE)
-                ehca_gen_err("H_FREE_RESOURCE failed ret=%li ", ret);
+                ehca_gen_err("H_FREE_RESOURCE failed ret=%lli ", ret);
 
         return ret;
 }
@@ -719,7 +719,7 @@ u64 hipz_h_destroy_eq(const struct ipz_adapter_handle adapter_handle,
                                       0, 0, 0, 0, 0);
 
         if (ret == H_RESOURCE)
-                ehca_gen_err("Resource in use. ret=%li ", ret);
+                ehca_gen_err("Resource in use. ret=%lli ", ret);
 
         return ret;
 }
@@ -733,7 +733,7 @@ u64 hipz_h_alloc_resource_mr(const struct ipz_adapter_handle adapter_handle,
                              struct ehca_mr_hipzout_parms *outparms)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_ALLOC_RESOURCE, outs,
                                 adapter_handle.handle,            /* r4 */
@@ -774,9 +774,9 @@ u64 hipz_h_register_rpage_mr(const struct ipz_adapter_handle adapter_handle,
 
         if ((count > 1) && (logical_address_of_page & (EHCA_PAGESIZE-1))) {
                 ehca_gen_err("logical_address_of_page not on a 4k boundary "
-                             "adapter_handle=%lx mr=%p mr_handle=%lx "
+                             "adapter_handle=%llx mr=%p mr_handle=%llx "
                              "pagesize=%x queue_type=%x "
-                             "logical_address_of_page=%lx count=%lx",
+                             "logical_address_of_page=%llx count=%llx",
                              adapter_handle.handle, mr,
                              mr->ipz_mr_handle.handle, pagesize, queue_type,
                              logical_address_of_page, count);
@@ -794,7 +794,7 @@ u64 hipz_h_query_mr(const struct ipz_adapter_handle adapter_handle,
                     struct ehca_mr_hipzout_parms *outparms)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_QUERY_MR, outs,
                                 adapter_handle.handle,     /* r4 */
@@ -828,7 +828,7 @@ u64 hipz_h_reregister_pmr(const struct ipz_adapter_handle adapter_handle,
                           struct ehca_mr_hipzout_parms *outparms)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_REREGISTER_PMR, outs,
                                 adapter_handle.handle,    /* r4 */
@@ -855,7 +855,7 @@ u64 hipz_h_register_smr(const struct ipz_adapter_handle adapter_handle,
                         struct ehca_mr_hipzout_parms *outparms)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_REGISTER_SMR, outs,
                                 adapter_handle.handle,            /* r4 */
@@ -877,7 +877,7 @@ u64 hipz_h_alloc_resource_mw(const struct ipz_adapter_handle adapter_handle,
                              struct ehca_mw_hipzout_parms *outparms)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_ALLOC_RESOURCE, outs,
                                 adapter_handle.handle,      /* r4 */
@@ -895,7 +895,7 @@ u64 hipz_h_query_mw(const struct ipz_adapter_handle adapter_handle,
                     struct ehca_mw_hipzout_parms *outparms)
 {
         u64 ret;
-        u64 outs[PLPAR_HCALL9_BUFSIZE];
+        unsigned long outs[PLPAR_HCALL9_BUFSIZE];
 
         ret = ehca_plpar_hcall9(H_QUERY_MW, outs,
                                 adapter_handle.handle,    /* r4 */
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index 39167a797f99..a91cb4c3fa5c 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -1462,7 +1462,8 @@ static void __set_data_seg(struct mlx4_wqe_data_seg *dseg, struct ib_sge *sg)
 }
 
 static int build_lso_seg(struct mlx4_wqe_lso_seg *wqe, struct ib_send_wr *wr,
-                         struct mlx4_ib_qp *qp, unsigned *lso_seg_len)
+                         struct mlx4_ib_qp *qp, unsigned *lso_seg_len,
+                         __be32 *lso_hdr_sz)
 {
         unsigned halign = ALIGN(sizeof *wqe + wr->wr.ud.hlen, 16);
 
@@ -1479,12 +1480,8 @@ static int build_lso_seg(struct mlx4_wqe_lso_seg *wqe, struct ib_send_wr *wr,
 
         memcpy(wqe->header, wr->wr.ud.header, wr->wr.ud.hlen);
 
-        /* make sure LSO header is written before overwriting stamping */
-        wmb();
-
-        wqe->mss_hdr_size = cpu_to_be32((wr->wr.ud.mss - wr->wr.ud.hlen) << 16 |
-                                        wr->wr.ud.hlen);
-
+        *lso_hdr_sz  = cpu_to_be32((wr->wr.ud.mss - wr->wr.ud.hlen) << 16 |
+                                   wr->wr.ud.hlen);
         *lso_seg_len = halign;
         return 0;
 }
@@ -1518,6 +1515,9 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
         int uninitialized_var(stamp);
         int uninitialized_var(size);
         unsigned uninitialized_var(seglen);
+        __be32 dummy;
+        __be32 *lso_wqe;
+        __be32 uninitialized_var(lso_hdr_sz);
         int i;
 
         spin_lock_irqsave(&qp->sq.lock, flags);
@@ -1525,6 +1525,8 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
         ind = qp->sq_next_wqe;
 
         for (nreq = 0; wr; ++nreq, wr = wr->next) {
+                lso_wqe = &dummy;
+
                 if (mlx4_wq_overflow(&qp->sq, nreq, qp->ibqp.send_cq)) {
                         err = -ENOMEM;
                         *bad_wr = wr;
@@ -1606,11 +1608,12 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         size += sizeof (struct mlx4_wqe_datagram_seg) / 16;
 
                         if (wr->opcode == IB_WR_LSO) {
-                                err = build_lso_seg(wqe, wr, qp, &seglen);
+                                err = build_lso_seg(wqe, wr, qp, &seglen, &lso_hdr_sz);
                                 if (unlikely(err)) {
                                         *bad_wr = wr;
                                         goto out;
                                 }
+                                lso_wqe = (__be32 *) wqe;
                                 wqe  += seglen;
                                 size += seglen / 16;
                         }
@@ -1652,6 +1655,14 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 for (i = wr->num_sge - 1; i >= 0; --i, --dseg)
                         set_data_seg(dseg, wr->sg_list + i);
 
+                /*
+                 * Possibly overwrite stamping in cacheline with LSO
+                 * segment only after making sure all data segments
+                 * are written.
+                 */
+                wmb();
+                *lso_wqe = lso_hdr_sz;
+
                 ctrl->fence_size = (wr->send_flags & IB_SEND_FENCE ?
                                     MLX4_WQE_CTRL_FENCE : 0) | size;
 
@@ -1686,7 +1697,6 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                         stamp_send_wqe(qp, stamp, size * 16);
                         ind = pad_wraparound(qp, ind);
                 }
-
         }
 
 out:
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c
index dce0443f9d69..0bd2a4ff0842 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_main.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c
@@ -106,23 +106,17 @@ int ipoib_open(struct net_device *dev)
 
         ipoib_dbg(priv, "bringing up interface\n");
 
-        set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
+        if (!test_and_set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
+                napi_enable(&priv->napi);
 
         if (ipoib_pkey_dev_delay_open(dev))
                 return 0;
 
-        napi_enable(&priv->napi);
+        if (ipoib_ib_dev_open(dev))
+                goto err_disable;
 
-        if (ipoib_ib_dev_open(dev)) {
-                napi_disable(&priv->napi);
-                return -EINVAL;
-        }
-
-        if (ipoib_ib_dev_up(dev)) {
-                ipoib_ib_dev_stop(dev, 1);
-                napi_disable(&priv->napi);
-                return -EINVAL;
-        }
+        if (ipoib_ib_dev_up(dev))
+                goto err_stop;
 
         if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) {
                 struct ipoib_dev_priv *cpriv;
@@ -144,6 +138,15 @@ int ipoib_open(struct net_device *dev)
         netif_start_queue(dev);
 
         return 0;
+
+err_stop:
+        ipoib_ib_dev_stop(dev, 1);
+
+err_disable:
+        napi_disable(&priv->napi);
+        clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
+
+        return -EINVAL;
 }
 
 static int ipoib_stop(struct net_device *dev)
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
index 59d02e0b8df1..425e31112ed7 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_multicast.c
@@ -409,7 +409,7 @@ static int ipoib_mcast_join_complete(int status,
         }
 
         if (mcast->logcount++ < 20) {
-                if (status == -ETIMEDOUT) {
+                if (status == -ETIMEDOUT || status == -EAGAIN) {
                         ipoib_dbg_mcast(priv, "multicast join failed for %pI6, status %d\n",
                                         mcast->mcmember.mgid.raw, status);
                 } else {
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
index 2cf1a4088718..5a76a5510350 100644
--- a/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
+++ b/drivers/infiniband/ulp/ipoib/ipoib_vlan.c
@@ -61,6 +61,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
 
         ppriv = netdev_priv(pdev);
 
+        rtnl_lock();
         mutex_lock(&ppriv->vlan_mutex);
 
         /*
@@ -111,7 +112,7 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
                 goto device_init_failed;
         }
 
-        result = register_netdev(priv->dev);
+        result = register_netdevice(priv->dev);
         if (result) {
                 ipoib_warn(priv, "failed to initialize; error %i", result);
                 goto register_failed;
@@ -134,12 +135,13 @@ int ipoib_vlan_add(struct net_device *pdev, unsigned short pkey)
         list_add_tail(&priv->list, &ppriv->child_intfs);
 
         mutex_unlock(&ppriv->vlan_mutex);
+        rtnl_unlock();
 
         return 0;
 
 sysfs_failed:
         ipoib_delete_debug_files(priv->dev);
-        unregister_netdev(priv->dev);
+        unregister_netdevice(priv->dev);
 
 register_failed:
         ipoib_dev_cleanup(priv->dev);
@@ -149,6 +151,7 @@ device_init_failed:
 
 err:
         mutex_unlock(&ppriv->vlan_mutex);
+        rtnl_unlock();
         return result;
 }
 
@@ -162,10 +165,11 @@ int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
 
         ppriv = netdev_priv(pdev);
 
+        rtnl_lock();
         mutex_lock(&ppriv->vlan_mutex);
         list_for_each_entry_safe(priv, tpriv, &ppriv->child_intfs, list) {
                 if (priv->pkey == pkey) {
-                        unregister_netdev(priv->dev);
+                        unregister_netdevice(priv->dev);
                         ipoib_dev_cleanup(priv->dev);
                         list_del(&priv->list);
                         free_netdev(priv->dev);
@@ -175,6 +179,7 @@ int ipoib_vlan_delete(struct net_device *pdev, unsigned short pkey)
                 }
         }
         mutex_unlock(&ppriv->vlan_mutex);
+        rtnl_unlock();
 
         return ret;
 }
diff --git a/drivers/isdn/i4l/isdn_net.c b/drivers/isdn/i4l/isdn_net.c
index 7c5f97033b9f..cb8943da4f12 100644
--- a/drivers/isdn/i4l/isdn_net.c
+++ b/drivers/isdn/i4l/isdn_net.c
@@ -292,7 +292,9 @@ isdn_net_unbind_channel(isdn_net_local * lp)
         lp->dialstate = 0;
         dev->rx_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
         dev->st_netdev[isdn_dc2minor(lp->isdn_device, lp->isdn_channel)] = NULL;
-        isdn_free_channel(lp->isdn_device, lp->isdn_channel, ISDN_USAGE_NET);
+        if (lp->isdn_device != -1 && lp->isdn_channel != -1)
+                isdn_free_channel(lp->isdn_device, lp->isdn_channel,
+                                  ISDN_USAGE_NET);
         lp->flags &= ~ISDN_NET_CONNECTED;
         lp->isdn_device = -1;
         lp->isdn_channel = -1;
@@ -2513,7 +2515,6 @@ static const struct net_device_ops isdn_netdev_ops = {
         .ndo_stop             = isdn_net_close,
         .ndo_do_ioctl         = isdn_net_ioctl,
 
-        .ndo_validate_addr    = NULL,
         .ndo_start_xmit       = isdn_net_start_xmit,
         .ndo_get_stats        = isdn_net_get_stats,
         .ndo_tx_timeout       = isdn_net_tx_timeout,
@@ -2528,12 +2529,8 @@ static void _isdn_setup(struct net_device *dev)
 
         ether_setup(dev);
 
-        dev->flags = IFF_NOARP | IFF_POINTOPOINT;
         /* Setup the generic properties */
-        dev->mtu = 1500;
         dev->flags = IFF_NOARP|IFF_POINTOPOINT;
-        dev->type = ARPHRD_ETHER;
-        dev->addr_len = ETH_ALEN;
         dev->header_ops = NULL;
         dev->netdev_ops = &isdn_netdev_ops;
 
diff --git a/drivers/isdn/i4l/isdn_ppp.c b/drivers/isdn/i4l/isdn_ppp.c
index a3551dd0324d..aa30b5cb3513 100644
--- a/drivers/isdn/i4l/isdn_ppp.c
+++ b/drivers/isdn/i4l/isdn_ppp.c
@@ -431,6 +431,7 @@ set_arg(void __user *b, void *val,int len)
         return 0;
 }
 
+#ifdef CONFIG_IPPP_FILTER
 static int get_filter(void __user *arg, struct sock_filter **p)
 {
         struct sock_fprog uprog;
@@ -465,6 +466,7 @@ static int get_filter(void __user *arg, struct sock_filter **p)
         *p = code;
         return uprog.len;
 }
+#endif /* CONFIG_IPPP_FILTER */
 
 /*
  * ippp device ioctl
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index a4a1ae214630..742713611bc5 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -119,13 +119,6 @@ config LEDS_GPIO
           outputs. To be useful the particular board must have LEDs
           and they must be connected to the GPIO lines.
 
-config LEDS_HP_DISK
-        tristate "LED Support for disk protection LED on HP notebooks"
-        depends on LEDS_CLASS && ACPI
-        help
-          This option enable support for disk protection LED, found on
-          newer HP notebooks.
-
 config LEDS_CLEVO_MAIL
         tristate "Mail LED on Clevo notebook (EXPERIMENTAL)"
         depends on LEDS_CLASS && X86 && SERIO_I8042 && DMI && EXPERIMENTAL
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index bc247cb02e82..9d76f0f160a4 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -23,7 +23,6 @@ obj-$(CONFIG_LEDS_HP6XX)		+= leds-hp6xx.o
 obj-$(CONFIG_LEDS_FSG)                  += leds-fsg.o
 obj-$(CONFIG_LEDS_PCA955X)              += leds-pca955x.o
 obj-$(CONFIG_LEDS_DA903X)               += leds-da903x.o
-obj-$(CONFIG_LEDS_HP_DISK)              += leds-hp-disk.o
 obj-$(CONFIG_LEDS_WM8350)               += leds-wm8350.o
 
 # LED Triggers
diff --git a/drivers/leds/leds-hp-disk.c b/drivers/leds/leds-hp-disk.c
deleted file mode 100644
index d786adc8c5e3..000000000000
--- a/drivers/leds/leds-hp-disk.c
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- *  leds-hp-disk.c - driver for HP "hard disk protection" LED
- *
- *  Copyright (C) 2008 Pavel Machek
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/dmi.h>
-#include <linux/module.h>
-#include <linux/types.h>
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/input.h>
-#include <linux/kthread.h>
-#include <linux/leds.h>
-#include <acpi/acpi_drivers.h>
-
-#define DRIVER_NAME     "leds-hp-disk"
-#define ACPI_MDPS_CLASS "led"
-
-/* For automatic insertion of the module */
-static struct acpi_device_id hpled_device_ids[] = {
-        {"HPQ0004", 0}, /* HP Mobile Data Protection System PNP */
-        {"", 0},
-};
-MODULE_DEVICE_TABLE(acpi, hpled_device_ids);
-
-struct acpi_hpled {
-        struct acpi_device      *device;   /* The ACPI device */
-};
-
-static struct acpi_hpled adev;
-
-static acpi_status hpled_acpi_write(acpi_handle handle, int reg)
-{
-        unsigned long long ret; /* Not used when writing */
-        union acpi_object in_obj[1];
-        struct acpi_object_list args = { 1, in_obj };
-
-        in_obj[0].type          = ACPI_TYPE_INTEGER;
-        in_obj[0].integer.value = reg;
-
-        return acpi_evaluate_integer(handle, "ALED", &args, &ret);
-}
-
-static void hpled_set(struct led_classdev *led_cdev,
-                               enum led_brightness value)
-{
-        hpled_acpi_write(adev.device->handle, !!value);
-}
-
-static struct led_classdev hpled_led = {
-        .name                   = "hp:red:hddprotection",
-        .default_trigger        = "heartbeat",
-        .brightness_set         = hpled_set,
-        .flags                  = LED_CORE_SUSPENDRESUME,
-};
-
-static int hpled_add(struct acpi_device *device)
-{
-        int ret;
-
-        if (!device)
-                return -EINVAL;
-
-        adev.device = device;
-        strcpy(acpi_device_name(device), DRIVER_NAME);
-        strcpy(acpi_device_class(device), ACPI_MDPS_CLASS);
-        device->driver_data = &adev;
-
-        ret = led_classdev_register(NULL, &hpled_led);
-        return ret;
-}
-
-static int hpled_remove(struct acpi_device *device, int type)
-{
-        if (!device)
-                return -EINVAL;
-
-        led_classdev_unregister(&hpled_led);
-        return 0;
-}
-
-
-
-static struct acpi_driver leds_hp_driver = {
-        .name  = DRIVER_NAME,
-        .class = ACPI_MDPS_CLASS,
-        .ids   = hpled_device_ids,
-        .ops = {
-                .add     = hpled_add,
-                .remove  = hpled_remove,
-        }
-};
-
-static int __init hpled_init_module(void)
-{
-        int ret;
-
-        if (acpi_disabled)
-                return -ENODEV;
-
-        ret = acpi_bus_register_driver(&leds_hp_driver);
-        if (ret < 0)
-                return ret;
-
-        printk(KERN_INFO DRIVER_NAME " driver loaded.\n");
-
-        return 0;
-}
-
-static void __exit hpled_exit_module(void)
-{
-        acpi_bus_unregister_driver(&leds_hp_driver);
-}
-
-MODULE_DESCRIPTION("Driver for HP disk protection LED");
-MODULE_AUTHOR("Pavel Machek <pavel@suse.cz>");
-MODULE_LICENSE("GPL");
-
-module_init(hpled_init_module);
-module_exit(hpled_exit_module);
diff --git a/drivers/message/fusion/lsi/mpi.h b/drivers/message/fusion/lsi/mpi.h
index 10b6ef758725..11c0f461320e 100644
--- a/drivers/message/fusion/lsi/mpi.h
+++ b/drivers/message/fusion/lsi/mpi.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Message independent structures and definitions
  *  Creation Date:  July 27, 2000
  *
- *    mpi.h Version:  01.05.13
+ *    mpi.h Version:  01.05.16
  *
  *  Version History
  *  ---------------
@@ -79,6 +79,9 @@
  *  03-27-06  01.05.11  Bumped MPI_HEADER_VERSION_UNIT.
  *  10-11-06  01.05.12  Bumped MPI_HEADER_VERSION_UNIT.
  *  05-24-07  01.05.13  Bumped MPI_HEADER_VERSION_UNIT.
+ *  08-07-07  01.05.14  Bumped MPI_HEADER_VERSION_UNIT.
+ *  01-15-08  01.05.15  Bumped MPI_HEADER_VERSION_UNIT.
+ *  03-28-08  01.05.16  Bumped MPI_HEADER_VERSION_UNIT.
  *  --------------------------------------------------------------------------
  */
 
@@ -109,7 +112,7 @@
 /* Note: The major versions of 0xe0 through 0xff are reserved */
 
 /* versioning for this MPI header set */
-#define MPI_HEADER_VERSION_UNIT             (0x10)
+#define MPI_HEADER_VERSION_UNIT             (0x13)
 #define MPI_HEADER_VERSION_DEV              (0x00)
 #define MPI_HEADER_VERSION_UNIT_MASK        (0xFF00)
 #define MPI_HEADER_VERSION_UNIT_SHIFT       (8)
diff --git a/drivers/message/fusion/lsi/mpi_cnfg.h b/drivers/message/fusion/lsi/mpi_cnfg.h
index b2db3330c591..013c7d881948 100644
--- a/drivers/message/fusion/lsi/mpi_cnfg.h
+++ b/drivers/message/fusion/lsi/mpi_cnfg.h
@@ -6,7 +6,7 @@
  *          Title:  MPI Config message, structures, and Pages
  *  Creation Date:  July 27, 2000
  *
- *    mpi_cnfg.h Version:  01.05.15
+ *    mpi_cnfg.h Version:  01.05.18
  *
  *  Version History
  *  ---------------
@@ -308,6 +308,20 @@
  *                      Expander Page 0 Flags field.
  *                      Fixed define for
  *                      MPI_SAS_EXPANDER1_DISCINFO_BAD_PHY_DISABLED.
+ *  08-07-07  01.05.16  Added MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT
+ *                      define.
+ *                      Added BIOS Page 4 structure.
+ *                      Added MPI_RAID_PHYS_DISK1_PATH_MAX define for RAID
+ *                      Physcial Disk Page 1.
+ *  01-15-07  01.05.17  Added additional bit defines for ExtFlags field of
+ *                      Manufacturing Page 4.
+ *                      Added Solid State Drives Supported bit to IOC Page 6
+ *                      Capabilities Flags.
+ *                      Added new value for AccessStatus field of SAS Device
+ *                      Page 0 (_SATA_NEEDS_INITIALIZATION).
+ *  03-28-08  01.05.18  Defined new bits in Manufacturing Page 4 ExtFlags field
+ *                      to control coercion size and the mixing of SAS and SATA
+ *                      SSD drives.
  *  --------------------------------------------------------------------------
  */
 
@@ -686,6 +700,14 @@ typedef struct _CONFIG_PAGE_MANUFACTURING_4
 #define MPI_MANPAGE4_IR_NO_MIX_SAS_SATA                 (0x01)
 
 /* defines for the ExtFlags field */
+#define MPI_MANPAGE4_EXTFLAGS_MASK_COERCION_SIZE        (0x0180)
+#define MPI_MANPAGE4_EXTFLAGS_SHIFT_COERCION_SIZE       (7)
+#define MPI_MANPAGE4_EXTFLAGS_1GB_COERCION_SIZE         (0)
+#define MPI_MANPAGE4_EXTFLAGS_128MB_COERCION_SIZE       (1)
+
+#define MPI_MANPAGE4_EXTFLAGS_NO_MIX_SSD_SAS_SATA       (0x0040)
+#define MPI_MANPAGE4_EXTFLAGS_MIX_SSD_AND_NON_SSD       (0x0020)
+#define MPI_MANPAGE4_EXTFLAGS_DUAL_PORT_SUPPORT         (0x0010)
 #define MPI_MANPAGE4_EXTFLAGS_HIDE_NON_IR_METADATA      (0x0008)
 #define MPI_MANPAGE4_EXTFLAGS_SAS_CACHE_DISABLE         (0x0004)
 #define MPI_MANPAGE4_EXTFLAGS_SATA_CACHE_DISABLE        (0x0002)
@@ -1159,6 +1181,8 @@ typedef struct _CONFIG_PAGE_IOC_6
 
 /* IOC Page 6 Capabilities Flags */
 
+#define MPI_IOCPAGE6_CAP_FLAGS_SSD_SUPPORT              (0x00000020)
+#define MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT  (0x00000010)
 #define MPI_IOCPAGE6_CAP_FLAGS_DISABLE_SMART_POLLING    (0x00000008)
 
 #define MPI_IOCPAGE6_CAP_FLAGS_MASK_METADATA_SIZE       (0x00000006)
@@ -1428,6 +1452,15 @@ typedef struct _CONFIG_PAGE_BIOS_2
 #define MPI_BIOSPAGE2_FORM_SAS_WWN                      (0x05)
 #define MPI_BIOSPAGE2_FORM_ENCLOSURE_SLOT               (0x06)
 
+typedef struct _CONFIG_PAGE_BIOS_4
+{
+    CONFIG_PAGE_HEADER      Header;                     /* 00h */
+    U64                     ReassignmentBaseWWID;       /* 04h */
+} CONFIG_PAGE_BIOS_4, MPI_POINTER PTR_CONFIG_PAGE_BIOS_4,
+  BIOSPage4_t, MPI_POINTER pBIOSPage4_t;
+
+#define MPI_BIOSPAGE4_PAGEVERSION                       (0x00)
+
 
 /****************************************************************************
 *   SCSI Port Config Pages
@@ -2419,6 +2452,15 @@ typedef struct _RAID_PHYS_DISK1_PATH
 #define MPI_RAID_PHYSDISK1_FLAG_BROKEN          (0x0002)
 #define MPI_RAID_PHYSDISK1_FLAG_INVALID         (0x0001)
 
+
+/*
+ * Host code (drivers, BIOS, utilities, etc.) should leave this define set to
+ * one and check Header.PageLength or NumPhysDiskPaths at runtime.
+ */
+#ifndef MPI_RAID_PHYS_DISK1_PATH_MAX
+#define MPI_RAID_PHYS_DISK1_PATH_MAX    (1)
+#endif
+
 typedef struct _CONFIG_PAGE_RAID_PHYS_DISK_1
 {
     CONFIG_PAGE_HEADER              Header;             /* 00h */
@@ -2426,7 +2468,7 @@ typedef struct _CONFIG_PAGE_RAID_PHYS_DISK_1
     U8                              PhysDiskNum;        /* 05h */
     U16                             Reserved2;          /* 06h */
     U32                             Reserved1;          /* 08h */
-    RAID_PHYS_DISK1_PATH            Path[1];            /* 0Ch */
+    RAID_PHYS_DISK1_PATH            Path[MPI_RAID_PHYS_DISK1_PATH_MAX];/* 0Ch */
 } CONFIG_PAGE_RAID_PHYS_DISK_1, MPI_POINTER PTR_CONFIG_PAGE_RAID_PHYS_DISK_1,
   RaidPhysDiskPage1_t, MPI_POINTER pRaidPhysDiskPage1_t;
 
@@ -2844,6 +2886,7 @@ typedef struct _CONFIG_PAGE_SAS_DEVICE_0
 #define MPI_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED            (0x01)
 #define MPI_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED      (0x02)
 #define MPI_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT   (0x03)
+#define MPI_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION   (0x04)
 /* specific values for SATA Init failures */
 #define MPI_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN                 (0x10)
 #define MPI_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT    (0x11)
diff --git a/drivers/message/fusion/lsi/mpi_fc.h b/drivers/message/fusion/lsi/mpi_fc.h
index 627acfbb8623..7d663ce76f8c 100644
--- a/drivers/message/fusion/lsi/mpi_fc.h
+++ b/drivers/message/fusion/lsi/mpi_fc.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2000-2004 LSI Corporation.
+ *  Copyright (c) 2000-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_fc.h
diff --git a/drivers/message/fusion/lsi/mpi_history.txt b/drivers/message/fusion/lsi/mpi_history.txt
index 3f15fcfe4a2e..693e4b511354 100644
--- a/drivers/message/fusion/lsi/mpi_history.txt
+++ b/drivers/message/fusion/lsi/mpi_history.txt
@@ -3,28 +3,28 @@
  MPI Header File Change History
  ==============================
 
- Copyright (c) 2000-2007 LSI Corporation.
+ Copyright (c) 2000-2008 LSI Corporation.
 
  ---------------------------------------
- Header Set Release Version:    01.05.16
- Header Set Release Date:       05-24-07
+ Header Set Release Version:    01.05.19
+ Header Set Release Date:       03-28-08
  ---------------------------------------
 
  Filename               Current version     Prior version
  ----------             ---------------     -------------
- mpi.h                  01.05.13            01.05.12
- mpi_ioc.h              01.05.14            01.05.13
- mpi_cnfg.h             01.05.15            01.05.14
+ mpi.h                  01.05.16            01.05.15
+ mpi_ioc.h              01.05.16            01.05.15
+ mpi_cnfg.h             01.05.18            01.05.17
  mpi_init.h             01.05.09            01.05.09
  mpi_targ.h             01.05.06            01.05.06
  mpi_fc.h               01.05.01            01.05.01
  mpi_lan.h              01.05.01            01.05.01
- mpi_raid.h             01.05.03            01.05.03
+ mpi_raid.h             01.05.05            01.05.05
  mpi_tool.h             01.05.03            01.05.03
  mpi_inb.h              01.05.01            01.05.01
- mpi_sas.h              01.05.04            01.05.04
+ mpi_sas.h              01.05.05            01.05.05
  mpi_type.h             01.05.02            01.05.02
- mpi_history.txt        01.05.14            01.05.14
+ mpi_history.txt        01.05.19            01.05.18
 
 
  *  Date      Version   Description
@@ -96,6 +96,9 @@ mpi.h
  *  03-27-06  01.05.11  Bumped MPI_HEADER_VERSION_UNIT.
  *  10-11-06  01.05.12  Bumped MPI_HEADER_VERSION_UNIT.
  *  05-24-07  01.05.13  Bumped MPI_HEADER_VERSION_UNIT.
+ *  08-07-07  01.05.14  Bumped MPI_HEADER_VERSION_UNIT.
+ *  01-15-08  01.05.15  Bumped MPI_HEADER_VERSION_UNIT.
+ *  03-28-08  01.05.16  Bumped MPI_HEADER_VERSION_UNIT.
  *  --------------------------------------------------------------------------
 
 mpi_ioc.h
@@ -127,7 +130,7 @@ mpi_ioc.h
  *  08-08-01  01.02.01  Original release for v1.2 work.
  *                      New format for FWVersion and ProductId in
  *                      MSG_IOC_FACTS_REPLY and MPI_FW_HEADER.
- *  08-31-01  01.02.02  Added event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
+ *  08-31-01  01.02.02  Addded event MPI_EVENT_SCSI_DEVICE_STATUS_CHANGE and
  *                      related structure and defines.
  *                      Added event MPI_EVENT_ON_BUS_TIMER_EXPIRED.
  *                      Added MPI_IOCINIT_FLAGS_DISCARD_FW_IMAGE.
@@ -187,7 +190,7 @@ mpi_ioc.h
  *  10-11-06  01.05.12  Added MPI_IOCFACTS_EXCEPT_METADATA_UNSUPPORTED.
  *                      Added MaxInitiators field to PortFacts reply.
  *                      Added SAS Device Status Change ReasonCode for
- *                      asynchronous notification.
+ *                      asynchronous notificaiton.
  *                      Added MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE and event
  *                      data structure.
  *                      Added new ImageType values for FWDownload and FWUpload
@@ -199,6 +202,16 @@ mpi_ioc.h
  *                      added _MULTI_PORT_DOMAIN.
  *  05-24-07  01.05.14  Added Common Boot Block type to FWDownload Request.
  *                      Added Common Boot Block type to FWUpload Request.
+ *  08-07-07  01.05.15  Added MPI_EVENT_SAS_INIT_RC_REMOVED define.
+ *                      Added MPI_EVENT_IR2_RC_DUAL_PORT_ADDED and
+ *                      MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED for IR2 event data.
+ *                      Added SASAddress field to SAS Initiator Device Table
+ *                      Overflow event data structure.
+ *  03-28-08  01.05.16  Added two new ReasonCode values to SAS Device Status
+ *                      Change Event data to indicate completion of internally
+ *                      generated task management.
+ *                      Added MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE define.
+ *                      Added MPI_EVENT_SAS_INIT_RC_INACCESSIBLE define.
  *  --------------------------------------------------------------------------
 
 mpi_cnfg.h
@@ -213,7 +226,7 @@ mpi_cnfg.h
  *                      Added _RESPONSE_ID_MASK definition to SCSI_PORT_1
  *                      page and updated the page version.
  *                      Added Information field and _INFO_PARAMS_NEGOTIATED
- *                      definition to SCSI_DEVICE_0 page.
+ *                      definitionto SCSI_DEVICE_0 page.
  *  06-22-00  01.00.03  Removed batch controls from LAN_0 page and updated the
  *                      page version.
  *                      Added BucketsRemaining to LAN_1 page, redefined the
@@ -496,6 +509,20 @@ mpi_cnfg.h
  *                      Expander Page 0 Flags field.
  *                      Fixed define for
  *                      MPI_SAS_EXPANDER1_DISCINFO_BAD_PHY_DISABLED.
+ *  08-07-07  01.05.16  Added MPI_IOCPAGE6_CAP_FLAGS_MULTIPORT_DRIVE_SUPPORT
+ *                      define.
+ *                      Added BIOS Page 4 structure.
+ *                      Added MPI_RAID_PHYS_DISK1_PATH_MAX define for RAID
+ *                      Physcial Disk Page 1.
+ *  01-15-07  01.05.17  Added additional bit defines for ExtFlags field of
+ *                      Manufacturing Page 4.
+ *                      Added Solid State Drives Supported bit to IOC Page 6
+ *                      Capabilities Flags.
+ *                      Added new value for AccessStatus field of SAS Device
+ *                      Page 0 (_SATA_NEEDS_INITIALIZATION).
+ *  03-28-08  01.05.18  Defined new bits in Manufacturing Page 4 ExtFlags field
+ *                      to control coercion size and the mixing of SAS and SATA
+ *                      SSD drives.
  *  --------------------------------------------------------------------------
 
 mpi_init.h
@@ -661,6 +688,9 @@ mpi_raid.h
  *                      _SET_RESYNC_RATE and _SET_DATA_SCRUB_RATE.
  *  02-28-07  01.05.03  Added new RAID Action, Device FW Update Mode, and
  *                      associated defines.
+ *  08-07-07  01.05.04  Added Disable Full Rebuild bit to the ActionDataWord
+ *                      for the RAID Action MPI_RAID_ACTION_DISABLE_VOLUME.
+ *  01-15-08  01.05.05  Added define for MPI_RAID_ACTION_SET_VOLUME_NAME.
  *  --------------------------------------------------------------------------
 
 mpi_tool.h
@@ -694,6 +724,10 @@ mpi_sas.h
  *                      reply.
  *  10-11-06  01.05.04  Fixed the name of a define for Operation field of SAS IO
  *                      Unit Control request.
+ *  01-15-08  01.05.05  Added support for MPI_SAS_OP_SET_IOC_PARAMETER,
+ *                      including adding IOCParameter and IOCParameter value
+ *                      fields to SAS IO Unit Control Request.
+ *                      Added MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC define.
  *  --------------------------------------------------------------------------
 
 mpi_type.h
@@ -709,20 +743,20 @@ mpi_type.h
 
 mpi_history.txt         Parts list history
 
-Filename    01.05.15   01.05.15
-----------  --------   --------
-mpi.h       01.05.12   01.05.13
-mpi_ioc.h   01.05.13   01.05.14
-mpi_cnfg.h  01.05.14   01.05.15
-mpi_init.h  01.05.09   01.05.09
-mpi_targ.h  01.05.06   01.05.06
-mpi_fc.h    01.05.01   01.05.01
-mpi_lan.h   01.05.01   01.05.01
-mpi_raid.h  01.05.03   01.05.03
-mpi_tool.h  01.05.03   01.05.03
-mpi_inb.h   01.05.01   01.05.01
-mpi_sas.h   01.05.04   01.05.04
-mpi_type.h  01.05.02   01.05.02
+Filename    01.05.19   01.05.18   01.05.17   01.05.16   01.05.15
+----------  --------   --------   --------   --------   --------
+mpi.h       01.05.16   01.05.15   01.05.14   01.05.13   01.05.12
+mpi_ioc.h   01.05.16   01.05.15   01.05.15   01.05.14   01.05.13
+mpi_cnfg.h  01.05.18   01.05.17   01.05.16   01.05.15   01.05.14
+mpi_init.h  01.05.09   01.05.09   01.05.09   01.05.09   01.05.09
+mpi_targ.h  01.05.06   01.05.06   01.05.06   01.05.06   01.05.06
+mpi_fc.h    01.05.01   01.05.01   01.05.01   01.05.01   01.05.01
+mpi_lan.h   01.05.01   01.05.01   01.05.01   01.05.01   01.05.01
+mpi_raid.h  01.05.05   01.05.05   01.05.04   01.05.03   01.05.03
+mpi_tool.h  01.05.03   01.05.03   01.05.03   01.05.03   01.05.03
+mpi_inb.h   01.05.01   01.05.01   01.05.01   01.05.01   01.05.01
+mpi_sas.h   01.05.05   01.05.05   01.05.04   01.05.04   01.05.04
+mpi_type.h  01.05.02   01.05.02   01.05.02   01.05.02   01.05.02
 
 Filename    01.05.14   01.05.13   01.05.12   01.05.11   01.05.10   01.05.09
 ----------  --------   --------   --------   --------   --------   --------
diff --git a/drivers/message/fusion/lsi/mpi_init.h b/drivers/message/fusion/lsi/mpi_init.h
index a9e3693601a7..4295d062caa7 100644
--- a/drivers/message/fusion/lsi/mpi_init.h
+++ b/drivers/message/fusion/lsi/mpi_init.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2000-2007 LSI Corporation.
+ *  Copyright (c) 2000-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_init.h
diff --git a/drivers/message/fusion/lsi/mpi_ioc.h b/drivers/message/fusion/lsi/mpi_ioc.h
index 5cbb6bd048e1..8faa4fab7b89 100644
--- a/drivers/message/fusion/lsi/mpi_ioc.h
+++ b/drivers/message/fusion/lsi/mpi_ioc.h
@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2000-2007 LSI Corporation.
+ *  Copyright (c) 2000-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_ioc.h
  *          Title:  MPI IOC, Port, Event, FW Download, and FW Upload messages
  *  Creation Date:  August 11, 2000
  *
- *    mpi_ioc.h Version:  01.05.14
+ *    mpi_ioc.h Version:  01.05.16
  *
  *  Version History
  *  ---------------
@@ -113,6 +113,16 @@
  *                      added _MULTI_PORT_DOMAIN.
  *  05-24-07  01.05.14  Added Common Boot Block type to FWDownload Request.
  *                      Added Common Boot Block type to FWUpload Request.
+ *  08-07-07  01.05.15  Added MPI_EVENT_SAS_INIT_RC_REMOVED define.
+ *                      Added MPI_EVENT_IR2_RC_DUAL_PORT_ADDED and
+ *                      MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED for IR2 event data.
+ *                      Added SASAddress field to SAS Initiator Device Table
+ *                      Overflow event data structure.
+ *  03-28-08  01.05.16  Added two new ReasonCode values to SAS Device Status
+ *                      Change Event data to indicate completion of internally
+ *                      generated task management.
+ *                      Added MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE define.
+ *                      Added MPI_EVENT_SAS_INIT_RC_INACCESSIBLE define.
  *  --------------------------------------------------------------------------
  */
 
@@ -612,6 +622,8 @@ typedef struct _EVENT_DATA_SAS_DEVICE_STATUS_CHANGE
 #define MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL   (0x0B)
 #define MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL       (0x0C)
 #define MPI_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION        (0x0D)
+#define MPI_EVENT_SAS_DEV_STAT_RC_CMPL_INTERNAL_DEV_RESET   (0x0E)
+#define MPI_EVENT_SAS_DEV_STAT_RC_CMPL_TASK_ABORT_INTERNAL  (0x0F)
 
 
 /* SCSI Event data for Queue Full event */
@@ -708,6 +720,8 @@ typedef struct _MPI_EVENT_DATA_IR2
 #define MPI_EVENT_IR2_RC_PD_REMOVED                 (0x05)
 #define MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED       (0x06)
 #define MPI_EVENT_IR2_RC_REBUILD_MEDIUM_ERROR       (0x07)
+#define MPI_EVENT_IR2_RC_DUAL_PORT_ADDED            (0x08)
+#define MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED          (0x09)
 
 /* defines for logical disk states */
 #define MPI_LD_STATE_OPTIMAL                        (0x00)
@@ -867,6 +881,7 @@ typedef struct _EVENT_DATA_DISCOVERY_ERROR
 #define MPI_EVENT_DSCVRY_ERR_DS_UNSUPPORTED_DEVICE          (0x00000800)
 #define MPI_EVENT_DSCVRY_ERR_DS_MAX_SATA_TARGETS            (0x00001000)
 #define MPI_EVENT_DSCVRY_ERR_DS_MULTI_PORT_DOMAIN           (0x00002000)
+#define MPI_EVENT_DSCVRY_ERR_DS_SATA_INIT_FAILURE           (0x00004000)
 
 /* SAS SMP Error Event data */
 
@@ -902,6 +917,8 @@ typedef struct _EVENT_DATA_SAS_INIT_DEV_STATUS_CHANGE
 
 /* defines for the ReasonCode field of the SAS Initiator Device Status Change event */
 #define MPI_EVENT_SAS_INIT_RC_ADDED                 (0x01)
+#define MPI_EVENT_SAS_INIT_RC_REMOVED               (0x02)
+#define MPI_EVENT_SAS_INIT_RC_INACCESSIBLE          (0x03)
 
 /* SAS Initiator Device Table Overflow Event data */
 
@@ -910,6 +927,7 @@ typedef struct _EVENT_DATA_SAS_INIT_TABLE_OVERFLOW
     U8                      MaxInit;                    /* 00h */
     U8                      CurrentInit;                /* 01h */
     U16                     Reserved1;                  /* 02h */
+    U64                     SASAddress;                 /* 04h */
 } EVENT_DATA_SAS_INIT_TABLE_OVERFLOW,
   MPI_POINTER PTR_EVENT_DATA_SAS_INIT_TABLE_OVERFLOW,
   MpiEventDataSasInitTableOverflow_t,
diff --git a/drivers/message/fusion/lsi/mpi_lan.h b/drivers/message/fusion/lsi/mpi_lan.h
index 03253b53b785..f41fcb69b359 100644
--- a/drivers/message/fusion/lsi/mpi_lan.h
+++ b/drivers/message/fusion/lsi/mpi_lan.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2000-2004 LSI Corporation.
+ *  Copyright (c) 2000-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_lan.h
diff --git a/drivers/message/fusion/lsi/mpi_log_fc.h b/drivers/message/fusion/lsi/mpi_log_fc.h
index e4dafcefeecd..face6e7acc72 100644
--- a/drivers/message/fusion/lsi/mpi_log_fc.h
+++ b/drivers/message/fusion/lsi/mpi_log_fc.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2000-2001 LSI Corporation. All rights reserved.
+ *  Copyright (c) 2000-2008 LSI Corporation. All rights reserved.
  *
  *  NAME:           fc_log.h
  *  SUMMARY:        MPI IocLogInfo definitions for the SYMFC9xx chips
diff --git a/drivers/message/fusion/lsi/mpi_log_sas.h b/drivers/message/fusion/lsi/mpi_log_sas.h
index af9da03e95e5..691620dbedd2 100644
--- a/drivers/message/fusion/lsi/mpi_log_sas.h
+++ b/drivers/message/fusion/lsi/mpi_log_sas.h
@@ -1,6 +1,6 @@
 /***************************************************************************
  *                                                                         *
- *  Copyright 2003 LSI Corporation.  All rights reserved.            *
+ *  Copyright (c) 2000-2008 LSI Corporation.  All rights reserved.         *
  *                                                                         *
  * Description                                                             *
  * ------------                                                            *
@@ -73,6 +73,8 @@
 #define IOP_LOGINFO_CODE_TARGET_MODE_ABORT_EXACT_IO          (0x00070004)
 #define IOP_LOGINFO_CODE_TARGET_MODE_ABORT_EXACT_IO_REQ      (0x00070005)
 
+#define IOP_LOGINFO_CODE_LOG_TIMESTAMP_EVENT                 (0x00080000)
+
 /****************************************************************************/
 /* PL LOGINFO_CODE defines, valid if IOC_LOGINFO_ORIGINATOR = PL            */
 /****************************************************************************/
@@ -92,7 +94,7 @@
 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_OPEN_TIMEOUT_EXP       (0x0000000C)
 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_UNUSED_0D              (0x0000000D)
 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_DVTBLE_ACCSS_FAIL      (0x0000000E)
-#define PL_LOGINFO_SUB CODE_OPEN_FAIL_BAD_DEST               (0x00000011)
+#define PL_LOGINFO_SUB_CODE_OPEN_FAIL_BAD_DEST               (0x00000011)
 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_RATE_NOT_SUPP          (0x00000012)
 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_PROT_NOT_SUPP          (0x00000013)
 #define PL_LOGINFO_SUB_CODE_OPEN_FAIL_RESERVED_ABANDON0      (0x00000014)
@@ -159,10 +161,11 @@
 
 #define PL_LOGINFO_SUB_CODE_INVALID_SGL                      (0x00000200)
 #define PL_LOGINFO_SUB_CODE_WRONG_REL_OFF_OR_FRAME_LENGTH    (0x00000300)
-#define PL_LOGINFO_SUB_CODE_FRAME_XFER_ERROR                 (0x00000400) /* Bits 0-3 encode Transport Status Register (offset 0x08) */
-                                                                          /* Bit 0 is Status Bit 0: FrameXferErr */
-                                                                          /* Bit 1 & 2 are Status Bits 16 and 17: FrameXmitErrStatus */
-                                                                          /* Bit 3 is Status Bit 18 WriteDataLengthGTDataLengthErr */
+#define PL_LOGINFO_SUB_CODE_FRAME_XFER_ERROR                 (0x00000400)
+/* Bits 0-3 encode Transport Status Register (offset 0x08) */
+/* Bit 0 is Status Bit 0: FrameXferErr */
+/* Bit 1 & 2 are Status Bits 16 and 17: FrameXmitErrStatus */
+/* Bit 3 is Status Bit 18 WriteDataLenghtGTDataLengthErr */
 
 #define PL_LOGINFO_SUB_CODE_TX_FM_CONNECTED_LOW              (0x00000500)
 #define PL_LOGINFO_SUB_CODE_SATA_NON_NCQ_RW_ERR_BIT_SET      (0x00000600)
@@ -177,6 +180,11 @@
 #define PL_LOGINFO_SUB_CODE_DISCOVERY_REMOTE_SEP_RESET       (0x00000E01)
 #define PL_LOGINFO_SUB_CODE_SECOND_OPEN                      (0x00000F00)
 #define PL_LOGINFO_SUB_CODE_DSCVRY_SATA_INIT_TIMEOUT         (0x00001000)
+#define PL_LOGINFO_SUB_CODE_BREAK_ON_SATA_CONNECTION         (0x00002000)
+/* not currently used in mainline */
+#define PL_LOGINFO_SUB_CODE_BREAK_ON_STUCK_LINK              (0x00003000)
+#define PL_LOGINFO_SUB_CODE_BREAK_ON_STUCK_LINK_AIP          (0x00004000)
+#define PL_LOGINFO_SUB_CODE_BREAK_ON_INCOMPLETE_BREAK_RCVD   (0x00005000)
 
 #define PL_LOGINFO_CODE_ENCL_MGMT_SMP_FRAME_FAILURE          (0x00200000) /* Can't get SMP Frame */
 #define PL_LOGINFO_CODE_ENCL_MGMT_SMP_READ_ERROR             (0x00200010) /* Error occured on SMP Read */
@@ -243,6 +251,8 @@
 #define IR_LOGINFO_VOLUME_ACTIVATE_VOLUME_FAILED               (0x00010014)
 /* Activation failed trying to import the volume */
 #define IR_LOGINFO_VOLUME_ACTIVATING_IMPORT_VOLUME_FAILED      (0x00010015)
+/* Activation failed trying to import the volume */
+#define IR_LOGINFO_VOLUME_ACTIVATING_TOO_MANY_PHYS_DISKS       (0x00010016)
 
 /* Phys Disk failed, too many phys disks */
 #define IR_LOGINFO_PHYSDISK_CREATE_TOO_MANY_DISKS              (0x00010020)
@@ -285,6 +295,21 @@
 /* Compatibility Error : IME size limited to < 2TB */
 #define IR_LOGINFO_COMPAT_ERROR_IME_VOL_NOT_CURRENTLY_SUPPORTED (0x0001003D)
 
+/* Device Firmware Update: DFU can only be started once */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_DFU_IN_PROGRESS            (0x00010050)
+/* Device Firmware Update: Volume must be Optimal/Active/non-Quiesced */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_DEVICE_IN_INVALID_STATE    (0x00010051)
+/* Device Firmware Update: DFU Timeout cannot be zero */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_INVALID_TIMEOUT            (0x00010052)
+/* Device Firmware Update: CREATE TIMER FAILED */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_NO_TIMERS                  (0x00010053)
+/* Device Firmware Update: Failed to read SAS_IO_UNIT_PG_1 */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_READING_CFG_PAGE           (0x00010054)
+/* Device Firmware Update: Invalid SAS_IO_UNIT_PG_1 value(s) */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_PORT_IO_TIMEOUTS_REQUIRED  (0x00010055)
+/* Device Firmware Update: Unable to allocate memory for page */
+#define IR_LOGINFO_DEV_FW_UPDATE_ERR_ALLOC_CFG_PAGE             (0x00010056)
+
 
 /****************************************************************************/
 /* Defines for convenience                                                  */
diff --git a/drivers/message/fusion/lsi/mpi_raid.h b/drivers/message/fusion/lsi/mpi_raid.h
index 2856108421d7..add60cc85be1 100644
--- a/drivers/message/fusion/lsi/mpi_raid.h
+++ b/drivers/message/fusion/lsi/mpi_raid.h
@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2001-2007 LSI Corporation.
+ *  Copyright (c) 2001-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_raid.h
  *          Title:  MPI RAID message and structures
  *  Creation Date:  February 27, 2001
  *
- *    mpi_raid.h Version:  01.05.03
+ *    mpi_raid.h Version:  01.05.05
  *
  *  Version History
  *  ---------------
@@ -34,6 +34,9 @@
  *                      _SET_RESYNC_RATE and _SET_DATA_SCRUB_RATE.
  *  02-28-07  01.05.03  Added new RAID Action, Device FW Update Mode, and
  *                      associated defines.
+ *  08-07-07  01.05.04  Added Disable Full Rebuild bit to the ActionDataWord
+ *                      for the RAID Action MPI_RAID_ACTION_DISABLE_VOLUME.
+ *  01-15-08  01.05.05  Added define for MPI_RAID_ACTION_SET_VOLUME_NAME.
  *  --------------------------------------------------------------------------
  */
 
@@ -93,6 +96,7 @@ typedef struct _MSG_RAID_ACTION
 #define MPI_RAID_ACTION_SET_RESYNC_RATE             (0x13)
 #define MPI_RAID_ACTION_SET_DATA_SCRUB_RATE         (0x14)
 #define MPI_RAID_ACTION_DEVICE_FW_UPDATE_MODE       (0x15)
+#define MPI_RAID_ACTION_SET_VOLUME_NAME             (0x16)
 
 /* ActionDataWord defines for use with MPI_RAID_ACTION_CREATE_VOLUME action */
 #define MPI_RAID_ACTION_ADATA_DO_NOT_SYNC           (0x00000001)
@@ -105,6 +109,9 @@ typedef struct _MSG_RAID_ACTION
 #define MPI_RAID_ACTION_ADATA_KEEP_LBA0             (0x00000000)
 #define MPI_RAID_ACTION_ADATA_ZERO_LBA0             (0x00000002)
 
+/* ActionDataWord defines for use with MPI_RAID_ACTION_DISABLE_VOLUME action */
+#define MPI_RAID_ACTION_ADATA_DISABLE_FULL_REBUILD  (0x00000001)
+
 /* ActionDataWord defines for use with MPI_RAID_ACTION_ACTIVATE_VOLUME action */
 #define MPI_RAID_ACTION_ADATA_INACTIVATE_ALL        (0x00000001)
 
diff --git a/drivers/message/fusion/lsi/mpi_sas.h b/drivers/message/fusion/lsi/mpi_sas.h
index 33fca83cefc2..ab410036bbfc 100644
--- a/drivers/message/fusion/lsi/mpi_sas.h
+++ b/drivers/message/fusion/lsi/mpi_sas.h
@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2004-2006 LSI Corporation.
+ *  Copyright (c) 2004-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_sas.h
  *          Title:  MPI Serial Attached SCSI structures and definitions
  *  Creation Date:  August 19, 2004
  *
- *    mpi_sas.h Version:  01.05.04
+ *    mpi_sas.h Version:  01.05.05
  *
  *  Version History
  *  ---------------
@@ -23,6 +23,10 @@
  *                      reply.
  *  10-11-06  01.05.04  Fixed the name of a define for Operation field of SAS IO
  *                      Unit Control request.
+ *  01-15-08  01.05.05  Added support for MPI_SAS_OP_SET_IOC_PARAMETER,
+ *                      including adding IOCParameter and IOCParameter value
+ *                      fields to SAS IO Unit Control Request.
+ *                      Added MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC define.
  *  --------------------------------------------------------------------------
  */
 
@@ -60,6 +64,8 @@
  * Values for the SAS DeviceInfo field used in SAS Device Status Change Event
  * data and SAS IO Unit Configuration pages.
  */
+#define MPI_SAS_DEVICE_INFO_PRODUCT_SPECIFIC    (0xF0000000)
+
 #define MPI_SAS_DEVICE_INFO_SEP                 (0x00004000)
 #define MPI_SAS_DEVICE_INFO_ATAPI_DEVICE        (0x00002000)
 #define MPI_SAS_DEVICE_INFO_LSI_DEVICE          (0x00001000)
@@ -216,7 +222,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_REQUEST
     U8                      ChainOffset;        /* 02h */
     U8                      Function;           /* 03h */
     U16                     DevHandle;          /* 04h */
-    U8                      Reserved3;          /* 06h */
+    U8                      IOCParameter;       /* 06h */
     U8                      MsgFlags;           /* 07h */
     U32                     MsgContext;         /* 08h */
     U8                      TargetID;           /* 0Ch */
@@ -225,7 +231,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_REQUEST
     U8                      PrimFlags;          /* 0Fh */
     U32                     Primitive;          /* 10h */
     U64                     SASAddress;         /* 14h */
-    U32                     Reserved4;          /* 1Ch */
+    U32                     IOCParameterValue;  /* 1Ch */
 } MSG_SAS_IOUNIT_CONTROL_REQUEST, MPI_POINTER PTR_MSG_SAS_IOUNIT_CONTROL_REQUEST,
   SasIoUnitControlRequest_t, MPI_POINTER pSasIoUnitControlRequest_t;
 
@@ -241,6 +247,8 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_REQUEST
 #define MPI_SAS_OP_TRANSMIT_PORT_SELECT_SIGNAL  (0x0C)
 #define MPI_SAS_OP_TRANSMIT_REMOVE_DEVICE       (0x0D)  /* obsolete name */
 #define MPI_SAS_OP_REMOVE_DEVICE                (0x0D)
+#define MPI_SAS_OP_SET_IOC_PARAMETER            (0x0E)
+#define MPI_SAS_OP_PRODUCT_SPECIFIC_MIN         (0x80)
 
 /* values for the PrimFlags field */
 #define MPI_SAS_PRIMFLAGS_SINGLE                (0x08)
@@ -256,7 +264,7 @@ typedef struct _MSG_SAS_IOUNIT_CONTROL_REPLY
     U8                      MsgLength;          /* 02h */
     U8                      Function;           /* 03h */
     U16                     DevHandle;          /* 04h */
-    U8                      Reserved3;          /* 06h */
+    U8                      IOCParameter;       /* 06h */
     U8                      MsgFlags;           /* 07h */
     U32                     MsgContext;         /* 08h */
     U16                     Reserved4;          /* 0Ch */
diff --git a/drivers/message/fusion/lsi/mpi_targ.h b/drivers/message/fusion/lsi/mpi_targ.h
index ff8c37d3fdcb..c3dea7f6909d 100644
--- a/drivers/message/fusion/lsi/mpi_targ.h
+++ b/drivers/message/fusion/lsi/mpi_targ.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2000-2004 LSI Corporation.
+ *  Copyright (c) 2000-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_targ.h
diff --git a/drivers/message/fusion/lsi/mpi_tool.h b/drivers/message/fusion/lsi/mpi_tool.h
index 8834ae6ce0f2..53cd715aa7e4 100644
--- a/drivers/message/fusion/lsi/mpi_tool.h
+++ b/drivers/message/fusion/lsi/mpi_tool.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright (c) 2001-2005 LSI Corporation.
+ *  Copyright (c) 2001-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_tool.h
diff --git a/drivers/message/fusion/lsi/mpi_type.h b/drivers/message/fusion/lsi/mpi_type.h
index 08dad9c1e446..888b26dbc413 100644
--- a/drivers/message/fusion/lsi/mpi_type.h
+++ b/drivers/message/fusion/lsi/mpi_type.h
@@ -1,12 +1,12 @@
 /*
- *  Copyright (c) 2000-2004 LSI Corporation.
+ *  Copyright (c) 2000-2008 LSI Corporation.
  *
  *
  *           Name:  mpi_type.h
  *          Title:  MPI Basic type definitions
  *  Creation Date:  June 6, 2000
  *
- *    mpi_type.h Version:  01.05.01
+ *    mpi_type.h Version:  01.05.02
  *
  *  Version History
  *  ---------------
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index c4e8b9aa3827..96ac88317b8e 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -79,9 +79,22 @@ MODULE_VERSION(my_VERSION);
 /*
  *  cmd line parameters
  */
-static int mpt_msi_enable = -1;
-module_param(mpt_msi_enable, int, 0);
-MODULE_PARM_DESC(mpt_msi_enable, " MSI Support Enable (default=0)");
+
+static int mpt_msi_enable_spi;
+module_param(mpt_msi_enable_spi, int, 0);
+MODULE_PARM_DESC(mpt_msi_enable_spi, " Enable MSI Support for SPI \
+                controllers (default=0)");
+
+static int mpt_msi_enable_fc;
+module_param(mpt_msi_enable_fc, int, 0);
+MODULE_PARM_DESC(mpt_msi_enable_fc, " Enable MSI Support for FC \
+                controllers (default=0)");
+
+static int mpt_msi_enable_sas;
+module_param(mpt_msi_enable_sas, int, 1);
+MODULE_PARM_DESC(mpt_msi_enable_sas, " Enable MSI Support for SAS \
+                controllers (default=1)");
+
 
 static int mpt_channel_mapping;
 module_param(mpt_channel_mapping, int, 0);
@@ -91,7 +104,17 @@ static int mpt_debug_level;
 static int mpt_set_debug_level(const char *val, struct kernel_param *kp);
 module_param_call(mpt_debug_level, mpt_set_debug_level, param_get_int,
                   &mpt_debug_level, 0600);
-MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h - (default=0)");
+MODULE_PARM_DESC(mpt_debug_level, " debug level - refer to mptdebug.h \
+        - (default=0)");
+
+int mpt_fwfault_debug;
+EXPORT_SYMBOL(mpt_fwfault_debug);
+module_param_call(mpt_fwfault_debug, param_set_int, param_get_int,
+          &mpt_fwfault_debug, 0600);
+MODULE_PARM_DESC(mpt_fwfault_debug, "Enable detection of Firmware fault"
+        " and halt Firmware on fault - (default=0)");
+
+
 
 #ifdef MFCNT
 static int mfcounter = 0;
@@ -1751,16 +1774,25 @@ mpt_attach(struct pci_dev *pdev, const struct pci_device_id *id)
                 ioc->bus_type = SAS;
         }
 
-        if (mpt_msi_enable == -1) {
-                /* Enable on SAS, disable on FC and SPI */
-                if (ioc->bus_type == SAS)
-                        ioc->msi_enable = 1;
-                else
-                        ioc->msi_enable = 0;
-        } else
-                /* follow flag: 0 - disable; 1 - enable */
-                ioc->msi_enable = mpt_msi_enable;
 
+        switch (ioc->bus_type) {
+
+        case SAS:
+                ioc->msi_enable = mpt_msi_enable_sas;
+                break;
+
+        case SPI:
+                ioc->msi_enable = mpt_msi_enable_spi;
+                break;
+
+        case FC:
+                ioc->msi_enable = mpt_msi_enable_fc;
+                break;
+
+        default:
+                ioc->msi_enable = 0;
+                break;
+        }
         if (ioc->errata_flag_1064)
                 pci_disable_io_access(pdev);
 
@@ -6313,6 +6345,33 @@ mpt_print_ioc_summary(MPT_ADAPTER *ioc, char *buffer, int *size, int len, int sh
         *size = y;
 }
 
+
+/**
+ *      mpt_halt_firmware - Halts the firmware if it is operational and panic
+ *      the kernel
+ *      @ioc: Pointer to MPT_ADAPTER structure
+ *
+ **/
+void
+mpt_halt_firmware(MPT_ADAPTER *ioc)
+{
+        u32      ioc_raw_state;
+
+        ioc_raw_state = mpt_GetIocState(ioc, 0);
+
+        if ((ioc_raw_state & MPI_IOC_STATE_MASK) == MPI_IOC_STATE_FAULT) {
+                printk(MYIOC_s_ERR_FMT "IOC is in FAULT state (%04xh)!!!\n",
+                        ioc->name, ioc_raw_state & MPI_DOORBELL_DATA_MASK);
+                panic("%s: IOC Fault (%04xh)!!!\n", ioc->name,
+                        ioc_raw_state & MPI_DOORBELL_DATA_MASK);
+        } else {
+                CHIPREG_WRITE32(&ioc->chip->Doorbell, 0xC0FFEE00);
+                panic("%s: Firmware is halted due to command timeout\n",
+                        ioc->name);
+        }
+}
+EXPORT_SYMBOL(mpt_halt_firmware);
+
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 /*
  *      Reset Handling
@@ -6345,6 +6404,8 @@ mpt_HardResetHandler(MPT_ADAPTER *ioc, int sleepFlag)
         printk(MYIOC_s_INFO_FMT "HardResetHandler Entered!\n", ioc->name);
         printk("MF count 0x%x !\n", ioc->mfcnt);
 #endif
+        if (mpt_fwfault_debug)
+                mpt_halt_firmware(ioc);
 
         /* Reset the adapter. Prevent more than 1 call to
          * mpt_do_ioc_recovery at any instant in time.
diff --git a/drivers/message/fusion/mptbase.h b/drivers/message/fusion/mptbase.h
index dff048cfa101..b3e981d2a506 100644
--- a/drivers/message/fusion/mptbase.h
+++ b/drivers/message/fusion/mptbase.h
@@ -922,11 +922,14 @@ extern void	 mpt_free_fw_memory(MPT_ADAPTER *ioc);
 extern int       mpt_findImVolumes(MPT_ADAPTER *ioc);
 extern int       mptbase_sas_persist_operation(MPT_ADAPTER *ioc, u8 persist_opcode);
 extern int       mpt_raid_phys_disk_pg0(MPT_ADAPTER *ioc, u8 phys_disk_num, pRaidPhysDiskPage0_t phys_disk);
+extern void     mpt_halt_firmware(MPT_ADAPTER *ioc);
+
 
 /*
  *  Public data decl's...
  */
 extern struct list_head   ioc_list;
+extern int mpt_fwfault_debug;
 
 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/
 #endif          /* } __KERNEL__ */
diff --git a/drivers/message/fusion/mptscsih.c b/drivers/message/fusion/mptscsih.c
index ee090413e598..e62c6bc4ad33 100644
--- a/drivers/message/fusion/mptscsih.c
+++ b/drivers/message/fusion/mptscsih.c
@@ -1846,6 +1846,9 @@ mptscsih_abort(struct scsi_cmnd * SCpnt)
         if (hd->timeouts < -1)
                 hd->timeouts++;
 
+        if (mpt_fwfault_debug)
+                mpt_halt_firmware(ioc);
+
         /* Most important!  Set TaskMsgContext to SCpnt's MsgContext!
          * (the IO to be ABORT'd)
          *
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 419c378bd24b..56073199ceba 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -87,14 +87,6 @@ config PHANTOM
           If you choose to build module, its name will be phantom. If unsure,
           say N here.
 
-config EEPROM_93CX6
-        tristate "EEPROM 93CX6 support"
-        ---help---
-          This is a driver for the EEPROM chipsets 93c46 and 93c66.
-          The driver supports both read as well as write commands.
-
-          If unsure, say N.
-
 config SGI_IOC4
         tristate "SGI IOC4 Base IO support"
         depends on PCI
@@ -231,5 +223,6 @@ config DELL_LAPTOP
         laptops.
 
 source "drivers/misc/c2port/Kconfig"
+source "drivers/misc/eeprom/Kconfig"
 
 endif # MISC_DEVICES
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index 9cf8ae6e4b39..bc1199830554 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -10,14 +10,13 @@ obj-$(CONFIG_ATMEL_TCLIB)	+= atmel_tclib.o
 obj-$(CONFIG_ICS932S401)        += ics932s401.o
 obj-$(CONFIG_LKDTM)             += lkdtm.o
 obj-$(CONFIG_TIFM_CORE)         += tifm_core.o
-obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_TIFM_7XX1)         += tifm_7xx1.o
 obj-$(CONFIG_PHANTOM)           += phantom.o
 obj-$(CONFIG_SGI_IOC4)          += ioc4.o
-obj-$(CONFIG_EEPROM_93CX6)      += eeprom_93cx6.o
 obj-$(CONFIG_ENCLOSURE_SERVICES) += enclosure.o
 obj-$(CONFIG_KGDB_TESTS)        += kgdbts.o
 obj-$(CONFIG_SGI_XP)            += sgi-xp/
 obj-$(CONFIG_SGI_GRU)           += sgi-gru/
 obj-$(CONFIG_HP_ILO)            += hpilo.o
 obj-$(CONFIG_C2PORT)            += c2port/
+obj-y                           += eeprom/
diff --git a/drivers/misc/eeprom/Kconfig b/drivers/misc/eeprom/Kconfig
new file mode 100644
index 000000000000..c76df8cda5ef
--- /dev/null
+++ b/drivers/misc/eeprom/Kconfig
@@ -0,0 +1,59 @@
+menu "EEPROM support"
+
+config EEPROM_AT24
+        tristate "I2C EEPROMs from most vendors"
+        depends on I2C && SYSFS && EXPERIMENTAL
+        help
+          Enable this driver to get read/write support to most I2C EEPROMs,
+          after you configure the driver to know about each EEPROM on
+          your target board.  Use these generic chip names, instead of
+          vendor-specific ones like at24c64 or 24lc02:
+
+             24c00, 24c01, 24c02, spd (readonly 24c02), 24c04, 24c08,
+             24c16, 24c32, 24c64, 24c128, 24c256, 24c512, 24c1024
+
+          Unless you like data loss puzzles, always be sure that any chip
+          you configure as a 24c32 (32 kbit) or larger is NOT really a
+          24c16 (16 kbit) or smaller, and vice versa. Marking the chip
+          as read-only won't help recover from this. Also, if your chip
+          has any software write-protect mechanism you may want to review the
+          code to make sure this driver won't turn it on by accident.
+
+          If you use this with an SMBus adapter instead of an I2C adapter,
+          full functionality is not available.  Only smaller devices are
+          supported (24c16 and below, max 4 kByte).
+
+          This driver can also be built as a module.  If so, the module
+          will be called at24.
+
+config EEPROM_AT25
+        tristate "SPI EEPROMs from most vendors"
+        depends on SPI && SYSFS
+        help
+          Enable this driver to get read/write support to most SPI EEPROMs,
+          after you configure the board init code to know about each eeprom
+          on your target board.
+
+          This driver can also be built as a module.  If so, the module
+          will be called at25.
+
+config EEPROM_LEGACY
+        tristate "Old I2C EEPROM reader"
+        depends on I2C && SYSFS
+        help
+          If you say yes here you get read-only access to the EEPROM data
+          available on modern memory DIMMs and Sony Vaio laptops via I2C. Such
+          EEPROMs could theoretically be available on other devices as well.
+
+          This driver can also be built as a module.  If so, the module
+          will be called eeprom.
+
+config EEPROM_93CX6
+        tristate "EEPROM 93CX6 support"
+        help
+          This is a driver for the EEPROM chipsets 93c46 and 93c66.
+          The driver supports both read as well as write commands.
+
+          If unsure, say N.
+
+endmenu
diff --git a/drivers/misc/eeprom/Makefile b/drivers/misc/eeprom/Makefile
new file mode 100644
index 000000000000..539dd8f88128
--- /dev/null
+++ b/drivers/misc/eeprom/Makefile
@@ -0,0 +1,4 @@
+obj-$(CONFIG_EEPROM_AT24)       += at24.o
+obj-$(CONFIG_EEPROM_AT25)       += at25.o
+obj-$(CONFIG_EEPROM_LEGACY)     += eeprom.o
+obj-$(CONFIG_EEPROM_93CX6)      += eeprom_93cx6.o
diff --git a/drivers/i2c/chips/at24.c b/drivers/misc/eeprom/at24.c
index d4775528abc6..d4775528abc6 100644
--- a/drivers/i2c/chips/at24.c
+++ b/drivers/misc/eeprom/at24.c
diff --git a/drivers/spi/at25.c b/drivers/misc/eeprom/at25.c
index 290dbe99647a..290dbe99647a 100644
--- a/drivers/spi/at25.c
+++ b/drivers/misc/eeprom/at25.c
diff --git a/drivers/i2c/chips/eeprom.c b/drivers/misc/eeprom/eeprom.c
index 2c27193aeaa0..2c27193aeaa0 100644
--- a/drivers/i2c/chips/eeprom.c
+++ b/drivers/misc/eeprom/eeprom.c
diff --git a/drivers/misc/eeprom_93cx6.c b/drivers/misc/eeprom/eeprom_93cx6.c
index 15b1780025c8..15b1780025c8 100644
--- a/drivers/misc/eeprom_93cx6.c
+++ b/drivers/misc/eeprom/eeprom_93cx6.c
diff --git a/drivers/misc/sgi-xp/xpc_sn2.c b/drivers/misc/sgi-xp/xpc_sn2.c
index 73b7fb8de47a..82fb9958f22f 100644
--- a/drivers/misc/sgi-xp/xpc_sn2.c
+++ b/drivers/misc/sgi-xp/xpc_sn2.c
@@ -899,7 +899,7 @@ xpc_update_partition_info_sn2(struct xpc_partition *part, u8 remote_rp_version,
         dev_dbg(xpc_part, "  remote_vars_pa = 0x%016lx\n",
                 part_sn2->remote_vars_pa);
 
-        part->last_heartbeat = remote_vars->heartbeat;
+        part->last_heartbeat = remote_vars->heartbeat - 1;
         dev_dbg(xpc_part, "  last_heartbeat = 0x%016lx\n",
                 part->last_heartbeat);
 
diff --git a/drivers/net/arm/etherh.c b/drivers/net/arm/etherh.c
index 745ac188babe..d15d8b79d8e5 100644
--- a/drivers/net/arm/etherh.c
+++ b/drivers/net/arm/etherh.c
@@ -646,7 +646,7 @@ static const struct net_device_ops etherh_netdev_ops = {
         .ndo_get_stats          = ei_get_stats,
         .ndo_set_multicast_list = ei_set_multicast_list,
         .ndo_validate_addr      = eth_validate_addr,
-        .ndo_set_mac_addr       = eth_set_mac_addr,
+        .ndo_set_mac_address    = eth_set_mac_addr,
         .ndo_change_mtu         = eth_change_mtu,
 #ifdef CONFIG_NET_POLL_CONTROLLER
         .ndo_poll_controller    = ei_poll,
diff --git a/drivers/net/ax88796.c b/drivers/net/ax88796.c
index 337488ec707c..a4eb6c40678c 100644
--- a/drivers/net/ax88796.c
+++ b/drivers/net/ax88796.c
@@ -37,7 +37,10 @@ static int phy_debug = 0;
 #define __ei_open       ax_ei_open
 #define __ei_close      ax_ei_close
 #define __ei_poll       ax_ei_poll
+#define __ei_start_xmit ax_ei_start_xmit
 #define __ei_tx_timeout ax_ei_tx_timeout
+#define __ei_get_stats  ax_ei_get_stats
+#define __ei_set_multicast_list ax_ei_set_multicast_list
 #define __ei_interrupt  ax_ei_interrupt
 #define ____alloc_ei_netdev ax__alloc_ei_netdev
 #define __NS8390_init   ax_NS8390_init
@@ -623,6 +626,23 @@ static void ax_eeprom_register_write(struct eeprom_93cx6 *eeprom)
 }
 #endif
 
+static const struct net_device_ops ax_netdev_ops = {
+        .ndo_open               = ax_open,
+        .ndo_stop               = ax_close,
+        .ndo_do_ioctl           = ax_ioctl,
+
+        .ndo_start_xmit         = ax_ei_start_xmit,
+        .ndo_tx_timeout         = ax_ei_tx_timeout,
+        .ndo_get_stats          = ax_ei_get_stats,
+        .ndo_set_multicast_list = ax_ei_set_multicast_list,
+        .ndo_validate_addr      = eth_validate_addr,
+        .ndo_set_mac_address    = eth_mac_addr,
+        .ndo_change_mtu         = eth_change_mtu,
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        .ndo_poll_controller    = ax_ei_poll,
+#endif
+};
+
 /* setup code */
 
 static void ax_initial_setup(struct net_device *dev, struct ei_device *ei_local)
@@ -738,9 +758,7 @@ static int ax_init_dev(struct net_device *dev, int first_init)
         ei_status.get_8390_hdr  = &ax_get_8390_hdr;
         ei_status.priv = 0;
 
-        dev->open               = ax_open;
-        dev->stop               = ax_close;
-        dev->do_ioctl           = ax_ioctl;
+        dev->netdev_ops         = &ax_netdev_ops;
         dev->ethtool_ops        = &ax_ethtool_ops;
 
         ax->msg_enable          = NETIF_MSG_LINK;
@@ -753,9 +771,6 @@ static int ax_init_dev(struct net_device *dev, int first_init)
         ax->mii.mdio_write      = ax_phy_write;
         ax->mii.dev             = dev;
 
-#ifdef CONFIG_NET_POLL_CONTROLLER
-        dev->poll_controller = ax_ei_poll;
-#endif
         ax_NS8390_init(dev, 0);
 
         if (first_init)
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 5ae131c147f9..c38512ebcea6 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -679,6 +679,7 @@ static int b44_alloc_rx_skb(struct b44 *bp, int src_idx, u32 dest_idx_unmasked)
                         dev_kfree_skb_any(skb);
                         return -ENOMEM;
                 }
+                bp->force_copybreak = 1;
         }
 
         rh = (struct rx_header *) skb->data;
@@ -800,7 +801,7 @@ static int b44_rx(struct b44 *bp, int budget)
                 /* Omit CRC. */
                 len -= 4;
 
-                if (len > RX_COPY_THRESHOLD) {
+                if (!bp->force_copybreak && len > RX_COPY_THRESHOLD) {
                         int skb_size;
                         skb_size = b44_alloc_rx_skb(bp, cons, bp->rx_prod);
                         if (skb_size < 0)
@@ -2152,6 +2153,7 @@ static int __devinit b44_init_one(struct ssb_device *sdev,
         bp = netdev_priv(dev);
         bp->sdev = sdev;
         bp->dev = dev;
+        bp->force_copybreak = 0;
 
         bp->msg_enable = netif_msg_init(b44_debug, B44_DEF_MSG_ENABLE);
 
diff --git a/drivers/net/b44.h b/drivers/net/b44.h
index 7db0c84a7950..e678498de6db 100644
--- a/drivers/net/b44.h
+++ b/drivers/net/b44.h
@@ -395,7 +395,7 @@ struct b44 {
         u32                     rx_pending;
         u32                     tx_pending;
         u8                      phy_addr;
-
+        u8                      force_copybreak;
         struct mii_if_info      mii_if;
 };
 
diff --git a/drivers/net/bnx2x.h b/drivers/net/bnx2x.h
index fd705d1295a7..15a5cf0f676b 100644
--- a/drivers/net/bnx2x.h
+++ b/drivers/net/bnx2x.h
@@ -1,6 +1,6 @@
 /* bnx2x.h: Broadcom Everest network driver.
  *
- * Copyright (c) 2007-2008 Broadcom Corporation
+ * Copyright (c) 2007-2009 Broadcom Corporation
  *
  * 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
@@ -20,6 +20,11 @@
  * (you will need to reboot afterwards) */
 /* #define BNX2X_STOP_ON_ERROR */
 
+#if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
+#define BCM_VLAN                        1
+#endif
+
+
 /* error/debug prints */
 
 #define DRV_MODULE_NAME         "bnx2x"
@@ -78,11 +83,6 @@
 #endif
 
 
-#ifdef NETIF_F_HW_VLAN_TX
-#define BCM_VLAN                        1
-#endif
-
-
 #define U64_LO(x)                       (u32)(((u64)(x)) & 0xffffffff)
 #define U64_HI(x)                       (u32)(((u64)(x)) >> 32)
 #define HILO_U64(hi, lo)                ((((u64)(hi)) << 32) + (lo))
@@ -150,6 +150,9 @@ struct sw_rx_page {
 
 #define PAGES_PER_SGE_SHIFT             0
 #define PAGES_PER_SGE                   (1 << PAGES_PER_SGE_SHIFT)
+#define SGE_PAGE_SIZE                   PAGE_SIZE
+#define SGE_PAGE_SHIFT                  PAGE_SHIFT
+#define SGE_PAGE_ALIGN(addr)            PAGE_ALIGN(addr)
 
 #define BCM_RX_ETH_PAYLOAD_ALIGN        64
 
@@ -268,14 +271,7 @@ struct bnx2x_fastpath {
 
 #define bnx2x_fp(bp, nr, var)           (bp->fp[nr].var)
 
-#define BNX2X_HAS_TX_WORK(fp) \
-                        ((fp->tx_pkt_prod != le16_to_cpu(*fp->tx_cons_sb)) || \
-                         (fp->tx_pkt_prod != fp->tx_pkt_cons))
-
-#define BNX2X_HAS_RX_WORK(fp) \
-                        (fp->rx_comp_cons != rx_cons_sb)
-
-#define BNX2X_HAS_WORK(fp)      (BNX2X_HAS_RX_WORK(fp) || BNX2X_HAS_TX_WORK(fp))
+#define BNX2X_HAS_WORK(fp)      (bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))
 
 
 /* MC hsi */
@@ -736,7 +732,7 @@ struct bnx2x {
         struct bnx2x_fastpath   fp[MAX_CONTEXT];
         void __iomem            *regview;
         void __iomem            *doorbells;
-#define BNX2X_DB_SIZE           (16*2048)
+#define BNX2X_DB_SIZE           (16*BCM_PAGE_SIZE)
 
         struct net_device       *dev;
         struct pci_dev          *pdev;
@@ -801,6 +797,8 @@ struct bnx2x {
 #define TPA_ENABLE_FLAG                 0x80
 #define NO_MCP_FLAG                     0x100
 #define BP_NOMCP(bp)                    (bp->flags & NO_MCP_FLAG)
+#define HW_VLAN_TX_FLAG                 0x400
+#define HW_VLAN_RX_FLAG                 0x800
 
         int                     func;
 #define BP_PORT(bp)                     (bp->func % PORT_MAX)
@@ -811,7 +809,7 @@ struct bnx2x {
         int                     pm_cap;
         int                     pcie_cap;
 
-        struct work_struct      sp_task;
+        struct delayed_work     sp_task;
         struct work_struct      reset_task;
 
         struct timer_list       timer;
diff --git a/drivers/net/bnx2x_link.c b/drivers/net/bnx2x_link.c
index fefa6ab13064..aea26b4dc453 100644
--- a/drivers/net/bnx2x_link.c
+++ b/drivers/net/bnx2x_link.c
@@ -1,4 +1,4 @@
-/* Copyright 2008 Broadcom Corporation
+/* Copyright 2008-2009 Broadcom Corporation
  *
  * Unless you and Broadcom execute a separate written software license
  * agreement governing use of this software, this software is licensed to you
@@ -317,6 +317,9 @@ static u8 bnx2x_emac_enable(struct link_params *params,
                 val &= ~0x810;
         EMAC_WR(bp, EMAC_REG_EMAC_MODE, val);
 
+        /* enable emac */
+        REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 1);
+
         /* enable emac for jumbo packets */
         EMAC_WR(bp, EMAC_REG_EMAC_RX_MTU_SIZE,
                 (EMAC_RX_MTU_SIZE_JUMBO_ENA |
@@ -1609,7 +1612,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                                       u32 gp_status)
 {
         struct bnx2x *bp = params->bp;
-
+        u16 new_line_speed;
         u8 rc = 0;
         vars->link_status = 0;
 
@@ -1629,7 +1632,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
 
                 switch (gp_status & GP_STATUS_SPEED_MASK) {
                 case GP_STATUS_10M:
-                        vars->line_speed = SPEED_10;
+                        new_line_speed = SPEED_10;
                         if (vars->duplex == DUPLEX_FULL)
                                 vars->link_status |= LINK_10TFD;
                         else
@@ -1637,7 +1640,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                         break;
 
                 case GP_STATUS_100M:
-                        vars->line_speed = SPEED_100;
+                        new_line_speed = SPEED_100;
                         if (vars->duplex == DUPLEX_FULL)
                                 vars->link_status |= LINK_100TXFD;
                         else
@@ -1646,7 +1649,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
 
                 case GP_STATUS_1G:
                 case GP_STATUS_1G_KX:
-                        vars->line_speed = SPEED_1000;
+                        new_line_speed = SPEED_1000;
                         if (vars->duplex == DUPLEX_FULL)
                                 vars->link_status |= LINK_1000TFD;
                         else
@@ -1654,7 +1657,7 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                         break;
 
                 case GP_STATUS_2_5G:
-                        vars->line_speed = SPEED_2500;
+                        new_line_speed = SPEED_2500;
                         if (vars->duplex == DUPLEX_FULL)
                                 vars->link_status |= LINK_2500TFD;
                         else
@@ -1671,32 +1674,32 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                 case GP_STATUS_10G_KX4:
                 case GP_STATUS_10G_HIG:
                 case GP_STATUS_10G_CX4:
-                        vars->line_speed = SPEED_10000;
+                        new_line_speed = SPEED_10000;
                         vars->link_status |= LINK_10GTFD;
                         break;
 
                 case GP_STATUS_12G_HIG:
-                        vars->line_speed = SPEED_12000;
+                        new_line_speed = SPEED_12000;
                         vars->link_status |= LINK_12GTFD;
                         break;
 
                 case GP_STATUS_12_5G:
-                        vars->line_speed = SPEED_12500;
+                        new_line_speed = SPEED_12500;
                         vars->link_status |= LINK_12_5GTFD;
                         break;
 
                 case GP_STATUS_13G:
-                        vars->line_speed = SPEED_13000;
+                        new_line_speed = SPEED_13000;
                         vars->link_status |= LINK_13GTFD;
                         break;
 
                 case GP_STATUS_15G:
-                        vars->line_speed = SPEED_15000;
+                        new_line_speed = SPEED_15000;
                         vars->link_status |= LINK_15GTFD;
                         break;
 
                 case GP_STATUS_16G:
-                        vars->line_speed = SPEED_16000;
+                        new_line_speed = SPEED_16000;
                         vars->link_status |= LINK_16GTFD;
                         break;
 
@@ -1708,6 +1711,15 @@ static u8 bnx2x_link_settings_status(struct link_params *params,
                         break;
                 }
 
+                /* Upon link speed change set the NIG into drain mode.
+                Comes to deals with possible FIFO glitch due to clk change
+                when speed is decreased without link down indicator */
+                if (new_line_speed != vars->line_speed) {
+                        REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE
+                                    + params->port*4, 0);
+                        msleep(1);
+                }
+                vars->line_speed = new_line_speed;
                 vars->link_status |= LINK_STATUS_SERDES_LINK;
 
                 if ((params->req_line_speed == SPEED_AUTO_NEG) &&
@@ -3571,7 +3583,7 @@ static void bnx2x_set_xgxs_loopback(struct link_params *params,
                                (MDIO_REG_BANK_CL73_IEEEB0 +
                                 (MDIO_CL73_IEEEB0_CL73_AN_CONTROL & 0xf)),
                                0x6041);
-
+                msleep(200);
                 /* set aer mmd back */
                 bnx2x_set_aer_mmd(params, vars);
 
@@ -3870,9 +3882,15 @@ static u8 bnx2x_link_initialize(struct link_params *params,
         }
 
         if (vars->phy_flags & PHY_XGXS_FLAG) {
-                if (params->req_line_speed &&
+                if ((params->req_line_speed &&
                     ((params->req_line_speed == SPEED_100) ||
-                     (params->req_line_speed == SPEED_10))) {
+                     (params->req_line_speed == SPEED_10))) ||
+                    (!params->req_line_speed &&
+                     (params->speed_cap_mask >=
+                       PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_FULL) &&
+                     (params->speed_cap_mask <
+                       PORT_HW_CFG_SPEED_CAPABILITY_D0_1G)
+                     ))  {
                         vars->phy_flags |= PHY_SGMII_FLAG;
                 } else {
                         vars->phy_flags &= ~PHY_SGMII_FLAG;
@@ -4194,6 +4212,11 @@ static u8 bnx2x_update_link_down(struct link_params *params,
         /* activate nig drain */
         REG_WR(bp, NIG_REG_EGRESS_DRAIN0_MODE + port*4, 1);
 
+        /* disable emac */
+        REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
+
+        msleep(10);
+
         /* reset BigMac */
         bnx2x_bmac_rx_disable(bp, params->port);
         REG_WR(bp, GRCBASE_MISC +
@@ -4238,6 +4261,7 @@ static u8 bnx2x_update_link_up(struct link_params *params,
 
         /* update shared memory */
         bnx2x_update_mng(params, vars->link_status);
+        msleep(20);
         return rc;
 }
 /* This function should called upon link interrupt */
@@ -4276,6 +4300,9 @@ u8 bnx2x_link_update(struct link_params *params, struct link_vars *vars)
           REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK10G + port*0x68),
           REG_RD(bp, NIG_REG_XGXS0_STATUS_LINK_STATUS + port*0x68));
 
+        /* disable emac */
+        REG_WR(bp, NIG_REG_NIG_EMAC0_EN + port*4, 0);
+
         ext_phy_type = XGXS_EXT_PHY_TYPE(params->ext_phy_config);
 
         /* Check external link change only for non-direct */
@@ -4377,10 +4404,11 @@ static u8 bnx2x_8073_common_init_phy(struct bnx2x *bp, u32 shmem_base)
                               ext_phy_addr[port],
                               MDIO_PMA_DEVAD,
                               MDIO_PMA_REG_ROM_VER1, &fw_ver1);
-                if (fw_ver1 == 0) {
+                if (fw_ver1 == 0 || fw_ver1 == 0x4321) {
                         DP(NETIF_MSG_LINK,
-                                 "bnx2x_8073_common_init_phy port %x "
-                                 "fw Download failed\n", port);
+                                 "bnx2x_8073_common_init_phy port %x:"
+                                 "Download failed. fw version = 0x%x\n",
+                                 port, fw_ver1);
                         return -EINVAL;
                 }
 
diff --git a/drivers/net/bnx2x_main.c b/drivers/net/bnx2x_main.c
index 4be05847f86f..d3e7775a9ccf 100644
--- a/drivers/net/bnx2x_main.c
+++ b/drivers/net/bnx2x_main.c
@@ -1,6 +1,6 @@
 /* bnx2x_main.c: Broadcom Everest network driver.
  *
- * Copyright (c) 2007-2008 Broadcom Corporation
+ * Copyright (c) 2007-2009 Broadcom Corporation
  *
  * 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
@@ -38,9 +38,7 @@
 #include <linux/time.h>
 #include <linux/ethtool.h>
 #include <linux/mii.h>
-#ifdef NETIF_F_HW_VLAN_TX
-        #include <linux/if_vlan.h>
-#endif
+#include <linux/if_vlan.h>
 #include <net/ip.h>
 #include <net/tcp.h>
 #include <net/checksum.h>
@@ -59,8 +57,8 @@
 #include "bnx2x.h"
 #include "bnx2x_init.h"
 
-#define DRV_MODULE_VERSION      "1.45.23"
-#define DRV_MODULE_RELDATE      "2008/11/03"
+#define DRV_MODULE_VERSION      "1.45.26"
+#define DRV_MODULE_RELDATE      "2009/01/26"
 #define BNX2X_BC_VER            0x040200
 
 /* Time in jiffies before concluding the transmitter is hung */
@@ -71,7 +69,7 @@ static char version[] __devinitdata =
         DRV_MODULE_NAME " " DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 
 MODULE_AUTHOR("Eliezer Tamir");
-MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710 Driver");
+MODULE_DESCRIPTION("Broadcom NetXtreme II BCM57710/57711/57711E Driver");
 MODULE_LICENSE("GPL");
 MODULE_VERSION(DRV_MODULE_VERSION);
 
@@ -95,6 +93,7 @@ MODULE_PARM_DESC(debug, "default debug msglevel");
 module_param(use_multi, int, 0);
 MODULE_PARM_DESC(use_multi, "use per-CPU queues");
 #endif
+static struct workqueue_struct *bnx2x_wq;
 
 enum bnx2x_board_type {
         BCM57710 = 0,
@@ -671,7 +670,8 @@ static void bnx2x_int_disable_sync(struct bnx2x *bp, int disable_hw)
                 synchronize_irq(bp->pdev->irq);
 
         /* make sure sp_task is not running */
-        cancel_work_sync(&bp->sp_task);
+        cancel_delayed_work(&bp->sp_task);
+        flush_workqueue(bnx2x_wq);
 }
 
 /* fast path */
@@ -733,6 +733,24 @@ static u16 bnx2x_ack_int(struct bnx2x *bp)
  * fast path service functions
  */
 
+static inline int bnx2x_has_tx_work(struct bnx2x_fastpath *fp)
+{
+        u16 tx_cons_sb;
+
+        /* Tell compiler that status block fields can change */
+        barrier();
+        tx_cons_sb = le16_to_cpu(*fp->tx_cons_sb);
+        return (fp->tx_pkt_cons != tx_cons_sb);
+}
+
+static inline int bnx2x_has_tx_work_unload(struct bnx2x_fastpath *fp)
+{
+        /* Tell compiler that consumer and producer can change */
+        barrier();
+        return (fp->tx_pkt_prod != fp->tx_pkt_cons);
+
+}
+
 /* free skb in the packet ring at pos idx
  * return idx of last bd freed
  */
@@ -972,7 +990,7 @@ static inline void bnx2x_free_rx_sge(struct bnx2x *bp,
                 return;
 
         pci_unmap_page(bp->pdev, pci_unmap_addr(sw_buf, mapping),
-                       BCM_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
+                       SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
         __free_pages(page, PAGES_PER_SGE_SHIFT);
 
         sw_buf->page = NULL;
@@ -1000,7 +1018,7 @@ static inline int bnx2x_alloc_rx_sge(struct bnx2x *bp,
         if (unlikely(page == NULL))
                 return -ENOMEM;
 
-        mapping = pci_map_page(bp->pdev, page, 0, BCM_PAGE_SIZE*PAGES_PER_SGE,
+        mapping = pci_map_page(bp->pdev, page, 0, SGE_PAGE_SIZE*PAGES_PER_SGE,
                                PCI_DMA_FROMDEVICE);
         if (unlikely(dma_mapping_error(&bp->pdev->dev, mapping))) {
                 __free_pages(page, PAGES_PER_SGE_SHIFT);
@@ -1096,9 +1114,9 @@ static void bnx2x_update_sge_prod(struct bnx2x_fastpath *fp,
                                   struct eth_fast_path_rx_cqe *fp_cqe)
 {
         struct bnx2x *bp = fp->bp;
-        u16 sge_len = BCM_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
+        u16 sge_len = SGE_PAGE_ALIGN(le16_to_cpu(fp_cqe->pkt_len) -
                                      le16_to_cpu(fp_cqe->len_on_bd)) >>
-                      BCM_PAGE_SHIFT;
+                      SGE_PAGE_SHIFT;
         u16 last_max, last_elem, first_elem;
         u16 delta = 0;
         u16 i;
@@ -1203,22 +1221,22 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                                u16 cqe_idx)
 {
         struct sw_rx_page *rx_pg, old_rx_pg;
-        struct page *sge;
         u16 len_on_bd = le16_to_cpu(fp_cqe->len_on_bd);
         u32 i, frag_len, frag_size, pages;
         int err;
         int j;
 
         frag_size = le16_to_cpu(fp_cqe->pkt_len) - len_on_bd;
-        pages = BCM_PAGE_ALIGN(frag_size) >> BCM_PAGE_SHIFT;
+        pages = SGE_PAGE_ALIGN(frag_size) >> SGE_PAGE_SHIFT;
 
         /* This is needed in order to enable forwarding support */
         if (frag_size)
-                skb_shinfo(skb)->gso_size = min((u32)BCM_PAGE_SIZE,
+                skb_shinfo(skb)->gso_size = min((u32)SGE_PAGE_SIZE,
                                                max(frag_size, (u32)len_on_bd));
 
 #ifdef BNX2X_STOP_ON_ERROR
-        if (pages > 8*PAGES_PER_SGE) {
+        if (pages >
+            min((u32)8, (u32)MAX_SKB_FRAGS) * SGE_PAGE_SIZE * PAGES_PER_SGE) {
                 BNX2X_ERR("SGL length is too long: %d. CQE index is %d\n",
                           pages, cqe_idx);
                 BNX2X_ERR("fp_cqe->pkt_len = %d  fp_cqe->len_on_bd = %d\n",
@@ -1234,9 +1252,8 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 
                 /* FW gives the indices of the SGE as if the ring is an array
                    (meaning that "next" element will consume 2 indices) */
-                frag_len = min(frag_size, (u32)(BCM_PAGE_SIZE*PAGES_PER_SGE));
+                frag_len = min(frag_size, (u32)(SGE_PAGE_SIZE*PAGES_PER_SGE));
                 rx_pg = &fp->rx_page_ring[sge_idx];
-                sge = rx_pg->page;
                 old_rx_pg = *rx_pg;
 
                 /* If we fail to allocate a substitute page, we simply stop
@@ -1249,7 +1266,7 @@ static int bnx2x_fill_frag_skb(struct bnx2x *bp, struct bnx2x_fastpath *fp,
 
                 /* Unmap the page as we r going to pass it to the stack */
                 pci_unmap_page(bp->pdev, pci_unmap_addr(&old_rx_pg, mapping),
-                              BCM_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
+                              SGE_PAGE_SIZE*PAGES_PER_SGE, PCI_DMA_FROMDEVICE);
 
                 /* Add one frag and update the appropriate fields in the skb */
                 skb_fill_page_desc(skb, j, old_rx_pg.page, 0, frag_len);
@@ -1282,6 +1299,13 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
         if (likely(new_skb)) {
                 /* fix ip xsum and give it to the stack */
                 /* (no need to map the new skb) */
+#ifdef BCM_VLAN
+                int is_vlan_cqe =
+                        (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
+                         PARSING_FLAGS_VLAN);
+                int is_not_hwaccel_vlan_cqe =
+                        (is_vlan_cqe && (!(bp->flags & HW_VLAN_RX_FLAG)));
+#endif
 
                 prefetch(skb);
                 prefetch(((char *)(skb)) + 128);
@@ -1306,6 +1330,12 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                         struct iphdr *iph;
 
                         iph = (struct iphdr *)skb->data;
+#ifdef BCM_VLAN
+                        /* If there is no Rx VLAN offloading -
+                           take VLAN tag into an account */
+                        if (unlikely(is_not_hwaccel_vlan_cqe))
+                                iph = (struct iphdr *)((u8 *)iph + VLAN_HLEN);
+#endif
                         iph->check = 0;
                         iph->check = ip_fast_csum((u8 *)iph, iph->ihl);
                 }
@@ -1313,9 +1343,8 @@ static void bnx2x_tpa_stop(struct bnx2x *bp, struct bnx2x_fastpath *fp,
                 if (!bnx2x_fill_frag_skb(bp, fp, skb,
                                          &cqe->fast_path_cqe, cqe_idx)) {
 #ifdef BCM_VLAN
-                        if ((bp->vlgrp != NULL) &&
-                            (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
-                             PARSING_FLAGS_VLAN))
+                        if ((bp->vlgrp != NULL) && is_vlan_cqe &&
+                            (!is_not_hwaccel_vlan_cqe))
                                 vlan_hwaccel_receive_skb(skb, bp->vlgrp,
                                                 le16_to_cpu(cqe->fast_path_cqe.
                                                             vlan_tag));
@@ -1355,11 +1384,23 @@ static inline void bnx2x_update_rx_prod(struct bnx2x *bp,
         rx_prods.cqe_prod = rx_comp_prod;
         rx_prods.sge_prod = rx_sge_prod;
 
+        /*
+         * Make sure that the BD and SGE data is updated before updating the
+         * producers since FW might read the BD/SGE right after the producer
+         * is updated.
+         * This is only applicable for weak-ordered memory model archs such
+         * as IA-64. The following barrier is also mandatory since FW will
+         * assumes BDs must have buffers.
+         */
+        wmb();
+
         for (i = 0; i < sizeof(struct tstorm_eth_rx_producers)/4; i++)
                 REG_WR(bp, BAR_TSTRORM_INTMEM +
                        TSTORM_RX_PRODS_OFFSET(BP_PORT(bp), FP_CL_ID(fp)) + i*4,
                        ((u32 *)&rx_prods)[i]);
 
+        mmiowb(); /* keep prod updates ordered */
+
         DP(NETIF_MSG_RX_STATUS,
            "Wrote: bd_prod %u  cqe_prod %u  sge_prod %u\n",
            bd_prod, rx_comp_prod, rx_sge_prod);
@@ -1415,7 +1456,7 @@ static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                 DP(NETIF_MSG_RX_STATUS, "CQE type %x  err %x  status %x"
                    "  queue %x  vlan %x  len %u\n", CQE_TYPE(cqe_fp_flags),
                    cqe_fp_flags, cqe->fast_path_cqe.status_flags,
-                   cqe->fast_path_cqe.rss_hash_result,
+                   le32_to_cpu(cqe->fast_path_cqe.rss_hash_result),
                    le16_to_cpu(cqe->fast_path_cqe.vlan_tag),
                    le16_to_cpu(cqe->fast_path_cqe.pkt_len));
 
@@ -1547,7 +1588,7 @@ reuse_rx:
                 }
 
 #ifdef BCM_VLAN
-                if ((bp->vlgrp != NULL) &&
+                if ((bp->vlgrp != NULL) && (bp->flags & HW_VLAN_RX_FLAG) &&
                     (le16_to_cpu(cqe->fast_path_cqe.pars_flags.flags) &
                      PARSING_FLAGS_VLAN))
                         vlan_hwaccel_receive_skb(skb, bp->vlgrp,
@@ -1580,7 +1621,6 @@ next_cqe:
         /* Update producers */
         bnx2x_update_rx_prod(bp, fp, bd_prod_fw, sw_comp_prod,
                              fp->rx_sge_prod);
-        mmiowb(); /* keep prod updates ordered */
 
         fp->rx_pkt += rx_pkt;
         fp->rx_calls++;
@@ -1660,7 +1700,7 @@ static irqreturn_t bnx2x_interrupt(int irq, void *dev_instance)
 
 
         if (unlikely(status & 0x1)) {
-                schedule_work(&bp->sp_task);
+                queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
 
                 status &= ~0x1;
                 if (!status)
@@ -1887,7 +1927,8 @@ static int bnx2x_set_spio(struct bnx2x *bp, int spio_num, u32 mode)
 
 static void bnx2x_calc_fc_adv(struct bnx2x *bp)
 {
-        switch (bp->link_vars.ieee_fc) {
+        switch (bp->link_vars.ieee_fc &
+                MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) {
         case MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE:
                 bp->port.advertising &= ~(ADVERTISED_Asym_Pause |
                                           ADVERTISED_Pause);
@@ -1957,10 +1998,11 @@ static u8 bnx2x_initial_phy_init(struct bnx2x *bp)
                 rc = bnx2x_phy_init(&bp->link_params, &bp->link_vars);
                 bnx2x_release_phy_lock(bp);
 
+                bnx2x_calc_fc_adv(bp);
+
                 if (bp->link_vars.link_up)
                         bnx2x_link_report(bp);
 
-                bnx2x_calc_fc_adv(bp);
 
                 return rc;
         }
@@ -2220,9 +2262,7 @@ static void bnx2x_link_attn(struct bnx2x *bp)
         /* Make sure that we are synced with the current statistics */
         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
 
-        bnx2x_acquire_phy_lock(bp);
         bnx2x_link_update(&bp->link_params, &bp->link_vars);
-        bnx2x_release_phy_lock(bp);
 
         if (bp->link_vars.link_up) {
 
@@ -2471,6 +2511,8 @@ static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
         if (asserted & ATTN_HARD_WIRED_MASK) {
                 if (asserted & ATTN_NIG_FOR_FUNC) {
 
+                        bnx2x_acquire_phy_lock(bp);
+
                         /* save nig interrupt mask */
                         bp->nig_mask = REG_RD(bp, nig_int_mask_addr);
                         REG_WR(bp, nig_int_mask_addr, 0);
@@ -2526,8 +2568,10 @@ static void bnx2x_attn_int_asserted(struct bnx2x *bp, u32 asserted)
         REG_WR(bp, hc_addr, asserted);
 
         /* now set back the mask */
-        if (asserted & ATTN_NIG_FOR_FUNC)
+        if (asserted & ATTN_NIG_FOR_FUNC) {
                 REG_WR(bp, nig_int_mask_addr, bp->nig_mask);
+                bnx2x_release_phy_lock(bp);
+        }
 }
 
 static inline void bnx2x_attn_int_deasserted0(struct bnx2x *bp, u32 attn)
@@ -2795,8 +2839,10 @@ static void bnx2x_attn_int_deasserted(struct bnx2x *bp, u32 deasserted)
 static void bnx2x_attn_int(struct bnx2x *bp)
 {
         /* read local copy of bits */
-        u32 attn_bits = bp->def_status_blk->atten_status_block.attn_bits;
-        u32 attn_ack = bp->def_status_blk->atten_status_block.attn_bits_ack;
+        u32 attn_bits = le32_to_cpu(bp->def_status_blk->atten_status_block.
+                                                                attn_bits);
+        u32 attn_ack = le32_to_cpu(bp->def_status_blk->atten_status_block.
+                                                                attn_bits_ack);
         u32 attn_state = bp->attn_state;
 
         /* look for changed bits */
@@ -2820,7 +2866,7 @@ static void bnx2x_attn_int(struct bnx2x *bp)
 
 static void bnx2x_sp_task(struct work_struct *work)
 {
-        struct bnx2x *bp = container_of(work, struct bnx2x, sp_task);
+        struct bnx2x *bp = container_of(work, struct bnx2x, sp_task.work);
         u16 status;
 
 
@@ -2844,7 +2890,7 @@ static void bnx2x_sp_task(struct work_struct *work)
         if (status & 0x2)
                 bp->stats_pending = 0;
 
-        bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, bp->def_att_idx,
+        bnx2x_ack_sb(bp, DEF_SB_ID, ATTENTION_ID, le16_to_cpu(bp->def_att_idx),
                      IGU_INT_NOP, 1);
         bnx2x_ack_sb(bp, DEF_SB_ID, USTORM_ID, le16_to_cpu(bp->def_u_idx),
                      IGU_INT_NOP, 1);
@@ -2875,7 +2921,7 @@ static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
                 return IRQ_HANDLED;
 #endif
 
-        schedule_work(&bp->sp_task);
+        queue_delayed_work(bnx2x_wq, &bp->sp_task, 0);
 
         return IRQ_HANDLED;
 }
@@ -2892,7 +2938,7 @@ static irqreturn_t bnx2x_msix_sp_int(int irq, void *dev_instance)
 #define ADD_64(s_hi, a_hi, s_lo, a_lo) \
         do { \
                 s_lo += a_lo; \
-                s_hi += a_hi + (s_lo < a_lo) ? 1 : 0; \
+                s_hi += a_hi + ((s_lo < a_lo) ? 1 : 0); \
         } while (0)
 
 /* difference = minuend - subtrahend */
@@ -4496,7 +4542,7 @@ static void bnx2x_init_context(struct bnx2x *bp)
 
 static void bnx2x_init_ind_table(struct bnx2x *bp)
 {
-        int port = BP_PORT(bp);
+        int func = BP_FUNC(bp);
         int i;
 
         if (!is_multi(bp))
@@ -4505,10 +4551,8 @@ static void bnx2x_init_ind_table(struct bnx2x *bp)
         DP(NETIF_MSG_IFUP, "Initializing indirection table\n");
         for (i = 0; i < TSTORM_INDIRECTION_TABLE_SIZE; i++)
                 REG_WR8(bp, BAR_TSTRORM_INTMEM +
-                        TSTORM_INDIRECTION_TABLE_OFFSET(port) + i,
-                        i % bp->num_queues);
-
-        REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
+                        TSTORM_INDIRECTION_TABLE_OFFSET(func) + i,
+                        BP_CL_ID(bp) + (i % bp->num_queues));
 }
 
 static void bnx2x_set_client_config(struct bnx2x *bp)
@@ -4517,12 +4561,12 @@ static void bnx2x_set_client_config(struct bnx2x *bp)
         int port = BP_PORT(bp);
         int i;
 
-        tstorm_client.mtu = bp->dev->mtu + ETH_OVREHEAD;
+        tstorm_client.mtu = bp->dev->mtu;
         tstorm_client.statistics_counter_id = BP_CL_ID(bp);
         tstorm_client.config_flags =
                                 TSTORM_ETH_CLIENT_CONFIG_STATSITICS_ENABLE;
 #ifdef BCM_VLAN
-        if (bp->rx_mode && bp->vlgrp) {
+        if (bp->rx_mode && bp->vlgrp && (bp->flags & HW_VLAN_RX_FLAG)) {
                 tstorm_client.config_flags |=
                                 TSTORM_ETH_CLIENT_CONFIG_VLAN_REMOVAL_ENABLE;
                 DP(NETIF_MSG_IFUP, "vlan removal enabled\n");
@@ -4531,7 +4575,7 @@ static void bnx2x_set_client_config(struct bnx2x *bp)
 
         if (bp->flags & TPA_ENABLE_FLAG) {
                 tstorm_client.max_sges_for_packet =
-                        BCM_PAGE_ALIGN(tstorm_client.mtu) >> BCM_PAGE_SHIFT;
+                        SGE_PAGE_ALIGN(tstorm_client.mtu) >> SGE_PAGE_SHIFT;
                 tstorm_client.max_sges_for_packet =
                         ((tstorm_client.max_sges_for_packet +
                           PAGES_PER_SGE - 1) & (~(PAGES_PER_SGE - 1))) >>
@@ -4714,10 +4758,11 @@ static void bnx2x_init_internal_func(struct bnx2x *bp)
                          bp->e1hov);
         }
 
-        /* Init CQ ring mapping and aggregation size */
-        max_agg_size = min((u32)(bp->rx_buf_size +
-                                 8*BCM_PAGE_SIZE*PAGES_PER_SGE),
-                           (u32)0xffff);
+        /* Init CQ ring mapping and aggregation size, the FW limit is 8 frags */
+        max_agg_size =
+                min((u32)(min((u32)8, (u32)MAX_SKB_FRAGS) *
+                          SGE_PAGE_SIZE * PAGES_PER_SGE),
+                    (u32)0xffff);
         for_each_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
 
@@ -4785,6 +4830,15 @@ static void bnx2x_nic_init(struct bnx2x *bp, u32 load_code)
         bnx2x_init_context(bp);
         bnx2x_init_internal(bp, load_code);
         bnx2x_init_ind_table(bp);
+        bnx2x_stats_init(bp);
+
+        /* At this point, we are ready for interrupts */
+        atomic_set(&bp->intr_sem, 0);
+
+        /* flush all before enabling interrupts */
+        mb();
+        mmiowb();
+
         bnx2x_int_enable(bp);
 }
 
@@ -5101,12 +5155,21 @@ static void enable_blocks_attention(struct bnx2x *bp)
 }
 
 
+static void bnx2x_reset_common(struct bnx2x *bp)
+{
+        /* reset_common */
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
+               0xd3ffff7f);
+        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
+}
+
 static int bnx2x_init_common(struct bnx2x *bp)
 {
         u32 val, i;
 
         DP(BNX2X_MSG_MCP, "starting common init  func %d\n", BP_FUNC(bp));
 
+        bnx2x_reset_common(bp);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_SET, 0xffffffff);
         REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET, 0xfffc);
 
@@ -5134,7 +5197,6 @@ static int bnx2x_init_common(struct bnx2x *bp)
         REG_WR(bp, PXP2_REG_RQ_SRC_ENDIAN_M, 1);
         REG_WR(bp, PXP2_REG_RQ_CDU_ENDIAN_M, 1);
         REG_WR(bp, PXP2_REG_RQ_DBG_ENDIAN_M, 1);
-        REG_WR(bp, PXP2_REG_RQ_HC_ENDIAN_M, 1);
 
 /*      REG_WR(bp, PXP2_REG_RD_PBF_SWAP_MODE, 1); */
         REG_WR(bp, PXP2_REG_RD_QM_SWAP_MODE, 1);
@@ -5212,6 +5274,7 @@ static int bnx2x_init_common(struct bnx2x *bp)
         }
 
         bnx2x_init_block(bp, PRS_COMMON_START, PRS_COMMON_END);
+        REG_WR(bp, PRS_REG_A_PRSU_20, 0xf);
         /* set NIC mode */
         REG_WR(bp, PRS_REG_NIC_MODE, 1);
         if (CHIP_IS_E1H(bp))
@@ -6087,8 +6150,8 @@ static void bnx2x_netif_start(struct bnx2x *bp)
 static void bnx2x_netif_stop(struct bnx2x *bp, int disable_hw)
 {
         bnx2x_int_disable_sync(bp, disable_hw);
+        bnx2x_napi_disable(bp);
         if (netif_running(bp->dev)) {
-                bnx2x_napi_disable(bp);
                 netif_tx_disable(bp->dev);
                 bp->dev->trans_start = jiffies; /* prevent tx timeout */
         }
@@ -6108,7 +6171,7 @@ static void bnx2x_set_mac_addr_e1(struct bnx2x *bp, int set)
          * multicast 64-127:port0 128-191:port1
          */
         config->hdr.length_6b = 2;
-        config->hdr.offset = port ? 31 : 0;
+        config->hdr.offset = port ? 32 : 0;
         config->hdr.client_id = BP_CL_ID(bp);
         config->hdr.reserved1 = 0;
 
@@ -6272,7 +6335,7 @@ static void bnx2x_set_rx_mode(struct net_device *dev);
 static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 {
         u32 load_code;
-        int i, rc;
+        int i, rc = 0;
 #ifdef BNX2X_STOP_ON_ERROR
         if (unlikely(bp->panic))
                 return -EPERM;
@@ -6280,48 +6343,6 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 
         bp->state = BNX2X_STATE_OPENING_WAIT4_LOAD;
 
-        /* Send LOAD_REQUEST command to MCP
-           Returns the type of LOAD command:
-           if it is the first port to be initialized
-           common blocks should be initialized, otherwise - not
-        */
-        if (!BP_NOMCP(bp)) {
-                load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
-                if (!load_code) {
-                        BNX2X_ERR("MCP response failure, aborting\n");
-                        return -EBUSY;
-                }
-                if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED)
-                        return -EBUSY; /* other port in diagnostic mode */
-
-        } else {
-                int port = BP_PORT(bp);
-
-                DP(NETIF_MSG_IFUP, "NO MCP load counts before us %d, %d, %d\n",
-                   load_count[0], load_count[1], load_count[2]);
-                load_count[0]++;
-                load_count[1 + port]++;
-                DP(NETIF_MSG_IFUP, "NO MCP new load counts       %d, %d, %d\n",
-                   load_count[0], load_count[1], load_count[2]);
-                if (load_count[0] == 1)
-                        load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
-                else if (load_count[1 + port] == 1)
-                        load_code = FW_MSG_CODE_DRV_LOAD_PORT;
-                else
-                        load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
-        }
-
-        if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
-            (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
-                bp->port.pmf = 1;
-        else
-                bp->port.pmf = 0;
-        DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
-
-        /* if we can't use MSI-X we only need one fp,
-         * so try to enable MSI-X with the requested number of fp's
-         * and fallback to inta with one fp
-         */
         if (use_inta) {
                 bp->num_queues = 1;
 
@@ -6336,7 +6357,15 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 else
                         bp->num_queues = 1;
 
-                if (bnx2x_enable_msix(bp)) {
+                DP(NETIF_MSG_IFUP,
+                   "set number of queues to %d\n", bp->num_queues);
+
+                /* if we can't use MSI-X we only need one fp,
+                 * so try to enable MSI-X with the requested number of fp's
+                 * and fallback to MSI or legacy INTx with one fp
+                 */
+                rc = bnx2x_enable_msix(bp);
+                if (rc) {
                         /* failed to enable MSI-X */
                         bp->num_queues = 1;
                         if (use_multi)
@@ -6344,8 +6373,6 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                                           " to enable MSI-X\n");
                 }
         }
-        DP(NETIF_MSG_IFUP,
-           "set number of queues to %d\n", bp->num_queues);
 
         if (bnx2x_alloc_mem(bp))
                 return -ENOMEM;
@@ -6354,30 +6381,85 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 bnx2x_fp(bp, i, disable_tpa) =
                                         ((bp->flags & TPA_ENABLE_FLAG) == 0);
 
+        for_each_queue(bp, i)
+                netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
+                               bnx2x_poll, 128);
+
+#ifdef BNX2X_STOP_ON_ERROR
+        for_each_queue(bp, i) {
+                struct bnx2x_fastpath *fp = &bp->fp[i];
+
+                fp->poll_no_work = 0;
+                fp->poll_calls = 0;
+                fp->poll_max_calls = 0;
+                fp->poll_complete = 0;
+                fp->poll_exit = 0;
+        }
+#endif
+        bnx2x_napi_enable(bp);
+
         if (bp->flags & USING_MSIX_FLAG) {
                 rc = bnx2x_req_msix_irqs(bp);
                 if (rc) {
                         pci_disable_msix(bp->pdev);
-                        goto load_error;
+                        goto load_error1;
                 }
+                printk(KERN_INFO PFX "%s: using MSI-X\n", bp->dev->name);
         } else {
                 bnx2x_ack_int(bp);
                 rc = bnx2x_req_irq(bp);
                 if (rc) {
-                        BNX2X_ERR("IRQ request failed, aborting\n");
-                        goto load_error;
+                        BNX2X_ERR("IRQ request failed  rc %d, aborting\n", rc);
+                        goto load_error1;
                 }
         }
 
-        for_each_queue(bp, i)
-                netif_napi_add(bp->dev, &bnx2x_fp(bp, i, napi),
-                               bnx2x_poll, 128);
+        /* Send LOAD_REQUEST command to MCP
+           Returns the type of LOAD command:
+           if it is the first port to be initialized
+           common blocks should be initialized, otherwise - not
+        */
+        if (!BP_NOMCP(bp)) {
+                load_code = bnx2x_fw_command(bp, DRV_MSG_CODE_LOAD_REQ);
+                if (!load_code) {
+                        BNX2X_ERR("MCP response failure, aborting\n");
+                        rc = -EBUSY;
+                        goto load_error2;
+                }
+                if (load_code == FW_MSG_CODE_DRV_LOAD_REFUSED) {
+                        rc = -EBUSY; /* other port in diagnostic mode */
+                        goto load_error2;
+                }
+
+        } else {
+                int port = BP_PORT(bp);
+
+                DP(NETIF_MSG_IFUP, "NO MCP load counts before us %d, %d, %d\n",
+                   load_count[0], load_count[1], load_count[2]);
+                load_count[0]++;
+                load_count[1 + port]++;
+                DP(NETIF_MSG_IFUP, "NO MCP new load counts       %d, %d, %d\n",
+                   load_count[0], load_count[1], load_count[2]);
+                if (load_count[0] == 1)
+                        load_code = FW_MSG_CODE_DRV_LOAD_COMMON;
+                else if (load_count[1 + port] == 1)
+                        load_code = FW_MSG_CODE_DRV_LOAD_PORT;
+                else
+                        load_code = FW_MSG_CODE_DRV_LOAD_FUNCTION;
+        }
+
+        if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
+            (load_code == FW_MSG_CODE_DRV_LOAD_PORT))
+                bp->port.pmf = 1;
+        else
+                bp->port.pmf = 0;
+        DP(NETIF_MSG_LINK, "pmf %d\n", bp->port.pmf);
 
         /* Initialize HW */
         rc = bnx2x_init_hw(bp, load_code);
         if (rc) {
                 BNX2X_ERR("HW init failed, aborting\n");
-                goto load_int_disable;
+                goto load_error2;
         }
 
         /* Setup NIC internals and enable interrupts */
@@ -6389,25 +6471,16 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 if (!load_code) {
                         BNX2X_ERR("MCP response failure, aborting\n");
                         rc = -EBUSY;
-                        goto load_rings_free;
+                        goto load_error3;
                 }
         }
 
-        bnx2x_stats_init(bp);
-
         bp->state = BNX2X_STATE_OPENING_WAIT4_PORT;
 
-        /* Enable Rx interrupt handling before sending the ramrod
-           as it's completed on Rx FP queue */
-        bnx2x_napi_enable(bp);
-
-        /* Enable interrupt handling */
-        atomic_set(&bp->intr_sem, 0);
-
         rc = bnx2x_setup_leading(bp);
         if (rc) {
                 BNX2X_ERR("Setup leading failed!\n");
-                goto load_netif_stop;
+                goto load_error3;
         }
 
         if (CHIP_IS_E1H(bp))
@@ -6420,7 +6493,7 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
                 for_each_nondefault_queue(bp, i) {
                         rc = bnx2x_setup_multi(bp, i);
                         if (rc)
-                                goto load_netif_stop;
+                                goto load_error3;
                 }
 
         if (CHIP_IS_E1(bp))
@@ -6436,18 +6509,18 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
         case LOAD_NORMAL:
                 /* Tx queue should be only reenabled */
                 netif_wake_queue(bp->dev);
+                /* Initialize the receive filter. */
                 bnx2x_set_rx_mode(bp->dev);
                 break;
 
         case LOAD_OPEN:
                 netif_start_queue(bp->dev);
+                /* Initialize the receive filter. */
                 bnx2x_set_rx_mode(bp->dev);
-                if (bp->flags & USING_MSIX_FLAG)
-                        printk(KERN_INFO PFX "%s: using MSI-X\n",
-                               bp->dev->name);
                 break;
 
         case LOAD_DIAG:
+                /* Initialize the receive filter. */
                 bnx2x_set_rx_mode(bp->dev);
                 bp->state = BNX2X_STATE_DIAG;
                 break;
@@ -6465,20 +6538,25 @@ static int bnx2x_nic_load(struct bnx2x *bp, int load_mode)
 
         return 0;
 
-load_netif_stop:
-        bnx2x_napi_disable(bp);
-load_rings_free:
+load_error3:
+        bnx2x_int_disable_sync(bp, 1);
+        if (!BP_NOMCP(bp)) {
+                bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_REQ_WOL_MCP);
+                bnx2x_fw_command(bp, DRV_MSG_CODE_UNLOAD_DONE);
+        }
+        bp->port.pmf = 0;
         /* Free SKBs, SGEs, TPA pool and driver internals */
         bnx2x_free_skbs(bp);
         for_each_queue(bp, i)
                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
-load_int_disable:
-        bnx2x_int_disable_sync(bp, 1);
+load_error2:
         /* Release IRQs */
         bnx2x_free_irq(bp);
-load_error:
+load_error1:
+        bnx2x_napi_disable(bp);
+        for_each_queue(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
         bnx2x_free_mem(bp);
-        bp->port.pmf = 0;
 
         /* TBD we really need to reset the chip
            if we want to recover from this */
@@ -6551,6 +6629,7 @@ static int bnx2x_stop_leading(struct bnx2x *bp)
                 }
                 cnt--;
                 msleep(1);
+                rmb(); /* Refresh the dsb_sp_prod */
         }
         bp->state = BNX2X_STATE_CLOSING_WAIT4_UNLOAD;
         bp->fp[0].state = BNX2X_FP_STATE_CLOSED;
@@ -6602,14 +6681,6 @@ static void bnx2x_reset_port(struct bnx2x *bp)
         /* TODO: Close Doorbell port? */
 }
 
-static void bnx2x_reset_common(struct bnx2x *bp)
-{
-        /* reset_common */
-        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR,
-               0xd3ffff7f);
-        REG_WR(bp, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR, 0x1403);
-}
-
 static void bnx2x_reset_chip(struct bnx2x *bp, u32 reset_code)
 {
         DP(BNX2X_MSG_MCP, "function %d  reset_code %x\n",
@@ -6650,20 +6721,22 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
         bnx2x_set_storm_rx_mode(bp);
 
         bnx2x_netif_stop(bp, 1);
-        if (!netif_running(bp->dev))
-                bnx2x_napi_disable(bp);
+
         del_timer_sync(&bp->timer);
         SHMEM_WR(bp, func_mb[BP_FUNC(bp)].drv_pulse_mb,
                  (DRV_PULSE_ALWAYS_ALIVE | bp->fw_drv_pulse_wr_seq));
         bnx2x_stats_handle(bp, STATS_EVENT_STOP);
 
+        /* Release IRQs */
+        bnx2x_free_irq(bp);
+
         /* Wait until tx fast path tasks complete */
         for_each_queue(bp, i) {
                 struct bnx2x_fastpath *fp = &bp->fp[i];
 
                 cnt = 1000;
                 smp_rmb();
-                while (BNX2X_HAS_TX_WORK(fp)) {
+                while (bnx2x_has_tx_work_unload(fp)) {
 
                         bnx2x_tx_int(fp, 1000);
                         if (!cnt) {
@@ -6684,9 +6757,6 @@ static int bnx2x_nic_unload(struct bnx2x *bp, int unload_mode)
         /* Give HW time to discard old tx messages */
         msleep(1);
 
-        /* Release IRQs */
-        bnx2x_free_irq(bp);
-
         if (CHIP_IS_E1(bp)) {
                 struct mac_configuration_cmd *config =
                                                 bnx2x_sp(bp, mcast_config);
@@ -6795,6 +6865,8 @@ unload_error:
         bnx2x_free_skbs(bp);
         for_each_queue(bp, i)
                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
+        for_each_queue(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
         bnx2x_free_mem(bp);
 
         bp->state = BNX2X_STATE_CLOSED;
@@ -6847,10 +6919,6 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                  */
                 bnx2x_acquire_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
                 val = REG_RD(bp, DORQ_REG_NORM_CID_OFST);
-                if (val == 0x7)
-                        REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
-                bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
-
                 if (val == 0x7) {
                         u32 reset_code = DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS;
                         /* save our func */
@@ -6858,6 +6926,9 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                         u32 swap_en;
                         u32 swap_val;
 
+                        /* clear the UNDI indication */
+                        REG_WR(bp, DORQ_REG_NORM_CID_OFST, 0);
+
                         BNX2X_DEV_INFO("UNDI is active! reset device\n");
 
                         /* try unload UNDI on port 0 */
@@ -6883,6 +6954,9 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                                 bnx2x_fw_command(bp, reset_code);
                         }
 
+                        /* now it's safe to release the lock */
+                        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
+
                         REG_WR(bp, (BP_PORT(bp) ? HC_REG_CONFIG_1 :
                                     HC_REG_CONFIG_0), 0x1000);
 
@@ -6927,7 +7001,9 @@ static void __devinit bnx2x_undi_unload(struct bnx2x *bp)
                         bp->fw_seq =
                                (SHMEM_RD(bp, func_mb[bp->func].drv_mb_header) &
                                 DRV_MSG_SEQ_NUMBER_MASK);
-                }
+
+                } else
+                        bnx2x_release_hw_lock(bp, HW_LOCK_RESOURCE_UNDI);
         }
 }
 
@@ -6944,7 +7020,7 @@ static void __devinit bnx2x_get_common_hwinfo(struct bnx2x *bp)
         id |= ((val & 0xf) << 12);
         val = REG_RD(bp, MISC_REG_CHIP_METAL);
         id |= ((val & 0xff) << 4);
-        REG_RD(bp, MISC_REG_BOND_ID);
+        val = REG_RD(bp, MISC_REG_BOND_ID);
         id |= (val & 0xf);
         bp->common.chip_id = id;
         bp->link_params.chip_id = bp->common.chip_id;
@@ -7501,7 +7577,7 @@ static int __devinit bnx2x_init_bp(struct bnx2x *bp)
 
         mutex_init(&bp->port.phy_mutex);
 
-        INIT_WORK(&bp->sp_task, bnx2x_sp_task);
+        INIT_DELAYED_WORK(&bp->sp_task, bnx2x_sp_task);
         INIT_WORK(&bp->reset_task, bnx2x_reset_task);
 
         rc = bnx2x_get_hwinfo(bp);
@@ -8076,6 +8152,9 @@ static int bnx2x_get_eeprom(struct net_device *dev,
         struct bnx2x *bp = netdev_priv(dev);
         int rc;
 
+        if (!netif_running(dev))
+                return -EAGAIN;
+
         DP(BNX2X_MSG_NVM, "ethtool_eeprom: cmd %d\n"
            DP_LEVEL "  magic 0x%x  offset 0x%x (%d)  len 0x%x (%d)\n",
            eeprom->cmd, eeprom->magic, eeprom->offset, eeprom->offset,
@@ -8678,18 +8757,17 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
 
         if (loopback_mode == BNX2X_MAC_LOOPBACK) {
                 bp->link_params.loopback_mode = LOOPBACK_BMAC;
-                bnx2x_acquire_phy_lock(bp);
                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
-                bnx2x_release_phy_lock(bp);
 
         } else if (loopback_mode == BNX2X_PHY_LOOPBACK) {
+                u16 cnt = 1000;
                 bp->link_params.loopback_mode = LOOPBACK_XGXS_10;
-                bnx2x_acquire_phy_lock(bp);
                 bnx2x_phy_init(&bp->link_params, &bp->link_vars);
-                bnx2x_release_phy_lock(bp);
                 /* wait until link state is restored */
-                bnx2x_wait_for_link(bp, link_up);
-
+                if (link_up)
+                        while (cnt-- && bnx2x_test_link(&bp->link_params,
+                                                        &bp->link_vars))
+                                msleep(10);
         } else
                 return -EINVAL;
 
@@ -8727,6 +8805,8 @@ static int bnx2x_run_loopback(struct bnx2x *bp, int loopback_mode, u8 link_up)
         tx_bd->general_data = ((UNICAST_ADDRESS <<
                                 ETH_TX_BD_ETH_ADDR_TYPE_SHIFT) | 1);
 
+        wmb();
+
         fp->hw_tx_prods->bds_prod =
                 cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + 1);
         mb(); /* FW restriction: must not reorder writing nbd and packets */
@@ -8778,7 +8858,6 @@ test_loopback_rx_exit:
         /* Update producers */
         bnx2x_update_rx_prod(bp, fp, fp->rx_bd_prod, fp->rx_comp_prod,
                              fp->rx_sge_prod);
-        mmiowb(); /* keep prod updates ordered */
 
 test_loopback_exit:
         bp->link_params.loopback_mode = LOOPBACK_NONE;
@@ -8794,6 +8873,7 @@ static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
                 return BNX2X_LOOPBACK_FAILED;
 
         bnx2x_netif_stop(bp, 1);
+        bnx2x_acquire_phy_lock(bp);
 
         if (bnx2x_run_loopback(bp, BNX2X_MAC_LOOPBACK, link_up)) {
                 DP(NETIF_MSG_PROBE, "MAC loopback failed\n");
@@ -8805,6 +8885,7 @@ static int bnx2x_test_loopback(struct bnx2x *bp, u8 link_up)
                 rc |= BNX2X_PHY_LOOPBACK_FAILED;
         }
 
+        bnx2x_release_phy_lock(bp);
         bnx2x_netif_start(bp);
 
         return rc;
@@ -8878,7 +8959,10 @@ static int bnx2x_test_intr(struct bnx2x *bp)
                 return -ENODEV;
 
         config->hdr.length_6b = 0;
-        config->hdr.offset = 0;
+        if (CHIP_IS_E1(bp))
+                config->hdr.offset = (BP_PORT(bp) ? 32 : 0);
+        else
+                config->hdr.offset = BP_FUNC(bp);
         config->hdr.client_id = BP_CL_ID(bp);
         config->hdr.reserved1 = 0;
 
@@ -9243,6 +9327,18 @@ static int bnx2x_set_power_state(struct bnx2x *bp, pci_power_t state)
         return 0;
 }
 
+static inline int bnx2x_has_rx_work(struct bnx2x_fastpath *fp)
+{
+        u16 rx_cons_sb;
+
+        /* Tell compiler that status block fields can change */
+        barrier();
+        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
+        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
+                rx_cons_sb++;
+        return (fp->rx_comp_cons != rx_cons_sb);
+}
+
 /*
  * net_device service functions
  */
@@ -9253,7 +9349,6 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
                                                  napi);
         struct bnx2x *bp = fp->bp;
         int work_done = 0;
-        u16 rx_cons_sb;
 
 #ifdef BNX2X_STOP_ON_ERROR
         if (unlikely(bp->panic))
@@ -9266,19 +9361,12 @@ static int bnx2x_poll(struct napi_struct *napi, int budget)
 
         bnx2x_update_fpsb_idx(fp);
 
-        if (BNX2X_HAS_TX_WORK(fp))
+        if (bnx2x_has_tx_work(fp))
                 bnx2x_tx_int(fp, budget);
 
-        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
-        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
-                rx_cons_sb++;
-        if (BNX2X_HAS_RX_WORK(fp))
+        if (bnx2x_has_rx_work(fp))
                 work_done = bnx2x_rx_int(fp, budget);
-
         rmb(); /* BNX2X_HAS_WORK() reads the status block */
-        rx_cons_sb = le16_to_cpu(*fp->rx_cons_sb);
-        if ((rx_cons_sb & MAX_RCQ_DESC_CNT) == MAX_RCQ_DESC_CNT)
-                rx_cons_sb++;
 
         /* must not complete if we consumed full budget */
         if ((work_done < budget) && !BNX2X_HAS_WORK(fp)) {
@@ -9389,6 +9477,7 @@ static inline u32 bnx2x_xmit_type(struct bnx2x *bp, struct sk_buff *skb)
         return rc;
 }
 
+#if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
 /* check if packet requires linearization (packet is too fragmented) */
 static int bnx2x_pkt_req_lin(struct bnx2x *bp, struct sk_buff *skb,
                              u32 xmit_type)
@@ -9466,6 +9555,7 @@ exit_lbl:
 
         return to_copy;
 }
+#endif
 
 /* called with netif_tx_lock
  * bnx2x_tx_int() runs without netif_tx_lock unless it needs to call
@@ -9506,6 +9596,7 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
            skb->ip_summed, skb->protocol, ipv6_hdr(skb)->nexthdr,
            ip_hdr(skb)->protocol, skb_shinfo(skb)->gso_type, xmit_type);
 
+#if (MAX_SKB_FRAGS >= MAX_FETCH_BD - 3)
         /* First, check if we need to linearize the skb
            (due to FW restrictions) */
         if (bnx2x_pkt_req_lin(bp, skb, xmit_type)) {
@@ -9518,6 +9609,7 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
                         return NETDEV_TX_OK;
                 }
         }
+#endif
 
         /*
         Please read carefully. First we use one BD which we mark as start,
@@ -9549,11 +9641,14 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
            "sending pkt %u @%p  next_idx %u  bd %u @%p\n",
            pkt_prod, tx_buf, fp->tx_pkt_prod, bd_prod, tx_bd);
 
-        if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb)) {
+#ifdef BCM_VLAN
+        if ((bp->vlgrp != NULL) && vlan_tx_tag_present(skb) &&
+            (bp->flags & HW_VLAN_TX_FLAG)) {
                 tx_bd->vlan = cpu_to_le16(vlan_tx_tag_get(skb));
                 tx_bd->bd_flags.as_bitfield |= ETH_TX_BD_FLAGS_VLAN_TAG;
                 vlan_off += 4;
         } else
+#endif
                 tx_bd->vlan = cpu_to_le16(pkt_prod);
 
         if (xmit_type) {
@@ -9705,6 +9800,15 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
 
         DP(NETIF_MSG_TX_QUEUED, "doorbell: nbd %d  bd %u\n", nbd, bd_prod);
 
+        /*
+         * Make sure that the BD data is updated before updating the producer
+         * since FW might read the BD right after the producer is updated.
+         * This is only applicable for weak-ordered memory model archs such
+         * as IA-64. The following barrier is also mandatory since FW will
+         * assumes packets must have BDs.
+         */
+        wmb();
+
         fp->hw_tx_prods->bds_prod =
                 cpu_to_le16(le16_to_cpu(fp->hw_tx_prods->bds_prod) + nbd);
         mb(); /* FW restriction: must not reorder writing nbd and packets */
@@ -9718,6 +9822,9 @@ static int bnx2x_start_xmit(struct sk_buff *skb, struct net_device *dev)
         dev->trans_start = jiffies;
 
         if (unlikely(bnx2x_tx_avail(fp) < MAX_SKB_FRAGS + 3)) {
+                /* We want bnx2x_tx_int to "see" the updated tx_bd_prod
+                   if we put Tx into XOFF state. */
+                smp_mb();
                 netif_stop_queue(dev);
                 bp->eth_stats.driver_xoff++;
                 if (bnx2x_tx_avail(fp) >= MAX_SKB_FRAGS + 3)
@@ -9733,6 +9840,8 @@ static int bnx2x_open(struct net_device *dev)
 {
         struct bnx2x *bp = netdev_priv(dev);
 
+        netif_carrier_off(dev);
+
         bnx2x_set_power_state(bp, PCI_D0);
 
         return bnx2x_nic_load(bp, LOAD_OPEN);
@@ -9816,7 +9925,7 @@ static void bnx2x_set_rx_mode(struct net_device *dev)
                                 for (; i < old; i++) {
                                         if (CAM_IS_INVALID(config->
                                                            config_table[i])) {
-                                                i--; /* already invalidated */
+                                                /* already invalidated */
                                                 break;
                                         }
                                         /* invalidate */
@@ -9987,6 +10096,16 @@ static void bnx2x_vlan_rx_register(struct net_device *dev,
         struct bnx2x *bp = netdev_priv(dev);
 
         bp->vlgrp = vlgrp;
+
+        /* Set flags according to the required capabilities */
+        bp->flags &= ~(HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
+
+        if (dev->features & NETIF_F_HW_VLAN_TX)
+                bp->flags |= HW_VLAN_TX_FLAG;
+
+        if (dev->features & NETIF_F_HW_VLAN_RX)
+                bp->flags |= HW_VLAN_RX_FLAG;
+
         if (netif_running(dev))
                 bnx2x_set_client_config(bp);
 }
@@ -10143,6 +10262,7 @@ static int __devinit bnx2x_init_dev(struct pci_dev *pdev,
                 dev->features |= NETIF_F_HIGHDMA;
 #ifdef BCM_VLAN
         dev->features |= (NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX);
+        bp->flags |= (HW_VLAN_RX_FLAG | HW_VLAN_TX_FLAG);
 #endif
         dev->features |= (NETIF_F_TSO | NETIF_F_TSO_ECN);
         dev->features |= NETIF_F_TSO6;
@@ -10215,22 +10335,18 @@ static int __devinit bnx2x_init_one(struct pci_dev *pdev,
                 return rc;
         }
 
-        rc = register_netdev(dev);
-        if (rc) {
-                dev_err(&pdev->dev, "Cannot register net device\n");
-                goto init_one_exit;
-        }
-
         pci_set_drvdata(pdev, dev);
 
         rc = bnx2x_init_bp(bp);
+        if (rc)
+                goto init_one_exit;
+
+        rc = register_netdev(dev);
         if (rc) {
-                unregister_netdev(dev);
+                dev_err(&pdev->dev, "Cannot register net device\n");
                 goto init_one_exit;
         }
 
-        netif_carrier_off(dev);
-
         bp->common.name = board_info[ent->driver_data].name;
         printk(KERN_INFO "%s: %s (%c%d) PCI-E x%d %s found at mem %lx,"
                " IRQ %d, ", dev->name, bp->common.name,
@@ -10378,6 +10494,8 @@ static int bnx2x_eeh_nic_unload(struct bnx2x *bp)
         bnx2x_free_skbs(bp);
         for_each_queue(bp, i)
                 bnx2x_free_rx_sge_range(bp, bp->fp + i, NUM_RX_SGE);
+        for_each_queue(bp, i)
+                netif_napi_del(&bnx2x_fp(bp, i, napi));
         bnx2x_free_mem(bp);
 
         bp->state = BNX2X_STATE_CLOSED;
@@ -10519,12 +10637,20 @@ static struct pci_driver bnx2x_pci_driver = {
 
 static int __init bnx2x_init(void)
 {
+        bnx2x_wq = create_singlethread_workqueue("bnx2x");
+        if (bnx2x_wq == NULL) {
+                printk(KERN_ERR PFX "Cannot create workqueue\n");
+                return -ENOMEM;
+        }
+
         return pci_register_driver(&bnx2x_pci_driver);
 }
 
 static void __exit bnx2x_cleanup(void)
 {
         pci_unregister_driver(&bnx2x_pci_driver);
+
+        destroy_workqueue(bnx2x_wq);
 }
 
 module_init(bnx2x_init);
diff --git a/drivers/net/bnx2x_reg.h b/drivers/net/bnx2x_reg.h
index a67b0c358ae4..d084e5fc4b51 100644
--- a/drivers/net/bnx2x_reg.h
+++ b/drivers/net/bnx2x_reg.h
@@ -1,6 +1,6 @@
 /* bnx2x_reg.h: Broadcom Everest network driver.
  *
- * Copyright (c) 2007-2008 Broadcom Corporation
+ * Copyright (c) 2007-2009 Broadcom Corporation
  *
  * 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
diff --git a/drivers/net/cxgb3/sge.c b/drivers/net/cxgb3/sge.c
index 14f9fb3e8795..379a1324db4e 100644
--- a/drivers/net/cxgb3/sge.c
+++ b/drivers/net/cxgb3/sge.c
@@ -2104,6 +2104,7 @@ static void init_lro_mgr(struct sge_qset *qs, struct net_lro_mgr *lro_mgr)
 {
         lro_mgr->dev = qs->netdev;
         lro_mgr->features = LRO_F_NAPI;
+        lro_mgr->frag_align_pad = NET_IP_ALIGN;
         lro_mgr->ip_summed = CHECKSUM_UNNECESSARY;
         lro_mgr->ip_summed_aggr = CHECKSUM_UNNECESSARY;
         lro_mgr->max_desc = T3_MAX_LRO_SES;
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index cf43ee743b3c..0890162953e9 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -981,11 +981,15 @@ static void e1000_initialize_hw_bits_82571(struct e1000_hw *hw)
                 ew32(PBA_ECC, reg);
         }
 
-        /* PCI-Ex Control Register */
+        /* PCI-Ex Control Registers */
         if (hw->mac.type == e1000_82574) {
                 reg = er32(GCR);
                 reg |= (1 << 22);
                 ew32(GCR, reg);
+
+                reg = er32(GCR2);
+                reg |= 1;
+                ew32(GCR2, reg);
         }
 
         return;
diff --git a/drivers/net/e1000e/hw.h b/drivers/net/e1000e/hw.h
index f25e961c6b3b..2d4ce0492df0 100644
--- a/drivers/net/e1000e/hw.h
+++ b/drivers/net/e1000e/hw.h
@@ -206,6 +206,7 @@ enum e1e_registers {
         E1000_MANC2H    = 0x05860, /* Management Control To Host - RW */
         E1000_SW_FW_SYNC = 0x05B5C, /* Software-Firmware Synchronization - RW */
         E1000_GCR       = 0x05B00, /* PCI-Ex Control */
+        E1000_GCR2      = 0x05B64, /* PCI-Ex Control #2 */
         E1000_FACTPS    = 0x05B30, /* Function Active and Power State to MNG */
         E1000_SWSM      = 0x05B50, /* SW Semaphore */
         E1000_FWSM      = 0x05B54, /* FW Semaphore */
diff --git a/drivers/net/fs_enet/fs_enet-main.c b/drivers/net/fs_enet/fs_enet-main.c
index 4e6a9195fe5f..ce900e54d8d1 100644
--- a/drivers/net/fs_enet/fs_enet-main.c
+++ b/drivers/net/fs_enet/fs_enet-main.c
@@ -795,6 +795,7 @@ static int fs_enet_open(struct net_device *dev)
 
         err = fs_init_phy(dev);
         if (err) {
+                free_irq(fep->interrupt, dev);
                 if (fep->fpi->use_napi)
                         napi_disable(&fep->napi);
                 return err;
diff --git a/drivers/net/gianfar.c b/drivers/net/gianfar.c
index efcbeb6c8673..3f7eab42aef1 100644
--- a/drivers/net/gianfar.c
+++ b/drivers/net/gianfar.c
@@ -1423,15 +1423,11 @@ static void gfar_vlan_rx_register(struct net_device *dev,
 {
         struct gfar_private *priv = netdev_priv(dev);
         unsigned long flags;
-        struct vlan_group *old_grp;
         u32 tempval;
 
         spin_lock_irqsave(&priv->rxlock, flags);
 
-        old_grp = priv->vlgrp;
-
-        if (old_grp == grp)
-                return;
+        priv->vlgrp = grp;
 
         if (grp) {
                 /* Enable VLAN tag insertion */
@@ -1622,10 +1618,18 @@ static int gfar_clean_tx_ring(struct net_device *dev)
 static void gfar_schedule_cleanup(struct net_device *dev)
 {
         struct gfar_private *priv = netdev_priv(dev);
+        unsigned long flags;
+
+        spin_lock_irqsave(&priv->txlock, flags);
+        spin_lock(&priv->rxlock);
+
         if (netif_rx_schedule_prep(&priv->napi)) {
                 gfar_write(&priv->regs->imask, IMASK_RTX_DISABLED);
                 __netif_rx_schedule(&priv->napi);
         }
+
+        spin_unlock(&priv->rxlock);
+        spin_unlock_irqrestore(&priv->txlock, flags);
 }
 
 /* Interrupt Handler for Transmit complete */
diff --git a/drivers/net/ibm_newemac/mal.c b/drivers/net/ibm_newemac/mal.c
index ecf9798987fa..2a2fc17b2878 100644
--- a/drivers/net/ibm_newemac/mal.c
+++ b/drivers/net/ibm_newemac/mal.c
@@ -613,7 +613,9 @@ static int __devinit mal_probe(struct of_device *ofdev,
         INIT_LIST_HEAD(&mal->list);
         spin_lock_init(&mal->lock);
 
-        netif_napi_add(NULL, &mal->napi, mal_poll,
+        init_dummy_netdev(&mal->dummy_dev);
+
+        netif_napi_add(&mal->dummy_dev, &mal->napi, mal_poll,
                        CONFIG_IBM_NEW_EMAC_POLL_WEIGHT);
 
         /* Load power-on reset defaults */
diff --git a/drivers/net/ibm_newemac/mal.h b/drivers/net/ibm_newemac/mal.h
index 2f0a87360844..9ededfbf0726 100644
--- a/drivers/net/ibm_newemac/mal.h
+++ b/drivers/net/ibm_newemac/mal.h
@@ -214,6 +214,8 @@ struct mal_instance {
         int                     index;
         spinlock_t              lock;
 
+        struct net_device       dummy_dev;
+
         unsigned int features;
 };
 
diff --git a/drivers/net/irda/irda-usb.c b/drivers/net/irda/irda-usb.c
index 29118f58a141..3a22dc41b656 100644
--- a/drivers/net/irda/irda-usb.c
+++ b/drivers/net/irda/irda-usb.c
@@ -1073,7 +1073,7 @@ static int stir421x_patch_device(struct irda_usb_cb *self)
 {
         unsigned int i;
         int ret;
-        char stir421x_fw_name[11];
+        char stir421x_fw_name[12];
         const struct firmware *fw;
         const unsigned char *fw_version_ptr; /* pointer to version string */
         unsigned long fw_version = 0;
diff --git a/drivers/net/ixgbe/ixgbe_main.c b/drivers/net/ixgbe/ixgbe_main.c
index acef3c65cd2c..d2f4d5f508b7 100644
--- a/drivers/net/ixgbe/ixgbe_main.c
+++ b/drivers/net/ixgbe/ixgbe_main.c
@@ -318,6 +318,9 @@ static void ixgbe_update_rx_dca(struct ixgbe_adapter *adapter,
                 rxctrl |= dca3_get_tag(&adapter->pdev->dev, cpu);
                 rxctrl |= IXGBE_DCA_RXCTRL_DESC_DCA_EN;
                 rxctrl |= IXGBE_DCA_RXCTRL_HEAD_DCA_EN;
+                rxctrl &= ~(IXGBE_DCA_RXCTRL_DESC_RRO_EN);
+                rxctrl &= ~(IXGBE_DCA_RXCTRL_DESC_WRO_EN |
+                            IXGBE_DCA_RXCTRL_DESC_HSRO_EN);
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_DCA_RXCTRL(q), rxctrl);
                 rx_ring->cpu = cpu;
         }
@@ -1741,6 +1744,32 @@ static void ixgbe_configure_rx(struct ixgbe_adapter *adapter)
         IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);
 }
 
+static void ixgbe_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+
+        /* add VID to filter table */
+        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, true);
+}
+
+static void ixgbe_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
+{
+        struct ixgbe_adapter *adapter = netdev_priv(netdev);
+        struct ixgbe_hw *hw = &adapter->hw;
+
+        if (!test_bit(__IXGBE_DOWN, &adapter->state))
+                ixgbe_irq_disable(adapter);
+
+        vlan_group_set_device(adapter->vlgrp, vid, NULL);
+
+        if (!test_bit(__IXGBE_DOWN, &adapter->state))
+                ixgbe_irq_enable(adapter);
+
+        /* remove VID from filter table */
+        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, false);
+}
+
 static void ixgbe_vlan_rx_register(struct net_device *netdev,
                                    struct vlan_group *grp)
 {
@@ -1760,6 +1789,7 @@ static void ixgbe_vlan_rx_register(struct net_device *netdev,
         ctrl |= IXGBE_VLNCTRL_VME;
         ctrl &= ~IXGBE_VLNCTRL_CFIEN;
         IXGBE_WRITE_REG(&adapter->hw, IXGBE_VLNCTRL, ctrl);
+        ixgbe_vlan_rx_add_vid(netdev, 0);
 
         if (grp) {
                 /* enable VLAN tag insert/strip */
@@ -1773,32 +1803,6 @@ static void ixgbe_vlan_rx_register(struct net_device *netdev,
                 ixgbe_irq_enable(adapter);
 }
 
-static void ixgbe_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
-{
-        struct ixgbe_adapter *adapter = netdev_priv(netdev);
-        struct ixgbe_hw *hw = &adapter->hw;
-
-        /* add VID to filter table */
-        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, true);
-}
-
-static void ixgbe_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
-{
-        struct ixgbe_adapter *adapter = netdev_priv(netdev);
-        struct ixgbe_hw *hw = &adapter->hw;
-
-        if (!test_bit(__IXGBE_DOWN, &adapter->state))
-                ixgbe_irq_disable(adapter);
-
-        vlan_group_set_device(adapter->vlgrp, vid, NULL);
-
-        if (!test_bit(__IXGBE_DOWN, &adapter->state))
-                ixgbe_irq_enable(adapter);
-
-        /* remove VID from filter table */
-        hw->mac.ops.set_vfta(&adapter->hw, vid, 0, false);
-}
-
 static void ixgbe_restore_vlan(struct ixgbe_adapter *adapter)
 {
         ixgbe_vlan_rx_register(adapter->netdev, adapter->vlgrp);
@@ -2074,6 +2078,9 @@ static int ixgbe_up_complete(struct ixgbe_adapter *adapter)
 
         ixgbe_irq_enable(adapter);
 
+        /* enable transmits */
+        netif_tx_start_all_queues(netdev);
+
         /* bring the link up in the watchdog, this could race with our first
          * link up interrupt but shouldn't be a problem */
         adapter->flags |= IXGBE_FLAG_NEED_LINK_UPDATE;
@@ -3475,7 +3482,6 @@ static void ixgbe_watchdog_task(struct work_struct *work)
                                 (FLOW_TX ? "TX" : "None"))));
 
                         netif_carrier_on(netdev);
-                        netif_tx_wake_all_queues(netdev);
                 } else {
                         /* Force detection of hung controller */
                         adapter->detect_tx_hung = true;
@@ -3487,7 +3493,6 @@ static void ixgbe_watchdog_task(struct work_struct *work)
                         printk(KERN_INFO "ixgbe: %s NIC Link is Down\n",
                                netdev->name);
                         netif_carrier_off(netdev);
-                        netif_tx_stop_all_queues(netdev);
                 }
         }
 
@@ -4218,7 +4223,6 @@ static int __devinit ixgbe_probe(struct pci_dev *pdev,
         }
 
         netif_carrier_off(netdev);
-        netif_tx_stop_all_queues(netdev);
 
         strcpy(netdev->name, "eth%d");
         err = register_netdev(netdev);
diff --git a/drivers/net/ixgbe/ixgbe_type.h b/drivers/net/ixgbe/ixgbe_type.h
index 83a11ff9ffd1..f011c57c9205 100644
--- a/drivers/net/ixgbe/ixgbe_type.h
+++ b/drivers/net/ixgbe/ixgbe_type.h
@@ -404,6 +404,9 @@
 #define IXGBE_DCA_RXCTRL_DESC_DCA_EN (1 << 5) /* DCA Rx Desc enable */
 #define IXGBE_DCA_RXCTRL_HEAD_DCA_EN (1 << 6) /* DCA Rx Desc header enable */
 #define IXGBE_DCA_RXCTRL_DATA_DCA_EN (1 << 7) /* DCA Rx Desc payload enable */
+#define IXGBE_DCA_RXCTRL_DESC_RRO_EN (1 << 9) /* DCA Rx rd Desc Relax Order */
+#define IXGBE_DCA_RXCTRL_DESC_WRO_EN (1 << 13) /* DCA Rx wr Desc Relax Order */
+#define IXGBE_DCA_RXCTRL_DESC_HSRO_EN (1 << 15) /* DCA Rx Split Header RO */
 
 #define IXGBE_DCA_TXCTRL_CPUID_MASK 0x0000001F /* Tx CPUID Mask */
 #define IXGBE_DCA_TXCTRL_DESC_DCA_EN (1 << 5) /* DCA Tx Desc enable */
diff --git a/drivers/net/korina.c b/drivers/net/korina.c
index 4a5580c1126a..75010cac76ac 100644
--- a/drivers/net/korina.c
+++ b/drivers/net/korina.c
@@ -84,7 +84,10 @@
 #define KORINA_NUM_RDS  64  /* number of receive descriptors */
 #define KORINA_NUM_TDS  64  /* number of transmit descriptors */
 
-#define KORINA_RBSIZE   536 /* size of one resource buffer = Ether MTU */
+/* KORINA_RBSIZE is the hardware's default maximum receive
+ * frame size in bytes. Having this hardcoded means that there
+ * is no support for MTU sizes greater than 1500. */
+#define KORINA_RBSIZE   1536 /* size of one resource buffer = Ether MTU */
 #define KORINA_RDS_MASK (KORINA_NUM_RDS - 1)
 #define KORINA_TDS_MASK (KORINA_NUM_TDS - 1)
 #define RD_RING_SIZE    (KORINA_NUM_RDS * sizeof(struct dma_desc))
@@ -196,7 +199,7 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
         struct korina_private *lp = netdev_priv(dev);
         unsigned long flags;
         u32 length;
-        u32 chain_index;
+        u32 chain_prev, chain_next;
         struct dma_desc *td;
 
         spin_lock_irqsave(&lp->lock, flags);
@@ -228,8 +231,8 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
         /* Setup the transmit descriptor. */
         dma_cache_inv((u32) td, sizeof(*td));
         td->ca = CPHYSADDR(skb->data);
-        chain_index = (lp->tx_chain_tail - 1) &
-                        KORINA_TDS_MASK;
+        chain_prev = (lp->tx_chain_tail - 1) & KORINA_TDS_MASK;
+        chain_next = (lp->tx_chain_tail + 1) & KORINA_TDS_MASK;
 
         if (readl(&(lp->tx_dma_regs->dmandptr)) == 0) {
                 if (lp->tx_chain_status == desc_empty) {
@@ -237,7 +240,7 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                         td->control = DMA_COUNT(length) |
                                         DMA_DESC_COF | DMA_DESC_IOF;
                         /* Move tail */
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                         /* Write to NDPTR */
                         writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
                                         &lp->tx_dma_regs->dmandptr);
@@ -248,12 +251,12 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                         td->control = DMA_COUNT(length) |
                                         DMA_DESC_COF | DMA_DESC_IOF;
                         /* Link to prev */
-                        lp->td_ring[chain_index].control &=
+                        lp->td_ring[chain_prev].control &=
                                         ~DMA_DESC_COF;
                         /* Link to prev */
-                        lp->td_ring[chain_index].link =  CPHYSADDR(td);
+                        lp->td_ring[chain_prev].link =  CPHYSADDR(td);
                         /* Move tail */
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                         /* Write to NDPTR */
                         writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
                                         &(lp->tx_dma_regs->dmandptr));
@@ -267,17 +270,16 @@ static int korina_send_packet(struct sk_buff *skb, struct net_device *dev)
                         td->control = DMA_COUNT(length) |
                                         DMA_DESC_COF | DMA_DESC_IOF;
                         /* Move tail */
-                        lp->tx_chain_tail = chain_index;
+                        lp->tx_chain_tail = chain_next;
                         lp->tx_chain_status = desc_filled;
-                        netif_stop_queue(dev);
                 } else {
                         /* Update tail */
                         td->control = DMA_COUNT(length) |
                                         DMA_DESC_COF | DMA_DESC_IOF;
-                        lp->td_ring[chain_index].control &=
+                        lp->td_ring[chain_prev].control &=
                                         ~DMA_DESC_COF;
-                        lp->td_ring[chain_index].link =  CPHYSADDR(td);
-                        lp->tx_chain_tail = chain_index;
+                        lp->td_ring[chain_prev].link =  CPHYSADDR(td);
+                        lp->tx_chain_tail = chain_next;
                 }
         }
         dma_cache_wback((u32) td, sizeof(*td));
@@ -327,13 +329,13 @@ static irqreturn_t korina_rx_dma_interrupt(int irq, void *dev_id)
 
         dmas = readl(&lp->rx_dma_regs->dmas);
         if (dmas & (DMA_STAT_DONE | DMA_STAT_HALT | DMA_STAT_ERR)) {
-                netif_rx_schedule_prep(&lp->napi);
-
                 dmasm = readl(&lp->rx_dma_regs->dmasm);
                 writel(dmasm | (DMA_STAT_DONE |
                                 DMA_STAT_HALT | DMA_STAT_ERR),
                                 &lp->rx_dma_regs->dmasm);
 
+                netif_rx_schedule(&lp->napi);
+
                 if (dmas & DMA_STAT_ERR)
                         printk(KERN_ERR DRV_NAME "%s: DMA error\n", dev->name);
 
@@ -350,15 +352,20 @@ static int korina_rx(struct net_device *dev, int limit)
         struct dma_desc *rd = &lp->rd_ring[lp->rx_next_done];
         struct sk_buff *skb, *skb_new;
         u8 *pkt_buf;
-        u32 devcs, pkt_len, dmas, rx_free_desc;
+        u32 devcs, pkt_len, dmas;
         int count;
 
         dma_cache_inv((u32)rd, sizeof(*rd));
 
         for (count = 0; count < limit; count++) {
+                skb = lp->rx_skb[lp->rx_next_done];
+                skb_new = NULL;
 
                 devcs = rd->devcs;
 
+                if ((KORINA_RBSIZE - (u32)DMA_COUNT(rd->control)) == 0)
+                        break;
+
                 /* Update statistics counters */
                 if (devcs & ETH_RX_CRC)
                         dev->stats.rx_crc_errors++;
@@ -381,63 +388,58 @@ static int korina_rx(struct net_device *dev, int limit)
                          * in Rc32434 (errata ref #077) */
                         dev->stats.rx_errors++;
                         dev->stats.rx_dropped++;
-                }
-
-                while ((rx_free_desc = KORINA_RBSIZE - (u32)DMA_COUNT(rd->control)) != 0) {
-                        /* init the var. used for the later
-                         * operations within the while loop */
-                        skb_new = NULL;
+                } else if ((devcs & ETH_RX_ROK)) {
                         pkt_len = RCVPKT_LENGTH(devcs);
-                        skb = lp->rx_skb[lp->rx_next_done];
-
-                        if ((devcs & ETH_RX_ROK)) {
-                                /* must be the (first and) last
-                                 * descriptor then */
-                                pkt_buf = (u8 *)lp->rx_skb[lp->rx_next_done]->data;
-
-                                /* invalidate the cache */
-                                dma_cache_inv((unsigned long)pkt_buf, pkt_len - 4);
-
-                                /* Malloc up new buffer. */
-                                skb_new = netdev_alloc_skb(dev, KORINA_RBSIZE + 2);
-
-                                if (!skb_new)
-                                        break;
-                                /* Do not count the CRC */
-                                skb_put(skb, pkt_len - 4);
-                                skb->protocol = eth_type_trans(skb, dev);
-
-                                /* Pass the packet to upper layers */
-                                netif_receive_skb(skb);
-                                dev->stats.rx_packets++;
-                                dev->stats.rx_bytes += pkt_len;
-
-                                /* Update the mcast stats */
-                                if (devcs & ETH_RX_MP)
-                                        dev->stats.multicast++;
-
-                                lp->rx_skb[lp->rx_next_done] = skb_new;
-                        }
-
-                        rd->devcs = 0;
-
-                        /* Restore descriptor's curr_addr */
-                        if (skb_new)
-                                rd->ca = CPHYSADDR(skb_new->data);
-                        else
-                                rd->ca = CPHYSADDR(skb->data);
-
-                        rd->control = DMA_COUNT(KORINA_RBSIZE) |
-                                DMA_DESC_COD | DMA_DESC_IOD;
-                        lp->rd_ring[(lp->rx_next_done - 1) &
-                                KORINA_RDS_MASK].control &=
-                                ~DMA_DESC_COD;
-
-                        lp->rx_next_done = (lp->rx_next_done + 1) & KORINA_RDS_MASK;
-                        dma_cache_wback((u32)rd, sizeof(*rd));
-                        rd = &lp->rd_ring[lp->rx_next_done];
-                        writel(~DMA_STAT_DONE, &lp->rx_dma_regs->dmas);
+
+                        /* must be the (first and) last
+                         * descriptor then */
+                        pkt_buf = (u8 *)lp->rx_skb[lp->rx_next_done]->data;
+
+                        /* invalidate the cache */
+                        dma_cache_inv((unsigned long)pkt_buf, pkt_len - 4);
+
+                        /* Malloc up new buffer. */
+                        skb_new = netdev_alloc_skb(dev, KORINA_RBSIZE + 2);
+
+                        if (!skb_new)
+                                break;
+                        /* Do not count the CRC */
+                        skb_put(skb, pkt_len - 4);
+                        skb->protocol = eth_type_trans(skb, dev);
+
+                        /* Pass the packet to upper layers */
+                        netif_receive_skb(skb);
+                        dev->stats.rx_packets++;
+                        dev->stats.rx_bytes += pkt_len;
+
+                        /* Update the mcast stats */
+                        if (devcs & ETH_RX_MP)
+                                dev->stats.multicast++;
+
+                        /* 16 bit align */
+                        skb_reserve(skb_new, 2);
+
+                        lp->rx_skb[lp->rx_next_done] = skb_new;
                 }
+
+                rd->devcs = 0;
+
+                /* Restore descriptor's curr_addr */
+                if (skb_new)
+                        rd->ca = CPHYSADDR(skb_new->data);
+                else
+                        rd->ca = CPHYSADDR(skb->data);
+
+                rd->control = DMA_COUNT(KORINA_RBSIZE) |
+                        DMA_DESC_COD | DMA_DESC_IOD;
+                lp->rd_ring[(lp->rx_next_done - 1) &
+                        KORINA_RDS_MASK].control &=
+                        ~DMA_DESC_COD;
+
+                lp->rx_next_done = (lp->rx_next_done + 1) & KORINA_RDS_MASK;
+                dma_cache_wback((u32)rd, sizeof(*rd));
+                rd = &lp->rd_ring[lp->rx_next_done];
+                writel(~DMA_STAT_DONE, &lp->rx_dma_regs->dmas);
         }
 
         dmas = readl(&lp->rx_dma_regs->dmas);
@@ -623,12 +625,12 @@ korina_tx_dma_interrupt(int irq, void *dev_id)
         dmas = readl(&lp->tx_dma_regs->dmas);
 
         if (dmas & (DMA_STAT_FINI | DMA_STAT_ERR)) {
-                korina_tx(dev);
-
                 dmasm = readl(&lp->tx_dma_regs->dmasm);
                 writel(dmasm | (DMA_STAT_FINI | DMA_STAT_ERR),
                                 &lp->tx_dma_regs->dmasm);
 
+                korina_tx(dev);
+
                 if (lp->tx_chain_status == desc_filled &&
                         (readl(&(lp->tx_dma_regs->dmandptr)) == 0)) {
                         writel(CPHYSADDR(&lp->td_ring[lp->tx_chain_head]),
@@ -741,6 +743,7 @@ static struct ethtool_ops netdev_ethtool_ops = {
 static void korina_alloc_ring(struct net_device *dev)
 {
         struct korina_private *lp = netdev_priv(dev);
+        struct sk_buff *skb;
         int i;
 
         /* Initialize the transmit descriptors */
@@ -756,8 +759,6 @@ static void korina_alloc_ring(struct net_device *dev)
 
         /* Initialize the receive descriptors */
         for (i = 0; i < KORINA_NUM_RDS; i++) {
-                struct sk_buff *skb = lp->rx_skb[i];
-
                 skb = dev_alloc_skb(KORINA_RBSIZE + 2);
                 if (!skb)
                         break;
@@ -770,11 +771,12 @@ static void korina_alloc_ring(struct net_device *dev)
                 lp->rd_ring[i].link = CPHYSADDR(&lp->rd_ring[i+1]);
         }
 
-        /* loop back */
-        lp->rd_ring[i].link = CPHYSADDR(&lp->rd_ring[0]);
-        lp->rx_next_done  = 0;
+        /* loop back receive descriptors, so the last
+         * descriptor points to the first one */
+        lp->rd_ring[i - 1].link = CPHYSADDR(&lp->rd_ring[0]);
+        lp->rd_ring[i - 1].control |= DMA_DESC_COD;
 
-        lp->rd_ring[i].control |= DMA_DESC_COD;
+        lp->rx_next_done  = 0;
         lp->rx_chain_head = 0;
         lp->rx_chain_tail = 0;
         lp->rx_chain_status = desc_empty;
@@ -901,6 +903,8 @@ static int korina_restart(struct net_device *dev)
 
         korina_free_ring(dev);
 
+        napi_disable(&lp->napi);
+
         ret = korina_init(dev);
         if (ret < 0) {
                 printk(KERN_ERR DRV_NAME "%s: cannot restart device\n",
@@ -999,14 +1003,14 @@ static int korina_open(struct net_device *dev)
          * that handles the Done Finished
          * Ovr and Und Events */
         ret = request_irq(lp->rx_irq, &korina_rx_dma_interrupt,
-                IRQF_SHARED | IRQF_DISABLED, "Korina ethernet Rx", dev);
+                        IRQF_DISABLED, "Korina ethernet Rx", dev);
         if (ret < 0) {
                 printk(KERN_ERR DRV_NAME "%s: unable to get Rx DMA IRQ %d\n",
                     dev->name, lp->rx_irq);
                 goto err_release;
         }
         ret = request_irq(lp->tx_irq, &korina_tx_dma_interrupt,
-                IRQF_SHARED | IRQF_DISABLED, "Korina ethernet Tx", dev);
+                        IRQF_DISABLED, "Korina ethernet Tx", dev);
         if (ret < 0) {
                 printk(KERN_ERR DRV_NAME "%s: unable to get Tx DMA IRQ %d\n",
                     dev->name, lp->tx_irq);
@@ -1015,7 +1019,7 @@ static int korina_open(struct net_device *dev)
 
         /* Install handler for overrun error. */
         ret = request_irq(lp->ovr_irq, &korina_ovr_interrupt,
-                        IRQF_SHARED | IRQF_DISABLED, "Ethernet Overflow", dev);
+                        IRQF_DISABLED, "Ethernet Overflow", dev);
         if (ret < 0) {
                 printk(KERN_ERR DRV_NAME"%s: unable to get OVR IRQ %d\n",
                     dev->name, lp->ovr_irq);
@@ -1024,7 +1028,7 @@ static int korina_open(struct net_device *dev)
 
         /* Install handler for underflow error. */
         ret = request_irq(lp->und_irq, &korina_und_interrupt,
-                        IRQF_SHARED | IRQF_DISABLED, "Ethernet Underflow", dev);
+                        IRQF_DISABLED, "Ethernet Underflow", dev);
         if (ret < 0) {
                 printk(KERN_ERR DRV_NAME "%s: unable to get UND IRQ %d\n",
                     dev->name, lp->und_irq);
@@ -1067,6 +1071,8 @@ static int korina_close(struct net_device *dev)
 
         korina_free_ring(dev);
 
+        napi_disable(&lp->napi);
+
         free_irq(lp->rx_irq, dev);
         free_irq(lp->tx_irq, dev);
         free_irq(lp->ovr_irq, dev);
@@ -1089,7 +1095,6 @@ static int korina_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
         SET_NETDEV_DEV(dev, &pdev->dev);
-        platform_set_drvdata(pdev, dev);
         lp = netdev_priv(dev);
 
         bif->dev = dev;
diff --git a/drivers/net/macb.c b/drivers/net/macb.c
index a04da4ecaa88..f6c4936e2fa8 100644
--- a/drivers/net/macb.c
+++ b/drivers/net/macb.c
@@ -321,6 +321,10 @@ static void macb_tx(struct macb *bp)
                 printk(KERN_ERR "%s: TX underrun, resetting buffers\n",
                         bp->dev->name);
 
+                /* Transfer ongoing, disable transmitter, to avoid confusion */
+                if (status & MACB_BIT(TGO))
+                        macb_writel(bp, NCR, macb_readl(bp, NCR) & ~MACB_BIT(TE));
+
                 head = bp->tx_head;
 
                 /*Mark all the buffer as used to avoid sending a lost buffer*/
@@ -343,6 +347,10 @@ static void macb_tx(struct macb *bp)
                 }
 
                 bp->tx_head = bp->tx_tail = 0;
+
+                /* Enable the transmitter again */
+                if (status & MACB_BIT(TGO))
+                        macb_writel(bp, NCR, macb_readl(bp, NCR) | MACB_BIT(TE));
         }
 
         if (!(status & MACB_BIT(COMP)))
diff --git a/drivers/net/mlx4/profile.c b/drivers/net/mlx4/profile.c
index 919fb9eb1b62..cebdf3243ca1 100644
--- a/drivers/net/mlx4/profile.c
+++ b/drivers/net/mlx4/profile.c
@@ -107,9 +107,9 @@ u64 mlx4_make_profile(struct mlx4_dev *dev,
         profile[MLX4_RES_AUXC].num    = request->num_qp;
         profile[MLX4_RES_SRQ].num     = request->num_srq;
         profile[MLX4_RES_CQ].num      = request->num_cq;
-        profile[MLX4_RES_EQ].num      = min(dev_cap->max_eqs,
-                                            dev_cap->reserved_eqs +
-                                            num_possible_cpus() + 1);
+        profile[MLX4_RES_EQ].num      = min_t(unsigned, dev_cap->max_eqs,
+                                              dev_cap->reserved_eqs +
+                                              num_possible_cpus() + 1);
         profile[MLX4_RES_DMPT].num    = request->num_mpt;
         profile[MLX4_RES_CMPT].num    = MLX4_NUM_CMPTS;
         profile[MLX4_RES_MTT].num     = request->num_mtt;
diff --git a/drivers/net/mv643xx_eth.c b/drivers/net/mv643xx_eth.c
index 7253a499d9c8..5f31bbb614af 100644
--- a/drivers/net/mv643xx_eth.c
+++ b/drivers/net/mv643xx_eth.c
@@ -136,21 +136,23 @@ static char mv643xx_eth_driver_version[] = "1.4";
 /*
  * SDMA configuration register.
  */
+#define RX_BURST_SIZE_4_64BIT           (2 << 1)
 #define RX_BURST_SIZE_16_64BIT          (4 << 1)
 #define BLM_RX_NO_SWAP                  (1 << 4)
 #define BLM_TX_NO_SWAP                  (1 << 5)
+#define TX_BURST_SIZE_4_64BIT           (2 << 22)
 #define TX_BURST_SIZE_16_64BIT          (4 << 22)
 
 #if defined(__BIG_ENDIAN)
 #define PORT_SDMA_CONFIG_DEFAULT_VALUE          \
-                (RX_BURST_SIZE_16_64BIT |       \
-                TX_BURST_SIZE_16_64BIT)
+                (RX_BURST_SIZE_4_64BIT  |       \
+                 TX_BURST_SIZE_4_64BIT)
 #elif defined(__LITTLE_ENDIAN)
 #define PORT_SDMA_CONFIG_DEFAULT_VALUE          \
-                (RX_BURST_SIZE_16_64BIT |       \
-                BLM_RX_NO_SWAP          |       \
-                BLM_TX_NO_SWAP          |       \
-                TX_BURST_SIZE_16_64BIT)
+                (RX_BURST_SIZE_4_64BIT  |       \
+                 BLM_RX_NO_SWAP         |       \
+                 BLM_TX_NO_SWAP         |       \
+                 TX_BURST_SIZE_4_64BIT)
 #else
 #error One of __BIG_ENDIAN or __LITTLE_ENDIAN must be defined
 #endif
@@ -1594,7 +1596,7 @@ oom:
                         entry = addr_crc(a);
                 }
 
-                table[entry >> 2] |= 1 << (entry & 3);
+                table[entry >> 2] |= 1 << (8 * (entry & 3));
         }
 
         for (i = 0; i < 0x100; i += 4) {
@@ -2210,6 +2212,7 @@ static int mv643xx_eth_stop(struct net_device *dev)
         struct mv643xx_eth_private *mp = netdev_priv(dev);
         int i;
 
+        wrlp(mp, INT_MASK_EXT, 0x00000000);
         wrlp(mp, INT_MASK, 0x00000000);
         rdlp(mp, INT_MASK);
 
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index 6bb71b687f7b..e9c1296b267e 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -1,7 +1,7 @@
 /*************************************************************************
  * myri10ge.c: Myricom Myri-10G Ethernet driver.
  *
- * Copyright (C) 2005 - 2007 Myricom, Inc.
+ * Copyright (C) 2005 - 2009 Myricom, Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -75,7 +75,7 @@
 #include "myri10ge_mcp.h"
 #include "myri10ge_mcp_gen_header.h"
 
-#define MYRI10GE_VERSION_STR "1.4.4-1.398"
+#define MYRI10GE_VERSION_STR "1.4.4-1.401"
 
 MODULE_DESCRIPTION("Myricom 10G driver (10GbE)");
 MODULE_AUTHOR("Maintainer: help@myri.com");
@@ -3786,7 +3786,7 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         if (status != 0) {
                 dev_err(&pdev->dev, "Error %d writing PCI_EXP_DEVCTL\n",
                         status);
-                goto abort_with_netdev;
+                goto abort_with_enabled;
         }
 
         pci_set_master(pdev);
@@ -3801,13 +3801,13 @@ static int myri10ge_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
         }
         if (status != 0) {
                 dev_err(&pdev->dev, "Error %d setting DMA mask\n", status);
-                goto abort_with_netdev;
+                goto abort_with_enabled;
         }
         (void)pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK);
         mgp->cmd = dma_alloc_coherent(&pdev->dev, sizeof(*mgp->cmd),
                                       &mgp->cmd_bus, GFP_KERNEL);
         if (mgp->cmd == NULL)
-                goto abort_with_netdev;
+                goto abort_with_enabled;
 
         mgp->board_span = pci_resource_len(pdev, 0);
         mgp->iomem_base = pci_resource_start(pdev, 0);
@@ -3943,8 +3943,10 @@ abort_with_mtrr:
         dma_free_coherent(&pdev->dev, sizeof(*mgp->cmd),
                           mgp->cmd, mgp->cmd_bus);
 
-abort_with_netdev:
+abort_with_enabled:
+        pci_disable_device(pdev);
 
+abort_with_netdev:
         free_netdev(netdev);
         return status;
 }
@@ -3990,6 +3992,7 @@ static void myri10ge_remove(struct pci_dev *pdev)
                           mgp->cmd, mgp->cmd_bus);
 
         free_netdev(netdev);
+        pci_disable_device(pdev);
         pci_set_drvdata(pdev, NULL);
 }
 
diff --git a/drivers/net/netxen/netxen_nic.h b/drivers/net/netxen/netxen_nic.h
index f8e601c51da7..a75a31005fd3 100644
--- a/drivers/net/netxen/netxen_nic.h
+++ b/drivers/net/netxen/netxen_nic.h
@@ -146,7 +146,7 @@
 
 #define MAX_RX_BUFFER_LENGTH            1760
 #define MAX_RX_JUMBO_BUFFER_LENGTH      8062
-#define MAX_RX_LRO_BUFFER_LENGTH        ((48*1024)-512)
+#define MAX_RX_LRO_BUFFER_LENGTH        (8062)
 #define RX_DMA_MAP_LEN                  (MAX_RX_BUFFER_LENGTH - 2)
 #define RX_JUMBO_DMA_MAP_LEN    \
         (MAX_RX_JUMBO_BUFFER_LENGTH - 2)
@@ -207,11 +207,11 @@
 
 #define MAX_CMD_DESCRIPTORS             4096
 #define MAX_RCV_DESCRIPTORS             16384
-#define MAX_CMD_DESCRIPTORS_HOST        (MAX_CMD_DESCRIPTORS / 4)
-#define MAX_RCV_DESCRIPTORS_1G          (MAX_RCV_DESCRIPTORS / 4)
-#define MAX_RCV_DESCRIPTORS_10G         8192
-#define MAX_JUMBO_RCV_DESCRIPTORS       1024
-#define MAX_LRO_RCV_DESCRIPTORS         64
+#define MAX_CMD_DESCRIPTORS_HOST        1024
+#define MAX_RCV_DESCRIPTORS_1G          2048
+#define MAX_RCV_DESCRIPTORS_10G         4096
+#define MAX_JUMBO_RCV_DESCRIPTORS       512
+#define MAX_LRO_RCV_DESCRIPTORS         8
 #define MAX_RCVSTATUS_DESCRIPTORS       MAX_RCV_DESCRIPTORS
 #define MAX_JUMBO_RCV_DESC      MAX_JUMBO_RCV_DESCRIPTORS
 #define MAX_RCV_DESC            MAX_RCV_DESCRIPTORS
@@ -308,27 +308,16 @@ struct netxen_ring_ctx {
 #define netxen_set_cmd_desc_ctxid(cmd_desc, var)        \
         ((cmd_desc)->port_ctxid |= ((var) << 4 & 0xF0))
 
-#define netxen_set_cmd_desc_flags(cmd_desc, val)        \
-        (cmd_desc)->flags_opcode = ((cmd_desc)->flags_opcode & \
-                ~cpu_to_le16(0x7f)) | cpu_to_le16((val) & 0x7f)
-#define netxen_set_cmd_desc_opcode(cmd_desc, val)       \
-        (cmd_desc)->flags_opcode = ((cmd_desc)->flags_opcode & \
-                ~cpu_to_le16((u16)0x3f << 7)) | cpu_to_le16(((val) & 0x3f) << 7)
-
-#define netxen_set_cmd_desc_num_of_buff(cmd_desc, val)  \
-        (cmd_desc)->num_of_buffers_total_length = \
-                ((cmd_desc)->num_of_buffers_total_length & \
-                ~cpu_to_le32(0xff)) | cpu_to_le32((val) & 0xff)
-#define netxen_set_cmd_desc_totallength(cmd_desc, val)  \
-        (cmd_desc)->num_of_buffers_total_length = \
-                ((cmd_desc)->num_of_buffers_total_length & \
-                ~cpu_to_le32((u32)0xffffff << 8)) | \
-                cpu_to_le32(((val) & 0xffffff) << 8)
-
-#define netxen_get_cmd_desc_opcode(cmd_desc)    \
-        ((le16_to_cpu((cmd_desc)->flags_opcode) >> 7) & 0x003f)
-#define netxen_get_cmd_desc_totallength(cmd_desc)       \
-        ((le32_to_cpu((cmd_desc)->num_of_buffers_total_length) >> 8) & 0xffffff)
+#define netxen_set_tx_port(_desc, _port) \
+        (_desc)->port_ctxid = ((_port) & 0xf) | (((_port) << 4) & 0xf0)
+
+#define netxen_set_tx_flags_opcode(_desc, _flags, _opcode) \
+        (_desc)->flags_opcode = \
+        cpu_to_le16(((_flags) & 0x7f) | (((_opcode) & 0x3f) << 7))
+
+#define netxen_set_tx_frags_len(_desc, _frags, _len) \
+        (_desc)->num_of_buffers_total_length = \
+        cpu_to_le32(((_frags) & 0xff) | (((_len) & 0xffffff) << 8))
 
 struct cmd_desc_type0 {
         u8 tcp_hdr_offset;      /* For LSO only */
@@ -510,7 +499,8 @@ typedef enum {
         NETXEN_BRDTYPE_P3_10G_SFP_CT = 0x002a,
         NETXEN_BRDTYPE_P3_10G_SFP_QT = 0x002b,
         NETXEN_BRDTYPE_P3_10G_CX4 = 0x0031,
-        NETXEN_BRDTYPE_P3_10G_XFP = 0x0032
+        NETXEN_BRDTYPE_P3_10G_XFP = 0x0032,
+        NETXEN_BRDTYPE_P3_10G_TP = 0x0080
 
 } netxen_brdtype_t;
 
@@ -757,7 +747,7 @@ extern char netxen_nic_driver_name[];
  */
 struct netxen_skb_frag {
         u64 dma;
-        u32 length;
+        ulong length;
 };
 
 #define _netxen_set_bits(config_word, start, bits, val) {\
@@ -783,13 +773,7 @@ struct netxen_skb_frag {
 struct netxen_cmd_buffer {
         struct sk_buff *skb;
         struct netxen_skb_frag frag_array[MAX_BUFFERS_PER_CMD + 1];
-        u32 total_length;
-        u32 mss;
-        u16 port;
-        u8 cmd;
-        u8 frag_count;
-        unsigned long time_stamp;
-        u32 state;
+        u32 frag_count;
 };
 
 /* In rx_buffer, we do not need multiple fragments as is a single buffer */
@@ -876,7 +860,6 @@ struct nx_host_rds_ring {
         u32 skb_size;
         struct netxen_rx_buffer *rx_buf_arr;    /* rx buffers for receive   */
         struct list_head free_list;
-        int begin_alloc;
 };
 
 /*
@@ -995,31 +978,31 @@ struct netxen_recv_context {
  */
 
 typedef struct {
-        u64 host_phys_addr;     /* Ring base addr */
-        u32 ring_size;          /* Ring entries */
-        u16 msi_index;
-        u16 rsvd;               /* Padding */
+        __le64 host_phys_addr;  /* Ring base addr */
+        __le32 ring_size;               /* Ring entries */
+        __le16 msi_index;
+        __le16 rsvd;            /* Padding */
 } nx_hostrq_sds_ring_t;
 
 typedef struct {
-        u64 host_phys_addr;     /* Ring base addr */
-        u64 buff_size;          /* Packet buffer size */
-        u32 ring_size;          /* Ring entries */
-        u32 ring_kind;          /* Class of ring */
+        __le64 host_phys_addr;  /* Ring base addr */
+        __le64 buff_size;               /* Packet buffer size */
+        __le32 ring_size;               /* Ring entries */
+        __le32 ring_kind;               /* Class of ring */
 } nx_hostrq_rds_ring_t;
 
 typedef struct {
-        u64 host_rsp_dma_addr;  /* Response dma'd here */
-        u32 capabilities[4];    /* Flag bit vector */
-        u32 host_int_crb_mode;  /* Interrupt crb usage */
-        u32 host_rds_crb_mode;  /* RDS crb usage */
+        __le64 host_rsp_dma_addr;       /* Response dma'd here */
+        __le32 capabilities[4]; /* Flag bit vector */
+        __le32 host_int_crb_mode;       /* Interrupt crb usage */
+        __le32 host_rds_crb_mode;       /* RDS crb usage */
         /* These ring offsets are relative to data[0] below */
-        u32 rds_ring_offset;    /* Offset to RDS config */
-        u32 sds_ring_offset;    /* Offset to SDS config */
-        u16 num_rds_rings;      /* Count of RDS rings */
-        u16 num_sds_rings;      /* Count of SDS rings */
-        u16 rsvd1;              /* Padding */
-        u16 rsvd2;              /* Padding */
+        __le32 rds_ring_offset; /* Offset to RDS config */
+        __le32 sds_ring_offset; /* Offset to SDS config */
+        __le16 num_rds_rings;   /* Count of RDS rings */
+        __le16 num_sds_rings;   /* Count of SDS rings */
+        __le16 rsvd1;           /* Padding */
+        __le16 rsvd2;           /* Padding */
         u8  reserved[128];      /* reserve space for future expansion*/
         /* MUST BE 64-bit aligned.
            The following is packed:
@@ -1029,24 +1012,24 @@ typedef struct {
 } nx_hostrq_rx_ctx_t;
 
 typedef struct {
-        u32 host_producer_crb;  /* Crb to use */
-        u32 rsvd1;              /* Padding */
+        __le32 host_producer_crb;       /* Crb to use */
+        __le32 rsvd1;           /* Padding */
 } nx_cardrsp_rds_ring_t;
 
 typedef struct {
-        u32 host_consumer_crb;  /* Crb to use */
-        u32 interrupt_crb;      /* Crb to use */
+        __le32 host_consumer_crb;       /* Crb to use */
+        __le32 interrupt_crb;   /* Crb to use */
 } nx_cardrsp_sds_ring_t;
 
 typedef struct {
         /* These ring offsets are relative to data[0] below */
-        u32 rds_ring_offset;    /* Offset to RDS config */
-        u32 sds_ring_offset;    /* Offset to SDS config */
-        u32 host_ctx_state;     /* Starting State */
-        u32 num_fn_per_port;    /* How many PCI fn share the port */
-        u16 num_rds_rings;      /* Count of RDS rings */
-        u16 num_sds_rings;      /* Count of SDS rings */
-        u16 context_id;         /* Handle for context */
+        __le32 rds_ring_offset; /* Offset to RDS config */
+        __le32 sds_ring_offset; /* Offset to SDS config */
+        __le32 host_ctx_state;  /* Starting State */
+        __le32 num_fn_per_port; /* How many PCI fn share the port */
+        __le16 num_rds_rings;   /* Count of RDS rings */
+        __le16 num_sds_rings;   /* Count of SDS rings */
+        __le16 context_id;              /* Handle for context */
         u8  phys_port;          /* Physical id of port */
         u8  virt_port;          /* Virtual/Logical id of port */
         u8  reserved[128];      /* save space for future expansion */
@@ -1072,34 +1055,34 @@ typedef struct {
  */
 
 typedef struct {
-        u64 host_phys_addr;     /* Ring base addr */
-        u32 ring_size;          /* Ring entries */
-        u32 rsvd;               /* Padding */
+        __le64 host_phys_addr;  /* Ring base addr */
+        __le32 ring_size;               /* Ring entries */
+        __le32 rsvd;            /* Padding */
 } nx_hostrq_cds_ring_t;
 
 typedef struct {
-        u64 host_rsp_dma_addr;  /* Response dma'd here */
-        u64 cmd_cons_dma_addr;  /*  */
-        u64 dummy_dma_addr;     /*  */
-        u32 capabilities[4];    /* Flag bit vector */
-        u32 host_int_crb_mode;  /* Interrupt crb usage */
-        u32 rsvd1;              /* Padding */
-        u16 rsvd2;              /* Padding */
-        u16 interrupt_ctl;
-        u16 msi_index;
-        u16 rsvd3;              /* Padding */
+        __le64 host_rsp_dma_addr;       /* Response dma'd here */
+        __le64 cmd_cons_dma_addr;       /*  */
+        __le64 dummy_dma_addr;  /*  */
+        __le32 capabilities[4]; /* Flag bit vector */
+        __le32 host_int_crb_mode;       /* Interrupt crb usage */
+        __le32 rsvd1;           /* Padding */
+        __le16 rsvd2;           /* Padding */
+        __le16 interrupt_ctl;
+        __le16 msi_index;
+        __le16 rsvd3;           /* Padding */
         nx_hostrq_cds_ring_t cds_ring;  /* Desc of cds ring */
         u8  reserved[128];      /* future expansion */
 } nx_hostrq_tx_ctx_t;
 
 typedef struct {
-        u32 host_producer_crb;  /* Crb to use */
-        u32 interrupt_crb;      /* Crb to use */
+        __le32 host_producer_crb;       /* Crb to use */
+        __le32 interrupt_crb;   /* Crb to use */
 } nx_cardrsp_cds_ring_t;
 
 typedef struct {
-        u32 host_ctx_state;     /* Starting state */
-        u16 context_id;         /* Handle for context */
+        __le32 host_ctx_state;  /* Starting state */
+        __le16 context_id;              /* Handle for context */
         u8  phys_port;          /* Physical id of port */
         u8  virt_port;          /* Virtual/Logical id of port */
         nx_cardrsp_cds_ring_t cds_ring; /* Card cds settings */
@@ -1202,9 +1185,9 @@ enum {
 #define VPORT_MISS_MODE_ACCEPT_MULTI    2 /* accept unmatched multicast */
 
 typedef struct {
-        u64 qhdr;
-        u64 req_hdr;
-        u64 words[6];
+        __le64 qhdr;
+        __le64 req_hdr;
+        __le64 words[6];
 } nx_nic_req_t;
 
 typedef struct {
@@ -1486,8 +1469,6 @@ void netxen_release_tx_buffers(struct netxen_adapter *adapter);
 
 void netxen_initialize_adapter_ops(struct netxen_adapter *adapter);
 int netxen_init_firmware(struct netxen_adapter *adapter);
-void netxen_tso_check(struct netxen_adapter *adapter,
-                      struct cmd_desc_type0 *desc, struct sk_buff *skb);
 void netxen_nic_clear_stats(struct netxen_adapter *adapter);
 void netxen_watchdog_task(struct work_struct *work);
 void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx,
@@ -1496,6 +1477,7 @@ int netxen_process_cmd_ring(struct netxen_adapter *adapter);
 u32 netxen_process_rcv_ring(struct netxen_adapter *adapter, int ctx, int max);
 void netxen_p2_nic_set_multi(struct net_device *netdev);
 void netxen_p3_nic_set_multi(struct net_device *netdev);
+void netxen_p3_free_mac_list(struct netxen_adapter *adapter);
 int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32);
 int netxen_config_intr_coalesce(struct netxen_adapter *adapter);
 
diff --git a/drivers/net/netxen/netxen_nic_ctx.c b/drivers/net/netxen/netxen_nic_ctx.c
index 64b51643c626..746bdb470418 100644
--- a/drivers/net/netxen/netxen_nic_ctx.c
+++ b/drivers/net/netxen/netxen_nic_ctx.c
@@ -76,7 +76,7 @@ netxen_api_unlock(struct netxen_adapter *adapter)
 static u32
 netxen_poll_rsp(struct netxen_adapter *adapter)
 {
-        u32 raw_rsp, rsp = NX_CDRP_RSP_OK;
+        u32 rsp = NX_CDRP_RSP_OK;
         int     timeout = 0;
 
         do {
@@ -86,10 +86,7 @@ netxen_poll_rsp(struct netxen_adapter *adapter)
                 if (++timeout > NX_OS_CRB_RETRY_COUNT)
                         return NX_CDRP_RSP_TIMEOUT;
 
-                netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET,
-                                &raw_rsp);
-
-                rsp = le32_to_cpu(raw_rsp);
+                netxen_nic_read_w1(adapter, NX_CDRP_CRB_OFFSET, &rsp);
         } while (!NX_CDRP_IS_RSP(rsp));
 
         return rsp;
@@ -109,20 +106,16 @@ netxen_issue_cmd(struct netxen_adapter *adapter,
         if (netxen_api_lock(adapter))
                 return NX_RCODE_TIMEOUT;
 
-        netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET,
-                        cpu_to_le32(signature));
+        netxen_nic_write_w1(adapter, NX_SIGN_CRB_OFFSET, signature);
 
-        netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET,
-                        cpu_to_le32(arg1));
+        netxen_nic_write_w1(adapter, NX_ARG1_CRB_OFFSET, arg1);
 
-        netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET,
-                        cpu_to_le32(arg2));
+        netxen_nic_write_w1(adapter, NX_ARG2_CRB_OFFSET, arg2);
 
-        netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET,
-                        cpu_to_le32(arg3));
+        netxen_nic_write_w1(adapter, NX_ARG3_CRB_OFFSET, arg3);
 
         netxen_nic_write_w1(adapter, NX_CDRP_CRB_OFFSET,
-                        cpu_to_le32(NX_CDRP_FORM_CMD(cmd)));
+                        NX_CDRP_FORM_CMD(cmd));
 
         rsp = netxen_poll_rsp(adapter);
 
@@ -133,7 +126,6 @@ netxen_issue_cmd(struct netxen_adapter *adapter,
                 rcode = NX_RCODE_TIMEOUT;
         } else if (rsp == NX_CDRP_RSP_FAIL) {
                 netxen_nic_read_w1(adapter, NX_ARG1_CRB_OFFSET, &rcode);
-                rcode = le32_to_cpu(rcode);
 
                 printk(KERN_ERR "%s: failed card response code:0x%x\n",
                                 netxen_nic_driver_name, rcode);
@@ -183,7 +175,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
 
         int i, nrds_rings, nsds_rings;
         size_t rq_size, rsp_size;
-        u32 cap, reg;
+        u32 cap, reg, val;
 
         int err;
 
@@ -225,11 +217,14 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
 
         prq->num_rds_rings = cpu_to_le16(nrds_rings);
         prq->num_sds_rings = cpu_to_le16(nsds_rings);
-        prq->rds_ring_offset = 0;
-        prq->sds_ring_offset = prq->rds_ring_offset +
+        prq->rds_ring_offset = cpu_to_le32(0);
+
+        val = le32_to_cpu(prq->rds_ring_offset) +
                 (sizeof(nx_hostrq_rds_ring_t) * nrds_rings);
+        prq->sds_ring_offset = cpu_to_le32(val);
 
-        prq_rds = (nx_hostrq_rds_ring_t *)(prq->data + prq->rds_ring_offset);
+        prq_rds = (nx_hostrq_rds_ring_t *)(prq->data +
+                        le32_to_cpu(prq->rds_ring_offset));
 
         for (i = 0; i < nrds_rings; i++) {
 
@@ -241,17 +236,14 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
                 prq_rds[i].buff_size = cpu_to_le64(rds_ring->dma_size);
         }
 
-        prq_sds = (nx_hostrq_sds_ring_t *)(prq->data + prq->sds_ring_offset);
+        prq_sds = (nx_hostrq_sds_ring_t *)(prq->data +
+                        le32_to_cpu(prq->sds_ring_offset));
 
         prq_sds[0].host_phys_addr =
                 cpu_to_le64(recv_ctx->rcv_status_desc_phys_addr);
         prq_sds[0].ring_size = cpu_to_le32(adapter->max_rx_desc_count);
         /* only one msix vector for now */
-        prq_sds[0].msi_index = cpu_to_le32(0);
-
-        /* now byteswap offsets */
-        prq->rds_ring_offset = cpu_to_le32(prq->rds_ring_offset);
-        prq->sds_ring_offset = cpu_to_le32(prq->sds_ring_offset);
+        prq_sds[0].msi_index = cpu_to_le16(0);
 
         phys_addr = hostrq_phys_addr;
         err = netxen_issue_cmd(adapter,
@@ -269,9 +261,9 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
 
 
         prsp_rds = ((nx_cardrsp_rds_ring_t *)
-                         &prsp->data[prsp->rds_ring_offset]);
+                         &prsp->data[le32_to_cpu(prsp->rds_ring_offset)]);
 
-        for (i = 0; i < le32_to_cpu(prsp->num_rds_rings); i++) {
+        for (i = 0; i < le16_to_cpu(prsp->num_rds_rings); i++) {
                 rds_ring = &recv_ctx->rds_rings[i];
 
                 reg = le32_to_cpu(prsp_rds[i].host_producer_crb);
@@ -279,7 +271,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
         }
 
         prsp_sds = ((nx_cardrsp_sds_ring_t *)
-                        &prsp->data[prsp->sds_ring_offset]);
+                        &prsp->data[le32_to_cpu(prsp->sds_ring_offset)]);
         reg = le32_to_cpu(prsp_sds[0].host_consumer_crb);
         recv_ctx->crb_sts_consumer = NETXEN_NIC_REG(reg - 0x200);
 
@@ -288,7 +280,7 @@ nx_fw_cmd_create_rx_ctx(struct netxen_adapter *adapter)
 
         recv_ctx->state = le32_to_cpu(prsp->host_ctx_state);
         recv_ctx->context_id = le16_to_cpu(prsp->context_id);
-        recv_ctx->virt_port = le16_to_cpu(prsp->virt_port);
+        recv_ctx->virt_port = prsp->virt_port;
 
 out_free_rsp:
         pci_free_consistent(adapter->pdev, rsp_size, prsp, cardrsp_phys_addr);
diff --git a/drivers/net/netxen/netxen_nic_ethtool.c b/drivers/net/netxen/netxen_nic_ethtool.c
index e45ce2951729..0894a7be0225 100644
--- a/drivers/net/netxen/netxen_nic_ethtool.c
+++ b/drivers/net/netxen/netxen_nic_ethtool.c
@@ -136,11 +136,9 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 
                 ecmd->port = PORT_TP;
 
-                if (netif_running(dev)) {
-                        ecmd->speed = adapter->link_speed;
-                        ecmd->duplex = adapter->link_duplex;
-                        ecmd->autoneg = adapter->link_autoneg;
-                }
+                ecmd->speed = adapter->link_speed;
+                ecmd->duplex = adapter->link_duplex;
+                ecmd->autoneg = adapter->link_autoneg;
 
         } else if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
                 u32 val;
@@ -171,7 +169,7 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         } else
                 return -EIO;
 
-        ecmd->phy_address = adapter->portnum;
+        ecmd->phy_address = adapter->physical_port;
         ecmd->transceiver = XCVR_EXTERNAL;
 
         switch ((netxen_brdtype_t) boardinfo->board_type) {
@@ -180,13 +178,13 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
         case NETXEN_BRDTYPE_P3_REF_QG:
         case NETXEN_BRDTYPE_P3_4_GB:
         case NETXEN_BRDTYPE_P3_4_GB_MM:
-        case NETXEN_BRDTYPE_P3_10000_BASE_T:
 
                 ecmd->supported |= SUPPORTED_Autoneg;
                 ecmd->advertising |= ADVERTISED_Autoneg;
         case NETXEN_BRDTYPE_P2_SB31_10G_CX4:
         case NETXEN_BRDTYPE_P3_10G_CX4:
         case NETXEN_BRDTYPE_P3_10G_CX4_LP:
+        case NETXEN_BRDTYPE_P3_10000_BASE_T:
                 ecmd->supported |= SUPPORTED_TP;
                 ecmd->advertising |= ADVERTISED_TP;
                 ecmd->port = PORT_TP;
@@ -204,16 +202,33 @@ netxen_nic_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
                 ecmd->port = PORT_FIBRE;
                 ecmd->autoneg = AUTONEG_DISABLE;
                 break;
-        case NETXEN_BRDTYPE_P2_SB31_10G:
         case NETXEN_BRDTYPE_P3_10G_SFP_PLUS:
         case NETXEN_BRDTYPE_P3_10G_SFP_CT:
         case NETXEN_BRDTYPE_P3_10G_SFP_QT:
+                ecmd->advertising |= ADVERTISED_TP;
+                ecmd->supported |= SUPPORTED_TP;
+        case NETXEN_BRDTYPE_P2_SB31_10G:
         case NETXEN_BRDTYPE_P3_10G_XFP:
                 ecmd->supported |= SUPPORTED_FIBRE;
                 ecmd->advertising |= ADVERTISED_FIBRE;
                 ecmd->port = PORT_FIBRE;
                 ecmd->autoneg = AUTONEG_DISABLE;
                 break;
+        case NETXEN_BRDTYPE_P3_10G_TP:
+                if (adapter->ahw.board_type == NETXEN_NIC_XGBE) {
+                        ecmd->autoneg = AUTONEG_DISABLE;
+                        ecmd->supported |= (SUPPORTED_FIBRE | SUPPORTED_TP);
+                        ecmd->advertising |=
+                                (ADVERTISED_FIBRE | ADVERTISED_TP);
+                        ecmd->port = PORT_FIBRE;
+                } else {
+                        ecmd->autoneg = AUTONEG_ENABLE;
+                        ecmd->supported |= (SUPPORTED_TP |SUPPORTED_Autoneg);
+                        ecmd->advertising |=
+                                (ADVERTISED_TP | ADVERTISED_Autoneg);
+                        ecmd->port = PORT_TP;
+                }
+                break;
         default:
                 printk(KERN_ERR "netxen-nic: Unsupported board model %d\n",
                        (netxen_brdtype_t) boardinfo->board_type);
@@ -546,7 +561,10 @@ netxen_nic_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
         }
         ring->tx_pending = adapter->max_tx_desc_count;
 
-        ring->rx_max_pending = MAX_RCV_DESCRIPTORS;
+        if (adapter->ahw.board_type == NETXEN_NIC_GBE)
+                ring->rx_max_pending = MAX_RCV_DESCRIPTORS_1G;
+        else
+                ring->rx_max_pending = MAX_RCV_DESCRIPTORS_10G;
         ring->tx_max_pending = MAX_CMD_DESCRIPTORS_HOST;
         ring->rx_jumbo_max_pending = MAX_JUMBO_RCV_DESCRIPTORS;
         ring->rx_mini_max_pending = 0;
diff --git a/drivers/net/netxen/netxen_nic_hw.c b/drivers/net/netxen/netxen_nic_hw.c
index aa6e603bfcbf..821cff68b3f3 100644
--- a/drivers/net/netxen/netxen_nic_hw.c
+++ b/drivers/net/netxen/netxen_nic_hw.c
@@ -503,17 +503,15 @@ netxen_send_cmd_descs(struct netxen_adapter *adapter,
 
         i = 0;
 
+        netif_tx_lock_bh(adapter->netdev);
+
         producer = adapter->cmd_producer;
         do {
                 cmd_desc = &cmd_desc_arr[i];
 
                 pbuf = &adapter->cmd_buf_arr[producer];
-                pbuf->mss = 0;
-                pbuf->total_length = 0;
                 pbuf->skb = NULL;
-                pbuf->cmd = 0;
                 pbuf->frag_count = 0;
-                pbuf->port = 0;
 
                 /* adapter->ahw.cmd_desc_head[producer] = *cmd_desc; */
                 memcpy(&adapter->ahw.cmd_desc_head[producer],
@@ -531,6 +529,8 @@ netxen_send_cmd_descs(struct netxen_adapter *adapter,
 
         netxen_nic_update_cmd_producer(adapter, adapter->cmd_producer);
 
+        netif_tx_unlock_bh(adapter->netdev);
+
         return 0;
 }
 
@@ -539,16 +539,19 @@ static int nx_p3_sre_macaddr_change(struct net_device *dev,
 {
         struct netxen_adapter *adapter = netdev_priv(dev);
         nx_nic_req_t req;
-        nx_mac_req_t mac_req;
+        nx_mac_req_t *mac_req;
+        u64 word;
         int rv;
 
         memset(&req, 0, sizeof(nx_nic_req_t));
-        req.qhdr |= (NX_NIC_REQUEST << 23);
-        req.req_hdr |= NX_MAC_EVENT;
-        req.req_hdr |= ((u64)adapter->portnum << 16);
-        mac_req.op = op;
-        memcpy(&mac_req.mac_addr, addr, 6);
-        req.words[0] = cpu_to_le64(*(u64 *)&mac_req);
+        req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
+
+        word = NX_MAC_EVENT | ((u64)adapter->portnum << 16);
+        req.req_hdr = cpu_to_le64(word);
+
+        mac_req = (nx_mac_req_t *)&req.words[0];
+        mac_req->op = op;
+        memcpy(mac_req->mac_addr, addr, 6);
 
         rv = netxen_send_cmd_descs(adapter, (struct cmd_desc_type0 *)&req, 1);
         if (rv != 0) {
@@ -612,18 +615,35 @@ send_fw_cmd:
 int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
 {
         nx_nic_req_t req;
+        u64 word;
 
         memset(&req, 0, sizeof(nx_nic_req_t));
 
-        req.qhdr |= (NX_HOST_REQUEST << 23);
-        req.req_hdr |= NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE;
-        req.req_hdr |= ((u64)adapter->portnum << 16);
+        req.qhdr = cpu_to_le64(NX_HOST_REQUEST << 23);
+
+        word = NX_NIC_H2C_OPCODE_PROXY_SET_VPORT_MISS_MODE |
+                        ((u64)adapter->portnum << 16);
+        req.req_hdr = cpu_to_le64(word);
+
         req.words[0] = cpu_to_le64(mode);
 
         return netxen_send_cmd_descs(adapter,
                                 (struct cmd_desc_type0 *)&req, 1);
 }
 
+void netxen_p3_free_mac_list(struct netxen_adapter *adapter)
+{
+        nx_mac_list_t *cur, *next;
+
+        cur = adapter->mac_list;
+
+        while (cur) {
+                next = cur->next;
+                kfree(cur);
+                cur = next;
+        }
+}
+
 #define NETXEN_CONFIG_INTR_COALESCE     3
 
 /*
@@ -632,13 +652,15 @@ int netxen_p3_nic_set_promisc(struct netxen_adapter *adapter, u32 mode)
 int netxen_config_intr_coalesce(struct netxen_adapter *adapter)
 {
         nx_nic_req_t req;
+        u64 word;
         int rv;
 
         memset(&req, 0, sizeof(nx_nic_req_t));
 
-        req.qhdr |= (NX_NIC_REQUEST << 23);
-        req.req_hdr |= NETXEN_CONFIG_INTR_COALESCE;
-        req.req_hdr |= ((u64)adapter->portnum << 16);
+        req.qhdr = cpu_to_le64(NX_NIC_REQUEST << 23);
+
+        word = NETXEN_CONFIG_INTR_COALESCE | ((u64)adapter->portnum << 16);
+        req.req_hdr = cpu_to_le64(word);
 
         memcpy(&req.words[0], &adapter->coal, sizeof(adapter->coal));
 
@@ -772,13 +794,10 @@ int netxen_p3_get_mac_addr(struct netxen_adapter *adapter, __le64 *mac)
         adapter->hw_read_wx(adapter, crbaddr, &mac_lo, 4);
         adapter->hw_read_wx(adapter, crbaddr+4, &mac_hi, 4);
 
-        mac_hi = cpu_to_le32(mac_hi);
-        mac_lo = cpu_to_le32(mac_lo);
-
         if (pci_func & 1)
-                *mac = ((mac_lo >> 16) | ((u64)mac_hi << 16));
+                *mac = le64_to_cpu((mac_lo >> 16) | ((u64)mac_hi << 16));
         else
-                *mac = ((mac_lo) | ((u64)mac_hi << 32));
+                *mac = le64_to_cpu((u64)mac_lo | ((u64)mac_hi << 32));
 
         return 0;
 }
@@ -937,7 +956,7 @@ int netxen_load_firmware(struct netxen_adapter *adapter)
 {
         int i;
         u32 data, size = 0;
-        u32 flashaddr = NETXEN_BOOTLD_START, memaddr = NETXEN_BOOTLD_START;
+        u32 flashaddr = NETXEN_BOOTLD_START;
 
         size = (NETXEN_IMAGE_START - NETXEN_BOOTLD_START)/4;
 
@@ -949,10 +968,8 @@ int netxen_load_firmware(struct netxen_adapter *adapter)
                 if (netxen_rom_fast_read(adapter, flashaddr, (int *)&data) != 0)
                         return -EIO;
 
-                adapter->pci_mem_write(adapter, memaddr, &data, 4);
+                adapter->pci_mem_write(adapter, flashaddr, &data, 4);
                 flashaddr += 4;
-                memaddr += 4;
-                cond_resched();
         }
         msleep(1);
 
@@ -2034,7 +2051,13 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
                 rv = -1;
         }
 
-        DPRINTK(INFO, "Discovered board type:0x%x  ", boardinfo->board_type);
+        if (boardinfo->board_type == NETXEN_BRDTYPE_P3_4_GB_MM) {
+                u32 gpio = netxen_nic_reg_read(adapter,
+                                NETXEN_ROMUSB_GLB_PAD_GPIO_I);
+                if ((gpio & 0x8000) == 0)
+                        boardinfo->board_type = NETXEN_BRDTYPE_P3_10G_TP;
+        }
+
         switch ((netxen_brdtype_t) boardinfo->board_type) {
         case NETXEN_BRDTYPE_P2_SB35_4G:
                 adapter->ahw.board_type = NETXEN_NIC_GBE;
@@ -2053,7 +2076,6 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
         case NETXEN_BRDTYPE_P3_10G_SFP_QT:
         case NETXEN_BRDTYPE_P3_10G_XFP:
         case NETXEN_BRDTYPE_P3_10000_BASE_T:
-
                 adapter->ahw.board_type = NETXEN_NIC_XGBE;
                 break;
         case NETXEN_BRDTYPE_P1_BD:
@@ -2063,9 +2085,12 @@ int netxen_nic_get_board_info(struct netxen_adapter *adapter)
         case NETXEN_BRDTYPE_P3_REF_QG:
         case NETXEN_BRDTYPE_P3_4_GB:
         case NETXEN_BRDTYPE_P3_4_GB_MM:
-
                 adapter->ahw.board_type = NETXEN_NIC_GBE;
                 break;
+        case NETXEN_BRDTYPE_P3_10G_TP:
+                adapter->ahw.board_type = (adapter->portnum < 2) ?
+                        NETXEN_NIC_XGBE : NETXEN_NIC_GBE;
+                break;
         default:
                 printk("%s: Unknown(%x)\n", netxen_nic_driver_name,
                        boardinfo->board_type);
@@ -2110,12 +2135,16 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
 {
         __u32 status;
         __u32 autoneg;
-        __u32 mode;
         __u32 port_mode;
 
-        netxen_nic_read_w0(adapter, NETXEN_NIU_MODE, &mode);
-        if (netxen_get_niu_enable_ge(mode)) {   /* Gb 10/100/1000 Mbps mode */
+        if (!netif_carrier_ok(adapter->netdev)) {
+                adapter->link_speed   = 0;
+                adapter->link_duplex  = -1;
+                adapter->link_autoneg = AUTONEG_ENABLE;
+                return;
+        }
 
+        if (adapter->ahw.board_type == NETXEN_NIC_GBE) {
                 adapter->hw_read_wx(adapter,
                                 NETXEN_PORT_MODE_ADDR, &port_mode, 4);
                 if (port_mode == NETXEN_PORT_MODE_802_3_AP) {
@@ -2141,7 +2170,7 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
                                         adapter->link_speed = SPEED_1000;
                                         break;
                                 default:
-                                        adapter->link_speed = -1;
+                                        adapter->link_speed = 0;
                                         break;
                                 }
                                 switch (netxen_get_phy_duplex(status)) {
@@ -2164,7 +2193,7 @@ void netxen_nic_set_link_parameters(struct netxen_adapter *adapter)
                                 goto link_down;
                 } else {
                       link_down:
-                        adapter->link_speed = -1;
+                        adapter->link_speed = 0;
                         adapter->link_duplex = -1;
                 }
         }
diff --git a/drivers/net/netxen/netxen_nic_init.c b/drivers/net/netxen/netxen_nic_init.c
index d924468e506e..ca7c8d8050c9 100644
--- a/drivers/net/netxen/netxen_nic_init.c
+++ b/drivers/net/netxen/netxen_nic_init.c
@@ -308,7 +308,6 @@ int netxen_alloc_sw_resources(struct netxen_adapter *adapter)
                         }
                         memset(rds_ring->rx_buf_arr, 0, RCV_BUFFSIZE);
                         INIT_LIST_HEAD(&rds_ring->free_list);
-                        rds_ring->begin_alloc = 0;
                         /*
                          * Now go through all of them, set reference handles
                          * and put them in the queues.
@@ -439,6 +438,8 @@ static int netxen_wait_rom_done(struct netxen_adapter *adapter)
         long timeout = 0;
         long done = 0;
 
+        cond_resched();
+
         while (done == 0) {
                 done = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_GLB_STATUS);
                 done &= 2;
@@ -533,12 +534,9 @@ static int do_rom_fast_write(struct netxen_adapter *adapter, int addr,
 static int do_rom_fast_read(struct netxen_adapter *adapter,
                             int addr, int *valp)
 {
-        cond_resched();
-
         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ADDRESS, addr);
-        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
-        udelay(100);            /* prevent bursting on CRB */
         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
+        netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 3);
         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_INSTR_OPCODE, 0xb);
         if (netxen_wait_rom_done(adapter)) {
                 printk("Error waiting for rom done\n");
@@ -546,7 +544,7 @@ static int do_rom_fast_read(struct netxen_adapter *adapter,
         }
         /* reset abyte_cnt and dummy_byte_cnt */
         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_ABYTE_CNT, 0);
-        udelay(100);            /* prevent bursting on CRB */
+        udelay(10);
         netxen_nic_reg_write(adapter, NETXEN_ROMUSB_ROM_DUMMY_BYTE_CNT, 0);
 
         *valp = netxen_nic_reg_read(adapter, NETXEN_ROMUSB_ROM_RDATA);
@@ -884,14 +882,16 @@ int netxen_flash_unlock(struct netxen_adapter *adapter)
 int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 {
         int addr, val;
-        int i, init_delay = 0;
+        int i, n, init_delay = 0;
         struct crb_addr_pair *buf;
-        unsigned offset, n;
+        unsigned offset;
         u32 off;
 
         /* resetall */
+        rom_lock(adapter);
         netxen_crb_writelit_adapter(adapter, NETXEN_ROMUSB_GLB_SW_RESET,
                                     0xffffffff);
+        netxen_rom_unlock(adapter);
 
         if (verbose) {
                 if (netxen_rom_fast_read(adapter, NETXEN_BOARDTYPE, &val) == 0)
@@ -910,7 +910,7 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
 
         if (NX_IS_REVISION_P3(adapter->ahw.revision_id)) {
                 if (netxen_rom_fast_read(adapter, 0, &n) != 0 ||
-                        (n != 0xcafecafeUL) ||
+                        (n != 0xcafecafe) ||
                         netxen_rom_fast_read(adapter, 4, &n) != 0) {
                         printk(KERN_ERR "%s: ERROR Reading crb_init area: "
                                         "n: %08x\n", netxen_nic_driver_name, n);
@@ -975,6 +975,14 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
                         /* do not reset PCI */
                         if (off == (ROMUSB_GLB + 0xbc))
                                 continue;
+                        if (off == (ROMUSB_GLB + 0xa8))
+                                continue;
+                        if (off == (ROMUSB_GLB + 0xc8)) /* core clock */
+                                continue;
+                        if (off == (ROMUSB_GLB + 0x24)) /* MN clock */
+                                continue;
+                        if (off == (ROMUSB_GLB + 0x1c)) /* MS clock */
+                                continue;
                         if (off == (NETXEN_CRB_PEG_NET_1 + 0x18))
                                 buf[i].data = 0x1020;
                         /* skip the function enable register */
@@ -992,23 +1000,21 @@ int netxen_pinit_from_rom(struct netxen_adapter *adapter, int verbose)
                         continue;
                 }
 
+                init_delay = 1;
                 /* After writing this register, HW needs time for CRB */
                 /* to quiet down (else crb_window returns 0xffffffff) */
                 if (off == NETXEN_ROMUSB_GLB_SW_RESET) {
-                        init_delay = 1;
+                        init_delay = 1000;
                         if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
                                 /* hold xdma in reset also */
                                 buf[i].data = NETXEN_NIC_XDMA_RESET;
+                                buf[i].data = 0x8000ff;
                         }
                 }
 
                 adapter->hw_write_wx(adapter, off, &buf[i].data, 4);
 
-                if (init_delay == 1) {
-                        msleep(1000);
-                        init_delay = 0;
-                }
-                msleep(1);
+                msleep(init_delay);
         }
         kfree(buf);
 
@@ -1277,7 +1283,7 @@ static void netxen_process_rcv(struct netxen_adapter *adapter, int ctxid,
 
                 dev_kfree_skb_any(skb);
                 for (i = 0; i < nr_frags; i++) {
-                        index = frag_desc->frag_handles[i];
+                        index = le16_to_cpu(frag_desc->frag_handles[i]);
                         skb = netxen_process_rxbuf(adapter,
                                         rds_ring, index, cksum);
                         if (skb)
@@ -1428,7 +1434,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
         struct rcv_desc *pdesc;
         struct netxen_rx_buffer *buffer;
         int count = 0;
-        int index = 0;
         netxen_ctx_msg msg = 0;
         dma_addr_t dma;
         struct list_head *head;
@@ -1436,7 +1441,6 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
         rds_ring = &recv_ctx->rds_rings[ringid];
 
         producer = rds_ring->producer;
-        index = rds_ring->begin_alloc;
         head = &rds_ring->free_list;
 
         /* We can start writing rx descriptors into the phantom memory. */
@@ -1444,39 +1448,37 @@ void netxen_post_rx_buffers(struct netxen_adapter *adapter, u32 ctx, u32 ringid)
 
                 skb = dev_alloc_skb(rds_ring->skb_size);
                 if (unlikely(!skb)) {
-                        rds_ring->begin_alloc = index;
                         break;
                 }
 
+                if (!adapter->ahw.cut_through)
+                        skb_reserve(skb, 2);
+
+                dma = pci_map_single(pdev, skb->data,
+                                rds_ring->dma_size, PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(pdev, dma)) {
+                        dev_kfree_skb_any(skb);
+                        break;
+                }
+
+                count++;
                 buffer = list_entry(head->next, struct netxen_rx_buffer, list);
                 list_del(&buffer->list);
 
-                count++;        /* now there should be no failure */
-                pdesc = &rds_ring->desc_head[producer];
-
-                if (!adapter->ahw.cut_through)
-                        skb_reserve(skb, 2);
-                /* This will be setup when we receive the
-                 * buffer after it has been filled  FSL  TBD TBD
-                 * skb->dev = netdev;
-                 */
-                dma = pci_map_single(pdev, skb->data, rds_ring->dma_size,
-                                     PCI_DMA_FROMDEVICE);
-                pdesc->addr_buffer = cpu_to_le64(dma);
                 buffer->skb = skb;
                 buffer->state = NETXEN_BUFFER_BUSY;
                 buffer->dma = dma;
+
                 /* make a rcv descriptor  */
+                pdesc = &rds_ring->desc_head[producer];
+                pdesc->addr_buffer = cpu_to_le64(dma);
                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
                 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
-                DPRINTK(INFO, "done writing descripter\n");
-                producer =
-                    get_next_index(producer, rds_ring->max_rx_desc_count);
-                index = get_next_index(index, rds_ring->max_rx_desc_count);
+
+                producer = get_next_index(producer, rds_ring->max_rx_desc_count);
         }
         /* if we did allocate buffers, then write the count to Phantom */
         if (count) {
-                rds_ring->begin_alloc = index;
                 rds_ring->producer = producer;
                         /* Window = 1 */
                 adapter->pci_write_normalize(adapter,
@@ -1515,49 +1517,50 @@ static void netxen_post_rx_buffers_nodb(struct netxen_adapter *adapter,
         struct rcv_desc *pdesc;
         struct netxen_rx_buffer *buffer;
         int count = 0;
-        int index = 0;
         struct list_head *head;
+        dma_addr_t dma;
 
         rds_ring = &recv_ctx->rds_rings[ringid];
 
         producer = rds_ring->producer;
-        index = rds_ring->begin_alloc;
         head = &rds_ring->free_list;
         /* We can start writing rx descriptors into the phantom memory. */
         while (!list_empty(head)) {
 
                 skb = dev_alloc_skb(rds_ring->skb_size);
                 if (unlikely(!skb)) {
-                        rds_ring->begin_alloc = index;
                         break;
                 }
 
+                if (!adapter->ahw.cut_through)
+                        skb_reserve(skb, 2);
+
+                dma = pci_map_single(pdev, skb->data,
+                                rds_ring->dma_size, PCI_DMA_FROMDEVICE);
+                if (pci_dma_mapping_error(pdev, dma)) {
+                        dev_kfree_skb_any(skb);
+                        break;
+                }
+
+                count++;
                 buffer = list_entry(head->next, struct netxen_rx_buffer, list);
                 list_del(&buffer->list);
 
-                count++;        /* now there should be no failure */
-                pdesc = &rds_ring->desc_head[producer];
-                if (!adapter->ahw.cut_through)
-                        skb_reserve(skb, 2);
                 buffer->skb = skb;
                 buffer->state = NETXEN_BUFFER_BUSY;
-                buffer->dma = pci_map_single(pdev, skb->data,
-                                             rds_ring->dma_size,
-                                             PCI_DMA_FROMDEVICE);
+                buffer->dma = dma;
 
                 /* make a rcv descriptor  */
+                pdesc = &rds_ring->desc_head[producer];
                 pdesc->reference_handle = cpu_to_le16(buffer->ref_handle);
                 pdesc->buffer_length = cpu_to_le32(rds_ring->dma_size);
                 pdesc->addr_buffer = cpu_to_le64(buffer->dma);
-                producer =
-                    get_next_index(producer, rds_ring->max_rx_desc_count);
-                index = get_next_index(index, rds_ring->max_rx_desc_count);
-                buffer = &rds_ring->rx_buf_arr[index];
+
+                producer = get_next_index(producer, rds_ring->max_rx_desc_count);
         }
 
         /* if we did allocate buffers, then write the count to Phantom */
         if (count) {
-                rds_ring->begin_alloc = index;
                 rds_ring->producer = producer;
                         /* Window = 1 */
                 adapter->pci_write_normalize(adapter,
diff --git a/drivers/net/netxen/netxen_nic_main.c b/drivers/net/netxen/netxen_nic_main.c
index ba01524b5531..645d384fe87e 100644
--- a/drivers/net/netxen/netxen_nic_main.c
+++ b/drivers/net/netxen/netxen_nic_main.c
@@ -39,7 +39,9 @@
 #include "netxen_nic_phan_reg.h"
 
 #include <linux/dma-mapping.h>
+#include <linux/if_vlan.h>
 #include <net/ip.h>
+#include <linux/ipv6.h>
 
 MODULE_DESCRIPTION("NetXen Multi port (1/10) Gigabit Network Driver");
 MODULE_LICENSE("GPL");
@@ -242,7 +244,7 @@ static void netxen_check_options(struct netxen_adapter *adapter)
         case NETXEN_BRDTYPE_P3_4_GB:
         case NETXEN_BRDTYPE_P3_4_GB_MM:
                 adapter->msix_supported = !!use_msi_x;
-                adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_10G;
+                adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
                 break;
 
         case NETXEN_BRDTYPE_P2_SB35_4G:
@@ -251,6 +253,14 @@ static void netxen_check_options(struct netxen_adapter *adapter)
                 adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
                 break;
 
+        case NETXEN_BRDTYPE_P3_10G_TP:
+                adapter->msix_supported = !!use_msi_x;
+                if (adapter->ahw.board_type == NETXEN_NIC_XGBE)
+                        adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_10G;
+                else
+                        adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
+                break;
+
         default:
                 adapter->msix_supported = 0;
                 adapter->max_rx_desc_count = MAX_RCV_DESCRIPTORS_1G;
@@ -271,10 +281,15 @@ static void netxen_check_options(struct netxen_adapter *adapter)
 static int
 netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
 {
-        int ret = 0;
+        u32 val, timeout;
 
         if (first_boot == 0x55555555) {
                 /* This is the first boot after power up */
+                adapter->pci_write_normalize(adapter,
+                        NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
+
+                if (!NX_IS_REVISION_P2(adapter->ahw.revision_id))
+                        return 0;
 
                 /* PCI bus master workaround */
                 adapter->hw_read_wx(adapter,
@@ -294,18 +309,26 @@ netxen_check_hw_init(struct netxen_adapter *adapter, int first_boot)
                         /* clear the register for future unloads/loads */
                         adapter->pci_write_normalize(adapter,
                                         NETXEN_CAM_RAM(0x1fc), 0);
-                        ret = -1;
+                        return -EIO;
                 }
 
-                if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
-                        /* Start P2 boot loader */
-                        adapter->pci_write_normalize(adapter,
-                                NETXEN_CAM_RAM(0x1fc), NETXEN_BDINFO_MAGIC);
-                        adapter->pci_write_normalize(adapter,
-                                        NETXEN_ROMUSB_GLB_PEGTUNE_DONE, 1);
-                }
+                /* Start P2 boot loader */
+                val = adapter->pci_read_normalize(adapter,
+                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE);
+                adapter->pci_write_normalize(adapter,
+                                NETXEN_ROMUSB_GLB_PEGTUNE_DONE, val | 0x1);
+                timeout = 0;
+                do {
+                        msleep(1);
+                        val = adapter->pci_read_normalize(adapter,
+                                        NETXEN_CAM_RAM(0x1fc));
+
+                        if (++timeout > 5000)
+                                return -EIO;
+
+                } while (val == NETXEN_BDINFO_MAGIC);
         }
-        return ret;
+        return 0;
 }
 
 static void netxen_set_port_mode(struct netxen_adapter *adapter)
@@ -712,17 +735,18 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         SET_ETHTOOL_OPS(netdev, &netxen_nic_ethtool_ops);
 
-        /* ScatterGather support */
-        netdev->features = NETIF_F_SG;
-        netdev->features |= NETIF_F_IP_CSUM;
-        netdev->features |= NETIF_F_TSO;
+        netdev->features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
+        netdev->vlan_features |= (NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);
+
         if (NX_IS_REVISION_P3(revision_id)) {
-                netdev->features |= NETIF_F_IPV6_CSUM;
-                netdev->features |= NETIF_F_TSO6;
+                netdev->features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
+                netdev->vlan_features |= (NETIF_F_IPV6_CSUM | NETIF_F_TSO6);
         }
 
-        if (adapter->pci_using_dac)
+        if (adapter->pci_using_dac) {
                 netdev->features |= NETIF_F_HIGHDMA;
+                netdev->vlan_features |= NETIF_F_HIGHDMA;
+        }
 
         /*
          * Set the CRB window to invalid. If any register in window 0 is
@@ -784,8 +808,8 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                                                 CRB_CMDPEG_STATE, 0);
                         netxen_pinit_from_rom(adapter, 0);
                         msleep(1);
-                        netxen_load_firmware(adapter);
                 }
+                netxen_load_firmware(adapter);
 
                 if (NX_IS_REVISION_P3(revision_id))
                         netxen_pcie_strap_init(adapter);
@@ -801,13 +825,6 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
                 }
 
-                if ((first_boot == 0x55555555) &&
-                        (NX_IS_REVISION_P2(revision_id))) {
-                        /* Unlock the HW, prompting the boot sequence */
-                        adapter->pci_write_normalize(adapter,
-                                        NETXEN_ROMUSB_GLB_PEGTUNE_DONE, 1);
-                }
-
                 err = netxen_initialize_adapter_offload(adapter);
                 if (err)
                         goto err_out_iounmap;
@@ -821,7 +838,9 @@ netxen_nic_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                 adapter->pci_write_normalize(adapter, CRB_DRIVER_VERSION, i);
 
                 /* Handshake with the card before we register the devices. */
-                netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
+                err = netxen_phantom_init(adapter, NETXEN_NIC_PEG_TUNE);
+                if (err)
+                        goto err_out_free_offload;
 
         }       /* first_driver */
 
@@ -925,6 +944,7 @@ err_out_disable_msi:
         if (adapter->flags & NETXEN_NIC_MSI_ENABLED)
                 pci_disable_msi(pdev);
 
+err_out_free_offload:
         if (first_driver)
                 netxen_free_adapter_offload(adapter);
 
@@ -968,6 +988,9 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
                 netxen_free_hw_resources(adapter);
                 netxen_release_rx_buffers(adapter);
                 netxen_free_sw_resources(adapter);
+
+                if (NX_IS_REVISION_P3(adapter->ahw.revision_id))
+                        netxen_p3_free_mac_list(adapter);
         }
 
         if (adapter->portnum == 0)
@@ -983,8 +1006,10 @@ static void __devexit netxen_nic_remove(struct pci_dev *pdev)
 
         iounmap(adapter->ahw.db_base);
         iounmap(adapter->ahw.pci_base0);
-        iounmap(adapter->ahw.pci_base1);
-        iounmap(adapter->ahw.pci_base2);
+        if (adapter->ahw.pci_base1 != NULL)
+                iounmap(adapter->ahw.pci_base1);
+        if (adapter->ahw.pci_base2 != NULL)
+                iounmap(adapter->ahw.pci_base2);
 
         pci_release_regions(pdev);
         pci_disable_device(pdev);
@@ -1137,29 +1162,72 @@ static int netxen_nic_close(struct net_device *netdev)
         return 0;
 }
 
-void netxen_tso_check(struct netxen_adapter *adapter,
+static bool netxen_tso_check(struct net_device *netdev,
                       struct cmd_desc_type0 *desc, struct sk_buff *skb)
 {
-        if (desc->mss) {
-                desc->total_hdr_length = (sizeof(struct ethhdr) +
-                                          ip_hdrlen(skb) + tcp_hdrlen(skb));
+        bool tso = false;
+        u8 opcode = TX_ETHER_PKT;
+        __be16 protocol = skb->protocol;
+        u16 flags = 0;
+
+        if (protocol == __constant_htons(ETH_P_8021Q)) {
+                struct vlan_ethhdr *vh = (struct vlan_ethhdr *)skb->data;
+                protocol = vh->h_vlan_encapsulated_proto;
+                flags = FLAGS_VLAN_TAGGED;
+        }
 
-                if ((NX_IS_REVISION_P3(adapter->ahw.revision_id)) &&
-                                (skb->protocol == htons(ETH_P_IPV6)))
-                        netxen_set_cmd_desc_opcode(desc, TX_TCP_LSO6);
-                else
-                        netxen_set_cmd_desc_opcode(desc, TX_TCP_LSO);
+        if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
+                        skb_shinfo(skb)->gso_size > 0) {
+
+                desc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
+                desc->total_hdr_length =
+                        skb_transport_offset(skb) + tcp_hdrlen(skb);
+
+                opcode = (protocol == __constant_htons(ETH_P_IPV6)) ?
+                                TX_TCP_LSO6 : TX_TCP_LSO;
+                tso = true;
 
         } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
-                if (ip_hdr(skb)->protocol == IPPROTO_TCP)
-                        netxen_set_cmd_desc_opcode(desc, TX_TCP_PKT);
-                else if (ip_hdr(skb)->protocol == IPPROTO_UDP)
-                        netxen_set_cmd_desc_opcode(desc, TX_UDP_PKT);
-                else
-                        return;
+                u8 l4proto;
+
+                if (protocol == __constant_htons(ETH_P_IP)) {
+                        l4proto = ip_hdr(skb)->protocol;
+
+                        if (l4proto == IPPROTO_TCP)
+                                opcode = TX_TCP_PKT;
+                        else if(l4proto == IPPROTO_UDP)
+                                opcode = TX_UDP_PKT;
+                } else if (protocol == __constant_htons(ETH_P_IPV6)) {
+                        l4proto = ipv6_hdr(skb)->nexthdr;
+
+                        if (l4proto == IPPROTO_TCP)
+                                opcode = TX_TCPV6_PKT;
+                        else if(l4proto == IPPROTO_UDP)
+                                opcode = TX_UDPV6_PKT;
+                }
         }
         desc->tcp_hdr_offset = skb_transport_offset(skb);
         desc->ip_hdr_offset = skb_network_offset(skb);
+        netxen_set_tx_flags_opcode(desc, flags, opcode);
+        return tso;
+}
+
+static void
+netxen_clean_tx_dma_mapping(struct pci_dev *pdev,
+                struct netxen_cmd_buffer *pbuf, int last)
+{
+        int k;
+        struct netxen_skb_frag *buffrag;
+
+        buffrag = &pbuf->frag_array[0];
+        pci_unmap_single(pdev, buffrag->dma,
+                        buffrag->length, PCI_DMA_TODEVICE);
+
+        for (k = 1; k < last; k++) {
+                buffrag = &pbuf->frag_array[k];
+                pci_unmap_page(pdev, buffrag->dma,
+                        buffrag->length, PCI_DMA_TODEVICE);
+        }
 }
 
 static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
@@ -1167,33 +1235,22 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         struct netxen_adapter *adapter = netdev_priv(netdev);
         struct netxen_hardware_context *hw = &adapter->ahw;
         unsigned int first_seg_len = skb->len - skb->data_len;
+        struct netxen_cmd_buffer *pbuf;
         struct netxen_skb_frag *buffrag;
-        unsigned int i;
+        struct cmd_desc_type0 *hwdesc;
+        struct pci_dev *pdev = adapter->pdev;
+        dma_addr_t temp_dma;
+        int i, k;
 
         u32 producer, consumer;
-        u32 saved_producer = 0;
-        struct cmd_desc_type0 *hwdesc;
-        int k;
-        struct netxen_cmd_buffer *pbuf = NULL;
-        int frag_count;
-        int no_of_desc;
+        int frag_count, no_of_desc;
         u32 num_txd = adapter->max_tx_desc_count;
+        bool is_tso = false;
 
         frag_count = skb_shinfo(skb)->nr_frags + 1;
 
         /* There 4 fragments per descriptor */
         no_of_desc = (frag_count + 3) >> 2;
-        if (netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) {
-                if (skb_shinfo(skb)->gso_size > 0) {
-
-                        no_of_desc++;
-                        if ((ip_hdrlen(skb) + tcp_hdrlen(skb) +
-                             sizeof(struct ethhdr)) >
-                            (sizeof(struct cmd_desc_type0) - 2)) {
-                                no_of_desc++;
-                        }
-                }
-        }
 
         producer = adapter->cmd_producer;
         smp_mb();
@@ -1205,34 +1262,26 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         }
 
         /* Copy the descriptors into the hardware    */
-        saved_producer = producer;
         hwdesc = &hw->cmd_desc_head[producer];
         memset(hwdesc, 0, sizeof(struct cmd_desc_type0));
         /* Take skb->data itself */
         pbuf = &adapter->cmd_buf_arr[producer];
-        if ((netdev->features & (NETIF_F_TSO | NETIF_F_TSO6)) &&
-                        skb_shinfo(skb)->gso_size > 0) {
-                pbuf->mss = skb_shinfo(skb)->gso_size;
-                hwdesc->mss = cpu_to_le16(skb_shinfo(skb)->gso_size);
-        } else {
-                pbuf->mss = 0;
-                hwdesc->mss = 0;
-        }
-        pbuf->total_length = skb->len;
+
+        is_tso = netxen_tso_check(netdev, hwdesc, skb);
+
         pbuf->skb = skb;
-        pbuf->cmd = TX_ETHER_PKT;
         pbuf->frag_count = frag_count;
-        pbuf->port = adapter->portnum;
         buffrag = &pbuf->frag_array[0];
-        buffrag->dma = pci_map_single(adapter->pdev, skb->data, first_seg_len,
+        temp_dma = pci_map_single(pdev, skb->data, first_seg_len,
                                       PCI_DMA_TODEVICE);
+        if (pci_dma_mapping_error(pdev, temp_dma))
+                goto drop_packet;
+
+        buffrag->dma = temp_dma;
         buffrag->length = first_seg_len;
-        netxen_set_cmd_desc_totallength(hwdesc, skb->len);
-        netxen_set_cmd_desc_num_of_buff(hwdesc, frag_count);
-        netxen_set_cmd_desc_opcode(hwdesc, TX_ETHER_PKT);
+        netxen_set_tx_frags_len(hwdesc, frag_count, skb->len);
+        netxen_set_tx_port(hwdesc, adapter->portnum);
 
-        netxen_set_cmd_desc_port(hwdesc, adapter->portnum);
-        netxen_set_cmd_desc_ctxid(hwdesc, adapter->portnum);
         hwdesc->buffer1_length = cpu_to_le16(first_seg_len);
         hwdesc->addr_buffer1 = cpu_to_le64(buffrag->dma);
 
@@ -1240,7 +1289,6 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 struct skb_frag_struct *frag;
                 int len, temp_len;
                 unsigned long offset;
-                dma_addr_t temp_dma;
 
                 /* move to next desc. if there is a need */
                 if ((i & 0x3) == 0) {
@@ -1256,8 +1304,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                 offset = frag->page_offset;
 
                 temp_len = len;
-                temp_dma = pci_map_page(adapter->pdev, frag->page, offset,
+                temp_dma = pci_map_page(pdev, frag->page, offset,
                                         len, PCI_DMA_TODEVICE);
+                if (pci_dma_mapping_error(pdev, temp_dma)) {
+                        netxen_clean_tx_dma_mapping(pdev, pbuf, i);
+                        goto drop_packet;
+                }
 
                 buffrag++;
                 buffrag->dma = temp_dma;
@@ -1285,16 +1337,12 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         }
         producer = get_next_index(producer, num_txd);
 
-        /* might change opcode to TX_TCP_LSO */
-        netxen_tso_check(adapter, &hw->cmd_desc_head[saved_producer], skb);
-
         /* For LSO, we need to copy the MAC/IP/TCP headers into
          * the descriptor ring
          */
-        if (netxen_get_cmd_desc_opcode(&hw->cmd_desc_head[saved_producer])
-            == TX_TCP_LSO) {
+        if (is_tso) {
                 int hdr_len, first_hdr_len, more_hdr;
-                hdr_len = hw->cmd_desc_head[saved_producer].total_hdr_length;
+                hdr_len = skb_transport_offset(skb) + tcp_hdrlen(skb);
                 if (hdr_len > (sizeof(struct cmd_desc_type0) - 2)) {
                         first_hdr_len = sizeof(struct cmd_desc_type0) - 2;
                         more_hdr = 1;
@@ -1336,6 +1384,11 @@ static int netxen_nic_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
         netdev->trans_start = jiffies;
 
         return NETDEV_TX_OK;
+
+drop_packet:
+        adapter->stats.txdropped++;
+        dev_kfree_skb_any(skb);
+        return NETDEV_TX_OK;
 }
 
 static int netxen_nic_check_temp(struct netxen_adapter *adapter)
@@ -1407,6 +1460,8 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                         netif_carrier_off(netdev);
                         netif_stop_queue(netdev);
                 }
+
+                netxen_nic_set_link_parameters(adapter);
         } else if (!adapter->ahw.linkup && linkup) {
                 printk(KERN_INFO "%s: %s NIC Link is up\n",
                        netxen_nic_driver_name, netdev->name);
@@ -1415,6 +1470,8 @@ static void netxen_nic_handle_phy_intr(struct netxen_adapter *adapter)
                         netif_carrier_on(netdev);
                         netif_wake_queue(netdev);
                 }
+
+                netxen_nic_set_link_parameters(adapter);
         }
 }
 
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 11adf6ed4628..811a637695ca 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -296,9 +296,8 @@ static int mdio_bus_suspend(struct device * dev, pm_message_t state)
         struct phy_driver *phydrv = to_phy_driver(drv);
         struct phy_device *phydev = to_phy_device(dev);
 
-        if ((!device_may_wakeup(phydev->dev.parent)) &&
-                (phydrv && phydrv->suspend))
-                        ret = phydrv->suspend(phydev);
+        if (drv && phydrv->suspend && !device_may_wakeup(phydev->dev.parent))
+                ret = phydrv->suspend(phydev);
 
         return ret;
 }
@@ -310,8 +309,7 @@ static int mdio_bus_resume(struct device * dev)
         struct phy_driver *phydrv = to_phy_driver(drv);
         struct phy_device *phydev = to_phy_device(dev);
 
-        if ((!device_may_wakeup(phydev->dev.parent)) &&
-                (phydrv && phydrv->resume))
+        if (drv && phydrv->resume && !device_may_wakeup(phydev->dev.parent))
                 ret = phydrv->resume(phydev);
 
         return ret;
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index e35460165bf7..0a06e4fd37d9 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -231,15 +231,6 @@ struct phy_device * get_phy_device(struct mii_bus *bus, int addr)
         if ((phy_id & 0x1fffffff) == 0x1fffffff)
                 return NULL;
 
-        /*
-         * Broken hardware is sometimes missing the pull-up resistor on the
-         * MDIO line, which results in reads to non-existent devices returning
-         * 0 rather than 0xffff. Catch this here and treat 0 as a non-existent
-         * device as well.
-         */
-        if (phy_id == 0)
-                return NULL;
-
         dev = phy_device_create(bus, addr, phy_id);
 
         return dev;
diff --git a/drivers/net/phy/smsc.c b/drivers/net/phy/smsc.c
index c05d38d46350..1387187543e4 100644
--- a/drivers/net/phy/smsc.c
+++ b/drivers/net/phy/smsc.c
@@ -81,6 +81,9 @@ static struct phy_driver lan83c185_driver = {
         .ack_interrupt  = smsc_phy_ack_interrupt,
         .config_intr    = smsc_phy_config_intr,
 
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
+
         .driver         = { .owner = THIS_MODULE, }
 };
 
@@ -102,6 +105,9 @@ static struct phy_driver lan8187_driver = {
         .ack_interrupt  = smsc_phy_ack_interrupt,
         .config_intr    = smsc_phy_config_intr,
 
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
+
         .driver         = { .owner = THIS_MODULE, }
 };
 
@@ -123,6 +129,9 @@ static struct phy_driver lan8700_driver = {
         .ack_interrupt  = smsc_phy_ack_interrupt,
         .config_intr    = smsc_phy_config_intr,
 
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
+
         .driver         = { .owner = THIS_MODULE, }
 };
 
@@ -144,6 +153,9 @@ static struct phy_driver lan911x_int_driver = {
         .ack_interrupt  = smsc_phy_ack_interrupt,
         .config_intr    = smsc_phy_config_intr,
 
+        .suspend        = genphy_suspend,
+        .resume         = genphy_resume,
+
         .driver         = { .owner = THIS_MODULE, }
 };
 
diff --git a/drivers/net/ppp_generic.c b/drivers/net/ppp_generic.c
index 06b448285eb5..7b2728b8f1b7 100644
--- a/drivers/net/ppp_generic.c
+++ b/drivers/net/ppp_generic.c
@@ -250,6 +250,7 @@ static int ppp_connect_channel(struct channel *pch, int unit);
 static int ppp_disconnect_channel(struct channel *pch);
 static void ppp_destroy_channel(struct channel *pch);
 static int unit_get(struct idr *p, void *ptr);
+static int unit_set(struct idr *p, void *ptr, int n);
 static void unit_put(struct idr *p, int n);
 static void *unit_find(struct idr *p, int n);
 
@@ -2432,11 +2433,18 @@ ppp_create_interface(int unit, int *retp)
         } else {
                 if (unit_find(&ppp_units_idr, unit))
                         goto out2; /* unit already exists */
-                else {
-                        /* darn, someone is cheating us? */
-                        *retp = -EINVAL;
+                /*
+                 * if caller need a specified unit number
+                 * lets try to satisfy him, otherwise --
+                 * he should better ask us for new unit number
+                 *
+                 * NOTE: yes I know that returning EEXIST it's not
+                 * fair but at least pppd will ask us to allocate
+                 * new unit in this case so user is happy :)
+                 */
+                unit = unit_set(&ppp_units_idr, ppp, unit);
+                if (unit < 0)
                         goto out2;
-                }
         }
 
         /* Initialize the new ppp unit */
@@ -2677,14 +2685,37 @@ static void __exit ppp_cleanup(void)
  * by holding all_ppp_mutex
  */
 
+/* associate pointer with specified number */
+static int unit_set(struct idr *p, void *ptr, int n)
+{
+        int unit, err;
+
+again:
+        if (!idr_pre_get(p, GFP_KERNEL)) {
+                printk(KERN_ERR "PPP: No free memory for idr\n");
+                return -ENOMEM;
+        }
+
+        err = idr_get_new_above(p, ptr, n, &unit);
+        if (err == -EAGAIN)
+                goto again;
+
+        if (unit != n) {
+                idr_remove(p, unit);
+                return -EINVAL;
+        }
+
+        return unit;
+}
+
 /* get new free unit number and associate pointer with it */
 static int unit_get(struct idr *p, void *ptr)
 {
         int unit, err;
 
 again:
-        if (idr_pre_get(p, GFP_KERNEL) == 0) {
-                printk(KERN_ERR "Out of memory expanding drawable idr\n");
+        if (!idr_pre_get(p, GFP_KERNEL)) {
+                printk(KERN_ERR "PPP: No free memory for idr\n");
                 return -ENOMEM;
         }
 
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 6cbefcae9ac2..be4465bc0a69 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -509,10 +509,10 @@ static int __devinit sis900_probe(struct pci_dev *pci_dev,
         else
                 ret = sis900_get_mac_addr(pci_dev, net_dev);
 
-        if (ret == 0) {
-                printk(KERN_WARNING "%s: Cannot read MAC address.\n", dev_name);
-                ret = -ENODEV;
-                goto err_unmap_rx;
+        if (!ret || !is_valid_ether_addr(net_dev->dev_addr)) {
+                random_ether_addr(net_dev->dev_addr);
+                printk(KERN_WARNING "%s: Unreadable or invalid MAC address,"
+                                "using random generated one\n", dev_name);
         }
 
         /* 630ET : set the mii access mode as software-mode */
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 5e2dbaee125b..8b3f84685387 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -7535,11 +7535,58 @@ static int tg3_test_msi(struct tg3 *tp)
         return err;
 }
 
+static int tg3_request_firmware(struct tg3 *tp)
+{
+        const __be32 *fw_data;
+
+        if (request_firmware(&tp->fw, tp->fw_needed, &tp->pdev->dev)) {
+                printk(KERN_ERR "%s: Failed to load firmware \"%s\"\n",
+                       tp->dev->name, tp->fw_needed);
+                return -ENOENT;
+        }
+
+        fw_data = (void *)tp->fw->data;
+
+        /* Firmware blob starts with version numbers, followed by
+         * start address and _full_ length including BSS sections
+         * (which must be longer than the actual data, of course
+         */
+
+        tp->fw_len = be32_to_cpu(fw_data[2]);   /* includes bss */
+        if (tp->fw_len < (tp->fw->size - 12)) {
+                printk(KERN_ERR "%s: bogus length %d in \"%s\"\n",
+                       tp->dev->name, tp->fw_len, tp->fw_needed);
+                release_firmware(tp->fw);
+                tp->fw = NULL;
+                return -EINVAL;
+        }
+
+        /* We no longer need firmware; we have it. */
+        tp->fw_needed = NULL;
+        return 0;
+}
+
 static int tg3_open(struct net_device *dev)
 {
         struct tg3 *tp = netdev_priv(dev);
         int err;
 
+        if (tp->fw_needed) {
+                err = tg3_request_firmware(tp);
+                if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0) {
+                        if (err)
+                                return err;
+                } else if (err) {
+                        printk(KERN_WARNING "%s: TSO capability disabled.\n",
+                               tp->dev->name);
+                        tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
+                } else if (!(tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE)) {
+                        printk(KERN_NOTICE "%s: TSO capability restored.\n",
+                               tp->dev->name);
+                        tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
+                }
+        }
+
         netif_carrier_off(tp->dev);
 
         err = tg3_set_power_state(tp, PCI_D0);
@@ -12934,7 +12981,6 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         struct net_device *dev;
         struct tg3 *tp;
         int err, pm_cap;
-        const char *fw_name = NULL;
         char str[40];
         u64 dma_mask, persist_dma_mask;
 
@@ -13091,7 +13137,7 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
         tg3_init_bufmgr_config(tp);
 
         if (tp->pci_chip_rev_id == CHIPREV_ID_5701_A0)
-                fw_name = FIRMWARE_TG3;
+                tp->fw_needed = FIRMWARE_TG3;
 
         if (tp->tg3_flags2 & TG3_FLG2_HW_TSO) {
                 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE;
@@ -13104,37 +13150,10 @@ static int __devinit tg3_init_one(struct pci_dev *pdev,
                 tp->tg3_flags2 &= ~TG3_FLG2_TSO_CAPABLE;
         } else {
                 tp->tg3_flags2 |= TG3_FLG2_TSO_CAPABLE | TG3_FLG2_TSO_BUG;
-        }
-        if (tp->tg3_flags2 & TG3_FLG2_TSO_CAPABLE) {
                 if (GET_ASIC_REV(tp->pci_chip_rev_id) == ASIC_REV_5705)
-                        fw_name = FIRMWARE_TG3TSO5;
+                        tp->fw_needed = FIRMWARE_TG3TSO5;
                 else
-                        fw_name = FIRMWARE_TG3TSO;
-        }
-
-        if (fw_name) {
-                const __be32 *fw_data;
-
-                err = request_firmware(&tp->fw, fw_name, &tp->pdev->dev);
-                if (err) {
-                        printk(KERN_ERR "tg3: Failed to load firmware \"%s\"\n",
-                               fw_name);
-                        goto err_out_iounmap;
-                }
-
-                fw_data = (void *)tp->fw->data;
-
-                /* Firmware blob starts with version numbers, followed by
-                   start address and _full_ length including BSS sections
-                   (which must be longer than the actual data, of course */
-
-                tp->fw_len = be32_to_cpu(fw_data[2]);   /* includes bss */
-                if (tp->fw_len < (tp->fw->size - 12)) {
-                        printk(KERN_ERR "tg3: bogus length %d in \"%s\"\n",
-                               tp->fw_len, fw_name);
-                        err = -EINVAL;
-                        goto err_out_fw;
-                }
+                        tp->fw_needed = FIRMWARE_TG3TSO;
         }
 
         /* TSO is on by default on chips that support hardware TSO.
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index ae5da603c6af..508def3e077f 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2764,6 +2764,7 @@ struct tg3 {
         struct ethtool_coalesce         coal;
 
         /* firmware info */
+        const char                      *fw_needed;
         const struct firmware           *fw;
         u32                             fw_len; /* includes BSS */
 };
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index c4918b86ed19..0d0fa91c0251 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -1297,6 +1297,7 @@ static int hso_serial_open(struct tty_struct *tty, struct file *filp)
         /* setup */
         spin_lock_irq(&serial->serial_lock);
         tty->driver_data = serial;
+        tty_kref_put(serial->tty);
         serial->tty = tty_kref_get(tty);
         spin_unlock_irq(&serial->serial_lock);
 
@@ -1792,8 +1793,8 @@ static int mux_device_request(struct hso_serial *serial, u8 type, u16 port,
 
         /* initialize */
         ctrl_req->wValue = 0;
-        ctrl_req->wIndex = hso_port_to_mux(port);
-        ctrl_req->wLength = size;
+        ctrl_req->wIndex = cpu_to_le16(hso_port_to_mux(port));
+        ctrl_req->wLength = cpu_to_le16(size);
 
         if (type == USB_CDC_GET_ENCAPSULATED_RESPONSE) {
                 /* Reading command */
@@ -2043,9 +2044,8 @@ static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
                 return -2;
         }
 
-        spin_lock(&serial->serial_lock);
+        /* All callers to put_rxbuf_data hold serial_lock */
         tty = tty_kref_get(serial->tty);
-        spin_unlock(&serial->serial_lock);
 
         /* Push data to tty */
         if (tty) {
@@ -2053,8 +2053,10 @@ static int put_rxbuf_data(struct urb *urb, struct hso_serial *serial)
                         serial->curr_rx_urb_offset;
                 D1("data to push to tty");
                 while (write_length_remaining) {
-                        if (test_bit(TTY_THROTTLED, &tty->flags))
+                        if (test_bit(TTY_THROTTLED, &tty->flags)) {
+                                tty_kref_put(tty);
                                 return -1;
+                        }
                         curr_write_len =  tty_insert_flip_string
                                 (tty, urb->transfer_buffer +
                                  serial->curr_rx_urb_offset,
diff --git a/drivers/net/usb/mcs7830.c b/drivers/net/usb/mcs7830.c
index 5385d66b306e..ced8f36ebd01 100644
--- a/drivers/net/usb/mcs7830.c
+++ b/drivers/net/usb/mcs7830.c
@@ -94,10 +94,18 @@ static int mcs7830_get_reg(struct usbnet *dev, u16 index, u16 size, void *data)
 {
         struct usb_device *xdev = dev->udev;
         int ret;
+        void *buffer;
+
+        buffer = kmalloc(size, GFP_NOIO);
+        if (buffer == NULL)
+                return -ENOMEM;
 
         ret = usb_control_msg(xdev, usb_rcvctrlpipe(xdev, 0), MCS7830_RD_BREQ,
-                              MCS7830_RD_BMREQ, 0x0000, index, data,
+                              MCS7830_RD_BMREQ, 0x0000, index, buffer,
                               size, MCS7830_CTRL_TIMEOUT);
+        memcpy(data, buffer, size);
+        kfree(buffer);
+
         return ret;
 }
 
@@ -105,10 +113,18 @@ static int mcs7830_set_reg(struct usbnet *dev, u16 index, u16 size, void *data)
 {
         struct usb_device *xdev = dev->udev;
         int ret;
+        void *buffer;
+
+        buffer = kmalloc(size, GFP_NOIO);
+        if (buffer == NULL)
+                return -ENOMEM;
+
+        memcpy(buffer, data, size);
 
         ret = usb_control_msg(xdev, usb_sndctrlpipe(xdev, 0), MCS7830_WR_BREQ,
-                              MCS7830_WR_BMREQ, 0x0000, index, data,
+                              MCS7830_WR_BMREQ, 0x0000, index, buffer,
                               size, MCS7830_CTRL_TIMEOUT);
+        kfree(buffer);
         return ret;
 }
 
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index a75f91dc3153..c5691fdb7079 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -1302,7 +1302,7 @@ static void velocity_free_rd_ring(struct velocity_info *vptr)
 static int velocity_init_td_ring(struct velocity_info *vptr)
 {
         dma_addr_t curr;
-        unsigned int j;
+        int j;
 
         /* Init the TD ring entries */
         for (j = 0; j < vptr->tx.numq; j++) {
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 43f6523c40be..63ef2a8905fb 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -24,6 +24,7 @@
 #include <linux/virtio.h>
 #include <linux/virtio_net.h>
 #include <linux/scatterlist.h>
+#include <linux/if_vlan.h>
 
 static int napi_weight = 128;
 module_param(napi_weight, int, 0444);
@@ -33,7 +34,7 @@ module_param(csum, bool, 0444);
 module_param(gso, bool, 0444);
 
 /* FIXME: MTU in config. */
-#define MAX_PACKET_LEN (ETH_HLEN+ETH_DATA_LEN)
+#define MAX_PACKET_LEN (ETH_HLEN + VLAN_HLEN + ETH_DATA_LEN)
 #define GOOD_COPY_LEN   128
 
 struct virtnet_info
diff --git a/drivers/net/wan/ixp4xx_hss.c b/drivers/net/wan/ixp4xx_hss.c
index 2dc241689d37..0dbd85b0162d 100644
--- a/drivers/net/wan/ixp4xx_hss.c
+++ b/drivers/net/wan/ixp4xx_hss.c
@@ -622,7 +622,7 @@ static void hss_hdlc_rx_irq(void *pdev)
         printk(KERN_DEBUG "%s: hss_hdlc_rx_irq\n", dev->name);
 #endif
         qmgr_disable_irq(queue_ids[port->id].rx);
-        netif_rx_schedule(dev, &port->napi);
+        netif_rx_schedule(&port->napi);
 }
 
 static int hss_hdlc_poll(struct napi_struct *napi, int budget)
@@ -651,7 +651,7 @@ static int hss_hdlc_poll(struct napi_struct *napi, int budget)
                         printk(KERN_DEBUG "%s: hss_hdlc_poll"
                                " netif_rx_complete\n", dev->name);
 #endif
-                        netif_rx_complete(dev, napi);
+                        netif_rx_complete(napi);
                         qmgr_enable_irq(rxq);
                         if (!qmgr_stat_empty(rxq) &&
                             netif_rx_reschedule(napi)) {
@@ -1069,7 +1069,7 @@ static int hss_hdlc_open(struct net_device *dev)
         hss_start_hdlc(port);
 
         /* we may already have RX data, enables IRQ */
-        netif_rx_schedule(dev, &port->napi);
+        netif_rx_schedule(&port->napi);
         return 0;
 
 err_unlock:
diff --git a/drivers/net/wimax/i2400m/control.c b/drivers/net/wimax/i2400m/control.c
index d3d37fed6893..15d9f51b292c 100644
--- a/drivers/net/wimax/i2400m/control.c
+++ b/drivers/net/wimax/i2400m/control.c
@@ -609,7 +609,7 @@ void i2400m_msg_to_dev_cancel_wait(struct i2400m *i2400m, int code)
         spin_lock_irqsave(&i2400m->rx_lock, flags);
         ack_skb = i2400m->ack_skb;
         if (ack_skb && !IS_ERR(ack_skb))
-                kfree(ack_skb);
+                kfree_skb(ack_skb);
         i2400m->ack_skb = ERR_PTR(code);
         spin_unlock_irqrestore(&i2400m->rx_lock, flags);
 }
diff --git a/drivers/net/wimax/i2400m/usb-rx.c b/drivers/net/wimax/i2400m/usb-rx.c
index 074cc1f89853..a314799967cf 100644
--- a/drivers/net/wimax/i2400m/usb-rx.c
+++ b/drivers/net/wimax/i2400m/usb-rx.c
@@ -184,6 +184,8 @@ void i2400mu_rx_size_maybe_shrink(struct i2400mu *i2400mu)
  *   NOTE: this function might realloc the skb (if it is too small),
  *   so always update with the one returned.
  *   ERR_PTR() is < 0 on error.
+ *   Will return NULL if it cannot reallocate -- this can be
+ *   considered a transient retryable error.
  */
 static
 struct sk_buff *i2400mu_rx(struct i2400mu *i2400mu, struct sk_buff *rx_skb)
@@ -243,8 +245,8 @@ retry:
                         if (printk_ratelimit())
                                 dev_err(dev, "RX: Can't reallocate skb to %d; "
                                         "RX dropped\n", rx_size);
-                        kfree(rx_skb);
-                        result = 0;
+                        kfree_skb(rx_skb);
+                        rx_skb = NULL;
                         goto out;       /* drop it...*/
                 }
                 kfree_skb(rx_skb);
@@ -344,7 +346,8 @@ int i2400mu_rxd(void *_i2400mu)
                 if (IS_ERR(rx_skb))
                         goto out;
                 atomic_dec(&i2400mu->rx_pending_count);
-                if (rx_skb->len == 0) { /* some ignorable condition */
+                if (rx_skb == NULL || rx_skb->len == 0) {
+                        /* some "ignorable" condition */
                         kfree_skb(rx_skb);
                         continue;
                 }
diff --git a/drivers/net/wireless/Kconfig b/drivers/net/wireless/Kconfig
index ea543fcf2687..e4f9f747de88 100644
--- a/drivers/net/wireless/Kconfig
+++ b/drivers/net/wireless/Kconfig
@@ -111,7 +111,7 @@ config WLAN_80211
           lets you choose drivers.
 
 config PCMCIA_RAYCS
-        tristate "Aviator/Raytheon 2.4MHz wireless support"
+        tristate "Aviator/Raytheon 2.4GHz wireless support"
         depends on PCMCIA && WLAN_80211
         select WIRELESS_EXT
         ---help---
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index 4af2607deec0..8ef87356e083 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -2644,7 +2644,7 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 if (skb_headroom(skb) < padsize) {
                         ATH5K_ERR(sc, "tx hdrlen not %%4: %d not enough"
                                   " headroom to pad %d\n", hdrlen, padsize);
-                        return -1;
+                        return NETDEV_TX_BUSY;
                 }
                 skb_push(skb, padsize);
                 memmove(skb->data, skb->data+padsize, hdrlen);
@@ -2655,7 +2655,7 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 ATH5K_ERR(sc, "no further txbuf available, dropping packet\n");
                 spin_unlock_irqrestore(&sc->txbuflock, flags);
                 ieee80211_stop_queue(hw, skb_get_queue_mapping(skb));
-                return -1;
+                return NETDEV_TX_BUSY;
         }
         bf = list_first_entry(&sc->txbuf, struct ath5k_buf, list);
         list_del(&bf->list);
@@ -2673,10 +2673,10 @@ ath5k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 sc->txbuf_len++;
                 spin_unlock_irqrestore(&sc->txbuflock, flags);
                 dev_kfree_skb_any(skb);
-                return 0;
+                return NETDEV_TX_OK;
         }
 
-        return 0;
+        return NETDEV_TX_OK;
 }
 
 static int
diff --git a/drivers/net/wireless/ath5k/pcu.c b/drivers/net/wireless/ath5k/pcu.c
index 0cac05c6a9ce..75eb9f43c741 100644
--- a/drivers/net/wireless/ath5k/pcu.c
+++ b/drivers/net/wireless/ath5k/pcu.c
@@ -65,7 +65,7 @@ int ath5k_hw_set_opmode(struct ath5k_hw *ah)
                 if (ah->ah_version == AR5K_AR5210)
                         pcu_reg |= AR5K_STA_ID1_NO_PSPOLL;
                 else
-                        AR5K_REG_DISABLE_BITS(ah, AR5K_CFG, AR5K_CFG_ADHOC);
+                        AR5K_REG_ENABLE_BITS(ah, AR5K_CFG, AR5K_CFG_IBSS);
                 break;
 
         case NL80211_IFTYPE_AP:
@@ -75,7 +75,7 @@ int ath5k_hw_set_opmode(struct ath5k_hw *ah)
                 if (ah->ah_version == AR5K_AR5210)
                         pcu_reg |= AR5K_STA_ID1_NO_PSPOLL;
                 else
-                        AR5K_REG_ENABLE_BITS(ah, AR5K_CFG, AR5K_CFG_ADHOC);
+                        AR5K_REG_DISABLE_BITS(ah, AR5K_CFG, AR5K_CFG_IBSS);
                 break;
 
         case NL80211_IFTYPE_STATION:
diff --git a/drivers/net/wireless/ath5k/reg.h b/drivers/net/wireless/ath5k/reg.h
index 91aaeaf88199..9189ab13286c 100644
--- a/drivers/net/wireless/ath5k/reg.h
+++ b/drivers/net/wireless/ath5k/reg.h
@@ -73,7 +73,7 @@
 #define AR5K_CFG_SWRD           0x00000004      /* Byte-swap RX descriptor */
 #define AR5K_CFG_SWRB           0x00000008      /* Byte-swap RX buffer */
 #define AR5K_CFG_SWRG           0x00000010      /* Byte-swap Register access */
-#define AR5K_CFG_ADHOC          0x00000020      /* AP/Adhoc indication [5211+] */
+#define AR5K_CFG_IBSS           0x00000020      /* 0-BSS, 1-IBSS [5211+] */
 #define AR5K_CFG_PHY_OK         0x00000100      /* [5211+] */
 #define AR5K_CFG_EEBS           0x00000200      /* EEPROM is busy */
 #define AR5K_CFG_CLKGD          0x00000400      /* Clock gated (Disable dynamic clock) */
diff --git a/drivers/net/wireless/ath9k/Kconfig b/drivers/net/wireless/ath9k/Kconfig
index c43bd321f97f..90a8dd873786 100644
--- a/drivers/net/wireless/ath9k/Kconfig
+++ b/drivers/net/wireless/ath9k/Kconfig
@@ -1,6 +1,7 @@
 config ATH9K
         tristate "Atheros 802.11n wireless cards support"
         depends on PCI && MAC80211 && WLAN_80211
+        depends on RFKILL || RFKILL=n
         select MAC80211_LEDS
         select LEDS_CLASS
         select NEW_LEDS
diff --git a/drivers/net/wireless/ath9k/main.c b/drivers/net/wireless/ath9k/main.c
index 191eec50dc75..727f067aca4f 100644
--- a/drivers/net/wireless/ath9k/main.c
+++ b/drivers/net/wireless/ath9k/main.c
@@ -2164,13 +2164,13 @@ static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
                                                     conf->ht.channel_type);
                 }
 
+                ath_update_chainmask(sc, conf->ht.enabled);
+
                 if (ath_set_channel(sc, &sc->sc_ah->ah_channels[pos]) < 0) {
                         DPRINTF(sc, ATH_DBG_FATAL, "Unable to set channel\n");
                         mutex_unlock(&sc->mutex);
                         return -EINVAL;
                 }
-
-                ath_update_chainmask(sc, conf->ht.enabled);
         }
 
         if (changed & IEEE80211_CONF_CHANGE_POWER)
diff --git a/drivers/net/wireless/ath9k/rc.c b/drivers/net/wireless/ath9k/rc.c
index 04ab457a8faa..1b71b934bb5e 100644
--- a/drivers/net/wireless/ath9k/rc.c
+++ b/drivers/net/wireless/ath9k/rc.c
@@ -490,7 +490,7 @@ static inline int ath_rc_get_nextvalid_txrate(struct ath_rate_table *rate_table,
 
 static int ath_rc_valid_phyrate(u32 phy, u32 capflag, int ignore_cw)
 {
-        if (WLAN_RC_PHY_HT(phy) & !(capflag & WLAN_RC_HT_FLAG))
+        if (WLAN_RC_PHY_HT(phy) && !(capflag & WLAN_RC_HT_FLAG))
                 return 0;
         if (WLAN_RC_PHY_DS(phy) && !(capflag & WLAN_RC_DS_FLAG))
                 return 0;
diff --git a/drivers/net/wireless/ath9k/regd_common.h b/drivers/net/wireless/ath9k/regd_common.h
index 9112c030b1e8..6df1b3b77c25 100644
--- a/drivers/net/wireless/ath9k/regd_common.h
+++ b/drivers/net/wireless/ath9k/regd_common.h
@@ -228,7 +228,7 @@ enum {
 };
 
 #define REG_DOMAIN_2GHZ_MASK    (REQ_MASK & \
-        (!(ADHOC_NO_11A | DISALLOW_ADHOC_11A | DISALLOW_ADHOC_11A_TURB)))
+        (~(ADHOC_NO_11A | DISALLOW_ADHOC_11A | DISALLOW_ADHOC_11A_TURB)))
 #define REG_DOMAIN_5GHZ_MASK    REQ_MASK
 
 static struct reg_dmn_pair_mapping regDomainPairs[] = {
diff --git a/drivers/net/wireless/ath9k/xmit.c b/drivers/net/wireless/ath9k/xmit.c
index 3bfc3b90f256..c92f0c6e4adc 100644
--- a/drivers/net/wireless/ath9k/xmit.c
+++ b/drivers/net/wireless/ath9k/xmit.c
@@ -126,15 +126,7 @@ static void ath_tx_complete(struct ath_softc *sc, struct sk_buff *skb,
                 tx_info->flags |= IEEE80211_TX_STAT_ACK;
         }
 
-        tx_info->status.rates[0].count = tx_status->retries;
-        if (tx_info->status.rates[0].flags & IEEE80211_TX_RC_MCS) {
-                /* Change idx from internal table index to MCS index */
-                int idx = tx_info->status.rates[0].idx;
-                struct ath_rate_table *rate_table = sc->cur_rate_table;
-                if (idx >= 0 && idx < rate_table->rate_cnt)
-                        tx_info->status.rates[0].idx =
-                                rate_table->info[idx].ratecode & 0x7f;
-        }
+        tx_info->status.rates[0].count = tx_status->retries + 1;
 
         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
         padsize = hdrlen & 3;
@@ -264,25 +256,22 @@ static void assign_aggr_tid_seqno(struct sk_buff *skb,
         }
 
         /* Get seqno */
-
-        if (ieee80211_is_data(fc) && !is_pae(skb)) {
-                /* For HT capable stations, we save tidno for later use.
-                 * We also override seqno set by upper layer with the one
-                 * in tx aggregation state.
-                 *
-                 * If fragmentation is on, the sequence number is
-                 * not overridden, since it has been
-                 * incremented by the fragmentation routine.
-                 *
-                 * FIXME: check if the fragmentation threshold exceeds
-                 * IEEE80211 max.
-                 */
-                tid = ATH_AN_2_TID(an, bf->bf_tidno);
-                hdr->seq_ctrl = cpu_to_le16(tid->seq_next <<
-                                            IEEE80211_SEQ_SEQ_SHIFT);
-                bf->bf_seqno = tid->seq_next;
-                INCR(tid->seq_next, IEEE80211_SEQ_MAX);
-        }
+        /* For HT capable stations, we save tidno for later use.
+         * We also override seqno set by upper layer with the one
+         * in tx aggregation state.
+         *
+         * If fragmentation is on, the sequence number is
+         * not overridden, since it has been
+         * incremented by the fragmentation routine.
+         *
+         * FIXME: check if the fragmentation threshold exceeds
+         * IEEE80211 max.
+         */
+        tid = ATH_AN_2_TID(an, bf->bf_tidno);
+        hdr->seq_ctrl = cpu_to_le16(tid->seq_next <<
+                        IEEE80211_SEQ_SEQ_SHIFT);
+        bf->bf_seqno = tid->seq_next;
+        INCR(tid->seq_next, IEEE80211_SEQ_MAX);
 }
 
 static int setup_tx_flags(struct ath_softc *sc, struct sk_buff *skb,
@@ -1718,11 +1707,10 @@ static int ath_tx_setup_buffer(struct ath_softc *sc, struct ath_buf *bf,
 
         /* Assign seqno, tidno */
 
-        if (bf_isht(bf) && (sc->sc_flags & SC_OP_TXAGGR))
+        if (ieee80211_is_data_qos(fc) && (sc->sc_flags & SC_OP_TXAGGR))
                 assign_aggr_tid_seqno(skb, bf);
 
         /* DMA setup */
-
         bf->bf_mpdu = skb;
 
         bf->bf_dmacontext = pci_map_single(sc->pdev, skb->data,
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 7b31a327b24a..c788bad10661 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -3261,7 +3261,7 @@ static int b43_switch_band(struct b43_wl *wl, struct ieee80211_channel *chan)
         struct b43_wldev *down_dev;
         struct b43_wldev *d;
         int err;
-        bool gmode;
+        bool uninitialized_var(gmode);
         int prev_status;
 
         /* Find a device and PHY which supports the band. */
diff --git a/drivers/net/wireless/b43legacy/main.c b/drivers/net/wireless/b43legacy/main.c
index c1324e31d2f6..fb996c27a19b 100644
--- a/drivers/net/wireless/b43legacy/main.c
+++ b/drivers/net/wireless/b43legacy/main.c
@@ -2465,7 +2465,7 @@ static void b43legacy_put_phy_into_reset(struct b43legacy_wldev *dev)
 static int b43legacy_switch_phymode(struct b43legacy_wl *wl,
                                       unsigned int new_mode)
 {
-        struct b43legacy_wldev *up_dev;
+        struct b43legacy_wldev *uninitialized_var(up_dev);
         struct b43legacy_wldev *down_dev;
         int err;
         bool gmode = 0;
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
index 9b60a0c5de5f..21c841847d88 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945-rs.c
@@ -638,12 +638,16 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
         s8 scale_action = 0;
         unsigned long flags;
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
-        u16 fc, rate_mask;
+        u16 fc;
+        u16 rate_mask = 0;
         struct iwl3945_priv *priv = (struct iwl3945_priv *)priv_r;
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 
         IWL_DEBUG_RATE("enter\n");
 
+        if (sta)
+                rate_mask = sta->supp_rates[sband->band];
+
         /* Send management frames and broadcast/multicast data using lowest
          * rate. */
         fc = le16_to_cpu(hdr->frame_control);
@@ -651,11 +655,15 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta,
             is_multicast_ether_addr(hdr->addr1) ||
             !sta || !priv_sta) {
                 IWL_DEBUG_RATE("leave: No STA priv data to update!\n");
-                info->control.rates[0].idx = rate_lowest_index(sband, sta);
+                if (!rate_mask)
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, NULL);
+                else
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, sta);
                 return;
         }
 
-        rate_mask = sta->supp_rates[sband->band];
         index = min(rs_sta->last_txrate_idx & 0xffff, IWL_RATE_COUNT - 1);
 
         if (sband->band == IEEE80211_BAND_5GHZ)
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index 8fdb34222c0a..45cfa1cf194a 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -2219,7 +2219,7 @@ int iwl3945_txpower_set_from_eeprom(struct iwl3945_priv *priv)
                 /* set tx power value for all OFDM rates */
                 for (rate_index = 0; rate_index < IWL_OFDM_RATES;
                      rate_index++) {
-                        s32 power_idx;
+                        s32 uninitialized_var(power_idx);
                         int rc;
 
                         /* use channel group's clip-power table,
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
index f3f17929ca0b..27f50471aed8 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-rs.c
@@ -944,7 +944,8 @@ static void rs_tx_status(void *priv_r, struct ieee80211_supported_band *sband,
         }
 
         /* See if there's a better rate or modulation mode to try. */
-        rs_rate_scale_perform(priv, hdr, sta, lq_sta);
+        if (sta && sta->supp_rates[sband->band])
+                rs_rate_scale_perform(priv, hdr, sta, lq_sta);
 out:
         return;
 }
@@ -2101,14 +2102,23 @@ static void rs_get_rate(void *priv_r, struct ieee80211_sta *sta, void *priv_sta,
         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
         struct iwl_lq_sta *lq_sta = priv_sta;
         int rate_idx;
+        u64 mask_bit = 0;
 
         IWL_DEBUG_RATE_LIMIT("rate scale calculate new rate for skb\n");
 
+        if (sta)
+                mask_bit = sta->supp_rates[sband->band];
+
         /* Send management frames and broadcast/multicast data using lowest
          * rate. */
         if (!ieee80211_is_data(hdr->frame_control) ||
             is_multicast_ether_addr(hdr->addr1) || !sta || !lq_sta) {
-                info->control.rates[0].idx = rate_lowest_index(sband, sta);
+                if (!mask_bit)
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, NULL);
+                else
+                        info->control.rates[0].idx =
+                                        rate_lowest_index(sband, sta);
                 return;
         }
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index 5da6b35cd26d..0dc8eed16404 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -2482,7 +2482,7 @@ static int iwl_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 dev_kfree_skb_any(skb);
 
         IWL_DEBUG_MACDUMP("leave\n");
-        return 0;
+        return NETDEV_TX_OK;
 }
 
 static int iwl_mac_add_interface(struct ieee80211_hw *hw,
diff --git a/drivers/net/wireless/iwlwifi/iwl-commands.h b/drivers/net/wireless/iwlwifi/iwl-commands.h
index 52966ffbef6e..ba997204c8d4 100644
--- a/drivers/net/wireless/iwlwifi/iwl-commands.h
+++ b/drivers/net/wireless/iwlwifi/iwl-commands.h
@@ -255,7 +255,7 @@ struct iwl_cmd_header {
  *        0x3)  54 Mbps
  *
  * Legacy CCK rate format for bits 7:0 (bit 8 must be "0", bit 9 "1"):
- *  3-0:   10)  1 Mbps
+ *  6-0:   10)  1 Mbps
  *         20)  2 Mbps
  *         55)  5.5 Mbps
  *        110)  11 Mbps
diff --git a/drivers/net/wireless/iwlwifi/iwl-hcmd.c b/drivers/net/wireless/iwlwifi/iwl-hcmd.c
index 01a2169cecec..4b35b30e493e 100644
--- a/drivers/net/wireless/iwlwifi/iwl-hcmd.c
+++ b/drivers/net/wireless/iwlwifi/iwl-hcmd.c
@@ -51,6 +51,7 @@ const char *get_cmd_string(u8 cmd)
                 IWL_CMD(REPLY_REMOVE_STA);
                 IWL_CMD(REPLY_REMOVE_ALL_STA);
                 IWL_CMD(REPLY_WEPKEY);
+                IWL_CMD(REPLY_3945_RX);
                 IWL_CMD(REPLY_TX);
                 IWL_CMD(REPLY_RATE_SCALE);
                 IWL_CMD(REPLY_LEDS_CMD);
@@ -223,7 +224,7 @@ int iwl_send_cmd_sync(struct iwl_priv *priv, struct iwl_host_cmd *cmd)
                 IWL_ERROR("Error: Response NULL in '%s'\n",
                           get_cmd_string(cmd->id));
                 ret = -EIO;
-                goto out;
+                goto cancel;
         }
 
         ret = 0;
diff --git a/drivers/net/wireless/iwlwifi/iwl3945-base.c b/drivers/net/wireless/iwlwifi/iwl3945-base.c
index d64580805d6e..95d01984c80e 100644
--- a/drivers/net/wireless/iwlwifi/iwl3945-base.c
+++ b/drivers/net/wireless/iwlwifi/iwl3945-base.c
@@ -745,7 +745,7 @@ static int iwl3945_send_cmd_sync(struct iwl3945_priv *priv, struct iwl3945_host_
                 IWL_ERROR("Error: Response NULL in '%s'\n",
                           get_cmd_string(cmd->id));
                 ret = -EIO;
-                goto out;
+                goto cancel;
         }
 
         ret = 0;
@@ -6538,7 +6538,7 @@ static int iwl3945_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
                 dev_kfree_skb_any(skb);
 
         IWL_DEBUG_MAC80211("leave\n");
-        return 0;
+        return NETDEV_TX_OK;
 }
 
 static int iwl3945_mac_add_interface(struct ieee80211_hw *hw,
diff --git a/drivers/net/wireless/libertas/hostcmd.h b/drivers/net/wireless/libertas/hostcmd.h
index e173b1b46c23..f6a79a653b7b 100644
--- a/drivers/net/wireless/libertas/hostcmd.h
+++ b/drivers/net/wireless/libertas/hostcmd.h
@@ -32,7 +32,7 @@ struct txpd {
         u8 pktdelay_2ms;
         /* reserved */
         u8 reserved1;
-};
+} __attribute__ ((packed));
 
 /* RxPD Descriptor */
 struct rxpd {
@@ -63,7 +63,7 @@ struct rxpd {
         /* Pkt Priority */
         u8 priority;
         u8 reserved[3];
-};
+} __attribute__ ((packed));
 
 struct cmd_header {
         __le16 command;
@@ -97,7 +97,7 @@ struct enc_key {
 struct lbs_offset_value {
         u32 offset;
         u32 value;
-};
+} __attribute__ ((packed));
 
 /* Define general data structure */
 /* cmd_DS_GEN */
@@ -107,7 +107,7 @@ struct cmd_ds_gen {
         __le16 seqnum;
         __le16 result;
         void *cmdresp[0];
-};
+} __attribute__ ((packed));
 
 #define S_DS_GEN sizeof(struct cmd_ds_gen)
 
@@ -163,7 +163,7 @@ struct cmd_ds_802_11_subscribe_event {
          * bump this up a bit.
          */
         uint8_t tlv[128];
-};
+} __attribute__ ((packed));
 
 /*
  * This scan handle Country Information IE(802.11d compliant)
@@ -180,7 +180,7 @@ struct cmd_ds_802_11_scan {
         mrvlietypes_chanlistparamset_t ChanListParamSet;
         mrvlietypes_ratesparamset_t OpRateSet;
 #endif
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_scan_rsp {
         struct cmd_header hdr;
@@ -188,7 +188,7 @@ struct cmd_ds_802_11_scan_rsp {
         __le16 bssdescriptsize;
         uint8_t nr_sets;
         uint8_t bssdesc_and_tlvbuffer[0];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_get_log {
         struct cmd_header hdr;
@@ -206,33 +206,33 @@ struct cmd_ds_802_11_get_log {
         __le32 fcserror;
         __le32 txframe;
         __le32 wepundecryptable;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_mac_control {
         struct cmd_header hdr;
         __le16 action;
         u16 reserved;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_mac_multicast_adr {
         struct cmd_header hdr;
         __le16 action;
         __le16 nr_of_adrs;
         u8 maclist[ETH_ALEN * MRVDRV_MAX_MULTICAST_LIST_SIZE];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_authenticate {
         u8 macaddr[ETH_ALEN];
         u8 authtype;
         u8 reserved[10];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_deauthenticate {
         struct cmd_header hdr;
 
         u8 macaddr[ETH_ALEN];
         __le16 reasoncode;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_associate {
         u8 peerstaaddr[6];
@@ -251,7 +251,7 @@ struct cmd_ds_802_11_associate {
 
 struct cmd_ds_802_11_associate_rsp {
         struct ieeetypes_assocrsp assocRsp;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_set_wep {
         struct cmd_header hdr;
@@ -265,7 +265,7 @@ struct cmd_ds_802_11_set_wep {
         /* 40, 128bit or TXWEP */
         uint8_t keytype[4];
         uint8_t keymaterial[4][16];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_3_get_stat {
         __le32 xmitok;
@@ -274,7 +274,7 @@ struct cmd_ds_802_3_get_stat {
         __le32 rcverror;
         __le32 rcvnobuffer;
         __le32 rcvcrcerror;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_get_stat {
         __le32 txfragmentcnt;
@@ -294,7 +294,7 @@ struct cmd_ds_802_11_get_stat {
         __le32 txbeacon;
         __le32 rxbeacon;
         __le32 wepundecryptable;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_snmp_mib {
         struct cmd_header hdr;
@@ -303,58 +303,58 @@ struct cmd_ds_802_11_snmp_mib {
         __le16 oid;
         __le16 bufsize;
         u8 value[128];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_mac_reg_map {
         __le16 buffersize;
         u8 regmap[128];
         __le16 reserved;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_bbp_reg_map {
         __le16 buffersize;
         u8 regmap[128];
         __le16 reserved;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_rf_reg_map {
         __le16 buffersize;
         u8 regmap[64];
         __le16 reserved;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_mac_reg_access {
         __le16 action;
         __le16 offset;
         __le32 value;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_bbp_reg_access {
         __le16 action;
         __le16 offset;
         u8 value;
         u8 reserved[3];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_rf_reg_access {
         __le16 action;
         __le16 offset;
         u8 value;
         u8 reserved[3];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_radio_control {
         struct cmd_header hdr;
 
         __le16 action;
         __le16 control;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_beacon_control {
         __le16 action;
         __le16 beacon_enable;
         __le16 beacon_period;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_sleep_params {
         struct cmd_header hdr;
@@ -379,7 +379,7 @@ struct cmd_ds_802_11_sleep_params {
 
         /* reserved field, should be set to zero */
         __le16 reserved;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_inactivity_timeout {
         struct cmd_header hdr;
@@ -389,7 +389,7 @@ struct cmd_ds_802_11_inactivity_timeout {
 
         /* Inactivity timeout in msec */
         __le16 timeout;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_rf_channel {
         struct cmd_header hdr;
@@ -399,7 +399,7 @@ struct cmd_ds_802_11_rf_channel {
         __le16 rftype;      /* unused */
         __le16 reserved;    /* unused */
         u8 channellist[32]; /* unused */
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_rssi {
         /* weighting factor */
@@ -408,21 +408,21 @@ struct cmd_ds_802_11_rssi {
         __le16 reserved_0;
         __le16 reserved_1;
         __le16 reserved_2;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_rssi_rsp {
         __le16 SNR;
         __le16 noisefloor;
         __le16 avgSNR;
         __le16 avgnoisefloor;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_mac_address {
         struct cmd_header hdr;
 
         __le16 action;
         u8 macadd[ETH_ALEN];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_rf_tx_power {
         struct cmd_header hdr;
@@ -431,7 +431,7 @@ struct cmd_ds_802_11_rf_tx_power {
         __le16 curlevel;
         s8 maxlevel;
         s8 minlevel;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_rf_antenna {
         __le16 action;
@@ -439,33 +439,33 @@ struct cmd_ds_802_11_rf_antenna {
         /* Number of antennas or 0xffff(diversity) */
         __le16 antennamode;
 
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_monitor_mode {
         __le16 action;
         __le16 mode;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_set_boot2_ver {
         struct cmd_header hdr;
 
         __le16 action;
         __le16 version;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_fw_wake_method {
         struct cmd_header hdr;
 
         __le16 action;
         __le16 method;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_sleep_period {
         struct cmd_header hdr;
 
         __le16 action;
         __le16 period;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_ps_mode {
         __le16 action;
@@ -473,7 +473,7 @@ struct cmd_ds_802_11_ps_mode {
         __le16 multipledtim;
         __le16 reserved;
         __le16 locallisteninterval;
-};
+} __attribute__ ((packed));
 
 struct cmd_confirm_sleep {
         struct cmd_header hdr;
@@ -483,7 +483,7 @@ struct cmd_confirm_sleep {
         __le16 multipledtim;
         __le16 reserved;
         __le16 locallisteninterval;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_data_rate {
         struct cmd_header hdr;
@@ -491,14 +491,14 @@ struct cmd_ds_802_11_data_rate {
         __le16 action;
         __le16 reserved;
         u8 rates[MAX_RATES];
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_rate_adapt_rateset {
         struct cmd_header hdr;
         __le16 action;
         __le16 enablehwauto;
         __le16 bitmap;
-};
+} __attribute__ ((packed));
 
 struct cmd_ds_802_11_ad_hoc_start {
         struct cmd_header hdr;
@@ -520,7 +520,7 @@ struct cmd_ds_802_11_ad_hoc_result {
 
         u8 pad[3];
         u8 bssid[ETH_ALEN];
-};
+} __attribute__ ((packed));
 
 struct adhoc_bssdesc {
         u8 bssid[ETH_ALEN];
@@ -578,7 +578,7 @@ struct MrvlIEtype_keyParamSet {
 
         /* key material of size keylen */
         u8 key[32];
-};
+} __attribute__ ((packed));
 
 #define MAX_WOL_RULES           16
 
@@ -590,7 +590,7 @@ struct host_wol_rule {
         __le16 reserve;
         __be32 sig_mask;
         __be32 signature;
-};
+} __attribute__ ((packed));
 
 struct wol_config {
         uint8_t action;
@@ -598,8 +598,7 @@ struct wol_config {
         uint8_t no_rules_in_cmd;
         uint8_t result;
         struct host_wol_rule rule[MAX_WOL_RULES];
-};
-
+} __attribute__ ((packed));
 
 struct cmd_ds_host_sleep {
         struct cmd_header hdr;
diff --git a/drivers/net/wireless/libertas_tf/main.c b/drivers/net/wireless/libertas_tf/main.c
index d1fc305de5fe..e7289e2e7f16 100644
--- a/drivers/net/wireless/libertas_tf/main.c
+++ b/drivers/net/wireless/libertas_tf/main.c
@@ -206,7 +206,7 @@ static int lbtf_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
          * there are no buffered multicast frames to send
          */
         ieee80211_stop_queues(priv->hw);
-        return 0;
+        return NETDEV_TX_OK;
 }
 
 static void lbtf_tx_work(struct work_struct *work)
diff --git a/drivers/net/wireless/orinoco/orinoco.c b/drivers/net/wireless/orinoco/orinoco.c
index bc84e2792f8a..45a04faa7818 100644
--- a/drivers/net/wireless/orinoco/orinoco.c
+++ b/drivers/net/wireless/orinoco/orinoco.c
@@ -1610,6 +1610,16 @@ static void orinoco_rx_isr_tasklet(unsigned long data)
         struct orinoco_rx_data *rx_data, *temp;
         struct hermes_rx_descriptor *desc;
         struct sk_buff *skb;
+        unsigned long flags;
+
+        /* orinoco_rx requires the driver lock, and we also need to
+         * protect priv->rx_list, so just hold the lock over the
+         * lot.
+         *
+         * If orinoco_lock fails, we've unplugged the card. In this
+         * case just abort. */
+        if (orinoco_lock(priv, &flags) != 0)
+                return;
 
         /* extract desc and skb from queue */
         list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) {
@@ -1622,6 +1632,8 @@ static void orinoco_rx_isr_tasklet(unsigned long data)
 
                 kfree(desc);
         }
+
+        orinoco_unlock(priv, &flags);
 }
 
 /********************************************************************/
@@ -1661,7 +1673,7 @@ static void print_linkstatus(struct net_device *dev, u16 status)
                 s = "UNKNOWN";
         }
         
-        printk(KERN_INFO "%s: New link status: %s (%04x)\n",
+        printk(KERN_DEBUG "%s: New link status: %s (%04x)\n",
                dev->name, s, status);
 }
 
@@ -3645,12 +3657,22 @@ struct net_device
 void free_orinocodev(struct net_device *dev)
 {
         struct orinoco_private *priv = netdev_priv(dev);
+        struct orinoco_rx_data *rx_data, *temp;
 
-        /* No need to empty priv->rx_list: if the tasklet is scheduled
-         * when we call tasklet_kill it will run one final time,
-         * emptying the list */
+        /* If the tasklet is scheduled when we call tasklet_kill it
+         * will run one final time. However the tasklet will only
+         * drain priv->rx_list if the hw is still available. */
         tasklet_kill(&priv->rx_tasklet);
 
+        /* Explicitly drain priv->rx_list */
+        list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) {
+                list_del(&rx_data->list);
+
+                dev_kfree_skb(rx_data->skb);
+                kfree(rx_data->desc);
+                kfree(rx_data);
+        }
+
         unregister_pm_notifier(&priv->pm_notifier);
         orinoco_uncache_fw(priv);
 
@@ -5046,33 +5068,30 @@ static int orinoco_ioctl_set_genie(struct net_device *dev,
         struct orinoco_private *priv = netdev_priv(dev);
         u8 *buf;
         unsigned long flags;
-        int err = 0;
 
         /* cut off at IEEE80211_MAX_DATA_LEN */
         if ((wrqu->data.length > IEEE80211_MAX_DATA_LEN) ||
             (wrqu->data.length && (extra == NULL)))
                 return -EINVAL;
 
-        if (orinoco_lock(priv, &flags) != 0)
-                return -EBUSY;
-
         if (wrqu->data.length) {
                 buf = kmalloc(wrqu->data.length, GFP_KERNEL);
-                if (buf == NULL) {
-                        err = -ENOMEM;
-                        goto out;
-                }
+                if (buf == NULL)
+                        return -ENOMEM;
 
                 memcpy(buf, extra, wrqu->data.length);
-                kfree(priv->wpa_ie);
-                priv->wpa_ie = buf;
-                priv->wpa_ie_len = wrqu->data.length;
-        } else {
-                kfree(priv->wpa_ie);
-                priv->wpa_ie = NULL;
-                priv->wpa_ie_len = 0;
+        } else
+                buf = NULL;
+
+        if (orinoco_lock(priv, &flags) != 0) {
+                kfree(buf);
+                return -EBUSY;
         }
 
+        kfree(priv->wpa_ie);
+        priv->wpa_ie = buf;
+        priv->wpa_ie_len = wrqu->data.length;
+
         if (priv->wpa_ie) {
                 /* Looks like wl_lkm wants to check the auth alg, and
                  * somehow pass it to the firmware.
@@ -5081,9 +5100,8 @@ static int orinoco_ioctl_set_genie(struct net_device *dev,
                  */
         }
 
-out:
         orinoco_unlock(priv, &flags);
-        return err;
+        return 0;
 }
 
 static int orinoco_ioctl_get_genie(struct net_device *dev,
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index f127602670ec..0b32215d3f5d 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -435,6 +435,7 @@ static struct pcmcia_device_id orinoco_cs_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x0250, 0x0002), /* Samsung SWL2000-N 11Mb/s WLAN Card */
         PCMCIA_DEVICE_MANF_CARD(0x0261, 0x0002), /* AirWay 802.11 Adapter (PCMCIA) */
         PCMCIA_DEVICE_MANF_CARD(0x0268, 0x0001), /* ARtem Onair */
+        PCMCIA_DEVICE_MANF_CARD(0x0268, 0x0003), /* ARtem Onair Comcard 11 */
         PCMCIA_DEVICE_MANF_CARD(0x026f, 0x0305), /* Buffalo WLI-PCM-S11 */
         PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1612), /* Linksys WPC11 Version 2.5 */
         PCMCIA_DEVICE_MANF_CARD(0x0274, 0x1613), /* Linksys WPC11 Version 3 */
diff --git a/drivers/net/wireless/p54/p54common.c b/drivers/net/wireless/p54/p54common.c
index 82354b974a04..34561e6e816b 100644
--- a/drivers/net/wireless/p54/p54common.c
+++ b/drivers/net/wireless/p54/p54common.c
@@ -138,6 +138,7 @@ int p54_parse_firmware(struct ieee80211_hw *dev, const struct firmware *fw)
         u8 *fw_version = NULL;
         size_t len;
         int i;
+        int maxlen;
 
         if (priv->rx_start)
                 return 0;
@@ -195,6 +196,16 @@ int p54_parse_firmware(struct ieee80211_hw *dev, const struct firmware *fw)
                         else
                                 priv->rx_mtu = (size_t)
                                         0x620 - priv->tx_hdr_len;
+                        maxlen = priv->tx_hdr_len + /* USB devices */
+                                 sizeof(struct p54_rx_data) +
+                                 4 + /* rx alignment */
+                                 IEEE80211_MAX_FRAG_THRESHOLD;
+                        if (priv->rx_mtu > maxlen && PAGE_SIZE == 4096) {
+                                printk(KERN_INFO "p54: rx_mtu reduced from %d "
+                                                 "to %d\n", priv->rx_mtu,
+                                                 maxlen);
+                                priv->rx_mtu = maxlen;
+                        }
                         break;
                         }
                 case BR_CODE_EXPOSED_IF:
@@ -440,8 +451,8 @@ static int p54_parse_eeprom(struct ieee80211_hw *dev, void *eeprom, int len)
                         }
                         if (err)
                                 goto err;
-
-                }
+                        }
+                        break;
                 case PDR_PRISM_ZIF_TX_IQ_CALIBRATION:
                         priv->iq_autocal = kmalloc(data_len, GFP_KERNEL);
                         if (!priv->iq_autocal) {
@@ -575,6 +586,7 @@ static int p54_rx_data(struct ieee80211_hw *dev, struct sk_buff *skb)
         u16 freq = le16_to_cpu(hdr->freq);
         size_t header_len = sizeof(*hdr);
         u32 tsf32;
+        u8 rate = hdr->rate & 0xf;
 
         /*
          * If the device is in a unspecified state we have to
@@ -603,8 +615,11 @@ static int p54_rx_data(struct ieee80211_hw *dev, struct sk_buff *skb)
         rx_status.qual = (100 * hdr->rssi) / 127;
         if (hdr->rate & 0x10)
                 rx_status.flag |= RX_FLAG_SHORTPRE;
-        rx_status.rate_idx = (dev->conf.channel->band == IEEE80211_BAND_2GHZ ?
-                        hdr->rate : (hdr->rate - 4)) & 0xf;
+        if (dev->conf.channel->band == IEEE80211_BAND_5GHZ)
+                rx_status.rate_idx = (rate < 4) ? 0 : rate - 4;
+        else
+                rx_status.rate_idx = rate;
+
         rx_status.freq = freq;
         rx_status.band =  dev->conf.channel->band;
         rx_status.antenna = hdr->antenna;
@@ -730,7 +745,7 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
                 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(entry);
                 struct p54_hdr *entry_hdr;
                 struct p54_tx_data *entry_data;
-                int pad = 0;
+                unsigned int pad = 0, frame_len;
 
                 range = (void *)info->rate_driver_data;
                 if (range->start_addr != addr) {
@@ -753,6 +768,7 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
                 __skb_unlink(entry, &priv->tx_queue);
                 spin_unlock_irqrestore(&priv->tx_queue.lock, flags);
 
+                frame_len = entry->len;
                 entry_hdr = (struct p54_hdr *) entry->data;
                 entry_data = (struct p54_tx_data *) entry_hdr->data;
                 priv->tx_stats[entry_data->hw_queue].len--;
@@ -798,6 +814,29 @@ static void p54_rx_frame_sent(struct ieee80211_hw *dev, struct sk_buff *skb)
                         info->flags |= IEEE80211_TX_STAT_TX_FILTERED;
                 info->status.ack_signal = p54_rssi_to_dbm(dev,
                                 (int)payload->ack_rssi);
+
+                /* Undo all changes to the frame. */
+                switch (entry_data->key_type) {
+                case P54_CRYPTO_TKIPMICHAEL: {
+                        u8 *iv = (u8 *)(entry_data->align + pad +
+                                        entry_data->crypt_offset);
+
+                        /* Restore the original TKIP IV. */
+                        iv[2] = iv[0];
+                        iv[0] = iv[1];
+                        iv[1] = (iv[0] | 0x20) & 0x7f;  /* WEPSeed - 8.3.2.2 */
+
+                        frame_len -= 12; /* remove TKIP_MMIC + TKIP_ICV */
+                        break;
+                        }
+                case P54_CRYPTO_AESCCMP:
+                        frame_len -= 8; /* remove CCMP_MIC */
+                        break;
+                case P54_CRYPTO_WEP:
+                        frame_len -= 4; /* remove WEP_ICV */
+                        break;
+                }
+                skb_trim(entry, frame_len);
                 skb_pull(entry, sizeof(*hdr) + pad + sizeof(*entry_data));
                 ieee80211_tx_status_irqsafe(dev, entry);
                 goto out;
@@ -1122,7 +1161,7 @@ static int p54_set_tim(struct ieee80211_hw *dev, struct ieee80211_sta *sta,
 
         skb = p54_alloc_skb(dev, P54_HDR_FLAG_CONTROL_OPSET,
                       sizeof(struct p54_hdr) + sizeof(*tim),
-                      P54_CONTROL_TYPE_TIM, GFP_KERNEL);
+                      P54_CONTROL_TYPE_TIM, GFP_ATOMIC);
         if (!skb)
                 return -ENOMEM;
 
@@ -1383,7 +1422,6 @@ static int p54_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
         hdr->tries = ridx;
         txhdr->rts_rate_idx = 0;
         if (info->control.hw_key) {
-                crypt_offset += info->control.hw_key->iv_len;
                 txhdr->key_type = p54_convert_algo(info->control.hw_key->alg);
                 txhdr->key_len = min((u8)16, info->control.hw_key->keylen);
                 memcpy(txhdr->key, info->control.hw_key->key, txhdr->key_len);
@@ -1397,6 +1435,8 @@ static int p54_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
                 }
                 /* reserve some space for ICV */
                 len += info->control.hw_key->icv_len;
+                memset(skb_put(skb, info->control.hw_key->icv_len), 0,
+                       info->control.hw_key->icv_len);
         } else {
                 txhdr->key_type = 0;
                 txhdr->key_len = 0;
@@ -1584,7 +1624,7 @@ static int p54_scan(struct ieee80211_hw *dev, u16 mode, u16 dwell)
 
  err:
         printk(KERN_ERR "%s: frequency change failed\n", wiphy_name(dev->wiphy));
-        kfree_skb(skb);
+        p54_free_skb(dev, skb);
         return -EINVAL;
 }
 
@@ -1824,7 +1864,7 @@ static void p54_remove_interface(struct ieee80211_hw *dev,
 
 static int p54_config(struct ieee80211_hw *dev, u32 changed)
 {
-        int ret;
+        int ret = 0;
         struct p54_common *priv = dev->priv;
         struct ieee80211_conf *conf = &dev->conf;
 
@@ -2051,7 +2091,7 @@ static int p54_set_key(struct ieee80211_hw *dev, enum set_key_cmd cmd,
                         algo = P54_CRYPTO_AESCCMP;
                         break;
                 default:
-                        return -EINVAL;
+                        return -EOPNOTSUPP;
                 }
         }
 
diff --git a/drivers/net/wireless/p54/p54usb.c b/drivers/net/wireless/p54/p54usb.c
index c44a200059d2..5de2ebfb28c7 100644
--- a/drivers/net/wireless/p54/p54usb.c
+++ b/drivers/net/wireless/p54/p54usb.c
@@ -56,6 +56,7 @@ static struct usb_device_id p54u_table[] __devinitdata = {
         {USB_DEVICE(0x050d, 0x7050)},   /* Belkin F5D7050 ver 1000 */
         {USB_DEVICE(0x0572, 0x2000)},   /* Cohiba Proto board */
         {USB_DEVICE(0x0572, 0x2002)},   /* Cohiba Proto board */
+        {USB_DEVICE(0x06b9, 0x0121)},   /* Thomson SpeedTouch 121g */
         {USB_DEVICE(0x0707, 0xee13)},   /* SMC 2862W-G version 2 */
         {USB_DEVICE(0x083a, 0x4521)},   /* Siemens Gigaset USB Adapter 54 version 2 */
         {USB_DEVICE(0x0846, 0x4240)},   /* Netgear WG111 (v2) */
@@ -143,11 +144,8 @@ static void p54u_tx_cb(struct urb *urb)
         struct sk_buff *skb = urb->context;
         struct ieee80211_hw *dev = (struct ieee80211_hw *)
                 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
-        struct p54u_priv *priv = dev->priv;
 
-        skb_pull(skb, priv->common.tx_hdr_len);
-        if (FREE_AFTER_TX(skb))
-                p54_free_skb(dev, skb);
+        p54_free_skb(dev, skb);
 }
 
 static void p54u_tx_dummy_cb(struct urb *urb) { }
@@ -229,7 +227,10 @@ static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb)
                           p54u_tx_dummy_cb, dev);
         usb_fill_bulk_urb(data_urb, priv->udev,
                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
-                          skb->data, skb->len, p54u_tx_cb, skb);
+                          skb->data, skb->len, FREE_AFTER_TX(skb) ?
+                          p54u_tx_cb : p54u_tx_dummy_cb, skb);
+        addr_urb->transfer_flags |= URB_ZERO_PACKET;
+        data_urb->transfer_flags |= URB_ZERO_PACKET;
 
         usb_anchor_urb(addr_urb, &priv->submitted);
         err = usb_submit_urb(addr_urb, GFP_ATOMIC);
@@ -238,7 +239,7 @@ static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb)
                 goto out;
         }
 
-        usb_anchor_urb(addr_urb, &priv->submitted);
+        usb_anchor_urb(data_urb, &priv->submitted);
         err = usb_submit_urb(data_urb, GFP_ATOMIC);
         if (err)
                 usb_unanchor_urb(data_urb);
@@ -268,27 +269,24 @@ static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
 {
         struct p54u_priv *priv = dev->priv;
         struct urb *data_urb;
-        struct lm87_tx_hdr *hdr;
-        __le32 checksum;
-        __le32 addr = ((struct p54_hdr *)skb->data)->req_id;
+        struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
 
         data_urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!data_urb)
                 return;
 
-        checksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
-        hdr = (struct lm87_tx_hdr *)skb_push(skb, sizeof(*hdr));
-        hdr->chksum = checksum;
-        hdr->device_addr = addr;
+        hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
+        hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
 
         usb_fill_bulk_urb(data_urb, priv->udev,
                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
-                          skb->data, skb->len, p54u_tx_cb, skb);
+                          hdr, skb->len + sizeof(*hdr),  FREE_AFTER_TX(skb) ?
+                          p54u_tx_cb : p54u_tx_dummy_cb, skb);
+        data_urb->transfer_flags |= URB_ZERO_PACKET;
 
         usb_anchor_urb(data_urb, &priv->submitted);
         if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
                 usb_unanchor_urb(data_urb);
-                skb_pull(skb, sizeof(*hdr));
                 p54_free_skb(dev, skb);
         }
         usb_free_urb(data_urb);
@@ -298,11 +296,9 @@ static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
 {
         struct p54u_priv *priv = dev->priv;
         struct urb *int_urb, *data_urb;
-        struct net2280_tx_hdr *hdr;
+        struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
         struct net2280_reg_write *reg;
         int err = 0;
-        __le32 addr = ((struct p54_hdr *) skb->data)->req_id;
-        __le16 len = cpu_to_le16(skb->len);
 
         reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
         if (!reg)
@@ -325,10 +321,9 @@ static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
         reg->addr = cpu_to_le32(P54U_DEV_BASE);
         reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
 
-        hdr = (void *)skb_push(skb, sizeof(*hdr));
         memset(hdr, 0, sizeof(*hdr));
-        hdr->len = len;
-        hdr->device_addr = addr;
+        hdr->len = cpu_to_le16(skb->len);
+        hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
 
         usb_fill_bulk_urb(int_urb, priv->udev,
                 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
@@ -339,11 +334,13 @@ static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
          * free what's inside the transfer_buffer after the callback routine
          * has completed.
          */
-        int_urb->transfer_flags |= URB_FREE_BUFFER;
+        int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
 
         usb_fill_bulk_urb(data_urb, priv->udev,
                           usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
-                          skb->data, skb->len, p54u_tx_cb, skb);
+                          hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
+                          p54u_tx_cb : p54u_tx_dummy_cb, skb);
+        data_urb->transfer_flags |= URB_ZERO_PACKET;
 
         usb_anchor_urb(int_urb, &priv->submitted);
         err = usb_submit_urb(int_urb, GFP_ATOMIC);
diff --git a/drivers/net/wireless/rndis_wlan.c b/drivers/net/wireless/rndis_wlan.c
index 607ce9f61b54..ed93ac41297f 100644
--- a/drivers/net/wireless/rndis_wlan.c
+++ b/drivers/net/wireless/rndis_wlan.c
@@ -1649,9 +1649,7 @@ static char *rndis_translate_scan(struct net_device *dev,
                                   char *end_buf,
                                   struct ndis_80211_bssid_ex *bssid)
 {
-#ifdef DEBUG
         struct usbnet *usbdev = netdev_priv(dev);
-#endif
         u8 *ie;
         char *current_val;
         int bssid_len, ie_len, i;
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index 30028e2422fc..af6b5847be5c 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -38,7 +38,7 @@
 /*
  * Allow hardware encryption to be disabled.
  */
-static int modparam_nohwcrypt = 1;
+static int modparam_nohwcrypt = 0;
 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
 MODULE_PARM_DESC(nohwcrypt, "Disable hardware encryption.");
 
@@ -376,11 +376,11 @@ static int rt2500usb_config_key(struct rt2x00_dev *rt2x00dev,
 
                 /*
                  * The driver does not support the IV/EIV generation
-                 * in hardware. However it doesn't support the IV/EIV
-                 * inside the ieee80211 frame either, but requires it
-                 * to be provided seperately for the descriptor.
-                 * rt2x00lib will cut the IV/EIV data out of all frames
-                 * given to us by mac80211, but we must tell mac80211
+                 * in hardware. However it demands the data to be provided
+                 * both seperately as well as inside the frame.
+                 * We already provided the CONFIG_CRYPTO_COPY_IV to rt2x00lib
+                 * to ensure rt2x00lib will not strip the data from the
+                 * frame after the copy, now we must tell mac80211
                  * to generate the IV/EIV data.
                  */
                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
@@ -1181,7 +1181,7 @@ static void rt2500usb_write_tx_desc(struct rt2x00_dev *rt2x00dev,
                            test_bit(ENTRY_TXD_FIRST_FRAGMENT, &txdesc->flags));
         rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs);
         rt2x00_set_field32(&word, TXD_W0_DATABYTE_COUNT, skb->len);
-        rt2x00_set_field32(&word, TXD_W0_CIPHER, txdesc->cipher);
+        rt2x00_set_field32(&word, TXD_W0_CIPHER, !!txdesc->cipher);
         rt2x00_set_field32(&word, TXD_W0_KEY_ID, txdesc->key_idx);
         rt2x00_desc_write(txd, 0, word);
 }
@@ -1334,14 +1334,7 @@ static void rt2500usb_fill_rxdone(struct queue_entry *entry,
 
                 /* ICV is located at the end of frame */
 
-                /*
-                 * Hardware has stripped IV/EIV data from 802.11 frame during
-                 * decryption. It has provided the data seperately but rt2x00lib
-                 * should decide if it should be reinserted.
-                 */
-                rxdesc->flags |= RX_FLAG_IV_STRIPPED;
-                if (rxdesc->cipher != CIPHER_TKIP)
-                        rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
+                rxdesc->flags |= RX_FLAG_MMIC_STRIPPED;
                 if (rxdesc->cipher_status == RX_CRYPTO_SUCCESS)
                         rxdesc->flags |= RX_FLAG_DECRYPTED;
                 else if (rxdesc->cipher_status == RX_CRYPTO_FAIL_MIC)
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index 6d92542fcf0d..87c0f2c83077 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -807,13 +807,11 @@ static void rt2x00lib_rate(struct ieee80211_rate *entry,
 {
         entry->flags = 0;
         entry->bitrate = rate->bitrate;
-        entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
-        entry->hw_value_short = entry->hw_value;
+        entry->hw_value =index;
+        entry->hw_value_short = index;
 
-        if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
+        if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
                 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
-                entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
-        }
 }
 
 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
diff --git a/drivers/net/wireless/rt2x00/rt2x00leds.c b/drivers/net/wireless/rt2x00/rt2x00leds.c
index 68f4e0fc35b9..a0cd35b6beb5 100644
--- a/drivers/net/wireless/rt2x00/rt2x00leds.c
+++ b/drivers/net/wireless/rt2x00/rt2x00leds.c
@@ -97,7 +97,7 @@ void rt2x00leds_led_assoc(struct rt2x00_dev *rt2x00dev, bool enabled)
 
 void rt2x00leds_led_radio(struct rt2x00_dev *rt2x00dev, bool enabled)
 {
-        if (rt2x00dev->led_radio.type == LED_TYPE_ASSOC)
+        if (rt2x00dev->led_radio.type == LED_TYPE_RADIO)
                 rt2x00led_led_simple(&rt2x00dev->led_radio, enabled);
 }
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00lib.h b/drivers/net/wireless/rt2x00/rt2x00lib.h
index 03024327767b..86cd26fbf769 100644
--- a/drivers/net/wireless/rt2x00/rt2x00lib.h
+++ b/drivers/net/wireless/rt2x00/rt2x00lib.h
@@ -52,22 +52,11 @@ struct rt2x00_rate {
 
 extern const struct rt2x00_rate rt2x00_supported_rates[12];
 
-static inline u16 rt2x00_create_rate_hw_value(const u16 index,
-                                              const u16 short_preamble)
-{
-        return (short_preamble << 8) | (index & 0xff);
-}
-
 static inline const struct rt2x00_rate *rt2x00_get_rate(const u16 hw_value)
 {
         return &rt2x00_supported_rates[hw_value & 0xff];
 }
 
-static inline int rt2x00_get_rate_preamble(const u16 hw_value)
-{
-        return (hw_value & 0xff00);
-}
-
 /*
  * Radio control handlers.
  */
diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.c b/drivers/net/wireless/rt2x00/rt2x00queue.c
index eaec6bd93ed5..0709decec9c2 100644
--- a/drivers/net/wireless/rt2x00/rt2x00queue.c
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.c
@@ -154,6 +154,7 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry,
         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
         struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)entry->skb->data;
+        struct ieee80211_tx_rate *txrate = &tx_info->control.rates[0];
         struct ieee80211_rate *rate =
             ieee80211_get_tx_rate(rt2x00dev->hw, tx_info);
         const struct rt2x00_rate *hwrate;
@@ -313,7 +314,7 @@ static void rt2x00queue_create_tx_descriptor(struct queue_entry *entry,
                  * When preamble is enabled we should set the
                  * preamble bit for the signal.
                  */
-                if (rt2x00_get_rate_preamble(rate->hw_value))
+                if (txrate->flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
                         txdesc->signal |= 0x08;
         }
 }
diff --git a/drivers/net/wireless/rt2x00/rt2x00rfkill.c b/drivers/net/wireless/rt2x00/rt2x00rfkill.c
index c3f53a92180a..3298cae1e12d 100644
--- a/drivers/net/wireless/rt2x00/rt2x00rfkill.c
+++ b/drivers/net/wireless/rt2x00/rt2x00rfkill.c
@@ -162,7 +162,7 @@ void rt2x00rfkill_allocate(struct rt2x00_dev *rt2x00dev)
 
 void rt2x00rfkill_free(struct rt2x00_dev *rt2x00dev)
 {
-        if (!test_bit(RFKILL_STATE_ALLOCATED, &rt2x00dev->flags))
+        if (!test_bit(RFKILL_STATE_ALLOCATED, &rt2x00dev->rfkill_state))
                 return;
 
         cancel_delayed_work_sync(&rt2x00dev->rfkill_work);
diff --git a/drivers/net/wireless/rt2x00/rt2x00usb.c b/drivers/net/wireless/rt2x00/rt2x00usb.c
index 83df312ac56f..0b29d767a258 100644
--- a/drivers/net/wireless/rt2x00/rt2x00usb.c
+++ b/drivers/net/wireless/rt2x00/rt2x00usb.c
@@ -434,11 +434,11 @@ static int rt2x00usb_find_endpoints(struct rt2x00_dev *rt2x00dev)
 
                 if (usb_endpoint_is_bulk_in(ep_desc)) {
                         rt2x00usb_assign_endpoint(rt2x00dev->rx, ep_desc);
-                } else if (usb_endpoint_is_bulk_out(ep_desc)) {
+                } else if (usb_endpoint_is_bulk_out(ep_desc) &&
+                           (queue != queue_end(rt2x00dev))) {
                         rt2x00usb_assign_endpoint(queue, ep_desc);
+                        queue = queue_next(queue);
 
-                        if (queue != queue_end(rt2x00dev))
-                                queue = queue_next(queue);
                         tx_ep_desc = ep_desc;
                 }
         }
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index d638a8a59370..96a8d69f8790 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -2321,6 +2321,7 @@ static struct usb_device_id rt73usb_device_table[] = {
         /* Linksys */
         { USB_DEVICE(0x13b1, 0x0020), USB_DEVICE_DATA(&rt73usb_ops) },
         { USB_DEVICE(0x13b1, 0x0023), USB_DEVICE_DATA(&rt73usb_ops) },
+        { USB_DEVICE(0x13b1, 0x0028), USB_DEVICE_DATA(&rt73usb_ops) },
         /* MSI */
         { USB_DEVICE(0x0db0, 0x6877), USB_DEVICE_DATA(&rt73usb_ops) },
         { USB_DEVICE(0x0db0, 0x6874), USB_DEVICE_DATA(&rt73usb_ops) },
diff --git a/drivers/net/wireless/rtl818x/rtl8180_dev.c b/drivers/net/wireless/rtl818x/rtl8180_dev.c
index 5f887fb137a9..387c133ec0f2 100644
--- a/drivers/net/wireless/rtl818x/rtl8180_dev.c
+++ b/drivers/net/wireless/rtl818x/rtl8180_dev.c
@@ -897,6 +897,7 @@ static int __devinit rtl8180_probe(struct pci_dev *pdev,
         dev->flags = IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
                      IEEE80211_HW_RX_INCLUDES_FCS |
                      IEEE80211_HW_SIGNAL_UNSPEC;
+        dev->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
         dev->queues = 1;
         dev->max_signal = 65;
 
diff --git a/drivers/net/wireless/rtl818x/rtl8187_dev.c b/drivers/net/wireless/rtl818x/rtl8187_dev.c
index 00ce3ef39abe..22bc07ef2f37 100644
--- a/drivers/net/wireless/rtl818x/rtl8187_dev.c
+++ b/drivers/net/wireless/rtl818x/rtl8187_dev.c
@@ -213,7 +213,7 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
                 kfree_skb(skb);
-                return -ENOMEM;
+                return NETDEV_TX_OK;
         }
 
         flags = skb->len;
@@ -273,6 +273,7 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
 
         usb_fill_bulk_urb(urb, priv->udev, usb_sndbulkpipe(priv->udev, ep),
                           buf, skb->len, rtl8187_tx_cb, skb);
+        urb->transfer_flags |= URB_ZERO_PACKET;
         usb_anchor_urb(urb, &priv->anchored);
         rc = usb_submit_urb(urb, GFP_ATOMIC);
         if (rc < 0) {
@@ -281,7 +282,7 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
         }
         usb_free_urb(urb);
 
-        return rc;
+        return NETDEV_TX_OK;
 }
 
 static void rtl8187_rx_cb(struct urb *urb)
@@ -1471,6 +1472,7 @@ static void __devexit rtl8187_disconnect(struct usb_interface *intf)
         ieee80211_unregister_hw(dev);
 
         priv = dev->priv;
+        usb_reset_device(priv->udev);
         usb_put_dev(interface_to_usbdev(intf));
         ieee80211_free_hw(dev);
 }
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index b5db57d2fcf5..17527f765b39 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -84,6 +84,7 @@ static struct usb_device_id usb_ids[] = {
         { USB_DEVICE(0x0586, 0x340a), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
         { USB_DEVICE(0x07fa, 0x1196), .driver_info = DEVICE_ZD1211B },
+        { USB_DEVICE(0x0df6, 0x0036), .driver_info = DEVICE_ZD1211B },
         /* "Driverless" devices that need ejecting */
         { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
         { USB_DEVICE(0x0ace, 0x20ff), .driver_info = DEVICE_INSTALLER },
diff --git a/drivers/oprofile/cpu_buffer.c b/drivers/oprofile/cpu_buffer.c
index 2e03b6d796d3..e76d715e4342 100644
--- a/drivers/oprofile/cpu_buffer.c
+++ b/drivers/oprofile/cpu_buffer.c
@@ -393,16 +393,21 @@ oprofile_write_reserve(struct op_entry *entry, struct pt_regs * const regs,
         return;
 
 fail:
+        entry->event = NULL;
         cpu_buf->sample_lost_overflow++;
 }
 
 int oprofile_add_data(struct op_entry *entry, unsigned long val)
 {
+        if (!entry->event)
+                return 0;
         return op_cpu_buffer_add_data(entry, val);
 }
 
 int oprofile_write_commit(struct op_entry *entry)
 {
+        if (!entry->event)
+                return -EINVAL;
         return op_cpu_buffer_write_commit(entry);
 }
 
diff --git a/drivers/oprofile/cpu_buffer.h b/drivers/oprofile/cpu_buffer.h
index 63f81c44846a..272995d20293 100644
--- a/drivers/oprofile/cpu_buffer.h
+++ b/drivers/oprofile/cpu_buffer.h
@@ -66,6 +66,13 @@ static inline void op_cpu_buffer_reset(int cpu)
         cpu_buf->last_task = NULL;
 }
 
+/*
+ * op_cpu_buffer_add_data() and op_cpu_buffer_write_commit() may be
+ * called only if op_cpu_buffer_write_reserve() did not return NULL or
+ * entry->event != NULL, otherwise entry->size or entry->event will be
+ * used uninitialized.
+ */
+
 struct op_sample
 *op_cpu_buffer_write_reserve(struct op_entry *entry, unsigned long size);
 int op_cpu_buffer_write_commit(struct op_entry *entry);
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c
index f09b1010d477..803d9ddd6e75 100644
--- a/drivers/pci/hotplug/acpiphp_glue.c
+++ b/drivers/pci/hotplug/acpiphp_glue.c
@@ -266,6 +266,8 @@ static int detect_ejectable_slots(struct pci_bus *pbus)
         int found = acpi_pci_detect_ejectable(pbus);
         if (!found) {
                 acpi_handle bridge_handle = acpi_pci_get_bridge_handle(pbus);
+                if (!bridge_handle)
+                        return 0;
                 acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge_handle, (u32)1,
                                     is_pci_dock_device, (void *)&found, NULL);
         }
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 5482d4ed8256..c2485542f543 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -126,8 +126,10 @@ static int set_lock_status(struct hotplug_slot *hotplug_slot, u8 status)
         mutex_lock(&slot->ctrl->crit_sect);
 
         /* has it been >1 sec since our last toggle? */
-        if ((get_seconds() - slot->last_emi_toggle) < 1)
+        if ((get_seconds() - slot->last_emi_toggle) < 1) {
+                mutex_unlock(&slot->ctrl->crit_sect);
                 return -EINVAL;
+        }
 
         /* see what our current state is */
         retval = get_lock_status(hotplug_slot, &value);
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index b4a90badd0a6..896a15d70f5b 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -398,21 +398,19 @@ static int msi_capability_init(struct pci_dev *dev)
         entry->msi_attrib.masked = 1;
         entry->msi_attrib.default_irq = dev->irq;       /* Save IOAPIC IRQ */
         entry->msi_attrib.pos = pos;
-        if (entry->msi_attrib.maskbit) {
-                entry->mask_base = (void __iomem *)(long)msi_mask_bits_reg(pos,
-                                entry->msi_attrib.is_64);
-        }
         entry->dev = dev;
         if (entry->msi_attrib.maskbit) {
-                unsigned int maskbits, temp;
+                unsigned int base, maskbits, temp;
+
+                base = msi_mask_bits_reg(pos, entry->msi_attrib.is_64);
+                entry->mask_base = (void __iomem *)(long)base;
+
                 /* All MSIs are unmasked by default, Mask them all */
-                pci_read_config_dword(dev,
-                        msi_mask_bits_reg(pos, entry->msi_attrib.is_64),
-                        &maskbits);
+                pci_read_config_dword(dev, base, &maskbits);
                 temp = (1 << multi_msi_capable(control));
                 temp = ((temp - 1) & ~temp);
                 maskbits |= temp;
-                pci_write_config_dword(dev, entry->msi_attrib.is_64, maskbits);
+                pci_write_config_dword(dev, base, maskbits);
                 entry->msi_attrib.maskbits_mask = temp;
         }
         list_add_tail(&entry->list, &dev->msi_list);
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index c697f2680856..9de07b75b993 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -355,17 +355,27 @@ static int pci_legacy_suspend(struct device *dev, pm_message_t state)
         int i = 0;
 
         if (drv && drv->suspend) {
+                pci_dev->state_saved = false;
+
                 i = drv->suspend(pci_dev, state);
                 suspend_report_result(drv->suspend, i);
-        } else {
-                pci_save_state(pci_dev);
-                /*
-                 * This is for compatibility with existing code with legacy PM
-                 * support.
-                 */
-                pci_pm_set_unknown_state(pci_dev);
+                if (i)
+                        return i;
+
+                if (pci_dev->state_saved)
+                        goto Fixup;
+
+                if (WARN_ON_ONCE(pci_dev->current_state != PCI_D0))
+                        goto Fixup;
         }
 
+        pci_save_state(pci_dev);
+        /*
+         * This is for compatibility with existing code with legacy PM support.
+         */
+        pci_pm_set_unknown_state(pci_dev);
+
+ Fixup:
         pci_fixup_device(pci_fixup_suspend, pci_dev);
 
         return i;
@@ -386,81 +396,34 @@ static int pci_legacy_suspend_late(struct device *dev, pm_message_t state)
 
 static int pci_legacy_resume_early(struct device *dev)
 {
-        int error = 0;
         struct pci_dev * pci_dev = to_pci_dev(dev);
         struct pci_driver * drv = pci_dev->driver;
 
-        pci_fixup_device(pci_fixup_resume_early, pci_dev);
-
-        if (drv && drv->resume_early)
-                error = drv->resume_early(pci_dev);
-        return error;
+        return drv && drv->resume_early ?
+                        drv->resume_early(pci_dev) : 0;
 }
 
 static int pci_legacy_resume(struct device *dev)
 {
-        int error;
         struct pci_dev * pci_dev = to_pci_dev(dev);
         struct pci_driver * drv = pci_dev->driver;
 
         pci_fixup_device(pci_fixup_resume, pci_dev);
 
-        if (drv && drv->resume) {
-                error = drv->resume(pci_dev);
-        } else {
-                /* restore the PCI config space */
-                pci_restore_state(pci_dev);
-                error = pci_pm_reenable_device(pci_dev);
-        }
-        return error;
+        return drv && drv->resume ?
+                        drv->resume(pci_dev) : pci_pm_reenable_device(pci_dev);
 }
 
 /* Auxiliary functions used by the new power management framework */
 
-static int pci_restore_standard_config(struct pci_dev *pci_dev)
-{
-        struct pci_dev *parent = pci_dev->bus->self;
-        int error = 0;
-
-        /* Check if the device's bus is operational */
-        if (!parent || parent->current_state == PCI_D0) {
-                pci_restore_state(pci_dev);
-                pci_update_current_state(pci_dev, PCI_D0);
-        } else {
-                dev_warn(&pci_dev->dev, "unable to restore config, "
-                        "bridge %s in low power state D%d\n", pci_name(parent),
-                        parent->current_state);
-                pci_dev->current_state = PCI_UNKNOWN;
-                error = -EAGAIN;
-        }
-
-        return error;
-}
-
-static bool pci_is_bridge(struct pci_dev *pci_dev)
-{
-        return !!(pci_dev->subordinate);
-}
-
 static void pci_pm_default_resume_noirq(struct pci_dev *pci_dev)
 {
-        if (pci_restore_standard_config(pci_dev))
-                pci_fixup_device(pci_fixup_resume_early, pci_dev);
+        pci_restore_standard_config(pci_dev);
+        pci_fixup_device(pci_fixup_resume_early, pci_dev);
 }
 
 static int pci_pm_default_resume(struct pci_dev *pci_dev)
 {
-        /*
-         * pci_restore_standard_config() should have been called once already,
-         * but it would have failed if the device's parent bridge had not been
-         * in power state D0 at that time.  Check it and try again if necessary.
-         */
-        if (pci_dev->current_state == PCI_UNKNOWN) {
-                int error = pci_restore_standard_config(pci_dev);
-                if (error)
-                        return error;
-        }
-
         pci_fixup_device(pci_fixup_resume, pci_dev);
 
         if (!pci_is_bridge(pci_dev))
@@ -575,11 +538,11 @@ static int pci_pm_resume_noirq(struct device *dev)
         struct device_driver *drv = dev->driver;
         int error = 0;
 
+        pci_pm_default_resume_noirq(pci_dev);
+
         if (pci_has_legacy_pm_support(pci_dev))
                 return pci_legacy_resume_early(dev);
 
-        pci_pm_default_resume_noirq(pci_dev);
-
         if (drv && drv->pm && drv->pm->resume_noirq)
                 error = drv->pm->resume_noirq(dev);
 
@@ -730,11 +693,11 @@ static int pci_pm_restore_noirq(struct device *dev)
         struct device_driver *drv = dev->driver;
         int error = 0;
 
+        pci_pm_default_resume_noirq(pci_dev);
+
         if (pci_has_legacy_pm_support(pci_dev))
                 return pci_legacy_resume_early(dev);
 
-        pci_pm_default_resume_noirq(pci_dev);
-
         if (drv && drv->pm && drv->pm->restore_noirq)
                 error = drv->pm->restore_noirq(dev);
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index c12f6c790698..17bd9325a245 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -22,7 +22,7 @@
 #include <asm/dma.h>    /* isa_dma_bridge_buggy */
 #include "pci.h"
 
-unsigned int pci_pm_d3_delay = 10;
+unsigned int pci_pm_d3_delay = PCI_PM_D3_WAIT;
 
 #ifdef CONFIG_PCI_DOMAINS
 int pci_domains_supported = 1;
@@ -426,6 +426,7 @@ static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
  *                           given PCI device
  * @dev: PCI device to handle.
  * @state: PCI power state (D0, D1, D2, D3hot) to put the device into.
+ * @wait: If 'true', wait for the device to change its power state
  *
  * RETURN VALUE:
  * -EINVAL if the requested state is invalid.
@@ -435,7 +436,7 @@ static inline int platform_pci_sleep_wake(struct pci_dev *dev, bool enable)
  * 0 if device's power state has been successfully changed.
  */
 static int
-pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
+pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state, bool wait)
 {
         u16 pmcsr;
         bool need_restore = false;
@@ -480,8 +481,10 @@ pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
                 break;
         case PCI_UNKNOWN: /* Boot-up */
                 if ((pmcsr & PCI_PM_CTRL_STATE_MASK) == PCI_D3hot
-                 && !(pmcsr & PCI_PM_CTRL_NO_SOFT_RESET))
+                 && !(pmcsr & PCI_PM_CTRL_NO_SOFT_RESET)) {
                         need_restore = true;
+                        wait = true;
+                }
                 /* Fall-through: force to D0 */
         default:
                 pmcsr = 0;
@@ -491,12 +494,15 @@ pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
         /* enter specified state */
         pci_write_config_word(dev, dev->pm_cap + PCI_PM_CTRL, pmcsr);
 
+        if (!wait)
+                return 0;
+
         /* Mandatory power management transition delays */
         /* see PCI PM 1.1 5.6.1 table 18 */
         if (state == PCI_D3hot || dev->current_state == PCI_D3hot)
                 msleep(pci_pm_d3_delay);
         else if (state == PCI_D2 || dev->current_state == PCI_D2)
-                udelay(200);
+                udelay(PCI_PM_D2_DELAY);
 
         dev->current_state = state;
 
@@ -515,7 +521,7 @@ pci_raw_set_power_state(struct pci_dev *dev, pci_power_t state)
         if (need_restore)
                 pci_restore_bars(dev);
 
-        if (dev->bus->self)
+        if (wait && dev->bus->self)
                 pcie_aspm_pm_state_change(dev->bus->self);
 
         return 0;
@@ -585,7 +591,7 @@ int pci_set_power_state(struct pci_dev *dev, pci_power_t state)
         if (state == PCI_D3hot && (dev->dev_flags & PCI_DEV_FLAGS_NO_D3))
                 return 0;
 
-        error = pci_raw_set_power_state(dev, state);
+        error = pci_raw_set_power_state(dev, state, true);
 
         if (state > PCI_D0 && platform_pci_power_manageable(dev)) {
                 /* Allow the platform to finalize the transition */
@@ -730,6 +736,7 @@ pci_save_state(struct pci_dev *dev)
         /* XXX: 100% dword access ok here? */
         for (i = 0; i < 16; i++)
                 pci_read_config_dword(dev, i * 4,&dev->saved_config_space[i]);
+        dev->state_saved = true;
         if ((i = pci_save_pcie_state(dev)) != 0)
                 return i;
         if ((i = pci_save_pcix_state(dev)) != 0)
@@ -1260,15 +1267,14 @@ void pci_pm_init(struct pci_dev *dev)
         /* find PCI PM capability in list */
         pm = pci_find_capability(dev, PCI_CAP_ID_PM);
         if (!pm)
-                goto Exit;
-
+                return;
         /* Check device's ability to generate PME# */
         pci_read_config_word(dev, pm + PCI_PM_PMC, &pmc);
 
         if ((pmc & PCI_PM_CAP_VER_MASK) > 3) {
                 dev_err(&dev->dev, "unsupported PM cap regs version (%u)\n",
                         pmc & PCI_PM_CAP_VER_MASK);
-                goto Exit;
+                return;
         }
 
         dev->pm_cap = pm;
@@ -1307,9 +1313,6 @@ void pci_pm_init(struct pci_dev *dev)
         } else {
                 dev->pme_support = 0;
         }
-
- Exit:
-        pci_update_current_state(dev, PCI_D0);
 }
 
 /**
@@ -1378,6 +1381,50 @@ void pci_allocate_cap_save_buffers(struct pci_dev *dev)
 }
 
 /**
+ * pci_restore_standard_config - restore standard config registers of PCI device
+ * @dev: PCI device to handle
+ *
+ * This function assumes that the device's configuration space is accessible.
+ * If the device needs to be powered up, the function will wait for it to
+ * change the state.
+ */
+int pci_restore_standard_config(struct pci_dev *dev)
+{
+        pci_power_t prev_state;
+        int error;
+
+        pci_restore_state(dev);
+        pci_update_current_state(dev, PCI_D0);
+
+        prev_state = dev->current_state;
+        if (prev_state == PCI_D0)
+                return 0;
+
+        error = pci_raw_set_power_state(dev, PCI_D0, false);
+        if (error)
+                return error;
+
+        if (pci_is_bridge(dev)) {
+                if (prev_state > PCI_D1)
+                        mdelay(PCI_PM_BUS_WAIT);
+        } else {
+                switch(prev_state) {
+                case PCI_D3cold:
+                case PCI_D3hot:
+                        mdelay(pci_pm_d3_delay);
+                        break;
+                case PCI_D2:
+                        udelay(PCI_PM_D2_DELAY);
+                        break;
+                }
+        }
+
+        dev->current_state = PCI_D0;
+
+        return 0;
+}
+
+/**
  * pci_enable_ari - enable ARI forwarding if hardware support it
  * @dev: the PCI device
  */
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index 1351bb4addde..26ddf78ac300 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -49,6 +49,12 @@ extern void pci_disable_enabled_device(struct pci_dev *dev);
 extern void pci_pm_init(struct pci_dev *dev);
 extern void platform_pci_wakeup_init(struct pci_dev *dev);
 extern void pci_allocate_cap_save_buffers(struct pci_dev *dev);
+extern int pci_restore_standard_config(struct pci_dev *dev);
+
+static inline bool pci_is_bridge(struct pci_dev *pci_dev)
+{
+        return !!(pci_dev->subordinate);
+}
 
 extern int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
 extern int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index e65448e99b48..1a266d4ab5f1 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -54,6 +54,18 @@ config ASUS_LAPTOP
 
           If you have an ACPI-compatible ASUS laptop, say Y or M here.
 
+config DELL_LAPTOP
+        tristate "Dell Laptop Extras (EXPERIMENTAL)"
+        depends on X86
+        depends on DCDBAS
+        depends on EXPERIMENTAL
+        depends on BACKLIGHT_CLASS_DEVICE
+        depends on RFKILL
+        default n
+        ---help---
+        This driver adds support for rfkill and backlight control to Dell
+        laptops.
+
 config FUJITSU_LAPTOP
         tristate "Fujitsu Laptop Extras"
         depends on ACPI
@@ -192,6 +204,17 @@ config THINKPAD_ACPI
 
           If you have an IBM or Lenovo ThinkPad laptop, say Y or M here.
 
+config THINKPAD_ACPI_DEBUGFACILITIES
+        bool "Maintainer debug facilities"
+        depends on THINKPAD_ACPI
+        default n
+        ---help---
+          Enables extra stuff in the thinkpad-acpi which is completely useless
+          for normal use.  Read the driver source to find out what it does.
+
+          Say N here, unless you were told by a kernel maintainer to do
+          otherwise.
+
 config THINKPAD_ACPI_DEBUG
         bool "Verbose debug mode"
         depends on THINKPAD_ACPI
diff --git a/drivers/platform/x86/Makefile b/drivers/platform/x86/Makefile
index 1e9de2ae0de5..e29065120be9 100644
--- a/drivers/platform/x86/Makefile
+++ b/drivers/platform/x86/Makefile
@@ -6,6 +6,7 @@ obj-$(CONFIG_ASUS_LAPTOP)	+= asus-laptop.o
 obj-$(CONFIG_EEEPC_LAPTOP)      += eeepc-laptop.o
 obj-$(CONFIG_MSI_LAPTOP)        += msi-laptop.o
 obj-$(CONFIG_COMPAL_LAPTOP)     += compal-laptop.o
+obj-$(CONFIG_DELL_LAPTOP)       += dell-laptop.o
 obj-$(CONFIG_ACER_WMI)          += acer-wmi.o
 obj-$(CONFIG_HP_WMI)            += hp-wmi.o
 obj-$(CONFIG_TC1100_WMI)        += tc1100-wmi.o
diff --git a/drivers/misc/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index 4d33a2068b7a..16e11c2ee19a 100644
--- a/drivers/misc/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -22,7 +22,7 @@
 #include <linux/rfkill.h>
 #include <linux/power_supply.h>
 #include <linux/acpi.h>
-#include "../firmware/dcdbas.h"
+#include "../../firmware/dcdbas.h"
 
 #define BRIGHTNESS_TOKEN 0x7d
 
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index 02fe2b8b8939..9d93cb971e59 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -90,7 +90,7 @@ enum {
 };
 
 static const char *cm_getv[] = {
-        "WLDG", NULL, NULL, NULL,
+        "WLDG", "BTHG", NULL, NULL,
         "CAMG", NULL, NULL, NULL,
         NULL, "PBLG", NULL, NULL,
         "CFVG", NULL, NULL, NULL,
@@ -99,7 +99,7 @@ static const char *cm_getv[] = {
 };
 
 static const char *cm_setv[] = {
-        "WLDS", NULL, NULL, NULL,
+        "WLDS", "BTHS", NULL, NULL,
         "CAMS", NULL, NULL, NULL,
         "SDSP", "PBLS", "HDPS", NULL,
         "CFVS", NULL, NULL, NULL,
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index 3478453eba7a..bcbc05107ba8 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -21,7 +21,7 @@
  *  02110-1301, USA.
  */
 
-#define TPACPI_VERSION "0.21"
+#define TPACPI_VERSION "0.22"
 #define TPACPI_SYSFS_VERSION 0x020200
 
 /*
@@ -122,6 +122,27 @@ enum {
 #define TPACPI_HKEY_INPUT_PRODUCT       0x5054 /* "TP" */
 #define TPACPI_HKEY_INPUT_VERSION       0x4101
 
+/* ACPI \WGSV commands */
+enum {
+        TP_ACPI_WGSV_GET_STATE          = 0x01, /* Get state information */
+        TP_ACPI_WGSV_PWR_ON_ON_RESUME   = 0x02, /* Resume WWAN powered on */
+        TP_ACPI_WGSV_PWR_OFF_ON_RESUME  = 0x03, /* Resume WWAN powered off */
+        TP_ACPI_WGSV_SAVE_STATE         = 0x04, /* Save state for S4/S5 */
+};
+
+/* TP_ACPI_WGSV_GET_STATE bits */
+enum {
+        TP_ACPI_WGSV_STATE_WWANEXIST    = 0x0001, /* WWAN hw available */
+        TP_ACPI_WGSV_STATE_WWANPWR      = 0x0002, /* WWAN radio enabled */
+        TP_ACPI_WGSV_STATE_WWANPWRRES   = 0x0004, /* WWAN state at resume */
+        TP_ACPI_WGSV_STATE_WWANBIOSOFF  = 0x0008, /* WWAN disabled in BIOS */
+        TP_ACPI_WGSV_STATE_BLTHEXIST    = 0x0001, /* BLTH hw available */
+        TP_ACPI_WGSV_STATE_BLTHPWR      = 0x0002, /* BLTH radio enabled */
+        TP_ACPI_WGSV_STATE_BLTHPWRRES   = 0x0004, /* BLTH state at resume */
+        TP_ACPI_WGSV_STATE_BLTHBIOSOFF  = 0x0008, /* BLTH disabled in BIOS */
+        TP_ACPI_WGSV_STATE_UWBEXIST     = 0x0010, /* UWB hw available */
+        TP_ACPI_WGSV_STATE_UWBPWR       = 0x0020, /* UWB radio enabled */
+};
 
 /****************************************************************************
  * Main driver
@@ -148,14 +169,17 @@ enum {
 enum {
         TPACPI_RFK_BLUETOOTH_SW_ID = 0,
         TPACPI_RFK_WWAN_SW_ID,
+        TPACPI_RFK_UWB_SW_ID,
 };
 
 /* Debugging */
 #define TPACPI_LOG TPACPI_FILE ": "
-#define TPACPI_ERR         KERN_ERR    TPACPI_LOG
-#define TPACPI_NOTICE KERN_NOTICE TPACPI_LOG
-#define TPACPI_INFO   KERN_INFO   TPACPI_LOG
-#define TPACPI_DEBUG  KERN_DEBUG  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_NOTICE   KERN_NOTICE TPACPI_LOG
+#define TPACPI_INFO     KERN_INFO   TPACPI_LOG
+#define TPACPI_DEBUG    KERN_DEBUG  TPACPI_LOG
 
 #define TPACPI_DBG_ALL          0xffff
 #define TPACPI_DBG_INIT         0x0001
@@ -201,6 +225,7 @@ struct ibm_struct {
         void (*exit) (void);
         void (*resume) (void);
         void (*suspend) (pm_message_t state);
+        void (*shutdown) (void);
 
         struct list_head all_drivers;
 
@@ -239,6 +264,7 @@ static struct {
         u32 bright_16levels:1;
         u32 bright_acpimode:1;
         u32 wan:1;
+        u32 uwb:1;
         u32 fan_ctrl_status_undef:1;
         u32 input_device_registered:1;
         u32 platform_drv_registered:1;
@@ -288,6 +314,18 @@ struct tpacpi_led_classdev {
         unsigned int led;
 };
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+static int dbg_wlswemul;
+static int tpacpi_wlsw_emulstate;
+static int dbg_bluetoothemul;
+static int tpacpi_bluetooth_emulstate;
+static int dbg_wwanemul;
+static int tpacpi_wwan_emulstate;
+static int dbg_uwbemul;
+static int tpacpi_uwb_emulstate;
+#endif
+
+
 /****************************************************************************
  ****************************************************************************
  *
@@ -728,6 +766,18 @@ static int tpacpi_resume_handler(struct platform_device *pdev)
         return 0;
 }
 
+static void tpacpi_shutdown_handler(struct platform_device *pdev)
+{
+        struct ibm_struct *ibm, *itmp;
+
+        list_for_each_entry_safe(ibm, itmp,
+                                 &tpacpi_all_drivers,
+                                 all_drivers) {
+                if (ibm->shutdown)
+                        (ibm->shutdown)();
+        }
+}
+
 static struct platform_driver tpacpi_pdriver = {
         .driver = {
                 .name = TPACPI_DRVR_NAME,
@@ -735,6 +785,7 @@ static struct platform_driver tpacpi_pdriver = {
         },
         .suspend = tpacpi_suspend_handler,
         .resume = tpacpi_resume_handler,
+        .shutdown = tpacpi_shutdown_handler,
 };
 
 static struct platform_driver tpacpi_hwmon_pdriver = {
@@ -922,11 +973,27 @@ static int __init tpacpi_new_rfkill(const unsigned int id,
                         struct rfkill **rfk,
                         const enum rfkill_type rfktype,
                         const char *name,
+                        const bool set_default,
                         int (*toggle_radio)(void *, enum rfkill_state),
                         int (*get_state)(void *, enum rfkill_state *))
 {
         int res;
-        enum rfkill_state initial_state;
+        enum rfkill_state initial_state = RFKILL_STATE_SOFT_BLOCKED;
+
+        res = get_state(NULL, &initial_state);
+        if (res < 0) {
+                printk(TPACPI_ERR
+                        "failed to read initial state for %s, error %d; "
+                        "will turn radio off\n", name, res);
+        } else if (set_default) {
+                /* try to set the initial state as the default for the rfkill
+                 * type, since we ask the firmware to preserve it across S5 in
+                 * NVRAM */
+                rfkill_set_default(rfktype,
+                                (initial_state == RFKILL_STATE_UNBLOCKED) ?
+                                        RFKILL_STATE_UNBLOCKED :
+                                        RFKILL_STATE_SOFT_BLOCKED);
+        }
 
         *rfk = rfkill_allocate(&tpacpi_pdev->dev, rfktype);
         if (!*rfk) {
@@ -938,9 +1005,7 @@ static int __init tpacpi_new_rfkill(const unsigned int id,
         (*rfk)->name = name;
         (*rfk)->get_state = get_state;
         (*rfk)->toggle_radio = toggle_radio;
-
-        if (!get_state(NULL, &initial_state))
-                (*rfk)->state = initial_state;
+        (*rfk)->state = initial_state;
 
         res = rfkill_register(*rfk);
         if (res < 0) {
@@ -1006,6 +1071,119 @@ static DRIVER_ATTR(version, S_IRUGO,
 
 /* --------------------------------------------------------------------- */
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+
+static void tpacpi_send_radiosw_update(void);
+
+/* wlsw_emulstate ------------------------------------------------------ */
+static ssize_t tpacpi_driver_wlsw_emulstate_show(struct device_driver *drv,
+                                                char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wlsw_emulstate);
+}
+
+static ssize_t tpacpi_driver_wlsw_emulstate_store(struct device_driver *drv,
+                                                const char *buf, size_t count)
+{
+        unsigned long t;
+
+        if (parse_strtoul(buf, 1, &t))
+                return -EINVAL;
+
+        if (tpacpi_wlsw_emulstate != t) {
+                tpacpi_wlsw_emulstate = !!t;
+                tpacpi_send_radiosw_update();
+        } else
+                tpacpi_wlsw_emulstate = !!t;
+
+        return count;
+}
+
+static DRIVER_ATTR(wlsw_emulstate, S_IWUSR | S_IRUGO,
+                tpacpi_driver_wlsw_emulstate_show,
+                tpacpi_driver_wlsw_emulstate_store);
+
+/* bluetooth_emulstate ------------------------------------------------- */
+static ssize_t tpacpi_driver_bluetooth_emulstate_show(
+                                        struct device_driver *drv,
+                                        char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_bluetooth_emulstate);
+}
+
+static ssize_t tpacpi_driver_bluetooth_emulstate_store(
+                                        struct device_driver *drv,
+                                        const char *buf, size_t count)
+{
+        unsigned long t;
+
+        if (parse_strtoul(buf, 1, &t))
+                return -EINVAL;
+
+        tpacpi_bluetooth_emulstate = !!t;
+
+        return count;
+}
+
+static DRIVER_ATTR(bluetooth_emulstate, S_IWUSR | S_IRUGO,
+                tpacpi_driver_bluetooth_emulstate_show,
+                tpacpi_driver_bluetooth_emulstate_store);
+
+/* wwan_emulstate ------------------------------------------------- */
+static ssize_t tpacpi_driver_wwan_emulstate_show(
+                                        struct device_driver *drv,
+                                        char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_wwan_emulstate);
+}
+
+static ssize_t tpacpi_driver_wwan_emulstate_store(
+                                        struct device_driver *drv,
+                                        const char *buf, size_t count)
+{
+        unsigned long t;
+
+        if (parse_strtoul(buf, 1, &t))
+                return -EINVAL;
+
+        tpacpi_wwan_emulstate = !!t;
+
+        return count;
+}
+
+static DRIVER_ATTR(wwan_emulstate, S_IWUSR | S_IRUGO,
+                tpacpi_driver_wwan_emulstate_show,
+                tpacpi_driver_wwan_emulstate_store);
+
+/* uwb_emulstate ------------------------------------------------- */
+static ssize_t tpacpi_driver_uwb_emulstate_show(
+                                        struct device_driver *drv,
+                                        char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!tpacpi_uwb_emulstate);
+}
+
+static ssize_t tpacpi_driver_uwb_emulstate_store(
+                                        struct device_driver *drv,
+                                        const char *buf, size_t count)
+{
+        unsigned long t;
+
+        if (parse_strtoul(buf, 1, &t))
+                return -EINVAL;
+
+        tpacpi_uwb_emulstate = !!t;
+
+        return count;
+}
+
+static DRIVER_ATTR(uwb_emulstate, S_IWUSR | S_IRUGO,
+                tpacpi_driver_uwb_emulstate_show,
+                tpacpi_driver_uwb_emulstate_store);
+#endif
+
+/* --------------------------------------------------------------------- */
+
 static struct driver_attribute *tpacpi_driver_attributes[] = {
         &driver_attr_debug_level, &driver_attr_version,
         &driver_attr_interface_version,
@@ -1022,6 +1200,17 @@ static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
                 i++;
         }
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (!res && dbg_wlswemul)
+                res = driver_create_file(drv, &driver_attr_wlsw_emulstate);
+        if (!res && dbg_bluetoothemul)
+                res = driver_create_file(drv, &driver_attr_bluetooth_emulstate);
+        if (!res && dbg_wwanemul)
+                res = driver_create_file(drv, &driver_attr_wwan_emulstate);
+        if (!res && dbg_uwbemul)
+                res = driver_create_file(drv, &driver_attr_uwb_emulstate);
+#endif
+
         return res;
 }
 
@@ -1031,6 +1220,13 @@ static void tpacpi_remove_driver_attributes(struct device_driver *drv)
 
         for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
                 driver_remove_file(drv, tpacpi_driver_attributes[i]);
+
+#ifdef THINKPAD_ACPI_DEBUGFACILITIES
+        driver_remove_file(drv, &driver_attr_wlsw_emulstate);
+        driver_remove_file(drv, &driver_attr_bluetooth_emulstate);
+        driver_remove_file(drv, &driver_attr_wwan_emulstate);
+        driver_remove_file(drv, &driver_attr_uwb_emulstate);
+#endif
 }
 
 /****************************************************************************
@@ -1216,6 +1412,12 @@ static struct attribute_set *hotkey_dev_attributes;
 
 static int hotkey_get_wlsw(int *status)
 {
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_wlswemul) {
+                *status = !!tpacpi_wlsw_emulstate;
+                return 0;
+        }
+#endif
         if (!acpi_evalf(hkey_handle, status, "WLSW", "d"))
                 return -EIO;
         return 0;
@@ -1678,7 +1880,7 @@ static ssize_t hotkey_mask_show(struct device *dev,
 {
         int res;
 
-        if (mutex_lock_interruptible(&hotkey_mutex))
+        if (mutex_lock_killable(&hotkey_mutex))
                 return -ERESTARTSYS;
         res = hotkey_mask_get();
         mutex_unlock(&hotkey_mutex);
@@ -1697,7 +1899,7 @@ static ssize_t hotkey_mask_store(struct device *dev,
         if (parse_strtoul(buf, 0xffffffffUL, &t))
                 return -EINVAL;
 
-        if (mutex_lock_interruptible(&hotkey_mutex))
+        if (mutex_lock_killable(&hotkey_mutex))
                 return -ERESTARTSYS;
 
         res = hotkey_mask_set(t);
@@ -1783,7 +1985,7 @@ static ssize_t hotkey_source_mask_store(struct device *dev,
                 ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
                 return -EINVAL;
 
-        if (mutex_lock_interruptible(&hotkey_mutex))
+        if (mutex_lock_killable(&hotkey_mutex))
                 return -ERESTARTSYS;
 
         HOTKEY_CONFIG_CRITICAL_START
@@ -1818,7 +2020,7 @@ static ssize_t hotkey_poll_freq_store(struct device *dev,
         if (parse_strtoul(buf, 25, &t))
                 return -EINVAL;
 
-        if (mutex_lock_interruptible(&hotkey_mutex))
+        if (mutex_lock_killable(&hotkey_mutex))
                 return -ERESTARTSYS;
 
         hotkey_poll_freq = t;
@@ -1958,6 +2160,7 @@ static struct attribute *hotkey_mask_attributes[] __initdata = {
 
 static void bluetooth_update_rfk(void);
 static void wan_update_rfk(void);
+static void uwb_update_rfk(void);
 static void tpacpi_send_radiosw_update(void)
 {
         int wlsw;
@@ -1967,6 +2170,8 @@ static void tpacpi_send_radiosw_update(void)
                 bluetooth_update_rfk();
         if (tp_features.wan)
                 wan_update_rfk();
+        if (tp_features.uwb)
+                uwb_update_rfk();
 
         if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw)) {
                 mutex_lock(&tpacpi_inputdev_send_mutex);
@@ -2222,6 +2427,13 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                     hotkey_source_mask, hotkey_poll_freq);
 #endif
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_wlswemul) {
+                tp_features.hotkey_wlsw = 1;
+                printk(TPACPI_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;
@@ -2361,13 +2573,154 @@ err_exit:
         return (res < 0)? res : 1;
 }
 
+static bool hotkey_notify_hotkey(const u32 hkey,
+                                 bool *send_acpi_ev,
+                                 bool *ignore_acpi_ev)
+{
+        /* 0x1000-0x1FFF: key presses */
+        unsigned int scancode = hkey & 0xfff;
+        *send_acpi_ev = true;
+        *ignore_acpi_ev = false;
+
+        if (scancode > 0 && scancode < 0x21) {
+                scancode--;
+                if (!(hotkey_source_mask & (1 << scancode))) {
+                        tpacpi_input_send_key(scancode);
+                        *send_acpi_ev = false;
+                } else {
+                        *ignore_acpi_ev = true;
+                }
+                return true;
+        }
+        return false;
+}
+
+static bool hotkey_notify_wakeup(const u32 hkey,
+                                 bool *send_acpi_ev,
+                                 bool *ignore_acpi_ev)
+{
+        /* 0x2000-0x2FFF: Wakeup reason */
+        *send_acpi_ev = true;
+        *ignore_acpi_ev = false;
+
+        switch (hkey) {
+        case 0x2304: /* suspend, undock */
+        case 0x2404: /* hibernation, undock */
+                hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
+                *ignore_acpi_ev = true;
+                break;
+
+        case 0x2305: /* suspend, bay eject */
+        case 0x2405: /* hibernation, bay eject */
+                hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
+                *ignore_acpi_ev = true;
+                break;
+
+        case 0x2313: /* Battery on critical low level (S3) */
+        case 0x2413: /* Battery on critical low level (S4) */
+                printk(TPACPI_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 */
+                break;
+
+        default:
+                return false;
+        }
+
+        if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
+                printk(TPACPI_INFO
+                       "woke up due to a hot-unplug "
+                       "request...\n");
+                hotkey_wakeup_reason_notify_change();
+        }
+        return true;
+}
+
+static bool hotkey_notify_usrevent(const u32 hkey,
+                                 bool *send_acpi_ev,
+                                 bool *ignore_acpi_ev)
+{
+        /* 0x5000-0x5FFF: human interface helpers */
+        *send_acpi_ev = true;
+        *ignore_acpi_ev = false;
+
+        switch (hkey) {
+        case 0x5010: /* Lenovo new BIOS: brightness changed */
+        case 0x500b: /* X61t: tablet pen inserted into bay */
+        case 0x500c: /* X61t: tablet pen removed from bay */
+                return true;
+
+        case 0x5009: /* X41t-X61t: swivel up (tablet mode) */
+        case 0x500a: /* X41t-X61t: swivel down (normal mode) */
+                tpacpi_input_send_tabletsw();
+                hotkey_tablet_mode_notify_change();
+                *send_acpi_ev = false;
+                return true;
+
+        case 0x5001:
+        case 0x5002:
+                /* LID switch events.  Do not propagate */
+                *ignore_acpi_ev = true;
+                return true;
+
+        default:
+                return false;
+        }
+}
+
+static bool hotkey_notify_thermal(const u32 hkey,
+                                 bool *send_acpi_ev,
+                                 bool *ignore_acpi_ev)
+{
+        /* 0x6000-0x6FFF: thermal alarms */
+        *send_acpi_ev = true;
+        *ignore_acpi_ev = false;
+
+        switch (hkey) {
+        case 0x6011:
+                printk(TPACPI_CRIT
+                        "THERMAL ALARM: battery is too hot!\n");
+                /* recommended action: warn user through gui */
+                return true;
+        case 0x6012:
+                printk(TPACPI_ALERT
+                        "THERMAL EMERGENCY: battery is extremely hot!\n");
+                /* recommended action: immediate sleep/hibernate */
+                return true;
+        case 0x6021:
+                printk(TPACPI_CRIT
+                        "THERMAL ALARM: "
+                        "a sensor reports something is too hot!\n");
+                /* recommended action: warn user through gui, that */
+                /* some internal component is too hot */
+                return true;
+        case 0x6022:
+                printk(TPACPI_ALERT
+                        "THERMAL EMERGENCY: "
+                        "a sensor reports something is extremely hot!\n");
+                /* recommended action: immediate sleep/hibernate */
+                return true;
+        case 0x6030:
+                printk(TPACPI_INFO
+                        "EC reports that Thermal Table has changed\n");
+                /* recommended action: do nothing, we don't have
+                 * Lenovo ATM information */
+                return true;
+        default:
+                printk(TPACPI_ALERT
+                         "THERMAL ALERT: unknown thermal alarm received\n");
+                return false;
+        }
+}
+
 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
 {
         u32 hkey;
-        unsigned int scancode;
-        int send_acpi_ev;
-        int ignore_acpi_ev;
-        int unk_ev;
+        bool send_acpi_ev;
+        bool ignore_acpi_ev;
+        bool known_ev;
 
         if (event != 0x80) {
                 printk(TPACPI_ERR
@@ -2375,7 +2728,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                 /* forward it to userspace, maybe it knows how to handle it */
                 acpi_bus_generate_netlink_event(
                                         ibm->acpi->device->pnp.device_class,
-                                        ibm->acpi->device->dev.bus_id,
+                                        dev_name(&ibm->acpi->device->dev),
                                         event, 0);
                 return;
         }
@@ -2391,107 +2744,72 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                         return;
                 }
 
-                send_acpi_ev = 1;
-                ignore_acpi_ev = 0;
-                unk_ev = 0;
+                send_acpi_ev = true;
+                ignore_acpi_ev = false;
 
                 switch (hkey >> 12) {
                 case 1:
                         /* 0x1000-0x1FFF: key presses */
-                        scancode = hkey & 0xfff;
-                        if (scancode > 0 && scancode < 0x21) {
-                                scancode--;
-                                if (!(hotkey_source_mask & (1 << scancode))) {
-                                        tpacpi_input_send_key(scancode);
-                                        send_acpi_ev = 0;
-                                } else {
-                                        ignore_acpi_ev = 1;
-                                }
-                        } else {
-                                unk_ev = 1;
-                        }
+                        known_ev = hotkey_notify_hotkey(hkey, &send_acpi_ev,
+                                                 &ignore_acpi_ev);
                         break;
                 case 2:
-                        /* Wakeup reason */
-                        switch (hkey) {
-                        case 0x2304: /* suspend, undock */
-                        case 0x2404: /* hibernation, undock */
-                                hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
-                                ignore_acpi_ev = 1;
-                                break;
-                        case 0x2305: /* suspend, bay eject */
-                        case 0x2405: /* hibernation, bay eject */
-                                hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
-                                ignore_acpi_ev = 1;
-                                break;
-                        default:
-                                unk_ev = 1;
-                        }
-                        if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
-                                printk(TPACPI_INFO
-                                       "woke up due to a hot-unplug "
-                                       "request...\n");
-                                hotkey_wakeup_reason_notify_change();
-                        }
+                        /* 0x2000-0x2FFF: Wakeup reason */
+                        known_ev = hotkey_notify_wakeup(hkey, &send_acpi_ev,
+                                                 &ignore_acpi_ev);
                         break;
                 case 3:
-                        /* bay-related wakeups */
+                        /* 0x3000-0x3FFF: bay-related wakeups */
                         if (hkey == 0x3003) {
                                 hotkey_autosleep_ack = 1;
                                 printk(TPACPI_INFO
                                        "bay ejected\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
+                                known_ev = true;
                         } else {
-                                unk_ev = 1;
+                                known_ev = false;
                         }
                         break;
                 case 4:
-                        /* dock-related wakeups */
+                        /* 0x4000-0x4FFF: dock-related wakeups */
                         if (hkey == 0x4003) {
                                 hotkey_autosleep_ack = 1;
                                 printk(TPACPI_INFO
                                        "undocked\n");
                                 hotkey_wakeup_hotunplug_complete_notify_change();
+                                known_ev = true;
                         } else {
-                                unk_ev = 1;
+                                known_ev = false;
                         }
                         break;
                 case 5:
                         /* 0x5000-0x5FFF: human interface helpers */
-                        switch (hkey) {
-                        case 0x5010: /* Lenovo new BIOS: brightness changed */
-                        case 0x500b: /* X61t: tablet pen inserted into bay */
-                        case 0x500c: /* X61t: tablet pen removed from bay */
-                                break;
-                        case 0x5009: /* X41t-X61t: swivel up (tablet mode) */
-                        case 0x500a: /* X41t-X61t: swivel down (normal mode) */
-                                tpacpi_input_send_tabletsw();
-                                hotkey_tablet_mode_notify_change();
-                                send_acpi_ev = 0;
-                                break;
-                        case 0x5001:
-                        case 0x5002:
-                                /* LID switch events.  Do not propagate */
-                                ignore_acpi_ev = 1;
-                                break;
-                        default:
-                                unk_ev = 1;
-                        }
+                        known_ev = hotkey_notify_usrevent(hkey, &send_acpi_ev,
+                                                 &ignore_acpi_ev);
+                        break;
+                case 6:
+                        /* 0x6000-0x6FFF: thermal alarms */
+                        known_ev = hotkey_notify_thermal(hkey, &send_acpi_ev,
+                                                 &ignore_acpi_ev);
                         break;
                 case 7:
                         /* 0x7000-0x7FFF: misc */
                         if (tp_features.hotkey_wlsw && hkey == 0x7000) {
                                 tpacpi_send_radiosw_update();
                                 send_acpi_ev = 0;
+                                known_ev = true;
                                 break;
                         }
                         /* fallthrough to default */
                 default:
-                        unk_ev = 1;
+                        known_ev = false;
                 }
-                if (unk_ev) {
+                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);
                 }
 
                 /* Legacy events */
@@ -2505,7 +2823,7 @@ static void hotkey_notify(struct ibm_struct *ibm, u32 event)
                 if (!ignore_acpi_ev && send_acpi_ev) {
                         acpi_bus_generate_netlink_event(
                                         ibm->acpi->device->pnp.device_class,
-                                        ibm->acpi->device->dev.bus_id,
+                                        dev_name(&ibm->acpi->device->dev),
                                         event, hkey);
                 }
         }
@@ -2544,7 +2862,7 @@ static int hotkey_read(char *p)
                 return len;
         }
 
-        if (mutex_lock_interruptible(&hotkey_mutex))
+        if (mutex_lock_killable(&hotkey_mutex))
                 return -ERESTARTSYS;
         res = hotkey_status_get(&status);
         if (!res)
@@ -2575,7 +2893,7 @@ static int hotkey_write(char *buf)
         if (!tp_features.hotkey)
                 return -ENODEV;
 
-        if (mutex_lock_interruptible(&hotkey_mutex))
+        if (mutex_lock_killable(&hotkey_mutex))
                 return -ERESTARTSYS;
 
         status = -1;
@@ -2640,11 +2958,28 @@ enum {
         /* ACPI GBDC/SBDC bits */
         TP_ACPI_BLUETOOTH_HWPRESENT     = 0x01, /* Bluetooth hw available */
         TP_ACPI_BLUETOOTH_RADIOSSW      = 0x02, /* Bluetooth radio enabled */
-        TP_ACPI_BLUETOOTH_UNK           = 0x04, /* unknown function */
+        TP_ACPI_BLUETOOTH_RESUMECTRL    = 0x04, /* Bluetooth state at resume:
+                                                   off / last state */
+};
+
+enum {
+        /* ACPI \BLTH commands */
+        TP_ACPI_BLTH_GET_ULTRAPORT_ID   = 0x00, /* Get Ultraport BT ID */
+        TP_ACPI_BLTH_GET_PWR_ON_RESUME  = 0x01, /* Get power-on-resume state */
+        TP_ACPI_BLTH_PWR_ON_ON_RESUME   = 0x02, /* Resume powered on */
+        TP_ACPI_BLTH_PWR_OFF_ON_RESUME  = 0x03, /* Resume powered off */
+        TP_ACPI_BLTH_SAVE_STATE         = 0x05, /* Save state for S4/S5 */
 };
 
 static struct rfkill *tpacpi_bluetooth_rfkill;
 
+static void bluetooth_suspend(pm_message_t state)
+{
+        /* Try to make sure radio will resume powered off */
+        acpi_evalf(NULL, NULL, "\\BLTH", "vd",
+                   TP_ACPI_BLTH_PWR_OFF_ON_RESUME);
+}
+
 static int bluetooth_get_radiosw(void)
 {
         int status;
@@ -2656,6 +2991,12 @@ static int bluetooth_get_radiosw(void)
         if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status)
                 return RFKILL_STATE_HARD_BLOCKED;
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_bluetoothemul)
+                return (tpacpi_bluetooth_emulstate) ?
+                        RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
+#endif
+
         if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
                 return -EIO;
 
@@ -2689,12 +3030,20 @@ static int bluetooth_set_radiosw(int radio_on, int update_rfk)
             && radio_on)
                 return -EPERM;
 
-        if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
-                return -EIO;
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_bluetoothemul) {
+                tpacpi_bluetooth_emulstate = !!radio_on;
+                if (update_rfk)
+                        bluetooth_update_rfk();
+                return 0;
+        }
+#endif
+
+        /* We make sure to keep TP_ACPI_BLUETOOTH_RESUMECTRL off */
         if (radio_on)
-                status |= TP_ACPI_BLUETOOTH_RADIOSSW;
+                status = TP_ACPI_BLUETOOTH_RADIOSSW;
         else
-                status &= ~TP_ACPI_BLUETOOTH_RADIOSSW;
+                status = 0;
         if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
                 return -EIO;
 
@@ -2765,8 +3114,19 @@ static int tpacpi_bluetooth_rfk_set(void *data, enum rfkill_state state)
         return bluetooth_set_radiosw((state == RFKILL_STATE_UNBLOCKED), 0);
 }
 
+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");
+}
+
 static void bluetooth_exit(void)
 {
+        bluetooth_shutdown();
+
         if (tpacpi_bluetooth_rfkill)
                 rfkill_unregister(tpacpi_bluetooth_rfkill);
 
@@ -2792,6 +3152,13 @@ static int __init bluetooth_init(struct ibm_init_struct *iibm)
                 str_supported(tp_features.bluetooth),
                 status);
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_bluetoothemul) {
+                tp_features.bluetooth = 1;
+                printk(TPACPI_INFO
+                        "bluetooth switch emulation enabled\n");
+        } else
+#endif
         if (tp_features.bluetooth &&
             !(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
                 /* no bluetooth hardware present in system */
@@ -2812,6 +3179,7 @@ static int __init bluetooth_init(struct ibm_init_struct *iibm)
                                 &tpacpi_bluetooth_rfkill,
                                 RFKILL_TYPE_BLUETOOTH,
                                 "tpacpi_bluetooth_sw",
+                                true,
                                 tpacpi_bluetooth_rfk_set,
                                 tpacpi_bluetooth_rfk_get);
         if (res) {
@@ -2864,6 +3232,8 @@ static struct ibm_struct bluetooth_driver_data = {
         .read = bluetooth_read,
         .write = bluetooth_write,
         .exit = bluetooth_exit,
+        .suspend = bluetooth_suspend,
+        .shutdown = bluetooth_shutdown,
 };
 
 /*************************************************************************
@@ -2874,11 +3244,19 @@ enum {
         /* ACPI GWAN/SWAN bits */
         TP_ACPI_WANCARD_HWPRESENT       = 0x01, /* Wan hw available */
         TP_ACPI_WANCARD_RADIOSSW        = 0x02, /* Wan radio enabled */
-        TP_ACPI_WANCARD_UNK             = 0x04, /* unknown function */
+        TP_ACPI_WANCARD_RESUMECTRL      = 0x04, /* Wan state at resume:
+                                                   off / last state */
 };
 
 static struct rfkill *tpacpi_wan_rfkill;
 
+static void wan_suspend(pm_message_t state)
+{
+        /* Try to make sure radio will resume powered off */
+        acpi_evalf(NULL, NULL, "\\WGSV", "qvd",
+                   TP_ACPI_WGSV_PWR_OFF_ON_RESUME);
+}
+
 static int wan_get_radiosw(void)
 {
         int status;
@@ -2890,6 +3268,12 @@ static int wan_get_radiosw(void)
         if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status)
                 return RFKILL_STATE_HARD_BLOCKED;
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_wwanemul)
+                return (tpacpi_wwan_emulstate) ?
+                        RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
+#endif
+
         if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
                 return -EIO;
 
@@ -2923,12 +3307,20 @@ static int wan_set_radiosw(int radio_on, int update_rfk)
             && radio_on)
                 return -EPERM;
 
-        if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
-                return -EIO;
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_wwanemul) {
+                tpacpi_wwan_emulstate = !!radio_on;
+                if (update_rfk)
+                        wan_update_rfk();
+                return 0;
+        }
+#endif
+
+        /* We make sure to keep TP_ACPI_WANCARD_RESUMECTRL off */
         if (radio_on)
-                status |= TP_ACPI_WANCARD_RADIOSSW;
+                status = TP_ACPI_WANCARD_RADIOSSW;
         else
-                status &= ~TP_ACPI_WANCARD_RADIOSSW;
+                status = 0;
         if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
                 return -EIO;
 
@@ -2999,8 +3391,19 @@ static int tpacpi_wan_rfk_set(void *data, enum rfkill_state state)
         return wan_set_radiosw((state == RFKILL_STATE_UNBLOCKED), 0);
 }
 
+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");
+}
+
 static void wan_exit(void)
 {
+        wan_shutdown();
+
         if (tpacpi_wan_rfkill)
                 rfkill_unregister(tpacpi_wan_rfkill);
 
@@ -3024,6 +3427,13 @@ static int __init wan_init(struct ibm_init_struct *iibm)
                 str_supported(tp_features.wan),
                 status);
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_wwanemul) {
+                tp_features.wan = 1;
+                printk(TPACPI_INFO
+                        "wwan switch emulation enabled\n");
+        } else
+#endif
         if (tp_features.wan &&
             !(status & TP_ACPI_WANCARD_HWPRESENT)) {
                 /* no wan hardware present in system */
@@ -3044,6 +3454,7 @@ static int __init wan_init(struct ibm_init_struct *iibm)
                                 &tpacpi_wan_rfkill,
                                 RFKILL_TYPE_WWAN,
                                 "tpacpi_wwan_sw",
+                                true,
                                 tpacpi_wan_rfk_set,
                                 tpacpi_wan_rfk_get);
         if (res) {
@@ -3096,6 +3507,164 @@ static struct ibm_struct wan_driver_data = {
         .read = wan_read,
         .write = wan_write,
         .exit = wan_exit,
+        .suspend = wan_suspend,
+        .shutdown = wan_shutdown,
+};
+
+/*************************************************************************
+ * UWB subdriver
+ */
+
+enum {
+        /* ACPI GUWB/SUWB bits */
+        TP_ACPI_UWB_HWPRESENT   = 0x01, /* UWB hw available */
+        TP_ACPI_UWB_RADIOSSW    = 0x02, /* UWB radio enabled */
+};
+
+static struct rfkill *tpacpi_uwb_rfkill;
+
+static int uwb_get_radiosw(void)
+{
+        int status;
+
+        if (!tp_features.uwb)
+                return -ENODEV;
+
+        /* WLSW overrides UWB in firmware/hardware, reflect that */
+        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status)
+                return RFKILL_STATE_HARD_BLOCKED;
+
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_uwbemul)
+                return (tpacpi_uwb_emulstate) ?
+                        RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
+#endif
+
+        if (!acpi_evalf(hkey_handle, &status, "GUWB", "d"))
+                return -EIO;
+
+        return ((status & TP_ACPI_UWB_RADIOSSW) != 0) ?
+                RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
+}
+
+static void uwb_update_rfk(void)
+{
+        int status;
+
+        if (!tpacpi_uwb_rfkill)
+                return;
+
+        status = uwb_get_radiosw();
+        if (status < 0)
+                return;
+        rfkill_force_state(tpacpi_uwb_rfkill, status);
+}
+
+static int uwb_set_radiosw(int radio_on, int update_rfk)
+{
+        int status;
+
+        if (!tp_features.uwb)
+                return -ENODEV;
+
+        /* WLSW overrides UWB in firmware/hardware, but there is no
+         * reason to risk weird behaviour. */
+        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status
+            && radio_on)
+                return -EPERM;
+
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_uwbemul) {
+                tpacpi_uwb_emulstate = !!radio_on;
+                if (update_rfk)
+                        uwb_update_rfk();
+                return 0;
+        }
+#endif
+
+        status = (radio_on) ? TP_ACPI_UWB_RADIOSSW : 0;
+        if (!acpi_evalf(hkey_handle, NULL, "SUWB", "vd", status))
+                return -EIO;
+
+        if (update_rfk)
+                uwb_update_rfk();
+
+        return 0;
+}
+
+/* --------------------------------------------------------------------- */
+
+static int tpacpi_uwb_rfk_get(void *data, enum rfkill_state *state)
+{
+        int uwbs = uwb_get_radiosw();
+
+        if (uwbs < 0)
+                return uwbs;
+
+        *state = uwbs;
+        return 0;
+}
+
+static int tpacpi_uwb_rfk_set(void *data, enum rfkill_state state)
+{
+        return uwb_set_radiosw((state == RFKILL_STATE_UNBLOCKED), 0);
+}
+
+static void uwb_exit(void)
+{
+        if (tpacpi_uwb_rfkill)
+                rfkill_unregister(tpacpi_uwb_rfkill);
+}
+
+static int __init uwb_init(struct ibm_init_struct *iibm)
+{
+        int res;
+        int status = 0;
+
+        vdbg_printk(TPACPI_DBG_INIT, "initializing uwb subdriver\n");
+
+        TPACPI_ACPIHANDLE_INIT(hkey);
+
+        tp_features.uwb = hkey_handle &&
+            acpi_evalf(hkey_handle, &status, "GUWB", "qd");
+
+        vdbg_printk(TPACPI_DBG_INIT, "uwb is %s, status 0x%02x\n",
+                str_supported(tp_features.uwb),
+                status);
+
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+        if (dbg_uwbemul) {
+                tp_features.uwb = 1;
+                printk(TPACPI_INFO
+                        "uwb switch emulation enabled\n");
+        } else
+#endif
+        if (tp_features.uwb &&
+            !(status & TP_ACPI_UWB_HWPRESENT)) {
+                /* no uwb hardware present in system */
+                tp_features.uwb = 0;
+                dbg_printk(TPACPI_DBG_INIT,
+                           "uwb hardware not installed\n");
+        }
+
+        if (!tp_features.uwb)
+                return 1;
+
+        res = tpacpi_new_rfkill(TPACPI_RFK_UWB_SW_ID,
+                                &tpacpi_uwb_rfkill,
+                                RFKILL_TYPE_UWB,
+                                "tpacpi_uwb_sw",
+                                false,
+                                tpacpi_uwb_rfk_set,
+                                tpacpi_uwb_rfk_get);
+
+        return res;
+}
+
+static struct ibm_struct uwb_driver_data = {
+        .name = "uwb",
+        .exit = uwb_exit,
+        .flags.experimental = 1,
 };
 
 /*************************************************************************
@@ -3724,7 +4293,7 @@ static void dock_notify(struct ibm_struct *ibm, u32 event)
         }
         acpi_bus_generate_proc_event(ibm->acpi->device, event, data);
         acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
-                                          ibm->acpi->device->dev.bus_id,
+                                          dev_name(&ibm->acpi->device->dev),
                                           event, data);
 }
 
@@ -3826,7 +4395,7 @@ static void bay_notify(struct ibm_struct *ibm, u32 event)
 {
         acpi_bus_generate_proc_event(ibm->acpi->device, event, 0);
         acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
-                                          ibm->acpi->device->dev.bus_id,
+                                          dev_name(&ibm->acpi->device->dev),
                                           event, 0);
 }
 
@@ -4850,7 +5419,7 @@ static int brightness_set(int value)
             value < 0)
                 return -EINVAL;
 
-        res = mutex_lock_interruptible(&brightness_mutex);
+        res = mutex_lock_killable(&brightness_mutex);
         if (res < 0)
                 return res;
 
@@ -5334,6 +5903,60 @@ TPACPI_HANDLE(sfan, ec, "SFAN",	/* 570 */
            );                   /* all others */
 
 /*
+ * Unitialized HFSP quirk: ACPI DSDT and EC fail to initialize the
+ * HFSP register at boot, so it contains 0x07 but the Thinkpad could
+ * be in auto mode (0x80).
+ *
+ * This is corrected by any write to HFSP either by the driver, or
+ * by the firmware.
+ *
+ * We assume 0x07 really means auto mode while this quirk is active,
+ * as this is far more likely than the ThinkPad being in level 7,
+ * which is only used by the firmware during thermal emergencies.
+ */
+
+static void fan_quirk1_detect(void)
+{
+        /* In some ThinkPads, neither the EC nor the ACPI
+         * DSDT initialize the HFSP register, and it ends up
+         * being initially set to 0x07 when it *could* be
+         * either 0x07 or 0x80.
+         *
+         * Enable for TP-1Y (T43), TP-78 (R51e),
+         * TP-76 (R52), TP-70 (T43, R52), which are known
+         * to be buggy. */
+        if (fan_control_initial_status == 0x07) {
+                switch (thinkpad_id.ec_model) {
+                case 0x5931: /* TP-1Y */
+                case 0x3837: /* TP-78 */
+                case 0x3637: /* TP-76 */
+                case 0x3037: /* TP-70 */
+                        printk(TPACPI_NOTICE
+                               "fan_init: initial fan status is unknown, "
+                               "assuming it is in auto mode\n");
+                        tp_features.fan_ctrl_status_undef = 1;
+                        ;;
+                }
+        }
+}
+
+static void fan_quirk1_handle(u8 *fan_status)
+{
+        if (unlikely(tp_features.fan_ctrl_status_undef)) {
+                if (*fan_status != fan_control_initial_status) {
+                        /* something changed the HFSP regisnter since
+                         * driver init time, so it is not undefined
+                         * anymore */
+                        tp_features.fan_ctrl_status_undef = 0;
+                } else {
+                        /* Return most likely status. In fact, it
+                         * might be the only possible status */
+                        *fan_status = TP_EC_FAN_AUTO;
+                }
+        }
+}
+
+/*
  * Call with fan_mutex held
  */
 static void fan_update_desired_level(u8 status)
@@ -5371,8 +5994,10 @@ static int fan_get_status(u8 *status)
                 if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
                         return -EIO;
 
-                if (likely(status))
+                if (likely(status)) {
                         *status = s;
+                        fan_quirk1_handle(status);
+                }
 
                 break;
 
@@ -5388,7 +6013,7 @@ static int fan_get_status_safe(u8 *status)
         int rc;
         u8 s;
 
-        if (mutex_lock_interruptible(&fan_mutex))
+        if (mutex_lock_killable(&fan_mutex))
                 return -ERESTARTSYS;
         rc = fan_get_status(&s);
         if (!rc)
@@ -5471,7 +6096,7 @@ static int fan_set_level_safe(int level)
         if (!fan_control_allowed)
                 return -EPERM;
 
-        if (mutex_lock_interruptible(&fan_mutex))
+        if (mutex_lock_killable(&fan_mutex))
                 return -ERESTARTSYS;
 
         if (level == TPACPI_FAN_LAST_LEVEL)
@@ -5493,7 +6118,7 @@ static int fan_set_enable(void)
         if (!fan_control_allowed)
                 return -EPERM;
 
-        if (mutex_lock_interruptible(&fan_mutex))
+        if (mutex_lock_killable(&fan_mutex))
                 return -ERESTARTSYS;
 
         switch (fan_control_access_mode) {
@@ -5548,7 +6173,7 @@ static int fan_set_disable(void)
         if (!fan_control_allowed)
                 return -EPERM;
 
-        if (mutex_lock_interruptible(&fan_mutex))
+        if (mutex_lock_killable(&fan_mutex))
                 return -ERESTARTSYS;
 
         rc = 0;
@@ -5586,7 +6211,7 @@ static int fan_set_speed(int speed)
         if (!fan_control_allowed)
                 return -EPERM;
 
-        if (mutex_lock_interruptible(&fan_mutex))
+        if (mutex_lock_killable(&fan_mutex))
                 return -ERESTARTSYS;
 
         rc = 0;
@@ -5682,16 +6307,6 @@ static ssize_t fan_pwm1_enable_show(struct device *dev,
         if (res)
                 return res;
 
-        if (unlikely(tp_features.fan_ctrl_status_undef)) {
-                if (status != fan_control_initial_status) {
-                        tp_features.fan_ctrl_status_undef = 0;
-                } else {
-                        /* Return most likely status. In fact, it
-                         * might be the only possible status */
-                        status = TP_EC_FAN_AUTO;
-                }
-        }
-
         if (status & TP_EC_FAN_FULLSPEED) {
                 mode = 0;
         } else if (status & TP_EC_FAN_AUTO) {
@@ -5756,14 +6371,6 @@ static ssize_t fan_pwm1_show(struct device *dev,
         if (res)
                 return res;
 
-        if (unlikely(tp_features.fan_ctrl_status_undef)) {
-                if (status != fan_control_initial_status) {
-                        tp_features.fan_ctrl_status_undef = 0;
-                } else {
-                        status = TP_EC_FAN_AUTO;
-                }
-        }
-
         if ((status &
              (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0)
                 status = fan_control_desired_level;
@@ -5788,7 +6395,7 @@ static ssize_t fan_pwm1_store(struct device *dev,
         /* scale down from 0-255 to 0-7 */
         newlevel = (s >> 5) & 0x07;
 
-        if (mutex_lock_interruptible(&fan_mutex))
+        if (mutex_lock_killable(&fan_mutex))
                 return -ERESTARTSYS;
 
         rc = fan_get_status(&status);
@@ -5895,29 +6502,7 @@ static int __init fan_init(struct ibm_init_struct *iibm)
                 if (likely(acpi_ec_read(fan_status_offset,
                                         &fan_control_initial_status))) {
                         fan_status_access_mode = TPACPI_FAN_RD_TPEC;
-
-                        /* In some ThinkPads, neither the EC nor the ACPI
-                         * DSDT initialize the fan status, and it ends up
-                         * being set to 0x07 when it *could* be either
-                         * 0x07 or 0x80.
-                         *
-                         * Enable for TP-1Y (T43), TP-78 (R51e),
-                         * TP-76 (R52), TP-70 (T43, R52), which are known
-                         * to be buggy. */
-                        if (fan_control_initial_status == 0x07) {
-                                switch (thinkpad_id.ec_model) {
-                                case 0x5931: /* TP-1Y */
-                                case 0x3837: /* TP-78 */
-                                case 0x3637: /* TP-76 */
-                                case 0x3037: /* TP-70 */
-                                        printk(TPACPI_NOTICE
-                                               "fan_init: initial fan status "
-                                               "is unknown, assuming it is "
-                                               "in auto mode\n");
-                                        tp_features.fan_ctrl_status_undef = 1;
-                                        ;;
-                                }
-                        }
+                        fan_quirk1_detect();
                 } else {
                         printk(TPACPI_ERR
                                "ThinkPad ACPI EC access misbehaving, "
@@ -6106,15 +6691,6 @@ static int fan_read(char *p)
                 if (rc < 0)
                         return rc;
 
-                if (unlikely(tp_features.fan_ctrl_status_undef)) {
-                        if (status != fan_control_initial_status)
-                                tp_features.fan_ctrl_status_undef = 0;
-                        else
-                                /* Return most likely status. In fact, it
-                                 * might be the only possible status */
-                                status = TP_EC_FAN_AUTO;
-                }
-
                 len += sprintf(p + len, "status:\t\t%s\n",
                                (status != 0) ? "enabled" : "disabled");
 
@@ -6563,6 +7139,10 @@ static struct ibm_init_struct ibms_init[] __initdata = {
                 .init = wan_init,
                 .data = &wan_driver_data,
         },
+        {
+                .init = uwb_init,
+                .data = &uwb_driver_data,
+        },
 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
         {
                 .init = video_init,
@@ -6701,6 +7281,32 @@ TPACPI_PARAM(brightness);
 TPACPI_PARAM(volume);
 TPACPI_PARAM(fan);
 
+#ifdef CONFIG_THINKPAD_ACPI_DEBUGFACILITIES
+module_param(dbg_wlswemul, uint, 0);
+MODULE_PARM_DESC(dbg_wlswemul, "Enables WLSW emulation");
+module_param_named(wlsw_state, tpacpi_wlsw_emulstate, bool, 0);
+MODULE_PARM_DESC(wlsw_state,
+                 "Initial state of the emulated WLSW switch");
+
+module_param(dbg_bluetoothemul, uint, 0);
+MODULE_PARM_DESC(dbg_bluetoothemul, "Enables bluetooth switch emulation");
+module_param_named(bluetooth_state, tpacpi_bluetooth_emulstate, bool, 0);
+MODULE_PARM_DESC(bluetooth_state,
+                 "Initial state of the emulated bluetooth switch");
+
+module_param(dbg_wwanemul, uint, 0);
+MODULE_PARM_DESC(dbg_wwanemul, "Enables WWAN switch emulation");
+module_param_named(wwan_state, tpacpi_wwan_emulstate, bool, 0);
+MODULE_PARM_DESC(wwan_state,
+                 "Initial state of the emulated WWAN switch");
+
+module_param(dbg_uwbemul, uint, 0);
+MODULE_PARM_DESC(dbg_uwbemul, "Enables UWB switch emulation");
+module_param_named(uwb_state, tpacpi_uwb_emulstate, bool, 0);
+MODULE_PARM_DESC(uwb_state,
+                 "Initial state of the emulated UWB switch");
+#endif
+
 static void thinkpad_acpi_module_exit(void)
 {
         struct ibm_struct *ibm, *itmp;
diff --git a/drivers/power/pda_power.c b/drivers/power/pda_power.c
index d30bb766fcef..b56a704409d2 100644
--- a/drivers/power/pda_power.c
+++ b/drivers/power/pda_power.c
@@ -20,7 +20,7 @@
 
 static inline unsigned int get_irq_flags(struct resource *res)
 {
-        unsigned int flags = IRQF_DISABLED | IRQF_SHARED;
+        unsigned int flags = IRQF_SAMPLE_RANDOM | IRQF_SHARED;
 
         flags |= res->flags & IRQF_TRIGGER_MASK;
 
diff --git a/drivers/ps3/ps3-lpm.c b/drivers/ps3/ps3-lpm.c
index 204158cf7a55..fe96793e3f08 100644
--- a/drivers/ps3/ps3-lpm.c
+++ b/drivers/ps3/ps3-lpm.c
@@ -732,7 +732,7 @@ static u64 pm_signal_group_to_ps3_lv1_signal_group(u64 group)
         case 8:
                 return pm_translate_signal_group_number_on_island8(subgroup);
         default:
-                dev_dbg(sbd_core(), "%s:%u: island not found: %lu\n", __func__,
+                dev_dbg(sbd_core(), "%s:%u: island not found: %llu\n", __func__,
                         __LINE__, group);
                 BUG();
                 break;
@@ -765,7 +765,7 @@ static int __ps3_set_signal(u64 lv1_signal_group, u64 bus_select,
                                  signal_select, attr1, attr2, attr3);
         if (ret)
                 dev_err(sbd_core(),
-                        "%s:%u: error:%d 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
+                        "%s:%u: error:%d 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx 0x%llx\n",
                         __func__, __LINE__, ret, lv1_signal_group, bus_select,
                         signal_select, attr1, attr2, attr3);
 
@@ -908,7 +908,7 @@ void ps3_disable_pm(u32 cpu)
 
         lpm_priv->tb_count = tmp;
 
-        dev_dbg(sbd_core(), "%s:%u: tb_count %lu (%lxh)\n", __func__, __LINE__,
+        dev_dbg(sbd_core(), "%s:%u: tb_count %llu (%llxh)\n", __func__, __LINE__,
                 lpm_priv->tb_count, lpm_priv->tb_count);
 }
 EXPORT_SYMBOL_GPL(ps3_disable_pm);
@@ -938,7 +938,7 @@ int ps3_lpm_copy_tb(unsigned long offset, void *buf, unsigned long count,
         if (offset >= lpm_priv->tb_count)
                 return 0;
 
-        count = min(count, lpm_priv->tb_count - offset);
+        count = min_t(u64, count, lpm_priv->tb_count - offset);
 
         while (*bytes_copied < count) {
                 const unsigned long request = count - *bytes_copied;
@@ -993,7 +993,7 @@ int ps3_lpm_copy_tb_to_user(unsigned long offset, void __user *buf,
         if (offset >= lpm_priv->tb_count)
                 return 0;
 
-        count = min(count, lpm_priv->tb_count - offset);
+        count = min_t(u64, count, lpm_priv->tb_count - offset);
 
         while (*bytes_copied < count) {
                 const unsigned long request = count - *bytes_copied;
@@ -1013,7 +1013,7 @@ int ps3_lpm_copy_tb_to_user(unsigned long offset, void __user *buf,
                 result = copy_to_user(buf, lpm_priv->tb_cache, tmp);
 
                 if (result) {
-                        dev_dbg(sbd_core(), "%s:%u: 0x%lx bytes at 0x%p\n",
+                        dev_dbg(sbd_core(), "%s:%u: 0x%llx bytes at 0x%p\n",
                                 __func__, __LINE__, tmp, buf);
                         dev_err(sbd_core(), "%s:%u: copy_to_user failed: %d\n",
                                 __func__, __LINE__, result);
@@ -1148,8 +1148,8 @@ int ps3_lpm_open(enum ps3_lpm_tb_type tb_type, void *tb_cache,
         lpm_priv->shadow.group_control = PS3_LPM_SHADOW_REG_INIT;
         lpm_priv->shadow.debug_bus_control = PS3_LPM_SHADOW_REG_INIT;
 
-        dev_dbg(sbd_core(), "%s:%u: lpm_id 0x%lx, outlet_id 0x%lx, "
-                "tb_size 0x%lx\n", __func__, __LINE__, lpm_priv->lpm_id,
+        dev_dbg(sbd_core(), "%s:%u: lpm_id 0x%llx, outlet_id 0x%llx, "
+                "tb_size 0x%llx\n", __func__, __LINE__, lpm_priv->lpm_id,
                 lpm_priv->outlet_id, tb_size);
 
         return 0;
diff --git a/drivers/ps3/ps3-vuart.c b/drivers/ps3/ps3-vuart.c
index 90c097a7a47a..e4ad5ba5d0a3 100644
--- a/drivers/ps3/ps3-vuart.c
+++ b/drivers/ps3/ps3-vuart.c
@@ -114,7 +114,7 @@ struct ports_bmp {
 static void __maybe_unused _dump_ports_bmp(
         const struct ports_bmp *bmp, const char *func, int line)
 {
-        pr_debug("%s:%d: ports_bmp: %016lxh\n", func, line, bmp->status);
+        pr_debug("%s:%d: ports_bmp: %016llxh\n", func, line, bmp->status);
 }
 
 #define dump_port_params(_b) _dump_port_params(_b, __func__, __LINE__)
@@ -159,11 +159,13 @@ int ps3_vuart_get_triggers(struct ps3_system_bus_device *dev,
         struct vuart_triggers *trig)
 {
         int result;
-        unsigned long size;
-        unsigned long val;
+        u64 size;
+        u64 val;
+        u64 tx;
 
         result = lv1_get_virtual_uart_param(dev->port_number,
-                PARAM_TX_TRIGGER, &trig->tx);
+                PARAM_TX_TRIGGER, &tx);
+        trig->tx = tx;
 
         if (result) {
                 dev_dbg(&dev->core, "%s:%d: tx_trigger failed: %s\n",
@@ -201,7 +203,7 @@ int ps3_vuart_set_triggers(struct ps3_system_bus_device *dev, unsigned int tx,
         unsigned int rx)
 {
         int result;
-        unsigned long size;
+        u64 size;
 
         result = lv1_set_virtual_uart_param(dev->port_number,
                 PARAM_TX_TRIGGER, tx);
@@ -248,7 +250,7 @@ static int ps3_vuart_get_rx_bytes_waiting(struct ps3_system_bus_device *dev,
                 dev_dbg(&dev->core, "%s:%d: rx_bytes failed: %s\n",
                         __func__, __LINE__, ps3_result(result));
 
-        dev_dbg(&dev->core, "%s:%d: %lxh\n", __func__, __LINE__,
+        dev_dbg(&dev->core, "%s:%d: %llxh\n", __func__, __LINE__,
                 *bytes_waiting);
         return result;
 }
@@ -295,7 +297,7 @@ static int ps3_vuart_get_interrupt_status(struct ps3_system_bus_device *dev,
 
         *status = tmp & priv->interrupt_mask;
 
-        dev_dbg(&dev->core, "%s:%d: m %lxh, s %lxh, m&s %lxh\n",
+        dev_dbg(&dev->core, "%s:%d: m %llxh, s %llxh, m&s %lxh\n",
                 __func__, __LINE__, priv->interrupt_mask, tmp, *status);
 
         return result;
@@ -363,7 +365,7 @@ int ps3_vuart_disable_interrupt_disconnect(struct ps3_system_bus_device *dev)
  */
 
 static int ps3_vuart_raw_write(struct ps3_system_bus_device *dev,
-        const void *buf, unsigned int bytes, unsigned long *bytes_written)
+        const void *buf, unsigned int bytes, u64 *bytes_written)
 {
         int result;
         struct ps3_vuart_port_priv *priv = to_port_priv(dev);
@@ -379,7 +381,7 @@ static int ps3_vuart_raw_write(struct ps3_system_bus_device *dev,
 
         priv->stats.bytes_written += *bytes_written;
 
-        dev_dbg(&dev->core, "%s:%d: wrote %lxh/%xh=>%lxh\n", __func__, __LINE__,
+        dev_dbg(&dev->core, "%s:%d: wrote %llxh/%xh=>%lxh\n", __func__, __LINE__,
                 *bytes_written, bytes, priv->stats.bytes_written);
 
         return result;
@@ -393,7 +395,7 @@ static int ps3_vuart_raw_write(struct ps3_system_bus_device *dev,
  */
 
 static int ps3_vuart_raw_read(struct ps3_system_bus_device *dev, void *buf,
-        unsigned int bytes, unsigned long *bytes_read)
+        unsigned int bytes, u64 *bytes_read)
 {
         int result;
         struct ps3_vuart_port_priv *priv = to_port_priv(dev);
@@ -411,7 +413,7 @@ static int ps3_vuart_raw_read(struct ps3_system_bus_device *dev, void *buf,
 
         priv->stats.bytes_read += *bytes_read;
 
-        dev_dbg(&dev->core, "%s:%d: read %lxh/%xh=>%lxh\n", __func__, __LINE__,
+        dev_dbg(&dev->core, "%s:%d: read %llxh/%xh=>%lxh\n", __func__, __LINE__,
                 *bytes_read, bytes, priv->stats.bytes_read);
 
         return result;
@@ -500,7 +502,7 @@ int ps3_vuart_write(struct ps3_system_bus_device *dev, const void *buf,
         spin_lock_irqsave(&priv->tx_list.lock, flags);
 
         if (list_empty(&priv->tx_list.head)) {
-                unsigned long bytes_written;
+                u64 bytes_written;
 
                 result = ps3_vuart_raw_write(dev, buf, bytes, &bytes_written);
 
@@ -592,7 +594,7 @@ static int ps3_vuart_queue_rx_bytes(struct ps3_system_bus_device *dev,
         list_add_tail(&lb->link, &priv->rx_list.head);
         priv->rx_list.bytes_held += bytes;
 
-        dev_dbg(&dev->core, "%s:%d: buf_%lu: queued %lxh bytes\n",
+        dev_dbg(&dev->core, "%s:%d: buf_%lu: queued %llxh bytes\n",
                 __func__, __LINE__, lb->dbg_number, bytes);
 
         *bytes_queued = bytes;
@@ -745,7 +747,7 @@ static int ps3_vuart_handle_interrupt_tx(struct ps3_system_bus_device *dev)
 
         list_for_each_entry_safe(lb, n, &priv->tx_list.head, link) {
 
-                unsigned long bytes_written;
+                u64 bytes_written;
 
                 result = ps3_vuart_raw_write(dev, lb->head, lb->tail - lb->head,
                         &bytes_written);
@@ -762,7 +764,7 @@ static int ps3_vuart_handle_interrupt_tx(struct ps3_system_bus_device *dev)
                 if (bytes_written < lb->tail - lb->head) {
                         lb->head += bytes_written;
                         dev_dbg(&dev->core,
-                                "%s:%d cleared buf_%lu, %lxh bytes\n",
+                                "%s:%d cleared buf_%lu, %llxh bytes\n",
                                 __func__, __LINE__, lb->dbg_number,
                                 bytes_written);
                         goto port_full;
diff --git a/drivers/ps3/ps3stor_lib.c b/drivers/ps3/ps3stor_lib.c
index 55955f16ad91..18066d555397 100644
--- a/drivers/ps3/ps3stor_lib.c
+++ b/drivers/ps3/ps3stor_lib.c
@@ -70,7 +70,7 @@ static int ps3stor_probe_access(struct ps3_storage_device *dev)
                          __func__, __LINE__, n);
         dev->region_idx = __ffs(dev->accessible_regions);
         dev_info(&dev->sbd.core,
-                 "First accessible region has index %u start %lu size %lu\n",
+                 "First accessible region has index %u start %llu size %llu\n",
                  dev->region_idx, dev->regions[dev->region_idx].start,
                  dev->regions[dev->region_idx].size);
 
@@ -220,7 +220,7 @@ u64 ps3stor_read_write_sectors(struct ps3_storage_device *dev, u64 lpar,
         const char *op = write ? "write" : "read";
         int res;
 
-        dev_dbg(&dev->sbd.core, "%s:%u: %s %lu sectors starting at %lu\n",
+        dev_dbg(&dev->sbd.core, "%s:%u: %s %llu sectors starting at %llu\n",
                 __func__, __LINE__, op, sectors, start_sector);
 
         init_completion(&dev->done);
@@ -238,7 +238,7 @@ u64 ps3stor_read_write_sectors(struct ps3_storage_device *dev, u64 lpar,
 
         wait_for_completion(&dev->done);
         if (dev->lv1_status) {
-                dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%llx\n", __func__,
                         __LINE__, op, dev->lv1_status);
                 return dev->lv1_status;
         }
@@ -268,7 +268,7 @@ u64 ps3stor_send_command(struct ps3_storage_device *dev, u64 cmd, u64 arg1,
 {
         int res;
 
-        dev_dbg(&dev->sbd.core, "%s:%u: send device command 0x%lx\n", __func__,
+        dev_dbg(&dev->sbd.core, "%s:%u: send device command 0x%llx\n", __func__,
                 __LINE__, cmd);
 
         init_completion(&dev->done);
@@ -277,19 +277,19 @@ u64 ps3stor_send_command(struct ps3_storage_device *dev, u64 cmd, u64 arg1,
                                               arg2, arg3, arg4, &dev->tag);
         if (res) {
                 dev_err(&dev->sbd.core,
-                        "%s:%u: send_device_command 0x%lx failed %d\n",
+                        "%s:%u: send_device_command 0x%llx failed %d\n",
                         __func__, __LINE__, cmd, res);
                 return -1;
         }
 
         wait_for_completion(&dev->done);
         if (dev->lv1_status) {
-                dev_dbg(&dev->sbd.core, "%s:%u: command 0x%lx failed 0x%lx\n",
+                dev_dbg(&dev->sbd.core, "%s:%u: command 0x%llx failed 0x%llx\n",
                         __func__, __LINE__, cmd, dev->lv1_status);
                 return dev->lv1_status;
         }
 
-        dev_dbg(&dev->sbd.core, "%s:%u: command 0x%lx completed\n", __func__,
+        dev_dbg(&dev->sbd.core, "%s:%u: command 0x%llx completed\n", __func__,
                 __LINE__, cmd);
 
         return 0;
diff --git a/drivers/regulator/wm8400-regulator.c b/drivers/regulator/wm8400-regulator.c
index 48b372e038a8..56e23d44ba59 100644
--- a/drivers/regulator/wm8400-regulator.c
+++ b/drivers/regulator/wm8400-regulator.c
@@ -289,7 +289,7 @@ static struct regulator_desc regulators[] = {
         },
 };
 
-static int __init wm8400_regulator_probe(struct platform_device *pdev)
+static int __devinit wm8400_regulator_probe(struct platform_device *pdev)
 {
         struct regulator_dev *rdev;
 
diff --git a/drivers/rtc/rtc-pxa.c b/drivers/rtc/rtc-pxa.c
index cc7eb8767b82..bd56a033bfd0 100644
--- a/drivers/rtc/rtc-pxa.c
+++ b/drivers/rtc/rtc-pxa.c
@@ -27,6 +27,8 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 
+#include <mach/hardware.h>
+
 #define TIMER_FREQ              CLOCK_TICK_RATE
 #define RTC_DEF_DIVIDER         (32768 - 1)
 #define RTC_DEF_TRIM            0
diff --git a/drivers/rtc/rtc-twl4030.c b/drivers/rtc/rtc-twl4030.c
index 8ce5f74ee45b..ad35f76c46b7 100644
--- a/drivers/rtc/rtc-twl4030.c
+++ b/drivers/rtc/rtc-twl4030.c
@@ -120,7 +120,7 @@ static int twl4030_rtc_write_u8(u8 data, u8 reg)
 static unsigned char rtc_irq_bits;
 
 /*
- * Enable timer and/or alarm interrupts.
+ * Enable 1/second update and/or alarm interrupts.
  */
 static int set_rtc_irq_bit(unsigned char bit)
 {
@@ -128,6 +128,7 @@ static int set_rtc_irq_bit(unsigned char bit)
         int ret;
 
         val = rtc_irq_bits | bit;
+        val &= ~BIT_RTC_INTERRUPTS_REG_EVERY_M;
         ret = twl4030_rtc_write_u8(val, REG_RTC_INTERRUPTS_REG);
         if (ret == 0)
                 rtc_irq_bits = val;
@@ -136,7 +137,7 @@ static int set_rtc_irq_bit(unsigned char bit)
 }
 
 /*
- * Disable timer and/or alarm interrupts.
+ * Disable update and/or alarm interrupts.
  */
 static int mask_rtc_irq_bit(unsigned char bit)
 {
@@ -151,7 +152,7 @@ static int mask_rtc_irq_bit(unsigned char bit)
         return ret;
 }
 
-static inline int twl4030_rtc_alarm_irq_set_state(int enabled)
+static int twl4030_rtc_alarm_irq_enable(struct device *dev, unsigned enabled)
 {
         int ret;
 
@@ -163,7 +164,7 @@ static inline int twl4030_rtc_alarm_irq_set_state(int enabled)
         return ret;
 }
 
-static inline int twl4030_rtc_irq_set_state(int enabled)
+static int twl4030_rtc_update_irq_enable(struct device *dev, unsigned enabled)
 {
         int ret;
 
@@ -292,7 +293,7 @@ static int twl4030_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
         unsigned char alarm_data[ALL_TIME_REGS + 1];
         int ret;
 
-        ret = twl4030_rtc_alarm_irq_set_state(0);
+        ret = twl4030_rtc_alarm_irq_enable(dev, 0);
         if (ret)
                 goto out;
 
@@ -312,35 +313,11 @@ static int twl4030_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
         }
 
         if (alm->enabled)
-                ret = twl4030_rtc_alarm_irq_set_state(1);
+                ret = twl4030_rtc_alarm_irq_enable(dev, 1);
 out:
         return ret;
 }
 
-#ifdef  CONFIG_RTC_INTF_DEV
-
-static int twl4030_rtc_ioctl(struct device *dev, unsigned int cmd,
-                             unsigned long arg)
-{
-        switch (cmd) {
-        case RTC_AIE_OFF:
-                return twl4030_rtc_alarm_irq_set_state(0);
-        case RTC_AIE_ON:
-                return twl4030_rtc_alarm_irq_set_state(1);
-        case RTC_UIE_OFF:
-                return twl4030_rtc_irq_set_state(0);
-        case RTC_UIE_ON:
-                return twl4030_rtc_irq_set_state(1);
-
-        default:
-                return -ENOIOCTLCMD;
-        }
-}
-
-#else
-#define twl4030_rtc_ioctl       NULL
-#endif
-
 static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc)
 {
         unsigned long events = 0;
@@ -400,11 +377,12 @@ out:
 }
 
 static struct rtc_class_ops twl4030_rtc_ops = {
-        .ioctl          = twl4030_rtc_ioctl,
         .read_time      = twl4030_rtc_read_time,
         .set_time       = twl4030_rtc_set_time,
         .read_alarm     = twl4030_rtc_read_alarm,
         .set_alarm      = twl4030_rtc_set_alarm,
+        .alarm_irq_enable = twl4030_rtc_alarm_irq_enable,
+        .update_irq_enable = twl4030_rtc_update_irq_enable,
 };
 
 /*----------------------------------------------------------------------*/
@@ -422,7 +400,7 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
         rtc = rtc_device_register(pdev->name,
                                   &pdev->dev, &twl4030_rtc_ops, THIS_MODULE);
         if (IS_ERR(rtc)) {
-                ret = -EINVAL;
+                ret = PTR_ERR(rtc);
                 dev_err(&pdev->dev, "can't register RTC device, err %ld\n",
                         PTR_ERR(rtc));
                 goto out0;
@@ -432,7 +410,6 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, rtc);
 
         ret = twl4030_rtc_read_u8(&rd_reg, REG_RTC_STATUS_REG);
-
         if (ret < 0)
                 goto out1;
 
@@ -475,7 +452,6 @@ static int __devinit twl4030_rtc_probe(struct platform_device *pdev)
 
         return ret;
 
-
 out2:
         free_irq(irq, rtc);
 out1:
@@ -506,8 +482,9 @@ static int __devexit twl4030_rtc_remove(struct platform_device *pdev)
 
 static void twl4030_rtc_shutdown(struct platform_device *pdev)
 {
-        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M |
-                         BIT_RTC_INTERRUPTS_REG_IT_ALARM_M);
+        /* mask timer interrupts, but leave alarm interrupts on to enable
+           power-on when alarm is triggered */
+        mask_rtc_irq_bit(BIT_RTC_INTERRUPTS_REG_IT_TIMER_M);
 }
 
 #ifdef CONFIG_PM
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index acca6678cb2b..49c3bfa1afd7 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -70,7 +70,9 @@ static char debug_buffer[255];
 static void lcs_tasklet(unsigned long);
 static void lcs_start_kernel_thread(struct work_struct *);
 static void lcs_get_frames_cb(struct lcs_channel *, struct lcs_buffer *);
+#ifdef CONFIG_IP_MULTICAST
 static int lcs_send_delipm(struct lcs_card *, struct lcs_ipm_list *);
+#endif /* CONFIG_IP_MULTICAST */
 static int lcs_recovery(void *ptr);
 
 /**
@@ -1285,6 +1287,8 @@ out:
         lcs_clear_thread_running_bit(card, LCS_SET_MC_THREAD);
         return 0;
 }
+#endif /* CONFIG_IP_MULTICAST */
+
 /**
  * function called by net device to
  * handle multicast address relevant things
@@ -1292,6 +1296,7 @@ out:
 static void
 lcs_set_multicast_list(struct net_device *dev)
 {
+#ifdef CONFIG_IP_MULTICAST
         struct lcs_card *card;
 
         LCS_DBF_TEXT(4, trace, "setmulti");
@@ -1299,9 +1304,8 @@ lcs_set_multicast_list(struct net_device *dev)
 
         if (!lcs_set_thread_start_bit(card, LCS_SET_MC_THREAD))
                 schedule_work(&card->kernel_thread_starter);
-}
-
 #endif /* CONFIG_IP_MULTICAST */
+}
 
 static long
 lcs_check_irb_error(struct ccw_device *cdev, struct irb *irb)
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.c b/drivers/scsi/ibmvscsi/ibmvfc.c
index ee0739b217b6..91ef669d98f6 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.c
+++ b/drivers/scsi/ibmvscsi/ibmvfc.c
@@ -933,7 +933,7 @@ static void ibmvfc_get_host_speed(struct Scsi_Host *shost)
                         fc_host_speed(shost) = FC_PORTSPEED_16GBIT;
                         break;
                 default:
-                        ibmvfc_log(vhost, 3, "Unknown port speed: %ld Gbit\n",
+                        ibmvfc_log(vhost, 3, "Unknown port speed: %lld Gbit\n",
                                    vhost->login_buf->resp.link_speed / 100);
                         fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN;
                         break;
@@ -2149,8 +2149,8 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
 {
         const char *desc = ibmvfc_get_ae_desc(crq->event);
 
-        ibmvfc_log(vhost, 3, "%s event received. scsi_id: %lx, wwpn: %lx,"
-                   " node_name: %lx\n", desc, crq->scsi_id, crq->wwpn, crq->node_name);
+        ibmvfc_log(vhost, 3, "%s event received. scsi_id: %llx, wwpn: %llx,"
+                   " node_name: %llx\n", desc, crq->scsi_id, crq->wwpn, crq->node_name);
 
         switch (crq->event) {
         case IBMVFC_AE_LINK_UP:
@@ -2184,7 +2184,7 @@ static void ibmvfc_handle_async(struct ibmvfc_async_crq *crq,
                 ibmvfc_link_down(vhost, IBMVFC_HALTED);
                 break;
         default:
-                dev_err(vhost->dev, "Unknown async event received: %ld\n", crq->event);
+                dev_err(vhost->dev, "Unknown async event received: %lld\n", crq->event);
                 break;
         };
 }
@@ -2261,13 +2261,13 @@ static void ibmvfc_handle_crq(struct ibmvfc_crq *crq, struct ibmvfc_host *vhost)
          * actually sent
          */
         if (unlikely(!ibmvfc_valid_event(&vhost->pool, evt))) {
-                dev_err(vhost->dev, "Returned correlation_token 0x%08lx is invalid!\n",
+                dev_err(vhost->dev, "Returned correlation_token 0x%08llx is invalid!\n",
                         crq->ioba);
                 return;
         }
 
         if (unlikely(atomic_read(&evt->free))) {
-                dev_err(vhost->dev, "Received duplicate correlation_token 0x%08lx!\n",
+                dev_err(vhost->dev, "Received duplicate correlation_token 0x%08llx!\n",
                         crq->ioba);
                 return;
         }
@@ -3259,7 +3259,7 @@ static int ibmvfc_alloc_target(struct ibmvfc_host *vhost, u64 scsi_id)
 
         tgt = mempool_alloc(vhost->tgt_pool, GFP_KERNEL);
         if (!tgt) {
-                dev_err(vhost->dev, "Target allocation failure for scsi id %08lx\n",
+                dev_err(vhost->dev, "Target allocation failure for scsi id %08llx\n",
                         scsi_id);
                 return -ENOMEM;
         }
diff --git a/drivers/scsi/ibmvscsi/ibmvfc.h b/drivers/scsi/ibmvscsi/ibmvfc.h
index babdf3db59df..87dafd0f8d44 100644
--- a/drivers/scsi/ibmvscsi/ibmvfc.h
+++ b/drivers/scsi/ibmvscsi/ibmvfc.h
@@ -691,13 +691,13 @@ struct ibmvfc_host {
 #define DBG_CMD(CMD) do { if (ibmvfc_debug) CMD; } while (0)
 
 #define tgt_dbg(t, fmt, ...)                    \
-        DBG_CMD(dev_info((t)->vhost->dev, "%lX: " fmt, (t)->scsi_id, ##__VA_ARGS__))
+        DBG_CMD(dev_info((t)->vhost->dev, "%llX: " fmt, (t)->scsi_id, ##__VA_ARGS__))
 
 #define tgt_info(t, fmt, ...)           \
-        dev_info((t)->vhost->dev, "%lX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
+        dev_info((t)->vhost->dev, "%llX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
 
 #define tgt_err(t, fmt, ...)            \
-        dev_err((t)->vhost->dev, "%lX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
+        dev_err((t)->vhost->dev, "%llX: " fmt, (t)->scsi_id, ##__VA_ARGS__)
 
 #define ibmvfc_dbg(vhost, ...) \
         DBG_CMD(dev_info((vhost)->dev, ##__VA_ARGS__))
diff --git a/drivers/scsi/ipr.c b/drivers/scsi/ipr.c
index 841f460edbc4..07829009a8be 100644
--- a/drivers/scsi/ipr.c
+++ b/drivers/scsi/ipr.c
@@ -4912,7 +4912,7 @@ static int ipr_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
         if (res && ipr_is_gata(res)) {
                 if (cmd == HDIO_GET_IDENTITY)
                         return -ENOTTY;
-                return ata_scsi_ioctl(sdev, cmd, arg);
+                return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
         }
 
         return -EINVAL;
diff --git a/drivers/scsi/libiscsi_tcp.c b/drivers/scsi/libiscsi_tcp.c
index a745f91d2928..e7705d3532c9 100644
--- a/drivers/scsi/libiscsi_tcp.c
+++ b/drivers/scsi/libiscsi_tcp.c
@@ -177,7 +177,6 @@ int iscsi_tcp_segment_done(struct iscsi_tcp_conn *tcp_conn,
                            struct iscsi_segment *segment, int recv,
                            unsigned copied)
 {
-        static unsigned char padbuf[ISCSI_PAD_LEN];
         struct scatterlist sg;
         unsigned int pad;
 
@@ -233,7 +232,7 @@ int iscsi_tcp_segment_done(struct iscsi_tcp_conn *tcp_conn,
                         debug_tcp("consume %d pad bytes\n", pad);
                         segment->total_size += pad;
                         segment->size = pad;
-                        segment->data = padbuf;
+                        segment->data = segment->padbuf;
                         return 0;
                 }
         }
diff --git a/drivers/scsi/libsas/sas_scsi_host.c b/drivers/scsi/libsas/sas_scsi_host.c
index 744838780ada..1c558d3bce18 100644
--- a/drivers/scsi/libsas/sas_scsi_host.c
+++ b/drivers/scsi/libsas/sas_scsi_host.c
@@ -717,7 +717,7 @@ int sas_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
         struct domain_device *dev = sdev_to_domain_dev(sdev);
 
         if (dev_is_sata(dev))
-                return ata_scsi_ioctl(sdev, cmd, arg);
+                return ata_sas_scsi_ioctl(dev->sata_dev.ap, sdev, cmd, arg);
 
         return -EINVAL;
 }
diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
index ce48e2d0193c..ca0dd33497ec 100644
--- a/drivers/scsi/ps3rom.c
+++ b/drivers/scsi/ps3rom.c
@@ -290,11 +290,11 @@ static irqreturn_t ps3rom_interrupt(int irq, void *data)
 
         if (tag != dev->tag)
                 dev_err(&dev->sbd.core,
-                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        "%s:%u: tag mismatch, got %llx, expected %llx\n",
                         __func__, __LINE__, tag, dev->tag);
 
         if (res) {
-                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%llx\n",
                         __func__, __LINE__, res, status);
                 return IRQ_HANDLED;
         }
@@ -364,7 +364,7 @@ static int __devinit ps3rom_probe(struct ps3_system_bus_device *_dev)
 
         if (dev->blk_size != CD_FRAMESIZE) {
                 dev_err(&dev->sbd.core,
-                        "%s:%u: cannot handle block size %lu\n", __func__,
+                        "%s:%u: cannot handle block size %llu\n", __func__,
                         __LINE__, dev->blk_size);
                 return -EINVAL;
         }
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 2d4f32b4df5c..9ad4d0968e5c 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -1258,35 +1258,48 @@ qla2x00_init_rings(scsi_qla_host_t *vha)
 {
         int     rval;
         unsigned long flags = 0;
-        int cnt;
+        int cnt, que;
         struct qla_hw_data *ha = vha->hw;
-        struct req_que *req = ha->req_q_map[0];
-        struct rsp_que *rsp = ha->rsp_q_map[0];
+        struct req_que *req;
+        struct rsp_que *rsp;
+        struct scsi_qla_host *vp;
         struct mid_init_cb_24xx *mid_init_cb =
             (struct mid_init_cb_24xx *) ha->init_cb;
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
 
         /* Clear outstanding commands array. */
-        for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
-                req->outstanding_cmds[cnt] = NULL;
+        for (que = 0; que < ha->max_queues; que++) {
+                req = ha->req_q_map[que];
+                if (!req)
+                        continue;
+                for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++)
+                        req->outstanding_cmds[cnt] = NULL;
 
-        req->current_outstanding_cmd = 0;
+                req->current_outstanding_cmd = 0;
 
-        /* Clear RSCN queue. */
-        vha->rscn_in_ptr = 0;
-        vha->rscn_out_ptr = 0;
+                /* Initialize firmware. */
+                req->ring_ptr  = req->ring;
+                req->ring_index    = 0;
+                req->cnt      = req->length;
+        }
 
-        /* Initialize firmware. */
-        req->ring_ptr  = req->ring;
-        req->ring_index    = 0;
-        req->cnt      = req->length;
-        rsp->ring_ptr = rsp->ring;
-        rsp->ring_index    = 0;
+        for (que = 0; que < ha->max_queues; que++) {
+                rsp = ha->rsp_q_map[que];
+                if (!rsp)
+                        continue;
+                rsp->ring_ptr = rsp->ring;
+                rsp->ring_index    = 0;
 
-        /* Initialize response queue entries */
-        qla2x00_init_response_q_entries(rsp);
+                /* Initialize response queue entries */
+                qla2x00_init_response_q_entries(rsp);
+        }
 
+        /* Clear RSCN queue. */
+        list_for_each_entry(vp, &ha->vp_list, list) {
+                vp->rscn_in_ptr = 0;
+                vp->rscn_out_ptr = 0;
+        }
         ha->isp_ops->config_rings(vha);
 
         spin_unlock_irqrestore(&ha->hardware_lock, flags);
@@ -3212,8 +3225,8 @@ qla2x00_loop_resync(scsi_qla_host_t *vha)
         int rval = QLA_SUCCESS;
         uint32_t wait_time;
         struct qla_hw_data *ha = vha->hw;
-        struct req_que *req = ha->req_q_map[0];
-        struct rsp_que *rsp = ha->rsp_q_map[0];
+        struct req_que *req = ha->req_q_map[vha->req_ques[0]];
+        struct rsp_que *rsp = req->rsp;
 
         atomic_set(&vha->loop_state, LOOP_UPDATE);
         clear_bit(ISP_ABORT_RETRY, &vha->dpc_flags);
@@ -3492,6 +3505,7 @@ qla25xx_init_queues(struct qla_hw_data *ha)
                 }
                 req = ha->req_q_map[i];
                 if (req) {
+                /* Clear outstanding commands array. */
                         req->options &= ~BIT_0;
                         ret = qla25xx_init_req_que(base_vha, req, req->options);
                         if (ret != QLA_SUCCESS)
@@ -3500,7 +3514,7 @@ qla25xx_init_queues(struct qla_hw_data *ha)
                                                 req->id));
                         else
                                 DEBUG2_17(printk(KERN_WARNING
-                                        "%s Rsp que:%d inited\n", __func__,
+                                        "%s Req que:%d inited\n", __func__,
                                                 req->id));
                 }
         }
@@ -4151,8 +4165,8 @@ qla24xx_configure_vhba(scsi_qla_host_t *vha)
         uint16_t mb[MAILBOX_REGISTER_COUNT];
         struct qla_hw_data *ha = vha->hw;
         struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
-        struct req_que *req = ha->req_q_map[0];
-        struct rsp_que *rsp = ha->rsp_q_map[0];
+        struct req_que *req = ha->req_q_map[vha->req_ques[0]];
+        struct rsp_que *rsp = req->rsp;
 
         if (!vha->vp_idx)
                 return -EINVAL;
diff --git a/drivers/scsi/qla2xxx/qla_mid.c b/drivers/scsi/qla2xxx/qla_mid.c
index 886323130fcc..f53179c46423 100644
--- a/drivers/scsi/qla2xxx/qla_mid.c
+++ b/drivers/scsi/qla2xxx/qla_mid.c
@@ -629,6 +629,7 @@ qla25xx_create_req_que(struct qla_hw_data *ha, uint16_t options,
         req->ring_index = 0;
         req->cnt = req->length;
         req->id = que_id;
+        req->max_q_depth = ha->req_q_map[0]->max_q_depth;
         mutex_unlock(&ha->vport_lock);
 
         ret = qla25xx_init_req_que(base_vha, req, options);
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index 4a71f522f925..cf32653fe01a 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -1158,8 +1158,8 @@ qla2x00_abort_all_cmds(scsi_qla_host_t *vha, int res)
         struct req_que *req;
 
         spin_lock_irqsave(&ha->hardware_lock, flags);
-        for (que = 0; que < QLA_MAX_HOST_QUES; que++) {
-                req = ha->req_q_map[vha->req_ques[que]];
+        for (que = 0; que < ha->max_queues; que++) {
+                req = ha->req_q_map[que];
                 if (!req)
                         continue;
                 for (cnt = 1; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
@@ -1193,7 +1193,7 @@ qla2xxx_slave_configure(struct scsi_device *sdev)
         scsi_qla_host_t *vha = shost_priv(sdev->host);
         struct qla_hw_data *ha = vha->hw;
         struct fc_rport *rport = starget_to_rport(sdev->sdev_target);
-        struct req_que *req = ha->req_q_map[0];
+        struct req_que *req = ha->req_q_map[vha->req_ques[0]];
 
         if (sdev->tagged_supported)
                 scsi_activate_tcq(sdev, req->max_q_depth);
@@ -1998,7 +1998,6 @@ qla2x00_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         return 0;
 
 probe_failed:
-        qla2x00_free_que(ha, req, rsp);
         qla2x00_free_device(base_vha);
 
         scsi_host_put(base_vha->host);
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index 42e72a2c1f98..cbcd3f681b62 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -1095,7 +1095,8 @@ EXPORT_SYMBOL(__starget_for_each_device);
  * Description: Looks up the scsi_device with the specified @lun for a given
  * @starget.  The returned scsi_device does not have an additional
  * reference.  You must hold the host's host_lock over this call and
- * any access to the returned scsi_device.
+ * any access to the returned scsi_device. A scsi_device in state
+ * SDEV_DEL is skipped.
  *
  * Note:  The only reason why drivers should use this is because
  * they need to access the device list in irq context.  Otherwise you
@@ -1107,6 +1108,8 @@ struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *starget,
         struct scsi_device *sdev;
 
         list_for_each_entry(sdev, &starget->devices, same_target_siblings) {
+                if (sdev->sdev_state == SDEV_DEL)
+                        continue;
                 if (sdev->lun ==lun)
                         return sdev;
         }
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index 4969e4ec75ea..099b5455bbce 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -224,6 +224,7 @@ static struct {
         {"SGI", "TP9100", "*", BLIST_REPORTLUN2},
         {"SGI", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
         {"IBM", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
+        {"SUN", "Universal Xport", "*", BLIST_NO_ULD_ATTACH},
         {"SMSC", "USB 2 HS-CF", NULL, BLIST_SPARSELUN | BLIST_INQUIRY_36},
         {"SONY", "CD-ROM CDU-8001", NULL, BLIST_BORKEN},
         {"SONY", "TSL", NULL, BLIST_FORCELUN},          /* DDS3 & DDS4 autoloaders */
diff --git a/drivers/serial/8250_pci.c b/drivers/serial/8250_pci.c
index c088146b7513..2a3671233b15 100644
--- a/drivers/serial/8250_pci.c
+++ b/drivers/serial/8250_pci.c
@@ -602,6 +602,10 @@ static int pci_netmos_init(struct pci_dev *dev)
         /* subdevice 0x00PS means <P> parallel, <S> serial */
         unsigned int num_serial = dev->subsystem_device & 0xf;
 
+        if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM &&
+                        dev->subsystem_device == 0x0299)
+                return 0;
+
         if (num_serial == 0)
                 return -ENODEV;
         return num_serial;
@@ -3096,6 +3100,10 @@ static struct pci_device_id serial_pci_tbl[] = {
                 0,
                 pbn_b0_8_115200 },
 
+        {       PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9835,
+                PCI_VENDOR_ID_IBM, 0x0299,
+                0, 0, pbn_b0_bt_2_115200 },
+
         /*
          * These entries match devices with class COMMUNICATION_SERIAL,
          * COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL
diff --git a/drivers/serial/8250_pnp.c b/drivers/serial/8250_pnp.c
index fde7f9ccf57e..bbcfc26a3b6d 100644
--- a/drivers/serial/8250_pnp.c
+++ b/drivers/serial/8250_pnp.c
@@ -270,6 +270,8 @@ static const struct pnp_device_id pnp_dev_table[] = {
         {       "RSS0250",              0       },
         /* SupraExpress 28.8 Data/Fax PnP modem */
         {       "SUP1310",              0       },
+        /* SupraExpress 336i PnP Voice Modem */
+        {       "SUP1381",              0       },
         /* SupraExpress 33.6 Data/Fax PnP modem */
         {       "SUP1421",              0       },
         /* SupraExpress 33.6 Data/Fax PnP modem */
diff --git a/drivers/serial/atmel_serial.c b/drivers/serial/atmel_serial.c
index d5efd6c77904..89362d733d62 100644
--- a/drivers/serial/atmel_serial.c
+++ b/drivers/serial/atmel_serial.c
@@ -579,7 +579,7 @@ static void atmel_tx_dma(struct uart_port *port)
         /* disable PDC transmit */
         UART_PUT_PTCR(port, ATMEL_PDC_TXTDIS);
 
-        if (!uart_circ_empty(xmit)) {
+        if (!uart_circ_empty(xmit) && !uart_tx_stopped(port)) {
                 dma_sync_single_for_device(port->dev,
                                            pdc->dma_addr,
                                            pdc->dma_size,
diff --git a/drivers/serial/of_serial.c b/drivers/serial/of_serial.c
index a821e3a3d664..14f8fa9135be 100644
--- a/drivers/serial/of_serial.c
+++ b/drivers/serial/of_serial.c
@@ -163,6 +163,7 @@ static struct of_device_id __devinitdata of_platform_serial_table[] = {
         { .type = "serial", .compatible = "ns16450",  .data = (void *)PORT_16450, },
         { .type = "serial", .compatible = "ns16550",  .data = (void *)PORT_16550, },
         { .type = "serial", .compatible = "ns16750",  .data = (void *)PORT_16750, },
+        { .type = "serial", .compatible = "ns16850",  .data = (void *)PORT_16850, },
 #ifdef CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL
         { .type = "serial", .compatible = "ibm,qpace-nwp-serial",
                                         .data = (void *)PORT_NWPSERIAL, },
diff --git a/drivers/serial/pnx8xxx_uart.c b/drivers/serial/pnx8xxx_uart.c
index 22e30d21225e..1bb8f1b45767 100644
--- a/drivers/serial/pnx8xxx_uart.c
+++ b/drivers/serial/pnx8xxx_uart.c
@@ -187,7 +187,7 @@ static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
         status = FIFO_TO_SM(serial_in(sport, PNX8XXX_FIFO)) |
                  ISTAT_TO_SM(serial_in(sport, PNX8XXX_ISTAT));
         while (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFIFO)) {
-                ch = serial_in(sport, PNX8XXX_FIFO);
+                ch = serial_in(sport, PNX8XXX_FIFO) & 0xff;
 
                 sport->port.icount.rx++;
 
@@ -198,9 +198,16 @@ static void pnx8xxx_rx_chars(struct pnx8xxx_port *sport)
                  * out of the main execution path
                  */
                 if (status & (FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE |
-                                        PNX8XXX_UART_FIFO_RXPAR) |
+                                        PNX8XXX_UART_FIFO_RXPAR |
+                                        PNX8XXX_UART_FIFO_RXBRK) |
                               ISTAT_TO_SM(PNX8XXX_UART_INT_RXOVRN))) {
-                        if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXPAR))
+                        if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXBRK)) {
+                                status &= ~(FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE) |
+                                        FIFO_TO_SM(PNX8XXX_UART_FIFO_RXPAR));
+                                sport->port.icount.brk++;
+                                if (uart_handle_break(&sport->port))
+                                        goto ignore_char;
+                        } else if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXPAR))
                                 sport->port.icount.parity++;
                         else if (status & FIFO_TO_SM(PNX8XXX_UART_FIFO_RXFE))
                                 sport->port.icount.frame++;
@@ -284,14 +291,8 @@ static irqreturn_t pnx8xxx_int(int irq, void *dev_id)
         /* Get the interrupts */
         status  = serial_in(sport, PNX8XXX_ISTAT) & serial_in(sport, PNX8XXX_IEN);
 
-        /* Break signal received */
-        if (status & PNX8XXX_UART_INT_BREAK) {
-                sport->port.icount.brk++;
-                uart_handle_break(&sport->port);
-        }
-
-        /* Byte received */
-        if (status & PNX8XXX_UART_INT_RX)
+        /* Byte or break signal received */
+        if (status & (PNX8XXX_UART_INT_RX | PNX8XXX_UART_INT_BREAK))
                 pnx8xxx_rx_chars(sport);
 
         /* TX holding register empty - transmit a byte */
diff --git a/drivers/serial/sh-sci.h b/drivers/serial/sh-sci.h
index 38c600c0dbbf..3599828b9766 100644
--- a/drivers/serial/sh-sci.h
+++ b/drivers/serial/sh-sci.h
@@ -32,7 +32,9 @@
 #elif defined(CONFIG_CPU_SUBTYPE_SH7720) || \
       defined(CONFIG_CPU_SUBTYPE_SH7721)
 # define SCSCR_INIT(port)  0x0030 /* TIE=0,RIE=0,TE=1,RE=1 */
-#define SCIF_ORER    0x0200   /* overrun error bit */
+# define PORT_PTCR         0xA405011EUL
+# define PORT_PVCR         0xA4050122UL
+# define SCIF_ORER         0x0200   /* overrun error bit */
 #elif defined(CONFIG_SH_RTS7751R2D)
 # define SCSPTR1 0xFFE0001C /* 8 bit SCIF */
 # define SCSPTR2 0xFFE80020 /* 16 bit SCIF */
@@ -393,6 +395,7 @@ SCIx_FNS(SCSCR,  0x08, 16, 0x08, 16)
 SCIx_FNS(SCxTDR, 0x20,  8, 0x0c,  8)
 SCIx_FNS(SCxSR,  0x14, 16, 0x10, 16)
 SCIx_FNS(SCxRDR, 0x24,  8, 0x14,  8)
+SCIx_FNS(SCSPTR, 0,     0,    0,  0)
 SCIF_FNS(SCTDSR, 0x0c,  8)
 SCIF_FNS(SCFER,  0x10, 16)
 SCIF_FNS(SCFCR,  0x18, 16)
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 4a6fe01831a8..83a185d52961 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -230,17 +230,6 @@ config SPI_XILINX
 #
 comment "SPI Protocol Masters"
 
-config SPI_AT25
-        tristate "SPI EEPROMs from most vendors"
-        depends on SYSFS
-        help
-          Enable this driver to get read/write support to most SPI EEPROMs,
-          after you configure the board init code to know about each eeprom
-          on your target board.
-
-          This driver can also be built as a module.  If so, the module
-          will be called at25.
-
 config SPI_SPIDEV
         tristate "User mode SPI device driver support"
         depends on EXPERIMENTAL
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index 5e9f521b8844..5d0451936d86 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -33,7 +33,6 @@ obj-$(CONFIG_SPI_SH_SCI)		+= spi_sh_sci.o
 #       ... add above this line ...
 
 # SPI protocol drivers (device/link on bus)
-obj-$(CONFIG_SPI_AT25)          += at25.o
 obj-$(CONFIG_SPI_SPIDEV)        += spidev.o
 obj-$(CONFIG_SPI_TLE62X0)       += tle62x0.o
 #       ... add above this line ...
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index 5e39bac9c51b..56ff3e6864ea 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -670,8 +670,7 @@ static int atmel_spi_transfer(struct spi_device *spi, struct spi_message *msg)
         dev_dbg(controller, "new message %p submitted for %s\n",
                         msg, spi->dev.bus_id);
 
-        if (unlikely(list_empty(&msg->transfers)
-                        || !spi->max_speed_hz))
+        if (unlikely(list_empty(&msg->transfers)))
                 return -EINVAL;
 
         if (as->stopping)
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index d5d0e40b1e2d..94d5ee263c20 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1554,7 +1554,7 @@ static int usb_configure_device_otg(struct usb_device *udev)
                  * (Includes HNP test device.)
                  */
                 if (udev->bus->b_hnp_enable || udev->bus->is_b_host) {
-                        err = usb_port_suspend(udev);
+                        err = usb_port_suspend(udev, PMSG_SUSPEND);
                         if (err < 0)
                                 dev_dbg(&udev->dev, "HNP fail, %d\n", err);
                 }
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index ef6cfa5a447f..c70a8f667d85 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -2030,7 +2030,7 @@ static void ftdi_process_read(struct work_struct *work)
                         spin_unlock_irqrestore(&priv->rx_lock, flags);
                         dbg("%s - deferring remainder until unthrottled",
                                         __func__);
-                        return;
+                        goto out;
                 }
                 spin_unlock_irqrestore(&priv->rx_lock, flags);
                 /* if the port is closed stop trying to read */
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 6372f8b17b45..c94f71980c1b 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -2123,6 +2123,18 @@ config FB_PRE_INIT_FB
           Select this option if display contents should be inherited as set by
           the bootloader.
 
+config FB_MX3
+       tristate "MX3 Framebuffer support"
+       depends on FB && MX3_IPU
+       select FB_CFB_FILLRECT
+       select FB_CFB_COPYAREA
+       select FB_CFB_IMAGEBLIT
+       default y
+       help
+         This is a framebuffer device for the i.MX31 LCD Controller. So
+         far only synchronous displays are supported. If you plan to use
+         an LCD display with your i.MX31 system, say Y here.
+
 source "drivers/video/omap/Kconfig"
 
 source "drivers/video/backlight/Kconfig"
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index be2b657546ef..2a998ca6181d 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -132,6 +132,7 @@ obj-$(CONFIG_FB_VGA16)            += vga16fb.o
 obj-$(CONFIG_FB_OF)               += offb.o
 obj-$(CONFIG_FB_BF54X_LQ043)      += bf54x-lq043fb.o
 obj-$(CONFIG_FB_BFIN_T350MCQB)    += bfin-t350mcqb-fb.o
+obj-$(CONFIG_FB_MX3)              += mx3fb.o
 
 # the test framebuffer is last
 obj-$(CONFIG_FB_VIRTUAL)          += vfb.o
diff --git a/drivers/video/aty/radeon_i2c.c b/drivers/video/aty/radeon_i2c.c
index 2c5567175dca..359fc64e761a 100644
--- a/drivers/video/aty/radeon_i2c.c
+++ b/drivers/video/aty/radeon_i2c.c
@@ -72,7 +72,6 @@ static int radeon_setup_i2c_bus(struct radeon_i2c_chan *chan, const char *name)
         snprintf(chan->adapter.name, sizeof(chan->adapter.name),
                  "radeonfb %s", name);
         chan->adapter.owner             = THIS_MODULE;
-        chan->adapter.id                = I2C_HW_B_RADEON;
         chan->adapter.algo_data         = &chan->algo;
         chan->adapter.dev.parent        = &chan->rinfo->pdev->dev;
         chan->algo.setsda               = radeon_gpio_setsda;
diff --git a/drivers/video/bf54x-lq043fb.c b/drivers/video/bf54x-lq043fb.c
index 7644ed249564..37e60b1d2ed9 100644
--- a/drivers/video/bf54x-lq043fb.c
+++ b/drivers/video/bf54x-lq043fb.c
@@ -335,7 +335,20 @@ static int bfin_bf54x_fb_check_var(struct fb_var_screeninfo *var,
                                    struct fb_info *info)
 {
 
-        if (var->bits_per_pixel != LCD_BPP) {
+        switch (var->bits_per_pixel) {
+        case 24:/* TRUECOLOUR, 16m */
+                var->red.offset = 16;
+                var->green.offset = 8;
+                var->blue.offset = 0;
+                var->red.length = var->green.length = var->blue.length = 8;
+                var->transp.offset = 0;
+                var->transp.length = 0;
+                var->transp.msb_right = 0;
+                var->red.msb_right = 0;
+                var->green.msb_right = 0;
+                var->blue.msb_right = 0;
+                break;
+        default:
                 pr_debug("%s: depth not supported: %u BPP\n", __func__,
                          var->bits_per_pixel);
                 return -EINVAL;
diff --git a/drivers/video/bfin-t350mcqb-fb.c b/drivers/video/bfin-t350mcqb-fb.c
index a9b3ada05d99..2a423d3a2a8e 100644
--- a/drivers/video/bfin-t350mcqb-fb.c
+++ b/drivers/video/bfin-t350mcqb-fb.c
@@ -254,7 +254,20 @@ static int bfin_t350mcqb_fb_check_var(struct fb_var_screeninfo *var,
                                    struct fb_info *info)
 {
 
-        if (var->bits_per_pixel != LCD_BPP) {
+        switch (var->bits_per_pixel) {
+        case 24:/* TRUECOLOUR, 16m */
+                var->red.offset = 0;
+                var->green.offset = 8;
+                var->blue.offset = 16;
+                var->red.length = var->green.length = var->blue.length = 8;
+                var->transp.offset = 0;
+                var->transp.length = 0;
+                var->transp.msb_right = 0;
+                var->red.msb_right = 0;
+                var->green.msb_right = 0;
+                var->blue.msb_right = 0;
+                break;
+        default:
                 pr_debug("%s: depth not supported: %u BPP\n", __func__,
                          var->bits_per_pixel);
                 return -EINVAL;
diff --git a/drivers/video/i810/i810-i2c.c b/drivers/video/i810/i810-i2c.c
index 7787c3322ffb..9dd55e5324a1 100644
--- a/drivers/video/i810/i810-i2c.c
+++ b/drivers/video/i810/i810-i2c.c
@@ -90,7 +90,6 @@ static int i810_setup_i2c_bus(struct i810fb_i2c_chan *chan, const char *name)
         chan->adapter.owner             = THIS_MODULE;
         chan->adapter.algo_data         = &chan->algo;
         chan->adapter.dev.parent        = &chan->par->dev->dev;
-        chan->adapter.id                = I2C_HW_B_I810;
         chan->algo.setsda               = i810i2c_setsda;
         chan->algo.setscl               = i810i2c_setscl;
         chan->algo.getsda               = i810i2c_getsda;
diff --git a/drivers/video/intelfb/intelfb_i2c.c b/drivers/video/intelfb/intelfb_i2c.c
index 5d896b81f4e0..b3065492bb20 100644
--- a/drivers/video/intelfb/intelfb_i2c.c
+++ b/drivers/video/intelfb/intelfb_i2c.c
@@ -111,7 +111,6 @@ static int intelfb_setup_i2c_bus(struct intelfb_info *dinfo,
                  "intelfb %s", name);
         chan->adapter.class             = class;
         chan->adapter.owner             = THIS_MODULE;
-        chan->adapter.id                = I2C_HW_B_INTELFB;
         chan->adapter.algo_data         = &chan->algo;
         chan->adapter.dev.parent        = &chan->dinfo->pdev->dev;
         chan->algo.setsda               = intelfb_gpio_setsda;
diff --git a/drivers/video/mx3fb.c b/drivers/video/mx3fb.c
new file mode 100644
index 000000000000..8a75d05f4334
--- /dev/null
+++ b/drivers/video/mx3fb.c
@@ -0,0 +1,1555 @@
+/*
+ * Copyright (C) 2008
+ * Guennadi Liakhovetski, DENX Software Engineering, <lg@denx.de>
+ *
+ * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/interrupt.h>
+#include <linux/slab.h>
+#include <linux/fb.h>
+#include <linux/delay.h>
+#include <linux/init.h>
+#include <linux/ioport.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmaengine.h>
+#include <linux/console.h>
+#include <linux/clk.h>
+#include <linux/mutex.h>
+
+#include <mach/hardware.h>
+#include <mach/ipu.h>
+#include <mach/mx3fb.h>
+
+#include <asm/io.h>
+#include <asm/uaccess.h>
+
+#define MX3FB_NAME             "mx3_sdc_fb"
+
+#define MX3FB_REG_OFFSET       0xB4
+
+/* SDC Registers */
+#define SDC_COM_CONF           (0xB4 - MX3FB_REG_OFFSET)
+#define SDC_GW_CTRL            (0xB8 - MX3FB_REG_OFFSET)
+#define SDC_FG_POS             (0xBC - MX3FB_REG_OFFSET)
+#define SDC_BG_POS             (0xC0 - MX3FB_REG_OFFSET)
+#define SDC_CUR_POS            (0xC4 - MX3FB_REG_OFFSET)
+#define SDC_PWM_CTRL           (0xC8 - MX3FB_REG_OFFSET)
+#define SDC_CUR_MAP            (0xCC - MX3FB_REG_OFFSET)
+#define SDC_HOR_CONF           (0xD0 - MX3FB_REG_OFFSET)
+#define SDC_VER_CONF           (0xD4 - MX3FB_REG_OFFSET)
+#define SDC_SHARP_CONF_1       (0xD8 - MX3FB_REG_OFFSET)
+#define SDC_SHARP_CONF_2       (0xDC - MX3FB_REG_OFFSET)
+
+/* Register bits */
+#define SDC_COM_TFT_COLOR      0x00000001UL
+#define SDC_COM_FG_EN          0x00000010UL
+#define SDC_COM_GWSEL          0x00000020UL
+#define SDC_COM_GLB_A          0x00000040UL
+#define SDC_COM_KEY_COLOR_G    0x00000080UL
+#define SDC_COM_BG_EN          0x00000200UL
+#define SDC_COM_SHARP          0x00001000UL
+
+#define SDC_V_SYNC_WIDTH_L     0x00000001UL
+
+/* Display Interface registers */
+#define DI_DISP_IF_CONF                (0x0124 - MX3FB_REG_OFFSET)
+#define DI_DISP_SIG_POL                (0x0128 - MX3FB_REG_OFFSET)
+#define DI_SER_DISP1_CONF      (0x012C - MX3FB_REG_OFFSET)
+#define DI_SER_DISP2_CONF      (0x0130 - MX3FB_REG_OFFSET)
+#define DI_HSP_CLK_PER         (0x0134 - MX3FB_REG_OFFSET)
+#define DI_DISP0_TIME_CONF_1   (0x0138 - MX3FB_REG_OFFSET)
+#define DI_DISP0_TIME_CONF_2   (0x013C - MX3FB_REG_OFFSET)
+#define DI_DISP0_TIME_CONF_3   (0x0140 - MX3FB_REG_OFFSET)
+#define DI_DISP1_TIME_CONF_1   (0x0144 - MX3FB_REG_OFFSET)
+#define DI_DISP1_TIME_CONF_2   (0x0148 - MX3FB_REG_OFFSET)
+#define DI_DISP1_TIME_CONF_3   (0x014C - MX3FB_REG_OFFSET)
+#define DI_DISP2_TIME_CONF_1   (0x0150 - MX3FB_REG_OFFSET)
+#define DI_DISP2_TIME_CONF_2   (0x0154 - MX3FB_REG_OFFSET)
+#define DI_DISP2_TIME_CONF_3   (0x0158 - MX3FB_REG_OFFSET)
+#define DI_DISP3_TIME_CONF     (0x015C - MX3FB_REG_OFFSET)
+#define DI_DISP0_DB0_MAP       (0x0160 - MX3FB_REG_OFFSET)
+#define DI_DISP0_DB1_MAP       (0x0164 - MX3FB_REG_OFFSET)
+#define DI_DISP0_DB2_MAP       (0x0168 - MX3FB_REG_OFFSET)
+#define DI_DISP0_CB0_MAP       (0x016C - MX3FB_REG_OFFSET)
+#define DI_DISP0_CB1_MAP       (0x0170 - MX3FB_REG_OFFSET)
+#define DI_DISP0_CB2_MAP       (0x0174 - MX3FB_REG_OFFSET)
+#define DI_DISP1_DB0_MAP       (0x0178 - MX3FB_REG_OFFSET)
+#define DI_DISP1_DB1_MAP       (0x017C - MX3FB_REG_OFFSET)
+#define DI_DISP1_DB2_MAP       (0x0180 - MX3FB_REG_OFFSET)
+#define DI_DISP1_CB0_MAP       (0x0184 - MX3FB_REG_OFFSET)
+#define DI_DISP1_CB1_MAP       (0x0188 - MX3FB_REG_OFFSET)
+#define DI_DISP1_CB2_MAP       (0x018C - MX3FB_REG_OFFSET)
+#define DI_DISP2_DB0_MAP       (0x0190 - MX3FB_REG_OFFSET)
+#define DI_DISP2_DB1_MAP       (0x0194 - MX3FB_REG_OFFSET)
+#define DI_DISP2_DB2_MAP       (0x0198 - MX3FB_REG_OFFSET)
+#define DI_DISP2_CB0_MAP       (0x019C - MX3FB_REG_OFFSET)
+#define DI_DISP2_CB1_MAP       (0x01A0 - MX3FB_REG_OFFSET)
+#define DI_DISP2_CB2_MAP       (0x01A4 - MX3FB_REG_OFFSET)
+#define DI_DISP3_B0_MAP                (0x01A8 - MX3FB_REG_OFFSET)
+#define DI_DISP3_B1_MAP                (0x01AC - MX3FB_REG_OFFSET)
+#define DI_DISP3_B2_MAP                (0x01B0 - MX3FB_REG_OFFSET)
+#define DI_DISP_ACC_CC         (0x01B4 - MX3FB_REG_OFFSET)
+#define DI_DISP_LLA_CONF       (0x01B8 - MX3FB_REG_OFFSET)
+#define DI_DISP_LLA_DATA       (0x01BC - MX3FB_REG_OFFSET)
+
+/* DI_DISP_SIG_POL bits */
+#define DI_D3_VSYNC_POL_SHIFT          28
+#define DI_D3_HSYNC_POL_SHIFT          27
+#define DI_D3_DRDY_SHARP_POL_SHIFT     26
+#define DI_D3_CLK_POL_SHIFT            25
+#define DI_D3_DATA_POL_SHIFT           24
+
+/* DI_DISP_IF_CONF bits */
+#define DI_D3_CLK_IDLE_SHIFT           26
+#define DI_D3_CLK_SEL_SHIFT            25
+#define DI_D3_DATAMSK_SHIFT            24
+
+enum ipu_panel {
+       IPU_PANEL_SHARP_TFT,
+       IPU_PANEL_TFT,
+};
+
+struct ipu_di_signal_cfg {
+       unsigned datamask_en:1;
+       unsigned clksel_en:1;
+       unsigned clkidle_en:1;
+       unsigned data_pol:1;    /* true = inverted */
+       unsigned clk_pol:1;     /* true = rising edge */
+       unsigned enable_pol:1;
+       unsigned Hsync_pol:1;   /* true = active high */
+       unsigned Vsync_pol:1;
+};
+
+static const struct fb_videomode mx3fb_modedb[] = {
+       {
+               /* 240x320 @ 60 Hz */
+               .name           = "Sharp-QVGA",
+               .refresh        = 60,
+               .xres           = 240,
+               .yres           = 320,
+               .pixclock       = 185925,
+               .left_margin    = 9,
+               .right_margin   = 16,
+               .upper_margin   = 7,
+               .lower_margin   = 9,
+               .hsync_len      = 1,
+               .vsync_len      = 1,
+               .sync           = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_SHARP_MODE |
+                                 FB_SYNC_CLK_INVERT | FB_SYNC_DATA_INVERT |
+                                 FB_SYNC_CLK_IDLE_EN,
+               .vmode          = FB_VMODE_NONINTERLACED,
+               .flag           = 0,
+       }, {
+               /* 240x33 @ 60 Hz */
+               .name           = "Sharp-CLI",
+               .refresh        = 60,
+               .xres           = 240,
+               .yres           = 33,
+               .pixclock       = 185925,
+               .left_margin    = 9,
+               .right_margin   = 16,
+               .upper_margin   = 7,
+               .lower_margin   = 9 + 287,
+               .hsync_len      = 1,
+               .vsync_len      = 1,
+               .sync           = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_SHARP_MODE |
+                                 FB_SYNC_CLK_INVERT | FB_SYNC_DATA_INVERT |
+                                 FB_SYNC_CLK_IDLE_EN,
+               .vmode          = FB_VMODE_NONINTERLACED,
+               .flag           = 0,
+       }, {
+               /* 640x480 @ 60 Hz */
+               .name           = "NEC-VGA",
+               .refresh        = 60,
+               .xres           = 640,
+               .yres           = 480,
+               .pixclock       = 38255,
+               .left_margin    = 144,
+               .right_margin   = 0,
+               .upper_margin   = 34,
+               .lower_margin   = 40,
+               .hsync_len      = 1,
+               .vsync_len      = 1,
+               .sync           = FB_SYNC_VERT_HIGH_ACT | FB_SYNC_OE_ACT_HIGH,
+               .vmode          = FB_VMODE_NONINTERLACED,
+               .flag           = 0,
+       }, {
+               /* NTSC TV output */
+               .name           = "TV-NTSC",
+               .refresh        = 60,
+               .xres           = 640,
+               .yres           = 480,
+               .pixclock       = 37538,
+               .left_margin    = 38,
+               .right_margin   = 858 - 640 - 38 - 3,
+               .upper_margin   = 36,
+               .lower_margin   = 518 - 480 - 36 - 1,
+               .hsync_len      = 3,
+               .vsync_len      = 1,
+               .sync           = 0,
+               .vmode          = FB_VMODE_NONINTERLACED,
+               .flag           = 0,
+       }, {
+               /* PAL TV output */
+               .name           = "TV-PAL",
+               .refresh        = 50,
+               .xres           = 640,
+               .yres           = 480,
+               .pixclock       = 37538,
+               .left_margin    = 38,
+               .right_margin   = 960 - 640 - 38 - 32,
+               .upper_margin   = 32,
+               .lower_margin   = 555 - 480 - 32 - 3,
+               .hsync_len      = 32,
+               .vsync_len      = 3,
+               .sync           = 0,
+               .vmode          = FB_VMODE_NONINTERLACED,
+               .flag           = 0,
+       }, {
+               /* TV output VGA mode, 640x480 @ 65 Hz */
+               .name           = "TV-VGA",
+               .refresh        = 60,
+               .xres           = 640,
+               .yres           = 480,
+               .pixclock       = 40574,
+               .left_margin    = 35,
+               .right_margin   = 45,
+               .upper_margin   = 9,
+               .lower_margin   = 1,
+               .hsync_len      = 46,
+               .vsync_len      = 5,
+               .sync           = 0,
+               .vmode          = FB_VMODE_NONINTERLACED,
+               .flag           = 0,
+       },
+};
+
+struct mx3fb_data {
+       struct fb_info          *fbi;
+       int                     backlight_level;
+       void __iomem            *reg_base;
+       spinlock_t              lock;
+       struct device           *dev;
+
+       uint32_t                h_start_width;
+       uint32_t                v_start_width;
+};
+
+struct dma_chan_request {
+       struct mx3fb_data       *mx3fb;
+       enum ipu_channel        id;
+};
+
+/* MX3 specific framebuffer information. */
+struct mx3fb_info {
+       int                             blank;
+       enum ipu_channel                ipu_ch;
+       uint32_t                        cur_ipu_buf;
+
+       u32                             pseudo_palette[16];
+
+       struct completion               flip_cmpl;
+       struct mutex                    mutex;  /* Protects fb-ops */
+       struct mx3fb_data               *mx3fb;
+       struct idmac_channel            *idmac_channel;
+       struct dma_async_tx_descriptor  *txd;
+       dma_cookie_t                    cookie;
+       struct scatterlist              sg[2];
+
+       u32                             sync;   /* preserve var->sync flags */
+};
+
+static void mx3fb_dma_done(void *);
+
+/* Used fb-mode and bpp. Can be set on kernel command line, therefore file-static. */
+static const char *fb_mode;
+static unsigned long default_bpp = 16;
+
+static u32 mx3fb_read_reg(struct mx3fb_data *mx3fb, unsigned long reg)
+{
+       return __raw_readl(mx3fb->reg_base + reg);
+}
+
+static void mx3fb_write_reg(struct mx3fb_data *mx3fb, u32 value, unsigned long reg)
+{
+       __raw_writel(value, mx3fb->reg_base + reg);
+}
+
+static const uint32_t di_mappings[] = {
+       0x1600AAAA, 0x00E05555, 0x00070000, 3,  /* RGB888 */
+       0x0005000F, 0x000B000F, 0x0011000F, 1,  /* RGB666 */
+       0x0011000F, 0x000B000F, 0x0005000F, 1,  /* BGR666 */
+       0x0004003F, 0x000A000F, 0x000F003F, 1   /* RGB565 */
+};
+
+static void sdc_fb_init(struct mx3fb_info *fbi)
+{
+       struct mx3fb_data *mx3fb = fbi->mx3fb;
+       uint32_t reg;
+
+       reg = mx3fb_read_reg(mx3fb, SDC_COM_CONF);
+
+       mx3fb_write_reg(mx3fb, reg | SDC_COM_BG_EN, SDC_COM_CONF);
+}
+
+/* Returns enabled flag before uninit */
+static uint32_t sdc_fb_uninit(struct mx3fb_info *fbi)
+{
+       struct mx3fb_data *mx3fb = fbi->mx3fb;
+       uint32_t reg;
+
+       reg = mx3fb_read_reg(mx3fb, SDC_COM_CONF);
+
+       mx3fb_write_reg(mx3fb, reg & ~SDC_COM_BG_EN, SDC_COM_CONF);
+
+       return reg & SDC_COM_BG_EN;
+}
+
+static void sdc_enable_channel(struct mx3fb_info *mx3_fbi)
+{
+       struct mx3fb_data *mx3fb = mx3_fbi->mx3fb;
+       struct idmac_channel *ichan = mx3_fbi->idmac_channel;
+       struct dma_chan *dma_chan = &ichan->dma_chan;
+       unsigned long flags;
+       dma_cookie_t cookie;
+
+       dev_dbg(mx3fb->dev, "mx3fbi %p, desc %p, sg %p\n", mx3_fbi,
+               to_tx_desc(mx3_fbi->txd), to_tx_desc(mx3_fbi->txd)->sg);
+
+       /* This enables the channel */
+       if (mx3_fbi->cookie < 0) {
+               mx3_fbi->txd = dma_chan->device->device_prep_slave_sg(dma_chan,
+                     &mx3_fbi->sg[0], 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT);
+               if (!mx3_fbi->txd) {
+                       dev_err(mx3fb->dev, "Cannot allocate descriptor on %d\n",
+                               dma_chan->chan_id);
+                       return;
+               }
+
+               mx3_fbi->txd->callback_param    = mx3_fbi->txd;
+               mx3_fbi->txd->callback          = mx3fb_dma_done;
+
+               cookie = mx3_fbi->txd->tx_submit(mx3_fbi->txd);
+               dev_dbg(mx3fb->dev, "%d: Submit %p #%d [%c]\n", __LINE__,
+                      mx3_fbi->txd, cookie, list_empty(&ichan->queue) ? '-' : '+');
+       } else {
+               if (!mx3_fbi->txd || !mx3_fbi->txd->tx_submit) {
+                       dev_err(mx3fb->dev, "Cannot enable channel %d\n",
+                               dma_chan->chan_id);
+                       return;
+               }
+
+               /* Just re-activate the same buffer */
+               dma_async_issue_pending(dma_chan);
+               cookie = mx3_fbi->cookie;
+               dev_dbg(mx3fb->dev, "%d: Re-submit %p #%d [%c]\n", __LINE__,
+                      mx3_fbi->txd, cookie, list_empty(&ichan->queue) ? '-' : '+');
+       }
+
+       if (cookie >= 0) {
+               spin_lock_irqsave(&mx3fb->lock, flags);
+               sdc_fb_init(mx3_fbi);
+               mx3_fbi->cookie = cookie;
+               spin_unlock_irqrestore(&mx3fb->lock, flags);
+       }
+
+       /*
+        * Attention! Without this msleep the channel keeps generating
+        * interrupts. Next sdc_set_brightness() is going to be called
+        * from mx3fb_blank().
+        */
+       msleep(2);
+}
+
+static void sdc_disable_channel(struct mx3fb_info *mx3_fbi)
+{
+       struct mx3fb_data *mx3fb = mx3_fbi->mx3fb;
+       uint32_t enabled;
+       unsigned long flags;
+
+       spin_lock_irqsave(&mx3fb->lock, flags);
+
+       enabled = sdc_fb_uninit(mx3_fbi);
+
+       spin_unlock_irqrestore(&mx3fb->lock, flags);
+
+       mx3_fbi->txd->chan->device->device_terminate_all(mx3_fbi->txd->chan);
+       mx3_fbi->txd = NULL;
+       mx3_fbi->cookie = -EINVAL;
+}
+
+/**
+ * sdc_set_window_pos() - set window position of the respective plane.
+ * @mx3fb:     mx3fb context.
+ * @channel:   IPU DMAC channel ID.
+ * @x_pos:     X coordinate relative to the top left corner to place window at.
+ * @y_pos:     Y coordinate relative to the top left corner to place window at.
+ * @return:    0 on success or negative error code on failure.
+ */
+static int sdc_set_window_pos(struct mx3fb_data *mx3fb, enum ipu_channel channel,
+                             int16_t x_pos, int16_t y_pos)
+{
+       x_pos += mx3fb->h_start_width;
+       y_pos += mx3fb->v_start_width;
+
+       if (channel != IDMAC_SDC_0)
+               return -EINVAL;
+
+       mx3fb_write_reg(mx3fb, (x_pos << 16) | y_pos, SDC_BG_POS);
+       return 0;
+}
+
+/**
+ * sdc_init_panel() - initialize a synchronous LCD panel.
+ * @mx3fb:             mx3fb context.
+ * @panel:             panel type.
+ * @pixel_clk:         desired pixel clock frequency in Hz.
+ * @width:             width of panel in pixels.
+ * @height:            height of panel in pixels.
+ * @pixel_fmt:         pixel format of buffer as FOURCC ASCII code.
+ * @h_start_width:     number of pixel clocks between the HSYNC signal pulse
+ *                     and the start of valid data.
+ * @h_sync_width:      width of the HSYNC signal in units of pixel clocks.
+ * @h_end_width:       number of pixel clocks between the end of valid data
+ *                     and the HSYNC signal for next line.
+ * @v_start_width:     number of lines between the VSYNC signal pulse and the
+ *                     start of valid data.
+ * @v_sync_width:      width of the VSYNC signal in units of lines
+ * @v_end_width:       number of lines between the end of valid data and the
+ *                     VSYNC signal for next frame.
+ * @sig:               bitfield of signal polarities for LCD interface.
+ * @return:            0 on success or negative error code on failure.
+ */
+static int sdc_init_panel(struct mx3fb_data *mx3fb, enum ipu_panel panel,
+                         uint32_t pixel_clk,
+                         uint16_t width, uint16_t height,
+                         enum pixel_fmt pixel_fmt,
+                         uint16_t h_start_width, uint16_t h_sync_width,
+                         uint16_t h_end_width, uint16_t v_start_width,
+                         uint16_t v_sync_width, uint16_t v_end_width,
+                         struct ipu_di_signal_cfg sig)
+{
+       unsigned long lock_flags;
+       uint32_t reg;
+       uint32_t old_conf;
+       uint32_t div;
+       struct clk *ipu_clk;
+
+       dev_dbg(mx3fb->dev, "panel size = %d x %d", width, height);
+
+       if (v_sync_width == 0 || h_sync_width == 0)
+               return -EINVAL;
+
+       /* Init panel size and blanking periods */
+       reg = ((uint32_t) (h_sync_width - 1) << 26) |
+               ((uint32_t) (width + h_start_width + h_end_width - 1) << 16);
+       mx3fb_write_reg(mx3fb, reg, SDC_HOR_CONF);
+
+#ifdef DEBUG
+       printk(KERN_CONT " hor_conf %x,", reg);
+#endif
+
+       reg = ((uint32_t) (v_sync_width - 1) << 26) | SDC_V_SYNC_WIDTH_L |
+           ((uint32_t) (height + v_start_width + v_end_width - 1) << 16);
+       mx3fb_write_reg(mx3fb, reg, SDC_VER_CONF);
+
+#ifdef DEBUG
+       printk(KERN_CONT " ver_conf %x\n", reg);
+#endif
+
+       mx3fb->h_start_width = h_start_width;
+       mx3fb->v_start_width = v_start_width;
+
+       switch (panel) {
+       case IPU_PANEL_SHARP_TFT:
+               mx3fb_write_reg(mx3fb, 0x00FD0102L, SDC_SHARP_CONF_1);
+               mx3fb_write_reg(mx3fb, 0x00F500F4L, SDC_SHARP_CONF_2);
+               mx3fb_write_reg(mx3fb, SDC_COM_SHARP | SDC_COM_TFT_COLOR, SDC_COM_CONF);
+               break;
+       case IPU_PANEL_TFT:
+               mx3fb_write_reg(mx3fb, SDC_COM_TFT_COLOR, SDC_COM_CONF);
+               break;
+       default:
+               return -EINVAL;
+       }
+
+       /* Init clocking */
+
+       /*
+        * Calculate divider: fractional part is 4 bits so simply multiple by
+        * 24 to get fractional part, as long as we stay under ~250MHz and on
+        * i.MX31 it (HSP_CLK) is <= 178MHz. Currently 128.267MHz
+        */
+       dev_dbg(mx3fb->dev, "pixel clk = %d\n", pixel_clk);
+
+       ipu_clk = clk_get(mx3fb->dev, "ipu_clk");
+       div = clk_get_rate(ipu_clk) * 16 / pixel_clk;
+       clk_put(ipu_clk);
+
+       if (div < 0x40) {       /* Divider less than 4 */
+               dev_dbg(mx3fb->dev,
+                       "InitPanel() - Pixel clock divider less than 4\n");
+               div = 0x40;
+       }
+
+       spin_lock_irqsave(&mx3fb->lock, lock_flags);
+
+       /*
+        * DISP3_IF_CLK_DOWN_WR is half the divider value and 2 fraction bits
+        * fewer. Subtract 1 extra from DISP3_IF_CLK_DOWN_WR based on timing
+        * debug. DISP3_IF_CLK_UP_WR is 0
+        */
+       mx3fb_write_reg(mx3fb, (((div / 8) - 1) << 22) | div, DI_DISP3_TIME_CONF);
+
+       /* DI settings */
+       old_conf = mx3fb_read_reg(mx3fb, DI_DISP_IF_CONF) & 0x78FFFFFF;
+       old_conf |= sig.datamask_en << DI_D3_DATAMSK_SHIFT |
+           sig.clksel_en << DI_D3_CLK_SEL_SHIFT |
+           sig.clkidle_en << DI_D3_CLK_IDLE_SHIFT;
+       mx3fb_write_reg(mx3fb, old_conf, DI_DISP_IF_CONF);
+
+       old_conf = mx3fb_read_reg(mx3fb, DI_DISP_SIG_POL) & 0xE0FFFFFF;
+       old_conf |= sig.data_pol << DI_D3_DATA_POL_SHIFT |
+           sig.clk_pol << DI_D3_CLK_POL_SHIFT |
+           sig.enable_pol << DI_D3_DRDY_SHARP_POL_SHIFT |
+           sig.Hsync_pol << DI_D3_HSYNC_POL_SHIFT |
+           sig.Vsync_pol << DI_D3_VSYNC_POL_SHIFT;
+       mx3fb_write_reg(mx3fb, old_conf, DI_DISP_SIG_POL);
+
+       switch (pixel_fmt) {
+       case IPU_PIX_FMT_RGB24:
+               mx3fb_write_reg(mx3fb, di_mappings[0], DI_DISP3_B0_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[1], DI_DISP3_B1_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[2], DI_DISP3_B2_MAP);
+               mx3fb_write_reg(mx3fb, mx3fb_read_reg(mx3fb, DI_DISP_ACC_CC) |
+                            ((di_mappings[3] - 1) << 12), DI_DISP_ACC_CC);
+               break;
+       case IPU_PIX_FMT_RGB666:
+               mx3fb_write_reg(mx3fb, di_mappings[4], DI_DISP3_B0_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[5], DI_DISP3_B1_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[6], DI_DISP3_B2_MAP);
+               mx3fb_write_reg(mx3fb, mx3fb_read_reg(mx3fb, DI_DISP_ACC_CC) |
+                            ((di_mappings[7] - 1) << 12), DI_DISP_ACC_CC);
+               break;
+       case IPU_PIX_FMT_BGR666:
+               mx3fb_write_reg(mx3fb, di_mappings[8], DI_DISP3_B0_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[9], DI_DISP3_B1_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[10], DI_DISP3_B2_MAP);
+               mx3fb_write_reg(mx3fb, mx3fb_read_reg(mx3fb, DI_DISP_ACC_CC) |
+                            ((di_mappings[11] - 1) << 12), DI_DISP_ACC_CC);
+               break;
+       default:
+               mx3fb_write_reg(mx3fb, di_mappings[12], DI_DISP3_B0_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[13], DI_DISP3_B1_MAP);
+               mx3fb_write_reg(mx3fb, di_mappings[14], DI_DISP3_B2_MAP);
+               mx3fb_write_reg(mx3fb, mx3fb_read_reg(mx3fb, DI_DISP_ACC_CC) |
+                            ((di_mappings[15] - 1) << 12), DI_DISP_ACC_CC);
+               break;
+       }
+
+       spin_unlock_irqrestore(&mx3fb->lock, lock_flags);
+
+       dev_dbg(mx3fb->dev, "DI_DISP_IF_CONF = 0x%08X\n",
+               mx3fb_read_reg(mx3fb, DI_DISP_IF_CONF));
+       dev_dbg(mx3fb->dev, "DI_DISP_SIG_POL = 0x%08X\n",
+               mx3fb_read_reg(mx3fb, DI_DISP_SIG_POL));
+       dev_dbg(mx3fb->dev, "DI_DISP3_TIME_CONF = 0x%08X\n",
+               mx3fb_read_reg(mx3fb, DI_DISP3_TIME_CONF));
+
+       return 0;
+}
+
+/**
+ * sdc_set_color_key() - set the transparent color key for SDC graphic plane.
+ * @mx3fb:     mx3fb context.
+ * @channel:   IPU DMAC channel ID.
+ * @enable:    boolean to enable or disable color keyl.
+ * @color_key: 24-bit RGB color to use as transparent color key.
+ * @return:    0 on success or negative error code on failure.
+ */
+static int sdc_set_color_key(struct mx3fb_data *mx3fb, enum ipu_channel channel,
+                            bool enable, uint32_t color_key)
+{
+       uint32_t reg, sdc_conf;
+       unsigned long lock_flags;
+
+       spin_lock_irqsave(&mx3fb->lock, lock_flags);
+
+       sdc_conf = mx3fb_read_reg(mx3fb, SDC_COM_CONF);
+       if (channel == IDMAC_SDC_0)
+               sdc_conf &= ~SDC_COM_GWSEL;
+       else
+               sdc_conf |= SDC_COM_GWSEL;
+
+       if (enable) {
+               reg = mx3fb_read_reg(mx3fb, SDC_GW_CTRL) & 0xFF000000L;
+               mx3fb_write_reg(mx3fb, reg | (color_key & 0x00FFFFFFL),
+                            SDC_GW_CTRL);
+
+               sdc_conf |= SDC_COM_KEY_COLOR_G;
+       } else {
+               sdc_conf &= ~SDC_COM_KEY_COLOR_G;
+       }
+       mx3fb_write_reg(mx3fb, sdc_conf, SDC_COM_CONF);
+
+       spin_unlock_irqrestore(&mx3fb->lock, lock_flags);
+
+       return 0;
+}
+
+/**
+ * sdc_set_global_alpha() - set global alpha blending modes.
+ * @mx3fb:     mx3fb context.
+ * @enable:    boolean to enable or disable global alpha blending. If disabled,
+ *             per pixel blending is used.
+ * @alpha:     global alpha value.
+ * @return:    0 on success or negative error code on failure.
+ */
+static int sdc_set_global_alpha(struct mx3fb_data *mx3fb, bool enable, uint8_t alpha)
+{
+       uint32_t reg;
+       unsigned long lock_flags;
+
+       spin_lock_irqsave(&mx3fb->lock, lock_flags);
+
+       if (enable) {
+               reg = mx3fb_read_reg(mx3fb, SDC_GW_CTRL) & 0x00FFFFFFL;
+               mx3fb_write_reg(mx3fb, reg | ((uint32_t) alpha << 24), SDC_GW_CTRL);
+
+               reg = mx3fb_read_reg(mx3fb, SDC_COM_CONF);
+               mx3fb_write_reg(mx3fb, reg | SDC_COM_GLB_A, SDC_COM_CONF);
+       } else {
+               reg = mx3fb_read_reg(mx3fb, SDC_COM_CONF);
+               mx3fb_write_reg(mx3fb, reg & ~SDC_COM_GLB_A, SDC_COM_CONF);
+       }
+
+       spin_unlock_irqrestore(&mx3fb->lock, lock_flags);
+
+       return 0;
+}
+
+static void sdc_set_brightness(struct mx3fb_data *mx3fb, uint8_t value)
+{
+       /* This might be board-specific */
+       mx3fb_write_reg(mx3fb, 0x03000000UL | value << 16, SDC_PWM_CTRL);
+       return;
+}
+
+static uint32_t bpp_to_pixfmt(int bpp)
+{
+       uint32_t pixfmt = 0;
+       switch (bpp) {
+       case 24:
+               pixfmt = IPU_PIX_FMT_BGR24;
+               break;
+       case 32:
+               pixfmt = IPU_PIX_FMT_BGR32;
+               break;
+       case 16:
+               pixfmt = IPU_PIX_FMT_RGB565;
+               break;
+       }
+       return pixfmt;
+}
+
+static int mx3fb_blank(int blank, struct fb_info *fbi);
+static int mx3fb_map_video_memory(struct fb_info *fbi);
+static int mx3fb_unmap_video_memory(struct fb_info *fbi);
+
+/**
+ * mx3fb_set_fix() - set fixed framebuffer parameters from variable settings.
+ * @info:      framebuffer information pointer
+ * @return:    0 on success or negative error code on failure.
+ */
+static int mx3fb_set_fix(struct fb_info *fbi)
+{
+       struct fb_fix_screeninfo *fix = &fbi->fix;
+       struct fb_var_screeninfo *var = &fbi->var;
+
+       strncpy(fix->id, "DISP3 BG", 8);
+
+       fix->line_length = var->xres_virtual * var->bits_per_pixel / 8;
+
+       fix->type = FB_TYPE_PACKED_PIXELS;
+       fix->accel = FB_ACCEL_NONE;
+       fix->visual = FB_VISUAL_TRUECOLOR;
+       fix->xpanstep = 1;
+       fix->ypanstep = 1;
+
+       return 0;
+}
+
+static void mx3fb_dma_done(void *arg)
+{
+       struct idmac_tx_desc *tx_desc = to_tx_desc(arg);
+       struct dma_chan *chan = tx_desc->txd.chan;
+       struct idmac_channel *ichannel = to_idmac_chan(chan);
+       struct mx3fb_data *mx3fb = ichannel->client;
+       struct mx3fb_info *mx3_fbi = mx3fb->fbi->par;
+
+       dev_dbg(mx3fb->dev, "irq %d callback\n", ichannel->eof_irq);
+
+       /* We only need one interrupt, it will be re-enabled as needed */
+       disable_irq(ichannel->eof_irq);
+
+       complete(&mx3_fbi->flip_cmpl);
+}
+
+/**
+ * mx3fb_set_par() - set framebuffer parameters and change the operating mode.
+ * @fbi:       framebuffer information pointer.
+ * @return:    0 on success or negative error code on failure.
+ */
+static int mx3fb_set_par(struct fb_info *fbi)
+{
+       u32 mem_len;
+       struct ipu_di_signal_cfg sig_cfg;
+       enum ipu_panel mode = IPU_PANEL_TFT;
+       struct mx3fb_info *mx3_fbi = fbi->par;
+       struct mx3fb_data *mx3fb = mx3_fbi->mx3fb;
+       struct idmac_channel *ichan = mx3_fbi->idmac_channel;
+       struct idmac_video_param *video = &ichan->params.video;
+       struct scatterlist *sg = mx3_fbi->sg;
+       size_t screen_size;
+
+       dev_dbg(mx3fb->dev, "%s [%c]\n", __func__, list_empty(&ichan->queue) ? '-' : '+');
+
+       mutex_lock(&mx3_fbi->mutex);
+
+       /* Total cleanup */
+       if (mx3_fbi->txd)
+               sdc_disable_channel(mx3_fbi);
+
+       mx3fb_set_fix(fbi);
+
+       mem_len = fbi->var.yres_virtual * fbi->fix.line_length;
+       if (mem_len > fbi->fix.smem_len) {
+               if (fbi->fix.smem_start)
+                       mx3fb_unmap_video_memory(fbi);
+
+               fbi->fix.smem_len = mem_len;
+               if (mx3fb_map_video_memory(fbi) < 0) {
+                       mutex_unlock(&mx3_fbi->mutex);
+                       return -ENOMEM;
+               }
+       }
+
+       screen_size = fbi->fix.line_length * fbi->var.yres;
+
+       sg_init_table(&sg[0], 1);
+       sg_init_table(&sg[1], 1);
+
+       sg_dma_address(&sg[0])  = fbi->fix.smem_start;
+       sg_set_page(&sg[0], virt_to_page(fbi->screen_base),
+                   fbi->fix.smem_len,
+                   offset_in_page(fbi->screen_base));
+
+       if (mx3_fbi->ipu_ch == IDMAC_SDC_0) {
+               memset(&sig_cfg, 0, sizeof(sig_cfg));
+               if (fbi->var.sync & FB_SYNC_HOR_HIGH_ACT)
+                       sig_cfg.Hsync_pol = true;
+               if (fbi->var.sync & FB_SYNC_VERT_HIGH_ACT)
+                       sig_cfg.Vsync_pol = true;
+               if (fbi->var.sync & FB_SYNC_CLK_INVERT)
+                       sig_cfg.clk_pol = true;
+               if (fbi->var.sync & FB_SYNC_DATA_INVERT)
+                       sig_cfg.data_pol = true;
+               if (fbi->var.sync & FB_SYNC_OE_ACT_HIGH)
+                       sig_cfg.enable_pol = true;
+               if (fbi->var.sync & FB_SYNC_CLK_IDLE_EN)
+                       sig_cfg.clkidle_en = true;
+               if (fbi->var.sync & FB_SYNC_CLK_SEL_EN)
+                       sig_cfg.clksel_en = true;
+               if (fbi->var.sync & FB_SYNC_SHARP_MODE)
+                       mode = IPU_PANEL_SHARP_TFT;
+
+               dev_dbg(fbi->device, "pixclock = %ul Hz\n",
+                       (u32) (PICOS2KHZ(fbi->var.pixclock) * 1000UL));
+
+               if (sdc_init_panel(mx3fb, mode,
+                                  (PICOS2KHZ(fbi->var.pixclock)) * 1000UL,
+                                  fbi->var.xres, fbi->var.yres,
+                                  (fbi->var.sync & FB_SYNC_SWAP_RGB) ?
+                                  IPU_PIX_FMT_BGR666 : IPU_PIX_FMT_RGB666,
+                                  fbi->var.left_margin,
+                                  fbi->var.hsync_len,
+                                  fbi->var.right_margin +
+                                  fbi->var.hsync_len,
+                                  fbi->var.upper_margin,
+                                  fbi->var.vsync_len,
+                                  fbi->var.lower_margin +
+                                  fbi->var.vsync_len, sig_cfg) != 0) {
+                       mutex_unlock(&mx3_fbi->mutex);
+                       dev_err(fbi->device,
+                               "mx3fb: Error initializing panel.\n");
+                       return -EINVAL;
+               }
+       }
+
+       sdc_set_window_pos(mx3fb, mx3_fbi->ipu_ch, 0, 0);
+
+       mx3_fbi->cur_ipu_buf    = 0;
+
+       video->out_pixel_fmt    = bpp_to_pixfmt(fbi->var.bits_per_pixel);
+       video->out_width        = fbi->var.xres;
+       video->out_height       = fbi->var.yres;
+       video->out_stride       = fbi->var.xres_virtual;
+
+       if (mx3_fbi->blank == FB_BLANK_UNBLANK)
+               sdc_enable_channel(mx3_fbi);
+
+       mutex_unlock(&mx3_fbi->mutex);
+
+       return 0;
+}
+
+/**
+ * mx3fb_check_var() - check and adjust framebuffer variable parameters.
+ * @var:       framebuffer variable parameters
+ * @fbi:       framebuffer information pointer
+ */
+static int mx3fb_check_var(struct fb_var_screeninfo *var, struct fb_info *fbi)
+{
+       struct mx3fb_info *mx3_fbi = fbi->par;
+       u32 vtotal;
+       u32 htotal;
+
+       dev_dbg(fbi->device, "%s\n", __func__);
+
+       if (var->xres_virtual < var->xres)
+               var->xres_virtual = var->xres;
+       if (var->yres_virtual < var->yres)
+               var->yres_virtual = var->yres;
+
+       if ((var->bits_per_pixel != 32) && (var->bits_per_pixel != 24) &&
+           (var->bits_per_pixel != 16))
+               var->bits_per_pixel = default_bpp;
+
+       switch (var->bits_per_pixel) {
+       case 16:
+               var->red.length = 5;
+               var->red.offset = 11;
+               var->red.msb_right = 0;
+
+               var->green.length = 6;
+               var->green.offset = 5;
+               var->green.msb_right = 0;
+
+               var->blue.length = 5;
+               var->blue.offset = 0;
+               var->blue.msb_right = 0;
+
+               var->transp.length = 0;
+               var->transp.offset = 0;
+               var->transp.msb_right = 0;
+               break;
+       case 24:
+               var->red.length = 8;
+               var->red.offset = 16;
+               var->red.msb_right = 0;
+
+               var->green.length = 8;
+               var->green.offset = 8;
+               var->green.msb_right = 0;
+
+               var->blue.length = 8;
+               var->blue.offset = 0;
+               var->blue.msb_right = 0;
+
+               var->transp.length = 0;
+               var->transp.offset = 0;
+               var->transp.msb_right = 0;
+               break;
+       case 32:
+               var->red.length = 8;
+               var->red.offset = 16;
+               var->red.msb_right = 0;
+
+               var->green.length = 8;
+               var->green.offset = 8;
+               var->green.msb_right = 0;
+
+               var->blue.length = 8;
+               var->blue.offset = 0;
+               var->blue.msb_right = 0;
+
+               var->transp.length = 8;
+               var->transp.offset = 24;
+               var->transp.msb_right = 0;
+               break;
+       }
+
+       if (var->pixclock < 1000) {
+               htotal = var->xres + var->right_margin + var->hsync_len +
+                   var->left_margin;
+               vtotal = var->yres + var->lower_margin + var->vsync_len +
+                   var->upper_margin;
+               var->pixclock = (vtotal * htotal * 6UL) / 100UL;
+               var->pixclock = KHZ2PICOS(var->pixclock);
+               dev_dbg(fbi->device, "pixclock set for 60Hz refresh = %u ps\n",
+                       var->pixclock);
+       }
+
+       var->height = -1;
+       var->width = -1;
+       var->grayscale = 0;
+
+       /* Preserve sync flags */
+       var->sync |= mx3_fbi->sync;
+       mx3_fbi->sync |= var->sync;
+
+       return 0;
+}
+
+static u32 chan_to_field(unsigned int chan, struct fb_bitfield *bf)
+{
+       chan &= 0xffff;
+       chan >>= 16 - bf->length;
+       return chan << bf->offset;
+}
+
+static int mx3fb_setcolreg(unsigned int regno, unsigned int red,
+                          unsigned int green, unsigned int blue,
+                          unsigned int trans, struct fb_info *fbi)
+{
+       struct mx3fb_info *mx3_fbi = fbi->par;
+       u32 val;
+       int ret = 1;
+
+       dev_dbg(fbi->device, "%s\n", __func__);
+
+       mutex_lock(&mx3_fbi->mutex);
+       /*
+        * If greyscale is true, then we convert the RGB value
+        * to greyscale no matter what visual we are using.
+        */
+       if (fbi->var.grayscale)
+               red = green = blue = (19595 * red + 38470 * green +
+                                     7471 * blue) >> 16;
+       switch (fbi->fix.visual) {
+       case FB_VISUAL_TRUECOLOR:
+               /*
+                * 16-bit True Colour.  We encode the RGB value
+                * according to the RGB bitfield information.
+                */
+               if (regno < 16) {
+                       u32 *pal = fbi->pseudo_palette;
+
+                       val = chan_to_field(red, &fbi->var.red);
+                       val |= chan_to_field(green, &fbi->var.green);
+                       val |= chan_to_field(blue, &fbi->var.blue);
+
+                       pal[regno] = val;
+
+                       ret = 0;
+               }
+               break;
+
+       case FB_VISUAL_STATIC_PSEUDOCOLOR:
+       case FB_VISUAL_PSEUDOCOLOR:
+               break;
+       }
+       mutex_unlock(&mx3_fbi->mutex);
+
+       return ret;
+}
+
+/**
+ * mx3fb_blank() - blank the display.
+ */
+static int mx3fb_blank(int blank, struct fb_info *fbi)
+{
+       struct mx3fb_info *mx3_fbi = fbi->par;
+       struct mx3fb_data *mx3fb = mx3_fbi->mx3fb;
+
+       dev_dbg(fbi->device, "%s\n", __func__);
+
+       dev_dbg(fbi->device, "blank = %d\n", blank);
+
+       if (mx3_fbi->blank == blank)
+               return 0;
+
+       mutex_lock(&mx3_fbi->mutex);
+       mx3_fbi->blank = blank;
+
+       switch (blank) {
+       case FB_BLANK_POWERDOWN:
+       case FB_BLANK_VSYNC_SUSPEND:
+       case FB_BLANK_HSYNC_SUSPEND:
+       case FB_BLANK_NORMAL:
+               sdc_disable_channel(mx3_fbi);
+               sdc_set_brightness(mx3fb, 0);
+               break;
+       case FB_BLANK_UNBLANK:
+               sdc_enable_channel(mx3_fbi);
+               sdc_set_brightness(mx3fb, mx3fb->backlight_level);
+               break;
+       }
+       mutex_unlock(&mx3_fbi->mutex);
+
+       return 0;
+}
+
+/**
+ * mx3fb_pan_display() - pan or wrap the display
+ * @var:       variable screen buffer information.
+ * @info:      framebuffer information pointer.
+ *
+ * We look only at xoffset, yoffset and the FB_VMODE_YWRAP flag
+ */
+static int mx3fb_pan_display(struct fb_var_screeninfo *var,
+                            struct fb_info *fbi)
+{
+       struct mx3fb_info *mx3_fbi = fbi->par;
+       u32 y_bottom;
+       unsigned long base;
+       off_t offset;
+       dma_cookie_t cookie;
+       struct scatterlist *sg = mx3_fbi->sg;
+       struct dma_chan *dma_chan = &mx3_fbi->idmac_channel->dma_chan;
+       struct dma_async_tx_descriptor *txd;
+       int ret;
+
+       dev_dbg(fbi->device, "%s [%c]\n", __func__,
+               list_empty(&mx3_fbi->idmac_channel->queue) ? '-' : '+');
+
+       if (var->xoffset > 0) {
+               dev_dbg(fbi->device, "x panning not supported\n");
+               return -EINVAL;
+       }
+
+       if (fbi->var.xoffset == var->xoffset &&
+           fbi->var.yoffset == var->yoffset)
+               return 0;       /* No change, do nothing */
+
+       y_bottom = var->yoffset;
+
+       if (!(var->vmode & FB_VMODE_YWRAP))
+               y_bottom += var->yres;
+
+       if (y_bottom > fbi->var.yres_virtual)
+               return -EINVAL;
+
+       mutex_lock(&mx3_fbi->mutex);
+
+       offset = (var->yoffset * var->xres_virtual + var->xoffset) *
+               (var->bits_per_pixel / 8);
+       base = fbi->fix.smem_start + offset;
+
+       dev_dbg(fbi->device, "Updating SDC BG buf %d address=0x%08lX\n",
+               mx3_fbi->cur_ipu_buf, base);
+
+       /*
+        * We enable the End of Frame interrupt, which will free a tx-descriptor,
+        * which we will need for the next device_prep_slave_sg(). The
+        * IRQ-handler will disable the IRQ again.
+        */
+       init_completion(&mx3_fbi->flip_cmpl);
+       enable_irq(mx3_fbi->idmac_channel->eof_irq);
+
+       ret = wait_for_completion_timeout(&mx3_fbi->flip_cmpl, HZ / 10);
+       if (ret <= 0) {
+               mutex_unlock(&mx3_fbi->mutex);
+               dev_info(fbi->device, "Panning failed due to %s\n", ret < 0 ?
+                        "user interrupt" : "timeout");
+               return ret ? : -ETIMEDOUT;
+       }
+
+       mx3_fbi->cur_ipu_buf = !mx3_fbi->cur_ipu_buf;
+
+       sg_dma_address(&sg[mx3_fbi->cur_ipu_buf]) = base;
+       sg_set_page(&sg[mx3_fbi->cur_ipu_buf],
+                   virt_to_page(fbi->screen_base + offset), fbi->fix.smem_len,
+                   offset_in_page(fbi->screen_base + offset));
+
+       txd = dma_chan->device->device_prep_slave_sg(dma_chan, sg +
+               mx3_fbi->cur_ipu_buf, 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT);
+       if (!txd) {
+               dev_err(fbi->device,
+                       "Error preparing a DMA transaction descriptor.\n");
+               mutex_unlock(&mx3_fbi->mutex);
+               return -EIO;
+       }
+
+       txd->callback_param     = txd;
+       txd->callback           = mx3fb_dma_done;
+
+       /*
+        * Emulate original mx3fb behaviour: each new call to idmac_tx_submit()
+        * should switch to another buffer
+        */
+       cookie = txd->tx_submit(txd);
+       dev_dbg(fbi->device, "%d: Submit %p #%d\n", __LINE__, txd, cookie);
+       if (cookie < 0) {
+               dev_err(fbi->device,
+                       "Error updating SDC buf %d to address=0x%08lX\n",
+                       mx3_fbi->cur_ipu_buf, base);
+               mutex_unlock(&mx3_fbi->mutex);
+               return -EIO;
+       }
+
+       if (mx3_fbi->txd)
+               async_tx_ack(mx3_fbi->txd);
+       mx3_fbi->txd = txd;
+
+       fbi->var.xoffset = var->xoffset;
+       fbi->var.yoffset = var->yoffset;
+
+       if (var->vmode & FB_VMODE_YWRAP)
+               fbi->var.vmode |= FB_VMODE_YWRAP;
+       else
+               fbi->var.vmode &= ~FB_VMODE_YWRAP;
+
+       mutex_unlock(&mx3_fbi->mutex);
+
+       dev_dbg(fbi->device, "Update complete\n");
+
+       return 0;
+}
+
+/*
+ * This structure contains the pointers to the control functions that are
+ * invoked by the core framebuffer driver to perform operations like
+ * blitting, rectangle filling, copy regions and cursor definition.
+ */
+static struct fb_ops mx3fb_ops = {
+       .owner = THIS_MODULE,
+       .fb_set_par = mx3fb_set_par,
+       .fb_check_var = mx3fb_check_var,
+       .fb_setcolreg = mx3fb_setcolreg,
+       .fb_pan_display = mx3fb_pan_display,
+       .fb_fillrect = cfb_fillrect,
+       .fb_copyarea = cfb_copyarea,
+       .fb_imageblit = cfb_imageblit,
+       .fb_blank = mx3fb_blank,
+};
+
+#ifdef CONFIG_PM
+/*
+ * Power management hooks.      Note that we won't be called from IRQ context,
+ * unlike the blank functions above, so we may sleep.
+ */
+
+/*
+ * Suspends the framebuffer and blanks the screen. Power management support
+ */
+static int mx3fb_suspend(struct platform_device *pdev, pm_message_t state)
+{
+       struct mx3fb_data *drv_data = platform_get_drvdata(pdev);
+       struct mx3fb_info *mx3_fbi = drv_data->fbi->par;
+
+       acquire_console_sem();
+       fb_set_suspend(drv_data->fbi, 1);
+       release_console_sem();
+
+       if (mx3_fbi->blank == FB_BLANK_UNBLANK) {
+               sdc_disable_channel(mx3_fbi);
+               sdc_set_brightness(mx3fb, 0);
+
+       }
+       return 0;
+}
+
+/*
+ * Resumes the framebuffer and unblanks the screen. Power management support
+ */
+static int mx3fb_resume(struct platform_device *pdev)
+{
+       struct mx3fb_data *drv_data = platform_get_drvdata(pdev);
+       struct mx3fb_info *mx3_fbi = drv_data->fbi->par;
+
+       if (mx3_fbi->blank == FB_BLANK_UNBLANK) {
+               sdc_enable_channel(mx3_fbi);
+               sdc_set_brightness(mx3fb, drv_data->backlight_level);
+       }
+
+       acquire_console_sem();
+       fb_set_suspend(drv_data->fbi, 0);
+       release_console_sem();
+
+       return 0;
+}
+#else
+#define mx3fb_suspend   NULL
+#define mx3fb_resume    NULL
+#endif
+
+/*
+ * Main framebuffer functions
+ */
+
+/**
+ * mx3fb_map_video_memory() - allocates the DRAM memory for the frame buffer.
+ * @fbi:       framebuffer information pointer
+ * @return:    Error code indicating success or failure
+ *
+ * This buffer is remapped into a non-cached, non-buffered, memory region to
+ * allow palette and pixel writes to occur without flushing the cache. Once this
+ * area is remapped, all virtual memory access to the video memory should occur
+ * at the new region.
+ */
+static int mx3fb_map_video_memory(struct fb_info *fbi)
+{
+       int retval = 0;
+       dma_addr_t addr;
+
+       fbi->screen_base = dma_alloc_writecombine(fbi->device,
+                                                 fbi->fix.smem_len,
+                                                 &addr, GFP_DMA);
+
+       if (!fbi->screen_base) {
+               dev_err(fbi->device, "Cannot allocate %u bytes framebuffer memory\n",
+                       fbi->fix.smem_len);
+               retval = -EBUSY;
+               goto err0;
+       }
+
+       fbi->fix.smem_start = addr;
+
+       dev_dbg(fbi->device, "allocated fb @ p=0x%08x, v=0x%p, size=%d.\n",
+               (uint32_t) fbi->fix.smem_start, fbi->screen_base, fbi->fix.smem_len);
+
+       fbi->screen_size = fbi->fix.smem_len;
+
+       /* Clear the screen */
+       memset((char *)fbi->screen_base, 0, fbi->fix.smem_len);
+
+       return 0;
+
+err0:
+       fbi->fix.smem_len = 0;
+       fbi->fix.smem_start = 0;
+       fbi->screen_base = NULL;
+       return retval;
+}
+
+/**
+ * mx3fb_unmap_video_memory() - de-allocate frame buffer memory.
+ * @fbi:       framebuffer information pointer
+ * @return:    error code indicating success or failure
+ */
+static int mx3fb_unmap_video_memory(struct fb_info *fbi)
+{
+       dma_free_writecombine(fbi->device, fbi->fix.smem_len,
+                             fbi->screen_base, fbi->fix.smem_start);
+
+       fbi->screen_base = 0;
+       fbi->fix.smem_start = 0;
+       fbi->fix.smem_len = 0;
+       return 0;
+}
+
+/**
+ * mx3fb_init_fbinfo() - initialize framebuffer information object.
+ * @return:    initialized framebuffer structure.
+ */
+static struct fb_info *mx3fb_init_fbinfo(struct device *dev, struct fb_ops *ops)
+{
+       struct fb_info *fbi;
+       struct mx3fb_info *mx3fbi;
+       int ret;
+
+       /* Allocate sufficient memory for the fb structure */
+       fbi = framebuffer_alloc(sizeof(struct mx3fb_info), dev);
+       if (!fbi)
+               return NULL;
+
+       mx3fbi                  = fbi->par;
+       mx3fbi->cookie          = -EINVAL;
+       mx3fbi->cur_ipu_buf     = 0;
+
+       fbi->var.activate       = FB_ACTIVATE_NOW;
+
+       fbi->fbops              = ops;
+       fbi->flags              = FBINFO_FLAG_DEFAULT;
+       fbi->pseudo_palette     = mx3fbi->pseudo_palette;
+
+       mutex_init(&mx3fbi->mutex);
+
+       /* Allocate colormap */
+       ret = fb_alloc_cmap(&fbi->cmap, 16, 0);
+       if (ret < 0) {
+               framebuffer_release(fbi);
+               return NULL;
+       }
+
+       return fbi;
+}
+
+static int init_fb_chan(struct mx3fb_data *mx3fb, struct idmac_channel *ichan)
+{
+       struct device *dev = mx3fb->dev;
+       struct mx3fb_platform_data *mx3fb_pdata = dev->platform_data;
+       const char *name = mx3fb_pdata->name;
+       unsigned int irq;
+       struct fb_info *fbi;
+       struct mx3fb_info *mx3fbi;
+       const struct fb_videomode *mode;
+       int ret, num_modes;
+
+       ichan->client = mx3fb;
+       irq = ichan->eof_irq;
+
+       if (ichan->dma_chan.chan_id != IDMAC_SDC_0)
+               return -EINVAL;
+
+       fbi = mx3fb_init_fbinfo(dev, &mx3fb_ops);
+       if (!fbi)
+               return -ENOMEM;
+
+       if (!fb_mode)
+               fb_mode = name;
+
+       if (!fb_mode) {
+               ret = -EINVAL;
+               goto emode;
+       }
+
+       if (mx3fb_pdata->mode && mx3fb_pdata->num_modes) {
+               mode = mx3fb_pdata->mode;
+               num_modes = mx3fb_pdata->num_modes;
+       } else {
+               mode = mx3fb_modedb;
+               num_modes = ARRAY_SIZE(mx3fb_modedb);
+       }
+
+       if (!fb_find_mode(&fbi->var, fbi, fb_mode, mode,
+                         num_modes, NULL, default_bpp)) {
+               ret = -EBUSY;
+               goto emode;
+       }
+
+       fb_videomode_to_modelist(mode, num_modes, &fbi->modelist);
+
+       /* Default Y virtual size is 2x panel size */
+       fbi->var.yres_virtual = fbi->var.yres * 2;
+
+       mx3fb->fbi = fbi;
+
+       /* set Display Interface clock period */
+       mx3fb_write_reg(mx3fb, 0x00100010L, DI_HSP_CLK_PER);
+       /* Might need to trigger HSP clock change - see 44.3.3.8.5 */
+
+       sdc_set_brightness(mx3fb, 255);
+       sdc_set_global_alpha(mx3fb, true, 0xFF);
+       sdc_set_color_key(mx3fb, IDMAC_SDC_0, false, 0);
+
+       mx3fbi                  = fbi->par;
+       mx3fbi->idmac_channel   = ichan;
+       mx3fbi->ipu_ch          = ichan->dma_chan.chan_id;
+       mx3fbi->mx3fb           = mx3fb;
+       mx3fbi->blank           = FB_BLANK_NORMAL;
+
+       init_completion(&mx3fbi->flip_cmpl);
+       disable_irq(ichan->eof_irq);
+       dev_dbg(mx3fb->dev, "disabling irq %d\n", ichan->eof_irq);
+       ret = mx3fb_set_par(fbi);
+       if (ret < 0)
+               goto esetpar;
+
+       mx3fb_blank(FB_BLANK_UNBLANK, fbi);
+
+       dev_info(dev, "mx3fb: fb registered, using mode %s\n", fb_mode);
+
+       ret = register_framebuffer(fbi);
+       if (ret < 0)
+               goto erfb;
+
+       return 0;
+
+erfb:
+esetpar:
+emode:
+       fb_dealloc_cmap(&fbi->cmap);
+       framebuffer_release(fbi);
+
+       return ret;
+}
+
+static bool chan_filter(struct dma_chan *chan, void *arg)
+{
+       struct dma_chan_request *rq = arg;
+       struct device *dev;
+       struct mx3fb_platform_data *mx3fb_pdata;
+
+       if (!rq)
+               return false;
+
+       dev = rq->mx3fb->dev;
+       mx3fb_pdata = dev->platform_data;
+
+       return rq->id == chan->chan_id &&
+               mx3fb_pdata->dma_dev == chan->device->dev;
+}
+
+static void release_fbi(struct fb_info *fbi)
+{
+       mx3fb_unmap_video_memory(fbi);
+
+       fb_dealloc_cmap(&fbi->cmap);
+
+       unregister_framebuffer(fbi);
+       framebuffer_release(fbi);
+}
+
+static int mx3fb_probe(struct platform_device *pdev)
+{
+       struct device *dev = &pdev->dev;
+       int ret;
+       struct resource *sdc_reg;
+       struct mx3fb_data *mx3fb;
+       dma_cap_mask_t mask;
+       struct dma_chan *chan;
+       struct dma_chan_request rq;
+
+       /*
+        * Display Interface (DI) and Synchronous Display Controller (SDC)
+        * registers
+        */
+       sdc_reg = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+       if (!sdc_reg)
+               return -EINVAL;
+
+       mx3fb = kzalloc(sizeof(*mx3fb), GFP_KERNEL);
+       if (!mx3fb)
+               return -ENOMEM;
+
+       spin_lock_init(&mx3fb->lock);
+
+       mx3fb->reg_base = ioremap(sdc_reg->start, resource_size(sdc_reg));
+       if (!mx3fb->reg_base) {
+               ret = -ENOMEM;
+               goto eremap;
+       }
+
+       pr_debug("Remapped %x to %x at %p\n", sdc_reg->start, sdc_reg->end,
+                mx3fb->reg_base);
+
+       /* IDMAC interface */
+       dmaengine_get();
+
+       mx3fb->dev = dev;
+       platform_set_drvdata(pdev, mx3fb);
+
+       rq.mx3fb = mx3fb;
+
+       dma_cap_zero(mask);
+       dma_cap_set(DMA_SLAVE, mask);
+       dma_cap_set(DMA_PRIVATE, mask);
+       rq.id = IDMAC_SDC_0;
+       chan = dma_request_channel(mask, chan_filter, &rq);
+       if (!chan) {
+               ret = -EBUSY;
+               goto ersdc0;
+       }
+
+       ret = init_fb_chan(mx3fb, to_idmac_chan(chan));
+       if (ret < 0)
+               goto eisdc0;
+
+       mx3fb->backlight_level = 255;
+
+       return 0;
+
+eisdc0:
+       dma_release_channel(chan);
+ersdc0:
+       dmaengine_put();
+       iounmap(mx3fb->reg_base);
+eremap:
+       kfree(mx3fb);
+       dev_err(dev, "mx3fb: failed to register fb\n");
+       return ret;
+}
+
+static int mx3fb_remove(struct platform_device *dev)
+{
+       struct mx3fb_data *mx3fb = platform_get_drvdata(dev);
+       struct fb_info *fbi = mx3fb->fbi;
+       struct mx3fb_info *mx3_fbi = fbi->par;
+       struct dma_chan *chan;
+
+       chan = &mx3_fbi->idmac_channel->dma_chan;
+       release_fbi(fbi);
+
+       dma_release_channel(chan);
+       dmaengine_put();
+
+       iounmap(mx3fb->reg_base);
+       kfree(mx3fb);
+       return 0;
+}
+
+static struct platform_driver mx3fb_driver = {
+       .driver = {
+                  .name = MX3FB_NAME,
+       },
+       .probe = mx3fb_probe,
+       .remove = mx3fb_remove,
+       .suspend = mx3fb_suspend,
+       .resume = mx3fb_resume,
+};
+
+/*
+ * Parse user specified options (`video=mx3fb:')
+ * example:
+ *     video=mx3fb:bpp=16
+ */
+static int mx3fb_setup(void)
+{
+#ifndef MODULE
+       char *opt, *options = NULL;
+
+       if (fb_get_options("mx3fb", &options))
+               return -ENODEV;
+
+       if (!options || !*options)
+               return 0;
+
+       while ((opt = strsep(&options, ",")) != NULL) {
+               if (!*opt)
+                       continue;
+               if (!strncmp(opt, "bpp=", 4))
+                       default_bpp = simple_strtoul(opt + 4, NULL, 0);
+               else
+                       fb_mode = opt;
+       }
+#endif
+
+       return 0;
+}
+
+static int __init mx3fb_init(void)
+{
+       int ret = mx3fb_setup();
+
+       if (ret < 0)
+               return ret;
+
+       ret = platform_driver_register(&mx3fb_driver);
+       return ret;
+}
+
+static void __exit mx3fb_exit(void)
+{
+       platform_driver_unregister(&mx3fb_driver);
+}
+
+module_init(mx3fb_init);
+module_exit(mx3fb_exit);
+
+MODULE_AUTHOR("Freescale Semiconductor, Inc.");
+MODULE_DESCRIPTION("MX3 framebuffer driver");
+MODULE_ALIAS("platform:" MX3FB_NAME);
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/video/nvidia/nv_i2c.c b/drivers/video/nvidia/nv_i2c.c
index 6fd7cb8f9b8e..6aaddb4f6788 100644
--- a/drivers/video/nvidia/nv_i2c.c
+++ b/drivers/video/nvidia/nv_i2c.c
@@ -87,7 +87,6 @@ static int nvidia_setup_i2c_bus(struct nvidia_i2c_chan *chan, const char *name,
 
         strcpy(chan->adapter.name, name);
         chan->adapter.owner = THIS_MODULE;
-        chan->adapter.id = I2C_HW_B_NVIDIA;
         chan->adapter.class = i2c_class;
         chan->adapter.algo_data = &chan->algo;
         chan->adapter.dev.parent = &chan->par->pci_dev->dev;
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 38ac805db97d..87f826e4c958 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1006,7 +1006,7 @@ static int ps3fb_xdr_settings(u64 xdr_lpar, struct device *dev)
                         __func__, status);
                 return -ENXIO;
         }
-        dev_dbg(dev, "video:%p ioif:%lx lpar:%lx size:%lx\n",
+        dev_dbg(dev, "video:%p ioif:%lx lpar:%llx size:%lx\n",
                 ps3fb_videomemory.address, GPU_IOIF, xdr_lpar,
                 ps3fb_videomemory.size);
 
@@ -1133,7 +1133,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
                         __func__, status);
                 goto err;
         }
-        dev_dbg(&dev->core, "ddr:lpar:0x%lx\n", ddr_lpar);
+        dev_dbg(&dev->core, "ddr:lpar:0x%llx\n", ddr_lpar);
 
         status = lv1_gpu_context_allocate(ps3fb.memory_handle, 0,
                                           &ps3fb.context_handle,
diff --git a/drivers/video/savage/savagefb-i2c.c b/drivers/video/savage/savagefb-i2c.c
index 783d4adffb93..574b29e9f8f2 100644
--- a/drivers/video/savage/savagefb-i2c.c
+++ b/drivers/video/savage/savagefb-i2c.c
@@ -137,7 +137,6 @@ static int savage_setup_i2c_bus(struct savagefb_i2c_chan *chan,
         if (chan->par) {
                 strcpy(chan->adapter.name, name);
                 chan->adapter.owner             = THIS_MODULE;
-                chan->adapter.id                = I2C_HW_B_SAVAGE;
                 chan->adapter.algo_data         = &chan->algo;
                 chan->adapter.dev.parent        = &chan->par->pcidev->dev;
                 chan->algo.udelay               = 10;
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 8dc7109d61b7..2ba8f95516a0 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -298,6 +298,14 @@ static int decrease_reservation(unsigned long nr_pages)
                 frame_list[i] = pfn_to_mfn(pfn);
 
                 scrub_page(page);
+
+                if (!PageHighMem(page)) {
+                        ret = HYPERVISOR_update_va_mapping(
+                                (unsigned long)__va(pfn << PAGE_SHIFT),
+                                __pte_ma(0), 0);
+                        BUG_ON(ret);
+                }
+
         }
 
         /* Ensure that ballooned highmem pages don't have kmaps. */
diff --git a/drivers/xen/xenfs/xenbus.c b/drivers/xen/xenfs/xenbus.c
index 875a4c59c594..a9592d981b10 100644
--- a/drivers/xen/xenfs/xenbus.c
+++ b/drivers/xen/xenfs/xenbus.c
@@ -291,7 +291,7 @@ static void watch_fired(struct xenbus_watch *watch,
 static int xenbus_write_transaction(unsigned msg_type,
                                     struct xenbus_file_priv *u)
 {
-        int rc, ret;
+        int rc;
         void *reply;
         struct xenbus_transaction_holder *trans = NULL;
         LIST_HEAD(staging_q);
@@ -326,15 +326,14 @@ static int xenbus_write_transaction(unsigned msg_type,
         }
 
         mutex_lock(&u->reply_mutex);
-        ret = queue_reply(&staging_q, &u->u.msg, sizeof(u->u.msg));
-        if (!ret)
-                ret = queue_reply(&staging_q, reply, u->u.msg.len);
-        if (!ret) {
+        rc = queue_reply(&staging_q, &u->u.msg, sizeof(u->u.msg));
+        if (!rc)
+                rc = queue_reply(&staging_q, reply, u->u.msg.len);
+        if (!rc) {
                 list_splice_tail(&staging_q, &u->read_buffers);
                 wake_up(&u->read_waitq);
         } else {
                 queue_cleanup(&staging_q);
-                rc = ret;
         }
         mutex_unlock(&u->reply_mutex);