Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/pci-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/gregkh/pci-2.6: (27 commits)
  [PATCH] PCI: nVidia quirk to make AER PCI-E extended capability visible
  [PATCH] PCI: fix issues with extended conf space when MMCONFIG disabled because of e820
  [PATCH] PCI: Bus Parity Status sysfs interface
  [PATCH] PCI: fix memory leak in MMCONFIG error path
  [PATCH] PCI: fix error with pci_get_device() call in the mpc85xx driver
  [PATCH] PCI: MSI-K8T-Neo2-Fir: run only where needed
  [PATCH] PCI: fix race with pci_walk_bus and pci_destroy_dev
  [PATCH] PCI: clean up pci documentation to be more specific
  [PATCH] PCI: remove unneeded msi code
  [PATCH] PCI: don't move ioapics below PCI bridge
  [PATCH] PCI: cleanup unused variable about msi driver
  [PATCH] PCI: disable msi mode in pci_disable_device
  [PATCH] PCI: Allow MSI to work on kexec kernel
  [PATCH] PCI: AMD 8131 MSI quirk called too late, bus_flags not inherited ?
  [PATCH] PCI: Move various PCI IDs to header file
  [PATCH] PCI Bus Parity Status-broken hardware attribute, EDAC foundation
  [PATCH] PCI: i386/x86_84: disable PCI resource decode on device disable
  [PATCH] PCI ACPI: Rename the functions to avoid multiple instances.
  [PATCH] PCI: don't enable device if already enabled
  [PATCH] PCI: Add a "enable" sysfs attribute to the pci devices to allow userspace (Xorg) to enable devices without doing foul direct access
  ...

14 files changed, 235 insertions, 124 deletions

diff --git a/arch/i386/kernel/acpi/boot.c b/arch/i386/kernel/acpi/boot.c
index 40e5aba3ad3d..fbe93084244c 100644
--- a/arch/i386/kernel/acpi/boot.c
+++ b/arch/i386/kernel/acpi/boot.c
@@ -202,6 +202,8 @@ int __init acpi_parse_mcfg(unsigned long phys_addr, unsigned long size)
                 if (mcfg->config[i].base_reserved) {
                         printk(KERN_ERR PREFIX
                                "MMCONFIG not in low 4GB of memory\n");
+                        kfree(pci_mmcfg_config);
+                        pci_mmcfg_config_num = 0;
                         return -ENODEV;
                 }
         }
diff --git a/arch/i386/pci/common.c b/arch/i386/pci/common.c
index dbece776c5b2..c624b61e1104 100644
--- a/arch/i386/pci/common.c
+++ b/arch/i386/pci/common.c
@@ -288,6 +288,7 @@ int pcibios_enable_device(struct pci_dev *dev, int mask)
 
 void pcibios_disable_device (struct pci_dev *dev)
 {
+        pcibios_disable_resources(dev);
         if (pcibios_disable_irq)
                 pcibios_disable_irq(dev);
 }
diff --git a/arch/i386/pci/i386.c b/arch/i386/pci/i386.c
index ed2c8c899bd3..7852827a599b 100644
--- a/arch/i386/pci/i386.c
+++ b/arch/i386/pci/i386.c
@@ -242,6 +242,15 @@ int pcibios_enable_resources(struct pci_dev *dev, int mask)
         return 0;
 }
 
+void pcibios_disable_resources(struct pci_dev *dev)
+{
+        u16 cmd;
+
+        pci_read_config_word(dev, PCI_COMMAND, &cmd);
+        cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
+        pci_write_config_word(dev, PCI_COMMAND, cmd);
+}
+
 /*
  *  If we set up a device for bus mastering, we need to check the latency
  *  timer as certain crappy BIOSes forget to set it properly.
diff --git a/arch/i386/pci/mmconfig.c b/arch/i386/pci/mmconfig.c
index 6b1ea0c9a570..e545b0992c48 100644
--- a/arch/i386/pci/mmconfig.c
+++ b/arch/i386/pci/mmconfig.c
@@ -15,7 +15,9 @@
 #include <asm/e820.h>
 #include "pci.h"
 
-#define MMCONFIG_APER_SIZE (256*1024*1024)
+/* aperture is up to 256MB but BIOS may reserve less */
+#define MMCONFIG_APER_MIN       (2 * 1024*1024)
+#define MMCONFIG_APER_MAX       (256 * 1024*1024)
 
 /* Assume systems with more busses have correct MCFG */
 #define MAX_CHECK_BUS 16
@@ -197,9 +199,10 @@ void __init pci_mmcfg_init(void)
                 return;
 
         if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
-                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_SIZE,
+                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
                         E820_RESERVED)) {
-                printk(KERN_ERR "PCI: BIOS Bug: MCFG area is not E820-reserved\n");
+                printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                                pci_mmcfg_config[0].base_address);
                 printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
                 return;
         }
diff --git a/arch/i386/pci/pci.h b/arch/i386/pci/pci.h
index 12035e29108b..12bf3d8dda29 100644
--- a/arch/i386/pci/pci.h
+++ b/arch/i386/pci/pci.h
@@ -35,6 +35,7 @@ extern unsigned int pcibios_max_latency;
 
 void pcibios_resource_survey(void);
 int pcibios_enable_resources(struct pci_dev *, int);
+void pcibios_disable_resources(struct pci_dev *);
 
 /* pci-pc.c */
 
diff --git a/arch/ia64/kernel/irq_ia64.c b/arch/ia64/kernel/irq_ia64.c
index 6c4d59fd0364..ef9a2b49307a 100644
--- a/arch/ia64/kernel/irq_ia64.c
+++ b/arch/ia64/kernel/irq_ia64.c
@@ -46,6 +46,10 @@
 
 #define IRQ_DEBUG       0
 
+/* These can be overridden in platform_irq_init */
+int ia64_first_device_vector = IA64_DEF_FIRST_DEVICE_VECTOR;
+int ia64_last_device_vector = IA64_DEF_LAST_DEVICE_VECTOR;
+
 /* default base addr of IPI table */
 void __iomem *ipi_base_addr = ((void __iomem *)
                                (__IA64_UNCACHED_OFFSET | IA64_IPI_DEFAULT_BASE_ADDR));
@@ -60,7 +64,7 @@ __u8 isa_irq_to_vector_map[16] = {
 };
 EXPORT_SYMBOL(isa_irq_to_vector_map);
 
-static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_NUM_DEVICE_VECTORS)];
+static unsigned long ia64_vector_mask[BITS_TO_LONGS(IA64_MAX_DEVICE_VECTORS)];
 
 int
 assign_irq_vector (int irq)
@@ -89,6 +93,19 @@ free_irq_vector (int vector)
                 printk(KERN_WARNING "%s: double free!\n", __FUNCTION__);
 }
 
+int
+reserve_irq_vector (int vector)
+{
+        int pos;
+
+        if (vector < IA64_FIRST_DEVICE_VECTOR ||
+            vector > IA64_LAST_DEVICE_VECTOR)
+                return -EINVAL;
+
+        pos = vector - IA64_FIRST_DEVICE_VECTOR;
+        return test_and_set_bit(pos, ia64_vector_mask);
+}
+
 #ifdef CONFIG_SMP
 #       define IS_RESCHEDULE(vec)       (vec == IA64_IPI_RESCHEDULE)
 #else
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 5101ac462643..dc09a6a28a37 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -58,7 +58,7 @@ static int max_pcibus_number = 255;	/* Default highest pci bus number */
  */
 
 static dma_addr_t
-sn_default_pci_map(struct pci_dev *pdev, unsigned long paddr, size_t size)
+sn_default_pci_map(struct pci_dev *pdev, unsigned long paddr, size_t size, int type)
 {
         return 0;
 }
@@ -457,13 +457,6 @@ void sn_pci_fixup_slot(struct pci_dev *dev)
                 pcidev_info->pdi_sn_irq_info = NULL;
                 kfree(sn_irq_info);
         }
-
-        /*
-         * MSI currently not supported on altix.  Remove this when
-         * the MSI abstraction patches are integrated into the kernel
-         * (sometime after 2.6.16 releases)
-         */
-        dev->no_msi = 1;
 }
 
 /*
diff --git a/arch/ia64/sn/kernel/irq.c b/arch/ia64/sn/kernel/irq.c
index c265e02f5036..dc8e2b696713 100644
--- a/arch/ia64/sn/kernel/irq.c
+++ b/arch/ia64/sn/kernel/irq.c
@@ -26,11 +26,11 @@ static void unregister_intr_pda(struct sn_irq_info *sn_irq_info);
 
 int sn_force_interrupt_flag = 1;
 extern int sn_ioif_inited;
-static struct list_head **sn_irq_lh;
+struct list_head **sn_irq_lh;
 static spinlock_t sn_irq_info_lock = SPIN_LOCK_UNLOCKED; /* non-IRQ lock */
 
-static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
-                                     u64 sn_irq_info,
+u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
+                                     struct sn_irq_info *sn_irq_info,
                                      int req_irq, nasid_t req_nasid,
                                      int req_slice)
 {
@@ -40,12 +40,13 @@ static inline u64 sn_intr_alloc(nasid_t local_nasid, int local_widget,
 
         SAL_CALL_NOLOCK(ret_stuff, (u64) SN_SAL_IOIF_INTERRUPT,
                         (u64) SAL_INTR_ALLOC, (u64) local_nasid,
-                        (u64) local_widget, (u64) sn_irq_info, (u64) req_irq,
+                        (u64) local_widget, __pa(sn_irq_info), (u64) req_irq,
                         (u64) req_nasid, (u64) req_slice);
+
         return ret_stuff.status;
 }
 
-static inline void sn_intr_free(nasid_t local_nasid, int local_widget,
+void sn_intr_free(nasid_t local_nasid, int local_widget,
                                 struct sn_irq_info *sn_irq_info)
 {
         struct ia64_sal_retval ret_stuff;
@@ -112,73 +113,91 @@ static void sn_end_irq(unsigned int irq)
 
 static void sn_irq_info_free(struct rcu_head *head);
 
-static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
+struct sn_irq_info *sn_retarget_vector(struct sn_irq_info *sn_irq_info,
+                                       nasid_t nasid, int slice)
 {
-        struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
-        int cpuid, cpuphys;
+        int vector;
+        int cpuphys;
+        int64_t bridge;
+        int local_widget, status;
+        nasid_t local_nasid;
+        struct sn_irq_info *new_irq_info;
+        struct sn_pcibus_provider *pci_provider;
 
-        cpuid = first_cpu(mask);
-        cpuphys = cpu_physical_id(cpuid);
+        new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
+        if (new_irq_info == NULL)
+                return NULL;
 
-        list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
-                                 sn_irq_lh[irq], list) {
-                u64 bridge;
-                int local_widget, status;
-                nasid_t local_nasid;
-                struct sn_irq_info *new_irq_info;
-                struct sn_pcibus_provider *pci_provider;
-
-                new_irq_info = kmalloc(sizeof(struct sn_irq_info), GFP_ATOMIC);
-                if (new_irq_info == NULL)
-                        break;
-                memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
-
-                bridge = (u64) new_irq_info->irq_bridge;
-                if (!bridge) {
-                        kfree(new_irq_info);
-                        break; /* irq is not a device interrupt */
-                }
+        memcpy(new_irq_info, sn_irq_info, sizeof(struct sn_irq_info));
+
+        bridge = (u64) new_irq_info->irq_bridge;
+        if (!bridge) {
+                kfree(new_irq_info);
+                return NULL; /* irq is not a device interrupt */
+        }
 
-                local_nasid = NASID_GET(bridge);
+        local_nasid = NASID_GET(bridge);
 
-                if (local_nasid & 1)
-                        local_widget = TIO_SWIN_WIDGETNUM(bridge);
-                else
-                        local_widget = SWIN_WIDGETNUM(bridge);
+        if (local_nasid & 1)
+                local_widget = TIO_SWIN_WIDGETNUM(bridge);
+        else
+                local_widget = SWIN_WIDGETNUM(bridge);
 
-                /* Free the old PROM new_irq_info structure */
-                sn_intr_free(local_nasid, local_widget, new_irq_info);
-                /* Update kernels new_irq_info with new target info */
-                unregister_intr_pda(new_irq_info);
+        vector = sn_irq_info->irq_irq;
+        /* Free the old PROM new_irq_info structure */
+        sn_intr_free(local_nasid, local_widget, new_irq_info);
+        /* Update kernels new_irq_info with new target info */
+        unregister_intr_pda(new_irq_info);
 
-                /* allocate a new PROM new_irq_info struct */
-                status = sn_intr_alloc(local_nasid, local_widget,
-                                       __pa(new_irq_info), irq,
-                                       cpuid_to_nasid(cpuid),
-                                       cpuid_to_slice(cpuid));
+        /* allocate a new PROM new_irq_info struct */
+        status = sn_intr_alloc(local_nasid, local_widget,
+                               new_irq_info, vector,
+                               nasid, slice);
 
-                /* SAL call failed */
-                if (status) {
-                        kfree(new_irq_info);
-                        break;
-                }
+        /* SAL call failed */
+        if (status) {
+                kfree(new_irq_info);
+                return NULL;
+        }
 
-                new_irq_info->irq_cpuid = cpuid;
-                register_intr_pda(new_irq_info);
+        cpuphys = nasid_slice_to_cpuid(nasid, slice);
+        new_irq_info->irq_cpuid = cpuphys;
+        register_intr_pda(new_irq_info);
 
-                pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
-                if (pci_provider && pci_provider->target_interrupt)
-                        (pci_provider->target_interrupt)(new_irq_info);
+        pci_provider = sn_pci_provider[new_irq_info->irq_bridge_type];
 
-                spin_lock(&sn_irq_info_lock);
-                list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
-                spin_unlock(&sn_irq_info_lock);
-                call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
+        /*
+         * If this represents a line interrupt, target it.  If it's
+         * an msi (irq_int_bit < 0), it's already targeted.
+         */
+        if (new_irq_info->irq_int_bit >= 0 &&
+            pci_provider && pci_provider->target_interrupt)
+                (pci_provider->target_interrupt)(new_irq_info);
+
+        spin_lock(&sn_irq_info_lock);
+        list_replace_rcu(&sn_irq_info->list, &new_irq_info->list);
+        spin_unlock(&sn_irq_info_lock);
+        call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
 
 #ifdef CONFIG_SMP
-                set_irq_affinity_info((irq & 0xff), cpuphys, 0);
+        set_irq_affinity_info((vector & 0xff), cpuphys, 0);
 #endif
-        }
+
+        return new_irq_info;
+}
+
+static void sn_set_affinity_irq(unsigned int irq, cpumask_t mask)
+{
+        struct sn_irq_info *sn_irq_info, *sn_irq_info_safe;
+        nasid_t nasid;
+        int slice;
+
+        nasid = cpuid_to_nasid(first_cpu(mask));
+        slice = cpuid_to_slice(first_cpu(mask));
+
+        list_for_each_entry_safe(sn_irq_info, sn_irq_info_safe,
+                                 sn_irq_lh[irq], list)
+                (void)sn_retarget_vector(sn_irq_info, nasid, slice);
 }
 
 struct hw_interrupt_type irq_type_sn = {
@@ -202,6 +221,9 @@ void sn_irq_init(void)
         int i;
         irq_desc_t *base_desc = irq_desc;
 
+        ia64_first_device_vector = IA64_SN2_FIRST_DEVICE_VECTOR;
+        ia64_last_device_vector = IA64_SN2_LAST_DEVICE_VECTOR;
+
         for (i = 0; i < NR_IRQS; i++) {
                 if (base_desc[i].handler == &no_irq_type) {
                         base_desc[i].handler = &irq_type_sn;
@@ -285,6 +307,7 @@ void sn_irq_fixup(struct pci_dev *pci_dev, struct sn_irq_info *sn_irq_info)
         /* link it into the sn_irq[irq] list */
         spin_lock(&sn_irq_info_lock);
         list_add_rcu(&sn_irq_info->list, sn_irq_lh[sn_irq_info->irq_irq]);
+        reserve_irq_vector(sn_irq_info->irq_irq);
         spin_unlock(&sn_irq_info_lock);
 
         register_intr_pda(sn_irq_info);
@@ -310,8 +333,11 @@ void sn_irq_unfixup(struct pci_dev *pci_dev)
         spin_lock(&sn_irq_info_lock);
         list_del_rcu(&sn_irq_info->list);
         spin_unlock(&sn_irq_info_lock);
+        if (list_empty(sn_irq_lh[sn_irq_info->irq_irq]))
+                free_irq_vector(sn_irq_info->irq_irq);
         call_rcu(&sn_irq_info->rcu, sn_irq_info_free);
         pci_dev_put(pci_dev);
+
 }
 
 static inline void
diff --git a/arch/ia64/sn/pci/pci_dma.c b/arch/ia64/sn/pci/pci_dma.c
index b4b84c269210..7a291a271511 100644
--- a/arch/ia64/sn/pci/pci_dma.c
+++ b/arch/ia64/sn/pci/pci_dma.c
@@ -11,7 +11,7 @@
 
 #include <linux/module.h>
 #include <asm/dma.h>
-#include <asm/sn/pcibr_provider.h>
+#include <asm/sn/intr.h>
 #include <asm/sn/pcibus_provider_defs.h>
 #include <asm/sn/pcidev.h>
 #include <asm/sn/sn_sal.h>
@@ -113,7 +113,8 @@ void *sn_dma_alloc_coherent(struct device *dev, size_t size,
          * resources.
          */
 
-        *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size);
+        *dma_handle = provider->dma_map_consistent(pdev, phys_addr, size,
+                                                   SN_DMA_ADDR_PHYS);
         if (!*dma_handle) {
                 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
                 free_pages((unsigned long)cpuaddr, get_order(size));
@@ -176,7 +177,7 @@ dma_addr_t sn_dma_map_single(struct device *dev, void *cpu_addr, size_t size,
         BUG_ON(dev->bus != &pci_bus_type);
 
         phys_addr = __pa(cpu_addr);
-        dma_addr = provider->dma_map(pdev, phys_addr, size);
+        dma_addr = provider->dma_map(pdev, phys_addr, size, SN_DMA_ADDR_PHYS);
         if (!dma_addr) {
                 printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
                 return 0;
@@ -260,7 +261,8 @@ int sn_dma_map_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
         for (i = 0; i < nhwentries; i++, sg++) {
                 phys_addr = SG_ENT_PHYS_ADDRESS(sg);
                 sg->dma_address = provider->dma_map(pdev,
-                                                    phys_addr, sg->length);
+                                                    phys_addr, sg->length,
+                                                    SN_DMA_ADDR_PHYS);
 
                 if (!sg->dma_address) {
                         printk(KERN_ERR "%s: out of ATEs\n", __FUNCTION__);
diff --git a/arch/ia64/sn/pci/pcibr/pcibr_dma.c b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
index 9f86bb6519aa..a86c7b945962 100644
--- a/arch/ia64/sn/pci/pcibr/pcibr_dma.c
+++ b/arch/ia64/sn/pci/pcibr/pcibr_dma.c
@@ -41,7 +41,7 @@ extern int sn_ioif_inited;
 
 static dma_addr_t
 pcibr_dmamap_ate32(struct pcidev_info *info,
-                   u64 paddr, size_t req_size, u64 flags)
+                   u64 paddr, size_t req_size, u64 flags, int dma_flags)
 {
 
         struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
@@ -81,9 +81,12 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
         if (IS_PCIX(pcibus_info))
                 ate_flags &= ~(PCI32_ATE_PREF);
 
-        xio_addr =
-            IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-            PHYS_TO_TIODMA(paddr);
+        if (SN_DMA_ADDRTYPE(dma_flags == SN_DMA_ADDR_PHYS))
+                xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
+                                                      PHYS_TO_TIODMA(paddr);
+        else
+                xio_addr = paddr;
+
         offset = IOPGOFF(xio_addr);
         ate = ate_flags | (xio_addr - offset);
 
@@ -91,6 +94,13 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
         if (IS_PIC_SOFT(pcibus_info)) {
                 ate |= (pcibus_info->pbi_hub_xid << PIC_ATE_TARGETID_SHFT);
         }
+
+        /*
+         * If we're mapping for MSI, set the MSI bit in the ATE
+         */
+        if (dma_flags & SN_DMA_MSI)
+                ate |= PCI32_ATE_MSI;
+
         ate_write(pcibus_info, ate_index, ate_count, ate);
 
         /*
@@ -105,20 +115,27 @@ pcibr_dmamap_ate32(struct pcidev_info *info,
         if (pcibus_info->pbi_devreg[internal_device] & PCIBR_DEV_SWAP_DIR)
                 ATE_SWAP_ON(pci_addr);
 
+
         return pci_addr;
 }
 
 static dma_addr_t
 pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
-                        u64 dma_attributes)
+                        u64 dma_attributes, int dma_flags)
 {
         struct pcibus_info *pcibus_info = (struct pcibus_info *)
             ((info->pdi_host_pcidev_info)->pdi_pcibus_info);
         u64 pci_addr;
 
         /* Translate to Crosstalk View of Physical Address */
-        pci_addr = (IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-                    PHYS_TO_TIODMA(paddr)) | dma_attributes;
+        if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+                pci_addr = IS_PIC_SOFT(pcibus_info) ?
+                                PHYS_TO_DMA(paddr) :
+                                PHYS_TO_TIODMA(paddr) | dma_attributes;
+        else
+                pci_addr = IS_PIC_SOFT(pcibus_info) ?
+                                paddr :
+                                paddr | dma_attributes;
 
         /* Handle Bus mode */
         if (IS_PCIX(pcibus_info))
@@ -130,7 +147,9 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
                     ((u64) pcibus_info->
                      pbi_hub_xid << PIC_PCI64_ATTR_TARG_SHFT);
         } else
-                pci_addr |= TIOCP_PCI64_CMDTYPE_MEM;
+                pci_addr |= (dma_flags & SN_DMA_MSI) ?
+                                TIOCP_PCI64_CMDTYPE_MSI :
+                                TIOCP_PCI64_CMDTYPE_MEM;
 
         /* If PCI mode, func zero uses VCHAN0, every other func uses VCHAN1 */
         if (!IS_PCIX(pcibus_info) && PCI_FUNC(info->pdi_linux_pcidev->devfn))
@@ -141,7 +160,7 @@ pcibr_dmatrans_direct64(struct pcidev_info * info, u64 paddr,
 
 static dma_addr_t
 pcibr_dmatrans_direct32(struct pcidev_info * info,
-                        u64 paddr, size_t req_size, u64 flags)
+                        u64 paddr, size_t req_size, u64 flags, int dma_flags)
 {
         struct pcidev_info *pcidev_info = info->pdi_host_pcidev_info;
         struct pcibus_info *pcibus_info = (struct pcibus_info *)pcidev_info->
@@ -156,8 +175,14 @@ pcibr_dmatrans_direct32(struct pcidev_info * info,
                 return 0;
         }
 
-        xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
-            PHYS_TO_TIODMA(paddr);
+        if (dma_flags & SN_DMA_MSI)
+                return 0;
+
+        if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+                xio_addr = IS_PIC_SOFT(pcibus_info) ? PHYS_TO_DMA(paddr) :
+                                                      PHYS_TO_TIODMA(paddr);
+        else
+                xio_addr = paddr;
 
         xio_base = pcibus_info->pbi_dir_xbase;
         offset = xio_addr - xio_base;
@@ -327,7 +352,7 @@ void sn_dma_flush(u64 addr)
  */
 
 dma_addr_t
-pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
+pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size, int dma_flags)
 {
         dma_addr_t dma_handle;
         struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(hwdev);
@@ -344,11 +369,11 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
                  */
 
                 dma_handle = pcibr_dmatrans_direct64(pcidev_info, phys_addr,
-                                                     PCI64_ATTR_PREF);
+                                                     PCI64_ATTR_PREF, dma_flags);
         } else {
                 /* Handle 32-63 bit cards via direct mapping */
                 dma_handle = pcibr_dmatrans_direct32(pcidev_info, phys_addr,
-                                                     size, 0);
+                                                     size, 0, dma_flags);
                 if (!dma_handle) {
                         /*
                          * It is a 32 bit card and we cannot do direct mapping,
@@ -356,7 +381,8 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
                          */
 
                         dma_handle = pcibr_dmamap_ate32(pcidev_info, phys_addr,
-                                                        size, PCI32_ATE_PREF);
+                                                        size, PCI32_ATE_PREF,
+                                                        dma_flags);
                 }
         }
 
@@ -365,18 +391,18 @@ pcibr_dma_map(struct pci_dev * hwdev, unsigned long phys_addr, size_t size)
 
 dma_addr_t
 pcibr_dma_map_consistent(struct pci_dev * hwdev, unsigned long phys_addr,
-                         size_t size)
+                         size_t size, int dma_flags)
 {
         dma_addr_t dma_handle;
         struct pcidev_info *pcidev_info = SN_PCIDEV_INFO(hwdev);
 
         if (hwdev->dev.coherent_dma_mask == ~0UL) {
                 dma_handle = pcibr_dmatrans_direct64(pcidev_info, phys_addr,
-                                            PCI64_ATTR_BAR);
+                                            PCI64_ATTR_BAR, dma_flags);
         } else {
                 dma_handle = (dma_addr_t) pcibr_dmamap_ate32(pcidev_info,
                                                     phys_addr, size,
-                                                    PCI32_ATE_BAR);
+                                                    PCI32_ATE_BAR, dma_flags);
         }
 
         return dma_handle;
diff --git a/arch/ia64/sn/pci/tioca_provider.c b/arch/ia64/sn/pci/tioca_provider.c
index be0176912968..20de72791b97 100644
--- a/arch/ia64/sn/pci/tioca_provider.c
+++ b/arch/ia64/sn/pci/tioca_provider.c
@@ -515,11 +515,17 @@ tioca_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  * use the GART mapped mode.
  */
 static u64
-tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioca_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
         u64 mapaddr;
 
         /*
+         * Not supported for now ...
+         */
+        if (dma_flags & SN_DMA_MSI)
+                return 0;
+
+        /*
          * If card is 64 or 48 bit addresable, use a direct mapping.  32
          * bit direct is so restrictive w.r.t. where the memory resides that
          * we don't use it even though CA has some support.
diff --git a/arch/ia64/sn/pci/tioce_provider.c b/arch/ia64/sn/pci/tioce_provider.c
index 833295624e5d..4cac7bdc7c7f 100644
--- a/arch/ia64/sn/pci/tioce_provider.c
+++ b/arch/ia64/sn/pci/tioce_provider.c
@@ -170,7 +170,8 @@ tioce_mmr_war_post(struct tioce_kernel *kern, void *mmr_addr)
         (ATE_PAGE((start)+(len)-1, pagesize) - ATE_PAGE(start, pagesize) + 1)
 
 #define ATE_VALID(ate)  ((ate) & (1UL << 63))
-#define ATE_MAKE(addr, ps) (((addr) & ~ATE_PAGEMASK(ps)) | (1UL << 63))
+#define ATE_MAKE(addr, ps, msi) \
+        (((addr) & ~ATE_PAGEMASK(ps)) | (1UL << 63) | ((msi)?(1UL << 62):0))
 
 /*
  * Flavors of ate-based mapping supported by tioce_alloc_map()
@@ -196,15 +197,17 @@ tioce_mmr_war_post(struct tioce_kernel *kern, void *mmr_addr)
  *
  * 63    - must be 1 to indicate d64 mode to CE hardware
  * 62    - barrier bit ... controlled with tioce_dma_barrier()
- * 61    - 0 since this is not an MSI transaction
+ * 61    - msi bit ... specified through dma_flags
  * 60:54 - reserved, MBZ
  */
 static u64
-tioce_dma_d64(unsigned long ct_addr)
+tioce_dma_d64(unsigned long ct_addr, int dma_flags)
 {
         u64 bus_addr;
 
         bus_addr = ct_addr | (1UL << 63);
+        if (dma_flags & SN_DMA_MSI)
+                bus_addr |= (1UL << 61);
 
         return bus_addr;
 }
@@ -261,7 +264,7 @@ pcidev_to_tioce(struct pci_dev *pdev, struct tioce **base,
  */
 static u64
 tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
-                u64 ct_addr, int len)
+                u64 ct_addr, int len, int dma_flags)
 {
         int i;
         int j;
@@ -270,6 +273,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
         int entries;
         int nates;
         u64 pagesize;
+        int msi_capable, msi_wanted;
         u64 *ate_shadow;
         u64 *ate_reg;
         u64 addr;
@@ -291,6 +295,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                 ate_reg = ce_mmr->ce_ure_ate3240;
                 pagesize = ce_kern->ce_ate3240_pagesize;
                 bus_base = TIOCE_M32_MIN;
+                msi_capable = 1;
                 break;
         case TIOCE_ATE_M40:
                 first = 0;
@@ -299,6 +304,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                 ate_reg = ce_mmr->ce_ure_ate40;
                 pagesize = MB(64);
                 bus_base = TIOCE_M40_MIN;
+                msi_capable = 0;
                 break;
         case TIOCE_ATE_M40S:
                 /*
@@ -311,11 +317,16 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
                 ate_reg = ce_mmr->ce_ure_ate3240;
                 pagesize = GB(16);
                 bus_base = TIOCE_M40S_MIN;
+                msi_capable = 0;
                 break;
         default:
                 return 0;
         }
 
+        msi_wanted = dma_flags & SN_DMA_MSI;
+        if (msi_wanted && !msi_capable)
+                return 0;
+
         nates = ATE_NPAGES(ct_addr, len, pagesize);
         if (nates > entries)
                 return 0;
@@ -344,7 +355,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
         for (j = 0; j < nates; j++) {
                 u64 ate;
 
-                ate = ATE_MAKE(addr, pagesize);
+                ate = ATE_MAKE(addr, pagesize, msi_wanted);
                 ate_shadow[i + j] = ate;
                 tioce_mmr_storei(ce_kern, &ate_reg[i + j], ate);
                 addr += pagesize;
@@ -371,7 +382,7 @@ tioce_alloc_map(struct tioce_kernel *ce_kern, int type, int port,
  * Map @paddr into 32-bit bus space of the CE associated with @pcidev_info.
  */
 static u64
-tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
+tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr, int dma_flags)
 {
         int dma_ok;
         int port;
@@ -381,6 +392,9 @@ tioce_dma_d32(struct pci_dev *pdev, u64 ct_addr)
         u64 ct_lower;
         dma_addr_t bus_addr;
 
+        if (dma_flags & SN_DMA_MSI)
+                return 0;
+
         ct_upper = ct_addr & ~0x3fffffffUL;
         ct_lower = ct_addr & 0x3fffffffUL;
 
@@ -507,7 +521,7 @@ tioce_dma_unmap(struct pci_dev *pdev, dma_addr_t bus_addr, int dir)
  */
 static u64
 tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
-                 int barrier)
+                 int barrier, int dma_flags)
 {
         unsigned long flags;
         u64 ct_addr;
@@ -523,15 +537,18 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
         if (dma_mask < 0x7fffffffUL)
                 return 0;
 
-        ct_addr = PHYS_TO_TIODMA(paddr);
+        if (SN_DMA_ADDRTYPE(dma_flags) == SN_DMA_ADDR_PHYS)
+                ct_addr = PHYS_TO_TIODMA(paddr);
+        else
+                ct_addr = paddr;
 
         /*
          * If the device can generate 64 bit addresses, create a D64 map.
-         * Since this should never fail, bypass the rest of the checks.
          */
         if (dma_mask == ~0UL) {
-                mapaddr = tioce_dma_d64(ct_addr);
-                goto dma_map_done;
+                mapaddr = tioce_dma_d64(ct_addr, dma_flags);
+                if (mapaddr)
+                        goto dma_map_done;
         }
 
         pcidev_to_tioce(pdev, NULL, &ce_kern, &port);
@@ -574,18 +591,22 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
 
                 if (byte_count > MB(64)) {
                         mapaddr = tioce_alloc_map(ce_kern, TIOCE_ATE_M40S,
-                                                  port, ct_addr, byte_count);
+                                                  port, ct_addr, byte_count,
+                                                  dma_flags);
                         if (!mapaddr)
                                 mapaddr =
                                     tioce_alloc_map(ce_kern, TIOCE_ATE_M40, -1,
-                                                    ct_addr, byte_count);
+                                                    ct_addr, byte_count,
+                                                    dma_flags);
                 } else {
                         mapaddr = tioce_alloc_map(ce_kern, TIOCE_ATE_M40, -1,
-                                                  ct_addr, byte_count);
+                                                  ct_addr, byte_count,
+                                                  dma_flags);
                         if (!mapaddr)
                                 mapaddr =
                                     tioce_alloc_map(ce_kern, TIOCE_ATE_M40S,
-                                                    port, ct_addr, byte_count);
+                                                    port, ct_addr, byte_count,
+                                                    dma_flags);
                 }
         }
 
@@ -593,7 +614,7 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
          * 32-bit direct is the next mode to try
          */
         if (!mapaddr && dma_mask >= 0xffffffffUL)
-                mapaddr = tioce_dma_d32(pdev, ct_addr);
+                mapaddr = tioce_dma_d32(pdev, ct_addr, dma_flags);
 
         /*
          * Last resort, try 32-bit ATE-based map.
@@ -601,7 +622,7 @@ tioce_do_dma_map(struct pci_dev *pdev, u64 paddr, size_t byte_count,
         if (!mapaddr)
                 mapaddr =
                     tioce_alloc_map(ce_kern, TIOCE_ATE_M32, -1, ct_addr,
-                                    byte_count);
+                                    byte_count, dma_flags);
 
         spin_unlock_irqrestore(&ce_kern->ce_lock, flags);
 
@@ -622,9 +643,9 @@ dma_map_done:
  * in the address.
  */
 static u64
-tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
-        return tioce_do_dma_map(pdev, paddr, byte_count, 0);
+        return tioce_do_dma_map(pdev, paddr, byte_count, 0, dma_flags);
 }
 
 /**
@@ -636,9 +657,9 @@ tioce_dma(struct pci_dev *pdev, u64 paddr, size_t byte_count)
  * Simply call tioce_do_dma_map() to create a map with the barrier bit set
  * in the address.
  */ static u64
-tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count)
+tioce_dma_consistent(struct pci_dev *pdev, u64 paddr, size_t byte_count, int dma_flags)
 {
-        return tioce_do_dma_map(pdev, paddr, byte_count, 1);
+        return tioce_do_dma_map(pdev, paddr, byte_count, 1, dma_flags);
 }
 
 /**
@@ -696,7 +717,7 @@ tioce_reserve_m32(struct tioce_kernel *ce_kern, u64 base, u64 limit)
         while (ate_index <= last_ate) {
                 u64 ate;
 
-                ate = ATE_MAKE(0xdeadbeef, ps);
+                ate = ATE_MAKE(0xdeadbeef, ps, 0);
                 ce_kern->ce_ate3240_shadow[ate_index] = ate;
                 tioce_mmr_storei(ce_kern, &ce_mmr->ce_ure_ate3240[ate_index],
                                  ate);
diff --git a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
index c9e0aeeca3d8..4368dc3f3c30 100644
--- a/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
+++ b/arch/ppc/platforms/85xx/mpc85xx_cds_common.c
@@ -379,13 +379,12 @@ mpc85xx_cds_pcibios_fixup(void)
                                         PCI_DEVICE_ID_VIA_82C586_2, NULL))) {
                 dev->irq = 10;
                 pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 10);
-                pci_dev_put(dev);
-        }
 
-        if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
+                if ((dev = pci_get_device(PCI_VENDOR_ID_VIA,
                                         PCI_DEVICE_ID_VIA_82C586_2, dev))) {
-                dev->irq = 11;
-                pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                        dev->irq = 11;
+                        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, 11);
+                }
                 pci_dev_put(dev);
         }
 }
diff --git a/arch/x86_64/pci/mmconfig.c b/arch/x86_64/pci/mmconfig.c
index a2060e4d5de6..3c55c76c6fd5 100644
--- a/arch/x86_64/pci/mmconfig.c
+++ b/arch/x86_64/pci/mmconfig.c
@@ -13,7 +13,10 @@
 
 #include "pci.h"
 
-#define MMCONFIG_APER_SIZE (256*1024*1024)
+/* aperture is up to 256MB but BIOS may reserve less */
+#define MMCONFIG_APER_MIN       (2 * 1024*1024)
+#define MMCONFIG_APER_MAX       (256 * 1024*1024)
+
 /* Verify the first 16 busses. We assume that systems with more busses
    get MCFG right. */
 #define MAX_CHECK_BUS 16
@@ -175,9 +178,10 @@ void __init pci_mmcfg_init(void)
                 return;
 
         if (!e820_all_mapped(pci_mmcfg_config[0].base_address,
-                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_SIZE,
+                        pci_mmcfg_config[0].base_address + MMCONFIG_APER_MIN,
                         E820_RESERVED)) {
-                printk(KERN_ERR "PCI: BIOS Bug: MCFG area is not E820-reserved\n");
+                printk(KERN_ERR "PCI: BIOS Bug: MCFG area at %x is not E820-reserved\n",
+                                pci_mmcfg_config[0].base_address);
                 printk(KERN_ERR "PCI: Not using MMCONFIG.\n");
                 return;
         }
@@ -190,7 +194,8 @@ void __init pci_mmcfg_init(void)
         }
         for (i = 0; i < pci_mmcfg_config_num; ++i) {
                 pci_mmcfg_virt[i].cfg = &pci_mmcfg_config[i];
-                pci_mmcfg_virt[i].virt = ioremap_nocache(pci_mmcfg_config[i].base_address, MMCONFIG_APER_SIZE);
+                pci_mmcfg_virt[i].virt = ioremap_nocache(pci_mmcfg_config[i].base_address,
+                                                         MMCONFIG_APER_MAX);
                 if (!pci_mmcfg_virt[i].virt) {
                         printk("PCI: Cannot map mmconfig aperture for segment %d\n",
                                pci_mmcfg_config[i].pci_segment_group_number);