26 files changed, 108 insertions, 533 deletions

diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 0cd3ad49713..4214bfb13bb 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -612,7 +612,7 @@ u64 ata_tf_read_block(struct ata_taskfile *tf, struct ata_device *dev)
                 if (tf->flags & ATA_TFLAG_LBA48) {
                         block |= (u64)tf->hob_lbah << 40;
                         block |= (u64)tf->hob_lbam << 32;
-                        block |= tf->hob_lbal << 24;
+                        block |= (u64)tf->hob_lbal << 24;
                 } else
                         block |= (tf->device & 0xf) << 24;
 
diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
index 8077bdf5d30..32da9a93ce4 100644
--- a/drivers/ata/libata-eh.c
+++ b/drivers/ata/libata-eh.c
@@ -610,9 +610,6 @@ void ata_scsi_error(struct Scsi_Host *host)
                                 if (ata_ncq_enabled(dev))
                                         ehc->saved_ncq_enabled |= 1 << devno;
                         }
-
-                        /* set last reset timestamp to some time in the past */
-                        ehc->last_reset = jiffies - 60 * HZ;
                 }
 
                 ap->pflags |= ATA_PFLAG_EH_IN_PROGRESS;
@@ -2281,17 +2278,21 @@ int ata_eh_reset(struct ata_link *link, int classify,
         if (link->flags & ATA_LFLAG_NO_SRST)
                 softreset = NULL;
 
-        now = jiffies;
-        deadline = ata_deadline(ehc->last_reset, ATA_EH_RESET_COOL_DOWN);
-        if (time_before(now, deadline))
-                schedule_timeout_uninterruptible(deadline - now);
+        /* make sure each reset attemp is at least COOL_DOWN apart */
+        if (ehc->i.flags & ATA_EHI_DID_RESET) {
+                now = jiffies;
+                WARN_ON(time_after(ehc->last_reset, now));
+                deadline = ata_deadline(ehc->last_reset,
+                                        ATA_EH_RESET_COOL_DOWN);
+                if (time_before(now, deadline))
+                        schedule_timeout_uninterruptible(deadline - now);
+        }
 
         spin_lock_irqsave(ap->lock, flags);
         ap->pflags |= ATA_PFLAG_RESETTING;
         spin_unlock_irqrestore(ap->lock, flags);
 
         ata_eh_about_to_do(link, NULL, ATA_EH_RESET);
-        ehc->last_reset = jiffies;
 
         ata_link_for_each_dev(dev, link) {
                 /* If we issue an SRST then an ATA drive (not ATAPI)
@@ -2379,7 +2380,6 @@ int ata_eh_reset(struct ata_link *link, int classify,
         /*
          * Perform reset
          */
-        ehc->last_reset = jiffies;
         if (ata_is_host_link(link))
                 ata_eh_freeze_port(ap);
 
@@ -2391,6 +2391,7 @@ int ata_eh_reset(struct ata_link *link, int classify,
                                         reset == softreset ? "soft" : "hard");
 
                 /* mark that this EH session started with reset */
+                ehc->last_reset = jiffies;
                 if (reset == hardreset)
                         ehc->i.flags |= ATA_EHI_DID_HARDRESET;
                 else
@@ -2535,7 +2536,7 @@ int ata_eh_reset(struct ata_link *link, int classify,
         ata_eh_done(link, NULL, ATA_EH_RESET);
         if (slave)
                 ata_eh_done(slave, NULL, ATA_EH_RESET);
-        ehc->last_reset = jiffies;
+        ehc->last_reset = jiffies;      /* update to completion time */
         ehc->i.action |= ATA_EH_REVALIDATE;
 
         rc = 0;
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index 1b2d4a0f5f7..8b236af84c2 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -72,7 +72,6 @@
 /**
  *      cs5535_cable_detect     -       detect cable type
  *      @ap: Port to detect on
- *      @deadline: deadline jiffies for the operation
  *
  *      Perform cable detection for ATA66 capable cable. Return a libata
  *      cable type.
diff --git a/drivers/ata/pata_cs5536.c b/drivers/ata/pata_cs5536.c
index 73f8332cb67..afed9297619 100644
--- a/drivers/ata/pata_cs5536.c
+++ b/drivers/ata/pata_cs5536.c
@@ -110,7 +110,6 @@ static inline int cs5536_write(struct pci_dev *pdev, int reg, int val)
 /**
  *      cs5536_cable_detect     -       detect cable type
  *      @ap: Port to detect on
- *      @deadline: deadline jiffies for the operation
  *
  *      Perform cable detection for ATA66 capable cable. Return a libata
  *      cable type.
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index 271cb64d429..64b2e2281ee 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -416,6 +416,7 @@ static struct pcmcia_device_id pcmcia_devices[] = {
         PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
         PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
         PCMCIA_MFC_DEVICE_PROD_ID12(1, "SanDisk", "ConnectPlus", 0x7a954bd9, 0x74be00c6),
+        PCMCIA_DEVICE_PROD_ID2("Flash Card", 0x5a362506),
         PCMCIA_DEVICE_NULL,
 };
 
diff --git a/drivers/ata/pata_sch.c b/drivers/ata/pata_sch.c
index c8cc027789f..6aeeeeb3412 100644
--- a/drivers/ata/pata_sch.c
+++ b/drivers/ata/pata_sch.c
@@ -83,7 +83,7 @@ static struct ata_port_operations sch_pata_ops = {
 };
 
 static struct ata_port_info sch_port_info = {
-        .flags          = 0,
+        .flags          = ATA_FLAG_SLAVE_POSS,
         .pio_mask       = ATA_PIO4,   /* pio0-4 */
         .mwdma_mask     = ATA_MWDMA2, /* mwdma0-2 */
         .udma_mask      = ATA_UDMA5,  /* udma0-5 */
diff --git a/drivers/dca/dca-core.c b/drivers/dca/dca-core.c
index ec249d2db63..d883e1b8bb8 100644
--- a/drivers/dca/dca-core.c
+++ b/drivers/dca/dca-core.c
@@ -270,6 +270,6 @@ static void __exit dca_exit(void)
         dca_sysfs_exit();
 }
 
-module_init(dca_init);
+subsys_initcall(dca_init);
 module_exit(dca_exit);
 
diff --git a/drivers/dma/ioat_dma.c b/drivers/dma/ioat_dma.c
index b0438c4f0c3..ecd743f7cc6 100644
--- a/drivers/dma/ioat_dma.c
+++ b/drivers/dma/ioat_dma.c
@@ -525,7 +525,7 @@ static dma_cookie_t ioat1_tx_submit(struct dma_async_tx_descriptor *tx)
         }
 
         hw->ctl = IOAT_DMA_DESCRIPTOR_CTL_CP_STS;
-        if (new->async_tx.callback) {
+        if (first->async_tx.callback) {
                 hw->ctl |= IOAT_DMA_DESCRIPTOR_CTL_INT_GN;
                 if (first != new) {
                         /* move callback into to last desc */
@@ -617,7 +617,7 @@ static dma_cookie_t ioat2_tx_submit(struct dma_async_tx_descriptor *tx)
         }
 
         hw->ctl |= IOAT_DMA_DESCRIPTOR_CTL_CP_STS;
-        if (new->async_tx.callback) {
+        if (first->async_tx.callback) {
                 hw->ctl |= IOAT_DMA_DESCRIPTOR_CTL_INT_GN;
                 if (first != new) {
                         /* move callback into to last desc */
@@ -807,6 +807,12 @@ static void ioat_dma_free_chan_resources(struct dma_chan *chan)
         struct ioat_desc_sw *desc, *_desc;
         int in_use_descs = 0;
 
+        /* Before freeing channel resources first check
+         * if they have been previously allocated for this channel.
+         */
+        if (ioat_chan->desccount == 0)
+                return;
+
         tasklet_disable(&ioat_chan->cleanup_task);
         ioat_dma_memcpy_cleanup(ioat_chan);
 
@@ -869,6 +875,7 @@ static void ioat_dma_free_chan_resources(struct dma_chan *chan)
         ioat_chan->last_completion = ioat_chan->completion_addr = 0;
         ioat_chan->pending = 0;
         ioat_chan->dmacount = 0;
+        ioat_chan->desccount = 0;
         ioat_chan->watchdog_completion = 0;
         ioat_chan->last_compl_desc_addr_hw = 0;
         ioat_chan->watchdog_tcp_cookie =
diff --git a/drivers/dma/iovlock.c b/drivers/dma/iovlock.c
index e763d723e4c..9f6fe46a9b8 100644
--- a/drivers/dma/iovlock.c
+++ b/drivers/dma/iovlock.c
@@ -55,7 +55,6 @@ struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len)
         int nr_iovecs = 0;
         int iovec_len_used = 0;
         int iovec_pages_used = 0;
-        long err;
 
         /* don't pin down non-user-based iovecs */
         if (segment_eq(get_fs(), KERNEL_DS))
@@ -72,23 +71,21 @@ struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len)
         local_list = kmalloc(sizeof(*local_list)
                 + (nr_iovecs * sizeof (struct dma_page_list))
                 + (iovec_pages_used * sizeof (struct page*)), GFP_KERNEL);
-        if (!local_list) {
-                err = -ENOMEM;
+        if (!local_list)
                 goto out;
-        }
 
         /* list of pages starts right after the page list array */
         pages = (struct page **) &local_list->page_list[nr_iovecs];
 
+        local_list->nr_iovecs = 0;
+
         for (i = 0; i < nr_iovecs; i++) {
                 struct dma_page_list *page_list = &local_list->page_list[i];
 
                 len -= iov[i].iov_len;
 
-                if (!access_ok(VERIFY_WRITE, iov[i].iov_base, iov[i].iov_len)) {
-                        err = -EFAULT;
+                if (!access_ok(VERIFY_WRITE, iov[i].iov_base, iov[i].iov_len))
                         goto unpin;
-                }
 
                 page_list->nr_pages = num_pages_spanned(&iov[i]);
                 page_list->base_address = iov[i].iov_base;
@@ -109,10 +106,8 @@ struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len)
                         NULL);
                 up_read(&current->mm->mmap_sem);
 
-                if (ret != page_list->nr_pages) {
-                        err = -ENOMEM;
+                if (ret != page_list->nr_pages)
                         goto unpin;
-                }
 
                 local_list->nr_iovecs = i + 1;
         }
@@ -122,7 +117,7 @@ struct dma_pinned_list *dma_pin_iovec_pages(struct iovec *iov, size_t len)
 unpin:
         dma_unpin_iovec_pages(local_list);
 out:
-        return ERR_PTR(err);
+        return NULL;
 }
 
 void dma_unpin_iovec_pages(struct dma_pinned_list *pinned_list)
diff --git a/drivers/gpu/drm/drm_drv.c b/drivers/gpu/drm/drm_drv.c
index 96f416afc3f..3ab1e9cc469 100644
--- a/drivers/gpu/drm/drm_drv.c
+++ b/drivers/gpu/drm/drm_drv.c
@@ -266,11 +266,19 @@ int drm_init(struct drm_driver *driver)
         for (i = 0; driver->pci_driver.id_table[i].vendor != 0; i++) {
                 pid = (struct pci_device_id *)&driver->pci_driver.id_table[i];
 
+                /* Loop around setting up a DRM device for each PCI device
+                 * matching our ID and device class.  If we had the internal
+                 * function that pci_get_subsys and pci_get_class used, we'd
+                 * be able to just pass pid in instead of doing a two-stage
+                 * thing.
+                 */
                 pdev = NULL;
-                /* pass back in pdev to account for multiple identical cards */
                 while ((pdev =
                         pci_get_subsys(pid->vendor, pid->device, pid->subvendor,
                                        pid->subdevice, pdev)) != NULL) {
+                        if ((pdev->class & pid->class_mask) != pid->class)
+                                continue;
+
                         /* stealth mode requires a manual probe */
                         pci_dev_get(pdev);
                         drm_get_dev(pdev, pid, driver);
diff --git a/drivers/gpu/drm/drm_irq.c b/drivers/gpu/drm/drm_irq.c
index 212a94f715b..15c8dabc3e9 100644
--- a/drivers/gpu/drm/drm_irq.c
+++ b/drivers/gpu/drm/drm_irq.c
@@ -280,8 +280,6 @@ int drm_irq_uninstall(struct drm_device * dev)
 
         drm_vblank_cleanup(dev);
 
-        dev->locked_tasklet_func = NULL;
-
         return 0;
 }
 EXPORT_SYMBOL(drm_irq_uninstall);
@@ -699,81 +697,3 @@ void drm_handle_vblank(struct drm_device *dev, int crtc)
         drm_vbl_send_signals(dev, crtc);
 }
 EXPORT_SYMBOL(drm_handle_vblank);
-
-/**
- * Tasklet wrapper function.
- *
- * \param data DRM device in disguise.
- *
- * Attempts to grab the HW lock and calls the driver callback on success. On
- * failure, leave the lock marked as contended so the callback can be called
- * from drm_unlock().
- */
-static void drm_locked_tasklet_func(unsigned long data)
-{
-        struct drm_device *dev = (struct drm_device *)data;
-        unsigned long irqflags;
-        void (*tasklet_func)(struct drm_device *);
-        
-        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
-        tasklet_func = dev->locked_tasklet_func;
-        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-
-        if (!tasklet_func ||
-            !drm_lock_take(&dev->lock,
-                           DRM_KERNEL_CONTEXT)) {
-                return;
-        }
-
-        dev->lock.lock_time = jiffies;
-        atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
-
-        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
-        tasklet_func = dev->locked_tasklet_func;
-        dev->locked_tasklet_func = NULL;
-        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-        
-        if (tasklet_func != NULL)
-                tasklet_func(dev);
-
-        drm_lock_free(&dev->lock,
-                      DRM_KERNEL_CONTEXT);
-}
-
-/**
- * Schedule a tasklet to call back a driver hook with the HW lock held.
- *
- * \param dev DRM device.
- * \param func Driver callback.
- *
- * This is intended for triggering actions that require the HW lock from an
- * interrupt handler. The lock will be grabbed ASAP after the interrupt handler
- * completes. Note that the callback may be called from interrupt or process
- * context, it must not make any assumptions about this. Also, the HW lock will
- * be held with the kernel context or any client context.
- */
-void drm_locked_tasklet(struct drm_device *dev, void (*func)(struct drm_device *))
-{
-        unsigned long irqflags;
-        static DECLARE_TASKLET(drm_tasklet, drm_locked_tasklet_func, 0);
-
-        if (!drm_core_check_feature(dev, DRIVER_HAVE_IRQ) ||
-            test_bit(TASKLET_STATE_SCHED, &drm_tasklet.state))
-                return;
-
-        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
-
-        if (dev->locked_tasklet_func) {
-                spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-                return;
-        }
-
-        dev->locked_tasklet_func = func;
-
-        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-
-        drm_tasklet.data = (unsigned long)dev;
-
-        tasklet_hi_schedule(&drm_tasklet);
-}
-EXPORT_SYMBOL(drm_locked_tasklet);
diff --git a/drivers/gpu/drm/drm_lock.c b/drivers/gpu/drm/drm_lock.c
index 888159e03d2..1cfa72031f8 100644
--- a/drivers/gpu/drm/drm_lock.c
+++ b/drivers/gpu/drm/drm_lock.c
@@ -154,8 +154,6 @@ int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
 int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
 {
         struct drm_lock *lock = data;
-        unsigned long irqflags;
-        void (*tasklet_func)(struct drm_device *);
 
         if (lock->context == DRM_KERNEL_CONTEXT) {
                 DRM_ERROR("Process %d using kernel context %d\n",
@@ -163,13 +161,6 @@ int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
                 return -EINVAL;
         }
 
-        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
-        tasklet_func = dev->locked_tasklet_func;
-        dev->locked_tasklet_func = NULL;
-        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-        if (tasklet_func != NULL)
-                tasklet_func(dev);
-
         atomic_inc(&dev->counts[_DRM_STAT_UNLOCKS]);
 
         /* kernel_context_switch isn't used by any of the x86 drm
diff --git a/drivers/gpu/drm/drm_stub.c b/drivers/gpu/drm/drm_stub.c
index 141e33004a7..66c96ec6667 100644
--- a/drivers/gpu/drm/drm_stub.c
+++ b/drivers/gpu/drm/drm_stub.c
@@ -92,7 +92,6 @@ static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
 
         spin_lock_init(&dev->count_lock);
         spin_lock_init(&dev->drw_lock);
-        spin_lock_init(&dev->tasklet_lock);
         spin_lock_init(&dev->lock.spinlock);
         init_timer(&dev->timer);
         mutex_init(&dev->struct_mutex);
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index 256e22963ae..0d215e38606 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -154,6 +154,9 @@ static int i915_dma_cleanup(struct drm_device * dev)
         if (I915_NEED_GFX_HWS(dev))
                 i915_free_hws(dev);
 
+        dev_priv->sarea = NULL;
+        dev_priv->sarea_priv = NULL;
+
         return 0;
 }
 
@@ -442,7 +445,7 @@ static void i915_emit_breadcrumb(struct drm_device *dev)
 
         BEGIN_LP_RING(4);
         OUT_RING(MI_STORE_DWORD_INDEX);
-        OUT_RING(5 << MI_STORE_DWORD_INDEX_SHIFT);
+        OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
         OUT_RING(dev_priv->counter);
         OUT_RING(0);
         ADVANCE_LP_RING();
@@ -573,7 +576,7 @@ static int i915_dispatch_flip(struct drm_device * dev)
 
         BEGIN_LP_RING(4);
         OUT_RING(MI_STORE_DWORD_INDEX);
-        OUT_RING(5 << MI_STORE_DWORD_INDEX_SHIFT);
+        OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
         OUT_RING(dev_priv->counter);
         OUT_RING(0);
         ADVANCE_LP_RING();
@@ -608,7 +611,6 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
                             struct drm_file *file_priv)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u32 *hw_status = dev_priv->hw_status_page;
         drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
             dev_priv->sarea_priv;
         drm_i915_batchbuffer_t *batch = data;
@@ -634,7 +636,7 @@ static int i915_batchbuffer(struct drm_device *dev, void *data,
         mutex_unlock(&dev->struct_mutex);
 
         if (sarea_priv)
-                sarea_priv->last_dispatch = (int)hw_status[5];
+                sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
         return ret;
 }
 
@@ -642,7 +644,6 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
                           struct drm_file *file_priv)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        u32 *hw_status = dev_priv->hw_status_page;
         drm_i915_sarea_t *sarea_priv = (drm_i915_sarea_t *)
             dev_priv->sarea_priv;
         drm_i915_cmdbuffer_t *cmdbuf = data;
@@ -670,7 +671,7 @@ static int i915_cmdbuffer(struct drm_device *dev, void *data,
         }
 
         if (sarea_priv)
-                sarea_priv->last_dispatch = (int)hw_status[5];
+                sarea_priv->last_dispatch = READ_BREADCRUMB(dev_priv);
         return 0;
 }
 
@@ -849,8 +850,7 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
          * be lost or delayed
          */
         if (!IS_I945G(dev) && !IS_I945GM(dev) && !IS_I965GM(dev))
-                if (pci_enable_msi(dev->pdev))
-                        DRM_ERROR("failed to enable MSI\n");
+                pci_enable_msi(dev->pdev);
 
         intel_opregion_init(dev);
 
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 572dcd0e3e0..ef1c0b8f8d0 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -88,13 +88,6 @@ struct mem_block {
         struct drm_file *file_priv; /* NULL: free, -1: heap, other: real files */
 };
 
-typedef struct _drm_i915_vbl_swap {
-        struct list_head head;
-        drm_drawable_t drw_id;
-        unsigned int pipe;
-        unsigned int sequence;
-} drm_i915_vbl_swap_t;
-
 struct opregion_header;
 struct opregion_acpi;
 struct opregion_swsci;
@@ -146,10 +139,6 @@ typedef struct drm_i915_private {
         unsigned int sr01, adpa, ppcr, dvob, dvoc, lvds;
         int vblank_pipe;
 
-        spinlock_t swaps_lock;
-        drm_i915_vbl_swap_t vbl_swaps;
-        unsigned int swaps_pending;
-
         struct intel_opregion opregion;
 
         /* Register state */
@@ -157,6 +146,7 @@ typedef struct drm_i915_private {
         u32 saveDSPACNTR;
         u32 saveDSPBCNTR;
         u32 saveDSPARB;
+        u32 saveRENDERSTANDBY;
         u32 savePIPEACONF;
         u32 savePIPEBCONF;
         u32 savePIPEASRC;
@@ -241,9 +231,6 @@ typedef struct drm_i915_private {
         u8 saveDACDATA[256*3]; /* 256 3-byte colors */
         u8 saveCR[37];
 
-        /** Work task for vblank-related ring access */
-        struct work_struct vblank_work;
-
         struct {
                 struct drm_mm gtt_space;
 
@@ -444,7 +431,6 @@ extern int i915_irq_wait(struct drm_device *dev, void *data,
 void i915_user_irq_get(struct drm_device *dev);
 void i915_user_irq_put(struct drm_device *dev);
 
-extern void i915_vblank_work_handler(struct work_struct *work);
 extern irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS);
 extern void i915_driver_irq_preinstall(struct drm_device * dev);
 extern int i915_driver_irq_postinstall(struct drm_device *dev);
@@ -622,8 +608,9 @@ static inline void opregion_enable_asle(struct drm_device *dev) { return; }
  * The area from dword 0x20 to 0x3ff is available for driver usage.
  */
 #define READ_HWSP(dev_priv, reg)  (((volatile u32*)(dev_priv->hw_status_page))[reg])
-#define READ_BREADCRUMB(dev_priv) READ_HWSP(dev_priv, 5)
+#define READ_BREADCRUMB(dev_priv) READ_HWSP(dev_priv, I915_BREADCRUMB_INDEX)
 #define I915_GEM_HWS_INDEX              0x20
+#define I915_BREADCRUMB_INDEX           0x21
 
 extern int i915_wait_ring(struct drm_device * dev, int n, const char *caller);
 
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index b0ec73fa6a9..6b4a2bd2064 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -1455,11 +1455,9 @@ i915_gem_object_set_domain_range(struct drm_gem_object *obj,
                                                   read_domains, write_domain);
 
         /* Wait on any GPU rendering to the object to be flushed. */
-        if (obj->write_domain & ~(I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT)) {
-                ret = i915_gem_object_wait_rendering(obj);
-                if (ret)
-                        return ret;
-        }
+        ret = i915_gem_object_wait_rendering(obj);
+        if (ret)
+                return ret;
 
         if (obj_priv->page_cpu_valid == NULL) {
                 obj_priv->page_cpu_valid = drm_calloc(1, obj->size / PAGE_SIZE,
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 26f48932a51..82752d6177a 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -80,211 +80,6 @@ i915_pipe_enabled(struct drm_device *dev, int pipe)
         return 0;
 }
 
-/**
- * Emit blits for scheduled buffer swaps.
- *
- * This function will be called with the HW lock held.
- * Because this function must grab the ring mutex (dev->struct_mutex),
- * it can no longer run at soft irq time. We'll fix this when we do
- * the DRI2 swap buffer work.
- */
-static void i915_vblank_tasklet(struct drm_device *dev)
-{
-        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
-        unsigned long irqflags;
-        struct list_head *list, *tmp, hits, *hit;
-        int nhits, nrects, slice[2], upper[2], lower[2], i;
-        unsigned counter[2];
-        struct drm_drawable_info *drw;
-        drm_i915_sarea_t *sarea_priv = dev_priv->sarea_priv;
-        u32 cpp = dev_priv->cpp;
-        u32 cmd = (cpp == 4) ? (XY_SRC_COPY_BLT_CMD |
-                                XY_SRC_COPY_BLT_WRITE_ALPHA |
-                                XY_SRC_COPY_BLT_WRITE_RGB)
-                             : XY_SRC_COPY_BLT_CMD;
-        u32 src_pitch = sarea_priv->pitch * cpp;
-        u32 dst_pitch = sarea_priv->pitch * cpp;
-        u32 ropcpp = (0xcc << 16) | ((cpp - 1) << 24);
-        RING_LOCALS;
-
-        mutex_lock(&dev->struct_mutex);
-
-        if (IS_I965G(dev) && sarea_priv->front_tiled) {
-                cmd |= XY_SRC_COPY_BLT_DST_TILED;
-                dst_pitch >>= 2;
-        }
-        if (IS_I965G(dev) && sarea_priv->back_tiled) {
-                cmd |= XY_SRC_COPY_BLT_SRC_TILED;
-                src_pitch >>= 2;
-        }
-
-        counter[0] = drm_vblank_count(dev, 0);
-        counter[1] = drm_vblank_count(dev, 1);
-
-        DRM_DEBUG("\n");
-
-        INIT_LIST_HEAD(&hits);
-
-        nhits = nrects = 0;
-
-        spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
-
-        /* Find buffer swaps scheduled for this vertical blank */
-        list_for_each_safe(list, tmp, &dev_priv->vbl_swaps.head) {
-                drm_i915_vbl_swap_t *vbl_swap =
-                        list_entry(list, drm_i915_vbl_swap_t, head);
-                int pipe = vbl_swap->pipe;
-
-                if ((counter[pipe] - vbl_swap->sequence) > (1<<23))
-                        continue;
-
-                list_del(list);
-                dev_priv->swaps_pending--;
-                drm_vblank_put(dev, pipe);
-
-                spin_unlock(&dev_priv->swaps_lock);
-                spin_lock(&dev->drw_lock);
-
-                drw = drm_get_drawable_info(dev, vbl_swap->drw_id);
-
-                list_for_each(hit, &hits) {
-                        drm_i915_vbl_swap_t *swap_cmp =
-                                list_entry(hit, drm_i915_vbl_swap_t, head);
-                        struct drm_drawable_info *drw_cmp =
-                                drm_get_drawable_info(dev, swap_cmp->drw_id);
-
-                        /* Make sure both drawables are still
-                         * around and have some rectangles before
-                         * we look inside to order them for the
-                         * blts below.
-                         */
-                        if (drw_cmp && drw_cmp->num_rects > 0 &&
-                            drw && drw->num_rects > 0 &&
-                            drw_cmp->rects[0].y1 > drw->rects[0].y1) {
-                                list_add_tail(list, hit);
-                                break;
-                        }
-                }
-
-                spin_unlock(&dev->drw_lock);
-
-                /* List of hits was empty, or we reached the end of it */
-                if (hit == &hits)
-                        list_add_tail(list, hits.prev);
-
-                nhits++;
-
-                spin_lock(&dev_priv->swaps_lock);
-        }
-
-        if (nhits == 0) {
-                spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
-                mutex_unlock(&dev->struct_mutex);
-                return;
-        }
-
-        spin_unlock(&dev_priv->swaps_lock);
-
-        i915_kernel_lost_context(dev);
-
-        if (IS_I965G(dev)) {
-                BEGIN_LP_RING(4);
-
-                OUT_RING(GFX_OP_DRAWRECT_INFO_I965);
-                OUT_RING(0);
-                OUT_RING(((sarea_priv->width - 1) & 0xffff) | ((sarea_priv->height - 1) << 16));
-                OUT_RING(0);
-                ADVANCE_LP_RING();
-        } else {
-                BEGIN_LP_RING(6);
-
-                OUT_RING(GFX_OP_DRAWRECT_INFO);
-                OUT_RING(0);
-                OUT_RING(0);
-                OUT_RING(sarea_priv->width | sarea_priv->height << 16);
-                OUT_RING(sarea_priv->width | sarea_priv->height << 16);
-                OUT_RING(0);
-
-                ADVANCE_LP_RING();
-        }
-
-        sarea_priv->ctxOwner = DRM_KERNEL_CONTEXT;
-
-        upper[0] = upper[1] = 0;
-        slice[0] = max(sarea_priv->pipeA_h / nhits, 1);
-        slice[1] = max(sarea_priv->pipeB_h / nhits, 1);
-        lower[0] = sarea_priv->pipeA_y + slice[0];
-        lower[1] = sarea_priv->pipeB_y + slice[0];
-
-        spin_lock(&dev->drw_lock);
-
-        /* Emit blits for buffer swaps, partitioning both outputs into as many
-         * slices as there are buffer swaps scheduled in order to avoid tearing
-         * (based on the assumption that a single buffer swap would always
-         * complete before scanout starts).
-         */
-        for (i = 0; i++ < nhits;
-             upper[0] = lower[0], lower[0] += slice[0],
-             upper[1] = lower[1], lower[1] += slice[1]) {
-                if (i == nhits)
-                        lower[0] = lower[1] = sarea_priv->height;
-
-                list_for_each(hit, &hits) {
-                        drm_i915_vbl_swap_t *swap_hit =
-                                list_entry(hit, drm_i915_vbl_swap_t, head);
-                        struct drm_clip_rect *rect;
-                        int num_rects, pipe;
-                        unsigned short top, bottom;
-
-                        drw = drm_get_drawable_info(dev, swap_hit->drw_id);
-
-                        /* The drawable may have been destroyed since
-                         * the vblank swap was queued
-                         */
-                        if (!drw)
-                                continue;
-
-                        rect = drw->rects;
-                        pipe = swap_hit->pipe;
-                        top = upper[pipe];
-                        bottom = lower[pipe];
-
-                        for (num_rects = drw->num_rects; num_rects--; rect++) {
-                                int y1 = max(rect->y1, top);
-                                int y2 = min(rect->y2, bottom);
-
-                                if (y1 >= y2)
-                                        continue;
-
-                                BEGIN_LP_RING(8);
-
-                                OUT_RING(cmd);
-                                OUT_RING(ropcpp | dst_pitch);
-                                OUT_RING((y1 << 16) | rect->x1);
-                                OUT_RING((y2 << 16) | rect->x2);
-                                OUT_RING(sarea_priv->front_offset);
-                                OUT_RING((y1 << 16) | rect->x1);
-                                OUT_RING(src_pitch);
-                                OUT_RING(sarea_priv->back_offset);
-
-                                ADVANCE_LP_RING();
-                        }
-                }
-        }
-
-        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
-        mutex_unlock(&dev->struct_mutex);
-
-        list_for_each_safe(hit, tmp, &hits) {
-                drm_i915_vbl_swap_t *swap_hit =
-                        list_entry(hit, drm_i915_vbl_swap_t, head);
-
-                list_del(hit);
-
-                drm_free(swap_hit, sizeof(*swap_hit), DRM_MEM_DRIVER);
-        }
-}
-
 /* Called from drm generic code, passed a 'crtc', which
  * we use as a pipe index
  */
@@ -322,40 +117,6 @@ u32 i915_get_vblank_counter(struct drm_device *dev, int pipe)
         return count;
 }
 
-void
-i915_vblank_work_handler(struct work_struct *work)
-{
-        drm_i915_private_t *dev_priv = container_of(work, drm_i915_private_t,
-                                                    vblank_work);
-        struct drm_device *dev = dev_priv->dev;
-        unsigned long irqflags;
-
-        if (dev->lock.hw_lock == NULL) {
-                i915_vblank_tasklet(dev);
-                return;
-        }
-
-        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
-        dev->locked_tasklet_func = i915_vblank_tasklet;
-        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-
-        /* Try to get the lock now, if this fails, the lock
-         * holder will execute the tasklet during unlock
-         */
-        if (!drm_lock_take(&dev->lock, DRM_KERNEL_CONTEXT))
-                return;
-
-        dev->lock.lock_time = jiffies;
-        atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
-
-        spin_lock_irqsave(&dev->tasklet_lock, irqflags);
-        dev->locked_tasklet_func = NULL;
-        spin_unlock_irqrestore(&dev->tasklet_lock, irqflags);
-
-        i915_vblank_tasklet(dev);
-        drm_lock_free(&dev->lock, DRM_KERNEL_CONTEXT);
-}
-
 irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
 {
         struct drm_device *dev = (struct drm_device *) arg;
@@ -433,9 +194,6 @@ irqreturn_t i915_driver_irq_handler(DRM_IRQ_ARGS)
         if (iir & I915_ASLE_INTERRUPT)
                 opregion_asle_intr(dev);
 
-        if (vblank && dev_priv->swaps_pending > 0)
-                schedule_work(&dev_priv->vblank_work);
-
         return IRQ_HANDLED;
 }
 
@@ -454,12 +212,10 @@ static int i915_emit_irq(struct drm_device * dev)
         if (dev_priv->sarea_priv)
                 dev_priv->sarea_priv->last_enqueue = dev_priv->counter;
 
-        BEGIN_LP_RING(6);
+        BEGIN_LP_RING(4);
         OUT_RING(MI_STORE_DWORD_INDEX);
-        OUT_RING(5 << MI_STORE_DWORD_INDEX_SHIFT);
+        OUT_RING(I915_BREADCRUMB_INDEX << MI_STORE_DWORD_INDEX_SHIFT);
         OUT_RING(dev_priv->counter);
-        OUT_RING(0);
-        OUT_RING(0);
         OUT_RING(MI_USER_INTERRUPT);
         ADVANCE_LP_RING();
 
@@ -696,123 +452,21 @@ int i915_vblank_pipe_get(struct drm_device *dev, void *data,
 int i915_vblank_swap(struct drm_device *dev, void *data,
                      struct drm_file *file_priv)
 {
-        drm_i915_private_t *dev_priv = dev->dev_private;
-        drm_i915_vblank_swap_t *swap = data;
-        drm_i915_vbl_swap_t *vbl_swap, *vbl_old;
-        unsigned int pipe, seqtype, curseq;
-        unsigned long irqflags;
-        struct list_head *list;
-        int ret;
-
-        if (!dev_priv || !dev_priv->sarea_priv) {
-                DRM_ERROR("%s called with no initialization\n", __func__);
-                return -EINVAL;
-        }
-
-        if (dev_priv->sarea_priv->rotation) {
-                DRM_DEBUG("Rotation not supported\n");
-                return -EINVAL;
-        }
-
-        if (swap->seqtype & ~(_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE |
-                             _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)) {
-                DRM_ERROR("Invalid sequence type 0x%x\n", swap->seqtype);
-                return -EINVAL;
-        }
-
-        pipe = (swap->seqtype & _DRM_VBLANK_SECONDARY) ? 1 : 0;
-
-        seqtype = swap->seqtype & (_DRM_VBLANK_RELATIVE | _DRM_VBLANK_ABSOLUTE);
-
-        if (!(dev_priv->vblank_pipe & (1 << pipe))) {
-                DRM_ERROR("Invalid pipe %d\n", pipe);
-                return -EINVAL;
-        }
-
-        spin_lock_irqsave(&dev->drw_lock, irqflags);
-
-        if (!drm_get_drawable_info(dev, swap->drawable)) {
-                spin_unlock_irqrestore(&dev->drw_lock, irqflags);
-                DRM_DEBUG("Invalid drawable ID %d\n", swap->drawable);
-                return -EINVAL;
-        }
-
-        spin_unlock_irqrestore(&dev->drw_lock, irqflags);
-
-        /*
-         * We take the ref here and put it when the swap actually completes
-         * in the tasklet.
+        /* The delayed swap mechanism was fundamentally racy, and has been
+         * removed.  The model was that the client requested a delayed flip/swap
+         * from the kernel, then waited for vblank before continuing to perform
+         * rendering.  The problem was that the kernel might wake the client
+         * up before it dispatched the vblank swap (since the lock has to be
+         * held while touching the ringbuffer), in which case the client would
+         * clear and start the next frame before the swap occurred, and
+         * flicker would occur in addition to likely missing the vblank.
+         *
+         * In the absence of this ioctl, userland falls back to a correct path
+         * of waiting for a vblank, then dispatching the swap on its own.
+         * Context switching to userland and back is plenty fast enough for
+         * meeting the requirements of vblank swapping.
          */
-        ret = drm_vblank_get(dev, pipe);
-        if (ret)
-                return ret;
-        curseq = drm_vblank_count(dev, pipe);
-
-        if (seqtype == _DRM_VBLANK_RELATIVE)
-                swap->sequence += curseq;
-
-        if ((curseq - swap->sequence) <= (1<<23)) {
-                if (swap->seqtype & _DRM_VBLANK_NEXTONMISS) {
-                        swap->sequence = curseq + 1;
-                } else {
-                        DRM_DEBUG("Missed target sequence\n");
-                        drm_vblank_put(dev, pipe);
-                        return -EINVAL;
-                }
-        }
-
-        vbl_swap = drm_calloc(1, sizeof(*vbl_swap), DRM_MEM_DRIVER);
-
-        if (!vbl_swap) {
-                DRM_ERROR("Failed to allocate memory to queue swap\n");
-                drm_vblank_put(dev, pipe);
-                return -ENOMEM;
-        }
-
-        vbl_swap->drw_id = swap->drawable;
-        vbl_swap->pipe = pipe;
-        vbl_swap->sequence = swap->sequence;
-
-        spin_lock_irqsave(&dev_priv->swaps_lock, irqflags);
-
-        list_for_each(list, &dev_priv->vbl_swaps.head) {
-                vbl_old = list_entry(list, drm_i915_vbl_swap_t, head);
-
-                if (vbl_old->drw_id == swap->drawable &&
-                    vbl_old->pipe == pipe &&
-                    vbl_old->sequence == swap->sequence) {
-                        spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
-                        drm_vblank_put(dev, pipe);
-                        drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
-                        DRM_DEBUG("Already scheduled\n");
-                        return 0;
-                }
-        }
-
-        if (dev_priv->swaps_pending >= 10) {
-                DRM_DEBUG("Too many swaps queued\n");
-                DRM_DEBUG(" pipe 0: %d pipe 1: %d\n",
-                          drm_vblank_count(dev, 0),
-                          drm_vblank_count(dev, 1));
-
-                list_for_each(list, &dev_priv->vbl_swaps.head) {
-                        vbl_old = list_entry(list, drm_i915_vbl_swap_t, head);
-                        DRM_DEBUG("\tdrw %x pipe %d seq %x\n",
-                                  vbl_old->drw_id, vbl_old->pipe,
-                                  vbl_old->sequence);
-                }
-                spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
-                drm_vblank_put(dev, pipe);
-                drm_free(vbl_swap, sizeof(*vbl_swap), DRM_MEM_DRIVER);
-                return -EBUSY;
-        }
-
-        list_add_tail(&vbl_swap->head, &dev_priv->vbl_swaps.head);
-        dev_priv->swaps_pending++;
-
-        spin_unlock_irqrestore(&dev_priv->swaps_lock, irqflags);
-
-        return 0;
+        return -EINVAL;
 }
 
 /* drm_dma.h hooks
@@ -831,11 +485,6 @@ int i915_driver_irq_postinstall(struct drm_device *dev)
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
         int ret, num_pipes = 2;
 
-        spin_lock_init(&dev_priv->swaps_lock);
-        INIT_LIST_HEAD(&dev_priv->vbl_swaps.head);
-        INIT_WORK(&dev_priv->vblank_work, i915_vblank_work_handler);
-        dev_priv->swaps_pending = 0;
-
         /* Set initial unmasked IRQs to just the selected vblank pipes. */
         dev_priv->irq_mask_reg = ~0;
 
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index 5c2d9f206d0..0e476eba36e 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -527,6 +527,9 @@
 #define C0DRB3                  0x10206
 #define C1DRB3                  0x10606
 
+/** GM965 GM45 render standby register */
+#define MCHBAR_RENDER_STANDBY   0x111B8
+
 /*
  * Overlay regs
  */
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index 603fe742ccd..5ddc6e595c0 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -240,6 +240,10 @@ int i915_save_state(struct drm_device *dev)
 
         pci_read_config_byte(dev->pdev, LBB, &dev_priv->saveLBB);
 
+        /* Render Standby */
+        if (IS_I965G(dev) && IS_MOBILE(dev))
+                dev_priv->saveRENDERSTANDBY = I915_READ(MCHBAR_RENDER_STANDBY);
+
         /* Display arbitration control */
         dev_priv->saveDSPARB = I915_READ(DSPARB);
 
@@ -365,6 +369,11 @@ int i915_restore_state(struct drm_device *dev)
 
         pci_write_config_byte(dev->pdev, LBB, dev_priv->saveLBB);
 
+        /* Render Standby */
+        if (IS_I965G(dev) && IS_MOBILE(dev))
+                I915_WRITE(MCHBAR_RENDER_STANDBY, dev_priv->saveRENDERSTANDBY);
+
+        /* Display arbitration */
         I915_WRITE(DSPARB, dev_priv->saveDSPARB);
 
         /* Pipe & plane A info */
diff --git a/drivers/gpu/drm/radeon/radeon_cp.c b/drivers/gpu/drm/radeon/radeon_cp.c
index 073894824e6..abdc1ae3846 100644
--- a/drivers/gpu/drm/radeon/radeon_cp.c
+++ b/drivers/gpu/drm/radeon/radeon_cp.c
@@ -1751,6 +1751,12 @@ int radeon_driver_load(struct drm_device *dev, unsigned long flags)
         else
                 dev_priv->flags |= RADEON_IS_PCI;
 
+        ret = drm_addmap(dev, drm_get_resource_start(dev, 2),
+                         drm_get_resource_len(dev, 2), _DRM_REGISTERS,
+                         _DRM_READ_ONLY | _DRM_DRIVER, &dev_priv->mmio);
+        if (ret != 0)
+                return ret;
+
         DRM_DEBUG("%s card detected\n",
                   ((dev_priv->flags & RADEON_IS_AGP) ? "AGP" : (((dev_priv->flags & RADEON_IS_PCIE) ? "PCIE" : "PCI"))));
         return ret;
@@ -1767,12 +1773,6 @@ int radeon_driver_firstopen(struct drm_device *dev)
 
         dev_priv->gart_info.table_size = RADEON_PCIGART_TABLE_SIZE;
 
-        ret = drm_addmap(dev, drm_get_resource_start(dev, 2),
-                         drm_get_resource_len(dev, 2), _DRM_REGISTERS,
-                         _DRM_READ_ONLY, &dev_priv->mmio);
-        if (ret != 0)
-                return ret;
-
         dev_priv->fb_aper_offset = drm_get_resource_start(dev, 0);
         ret = drm_addmap(dev, dev_priv->fb_aper_offset,
                          drm_get_resource_len(dev, 0), _DRM_FRAME_BUFFER,
@@ -1788,6 +1788,9 @@ int radeon_driver_unload(struct drm_device *dev)
         drm_radeon_private_t *dev_priv = dev->dev_private;
 
         DRM_DEBUG("\n");
+
+        drm_rmmap(dev, dev_priv->mmio);
+
         drm_free(dev_priv, sizeof(*dev_priv), DRM_MEM_DRIVER);
 
         dev->dev_private = NULL;
diff --git a/drivers/gpu/drm/radeon/radeon_drv.h b/drivers/gpu/drm/radeon/radeon_drv.h
index 02f5575ba39..7a183789be9 100644
--- a/drivers/gpu/drm/radeon/radeon_drv.h
+++ b/drivers/gpu/drm/radeon/radeon_drv.h
@@ -287,7 +287,6 @@ typedef struct drm_radeon_private {
         unsigned long gart_textures_offset;
 
         drm_local_map_t *sarea;
-        drm_local_map_t *mmio;
         drm_local_map_t *cp_ring;
         drm_local_map_t *ring_rptr;
         drm_local_map_t *gart_textures;
@@ -318,6 +317,7 @@ typedef struct drm_radeon_private {
 
         int num_gb_pipes;
         int track_flush;
+        drm_local_map_t *mmio;
 } drm_radeon_private_t;
 
 typedef struct drm_radeon_buf_priv {
diff --git a/drivers/net/mlx4/en_netdev.c b/drivers/net/mlx4/en_netdev.c
index a339afbeed3..a3f732418c4 100644
--- a/drivers/net/mlx4/en_netdev.c
+++ b/drivers/net/mlx4/en_netdev.c
@@ -706,7 +706,7 @@ tx_err:
         mlx4_en_release_rss_steer(priv);
 rx_err:
         for (i = 0; i < priv->rx_ring_num; i++)
-                mlx4_en_deactivate_rx_ring(priv, &priv->rx_ring[rx_index]);
+                mlx4_en_deactivate_rx_ring(priv, &priv->rx_ring[i]);
 cq_err:
         while (rx_index--)
                 mlx4_en_deactivate_cq(priv, &priv->rx_cq[rx_index]);
diff --git a/drivers/net/sfc/ethtool.c b/drivers/net/sfc/ethtool.c
index fa98af58223..cd0d0873d97 100644
--- a/drivers/net/sfc/ethtool.c
+++ b/drivers/net/sfc/ethtool.c
@@ -174,8 +174,8 @@ static struct efx_ethtool_stat efx_ethtool_stats[] = {
 
 /* EEPROM range with gPXE configuration */
 #define EFX_ETHTOOL_EEPROM_MAGIC 0xEFAB
-#define EFX_ETHTOOL_EEPROM_MIN 0x100U
-#define EFX_ETHTOOL_EEPROM_MAX 0x400U
+#define EFX_ETHTOOL_EEPROM_MIN 0x800U
+#define EFX_ETHTOOL_EEPROM_MAX 0x1800U
 
 /**************************************************************************
  *
diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c
index 1164c52e2c0..8e90891f0e4 100644
--- a/drivers/net/usb/hso.c
+++ b/drivers/net/usb/hso.c
@@ -2184,19 +2184,20 @@ static void hso_create_rfkill(struct hso_device *hso_dev,
                              struct usb_interface *interface)
 {
         struct hso_net *hso_net = dev2net(hso_dev);
-        struct device *dev = hso_dev->dev;
+        struct device *dev = &hso_net->net->dev;
         char *rfkn;
 
         hso_net->rfkill = rfkill_allocate(&interface_to_usbdev(interface)->dev,
-                                 RFKILL_TYPE_WLAN);
+                                 RFKILL_TYPE_WWAN);
         if (!hso_net->rfkill) {
-                dev_err(dev, "%s - Out of memory", __func__);
+                dev_err(dev, "%s - Out of memory\n", __func__);
                 return;
         }
         rfkn = kzalloc(20, GFP_KERNEL);
         if (!rfkn) {
                 rfkill_free(hso_net->rfkill);
-                dev_err(dev, "%s - Out of memory", __func__);
+                hso_net->rfkill = NULL;
+                dev_err(dev, "%s - Out of memory\n", __func__);
                 return;
         }
         snprintf(rfkn, 20, "hso-%d",
@@ -2209,7 +2210,8 @@ static void hso_create_rfkill(struct hso_device *hso_dev,
                 kfree(rfkn);
                 hso_net->rfkill->name = NULL;
                 rfkill_free(hso_net->rfkill);
-                dev_err(dev, "%s - Failed to register rfkill", __func__);
+                hso_net->rfkill = NULL;
+                dev_err(dev, "%s - Failed to register rfkill\n", __func__);
                 return;
         }
 }
diff --git a/drivers/ssb/Kconfig b/drivers/ssb/Kconfig
index 307b1f62d94..b1b947edcf0 100644
--- a/drivers/ssb/Kconfig
+++ b/drivers/ssb/Kconfig
@@ -1,10 +1,11 @@
-menu "Sonics Silicon Backplane"
-
 config SSB_POSSIBLE
         bool
         depends on HAS_IOMEM && HAS_DMA
         default y
 
+menu "Sonics Silicon Backplane"
+        depends on SSB_POSSIBLE
+
 config SSB
         tristate "Sonics Silicon Backplane support"
         depends on SSB_POSSIBLE
diff --git a/drivers/watchdog/booke_wdt.c b/drivers/watchdog/booke_wdt.c
index c3b78a76f17..225398fd504 100644
--- a/drivers/watchdog/booke_wdt.c
+++ b/drivers/watchdog/booke_wdt.c
@@ -42,8 +42,10 @@ u32 booke_wdt_period = WDT_PERIOD_DEFAULT;
 
 #ifdef  CONFIG_FSL_BOOKE
 #define WDTP(x)         ((((63-x)&0x3)<<30)|(((63-x)&0x3c)<<15))
+#define WDTP_MASK       (WDTP(0))
 #else
 #define WDTP(x)         (TCR_WP(x))
+#define WDTP_MASK       (TCR_WP_MASK)
 #endif
 
 static DEFINE_SPINLOCK(booke_wdt_lock);
@@ -65,6 +67,7 @@ static void __booke_wdt_enable(void *data)
         /* clear status before enabling watchdog */
         __booke_wdt_ping(NULL);
         val = mfspr(SPRN_TCR);
+        val &= ~WDTP_MASK;
         val |= (TCR_WIE|TCR_WRC(WRC_CHIP)|WDTP(booke_wdt_period));
 
         mtspr(SPRN_TCR, val);
@@ -114,7 +117,7 @@ static long booke_wdt_ioctl(struct file *file,
         case WDIOC_SETTIMEOUT:
                 if (get_user(booke_wdt_period, p))
                         return -EFAULT;
-                mtspr(SPRN_TCR, (mfspr(SPRN_TCR) & ~WDTP(0)) |
+                mtspr(SPRN_TCR, (mfspr(SPRN_TCR) & ~WDTP_MASK) |
                                                 WDTP(booke_wdt_period));
                 return 0;
         case WDIOC_GETTIMEOUT: