2005-09-26 10:04:21 +04:00
|
|
|
/*
|
|
|
|
* This file contains ioremap and related functions for 64-bit machines.
|
|
|
|
*
|
|
|
|
* Derived from arch/ppc64/mm/init.c
|
|
|
|
* Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org)
|
|
|
|
*
|
|
|
|
* Modifications by Paul Mackerras (PowerMac) (paulus@samba.org)
|
|
|
|
* and Cort Dougan (PReP) (cort@cs.nmt.edu)
|
|
|
|
* Copyright (C) 1996 Paul Mackerras
|
|
|
|
*
|
|
|
|
* Derived from "arch/i386/mm/init.c"
|
|
|
|
* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
|
|
|
|
*
|
|
|
|
* Dave Engebretsen <engebret@us.ibm.com>
|
|
|
|
* Rework for PPC64 port.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/signal.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/string.h>
|
2011-05-27 18:46:24 +04:00
|
|
|
#include <linux/export.h>
|
2005-09-26 10:04:21 +04:00
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/mman.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/stddef.h>
|
|
|
|
#include <linux/vmalloc.h>
|
2010-07-12 08:36:09 +04:00
|
|
|
#include <linux/memblock.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 11:04:11 +03:00
|
|
|
#include <linux/slab.h>
|
2014-11-05 19:27:39 +03:00
|
|
|
#include <linux/hugetlb.h>
|
2005-09-26 10:04:21 +04:00
|
|
|
|
|
|
|
#include <asm/pgalloc.h>
|
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/prom.h>
|
|
|
|
#include <asm/io.h>
|
|
|
|
#include <asm/mmu_context.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/mmu.h>
|
|
|
|
#include <asm/smp.h>
|
|
|
|
#include <asm/machdep.h>
|
|
|
|
#include <asm/tlb.h>
|
|
|
|
#include <asm/processor.h>
|
|
|
|
#include <asm/cputable.h>
|
|
|
|
#include <asm/sections.h>
|
2006-09-25 07:36:31 +04:00
|
|
|
#include <asm/firmware.h>
|
2014-09-17 16:15:35 +04:00
|
|
|
#include <asm/dma.h>
|
2005-11-16 07:43:48 +03:00
|
|
|
|
|
|
|
#include "mmu_decl.h"
|
2005-09-26 10:04:21 +04:00
|
|
|
|
2014-08-13 11:02:04 +04:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/thp.h>
|
|
|
|
|
2012-09-10 06:52:57 +04:00
|
|
|
#ifdef CONFIG_PPC_STD_MMU_64
|
2013-03-13 07:34:55 +04:00
|
|
|
#if TASK_SIZE_USER64 > (1UL << (ESID_BITS + SID_SHIFT))
|
2012-09-10 06:52:57 +04:00
|
|
|
#error TASK_SIZE_USER64 exceeds user VSID range
|
|
|
|
#endif
|
|
|
|
#endif
|
2005-09-26 10:04:21 +04:00
|
|
|
|
2016-04-29 16:25:43 +03:00
|
|
|
#ifdef CONFIG_PPC_BOOK3S_64
|
|
|
|
/*
|
|
|
|
* partition table and process table for ISA 3.0
|
|
|
|
*/
|
|
|
|
struct prtb_entry *process_tb;
|
|
|
|
struct patb_entry *partition_tb;
|
2016-04-29 16:25:49 +03:00
|
|
|
/*
|
|
|
|
* page table size
|
|
|
|
*/
|
|
|
|
unsigned long __pte_index_size;
|
|
|
|
EXPORT_SYMBOL(__pte_index_size);
|
|
|
|
unsigned long __pmd_index_size;
|
|
|
|
EXPORT_SYMBOL(__pmd_index_size);
|
|
|
|
unsigned long __pud_index_size;
|
|
|
|
EXPORT_SYMBOL(__pud_index_size);
|
|
|
|
unsigned long __pgd_index_size;
|
|
|
|
EXPORT_SYMBOL(__pgd_index_size);
|
|
|
|
unsigned long __pmd_cache_index;
|
|
|
|
EXPORT_SYMBOL(__pmd_cache_index);
|
|
|
|
unsigned long __pte_table_size;
|
|
|
|
EXPORT_SYMBOL(__pte_table_size);
|
|
|
|
unsigned long __pmd_table_size;
|
|
|
|
EXPORT_SYMBOL(__pmd_table_size);
|
|
|
|
unsigned long __pud_table_size;
|
|
|
|
EXPORT_SYMBOL(__pud_table_size);
|
|
|
|
unsigned long __pgd_table_size;
|
|
|
|
EXPORT_SYMBOL(__pgd_table_size);
|
|
|
|
|
2016-04-29 16:25:43 +03:00
|
|
|
#endif
|
2012-09-10 06:52:57 +04:00
|
|
|
unsigned long ioremap_bot = IOREMAP_BASE;
|
2009-07-24 03:15:16 +04:00
|
|
|
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
/**
|
|
|
|
* __ioremap_at - Low level function to establish the page tables
|
|
|
|
* for an IO mapping
|
|
|
|
*/
|
|
|
|
void __iomem * __ioremap_at(phys_addr_t pa, void *ea, unsigned long size,
|
2005-09-26 10:04:21 +04:00
|
|
|
unsigned long flags)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
|
|
|
|
2008-07-24 08:27:08 +04:00
|
|
|
/* Make sure we have the base flags */
|
2005-09-26 10:04:21 +04:00
|
|
|
if ((flags & _PAGE_PRESENT) == 0)
|
|
|
|
flags |= pgprot_val(PAGE_KERNEL);
|
|
|
|
|
2008-07-24 08:27:08 +04:00
|
|
|
/* We don't support the 4K PFN hack with ioremap */
|
2016-04-29 16:25:45 +03:00
|
|
|
if (flags & H_PAGE_4K_PFN)
|
2008-07-24 08:27:08 +04:00
|
|
|
return NULL;
|
|
|
|
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
WARN_ON(pa & ~PAGE_MASK);
|
|
|
|
WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
|
|
|
|
WARN_ON(size & ~PAGE_MASK);
|
|
|
|
|
2005-09-26 10:04:21 +04:00
|
|
|
for (i = 0; i < size; i += PAGE_SIZE)
|
2009-07-24 03:15:16 +04:00
|
|
|
if (map_kernel_page((unsigned long)ea+i, pa+i, flags))
|
2005-09-26 10:04:21 +04:00
|
|
|
return NULL;
|
|
|
|
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
return (void __iomem *)ea;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __iounmap_from - Low level function to tear down the page tables
|
|
|
|
* for an IO mapping. This is used for mappings that
|
|
|
|
* are manipulated manually, like partial unmapping of
|
|
|
|
* PCI IOs or ISA space.
|
|
|
|
*/
|
|
|
|
void __iounmap_at(void *ea, unsigned long size)
|
|
|
|
{
|
|
|
|
WARN_ON(((unsigned long)ea) & ~PAGE_MASK);
|
|
|
|
WARN_ON(size & ~PAGE_MASK);
|
|
|
|
|
|
|
|
unmap_kernel_range((unsigned long)ea, size);
|
2005-09-26 10:04:21 +04:00
|
|
|
}
|
|
|
|
|
2009-02-22 19:19:14 +03:00
|
|
|
void __iomem * __ioremap_caller(phys_addr_t addr, unsigned long size,
|
|
|
|
unsigned long flags, void *caller)
|
2005-09-26 10:04:21 +04:00
|
|
|
{
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
phys_addr_t paligned;
|
2005-09-26 10:04:21 +04:00
|
|
|
void __iomem *ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Choose an address to map it to.
|
|
|
|
* Once the imalloc system is running, we use it.
|
|
|
|
* Before that, we map using addresses going
|
|
|
|
* up from ioremap_bot. imalloc will use
|
|
|
|
* the addresses from ioremap_bot through
|
|
|
|
* IMALLOC_END
|
|
|
|
*
|
|
|
|
*/
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
paligned = addr & PAGE_MASK;
|
|
|
|
size = PAGE_ALIGN(addr + size) - paligned;
|
2005-09-26 10:04:21 +04:00
|
|
|
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
if ((size == 0) || (paligned == 0))
|
2005-09-26 10:04:21 +04:00
|
|
|
return NULL;
|
|
|
|
|
2015-03-30 06:10:37 +03:00
|
|
|
if (slab_is_available()) {
|
2005-09-26 10:04:21 +04:00
|
|
|
struct vm_struct *area;
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
|
2009-02-22 19:19:14 +03:00
|
|
|
area = __get_vm_area_caller(size, VM_IOREMAP,
|
|
|
|
ioremap_bot, IOREMAP_END,
|
|
|
|
caller);
|
2005-09-26 10:04:21 +04:00
|
|
|
if (area == NULL)
|
|
|
|
return NULL;
|
2010-11-28 21:26:36 +03:00
|
|
|
|
|
|
|
area->phys_addr = paligned;
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
ret = __ioremap_at(paligned, area->addr, size, flags);
|
2005-09-26 10:04:21 +04:00
|
|
|
if (!ret)
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
vunmap(area->addr);
|
2005-09-26 10:04:21 +04:00
|
|
|
} else {
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
ret = __ioremap_at(paligned, (void *)ioremap_bot, size, flags);
|
2005-09-26 10:04:21 +04:00
|
|
|
if (ret)
|
|
|
|
ioremap_bot += size;
|
|
|
|
}
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
|
|
|
|
if (ret)
|
|
|
|
ret += addr & ~PAGE_MASK;
|
2005-09-26 10:04:21 +04:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-02-22 19:19:14 +03:00
|
|
|
void __iomem * __ioremap(phys_addr_t addr, unsigned long size,
|
|
|
|
unsigned long flags)
|
|
|
|
{
|
|
|
|
return __ioremap_caller(addr, size, flags, __builtin_return_address(0));
|
|
|
|
}
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
|
2006-11-13 01:27:39 +03:00
|
|
|
void __iomem * ioremap(phys_addr_t addr, unsigned long size)
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
{
|
2016-04-29 16:25:37 +03:00
|
|
|
unsigned long flags = pgprot_val(pgprot_noncached(__pgprot(0)));
|
2009-02-22 19:19:14 +03:00
|
|
|
void *caller = __builtin_return_address(0);
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
|
|
|
|
if (ppc_md.ioremap)
|
2009-02-22 19:19:14 +03:00
|
|
|
return ppc_md.ioremap(addr, size, flags, caller);
|
|
|
|
return __ioremap_caller(addr, size, flags, caller);
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
}
|
|
|
|
|
2011-05-09 01:41:59 +04:00
|
|
|
void __iomem * ioremap_wc(phys_addr_t addr, unsigned long size)
|
|
|
|
{
|
2016-04-29 16:25:37 +03:00
|
|
|
unsigned long flags = pgprot_val(pgprot_noncached_wc(__pgprot(0)));
|
2011-05-09 01:41:59 +04:00
|
|
|
void *caller = __builtin_return_address(0);
|
|
|
|
|
|
|
|
if (ppc_md.ioremap)
|
|
|
|
return ppc_md.ioremap(addr, size, flags, caller);
|
|
|
|
return __ioremap_caller(addr, size, flags, caller);
|
|
|
|
}
|
|
|
|
|
2011-05-09 01:43:47 +04:00
|
|
|
void __iomem * ioremap_prot(phys_addr_t addr, unsigned long size,
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
unsigned long flags)
|
|
|
|
{
|
2009-02-22 19:19:14 +03:00
|
|
|
void *caller = __builtin_return_address(0);
|
|
|
|
|
2008-07-24 08:27:08 +04:00
|
|
|
/* writeable implies dirty for kernel addresses */
|
2016-04-29 16:25:30 +03:00
|
|
|
if (flags & _PAGE_WRITE)
|
2008-07-24 08:27:08 +04:00
|
|
|
flags |= _PAGE_DIRTY;
|
|
|
|
|
2016-04-29 16:25:34 +03:00
|
|
|
/* we don't want to let _PAGE_EXEC leak out */
|
|
|
|
flags &= ~_PAGE_EXEC;
|
|
|
|
/*
|
|
|
|
* Force kernel mapping.
|
|
|
|
*/
|
|
|
|
#if defined(CONFIG_PPC_BOOK3S_64)
|
|
|
|
flags |= _PAGE_PRIVILEGED;
|
|
|
|
#else
|
|
|
|
flags &= ~_PAGE_USER;
|
|
|
|
#endif
|
|
|
|
|
2008-07-24 08:27:08 +04:00
|
|
|
|
2010-04-07 08:39:36 +04:00
|
|
|
#ifdef _PAGE_BAP_SR
|
|
|
|
/* _PAGE_USER contains _PAGE_BAP_SR on BookE using the new PTE format
|
|
|
|
* which means that we just cleared supervisor access... oops ;-) This
|
|
|
|
* restores it
|
|
|
|
*/
|
|
|
|
flags |= _PAGE_BAP_SR;
|
|
|
|
#endif
|
|
|
|
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
if (ppc_md.ioremap)
|
2009-02-22 19:19:14 +03:00
|
|
|
return ppc_md.ioremap(addr, size, flags, caller);
|
|
|
|
return __ioremap_caller(addr, size, flags, caller);
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-09-26 10:04:21 +04:00
|
|
|
/*
|
|
|
|
* Unmap an IO region and remove it from imalloc'd list.
|
|
|
|
* Access to IO memory should be serialized by driver.
|
|
|
|
*/
|
2006-11-13 01:27:39 +03:00
|
|
|
void __iounmap(volatile void __iomem *token)
|
2005-09-26 10:04:21 +04:00
|
|
|
{
|
|
|
|
void *addr;
|
|
|
|
|
2015-03-30 06:10:37 +03:00
|
|
|
if (!slab_is_available())
|
2005-09-26 10:04:21 +04:00
|
|
|
return;
|
|
|
|
|
[POWERPC] Rewrite IO allocation & mapping on powerpc64
This rewrites pretty much from scratch the handling of MMIO and PIO
space allocations on powerpc64. The main goals are:
- Get rid of imalloc and use more common code where possible
- Simplify the current mess so that PIO space is allocated and
mapped in a single place for PCI bridges
- Handle allocation constraints of PIO for all bridges including
hot plugged ones within the 2GB space reserved for IO ports,
so that devices on hotplugged busses will now work with drivers
that assume IO ports fit in an int.
- Cleanup and separate tracking of the ISA space in the reserved
low 64K of IO space. No ISA -> Nothing mapped there.
I booted a cell blade with IDE on PIO and MMIO and a dual G5 so
far, that's it :-)
With this patch, all allocations are done using the code in
mm/vmalloc.c, though we use the low level __get_vm_area with
explicit start/stop constraints in order to manage separate
areas for vmalloc/vmap, ioremap, and PCI IOs.
This greatly simplifies a lot of things, as you can see in the
diffstat of that patch :-)
A new pair of functions pcibios_map/unmap_io_space() now replace
all of the previous code that used to manipulate PCI IOs space.
The allocation is done at mapping time, which is now called from
scan_phb's, just before the devices are probed (instead of after,
which is by itself a bug fix). The only other caller is the PCI
hotplug code for hot adding PCI-PCI bridges (slots).
imalloc is gone, as is the "sub-allocation" thing, but I do beleive
that hotplug should still work in the sense that the space allocation
is always done by the PHB, but if you unmap a child bus of this PHB
(which seems to be possible), then the code should properly tear
down all the HPTE mappings for that area of the PHB allocated IO space.
I now always reserve the first 64K of IO space for the bridge with
the ISA bus on it. I have moved the code for tracking ISA in a separate
file which should also make it smarter if we ever are capable of
hot unplugging or re-plugging an ISA bridge.
This should have a side effect on platforms like powermac where VGA IOs
will no longer work. This is done on purpose though as they would have
worked semi-randomly before. The idea at this point is to isolate drivers
that might need to access those and fix them by providing a proper
function to obtain an offset to the legacy IOs of a given bus.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2007-06-04 09:15:36 +04:00
|
|
|
addr = (void *) ((unsigned long __force)
|
|
|
|
PCI_FIX_ADDR(token) & PAGE_MASK);
|
|
|
|
if ((unsigned long)addr < ioremap_bot) {
|
|
|
|
printk(KERN_WARNING "Attempt to iounmap early bolted mapping"
|
|
|
|
" at 0x%p\n", addr);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
vunmap(addr);
|
2005-09-26 10:04:21 +04:00
|
|
|
}
|
|
|
|
|
2006-11-13 01:27:39 +03:00
|
|
|
void iounmap(volatile void __iomem *token)
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
{
|
|
|
|
if (ppc_md.iounmap)
|
|
|
|
ppc_md.iounmap(token);
|
|
|
|
else
|
|
|
|
__iounmap(token);
|
|
|
|
}
|
|
|
|
|
2005-09-26 10:04:21 +04:00
|
|
|
EXPORT_SYMBOL(ioremap);
|
2011-05-09 01:41:59 +04:00
|
|
|
EXPORT_SYMBOL(ioremap_wc);
|
2011-05-09 01:43:47 +04:00
|
|
|
EXPORT_SYMBOL(ioremap_prot);
|
2005-09-26 10:04:21 +04:00
|
|
|
EXPORT_SYMBOL(__ioremap);
|
2007-08-31 07:58:51 +04:00
|
|
|
EXPORT_SYMBOL(__ioremap_at);
|
2005-09-26 10:04:21 +04:00
|
|
|
EXPORT_SYMBOL(iounmap);
|
[POWERPC] Allow hooking of PCI MMIO & PIO accessors on 64 bits
This patch reworks the way iSeries hooks on PCI IO operations (both MMIO
and PIO) and provides a generic way for other platforms to do so (we
have need to do that for various other platforms).
While reworking the IO ops, I ended up doing some spring cleaning in
io.h and eeh.h which I might want to split into 2 or 3 patches (among
others, eeh.h had a lot of useless stuff in it).
A side effect is that EEH for PIO should work now (it used to pass IO
ports down to the eeh address check functions which is bogus).
Also, new are MMIO "repeat" ops, which other archs like ARM already had,
and that we have too now: readsb, readsw, readsl, writesb, writesw,
writesl.
In the long run, I might also make EEH use the hooks instead
of wrapping at the toplevel, which would make things even cleaner and
relegate EEH completely in platforms/iseries, but we have to measure the
performance impact there (though it's really only on MMIO reads)
Since I also need to hook on ioremap, I shuffled the functions a bit
there. I introduced ioremap_flags() to use by drivers who want to pass
explicit flags to ioremap (and it can be hooked). The old __ioremap() is
still there as a low level and cannot be hooked, thus drivers who use it
should migrate unless they know they want the low level version.
The patch "arch provides generic iomap missing accessors" (should be
number 4 in this series) is a pre-requisite to provide full iomap
API support with this patch.
Signed-off-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2006-11-11 09:25:10 +03:00
|
|
|
EXPORT_SYMBOL(__iounmap);
|
2007-08-31 07:58:51 +04:00
|
|
|
EXPORT_SYMBOL(__iounmap_at);
|
2013-04-28 13:37:33 +04:00
|
|
|
|
2014-11-05 19:27:39 +03:00
|
|
|
#ifndef __PAGETABLE_PUD_FOLDED
|
|
|
|
/* 4 level page table */
|
|
|
|
struct page *pgd_page(pgd_t pgd)
|
|
|
|
{
|
|
|
|
if (pgd_huge(pgd))
|
|
|
|
return pte_page(pgd_pte(pgd));
|
|
|
|
return virt_to_page(pgd_page_vaddr(pgd));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct page *pud_page(pud_t pud)
|
|
|
|
{
|
|
|
|
if (pud_huge(pud))
|
|
|
|
return pte_page(pud_pte(pud));
|
|
|
|
return virt_to_page(pud_page_vaddr(pud));
|
|
|
|
}
|
|
|
|
|
2013-06-20 13:00:15 +04:00
|
|
|
/*
|
|
|
|
* For hugepage we have pfn in the pmd, we use PTE_RPN_SHIFT bits for flags
|
|
|
|
* For PTE page, we have a PTE_FRAG_SIZE (4K) aligned virtual address.
|
|
|
|
*/
|
|
|
|
struct page *pmd_page(pmd_t pmd)
|
|
|
|
{
|
2014-11-05 19:27:39 +03:00
|
|
|
if (pmd_trans_huge(pmd) || pmd_huge(pmd))
|
2015-12-01 06:36:53 +03:00
|
|
|
return pte_page(pmd_pte(pmd));
|
2013-06-20 13:00:15 +04:00
|
|
|
return virt_to_page(pmd_page_vaddr(pmd));
|
|
|
|
}
|
|
|
|
|
2013-04-28 13:37:33 +04:00
|
|
|
#ifdef CONFIG_PPC_64K_PAGES
|
|
|
|
static pte_t *get_from_cache(struct mm_struct *mm)
|
|
|
|
{
|
|
|
|
void *pte_frag, *ret;
|
|
|
|
|
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
ret = mm->context.pte_frag;
|
|
|
|
if (ret) {
|
|
|
|
pte_frag = ret + PTE_FRAG_SIZE;
|
|
|
|
/*
|
|
|
|
* If we have taken up all the fragments mark PTE page NULL
|
|
|
|
*/
|
|
|
|
if (((unsigned long)pte_frag & ~PAGE_MASK) == 0)
|
|
|
|
pte_frag = NULL;
|
|
|
|
mm->context.pte_frag = pte_frag;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
return (pte_t *)ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static pte_t *__alloc_for_cache(struct mm_struct *mm, int kernel)
|
|
|
|
{
|
|
|
|
void *ret = NULL;
|
|
|
|
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK |
|
|
|
|
__GFP_REPEAT | __GFP_ZERO);
|
|
|
|
if (!page)
|
|
|
|
return NULL;
|
2013-11-15 02:31:38 +04:00
|
|
|
if (!kernel && !pgtable_page_ctor(page)) {
|
|
|
|
__free_page(page);
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-04-28 13:37:33 +04:00
|
|
|
|
|
|
|
ret = page_address(page);
|
|
|
|
spin_lock(&mm->page_table_lock);
|
|
|
|
/*
|
|
|
|
* If we find pgtable_page set, we return
|
|
|
|
* the allocated page with single fragement
|
|
|
|
* count.
|
|
|
|
*/
|
|
|
|
if (likely(!mm->context.pte_frag)) {
|
2016-03-18 00:19:26 +03:00
|
|
|
set_page_count(page, PTE_FRAG_NR);
|
2013-04-28 13:37:33 +04:00
|
|
|
mm->context.pte_frag = ret + PTE_FRAG_SIZE;
|
|
|
|
}
|
|
|
|
spin_unlock(&mm->page_table_lock);
|
|
|
|
|
|
|
|
return (pte_t *)ret;
|
|
|
|
}
|
|
|
|
|
2016-04-29 16:26:17 +03:00
|
|
|
pte_t *pte_fragment_alloc(struct mm_struct *mm, unsigned long vmaddr, int kernel)
|
2013-04-28 13:37:33 +04:00
|
|
|
{
|
|
|
|
pte_t *pte;
|
|
|
|
|
|
|
|
pte = get_from_cache(mm);
|
|
|
|
if (pte)
|
|
|
|
return pte;
|
|
|
|
|
|
|
|
return __alloc_for_cache(mm, kernel);
|
|
|
|
}
|
|
|
|
|
2016-04-29 16:26:17 +03:00
|
|
|
void pte_fragment_free(unsigned long *table, int kernel)
|
2013-04-28 13:37:33 +04:00
|
|
|
{
|
|
|
|
struct page *page = virt_to_page(table);
|
|
|
|
if (put_page_testzero(page)) {
|
|
|
|
if (!kernel)
|
|
|
|
pgtable_page_dtor(page);
|
|
|
|
free_hot_cold_page(page, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
void pgtable_free_tlb(struct mmu_gather *tlb, void *table, int shift)
|
|
|
|
{
|
|
|
|
unsigned long pgf = (unsigned long)table;
|
|
|
|
|
|
|
|
BUG_ON(shift > MAX_PGTABLE_INDEX_SIZE);
|
|
|
|
pgf |= shift;
|
|
|
|
tlb_remove_table(tlb, (void *)pgf);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __tlb_remove_table(void *_table)
|
|
|
|
{
|
|
|
|
void *table = (void *)((unsigned long)_table & ~MAX_PGTABLE_INDEX_SIZE);
|
|
|
|
unsigned shift = (unsigned long)_table & MAX_PGTABLE_INDEX_SIZE;
|
|
|
|
|
|
|
|
if (!shift)
|
|
|
|
/* PTE page needs special handling */
|
2016-04-29 16:26:17 +03:00
|
|
|
pte_fragment_free(table, 0);
|
2013-04-28 13:37:33 +04:00
|
|
|
else {
|
|
|
|
BUG_ON(shift > MAX_PGTABLE_INDEX_SIZE);
|
|
|
|
kmem_cache_free(PGT_CACHE(shift), table);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
void pgtable_free_tlb(struct mmu_gather *tlb, void *table, int shift)
|
|
|
|
{
|
|
|
|
if (!shift) {
|
|
|
|
/* PTE page needs special handling */
|
2016-04-29 16:26:17 +03:00
|
|
|
pte_fragment_free(table, 0);
|
2013-04-28 13:37:33 +04:00
|
|
|
} else {
|
|
|
|
BUG_ON(shift > MAX_PGTABLE_INDEX_SIZE);
|
|
|
|
kmem_cache_free(PGT_CACHE(shift), table);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif /* CONFIG_PPC_64K_PAGES */
|
2013-06-20 13:00:15 +04:00
|
|
|
|
|
|
|
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called when relaxing access to a hugepage. It's also called in the page
|
|
|
|
* fault path when we don't hit any of the major fault cases, ie, a minor
|
|
|
|
* update of _PAGE_ACCESSED, _PAGE_DIRTY, etc... The generic code will have
|
|
|
|
* handled those two for us, we additionally deal with missing execute
|
|
|
|
* permission here on some processors
|
|
|
|
*/
|
|
|
|
int pmdp_set_access_flags(struct vm_area_struct *vma, unsigned long address,
|
|
|
|
pmd_t *pmdp, pmd_t entry, int dirty)
|
|
|
|
{
|
|
|
|
int changed;
|
|
|
|
#ifdef CONFIG_DEBUG_VM
|
|
|
|
WARN_ON(!pmd_trans_huge(*pmdp));
|
|
|
|
assert_spin_locked(&vma->vm_mm->page_table_lock);
|
|
|
|
#endif
|
|
|
|
changed = !pmd_same(*(pmdp), entry);
|
|
|
|
if (changed) {
|
|
|
|
__ptep_set_access_flags(pmdp_ptep(pmdp), pmd_pte(entry));
|
|
|
|
/*
|
|
|
|
* Since we are not supporting SW TLB systems, we don't
|
|
|
|
* have any thing similar to flush_tlb_page_nohash()
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long pmd_hugepage_update(struct mm_struct *mm, unsigned long addr,
|
2014-02-12 07:43:36 +04:00
|
|
|
pmd_t *pmdp, unsigned long clr,
|
|
|
|
unsigned long set)
|
2013-06-20 13:00:15 +04:00
|
|
|
{
|
|
|
|
|
2016-04-29 16:25:28 +03:00
|
|
|
__be64 old_be, tmp;
|
|
|
|
unsigned long old;
|
2013-06-20 13:00:15 +04:00
|
|
|
|
|
|
|
#ifdef CONFIG_DEBUG_VM
|
|
|
|
WARN_ON(!pmd_trans_huge(*pmdp));
|
|
|
|
assert_spin_locked(&mm->page_table_lock);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
__asm__ __volatile__(
|
|
|
|
"1: ldarx %0,0,%3\n\
|
2016-04-29 16:25:28 +03:00
|
|
|
and. %1,%0,%6\n\
|
2013-06-20 13:00:15 +04:00
|
|
|
bne- 1b \n\
|
|
|
|
andc %1,%0,%4 \n\
|
2014-02-12 07:43:36 +04:00
|
|
|
or %1,%1,%7\n\
|
2013-06-20 13:00:15 +04:00
|
|
|
stdcx. %1,0,%3 \n\
|
|
|
|
bne- 1b"
|
2016-04-29 16:25:28 +03:00
|
|
|
: "=&r" (old_be), "=&r" (tmp), "=m" (*pmdp)
|
|
|
|
: "r" (pmdp), "r" (cpu_to_be64(clr)), "m" (*pmdp),
|
2016-04-29 16:25:45 +03:00
|
|
|
"r" (cpu_to_be64(H_PAGE_BUSY)), "r" (cpu_to_be64(set))
|
2013-06-20 13:00:15 +04:00
|
|
|
: "cc" );
|
2016-04-29 16:25:26 +03:00
|
|
|
|
2016-04-29 16:25:28 +03:00
|
|
|
old = be64_to_cpu(old_be);
|
|
|
|
|
2014-08-13 11:02:04 +04:00
|
|
|
trace_hugepage_update(addr, old, clr, set);
|
2016-04-29 16:25:45 +03:00
|
|
|
if (old & H_PAGE_HASHPTE)
|
2014-08-13 11:02:00 +04:00
|
|
|
hpte_do_hugepage_flush(mm, addr, pmdp, old);
|
2013-06-20 13:00:15 +04:00
|
|
|
return old;
|
|
|
|
}
|
|
|
|
|
2015-06-25 02:57:39 +03:00
|
|
|
pmd_t pmdp_collapse_flush(struct vm_area_struct *vma, unsigned long address,
|
|
|
|
pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
pmd_t pmd;
|
|
|
|
|
|
|
|
VM_BUG_ON(address & ~HPAGE_PMD_MASK);
|
|
|
|
VM_BUG_ON(pmd_trans_huge(*pmdp));
|
|
|
|
|
|
|
|
pmd = *pmdp;
|
|
|
|
pmd_clear(pmdp);
|
|
|
|
/*
|
|
|
|
* Wait for all pending hash_page to finish. This is needed
|
|
|
|
* in case of subpage collapse. When we collapse normal pages
|
|
|
|
* to hugepage, we first clear the pmd, then invalidate all
|
|
|
|
* the PTE entries. The assumption here is that any low level
|
|
|
|
* page fault will see a none pmd and take the slow path that
|
|
|
|
* will wait on mmap_sem. But we could very well be in a
|
|
|
|
* hash_page with local ptep pointer value. Such a hash page
|
|
|
|
* can result in adding new HPTE entries for normal subpages.
|
|
|
|
* That means we could be modifying the page content as we
|
|
|
|
* copy them to a huge page. So wait for parallel hash_page
|
|
|
|
* to finish before invalidating HPTE entries. We can do this
|
|
|
|
* by sending an IPI to all the cpus and executing a dummy
|
|
|
|
* function there.
|
|
|
|
*/
|
|
|
|
kick_all_cpus_sync();
|
|
|
|
/*
|
|
|
|
* Now invalidate the hpte entries in the range
|
|
|
|
* covered by pmd. This make sure we take a
|
|
|
|
* fault and will find the pmd as none, which will
|
|
|
|
* result in a major fault which takes mmap_sem and
|
|
|
|
* hence wait for collapse to complete. Without this
|
|
|
|
* the __collapse_huge_page_copy can result in copying
|
|
|
|
* the old content.
|
|
|
|
*/
|
|
|
|
flush_tlb_pmd_range(vma->vm_mm, &pmd, address);
|
2013-06-20 13:00:15 +04:00
|
|
|
return pmd;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We currently remove entries from the hashtable regardless of whether
|
2016-04-29 16:25:39 +03:00
|
|
|
* the entry was young or dirty.
|
2013-06-20 13:00:15 +04:00
|
|
|
*
|
|
|
|
* We should be more intelligent about this but for the moment we override
|
|
|
|
* these functions and force a tlb flush unconditionally
|
|
|
|
*/
|
2016-04-29 16:25:39 +03:00
|
|
|
int pmdp_test_and_clear_young(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pmd_t *pmdp)
|
2013-06-20 13:00:15 +04:00
|
|
|
{
|
|
|
|
return __pmdp_test_and_clear_young(vma->vm_mm, address, pmdp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We want to put the pgtable in pmd and use pgtable for tracking
|
|
|
|
* the base page size hptes
|
|
|
|
*/
|
|
|
|
void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
|
|
|
|
pgtable_t pgtable)
|
|
|
|
{
|
|
|
|
pgtable_t *pgtable_slot;
|
|
|
|
assert_spin_locked(&mm->page_table_lock);
|
|
|
|
/*
|
|
|
|
* we store the pgtable in the second half of PMD
|
|
|
|
*/
|
|
|
|
pgtable_slot = (pgtable_t *)pmdp + PTRS_PER_PMD;
|
|
|
|
*pgtable_slot = pgtable;
|
|
|
|
/*
|
|
|
|
* expose the deposited pgtable to other cpus.
|
|
|
|
* before we set the hugepage PTE at pmd level
|
|
|
|
* hash fault code looks at the deposted pgtable
|
|
|
|
* to store hash index values.
|
|
|
|
*/
|
|
|
|
smp_wmb();
|
|
|
|
}
|
|
|
|
|
|
|
|
pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
pgtable_t pgtable;
|
|
|
|
pgtable_t *pgtable_slot;
|
|
|
|
|
|
|
|
assert_spin_locked(&mm->page_table_lock);
|
|
|
|
pgtable_slot = (pgtable_t *)pmdp + PTRS_PER_PMD;
|
|
|
|
pgtable = *pgtable_slot;
|
|
|
|
/*
|
|
|
|
* Once we withdraw, mark the entry NULL.
|
|
|
|
*/
|
|
|
|
*pgtable_slot = NULL;
|
|
|
|
/*
|
|
|
|
* We store HPTE information in the deposited PTE fragment.
|
|
|
|
* zero out the content on withdraw.
|
|
|
|
*/
|
|
|
|
memset(pgtable, 0, PTE_FRAG_SIZE);
|
|
|
|
return pgtable;
|
|
|
|
}
|
|
|
|
|
2016-02-09 04:20:31 +03:00
|
|
|
void pmdp_huge_split_prepare(struct vm_area_struct *vma,
|
|
|
|
unsigned long address, pmd_t *pmdp)
|
|
|
|
{
|
|
|
|
VM_BUG_ON(address & ~HPAGE_PMD_MASK);
|
|
|
|
VM_BUG_ON(REGION_ID(address) != USER_REGION_ID);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can't mark the pmd none here, because that will cause a race
|
|
|
|
* against exit_mmap. We need to continue mark pmd TRANS HUGE, while
|
|
|
|
* we spilt, but at the same time we wan't rest of the ppc64 code
|
|
|
|
* not to insert hash pte on this, because we will be modifying
|
|
|
|
* the deposited pgtable in the caller of this function. Hence
|
|
|
|
* clear the _PAGE_USER so that we move the fault handling to
|
|
|
|
* higher level function and that will serialize against ptl.
|
|
|
|
* We need to flush existing hash pte entries here even though,
|
|
|
|
* the translation is still valid, because we will withdraw
|
|
|
|
* pgtable_t after this.
|
|
|
|
*/
|
2016-04-29 16:25:34 +03:00
|
|
|
pmd_hugepage_update(vma->vm_mm, address, pmdp, 0, _PAGE_PRIVILEGED);
|
2016-02-09 04:20:31 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-06-20 13:00:15 +04:00
|
|
|
/*
|
|
|
|
* set a new huge pmd. We should not be called for updating
|
|
|
|
* an existing pmd entry. That should go via pmd_hugepage_update.
|
|
|
|
*/
|
|
|
|
void set_pmd_at(struct mm_struct *mm, unsigned long addr,
|
|
|
|
pmd_t *pmdp, pmd_t pmd)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_DEBUG_VM
|
2016-04-29 16:25:30 +03:00
|
|
|
WARN_ON(pte_present(pmd_pte(*pmdp)) && !pte_protnone(pmd_pte(*pmdp)));
|
2013-06-20 13:00:15 +04:00
|
|
|
assert_spin_locked(&mm->page_table_lock);
|
|
|
|
WARN_ON(!pmd_trans_huge(pmd));
|
|
|
|
#endif
|
2015-03-25 12:11:57 +03:00
|
|
|
trace_hugepage_set_pmd(addr, pmd_val(pmd));
|
2013-06-20 13:00:15 +04:00
|
|
|
return set_pte_at(mm, addr, pmdp_ptep(pmdp), pmd_pte(pmd));
|
|
|
|
}
|
|
|
|
|
2016-02-09 04:20:31 +03:00
|
|
|
/*
|
|
|
|
* We use this to invalidate a pmdp entry before switching from a
|
|
|
|
* hugepte to regular pmd entry.
|
|
|
|
*/
|
2013-06-20 13:00:15 +04:00
|
|
|
void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
|
|
|
|
pmd_t *pmdp)
|
|
|
|
{
|
2014-02-12 07:43:36 +04:00
|
|
|
pmd_hugepage_update(vma->vm_mm, address, pmdp, _PAGE_PRESENT, 0);
|
2016-02-09 04:20:31 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This ensures that generic code that rely on IRQ disabling
|
|
|
|
* to prevent a parallel THP split work as expected.
|
|
|
|
*/
|
|
|
|
kick_all_cpus_sync();
|
2013-06-20 13:00:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A linux hugepage PMD was changed and the corresponding hash table entries
|
|
|
|
* neesd to be flushed.
|
|
|
|
*/
|
|
|
|
void hpte_do_hugepage_flush(struct mm_struct *mm, unsigned long addr,
|
2014-08-13 11:02:00 +04:00
|
|
|
pmd_t *pmdp, unsigned long old_pmd)
|
2013-06-20 13:00:15 +04:00
|
|
|
{
|
2014-12-04 08:30:14 +03:00
|
|
|
int ssize;
|
2014-11-02 18:45:27 +03:00
|
|
|
unsigned int psize;
|
|
|
|
unsigned long vsid;
|
2014-12-04 08:30:14 +03:00
|
|
|
unsigned long flags = 0;
|
2014-11-02 18:45:28 +03:00
|
|
|
const struct cpumask *tmp;
|
2013-06-20 13:00:15 +04:00
|
|
|
|
2014-08-13 11:01:58 +04:00
|
|
|
/* get the base page size,vsid and segment size */
|
2014-08-13 11:02:00 +04:00
|
|
|
#ifdef CONFIG_DEBUG_VM
|
2014-11-02 18:45:27 +03:00
|
|
|
psize = get_slice_psize(mm, addr);
|
2014-08-13 11:02:00 +04:00
|
|
|
BUG_ON(psize == MMU_PAGE_16M);
|
|
|
|
#endif
|
2016-04-29 16:25:45 +03:00
|
|
|
if (old_pmd & H_PAGE_COMBO)
|
2014-08-13 11:02:00 +04:00
|
|
|
psize = MMU_PAGE_4K;
|
|
|
|
else
|
|
|
|
psize = MMU_PAGE_64K;
|
|
|
|
|
2014-11-02 18:45:27 +03:00
|
|
|
if (!is_kernel_addr(addr)) {
|
|
|
|
ssize = user_segment_size(addr);
|
|
|
|
vsid = get_vsid(mm->context.id, addr, ssize);
|
2014-08-13 11:01:58 +04:00
|
|
|
WARN_ON(vsid == 0);
|
|
|
|
} else {
|
2014-11-02 18:45:27 +03:00
|
|
|
vsid = get_kernel_vsid(addr, mmu_kernel_ssize);
|
2014-08-13 11:01:58 +04:00
|
|
|
ssize = mmu_kernel_ssize;
|
|
|
|
}
|
2013-06-20 13:00:15 +04:00
|
|
|
|
2014-11-02 18:45:28 +03:00
|
|
|
tmp = cpumask_of(smp_processor_id());
|
|
|
|
if (cpumask_equal(mm_cpumask(mm), tmp))
|
2014-12-04 08:30:14 +03:00
|
|
|
flags |= HPTE_LOCAL_UPDATE;
|
2014-11-02 18:45:28 +03:00
|
|
|
|
2014-12-04 08:30:14 +03:00
|
|
|
return flush_hash_hugepage(vsid, addr, pmdp, psize, ssize, flags);
|
2013-06-20 13:00:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static pmd_t pmd_set_protbits(pmd_t pmd, pgprot_t pgprot)
|
|
|
|
{
|
2015-12-01 06:36:35 +03:00
|
|
|
return __pmd(pmd_val(pmd) | pgprot_val(pgprot));
|
2013-06-20 13:00:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
pmd_t pfn_pmd(unsigned long pfn, pgprot_t pgprot)
|
|
|
|
{
|
2015-12-01 06:36:35 +03:00
|
|
|
unsigned long pmdv;
|
2015-12-01 06:36:54 +03:00
|
|
|
|
2016-04-29 16:25:35 +03:00
|
|
|
pmdv = (pfn << PAGE_SHIFT) & PTE_RPN_MASK;
|
2015-12-01 06:36:35 +03:00
|
|
|
return pmd_set_protbits(__pmd(pmdv), pgprot);
|
2013-06-20 13:00:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
pmd_t mk_pmd(struct page *page, pgprot_t pgprot)
|
|
|
|
{
|
|
|
|
return pfn_pmd(page_to_pfn(page), pgprot);
|
|
|
|
}
|
|
|
|
|
|
|
|
pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
|
|
|
|
{
|
2015-12-01 06:36:35 +03:00
|
|
|
unsigned long pmdv;
|
2013-06-20 13:00:15 +04:00
|
|
|
|
2015-12-01 06:36:35 +03:00
|
|
|
pmdv = pmd_val(pmd);
|
|
|
|
pmdv &= _HPAGE_CHG_MASK;
|
|
|
|
return pmd_set_protbits(__pmd(pmdv), newprot);
|
2013-06-20 13:00:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is called at the end of handling a user page fault, when the
|
|
|
|
* fault has been handled by updating a HUGE PMD entry in the linux page tables.
|
|
|
|
* We use it to preload an HPTE into the hash table corresponding to
|
|
|
|
* the updated linux HUGE PMD entry.
|
|
|
|
*/
|
|
|
|
void update_mmu_cache_pmd(struct vm_area_struct *vma, unsigned long addr,
|
|
|
|
pmd_t *pmd)
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-06-25 02:57:44 +03:00
|
|
|
pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm,
|
|
|
|
unsigned long addr, pmd_t *pmdp)
|
2013-06-20 13:00:15 +04:00
|
|
|
{
|
|
|
|
pmd_t old_pmd;
|
|
|
|
pgtable_t pgtable;
|
|
|
|
unsigned long old;
|
|
|
|
pgtable_t *pgtable_slot;
|
|
|
|
|
2014-02-12 07:43:36 +04:00
|
|
|
old = pmd_hugepage_update(mm, addr, pmdp, ~0UL, 0);
|
2013-06-20 13:00:15 +04:00
|
|
|
old_pmd = __pmd(old);
|
|
|
|
/*
|
|
|
|
* We have pmd == none and we are holding page_table_lock.
|
|
|
|
* So we can safely go and clear the pgtable hash
|
|
|
|
* index info.
|
|
|
|
*/
|
|
|
|
pgtable_slot = (pgtable_t *)pmdp + PTRS_PER_PMD;
|
|
|
|
pgtable = *pgtable_slot;
|
|
|
|
/*
|
|
|
|
* Let's zero out old valid and hash index details
|
|
|
|
* hash fault look at them.
|
|
|
|
*/
|
|
|
|
memset(pgtable, 0, PTE_FRAG_SIZE);
|
2015-05-11 09:26:01 +03:00
|
|
|
/*
|
|
|
|
* Serialize against find_linux_pte_or_hugepte which does lock-less
|
|
|
|
* lookup in page tables with local interrupts disabled. For huge pages
|
|
|
|
* it casts pmd_t to pte_t. Since format of pte_t is different from
|
|
|
|
* pmd_t we want to prevent transit from pmd pointing to page table
|
|
|
|
* to pmd pointing to huge page (and back) while interrupts are disabled.
|
|
|
|
* We clear pmd to possibly replace it with page table pointer in
|
|
|
|
* different code paths. So make sure we wait for the parallel
|
|
|
|
* find_linux_pte_or_hugepage to finish.
|
|
|
|
*/
|
|
|
|
kick_all_cpus_sync();
|
2013-06-20 13:00:15 +04:00
|
|
|
return old_pmd;
|
|
|
|
}
|
2013-06-20 13:00:26 +04:00
|
|
|
|
|
|
|
int has_transparent_hugepage(void)
|
|
|
|
{
|
2016-03-01 07:15:14 +03:00
|
|
|
|
2013-06-20 13:00:26 +04:00
|
|
|
if (!mmu_has_feature(MMU_FTR_16M_PAGE))
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* We support THP only if PMD_SIZE is 16MB.
|
|
|
|
*/
|
|
|
|
if (mmu_psize_defs[MMU_PAGE_16M].shift != PMD_SHIFT)
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* We need to make sure that we support 16MB hugepage in a segement
|
|
|
|
* with base page size 64K or 4K. We only enable THP with a PAGE_SIZE
|
|
|
|
* of 64K.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* If we have 64K HPTE, we will be using that by default
|
|
|
|
*/
|
|
|
|
if (mmu_psize_defs[MMU_PAGE_64K].shift &&
|
|
|
|
(mmu_psize_defs[MMU_PAGE_64K].penc[MMU_PAGE_16M] == -1))
|
|
|
|
return 0;
|
|
|
|
/*
|
|
|
|
* Ok we only have 4K HPTE
|
|
|
|
*/
|
|
|
|
if (mmu_psize_defs[MMU_PAGE_4K].penc[MMU_PAGE_16M] == -1)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2013-06-20 13:00:15 +04:00
|
|
|
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
|