12 files changed, 162 insertions, 160 deletions

diff --git a/arch/ia64/pci/fixup.c b/arch/ia64/pci/fixup.c
index fc505d58f078..41caa99add51 100644
--- a/arch/ia64/pci/fixup.c
+++ b/arch/ia64/pci/fixup.c
@@ -17,14 +17,14 @@
  *
  * The standard boot ROM sequence for an x86 machine uses the BIOS
  * to select an initial video card for boot display. This boot video
- * card will have it's BIOS copied to C0000 in system RAM.
+ * card will have its BIOS copied to 0xC0000 in system RAM.
  * IORESOURCE_ROM_SHADOW is used to associate the boot video
  * card with this copy. On laptops this copy has to be used since
  * the main ROM may be compressed or combined with another image.
  * See pci_map_rom() for use of this flag. Before marking the device
  * with IORESOURCE_ROM_SHADOW check if a vga_default_device is already set
- * by either arch cde or vga-arbitration, if so only apply the fixup to this
- * already determined primary video card.
+ * by either arch code or vga-arbitration; if so only apply the fixup to this
+ * already-determined primary video card.
  */
 
 static void pci_fixup_video(struct pci_dev *pdev)
@@ -32,6 +32,7 @@ static void pci_fixup_video(struct pci_dev *pdev)
         struct pci_dev *bridge;
         struct pci_bus *bus;
         u16 config;
+        struct resource *res;
 
         if ((strcmp(ia64_platform_name, "dig") != 0)
             && (strcmp(ia64_platform_name, "hpzx1")  != 0))
@@ -61,8 +62,18 @@ static void pci_fixup_video(struct pci_dev *pdev)
         if (!vga_default_device() || pdev == vga_default_device()) {
                 pci_read_config_word(pdev, PCI_COMMAND, &config);
                 if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
-                        pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW;
-                        dev_printk(KERN_DEBUG, &pdev->dev, "Video device with shadowed ROM\n");
+                        res = &pdev->resource[PCI_ROM_RESOURCE];
+
+                        pci_disable_rom(pdev);
+                        if (res->parent)
+                                release_resource(res);
+
+                        res->start = 0xC0000;
+                        res->end = res->start + 0x20000 - 1;
+                        res->flags = IORESOURCE_MEM | IORESOURCE_ROM_SHADOW |
+                                     IORESOURCE_PCI_FIXED;
+                        dev_info(&pdev->dev, "Video device with shadowed ROM at %pR\n",
+                                 res);
                 }
         }
 }
diff --git a/arch/ia64/sn/kernel/io_acpi_init.c b/arch/ia64/sn/kernel/io_acpi_init.c
index 0640739cc20c..231234c8d113 100644
--- a/arch/ia64/sn/kernel/io_acpi_init.c
+++ b/arch/ia64/sn/kernel/io_acpi_init.c
@@ -429,7 +429,8 @@ sn_acpi_slot_fixup(struct pci_dev *dev)
         void __iomem *addr;
         struct pcidev_info *pcidev_info = NULL;
         struct sn_irq_info *sn_irq_info = NULL;
-        size_t image_size, size;
+        struct resource *res;
+        size_t size;
 
         if (sn_acpi_get_pcidev_info(dev, &pcidev_info, &sn_irq_info)) {
                 panic("%s:  Failure obtaining pcidev_info for %s\n",
@@ -443,17 +444,20 @@ sn_acpi_slot_fixup(struct pci_dev *dev)
                  * of the shadowed copy, and the actual length of the ROM image.
                  */
                 size = pci_resource_len(dev, PCI_ROM_RESOURCE);
-                addr = ioremap(pcidev_info->pdi_pio_mapped_addr[PCI_ROM_RESOURCE],
-                               size);
-                image_size = pci_get_rom_size(dev, addr, size);
-                dev->resource[PCI_ROM_RESOURCE].start = (unsigned long) addr;
-                dev->resource[PCI_ROM_RESOURCE].end =
-                                        (unsigned long) addr + image_size - 1;
-                dev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_BIOS_COPY;
+
+                res = &dev->resource[PCI_ROM_RESOURCE];
+
+                pci_disable_rom(dev);
+                if (res->parent)
+                        release_resource(res);
+
+                res->start = pcidev_info->pdi_pio_mapped_addr[PCI_ROM_RESOURCE];
+                res->end = res->start + size - 1;
+                res->flags = IORESOURCE_MEM | IORESOURCE_ROM_SHADOW |
+                             IORESOURCE_PCI_FIXED;
         }
         sn_pci_fixup_slot(dev, pcidev_info, sn_irq_info);
 }
-
 EXPORT_SYMBOL(sn_acpi_slot_fixup);
 
 
diff --git a/arch/ia64/sn/kernel/io_init.c b/arch/ia64/sn/kernel/io_init.c
index 1be65eb074ec..c15a41e2d1f2 100644
--- a/arch/ia64/sn/kernel/io_init.c
+++ b/arch/ia64/sn/kernel/io_init.c
@@ -150,7 +150,8 @@ void
 sn_io_slot_fixup(struct pci_dev *dev)
 {
         int idx;
-        unsigned long addr, end, size, start;
+        struct resource *res;
+        unsigned long addr, size;
         struct pcidev_info *pcidev_info;
         struct sn_irq_info *sn_irq_info;
         int status;
@@ -175,55 +176,41 @@ sn_io_slot_fixup(struct pci_dev *dev)
 
         /* Copy over PIO Mapped Addresses */
         for (idx = 0; idx <= PCI_ROM_RESOURCE; idx++) {
-
-                if (!pcidev_info->pdi_pio_mapped_addr[idx]) {
+                if (!pcidev_info->pdi_pio_mapped_addr[idx])
                         continue;
-                }
 
-                start = dev->resource[idx].start;
-                end = dev->resource[idx].end;
-                size = end - start;
-                if (size == 0) {
+                res = &dev->resource[idx];
+
+                size = res->end - res->start;
+                if (size == 0)
                         continue;
-                }
-                addr = pcidev_info->pdi_pio_mapped_addr[idx];
-                addr = ((addr << 4) >> 4) | __IA64_UNCACHED_OFFSET;
-                dev->resource[idx].start = addr;
-                dev->resource[idx].end = addr + size;
+
+                res->start = pcidev_info->pdi_pio_mapped_addr[idx];
+                res->end = addr + size;
 
                 /*
                  * if it's already in the device structure, remove it before
                  * inserting
                  */
-                if (dev->resource[idx].parent && dev->resource[idx].parent->child)
-                        release_resource(&dev->resource[idx]);
+                if (res->parent && res->parent->child)
+                        release_resource(res);
 
-                if (dev->resource[idx].flags & IORESOURCE_IO)
-                        insert_resource(&ioport_resource, &dev->resource[idx]);
+                if (res->flags & IORESOURCE_IO)
+                        insert_resource(&ioport_resource, res);
                 else
-                        insert_resource(&iomem_resource, &dev->resource[idx]);
+                        insert_resource(&iomem_resource, res);
                 /*
-                 * If ROM, set the actual ROM image size, and mark as
-                 * shadowed in PROM.
+                 * If ROM, mark as shadowed in PROM.
                  */
                 if (idx == PCI_ROM_RESOURCE) {
-                        size_t image_size;
-                        void __iomem *rom;
-
-                        rom = ioremap(pci_resource_start(dev, PCI_ROM_RESOURCE),
-                                      size + 1);
-                        image_size = pci_get_rom_size(dev, rom, size + 1);
-                        dev->resource[PCI_ROM_RESOURCE].end =
-                                dev->resource[PCI_ROM_RESOURCE].start +
-                                image_size - 1;
-                        dev->resource[PCI_ROM_RESOURCE].flags |=
-                                                 IORESOURCE_ROM_BIOS_COPY;
+                        pci_disable_rom(dev);
+                        res->flags = IORESOURCE_MEM | IORESOURCE_ROM_SHADOW |
+                                     IORESOURCE_PCI_FIXED;
                 }
         }
 
         sn_pci_fixup_slot(dev, pcidev_info, sn_irq_info);
 }
-
 EXPORT_SYMBOL(sn_io_slot_fixup);
 
 /*
diff --git a/arch/mips/pci/fixup-loongson3.c b/arch/mips/pci/fixup-loongson3.c
index d708ae46d325..2b6d5e196f99 100644
--- a/arch/mips/pci/fixup-loongson3.c
+++ b/arch/mips/pci/fixup-loongson3.c
@@ -40,20 +40,25 @@ int __init pcibios_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
 
 static void pci_fixup_radeon(struct pci_dev *pdev)
 {
-        if (pdev->resource[PCI_ROM_RESOURCE].start)
+        struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
+
+        if (res->start)
                 return;
 
         if (!loongson_sysconf.vgabios_addr)
                 return;
 
-        pdev->resource[PCI_ROM_RESOURCE].start =
-                loongson_sysconf.vgabios_addr;
-        pdev->resource[PCI_ROM_RESOURCE].end   =
-                loongson_sysconf.vgabios_addr + 256*1024 - 1;
-        pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_COPY;
+        pci_disable_rom(pdev);
+        if (res->parent)
+                release_resource(res);
+
+        res->start = virt_to_phys((void *) loongson_sysconf.vgabios_addr);
+        res->end   = res->start + 256*1024 - 1;
+        res->flags = IORESOURCE_MEM | IORESOURCE_ROM_SHADOW |
+                     IORESOURCE_PCI_FIXED;
 
         dev_info(&pdev->dev, "BAR %d: assigned %pR for Radeon ROM\n",
-                        PCI_ROM_RESOURCE, &pdev->resource[PCI_ROM_RESOURCE]);
+                 PCI_ROM_RESOURCE, res);
 }
 
 DECLARE_PCI_FIXUP_CLASS_FINAL(PCI_VENDOR_ID_ATI, PCI_ANY_ID,
diff --git a/arch/x86/pci/fixup.c b/arch/x86/pci/fixup.c
index e58565556703..b7de1929714b 100644
--- a/arch/x86/pci/fixup.c
+++ b/arch/x86/pci/fixup.c
@@ -297,14 +297,14 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL,	PCI_DEVICE_ID_INTEL_MCH_PC1,	pcie_r
  *
  * The standard boot ROM sequence for an x86 machine uses the BIOS
  * to select an initial video card for boot display. This boot video
- * card will have it's BIOS copied to C0000 in system RAM.
+ * card will have its BIOS copied to 0xC0000 in system RAM.
  * IORESOURCE_ROM_SHADOW is used to associate the boot video
  * card with this copy. On laptops this copy has to be used since
  * the main ROM may be compressed or combined with another image.
  * See pci_map_rom() for use of this flag. Before marking the device
  * with IORESOURCE_ROM_SHADOW check if a vga_default_device is already set
- * by either arch cde or vga-arbitration, if so only apply the fixup to this
- * already determined primary video card.
+ * by either arch code or vga-arbitration; if so only apply the fixup to this
+ * already-determined primary video card.
  */
 
 static void pci_fixup_video(struct pci_dev *pdev)
@@ -312,6 +312,7 @@ static void pci_fixup_video(struct pci_dev *pdev)
         struct pci_dev *bridge;
         struct pci_bus *bus;
         u16 config;
+        struct resource *res;
 
         /* Is VGA routed to us? */
         bus = pdev->bus;
@@ -336,8 +337,18 @@ static void pci_fixup_video(struct pci_dev *pdev)
         if (!vga_default_device() || pdev == vga_default_device()) {
                 pci_read_config_word(pdev, PCI_COMMAND, &config);
                 if (config & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
-                        pdev->resource[PCI_ROM_RESOURCE].flags |= IORESOURCE_ROM_SHADOW;
-                        dev_printk(KERN_DEBUG, &pdev->dev, "Video device with shadowed ROM\n");
+                        res = &pdev->resource[PCI_ROM_RESOURCE];
+
+                        pci_disable_rom(pdev);
+                        if (res->parent)
+                                release_resource(res);
+
+                        res->start = 0xC0000;
+                        res->end = res->start + 0x20000 - 1;
+                        res->flags = IORESOURCE_MEM | IORESOURCE_ROM_SHADOW |
+                                     IORESOURCE_PCI_FIXED;
+                        dev_info(&pdev->dev, "Video device with shadowed ROM at %pR\n",
+                                 res);
                 }
         }
 }
@@ -540,3 +551,10 @@ static void twinhead_reserve_killing_zone(struct pci_dev *dev)
         }
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_INTEL, 0x27B9, twinhead_reserve_killing_zone);
+
+static void pci_bdwep_bar(struct pci_dev *dev)
+{
+        dev->non_compliant_bars = 1;
+}
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fa0, pci_bdwep_bar);
+DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_INTEL, 0x6fc0, pci_bdwep_bar);
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index ed39c093aa15..e982010f0ed1 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -1138,33 +1138,36 @@ static int pci_create_attr(struct pci_dev *pdev, int num, int write_combine)
         /* allocate attribute structure, piggyback attribute name */
         int name_len = write_combine ? 13 : 10;
         struct bin_attribute *res_attr;
+        char *res_attr_name;
         int retval;
 
         res_attr = kzalloc(sizeof(*res_attr) + name_len, GFP_ATOMIC);
-        if (res_attr) {
-                char *res_attr_name = (char *)(res_attr + 1);
-
-                sysfs_bin_attr_init(res_attr);
-                if (write_combine) {
-                        pdev->res_attr_wc[num] = res_attr;
-                        sprintf(res_attr_name, "resource%d_wc", num);
-                        res_attr->mmap = pci_mmap_resource_wc;
-                } else {
-                        pdev->res_attr[num] = res_attr;
-                        sprintf(res_attr_name, "resource%d", num);
-                        res_attr->mmap = pci_mmap_resource_uc;
-                }
-                if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
-                        res_attr->read = pci_read_resource_io;
-                        res_attr->write = pci_write_resource_io;
-                }
-                res_attr->attr.name = res_attr_name;
-                res_attr->attr.mode = S_IRUSR | S_IWUSR;
-                res_attr->size = pci_resource_len(pdev, num);
-                res_attr->private = &pdev->resource[num];
-                retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
-        } else
-                retval = -ENOMEM;
+        if (!res_attr)
+                return -ENOMEM;
+
+        res_attr_name = (char *)(res_attr + 1);
+
+        sysfs_bin_attr_init(res_attr);
+        if (write_combine) {
+                pdev->res_attr_wc[num] = res_attr;
+                sprintf(res_attr_name, "resource%d_wc", num);
+                res_attr->mmap = pci_mmap_resource_wc;
+        } else {
+                pdev->res_attr[num] = res_attr;
+                sprintf(res_attr_name, "resource%d", num);
+                res_attr->mmap = pci_mmap_resource_uc;
+        }
+        if (pci_resource_flags(pdev, num) & IORESOURCE_IO) {
+                res_attr->read = pci_read_resource_io;
+                res_attr->write = pci_write_resource_io;
+        }
+        res_attr->attr.name = res_attr_name;
+        res_attr->attr.mode = S_IRUSR | S_IWUSR;
+        res_attr->size = pci_resource_len(pdev, num);
+        res_attr->private = &pdev->resource[num];
+        retval = sysfs_create_bin_file(&pdev->dev.kobj, res_attr);
+        if (retval)
+                kfree(res_attr);
 
         return retval;
 }
@@ -1360,7 +1363,7 @@ error:
 int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev)
 {
         int retval;
-        int rom_size = 0;
+        int rom_size;
         struct bin_attribute *attr;
 
         if (!sysfs_initialized)
@@ -1377,12 +1380,8 @@ int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev)
         if (retval)
                 goto err_config_file;
 
-        if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
-                rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
-        else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
-                rom_size = 0x20000;
-
         /* If the device has a ROM, try to expose it in sysfs. */
+        rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
         if (rom_size) {
                 attr = kzalloc(sizeof(*attr), GFP_ATOMIC);
                 if (!attr) {
@@ -1413,7 +1412,7 @@ int __must_check pci_create_sysfs_dev_files(struct pci_dev *pdev)
         return 0;
 
 err_rom_file:
-        if (rom_size) {
+        if (pdev->rom_attr) {
                 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
                 kfree(pdev->rom_attr);
                 pdev->rom_attr = NULL;
@@ -1451,8 +1450,6 @@ static void pci_remove_capabilities_sysfs(struct pci_dev *dev)
  */
 void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
 {
-        int rom_size = 0;
-
         if (!sysfs_initialized)
                 return;
 
@@ -1465,18 +1462,13 @@ void pci_remove_sysfs_dev_files(struct pci_dev *pdev)
 
         pci_remove_resource_files(pdev);
 
-        if (pci_resource_len(pdev, PCI_ROM_RESOURCE))
-                rom_size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
-        else if (pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW)
-                rom_size = 0x20000;
-
-        if (rom_size && pdev->rom_attr) {
+        if (pdev->rom_attr) {
                 sysfs_remove_bin_file(&pdev->dev.kobj, pdev->rom_attr);
                 kfree(pdev->rom_attr);
+                pdev->rom_attr = NULL;
         }
 
         pci_remove_firmware_label_files(pdev);
-
 }
 
 static int __init pci_sysfs_init(void)
diff --git a/drivers/pci/probe.c b/drivers/pci/probe.c
index c4e1eff8b07c..8004f67c57ec 100644
--- a/drivers/pci/probe.c
+++ b/drivers/pci/probe.c
@@ -179,6 +179,9 @@ int __pci_read_base(struct pci_dev *dev, enum pci_bar_type type,
         u16 orig_cmd;
         struct pci_bus_region region, inverted_region;
 
+        if (dev->non_compliant_bars)
+                return 0;
+
         mask = type ? PCI_ROM_ADDRESS_MASK : ~0;
 
         /* No printks while decoding is disabled! */
@@ -1191,6 +1194,7 @@ static void pci_msi_setup_pci_dev(struct pci_dev *dev)
 int pci_setup_device(struct pci_dev *dev)
 {
         u32 class;
+        u16 cmd;
         u8 hdr_type;
         int pos = 0;
         struct pci_bus_region region;
@@ -1234,6 +1238,16 @@ int pci_setup_device(struct pci_dev *dev)
         /* device class may be changed after fixup */
         class = dev->class >> 8;
 
+        if (dev->non_compliant_bars) {
+                pci_read_config_word(dev, PCI_COMMAND, &cmd);
+                if (cmd & (PCI_COMMAND_IO | PCI_COMMAND_MEMORY)) {
+                        dev_info(&dev->dev, "device has non-compliant BARs; disabling IO/MEM decoding\n");
+                        cmd &= ~PCI_COMMAND_IO;
+                        cmd &= ~PCI_COMMAND_MEMORY;
+                        pci_write_config_word(dev, PCI_COMMAND, cmd);
+                }
+        }
+
         switch (dev->hdr_type) {                    /* header type */
         case PCI_HEADER_TYPE_NORMAL:                /* standard header */
                 if (class == PCI_CLASS_BRIDGE_PCI)
diff --git a/drivers/pci/remove.c b/drivers/pci/remove.c
index d35c7fcde3af..8982026637d5 100644
--- a/drivers/pci/remove.c
+++ b/drivers/pci/remove.c
@@ -7,7 +7,6 @@ static void pci_free_resources(struct pci_dev *dev)
 {
         int i;
 
-        pci_cleanup_rom(dev);
         for (i = 0; i < PCI_NUM_RESOURCES; i++) {
                 struct resource *res = dev->resource + i;
                 if (res->parent)
diff --git a/drivers/pci/rom.c b/drivers/pci/rom.c
index 9eaca39ef38d..06663d391b39 100644
--- a/drivers/pci/rom.c
+++ b/drivers/pci/rom.c
@@ -24,13 +24,17 @@
  */
 int pci_enable_rom(struct pci_dev *pdev)
 {
-        struct resource *res = pdev->resource + PCI_ROM_RESOURCE;
+        struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
         struct pci_bus_region region;
         u32 rom_addr;
 
         if (!res->flags)
                 return -1;
 
+        /* Nothing to enable if we're using a shadow copy in RAM */
+        if (res->flags & IORESOURCE_ROM_SHADOW)
+                return 0;
+
         pcibios_resource_to_bus(pdev->bus, &region, res);
         pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
         rom_addr &= ~PCI_ROM_ADDRESS_MASK;
@@ -49,7 +53,12 @@ EXPORT_SYMBOL_GPL(pci_enable_rom);
  */
 void pci_disable_rom(struct pci_dev *pdev)
 {
+        struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
         u32 rom_addr;
+
+        if (res->flags & IORESOURCE_ROM_SHADOW)
+                return;
+
         pci_read_config_dword(pdev, pdev->rom_base_reg, &rom_addr);
         rom_addr &= ~PCI_ROM_ADDRESS_ENABLE;
         pci_write_config_dword(pdev, pdev->rom_base_reg, rom_addr);
@@ -119,43 +128,23 @@ void __iomem *pci_map_rom(struct pci_dev *pdev, size_t *size)
         loff_t start;
         void __iomem *rom;
 
-        /*
-         * IORESOURCE_ROM_SHADOW set on x86, x86_64 and IA64 supports legacy
-         * memory map if the VGA enable bit of the Bridge Control register is
-         * set for embedded VGA.
-         */
-        if (res->flags & IORESOURCE_ROM_SHADOW) {
-                /* primary video rom always starts here */
-                start = (loff_t)0xC0000;
-                *size = 0x20000; /* cover C000:0 through E000:0 */
-        } else {
-                if (res->flags &
-                        (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY)) {
-                        *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
-                        return (void __iomem *)(unsigned long)
-                                pci_resource_start(pdev, PCI_ROM_RESOURCE);
-                } else {
-                        /* assign the ROM an address if it doesn't have one */
-                        if (res->parent == NULL &&
-                            pci_assign_resource(pdev, PCI_ROM_RESOURCE))
-                                return NULL;
-                        start = pci_resource_start(pdev, PCI_ROM_RESOURCE);
-                        *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
-                        if (*size == 0)
-                                return NULL;
-
-                        /* Enable ROM space decodes */
-                        if (pci_enable_rom(pdev))
-                                return NULL;
-                }
-        }
+        /* assign the ROM an address if it doesn't have one */
+        if (res->parent == NULL && pci_assign_resource(pdev, PCI_ROM_RESOURCE))
+                return NULL;
+
+        start = pci_resource_start(pdev, PCI_ROM_RESOURCE);
+        *size = pci_resource_len(pdev, PCI_ROM_RESOURCE);
+        if (*size == 0)
+                return NULL;
+
+        /* Enable ROM space decodes */
+        if (pci_enable_rom(pdev))
+                return NULL;
 
         rom = ioremap(start, *size);
         if (!rom) {
                 /* restore enable if ioremap fails */
-                if (!(res->flags & (IORESOURCE_ROM_ENABLE |
-                                    IORESOURCE_ROM_SHADOW |
-                                    IORESOURCE_ROM_COPY)))
+                if (!(res->flags & IORESOURCE_ROM_ENABLE))
                         pci_disable_rom(pdev);
                 return NULL;
         }
@@ -181,37 +170,15 @@ void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom)
 {
         struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
 
-        if (res->flags & (IORESOURCE_ROM_COPY | IORESOURCE_ROM_BIOS_COPY))
-                return;
-
         iounmap(rom);
 
-        /* Disable again before continuing, leave enabled if pci=rom */
-        if (!(res->flags & (IORESOURCE_ROM_ENABLE | IORESOURCE_ROM_SHADOW)))
+        /* Disable again before continuing */
+        if (!(res->flags & IORESOURCE_ROM_ENABLE))
                 pci_disable_rom(pdev);
 }
 EXPORT_SYMBOL(pci_unmap_rom);
 
 /**
- * pci_cleanup_rom - free the ROM copy created by pci_map_rom_copy
- * @pdev: pointer to pci device struct
- *
- * Free the copied ROM if we allocated one.
- */
-void pci_cleanup_rom(struct pci_dev *pdev)
-{
-        struct resource *res = &pdev->resource[PCI_ROM_RESOURCE];
-
-        if (res->flags & IORESOURCE_ROM_COPY) {
-                kfree((void *)(unsigned long)res->start);
-                res->flags |= IORESOURCE_UNSET;
-                res->flags &= ~IORESOURCE_ROM_COPY;
-                res->start = 0;
-                res->end = 0;
-        }
-}
-
-/**
  * pci_platform_rom - provides a pointer to any ROM image provided by the
  * platform
  * @pdev: pointer to pci device struct
diff --git a/drivers/pci/setup-res.c b/drivers/pci/setup-res.c
index 604011e047d6..66c4d8f42233 100644
--- a/drivers/pci/setup-res.c
+++ b/drivers/pci/setup-res.c
@@ -276,6 +276,9 @@ int pci_assign_resource(struct pci_dev *dev, int resno)
         resource_size_t align, size;
         int ret;
 
+        if (res->flags & IORESOURCE_PCI_FIXED)
+                return 0;
+
         res->flags |= IORESOURCE_UNSET;
         align = pci_resource_alignment(dev, res);
         if (!align) {
@@ -321,6 +324,9 @@ int pci_reassign_resource(struct pci_dev *dev, int resno, resource_size_t addsiz
         resource_size_t new_size;
         int ret;
 
+        if (res->flags & IORESOURCE_PCI_FIXED)
+                return 0;
+
         flags = res->flags;
         res->flags |= IORESOURCE_UNSET;
         if (!res->parent) {
diff --git a/include/linux/ioport.h b/include/linux/ioport.h
index 24bea087e7af..29a6deb9f054 100644
--- a/include/linux/ioport.h
+++ b/include/linux/ioport.h
@@ -98,9 +98,7 @@ struct resource {
 
 /* PCI ROM control bits (IORESOURCE_BITS) */
 #define IORESOURCE_ROM_ENABLE           (1<<0)  /* ROM is enabled, same as PCI_ROM_ADDRESS_ENABLE */
-#define IORESOURCE_ROM_SHADOW           (1<<1)  /* ROM is copy at C000:0 */
-#define IORESOURCE_ROM_COPY             (1<<2)  /* ROM is alloc'd copy, resource field overlaid */
-#define IORESOURCE_ROM_BIOS_COPY        (1<<3)  /* ROM is BIOS copy, resource field overlaid */
+#define IORESOURCE_ROM_SHADOW           (1<<1)  /* Use RAM image, not ROM BAR */
 
 /* PCI control bits.  Shares IORESOURCE_BITS with above PCI ROM.  */
 #define IORESOURCE_PCI_FIXED            (1<<4)  /* Do not move resource */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index bd757f3c721c..15f466e52d0d 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -353,6 +353,7 @@ struct pci_dev {
         unsigned int    io_window_1k:1; /* Intel P2P bridge 1K I/O windows */
         unsigned int    irq_managed:1;
         unsigned int    has_secondary_link:1;
+        unsigned int    non_compliant_bars:1;   /* broken BARs; ignore them */
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */