18 files changed, 260 insertions, 161 deletions
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 6978469eb16d..17ee6ed985d9 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -49,6 +49,10 @@
 #define DRV_NAME        "ahci"
 #define DRV_VERSION     "3.0"
+static int ahci_skip_host_reset;
+module_param_named(skip_host_reset, ahci_skip_host_reset, int, 0444);
+MODULE_PARM_DESC(skip_host_reset, "skip global host reset (0=don't skip, 1=skip)");
 static int ahci_enable_alpm(struct ata_port *ap,
                enum link_pm policy);
 static void ahci_disable_alpm(struct ata_port *ap);
@@ -587,6 +591,7 @@ static const struct pci_device_id ahci_pci_tbl[] = {
        /* Marvell */
        { PCI_VDEVICE(MARVELL, 0x6145), board_ahci_mv },        /* 6145 */
+        { PCI_VDEVICE(MARVELL, 0x6121), board_ahci_mv },        /* 6121 */
        /* Generic, PCI class code for AHCI */
        { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID,
@@ -661,6 +666,7 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
        void __iomem *mmio = pcim_iomap_table(pdev)[AHCI_PCI_BAR];
        u32 cap, port_map;
        int i;
+        int mv;
        /* make sure AHCI mode is enabled before accessing CAP */
        ahci_enable_ahci(mmio);
@@ -696,12 +702,16 @@ static void ahci_save_initial_config(struct pci_dev *pdev,
         * presence register, as bit 4 (counting from 0)
         */
        if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
+                if (pdev->device == 0x6121)
+                        mv = 0x3;
+                else
+                        mv = 0xf;
                dev_printk(KERN_ERR, &pdev->dev,
                           "MV_AHCI HACK: port_map %x -> %x\n",
-                           hpriv->port_map,
+                           port_map,
-                           hpriv->port_map & 0xf);
+                           port_map & mv);
-                port_map &= 0xf;
+                port_map &= mv;
        }
        /* cross check port_map and cap.n_ports */
@@ -1088,29 +1098,35 @@ static int ahci_reset_controller(struct ata_host *host)
        ahci_enable_ahci(mmio);
        /* global controller reset */
-        tmp = readl(mmio + HOST_CTL);
+        if (!ahci_skip_host_reset) {
-        if ((tmp & HOST_RESET) == 0) {
+                tmp = readl(mmio + HOST_CTL);
-                writel(tmp | HOST_RESET, mmio + HOST_CTL);
+                if ((tmp & HOST_RESET) == 0) {
-                readl(mmio + HOST_CTL); /* flush */
+                        writel(tmp | HOST_RESET, mmio + HOST_CTL);
-        }
+                        readl(mmio + HOST_CTL); /* flush */
+                }
-        /* reset must complete within 1 second, or
+                /* reset must complete within 1 second, or
-         * the hardware should be considered fried.
+                 * the hardware should be considered fried.
-         */
+                 */
-        ssleep(1);
+                ssleep(1);
-        tmp = readl(mmio + HOST_CTL);
+                tmp = readl(mmio + HOST_CTL);
-        if (tmp & HOST_RESET) {
+                if (tmp & HOST_RESET) {
-                dev_printk(KERN_ERR, host->dev,
+                        dev_printk(KERN_ERR, host->dev,
-                           "controller reset failed (0x%x)\n", tmp);
+                                   "controller reset failed (0x%x)\n", tmp);
-                return -EIO;
+                        return -EIO;
-        }
+                }
-        /* turn on AHCI mode */
+                /* turn on AHCI mode */
-        ahci_enable_ahci(mmio);
+                ahci_enable_ahci(mmio);
-        /* some registers might be cleared on reset.  restore initial values */
+                /* Some registers might be cleared on reset.  Restore
-        ahci_restore_initial_config(host);
+                 * initial values.
+                 */
+                ahci_restore_initial_config(host);
+        } else
+                dev_printk(KERN_INFO, host->dev,
+                           "skipping global host reset\n");
        if (pdev->vendor == PCI_VENDOR_ID_INTEL) {
                u16 tmp16;
@@ -1162,9 +1178,14 @@ static void ahci_init_controller(struct ata_host *host)
        int i;
        void __iomem *port_mmio;
        u32 tmp;
+        int mv;
        if (hpriv->flags & AHCI_HFLAG_MV_PATA) {
-                port_mmio = __ahci_port_base(host, 4);
+                if (pdev->device == 0x6121)
+                        mv = 2;
+                else
+                        mv = 4;
+                port_mmio = __ahci_port_base(host, mv);
                writel(0, port_mmio + PORT_IRQ_MASK);
@@ -2241,7 +2262,10 @@ static int ahci_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (rc)
                return rc;
-        rc = pcim_iomap_regions(pdev, 1 << AHCI_PCI_BAR, DRV_NAME);
+        /* AHCI controllers often implement SFF compatible interface.
+         * Grab all PCI BARs just in case.
+         */
+        rc = pcim_iomap_regions_request_all(pdev, 1 << AHCI_PCI_BAR, DRV_NAME);
        if (rc == -EBUSY)
                pcim_pin_device(pdev);
        if (rc)
diff --git a/drivers/ata/libata-acpi.c b/drivers/ata/libata-acpi.c
index 0770cb7391a4..bf98a566adac 100644
--- a/drivers/ata/libata-acpi.c
+++ b/drivers/ata/libata-acpi.c
@@ -118,45 +118,77 @@ static void ata_acpi_associate_ide_port(struct ata_port *ap)
                ap->pflags |= ATA_PFLAG_INIT_GTM_VALID;
 }
-static void ata_acpi_handle_hotplug(struct ata_port *ap, struct kobject *kobj,
+static void ata_acpi_handle_hotplug(struct ata_port *ap, struct ata_device *dev,
                                    u32 event)
 {
        char event_string[12];
        char *envp[] = { event_string, NULL };
-        struct ata_eh_info *ehi = &ap->link.eh_info;
+        struct ata_eh_info *ehi;
+        struct kobject *kobj = NULL;
-        if (event == 0 || event == 1) {
+        int wait = 0;
-               unsigned long flags;
+        unsigned long flags;
-               spin_lock_irqsave(ap->lock, flags);
-               ata_ehi_clear_desc(ehi);
+        if (!ap)
-               ata_ehi_push_desc(ehi, "ACPI event");
+                ap = dev->link->ap;
-               ata_ehi_hotplugged(ehi);
+        ehi = &ap->link.eh_info;
-               ata_port_freeze(ap);
-               spin_unlock_irqrestore(ap->lock, flags);
+        spin_lock_irqsave(ap->lock, flags);
+        switch (event) {
+        case ACPI_NOTIFY_BUS_CHECK:
+        case ACPI_NOTIFY_DEVICE_CHECK:
+                ata_ehi_push_desc(ehi, "ACPI event");
+                ata_ehi_hotplugged(ehi);
+                ata_port_freeze(ap);
+                break;
+        case ACPI_NOTIFY_EJECT_REQUEST:
+                ata_ehi_push_desc(ehi, "ACPI event");
+                if (dev)
+                        dev->flags |= ATA_DFLAG_DETACH;
+                else {
+                        struct ata_link *tlink;
+                        struct ata_device *tdev;
+                        ata_port_for_each_link(tlink, ap)
+                                ata_link_for_each_dev(tdev, tlink)
+                                        tdev->flags |= ATA_DFLAG_DETACH;
+                }
+                ata_port_schedule_eh(ap);
+                wait = 1;
+                break;
        }
+        if (dev) {
+                if (dev->sdev)
+                        kobj = &dev->sdev->sdev_gendev.kobj;
+        } else
+                kobj = &ap->dev->kobj;
        if (kobj) {
                sprintf(event_string, "BAY_EVENT=%d", event);
                kobject_uevent_env(kobj, KOBJ_CHANGE, envp);
        }
+        spin_unlock_irqrestore(ap->lock, flags);
+        if (wait)
+                ata_port_wait_eh(ap);
 }
 static void ata_acpi_dev_notify(acpi_handle handle, u32 event, void *data)
 {
        struct ata_device *dev = data;
-        struct kobject *kobj = NULL;
-        if (dev->sdev)
+        ata_acpi_handle_hotplug(NULL, dev, event);
-                kobj = &dev->sdev->sdev_gendev.kobj;
-        ata_acpi_handle_hotplug(dev->link->ap, kobj, event);
 }
 static void ata_acpi_ap_notify(acpi_handle handle, u32 event, void *data)
 {
        struct ata_port *ap = data;
-        ata_acpi_handle_hotplug(ap, &ap->dev->kobj, event);
+        ata_acpi_handle_hotplug(ap, NULL, event);
 }
 /**
@@ -191,20 +223,30 @@ void ata_acpi_associate(struct ata_host *host)
                else
                        ata_acpi_associate_ide_port(ap);
-                if (ap->acpi_handle)
+                if (ap->acpi_handle) {
-                        acpi_install_notify_handler (ap->acpi_handle,
+                        acpi_install_notify_handler(ap->acpi_handle,
-                                                     ACPI_SYSTEM_NOTIFY,
+                                                    ACPI_SYSTEM_NOTIFY,
-                                                     ata_acpi_ap_notify,
+                                                    ata_acpi_ap_notify, ap);
-                                                     ap);
+#if defined(CONFIG_ACPI_DOCK) || defined(CONFIG_ACPI_DOCK_MODULE)
+                        /* we might be on a docking station */
+                        register_hotplug_dock_device(ap->acpi_handle,
+                                                     ata_acpi_ap_notify, ap);
+#endif
+                }
                for (j = 0; j < ata_link_max_devices(&ap->link); j++) {
                        struct ata_device *dev = &ap->link.device[j];
-                        if (dev->acpi_handle)
+                        if (dev->acpi_handle) {
-                                acpi_install_notify_handler (dev->acpi_handle,
+                                acpi_install_notify_handler(dev->acpi_handle,
-                                                             ACPI_SYSTEM_NOTIFY,
+                                                ACPI_SYSTEM_NOTIFY,
-                                                             ata_acpi_dev_notify,
+                                                ata_acpi_dev_notify, dev);
-                                                             dev);
+#if defined(CONFIG_ACPI_DOCK) || defined(CONFIG_ACPI_DOCK_MODULE)
+                                /* we might be on a docking station */
+                                register_hotplug_dock_device(dev->acpi_handle,
+                                                ata_acpi_dev_notify, dev);
+#endif
+                        }
                }
        }
 }
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index 7e68edf3c0f3..8786455c901d 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -295,7 +295,7 @@ static void ali_lock_sectors(struct ata_device *adev)
 static int ali_check_atapi_dma(struct ata_queued_cmd *qc)
 {
        /* If its not a media command, its not worth it */
-        if (qc->nbytes < 2048)
+        if (atapi_cmd_type(qc->cdb[0]) == ATAPI_MISC)
                return -EOPNOTSUPP;
        return 0;
 }
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 3b1a68d6eddb..0cfbe8c594a5 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -238,6 +238,7 @@ static int virtblk_probe(struct virtio_device *vdev)
        vblk->disk->first_minor = index_to_minor(index);
        vblk->disk->private_data = vblk;
        vblk->disk->fops = &virtblk_fops;
+        vblk->disk->driverfs_dev = &vdev->dev;
        index++;
        /* If barriers are supported, tell block layer that queue is ordered */
diff --git a/drivers/char/drm/ati_pcigart.c b/drivers/char/drm/ati_pcigart.c
index d352dbb4ccf7..e5a0e97cfdda 100644
--- a/drivers/char/drm/ati_pcigart.c
+++ b/drivers/char/drm/ati_pcigart.c
@@ -35,42 +35,23 @@
 # define ATI_PCIGART_PAGE_SIZE          4096    /**< PCI GART page size */
-static void *drm_ati_alloc_pcigart_table(int order)
+static int drm_ati_alloc_pcigart_table(struct drm_device *dev,
+                                       struct drm_ati_pcigart_info *gart_info)
 {
-        unsigned long address;
+        gart_info->table_handle = drm_pci_alloc(dev, gart_info->table_size,
-        struct page *page;
+                                                PAGE_SIZE,
-        int i;
+                                                gart_info->table_mask);
+        if (gart_info->table_handle == NULL)
-        DRM_DEBUG("%d order\n", order);
+                return -ENOMEM;
-        address = __get_free_pages(GFP_KERNEL | __GFP_COMP,
-                                   order);
-        if (address == 0UL) {
-                return NULL;
-        }
-        page = virt_to_page(address);
-        for (i = 0; i < order; i++, page++)
+        return 0;
-                SetPageReserved(page);
-        DRM_DEBUG("returning 0x%08lx\n", address);
-        return (void *)address;
 }
-static void drm_ati_free_pcigart_table(void *address, int order)
+static void drm_ati_free_pcigart_table(struct drm_device *dev,
+                                       struct drm_ati_pcigart_info *gart_info)
 {
-        struct page *page;
+        drm_pci_free(dev, gart_info->table_handle);
-        int i;
+        gart_info->table_handle = NULL;
-        int num_pages = 1 << order;
-        DRM_DEBUG("\n");
-        page = virt_to_page((unsigned long)address);
-        for (i = 0; i < num_pages; i++, page++)
-                ClearPageReserved(page);
-        free_pages((unsigned long)address, order);
 }
 int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info *gart_info)
@@ -78,8 +59,7 @@ int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info
        struct drm_sg_mem *entry = dev->sg;
        unsigned long pages;
        int i;
-        int order;
+        int max_pages;
-        int num_pages, max_pages;
        /* we need to support large memory configurations */
        if (!entry) {
@@ -87,15 +67,7 @@ int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info
                return 0;
        }
-        order = drm_order((gart_info->table_size + (PAGE_SIZE-1)) / PAGE_SIZE);
-        num_pages = 1 << order;
        if (gart_info->bus_addr) {
-                if (gart_info->gart_table_location == DRM_ATI_GART_MAIN) {
-                        pci_unmap_single(dev->pdev, gart_info->bus_addr,
-                                         num_pages * PAGE_SIZE,
-                                         PCI_DMA_TODEVICE);
-                }
                max_pages = (gart_info->table_size / sizeof(u32));
                pages = (entry->pages <= max_pages)
@@ -112,10 +84,9 @@ int drm_ati_pcigart_cleanup(struct drm_device *dev, struct drm_ati_pcigart_info
                        gart_info->bus_addr = 0;
        }
-        if (gart_info->gart_table_location == DRM_ATI_GART_MAIN
+        if (gart_info->gart_table_location == DRM_ATI_GART_MAIN &&
-            && gart_info->addr) {
+            gart_info->table_handle) {
-                drm_ati_free_pcigart_table(gart_info->addr, order);
+                drm_ati_free_pcigart_table(dev, gart_info);
-                gart_info->addr = NULL;
        }
        return 1;
@@ -127,11 +98,10 @@ int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *ga
        struct drm_sg_mem *entry = dev->sg;
        void *address = NULL;
        unsigned long pages;
-        u32 *pci_gart, page_base, bus_address = 0;
+        u32 *pci_gart, page_base;
+        dma_addr_t bus_address = 0;
        int i, j, ret = 0;
-        int order;
        int max_pages;
-        int num_pages;
        if (!entry) {
                DRM_ERROR("no scatter/gather memory!\n");
@@ -141,31 +111,14 @@ int drm_ati_pcigart_init(struct drm_device *dev, struct drm_ati_pcigart_info *ga
        if (gart_info->gart_table_location == DRM_ATI_GART_MAIN) {
                DRM_DEBUG("PCI: no table in VRAM: using normal RAM\n");
-                order = drm_order((gart_info->table_size +
+                ret = drm_ati_alloc_pcigart_table(dev, gart_info);
-                                   (PAGE_SIZE-1)) / PAGE_SIZE);
+                if (ret) {
-                num_pages = 1 << order;
-                address = drm_ati_alloc_pcigart_table(order);
-                if (!address) {
                        DRM_ERROR("cannot allocate PCI GART page!\n");
                        goto done;
                }
-                if (!dev->pdev) {
+                address = gart_info->table_handle->vaddr;
-                        DRM_ERROR("PCI device unknown!\n");
+                bus_address = gart_info->table_handle->busaddr;
-                        goto done;
-                }
-                bus_address = pci_map_single(dev->pdev, address,
-                                             num_pages * PAGE_SIZE,
-                                             PCI_DMA_TODEVICE);
-                if (bus_address == 0) {
-                        DRM_ERROR("unable to map PCIGART pages!\n");
-                        order = drm_order((gart_info->table_size +
-                                           (PAGE_SIZE-1)) / PAGE_SIZE);
-                        drm_ati_free_pcigart_table(address, order);
-                        address = NULL;
-                        goto done;
-                }
        } else {
                address = gart_info->addr;
                bus_address = gart_info->bus_addr;
diff --git a/drivers/char/drm/drmP.h b/drivers/char/drm/drmP.h
index a6789f25009b..8ea9dd1717a9 100644
--- a/drivers/char/drm/drmP.h
+++ b/drivers/char/drm/drmP.h
@@ -54,6 +54,7 @@
 #include <linux/pci.h>
 #include <linux/jiffies.h>
 #include <linux/smp_lock.h>     /* For (un)lock_kernel */
+#include <linux/dma-mapping.h>
 #include <linux/mm.h>
 #include <linux/cdev.h>
 #include <linux/mutex.h>
@@ -551,6 +552,8 @@ struct drm_ati_pcigart_info {
        int gart_reg_if;
        void *addr;
        dma_addr_t bus_addr;
+        dma_addr_t table_mask;
+        struct drm_dma_handle *table_handle;
        drm_local_map_t mapping;
        int table_size;
 };
diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 3992f73299cc..f09d4b5002b0 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -326,6 +326,7 @@ int drm_release(struct inode *inode, struct file *filp)
        struct drm_file *file_priv = filp->private_data;
        struct drm_device *dev = file_priv->head->dev;
        int retcode = 0;
+        unsigned long irqflags;
        lock_kernel();
@@ -357,9 +358,11 @@ int drm_release(struct inode *inode, struct file *filp)
                         */
                        do{
-                                spin_lock(&dev->lock.spinlock);
+                                spin_lock_irqsave(&dev->lock.spinlock,
+                                                  irqflags);
                                locked = dev->lock.idle_has_lock;
-                                spin_unlock(&dev->lock.spinlock);
+                                spin_unlock_irqrestore(&dev->lock.spinlock,
+                                                       irqflags);
                                if (locked)
                                        break;
                                schedule();
diff --git a/drivers/char/drm/drm_lock.c b/drivers/char/drm/drm_lock.c
index bea2a7d5b2b2..12dcdd1832f0 100644
--- a/drivers/char/drm/drm_lock.c
+++ b/drivers/char/drm/drm_lock.c
@@ -53,6 +53,7 @@ int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
        DECLARE_WAITQUEUE(entry, current);
        struct drm_lock *lock = data;
        int ret = 0;
+        unsigned long irqflags;
        ++file_priv->lock_count;
@@ -71,9 +72,9 @@ int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
                        return -EINVAL;
        add_wait_queue(&dev->lock.lock_queue, &entry);
-        spin_lock(&dev->lock.spinlock);
+        spin_lock_irqsave(&dev->lock.spinlock, irqflags);
        dev->lock.user_waiters++;
-        spin_unlock(&dev->lock.spinlock);
+        spin_unlock_irqrestore(&dev->lock.spinlock, irqflags);
        for (;;) {
                __set_current_state(TASK_INTERRUPTIBLE);
                if (!dev->lock.hw_lock) {
@@ -95,9 +96,9 @@ int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv)
                        break;
                }
        }
-        spin_lock(&dev->lock.spinlock);
+        spin_lock_irqsave(&dev->lock.spinlock, irqflags);
        dev->lock.user_waiters--;
-        spin_unlock(&dev->lock.spinlock);
+        spin_unlock_irqrestore(&dev->lock.spinlock, irqflags);
        __set_current_state(TASK_RUNNING);
        remove_wait_queue(&dev->lock.lock_queue, &entry);
@@ -198,8 +199,9 @@ int drm_lock_take(struct drm_lock_data *lock_data,
 {
        unsigned int old, new, prev;
        volatile unsigned int *lock = &lock_data->hw_lock->lock;
+        unsigned long irqflags;
-        spin_lock(&lock_data->spinlock);
+        spin_lock_irqsave(&lock_data->spinlock, irqflags);
        do {
                old = *lock;
                if (old & _DRM_LOCK_HELD)
@@ -211,7 +213,7 @@ int drm_lock_take(struct drm_lock_data *lock_data,
                }
                prev = cmpxchg(lock, old, new);
        } while (prev != old);
-        spin_unlock(&lock_data->spinlock);
+        spin_unlock_irqrestore(&lock_data->spinlock, irqflags);
        if (_DRM_LOCKING_CONTEXT(old) == context) {
                if (old & _DRM_LOCK_HELD) {
@@ -272,15 +274,16 @@ int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context)
 {
        unsigned int old, new, prev;
        volatile unsigned int *lock = &lock_data->hw_lock->lock;
+        unsigned long irqflags;
-        spin_lock(&lock_data->spinlock);
+        spin_lock_irqsave(&lock_data->spinlock, irqflags);
        if (lock_data->kernel_waiters != 0) {
                drm_lock_transfer(lock_data, 0);
                lock_data->idle_has_lock = 1;
-                spin_unlock(&lock_data->spinlock);
+                spin_unlock_irqrestore(&lock_data->spinlock, irqflags);
                return 1;
        }
-        spin_unlock(&lock_data->spinlock);
+        spin_unlock_irqrestore(&lock_data->spinlock, irqflags);
        do {
                old = *lock;
@@ -344,19 +347,20 @@ static int drm_notifier(void *priv)
 void drm_idlelock_take(struct drm_lock_data *lock_data)
 {
        int ret = 0;
+        unsigned long irqflags;
-        spin_lock(&lock_data->spinlock);
+        spin_lock_irqsave(&lock_data->spinlock, irqflags);
        lock_data->kernel_waiters++;
        if (!lock_data->idle_has_lock) {
-                spin_unlock(&lock_data->spinlock);
+                spin_unlock_irqrestore(&lock_data->spinlock, irqflags);
                ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
-                spin_lock(&lock_data->spinlock);
+                spin_lock_irqsave(&lock_data->spinlock, irqflags);
                if (ret == 1)
                        lock_data->idle_has_lock = 1;
        }
-        spin_unlock(&lock_data->spinlock);
+        spin_unlock_irqrestore(&lock_data->spinlock, irqflags);
 }
 EXPORT_SYMBOL(drm_idlelock_take);
@@ -364,8 +368,9 @@ void drm_idlelock_release(struct drm_lock_data *lock_data)
 {
        unsigned int old, prev;
        volatile unsigned int *lock = &lock_data->hw_lock->lock;
+        unsigned long irqflags;
-        spin_lock(&lock_data->spinlock);
+        spin_lock_irqsave(&lock_data->spinlock, irqflags);
        if (--lock_data->kernel_waiters == 0) {
                if (lock_data->idle_has_lock) {
                        do {
@@ -376,7 +381,7 @@ void drm_idlelock_release(struct drm_lock_data *lock_data)
                        lock_data->idle_has_lock = 0;
                }
        }
-        spin_unlock(&lock_data->spinlock);
+        spin_unlock_irqrestore(&lock_data->spinlock, irqflags);
 }
 EXPORT_SYMBOL(drm_idlelock_release);
diff --git a/drivers/char/drm/drm_pciids.h b/drivers/char/drm/drm_pciids.h
index 715b361f0c2b..a6a499f97e22 100644
--- a/drivers/char/drm/drm_pciids.h
+++ b/drivers/char/drm/drm_pciids.h
@@ -205,9 +205,9 @@
        {0x1002, 0x71D6, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV530|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x71DA, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV530|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x71DE, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV530|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x7200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV530|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x7200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV515|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x7210, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV530|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x7210, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV515|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
-        {0x1002, 0x7211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV530|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x7211, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RV515|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x7240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R580|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x7243, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R580|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x7244, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_R580|RADEON_NEW_MEMMAP}, \
@@ -238,6 +238,7 @@
        {0x1002, 0x7834, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x7835, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS300|RADEON_IS_IGP|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
        {0x1002, 0x791e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS690|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \
+        {0x1002, 0x791f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_RS690|RADEON_IS_IGP|RADEON_NEW_MEMMAP|RADEON_IS_IGPGART}, \
        {0, 0, 0}
 #define r128_PCI_IDS \
diff --git a/drivers/char/drm/r128_cce.c b/drivers/char/drm/r128_cce.c
index 892e0a589846..f36adbd3aaf5 100644
--- a/drivers/char/drm/r128_cce.c
+++ b/drivers/char/drm/r128_cce.c
@@ -558,6 +558,7 @@ static int r128_do_init_cce(struct drm_device * dev, drm_r128_init_t * init)
 #if __OS_HAS_AGP
        if (dev_priv->is_pci) {
 #endif
+                dev_priv->gart_info.table_mask = DMA_BIT_MASK(32);
                dev_priv->gart_info.gart_table_location = DRM_ATI_GART_MAIN;
                dev_priv->gart_info.table_size = R128_PCIGART_TABLE_SIZE;
                dev_priv->gart_info.addr = NULL;
diff --git a/drivers/char/drm/radeon_cp.c b/drivers/char/drm/radeon_cp.c
index 833abc7e55fb..9072e4a1894e 100644
--- a/drivers/char/drm/radeon_cp.c
+++ b/drivers/char/drm/radeon_cp.c
@@ -1807,6 +1807,7 @@ static int radeon_do_init_cp(struct drm_device * dev, drm_radeon_init_t * init)
        } else
 #endif
        {
+                dev_priv->gart_info.table_mask = DMA_BIT_MASK(32);
                /* if we have an offset set from userspace */
                if (dev_priv->pcigart_offset_set) {
                        dev_priv->gart_info.bus_addr =
diff --git a/drivers/char/drm/via_dma.c b/drivers/char/drm/via_dma.c
index 94baec692b57..7a339dba6a69 100644
--- a/drivers/char/drm/via_dma.c
+++ b/drivers/char/drm/via_dma.c
@@ -126,6 +126,8 @@ via_cmdbuf_wait(drm_via_private_t * dev_priv, unsigned int size)
                             hw_addr, cur_addr, next_addr);
                        return -1;
                }
+                if  ((cur_addr < hw_addr) && (next_addr >= hw_addr))
+                        msleep(1);
        } while ((cur_addr < hw_addr) && (next_addr >= hw_addr));
        return 0;
 }
@@ -416,27 +418,50 @@ static int via_hook_segment(drm_via_private_t * dev_priv,
        int paused, count;
        volatile uint32_t *paused_at = dev_priv->last_pause_ptr;
        uint32_t reader,ptr;
+        uint32_t diff;
        paused = 0;
        via_flush_write_combine();
        (void) *(volatile uint32_t *)(via_get_dma(dev_priv) -1);
        *paused_at = pause_addr_lo;
        via_flush_write_combine();
        (void) *paused_at;
        reader = *(dev_priv->hw_addr_ptr);
        ptr = ((volatile char *)paused_at - dev_priv->dma_ptr) +
                dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr + 4;
        dev_priv->last_pause_ptr = via_get_dma(dev_priv) - 1;
-        if ((ptr - reader) <= dev_priv->dma_diff ) {
+        /*
-                count = 10000000;
+         * If there is a possibility that the command reader will 
-                while (!(paused = (VIA_READ(0x41c) & 0x80000000)) && count--);
+         * miss the new pause address and pause on the old one,
+         * In that case we need to program the new start address
+         * using PCI.
+         */
+        diff = (uint32_t) (ptr - reader) - dev_priv->dma_diff;
+        count = 10000000;
+        while(diff == 0 && count--) {
+                paused = (VIA_READ(0x41c) & 0x80000000);
+                if (paused) 
+                        break;
+                reader = *(dev_priv->hw_addr_ptr);
+                diff = (uint32_t) (ptr - reader) - dev_priv->dma_diff;
        }
+        paused = VIA_READ(0x41c) & 0x80000000;
        if (paused && !no_pci_fire) {
                reader = *(dev_priv->hw_addr_ptr);
-                if ((ptr - reader) == dev_priv->dma_diff) {
+                diff = (uint32_t) (ptr - reader) - dev_priv->dma_diff;
+                diff &= (dev_priv->dma_high - 1);
+                if (diff != 0 && diff < (dev_priv->dma_high >> 1)) {
+                        DRM_ERROR("Paused at incorrect address. "
+                                  "0x%08x, 0x%08x 0x%08x\n",
+                                  ptr, reader, dev_priv->dma_diff);
+                } else if (diff == 0) {
                        /*
                         * There is a concern that these writes may stall the PCI bus
                         * if the GPU is not idle. However, idling the GPU first
@@ -577,6 +602,7 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
        uint32_t pause_addr_lo, pause_addr_hi;
        uint32_t jump_addr_lo, jump_addr_hi;
        volatile uint32_t *last_pause_ptr;
+        uint32_t dma_low_save1, dma_low_save2;
        agp_base = dev_priv->dma_offset + (uint32_t) dev_priv->agpAddr;
        via_align_cmd(dev_priv, HC_HAGPBpID_JUMP, 0, &jump_addr_hi,
@@ -603,8 +629,29 @@ static void via_cmdbuf_jump(drm_via_private_t * dev_priv)
                      &pause_addr_lo, 0);
        *last_pause_ptr = pause_addr_lo;
+        dma_low_save1 = dev_priv->dma_low;
-        via_hook_segment( dev_priv, jump_addr_hi, jump_addr_lo, 0);
+        /*
+         * Now, set a trap that will pause the regulator if it tries to rerun the old
+         * command buffer. (Which may happen if via_hook_segment detecs a command regulator pause
+         * and reissues the jump command over PCI, while the regulator has already taken the jump
+         * and actually paused at the current buffer end).
+         * There appears to be no other way to detect this condition, since the hw_addr_pointer
+         * does not seem to get updated immediately when a jump occurs.
+         */
+        last_pause_ptr =
+                via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
+                              &pause_addr_lo, 0) - 1;
+        via_align_cmd(dev_priv, HC_HAGPBpID_PAUSE, 0, &pause_addr_hi,
+                      &pause_addr_lo, 0);
+        *last_pause_ptr = pause_addr_lo;
+        dma_low_save2 = dev_priv->dma_low;
+        dev_priv->dma_low = dma_low_save1;
+        via_hook_segment(dev_priv, jump_addr_hi, jump_addr_lo, 0);
+        dev_priv->dma_low = dma_low_save2;
+        via_hook_segment(dev_priv, pause_addr_hi, pause_addr_lo, 0);
 }
diff --git a/drivers/char/drm/via_dmablit.c b/drivers/char/drm/via_dmablit.c
index 33c5197b73c4..409e00afdd07 100644
--- a/drivers/char/drm/via_dmablit.c
+++ b/drivers/char/drm/via_dmablit.c
@@ -603,7 +603,7 @@ via_build_sg_info(struct drm_device *dev, drm_via_sg_info_t *vsg, drm_via_dmabli
         * (Not a big limitation anyway.)
         */
-        if ((xfer->mem_stride - xfer->line_length) >= PAGE_SIZE) {
+        if ((xfer->mem_stride - xfer->line_length) > 2*PAGE_SIZE) {
                DRM_ERROR("Too large system memory stride. Stride: %d, "
                          "Length: %d\n", xfer->mem_stride, xfer->line_length);
                return -EINVAL;
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 19fd4cb0ddf8..b58472cf76f8 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -203,8 +203,11 @@ again:
        if (received < budget) {
                netif_rx_complete(vi->dev, napi);
                if (unlikely(!vi->rvq->vq_ops->enable_cb(vi->rvq))
-                    && netif_rx_reschedule(vi->dev, napi))
+                    && napi_schedule_prep(napi)) {
+                        vi->rvq->vq_ops->disable_cb(vi->rvq);
+                        __netif_rx_schedule(vi->dev, napi);
                        goto again;
+                }
        }
        return received;
@@ -278,10 +281,11 @@ again:
                pr_debug("%s: virtio not prepared to send\n", dev->name);
                netif_stop_queue(dev);
-                /* Activate callback for using skbs: if this fails it
+                /* Activate callback for using skbs: if this returns false it
                 * means some were used in the meantime. */
                if (unlikely(!vi->svq->vq_ops->enable_cb(vi->svq))) {
-                        printk("Unlikely: restart svq failed\n");
+                        printk("Unlikely: restart svq race\n");
+                        vi->svq->vq_ops->disable_cb(vi->svq);
                        netif_start_queue(dev);
                        goto again;
                }
@@ -294,6 +298,15 @@ again:
        return 0;
 }
+#ifdef CONFIG_NET_POLL_CONTROLLER
+static void virtnet_netpoll(struct net_device *dev)
+{
+        struct virtnet_info *vi = netdev_priv(dev);
+        napi_schedule(&vi->napi);
+}
+#endif
 static int virtnet_open(struct net_device *dev)
 {
        struct virtnet_info *vi = netdev_priv(dev);
@@ -336,6 +349,9 @@ static int virtnet_probe(struct virtio_device *vdev)
        dev->stop = virtnet_close;
        dev->hard_start_xmit = start_xmit;
        dev->features = NETIF_F_HIGHDMA;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        dev->poll_controller = virtnet_netpoll;
+#endif
        SET_NETDEV_DEV(dev, &vdev->dev);
        /* Do we support "hardware" checksums? */
diff --git a/drivers/pci/hotplug/pciehp_core.c b/drivers/pci/hotplug/pciehp_core.c
index 7f4836b8e71e..5fa4ba0d9934 100644
--- a/drivers/pci/hotplug/pciehp_core.c
+++ b/drivers/pci/hotplug/pciehp_core.c
@@ -467,7 +467,7 @@ static int pciehp_probe(struct pcie_device *dev, const struct pcie_port_service_
        t_slot = pciehp_find_slot(ctrl, ctrl->slot_device_offset);
        t_slot->hpc_ops->get_adapter_status(t_slot, &value); /* Check if slot is occupied */
-        if (value) {
+        if (value && pciehp_force) {
                rc = pciehp_enable_slot(t_slot);
                if (rc) /* -ENODEV: shouldn't happen, but deal with it */
                        value = 0;
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index c8a4332d1132..0b3efc31ee6d 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -152,7 +152,7 @@ static void virtballoon_changed(struct virtio_device *vdev)
        wake_up(&vb->config_change);
 }
-static inline int towards_target(struct virtio_balloon *vb)
+static inline s64 towards_target(struct virtio_balloon *vb)
 {
        u32 v;
        __virtio_config_val(vb->vdev,
@@ -176,7 +176,7 @@ static int balloon(void *_vballoon)
        set_freezable();
        while (!kthread_should_stop()) {
-                int diff;
+                s64 diff;
                try_to_freeze();
                wait_event_interruptible(vb->config_change,
diff --git a/drivers/virtio/virtio_pci.c b/drivers/virtio/virtio_pci.c
index 26f787ddd5ff..59a8f73dec73 100644
--- a/drivers/virtio/virtio_pci.c
+++ b/drivers/virtio/virtio_pci.c
@@ -177,6 +177,7 @@ static irqreturn_t vp_interrupt(int irq, void *opaque)
        struct virtio_pci_device *vp_dev = opaque;
        struct virtio_pci_vq_info *info;
        irqreturn_t ret = IRQ_NONE;
+        unsigned long flags;
        u8 isr;
        /* reading the ISR has the effect of also clearing it so it's very
@@ -197,12 +198,12 @@ static irqreturn_t vp_interrupt(int irq, void *opaque)
                        drv->config_changed(&vp_dev->vdev);
        }
-        spin_lock(&vp_dev->lock);
+        spin_lock_irqsave(&vp_dev->lock, flags);
        list_for_each_entry(info, &vp_dev->virtqueues, node) {
                if (vring_interrupt(irq, info->vq) == IRQ_HANDLED)
                        ret = IRQ_HANDLED;
        }
-        spin_unlock(&vp_dev->lock);
+        spin_unlock_irqrestore(&vp_dev->lock, flags);
        return ret;
 }
@@ -214,6 +215,7 @@ static struct virtqueue *vp_find_vq(struct virtio_device *vdev, unsigned index,
        struct virtio_pci_device *vp_dev = to_vp_device(vdev);
        struct virtio_pci_vq_info *info;
        struct virtqueue *vq;
+        unsigned long flags;
        u16 num;
        int err;
@@ -255,9 +257,9 @@ static struct virtqueue *vp_find_vq(struct virtio_device *vdev, unsigned index,
        vq->priv = info;
        info->vq = vq;
-        spin_lock(&vp_dev->lock);
+        spin_lock_irqsave(&vp_dev->lock, flags);
        list_add(&info->node, &vp_dev->virtqueues);
-        spin_unlock(&vp_dev->lock);
+        spin_unlock_irqrestore(&vp_dev->lock, flags);
        return vq;
@@ -274,10 +276,11 @@ static void vp_del_vq(struct virtqueue *vq)
 {
        struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
        struct virtio_pci_vq_info *info = vq->priv;
+        unsigned long flags;
-        spin_lock(&vp_dev->lock);
+        spin_lock_irqsave(&vp_dev->lock, flags);
        list_del(&info->node);
-        spin_unlock(&vp_dev->lock);
+        spin_unlock_irqrestore(&vp_dev->lock, flags);
        vring_del_virtqueue(vq);
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 3a28c1382131..aa714028641e 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -232,7 +232,6 @@ static bool vring_enable_cb(struct virtqueue *_vq)
        vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
        mb();
        if (unlikely(more_used(vq))) {
-                vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
                END_USE(vq);
                return false;
        }