17 files changed, 350 insertions, 106 deletions

diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c
index a38005008a20..cea46906408e 100644
--- a/drivers/memstick/core/memstick.c
+++ b/drivers/memstick/core/memstick.c
@@ -185,7 +185,7 @@ static void memstick_free(struct device *dev)
 }
 
 static struct class memstick_host_class = {
-        .name       = "memstick_host",
+        .name        = "memstick_host",
         .dev_release = memstick_free
 };
 
@@ -264,7 +264,7 @@ EXPORT_SYMBOL(memstick_new_req);
  * @sg - TPC argument
  */
 void memstick_init_req_sg(struct memstick_request *mrq, unsigned char tpc,
-                          struct scatterlist *sg)
+                          const struct scatterlist *sg)
 {
         mrq->tpc = tpc;
         if (tpc & 8)
@@ -294,7 +294,7 @@ EXPORT_SYMBOL(memstick_init_req_sg);
  * user supplied buffer.
  */
 void memstick_init_req(struct memstick_request *mrq, unsigned char tpc,
-                       void *buf, size_t length)
+                       const void *buf, size_t length)
 {
         mrq->tpc = tpc;
         if (tpc & 8)
@@ -439,7 +439,7 @@ static void memstick_check(struct work_struct *work)
         if (!host->card) {
                 if (memstick_power_on(host))
                         goto out_power_off;
-        } else
+        } else if (host->card->stop)
                 host->card->stop(host->card);
 
         card = memstick_alloc_card(host);
@@ -458,7 +458,7 @@ static void memstick_check(struct work_struct *work)
                             || !(host->card->check(host->card))) {
                                 device_unregister(&host->card->dev);
                                 host->card = NULL;
-                        } else
+                        } else if (host->card->start)
                                 host->card->start(host->card);
                 }
 
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 44b1817f2f2f..d2d2318dafa4 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -30,6 +30,8 @@ module_param(major, int, 0644);
 #define MSPRO_BLOCK_SIGNATURE        0xa5c3
 #define MSPRO_BLOCK_MAX_ATTRIBUTES   41
 
+#define MSPRO_BLOCK_PART_SHIFT 3
+
 enum {
         MSPRO_BLOCK_ID_SYSINFO         = 0x10,
         MSPRO_BLOCK_ID_MODELNAME       = 0x15,
@@ -195,7 +197,7 @@ static int mspro_block_bd_open(struct inode *inode, struct file *filp)
 static int mspro_block_disk_release(struct gendisk *disk)
 {
         struct mspro_block_data *msb = disk->private_data;
-        int disk_id = disk->first_minor >> MEMSTICK_PART_SHIFT;
+        int disk_id = disk->first_minor >> MSPRO_BLOCK_PART_SHIFT;
 
         mutex_lock(&mspro_block_disk_lock);
 
@@ -877,6 +879,7 @@ static int mspro_block_switch_interface(struct memstick_dev *card)
         struct mspro_block_data *msb = memstick_get_drvdata(card);
         int rc = 0;
 
+try_again:
         if (msb->caps & MEMSTICK_CAP_PAR4)
                 rc = mspro_block_set_interface(card, MEMSTICK_SYS_PAR4);
         else
@@ -930,6 +933,18 @@ static int mspro_block_switch_interface(struct memstick_dev *card)
                 rc = memstick_set_rw_addr(card);
                 if (!rc)
                         rc = mspro_block_set_interface(card, msb->system);
+
+                if (!rc) {
+                        msleep(150);
+                        rc = mspro_block_wait_for_ced(card);
+                        if (rc)
+                                return rc;
+
+                        if (msb->caps & MEMSTICK_CAP_PAR8) {
+                                msb->caps &= ~MEMSTICK_CAP_PAR8;
+                                goto try_again;
+                        }
+                }
         }
         return rc;
 }
@@ -1117,14 +1132,16 @@ static int mspro_block_init_card(struct memstick_dev *card)
                 return -EIO;
 
         msb->caps = host->caps;
-        rc = mspro_block_switch_interface(card);
+
+        msleep(150);
+        rc = mspro_block_wait_for_ced(card);
         if (rc)
                 return rc;
 
-        msleep(200);
-        rc = mspro_block_wait_for_ced(card);
+        rc = mspro_block_switch_interface(card);
         if (rc)
                 return rc;
+
         dev_dbg(&card->dev, "card activated\n");
         if (msb->system != MEMSTICK_SYS_SERIAL)
                 msb->caps |= MEMSTICK_CAP_AUTO_GET_INT;
@@ -1192,12 +1209,12 @@ static int mspro_block_init_disk(struct memstick_dev *card)
         if (rc)
                 return rc;
 
-        if ((disk_id << MEMSTICK_PART_SHIFT) > 255) {
+        if ((disk_id << MSPRO_BLOCK_PART_SHIFT) > 255) {
                 rc = -ENOSPC;
                 goto out_release_id;
         }
 
-        msb->disk = alloc_disk(1 << MEMSTICK_PART_SHIFT);
+        msb->disk = alloc_disk(1 << MSPRO_BLOCK_PART_SHIFT);
         if (!msb->disk) {
                 rc = -ENOMEM;
                 goto out_release_id;
@@ -1220,7 +1237,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)
                                    MSPRO_BLOCK_MAX_PAGES * msb->page_size);
 
         msb->disk->major = major;
-        msb->disk->first_minor = disk_id << MEMSTICK_PART_SHIFT;
+        msb->disk->first_minor = disk_id << MSPRO_BLOCK_PART_SHIFT;
         msb->disk->fops = &ms_block_bdops;
         msb->usage_count = 1;
         msb->disk->private_data = msb;
@@ -1416,7 +1433,7 @@ out_unlock:
 
 static struct memstick_device_id mspro_block_id_tbl[] = {
         {MEMSTICK_MATCH_ALL, MEMSTICK_TYPE_PRO, MEMSTICK_CATEGORY_STORAGE_DUO,
-         MEMSTICK_CLASS_GENERIC_DUO},
+         MEMSTICK_CLASS_DUO},
         {}
 };
 
diff --git a/drivers/memstick/host/jmb38x_ms.c b/drivers/memstick/host/jmb38x_ms.c
index 3485c63d20b0..2fb95a5b72eb 100644
--- a/drivers/memstick/host/jmb38x_ms.c
+++ b/drivers/memstick/host/jmb38x_ms.c
@@ -81,6 +81,8 @@ struct jmb38x_ms {
 #define TPC_CODE_SZ_MASK       0x00000700
 #define TPC_DATA_SZ_MASK       0x00000007
 
+#define HOST_CONTROL_TDELAY_EN 0x00040000
+#define HOST_CONTROL_HW_OC_P   0x00010000
 #define HOST_CONTROL_RESET_REQ 0x00008000
 #define HOST_CONTROL_REI       0x00004000
 #define HOST_CONTROL_LED       0x00000400
@@ -88,6 +90,7 @@ struct jmb38x_ms {
 #define HOST_CONTROL_RESET     0x00000100
 #define HOST_CONTROL_POWER_EN  0x00000080
 #define HOST_CONTROL_CLOCK_EN  0x00000040
+#define HOST_CONTROL_REO       0x00000008
 #define HOST_CONTROL_IF_SHIFT  4
 
 #define HOST_CONTROL_IF_SERIAL 0x0
@@ -133,11 +136,15 @@ struct jmb38x_ms {
 #define PAD_PU_PD_ON_MS_SOCK1 0x0f0f0000
 
 #define CLOCK_CONTROL_40MHZ   0x00000001
-#define CLOCK_CONTROL_50MHZ   0x00000002
+#define CLOCK_CONTROL_50MHZ   0x0000000a
 #define CLOCK_CONTROL_60MHZ   0x00000008
 #define CLOCK_CONTROL_62_5MHZ 0x0000000c
 #define CLOCK_CONTROL_OFF     0x00000000
 
+#define PCI_CTL_CLOCK_DLY_ADDR   0x000000b0
+#define PCI_CTL_CLOCK_DLY_MASK_A 0x00000f00
+#define PCI_CTL_CLOCK_DLY_MASK_B 0x0000f000
+
 enum {
         CMD_READY    = 0x01,
         FIFO_READY   = 0x02,
@@ -367,8 +374,7 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
                 return host->req->error;
         }
 
-        dev_dbg(&msh->dev, "control %08x\n",
-                readl(host->addr + HOST_CONTROL));
+        dev_dbg(&msh->dev, "control %08x\n", readl(host->addr + HOST_CONTROL));
         dev_dbg(&msh->dev, "status %08x\n", readl(host->addr + INT_STATUS));
         dev_dbg(&msh->dev, "hstatus %08x\n", readl(host->addr + STATUS));
 
@@ -637,7 +643,7 @@ static int jmb38x_ms_reset(struct jmb38x_ms_host *host)
                 ndelay(20);
         }
         dev_dbg(&host->chip->pdev->dev, "reset_req timeout\n");
-        return -EIO;
+        /* return -EIO; */
 
 reset_next:
         writel(HOST_CONTROL_RESET | HOST_CONTROL_CLOCK_EN
@@ -680,7 +686,9 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
 
                         host_ctl = 7;
                         host_ctl |= HOST_CONTROL_POWER_EN
-                                 | HOST_CONTROL_CLOCK_EN;
+                                    | HOST_CONTROL_CLOCK_EN
+                                    | HOST_CONTROL_HW_OC_P
+                                    | HOST_CONTROL_TDELAY_EN;
                         writel(host_ctl, host->addr + HOST_CONTROL);
 
                         writel(host->id ? PAD_PU_PD_ON_MS_SOCK1
@@ -704,33 +712,40 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
                 break;
         case MEMSTICK_INTERFACE:
                 host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT);
+                pci_read_config_dword(host->chip->pdev,
+                                      PCI_CTL_CLOCK_DLY_ADDR,
+                                      &clock_delay);
+                clock_delay &= host->id ? ~PCI_CTL_CLOCK_DLY_MASK_B
+                                        : ~PCI_CTL_CLOCK_DLY_MASK_A;
 
                 if (value == MEMSTICK_SERIAL) {
                         host_ctl &= ~HOST_CONTROL_FAST_CLK;
+                        host_ctl &= ~HOST_CONTROL_REO;
                         host_ctl |= HOST_CONTROL_IF_SERIAL
                                     << HOST_CONTROL_IF_SHIFT;
                         host_ctl |= HOST_CONTROL_REI;
                         clock_ctl = CLOCK_CONTROL_40MHZ;
-                        clock_delay = 0;
                 } else if (value == MEMSTICK_PAR4) {
-                        host_ctl |= HOST_CONTROL_FAST_CLK;
+                        host_ctl |= HOST_CONTROL_FAST_CLK | HOST_CONTROL_REO;
                         host_ctl |= HOST_CONTROL_IF_PAR4
                                     << HOST_CONTROL_IF_SHIFT;
                         host_ctl &= ~HOST_CONTROL_REI;
                         clock_ctl = CLOCK_CONTROL_40MHZ;
-                        clock_delay = 4;
+                        clock_delay |= host->id ? (4 << 12) : (4 << 8);
                 } else if (value == MEMSTICK_PAR8) {
                         host_ctl |= HOST_CONTROL_FAST_CLK;
                         host_ctl |= HOST_CONTROL_IF_PAR8
                                     << HOST_CONTROL_IF_SHIFT;
-                        host_ctl &= ~HOST_CONTROL_REI;
-                        clock_ctl = CLOCK_CONTROL_60MHZ;
-                        clock_delay = 0;
+                        host_ctl &= ~(HOST_CONTROL_REI | HOST_CONTROL_REO);
+                        clock_ctl = CLOCK_CONTROL_50MHZ;
                 } else
                         return -EINVAL;
+
                 writel(host_ctl, host->addr + HOST_CONTROL);
                 writel(clock_ctl, host->addr + CLOCK_CONTROL);
-                writel(clock_delay, host->addr + CLOCK_DELAY);
+                pci_write_config_dword(host->chip->pdev,
+                                       PCI_CTL_CLOCK_DLY_ADDR,
+                                       clock_delay);
                 break;
         };
         return 0;
diff --git a/drivers/misc/sgi-gru/grufile.c b/drivers/misc/sgi-gru/grufile.c
index 23c91f5f6b61..d61cee796efd 100644
--- a/drivers/misc/sgi-gru/grufile.c
+++ b/drivers/misc/sgi-gru/grufile.c
@@ -445,6 +445,9 @@ static void __exit gru_exit(void)
         int order = get_order(sizeof(struct gru_state) *
                               GRU_CHIPLETS_PER_BLADE);
 
+        if (!IS_UV())
+                return;
+
         for (i = 0; i < GRU_CHIPLETS_PER_BLADE; i++)
                 free_irq(IRQ_GRU + i, NULL);
 
diff --git a/drivers/net/niu.c b/drivers/net/niu.c
index e4765b713aba..e3be81eba8a4 100644
--- a/drivers/net/niu.c
+++ b/drivers/net/niu.c
@@ -5984,6 +5984,56 @@ static void niu_netif_start(struct niu *np)
         niu_enable_interrupts(np, 1);
 }
 
+static void niu_reset_buffers(struct niu *np)
+{
+        int i, j, k, err;
+
+        if (np->rx_rings) {
+                for (i = 0; i < np->num_rx_rings; i++) {
+                        struct rx_ring_info *rp = &np->rx_rings[i];
+
+                        for (j = 0, k = 0; j < MAX_RBR_RING_SIZE; j++) {
+                                struct page *page;
+
+                                page = rp->rxhash[j];
+                                while (page) {
+                                        struct page *next =
+                                                (struct page *) page->mapping;
+                                        u64 base = page->index;
+                                        base = base >> RBR_DESCR_ADDR_SHIFT;
+                                        rp->rbr[k++] = cpu_to_le32(base);
+                                        page = next;
+                                }
+                        }
+                        for (; k < MAX_RBR_RING_SIZE; k++) {
+                                err = niu_rbr_add_page(np, rp, GFP_ATOMIC, k);
+                                if (unlikely(err))
+                                        break;
+                        }
+
+                        rp->rbr_index = rp->rbr_table_size - 1;
+                        rp->rcr_index = 0;
+                        rp->rbr_pending = 0;
+                        rp->rbr_refill_pending = 0;
+                }
+        }
+        if (np->tx_rings) {
+                for (i = 0; i < np->num_tx_rings; i++) {
+                        struct tx_ring_info *rp = &np->tx_rings[i];
+
+                        for (j = 0; j < MAX_TX_RING_SIZE; j++) {
+                                if (rp->tx_buffs[j].skb)
+                                        (void) release_tx_packet(np, rp, j);
+                        }
+
+                        rp->pending = MAX_TX_RING_SIZE;
+                        rp->prod = 0;
+                        rp->cons = 0;
+                        rp->wrap_bit = 0;
+                }
+        }
+}
+
 static void niu_reset_task(struct work_struct *work)
 {
         struct niu *np = container_of(work, struct niu, reset_task);
@@ -6006,6 +6056,12 @@ static void niu_reset_task(struct work_struct *work)
 
         niu_stop_hw(np);
 
+        spin_unlock_irqrestore(&np->lock, flags);
+
+        niu_reset_buffers(np);
+
+        spin_lock_irqsave(&np->lock, flags);
+
         err = niu_init_hw(np);
         if (!err) {
                 np->timer.expires = jiffies + HZ;
diff --git a/drivers/net/wireless/ath9k/beacon.c b/drivers/net/wireless/ath9k/beacon.c
index caf569401a34..00a0eaa08866 100644
--- a/drivers/net/wireless/ath9k/beacon.c
+++ b/drivers/net/wireless/ath9k/beacon.c
@@ -209,6 +209,7 @@ static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
         unsigned int curlen;
         struct ath_txq *cabq;
         struct ath_txq *mcastq;
+        struct ieee80211_tx_info *info;
         avp = sc->sc_vaps[if_id];
 
         mcastq = &avp->av_mcastq;
@@ -232,6 +233,18 @@ static struct ath_buf *ath_beacon_generate(struct ath_softc *sc, int if_id)
          */
         curlen = skb->len;
 
+        info = IEEE80211_SKB_CB(skb);
+        if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+                /*
+                 * TODO: make sure the seq# gets assigned properly (vs. other
+                 * TX frames)
+                 */
+                struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+                sc->seq_no += 0x10;
+                hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+                hdr->seq_ctrl |= cpu_to_le16(sc->seq_no);
+        }
+
         /* XXX: spin_lock_bh should not be used here, but sparse bitches
          * otherwise. We should fix sparse :) */
         spin_lock_bh(&mcastq->axq_lock);
diff --git a/drivers/net/wireless/ath9k/core.h b/drivers/net/wireless/ath9k/core.h
index 673b3d81133a..4ee695b76b88 100644
--- a/drivers/net/wireless/ath9k/core.h
+++ b/drivers/net/wireless/ath9k/core.h
@@ -992,6 +992,7 @@ struct ath_softc {
         u32 sc_txintrperiod;    /* tx interrupt batching */
         int sc_haltype2q[ATH9K_WME_AC_VO+1]; /* HAL WME AC -> h/w qnum */
         u32 sc_ant_tx[8];       /* recent tx frames/antenna */
+        u16 seq_no; /* TX sequence number */
 
         /* Beacon */
         struct ath9k_tx_queue_info sc_beacon_qi;
diff --git a/drivers/net/wireless/ath9k/main.c b/drivers/net/wireless/ath9k/main.c
index c5107f269f24..99badf1404c3 100644
--- a/drivers/net/wireless/ath9k/main.c
+++ b/drivers/net/wireless/ath9k/main.c
@@ -369,6 +369,20 @@ static int ath9k_tx(struct ieee80211_hw *hw,
 {
         struct ath_softc *sc = hw->priv;
         int hdrlen, padsize;
+        struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
+        /*
+         * As a temporary workaround, assign seq# here; this will likely need
+         * to be cleaned up to work better with Beacon transmission and virtual
+         * BSSes.
+         */
+        if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
+                struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+                if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
+                        sc->seq_no += 0x10;
+                hdr->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
+                hdr->seq_ctrl |= cpu_to_le16(sc->seq_no);
+        }
 
         /* Add the padding after the header if this is not already done */
         hdrlen = ieee80211_get_hdrlen_from_skb(skb);
diff --git a/drivers/pci/hotplug/fakephp.c b/drivers/pci/hotplug/fakephp.c
index 40337a06c18a..146ca9cd1567 100644
--- a/drivers/pci/hotplug/fakephp.c
+++ b/drivers/pci/hotplug/fakephp.c
@@ -320,15 +320,15 @@ static int disable_slot(struct hotplug_slot *slot)
                         return -ENODEV;
                 }
 
+                /* remove the device from the pci core */
+                pci_remove_bus_device(dev);
+
                 /* queue work item to blow away this sysfs entry and other
                  * parts.
                  */
                 INIT_WORK(&dslot->remove_work, remove_slot_worker);
                 queue_work(dummyphp_wq, &dslot->remove_work);
 
-                /* blow away this sysfs entry and other parts. */
-                remove_slot(dslot);
-
                 pci_dev_put(dev);
         }
         return 0;
diff --git a/drivers/pci/hotplug/pciehp_hpc.c b/drivers/pci/hotplug/pciehp_hpc.c
index ab31f5ba665d..9d934ddee956 100644
--- a/drivers/pci/hotplug/pciehp_hpc.c
+++ b/drivers/pci/hotplug/pciehp_hpc.c
@@ -258,7 +258,7 @@ static int pcie_poll_cmd(struct controller *ctrl)
                         return 1;
                 }
         }
-        while (timeout > 1000) {
+        while (timeout > 0) {
                 msleep(10);
                 timeout -= 10;
                 if (!pciehp_readw(ctrl, SLOTSTATUS, &slot_status)) {
diff --git a/drivers/pci/intel-iommu.c b/drivers/pci/intel-iommu.c
index 8d0e60ac849c..c3edcdc08e72 100644
--- a/drivers/pci/intel-iommu.c
+++ b/drivers/pci/intel-iommu.c
@@ -2348,11 +2348,34 @@ static void __init iommu_exit_mempool(void)
 
 }
 
+static int blacklist_iommu(const struct dmi_system_id *id)
+{
+        printk(KERN_INFO "%s detected; disabling IOMMU\n",
+               id->ident);
+        dmar_disabled = 1;
+        return 0;
+}
+
+static struct dmi_system_id __initdata intel_iommu_dmi_table[] = {
+        {       /* Some DG33BU BIOS revisions advertised non-existent VT-d */
+                .callback = blacklist_iommu,
+                .ident = "Intel DG33BU",
+                {       DMI_MATCH(DMI_BOARD_VENDOR, "Intel Corporation"),
+                        DMI_MATCH(DMI_BOARD_NAME, "DG33BU"),
+                }
+        },
+        { }
+};
+
+
 void __init detect_intel_iommu(void)
 {
         if (swiotlb || no_iommu || iommu_detected || dmar_disabled)
                 return;
         if (early_dmar_detect()) {
+                dmi_check_system(intel_iommu_dmi_table);
+                if (dmar_disabled)
+                        return;
                 iommu_detected = 1;
         }
 }
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index cce2f4cb1fbf..36698e57b97f 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -304,6 +304,9 @@ static int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
                 } else {
                         res->start = l64;
                         res->end = l64 + sz64;
+                        printk(KERN_DEBUG "PCI: %s reg %x 64bit mmio: [%llx, %llx]\n",
+                                pci_name(dev), pos, (unsigned long long)res->start,
+                                (unsigned long long)res->end);
                 }
         } else {
                 sz = pci_size(l, sz, mask);
@@ -313,6 +316,9 @@ static int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
 
                 res->start = l;
                 res->end = l + sz;
+                printk(KERN_DEBUG "PCI: %s reg %x %s: [%llx, %llx]\n", pci_name(dev),
+                        pos, (res->flags & IORESOURCE_IO) ? "io port":"32bit mmio",
+                        (unsigned long long)res->start, (unsigned long long)res->end);
         }
 
  out:
@@ -383,7 +389,9 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                         res->start = base;
                 if (!res->end)
                         res->end = limit + 0xfff;
-                printk(KERN_INFO "PCI: bridge %s io port: [%llx, %llx]\n", pci_name(dev), res->start, res->end);
+                printk(KERN_DEBUG "PCI: bridge %s io port: [%llx, %llx]\n",
+                        pci_name(dev), (unsigned long long) res->start,
+                        (unsigned long long) res->end);
         }
 
         res = child->resource[1];
@@ -395,7 +403,9 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM;
                 res->start = base;
                 res->end = limit + 0xfffff;
-                printk(KERN_INFO "PCI: bridge %s 32bit mmio: [%llx, %llx]\n", pci_name(dev), res->start, res->end);
+                printk(KERN_DEBUG "PCI: bridge %s 32bit mmio: [%llx, %llx]\n",
+                        pci_name(dev), (unsigned long long) res->start,
+                        (unsigned long long) res->end);
         }
 
         res = child->resource[2];
@@ -431,7 +441,9 @@ void __devinit pci_read_bridge_bases(struct pci_bus *child)
                 res->flags = (mem_base_lo & PCI_MEMORY_RANGE_TYPE_MASK) | IORESOURCE_MEM | IORESOURCE_PREFETCH;
                 res->start = base;
                 res->end = limit + 0xfffff;
-                printk(KERN_INFO "PCI: bridge %s %sbit mmio pref: [%llx, %llx]\n", pci_name(dev), (res->flags & PCI_PREF_RANGE_TYPE_64)?"64":"32",res->start, res->end);
+                printk(KERN_DEBUG "PCI: bridge %s %sbit mmio pref: [%llx, %llx]\n",
+                        pci_name(dev), (res->flags & PCI_PREF_RANGE_TYPE_64) ? "64" : "32",
+                        (unsigned long long) res->start, (unsigned long long) res->end);
         }
 }
 
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 1aad599816f7..3abbfad9ddab 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -540,7 +540,11 @@ static void pci_bus_dump_res(struct pci_bus *bus)
                 if (!res)
                         continue;
 
-                printk(KERN_INFO "bus: %02x index %x %s: [%llx, %llx]\n", bus->number, i, (res->flags & IORESOURCE_IO)? "io port":"mmio", res->start, res->end);
+                printk(KERN_INFO "bus: %02x index %x %s: [%llx, %llx]\n",
+                        bus->number, i,
+                        (res->flags & IORESOURCE_IO) ? "io port" : "mmio",
+                        (unsigned long long) res->start,
+                        (unsigned long long) res->end);
         }
 }
 
diff --git a/drivers/spi/pxa2xx_spi.c b/drivers/spi/pxa2xx_spi.c
index 34c7c9875681..0e53354c1cfe 100644
--- a/drivers/spi/pxa2xx_spi.c
+++ b/drivers/spi/pxa2xx_spi.c
@@ -47,9 +47,10 @@ MODULE_ALIAS("platform:pxa2xx-spi");
 
 #define MAX_BUSES 3
 
-#define DMA_INT_MASK (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
-#define RESET_DMA_CHANNEL (DCSR_NODESC | DMA_INT_MASK)
-#define IS_DMA_ALIGNED(x) (((u32)(x)&0x07)==0)
+#define DMA_INT_MASK            (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
+#define RESET_DMA_CHANNEL       (DCSR_NODESC | DMA_INT_MASK)
+#define IS_DMA_ALIGNED(x)       (((x) & 0x07) == 0)
+#define MAX_DMA_LEN             8191
 
 /*
  * for testing SSCR1 changes that require SSP restart, basically
@@ -144,7 +145,6 @@ struct driver_data {
         size_t tx_map_len;
         u8 n_bytes;
         u32 dma_width;
-        int cs_change;
         int (*write)(struct driver_data *drv_data);
         int (*read)(struct driver_data *drv_data);
         irqreturn_t (*transfer_handler)(struct driver_data *drv_data);
@@ -406,8 +406,45 @@ static void giveback(struct driver_data *drv_data)
                                         struct spi_transfer,
                                         transfer_list);
 
+        /* Delay if requested before any change in chip select */
+        if (last_transfer->delay_usecs)
+                udelay(last_transfer->delay_usecs);
+
+        /* Drop chip select UNLESS cs_change is true or we are returning
+         * a message with an error, or next message is for another chip
+         */
         if (!last_transfer->cs_change)
                 drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        else {
+                struct spi_message *next_msg;
+
+                /* Holding of cs was hinted, but we need to make sure
+                 * the next message is for the same chip.  Don't waste
+                 * time with the following tests unless this was hinted.
+                 *
+                 * We cannot postpone this until pump_messages, because
+                 * after calling msg->complete (below) the driver that
+                 * sent the current message could be unloaded, which
+                 * could invalidate the cs_control() callback...
+                 */
+
+                /* get a pointer to the next message, if any */
+                spin_lock_irqsave(&drv_data->lock, flags);
+                if (list_empty(&drv_data->queue))
+                        next_msg = NULL;
+                else
+                        next_msg = list_entry(drv_data->queue.next,
+                                        struct spi_message, queue);
+                spin_unlock_irqrestore(&drv_data->lock, flags);
+
+                /* see if the next and current messages point
+                 * to the same chip
+                 */
+                if (next_msg && next_msg->spi != msg->spi)
+                        next_msg = NULL;
+                if (!next_msg || msg->state == ERROR_STATE)
+                        drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        }
 
         msg->state = NULL;
         if (msg->complete)
@@ -490,10 +527,9 @@ static void dma_transfer_complete(struct driver_data *drv_data)
         msg->actual_length += drv_data->len -
                                 (drv_data->rx_end - drv_data->rx);
 
-        /* Release chip select if requested, transfer delays are
-         * handled in pump_transfers */
-        if (drv_data->cs_change)
-                drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        /* Transfer delays and chip select release are
+         * handled in pump_transfers or giveback
+         */
 
         /* Move to next transfer */
         msg->state = next_transfer(drv_data);
@@ -602,10 +638,9 @@ static void int_transfer_complete(struct driver_data *drv_data)
         drv_data->cur_msg->actual_length += drv_data->len -
                                 (drv_data->rx_end - drv_data->rx);
 
-        /* Release chip select if requested, transfer delays are
-         * handled in pump_transfers */
-        if (drv_data->cs_change)
-                drv_data->cs_control(PXA2XX_CS_DEASSERT);
+        /* Transfer delays and chip select release are
+         * handled in pump_transfers or giveback
+         */
 
         /* Move to next transfer */
         drv_data->cur_msg->state = next_transfer(drv_data);
@@ -840,23 +875,40 @@ static void pump_transfers(unsigned long data)
                 return;
         }
 
-        /* Delay if requested at end of transfer*/
+        /* Delay if requested at end of transfer before CS change */
         if (message->state == RUNNING_STATE) {
                 previous = list_entry(transfer->transfer_list.prev,
                                         struct spi_transfer,
                                         transfer_list);
                 if (previous->delay_usecs)
                         udelay(previous->delay_usecs);
+
+                /* Drop chip select only if cs_change is requested */
+                if (previous->cs_change)
+                        drv_data->cs_control(PXA2XX_CS_DEASSERT);
         }
 
-        /* Check transfer length */
-        if (transfer->len > 8191)
-        {
-                dev_warn(&drv_data->pdev->dev, "pump_transfers: transfer "
-                                "length greater than 8191\n");
-                message->status = -EINVAL;
-                giveback(drv_data);
-                return;
+        /* Check for transfers that need multiple DMA segments */
+        if (transfer->len > MAX_DMA_LEN && chip->enable_dma) {
+
+                /* reject already-mapped transfers; PIO won't always work */
+                if (message->is_dma_mapped
+                                || transfer->rx_dma || transfer->tx_dma) {
+                        dev_err(&drv_data->pdev->dev,
+                                "pump_transfers: mapped transfer length "
+                                "of %lu is greater than %d\n",
+                                transfer->len, MAX_DMA_LEN);
+                        message->status = -EINVAL;
+                        giveback(drv_data);
+                        return;
+                }
+
+                /* warn ... we force this to PIO mode */
+                if (printk_ratelimit())
+                        dev_warn(&message->spi->dev, "pump_transfers: "
+                                "DMA disabled for transfer length %ld "
+                                "greater than %d\n",
+                                (long)drv_data->len, MAX_DMA_LEN);
         }
 
         /* Setup the transfer state based on the type of transfer */
@@ -878,7 +930,6 @@ static void pump_transfers(unsigned long data)
         drv_data->len = transfer->len & DCMD_LENGTH;
         drv_data->write = drv_data->tx ? chip->write : null_writer;
         drv_data->read = drv_data->rx ? chip->read : null_reader;
-        drv_data->cs_change = transfer->cs_change;
 
         /* Change speed and bit per word on a per transfer */
         cr0 = chip->cr0;
@@ -925,7 +976,7 @@ static void pump_transfers(unsigned long data)
                                                         &dma_thresh))
                                 if (printk_ratelimit())
                                         dev_warn(&message->spi->dev,
-                                                "pump_transfer: "
+                                                "pump_transfers: "
                                                 "DMA burst size reduced to "
                                                 "match bits_per_word\n");
                 }
@@ -939,8 +990,23 @@ static void pump_transfers(unsigned long data)
 
         message->state = RUNNING_STATE;
 
-        /* Try to map dma buffer and do a dma transfer if successful */
-        if ((drv_data->dma_mapped = map_dma_buffers(drv_data))) {
+        /* Try to map dma buffer and do a dma transfer if successful, but
+         * only if the length is non-zero and less than MAX_DMA_LEN.
+         *
+         * Zero-length non-descriptor DMA is illegal on PXA2xx; force use
+         * of PIO instead.  Care is needed above because the transfer may
+         * have have been passed with buffers that are already dma mapped.
+         * A zero-length transfer in PIO mode will not try to write/read
+         * to/from the buffers
+         *
+         * REVISIT large transfers are exactly where we most want to be
+         * using DMA.  If this happens much, split those transfers into
+         * multiple DMA segments rather than forcing PIO.
+         */
+        drv_data->dma_mapped = 0;
+        if (drv_data->len > 0 && drv_data->len <= MAX_DMA_LEN)
+                drv_data->dma_mapped = map_dma_buffers(drv_data);
+        if (drv_data->dma_mapped) {
 
                 /* Ensure we have the correct interrupt handler */
                 drv_data->transfer_handler = dma_transfer;
diff --git a/drivers/spi/spi_mpc83xx.c b/drivers/spi/spi_mpc83xx.c
index 070c6219e2d6..ac0e3e4b3c54 100644
--- a/drivers/spi/spi_mpc83xx.c
+++ b/drivers/spi/spi_mpc83xx.c
@@ -267,16 +267,13 @@ int mpc83xx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         cs->hw_mode |= SPMODE_LEN(bits_per_word);
 
         if ((mpc83xx_spi->spibrg / hz) > 64) {
+                cs->hw_mode |= SPMODE_DIV16;
                 pm = mpc83xx_spi->spibrg / (hz * 64);
                 if (pm > 16) {
-                        cs->hw_mode |= SPMODE_DIV16;
-                        pm /= 16;
-                        if (pm > 16) {
-                                dev_err(&spi->dev, "Requested speed is too "
-                                        "low: %d Hz. Will use %d Hz instead.\n",
-                                        hz, mpc83xx_spi->spibrg / 1024);
-                                pm = 16;
-                        }
+                        dev_err(&spi->dev, "Requested speed is too "
+                                "low: %d Hz. Will use %d Hz instead.\n",
+                                hz, mpc83xx_spi->spibrg / 1024);
+                        pm = 16;
                 }
         } else
                 pm = mpc83xx_spi->spibrg / (hz * 4);
@@ -315,11 +312,20 @@ static int mpc83xx_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
         if (t->bits_per_word)
                 bits_per_word = t->bits_per_word;
         len = t->len;
-        if (bits_per_word > 8)
+        if (bits_per_word > 8) {
+                /* invalid length? */
+                if (len & 1)
+                        return -EINVAL;
                 len /= 2;
-        if (bits_per_word > 16)
+        }
+        if (bits_per_word > 16) {
+                /* invalid length? */
+                if (len & 1)
+                        return -EINVAL;
                 len /= 2;
+        }
         mpc83xx_spi->count = len;
+
         INIT_COMPLETION(mpc83xx_spi->done);
 
         /* enable rx ints */
diff --git a/drivers/spi/spi_s3c24xx.c b/drivers/spi/spi_s3c24xx.c
index 98abc73c1a1d..3eb414b84a9d 100644
--- a/drivers/spi/spi_s3c24xx.c
+++ b/drivers/spi/spi_s3c24xx.c
@@ -430,7 +430,7 @@ static int s3c24xx_spi_resume(struct platform_device *pdev)
 #endif
 
 MODULE_ALIAS("platform:s3c2410-spi");
-static struct platform_driver s3c24xx_spidrv = {
+static struct platform_driver s3c24xx_spi_driver = {
         .remove         = __exit_p(s3c24xx_spi_remove),
         .suspend        = s3c24xx_spi_suspend,
         .resume         = s3c24xx_spi_resume,
@@ -442,12 +442,12 @@ static struct platform_driver s3c24xx_spidrv = {
 
 static int __init s3c24xx_spi_init(void)
 {
-        return platform_driver_probe(&s3c24xx_spidrv, s3c24xx_spi_probe);
+        return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);
 }
 
 static void __exit s3c24xx_spi_exit(void)
 {
-        platform_driver_unregister(&s3c24xx_spidrv);
+        platform_driver_unregister(&s3c24xx_spi_driver);
 }
 
 module_init(s3c24xx_spi_init);
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 5a24c6411d34..75dac578104f 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -208,6 +208,36 @@ static unsigned long compute_hozval(unsigned long xres, unsigned long lcdcon2)
         return value;
 }
 
+static void atmel_lcdfb_stop_nowait(struct atmel_lcdfb_info *sinfo)
+{
+        /* Turn off the LCD controller and the DMA controller */
+        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
+                        sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET);
+
+        /* Wait for the LCDC core to become idle */
+        while (lcdc_readl(sinfo, ATMEL_LCDC_PWRCON) & ATMEL_LCDC_BUSY)
+                msleep(10);
+
+        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
+}
+
+static void atmel_lcdfb_stop(struct atmel_lcdfb_info *sinfo)
+{
+        atmel_lcdfb_stop_nowait(sinfo);
+
+        /* Wait for DMA engine to become idle... */
+        while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
+                msleep(10);
+}
+
+static void atmel_lcdfb_start(struct atmel_lcdfb_info *sinfo)
+{
+        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, sinfo->default_dmacon);
+        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
+                (sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET)
+                | ATMEL_LCDC_PWR);
+}
+
 static void atmel_lcdfb_update_dma(struct fb_info *info,
                                struct fb_var_screeninfo *var)
 {
@@ -420,26 +450,8 @@ static void atmel_lcdfb_reset(struct atmel_lcdfb_info *sinfo)
 {
         might_sleep();
 
-        /* LCD power off */
-        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON, sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET);
-
-        /* wait for the LCDC core to become idle */
-        while (lcdc_readl(sinfo, ATMEL_LCDC_PWRCON) & ATMEL_LCDC_BUSY)
-                msleep(10);
-
-        /* DMA disable */
-        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
-
-        /* wait for DMA engine to become idle */
-        while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
-                msleep(10);
-
-        /* LCD power on */
-        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
-                (sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET) | ATMEL_LCDC_PWR);
-
-        /* DMA enable */
-        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, sinfo->default_dmacon);
+        atmel_lcdfb_stop(sinfo);
+        atmel_lcdfb_start(sinfo);
 }
 
 /**
@@ -471,14 +483,7 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
                  info->var.xres, info->var.yres,
                  info->var.xres_virtual, info->var.yres_virtual);
 
-        /* Turn off the LCD controller and the DMA controller */
-        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON, sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET);
-
-        /* Wait for the LCDC core to become idle */
-        while (lcdc_readl(sinfo, ATMEL_LCDC_PWRCON) & ATMEL_LCDC_BUSY)
-                msleep(10);
-
-        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
+        atmel_lcdfb_stop_nowait(sinfo);
 
         if (info->var.bits_per_pixel == 1)
                 info->fix.visual = FB_VISUAL_MONO01;
@@ -583,13 +588,7 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         while (lcdc_readl(sinfo, ATMEL_LCDC_DMACON) & ATMEL_LCDC_DMABUSY)
                 msleep(10);
 
-        dev_dbg(info->device, "  * re-enable DMA engine\n");
-        /* ...and enable it with updated configuration */
-        lcdc_writel(sinfo, ATMEL_LCDC_DMACON, sinfo->default_dmacon);
-
-        dev_dbg(info->device, "  * re-enable LCDC core\n");
-        lcdc_writel(sinfo, ATMEL_LCDC_PWRCON,
-                (sinfo->guard_time << ATMEL_LCDC_GUARDT_OFFSET) | ATMEL_LCDC_PWR);
+        atmel_lcdfb_start(sinfo);
 
         dev_dbg(info->device, "  * DONE\n");
 
@@ -1032,11 +1031,20 @@ static int atmel_lcdfb_suspend(struct platform_device *pdev, pm_message_t mesg)
         struct fb_info *info = platform_get_drvdata(pdev);
         struct atmel_lcdfb_info *sinfo = info->par;
 
+        /*
+         * We don't want to handle interrupts while the clock is
+         * stopped. It may take forever.
+         */
+        lcdc_writel(sinfo, ATMEL_LCDC_IDR, ~0UL);
+
         sinfo->saved_lcdcon = lcdc_readl(sinfo, ATMEL_LCDC_CONTRAST_VAL);
         lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, 0);
         if (sinfo->atmel_lcdfb_power_control)
                 sinfo->atmel_lcdfb_power_control(0);
+
+        atmel_lcdfb_stop(sinfo);
         atmel_lcdfb_stop_clock(sinfo);
+
         return 0;
 }
 
@@ -1046,9 +1054,15 @@ static int atmel_lcdfb_resume(struct platform_device *pdev)
         struct atmel_lcdfb_info *sinfo = info->par;
 
         atmel_lcdfb_start_clock(sinfo);
+        atmel_lcdfb_start(sinfo);
         if (sinfo->atmel_lcdfb_power_control)
                 sinfo->atmel_lcdfb_power_control(1);
         lcdc_writel(sinfo, ATMEL_LCDC_CONTRAST_CTR, sinfo->saved_lcdcon);
+
+        /* Enable FIFO & DMA errors */
+        lcdc_writel(sinfo, ATMEL_LCDC_IER, ATMEL_LCDC_UFLWI
+                        | ATMEL_LCDC_OWRI | ATMEL_LCDC_MERI);
+
         return 0;
 }