Merge commit 'v2.6.28-rc2' into x86/pci-ioapic-boot-irq-quirks

1 files changed, 172 insertions, 41 deletions

diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index 24c1d3c30186..ae71e11eb3e5 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -24,18 +24,47 @@
 
 #ifdef CONFIG_X86_64
 
+static inline int phys_addr_valid(unsigned long addr)
+{
+        return addr < (1UL << boot_cpu_data.x86_phys_bits);
+}
+
 unsigned long __phys_addr(unsigned long x)
 {
-        if (x >= __START_KERNEL_map)
-                return x - __START_KERNEL_map + phys_base;
-        return x - PAGE_OFFSET;
+        if (x >= __START_KERNEL_map) {
+                x -= __START_KERNEL_map;
+                VIRTUAL_BUG_ON(x >= KERNEL_IMAGE_SIZE);
+                x += phys_base;
+        } else {
+                VIRTUAL_BUG_ON(x < PAGE_OFFSET);
+                x -= PAGE_OFFSET;
+                VIRTUAL_BUG_ON(system_state == SYSTEM_BOOTING ? x > MAXMEM :
+                                        !phys_addr_valid(x));
+        }
+        return x;
 }
 EXPORT_SYMBOL(__phys_addr);
 
-static inline int phys_addr_valid(unsigned long addr)
+bool __virt_addr_valid(unsigned long x)
 {
-        return addr < (1UL << boot_cpu_data.x86_phys_bits);
+        if (x >= __START_KERNEL_map) {
+                x -= __START_KERNEL_map;
+                if (x >= KERNEL_IMAGE_SIZE)
+                        return false;
+                x += phys_base;
+        } else {
+                if (x < PAGE_OFFSET)
+                        return false;
+                x -= PAGE_OFFSET;
+                if (system_state == SYSTEM_BOOTING ?
+                                x > MAXMEM : !phys_addr_valid(x)) {
+                        return false;
+                }
+        }
+
+        return pfn_valid(x >> PAGE_SHIFT);
 }
+EXPORT_SYMBOL(__virt_addr_valid);
 
 #else
 
@@ -44,6 +73,28 @@ static inline int phys_addr_valid(unsigned long addr)
         return 1;
 }
 
+#ifdef CONFIG_DEBUG_VIRTUAL
+unsigned long __phys_addr(unsigned long x)
+{
+        /* VMALLOC_* aren't constants; not available at the boot time */
+        VIRTUAL_BUG_ON(x < PAGE_OFFSET);
+        VIRTUAL_BUG_ON(system_state != SYSTEM_BOOTING &&
+                is_vmalloc_addr((void *) x));
+        return x - PAGE_OFFSET;
+}
+EXPORT_SYMBOL(__phys_addr);
+#endif
+
+bool __virt_addr_valid(unsigned long x)
+{
+        if (x < PAGE_OFFSET)
+                return false;
+        if (system_state != SYSTEM_BOOTING && is_vmalloc_addr((void *) x))
+                return false;
+        return pfn_valid((x - PAGE_OFFSET) >> PAGE_SHIFT);
+}
+EXPORT_SYMBOL(__virt_addr_valid);
+
 #endif
 
 int page_is_ram(unsigned long pagenr)
@@ -83,6 +134,25 @@ int page_is_ram(unsigned long pagenr)
         return 0;
 }
 
+int pagerange_is_ram(unsigned long start, unsigned long end)
+{
+        int ram_page = 0, not_rampage = 0;
+        unsigned long page_nr;
+
+        for (page_nr = (start >> PAGE_SHIFT); page_nr < (end >> PAGE_SHIFT);
+             ++page_nr) {
+                if (page_is_ram(page_nr))
+                        ram_page = 1;
+                else
+                        not_rampage = 1;
+
+                if (ram_page == not_rampage)
+                        return -1;
+        }
+
+        return ram_page;
+}
+
 /*
  * Fix up the linear direct mapping of the kernel to avoid cache attribute
  * conflicts.
@@ -150,6 +220,12 @@ static void __iomem *__ioremap_caller(resource_size_t phys_addr,
                 return (__force void __iomem *)phys_to_virt(phys_addr);
 
         /*
+         * Check if the request spans more than any BAR in the iomem resource
+         * tree.
+         */
+        WARN_ON(iomem_map_sanity_check(phys_addr, size));
+
+        /*
          * Don't allow anybody to remap normal RAM that we're using..
          */
         for (pfn = phys_addr >> PAGE_SHIFT;
@@ -170,7 +246,7 @@ static void __iomem *__ioremap_caller(resource_size_t phys_addr,
         phys_addr &= PAGE_MASK;
         size = PAGE_ALIGN(last_addr+1) - phys_addr;
 
-        retval = reserve_memtype(phys_addr, phys_addr + size,
+        retval = reserve_memtype(phys_addr, (u64)phys_addr + size,
                                                 prot_val, &new_prot_val);
         if (retval) {
                 pr_debug("Warning: reserve_memtype returned %d\n", retval);
@@ -204,16 +280,16 @@ static void __iomem *__ioremap_caller(resource_size_t phys_addr,
         switch (prot_val) {
         case _PAGE_CACHE_UC:
         default:
-                prot = PAGE_KERNEL_NOCACHE;
+                prot = PAGE_KERNEL_IO_NOCACHE;
                 break;
         case _PAGE_CACHE_UC_MINUS:
-                prot = PAGE_KERNEL_UC_MINUS;
+                prot = PAGE_KERNEL_IO_UC_MINUS;
                 break;
         case _PAGE_CACHE_WC:
-                prot = PAGE_KERNEL_WC;
+                prot = PAGE_KERNEL_IO_WC;
                 break;
         case _PAGE_CACHE_WB:
-                prot = PAGE_KERNEL;
+                prot = PAGE_KERNEL_IO;
                 break;
         }
 
@@ -330,6 +406,14 @@ static void __iomem *ioremap_default(resource_size_t phys_addr,
         return (void __iomem *)ret;
 }
 
+void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
+                                unsigned long prot_val)
+{
+        return __ioremap_caller(phys_addr, size, (prot_val & _PAGE_CACHE_MASK),
+                                __builtin_return_address(0));
+}
+EXPORT_SYMBOL(ioremap_prot);
+
 /**
  * iounmap - Free a IO remapping
  * @addr: virtual address from ioremap_*
@@ -413,7 +497,7 @@ void unxlate_dev_mem_ptr(unsigned long phys, void *addr)
         return;
 }
 
-int __initdata early_ioremap_debug;
+static int __initdata early_ioremap_debug;
 
 static int __init early_ioremap_debug_setup(char *str)
 {
@@ -522,12 +606,12 @@ static void __init __early_set_fixmap(enum fixed_addresses idx,
 }
 
 static inline void __init early_set_fixmap(enum fixed_addresses idx,
-                                        unsigned long phys)
+                                           unsigned long phys, pgprot_t prot)
 {
         if (after_paging_init)
-                set_fixmap(idx, phys);
+                __set_fixmap(idx, phys, prot);
         else
-                __early_set_fixmap(idx, phys, PAGE_KERNEL);
+                __early_set_fixmap(idx, phys, prot);
 }
 
 static inline void __init early_clear_fixmap(enum fixed_addresses idx)
@@ -538,37 +622,56 @@ static inline void __init early_clear_fixmap(enum fixed_addresses idx)
                 __early_set_fixmap(idx, 0, __pgprot(0));
 }
 
-
-int __initdata early_ioremap_nested;
-
+static void *prev_map[FIX_BTMAPS_SLOTS] __initdata;
+static unsigned long prev_size[FIX_BTMAPS_SLOTS] __initdata;
 static int __init check_early_ioremap_leak(void)
 {
-        if (!early_ioremap_nested)
-                return 0;
+        int count = 0;
+        int i;
 
-        printk(KERN_WARNING
+        for (i = 0; i < FIX_BTMAPS_SLOTS; i++)
+                if (prev_map[i])
+                        count++;
+
+        if (!count)
+                return 0;
+        WARN(1, KERN_WARNING
                "Debug warning: early ioremap leak of %d areas detected.\n",
-               early_ioremap_nested);
+                count);
         printk(KERN_WARNING
-               "please boot with early_ioremap_debug and report the dmesg.\n");
-        WARN_ON(1);
+                "please boot with early_ioremap_debug and report the dmesg.\n");
 
         return 1;
 }
 late_initcall(check_early_ioremap_leak);
 
-void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
+static void __init *__early_ioremap(unsigned long phys_addr, unsigned long size, pgprot_t prot)
 {
         unsigned long offset, last_addr;
-        unsigned int nrpages, nesting;
+        unsigned int nrpages;
         enum fixed_addresses idx0, idx;
+        int i, slot;
 
         WARN_ON(system_state != SYSTEM_BOOTING);
 
-        nesting = early_ioremap_nested;
+        slot = -1;
+        for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
+                if (!prev_map[i]) {
+                        slot = i;
+                        break;
+                }
+        }
+
+        if (slot < 0) {
+                printk(KERN_INFO "early_iomap(%08lx, %08lx) not found slot\n",
+                         phys_addr, size);
+                WARN_ON(1);
+                return NULL;
+        }
+
         if (early_ioremap_debug) {
                 printk(KERN_INFO "early_ioremap(%08lx, %08lx) [%d] => ",
-                       phys_addr, size, nesting);
+                       phys_addr, size, slot);
                 dump_stack();
         }
 
@@ -579,17 +682,13 @@ void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
                 return NULL;
         }
 
-        if (nesting >= FIX_BTMAPS_NESTING) {
-                WARN_ON(1);
-                return NULL;
-        }
-        early_ioremap_nested++;
+        prev_size[slot] = size;
         /*
          * Mappings have to be page-aligned
          */
         offset = phys_addr & ~PAGE_MASK;
         phys_addr &= PAGE_MASK;
-        size = PAGE_ALIGN(last_addr) - phys_addr;
+        size = PAGE_ALIGN(last_addr + 1) - phys_addr;
 
         /*
          * Mappings have to fit in the FIX_BTMAP area.
@@ -603,10 +702,10 @@ void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
         /*
          * Ok, go for it..
          */
-        idx0 = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
+        idx0 = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot;
         idx = idx0;
         while (nrpages > 0) {
-                early_set_fixmap(idx, phys_addr);
+                early_set_fixmap(idx, phys_addr, prot);
                 phys_addr += PAGE_SIZE;
                 --idx;
                 --nrpages;
@@ -614,7 +713,20 @@ void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
         if (early_ioremap_debug)
                 printk(KERN_CONT "%08lx + %08lx\n", offset, fix_to_virt(idx0));
 
-        return (void *) (offset + fix_to_virt(idx0));
+        prev_map[slot] = (void *) (offset + fix_to_virt(idx0));
+        return prev_map[slot];
+}
+
+/* Remap an IO device */
+void __init *early_ioremap(unsigned long phys_addr, unsigned long size)
+{
+        return __early_ioremap(phys_addr, size, PAGE_KERNEL_IO);
+}
+
+/* Remap memory */
+void __init *early_memremap(unsigned long phys_addr, unsigned long size)
+{
+        return __early_ioremap(phys_addr, size, PAGE_KERNEL);
 }
 
 void __init early_iounmap(void *addr, unsigned long size)
@@ -623,15 +735,33 @@ void __init early_iounmap(void *addr, unsigned long size)
         unsigned long offset;
         unsigned int nrpages;
         enum fixed_addresses idx;
-        int nesting;
+        int i, slot;
+
+        slot = -1;
+        for (i = 0; i < FIX_BTMAPS_SLOTS; i++) {
+                if (prev_map[i] == addr) {
+                        slot = i;
+                        break;
+                }
+        }
 
-        nesting = --early_ioremap_nested;
-        if (WARN_ON(nesting < 0))
+        if (slot < 0) {
+                printk(KERN_INFO "early_iounmap(%p, %08lx) not found slot\n",
+                         addr, size);
+                WARN_ON(1);
                 return;
+        }
+
+        if (prev_size[slot] != size) {
+                printk(KERN_INFO "early_iounmap(%p, %08lx) [%d] size not consistent %08lx\n",
+                         addr, size, slot, prev_size[slot]);
+                WARN_ON(1);
+                return;
+        }
 
         if (early_ioremap_debug) {
                 printk(KERN_INFO "early_iounmap(%p, %08lx) [%d]\n", addr,
-                       size, nesting);
+                       size, slot);
                 dump_stack();
         }
 
@@ -643,12 +773,13 @@ void __init early_iounmap(void *addr, unsigned long size)
         offset = virt_addr & ~PAGE_MASK;
         nrpages = PAGE_ALIGN(offset + size - 1) >> PAGE_SHIFT;
 
-        idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*nesting;
+        idx = FIX_BTMAP_BEGIN - NR_FIX_BTMAPS*slot;
         while (nrpages > 0) {
                 early_clear_fixmap(idx);
                 --idx;
                 --nrpages;
         }
+        prev_map[slot] = 0;
 }
 
 void __this_fixmap_does_not_exist(void)