97 files changed, 3308 insertions, 2204 deletions
diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
index 1aabc81d82f..54e1f38ce30 100644
--- a/drivers/ata/ahci.c
+++ b/drivers/ata/ahci.c
@@ -299,76 +299,46 @@ static const struct ata_port_info ahci_port_info[] = {
 static const struct pci_device_id ahci_pci_tbl[] = {
        /* Intel */
-        { PCI_VENDOR_ID_INTEL, 0x2652, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x2652), board_ahci }, /* ICH6 */
-          board_ahci }, /* ICH6 */
+        { PCI_VDEVICE(INTEL, 0x2653), board_ahci }, /* ICH6M */
-        { PCI_VENDOR_ID_INTEL, 0x2653, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x27c1), board_ahci }, /* ICH7 */
-          board_ahci }, /* ICH6M */
+        { PCI_VDEVICE(INTEL, 0x27c5), board_ahci }, /* ICH7M */
-        { PCI_VENDOR_ID_INTEL, 0x27c1, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x27c3), board_ahci }, /* ICH7R */
-          board_ahci }, /* ICH7 */
+        { PCI_VDEVICE(AL, 0x5288), board_ahci }, /* ULi M5288 */
-        { PCI_VENDOR_ID_INTEL, 0x27c5, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x2681), board_ahci }, /* ESB2 */
-          board_ahci }, /* ICH7M */
+        { PCI_VDEVICE(INTEL, 0x2682), board_ahci }, /* ESB2 */
-        { PCI_VENDOR_ID_INTEL, 0x27c3, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x2683), board_ahci }, /* ESB2 */
-          board_ahci }, /* ICH7R */
+        { PCI_VDEVICE(INTEL, 0x27c6), board_ahci }, /* ICH7-M DH */
-        { PCI_VENDOR_ID_AL, 0x5288, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x2821), board_ahci }, /* ICH8 */
-          board_ahci }, /* ULi M5288 */
+        { PCI_VDEVICE(INTEL, 0x2822), board_ahci }, /* ICH8 */
-        { PCI_VENDOR_ID_INTEL, 0x2681, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x2824), board_ahci }, /* ICH8 */
-          board_ahci }, /* ESB2 */
+        { PCI_VDEVICE(INTEL, 0x2829), board_ahci }, /* ICH8M */
-        { PCI_VENDOR_ID_INTEL, 0x2682, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(INTEL, 0x282a), board_ahci }, /* ICH8M */
-          board_ahci }, /* ESB2 */
-        { PCI_VENDOR_ID_INTEL, 0x2683, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ESB2 */
-        { PCI_VENDOR_ID_INTEL, 0x27c6, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ICH7-M DH */
-        { PCI_VENDOR_ID_INTEL, 0x2821, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ICH8 */
-        { PCI_VENDOR_ID_INTEL, 0x2822, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ICH8 */
-        { PCI_VENDOR_ID_INTEL, 0x2824, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ICH8 */
-        { PCI_VENDOR_ID_INTEL, 0x2829, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ICH8M */
-        { PCI_VENDOR_ID_INTEL, 0x282a, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ICH8M */
        /* JMicron */
-        { 0x197b, 0x2360, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(JMICRON, 0x2360), board_ahci }, /* JMicron JMB360 */
-          board_ahci }, /* JMicron JMB360 */
+        { PCI_VDEVICE(JMICRON, 0x2361), board_ahci }, /* JMicron JMB361 */
-        { 0x197b, 0x2361, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(JMICRON, 0x2363), board_ahci }, /* JMicron JMB363 */
-          board_ahci }, /* JMicron JMB361 */
+        { PCI_VDEVICE(JMICRON, 0x2365), board_ahci }, /* JMicron JMB365 */
-        { 0x197b, 0x2363, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(JMICRON, 0x2366), board_ahci }, /* JMicron JMB366 */
-          board_ahci }, /* JMicron JMB363 */
-        { 0x197b, 0x2365, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* JMicron JMB365 */
-        { 0x197b, 0x2366, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* JMicron JMB366 */
        /* ATI */
-        { PCI_VENDOR_ID_ATI, 0x4380, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(ATI, 0x4380), board_ahci }, /* ATI SB600 non-raid */
-          board_ahci }, /* ATI SB600 non-raid */
+        { PCI_VDEVICE(ATI, 0x4381), board_ahci }, /* ATI SB600 raid */
-        { PCI_VENDOR_ID_ATI, 0x4381, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* ATI SB600 raid */
        /* VIA */
-        { PCI_VENDOR_ID_VIA, 0x3349, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(VIA, 0x3349), board_ahci_vt8251 }, /* VIA VT8251 */
-          board_ahci_vt8251 }, /* VIA VT8251 */
        /* NVIDIA */
-        { PCI_VENDOR_ID_NVIDIA, 0x044c, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(NVIDIA, 0x044c), board_ahci },            /* MCP65 */
-          board_ahci },         /* MCP65 */
+        { PCI_VDEVICE(NVIDIA, 0x044d), board_ahci },            /* MCP65 */
-        { PCI_VENDOR_ID_NVIDIA, 0x044d, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(NVIDIA, 0x044e), board_ahci },            /* MCP65 */
-          board_ahci },         /* MCP65 */
+        { PCI_VDEVICE(NVIDIA, 0x044f), board_ahci },            /* MCP65 */
-        { PCI_VENDOR_ID_NVIDIA, 0x044e, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci },         /* MCP65 */
-        { PCI_VENDOR_ID_NVIDIA, 0x044f, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci },         /* MCP65 */
        /* SiS */
-        { PCI_VENDOR_ID_SI, 0x1184, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(SI, 0x1184), board_ahci }, /* SiS 966 */
-          board_ahci }, /* SiS 966 */
+        { PCI_VDEVICE(SI, 0x1185), board_ahci }, /* SiS 966 */
-        { PCI_VENDOR_ID_SI, 0x1185, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(SI, 0x0186), board_ahci }, /* SiS 968 */
-          board_ahci }, /* SiS 966 */
-        { PCI_VENDOR_ID_SI, 0x0186, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_ahci }, /* SiS 968 */
        { }     /* terminate list */
 };
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index b4abd685036..dce65651d85 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -2340,7 +2340,8 @@ unsigned int ata_busy_sleep (struct ata_port *ap,
        if (status & ATA_BUSY)
                ata_port_printk(ap, KERN_WARNING,
-                                "port is slow to respond, please be patient\n");
+                                "port is slow to respond, please be patient "
+                                "(Status 0x%x)\n", status);
        timeout = timer_start + tmout;
        while ((status & ATA_BUSY) && (time_before(jiffies, timeout))) {
@@ -2350,7 +2351,8 @@ unsigned int ata_busy_sleep (struct ata_port *ap,
        if (status & ATA_BUSY) {
                ata_port_printk(ap, KERN_ERR, "port failed to respond "
-                                "(%lu secs)\n", tmout / HZ);
+                                "(%lu secs, Status 0x%x)\n",
+                                tmout / HZ, status);
                return 1;
        }
@@ -5478,11 +5480,10 @@ int ata_device_add(const struct ata_probe_ent *ent)
                int irq_line = ent->irq;
                ap = ata_port_add(ent, host, i);
+                host->ports[i] = ap;
                if (!ap)
                        goto err_out;
-                host->ports[i] = ap;
                /* dummy? */
                if (ent->dummy_port_mask & (1 << i)) {
                        ata_port_printk(ap, KERN_INFO, "DUMMY\n");
@@ -5740,7 +5741,7 @@ void ata_host_remove(struct ata_host *host)
 /**
 *      ata_scsi_release - SCSI layer callback hook for host unload
- *      @host: libata host to be unloaded
+ *      @shost: libata host to be unloaded
 *
 *      Performs all duties necessary to shut down a libata port...
 *      Kill port kthread, disable port, and release resources.
@@ -5786,6 +5787,7 @@ ata_probe_ent_alloc(struct device *dev, const struct ata_port_info *port)
        probe_ent->mwdma_mask = port->mwdma_mask;
        probe_ent->udma_mask = port->udma_mask;
        probe_ent->port_ops = port->port_ops;
+        probe_ent->private_data = port->private_data;
        return probe_ent;
 }
diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
index 3986ec8741b..b0d0cc41f3e 100644
--- a/drivers/ata/libata-scsi.c
+++ b/drivers/ata/libata-scsi.c
@@ -889,6 +889,7 @@ int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 {
        struct ata_port *ap = ata_shost_to_port(sdev->host);
        struct ata_device *dev;
+        unsigned long flags;
        int max_depth;
        if (queue_depth < 1)
@@ -904,6 +905,14 @@ int ata_scsi_change_queue_depth(struct scsi_device *sdev, int queue_depth)
                queue_depth = max_depth;
        scsi_adjust_queue_depth(sdev, MSG_SIMPLE_TAG, queue_depth);
+        spin_lock_irqsave(ap->lock, flags);
+        if (queue_depth > 1)
+                dev->flags &= ~ATA_DFLAG_NCQ_OFF;
+        else
+                dev->flags |= ATA_DFLAG_NCQ_OFF;
+        spin_unlock_irqrestore(ap->lock, flags);
        return queue_depth;
 }
@@ -1293,7 +1302,8 @@ static unsigned int ata_scsi_rw_xlat(struct ata_queued_cmd *qc, const u8 *scsicm
                 */
                goto nothing_to_do;
-        if ((dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ) {
+        if ((dev->flags & (ATA_DFLAG_PIO | ATA_DFLAG_NCQ_OFF |
+                           ATA_DFLAG_NCQ)) == ATA_DFLAG_NCQ) {
                /* yay, NCQ */
                if (!lba_48_ok(block, n_block))
                        goto out_of_range;
@@ -3174,7 +3184,7 @@ void ata_scsi_dev_rescan(void *data)
 /**
 *      ata_sas_port_alloc - Allocate port for a SAS attached SATA device
- *      @pdev: PCI device that the scsi device is attached to
+ *      @host: ATA host container for all SAS ports
 *      @port_info: Information from low-level host driver
 *      @shost: SCSI host that the scsi device is attached to
 *
diff --git a/drivers/ata/libata-sff.c b/drivers/ata/libata-sff.c
index 08b3a407473..06daaa3736a 100644
--- a/drivers/ata/libata-sff.c
+++ b/drivers/ata/libata-sff.c
@@ -828,7 +828,6 @@ ata_pci_init_native_mode(struct pci_dev *pdev, struct ata_port_info **port, int
        probe_ent->irq = pdev->irq;
        probe_ent->irq_flags = IRQF_SHARED;
-        probe_ent->private_data = port[0]->private_data;
        if (ports & ATA_PORT_PRIMARY) {
                probe_ent->port[p].cmd_addr = pci_resource_start(pdev, 0);
@@ -878,7 +877,6 @@ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev,
                return NULL;
        probe_ent->n_ports = 2;
-        probe_ent->private_data = port[0]->private_data;
        if (port_mask & ATA_PORT_PRIMARY) {
                probe_ent->irq = ATA_PRIMARY_IRQ;
@@ -908,6 +906,8 @@ static struct ata_probe_ent *ata_pci_init_legacy_port(struct pci_dev *pdev,
                                probe_ent->_host_flags |= ATA_HOST_SIMPLEX;
                }
                ata_std_ports(&probe_ent->port[1]);
+                /* FIXME: could be pointing to stack area; must copy */
                probe_ent->pinfo2 = port[1];
        } else
                probe_ent->dummy_port_mask |= ATA_PORT_SECONDARY;
@@ -946,35 +946,21 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
 {
        struct ata_probe_ent *probe_ent = NULL;
        struct ata_port_info *port[2];
-        u8 tmp8, mask;
+        u8 mask;
        unsigned int legacy_mode = 0;
        int disable_dev_on_err = 1;
        int rc;
        DPRINTK("ENTER\n");
+        BUG_ON(n_ports < 1 || n_ports > 2);
        port[0] = port_info[0];
        if (n_ports > 1)
                port[1] = port_info[1];
        else
                port[1] = port[0];
-        if ((port[0]->flags & ATA_FLAG_NO_LEGACY) == 0
-            && (pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
-                /* TODO: What if one channel is in native mode ... */
-                pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
-                mask = (1 << 2) | (1 << 0);
-                if ((tmp8 & mask) != mask)
-                        legacy_mode = (1 << 3);
-        }
-        /* FIXME... */
-        if ((!legacy_mode) && (n_ports > 2)) {
-                printk(KERN_ERR "ata: BUG: native mode, n_ports > 2\n");
-                n_ports = 2;
-                /* For now */
-        }
        /* FIXME: Really for ATA it isn't safe because the device may be
           multi-purpose and we want to leave it alone if it was already
           enabled. Secondly for shared use as Arjan says we want refcounting
@@ -987,6 +973,16 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
        if (rc)
                return rc;
+        if ((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) {
+                u8 tmp8;
+                /* TODO: What if one channel is in native mode ... */
+                pci_read_config_byte(pdev, PCI_CLASS_PROG, &tmp8);
+                mask = (1 << 2) | (1 << 0);
+                if ((tmp8 & mask) != mask)
+                        legacy_mode = (1 << 3);
+        }
        rc = pci_request_regions(pdev, DRV_NAME);
        if (rc) {
                disable_dev_on_err = 0;
@@ -1039,7 +1035,7 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
                goto err_out_regions;
        }
-        /* FIXME: If we get no DMA mask we should fall back to PIO */
+        /* TODO: If we get no DMA mask we should fall back to PIO */
        rc = pci_set_dma_mask(pdev, ATA_DMA_MASK);
        if (rc)
                goto err_out_regions;
@@ -1062,13 +1058,17 @@ int ata_pci_init_one (struct pci_dev *pdev, struct ata_port_info **port_info,
        pci_set_master(pdev);
-        /* FIXME: check ata_device_add return */
+        if (!ata_device_add(probe_ent)) {
-        ata_device_add(probe_ent);
+                rc = -ENODEV;
+                goto err_out_ent;
+        }
        kfree(probe_ent);
        return 0;
+err_out_ent:
+        kfree(probe_ent);
 err_out_regions:
        if (legacy_mode & ATA_PORT_PRIMARY)
                release_region(ATA_PRIMARY_CMD, 8);
diff --git a/drivers/ata/pata_ali.c b/drivers/ata/pata_ali.c
index 87af3b5861a..1d695df5860 100644
--- a/drivers/ata/pata_ali.c
+++ b/drivers/ata/pata_ali.c
@@ -34,7 +34,7 @@
 #include <linux/dmi.h>
 #define DRV_NAME "pata_ali"
-#define DRV_VERSION "0.6.5"
+#define DRV_VERSION "0.6.6"
 /*
 *      Cable special cases
@@ -630,7 +630,7 @@ static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
                pci_read_config_byte(pdev, 0x53, &tmp);
                if (rev <= 0x20)
                        tmp &= ~0x02;
-                if (rev == 0xc7)
+                if (rev >= 0xc7)
                        tmp |= 0x03;
                else
                        tmp |= 0x01;    /* CD_ROM enable for DMA */
@@ -644,10 +644,11 @@ static int ali_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        return ata_pci_init_one(pdev, port_info, 2);
 }
-static struct pci_device_id ali[] = {
+static const struct pci_device_id ali[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5228), },
+        { PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5228), },
-        { PCI_DEVICE(PCI_VENDOR_ID_AL, PCI_DEVICE_ID_AL_M5229), },
+        { PCI_VDEVICE(AL, PCI_DEVICE_ID_AL_M5229), },
-        { 0, },
+        { },
 };
 static struct pci_driver ali_pci_driver = {
diff --git a/drivers/ata/pata_amd.c b/drivers/ata/pata_amd.c
index 599ee266722..29234c89711 100644
--- a/drivers/ata/pata_amd.c
+++ b/drivers/ata/pata_amd.c
@@ -662,27 +662,28 @@ static int amd_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 }
 static const struct pci_device_id amd[] = {
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_COBRA_7401,           PCI_ANY_ID, PCI_ANY_ID, 0, 0,  0 },
+        { PCI_VDEVICE(AMD,      PCI_DEVICE_ID_AMD_COBRA_7401),          0 },
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_VIPER_7409,           PCI_ANY_ID, PCI_ANY_ID, 0, 0,  1 },
+        { PCI_VDEVICE(AMD,      PCI_DEVICE_ID_AMD_VIPER_7409),          1 },
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_VIPER_7411,           PCI_ANY_ID, PCI_ANY_ID, 0, 0,  3 },
+        { PCI_VDEVICE(AMD,      PCI_DEVICE_ID_AMD_VIPER_7411),          3 },
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_OPUS_7441,            PCI_ANY_ID, PCI_ANY_ID, 0, 0,  4 },
+        { PCI_VDEVICE(AMD,      PCI_DEVICE_ID_AMD_OPUS_7441),           4 },
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_8111_IDE,             PCI_ANY_ID, PCI_ANY_ID, 0, 0,  5 },
+        { PCI_VDEVICE(AMD,      PCI_DEVICE_ID_AMD_8111_IDE),            5 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_IDE,        PCI_ANY_ID, PCI_ANY_ID, 0, 0,  7 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE_IDE),       7 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2_IDE,       PCI_ANY_ID, PCI_ANY_ID, 0, 0,  8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE2_IDE),      8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_IDE,      PCI_ANY_ID, PCI_ANY_ID, 0, 0,  8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE2S_IDE),     8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3_IDE,       PCI_ANY_ID, PCI_ANY_ID, 0, 0,  8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE3_IDE),      8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_IDE,      PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE3S_IDE),     8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_IDE), 8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_IDE), 8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_IDE), 8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_IDE), 8 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE,  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(NVIDIA,   PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_IDE), 8 },
-        { PCI_VENDOR_ID_AMD,    PCI_DEVICE_ID_AMD_CS5536_IDE,           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
+        { PCI_VDEVICE(AMD,      PCI_DEVICE_ID_AMD_CS5536_IDE),          9 },
-        { 0, },
+        { },
 };
 static struct pci_driver amd_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = amd,
        .probe          = amd_init_one,
        .remove         = ata_pci_remove_one
@@ -698,7 +699,6 @@ static void __exit amd_exit(void)
        pci_unregister_driver(&amd_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for AMD PATA IDE");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_artop.c b/drivers/ata/pata_artop.c
index c4ccb75a4f1..690828eb522 100644
--- a/drivers/ata/pata_artop.c
+++ b/drivers/ata/pata_artop.c
@@ -426,7 +426,7 @@ static int artop_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
                .port_ops       = &artop6260_ops,
        };
        struct ata_port_info *port_info[2];
-        struct ata_port_info *info;
+        struct ata_port_info *info = NULL;
        int ports = 2;
        if (!printed_version++)
@@ -470,16 +470,20 @@ static int artop_init_one (struct pci_dev *pdev, const struct pci_device_id *id)
                pci_write_config_byte(pdev, 0x4a, (reg & ~0x01) | 0x80);
        }
+        BUG_ON(info == NULL);
        port_info[0] = port_info[1] = info;
        return ata_pci_init_one(pdev, port_info, ports);
 }
 static const struct pci_device_id artop_pci_tbl[] = {
-        { 0x1191, 0x0005, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_VDEVICE(ARTOP, 0x0005), 0 },
-        { 0x1191, 0x0006, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
+        { PCI_VDEVICE(ARTOP, 0x0006), 1 },
-        { 0x1191, 0x0007, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
+        { PCI_VDEVICE(ARTOP, 0x0007), 1 },
-        { 0x1191, 0x0008, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
+        { PCI_VDEVICE(ARTOP, 0x0008), 2 },
-        { 0x1191, 0x0009, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
+        { PCI_VDEVICE(ARTOP, 0x0009), 2 },
        { }     /* terminate list */
 };
@@ -500,7 +504,6 @@ static void __exit artop_exit(void)
        pci_unregister_driver(&artop_pci_driver);
 }
 module_init(artop_init);
 module_exit(artop_exit);
diff --git a/drivers/ata/pata_atiixp.c b/drivers/ata/pata_atiixp.c
index 6c2269b6bd3..1ce28d2125f 100644
--- a/drivers/ata/pata_atiixp.c
+++ b/drivers/ata/pata_atiixp.c
@@ -267,12 +267,13 @@ static int atiixp_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 2);
 }
-static struct pci_device_id atiixp[] = {
+static const struct pci_device_id atiixp[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP200_IDE), },
+        { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP200_IDE), },
-        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP300_IDE), },
+        { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP300_IDE), },
-        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP400_IDE), },
+        { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP400_IDE), },
-        { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_IXP600_IDE), },
+        { PCI_VDEVICE(ATI, PCI_DEVICE_ID_ATI_IXP600_IDE), },
-        { 0, },
+        { },
 };
 static struct pci_driver atiixp_pci_driver = {
@@ -293,7 +294,6 @@ static void __exit atiixp_exit(void)
        pci_unregister_driver(&atiixp_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for ATI IXP200/300/400");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_cmd64x.c b/drivers/ata/pata_cmd64x.c
index e92b0ef43ec..b9bbd1d454b 100644
--- a/drivers/ata/pata_cmd64x.c
+++ b/drivers/ata/pata_cmd64x.c
@@ -468,16 +468,17 @@ static int cmd64x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        return ata_pci_init_one(pdev, port_info, 2);
 }
-static struct pci_device_id cmd64x[] = {
+static const struct pci_device_id cmd64x[] = {
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_643, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_643), 0 },
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_646, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
+        { PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_646), 1 },
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_648, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
+        { PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_648), 4 },
-        { PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_CMD_649, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
+        { PCI_VDEVICE(CMD, PCI_DEVICE_ID_CMD_649), 5 },
-        { 0, },
+        { },
 };
 static struct pci_driver cmd64x_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = cmd64x,
        .probe          = cmd64x_init_one,
        .remove         = ata_pci_remove_one
@@ -488,13 +489,11 @@ static int __init cmd64x_init(void)
        return pci_register_driver(&cmd64x_pci_driver);
 }
 static void __exit cmd64x_exit(void)
 {
        pci_unregister_driver(&cmd64x_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for CMD64x series PATA controllers");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_cs5520.c b/drivers/ata/pata_cs5520.c
index a6c6cebd0da..2cd3c0ff76d 100644
--- a/drivers/ata/pata_cs5520.c
+++ b/drivers/ata/pata_cs5520.c
@@ -299,10 +299,11 @@ static void __devexit cs5520_remove_one(struct pci_dev *pdev)
 /* For now keep DMA off. We can set it for all but A rev CS5510 once the
   core ATA code can handle it */
-static struct pci_device_id pata_cs5520[] = {
+static const struct pci_device_id pata_cs5520[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5510), },
+        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5510), },
-        { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5520), },
+        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5520), },
-        { 0, },
+        { },
 };
 static struct pci_driver cs5520_pci_driver = {
@@ -312,7 +313,6 @@ static struct pci_driver cs5520_pci_driver = {
        .remove         = cs5520_remove_one
 };
 static int __init cs5520_init(void)
 {
        return pci_register_driver(&cs5520_pci_driver);
diff --git a/drivers/ata/pata_cs5530.c b/drivers/ata/pata_cs5530.c
index 7bba4d954e9..a07cc81ef79 100644
--- a/drivers/ata/pata_cs5530.c
+++ b/drivers/ata/pata_cs5530.c
@@ -353,13 +353,14 @@ fail_put:
        return -ENODEV;
 }
-static struct pci_device_id cs5530[] = {
+static const struct pci_device_id cs5530[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_CYRIX, PCI_DEVICE_ID_CYRIX_5530_IDE), },
+        { PCI_VDEVICE(CYRIX, PCI_DEVICE_ID_CYRIX_5530_IDE), },
-        { 0, },
+        { },
 };
 static struct pci_driver cs5530_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = cs5530,
        .probe          = cs5530_init_one,
        .remove         = ata_pci_remove_one
@@ -370,13 +371,11 @@ static int __init cs5530_init(void)
        return pci_register_driver(&cs5530_pci_driver);
 }
 static void __exit cs5530_exit(void)
 {
        pci_unregister_driver(&cs5530_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for the Cyrix/NS/AMD 5530");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_cs5535.c b/drivers/ata/pata_cs5535.c
index d64fcdceaf0..f8def3f9c61 100644
--- a/drivers/ata/pata_cs5535.c
+++ b/drivers/ata/pata_cs5535.c
@@ -257,9 +257,10 @@ static int cs5535_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, ports, 1);
 }
-static struct pci_device_id cs5535[] = {
+static const struct pci_device_id cs5535[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_NS, 0x002D), },
+        { PCI_VDEVICE(NS, 0x002D), },
-        { 0, },
+        { },
 };
 static struct pci_driver cs5535_pci_driver = {
@@ -274,13 +275,11 @@ static int __init cs5535_init(void)
        return pci_register_driver(&cs5535_pci_driver);
 }
 static void __exit cs5535_exit(void)
 {
        pci_unregister_driver(&cs5535_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox, Jens Altmann, Wolfgan Zuleger, Alexander Kiausch");
 MODULE_DESCRIPTION("low-level driver for the NS/AMD 5530");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_cypress.c b/drivers/ata/pata_cypress.c
index dfa5ac53904..247b43608b1 100644
--- a/drivers/ata/pata_cypress.c
+++ b/drivers/ata/pata_cypress.c
@@ -184,8 +184,8 @@ static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *i
        };
        static struct ata_port_info *port_info[1] = { &info };
-        /* Devfn 1 is the ATA primary. The secondary is magic and on devfn2. For the
+        /* Devfn 1 is the ATA primary. The secondary is magic and on devfn2.
-           moment we don't handle the secondary. FIXME */
+           For the moment we don't handle the secondary. FIXME */
        if (PCI_FUNC(pdev->devfn) != 1)
                return -ENODEV;
@@ -193,13 +193,14 @@ static int cy82c693_init_one(struct pci_dev *pdev, const struct pci_device_id *i
        return ata_pci_init_one(pdev, port_info, 1);
 }
-static struct pci_device_id cy82c693[] = {
+static const struct pci_device_id cy82c693[] = {
-        { PCI_VENDOR_ID_CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_VDEVICE(CONTAQ, PCI_DEVICE_ID_CONTAQ_82C693), },
-        { 0, },
+        { },
 };
 static struct pci_driver cy82c693_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = cy82c693,
        .probe          = cy82c693_init_one,
        .remove         = ata_pci_remove_one
diff --git a/drivers/ata/pata_efar.c b/drivers/ata/pata_efar.c
index 95cd1ca181f..ef18c60fe14 100644
--- a/drivers/ata/pata_efar.c
+++ b/drivers/ata/pata_efar.c
@@ -305,7 +305,8 @@ static int efar_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 }
 static const struct pci_device_id efar_pci_tbl[] = {
-        { 0x1055, 0x9130, PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_VDEVICE(EFAR, 0x9130), },
        { }     /* terminate list */
 };
@@ -326,7 +327,6 @@ static void __exit efar_exit(void)
        pci_unregister_driver(&efar_pci_driver);
 }
 module_init(efar_init);
 module_exit(efar_exit);
diff --git a/drivers/ata/pata_hpt366.c b/drivers/ata/pata_hpt366.c
index 8c757438f35..6d3e4c0f15f 100644
--- a/drivers/ata/pata_hpt366.c
+++ b/drivers/ata/pata_hpt366.c
@@ -444,13 +444,14 @@ static int hpt36x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 2);
 }
-static struct pci_device_id hpt36x[] = {
+static const struct pci_device_id hpt36x[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT366), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT366), },
-        { 0, },
+        { },
 };
 static struct pci_driver hpt36x_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = hpt36x,
        .probe          = hpt36x_init_one,
        .remove         = ata_pci_remove_one
diff --git a/drivers/ata/pata_hpt37x.c b/drivers/ata/pata_hpt37x.c
index 10318c0012e..7350443948c 100644
--- a/drivers/ata/pata_hpt37x.c
+++ b/drivers/ata/pata_hpt37x.c
@@ -1219,17 +1219,18 @@ static int hpt37x_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 2);
 }
-static struct pci_device_id hpt37x[] = {
+static const struct pci_device_id hpt37x[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT366), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT366), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT371), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT371), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT372), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT372), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT374), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT374), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT302), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT302), },
-        { 0, },
+        { },
 };
 static struct pci_driver hpt37x_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = hpt37x,
        .probe          = hpt37x_init_one,
        .remove         = ata_pci_remove_one
@@ -1240,13 +1241,11 @@ static int __init hpt37x_init(void)
        return pci_register_driver(&hpt37x_pci_driver);
 }
 static void __exit hpt37x_exit(void)
 {
        pci_unregister_driver(&hpt37x_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for the Highpoint HPT37x/30x");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_hpt3x2n.c b/drivers/ata/pata_hpt3x2n.c
index 5c5d4f6ab90..58cfb2bc809 100644
--- a/drivers/ata/pata_hpt3x2n.c
+++ b/drivers/ata/pata_hpt3x2n.c
@@ -560,16 +560,17 @@ static int hpt3x2n_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 2);
 }
-static struct pci_device_id hpt3x2n[] = {
+static const struct pci_device_id hpt3x2n[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT366), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT366), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT372), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT372), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT302), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT302), },
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT372N), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT372N), },
-        { 0, },
+        { },
 };
 static struct pci_driver hpt3x2n_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = hpt3x2n,
        .probe          = hpt3x2n_init_one,
        .remove         = ata_pci_remove_one
@@ -580,13 +581,11 @@ static int __init hpt3x2n_init(void)
        return pci_register_driver(&hpt3x2n_pci_driver);
 }
 static void __exit hpt3x2n_exit(void)
 {
        pci_unregister_driver(&hpt3x2n_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for the Highpoint HPT3x2n/30x");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_hpt3x3.c b/drivers/ata/pata_hpt3x3.c
index 1f084ab1ccc..3334d72e251 100644
--- a/drivers/ata/pata_hpt3x3.c
+++ b/drivers/ata/pata_hpt3x3.c
@@ -192,13 +192,14 @@ static int hpt3x3_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 2);
 }
-static struct pci_device_id hpt3x3[] = {
+static const struct pci_device_id hpt3x3[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_TTI, PCI_DEVICE_ID_TTI_HPT343), },
+        { PCI_VDEVICE(TTI, PCI_DEVICE_ID_TTI_HPT343), },
-        { 0, },
+        { },
 };
 static struct pci_driver hpt3x3_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = hpt3x3,
        .probe          = hpt3x3_init_one,
        .remove         = ata_pci_remove_one
diff --git a/drivers/ata/pata_it821x.c b/drivers/ata/pata_it821x.c
index 82a46ff4000..18ff3e59a89 100644
--- a/drivers/ata/pata_it821x.c
+++ b/drivers/ata/pata_it821x.c
@@ -808,14 +808,15 @@ static int it821x_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
        return ata_pci_init_one(pdev, port_info, 2);
 }
-static struct pci_device_id it821x[] = {
+static const struct pci_device_id it821x[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8211), },
+        { PCI_VDEVICE(ITE, PCI_DEVICE_ID_ITE_8211), },
-        { PCI_DEVICE(PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8212), },
+        { PCI_VDEVICE(ITE, PCI_DEVICE_ID_ITE_8212), },
-        { 0, },
+        { },
 };
 static struct pci_driver it821x_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = it821x,
        .probe          = it821x_init_one,
        .remove         = ata_pci_remove_one
@@ -826,13 +827,11 @@ static int __init it821x_init(void)
        return pci_register_driver(&it821x_pci_driver);
 }
 static void __exit it821x_exit(void)
 {
        pci_unregister_driver(&it821x_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for the IT8211/IT8212 IDE RAID controller");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_jmicron.c b/drivers/ata/pata_jmicron.c
index be3a866b111..52a2bdf3c38 100644
--- a/drivers/ata/pata_jmicron.c
+++ b/drivers/ata/pata_jmicron.c
@@ -229,11 +229,12 @@ static int jmicron_init_one (struct pci_dev *pdev, const struct pci_device_id *i
 }
 static const struct pci_device_id jmicron_pci_tbl[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB361), 361},
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB361), 361},
-        { PCI_DEVICE(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB363), 363},
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB363), 363},
-        { PCI_DEVICE(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB365), 365},
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB365), 365},
-        { PCI_DEVICE(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB366), 366},
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB366), 366},
-        { PCI_DEVICE(PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB368), 368},
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB368), 368},
        { }     /* terminate list */
 };
diff --git a/drivers/ata/pata_mpiix.c b/drivers/ata/pata_mpiix.c
index 3c65393c1f0..9dfe3e9abea 100644
--- a/drivers/ata/pata_mpiix.c
+++ b/drivers/ata/pata_mpiix.c
@@ -274,11 +274,10 @@ static void __devexit mpiix_remove_one(struct pci_dev *pdev)
        dev_set_drvdata(dev, NULL);
 }
 static const struct pci_device_id mpiix[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371MX), },
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_82371MX), },
-        { 0, },
+        { },
 };
 static struct pci_driver mpiix_pci_driver = {
@@ -293,13 +292,11 @@ static int __init mpiix_init(void)
        return pci_register_driver(&mpiix_pci_driver);
 }
 static void __exit mpiix_exit(void)
 {
        pci_unregister_driver(&mpiix_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Intel MPIIX");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_netcell.c b/drivers/ata/pata_netcell.c
index 76eb9c90bee..f5672de99c2 100644
--- a/drivers/ata/pata_netcell.c
+++ b/drivers/ata/pata_netcell.c
@@ -142,7 +142,8 @@ static int netcell_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 }
 static const struct pci_device_id netcell_pci_tbl[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_NETCELL, PCI_DEVICE_ID_REVOLUTION), },
+        { PCI_VDEVICE(NETCELL, PCI_DEVICE_ID_REVOLUTION), },
        { }     /* terminate list */
 };
diff --git a/drivers/ata/pata_ns87410.c b/drivers/ata/pata_ns87410.c
index 2005a95f48f..2a3dbeed89b 100644
--- a/drivers/ata/pata_ns87410.c
+++ b/drivers/ata/pata_ns87410.c
@@ -200,12 +200,13 @@ static int ns87410_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 }
 static const struct pci_device_id ns87410[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_87410), },
+        { PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_87410), },
-        { 0, },
+        { },
 };
 static struct pci_driver ns87410_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = ns87410,
        .probe          = ns87410_init_one,
        .remove         = ata_pci_remove_one
@@ -216,13 +217,11 @@ static int __init ns87410_init(void)
        return pci_register_driver(&ns87410_pci_driver);
 }
 static void __exit ns87410_exit(void)
 {
        pci_unregister_driver(&ns87410_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Nat Semi 87410");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_oldpiix.c b/drivers/ata/pata_oldpiix.c
index 31a285ca88d..fc947dfecd7 100644
--- a/drivers/ata/pata_oldpiix.c
+++ b/drivers/ata/pata_oldpiix.c
@@ -303,7 +303,8 @@ static int oldpiix_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 }
 static const struct pci_device_id oldpiix_pci_tbl[] = {
-        { PCI_DEVICE(0x8086, 0x1230), },
+        { PCI_VDEVICE(INTEL, 0x1230), },
        { }     /* terminate list */
 };
@@ -324,7 +325,6 @@ static void __exit oldpiix_exit(void)
        pci_unregister_driver(&oldpiix_pci_driver);
 }
 module_init(oldpiix_init);
 module_exit(oldpiix_exit);
diff --git a/drivers/ata/pata_opti.c b/drivers/ata/pata_opti.c
index 57fe21f3a97..a7320ba1557 100644
--- a/drivers/ata/pata_opti.c
+++ b/drivers/ata/pata_opti.c
@@ -256,13 +256,14 @@ static int opti_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 }
 static const struct pci_device_id opti[] = {
-        { PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C621, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
+        { PCI_VDEVICE(OPTI, PCI_DEVICE_ID_OPTI_82C621), 0 },
-        { PCI_VENDOR_ID_OPTI, PCI_DEVICE_ID_OPTI_82C825, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
+        { PCI_VDEVICE(OPTI, PCI_DEVICE_ID_OPTI_82C825), 1 },
-        { 0, },
+        { },
 };
 static struct pci_driver opti_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = opti,
        .probe          = opti_init_one,
        .remove         = ata_pci_remove_one
@@ -273,7 +274,6 @@ static int __init opti_init(void)
        return pci_register_driver(&opti_pci_driver);
 }
 static void __exit opti_exit(void)
 {
        pci_unregister_driver(&opti_pci_driver);
diff --git a/drivers/ata/pata_optidma.c b/drivers/ata/pata_optidma.c
index 7296a20cd10..c6906b4215d 100644
--- a/drivers/ata/pata_optidma.c
+++ b/drivers/ata/pata_optidma.c
@@ -512,12 +512,13 @@ static int optidma_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 }
 static const struct pci_device_id optidma[] = {
-        { PCI_DEVICE(0x1045, 0xD568), },        /* Opti 82C700 */
+        { PCI_VDEVICE(OPTI, 0xD568), },         /* Opti 82C700 */
-        { 0, },
+        { },
 };
 static struct pci_driver optidma_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = optidma,
        .probe          = optidma_init_one,
        .remove         = ata_pci_remove_one
@@ -528,13 +529,11 @@ static int __init optidma_init(void)
        return pci_register_driver(&optidma_pci_driver);
 }
 static void __exit optidma_exit(void)
 {
        pci_unregister_driver(&optidma_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Opti Firestar/Firestar Plus");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index cb501e145a4..e93ea2702c7 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -42,7 +42,7 @@
 #define DRV_NAME "pata_pcmcia"
-#define DRV_VERSION "0.2.9"
+#define DRV_VERSION "0.2.11"
 /*
 *      Private data structure to glue stuff together
@@ -355,6 +355,8 @@ static struct pcmcia_device_id pcmcia_devices[] = {
        PCMCIA_DEVICE_PROD_ID12("SAMSUNG", "04/05/06", 0x43d74cb4, 0x6a22777d),
        PCMCIA_DEVICE_PROD_ID12("SMI VENDOR", "SMI PRODUCT", 0x30896c92, 0x703cc5f6),
        PCMCIA_DEVICE_PROD_ID12("TOSHIBA", "MK2001MPL", 0xb4585a1a, 0x3489e003),
+        PCMCIA_DEVICE_PROD_ID1("TRANSCEND    512M   ", 0xd0909443),
+        PCMCIA_DEVICE_PROD_ID12("TRANSCEND", "TS4GCF120", 0x709b1bf1, 0xf54a91c8),
        PCMCIA_DEVICE_PROD_ID12("WIT", "IDE16", 0x244e5994, 0x3e232852),
        PCMCIA_DEVICE_PROD_ID1("STI Flash", 0xe4a13209),
        PCMCIA_DEVICE_PROD_ID12("STI", "Flash 5.0", 0xbf2df18d, 0x8cb57a0e),
diff --git a/drivers/ata/pata_pdc2027x.c b/drivers/ata/pata_pdc2027x.c
index bd4ed6734ed..d894d9918b1 100644
--- a/drivers/ata/pata_pdc2027x.c
+++ b/drivers/ata/pata_pdc2027x.c
@@ -108,13 +108,14 @@ static struct pdc2027x_udma_timing {
 };
 static const struct pci_device_id pdc2027x_pci_tbl[] = {
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20268, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_100 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20268), PDC_UDMA_100 },
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20269, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20269), PDC_UDMA_133 },
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20270, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_100 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20270), PDC_UDMA_100 },
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20271, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20271), PDC_UDMA_133 },
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20275, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20275), PDC_UDMA_133 },
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20276, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20276), PDC_UDMA_133 },
-        { PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20277, PCI_ANY_ID, PCI_ANY_ID, 0, 0, PDC_UDMA_133 },
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20277), PDC_UDMA_133 },
        { }     /* terminate list */
 };
diff --git a/drivers/ata/pata_pdc202xx_old.c b/drivers/ata/pata_pdc202xx_old.c
index 48f43432764..5ba9eb20a6c 100644
--- a/drivers/ata/pata_pdc202xx_old.c
+++ b/drivers/ata/pata_pdc202xx_old.c
@@ -385,17 +385,18 @@ static int pdc_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 2);
 }
-static struct pci_device_id pdc[] = {
+static const struct pci_device_id pdc[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20246), 0},
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20246), 0 },
-        { PCI_DEVICE(PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20262), 1},
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20262), 1 },
-        { PCI_DEVICE(PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20263), 1},
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20263), 1 },
-        { PCI_DEVICE(PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20265), 2},
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20265), 2 },
-        { PCI_DEVICE(PCI_VENDOR_ID_PROMISE, PCI_DEVICE_ID_PROMISE_20267), 2},
+        { PCI_VDEVICE(PROMISE, PCI_DEVICE_ID_PROMISE_20267), 2 },
-        { 0, },
+        { },
 };
 static struct pci_driver pdc_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = pdc,
        .probe          = pdc_init_one,
        .remove         = ata_pci_remove_one
@@ -406,13 +407,11 @@ static int __init pdc_init(void)
        return pci_register_driver(&pdc_pci_driver);
 }
 static void __exit pdc_exit(void)
 {
        pci_unregister_driver(&pdc_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Promise 2024x and 20262-20267");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_radisys.c b/drivers/ata/pata_radisys.c
index c20bcf43ed6..1af83d7694d 100644
--- a/drivers/ata/pata_radisys.c
+++ b/drivers/ata/pata_radisys.c
@@ -300,7 +300,8 @@ static int radisys_init_one (struct pci_dev *pdev, const struct pci_device_id *e
 }
 static const struct pci_device_id radisys_pci_tbl[] = {
-        { 0x1331, 0x8201, PCI_ANY_ID, PCI_ANY_ID, },
+        { PCI_VDEVICE(RADISYS, 0x8201), },
        { }     /* terminate list */
 };
@@ -321,7 +322,6 @@ static void __exit radisys_exit(void)
        pci_unregister_driver(&radisys_pci_driver);
 }
 module_init(radisys_init);
 module_exit(radisys_exit);
diff --git a/drivers/ata/pata_rz1000.c b/drivers/ata/pata_rz1000.c
index eccc6fd4503..4533b6357d9 100644
--- a/drivers/ata/pata_rz1000.c
+++ b/drivers/ata/pata_rz1000.c
@@ -170,20 +170,20 @@ fail:
        return -ENODEV;
 }
-static struct pci_device_id pata_rz1000[] = {
+static const struct pci_device_id pata_rz1000[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_RZ1000), },
+        { PCI_VDEVICE(PCTECH, PCI_DEVICE_ID_PCTECH_RZ1000), },
-        { PCI_DEVICE(PCI_VENDOR_ID_PCTECH, PCI_DEVICE_ID_PCTECH_RZ1001), },
+        { PCI_VDEVICE(PCTECH, PCI_DEVICE_ID_PCTECH_RZ1001), },
-        { 0, },
+        { },
 };
 static struct pci_driver rz1000_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = pata_rz1000,
        .probe          = rz1000_init_one,
        .remove         = ata_pci_remove_one
 };
 static int __init rz1000_init(void)
 {
        return pci_register_driver(&rz1000_pci_driver);
diff --git a/drivers/ata/pata_sc1200.c b/drivers/ata/pata_sc1200.c
index 107e6cd3dc0..067d9d223e3 100644
--- a/drivers/ata/pata_sc1200.c
+++ b/drivers/ata/pata_sc1200.c
@@ -253,13 +253,14 @@ static int sc1200_init_one(struct pci_dev *dev, const struct pci_device_id *id)
        return ata_pci_init_one(dev, port_info, 1);
 }
-static struct pci_device_id sc1200[] = {
+static const struct pci_device_id sc1200[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_IDE), },
+        { PCI_VDEVICE(NS, PCI_DEVICE_ID_NS_SCx200_IDE), },
-        { 0, },
+        { },
 };
 static struct pci_driver sc1200_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = sc1200,
        .probe          = sc1200_init_one,
        .remove         = ata_pci_remove_one
@@ -270,13 +271,11 @@ static int __init sc1200_init(void)
        return pci_register_driver(&sc1200_pci_driver);
 }
 static void __exit sc1200_exit(void)
 {
        pci_unregister_driver(&sc1200_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox, Mark Lord");
 MODULE_DESCRIPTION("low-level driver for the NS/AMD SC1200");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_serverworks.c b/drivers/ata/pata_serverworks.c
index a5c8d7e121d..5bbf76ec14a 100644
--- a/drivers/ata/pata_serverworks.c
+++ b/drivers/ata/pata_serverworks.c
@@ -553,13 +553,14 @@ static int serverworks_init_one(struct pci_dev *pdev, const struct pci_device_id
        return ata_pci_init_one(pdev, port_info, ports);
 }
-static struct pci_device_id serverworks[] = {
+static const struct pci_device_id serverworks[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE), 0},
+        { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_OSB4IDE), 0},
-        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE), 2},
+        { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB5IDE), 2},
-        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE), 2},
+        { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE), 2},
-        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2), 2},
+        { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_CSB6IDE2), 2},
-        { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE), 2},
+        { PCI_VDEVICE(SERVERWORKS, PCI_DEVICE_ID_SERVERWORKS_HT1000IDE), 2},
-        { 0, },
+        { },
 };
 static struct pci_driver serverworks_pci_driver = {
@@ -574,13 +575,11 @@ static int __init serverworks_init(void)
        return pci_register_driver(&serverworks_pci_driver);
 }
 static void __exit serverworks_exit(void)
 {
        pci_unregister_driver(&serverworks_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Serverworks OSB4/CSB5/CSB6");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_sil680.c b/drivers/ata/pata_sil680.c
index c8b2e26db70..4a2b72b4be8 100644
--- a/drivers/ata/pata_sil680.c
+++ b/drivers/ata/pata_sil680.c
@@ -348,12 +348,13 @@ static int sil680_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 }
 static const struct pci_device_id sil680[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_CMD, PCI_DEVICE_ID_SII_680), },
+        { PCI_VDEVICE(CMD, PCI_DEVICE_ID_SII_680), },
-        { 0, },
+        { },
 };
 static struct pci_driver sil680_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = sil680,
        .probe          = sil680_init_one,
        .remove         = ata_pci_remove_one
@@ -364,13 +365,11 @@ static int __init sil680_init(void)
        return pci_register_driver(&sil680_pci_driver);
 }
 static void __exit sil680_exit(void)
 {
        pci_unregister_driver(&sil680_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for SI680 PATA");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_sis.c b/drivers/ata/pata_sis.c
index 17791e2785f..b9ffafb4198 100644
--- a/drivers/ata/pata_sis.c
+++ b/drivers/ata/pata_sis.c
@@ -988,8 +988,9 @@ static int sis_init_one (struct pci_dev *pdev, const struct pci_device_id *ent)
 }
 static const struct pci_device_id sis_pci_tbl[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x5513), },      /* SiS 5513 */
+        { PCI_VDEVICE(SI, 0x5513), },   /* SiS 5513 */
-        { PCI_DEVICE(PCI_VENDOR_ID_SI, 0x5518), },      /* SiS 5518 */
+        { PCI_VDEVICE(SI, 0x5518), },   /* SiS 5518 */
        { }
 };
@@ -1010,7 +1011,6 @@ static void __exit sis_exit(void)
        pci_unregister_driver(&sis_pci_driver);
 }
 module_init(sis_init);
 module_exit(sis_exit);
diff --git a/drivers/ata/pata_sl82c105.c b/drivers/ata/pata_sl82c105.c
index 5b762acc568..08a6dc88676 100644
--- a/drivers/ata/pata_sl82c105.c
+++ b/drivers/ata/pata_sl82c105.c
@@ -351,9 +351,10 @@ static int sl82c105_init_one(struct pci_dev *dev, const struct pci_device_id *id
        return ata_pci_init_one(dev, port_info, 1); /* For now */
 }
-static struct pci_device_id sl82c105[] = {
+static const struct pci_device_id sl82c105[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_WINBOND, PCI_DEVICE_ID_WINBOND_82C105), },
+        { PCI_VDEVICE(WINBOND, PCI_DEVICE_ID_WINBOND_82C105), },
-        { 0, },
+        { },
 };
 static struct pci_driver sl82c105_pci_driver = {
@@ -368,13 +369,11 @@ static int __init sl82c105_init(void)
        return pci_register_driver(&sl82c105_pci_driver);
 }
 static void __exit sl82c105_exit(void)
 {
        pci_unregister_driver(&sl82c105_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Sl82c105");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_triflex.c b/drivers/ata/pata_triflex.c
index a954ed93a40..9640f80e8b0 100644
--- a/drivers/ata/pata_triflex.c
+++ b/drivers/ata/pata_triflex.c
@@ -248,13 +248,13 @@ static int triflex_init_one(struct pci_dev *dev, const struct pci_device_id *id)
 }
 static const struct pci_device_id triflex[] = {
-        { PCI_VENDOR_ID_COMPAQ, PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE,
+        { PCI_VDEVICE(COMPAQ, PCI_DEVICE_ID_COMPAQ_TRIFLEX_IDE), },
-                                  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
-        { 0, },
+        { },
 };
 static struct pci_driver triflex_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = triflex,
        .probe          = triflex_init_one,
        .remove         = ata_pci_remove_one
@@ -265,13 +265,11 @@ static int __init triflex_init(void)
        return pci_register_driver(&triflex_pci_driver);
 }
 static void __exit triflex_exit(void)
 {
        pci_unregister_driver(&triflex_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for Compaq Triflex");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pata_via.c b/drivers/ata/pata_via.c
index 7b5dd2343b9..1e7be9eee9c 100644
--- a/drivers/ata/pata_via.c
+++ b/drivers/ata/pata_via.c
@@ -529,15 +529,16 @@ static int via_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
 }
 static const struct pci_device_id via[] = {
-        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C576_1), },
+        { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_82C576_1), },
-        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_82C586_1), },
+        { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_82C586_1), },
-        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_6410), },
+        { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_6410), },
-        { PCI_DEVICE(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_SATA_EIDE), },
+        { PCI_VDEVICE(VIA, PCI_DEVICE_ID_VIA_SATA_EIDE), },
-        { 0, },
+        { },
 };
 static struct pci_driver via_pci_driver = {
-        .name           = DRV_NAME,
+        .name           = DRV_NAME,
        .id_table       = via,
        .probe          = via_init_one,
        .remove         = ata_pci_remove_one
@@ -548,13 +549,11 @@ static int __init via_init(void)
        return pci_register_driver(&via_pci_driver);
 }
 static void __exit via_exit(void)
 {
        pci_unregister_driver(&via_pci_driver);
 }
 MODULE_AUTHOR("Alan Cox");
 MODULE_DESCRIPTION("low-level driver for VIA PATA");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/pdc_adma.c b/drivers/ata/pdc_adma.c
index 0e23ecb77bc..81f3d219e70 100644
--- a/drivers/ata/pdc_adma.c
+++ b/drivers/ata/pdc_adma.c
@@ -192,8 +192,7 @@ static struct ata_port_info adma_port_info[] = {
 };
 static const struct pci_device_id adma_ata_pci_tbl[] = {
-        { PCI_VENDOR_ID_PDC, 0x1841, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PDC, 0x1841), board_1841_idx },
-          board_1841_idx },
        { }     /* terminate list */
 };
diff --git a/drivers/ata/sata_mv.c b/drivers/ata/sata_mv.c
index c01496df4a9..e6aa1a86d5c 100644
--- a/drivers/ata/sata_mv.c
+++ b/drivers/ata/sata_mv.c
@@ -533,19 +533,20 @@ static const struct ata_port_info mv_port_info[] = {
 };
 static const struct pci_device_id mv_pci_tbl[] = {
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5040), 0, 0, chip_504x},
+        { PCI_VDEVICE(MARVELL, 0x5040), chip_504x },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5041), 0, 0, chip_504x},
+        { PCI_VDEVICE(MARVELL, 0x5041), chip_504x },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5080), 0, 0, chip_5080},
+        { PCI_VDEVICE(MARVELL, 0x5080), chip_5080 },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x5081), 0, 0, chip_508x},
+        { PCI_VDEVICE(MARVELL, 0x5081), chip_508x },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6040), 0, 0, chip_604x},
+        { PCI_VDEVICE(MARVELL, 0x6040), chip_604x },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6041), 0, 0, chip_604x},
+        { PCI_VDEVICE(MARVELL, 0x6041), chip_604x },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6042), 0, 0, chip_6042},
+        { PCI_VDEVICE(MARVELL, 0x6042), chip_6042 },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6080), 0, 0, chip_608x},
+        { PCI_VDEVICE(MARVELL, 0x6080), chip_608x },
-        {PCI_DEVICE(PCI_VENDOR_ID_MARVELL, 0x6081), 0, 0, chip_608x},
+        { PCI_VDEVICE(MARVELL, 0x6081), chip_608x },
-        {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x0241), 0, 0, chip_604x},
+        { PCI_VDEVICE(ADAPTEC2, 0x0241), chip_604x },
-        {}                      /* terminate list */
+        { }                     /* terminate list */
 };
 static struct pci_driver mv_pci_driver = {
diff --git a/drivers/ata/sata_nv.c b/drivers/ata/sata_nv.c
index 8cd730fe5dd..d09d20a1779 100644
--- a/drivers/ata/sata_nv.c
+++ b/drivers/ata/sata_nv.c
@@ -106,45 +106,32 @@ enum nv_host_type
 };
 static const struct pci_device_id nv_pci_tbl[] = {
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE2S_SATA), NFORCE2 },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, NFORCE2 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA), NFORCE3 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2), NFORCE3 },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, NFORCE3 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA), CK804 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE3S_SATA2,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2), CK804 },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, NFORCE3 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA), CK804 },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2), CK804 },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA), GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_CK804_SATA2,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2), GENERIC },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA), GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2), GENERIC },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA), GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP04_SATA2,
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2), GENERIC },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, CK804 },
+        { PCI_VDEVICE(NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3), GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA,
+        { PCI_VDEVICE(NVIDIA, 0x045c), GENERIC },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
+        { PCI_VDEVICE(NVIDIA, 0x045d), GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP51_SATA2,
+        { PCI_VDEVICE(NVIDIA, 0x045e), GENERIC },
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
+        { PCI_VDEVICE(NVIDIA, 0x045f), GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP55_SATA2,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA2,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NFORCE_MCP61_SATA3,
-                PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, 0x045c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, 0x045d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, 0x045e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
-        { PCI_VENDOR_ID_NVIDIA, 0x045f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, GENERIC },
        { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
                PCI_ANY_ID, PCI_ANY_ID,
                PCI_CLASS_STORAGE_IDE<<8, 0xffff00, GENERIC },
        { PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID,
                PCI_ANY_ID, PCI_ANY_ID,
                PCI_CLASS_STORAGE_RAID<<8, 0xffff00, GENERIC },
-        { 0, } /* terminate list */
+        { } /* terminate list */
 };
 static struct pci_driver nv_pci_driver = {
diff --git a/drivers/ata/sata_promise.c b/drivers/ata/sata_promise.c
index d627812ea73..15c9437710f 100644
--- a/drivers/ata/sata_promise.c
+++ b/drivers/ata/sata_promise.c
@@ -234,48 +234,31 @@ static const struct ata_port_info pdc_port_info[] = {
 };
 static const struct pci_device_id pdc_ata_pci_tbl[] = {
-        { PCI_VENDOR_ID_PROMISE, 0x3371, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3371), board_2037x },
-          board_2037x },
+        { PCI_VDEVICE(PROMISE, 0x3570), board_2037x },
-        { PCI_VENDOR_ID_PROMISE, 0x3570, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3571), board_2037x },
-          board_2037x },
+        { PCI_VDEVICE(PROMISE, 0x3373), board_2037x },
-        { PCI_VENDOR_ID_PROMISE, 0x3571, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3375), board_2037x },
-          board_2037x },
+        { PCI_VDEVICE(PROMISE, 0x3376), board_2037x },
-        { PCI_VENDOR_ID_PROMISE, 0x3373, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3574), board_2057x },
-          board_2037x },
+        { PCI_VDEVICE(PROMISE, 0x3d75), board_2057x },
-        { PCI_VENDOR_ID_PROMISE, 0x3375, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3d73), board_2037x },
-          board_2037x },
-        { PCI_VENDOR_ID_PROMISE, 0x3376, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3318), board_20319 },
-          board_2037x },
+        { PCI_VDEVICE(PROMISE, 0x3319), board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3574, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3515), board_20319 },
-          board_2057x },
+        { PCI_VDEVICE(PROMISE, 0x3519), board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3d75, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3d17), board_20319 },
-          board_2057x },
+        { PCI_VDEVICE(PROMISE, 0x3d18), board_40518 },
-        { PCI_VENDOR_ID_PROMISE, 0x3d73, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_2037x },
+        { PCI_VDEVICE(PROMISE, 0x6629), board_20619 },
-        { PCI_VENDOR_ID_PROMISE, 0x3318, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3319, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3515, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3519, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3d17, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_20319 },
-        { PCI_VENDOR_ID_PROMISE, 0x3d18, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_40518 },
-        { PCI_VENDOR_ID_PROMISE, 0x6629, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
-          board_20619 },
 /* TODO: remove all associated board_20771 code, as it completely
 * duplicates board_2037x code, unless reason for separation can be
 * divined.
 */
 #if 0
-        { PCI_VENDOR_ID_PROMISE, 0x3570, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x3570), board_20771 },
-          board_20771 },
 #endif
        { }     /* terminate list */
diff --git a/drivers/ata/sata_qstor.c b/drivers/ata/sata_qstor.c
index fa29dfe2a7b..7f6cc3c07de 100644
--- a/drivers/ata/sata_qstor.c
+++ b/drivers/ata/sata_qstor.c
@@ -185,8 +185,7 @@ static const struct ata_port_info qs_port_info[] = {
 };
 static const struct pci_device_id qs_ata_pci_tbl[] = {
-        { PCI_VENDOR_ID_PDC, 0x2068, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PDC, 0x2068), board_2068_idx },
-          board_2068_idx },
        { }     /* terminate list */
 };
diff --git a/drivers/ata/sata_sil.c b/drivers/ata/sata_sil.c
index c63dbabc0cd..3d9fa1cc834 100644
--- a/drivers/ata/sata_sil.c
+++ b/drivers/ata/sata_sil.c
@@ -123,13 +123,14 @@ static void sil_thaw(struct ata_port *ap);
 static const struct pci_device_id sil_pci_tbl[] = {
-        { 0x1095, 0x3112, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { PCI_VDEVICE(CMD, 0x3112), sil_3112 },
-        { 0x1095, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { PCI_VDEVICE(CMD, 0x0240), sil_3112 },
-        { 0x1095, 0x3512, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3512 },
+        { PCI_VDEVICE(CMD, 0x3512), sil_3512 },
-        { 0x1095, 0x3114, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3114 },
+        { PCI_VDEVICE(CMD, 0x3114), sil_3114 },
-        { 0x1002, 0x436e, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112 },
+        { PCI_VDEVICE(ATI, 0x436e), sil_3112 },
-        { 0x1002, 0x4379, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_no_sata_irq },
+        { PCI_VDEVICE(ATI, 0x4379), sil_3112_no_sata_irq },
-        { 0x1002, 0x437a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sil_3112_no_sata_irq },
+        { PCI_VDEVICE(ATI, 0x437a), sil_3112_no_sata_irq },
        { }     /* terminate list */
 };
diff --git a/drivers/ata/sata_sil24.c b/drivers/ata/sata_sil24.c
index 39cb07baeba..a951f40c2f2 100644
--- a/drivers/ata/sata_sil24.c
+++ b/drivers/ata/sata_sil24.c
@@ -344,11 +344,12 @@ static int sil24_pci_device_resume(struct pci_dev *pdev);
 #endif
 static const struct pci_device_id sil24_pci_tbl[] = {
-        { 0x1095, 0x3124, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3124 },
+        { PCI_VDEVICE(CMD, 0x3124), BID_SIL3124 },
-        { 0x8086, 0x3124, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3124 },
+        { PCI_VDEVICE(INTEL, 0x3124), BID_SIL3124 },
-        { 0x1095, 0x3132, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3132 },
+        { PCI_VDEVICE(CMD, 0x3132), BID_SIL3132 },
-        { 0x1095, 0x3131, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3131 },
+        { PCI_VDEVICE(CMD, 0x3131), BID_SIL3131 },
-        { 0x1095, 0x3531, PCI_ANY_ID, PCI_ANY_ID, 0, 0, BID_SIL3131 },
+        { PCI_VDEVICE(CMD, 0x3531), BID_SIL3131 },
        { } /* terminate list */
 };
diff --git a/drivers/ata/sata_sis.c b/drivers/ata/sata_sis.c
index 18d49fff8dc..0738f52463a 100644
--- a/drivers/ata/sata_sis.c
+++ b/drivers/ata/sata_sis.c
@@ -67,13 +67,13 @@ static u32 sis_scr_read (struct ata_port *ap, unsigned int sc_reg);
 static void sis_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 static const struct pci_device_id sis_pci_tbl[] = {
-        { PCI_VENDOR_ID_SI, 0x180, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sis_180 },
+        { PCI_VDEVICE(SI, 0x180), sis_180 },
-        { PCI_VENDOR_ID_SI, 0x181, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sis_180 },
+        { PCI_VDEVICE(SI, 0x181), sis_180 },
-        { PCI_VENDOR_ID_SI, 0x182, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sis_180 },
+        { PCI_VDEVICE(SI, 0x182), sis_180 },
        { }     /* terminate list */
 };
 static struct pci_driver sis_pci_driver = {
        .name                   = DRV_NAME,
        .id_table               = sis_pci_tbl,
diff --git a/drivers/ata/sata_svw.c b/drivers/ata/sata_svw.c
index d6d6658d832..84025a2fd5b 100644
--- a/drivers/ata/sata_svw.c
+++ b/drivers/ata/sata_svw.c
@@ -469,15 +469,15 @@ err_out:
 * controller
 * */
 static const struct pci_device_id k2_sata_pci_tbl[] = {
-        { 0x1166, 0x0240, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x0240), 4 },
-        { 0x1166, 0x0241, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x0241), 4 },
-        { 0x1166, 0x0242, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
+        { PCI_VDEVICE(SERVERWORKS, 0x0242), 8 },
-        { 0x1166, 0x024a, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x024a), 4 },
-        { 0x1166, 0x024b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
+        { PCI_VDEVICE(SERVERWORKS, 0x024b), 4 },
        { }
 };
 static struct pci_driver k2_sata_pci_driver = {
        .name                   = DRV_NAME,
        .id_table               = k2_sata_pci_tbl,
@@ -485,19 +485,16 @@ static struct pci_driver k2_sata_pci_driver = {
        .remove                 = ata_pci_remove_one,
 };
 static int __init k2_sata_init(void)
 {
        return pci_register_driver(&k2_sata_pci_driver);
 }
 static void __exit k2_sata_exit(void)
 {
        pci_unregister_driver(&k2_sata_pci_driver);
 }
 MODULE_AUTHOR("Benjamin Herrenschmidt");
 MODULE_DESCRIPTION("low-level driver for K2 SATA controller");
 MODULE_LICENSE("GPL");
diff --git a/drivers/ata/sata_sx4.c b/drivers/ata/sata_sx4.c
index 091867e10ea..8c74f2ff434 100644
--- a/drivers/ata/sata_sx4.c
+++ b/drivers/ata/sata_sx4.c
@@ -230,12 +230,11 @@ static const struct ata_port_info pdc_port_info[] = {
 };
 static const struct pci_device_id pdc_sata_pci_tbl[] = {
-        { PCI_VENDOR_ID_PROMISE, 0x6622, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+        { PCI_VDEVICE(PROMISE, 0x6622), board_20621 },
-          board_20621 },
        { }     /* terminate list */
 };
 static struct pci_driver pdc_sata_pci_driver = {
        .name                   = DRV_NAME,
        .id_table               = pdc_sata_pci_tbl,
diff --git a/drivers/ata/sata_uli.c b/drivers/ata/sata_uli.c
index dd76f37be18..5c603ca3a50 100644
--- a/drivers/ata/sata_uli.c
+++ b/drivers/ata/sata_uli.c
@@ -61,13 +61,13 @@ static u32 uli_scr_read (struct ata_port *ap, unsigned int sc_reg);
 static void uli_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 static const struct pci_device_id uli_pci_tbl[] = {
-        { PCI_VENDOR_ID_AL, 0x5289, PCI_ANY_ID, PCI_ANY_ID, 0, 0, uli_5289 },
+        { PCI_VDEVICE(AL, 0x5289), uli_5289 },
-        { PCI_VENDOR_ID_AL, 0x5287, PCI_ANY_ID, PCI_ANY_ID, 0, 0, uli_5287 },
+        { PCI_VDEVICE(AL, 0x5287), uli_5287 },
-        { PCI_VENDOR_ID_AL, 0x5281, PCI_ANY_ID, PCI_ANY_ID, 0, 0, uli_5281 },
+        { PCI_VDEVICE(AL, 0x5281), uli_5281 },
        { }     /* terminate list */
 };
 static struct pci_driver uli_pci_driver = {
        .name                   = DRV_NAME,
        .id_table               = uli_pci_tbl,
diff --git a/drivers/ata/sata_via.c b/drivers/ata/sata_via.c
index a72a2389a11..f4455a1efe2 100644
--- a/drivers/ata/sata_via.c
+++ b/drivers/ata/sata_via.c
@@ -77,9 +77,9 @@ static void svia_scr_write (struct ata_port *ap, unsigned int sc_reg, u32 val);
 static void vt6420_error_handler(struct ata_port *ap);
 static const struct pci_device_id svia_pci_tbl[] = {
-        { 0x1106, 0x0591, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6420 },
+        { PCI_VDEVICE(VIA, 0x0591), vt6420 },
-        { 0x1106, 0x3149, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6420 },
+        { PCI_VDEVICE(VIA, 0x3149), vt6420 },
-        { 0x1106, 0x3249, PCI_ANY_ID, PCI_ANY_ID, 0, 0, vt6421 },
+        { PCI_VDEVICE(VIA, 0x3249), vt6421 },
        { }     /* terminate list */
 };
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index d0d92f33de5..273d88fcf98 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -442,16 +442,15 @@ err_out:
        return rc;
 }
 static const struct pci_device_id vsc_sata_pci_tbl[] = {
        { PCI_VENDOR_ID_VITESSE, 0x7174,
          PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
        { PCI_VENDOR_ID_INTEL, 0x3200,
          PCI_ANY_ID, PCI_ANY_ID, 0x10600, 0xFFFFFF, 0 },
        { }     /* terminate list */
 };
 static struct pci_driver vsc_sata_pci_driver = {
        .name                   = DRV_NAME,
        .id_table               = vsc_sata_pci_tbl,
@@ -459,19 +458,16 @@ static struct pci_driver vsc_sata_pci_driver = {
        .remove                 = ata_pci_remove_one,
 };
 static int __init vsc_sata_init(void)
 {
        return pci_register_driver(&vsc_sata_pci_driver);
 }
 static void __exit vsc_sata_exit(void)
 {
        pci_unregister_driver(&vsc_sata_pci_driver);
 }
 MODULE_AUTHOR("Jeremy Higdon");
 MODULE_DESCRIPTION("low-level driver for Vitesse VSC7174 SATA controller");
 MODULE_LICENSE("GPL");
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index a6b2aa67c9b..f2904f67af4 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -62,6 +62,8 @@
 #include <asm/uaccess.h>
+#define DRIVER_NAME     "pktcdvd"
 #if PACKET_DEBUG
 #define DPRINTK(fmt, args...) printk(KERN_NOTICE fmt, ##args)
 #else
@@ -80,7 +82,7 @@
 static struct pktcdvd_device *pkt_devs[MAX_WRITERS];
 static struct proc_dir_entry *pkt_proc;
-static int pkt_major;
+static int pktdev_major;
 static struct mutex ctl_mutex;  /* Serialize open/close/setup/teardown */
 static mempool_t *psd_pool;
@@ -89,7 +91,7 @@ static void pkt_bio_finished(struct pktcdvd_device *pd)
 {
        BUG_ON(atomic_read(&pd->cdrw.pending_bios) <= 0);
        if (atomic_dec_and_test(&pd->cdrw.pending_bios)) {
-                VPRINTK("pktcdvd: queue empty\n");
+                VPRINTK(DRIVER_NAME": queue empty\n");
                atomic_set(&pd->iosched.attention, 1);
                wake_up(&pd->wqueue);
        }
@@ -400,7 +402,7 @@ static void pkt_dump_sense(struct packet_command *cgc)
        int i;
        struct request_sense *sense = cgc->sense;
-        printk("pktcdvd:");
+        printk(DRIVER_NAME":");
        for (i = 0; i < CDROM_PACKET_SIZE; i++)
                printk(" %02x", cgc->cmd[i]);
        printk(" - ");
@@ -528,7 +530,7 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                                need_write_seek = 0;
                        if (need_write_seek && reads_queued) {
                                if (atomic_read(&pd->cdrw.pending_bios) > 0) {
-                                        VPRINTK("pktcdvd: write, waiting\n");
+                                        VPRINTK(DRIVER_NAME": write, waiting\n");
                                        break;
                                }
                                pkt_flush_cache(pd);
@@ -537,7 +539,7 @@ static void pkt_iosched_process_queue(struct pktcdvd_device *pd)
                } else {
                        if (!reads_queued && writes_queued) {
                                if (atomic_read(&pd->cdrw.pending_bios) > 0) {
-                                        VPRINTK("pktcdvd: read, waiting\n");
+                                        VPRINTK(DRIVER_NAME": read, waiting\n");
                                        break;
                                }
                                pd->iosched.writing = 1;
@@ -600,7 +602,7 @@ static int pkt_set_segment_merging(struct pktcdvd_device *pd, request_queue_t *q
                set_bit(PACKET_MERGE_SEGS, &pd->flags);
                return 0;
        } else {
-                printk("pktcdvd: cdrom max_phys_segments too small\n");
+                printk(DRIVER_NAME": cdrom max_phys_segments too small\n");
                return -EIO;
        }
 }
@@ -1049,7 +1051,7 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
        for (f = 0; f < pkt->frames; f++)
                if (!bio_add_page(pkt->w_bio, bvec[f].bv_page, CD_FRAMESIZE, bvec[f].bv_offset))
                        BUG();
-        VPRINTK("pktcdvd: vcnt=%d\n", pkt->w_bio->bi_vcnt);
+        VPRINTK(DRIVER_NAME": vcnt=%d\n", pkt->w_bio->bi_vcnt);
        atomic_set(&pkt->io_wait, 1);
        pkt->w_bio->bi_rw = WRITE;
@@ -1286,7 +1288,7 @@ work_to_do:
 static void pkt_print_settings(struct pktcdvd_device *pd)
 {
-        printk("pktcdvd: %s packets, ", pd->settings.fp ? "Fixed" : "Variable");
+        printk(DRIVER_NAME": %s packets, ", pd->settings.fp ? "Fixed" : "Variable");
        printk("%u blocks, ", pd->settings.size >> 2);
        printk("Mode-%c disc\n", pd->settings.block_mode == 8 ? '1' : '2');
 }
@@ -1471,7 +1473,7 @@ static int pkt_set_write_settings(struct pktcdvd_device *pd)
                /*
                 * paranoia
                 */
-                printk("pktcdvd: write mode wrong %d\n", wp->data_block_type);
+                printk(DRIVER_NAME": write mode wrong %d\n", wp->data_block_type);
                return 1;
        }
        wp->packet_size = cpu_to_be32(pd->settings.size >> 2);
@@ -1515,7 +1517,7 @@ static int pkt_writable_track(struct pktcdvd_device *pd, track_information *ti)
        if (ti->rt == 1 && ti->blank == 0)
                return 1;
-        printk("pktcdvd: bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet);
+        printk(DRIVER_NAME": bad state %d-%d-%d\n", ti->rt, ti->blank, ti->packet);
        return 0;
 }
@@ -1533,7 +1535,7 @@ static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
                case 0x12: /* DVD-RAM */
                        return 1;
                default:
-                        VPRINTK("pktcdvd: Wrong disc profile (%x)\n", pd->mmc3_profile);
+                        VPRINTK(DRIVER_NAME": Wrong disc profile (%x)\n", pd->mmc3_profile);
                        return 0;
        }
@@ -1542,22 +1544,22 @@ static int pkt_writable_disc(struct pktcdvd_device *pd, disc_information *di)
         * but i'm not sure, should we leave this to user apps? probably.
         */
        if (di->disc_type == 0xff) {
-                printk("pktcdvd: Unknown disc. No track?\n");
+                printk(DRIVER_NAME": Unknown disc. No track?\n");
                return 0;
        }
        if (di->disc_type != 0x20 && di->disc_type != 0) {
-                printk("pktcdvd: Wrong disc type (%x)\n", di->disc_type);
+                printk(DRIVER_NAME": Wrong disc type (%x)\n", di->disc_type);
                return 0;
        }
        if (di->erasable == 0) {
-                printk("pktcdvd: Disc not erasable\n");
+                printk(DRIVER_NAME": Disc not erasable\n");
                return 0;
        }
        if (di->border_status == PACKET_SESSION_RESERVED) {
-                printk("pktcdvd: Can't write to last track (reserved)\n");
+                printk(DRIVER_NAME": Can't write to last track (reserved)\n");
                return 0;
        }
@@ -1593,12 +1595,12 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
        track = 1; /* (di.last_track_msb << 8) | di.last_track_lsb; */
        if ((ret = pkt_get_track_info(pd, track, 1, &ti))) {
-                printk("pktcdvd: failed get_track\n");
+                printk(DRIVER_NAME": failed get_track\n");
                return ret;
        }
        if (!pkt_writable_track(pd, &ti)) {
-                printk("pktcdvd: can't write to this track\n");
+                printk(DRIVER_NAME": can't write to this track\n");
                return -EROFS;
        }
@@ -1608,11 +1610,11 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
         */
        pd->settings.size = be32_to_cpu(ti.fixed_packet_size) << 2;
        if (pd->settings.size == 0) {
-                printk("pktcdvd: detected zero packet size!\n");
+                printk(DRIVER_NAME": detected zero packet size!\n");
                return -ENXIO;
        }
        if (pd->settings.size > PACKET_MAX_SECTORS) {
-                printk("pktcdvd: packet size is too big\n");
+                printk(DRIVER_NAME": packet size is too big\n");
                return -EROFS;
        }
        pd->settings.fp = ti.fp;
@@ -1654,7 +1656,7 @@ static int pkt_probe_settings(struct pktcdvd_device *pd)
                        pd->settings.block_mode = PACKET_BLOCK_MODE2;
                        break;
                default:
-                        printk("pktcdvd: unknown data mode\n");
+                        printk(DRIVER_NAME": unknown data mode\n");
                        return -EROFS;
        }
        return 0;
@@ -1688,10 +1690,10 @@ static int pkt_write_caching(struct pktcdvd_device *pd, int set)
        cgc.buflen = cgc.cmd[8] = 2 + ((buf[0] << 8) | (buf[1] & 0xff));
        ret = pkt_mode_select(pd, &cgc);
        if (ret) {
-                printk("pktcdvd: write caching control failed\n");
+                printk(DRIVER_NAME": write caching control failed\n");
                pkt_dump_sense(&cgc);
        } else if (!ret && set)
-                printk("pktcdvd: enabled write caching on %s\n", pd->name);
+                printk(DRIVER_NAME": enabled write caching on %s\n", pd->name);
        return ret;
 }
@@ -1805,11 +1807,11 @@ static int pkt_media_speed(struct pktcdvd_device *pd, unsigned *speed)
        }
        if (!buf[6] & 0x40) {
-                printk("pktcdvd: Disc type is not CD-RW\n");
+                printk(DRIVER_NAME": Disc type is not CD-RW\n");
                return 1;
        }
        if (!buf[6] & 0x4) {
-                printk("pktcdvd: A1 values on media are not valid, maybe not CDRW?\n");
+                printk(DRIVER_NAME": A1 values on media are not valid, maybe not CDRW?\n");
                return 1;
        }
@@ -1829,14 +1831,14 @@ static int pkt_media_speed(struct pktcdvd_device *pd, unsigned *speed)
                        *speed = us_clv_to_speed[sp];
                        break;
                default:
-                        printk("pktcdvd: Unknown disc sub-type %d\n",st);
+                        printk(DRIVER_NAME": Unknown disc sub-type %d\n",st);
                        return 1;
        }
        if (*speed) {
-                printk("pktcdvd: Max. media speed: %d\n",*speed);
+                printk(DRIVER_NAME": Max. media speed: %d\n",*speed);
                return 0;
        } else {
-                printk("pktcdvd: Unknown speed %d for sub-type %d\n",sp,st);
+                printk(DRIVER_NAME": Unknown speed %d for sub-type %d\n",sp,st);
                return 1;
        }
 }
@@ -1847,7 +1849,7 @@ static int pkt_perform_opc(struct pktcdvd_device *pd)
        struct request_sense sense;
        int ret;
-        VPRINTK("pktcdvd: Performing OPC\n");
+        VPRINTK(DRIVER_NAME": Performing OPC\n");
        init_cdrom_command(&cgc, NULL, 0, CGC_DATA_NONE);
        cgc.sense = &sense;
@@ -1865,12 +1867,12 @@ static int pkt_open_write(struct pktcdvd_device *pd)
        unsigned int write_speed, media_write_speed, read_speed;
        if ((ret = pkt_probe_settings(pd))) {
-                VPRINTK("pktcdvd: %s failed probe\n", pd->name);
+                VPRINTK(DRIVER_NAME": %s failed probe\n", pd->name);
                return ret;
        }
        if ((ret = pkt_set_write_settings(pd))) {
-                DPRINTK("pktcdvd: %s failed saving write settings\n", pd->name);
+                DPRINTK(DRIVER_NAME": %s failed saving write settings\n", pd->name);
                return -EIO;
        }
@@ -1882,26 +1884,26 @@ static int pkt_open_write(struct pktcdvd_device *pd)
                case 0x13: /* DVD-RW */
                case 0x1a: /* DVD+RW */
                case 0x12: /* DVD-RAM */
-                        DPRINTK("pktcdvd: write speed %ukB/s\n", write_speed);
+                        DPRINTK(DRIVER_NAME": write speed %ukB/s\n", write_speed);
                        break;
                default:
                        if ((ret = pkt_media_speed(pd, &media_write_speed)))
                                media_write_speed = 16;
                        write_speed = min(write_speed, media_write_speed * 177);
-                        DPRINTK("pktcdvd: write speed %ux\n", write_speed / 176);
+                        DPRINTK(DRIVER_NAME": write speed %ux\n", write_speed / 176);
                        break;
        }
        read_speed = write_speed;
        if ((ret = pkt_set_speed(pd, write_speed, read_speed))) {
-                DPRINTK("pktcdvd: %s couldn't set write speed\n", pd->name);
+                DPRINTK(DRIVER_NAME": %s couldn't set write speed\n", pd->name);
                return -EIO;
        }
        pd->write_speed = write_speed;
        pd->read_speed = read_speed;
        if ((ret = pkt_perform_opc(pd))) {
-                DPRINTK("pktcdvd: %s Optimum Power Calibration failed\n", pd->name);
+                DPRINTK(DRIVER_NAME": %s Optimum Power Calibration failed\n", pd->name);
        }
        return 0;
@@ -1929,7 +1931,7 @@ static int pkt_open_dev(struct pktcdvd_device *pd, int write)
                goto out_putdev;
        if ((ret = pkt_get_last_written(pd, &lba))) {
-                printk("pktcdvd: pkt_get_last_written failed\n");
+                printk(DRIVER_NAME": pkt_get_last_written failed\n");
                goto out_unclaim;
        }
@@ -1959,11 +1961,11 @@ static int pkt_open_dev(struct pktcdvd_device *pd, int write)
        if (write) {
                if (!pkt_grow_pktlist(pd, CONFIG_CDROM_PKTCDVD_BUFFERS)) {
-                        printk("pktcdvd: not enough memory for buffers\n");
+                        printk(DRIVER_NAME": not enough memory for buffers\n");
                        ret = -ENOMEM;
                        goto out_unclaim;
                }
-                printk("pktcdvd: %lukB available on disc\n", lba << 1);
+                printk(DRIVER_NAME": %lukB available on disc\n", lba << 1);
        }
        return 0;
@@ -1983,7 +1985,7 @@ out:
 static void pkt_release_dev(struct pktcdvd_device *pd, int flush)
 {
        if (flush && pkt_flush_cache(pd))
-                DPRINTK("pktcdvd: %s not flushing cache\n", pd->name);
+                DPRINTK(DRIVER_NAME": %s not flushing cache\n", pd->name);
        pkt_lock_door(pd, 0);
@@ -2006,7 +2008,7 @@ static int pkt_open(struct inode *inode, struct file *file)
        struct pktcdvd_device *pd = NULL;
        int ret;
-        VPRINTK("pktcdvd: entering open\n");
+        VPRINTK(DRIVER_NAME": entering open\n");
        mutex_lock(&ctl_mutex);
        pd = pkt_find_dev_from_minor(iminor(inode));
@@ -2040,7 +2042,7 @@ static int pkt_open(struct inode *inode, struct file *file)
 out_dec:
        pd->refcnt--;
 out:
-        VPRINTK("pktcdvd: failed open (%d)\n", ret);
+        VPRINTK(DRIVER_NAME": failed open (%d)\n", ret);
        mutex_unlock(&ctl_mutex);
        return ret;
 }
@@ -2088,7 +2090,7 @@ static int pkt_make_request(request_queue_t *q, struct bio *bio)
        pd = q->queuedata;
        if (!pd) {
-                printk("pktcdvd: %s incorrect request queue\n", bdevname(bio->bi_bdev, b));
+                printk(DRIVER_NAME": %s incorrect request queue\n", bdevname(bio->bi_bdev, b));
                goto end_io;
        }
@@ -2110,13 +2112,13 @@ static int pkt_make_request(request_queue_t *q, struct bio *bio)
        }
        if (!test_bit(PACKET_WRITABLE, &pd->flags)) {
-                printk("pktcdvd: WRITE for ro device %s (%llu)\n",
+                printk(DRIVER_NAME": WRITE for ro device %s (%llu)\n",
                        pd->name, (unsigned long long)bio->bi_sector);
                goto end_io;
        }
        if (!bio->bi_size || (bio->bi_size % CD_FRAMESIZE)) {
-                printk("pktcdvd: wrong bio size\n");
+                printk(DRIVER_NAME": wrong bio size\n");
                goto end_io;
        }
@@ -2319,7 +2321,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
        struct block_device *bdev;
        if (pd->pkt_dev == dev) {
-                printk("pktcdvd: Recursive setup not allowed\n");
+                printk(DRIVER_NAME": Recursive setup not allowed\n");
                return -EBUSY;
        }
        for (i = 0; i < MAX_WRITERS; i++) {
@@ -2327,11 +2329,11 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
                if (!pd2)
                        continue;
                if (pd2->bdev->bd_dev == dev) {
-                        printk("pktcdvd: %s already setup\n", bdevname(pd2->bdev, b));
+                        printk(DRIVER_NAME": %s already setup\n", bdevname(pd2->bdev, b));
                        return -EBUSY;
                }
                if (pd2->pkt_dev == dev) {
-                        printk("pktcdvd: Can't chain pktcdvd devices\n");
+                        printk(DRIVER_NAME": Can't chain pktcdvd devices\n");
                        return -EBUSY;
                }
        }
@@ -2354,7 +2356,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
        atomic_set(&pd->cdrw.pending_bios, 0);
        pd->cdrw.thread = kthread_run(kcdrwd, pd, "%s", pd->name);
        if (IS_ERR(pd->cdrw.thread)) {
-                printk("pktcdvd: can't start kernel thread\n");
+                printk(DRIVER_NAME": can't start kernel thread\n");
                ret = -ENOMEM;
                goto out_mem;
        }
@@ -2364,7 +2366,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
                proc->data = pd;
                proc->proc_fops = &pkt_proc_fops;
        }
-        DPRINTK("pktcdvd: writer %s mapped to %s\n", pd->name, bdevname(bdev, b));
+        DPRINTK(DRIVER_NAME": writer %s mapped to %s\n", pd->name, bdevname(bdev, b));
        return 0;
 out_mem:
@@ -2401,7 +2403,7 @@ static int pkt_ioctl(struct inode *inode, struct file *file, unsigned int cmd, u
                return blkdev_ioctl(pd->bdev->bd_inode, file, cmd, arg);
        default:
-                VPRINTK("pktcdvd: Unknown ioctl for %s (%x)\n", pd->name, cmd);
+                VPRINTK(DRIVER_NAME": Unknown ioctl for %s (%x)\n", pd->name, cmd);
                return -ENOTTY;
        }
@@ -2446,7 +2448,7 @@ static int pkt_setup_dev(struct pkt_ctrl_command *ctrl_cmd)
                if (!pkt_devs[idx])
                        break;
        if (idx == MAX_WRITERS) {
-                printk("pktcdvd: max %d writers supported\n", MAX_WRITERS);
+                printk(DRIVER_NAME": max %d writers supported\n", MAX_WRITERS);
                return -EBUSY;
        }
@@ -2470,15 +2472,15 @@ static int pkt_setup_dev(struct pkt_ctrl_command *ctrl_cmd)
        spin_lock_init(&pd->lock);
        spin_lock_init(&pd->iosched.lock);
-        sprintf(pd->name, "pktcdvd%d", idx);
+        sprintf(pd->name, DRIVER_NAME"%d", idx);
        init_waitqueue_head(&pd->wqueue);
        pd->bio_queue = RB_ROOT;
-        disk->major = pkt_major;
+        disk->major = pktdev_major;
        disk->first_minor = idx;
        disk->fops = &pktcdvd_ops;
        disk->flags = GENHD_FL_REMOVABLE;
-        sprintf(disk->disk_name, "pktcdvd%d", idx);
+        sprintf(disk->disk_name, DRIVER_NAME"%d", idx);
        disk->private_data = pd;
        disk->queue = blk_alloc_queue(GFP_KERNEL);
        if (!disk->queue)
@@ -2520,7 +2522,7 @@ static int pkt_remove_dev(struct pkt_ctrl_command *ctrl_cmd)
                        break;
        }
        if (idx == MAX_WRITERS) {
-                DPRINTK("pktcdvd: dev not setup\n");
+                DPRINTK(DRIVER_NAME": dev not setup\n");
                return -ENXIO;
        }
@@ -2533,7 +2535,7 @@ static int pkt_remove_dev(struct pkt_ctrl_command *ctrl_cmd)
        blkdev_put(pd->bdev);
        remove_proc_entry(pd->name, pkt_proc);
-        DPRINTK("pktcdvd: writer %s unmapped\n", pd->name);
+        DPRINTK(DRIVER_NAME": writer %s unmapped\n", pd->name);
        del_gendisk(pd->disk);
        blk_cleanup_queue(pd->disk->queue);
@@ -2610,7 +2612,7 @@ static struct file_operations pkt_ctl_fops = {
 static struct miscdevice pkt_misc = {
        .minor          = MISC_DYNAMIC_MINOR,
-        .name           = "pktcdvd",
+        .name           = DRIVER_NAME,
        .fops           = &pkt_ctl_fops
 };
@@ -2623,28 +2625,28 @@ static int __init pkt_init(void)
        if (!psd_pool)
                return -ENOMEM;
-        ret = register_blkdev(pkt_major, "pktcdvd");
+        ret = register_blkdev(pktdev_major, DRIVER_NAME);
        if (ret < 0) {
-                printk("pktcdvd: Unable to register block device\n");
+                printk(DRIVER_NAME": Unable to register block device\n");
                goto out2;
        }
-        if (!pkt_major)
+        if (!pktdev_major)
-                pkt_major = ret;
+                pktdev_major = ret;
        ret = misc_register(&pkt_misc);
        if (ret) {
-                printk("pktcdvd: Unable to register misc device\n");
+                printk(DRIVER_NAME": Unable to register misc device\n");
                goto out;
        }
        mutex_init(&ctl_mutex);
-        pkt_proc = proc_mkdir("pktcdvd", proc_root_driver);
+        pkt_proc = proc_mkdir(DRIVER_NAME, proc_root_driver);
        return 0;
 out:
-        unregister_blkdev(pkt_major, "pktcdvd");
+        unregister_blkdev(pktdev_major, DRIVER_NAME);
 out2:
        mempool_destroy(psd_pool);
        return ret;
@@ -2652,9 +2654,9 @@ out2:
 static void __exit pkt_exit(void)
 {
-        remove_proc_entry("pktcdvd", proc_root_driver);
+        remove_proc_entry(DRIVER_NAME, proc_root_driver);
        misc_deregister(&pkt_misc);
-        unregister_blkdev(pkt_major, "pktcdvd");
+        unregister_blkdev(pktdev_major, DRIVER_NAME);
        mempool_destroy(psd_pool);
 }
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index f2305ee792a..fdc8f892eb8 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -636,7 +636,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
        intr = in_8(&sw->intr);
        err = (intr & ERROR_INTR)? in_8(&sw->error): 0;
        if ((intr & ERROR_INTR) && fs->state != do_transfer)
-                printk(KERN_ERR "swim3_interrupt, state=%d, dir=%lx, intr=%x, err=%x\n",
+                printk(KERN_ERR "swim3_interrupt, state=%d, dir=%x, intr=%x, err=%x\n",
                       fs->state, rq_data_dir(fd_req), intr, err);
        switch (fs->state) {
        case locating:
@@ -742,7 +742,7 @@ static irqreturn_t swim3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
                        if ((stat & ACTIVE) == 0 || resid != 0) {
                                /* musta been an error */
                                printk(KERN_ERR "swim3: fd dma: stat=%x resid=%d\n", stat, resid);
-                                printk(KERN_ERR "  state=%d, dir=%lx, intr=%x, err=%x\n",
+                                printk(KERN_ERR "  state=%d, dir=%x, intr=%x, err=%x\n",
                                       fs->state, rq_data_dir(fd_req), intr, err);
                                end_request(fd_req, 0);
                                fs->state = idle;
diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 22f8cf218cc..c603bf29158 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -1,6 +1,6 @@
 config AGP
        tristate "/dev/agpgart (AGP Support)"
-        depends on ALPHA || IA64 || PPC || X86
+        depends on ALPHA || IA64 || PARISC || PPC || X86
        depends on PCI
        ---help---
          AGP (Accelerated Graphics Port) is a bus system mainly used to
@@ -122,6 +122,14 @@ config AGP_HP_ZX1
          This option gives you AGP GART support for the HP ZX1 chipset
          for IA64 processors.
+config AGP_PARISC
+        tristate "HP Quicksilver AGP support"
+        depends on AGP && PARISC && 64BIT
+        help
+          This option gives you AGP GART support for the HP Quicksilver
+          AGP bus adapter on HP PA-RISC machines (Ok, just on the C8000
+          workstation...)
 config AGP_ALPHA_CORE
        tristate "Alpha AGP support"
        depends on AGP && (ALPHA_GENERIC || ALPHA_TITAN || ALPHA_MARVEL)
diff --git a/drivers/char/agp/Makefile b/drivers/char/agp/Makefile
index d33a22f2fa0..3e581603d0a 100644
--- a/drivers/char/agp/Makefile
+++ b/drivers/char/agp/Makefile
@@ -8,6 +8,7 @@ obj-$(CONFIG_AGP_AMD64)		+= amd64-agp.o
 obj-$(CONFIG_AGP_ALPHA_CORE)    += alpha-agp.o
 obj-$(CONFIG_AGP_EFFICEON)      += efficeon-agp.o
 obj-$(CONFIG_AGP_HP_ZX1)        += hp-agp.o
+obj-$(CONFIG_AGP_PARISC)        += parisc-agp.o
 obj-$(CONFIG_AGP_I460)          += i460-agp.o
 obj-$(CONFIG_AGP_INTEL)         += intel-agp.o
 obj-$(CONFIG_AGP_NVIDIA)        += nvidia-agp.o
diff --git a/drivers/char/agp/parisc-agp.c b/drivers/char/agp/parisc-agp.c
new file mode 100644
index 00000000000..17c50b0f83f
--- /dev/null
+++ b/drivers/char/agp/parisc-agp.c
@@ -0,0 +1,416 @@
+/*
+ * HP Quicksilver AGP GART routines
+ *
+ * Copyright (c) 2006, Kyle McMartin <kyle@parisc-linux.org>
+ *
+ * Based on drivers/char/agpgart/hp-agp.c which is
+ * (c) Copyright 2002, 2003 Hewlett-Packard Development Company, L.P.
+ *      Bjorn Helgaas <bjorn.helgaas@hp.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/init.h>
+#include <linux/klist.h>
+#include <linux/agp_backend.h>
+#include <asm-parisc/parisc-device.h>
+#include <asm-parisc/ropes.h>
+#include "agp.h"
+#define DRVNAME "quicksilver"
+#define DRVPFX  DRVNAME ": "
+#ifndef log2
+#define log2(x)         ffz(~(x))
+#endif
+#define AGP8X_MODE_BIT          3
+#define AGP8X_MODE              (1 << AGP8X_MODE_BIT)
+static struct _parisc_agp_info {
+        void __iomem *ioc_regs;
+        void __iomem *lba_regs;
+        int lba_cap_offset;
+        u64 *gatt;
+        u64 gatt_entries;
+        u64 gart_base;
+        u64 gart_size;
+        int io_page_size;
+        int io_pages_per_kpage;
+} parisc_agp_info;
+static struct gatt_mask parisc_agp_masks[] =
+{
+        {
+                .mask = SBA_PDIR_VALID_BIT,
+                .type = 0
+        }
+};
+static struct aper_size_info_fixed parisc_agp_sizes[] =
+{
+        {0, 0, 0},              /* filled in by parisc_agp_fetch_size() */
+};
+static int
+parisc_agp_fetch_size(void)
+{
+        int size;
+        size = parisc_agp_info.gart_size / MB(1);
+        parisc_agp_sizes[0].size = size;
+        agp_bridge->current_size = (void *) &parisc_agp_sizes[0];
+        return size;
+}
+static int
+parisc_agp_configure(void)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        agp_bridge->gart_bus_addr = info->gart_base;
+        agp_bridge->capndx = info->lba_cap_offset;
+        agp_bridge->mode = readl(info->lba_regs+info->lba_cap_offset+PCI_AGP_STATUS);
+        return 0;
+}
+static void
+parisc_agp_tlbflush(struct agp_memory *mem)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        writeq(info->gart_base | log2(info->gart_size), info->ioc_regs+IOC_PCOM);
+        readq(info->ioc_regs+IOC_PCOM); /* flush */
+}
+static int
+parisc_agp_create_gatt_table(struct agp_bridge_data *bridge)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int i;
+        for (i = 0; i < info->gatt_entries; i++) {
+                info->gatt[i] = (unsigned long)agp_bridge->scratch_page;
+        }
+        return 0;
+}
+static int
+parisc_agp_free_gatt_table(struct agp_bridge_data *bridge)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        info->gatt[0] = SBA_AGPGART_COOKIE;
+        return 0;
+}
+static int
+parisc_agp_insert_memory(struct agp_memory *mem, off_t pg_start, int type)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int i, k;
+        off_t j, io_pg_start;
+        int io_pg_count;
+        if (type != 0 || mem->type != 0) {
+                return -EINVAL;
+        }
+        io_pg_start = info->io_pages_per_kpage * pg_start;
+        io_pg_count = info->io_pages_per_kpage * mem->page_count;
+        if ((io_pg_start + io_pg_count) > info->gatt_entries) {
+                return -EINVAL;
+        }
+        j = io_pg_start;
+        while (j < (io_pg_start + io_pg_count)) {
+                if (info->gatt[j])
+                        return -EBUSY;
+                j++;
+        }
+        if (mem->is_flushed == FALSE) {
+                global_cache_flush();
+                mem->is_flushed = TRUE;
+        }
+        for (i = 0, j = io_pg_start; i < mem->page_count; i++) {
+                unsigned long paddr;
+                paddr = mem->memory[i];
+                for (k = 0;
+                     k < info->io_pages_per_kpage;
+                     k++, j++, paddr += info->io_page_size) {
+                        info->gatt[j] =
+                                agp_bridge->driver->mask_memory(agp_bridge,
+                                        paddr, type);
+                }
+        }
+        agp_bridge->driver->tlb_flush(mem);
+        return 0;
+}
+static int
+parisc_agp_remove_memory(struct agp_memory *mem, off_t pg_start, int type)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int i, io_pg_start, io_pg_count;
+        if (type != 0 || mem->type != 0) {
+                return -EINVAL;
+        }
+        io_pg_start = info->io_pages_per_kpage * pg_start;
+        io_pg_count = info->io_pages_per_kpage * mem->page_count;
+        for (i = io_pg_start; i < io_pg_count + io_pg_start; i++) {
+                info->gatt[i] = agp_bridge->scratch_page;
+        }
+        agp_bridge->driver->tlb_flush(mem);
+        return 0;
+}
+static unsigned long
+parisc_agp_mask_memory(struct agp_bridge_data *bridge,
+                    unsigned long addr, int type)
+{
+        return SBA_PDIR_VALID_BIT | addr;
+}
+static void
+parisc_agp_enable(struct agp_bridge_data *bridge, u32 mode)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        u32 command;
+        command = readl(info->lba_regs + info->lba_cap_offset + PCI_AGP_STATUS);
+        command = agp_collect_device_status(bridge, mode, command);
+        command |= 0x00000100;
+        writel(command, info->lba_regs + info->lba_cap_offset + PCI_AGP_COMMAND);
+        agp_device_command(command, (mode & AGP8X_MODE) != 0);
+}
+struct agp_bridge_driver parisc_agp_driver = {
+        .owner                  = THIS_MODULE,
+        .size_type              = FIXED_APER_SIZE,
+        .configure              = parisc_agp_configure,
+        .fetch_size             = parisc_agp_fetch_size,
+        .tlb_flush              = parisc_agp_tlbflush,
+        .mask_memory            = parisc_agp_mask_memory,
+        .masks                  = parisc_agp_masks,
+        .agp_enable             = parisc_agp_enable,
+        .cache_flush            = global_cache_flush,
+        .create_gatt_table      = parisc_agp_create_gatt_table,
+        .free_gatt_table        = parisc_agp_free_gatt_table,
+        .insert_memory          = parisc_agp_insert_memory,
+        .remove_memory          = parisc_agp_remove_memory,
+        .alloc_by_type          = agp_generic_alloc_by_type,
+        .free_by_type           = agp_generic_free_by_type,
+        .agp_alloc_page         = agp_generic_alloc_page,
+        .agp_destroy_page       = agp_generic_destroy_page,
+        .cant_use_aperture      = 1,
+};
+static int __init
+agp_ioc_init(void __iomem *ioc_regs)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        u64 *iova_base, *io_pdir, io_tlb_ps;
+        int io_tlb_shift;
+        printk(KERN_INFO DRVPFX "IO PDIR shared with sba_iommu\n");
+        info->ioc_regs = ioc_regs;
+        io_tlb_ps = readq(info->ioc_regs+IOC_TCNFG);
+        switch (io_tlb_ps) {
+        case 0: io_tlb_shift = 12; break;
+        case 1: io_tlb_shift = 13; break;
+        case 2: io_tlb_shift = 14; break;
+        case 3: io_tlb_shift = 16; break;
+        default:
+                printk(KERN_ERR DRVPFX "Invalid IOTLB page size "
+                       "configuration 0x%llx\n", io_tlb_ps);
+                info->gatt = NULL;
+                info->gatt_entries = 0;
+                return -ENODEV;
+        }
+        info->io_page_size = 1 << io_tlb_shift;
+        info->io_pages_per_kpage = PAGE_SIZE / info->io_page_size;
+        iova_base = readq(info->ioc_regs+IOC_IBASE) & ~0x1;
+        info->gart_base = iova_base + PLUTO_IOVA_SIZE - PLUTO_GART_SIZE;
+        info->gart_size = PLUTO_GART_SIZE;
+        info->gatt_entries = info->gart_size / info->io_page_size;
+        io_pdir = phys_to_virt(readq(info->ioc_regs+IOC_PDIR_BASE));
+        info->gatt = &io_pdir[(PLUTO_IOVA_SIZE/2) >> PAGE_SHIFT];
+        if (info->gatt[0] != SBA_AGPGART_COOKIE) {
+                info->gatt = NULL;
+                info->gatt_entries = 0;
+                printk(KERN_ERR DRVPFX "No reserved IO PDIR entry found; "
+                       "GART disabled\n");
+                return -ENODEV;
+        }
+        return 0;
+}
+static int
+lba_find_capability(int cap)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        u16 status;
+        u8 pos, id;
+        int ttl = 48;
+        status = readw(info->lba_regs + PCI_STATUS);
+        if (!(status & PCI_STATUS_CAP_LIST))
+                return 0;
+        pos = readb(info->lba_regs + PCI_CAPABILITY_LIST);
+        while (ttl-- && pos >= 0x40) {
+                pos &= ~3;
+                id = readb(info->lba_regs + pos + PCI_CAP_LIST_ID);
+                if (id == 0xff)
+                        break;
+                if (id == cap)
+                        return pos;
+                pos = readb(info->lba_regs + pos + PCI_CAP_LIST_NEXT);
+        }
+        return 0;
+}
+static int __init
+agp_lba_init(void __iomem *lba_hpa)
+{
+        struct _parisc_agp_info *info = &parisc_agp_info;
+        int cap;
+        info->lba_regs = lba_hpa;
+        info->lba_cap_offset = lba_find_capability(PCI_CAP_ID_AGP);
+        cap = readl(lba_hpa + info->lba_cap_offset) & 0xff;
+        if (cap != PCI_CAP_ID_AGP) {
+                printk(KERN_ERR DRVPFX "Invalid capability ID 0x%02x at 0x%x\n",
+                       cap, info->lba_cap_offset);
+                return -ENODEV;
+        }
+        return 0;
+}
+static int __init
+parisc_agp_setup(void __iomem *ioc_hpa, void __iomem *lba_hpa)
+{
+        struct pci_dev *fake_bridge_dev = NULL;
+        struct agp_bridge_data *bridge;
+        int error = 0;
+        fake_bridge_dev = kmalloc(sizeof (struct pci_dev), GFP_KERNEL);
+        if (!fake_bridge_dev) {
+                error = -ENOMEM;
+                goto fail;
+        }
+        error = agp_ioc_init(ioc_hpa);
+        if (error)
+                goto fail;
+        error = agp_lba_init(lba_hpa);
+        if (error)
+                goto fail;
+        bridge = agp_alloc_bridge();
+        if (!bridge) {
+                error = -ENOMEM;
+                goto fail;
+        }
+        bridge->driver = &parisc_agp_driver;
+        fake_bridge_dev->vendor = PCI_VENDOR_ID_HP;
+        fake_bridge_dev->device = PCI_DEVICE_ID_HP_PCIX_LBA;
+        bridge->dev = fake_bridge_dev;
+        error = agp_add_bridge(bridge);
+fail:
+        return error;
+}
+static struct device *next_device(struct klist_iter *i) {
+        struct klist_node * n = klist_next(i);
+        return n ? container_of(n, struct device, knode_parent) : NULL;
+}
+static int
+parisc_agp_init(void)
+{
+        extern struct sba_device *sba_list;
+        int err = -1;
+        struct parisc_device *sba = NULL, *lba = NULL;
+        struct lba_device *lbadev = NULL;
+        struct device *dev = NULL;
+        struct klist_iter i;
+        if (!sba_list)
+                goto out;
+        /* Find our parent Pluto */
+        sba = sba_list->dev;
+        if (!IS_PLUTO(sba)) {
+                printk(KERN_INFO DRVPFX "No Pluto found, so no AGPGART for you.\n");
+                goto out;
+        }
+        /* Now search our Pluto for our precious AGP device... */
+        klist_iter_init(&sba->dev.klist_children, &i);
+        while ((dev = next_device(&i))) {
+                struct parisc_device *padev = to_parisc_device(dev);
+                if (IS_QUICKSILVER(padev))
+                        lba = padev;
+        }
+        klist_iter_exit(&i);
+        if (!lba) {
+                printk(KERN_INFO DRVPFX "No AGP devices found.\n");
+                goto out;
+        }
+        lbadev = parisc_get_drvdata(lba);
+        /* w00t, let's go find our cookies... */
+        parisc_agp_setup(sba_list->ioc[0].ioc_hpa, lbadev->hba.base_addr);
+        return 0;
+out:
+        return err;
+}
+module_init(parisc_agp_init);
+MODULE_AUTHOR("Kyle McMartin <kyle@parisc-linux.org>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/char/amiserial.c b/drivers/char/amiserial.c
index d0e92ed0a36..486f97c3f4e 100644
--- a/drivers/char/amiserial.c
+++ b/drivers/char/amiserial.c
@@ -112,17 +112,6 @@ static struct serial_state rs_table[1];
 #define NR_PORTS ARRAY_SIZE(rs_table)
-/*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char *tmp_buf;
 #include <asm/uaccess.h>
 #define serial_isroot() (capable(CAP_SYS_ADMIN))
@@ -912,7 +901,7 @@ static int rs_write(struct tty_struct * tty, const unsigned char *buf, int count
        if (serial_paranoia_check(info, tty->name, "rs_write"))
                return 0;
-        if (!info->xmit.buf || !tmp_buf)
+        if (!info->xmit.buf)
                return 0;
        local_save_flags(flags);
@@ -1778,7 +1767,6 @@ static int rs_open(struct tty_struct *tty, struct file * filp)
 {
        struct async_struct     *info;
        int                     retval, line;
-        unsigned long           page;
        line = tty->index;
        if ((line < 0) || (line >= NR_PORTS)) {
@@ -1798,17 +1786,6 @@ static int rs_open(struct tty_struct *tty, struct file * filp)
 #endif
        info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
-        if (!tmp_buf) {
-                page = get_zeroed_page(GFP_KERNEL);
-                if (!page) {
-                        return -ENOMEM;
-                }
-                if (tmp_buf)
-                        free_page(page);
-                else
-                        tmp_buf = (unsigned char *) page;
-        }
        /*
         * If the port is the middle of closing, bail out now
         */
@@ -2090,11 +2067,6 @@ static __exit void rs_exit(void)
          kfree(info);
        }
-        if (tmp_buf) {
-                free_page((unsigned long) tmp_buf);
-                tmp_buf = NULL;
-        }
        release_mem_region(CUSTOM_PHYSADDR+0x30, 4);
 }
diff --git a/drivers/char/cyclades.c b/drivers/char/cyclades.c
index f85b4eb1661..87b2fb51087 100644
--- a/drivers/char/cyclades.c
+++ b/drivers/char/cyclades.c
@@ -748,18 +748,6 @@ static struct cyclades_port cy_port[NR_PORTS];
 static int cy_next_channel; /* next minor available */
 /*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ports, since it significantly saves
- * memory if large numbers of serial ports are open.  This buffer is
- * allocated when the first cy_open occurs.
- */
-static unsigned char *tmp_buf;
-/*
 * This is used to look up the divisor speeds and the timeouts
 * We're normally limited to 15 distinct baud rates.  The extra
 * are accessed via settings in info->flags.
@@ -2466,7 +2454,6 @@ cy_open(struct tty_struct *tty, struct file * filp)
 {
  struct cyclades_port  *info;
  int retval, line;
-  unsigned long page;
    line = tty->index;
    if ((line < 0) || (NR_PORTS <= line)){
@@ -2545,15 +2532,6 @@ cy_open(struct tty_struct *tty, struct file * filp)
    printk("cyc:cy_open (%d): incrementing count to %d\n",
        current->pid, info->count);
 #endif
-    if (!tmp_buf) {
-        page = get_zeroed_page(GFP_KERNEL);
-        if (!page)
-            return -ENOMEM;
-        if (tmp_buf)
-            free_page(page);
-        else
-            tmp_buf = (unsigned char *) page;
-    }
    /*
     * If the port is the middle of closing, bail out now
@@ -2832,7 +2810,7 @@ cy_write(struct tty_struct * tty, const unsigned char *buf, int count)
        return 0;
    }
        
-    if (!info->xmit_buf || !tmp_buf)
+    if (!info->xmit_buf)
        return 0;
    CY_LOCK(info, flags);
@@ -5490,10 +5468,6 @@ cy_cleanup_module(void)
 #endif
        }
    }
-    if (tmp_buf) {
-        free_page((unsigned long) tmp_buf);
-        tmp_buf = NULL;
-    }
 } /* cy_cleanup_module */
 module_init(cy_init);
diff --git a/drivers/char/epca.c b/drivers/char/epca.c
index 3baa2ab8cbd..c3f95583a12 100644
--- a/drivers/char/epca.c
+++ b/drivers/char/epca.c
@@ -1113,11 +1113,8 @@ static void __exit epca_module_exit(void)
                ch = card_ptr[crd];
                for (count = 0; count < bd->numports; count++, ch++) 
                { /* Begin for each port */
-                        if (ch) {
+                        if (ch && ch->tty)
-                                if (ch->tty)
+                                tty_hangup(ch->tty);
-                                        tty_hangup(ch->tty);
-                                kfree(ch->tmp_buf);
-                        }
                } /* End for each port */
        } /* End for each card */
        pci_unregister_driver (&epca_driver);
@@ -1635,16 +1632,6 @@ static void post_fep_init(unsigned int crd)
                init_waitqueue_head(&ch->close_wait);
                spin_unlock_irqrestore(&epca_lock, flags);
-                ch->tmp_buf = kmalloc(ch->txbufsize,GFP_KERNEL);
-                if (!ch->tmp_buf) {
-                        printk(KERN_ERR "POST FEP INIT : kmalloc failed for port 0x%x\n",i);
-                        release_region((int)bd->port, 4);
-                        while(i-- > 0)
-                                kfree((ch--)->tmp_buf);
-                        return;
-                } else
-                        memset((void *)ch->tmp_buf,0,ch->txbufsize);
        } /* End for each port */
        printk(KERN_INFO 
diff --git a/drivers/char/epca.h b/drivers/char/epca.h
index 456d6c8f94a..a297238cd3b 100644
--- a/drivers/char/epca.h
+++ b/drivers/char/epca.h
@@ -130,7 +130,6 @@ struct channel
        unsigned long  c_oflag;
        unsigned char __iomem *txptr;
        unsigned char __iomem *rxptr;
-        unsigned char *tmp_buf;
        struct board_info           *board;
        struct board_chan           __iomem *brdchan;
        struct digi_struct          digiext;
diff --git a/drivers/char/generic_serial.c b/drivers/char/generic_serial.c
index 4711d9b3a59..87127e49c0d 100644
--- a/drivers/char/generic_serial.c
+++ b/drivers/char/generic_serial.c
@@ -33,8 +33,6 @@
 #define DEBUG 
-static char *                  tmp_buf; 
 static int gs_debug;
 #ifdef DEBUG
@@ -205,7 +203,7 @@ int gs_write(struct tty_struct * tty,
        if (!tty) return -EIO;
        port = tty->driver_data;
-        if (!port || !port->xmit_buf || !tmp_buf)
+        if (!port || !port->xmit_buf)
                return -EIO;
        local_save_flags(flags);
@@ -837,24 +835,9 @@ void gs_set_termios (struct tty_struct * tty,
 int gs_init_port(struct gs_port *port)
 {
        unsigned long flags;
-        unsigned long page;
        func_enter ();
-        if (!tmp_buf) {
-                page = get_zeroed_page(GFP_KERNEL);
-                spin_lock_irqsave (&port->driver_lock, flags); /* Don't expect this to make a difference. */
-                if (tmp_buf)
-                        free_page(page);
-                else
-                        tmp_buf = (unsigned char *) page;
-                spin_unlock_irqrestore (&port->driver_lock, flags);
-                if (!tmp_buf) {
-                        func_exit ();
-                        return -ENOMEM;
-                }
-        }
        if (port->flags & ASYNC_INITIALIZED) {
                func_exit ();
                return 0;
diff --git a/drivers/char/hvc_iseries.c b/drivers/char/hvc_iseries.c
index 8b6f197e5f8..f144a947bd1 100644
--- a/drivers/char/hvc_iseries.c
+++ b/drivers/char/hvc_iseries.c
@@ -29,6 +29,7 @@
 #include <asm/hvconsole.h>
 #include <asm/vio.h>
 #include <asm/prom.h>
+#include <asm/firmware.h>
 #include <asm/iseries/vio.h>
 #include <asm/iseries/hv_call.h>
 #include <asm/iseries/hv_lp_config.h>
@@ -488,6 +489,9 @@ static int hvc_vio_init(void)
        atomic_t wait_flag;
        int rc;
+        if (!firmware_has_feature(FW_FEATURE_ISERIES))
+                return -EIO;
        /* +2 for fudge */
        rc = viopath_open(HvLpConfig_getPrimaryLpIndex(),
                        viomajorsubtype_chario, VIOCHAR_WINDOW + 2);
@@ -562,7 +566,7 @@ static int hvc_find_vtys(void)
        for (vty = of_find_node_by_name(NULL, "vty"); vty != NULL;
                        vty = of_find_node_by_name(vty, "vty")) {
-                uint32_t *vtermno;
+                const uint32_t *vtermno;
                /* We have statically defined space for only a certain number
                 * of console adapters.
@@ -571,7 +575,7 @@ static int hvc_find_vtys(void)
                                (num_found >= VTTY_PORTS))
                        break;
-                vtermno = (uint32_t *)get_property(vty, "reg", NULL);
+                vtermno = get_property(vty, "reg", NULL);
                if (!vtermno)
                        continue;
diff --git a/drivers/char/hvc_vio.c b/drivers/char/hvc_vio.c
index cc95941148f..f9c00844d2b 100644
--- a/drivers/char/hvc_vio.c
+++ b/drivers/char/hvc_vio.c
@@ -35,6 +35,7 @@
 #include <asm/hvconsole.h>
 #include <asm/vio.h>
 #include <asm/prom.h>
+#include <asm/firmware.h>
 #include "hvc_console.h"
@@ -120,6 +121,9 @@ static int hvc_vio_init(void)
 {
        int rc;
+        if (firmware_has_feature(FW_FEATURE_ISERIES))
+                return -EIO;
        /* Register as a vio device to receive callbacks */
        rc = vio_register_driver(&hvc_vio_driver);
diff --git a/drivers/char/riscom8.c b/drivers/char/riscom8.c
index 214d850112f..b0ab3f28cc6 100644
--- a/drivers/char/riscom8.c
+++ b/drivers/char/riscom8.c
@@ -81,7 +81,6 @@
 static struct riscom_board * IRQ_to_board[16];
 static struct tty_driver *riscom_driver;
-static unsigned char * tmp_buf;
 static unsigned long baud_table[] =  {
        0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
@@ -1124,7 +1123,7 @@ static int rc_write(struct tty_struct * tty,
        
        bp = port_Board(port);
-        if (!tty || !port->xmit_buf || !tmp_buf)
+        if (!tty || !port->xmit_buf)
                return 0;
        save_flags(flags);
@@ -1612,11 +1611,6 @@ static inline int rc_init_drivers(void)
        if (!riscom_driver)     
                return -ENOMEM;
        
-        if (!(tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL))) {
-                printk(KERN_ERR "rc: Couldn't get free page.\n");
-                put_tty_driver(riscom_driver);
-                return 1;
-        }
        memset(IRQ_to_board, 0, sizeof(IRQ_to_board));
        riscom_driver->owner = THIS_MODULE;
        riscom_driver->name = "ttyL";
@@ -1629,7 +1623,6 @@ static inline int rc_init_drivers(void)
        riscom_driver->flags = TTY_DRIVER_REAL_RAW;
        tty_set_operations(riscom_driver, &riscom_ops);
        if ((error = tty_register_driver(riscom_driver)))  {
-                free_page((unsigned long)tmp_buf);
                put_tty_driver(riscom_driver);
                printk(KERN_ERR "rc: Couldn't register RISCom/8 driver, "
                                "error = %d\n",
@@ -1657,7 +1650,6 @@ static void rc_release_drivers(void)
        save_flags(flags);
        cli();
-        free_page((unsigned long)tmp_buf);
        tty_unregister_driver(riscom_driver);
        put_tty_driver(riscom_driver);
        restore_flags(flags);
diff --git a/drivers/char/serial167.c b/drivers/char/serial167.c
index b4ea1266b66..f4809c8183c 100644
--- a/drivers/char/serial167.c
+++ b/drivers/char/serial167.c
@@ -119,17 +119,6 @@ struct cyclades_port cy_port[] = {
 #define NR_PORTS        ARRAY_SIZE(cy_port)
 /*
- * tmp_buf is used as a temporary buffer by serial_write.  We need to
- * lock it in case the copy_from_user blocks while swapping in a page,
- * and some other program tries to do a serial write at the same time.
- * Since the lock will only come under contention when the system is
- * swapping and available memory is low, it makes sense to share one
- * buffer across all the serial ports, since it significantly saves
- * memory if large numbers of serial ports are open.
- */
-static unsigned char *tmp_buf = 0;
-/*
 * This is used to look up the divisor speeds and the timeouts
 * We're normally limited to 15 distinct baud rates.  The extra
 * are accessed via settings in info->flags.
@@ -1132,7 +1121,7 @@ cy_put_char(struct tty_struct *tty, unsigned char ch)
    if (serial_paranoia_check(info, tty->name, "cy_put_char"))
        return;
-    if (!tty || !info->xmit_buf)
+    if (!info->xmit_buf)
        return;
    local_irq_save(flags);
@@ -1198,7 +1187,7 @@ cy_write(struct tty_struct * tty,
        return 0;
    }
        
-    if (!tty || !info->xmit_buf || !tmp_buf){
+    if (!info->xmit_buf){
        return 0;
    }
@@ -1983,13 +1972,6 @@ cy_open(struct tty_struct *tty, struct file * filp)
    tty->driver_data = info;
    info->tty = tty;
-    if (!tmp_buf) {
-        tmp_buf = (unsigned char *) get_zeroed_page(GFP_KERNEL);
-        if (!tmp_buf){
-            return -ENOMEM;
-        }
-    }
    /*
     * Start up serial port
     */
diff --git a/drivers/clocksource/scx200_hrt.c b/drivers/clocksource/scx200_hrt.c
index d418b829721..22915cc46ba 100644
--- a/drivers/clocksource/scx200_hrt.c
+++ b/drivers/clocksource/scx200_hrt.c
@@ -63,7 +63,7 @@ static struct clocksource cs_hrt = {
 static int __init init_hrt_clocksource(void)
 {
-        /* Make sure scx200 has initializedd the configuration block */
+        /* Make sure scx200 has initialized the configuration block */
        if (!scx200_cb_present())
                return -ENODEV;
@@ -76,7 +76,7 @@ static int __init init_hrt_clocksource(void)
        }
        /* write timer config */
-        outb(HR_TMEN | (mhz27) ? HR_TMCLKSEL : 0,
+        outb(HR_TMEN | (mhz27 ? HR_TMCLKSEL : 0),
             scx200_cb_base + SCx200_TMCNFG_OFFSET);
        if (mhz27) {
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 2caaf71d80c..86e69b7f912 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -52,8 +52,14 @@ static void handle_update(void *data);
 * The mutex locks both lists.
 */
 static BLOCKING_NOTIFIER_HEAD(cpufreq_policy_notifier_list);
-static BLOCKING_NOTIFIER_HEAD(cpufreq_transition_notifier_list);
+static struct srcu_notifier_head cpufreq_transition_notifier_list;
+static int __init init_cpufreq_transition_notifier_list(void)
+{
+        srcu_init_notifier_head(&cpufreq_transition_notifier_list);
+        return 0;
+}
+core_initcall(init_cpufreq_transition_notifier_list);
 static LIST_HEAD(cpufreq_governor_list);
 static DEFINE_MUTEX (cpufreq_governor_mutex);
@@ -262,14 +268,14 @@ void cpufreq_notify_transition(struct cpufreq_freqs *freqs, unsigned int state)
                                freqs->old = policy->cur;
                        }
                }
-                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
                                CPUFREQ_PRECHANGE, freqs);
                adjust_jiffies(CPUFREQ_PRECHANGE, freqs);
                break;
        case CPUFREQ_POSTCHANGE:
                adjust_jiffies(CPUFREQ_POSTCHANGE, freqs);
-                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
                                CPUFREQ_POSTCHANGE, freqs);
                if (likely(policy) && likely(policy->cpu == freqs->cpu))
                        policy->cur = freqs->new;
@@ -1049,7 +1055,7 @@ static int cpufreq_suspend(struct sys_device * sysdev, pm_message_t pmsg)
                freqs.old = cpu_policy->cur;
                freqs.new = cur_freq;
-                blocking_notifier_call_chain(&cpufreq_transition_notifier_list,
+                srcu_notifier_call_chain(&cpufreq_transition_notifier_list,
                                    CPUFREQ_SUSPENDCHANGE, &freqs);
                adjust_jiffies(CPUFREQ_SUSPENDCHANGE, &freqs);
@@ -1130,7 +1136,7 @@ static int cpufreq_resume(struct sys_device * sysdev)
                        freqs.old = cpu_policy->cur;
                        freqs.new = cur_freq;
-                        blocking_notifier_call_chain(
+                        srcu_notifier_call_chain(
                                        &cpufreq_transition_notifier_list,
                                        CPUFREQ_RESUMECHANGE, &freqs);
                        adjust_jiffies(CPUFREQ_RESUMECHANGE, &freqs);
@@ -1176,7 +1182,7 @@ int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list)
        switch (list) {
        case CPUFREQ_TRANSITION_NOTIFIER:
-                ret = blocking_notifier_chain_register(
+                ret = srcu_notifier_chain_register(
                                &cpufreq_transition_notifier_list, nb);
                break;
        case CPUFREQ_POLICY_NOTIFIER:
@@ -1208,7 +1214,7 @@ int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list)
        switch (list) {
        case CPUFREQ_TRANSITION_NOTIFIER:
-                ret = blocking_notifier_chain_unregister(
+                ret = srcu_notifier_chain_unregister(
                                &cpufreq_transition_notifier_list, nb);
                break;
        case CPUFREQ_POLICY_NOTIFIER:
diff --git a/drivers/isdn/hisax/niccy.c b/drivers/isdn/hisax/niccy.c
index 489022bdef7..0945336c28d 100644
--- a/drivers/isdn/hisax/niccy.c
+++ b/drivers/isdn/hisax/niccy.c
@@ -13,7 +13,6 @@
 *
 */
 #include <linux/init.h>
 #include "hisax.h"
 #include "isac.h"
@@ -45,33 +44,31 @@ static const char *niccy_revision = "$Revision: 1.21.2.4 $";
 #define PCI_IRQ_DISABLE         0xff0000
 #define PCI_IRQ_ASSERT          0x800000
-static inline u_char
+static inline u_char readreg(unsigned int ale, unsigned int adr, u_char off)
-readreg(unsigned int ale, unsigned int adr, u_char off)
 {
        register u_char ret;
        byteout(ale, off);
        ret = bytein(adr);
-        return (ret);
+        return ret;
 }
-static inline void
+static inline void readfifo(unsigned int ale, unsigned int adr, u_char off,
-readfifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
+                u_char *data, int size)
 {
        byteout(ale, off);
        insb(adr, data, size);
 }
+static inline void writereg(unsigned int ale, unsigned int adr, u_char off,
-static inline void
+                u_char data)
-writereg(unsigned int ale, unsigned int adr, u_char off, u_char data)
 {
        byteout(ale, off);
        byteout(adr, data);
 }
-static inline void
+static inline void writefifo(unsigned int ale, unsigned int adr, u_char off,
-writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int size)
+                u_char *data, int size)
 {
        byteout(ale, off);
        outsb(adr, data, size);
@@ -79,39 +76,34 @@ writefifo(unsigned int ale, unsigned int adr, u_char off, u_char * data, int siz
 /* Interface functions */
-static u_char
+static u_char ReadISAC(struct IsdnCardState *cs, u_char offset)
-ReadISAC(struct IsdnCardState *cs, u_char offset)
 {
-        return (readreg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, offset));
+        return readreg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, offset);
 }
-static void
+static void WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
-WriteISAC(struct IsdnCardState *cs, u_char offset, u_char value)
 {
        writereg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, offset, value);
 }
-static void
+static void ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
-ReadISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 {
        readfifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size);
 }
-static void
+static void WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
-WriteISACfifo(struct IsdnCardState *cs, u_char * data, int size)
 {
        writefifo(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, 0, data, size);
 }
-static u_char
+static u_char ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
-ReadHSCX(struct IsdnCardState *cs, int hscx, u_char offset)
 {
-        return (readreg(cs->hw.niccy.hscx_ale,
+        return readreg(cs->hw.niccy.hscx_ale,
-                        cs->hw.niccy.hscx, offset + (hscx ? 0x40 : 0)));
+                        cs->hw.niccy.hscx, offset + (hscx ? 0x40 : 0));
 }
-static void
+static void WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset,
-WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
+                u_char value)
 {
        writereg(cs->hw.niccy.hscx_ale,
                 cs->hw.niccy.hscx, offset + (hscx ? 0x40 : 0), value);
@@ -130,8 +122,8 @@ WriteHSCX(struct IsdnCardState *cs, int hscx, u_char offset, u_char value)
 #include "hscx_irq.c"
-static irqreturn_t
+static irqreturn_t niccy_interrupt(int intno, void *dev_id,
-niccy_interrupt(int intno, void *dev_id, struct pt_regs *regs)
+                struct pt_regs *regs)
 {
        struct IsdnCardState *cs = dev_id;
        u_char val;
@@ -141,21 +133,23 @@ niccy_interrupt(int intno, void *dev_id, struct pt_regs *regs)
        if (cs->subtyp == NICCY_PCI) {
                int ival;
                ival = inl(cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
-                if (!(ival & PCI_IRQ_ASSERT)) { /* IRQ not for us (shared) */
+                if (!(ival & PCI_IRQ_ASSERT)) { /* IRQ not for us (shared) */
                        spin_unlock_irqrestore(&cs->lock, flags);
                        return IRQ_NONE;
                }
                outl(ival, cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
        }
-        val = readreg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_ISTA + 0x40);
+        val = readreg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx,
-      Start_HSCX:
+                        HSCX_ISTA + 0x40);
+Start_HSCX:
        if (val)
                hscx_int_main(cs, val);
        val = readreg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_ISTA);
-      Start_ISAC:
+Start_ISAC:
        if (val)
                isac_interrupt(cs, val);
-        val = readreg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_ISTA + 0x40);
+        val = readreg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx,
+                        HSCX_ISTA + 0x40);
        if (val) {
                if (cs->debug & L1_DEB_HSCX)
                        debugl1(cs, "HSCX IntStat after IntRoutine");
@@ -168,21 +162,21 @@ niccy_interrupt(int intno, void *dev_id, struct pt_regs *regs)
                goto Start_ISAC;
        }
        writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK, 0xFF);
-        writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK + 0x40, 0xFF);
+        writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK + 0x40,
+                 0xFF);
        writereg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_MASK, 0xFF);
        writereg(cs->hw.niccy.isac_ale, cs->hw.niccy.isac, ISAC_MASK, 0);
        writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK, 0);
-        writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK + 0x40, 0);
+        writereg(cs->hw.niccy.hscx_ale, cs->hw.niccy.hscx, HSCX_MASK + 0x40,0);
        spin_unlock_irqrestore(&cs->lock, flags);
        return IRQ_HANDLED;
 }
-static void
+static void release_io_niccy(struct IsdnCardState *cs)
-release_io_niccy(struct IsdnCardState *cs)
 {
        if (cs->subtyp == NICCY_PCI) {
                int val;
-                
                val = inl(cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
                val &= PCI_IRQ_DISABLE;
                outl(val, cs->hw.niccy.cfg_reg + PCI_IRQ_CTRL_REG);
@@ -194,8 +188,7 @@ release_io_niccy(struct IsdnCardState *cs)
        }
 }
-static void
+static void niccy_reset(struct IsdnCardState *cs)
-niccy_reset(struct IsdnCardState *cs)
 {
        if (cs->subtyp == NICCY_PCI) {
                int val;
@@ -207,29 +200,28 @@ niccy_reset(struct IsdnCardState *cs)
        inithscxisac(cs, 3);
 }
-static int
+static int niccy_card_msg(struct IsdnCardState *cs, int mt, void *arg)
-niccy_card_msg(struct IsdnCardState *cs, int mt, void *arg)
 {
        u_long flags;
        switch (mt) {
-                case CARD_RESET:
+        case CARD_RESET:
-                        spin_lock_irqsave(&cs->lock, flags);
+                spin_lock_irqsave(&cs->lock, flags);
-                        niccy_reset(cs);
+                niccy_reset(cs);
-                        spin_unlock_irqrestore(&cs->lock, flags);
+                spin_unlock_irqrestore(&cs->lock, flags);
-                        return(0);
+                return 0;
-                case CARD_RELEASE:
+        case CARD_RELEASE:
-                        release_io_niccy(cs);
+                release_io_niccy(cs);
-                        return(0);
+                return 0;
-                case CARD_INIT:
+        case CARD_INIT:
-                        spin_lock_irqsave(&cs->lock, flags);
+                spin_lock_irqsave(&cs->lock, flags);
-                        niccy_reset(cs);
+                niccy_reset(cs);
-                        spin_unlock_irqrestore(&cs->lock, flags);
+                spin_unlock_irqrestore(&cs->lock, flags);
-                        return(0);
+                return 0;
-                case CARD_TEST:
+        case CARD_TEST:
-                        return(0);
+                return 0;
        }
-        return(0);
+        return 0;
 }
 static struct pci_dev *niccy_dev __devinitdata = NULL;
@@ -237,8 +229,7 @@ static struct pci_dev *niccy_dev __devinitdata = NULL;
 static struct pnp_card *pnp_c __devinitdata = NULL;
 #endif
-int __devinit
+int __devinit setup_niccy(struct IsdnCard *card)
-setup_niccy(struct IsdnCard *card)
 {
        struct IsdnCardState *cs = card->cs;
        char tmp[64];
@@ -246,40 +237,44 @@ setup_niccy(struct IsdnCard *card)
        strcpy(tmp, niccy_revision);
        printk(KERN_INFO "HiSax: Niccy driver Rev. %s\n", HiSax_getrev(tmp));
        if (cs->typ != ISDN_CTYPE_NICCY)
-                return (0);
+                return 0;
 #ifdef __ISAPNP__
        if (!card->para[1] && isapnp_present()) {
                struct pnp_dev *pnp_d = NULL;
                int err;
-                if ((pnp_c = pnp_find_card(
+                pnp_c = pnp_find_card(ISAPNP_VENDOR('S', 'D', 'A'),
-                        ISAPNP_VENDOR('S', 'D', 'A'),
+                                ISAPNP_FUNCTION(0x0150), pnp_c);
-                        ISAPNP_FUNCTION(0x0150), pnp_c))) {
+                if (pnp_c) {
-                        if (!(pnp_d = pnp_find_dev(pnp_c,
+                        pnp_d = pnp_find_dev(pnp_c,
-                                ISAPNP_VENDOR('S', 'D', 'A'),
+                                        ISAPNP_VENDOR('S', 'D', 'A'),
-                                ISAPNP_FUNCTION(0x0150), pnp_d))) {
+                                        ISAPNP_FUNCTION(0x0150), pnp_d);
-                                printk(KERN_ERR "NiccyPnP: PnP error card found, no device\n");
+                        if (!pnp_d) {
-                                return (0);
+                                printk(KERN_ERR "NiccyPnP: PnP error card "
+                                        "found, no device\n");
+                                return 0;
                        }
                        pnp_disable_dev(pnp_d);
                        err = pnp_activate_dev(pnp_d);
-                        if (err<0) {
+                        if (err < 0) {
-                                printk(KERN_WARNING "%s: pnp_activate_dev ret(%d)\n",
+                                printk(KERN_WARNING "%s: pnp_activate_dev "
-                                        __FUNCTION__, err);
+                                        "ret(%d)\n", __FUNCTION__, err);
-                                return(0);
+                                return 0;
                        }
                        card->para[1] = pnp_port_start(pnp_d, 0);
                        card->para[2] = pnp_port_start(pnp_d, 1);
                        card->para[0] = pnp_irq(pnp_d, 0);
-                        if (!card->para[0] || !card->para[1] || !card->para[2]) {
+                        if (!card->para[0] || !card->para[1] ||
-                                printk(KERN_ERR "NiccyPnP:some resources are missing %ld/%lx/%lx\n",
+                                        !card->para[2]) {
-                                        card->para[0], card->para[1], card->para[2]);
+                                printk(KERN_ERR "NiccyPnP:some resources are "
+                                        "missing %ld/%lx/%lx\n",
+                                        card->para[0], card->para[1],
+                                        card->para[2]);
                                pnp_disable_dev(pnp_d);
-                                return(0);
+                                return 0;
                        }
-                } else {
+                } else
                        printk(KERN_INFO "NiccyPnP: no ISAPnP card found\n");
-                }
        }
 #endif
        if (card->para[1]) {
@@ -291,50 +286,51 @@ setup_niccy(struct IsdnCard *card)
                cs->subtyp = NICCY_PNP;
                cs->irq = card->para[0];
                if (!request_region(cs->hw.niccy.isac, 2, "niccy data")) {
-                        printk(KERN_WARNING
+                        printk(KERN_WARNING "HiSax: %s data port %x-%x "
-                                "HiSax: %s data port %x-%x already in use\n",
+                                "already in use\n", CardType[card->typ],
-                                CardType[card->typ],
+                                cs->hw.niccy.isac, cs->hw.niccy.isac + 1);
-                                cs->hw.niccy.isac,
+                        return 0;
-                                cs->hw.niccy.isac + 1);
-                        return (0);
                }
                if (!request_region(cs->hw.niccy.isac_ale, 2, "niccy addr")) {
-                        printk(KERN_WARNING
+                        printk(KERN_WARNING "HiSax: %s address port %x-%x "
-                                "HiSax: %s address port %x-%x already in use\n",
+                                "already in use\n", CardType[card->typ],
-                                CardType[card->typ],
                                cs->hw.niccy.isac_ale,
                                cs->hw.niccy.isac_ale + 1);
                        release_region(cs->hw.niccy.isac, 2);
-                        return (0);
+                        return 0;
                }
        } else {
 #ifdef CONFIG_PCI
                u_int pci_ioaddr;
                cs->subtyp = 0;
                if ((niccy_dev = pci_find_device(PCI_VENDOR_ID_SATSAGEM,
-                        PCI_DEVICE_ID_SATSAGEM_NICCY, niccy_dev))) {
+                                                 PCI_DEVICE_ID_SATSAGEM_NICCY,
+                                                 niccy_dev))) {
                        if (pci_enable_device(niccy_dev))
-                                return(0);
+                                return 0;
                        /* get IRQ */
                        if (!niccy_dev->irq) {
-                                printk(KERN_WARNING "Niccy: No IRQ for PCI card found\n");
+                                printk(KERN_WARNING
-                                return(0);
+                                       "Niccy: No IRQ for PCI card found\n");
+                                return 0;
                        }
                        cs->irq = niccy_dev->irq;
                        cs->hw.niccy.cfg_reg = pci_resource_start(niccy_dev, 0);
                        if (!cs->hw.niccy.cfg_reg) {
-                                printk(KERN_WARNING "Niccy: No IO-Adr for PCI cfg found\n");
+                                printk(KERN_WARNING
-                                return(0);
+                                       "Niccy: No IO-Adr for PCI cfg found\n");
+                                return 0;
                        }
                        pci_ioaddr = pci_resource_start(niccy_dev, 1);
                        if (!pci_ioaddr) {
-                                printk(KERN_WARNING "Niccy: No IO-Adr for PCI card found\n");
+                                printk(KERN_WARNING
-                                return(0);
+                                       "Niccy: No IO-Adr for PCI card found\n");
+                                return 0;
                        }
                        cs->subtyp = NICCY_PCI;
                } else {
                        printk(KERN_WARNING "Niccy: No PCI card found\n");
-                        return(0);
+                        return 0;
                }
                cs->irq_flags |= IRQF_SHARED;
                cs->hw.niccy.isac = pci_ioaddr + ISAC_PCI_DATA;
@@ -343,29 +339,28 @@ setup_niccy(struct IsdnCard *card)
                cs->hw.niccy.hscx_ale = pci_ioaddr + HSCX_PCI_ADDR;
                if (!request_region(cs->hw.niccy.isac, 4, "niccy")) {
                        printk(KERN_WARNING
-                                "HiSax: %s data port %x-%x already in use\n",
+                               "HiSax: %s data port %x-%x already in use\n",
-                                CardType[card->typ],
+                               CardType[card->typ],
-                                cs->hw.niccy.isac,
+                               cs->hw.niccy.isac, cs->hw.niccy.isac + 4);
-                                cs->hw.niccy.isac + 4);
+                        return 0;
-                        return (0);
                }
                if (!request_region(cs->hw.niccy.cfg_reg, 0x40, "niccy pci")) {
                        printk(KERN_WARNING
                               "HiSax: %s pci port %x-%x already in use\n",
-                                CardType[card->typ],
+                               CardType[card->typ],
-                                cs->hw.niccy.cfg_reg,
+                               cs->hw.niccy.cfg_reg,
-                                cs->hw.niccy.cfg_reg + 0x40);
+                               cs->hw.niccy.cfg_reg + 0x40);
                        release_region(cs->hw.niccy.isac, 4);
-                        return (0);
+                        return 0;
                }
 #else
                printk(KERN_WARNING "Niccy: io0 0 and NO_PCI_BIOS\n");
                printk(KERN_WARNING "Niccy: unable to config NICCY PCI\n");
-                return (0);
+                return 0;
-#endif /* CONFIG_PCI */
+#endif                          /* CONFIG_PCI */
        }
        printk(KERN_INFO "HiSax: %s %s config irq:%d data:0x%X ale:0x%X\n",
-                CardType[cs->typ], (cs->subtyp==1) ? "PnP":"PCI",
+                CardType[cs->typ], (cs->subtyp == 1) ? "PnP" : "PCI",
                cs->irq, cs->hw.niccy.isac, cs->hw.niccy.isac_ale);
        setup_isac(cs);
        cs->readisac = &ReadISAC;
@@ -379,10 +374,10 @@ setup_niccy(struct IsdnCard *card)
        cs->irq_func = &niccy_interrupt;
        ISACVersion(cs, "Niccy:");
        if (HscxVersion(cs, "Niccy:")) {
-                printk(KERN_WARNING
+                printk(KERN_WARNING "Niccy: wrong HSCX versions check IO "
-                    "Niccy: wrong HSCX versions check IO address\n");
+                        "address\n");
                release_io_niccy(cs);
-                return (0);
+                return 0;
        }
-        return (1);
+        return 1;
 }
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 7fc692a8f5b..3df0e7a07c4 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -18,7 +18,7 @@ config IBM_ASM
          service processor board as a regular serial port. To make use of
          this feature serial driver support (CONFIG_SERIAL_8250) must be
          enabled.
-          
          WARNING: This software may not be supported or function
          correctly on your IBM server. Please consult the IBM ServerProven
          website <http://www.pc.ibm.com/ww/eserver/xseries/serverproven> for
@@ -28,5 +28,33 @@ config IBM_ASM
          If unsure, say N.
-endmenu
+config TIFM_CORE
+        tristate "TI Flash Media interface support (EXPERIMENTAL)"
+        depends on EXPERIMENTAL
+        help
+          If you want support for Texas Instruments(R) Flash Media adapters
+          you should select this option and then also choose an appropriate
+          host adapter, such as 'TI Flash Media PCI74xx/PCI76xx host adapter
+          support', if you have a TI PCI74xx compatible card reader, for
+          example.
+          You will also have to select some flash card format drivers. MMC/SD
+          cards are supported via 'MMC/SD Card support: TI Flash Media MMC/SD
+          Interface support (MMC_TIFM_SD)'.
+          To compile this driver as a module, choose M here: the module will
+          be called tifm_core.
+config TIFM_7XX1
+        tristate "TI Flash Media PCI74xx/PCI76xx host adapter support (EXPERIMENTAL)"
+        depends on PCI && TIFM_CORE && EXPERIMENTAL
+        default TIFM_CORE
+        help
+          This option enables support for Texas Instruments(R) PCI74xx and
+          PCI76xx families of Flash Media adapters, found in many laptops.
+          To make actual use of the device, you will have to select some
+          flash card format drivers, as outlined in the TIFM_CORE Help.
+          To compile this driver as a module, choose M here: the module will
+          be called tifm_7xx1.
+endmenu
diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
index c1bf1fb04c5..d65ece76095 100644
--- a/drivers/misc/Makefile
+++ b/drivers/misc/Makefile
@@ -6,3 +6,5 @@ obj- := misc.o	# Dummy rule to force built-in.o to be made
 obj-$(CONFIG_IBM_ASM)           += ibmasm/
 obj-$(CONFIG_HDPU_FEATURES)     += hdpuftrs/
 obj-$(CONFIG_LKDTM)             += lkdtm.o
+obj-$(CONFIG_TIFM_CORE)         += tifm_core.o
+obj-$(CONFIG_TIFM_7XX1)         += tifm_7xx1.o
diff --git a/drivers/misc/tifm_7xx1.c b/drivers/misc/tifm_7xx1.c
new file mode 100644
index 00000000000..a7ed3044618
--- /dev/null
+++ b/drivers/misc/tifm_7xx1.c
@@ -0,0 +1,437 @@
+/*
+ *  tifm_7xx1.c - TI FlashMedia driver
+ *
+ *  Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#include <linux/tifm.h>
+#include <linux/dma-mapping.h>
+#define DRIVER_NAME "tifm_7xx1"
+#define DRIVER_VERSION "0.6"
+static void tifm_7xx1_eject(struct tifm_adapter *fm, struct tifm_dev *sock)
+{
+        int cnt;
+        unsigned long flags;
+        spin_lock_irqsave(&fm->lock, flags);
+        if (!fm->inhibit_new_cards) {
+                for (cnt = 0; cnt < fm->max_sockets; cnt++) {
+                        if (fm->sockets[cnt] == sock) {
+                                fm->remove_mask |= (1 << cnt);
+                                queue_work(fm->wq, &fm->media_remover);
+                                break;
+                        }
+                }
+        }
+        spin_unlock_irqrestore(&fm->lock, flags);
+}
+static void tifm_7xx1_remove_media(void *adapter)
+{
+        struct tifm_adapter *fm = adapter;
+        unsigned long flags;
+        int cnt;
+        struct tifm_dev *sock;
+        if (!class_device_get(&fm->cdev))
+                return;
+        spin_lock_irqsave(&fm->lock, flags);
+        for (cnt = 0; cnt < fm->max_sockets; cnt++) {
+                if (fm->sockets[cnt] && (fm->remove_mask & (1 << cnt))) {
+                        printk(KERN_INFO DRIVER_NAME
+                               ": demand removing card from socket %d\n", cnt);
+                        sock = fm->sockets[cnt];
+                        fm->sockets[cnt] = 0;
+                        fm->remove_mask &= ~(1 << cnt);
+                        writel(0x0e00, sock->addr + SOCK_CONTROL);
+                        writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
+                                fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+                        writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
+                                fm->addr + FM_SET_INTERRUPT_ENABLE);
+                        spin_unlock_irqrestore(&fm->lock, flags);
+                        device_unregister(&sock->dev);
+                        spin_lock_irqsave(&fm->lock, flags);
+                }
+        }
+        spin_unlock_irqrestore(&fm->lock, flags);
+        class_device_put(&fm->cdev);
+}
+static irqreturn_t tifm_7xx1_isr(int irq, void *dev_id, struct pt_regs *regs)
+{
+        struct tifm_adapter *fm = dev_id;
+        unsigned int irq_status;
+        unsigned int sock_irq_status, cnt;
+        spin_lock(&fm->lock);
+        irq_status = readl(fm->addr + FM_INTERRUPT_STATUS);
+        if (irq_status == 0 || irq_status == (~0)) {
+                spin_unlock(&fm->lock);
+                return IRQ_NONE;
+        }
+        if (irq_status & TIFM_IRQ_ENABLE) {
+                writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+                for (cnt = 0; cnt <  fm->max_sockets; cnt++) {
+                        sock_irq_status = (irq_status >> cnt) &
+                                        (TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK);
+                        if (fm->sockets[cnt]) {
+                                if (sock_irq_status &&
+                                                fm->sockets[cnt]->signal_irq)
+                                        sock_irq_status = fm->sockets[cnt]->
+                                                signal_irq(fm->sockets[cnt],
+                                                        sock_irq_status);
+                                if (irq_status & (1 << cnt))
+                                        fm->remove_mask |= 1 << cnt;
+                        } else {
+                                if (irq_status & (1 << cnt))
+                                        fm->insert_mask |= 1 << cnt;
+                        }
+                }
+        }
+        writel(irq_status, fm->addr + FM_INTERRUPT_STATUS);
+        if (!fm->inhibit_new_cards) {
+                if (!fm->remove_mask && !fm->insert_mask) {
+                        writel(TIFM_IRQ_ENABLE,
+                                fm->addr + FM_SET_INTERRUPT_ENABLE);
+                } else {
+                        queue_work(fm->wq, &fm->media_remover);
+                        queue_work(fm->wq, &fm->media_inserter);
+                }
+        }
+        spin_unlock(&fm->lock);
+        return IRQ_HANDLED;
+}
+static tifm_media_id tifm_7xx1_toggle_sock_power(char *sock_addr, int is_x2)
+{
+        unsigned int s_state;
+        int cnt;
+        writel(0x0e00, sock_addr + SOCK_CONTROL);
+        for (cnt = 0; cnt < 100; cnt++) {
+                if (!(TIFM_SOCK_STATE_POWERED &
+                                readl(sock_addr + SOCK_PRESENT_STATE)))
+                        break;
+                msleep(10);
+        }
+        s_state = readl(sock_addr + SOCK_PRESENT_STATE);
+        if (!(TIFM_SOCK_STATE_OCCUPIED & s_state))
+                return FM_NULL;
+        if (is_x2) {
+                writel((s_state & 7) | 0x0c00, sock_addr + SOCK_CONTROL);
+        } else {
+                // SmartMedia cards need extra 40 msec
+                if (((readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7) == 1)
+                        msleep(40);
+                writel(readl(sock_addr + SOCK_CONTROL) | TIFM_CTRL_LED,
+                       sock_addr + SOCK_CONTROL);
+                msleep(10);
+                writel((s_state & 0x7) | 0x0c00 | TIFM_CTRL_LED,
+                        sock_addr + SOCK_CONTROL);
+        }
+        for (cnt = 0; cnt < 100; cnt++) {
+                if ((TIFM_SOCK_STATE_POWERED &
+                                readl(sock_addr + SOCK_PRESENT_STATE)))
+                        break;
+                msleep(10);
+        }
+        if (!is_x2)
+                writel(readl(sock_addr + SOCK_CONTROL) & (~TIFM_CTRL_LED),
+                       sock_addr + SOCK_CONTROL);
+        return (readl(sock_addr + SOCK_PRESENT_STATE) >> 4) & 7;
+}
+inline static char *tifm_7xx1_sock_addr(char *base_addr, unsigned int sock_num)
+{
+        return base_addr + ((sock_num + 1) << 10);
+}
+static void tifm_7xx1_insert_media(void *adapter)
+{
+        struct tifm_adapter *fm = adapter;
+        unsigned long flags;
+        tifm_media_id media_id;
+        char *card_name = "xx";
+        int cnt, ok_to_register;
+        unsigned int insert_mask;
+        struct tifm_dev *new_sock = 0;
+        if (!class_device_get(&fm->cdev))
+                return;
+        spin_lock_irqsave(&fm->lock, flags);
+        insert_mask = fm->insert_mask;
+        fm->insert_mask = 0;
+        if (fm->inhibit_new_cards) {
+                spin_unlock_irqrestore(&fm->lock, flags);
+                class_device_put(&fm->cdev);
+                return;
+        }
+        spin_unlock_irqrestore(&fm->lock, flags);
+        for (cnt = 0; cnt < fm->max_sockets; cnt++) {
+                if (!(insert_mask & (1 << cnt)))
+                        continue;
+                media_id = tifm_7xx1_toggle_sock_power(tifm_7xx1_sock_addr(fm->addr, cnt),
+                                                       fm->max_sockets == 2);
+                if (media_id) {
+                        ok_to_register = 0;
+                        new_sock = tifm_alloc_device(fm, cnt);
+                        if (new_sock) {
+                                new_sock->addr = tifm_7xx1_sock_addr(fm->addr,
+                                                                        cnt);
+                                new_sock->media_id = media_id;
+                                switch (media_id) {
+                                case 1:
+                                        card_name = "xd";
+                                        break;
+                                case 2:
+                                        card_name = "ms";
+                                        break;
+                                case 3:
+                                        card_name = "sd";
+                                        break;
+                                default:
+                                        break;
+                                }
+                                snprintf(new_sock->dev.bus_id, BUS_ID_SIZE,
+                                        "tifm_%s%u:%u", card_name, fm->id, cnt);
+                                printk(KERN_INFO DRIVER_NAME
+                                        ": %s card detected in socket %d\n",
+                                        card_name, cnt);
+                                spin_lock_irqsave(&fm->lock, flags);
+                                if (!fm->sockets[cnt]) {
+                                        fm->sockets[cnt] = new_sock;
+                                        ok_to_register = 1;
+                                }
+                                spin_unlock_irqrestore(&fm->lock, flags);
+                                if (!ok_to_register ||
+                                            device_register(&new_sock->dev)) {
+                                        spin_lock_irqsave(&fm->lock, flags);
+                                        fm->sockets[cnt] = 0;
+                                        spin_unlock_irqrestore(&fm->lock,
+                                                                flags);
+                                        tifm_free_device(&new_sock->dev);
+                                }
+                        }
+                }
+                writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
+                       fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+                writel((TIFM_IRQ_FIFOMASK | TIFM_IRQ_CARDMASK) << cnt,
+                       fm->addr + FM_SET_INTERRUPT_ENABLE);
+        }
+        writel(TIFM_IRQ_ENABLE, fm->addr + FM_SET_INTERRUPT_ENABLE);
+        class_device_put(&fm->cdev);
+}
+static int tifm_7xx1_suspend(struct pci_dev *dev, pm_message_t state)
+{
+        struct tifm_adapter *fm = pci_get_drvdata(dev);
+        unsigned long flags;
+        spin_lock_irqsave(&fm->lock, flags);
+        fm->inhibit_new_cards = 1;
+        fm->remove_mask = 0xf;
+        fm->insert_mask = 0;
+        writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        spin_unlock_irqrestore(&fm->lock, flags);
+        flush_workqueue(fm->wq);
+        tifm_7xx1_remove_media(fm);
+        pci_set_power_state(dev, PCI_D3hot);
+        pci_disable_device(dev);
+        pci_save_state(dev);
+        return 0;
+}
+static int tifm_7xx1_resume(struct pci_dev *dev)
+{
+        struct tifm_adapter *fm = pci_get_drvdata(dev);
+        unsigned long flags;
+        pci_restore_state(dev);
+        pci_enable_device(dev);
+        pci_set_power_state(dev, PCI_D0);
+        pci_set_master(dev);
+        spin_lock_irqsave(&fm->lock, flags);
+        fm->inhibit_new_cards = 0;
+        writel(TIFM_IRQ_SETALL, fm->addr + FM_INTERRUPT_STATUS);
+        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SETALLSOCK,
+                fm->addr + FM_SET_INTERRUPT_ENABLE);
+        fm->insert_mask = 0xf;
+        spin_unlock_irqrestore(&fm->lock, flags);
+        return 0;
+}
+static int tifm_7xx1_probe(struct pci_dev *dev,
+                        const struct pci_device_id *dev_id)
+{
+        struct tifm_adapter *fm;
+        int pci_dev_busy = 0;
+        int rc;
+        rc = pci_set_dma_mask(dev, DMA_32BIT_MASK);
+        if (rc)
+                return rc;
+        rc = pci_enable_device(dev);
+        if (rc)
+                return rc;
+        pci_set_master(dev);
+        rc = pci_request_regions(dev, DRIVER_NAME);
+        if (rc) {
+                pci_dev_busy = 1;
+                goto err_out;
+        }
+        pci_intx(dev, 1);
+        fm = tifm_alloc_adapter();
+        if (!fm) {
+                rc = -ENOMEM;
+                goto err_out_int;
+        }
+        fm->dev = &dev->dev;
+        fm->max_sockets = (dev->device == 0x803B) ? 2 : 4;
+        fm->sockets = kzalloc(sizeof(struct tifm_dev*) * fm->max_sockets,
+                                GFP_KERNEL);
+        if (!fm->sockets)
+                goto err_out_free;
+        INIT_WORK(&fm->media_inserter, tifm_7xx1_insert_media, fm);
+        INIT_WORK(&fm->media_remover, tifm_7xx1_remove_media, fm);
+        fm->eject = tifm_7xx1_eject;
+        pci_set_drvdata(dev, fm);
+        fm->addr = ioremap(pci_resource_start(dev, 0),
+                                pci_resource_len(dev, 0));
+        if (!fm->addr)
+                goto err_out_free;
+        rc = request_irq(dev->irq, tifm_7xx1_isr, SA_SHIRQ, DRIVER_NAME, fm);
+        if (rc)
+                goto err_out_unmap;
+        rc = tifm_add_adapter(fm);
+        if (rc)
+                goto err_out_irq;
+        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        writel(TIFM_IRQ_ENABLE | TIFM_IRQ_SETALLSOCK,
+                fm->addr + FM_SET_INTERRUPT_ENABLE);
+        fm->insert_mask = 0xf;
+        return 0;
+err_out_irq:
+        free_irq(dev->irq, fm);
+err_out_unmap:
+        iounmap(fm->addr);
+err_out_free:
+        pci_set_drvdata(dev, NULL);
+        tifm_free_adapter(fm);
+err_out_int:
+        pci_intx(dev, 0);
+        pci_release_regions(dev);
+err_out:
+        if (!pci_dev_busy)
+                pci_disable_device(dev);
+        return rc;
+}
+static void tifm_7xx1_remove(struct pci_dev *dev)
+{
+        struct tifm_adapter *fm = pci_get_drvdata(dev);
+        unsigned long flags;
+        spin_lock_irqsave(&fm->lock, flags);
+        fm->inhibit_new_cards = 1;
+        fm->remove_mask = 0xf;
+        fm->insert_mask = 0;
+        writel(TIFM_IRQ_ENABLE, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        spin_unlock_irqrestore(&fm->lock, flags);
+        flush_workqueue(fm->wq);
+        tifm_7xx1_remove_media(fm);
+        writel(TIFM_IRQ_SETALL, fm->addr + FM_CLEAR_INTERRUPT_ENABLE);
+        free_irq(dev->irq, fm);
+        tifm_remove_adapter(fm);
+        pci_set_drvdata(dev, 0);
+        iounmap(fm->addr);
+        pci_intx(dev, 0);
+        pci_release_regions(dev);
+        pci_disable_device(dev);
+        tifm_free_adapter(fm);
+}
+static struct pci_device_id tifm_7xx1_pci_tbl [] = {
+        { PCI_VENDOR_ID_TI, 0x8033, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          0 }, /* xx21 - the one I have */
+        { PCI_VENDOR_ID_TI, 0x803B, PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+          0 }, /* xx12 - should be also supported */
+        { }
+};
+static struct pci_driver tifm_7xx1_driver = {
+        .name = DRIVER_NAME,
+        .id_table = tifm_7xx1_pci_tbl,
+        .probe = tifm_7xx1_probe,
+        .remove = tifm_7xx1_remove,
+        .suspend = tifm_7xx1_suspend,
+        .resume = tifm_7xx1_resume,
+};
+static int __init tifm_7xx1_init(void)
+{
+        return pci_register_driver(&tifm_7xx1_driver);
+}
+static void __exit tifm_7xx1_exit(void)
+{
+        pci_unregister_driver(&tifm_7xx1_driver);
+}
+MODULE_AUTHOR("Alex Dubov");
+MODULE_DESCRIPTION("TI FlashMedia host driver");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(pci, tifm_7xx1_pci_tbl);
+MODULE_VERSION(DRIVER_VERSION);
+module_init(tifm_7xx1_init);
+module_exit(tifm_7xx1_exit);
diff --git a/drivers/misc/tifm_core.c b/drivers/misc/tifm_core.c
new file mode 100644
index 00000000000..cca5f852246
--- /dev/null
+++ b/drivers/misc/tifm_core.c
@@ -0,0 +1,272 @@
+/*
+ *  tifm_core.c - TI FlashMedia driver
+ *
+ *  Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#include <linux/tifm.h>
+#include <linux/init.h>
+#include <linux/idr.h>
+#define DRIVER_NAME "tifm_core"
+#define DRIVER_VERSION "0.6"
+static DEFINE_IDR(tifm_adapter_idr);
+static DEFINE_SPINLOCK(tifm_adapter_lock);
+static tifm_media_id *tifm_device_match(tifm_media_id *ids,
+                        struct tifm_dev *dev)
+{
+        while (*ids) {
+                if (dev->media_id == *ids)
+                        return ids;
+                ids++;
+        }
+        return NULL;
+}
+static int tifm_match(struct device *dev, struct device_driver *drv)
+{
+        struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
+        struct tifm_driver *fm_drv;
+        fm_drv = container_of(drv, struct tifm_driver, driver);
+        if (!fm_drv->id_table)
+                return -EINVAL;
+        if (tifm_device_match(fm_drv->id_table, fm_dev))
+                return 1;
+        return -ENODEV;
+}
+static int tifm_uevent(struct device *dev, char **envp, int num_envp,
+                       char *buffer, int buffer_size)
+{
+        struct tifm_dev *fm_dev;
+        int i = 0;
+        int length = 0;
+        const char *card_type_name[] = {"INV", "SM", "MS", "SD"};
+        if (!dev || !(fm_dev = container_of(dev, struct tifm_dev, dev)))
+                return -ENODEV;
+        if (add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
+                        "TIFM_CARD_TYPE=%s", card_type_name[fm_dev->media_id]))
+                return -ENOMEM;
+        return 0;
+}
+static struct bus_type tifm_bus_type = {
+        .name    = "tifm",
+        .match   = tifm_match,
+        .uevent  = tifm_uevent,
+};
+static void tifm_free(struct class_device *cdev)
+{
+        struct tifm_adapter *fm = container_of(cdev, struct tifm_adapter, cdev);
+        kfree(fm->sockets);
+        if (fm->wq)
+                destroy_workqueue(fm->wq);
+        kfree(fm);
+}
+static struct class tifm_adapter_class = {
+        .name    = "tifm_adapter",
+        .release = tifm_free
+};
+struct tifm_adapter *tifm_alloc_adapter(void)
+{
+        struct tifm_adapter *fm;
+        fm = kzalloc(sizeof(struct tifm_adapter), GFP_KERNEL);
+        if (fm) {
+                fm->cdev.class = &tifm_adapter_class;
+                spin_lock_init(&fm->lock);
+                class_device_initialize(&fm->cdev);
+        }
+        return fm;
+}
+EXPORT_SYMBOL(tifm_alloc_adapter);
+void tifm_free_adapter(struct tifm_adapter *fm)
+{
+        class_device_put(&fm->cdev);
+}
+EXPORT_SYMBOL(tifm_free_adapter);
+int tifm_add_adapter(struct tifm_adapter *fm)
+{
+        int rc;
+        if (!idr_pre_get(&tifm_adapter_idr, GFP_KERNEL))
+                return -ENOMEM;
+        spin_lock(&tifm_adapter_lock);
+        rc = idr_get_new(&tifm_adapter_idr, fm, &fm->id);
+        spin_unlock(&tifm_adapter_lock);
+        if (!rc) {
+                snprintf(fm->cdev.class_id, BUS_ID_SIZE, "tifm%u", fm->id);
+                strncpy(fm->wq_name, fm->cdev.class_id, KOBJ_NAME_LEN);
+                fm->wq = create_singlethread_workqueue(fm->wq_name);
+                if (fm->wq)
+                        return class_device_add(&fm->cdev);
+                spin_lock(&tifm_adapter_lock);
+                idr_remove(&tifm_adapter_idr, fm->id);
+                spin_unlock(&tifm_adapter_lock);
+                rc = -ENOMEM;
+        }
+        return rc;
+}
+EXPORT_SYMBOL(tifm_add_adapter);
+void tifm_remove_adapter(struct tifm_adapter *fm)
+{
+        class_device_del(&fm->cdev);
+        spin_lock(&tifm_adapter_lock);
+        idr_remove(&tifm_adapter_idr, fm->id);
+        spin_unlock(&tifm_adapter_lock);
+}
+EXPORT_SYMBOL(tifm_remove_adapter);
+void tifm_free_device(struct device *dev)
+{
+        struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
+        if (fm_dev->wq)
+                destroy_workqueue(fm_dev->wq);
+        kfree(fm_dev);
+}
+EXPORT_SYMBOL(tifm_free_device);
+struct tifm_dev *tifm_alloc_device(struct tifm_adapter *fm, unsigned int id)
+{
+        struct tifm_dev *dev = kzalloc(sizeof(struct tifm_dev), GFP_KERNEL);
+        if (dev) {
+                spin_lock_init(&dev->lock);
+                snprintf(dev->wq_name, KOBJ_NAME_LEN, "tifm%u:%u", fm->id, id);
+                dev->wq = create_singlethread_workqueue(dev->wq_name);
+                if (!dev->wq) {
+                        kfree(dev);
+                        return 0;
+                }
+                dev->dev.parent = fm->dev;
+                dev->dev.bus = &tifm_bus_type;
+                dev->dev.release = tifm_free_device;
+        }
+        return dev;
+}
+EXPORT_SYMBOL(tifm_alloc_device);
+void tifm_eject(struct tifm_dev *sock)
+{
+        struct tifm_adapter *fm = dev_get_drvdata(sock->dev.parent);
+        fm->eject(fm, sock);
+}
+EXPORT_SYMBOL(tifm_eject);
+int tifm_map_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
+                int direction)
+{
+        return pci_map_sg(to_pci_dev(sock->dev.parent), sg, nents, direction);
+}
+EXPORT_SYMBOL(tifm_map_sg);
+void tifm_unmap_sg(struct tifm_dev *sock, struct scatterlist *sg, int nents,
+                   int direction)
+{
+        pci_unmap_sg(to_pci_dev(sock->dev.parent), sg, nents, direction);
+}
+EXPORT_SYMBOL(tifm_unmap_sg);
+static int tifm_device_probe(struct device *dev)
+{
+        struct tifm_driver *drv;
+        struct tifm_dev *fm_dev;
+        int rc = 0;
+        const tifm_media_id *id;
+        drv = container_of(dev->driver, struct tifm_driver, driver);
+        fm_dev = container_of(dev, struct tifm_dev, dev);
+        get_device(dev);
+        if (!fm_dev->drv && drv->probe && drv->id_table) {
+                rc = -ENODEV;
+                id = tifm_device_match(drv->id_table, fm_dev);
+                if (id)
+                        rc = drv->probe(fm_dev);
+                if (rc >= 0) {
+                        rc = 0;
+                        fm_dev->drv = drv;
+                }
+        }
+        if (rc)
+                put_device(dev);
+        return rc;
+}
+static int tifm_device_remove(struct device *dev)
+{
+        struct tifm_dev *fm_dev = container_of(dev, struct tifm_dev, dev);
+        struct tifm_driver *drv = fm_dev->drv;
+        if (drv) {
+                if (drv->remove) drv->remove(fm_dev);
+                fm_dev->drv = 0;
+        }
+        put_device(dev);
+        return 0;
+}
+int tifm_register_driver(struct tifm_driver *drv)
+{
+        drv->driver.bus = &tifm_bus_type;
+        drv->driver.probe = tifm_device_probe;
+        drv->driver.remove = tifm_device_remove;
+        return driver_register(&drv->driver);
+}
+EXPORT_SYMBOL(tifm_register_driver);
+void tifm_unregister_driver(struct tifm_driver *drv)
+{
+        driver_unregister(&drv->driver);
+}
+EXPORT_SYMBOL(tifm_unregister_driver);
+static int __init tifm_init(void)
+{
+        int rc = bus_register(&tifm_bus_type);
+        if (!rc) {
+                rc = class_register(&tifm_adapter_class);
+                if (rc)
+                        bus_unregister(&tifm_bus_type);
+        }
+        return rc;
+}
+static void __exit tifm_exit(void)
+{
+        class_unregister(&tifm_adapter_class);
+        bus_unregister(&tifm_bus_type);
+}
+subsys_initcall(tifm_init);
+module_exit(tifm_exit);
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Alex Dubov");
+MODULE_DESCRIPTION("TI FlashMedia core driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRIVER_VERSION);
diff --git a/drivers/mmc/Kconfig b/drivers/mmc/Kconfig
index f540bd88dc5..ea41852ec8c 100644
--- a/drivers/mmc/Kconfig
+++ b/drivers/mmc/Kconfig
@@ -109,4 +109,20 @@ config MMC_IMX
          If unsure, say N.
+config MMC_TIFM_SD
+        tristate "TI Flash Media MMC/SD Interface support  (EXPERIMENTAL)"
+        depends on MMC && EXPERIMENTAL
+        select TIFM_CORE
+        help
+          Say Y here if you want to be able to access MMC/SD cards with
+          the Texas Instruments(R) Flash Media card reader, found in many
+          laptops.
+          This option 'selects' (turns on, enables) 'TIFM_CORE', but you
+          probably also need appropriate card reader host adapter, such as
+          'Misc devices: TI Flash Media PCI74xx/PCI76xx host adapter support
+          (TIFM_7XX1)'.
+          To compile this driver as a module, choose M here: the
+          module will be called tifm_sd.
 endmenu
diff --git a/drivers/mmc/Makefile b/drivers/mmc/Makefile
index b1f6e03e7aa..acfd4de0aba 100644
--- a/drivers/mmc/Makefile
+++ b/drivers/mmc/Makefile
@@ -23,6 +23,7 @@ obj-$(CONFIG_MMC_WBSD)		+= wbsd.o
 obj-$(CONFIG_MMC_AU1X)          += au1xmmc.o
 obj-$(CONFIG_MMC_OMAP)          += omap.o
 obj-$(CONFIG_MMC_AT91RM9200)    += at91_mci.o
+obj-$(CONFIG_MMC_TIFM_SD)       += tifm_sd.o
 mmc_core-y := mmc.o mmc_sysfs.o
 mmc_core-$(CONFIG_BLOCK) += mmc_queue.o
diff --git a/drivers/mmc/mmc.c b/drivers/mmc/mmc.c
index 5b9caa7978d..ee8863c123e 100644
--- a/drivers/mmc/mmc.c
+++ b/drivers/mmc/mmc.c
@@ -1166,9 +1166,9 @@ static void mmc_setup(struct mmc_host *host)
 void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 {
        if (delay)
-                schedule_delayed_work(&host->detect, delay);
+                mmc_schedule_delayed_work(&host->detect, delay);
        else
-                schedule_work(&host->detect);
+                mmc_schedule_work(&host->detect);
 }
 EXPORT_SYMBOL(mmc_detect_change);
@@ -1311,7 +1311,7 @@ EXPORT_SYMBOL(mmc_remove_host);
 */
 void mmc_free_host(struct mmc_host *host)
 {
-        flush_scheduled_work();
+        mmc_flush_scheduled_work();
        mmc_free_host_sysfs(host);
 }
diff --git a/drivers/mmc/mmc.h b/drivers/mmc/mmc.h
index 97bae00292f..cd5e0ab3d84 100644
--- a/drivers/mmc/mmc.h
+++ b/drivers/mmc/mmc.h
@@ -18,4 +18,8 @@ struct mmc_host *mmc_alloc_host_sysfs(int extra, struct device *dev);
 int mmc_add_host_sysfs(struct mmc_host *host);
 void mmc_remove_host_sysfs(struct mmc_host *host);
 void mmc_free_host_sysfs(struct mmc_host *host);
+int mmc_schedule_work(struct work_struct *work);
+int mmc_schedule_delayed_work(struct work_struct *work, unsigned long delay);
+void mmc_flush_scheduled_work(void);
 #endif
diff --git a/drivers/mmc/mmc_block.c b/drivers/mmc/mmc_block.c
index db0e8ad439a..c1293f1bda8 100644
--- a/drivers/mmc/mmc_block.c
+++ b/drivers/mmc/mmc_block.c
@@ -158,13 +158,13 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 {
        struct mmc_blk_data *md = mq->data;
        struct mmc_card *card = md->queue.card;
+        struct mmc_blk_request brq;
        int ret;
        if (mmc_card_claim_host(card))
                goto cmd_err;
        do {
-                struct mmc_blk_request brq;
                struct mmc_command cmd;
                u32 readcmd, writecmd;
@@ -278,17 +278,27 @@ static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req)
 cmd_err:
        mmc_card_release_host(card);
+        ret = 1;
        /*
-         * This is a little draconian, but until we get proper
+         * For writes and where the host claims to support proper
-         * error handling sorted out here, its the best we can
+         * error reporting, we first ok the successful blocks.
-         * do - especially as some hosts have no idea how much
+         *
-         * data was transferred before the error occurred.
+         * For reads we just fail the entire chunk as that should
+         * be safe in all cases.
         */
+        if (rq_data_dir(req) != READ &&
+            (card->host->caps & MMC_CAP_MULTIWRITE)) {
+                spin_lock_irq(&md->lock);
+                ret = end_that_request_chunk(req, 1, brq.data.bytes_xfered);
+                spin_unlock_irq(&md->lock);
+        }
        spin_lock_irq(&md->lock);
-        do {
+        while (ret) {
                ret = end_that_request_chunk(req, 0,
                                req->current_nr_sectors << 9);
-        } while (ret);
+        }
        add_disk_randomness(req->rq_disk);
        blkdev_dequeue_request(req);
diff --git a/drivers/mmc/mmc_sysfs.c b/drivers/mmc/mmc_sysfs.c
index a2a35fd946e..10cc9734eaa 100644
--- a/drivers/mmc/mmc_sysfs.c
+++ b/drivers/mmc/mmc_sysfs.c
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/device.h>
 #include <linux/idr.h>
+#include <linux/workqueue.h>
 #include <linux/mmc/card.h>
 #include <linux/mmc/host.h>
@@ -317,10 +318,41 @@ void mmc_free_host_sysfs(struct mmc_host *host)
        class_device_put(&host->class_dev);
 }
+static struct workqueue_struct *workqueue;
+/*
+ * Internal function. Schedule work in the MMC work queue.
+ */
+int mmc_schedule_work(struct work_struct *work)
+{
+        return queue_work(workqueue, work);
+}
+/*
+ * Internal function. Schedule delayed work in the MMC work queue.
+ */
+int mmc_schedule_delayed_work(struct work_struct *work, unsigned long delay)
+{
+        return queue_delayed_work(workqueue, work, delay);
+}
+/*
+ * Internal function. Flush all scheduled work from the MMC work queue.
+ */
+void mmc_flush_scheduled_work(void)
+{
+        flush_workqueue(workqueue);
+}
 static int __init mmc_init(void)
 {
-        int ret = bus_register(&mmc_bus_type);
+        int ret;
+        workqueue = create_singlethread_workqueue("kmmcd");
+        if (!workqueue)
+                return -ENOMEM;
+        ret = bus_register(&mmc_bus_type);
        if (ret == 0) {
                ret = class_register(&mmc_host_class);
                if (ret)
@@ -333,6 +365,7 @@ static void __exit mmc_exit(void)
 {
        class_unregister(&mmc_host_class);
        bus_unregister(&mmc_bus_type);
+        destroy_workqueue(workqueue);
 }
 module_init(mmc_init);
diff --git a/drivers/mmc/sdhci.c b/drivers/mmc/sdhci.c
index 4dab5ec392e..20711acb012 100644
--- a/drivers/mmc/sdhci.c
+++ b/drivers/mmc/sdhci.c
@@ -35,6 +35,8 @@ static unsigned int debug_quirks = 0;
 #define SDHCI_QUIRK_CLOCK_BEFORE_RESET                  (1<<0)
 #define SDHCI_QUIRK_FORCE_DMA                           (1<<1)
+/* Controller doesn't like some resets when there is no card inserted. */
+#define SDHCI_QUIRK_NO_CARD_NO_RESET                    (1<<2)
 static const struct pci_device_id pci_ids[] __devinitdata = {
        {
@@ -51,7 +53,8 @@ static const struct pci_device_id pci_ids[] __devinitdata = {
                .device         = PCI_DEVICE_ID_RICOH_R5C822,
                .subvendor      = PCI_ANY_ID,
                .subdevice      = PCI_ANY_ID,
-                .driver_data    = SDHCI_QUIRK_FORCE_DMA,
+                .driver_data    = SDHCI_QUIRK_FORCE_DMA |
+                                  SDHCI_QUIRK_NO_CARD_NO_RESET,
        },
        {
@@ -125,6 +128,12 @@ static void sdhci_reset(struct sdhci_host *host, u8 mask)
 {
        unsigned long timeout;
+        if (host->chip->quirks & SDHCI_QUIRK_NO_CARD_NO_RESET) {
+                if (!(readl(host->ioaddr + SDHCI_PRESENT_STATE) &
+                        SDHCI_CARD_PRESENT))
+                        return;
+        }
        writeb(mask, host->ioaddr + SDHCI_SOFTWARE_RESET);
        if (mask & SDHCI_RESET_ALL)
@@ -717,6 +726,7 @@ static void sdhci_request(struct mmc_host *mmc, struct mmc_request *mrq)
        } else
                sdhci_send_command(host, mrq->cmd);
+        mmiowb();
        spin_unlock_irqrestore(&host->lock, flags);
 }
@@ -753,6 +763,7 @@ static void sdhci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                ctrl &= ~SDHCI_CTRL_4BITBUS;
        writeb(ctrl, host->ioaddr + SDHCI_HOST_CONTROL);
+        mmiowb();
        spin_unlock_irqrestore(&host->lock, flags);
 }
@@ -860,6 +871,7 @@ static void sdhci_tasklet_finish(unsigned long param)
        sdhci_deactivate_led(host);
+        mmiowb();
        spin_unlock_irqrestore(&host->lock, flags);
        mmc_request_done(host->mmc, mrq);
@@ -893,6 +905,7 @@ static void sdhci_timeout_timer(unsigned long data)
                }
        }
+        mmiowb();
        spin_unlock_irqrestore(&host->lock, flags);
 }
@@ -1030,6 +1043,7 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id, struct pt_regs *regs)
        result = IRQ_HANDLED;
+        mmiowb();
 out:
        spin_unlock(&host->lock);
@@ -1095,6 +1109,7 @@ static int sdhci_resume (struct pci_dev *pdev)
                if (chip->hosts[i]->flags & SDHCI_USE_DMA)
                        pci_set_master(pdev);
                sdhci_init(chip->hosts[i]);
+                mmiowb();
                ret = mmc_resume_host(chip->hosts[i]->mmc);
                if (ret)
                        return ret;
@@ -1168,6 +1183,9 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
        host = mmc_priv(mmc);
        host->mmc = mmc;
+        host->chip = chip;
+        chip->hosts[slot] = host;
        host->bar = first_bar + slot;
        host->addr = pci_resource_start(pdev, host->bar);
@@ -1324,8 +1342,7 @@ static int __devinit sdhci_probe_slot(struct pci_dev *pdev, int slot)
        sdhci_dumpregs(host);
 #endif
-        host->chip = chip;
+        mmiowb();
-        chip->hosts[slot] = host;
        mmc_add_host(mmc);
diff --git a/drivers/mmc/tifm_sd.c b/drivers/mmc/tifm_sd.c
new file mode 100644
index 00000000000..6d23dc08d16
--- /dev/null
+++ b/drivers/mmc/tifm_sd.c
@@ -0,0 +1,933 @@
+/*
+ *  tifm_sd.c - TI FlashMedia driver
+ *
+ *  Copyright (C) 2006 Alex Dubov <oakad@yahoo.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+#include <linux/tifm.h>
+#include <linux/mmc/protocol.h>
+#include <linux/mmc/host.h>
+#include <linux/highmem.h>
+#define DRIVER_NAME "tifm_sd"
+#define DRIVER_VERSION "0.6"
+static int no_dma = 0;
+static int fixed_timeout = 0;
+module_param(no_dma, bool, 0644);
+module_param(fixed_timeout, bool, 0644);
+/* Constants here are mostly from OMAP5912 datasheet */
+#define TIFM_MMCSD_RESET      0x0002
+#define TIFM_MMCSD_CLKMASK    0x03ff
+#define TIFM_MMCSD_POWER      0x0800
+#define TIFM_MMCSD_4BBUS      0x8000
+#define TIFM_MMCSD_RXDE       0x8000   /* rx dma enable */
+#define TIFM_MMCSD_TXDE       0x0080   /* tx dma enable */
+#define TIFM_MMCSD_BUFINT     0x0c00   /* set bits: AE, AF */
+#define TIFM_MMCSD_DPE        0x0020   /* data timeout counted in kilocycles */
+#define TIFM_MMCSD_INAB       0x0080   /* abort / initialize command */
+#define TIFM_MMCSD_READ       0x8000
+#define TIFM_MMCSD_DATAMASK   0x001d   /* set bits: EOFB, BRS, CB, EOC */
+#define TIFM_MMCSD_ERRMASK    0x41e0   /* set bits: CERR, CCRC, CTO, DCRC, DTO */
+#define TIFM_MMCSD_EOC        0x0001   /* end of command phase  */
+#define TIFM_MMCSD_CB         0x0004   /* card enter busy state */
+#define TIFM_MMCSD_BRS        0x0008   /* block received/sent   */
+#define TIFM_MMCSD_EOFB       0x0010   /* card exit busy state  */
+#define TIFM_MMCSD_DTO        0x0020   /* data time-out         */
+#define TIFM_MMCSD_DCRC       0x0040   /* data crc error        */
+#define TIFM_MMCSD_CTO        0x0080   /* command time-out      */
+#define TIFM_MMCSD_CCRC       0x0100   /* command crc error     */
+#define TIFM_MMCSD_AF         0x0400   /* fifo almost full      */
+#define TIFM_MMCSD_AE         0x0800   /* fifo almost empty     */
+#define TIFM_MMCSD_CERR       0x4000   /* card status error     */
+#define TIFM_MMCSD_FIFO_SIZE  0x0020
+#define TIFM_MMCSD_RSP_R0     0x0000
+#define TIFM_MMCSD_RSP_R1     0x0100
+#define TIFM_MMCSD_RSP_R2     0x0200
+#define TIFM_MMCSD_RSP_R3     0x0300
+#define TIFM_MMCSD_RSP_R4     0x0400
+#define TIFM_MMCSD_RSP_R5     0x0500
+#define TIFM_MMCSD_RSP_R6     0x0600
+#define TIFM_MMCSD_RSP_BUSY   0x0800
+#define TIFM_MMCSD_CMD_BC     0x0000
+#define TIFM_MMCSD_CMD_BCR    0x1000
+#define TIFM_MMCSD_CMD_AC     0x2000
+#define TIFM_MMCSD_CMD_ADTC   0x3000
+typedef enum {
+        IDLE = 0,
+        CMD,    /* main command ended                   */
+        BRS,    /* block transfer finished              */
+        SCMD,   /* stop command ended                   */
+        CARD,   /* card left busy state                 */
+        FIFO,   /* FIFO operation completed (uncertain) */
+        READY
+} card_state_t;
+enum {
+        FIFO_RDY   = 0x0001,     /* hardware dependent value */
+        HOST_REG   = 0x0002,
+        EJECT      = 0x0004,
+        EJECT_DONE = 0x0008,
+        CARD_BUSY  = 0x0010,
+        OPENDRAIN  = 0x0040,     /* hardware dependent value */
+        CARD_EVENT = 0x0100,     /* hardware dependent value */
+        CARD_RO    = 0x0200,     /* hardware dependent value */
+        FIFO_EVENT = 0x10000 };  /* hardware dependent value */
+struct tifm_sd {
+        struct tifm_dev     *dev;
+        unsigned int        flags;
+        card_state_t        state;
+        unsigned int        clk_freq;
+        unsigned int        clk_div;
+        unsigned long       timeout_jiffies; // software timeout - 2 sec
+        struct mmc_request    *req;
+        struct work_struct    cmd_handler;
+        struct work_struct    abort_handler;
+        wait_queue_head_t     can_eject;
+        size_t                written_blocks;
+        char                  *buffer;
+        size_t                buffer_size;
+        size_t                buffer_pos;
+};
+static int tifm_sd_transfer_data(struct tifm_dev *sock, struct tifm_sd *host,
+                                        unsigned int host_status)
+{
+        struct mmc_command *cmd = host->req->cmd;
+        unsigned int t_val = 0, cnt = 0;
+        if (host_status & TIFM_MMCSD_BRS) {
+                /* in non-dma rx mode BRS fires when fifo is still not empty */
+                if (host->buffer && (cmd->data->flags & MMC_DATA_READ)) {
+                        while (host->buffer_size > host->buffer_pos) {
+                                t_val = readl(sock->addr + SOCK_MMCSD_DATA);
+                                host->buffer[host->buffer_pos++] = t_val & 0xff;
+                                host->buffer[host->buffer_pos++] =
+                                                        (t_val >> 8) & 0xff;
+                        }
+                }
+                return 1;
+        } else if (host->buffer) {
+                if ((cmd->data->flags & MMC_DATA_READ) &&
+                                (host_status & TIFM_MMCSD_AF)) {
+                        for (cnt = 0; cnt < TIFM_MMCSD_FIFO_SIZE; cnt++) {
+                                t_val = readl(sock->addr + SOCK_MMCSD_DATA);
+                                if (host->buffer_size > host->buffer_pos) {
+                                        host->buffer[host->buffer_pos++] =
+                                                        t_val & 0xff;
+                                        host->buffer[host->buffer_pos++] =
+                                                        (t_val >> 8) & 0xff;
+                                }
+                        }
+                } else if ((cmd->data->flags & MMC_DATA_WRITE)
+                           && (host_status & TIFM_MMCSD_AE)) {
+                        for (cnt = 0; cnt < TIFM_MMCSD_FIFO_SIZE; cnt++) {
+                                if (host->buffer_size > host->buffer_pos) {
+                                        t_val = host->buffer[host->buffer_pos++] & 0x00ff;
+                                        t_val |= ((host->buffer[host->buffer_pos++]) << 8)
+                                                 & 0xff00;
+                                        writel(t_val,
+                                                sock->addr + SOCK_MMCSD_DATA);
+                                }
+                        }
+                }
+        }
+        return 0;
+}
+static unsigned int tifm_sd_op_flags(struct mmc_command *cmd)
+{
+        unsigned int rc = 0;
+        switch (mmc_resp_type(cmd)) {
+        case MMC_RSP_NONE:
+                rc |= TIFM_MMCSD_RSP_R0;
+                break;
+        case MMC_RSP_R1B:
+                rc |= TIFM_MMCSD_RSP_BUSY; // deliberate fall-through
+        case MMC_RSP_R1:
+                rc |= TIFM_MMCSD_RSP_R1;
+                break;
+        case MMC_RSP_R2:
+                rc |= TIFM_MMCSD_RSP_R2;
+                break;
+        case MMC_RSP_R3:
+                rc |= TIFM_MMCSD_RSP_R3;
+                break;
+        case MMC_RSP_R6:
+                rc |= TIFM_MMCSD_RSP_R6;
+                break;
+        default:
+                BUG();
+        }
+        switch (mmc_cmd_type(cmd)) {
+        case MMC_CMD_BC:
+                rc |= TIFM_MMCSD_CMD_BC;
+                break;
+        case MMC_CMD_BCR:
+                rc |= TIFM_MMCSD_CMD_BCR;
+                break;
+        case MMC_CMD_AC:
+                rc |= TIFM_MMCSD_CMD_AC;
+                break;
+        case MMC_CMD_ADTC:
+                rc |= TIFM_MMCSD_CMD_ADTC;
+                break;
+        default:
+                BUG();
+        }
+        return rc;
+}
+static void tifm_sd_exec(struct tifm_sd *host, struct mmc_command *cmd)
+{
+        struct tifm_dev *sock = host->dev;
+        unsigned int cmd_mask = tifm_sd_op_flags(cmd) |
+                                (host->flags & OPENDRAIN);
+        if (cmd->data && (cmd->data->flags & MMC_DATA_READ))
+                cmd_mask |= TIFM_MMCSD_READ;
+        dev_dbg(&sock->dev, "executing opcode 0x%x, arg: 0x%x, mask: 0x%x\n",
+                                cmd->opcode, cmd->arg, cmd_mask);
+        writel((cmd->arg >> 16) & 0xffff, sock->addr + SOCK_MMCSD_ARG_HIGH);
+        writel(cmd->arg & 0xffff, sock->addr + SOCK_MMCSD_ARG_LOW);
+        writel(cmd->opcode | cmd_mask, sock->addr + SOCK_MMCSD_COMMAND);
+}
+static void tifm_sd_fetch_resp(struct mmc_command *cmd, struct tifm_dev *sock)
+{
+        cmd->resp[0] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x1c) << 16)
+                       | readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x18);
+        cmd->resp[1] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x14) << 16)
+                       | readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x10);
+        cmd->resp[2] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x0c) << 16)
+                       | readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x08);
+        cmd->resp[3] = (readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x04) << 16)
+                       | readl(sock->addr + SOCK_MMCSD_RESPONSE + 0x00);
+}
+static void tifm_sd_process_cmd(struct tifm_dev *sock, struct tifm_sd *host,
+                                       unsigned int host_status)
+{
+        struct mmc_command *cmd = host->req->cmd;
+change_state:
+        switch (host->state) {
+        case IDLE:
+                return;
+        case CMD:
+                if (host_status & TIFM_MMCSD_EOC) {
+                        tifm_sd_fetch_resp(cmd, sock);
+                        if (cmd->data) {
+                                host->state = BRS;
+                        } else
+                                host->state = READY;
+                        goto change_state;
+                }
+                break;
+        case BRS:
+                if (tifm_sd_transfer_data(sock, host, host_status)) {
+                        if (!host->req->stop) {
+                                if (cmd->data->flags & MMC_DATA_WRITE) {
+                                        host->state = CARD;
+                                } else {
+                                        host->state =
+                                                host->buffer ? READY : FIFO;
+                                }
+                                goto change_state;
+                        }
+                        tifm_sd_exec(host, host->req->stop);
+                        host->state = SCMD;
+                }
+                break;
+        case SCMD:
+                if (host_status & TIFM_MMCSD_EOC) {
+                        tifm_sd_fetch_resp(host->req->stop, sock);
+                        if (cmd->error) {
+                                host->state = READY;
+                        } else if (cmd->data->flags & MMC_DATA_WRITE) {
+                                host->state = CARD;
+                        } else {
+                                host->state = host->buffer ? READY : FIFO;
+                        }
+                        goto change_state;
+                }
+                break;
+        case CARD:
+                if (!(host->flags & CARD_BUSY)
+                    && (host->written_blocks == cmd->data->blocks)) {
+                        host->state = host->buffer ? READY : FIFO;
+                        goto change_state;
+                }
+                break;
+        case FIFO:
+                if (host->flags & FIFO_RDY) {
+                        host->state = READY;
+                        host->flags &= ~FIFO_RDY;
+                        goto change_state;
+                }
+                break;
+        case READY:
+                queue_work(sock->wq, &host->cmd_handler);
+                return;
+        }
+        queue_delayed_work(sock->wq, &host->abort_handler,
+                                host->timeout_jiffies);
+}
+/* Called from interrupt handler */
+static unsigned int tifm_sd_signal_irq(struct tifm_dev *sock,
+                                        unsigned int sock_irq_status)
+{
+        struct tifm_sd *host;
+        unsigned int host_status = 0, fifo_status = 0;
+        int error_code = 0;
+        spin_lock(&sock->lock);
+        host = mmc_priv((struct mmc_host*)tifm_get_drvdata(sock));
+        cancel_delayed_work(&host->abort_handler);
+        if (sock_irq_status & FIFO_EVENT) {
+                fifo_status = readl(sock->addr + SOCK_DMA_FIFO_STATUS);
+                writel(fifo_status, sock->addr + SOCK_DMA_FIFO_STATUS);
+                host->flags |= fifo_status & FIFO_RDY;
+        }
+        if (sock_irq_status & CARD_EVENT) {
+                host_status = readl(sock->addr + SOCK_MMCSD_STATUS);
+                writel(host_status, sock->addr + SOCK_MMCSD_STATUS);
+                if (!(host->flags & HOST_REG))
+                        queue_work(sock->wq, &host->cmd_handler);
+                if (!host->req)
+                        goto done;
+                if (host_status & TIFM_MMCSD_ERRMASK) {
+                        if (host_status & TIFM_MMCSD_CERR)
+                                error_code = MMC_ERR_FAILED;
+                        else if (host_status &
+                                        (TIFM_MMCSD_CTO | TIFM_MMCSD_DTO))
+                                error_code = MMC_ERR_TIMEOUT;
+                        else if (host_status &
+                                        (TIFM_MMCSD_CCRC | TIFM_MMCSD_DCRC))
+                                error_code = MMC_ERR_BADCRC;
+                        writel(TIFM_FIFO_INT_SETALL,
+                               sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
+                        writel(TIFM_DMA_RESET, sock->addr + SOCK_DMA_CONTROL);
+                        if (host->req->stop) {
+                                if (host->state == SCMD) {
+                                        host->req->stop->error = error_code;
+                                } else if(host->state == BRS) {
+                                        host->req->cmd->error = error_code;
+                                        tifm_sd_exec(host, host->req->stop);
+                                        queue_delayed_work(sock->wq,
+                                                &host->abort_handler,
+                                                host->timeout_jiffies);
+                                        host->state = SCMD;
+                                        goto done;
+                                } else {
+                                        host->req->cmd->error = error_code;
+                                }
+                        } else {
+                                host->req->cmd->error = error_code;
+                        }
+                        host->state = READY;
+                }
+                if (host_status & TIFM_MMCSD_CB)
+                        host->flags |= CARD_BUSY;
+                if ((host_status & TIFM_MMCSD_EOFB) &&
+                                (host->flags & CARD_BUSY)) {
+                        host->written_blocks++;
+                        host->flags &= ~CARD_BUSY;
+                }
+        }
+        if (host->req)
+                tifm_sd_process_cmd(sock, host, host_status);
+done:
+        dev_dbg(&sock->dev, "host_status %x, fifo_status %x\n",
+                        host_status, fifo_status);
+        spin_unlock(&sock->lock);
+        return sock_irq_status;
+}
+static void tifm_sd_prepare_data(struct tifm_sd *card, struct mmc_command *cmd)
+{
+        struct tifm_dev *sock = card->dev;
+        unsigned int dest_cnt;
+        /* DMA style IO */
+        writel(TIFM_FIFO_INT_SETALL,
+                sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
+        writel(long_log2(cmd->data->blksz) - 2,
+                        sock->addr + SOCK_FIFO_PAGE_SIZE);
+        writel(TIFM_FIFO_ENABLE, sock->addr + SOCK_FIFO_CONTROL);
+        writel(TIFM_FIFO_INTMASK, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
+        dest_cnt = (cmd->data->blocks) << 8;
+        writel(sg_dma_address(cmd->data->sg), sock->addr + SOCK_DMA_ADDRESS);
+        writel(cmd->data->blocks - 1, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
+        writel(cmd->data->blksz - 1, sock->addr + SOCK_MMCSD_BLOCK_LEN);
+        if (cmd->data->flags & MMC_DATA_WRITE) {
+                writel(TIFM_MMCSD_TXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
+                writel(dest_cnt | TIFM_DMA_TX | TIFM_DMA_EN,
+                        sock->addr + SOCK_DMA_CONTROL);
+        } else {
+                writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
+                writel(dest_cnt | TIFM_DMA_EN, sock->addr + SOCK_DMA_CONTROL);
+        }
+}
+static void tifm_sd_set_data_timeout(struct tifm_sd *host,
+                                        struct mmc_data *data)
+{
+        struct tifm_dev *sock = host->dev;
+        unsigned int data_timeout = data->timeout_clks;
+        if (fixed_timeout)
+                return;
+        data_timeout += data->timeout_ns /
+                        ((1000000000 / host->clk_freq) * host->clk_div);
+        data_timeout *= 10; // call it fudge factor for now
+        if (data_timeout < 0xffff) {
+                writel((~TIFM_MMCSD_DPE) &
+                                readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
+                       sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
+                writel(data_timeout, sock->addr + SOCK_MMCSD_DATA_TO);
+        } else {
+                writel(TIFM_MMCSD_DPE |
+                                readl(sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG),
+                        sock->addr + SOCK_MMCSD_SDIO_MODE_CONFIG);
+                data_timeout = (data_timeout >> 10) + 1;
+                if(data_timeout > 0xffff)
+                        data_timeout = 0;       /* set to unlimited */
+                writel(data_timeout, sock->addr + SOCK_MMCSD_DATA_TO);
+        }
+}
+static void tifm_sd_request(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct tifm_sd *host = mmc_priv(mmc);
+        struct tifm_dev *sock = host->dev;
+        unsigned long flags;
+        int sg_count = 0;
+        struct mmc_data *r_data = mrq->cmd->data;
+        spin_lock_irqsave(&sock->lock, flags);
+        if (host->flags & EJECT) {
+                spin_unlock_irqrestore(&sock->lock, flags);
+                goto err_out;
+        }
+        if (host->req) {
+                printk(KERN_ERR DRIVER_NAME ": unfinished request detected\n");
+                spin_unlock_irqrestore(&sock->lock, flags);
+                goto err_out;
+        }
+        if (r_data) {
+                tifm_sd_set_data_timeout(host, r_data);
+                sg_count = tifm_map_sg(sock, r_data->sg, r_data->sg_len,
+                                       mrq->cmd->flags & MMC_DATA_WRITE
+                                       ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
+                if (sg_count != 1) {
+                        printk(KERN_ERR DRIVER_NAME
+                                ": scatterlist map failed\n");
+                        spin_unlock_irqrestore(&sock->lock, flags);
+                        goto err_out;
+                }
+                host->written_blocks = 0;
+                host->flags &= ~CARD_BUSY;
+                tifm_sd_prepare_data(host, mrq->cmd);
+        }
+        host->req = mrq;
+        host->state = CMD;
+        queue_delayed_work(sock->wq, &host->abort_handler,
+                                host->timeout_jiffies);
+        writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
+                sock->addr + SOCK_CONTROL);
+        tifm_sd_exec(host, mrq->cmd);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        return;
+err_out:
+        if (sg_count > 0)
+                tifm_unmap_sg(sock, r_data->sg, r_data->sg_len,
+                              (r_data->flags & MMC_DATA_WRITE)
+                              ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
+        mrq->cmd->error = MMC_ERR_TIMEOUT;
+        mmc_request_done(mmc, mrq);
+}
+static void tifm_sd_end_cmd(void *data)
+{
+        struct tifm_sd *host = data;
+        struct tifm_dev *sock = host->dev;
+        struct mmc_host *mmc = tifm_get_drvdata(sock);
+        struct mmc_request *mrq;
+        struct mmc_data *r_data = 0;
+        unsigned long flags;
+        spin_lock_irqsave(&sock->lock, flags);
+        mrq = host->req;
+        host->req = 0;
+        host->state = IDLE;
+        if (!mrq) {
+                printk(KERN_ERR DRIVER_NAME ": no request to complete?\n");
+                spin_unlock_irqrestore(&sock->lock, flags);
+                return;
+        }
+        r_data = mrq->cmd->data;
+        if (r_data) {
+                if (r_data->flags & MMC_DATA_WRITE) {
+                        r_data->bytes_xfered = host->written_blocks *
+                                                r_data->blksz;
+                } else {
+                        r_data->bytes_xfered = r_data->blocks -
+                                readl(sock->addr + SOCK_MMCSD_NUM_BLOCKS) - 1;
+                        r_data->bytes_xfered *= r_data->blksz;
+                        r_data->bytes_xfered += r_data->blksz -
+                                readl(sock->addr + SOCK_MMCSD_BLOCK_LEN) + 1;
+                }
+                tifm_unmap_sg(sock, r_data->sg, r_data->sg_len,
+                              (r_data->flags & MMC_DATA_WRITE)
+                              ? PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
+        }
+        writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
+                        sock->addr + SOCK_CONTROL);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        mmc_request_done(mmc, mrq);
+}
+static void tifm_sd_request_nodma(struct mmc_host *mmc, struct mmc_request *mrq)
+{
+        struct tifm_sd *host = mmc_priv(mmc);
+        struct tifm_dev *sock = host->dev;
+        unsigned long flags;
+        struct mmc_data *r_data = mrq->cmd->data;
+        char *t_buffer = 0;
+        if (r_data) {
+                t_buffer = kmap(r_data->sg->page);
+                if (!t_buffer) {
+                        printk(KERN_ERR DRIVER_NAME ": kmap failed\n");
+                        goto err_out;
+                }
+        }
+        spin_lock_irqsave(&sock->lock, flags);
+        if (host->flags & EJECT) {
+                spin_unlock_irqrestore(&sock->lock, flags);
+                goto err_out;
+        }
+        if (host->req) {
+                printk(KERN_ERR DRIVER_NAME ": unfinished request detected\n");
+                spin_unlock_irqrestore(&sock->lock, flags);
+                goto err_out;
+        }
+        if (r_data) {
+                tifm_sd_set_data_timeout(host, r_data);
+                host->buffer = t_buffer + r_data->sg->offset;
+                host->buffer_size = mrq->cmd->data->blocks *
+                                        mrq->cmd->data->blksz;
+                writel(TIFM_MMCSD_BUFINT |
+                                readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
+                       sock->addr + SOCK_MMCSD_INT_ENABLE);
+                writel(((TIFM_MMCSD_FIFO_SIZE - 1) << 8) |
+                                (TIFM_MMCSD_FIFO_SIZE - 1),
+                       sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
+                host->written_blocks = 0;
+                host->flags &= ~CARD_BUSY;
+                host->buffer_pos = 0;
+                writel(r_data->blocks - 1, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
+                writel(r_data->blksz - 1, sock->addr + SOCK_MMCSD_BLOCK_LEN);
+        }
+        host->req = mrq;
+        host->state = CMD;
+        queue_delayed_work(sock->wq, &host->abort_handler,
+                                host->timeout_jiffies);
+        writel(TIFM_CTRL_LED | readl(sock->addr + SOCK_CONTROL),
+                sock->addr + SOCK_CONTROL);
+        tifm_sd_exec(host, mrq->cmd);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        return;
+err_out:
+        if (t_buffer)
+                kunmap(r_data->sg->page);
+        mrq->cmd->error = MMC_ERR_TIMEOUT;
+        mmc_request_done(mmc, mrq);
+}
+static void tifm_sd_end_cmd_nodma(void *data)
+{
+        struct tifm_sd *host = (struct tifm_sd*)data;
+        struct tifm_dev *sock = host->dev;
+        struct mmc_host *mmc = tifm_get_drvdata(sock);
+        struct mmc_request *mrq;
+        struct mmc_data *r_data = 0;
+        unsigned long flags;
+        spin_lock_irqsave(&sock->lock, flags);
+        mrq = host->req;
+        host->req = 0;
+        host->state = IDLE;
+        if (!mrq) {
+                printk(KERN_ERR DRIVER_NAME ": no request to complete?\n");
+                spin_unlock_irqrestore(&sock->lock, flags);
+                return;
+        }
+        r_data = mrq->cmd->data;
+        if (r_data) {
+                writel((~TIFM_MMCSD_BUFINT) &
+                        readl(sock->addr + SOCK_MMCSD_INT_ENABLE),
+                        sock->addr + SOCK_MMCSD_INT_ENABLE);
+                if (r_data->flags & MMC_DATA_WRITE) {
+                        r_data->bytes_xfered = host->written_blocks *
+                                                r_data->blksz;
+                } else {
+                        r_data->bytes_xfered = r_data->blocks -
+                                readl(sock->addr + SOCK_MMCSD_NUM_BLOCKS) - 1;
+                        r_data->bytes_xfered *= r_data->blksz;
+                        r_data->bytes_xfered += r_data->blksz -
+                                readl(sock->addr + SOCK_MMCSD_BLOCK_LEN) + 1;
+                }
+                host->buffer = 0;
+                host->buffer_pos = 0;
+                host->buffer_size = 0;
+        }
+        writel((~TIFM_CTRL_LED) & readl(sock->addr + SOCK_CONTROL),
+                        sock->addr + SOCK_CONTROL);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        if (r_data)
+                kunmap(r_data->sg->page);
+        mmc_request_done(mmc, mrq);
+}
+static void tifm_sd_abort(void *data)
+{
+        printk(KERN_ERR DRIVER_NAME
+                ": card failed to respond for a long period of time");
+        tifm_eject(((struct tifm_sd*)data)->dev);
+}
+static void tifm_sd_ios(struct mmc_host *mmc, struct mmc_ios *ios)
+{
+        struct tifm_sd *host = mmc_priv(mmc);
+        struct tifm_dev *sock = host->dev;
+        unsigned int clk_div1, clk_div2;
+        unsigned long flags;
+        spin_lock_irqsave(&sock->lock, flags);
+        dev_dbg(&sock->dev, "Setting bus width %d, power %d\n", ios->bus_width,
+                ios->power_mode);
+        if (ios->bus_width == MMC_BUS_WIDTH_4) {
+                writel(TIFM_MMCSD_4BBUS | readl(sock->addr + SOCK_MMCSD_CONFIG),
+                       sock->addr + SOCK_MMCSD_CONFIG);
+        } else {
+                writel((~TIFM_MMCSD_4BBUS) &
+                                readl(sock->addr + SOCK_MMCSD_CONFIG),
+                        sock->addr + SOCK_MMCSD_CONFIG);
+        }
+        if (ios->clock) {
+                clk_div1 = 20000000 / ios->clock;
+                if (!clk_div1)
+                        clk_div1 = 1;
+                clk_div2 = 24000000 / ios->clock;
+                if (!clk_div2)
+                        clk_div2 = 1;
+                if ((20000000 / clk_div1) > ios->clock)
+                        clk_div1++;
+                if ((24000000 / clk_div2) > ios->clock)
+                        clk_div2++;
+                if ((20000000 / clk_div1) > (24000000 / clk_div2)) {
+                        host->clk_freq = 20000000;
+                        host->clk_div = clk_div1;
+                        writel((~TIFM_CTRL_FAST_CLK) &
+                                        readl(sock->addr + SOCK_CONTROL),
+                                sock->addr + SOCK_CONTROL);
+                } else {
+                        host->clk_freq = 24000000;
+                        host->clk_div = clk_div2;
+                        writel(TIFM_CTRL_FAST_CLK |
+                                        readl(sock->addr + SOCK_CONTROL),
+                                sock->addr + SOCK_CONTROL);
+                }
+        } else {
+                host->clk_div = 0;
+        }
+        host->clk_div &= TIFM_MMCSD_CLKMASK;
+        writel(host->clk_div | ((~TIFM_MMCSD_CLKMASK) &
+                        readl(sock->addr + SOCK_MMCSD_CONFIG)),
+                sock->addr + SOCK_MMCSD_CONFIG);
+        if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN)
+                host->flags |= OPENDRAIN;
+        else
+                host->flags &= ~OPENDRAIN;
+        /* chip_select : maybe later */
+        //vdd
+        //power is set before probe / after remove
+        //I believe, power_off when already marked for eject is sufficient to
+        // allow removal.
+        if ((host->flags & EJECT) && ios->power_mode == MMC_POWER_OFF) {
+                host->flags |= EJECT_DONE;
+                wake_up_all(&host->can_eject);
+        }
+        spin_unlock_irqrestore(&sock->lock, flags);
+}
+static int tifm_sd_ro(struct mmc_host *mmc)
+{
+        int rc;
+        struct tifm_sd *host = mmc_priv(mmc);
+        struct tifm_dev *sock = host->dev;
+        unsigned long flags;
+        spin_lock_irqsave(&sock->lock, flags);
+        host->flags |= (CARD_RO & readl(sock->addr + SOCK_PRESENT_STATE));
+        rc = (host->flags & CARD_RO) ? 1 : 0;
+        spin_unlock_irqrestore(&sock->lock, flags);
+        return rc;
+}
+static struct mmc_host_ops tifm_sd_ops = {
+        .request = tifm_sd_request,
+        .set_ios = tifm_sd_ios,
+        .get_ro  = tifm_sd_ro
+};
+static void tifm_sd_register_host(void *data)
+{
+        struct tifm_sd *host = (struct tifm_sd*)data;
+        struct tifm_dev *sock = host->dev;
+        struct mmc_host *mmc = tifm_get_drvdata(sock);
+        unsigned long flags;
+        spin_lock_irqsave(&sock->lock, flags);
+        host->flags |= HOST_REG;
+        PREPARE_WORK(&host->cmd_handler,
+                        no_dma ? tifm_sd_end_cmd_nodma : tifm_sd_end_cmd,
+                        data);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        dev_dbg(&sock->dev, "adding host\n");
+        mmc_add_host(mmc);
+}
+static int tifm_sd_probe(struct tifm_dev *sock)
+{
+        struct mmc_host *mmc;
+        struct tifm_sd *host;
+        int rc = -EIO;
+        if (!(TIFM_SOCK_STATE_OCCUPIED &
+                        readl(sock->addr + SOCK_PRESENT_STATE))) {
+                printk(KERN_WARNING DRIVER_NAME ": card gone, unexpectedly\n");
+                return rc;
+        }
+        mmc = mmc_alloc_host(sizeof(struct tifm_sd), &sock->dev);
+        if (!mmc)
+                return -ENOMEM;
+        host = mmc_priv(mmc);
+        host->dev = sock;
+        host->clk_div = 61;
+        init_waitqueue_head(&host->can_eject);
+        INIT_WORK(&host->cmd_handler, tifm_sd_register_host, host);
+        INIT_WORK(&host->abort_handler, tifm_sd_abort, host);
+        tifm_set_drvdata(sock, mmc);
+        sock->signal_irq = tifm_sd_signal_irq;
+        host->clk_freq = 20000000;
+        host->timeout_jiffies = msecs_to_jiffies(1000);
+        tifm_sd_ops.request = no_dma ? tifm_sd_request_nodma : tifm_sd_request;
+        mmc->ops = &tifm_sd_ops;
+        mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
+        mmc->caps = MMC_CAP_4_BIT_DATA;
+        mmc->f_min = 20000000 / 60;
+        mmc->f_max = 24000000;
+        mmc->max_hw_segs = 1;
+        mmc->max_phys_segs = 1;
+        mmc->max_sectors = 127;
+        mmc->max_seg_size = mmc->max_sectors << 11; //2k maximum hw block length
+        writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
+        writel(TIFM_MMCSD_RESET, sock->addr + SOCK_MMCSD_SYSTEM_CONTROL);
+        writel(host->clk_div | TIFM_MMCSD_POWER,
+                        sock->addr + SOCK_MMCSD_CONFIG);
+        for (rc = 0; rc < 50; rc++) {
+                /* Wait for reset ack */
+                if (1 & readl(sock->addr + SOCK_MMCSD_SYSTEM_STATUS)) {
+                        rc = 0;
+                        break;
+                }
+                msleep(10);
+        }
+        if (rc) {
+                printk(KERN_ERR DRIVER_NAME
+                        ": card not ready - probe failed\n");
+                mmc_free_host(mmc);
+                return -ENODEV;
+        }
+        writel(0, sock->addr + SOCK_MMCSD_NUM_BLOCKS);
+        writel(host->clk_div | TIFM_MMCSD_POWER,
+                        sock->addr + SOCK_MMCSD_CONFIG);
+        writel(TIFM_MMCSD_RXDE, sock->addr + SOCK_MMCSD_BUFFER_CONFIG);
+        writel(TIFM_MMCSD_DATAMASK | TIFM_MMCSD_ERRMASK,
+                        sock->addr + SOCK_MMCSD_INT_ENABLE);
+        writel(64, sock->addr + SOCK_MMCSD_COMMAND_TO); // command timeout 64 clocks for now
+        writel(TIFM_MMCSD_INAB, sock->addr + SOCK_MMCSD_COMMAND);
+        writel(host->clk_div | TIFM_MMCSD_POWER,
+                        sock->addr + SOCK_MMCSD_CONFIG);
+        queue_delayed_work(sock->wq, &host->abort_handler,
+                        host->timeout_jiffies);
+        return 0;
+}
+static int tifm_sd_host_is_down(struct tifm_dev *sock)
+{
+        struct mmc_host *mmc = tifm_get_drvdata(sock);
+        struct tifm_sd *host = mmc_priv(mmc);
+        unsigned long flags;
+        int rc = 0;
+        spin_lock_irqsave(&sock->lock, flags);
+        rc = (host->flags & EJECT_DONE);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        return rc;
+}
+static void tifm_sd_remove(struct tifm_dev *sock)
+{
+        struct mmc_host *mmc = tifm_get_drvdata(sock);
+        struct tifm_sd *host = mmc_priv(mmc);
+        unsigned long flags;
+        spin_lock_irqsave(&sock->lock, flags);
+        host->flags |= EJECT;
+        if (host->req)
+                queue_work(sock->wq, &host->cmd_handler);
+        spin_unlock_irqrestore(&sock->lock, flags);
+        wait_event_timeout(host->can_eject, tifm_sd_host_is_down(sock),
+                                host->timeout_jiffies);
+        if (host->flags & HOST_REG)
+                mmc_remove_host(mmc);
+        /* The meaning of the bit majority in this constant is unknown. */
+        writel(0xfff8 & readl(sock->addr + SOCK_CONTROL),
+                sock->addr + SOCK_CONTROL);
+        writel(0, sock->addr + SOCK_MMCSD_INT_ENABLE);
+        writel(TIFM_FIFO_INT_SETALL,
+                sock->addr + SOCK_DMA_FIFO_INT_ENABLE_CLEAR);
+        writel(0, sock->addr + SOCK_DMA_FIFO_INT_ENABLE_SET);
+        tifm_set_drvdata(sock, 0);
+        mmc_free_host(mmc);
+}
+static tifm_media_id tifm_sd_id_tbl[] = {
+        FM_SD, 0
+};
+static struct tifm_driver tifm_sd_driver = {
+        .driver = {
+                .name  = DRIVER_NAME,
+                .owner = THIS_MODULE
+        },
+        .id_table = tifm_sd_id_tbl,
+        .probe    = tifm_sd_probe,
+        .remove   = tifm_sd_remove
+};
+static int __init tifm_sd_init(void)
+{
+        return tifm_register_driver(&tifm_sd_driver);
+}
+static void __exit tifm_sd_exit(void)
+{
+        tifm_unregister_driver(&tifm_sd_driver);
+}
+MODULE_AUTHOR("Alex Dubov");
+MODULE_DESCRIPTION("TI FlashMedia SD driver");
+MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(tifm, tifm_sd_id_tbl);
+MODULE_VERSION(DRIVER_VERSION);
+module_init(tifm_sd_init);
+module_exit(tifm_sd_exit);
diff --git a/drivers/parisc/iosapic.c b/drivers/parisc/iosapic.c
index 1fbda77cefc..c2949b4367e 100644
--- a/drivers/parisc/iosapic.c
+++ b/drivers/parisc/iosapic.c
@@ -146,7 +146,7 @@
 #include <asm/superio.h>
 #endif
-#include <asm/iosapic.h>
+#include <asm/ropes.h>
 #include "./iosapic_private.h"
 #define MODULE_NAME "iosapic"
@@ -692,6 +692,7 @@ static void iosapic_end_irq(unsigned int irq)
        DBG(KERN_DEBUG "end_irq(%d): eoi(%p, 0x%x)\n", irq,
                        vi->eoi_addr, vi->eoi_data);
        iosapic_eoi(vi->eoi_addr, vi->eoi_data);
+        cpu_end_irq(irq);
 }
 static unsigned int iosapic_startup_irq(unsigned int irq)
@@ -728,7 +729,7 @@ static struct hw_interrupt_type iosapic_interrupt_type = {
        .shutdown =     iosapic_disable_irq,
        .enable =       iosapic_enable_irq,
        .disable =      iosapic_disable_irq,
-        .ack =          no_ack_irq,
+        .ack =          cpu_ack_irq,
        .end =          iosapic_end_irq,
 #ifdef CONFIG_SMP
        .set_affinity = iosapic_set_affinity_irq,
diff --git a/drivers/parisc/lba_pci.c b/drivers/parisc/lba_pci.c
index 3fe4a77fa16..ba6769934c7 100644
--- a/drivers/parisc/lba_pci.c
+++ b/drivers/parisc/lba_pci.c
@@ -46,9 +46,9 @@
 #include <asm/page.h>
 #include <asm/system.h>
+#include <asm/ropes.h>
 #include <asm/hardware.h>       /* for register_parisc_driver() stuff */
 #include <asm/parisc-device.h>
-#include <asm/iosapic.h>        /* for iosapic_register() */
 #include <asm/io.h>             /* read/write stuff */
 #undef DEBUG_LBA        /* general stuff */
@@ -100,113 +100,10 @@
 #define MODULE_NAME "LBA"
-#define LBA_FUNC_ID     0x0000  /* function id */
-#define LBA_FCLASS      0x0008  /* function class, bist, header, rev... */
-#define LBA_CAPABLE     0x0030  /* capabilities register */
-#define LBA_PCI_CFG_ADDR        0x0040  /* poke CFG address here */
-#define LBA_PCI_CFG_DATA        0x0048  /* read or write data here */
-#define LBA_PMC_MTLT    0x0050  /* Firmware sets this - read only. */
-#define LBA_FW_SCRATCH  0x0058  /* Firmware writes the PCI bus number here. */
-#define LBA_ERROR_ADDR  0x0070  /* On error, address gets logged here */
-#define LBA_ARB_MASK    0x0080  /* bit 0 enable arbitration. PAT/PDC enables */
-#define LBA_ARB_PRI     0x0088  /* firmware sets this. */
-#define LBA_ARB_MODE    0x0090  /* firmware sets this. */
-#define LBA_ARB_MTLT    0x0098  /* firmware sets this. */
-#define LBA_MOD_ID      0x0100  /* Module ID. PDC_PAT_CELL reports 4 */
-#define LBA_STAT_CTL    0x0108  /* Status & Control */
-#define   LBA_BUS_RESET         0x01    /*  Deassert PCI Bus Reset Signal */
-#define   CLEAR_ERRLOG          0x10    /*  "Clear Error Log" cmd */
-#define   CLEAR_ERRLOG_ENABLE   0x20    /*  "Clear Error Log" Enable */
-#define   HF_ENABLE     0x40    /*    enable HF mode (default is -1 mode) */
-#define LBA_LMMIO_BASE  0x0200  /* < 4GB I/O address range */
-#define LBA_LMMIO_MASK  0x0208
-#define LBA_GMMIO_BASE  0x0210  /* > 4GB I/O address range */
-#define LBA_GMMIO_MASK  0x0218
-#define LBA_WLMMIO_BASE 0x0220  /* All < 4GB ranges under the same *SBA* */
-#define LBA_WLMMIO_MASK 0x0228
-#define LBA_WGMMIO_BASE 0x0230  /* All > 4GB ranges under the same *SBA* */
-#define LBA_WGMMIO_MASK 0x0238
-#define LBA_IOS_BASE    0x0240  /* I/O port space for this LBA */
-#define LBA_IOS_MASK    0x0248
-#define LBA_ELMMIO_BASE 0x0250  /* Extra LMMIO range */
-#define LBA_ELMMIO_MASK 0x0258
-#define LBA_EIOS_BASE   0x0260  /* Extra I/O port space */
-#define LBA_EIOS_MASK   0x0268
-#define LBA_GLOBAL_MASK 0x0270  /* Mercury only: Global Address Mask */
-#define LBA_DMA_CTL     0x0278  /* firmware sets this */
-#define LBA_IBASE       0x0300  /* SBA DMA support */
-#define LBA_IMASK       0x0308
-/* FIXME: ignore DMA Hint stuff until we can measure performance */
-#define LBA_HINT_CFG    0x0310
-#define LBA_HINT_BASE   0x0380  /* 14 registers at every 8 bytes. */
-#define LBA_BUS_MODE    0x0620
-/* ERROR regs are needed for config cycle kluges */
-#define LBA_ERROR_CONFIG 0x0680
-#define     LBA_SMART_MODE 0x20
-#define LBA_ERROR_STATUS 0x0688
-#define LBA_ROPE_CTL     0x06A0
-#define LBA_IOSAPIC_BASE        0x800 /* Offset of IRQ logic */
 /* non-postable I/O port space, densely packed */
 #define LBA_PORT_BASE   (PCI_F_EXTEND | 0xfee00000UL)
 static void __iomem *astro_iop_base __read_mostly;
-#define ELROY_HVERS     0x782
-#define MERCURY_HVERS   0x783
-#define QUICKSILVER_HVERS       0x784
-static inline int IS_ELROY(struct parisc_device *d)
-{
-        return (d->id.hversion == ELROY_HVERS);
-}
-static inline int IS_MERCURY(struct parisc_device *d)
-{
-        return (d->id.hversion == MERCURY_HVERS);
-}
-static inline int IS_QUICKSILVER(struct parisc_device *d)
-{
-        return (d->id.hversion == QUICKSILVER_HVERS);
-}
-/*
-** lba_device: Per instance Elroy data structure
-*/
-struct lba_device {
-        struct pci_hba_data hba;
-        spinlock_t      lba_lock;
-        void            *iosapic_obj;
-#ifdef CONFIG_64BIT
-        void __iomem *  iop_base;    /* PA_VIEW - for IO port accessor funcs */
-#endif
-        int             flags;       /* state/functionality enabled */
-        int             hw_rev;      /* HW revision of chip */
-};
 static u32 lba_t32;
 /* lba flags */
@@ -1542,8 +1439,8 @@ lba_driver_probe(struct parisc_device *dev)
                default: version = "TR4+";
                }
-                printk(KERN_INFO "%s version %s (0x%x) found at 0x%lx\n",
+                printk(KERN_INFO "Elroy version %s (0x%x) found at 0x%lx\n",
-                        MODULE_NAME, version, func_class & 0xf, dev->hpa.start);
+                       version, func_class & 0xf, dev->hpa.start);
                if (func_class < 2) {
                        printk(KERN_WARNING "Can't support LBA older than "
@@ -1563,14 +1460,18 @@ lba_driver_probe(struct parisc_device *dev)
                }
        } else if (IS_MERCURY(dev) || IS_QUICKSILVER(dev)) {
+                int major, minor;
                func_class &= 0xff;
-                version = kmalloc(6, GFP_KERNEL);
+                major = func_class >> 4, minor = func_class & 0xf;
-                snprintf(version, 6, "TR%d.%d",(func_class >> 4),(func_class & 0xf));
                /* We could use one printk for both Elroy and Mercury,
                 * but for the mask for func_class.
                 */ 
-                printk(KERN_INFO "%s version %s (0x%x) found at 0x%lx\n",
+                printk(KERN_INFO "%s version TR%d.%d (0x%x) found at 0x%lx\n",
-                       MODULE_NAME, version, func_class & 0xff, dev->hpa.start);
+                       IS_MERCURY(dev) ? "Mercury" : "Quicksilver", major,
+                       minor, func_class, dev->hpa.start);
                cfg_ops = &mercury_cfg_ops;
        } else {
                printk(KERN_ERR "Unknown LBA found at 0x%lx\n", dev->hpa.start);
@@ -1600,6 +1501,7 @@ lba_driver_probe(struct parisc_device *dev)
        lba_dev->hba.dev = dev;
        lba_dev->iosapic_obj = tmp_obj;  /* save interrupt handle */
        lba_dev->hba.iommu = sba_get_iommu(dev);  /* get iommu data */
+        parisc_set_drvdata(dev, lba_dev);
        /* ------------ Second : initialize common stuff ---------- */
        pci_bios = &lba_bios_ops;
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index 8b473281551..294c1117098 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -38,22 +38,15 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
+#include <asm/ropes.h>
+#include <asm/mckinley.h>       /* for proc_mckinley_root */
 #include <asm/runway.h>         /* for proc_runway_root */
 #include <asm/pdc.h>            /* for PDC_MODEL_* */
 #include <asm/pdcpat.h>         /* for is_pdc_pat() */
 #include <asm/parisc-device.h>
-/* declared in arch/parisc/kernel/setup.c */
-extern struct proc_dir_entry * proc_mckinley_root;
 #define MODULE_NAME "SBA"
-#ifdef CONFIG_PROC_FS
-/* depends on proc fs support. But costs CPU performance */
-#undef SBA_COLLECT_STATS
-#endif
 /*
 ** The number of debug flags is a clue - this code is fragile.
 ** Don't even think about messing with it unless you have
@@ -92,202 +85,12 @@ extern struct proc_dir_entry * proc_mckinley_root;
 #define DBG_RES(x...)
 #endif
-#if defined(CONFIG_64BIT)
-/* "low end" PA8800 machines use ZX1 chipset: PAT PDC and only run 64-bit */
-#define ZX1_SUPPORT
-#endif
 #define SBA_INLINE      __inline__
-/*
-** The number of pdir entries to "free" before issueing
-** a read to PCOM register to flush out PCOM writes.
-** Interacts with allocation granularity (ie 4 or 8 entries
-** allocated and free'd/purged at a time might make this
-** less interesting).
-*/
-#define DELAYED_RESOURCE_CNT    16
 #define DEFAULT_DMA_HINT_REG    0
-#define ASTRO_RUNWAY_PORT       0x582
+struct sba_device *sba_list;
-#define IKE_MERCED_PORT         0x803
+EXPORT_SYMBOL_GPL(sba_list);
-#define REO_MERCED_PORT         0x804
-#define REOG_MERCED_PORT        0x805
-#define PLUTO_MCKINLEY_PORT     0x880
-#define SBA_FUNC_ID     0x0000  /* function id */
-#define SBA_FCLASS      0x0008  /* function class, bist, header, rev... */
-#define IS_ASTRO(id)            ((id)->hversion == ASTRO_RUNWAY_PORT)
-#define IS_IKE(id)              ((id)->hversion == IKE_MERCED_PORT)
-#define IS_PLUTO(id)            ((id)->hversion == PLUTO_MCKINLEY_PORT)
-#define SBA_FUNC_SIZE 4096   /* SBA configuration function reg set */
-#define ASTRO_IOC_OFFSET        (32 * SBA_FUNC_SIZE)
-#define PLUTO_IOC_OFFSET        (1 * SBA_FUNC_SIZE)
-/* Ike's IOC's occupy functions 2 and 3 */
-#define IKE_IOC_OFFSET(p)       ((p+2) * SBA_FUNC_SIZE)
-#define IOC_CTRL          0x8   /* IOC_CTRL offset */
-#define IOC_CTRL_TC       (1 << 0) /* TOC Enable */
-#define IOC_CTRL_CE       (1 << 1) /* Coalesce Enable */
-#define IOC_CTRL_DE       (1 << 2) /* Dillon Enable */
-#define IOC_CTRL_RM       (1 << 8) /* Real Mode */
-#define IOC_CTRL_NC       (1 << 9) /* Non Coherent Mode */
-#define IOC_CTRL_D4       (1 << 11) /* Disable 4-byte coalescing */
-#define IOC_CTRL_DD       (1 << 13) /* Disable distr. LMMIO range coalescing */
-#define MAX_IOC         2       /* per Ike. Pluto/Astro only have 1. */
-#define ROPES_PER_IOC   8       /* per Ike half or Pluto/Astro */
-/*
-** Offsets into MBIB (Function 0 on Ike and hopefully Astro)
-** Firmware programs this stuff. Don't touch it.
-*/
-#define LMMIO_DIRECT0_BASE  0x300
-#define LMMIO_DIRECT0_MASK  0x308
-#define LMMIO_DIRECT0_ROUTE 0x310
-#define LMMIO_DIST_BASE  0x360
-#define LMMIO_DIST_MASK  0x368
-#define LMMIO_DIST_ROUTE 0x370
-#define IOS_DIST_BASE   0x390
-#define IOS_DIST_MASK   0x398
-#define IOS_DIST_ROUTE  0x3A0
-#define IOS_DIRECT_BASE 0x3C0
-#define IOS_DIRECT_MASK 0x3C8
-#define IOS_DIRECT_ROUTE 0x3D0
-/*
-** Offsets into I/O TLB (Function 2 and 3 on Ike)
-*/
-#define ROPE0_CTL       0x200  /* "regbus pci0" */
-#define ROPE1_CTL       0x208
-#define ROPE2_CTL       0x210
-#define ROPE3_CTL       0x218
-#define ROPE4_CTL       0x220
-#define ROPE5_CTL       0x228
-#define ROPE6_CTL       0x230
-#define ROPE7_CTL       0x238
-#define IOC_ROPE0_CFG   0x500   /* pluto only */
-#define   IOC_ROPE_AO     0x10  /* Allow "Relaxed Ordering" */
-#define HF_ENABLE       0x40
-#define IOC_IBASE       0x300   /* IO TLB */
-#define IOC_IMASK       0x308
-#define IOC_PCOM        0x310
-#define IOC_TCNFG       0x318
-#define IOC_PDIR_BASE   0x320
-/* AGP GART driver looks for this */
-#define SBA_IOMMU_COOKIE    0x0000badbadc0ffeeUL
-/*
-** IOC supports 4/8/16/64KB page sizes (see TCNFG register)
-** It's safer (avoid memory corruption) to keep DMA page mappings
-** equivalently sized to VM PAGE_SIZE.
-**
-** We really can't avoid generating a new mapping for each
-** page since the Virtual Coherence Index has to be generated
-** and updated for each page.
-**
-** PAGE_SIZE could be greater than IOVP_SIZE. But not the inverse.
-*/
-#define IOVP_SIZE       PAGE_SIZE
-#define IOVP_SHIFT      PAGE_SHIFT
-#define IOVP_MASK       PAGE_MASK
-#define SBA_PERF_CFG    0x708   /* Performance Counter stuff */
-#define SBA_PERF_MASK1  0x718
-#define SBA_PERF_MASK2  0x730
-/*
-** Offsets into PCI Performance Counters (functions 12 and 13)
-** Controlled by PERF registers in function 2 & 3 respectively.
-*/
-#define SBA_PERF_CNT1   0x200
-#define SBA_PERF_CNT2   0x208
-#define SBA_PERF_CNT3   0x210
-struct ioc {
-        void __iomem    *ioc_hpa;       /* I/O MMU base address */
-        char            *res_map;       /* resource map, bit == pdir entry */
-        u64             *pdir_base;     /* physical base address */
-        unsigned long   ibase;  /* pdir IOV Space base - shared w/lba_pci */
-        unsigned long   imask;  /* pdir IOV Space mask - shared w/lba_pci */
-#ifdef ZX1_SUPPORT
-        unsigned long   iovp_mask;      /* help convert IOVA to IOVP */
-#endif
-        unsigned long   *res_hint;      /* next avail IOVP - circular search */
-        spinlock_t      res_lock;
-        unsigned int    res_bitshift;   /* from the LEFT! */
-        unsigned int    res_size;       /* size of resource map in bytes */
-#ifdef SBA_HINT_SUPPORT
-/* FIXME : DMA HINTs not used */
-        unsigned long   hint_mask_pdir; /* bits used for DMA hints */
-        unsigned int    hint_shift_pdir;
-#endif
-#if DELAYED_RESOURCE_CNT > 0
-        int saved_cnt;
-        struct sba_dma_pair {
-                dma_addr_t      iova;
-                size_t          size;
-        } saved[DELAYED_RESOURCE_CNT];
-#endif
-#ifdef SBA_COLLECT_STATS
-#define SBA_SEARCH_SAMPLE       0x100
-        unsigned long avg_search[SBA_SEARCH_SAMPLE];
-        unsigned long avg_idx;  /* current index into avg_search */
-        unsigned long used_pages;
-        unsigned long msingle_calls;
-        unsigned long msingle_pages;
-        unsigned long msg_calls;
-        unsigned long msg_pages;
-        unsigned long usingle_calls;
-        unsigned long usingle_pages;
-        unsigned long usg_calls;
-        unsigned long usg_pages;
-#endif
-        /* STUFF We don't need in performance path */
-        unsigned int    pdir_size;      /* in bytes, determined by IOV Space size */
-};
-struct sba_device {
-        struct sba_device       *next;  /* list of SBA's in system */
-        struct parisc_device    *dev;   /* dev found in bus walk */
-        struct parisc_device_id *iodc;  /* data about dev from firmware */
-        const char              *name;
-        void __iomem            *sba_hpa; /* base address */
-        spinlock_t              sba_lock;
-        unsigned int            flags;  /* state/functionality enabled */
-        unsigned int            hw_rev;  /* HW revision of chip */
-        struct resource         chip_resv; /* MMIO reserved for chip */
-        struct resource         iommu_resv; /* MMIO reserved for iommu */
-        unsigned int            num_ioc;  /* number of on-board IOC's */
-        struct ioc              ioc[MAX_IOC];
-};
-static struct sba_device *sba_list;
 static unsigned long ioc_needs_fdc = 0;
@@ -300,8 +103,14 @@ static unsigned long piranha_bad_128k = 0;
 /* Looks nice and keeps the compiler happy */
 #define SBA_DEV(d) ((struct sba_device *) (d))
+#ifdef CONFIG_AGP_PARISC
+#define SBA_AGP_SUPPORT
+#endif /*CONFIG_AGP_PARISC*/
 #ifdef SBA_AGP_SUPPORT
-static int reserve_sba_gart = 1;
+static int sba_reserve_agpgart = 1;
+module_param(sba_reserve_agpgart, int, 1);
+MODULE_PARM_DESC(sba_reserve_agpgart, "Reserve half of IO pdir as AGPGART");
 #endif
 #define ROUNDUP(x,y) ((x + ((y)-1)) & ~((y)-1))
@@ -741,7 +550,7 @@ sba_io_pdir_entry(u64 *pdir_ptr, space_t sid, unsigned long vba,
        asm("lci 0(%%sr1, %1), %0" : "=r" (ci) : "r" (vba));
        pa |= (ci >> 12) & 0xff;  /* move CI (8 bits) into lowest byte */
-        pa |= 0x8000000000000000ULL;    /* set "valid" bit */
+        pa |= SBA_PDIR_VALID_BIT;       /* set "valid" bit */
        *pdir_ptr = cpu_to_le64(pa);    /* swap and store into I/O Pdir */
        /*
@@ -1498,6 +1307,10 @@ sba_ioc_init_pluto(struct parisc_device *sba, struct ioc *ioc, int ioc_num)
        WRITE_REG(ioc->ibase | 31, ioc->ioc_hpa + IOC_PCOM);
 #ifdef SBA_AGP_SUPPORT
+{
+        struct klist_iter i;
+        struct device *dev = NULL;
        /*
        ** If an AGP device is present, only use half of the IOV space
        ** for PCI DMA.  Unfortunately we can't know ahead of time
@@ -1506,20 +1319,22 @@ sba_ioc_init_pluto(struct parisc_device *sba, struct ioc *ioc, int ioc_num)
        ** We program the next pdir index after we stop w/ a key for
        ** the GART code to handshake on.
        */
-        device=NULL;
+        klist_iter_init(&sba->dev.klist_children, &i);
-        for (lba = sba->child; lba; lba = lba->sibling) {
+        while (dev = next_device(&i)) {
+                struct parisc_device *lba = to_parisc_device(dev);
                if (IS_QUICKSILVER(lba))
-                        break;
+                        agp_found = 1;
        }
+        klist_iter_exit(&sba->dev.klist_children, &i);
-        if (lba) {
+        if (agp_found && sba_reserve_agpgart) {
-                DBG_INIT("%s: Reserving half of IOVA space for AGP GART support\n", __FUNCTION__);
+                printk(KERN_INFO "%s: reserving %dMb of IOVA space for agpgart\n",
+                       __FUNCTION__, (iova_space_size/2) >> 20);
                ioc->pdir_size /= 2;
-                ((u64 *)ioc->pdir_base)[PDIR_INDEX(iova_space_size/2)] = SBA_IOMMU_COOKIE;
+                ioc->pdir_base[PDIR_INDEX(iova_space_size/2)] = SBA_AGPGART_COOKIE;
-        } else {
-                DBG_INIT("%s: No GART needed - no AGP controller found\n", __FUNCTION__);
        }
-#endif /* 0 */
+}
+#endif /*SBA_AGP_SUPPORT*/
 }
@@ -1701,7 +1516,7 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
        }
 #endif
-        if (!IS_PLUTO(sba_dev->iodc)) {
+        if (!IS_PLUTO(sba_dev->dev)) {
                ioc_ctl = READ_REG(sba_dev->sba_hpa+IOC_CTRL);
                DBG_INIT("%s() hpa 0x%lx ioc_ctl 0x%Lx ->",
                        __FUNCTION__, sba_dev->sba_hpa, ioc_ctl);
@@ -1718,9 +1533,8 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
 #endif
        } /* if !PLUTO */
-        if (IS_ASTRO(sba_dev->iodc)) {
+        if (IS_ASTRO(sba_dev->dev)) {
                int err;
-                /* PAT_PDC (L-class) also reports the same goofy base */
                sba_dev->ioc[0].ioc_hpa = ioc_remap(sba_dev, ASTRO_IOC_OFFSET);
                num_ioc = 1;
@@ -1730,13 +1544,9 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
                err = request_resource(&iomem_resource, &(sba_dev->chip_resv));
                BUG_ON(err < 0);
-        } else if (IS_PLUTO(sba_dev->iodc)) {
+        } else if (IS_PLUTO(sba_dev->dev)) {
                int err;
-                /* We use a negative value for IOC HPA so it gets 
-                 * corrected when we add it with IKE's IOC offset.
-                 * Doesnt look clean, but fewer code. 
-                 */
                sba_dev->ioc[0].ioc_hpa = ioc_remap(sba_dev, PLUTO_IOC_OFFSET);
                num_ioc = 1;
@@ -1752,14 +1562,14 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
                err = request_resource(&iomem_resource, &(sba_dev->iommu_resv));
                WARN_ON(err < 0);
        } else {
-                /* IS_IKE (ie N-class, L3000, L1500) */
+                /* IKE, REO */
                sba_dev->ioc[0].ioc_hpa = ioc_remap(sba_dev, IKE_IOC_OFFSET(0));
                sba_dev->ioc[1].ioc_hpa = ioc_remap(sba_dev, IKE_IOC_OFFSET(1));
                num_ioc = 2;
                /* TODO - LOOKUP Ike/Stretch chipset mem map */
        }
-        /* XXX: What about Reo? */
+        /* XXX: What about Reo Grande? */
        sba_dev->num_ioc = num_ioc;
        for (i = 0; i < num_ioc; i++) {
@@ -1774,7 +1584,7 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
                         * Overrides bit 1 in DMA Hint Sets.
                         * Improves netperf UDP_STREAM by ~10% for bcm5701.
                         */
-                        if (IS_PLUTO(sba_dev->iodc)) {
+                        if (IS_PLUTO(sba_dev->dev)) {
                                void __iomem *rope_cfg;
                                unsigned long cfg_val;
@@ -1803,7 +1613,7 @@ printk("sba_hw_init(): mem_boot 0x%x 0x%x 0x%x 0x%x\n", PAGE0->mem_boot.hpa,
                                READ_REG(sba_dev->ioc[i].ioc_hpa + 0x400)
                        );
-                if (IS_PLUTO(sba_dev->iodc)) {
+                if (IS_PLUTO(sba_dev->dev)) {
                        sba_ioc_init_pluto(sba_dev->dev, &(sba_dev->ioc[i]), i);
                } else {
                        sba_ioc_init(sba_dev->dev, &(sba_dev->ioc[i]), i);
@@ -2067,7 +1877,7 @@ sba_driver_callback(struct parisc_device *dev)
        /* Read HW Rev First */
        func_class = READ_REG(sba_addr + SBA_FCLASS);
-        if (IS_ASTRO(&dev->id)) {
+        if (IS_ASTRO(dev)) {
                unsigned long fclass;
                static char astro_rev[]="Astro ?.?";
@@ -2078,11 +1888,11 @@ sba_driver_callback(struct parisc_device *dev)
                astro_rev[8] = '0' + (char) ((fclass & 0x18) >> 3);
                version = astro_rev;
-        } else if (IS_IKE(&dev->id)) {
+        } else if (IS_IKE(dev)) {
                static char ike_rev[] = "Ike rev ?";
                ike_rev[8] = '0' + (char) (func_class & 0xff);
                version = ike_rev;
-        } else if (IS_PLUTO(&dev->id)) {
+        } else if (IS_PLUTO(dev)) {
                static char pluto_rev[]="Pluto ?.?";
                pluto_rev[6] = '0' + (char) ((func_class & 0xf0) >> 4); 
                pluto_rev[8] = '0' + (char) (func_class & 0x0f); 
@@ -2097,7 +1907,7 @@ sba_driver_callback(struct parisc_device *dev)
                global_ioc_cnt = count_parisc_driver(&sba_driver);
                /* Astro and Pluto have one IOC per SBA */
-                if ((!IS_ASTRO(&dev->id)) || (!IS_PLUTO(&dev->id)))
+                if ((!IS_ASTRO(dev)) || (!IS_PLUTO(dev)))
                        global_ioc_cnt *= 2;
        }
@@ -2117,7 +1927,6 @@ sba_driver_callback(struct parisc_device *dev)
        sba_dev->dev = dev;
        sba_dev->hw_rev = func_class;
-        sba_dev->iodc = &dev->id;
        sba_dev->name = dev->name;
        sba_dev->sba_hpa = sba_addr;
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index c27e782e6df..30294127a0a 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -52,3 +52,11 @@ config PCI_DEBUG
          When in doubt, say N.
+config HT_IRQ
+        bool "Interrupts on hypertransport devices"
+        default y
+        depends on X86_LOCAL_APIC && X86_IO_APIC
+        help
+           This allows native hypertransport devices to use interrupts.
+           If unsure say Y.
diff --git a/drivers/pci/Makefile b/drivers/pci/Makefile
index f2d152b818f..e3beb784406 100644
--- a/drivers/pci/Makefile
+++ b/drivers/pci/Makefile
@@ -14,6 +14,12 @@ obj-$(CONFIG_HOTPLUG) += hotplug.o
 # Build the PCI Hotplug drivers if we were asked to
 obj-$(CONFIG_HOTPLUG_PCI) += hotplug/
+# Build the PCI MSI interrupt support
+obj-$(CONFIG_PCI_MSI) += msi.o
+# Build the Hypertransport interrupt support
+obj-$(CONFIG_HT_IRQ) += htirq.o
 #
 # Some architectures use the generic PCI setup functions
 #
@@ -27,11 +33,6 @@ obj-$(CONFIG_PPC64) += setup-bus.o
 obj-$(CONFIG_MIPS) += setup-bus.o setup-irq.o
 obj-$(CONFIG_X86_VISWS) += setup-irq.o
-msiobj-y := msi.o msi-apic.o
-msiobj-$(CONFIG_IA64_GENERIC) += msi-altix.o
-msiobj-$(CONFIG_IA64_SGI_SN2) += msi-altix.o
-obj-$(CONFIG_PCI_MSI) += $(msiobj-y)
 #
 # ACPI Related PCI FW Functions
 #
diff --git a/drivers/pci/htirq.c b/drivers/pci/htirq.c
new file mode 100644
index 00000000000..0e27f2404a8
--- /dev/null
+++ b/drivers/pci/htirq.c
@@ -0,0 +1,190 @@
+/*
+ * File:        htirq.c
+ * Purpose:     Hypertransport Interrupt Capability
+ *
+ * Copyright (C) 2006 Linux Networx
+ * Copyright (C) Eric Biederman <ebiederman@lnxi.com>
+ */
+#include <linux/irq.h>
+#include <linux/pci.h>
+#include <linux/spinlock.h>
+#include <linux/slab.h>
+#include <linux/gfp.h>
+#include <linux/htirq.h>
+/* Global ht irq lock.
+ *
+ * This is needed to serialize access to the data port in hypertransport
+ * irq capability.
+ *
+ * With multiple simultaneous hypertransport irq devices it might pay
+ * to make this more fine grained.  But start with simple, stupid, and correct.
+ */
+static DEFINE_SPINLOCK(ht_irq_lock);
+struct ht_irq_cfg {
+        struct pci_dev *dev;
+        unsigned pos;
+        unsigned idx;
+};
+void write_ht_irq_low(unsigned int irq, u32 data)
+{
+        struct ht_irq_cfg *cfg = get_irq_data(irq);
+        unsigned long flags;
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx);
+        pci_write_config_dword(cfg->dev, cfg->pos + 4, data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+}
+void write_ht_irq_high(unsigned int irq, u32 data)
+{
+        struct ht_irq_cfg *cfg = get_irq_data(irq);
+        unsigned long flags;
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx + 1);
+        pci_write_config_dword(cfg->dev, cfg->pos + 4, data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+}
+u32 read_ht_irq_low(unsigned int irq)
+{
+        struct ht_irq_cfg *cfg = get_irq_data(irq);
+        unsigned long flags;
+        u32 data;
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx);
+        pci_read_config_dword(cfg->dev, cfg->pos + 4, &data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+        return data;
+}
+u32 read_ht_irq_high(unsigned int irq)
+{
+        struct ht_irq_cfg *cfg = get_irq_data(irq);
+        unsigned long flags;
+        u32 data;
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx + 1);
+        pci_read_config_dword(cfg->dev, cfg->pos + 4, &data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+        return data;
+}
+void mask_ht_irq(unsigned int irq)
+{
+        struct ht_irq_cfg *cfg;
+        unsigned long flags;
+        u32 data;
+        cfg = get_irq_data(irq);
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx);
+        pci_read_config_dword(cfg->dev, cfg->pos + 4, &data);
+        data |= 1;
+        pci_write_config_dword(cfg->dev, cfg->pos + 4, data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+}
+void unmask_ht_irq(unsigned int irq)
+{
+        struct ht_irq_cfg *cfg;
+        unsigned long flags;
+        u32 data;
+        cfg = get_irq_data(irq);
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(cfg->dev, cfg->pos + 2, cfg->idx);
+        pci_read_config_dword(cfg->dev, cfg->pos + 4, &data);
+        data &= ~1;
+        pci_write_config_dword(cfg->dev, cfg->pos + 4, data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+}
+/**
+ * ht_create_irq - create an irq and attach it to a device.
+ * @dev: The hypertransport device to find the irq capability on.
+ * @idx: Which of the possible irqs to attach to.
+ *
+ * ht_create_irq is needs to be called for all hypertransport devices
+ * that generate irqs.
+ *
+ * The irq number of the new irq or a negative error value is returned.
+ */
+int ht_create_irq(struct pci_dev *dev, int idx)
+{
+        struct ht_irq_cfg *cfg;
+        unsigned long flags;
+        u32 data;
+        int max_irq;
+        int pos;
+        int irq;
+        pos = pci_find_capability(dev, PCI_CAP_ID_HT);
+        while (pos) {
+                u8 subtype;
+                pci_read_config_byte(dev, pos + 3, &subtype);
+                if (subtype == HT_CAPTYPE_IRQ)
+                        break;
+                pos = pci_find_next_capability(dev, pos, PCI_CAP_ID_HT);
+        }
+        if (!pos)
+                return -EINVAL;
+        /* Verify the idx I want to use is in range */
+        spin_lock_irqsave(&ht_irq_lock, flags);
+        pci_write_config_byte(dev, pos + 2, 1);
+        pci_read_config_dword(dev, pos + 4, &data);
+        spin_unlock_irqrestore(&ht_irq_lock, flags);
+        max_irq = (data >> 16) & 0xff;
+        if ( idx > max_irq)
+                return -EINVAL;
+        cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
+        if (!cfg)
+                return -ENOMEM;
+        cfg->dev = dev;
+        cfg->pos = pos;
+        cfg->idx = 0x10 + (idx * 2);
+        irq = create_irq();
+        if (irq < 0) {
+                kfree(cfg);
+                return -EBUSY;
+        }
+        set_irq_data(irq, cfg);
+        if (arch_setup_ht_irq(irq, dev) < 0) {
+                ht_destroy_irq(irq);
+                return -EBUSY;
+        }
+        return irq;
+}
+/**
+ * ht_destroy_irq - destroy an irq created with ht_create_irq
+ *
+ * This reverses ht_create_irq removing the specified irq from
+ * existence.  The irq should be free before this happens.
+ */
+void ht_destroy_irq(unsigned int irq)
+{
+        struct ht_irq_cfg *cfg;
+        cfg = get_irq_data(irq);
+        set_irq_chip(irq, NULL);
+        set_irq_data(irq, NULL);
+        destroy_irq(irq);
+        kfree(cfg);
+}
+EXPORT_SYMBOL(ht_create_irq);
+EXPORT_SYMBOL(ht_destroy_irq);
diff --git a/drivers/pci/msi-altix.c b/drivers/pci/msi-altix.c
deleted file mode 100644
index bed4183a5e3..00000000000
--- a/drivers/pci/msi-altix.c
+++ /dev/null
@@ -1,210 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- * Copyright (C) 2006 Silicon Graphics, Inc.  All Rights Reserved.
- */
-#include <linux/types.h>
-#include <linux/pci.h>
-#include <linux/cpumask.h>
-#include <asm/sn/addrs.h>
-#include <asm/sn/intr.h>
-#include <asm/sn/pcibus_provider_defs.h>
-#include <asm/sn/pcidev.h>
-#include <asm/sn/nodepda.h>
-#include "msi.h"
-struct sn_msi_info {
-        u64 pci_addr;
-        struct sn_irq_info *sn_irq_info;
-};
-static struct sn_msi_info *sn_msi_info;
-static void
-sn_msi_teardown(unsigned int vector)
-{
-        nasid_t nasid;
-        int widget;
-        struct pci_dev *pdev;
-        struct pcidev_info *sn_pdev;
-        struct sn_irq_info *sn_irq_info;
-        struct pcibus_bussoft *bussoft;
-        struct sn_pcibus_provider *provider;
-        sn_irq_info = sn_msi_info[vector].sn_irq_info;
-        if (sn_irq_info == NULL || sn_irq_info->irq_int_bit >= 0)
-                return;
-        sn_pdev = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
-        pdev = sn_pdev->pdi_linux_pcidev;
-        provider = SN_PCIDEV_BUSPROVIDER(pdev);
-        (*provider->dma_unmap)(pdev,
-                               sn_msi_info[vector].pci_addr,
-                               PCI_DMA_FROMDEVICE);
-        sn_msi_info[vector].pci_addr = 0;
-        bussoft = SN_PCIDEV_BUSSOFT(pdev);
-        nasid = NASID_GET(bussoft->bs_base);
-        widget = (nasid & 1) ?
-                        TIO_SWIN_WIDGETNUM(bussoft->bs_base) :
-                        SWIN_WIDGETNUM(bussoft->bs_base);
-        sn_intr_free(nasid, widget, sn_irq_info);
-        sn_msi_info[vector].sn_irq_info = NULL;
-        return;
-}
-int
-sn_msi_setup(struct pci_dev *pdev, unsigned int vector,
-             u32 *addr_hi, u32 *addr_lo, u32 *data)
-{
-        int widget;
-        int status;
-        nasid_t nasid;
-        u64 bus_addr;
-        struct sn_irq_info *sn_irq_info;
-        struct pcibus_bussoft *bussoft = SN_PCIDEV_BUSSOFT(pdev);
-        struct sn_pcibus_provider *provider = SN_PCIDEV_BUSPROVIDER(pdev);
-        if (bussoft == NULL)
-                return -EINVAL;
-        if (provider == NULL || provider->dma_map_consistent == NULL)
-                return -EINVAL;
-        /*
-         * Set up the vector plumbing.  Let the prom (via sn_intr_alloc)
-         * decide which cpu to direct this msi at by default.
-         */
-        nasid = NASID_GET(bussoft->bs_base);
-        widget = (nasid & 1) ?
-                        TIO_SWIN_WIDGETNUM(bussoft->bs_base) :
-                        SWIN_WIDGETNUM(bussoft->bs_base);
-        sn_irq_info = kzalloc(sizeof(struct sn_irq_info), GFP_KERNEL);
-        if (! sn_irq_info)
-                return -ENOMEM;
-        status = sn_intr_alloc(nasid, widget, sn_irq_info, vector, -1, -1);
-        if (status) {
-                kfree(sn_irq_info);
-                return -ENOMEM;
-        }
-        sn_irq_info->irq_int_bit = -1;          /* mark this as an MSI irq */
-        sn_irq_fixup(pdev, sn_irq_info);
-        /* Prom probably should fill these in, but doesn't ... */
-        sn_irq_info->irq_bridge_type = bussoft->bs_asic_type;
-        sn_irq_info->irq_bridge = (void *)bussoft->bs_base;
-        /*
-         * Map the xio address into bus space
-         */
-        bus_addr = (*provider->dma_map_consistent)(pdev,
-                                        sn_irq_info->irq_xtalkaddr,
-                                        sizeof(sn_irq_info->irq_xtalkaddr),
-                                        SN_DMA_MSI|SN_DMA_ADDR_XIO);
-        if (! bus_addr) {
-                sn_intr_free(nasid, widget, sn_irq_info);
-                kfree(sn_irq_info);
-                return -ENOMEM;
-        }
-        sn_msi_info[vector].sn_irq_info = sn_irq_info;
-        sn_msi_info[vector].pci_addr = bus_addr;
-        *addr_hi = (u32)(bus_addr >> 32);
-        *addr_lo = (u32)(bus_addr & 0x00000000ffffffff);
-        /*
-         * In the SN platform, bit 16 is a "send vector" bit which
-         * must be present in order to move the vector through the system.
-         */
-        *data = 0x100 + (unsigned int)vector;
-#ifdef CONFIG_SMP
-        set_irq_affinity_info((vector & 0xff), sn_irq_info->irq_cpuid, 0);
-#endif
-        return 0;
-}
-static void
-sn_msi_target(unsigned int vector, unsigned int cpu,
-              u32 *addr_hi, u32 *addr_lo)
-{
-        int slice;
-        nasid_t nasid;
-        u64 bus_addr;
-        struct pci_dev *pdev;
-        struct pcidev_info *sn_pdev;
-        struct sn_irq_info *sn_irq_info;
-        struct sn_irq_info *new_irq_info;
-        struct sn_pcibus_provider *provider;
-        sn_irq_info = sn_msi_info[vector].sn_irq_info;
-        if (sn_irq_info == NULL || sn_irq_info->irq_int_bit >= 0)
-                return;
-        /*
-         * Release XIO resources for the old MSI PCI address
-         */
-        sn_pdev = (struct pcidev_info *)sn_irq_info->irq_pciioinfo;
-        pdev = sn_pdev->pdi_linux_pcidev;
-        provider = SN_PCIDEV_BUSPROVIDER(pdev);
-        bus_addr = (u64)(*addr_hi) << 32 | (u64)(*addr_lo);
-        (*provider->dma_unmap)(pdev, bus_addr, PCI_DMA_FROMDEVICE);
-        sn_msi_info[vector].pci_addr = 0;
-        nasid = cpuid_to_nasid(cpu);
-        slice = cpuid_to_slice(cpu);
-        new_irq_info = sn_retarget_vector(sn_irq_info, nasid, slice);
-        sn_msi_info[vector].sn_irq_info = new_irq_info;
-        if (new_irq_info == NULL)
-                return;
-        /*
-         * Map the xio address into bus space
-         */
-        bus_addr = (*provider->dma_map_consistent)(pdev,
-                                        new_irq_info->irq_xtalkaddr,
-                                        sizeof(new_irq_info->irq_xtalkaddr),
-                                        SN_DMA_MSI|SN_DMA_ADDR_XIO);
-        sn_msi_info[vector].pci_addr = bus_addr;
-        *addr_hi = (u32)(bus_addr >> 32);
-        *addr_lo = (u32)(bus_addr & 0x00000000ffffffff);
-}
-struct msi_ops sn_msi_ops = {
-        .setup = sn_msi_setup,
-        .teardown = sn_msi_teardown,
-#ifdef CONFIG_SMP
-        .target = sn_msi_target,
-#endif
-};
-int
-sn_msi_init(void)
-{
-        sn_msi_info =
-                kzalloc(sizeof(struct sn_msi_info) * NR_VECTORS, GFP_KERNEL);
-        if (! sn_msi_info)
-                return -ENOMEM;
-        msi_register(&sn_msi_ops);
-        return 0;
-}
diff --git a/drivers/pci/msi-apic.c b/drivers/pci/msi-apic.c
deleted file mode 100644
index 5ed798b319c..00000000000
--- a/drivers/pci/msi-apic.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * MSI hooks for standard x86 apic
- */
-#include <linux/pci.h>
-#include <linux/irq.h>
-#include <asm/smp.h>
-#include "msi.h"
-/*
- * Shifts for APIC-based data
- */
-#define MSI_DATA_VECTOR_SHIFT           0
-#define     MSI_DATA_VECTOR(v)          (((u8)v) << MSI_DATA_VECTOR_SHIFT)
-#define MSI_DATA_DELIVERY_SHIFT         8
-#define     MSI_DATA_DELIVERY_FIXED     (0 << MSI_DATA_DELIVERY_SHIFT)
-#define     MSI_DATA_DELIVERY_LOWPRI    (1 << MSI_DATA_DELIVERY_SHIFT)
-#define MSI_DATA_LEVEL_SHIFT            14
-#define     MSI_DATA_LEVEL_DEASSERT     (0 << MSI_DATA_LEVEL_SHIFT)
-#define     MSI_DATA_LEVEL_ASSERT       (1 << MSI_DATA_LEVEL_SHIFT)
-#define MSI_DATA_TRIGGER_SHIFT          15
-#define     MSI_DATA_TRIGGER_EDGE       (0 << MSI_DATA_TRIGGER_SHIFT)
-#define     MSI_DATA_TRIGGER_LEVEL      (1 << MSI_DATA_TRIGGER_SHIFT)
-/*
- * Shift/mask fields for APIC-based bus address
- */
-#define MSI_ADDR_HEADER                 0xfee00000
-#define MSI_ADDR_DESTID_MASK            0xfff0000f
-#define     MSI_ADDR_DESTID_CPU(cpu)    ((cpu) << MSI_TARGET_CPU_SHIFT)
-#define MSI_ADDR_DESTMODE_SHIFT         2
-#define     MSI_ADDR_DESTMODE_PHYS      (0 << MSI_ADDR_DESTMODE_SHIFT)
-#define     MSI_ADDR_DESTMODE_LOGIC     (1 << MSI_ADDR_DESTMODE_SHIFT)
-#define MSI_ADDR_REDIRECTION_SHIFT      3
-#define     MSI_ADDR_REDIRECTION_CPU    (0 << MSI_ADDR_REDIRECTION_SHIFT)
-#define     MSI_ADDR_REDIRECTION_LOWPRI (1 << MSI_ADDR_REDIRECTION_SHIFT)
-static void
-msi_target_apic(unsigned int vector,
-                unsigned int dest_cpu,
-                u32 *address_hi,        /* in/out */
-                u32 *address_lo)        /* in/out */
-{
-        u32 addr = *address_lo;
-        addr &= MSI_ADDR_DESTID_MASK;
-        addr |= MSI_ADDR_DESTID_CPU(cpu_physical_id(dest_cpu));
-        *address_lo = addr;
-}
-static int
-msi_setup_apic(struct pci_dev *pdev,    /* unused in generic */
-                unsigned int vector,
-                u32 *address_hi,
-                u32 *address_lo,
-                u32 *data)
-{
-        unsigned long   dest_phys_id;
-        dest_phys_id = cpu_physical_id(first_cpu(cpu_online_map));
-        *address_hi = 0;
-        *address_lo =   MSI_ADDR_HEADER |
-                        MSI_ADDR_DESTMODE_PHYS |
-                        MSI_ADDR_REDIRECTION_CPU |
-                        MSI_ADDR_DESTID_CPU(dest_phys_id);
-        *data = MSI_DATA_TRIGGER_EDGE |
-                MSI_DATA_LEVEL_ASSERT |
-                MSI_DATA_DELIVERY_FIXED |
-                MSI_DATA_VECTOR(vector);
-        return 0;
-}
-static void
-msi_teardown_apic(unsigned int vector)
-{
-        return;         /* no-op */
-}
-/*
- * Generic ops used on most IA archs/platforms.  Set with msi_register()
- */
-struct msi_ops msi_apic_ops = {
-        .setup = msi_setup_apic,
-        .teardown = msi_teardown_apic,
-        .target = msi_target_apic,
-};
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 27a057409ec..f9fdc54473c 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -6,6 +6,7 @@
 * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
 */
+#include <linux/err.h>
 #include <linux/mm.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
@@ -14,6 +15,7 @@
 #include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/proc_fs.h>
+#include <linux/msi.h>
 #include <asm/errno.h>
 #include <asm/io.h>
@@ -27,23 +29,6 @@ static struct msi_desc* msi_desc[NR_IRQS] = { [0 ... NR_IRQS-1] = NULL };
 static kmem_cache_t* msi_cachep;
 static int pci_msi_enable = 1;
-static int last_alloc_vector;
-static int nr_released_vectors;
-static int nr_reserved_vectors = NR_HP_RESERVED_VECTORS;
-static int nr_msix_devices;
-#ifndef CONFIG_X86_IO_APIC
-int vector_irq[NR_VECTORS] = { [0 ... NR_VECTORS - 1] = -1};
-#endif
-static struct msi_ops *msi_ops;
-int
-msi_register(struct msi_ops *ops)
-{
-        msi_ops = ops;
-        return 0;
-}
 static int msi_cache_init(void)
 {
@@ -55,26 +40,25 @@ static int msi_cache_init(void)
        return 0;
 }
-static void msi_set_mask_bit(unsigned int vector, int flag)
+static void msi_set_mask_bit(unsigned int irq, int flag)
 {
        struct msi_desc *entry;
-        entry = (struct msi_desc *)msi_desc[vector];
+        entry = msi_desc[irq];
-        if (!entry || !entry->dev || !entry->mask_base)
+        BUG_ON(!entry || !entry->dev);
-                return;
        switch (entry->msi_attrib.type) {
        case PCI_CAP_ID_MSI:
-        {
+                if (entry->msi_attrib.maskbit) {
-                int             pos;
+                        int             pos;
-                u32             mask_bits;
+                        u32             mask_bits;
-                pos = (long)entry->mask_base;
+                        pos = (long)entry->mask_base;
-                pci_read_config_dword(entry->dev, pos, &mask_bits);
+                        pci_read_config_dword(entry->dev, pos, &mask_bits);
-                mask_bits &= ~(1);
+                        mask_bits &= ~(1);
-                mask_bits |= flag;
+                        mask_bits |= flag;
-                pci_write_config_dword(entry->dev, pos, mask_bits);
+                        pci_write_config_dword(entry->dev, pos, mask_bits);
+                }
                break;
-        }
        case PCI_CAP_ID_MSIX:
        {
                int offset = entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
@@ -83,261 +67,101 @@ static void msi_set_mask_bit(unsigned int vector, int flag)
                break;
        }
        default:
+                BUG();
                break;
        }
 }
-#ifdef CONFIG_SMP
+void read_msi_msg(unsigned int irq, struct msi_msg *msg)
-static void set_msi_affinity(unsigned int vector, cpumask_t cpu_mask)
 {
-        struct msi_desc *entry;
+        struct msi_desc *entry = get_irq_data(irq);
-        u32 address_hi, address_lo;
+        switch(entry->msi_attrib.type) {
-        unsigned int irq = vector;
-        unsigned int dest_cpu = first_cpu(cpu_mask);
-        entry = (struct msi_desc *)msi_desc[vector];
-        if (!entry || !entry->dev)
-                return;
-        switch (entry->msi_attrib.type) {
        case PCI_CAP_ID_MSI:
        {
-                int pos = pci_find_capability(entry->dev, PCI_CAP_ID_MSI);
+                struct pci_dev *dev = entry->dev;
+                int pos = entry->msi_attrib.pos;
-                if (!pos)
+                u16 data;
-                        return;
+                pci_read_config_dword(dev, msi_lower_address_reg(pos),
-                pci_read_config_dword(entry->dev, msi_upper_address_reg(pos),
+                                        &msg->address_lo);
-                        &address_hi);
+                if (entry->msi_attrib.is_64) {
-                pci_read_config_dword(entry->dev, msi_lower_address_reg(pos),
+                        pci_read_config_dword(dev, msi_upper_address_reg(pos),
-                        &address_lo);
+                                                &msg->address_hi);
+                        pci_read_config_word(dev, msi_data_reg(pos, 1), &data);
-                msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
+                } else {
+                        msg->address_hi = 0;
-                pci_write_config_dword(entry->dev, msi_upper_address_reg(pos),
+                        pci_read_config_word(dev, msi_data_reg(pos, 1), &data);
-                        address_hi);
+                }
-                pci_write_config_dword(entry->dev, msi_lower_address_reg(pos),
+                msg->data = data;
-                        address_lo);
-                set_native_irq_info(irq, cpu_mask);
                break;
        }
        case PCI_CAP_ID_MSIX:
        {
-                int offset_hi =
+                void __iomem *base;
-                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
+                base = entry->mask_base +
-                                PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET;
+                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
-                int offset_lo =
-                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET;
-                address_hi = readl(entry->mask_base + offset_hi);
-                address_lo = readl(entry->mask_base + offset_lo);
-                msi_ops->target(vector, dest_cpu, &address_hi, &address_lo);
+                msg->address_lo = readl(base + PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
+                msg->address_hi = readl(base + PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
+                msg->data = readl(base + PCI_MSIX_ENTRY_DATA_OFFSET);
+                break;
+        }
+        default:
+                BUG();
+        }
+}
-                writel(address_hi, entry->mask_base + offset_hi);
+void write_msi_msg(unsigned int irq, struct msi_msg *msg)
-                writel(address_lo, entry->mask_base + offset_lo);
+{
-                set_native_irq_info(irq, cpu_mask);
+        struct msi_desc *entry = get_irq_data(irq);
+        switch (entry->msi_attrib.type) {
+        case PCI_CAP_ID_MSI:
+        {
+                struct pci_dev *dev = entry->dev;
+                int pos = entry->msi_attrib.pos;
+                pci_write_config_dword(dev, msi_lower_address_reg(pos),
+                                        msg->address_lo);
+                if (entry->msi_attrib.is_64) {
+                        pci_write_config_dword(dev, msi_upper_address_reg(pos),
+                                                msg->address_hi);
+                        pci_write_config_word(dev, msi_data_reg(pos, 1),
+                                                msg->data);
+                } else {
+                        pci_write_config_word(dev, msi_data_reg(pos, 0),
+                                                msg->data);
+                }
                break;
        }
-        default:
+        case PCI_CAP_ID_MSIX:
+        {
+                void __iomem *base;
+                base = entry->mask_base +
+                        entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
+                writel(msg->address_lo,
+                        base + PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
+                writel(msg->address_hi,
+                        base + PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
+                writel(msg->data, base + PCI_MSIX_ENTRY_DATA_OFFSET);
                break;
        }
-}
+        default:
-#else
+                BUG();
-#define set_msi_affinity NULL
-#endif /* CONFIG_SMP */
-static void mask_MSI_irq(unsigned int vector)
-{
-        msi_set_mask_bit(vector, 1);
-}
-static void unmask_MSI_irq(unsigned int vector)
-{
-        msi_set_mask_bit(vector, 0);
-}
-static unsigned int startup_msi_irq_wo_maskbit(unsigned int vector)
-{
-        struct msi_desc *entry;
-        unsigned long flags;
-        spin_lock_irqsave(&msi_lock, flags);
-        entry = msi_desc[vector];
-        if (!entry || !entry->dev) {
-                spin_unlock_irqrestore(&msi_lock, flags);
-                return 0;
        }
-        entry->msi_attrib.state = 1;    /* Mark it active */
-        spin_unlock_irqrestore(&msi_lock, flags);
-        return 0;       /* never anything pending */
 }
-static unsigned int startup_msi_irq_w_maskbit(unsigned int vector)
+void mask_msi_irq(unsigned int irq)
 {
-        startup_msi_irq_wo_maskbit(vector);
+        msi_set_mask_bit(irq, 1);
-        unmask_MSI_irq(vector);
-        return 0;       /* never anything pending */
-}
-static void shutdown_msi_irq(unsigned int vector)
-{
-        struct msi_desc *entry;
-        unsigned long flags;
-        spin_lock_irqsave(&msi_lock, flags);
-        entry = msi_desc[vector];
-        if (entry && entry->dev)
-                entry->msi_attrib.state = 0;    /* Mark it not active */
-        spin_unlock_irqrestore(&msi_lock, flags);
 }
-static void end_msi_irq_wo_maskbit(unsigned int vector)
+void unmask_msi_irq(unsigned int irq)
 {
-        move_native_irq(vector);
+        msi_set_mask_bit(irq, 0);
-        ack_APIC_irq();
-}
-static void end_msi_irq_w_maskbit(unsigned int vector)
-{
-        move_native_irq(vector);
-        unmask_MSI_irq(vector);
-        ack_APIC_irq();
-}
-static void do_nothing(unsigned int vector)
-{
-}
-/*
- * Interrupt Type for MSI-X PCI/PCI-X/PCI-Express Devices,
- * which implement the MSI-X Capability Structure.
- */
-static struct hw_interrupt_type msix_irq_type = {
-        .typename       = "PCI-MSI-X",
-        .startup        = startup_msi_irq_w_maskbit,
-        .shutdown       = shutdown_msi_irq,
-        .enable         = unmask_MSI_irq,
-        .disable        = mask_MSI_irq,
-        .ack            = mask_MSI_irq,
-        .end            = end_msi_irq_w_maskbit,
-        .set_affinity   = set_msi_affinity
-};
-/*
- * Interrupt Type for MSI PCI/PCI-X/PCI-Express Devices,
- * which implement the MSI Capability Structure with
- * Mask-and-Pending Bits.
- */
-static struct hw_interrupt_type msi_irq_w_maskbit_type = {
-        .typename       = "PCI-MSI",
-        .startup        = startup_msi_irq_w_maskbit,
-        .shutdown       = shutdown_msi_irq,
-        .enable         = unmask_MSI_irq,
-        .disable        = mask_MSI_irq,
-        .ack            = mask_MSI_irq,
-        .end            = end_msi_irq_w_maskbit,
-        .set_affinity   = set_msi_affinity
-};
-/*
- * Interrupt Type for MSI PCI/PCI-X/PCI-Express Devices,
- * which implement the MSI Capability Structure without
- * Mask-and-Pending Bits.
- */
-static struct hw_interrupt_type msi_irq_wo_maskbit_type = {
-        .typename       = "PCI-MSI",
-        .startup        = startup_msi_irq_wo_maskbit,
-        .shutdown       = shutdown_msi_irq,
-        .enable         = do_nothing,
-        .disable        = do_nothing,
-        .ack            = do_nothing,
-        .end            = end_msi_irq_wo_maskbit,
-        .set_affinity   = set_msi_affinity
-};
-static int msi_free_vector(struct pci_dev* dev, int vector, int reassign);
-static int assign_msi_vector(void)
-{
-        static int new_vector_avail = 1;
-        int vector;
-        unsigned long flags;
-        /*
-         * msi_lock is provided to ensure that successful allocation of MSI
-         * vector is assigned unique among drivers.
-         */
-        spin_lock_irqsave(&msi_lock, flags);
-        if (!new_vector_avail) {
-                int free_vector = 0;
-                /*
-                 * vector_irq[] = -1 indicates that this specific vector is:
-                 * - assigned for MSI (since MSI have no associated IRQ) or
-                 * - assigned for legacy if less than 16, or
-                 * - having no corresponding 1:1 vector-to-IOxAPIC IRQ mapping
-                 * vector_irq[] = 0 indicates that this vector, previously
-                 * assigned for MSI, is freed by hotplug removed operations.
-                 * This vector will be reused for any subsequent hotplug added
-                 * operations.
-                 * vector_irq[] > 0 indicates that this vector is assigned for
-                 * IOxAPIC IRQs. This vector and its value provides a 1-to-1
-                 * vector-to-IOxAPIC IRQ mapping.
-                 */
-                for (vector = FIRST_DEVICE_VECTOR; vector < NR_IRQS; vector++) {
-                        if (vector_irq[vector] != 0)
-                                continue;
-                        free_vector = vector;
-                        if (!msi_desc[vector])
-                                break;
-                        else
-                                continue;
-                }
-                if (!free_vector) {
-                        spin_unlock_irqrestore(&msi_lock, flags);
-                        return -EBUSY;
-                }
-                vector_irq[free_vector] = -1;
-                nr_released_vectors--;
-                spin_unlock_irqrestore(&msi_lock, flags);
-                if (msi_desc[free_vector] != NULL) {
-                        struct pci_dev *dev;
-                        int tail;
-                        /* free all linked vectors before re-assign */
-                        do {
-                                spin_lock_irqsave(&msi_lock, flags);
-                                dev = msi_desc[free_vector]->dev;
-                                tail = msi_desc[free_vector]->link.tail;
-                                spin_unlock_irqrestore(&msi_lock, flags);
-                                msi_free_vector(dev, tail, 1);
-                        } while (free_vector != tail);
-                }
-                return free_vector;
-        }
-        vector = assign_irq_vector(AUTO_ASSIGN);
-        last_alloc_vector = vector;
-        if (vector  == LAST_DEVICE_VECTOR)
-                new_vector_avail = 0;
-        spin_unlock_irqrestore(&msi_lock, flags);
-        return vector;
-}
-static int get_new_vector(void)
-{
-        int vector = assign_msi_vector();
-        if (vector > 0)
-                set_intr_gate(vector, interrupt[vector]);
-        return vector;
 }
+static int msi_free_irq(struct pci_dev* dev, int irq);
 static int msi_init(void)
 {
        static int status = -ENOMEM;
@@ -352,22 +176,6 @@ static int msi_init(void)
                return status;
        }
-        status = msi_arch_init();
-        if (status < 0) {
-                pci_msi_enable = 0;
-                printk(KERN_WARNING
-                       "PCI: MSI arch init failed.  MSI disabled.\n");
-                return status;
-        }
-        if (! msi_ops) {
-                printk(KERN_WARNING
-                       "PCI: MSI ops not registered. MSI disabled.\n");
-                status = -EINVAL;
-                return status;
-        }
-        last_alloc_vector = assign_irq_vector(AUTO_ASSIGN);
        status = msi_cache_init();
        if (status < 0) {
                pci_msi_enable = 0;
@@ -375,23 +183,9 @@ static int msi_init(void)
                return status;
        }
-        if (last_alloc_vector < 0) {
-                pci_msi_enable = 0;
-                printk(KERN_WARNING "PCI: No interrupt vectors available for MSI\n");
-                status = -EBUSY;
-                return status;
-        }
-        vector_irq[last_alloc_vector] = 0;
-        nr_released_vectors++;
        return status;
 }
-static int get_msi_vector(struct pci_dev *dev)
-{
-        return get_new_vector();
-}
 static struct msi_desc* alloc_msi_entry(void)
 {
        struct msi_desc *entry;
@@ -406,29 +200,44 @@ static struct msi_desc* alloc_msi_entry(void)
        return entry;
 }
-static void attach_msi_entry(struct msi_desc *entry, int vector)
+static void attach_msi_entry(struct msi_desc *entry, int irq)
 {
        unsigned long flags;
        spin_lock_irqsave(&msi_lock, flags);
-        msi_desc[vector] = entry;
+        msi_desc[irq] = entry;
        spin_unlock_irqrestore(&msi_lock, flags);
 }
-static void irq_handler_init(int cap_id, int pos, int mask)
+static int create_msi_irq(void)
 {
-        unsigned long flags;
+        struct msi_desc *entry;
+        int irq;
-        spin_lock_irqsave(&irq_desc[pos].lock, flags);
+        entry = alloc_msi_entry();
-        if (cap_id == PCI_CAP_ID_MSIX)
+        if (!entry)
-                irq_desc[pos].chip = &msix_irq_type;
+                return -ENOMEM;
-        else {
-                if (!mask)
+        irq = create_irq();
-                        irq_desc[pos].chip = &msi_irq_wo_maskbit_type;
+        if (irq < 0) {
-                else
+                kmem_cache_free(msi_cachep, entry);
-                        irq_desc[pos].chip = &msi_irq_w_maskbit_type;
+                return -EBUSY;
        }
-        spin_unlock_irqrestore(&irq_desc[pos].lock, flags);
+        set_irq_data(irq, entry);
+        return irq;
+}
+static void destroy_msi_irq(unsigned int irq)
+{
+        struct msi_desc *entry;
+        entry = get_irq_data(irq);
+        set_irq_chip(irq, NULL);
+        set_irq_data(irq, NULL);
+        destroy_irq(irq);
+        kmem_cache_free(msi_cachep, entry);
 }
 static void enable_msi_mode(struct pci_dev *dev, int pos, int type)
@@ -473,21 +282,21 @@ void disable_msi_mode(struct pci_dev *dev, int pos, int type)
        }
 }
-static int msi_lookup_vector(struct pci_dev *dev, int type)
+static int msi_lookup_irq(struct pci_dev *dev, int type)
 {
-        int vector;
+        int irq;
        unsigned long flags;
        spin_lock_irqsave(&msi_lock, flags);
-        for (vector = FIRST_DEVICE_VECTOR; vector < NR_IRQS; vector++) {
+        for (irq = 0; irq < NR_IRQS; irq++) {
-                if (!msi_desc[vector] || msi_desc[vector]->dev != dev ||
+                if (!msi_desc[irq] || msi_desc[irq]->dev != dev ||
-                        msi_desc[vector]->msi_attrib.type != type ||
+                        msi_desc[irq]->msi_attrib.type != type ||
-                        msi_desc[vector]->msi_attrib.default_vector != dev->irq)
+                        msi_desc[irq]->msi_attrib.default_irq != dev->irq)
                        continue;
                spin_unlock_irqrestore(&msi_lock, flags);
-                /* This pre-assigned MSI vector for this device
+                /* This pre-assigned MSI irq for this device
-                   already exits. Override dev->irq with this vector */
+                   already exits. Override dev->irq with this irq */
-                dev->irq = vector;
+                dev->irq = irq;
                return 0;
        }
        spin_unlock_irqrestore(&msi_lock, flags);
@@ -499,11 +308,6 @@ void pci_scan_msi_device(struct pci_dev *dev)
 {
        if (!dev)
                return;
-        if (pci_find_capability(dev, PCI_CAP_ID_MSIX) > 0)
-                nr_msix_devices++;
-        else if (pci_find_capability(dev, PCI_CAP_ID_MSI) > 0)
-                nr_reserved_vectors++;
 }
 #ifdef CONFIG_PM
@@ -577,7 +381,7 @@ int pci_save_msix_state(struct pci_dev *dev)
 {
        int pos;
        int temp;
-        int vector, head, tail = 0;
+        int irq, head, tail = 0;
        u16 control;
        struct pci_cap_saved_state *save_state;
@@ -599,33 +403,20 @@ int pci_save_msix_state(struct pci_dev *dev)
        /* save the table */
        temp = dev->irq;
-        if (msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        if (msi_lookup_irq(dev, PCI_CAP_ID_MSIX)) {
                kfree(save_state);
                return -EINVAL;
        }
-        vector = head = dev->irq;
+        irq = head = dev->irq;
        while (head != tail) {
-                int j;
-                void __iomem *base;
                struct msi_desc *entry;
-                entry = msi_desc[vector];
+                entry = msi_desc[irq];
-                base = entry->mask_base;
+                read_msi_msg(irq, &entry->msg_save);
-                j = entry->msi_attrib.entry_nr;
+                tail = msi_desc[irq]->link.tail;
-                entry->address_lo_save =
+                irq = tail;
-                        readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                              PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                entry->address_hi_save =
-                        readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                              PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                entry->data_save =
-                        readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                              PCI_MSIX_ENTRY_DATA_OFFSET);
-                tail = msi_desc[vector]->link.tail;
-                vector = tail;
        }
        dev->irq = temp;
@@ -638,9 +429,7 @@ void pci_restore_msix_state(struct pci_dev *dev)
 {
        u16 save;
        int pos;
-        int vector, head, tail = 0;
+        int irq, head, tail = 0;
-        void __iomem *base;
-        int j;
        struct msi_desc *entry;
        int temp;
        struct pci_cap_saved_state *save_state;
@@ -658,26 +447,15 @@ void pci_restore_msix_state(struct pci_dev *dev)
        /* route the table */
        temp = dev->irq;
-        if (msi_lookup_vector(dev, PCI_CAP_ID_MSIX))
+        if (msi_lookup_irq(dev, PCI_CAP_ID_MSIX))
                return;
-        vector = head = dev->irq;
+        irq = head = dev->irq;
        while (head != tail) {
-                entry = msi_desc[vector];
+                entry = msi_desc[irq];
-                base = entry->mask_base;
+                write_msi_msg(irq, &entry->msg_save);
-                j = entry->msi_attrib.entry_nr;
+                tail = msi_desc[irq]->link.tail;
-                writel(entry->address_lo_save,
+                irq = tail;
-                        base + j * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                writel(entry->address_hi_save,
-                        base + j * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                writel(entry->data_save,
-                        base + j * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_DATA_OFFSET);
-                tail = msi_desc[vector]->link.tail;
-                vector = tail;
        }
        dev->irq = temp;
@@ -686,104 +464,68 @@ void pci_restore_msix_state(struct pci_dev *dev)
 }
 #endif
-static int msi_register_init(struct pci_dev *dev, struct msi_desc *entry)
-{
-        int status;
-        u32 address_hi;
-        u32 address_lo;
-        u32 data;
-        int pos, vector = dev->irq;
-        u16 control;
-        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
-        pci_read_config_word(dev, msi_control_reg(pos), &control);
-        /* Configure MSI capability structure */
-        status = msi_ops->setup(dev, vector, &address_hi, &address_lo, &data);
-        if (status < 0)
-                return status;
-        pci_write_config_dword(dev, msi_lower_address_reg(pos), address_lo);
-        if (is_64bit_address(control)) {
-                pci_write_config_dword(dev,
-                        msi_upper_address_reg(pos), address_hi);
-                pci_write_config_word(dev,
-                        msi_data_reg(pos, 1), data);
-        } else
-                pci_write_config_word(dev,
-                        msi_data_reg(pos, 0), data);
-        if (entry->msi_attrib.maskbit) {
-                unsigned int maskbits, temp;
-                /* All MSIs are unmasked by default, Mask them all */
-                pci_read_config_dword(dev,
-                        msi_mask_bits_reg(pos, is_64bit_address(control)),
-                        &maskbits);
-                temp = (1 << multi_msi_capable(control));
-                temp = ((temp - 1) & ~temp);
-                maskbits |= temp;
-                pci_write_config_dword(dev,
-                        msi_mask_bits_reg(pos, is_64bit_address(control)),
-                        maskbits);
-        }
-        return 0;
-}
 /**
 * msi_capability_init - configure device's MSI capability structure
 * @dev: pointer to the pci_dev data structure of MSI device function
 *
 * Setup the MSI capability structure of device function with a single
- * MSI vector, regardless of device function is capable of handling
+ * MSI irq, regardless of device function is capable of handling
 * multiple messages. A return of zero indicates the successful setup
- * of an entry zero with the new MSI vector or non-zero for otherwise.
+ * of an entry zero with the new MSI irq or non-zero for otherwise.
 **/
 static int msi_capability_init(struct pci_dev *dev)
 {
        int status;
        struct msi_desc *entry;
-        int pos, vector;
+        int pos, irq;
        u16 control;
        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
        pci_read_config_word(dev, msi_control_reg(pos), &control);
        /* MSI Entry Initialization */
-        entry = alloc_msi_entry();
+        irq = create_msi_irq();
-        if (!entry)
+        if (irq < 0)
-                return -ENOMEM;
+                return irq;
-        vector = get_msi_vector(dev);
+        entry = get_irq_data(irq);
-        if (vector < 0) {
+        entry->link.head = irq;
-                kmem_cache_free(msi_cachep, entry);
+        entry->link.tail = irq;
-                return -EBUSY;
-        }
-        entry->link.head = vector;
-        entry->link.tail = vector;
        entry->msi_attrib.type = PCI_CAP_ID_MSI;
-        entry->msi_attrib.state = 0;                    /* Mark it not active */
+        entry->msi_attrib.is_64 = is_64bit_address(control);
        entry->msi_attrib.entry_nr = 0;
        entry->msi_attrib.maskbit = is_mask_bit_support(control);
-        entry->msi_attrib.default_vector = dev->irq;    /* Save IOAPIC IRQ */
+        entry->msi_attrib.default_irq = dev->irq;       /* Save IOAPIC IRQ */
-        dev->irq = vector;
+        entry->msi_attrib.pos = pos;
-        entry->dev = dev;
        if (is_mask_bit_support(control)) {
                entry->mask_base = (void __iomem *)(long)msi_mask_bits_reg(pos,
                                is_64bit_address(control));
        }
-        /* Replace with MSI handler */
+        entry->dev = dev;
-        irq_handler_init(PCI_CAP_ID_MSI, vector, entry->msi_attrib.maskbit);
+        if (entry->msi_attrib.maskbit) {
+                unsigned int maskbits, temp;
+                /* All MSIs are unmasked by default, Mask them all */
+                pci_read_config_dword(dev,
+                        msi_mask_bits_reg(pos, is_64bit_address(control)),
+                        &maskbits);
+                temp = (1 << multi_msi_capable(control));
+                temp = ((temp - 1) & ~temp);
+                maskbits |= temp;
+                pci_write_config_dword(dev,
+                        msi_mask_bits_reg(pos, is_64bit_address(control)),
+                        maskbits);
+        }
        /* Configure MSI capability structure */
-        status = msi_register_init(dev, entry);
+        status = arch_setup_msi_irq(irq, dev);
-        if (status != 0) {
+        if (status < 0) {
-                dev->irq = entry->msi_attrib.default_vector;
+                destroy_msi_irq(irq);
-                kmem_cache_free(msi_cachep, entry);
                return status;
        }
-        attach_msi_entry(entry, vector);
+        attach_msi_entry(entry, irq);
        /* Set MSI enabled bits  */
        enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
+        dev->irq = irq;
        return 0;
 }
@@ -794,18 +536,15 @@ static int msi_capability_init(struct pci_dev *dev)
 * @nvec: number of @entries
 *
 * Setup the MSI-X capability structure of device function with a
- * single MSI-X vector. A return of zero indicates the successful setup of
+ * single MSI-X irq. A return of zero indicates the successful setup of
- * requested MSI-X entries with allocated vectors or non-zero for otherwise.
+ * requested MSI-X entries with allocated irqs or non-zero for otherwise.
 **/
 static int msix_capability_init(struct pci_dev *dev,
                                struct msix_entry *entries, int nvec)
 {
        struct msi_desc *head = NULL, *tail = NULL, *entry = NULL;
-        u32 address_hi;
-        u32 address_lo;
-        u32 data;
        int status;
-        int vector, pos, i, j, nr_entries, temp = 0;
+        int irq, pos, i, j, nr_entries, temp = 0;
        unsigned long phys_addr;
        u32 table_offset;
        u16 control;
@@ -827,65 +566,56 @@ static int msix_capability_init(struct pci_dev *dev,
        /* MSI-X Table Initialization */
        for (i = 0; i < nvec; i++) {
-                entry = alloc_msi_entry();
+                irq = create_msi_irq();
-                if (!entry)
+                if (irq < 0)
                        break;
-                vector = get_msi_vector(dev);
-                if (vector < 0) {
-                        kmem_cache_free(msi_cachep, entry);
-                        break;
-                }
+                entry = get_irq_data(irq);
                j = entries[i].entry;
-                entries[i].vector = vector;
+                entries[i].vector = irq;
                entry->msi_attrib.type = PCI_CAP_ID_MSIX;
-                entry->msi_attrib.state = 0;            /* Mark it not active */
+                entry->msi_attrib.is_64 = 1;
                entry->msi_attrib.entry_nr = j;
                entry->msi_attrib.maskbit = 1;
-                entry->msi_attrib.default_vector = dev->irq;
+                entry->msi_attrib.default_irq = dev->irq;
+                entry->msi_attrib.pos = pos;
                entry->dev = dev;
                entry->mask_base = base;
                if (!head) {
-                        entry->link.head = vector;
+                        entry->link.head = irq;
-                        entry->link.tail = vector;
+                        entry->link.tail = irq;
                        head = entry;
                } else {
                        entry->link.head = temp;
                        entry->link.tail = tail->link.tail;
-                        tail->link.tail = vector;
+                        tail->link.tail = irq;
-                        head->link.head = vector;
+                        head->link.head = irq;
                }
-                temp = vector;
+                temp = irq;
                tail = entry;
-                /* Replace with MSI-X handler */
-                irq_handler_init(PCI_CAP_ID_MSIX, vector, 1);
                /* Configure MSI-X capability structure */
-                status = msi_ops->setup(dev, vector,
+                status = arch_setup_msi_irq(irq, dev);
-                                        &address_hi,
+                if (status < 0) {
-                                        &address_lo,
+                        destroy_msi_irq(irq);
-                                        &data);
-                if (status < 0)
                        break;
+                }
-                writel(address_lo,
+                attach_msi_entry(entry, irq);
-                        base + j * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                writel(address_hi,
-                        base + j * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                writel(data,
-                        base + j * PCI_MSIX_ENTRY_SIZE +
-                        PCI_MSIX_ENTRY_DATA_OFFSET);
-                attach_msi_entry(entry, vector);
        }
        if (i != nvec) {
+                int avail = i - 1;
                i--;
                for (; i >= 0; i--) {
-                        vector = (entries + i)->vector;
+                        irq = (entries + i)->vector;
-                        msi_free_vector(dev, vector, 0);
+                        msi_free_irq(dev, irq);
                        (entries + i)->vector = 0;
                }
-                return -EBUSY;
+                /* If we had some success report the number of irqs
+                 * we succeeded in setting up.
+                 */
+                if (avail <= 0)
+                        avail = -EBUSY;
+                return avail;
        }
        /* Set MSI-X enabled bits */
        enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
@@ -925,15 +655,14 @@ int pci_msi_supported(struct pci_dev * dev)
 * @dev: pointer to the pci_dev data structure of MSI device function
 *
 * Setup the MSI capability structure of device function with
- * a single MSI vector upon its software driver call to request for
+ * a single MSI irq upon its software driver call to request for
 * MSI mode enabled on its hardware device function. A return of zero
 * indicates the successful setup of an entry zero with the new MSI
- * vector or non-zero for otherwise.
+ * irq or non-zero for otherwise.
 **/
 int pci_enable_msi(struct pci_dev* dev)
 {
        int pos, temp, status;
-        u16 control;
        if (pci_msi_supported(dev) < 0)
                return -EINVAL;
@@ -948,52 +677,25 @@ int pci_enable_msi(struct pci_dev* dev)
        if (!pos)
                return -EINVAL;
-        if (!msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
+        WARN_ON(!msi_lookup_irq(dev, PCI_CAP_ID_MSI));
-                /* Lookup Sucess */
-                unsigned long flags;
-                pci_read_config_word(dev, msi_control_reg(pos), &control);
+        /* Check whether driver already requested for MSI-X irqs */
-                if (control & PCI_MSI_FLAGS_ENABLE)
-                        return 0;       /* Already in MSI mode */
-                spin_lock_irqsave(&msi_lock, flags);
-                if (!vector_irq[dev->irq]) {
-                        msi_desc[dev->irq]->msi_attrib.state = 0;
-                        vector_irq[dev->irq] = -1;
-                        nr_released_vectors--;
-                        spin_unlock_irqrestore(&msi_lock, flags);
-                        status = msi_register_init(dev, msi_desc[dev->irq]);
-                        if (status == 0)
-                                enable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
-                        return status;
-                }
-                spin_unlock_irqrestore(&msi_lock, flags);
-                dev->irq = temp;
-        }
-        /* Check whether driver already requested for MSI-X vectors */
        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
-        if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        if (pos > 0 && !msi_lookup_irq(dev, PCI_CAP_ID_MSIX)) {
                        printk(KERN_INFO "PCI: %s: Can't enable MSI.  "
-                               "Device already has MSI-X vectors assigned\n",
+                               "Device already has MSI-X irq assigned\n",
                               pci_name(dev));
                        dev->irq = temp;
                        return -EINVAL;
        }
        status = msi_capability_init(dev);
-        if (!status) {
-                if (!pos)
-                        nr_reserved_vectors--;  /* Only MSI capable */
-                else if (nr_msix_devices > 0)
-                        nr_msix_devices--;      /* Both MSI and MSI-X capable,
-                                                   but choose enabling MSI */
-        }
        return status;
 }
 void pci_disable_msi(struct pci_dev* dev)
 {
        struct msi_desc *entry;
-        int pos, default_vector;
+        int pos, default_irq;
        u16 control;
        unsigned long flags;
@@ -1010,41 +712,41 @@ void pci_disable_msi(struct pci_dev* dev)
        if (!(control & PCI_MSI_FLAGS_ENABLE))
                return;
+        disable_msi_mode(dev, pos, PCI_CAP_ID_MSI);
        spin_lock_irqsave(&msi_lock, flags);
        entry = msi_desc[dev->irq];
        if (!entry || !entry->dev || entry->msi_attrib.type != PCI_CAP_ID_MSI) {
                spin_unlock_irqrestore(&msi_lock, flags);
                return;
        }
-        if (entry->msi_attrib.state) {
+        if (irq_has_action(dev->irq)) {
                spin_unlock_irqrestore(&msi_lock, flags);
                printk(KERN_WARNING "PCI: %s: pci_disable_msi() called without "
-                       "free_irq() on MSI vector %d\n",
+                       "free_irq() on MSI irq %d\n",
                       pci_name(dev), dev->irq);
-                BUG_ON(entry->msi_attrib.state > 0);
+                BUG_ON(irq_has_action(dev->irq));
        } else {
-                vector_irq[dev->irq] = 0; /* free it */
+                default_irq = entry->msi_attrib.default_irq;
-                nr_released_vectors++;
-                default_vector = entry->msi_attrib.default_vector;
                spin_unlock_irqrestore(&msi_lock, flags);
-                /* Restore dev->irq to its default pin-assertion vector */
+                msi_free_irq(dev, dev->irq);
-                dev->irq = default_vector;
-                disable_msi_mode(dev, pci_find_capability(dev, PCI_CAP_ID_MSI),
+                /* Restore dev->irq to its default pin-assertion irq */
-                                        PCI_CAP_ID_MSI);
+                dev->irq = default_irq;
        }
 }
-static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
+static int msi_free_irq(struct pci_dev* dev, int irq)
 {
        struct msi_desc *entry;
        int head, entry_nr, type;
        void __iomem *base;
        unsigned long flags;
-        msi_ops->teardown(vector);
+        arch_teardown_msi_irq(irq);
        spin_lock_irqsave(&msi_lock, flags);
-        entry = msi_desc[vector];
+        entry = msi_desc[irq];
        if (!entry || entry->dev != dev) {
                spin_unlock_irqrestore(&msi_lock, flags);
                return -EINVAL;
@@ -1056,100 +758,42 @@ static int msi_free_vector(struct pci_dev* dev, int vector, int reassign)
        msi_desc[entry->link.head]->link.tail = entry->link.tail;
        msi_desc[entry->link.tail]->link.head = entry->link.head;
        entry->dev = NULL;
-        if (!reassign) {
+        msi_desc[irq] = NULL;
-                vector_irq[vector] = 0;
-                nr_released_vectors++;
-        }
-        msi_desc[vector] = NULL;
        spin_unlock_irqrestore(&msi_lock, flags);
-        kmem_cache_free(msi_cachep, entry);
+        destroy_msi_irq(irq);
        if (type == PCI_CAP_ID_MSIX) {
-                if (!reassign)
+                writel(1, base + entry_nr * PCI_MSIX_ENTRY_SIZE +
-                        writel(1, base +
+                        PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
-                                entry_nr * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_VECTOR_CTRL_OFFSET);
-                if (head == vector)
+                if (head == irq)
                        iounmap(base);
        }
        return 0;
 }
-static int reroute_msix_table(int head, struct msix_entry *entries, int *nvec)
-{
-        int vector = head, tail = 0;
-        int i, j = 0, nr_entries = 0;
-        void __iomem *base;
-        unsigned long flags;
-        spin_lock_irqsave(&msi_lock, flags);
-        while (head != tail) {
-                nr_entries++;
-                tail = msi_desc[vector]->link.tail;
-                if (entries[0].entry == msi_desc[vector]->msi_attrib.entry_nr)
-                        j = vector;
-                vector = tail;
-        }
-        if (*nvec > nr_entries) {
-                spin_unlock_irqrestore(&msi_lock, flags);
-                *nvec = nr_entries;
-                return -EINVAL;
-        }
-        vector = ((j > 0) ? j : head);
-        for (i = 0; i < *nvec; i++) {
-                j = msi_desc[vector]->msi_attrib.entry_nr;
-                msi_desc[vector]->msi_attrib.state = 0; /* Mark it not active */
-                vector_irq[vector] = -1;                /* Mark it busy */
-                nr_released_vectors--;
-                entries[i].vector = vector;
-                if (j != (entries + i)->entry) {
-                        base = msi_desc[vector]->mask_base;
-                        msi_desc[vector]->msi_attrib.entry_nr =
-                                (entries + i)->entry;
-                        writel( readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET), base +
-                                (entries + i)->entry * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_LOWER_ADDR_OFFSET);
-                        writel( readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET), base +
-                                (entries + i)->entry * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_UPPER_ADDR_OFFSET);
-                        writel( (readl(base + j * PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_DATA_OFFSET) & 0xff00) | vector,
-                                base + (entries+i)->entry*PCI_MSIX_ENTRY_SIZE +
-                                PCI_MSIX_ENTRY_DATA_OFFSET);
-                }
-                vector = msi_desc[vector]->link.tail;
-        }
-        spin_unlock_irqrestore(&msi_lock, flags);
-        return 0;
-}
 /**
 * pci_enable_msix - configure device's MSI-X capability structure
 * @dev: pointer to the pci_dev data structure of MSI-X device function
 * @entries: pointer to an array of MSI-X entries
- * @nvec: number of MSI-X vectors requested for allocation by device driver
+ * @nvec: number of MSI-X irqs requested for allocation by device driver
 *
 * Setup the MSI-X capability structure of device function with the number
- * of requested vectors upon its software driver call to request for
+ * of requested irqs upon its software driver call to request for
 * MSI-X mode enabled on its hardware device function. A return of zero
 * indicates the successful configuration of MSI-X capability structure
- * with new allocated MSI-X vectors. A return of < 0 indicates a failure.
+ * with new allocated MSI-X irqs. A return of < 0 indicates a failure.
 * Or a return of > 0 indicates that driver request is exceeding the number
- * of vectors available. Driver should use the returned value to re-send
+ * of irqs available. Driver should use the returned value to re-send
 * its request.
 **/
 int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
 {
-        int status, pos, nr_entries, free_vectors;
+        int status, pos, nr_entries;
        int i, j, temp;
        u16 control;
-        unsigned long flags;
        if (!entries || pci_msi_supported(dev) < 0)
                return -EINVAL;
@@ -1163,9 +807,6 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
                return -EINVAL;
        pci_read_config_word(dev, msi_control_reg(pos), &control);
-        if (control & PCI_MSIX_FLAGS_ENABLE)
-                return -EINVAL;                 /* Already in MSI-X mode */
        nr_entries = multi_msix_capable(control);
        if (nvec > nr_entries)
                return -EINVAL;
@@ -1180,56 +821,18 @@ int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec)
                }
        }
        temp = dev->irq;
-        if (!msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        WARN_ON(!msi_lookup_irq(dev, PCI_CAP_ID_MSIX));
-                /* Lookup Sucess */
-                nr_entries = nvec;
+        /* Check whether driver already requested for MSI irq */
-                /* Reroute MSI-X table */
-                if (reroute_msix_table(dev->irq, entries, &nr_entries)) {
-                        /* #requested > #previous-assigned */
-                        dev->irq = temp;
-                        return nr_entries;
-                }
-                dev->irq = temp;
-                enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
-                return 0;
-        }
-        /* Check whether driver already requested for MSI vector */
        if (pci_find_capability(dev, PCI_CAP_ID_MSI) > 0 &&
-                !msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
+                !msi_lookup_irq(dev, PCI_CAP_ID_MSI)) {
                printk(KERN_INFO "PCI: %s: Can't enable MSI-X.  "
-                       "Device already has an MSI vector assigned\n",
+                       "Device already has an MSI irq assigned\n",
                       pci_name(dev));
                dev->irq = temp;
                return -EINVAL;
        }
-        spin_lock_irqsave(&msi_lock, flags);
-        /*
-         * msi_lock is provided to ensure that enough vectors resources are
-         * available before granting.
-         */
-        free_vectors = pci_vector_resources(last_alloc_vector,
-                                nr_released_vectors);
-        /* Ensure that each MSI/MSI-X device has one vector reserved by
-           default to avoid any MSI-X driver to take all available
-           resources */
-        free_vectors -= nr_reserved_vectors;
-        /* Find the average of free vectors among MSI-X devices */
-        if (nr_msix_devices > 0)
-                free_vectors /= nr_msix_devices;
-        spin_unlock_irqrestore(&msi_lock, flags);
-        if (nvec > free_vectors) {
-                if (free_vectors > 0)
-                        return free_vectors;
-                else
-                        return -EBUSY;
-        }
        status = msix_capability_init(dev, entries, nvec);
-        if (!status && nr_msix_devices > 0)
-                nr_msix_devices--;
        return status;
 }
@@ -1251,53 +854,47 @@ void pci_disable_msix(struct pci_dev* dev)
        if (!(control & PCI_MSIX_FLAGS_ENABLE))
                return;
+        disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX);
        temp = dev->irq;
-        if (!msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        if (!msi_lookup_irq(dev, PCI_CAP_ID_MSIX)) {
-                int state, vector, head, tail = 0, warning = 0;
+                int irq, head, tail = 0, warning = 0;
                unsigned long flags;
-                vector = head = dev->irq;
+                irq = head = dev->irq;
-                spin_lock_irqsave(&msi_lock, flags);
+                dev->irq = temp;                        /* Restore pin IRQ */
                while (head != tail) {
-                        state = msi_desc[vector]->msi_attrib.state;
+                        spin_lock_irqsave(&msi_lock, flags);
-                        if (state)
+                        tail = msi_desc[irq]->link.tail;
+                        spin_unlock_irqrestore(&msi_lock, flags);
+                        if (irq_has_action(irq))
                                warning = 1;
-                        else {
+                        else if (irq != head)   /* Release MSI-X irq */
-                                vector_irq[vector] = 0; /* free it */
+                                msi_free_irq(dev, irq);
-                                nr_released_vectors++;
+                        irq = tail;
-                        }
-                        tail = msi_desc[vector]->link.tail;
-                        vector = tail;
                }
-                spin_unlock_irqrestore(&msi_lock, flags);
+                msi_free_irq(dev, irq);
                if (warning) {
-                        dev->irq = temp;
                        printk(KERN_WARNING "PCI: %s: pci_disable_msix() called without "
-                               "free_irq() on all MSI-X vectors\n",
+                               "free_irq() on all MSI-X irqs\n",
                               pci_name(dev));
                        BUG_ON(warning > 0);
-                } else {
-                        dev->irq = temp;
-                        disable_msi_mode(dev,
-                                pci_find_capability(dev, PCI_CAP_ID_MSIX),
-                                PCI_CAP_ID_MSIX);
                }
        }
 }
 /**
- * msi_remove_pci_irq_vectors - reclaim MSI(X) vectors to unused state
+ * msi_remove_pci_irq_vectors - reclaim MSI(X) irqs to unused state
 * @dev: pointer to the pci_dev data structure of MSI(X) device function
 *
 * Being called during hotplug remove, from which the device function
- * is hot-removed. All previous assigned MSI/MSI-X vectors, if
+ * is hot-removed. All previous assigned MSI/MSI-X irqs, if
 * allocated for this device function, are reclaimed to unused state,
 * which may be used later on.
 **/
 void msi_remove_pci_irq_vectors(struct pci_dev* dev)
 {
-        int state, pos, temp;
+        int pos, temp;
        unsigned long flags;
        if (!pci_msi_enable || !dev)
@@ -1305,42 +902,38 @@ void msi_remove_pci_irq_vectors(struct pci_dev* dev)
        temp = dev->irq;                /* Save IOAPIC IRQ */
        pos = pci_find_capability(dev, PCI_CAP_ID_MSI);
-        if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSI)) {
+        if (pos > 0 && !msi_lookup_irq(dev, PCI_CAP_ID_MSI)) {
-                spin_lock_irqsave(&msi_lock, flags);
+                if (irq_has_action(dev->irq)) {
-                state = msi_desc[dev->irq]->msi_attrib.state;
-                spin_unlock_irqrestore(&msi_lock, flags);
-                if (state) {
                        printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
-                               "called without free_irq() on MSI vector %d\n",
+                               "called without free_irq() on MSI irq %d\n",
                               pci_name(dev), dev->irq);
-                        BUG_ON(state > 0);
+                        BUG_ON(irq_has_action(dev->irq));
-                } else /* Release MSI vector assigned to this device */
+                } else /* Release MSI irq assigned to this device */
-                        msi_free_vector(dev, dev->irq, 0);
+                        msi_free_irq(dev, dev->irq);
                dev->irq = temp;                /* Restore IOAPIC IRQ */
        }
        pos = pci_find_capability(dev, PCI_CAP_ID_MSIX);
-        if (pos > 0 && !msi_lookup_vector(dev, PCI_CAP_ID_MSIX)) {
+        if (pos > 0 && !msi_lookup_irq(dev, PCI_CAP_ID_MSIX)) {
-                int vector, head, tail = 0, warning = 0;
+                int irq, head, tail = 0, warning = 0;
                void __iomem *base = NULL;
-                vector = head = dev->irq;
+                irq = head = dev->irq;
                while (head != tail) {
                        spin_lock_irqsave(&msi_lock, flags);
-                        state = msi_desc[vector]->msi_attrib.state;
+                        tail = msi_desc[irq]->link.tail;
-                        tail = msi_desc[vector]->link.tail;
+                        base = msi_desc[irq]->mask_base;
-                        base = msi_desc[vector]->mask_base;
                        spin_unlock_irqrestore(&msi_lock, flags);
-                        if (state)
+                        if (irq_has_action(irq))
                                warning = 1;
-                        else if (vector != head) /* Release MSI-X vector */
+                        else if (irq != head) /* Release MSI-X irq */
-                                msi_free_vector(dev, vector, 0);
+                                msi_free_irq(dev, irq);
-                        vector = tail;
+                        irq = tail;
                }
-                msi_free_vector(dev, vector, 0);
+                msi_free_irq(dev, irq);
                if (warning) {
                        iounmap(base);
                        printk(KERN_WARNING "PCI: %s: msi_remove_pci_irq_vectors() "
-                               "called without free_irq() on all MSI-X vectors\n",
+                               "called without free_irq() on all MSI-X irqs\n",
                               pci_name(dev));
                        BUG_ON(warning > 0);
                }
diff --git a/drivers/pci/msi.h b/drivers/pci/msi.h
index 56951c39d3a..f0cca1772f9 100644
--- a/drivers/pci/msi.h
+++ b/drivers/pci/msi.h
@@ -7,84 +7,6 @@
 #define MSI_H
 /*
- * MSI operation vector.  Used by the msi core code (drivers/pci/msi.c)
- * to abstract platform-specific tasks relating to MSI address generation
- * and resource management.
- */
-struct msi_ops {
-        /**
-         * setup - generate an MSI bus address and data for a given vector
-         * @pdev: PCI device context (in)
-         * @vector: vector allocated by the msi core (in)
-         * @addr_hi: upper 32 bits of PCI bus MSI address (out)
-         * @addr_lo: lower 32 bits of PCI bus MSI address (out)
-         * @data: MSI data payload (out)
-         *
-         * Description: The setup op is used to generate a PCI bus addres and
-         * data which the msi core will program into the card MSI capability
-         * registers.  The setup routine is responsible for picking an initial
-         * cpu to target the MSI at.  The setup routine is responsible for
-         * examining pdev to determine the MSI capabilities of the card and
-         * generating a suitable address/data.  The setup routine is
-         * responsible for allocating and tracking any system resources it
-         * needs to route the MSI to the cpu it picks, and for associating
-         * those resources with the passed in vector.
-         *
-         * Returns 0 if the MSI address/data was successfully setup.
-         **/
-        int     (*setup)    (struct pci_dev *pdev, unsigned int vector,
-                             u32 *addr_hi, u32 *addr_lo, u32 *data);
-        /**
-         * teardown - release resources allocated by setup
-         * @vector: vector context for resources (in)
-         *
-         * Description:  The teardown op is used to release any resources
-         * that were allocated in the setup routine associated with the passed
-         * in vector.
-         **/
-        void    (*teardown) (unsigned int vector);
-        /**
-         * target - retarget an MSI at a different cpu
-         * @vector: vector context for resources (in)
-         * @cpu:  new cpu to direct vector at (in)
-         * @addr_hi: new value of PCI bus upper 32 bits (in/out)
-         * @addr_lo: new value of PCI bus lower 32 bits (in/out)
-         *
-         * Description:  The target op is used to redirect an MSI vector
-         * at a different cpu.  addr_hi/addr_lo coming in are the existing
-         * values that the MSI core has programmed into the card.  The
-         * target code is responsible for freeing any resources (if any)
-         * associated with the old address, and generating a new PCI bus
-         * addr_hi/addr_lo that will redirect the vector at the indicated cpu.
-         **/
-        void    (*target)   (unsigned int vector, unsigned int cpu,
-                             u32 *addr_hi, u32 *addr_lo);
-};
-extern int msi_register(struct msi_ops *ops);
-#include <asm/msi.h>
-/*
- * Assume the maximum number of hot plug slots supported by the system is about
- * ten. The worstcase is that each of these slots is hot-added with a device,
- * which has two MSI/MSI-X capable functions. To avoid any MSI-X driver, which
- * attempts to request all available vectors, NR_HP_RESERVED_VECTORS is defined
- * as below to ensure at least one message is assigned to each detected MSI/
- * MSI-X device function.
- */
-#define NR_HP_RESERVED_VECTORS  20
-extern int vector_irq[NR_VECTORS];
-extern void (*interrupt[NR_IRQS])(void);
-extern int pci_vector_resources(int last, int nr_released);
-/*
 * MSI-X Address Register
 */
 #define PCI_MSIX_FLAGS_QSIZE            0x7FF
@@ -110,8 +32,8 @@ extern int pci_vector_resources(int last, int nr_released);
        (1 << ((control & PCI_MSI_FLAGS_QMASK) >> 1))
 #define multi_msi_enable(control, num) \
        control |= (((num >> 1) << 4) & PCI_MSI_FLAGS_QSIZE);
-#define is_64bit_address(control)       (control & PCI_MSI_FLAGS_64BIT)
+#define is_64bit_address(control)       (!!(control & PCI_MSI_FLAGS_64BIT))
-#define is_mask_bit_support(control)    (control & PCI_MSI_FLAGS_MASKBIT)
+#define is_mask_bit_support(control)    (!!(control & PCI_MSI_FLAGS_MASKBIT))
 #define msi_enable(control, num) multi_msi_enable(control, num); \
        control |= PCI_MSI_FLAGS_ENABLE
@@ -125,32 +47,4 @@ extern int pci_vector_resources(int last, int nr_released);
 #define msix_mask(address)              (address | PCI_MSIX_FLAGS_BITMASK)
 #define msix_is_pending(address)        (address & PCI_MSIX_FLAGS_PENDMASK)
-struct msi_desc {
-        struct {
-                __u8    type    : 5;    /* {0: unused, 5h:MSI, 11h:MSI-X} */
-                __u8    maskbit : 1;    /* mask-pending bit supported ?   */
-                __u8    state   : 1;    /* {0: free, 1: busy}             */
-                __u8    reserved: 1;    /* reserved                       */
-                __u8    entry_nr;       /* specific enabled entry         */
-                __u8    default_vector; /* default pre-assigned vector    */
-                __u8    unused;         /* formerly unused destination cpu*/
-        }msi_attrib;
-        struct {
-                __u16   head;
-                __u16   tail;
-        }link;
-        void __iomem *mask_base;
-        struct pci_dev *dev;
-#ifdef CONFIG_PM
-        /* PM save area for MSIX address/data */
-        u32     address_hi_save;
-        u32     address_lo_save;
-        u32     data_save;
-#endif
-};
 #endif /* MSI_H */
diff --git a/drivers/pci/setup-bus.c b/drivers/pci/setup-bus.c
index 54404917be9..8f7bcf56f14 100644
--- a/drivers/pci/setup-bus.c
+++ b/drivers/pci/setup-bus.c
@@ -55,16 +55,16 @@ pbus_assign_resources_sorted(struct pci_bus *bus)
        list_for_each_entry(dev, &bus->devices, bus_list) {
                u16 class = dev->class >> 8;
-                /* Don't touch classless devices or host bridges. */
+                /* Don't touch classless devices or host bridges or ioapics.  */
                if (class == PCI_CLASS_NOT_DEFINED ||
                    class == PCI_CLASS_BRIDGE_HOST)
                        continue;
-                /* Don't touch ioapics if it has the assigned resources. */
+                /* Don't touch ioapic devices already enabled by firmware */
                if (class == PCI_CLASS_SYSTEM_PIC) {
-                        res = &dev->resource[0];
+                        u16 command;
-                        if (res[0].start || res[1].start || res[2].start ||
+                        pci_read_config_word(dev, PCI_COMMAND, &command);
-                            res[3].start || res[4].start || res[5].start)
+                        if (command & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY))
                                continue;
                }
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index cc5032b6f42..3f0f7b8fa81 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -141,9 +141,9 @@ static int ds1307_set_time(struct device *dev, struct rtc_time *t)
        dev_dbg(dev, "%s secs=%d, mins=%d, "
                "hours=%d, mday=%d, mon=%d, year=%d, wday=%d\n",
-                "write", dt->tm_sec, dt->tm_min,
+                "write", t->tm_sec, t->tm_min,
-                dt->tm_hour, dt->tm_mday,
+                t->tm_hour, t->tm_mday,
-                dt->tm_mon, dt->tm_year, dt->tm_wday);
+                t->tm_mon, t->tm_year, t->tm_wday);
        *buf++ = 0;             /* first register addr */
        buf[DS1307_REG_SECS] = BIN2BCD(t->tm_sec);
diff --git a/drivers/rtc/rtc-ds1672.c b/drivers/rtc/rtc-ds1672.c
index 9c68ec99afa..67e816a9a39 100644
--- a/drivers/rtc/rtc-ds1672.c
+++ b/drivers/rtc/rtc-ds1672.c
@@ -55,7 +55,7 @@ static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm)
        }
        dev_dbg(&client->dev,
-                "%s: raw read data - counters=%02x,%02x,%02x,%02x\n"
+                "%s: raw read data - counters=%02x,%02x,%02x,%02x\n",
                __FUNCTION__, buf[0], buf[1], buf[2], buf[3]);
        time = (buf[3] << 24) | (buf[2] << 16) | (buf[1] << 8) | buf[0];
@@ -96,7 +96,7 @@ static int ds1672_set_datetime(struct i2c_client *client, struct rtc_time *tm)
        unsigned long secs;
        dev_dbg(&client->dev,
-                "%s: secs=%d, mins=%d, hours=%d, ",
+                "%s: secs=%d, mins=%d, hours=%d, "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
                __FUNCTION__,
                tm->tm_sec, tm->tm_min, tm->tm_hour,
diff --git a/drivers/rtc/rtc-rs5c372.c b/drivers/rtc/rtc-rs5c372.c
index bbdad099471..2a86632580f 100644
--- a/drivers/rtc/rtc-rs5c372.c
+++ b/drivers/rtc/rtc-rs5c372.c
@@ -91,7 +91,7 @@ static int rs5c372_set_datetime(struct i2c_client *client, struct rtc_time *tm)
        unsigned char buf[8] = { RS5C372_REG_BASE };
        dev_dbg(&client->dev,
-                "%s: secs=%d, mins=%d, hours=%d ",
+                "%s: secs=%d, mins=%d, hours=%d "
                "mday=%d, mon=%d, year=%d, wday=%d\n",
                __FUNCTION__, tm->tm_sec, tm->tm_min, tm->tm_hour,
                tm->tm_mday, tm->tm_mon, tm->tm_year, tm->tm_wday);
@@ -126,7 +126,7 @@ static int rs5c372_get_trim(struct i2c_client *client, int *osc, int *trim)
                return -EIO;
        }
-        dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, trim);
+        dev_dbg(&client->dev, "%s: raw trim=%x\n", __FUNCTION__, *trim);
        if (osc)
                *osc = (buf & RS5C372_TRIM_XSL) ? 32000 : 32768;
diff --git a/drivers/serial/8250_gsc.c b/drivers/serial/8250_gsc.c
index 1ebe6b585d2..c5d0addfda4 100644
--- a/drivers/serial/8250_gsc.c
+++ b/drivers/serial/8250_gsc.c
@@ -22,7 +22,6 @@
 #include <asm/hardware.h>
 #include <asm/parisc-device.h>
 #include <asm/io.h>
-#include <asm/serial.h> /* for LASI_BASE_BAUD */
 #include "8250.h"
@@ -54,7 +53,8 @@ serial_init_chip(struct parisc_device *dev)
        memset(&port, 0, sizeof(port));
        port.iotype     = UPIO_MEM;
-        port.uartclk    = LASI_BASE_BAUD * 16;
+        /* 7.272727MHz on Lasi.  Assumed the same for Dino, Wax and Timi. */
+        port.uartclk    = 7272727;
        port.mapbase    = address;
        port.membase    = ioremap_nocache(address, 16);
        port.irq        = dev->irq;
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 653098bc2dd..8edee745888 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -556,10 +556,11 @@ config SERIAL_MUX
        default y
        ---help---
          Saying Y here will enable the hardware MUX serial driver for
-          the Nova and K class systems.  The hardware MUX is not 8250/16550 
+          the Nova, K class systems and D class with a 'remote control card'.
-          compatible therefore the /dev/ttyB0 device is shared between the 
+          The hardware MUX is not 8250/16550 compatible therefore the
-          Serial MUX and the PDC software console.  The following steps 
+          /dev/ttyB0 device is shared between the Serial MUX and the PDC
-          need to be completed to use the Serial MUX:
+          software console. The following steps need to be completed to use
+          the Serial MUX:
            1. create the device entry (mknod /dev/ttyB0 c 11 0)
            2. Edit the /etc/inittab to start a getty listening on /dev/ttyB0
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index b120896c8ab..a433cc78ef9 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -1843,7 +1843,7 @@ static int __devinit riva_get_EDID_OF(struct fb_info *info, struct pci_dev *pd)
                for (i = 0; propnames[i] != NULL; ++i) {
                        pedid = get_property(dp, propnames[i], NULL);
                        if (pedid != NULL) {
-                                par->EDID = pedid;
+                                par->EDID = (unsigned char *)pedid;
                                NVTRACE("LCD found.\n");
                                return 1;
                        }