1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
/*
* OpenRISC ioremap.c
*
* Linux architectural port borrowing liberally from similar works of
* others. All original copyrights apply as per the original source
* declaration.
*
* Modifications for the OpenRISC architecture:
* Copyright (C) 2003 Matjaz Breskvar <phoenix@bsemi.com>
* Copyright (C) 2010-2011 Jonas Bonn <jonas@southpole.se>
*
* 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/vmalloc.h>
#include <linux/io.h>
#include <asm/pgalloc.h>
#include <asm/kmap_types.h>
#include <asm/fixmap.h>
#include <asm/bug.h>
#include <asm/pgtable.h>
#include <linux/sched.h>
#include <asm/tlbflush.h>
extern int mem_init_done;
static unsigned int fixmaps_used __initdata;
/*
* Remap an arbitrary physical address space into the kernel virtual
* address space. Needed when the kernel wants to access high addresses
* directly.
*
* NOTE! We need to allow non-page-aligned mappings too: we will obviously
* have to convert them into an offset in a page-aligned mapping, but the
* caller shouldn't need to know that small detail.
*/
void __iomem *__ref
__ioremap(phys_addr_t addr, unsigned long size, pgprot_t prot)
{
phys_addr_t p;
unsigned long v;
unsigned long offset, last_addr;
struct vm_struct *area = NULL;
/* Don't allow wraparound or zero size */
last_addr = addr + size - 1;
if (!size || last_addr < addr)
return NULL;
/*
* Mappings have to be page-aligned
*/
offset = addr & ~PAGE_MASK;
p = addr & PAGE_MASK;
size = PAGE_ALIGN(last_addr + 1) - p;
if (likely(mem_init_done)) {
area = get_vm_area(size, VM_IOREMAP);
if (!area)
return NULL;
v = (unsigned long)area->addr;
} else {
if ((fixmaps_used + (size >> PAGE_SHIFT)) > FIX_N_IOREMAPS)
return NULL;
v = fix_to_virt(FIX_IOREMAP_BEGIN + fixmaps_used);
fixmaps_used += (size >> PAGE_SHIFT);
}
if (ioremap_page_range(v, v + size, p, prot)) {
if (likely(mem_init_done))
vfree(area->addr);
else
fixmaps_used -= (size >> PAGE_SHIFT);
return NULL;
}
return (void __iomem *)(offset + (char *)v);
}
EXPORT_SYMBOL(__ioremap);
void iounmap(void *addr)
{
/* If the page is from the fixmap pool then we just clear out
* the fixmap mapping.
*/
if (unlikely((unsigned long)addr > FIXADDR_START)) {
/* This is a bit broken... we don't really know
* how big the area is so it's difficult to know
* how many fixed pages to invalidate...
* just flush tlb and hope for the best...
* consider this a FIXME
*
* Really we should be clearing out one or more page
* table entries for these virtual addresses so that
* future references cause a page fault... for now, we
* rely on two things:
* i) this code never gets called on known boards
* ii) invalid accesses to the freed areas aren't made
*/
flush_tlb_all();
return;
}
return vfree((void *)(PAGE_MASK & (unsigned long)addr));
}
EXPORT_SYMBOL(iounmap);
/**
* OK, this one's a bit tricky... ioremap can get called before memory is
* initialized (early serial console does this) and will want to alloc a page
* for its mapping. No userspace pages will ever get allocated before memory
* is initialized so this applies only to kernel pages. In the event that
* this is called before memory is initialized we allocate the page using
* the memblock infrastructure.
*/
pte_t __ref *pte_alloc_one_kernel(struct mm_struct *mm)
{
pte_t *pte;
if (likely(mem_init_done)) {
pte = (pte_t *)get_zeroed_page(GFP_KERNEL);
} else {
pte = memblock_alloc(PAGE_SIZE, PAGE_SIZE);
if (!pte)
panic("%s: Failed to allocate %lu bytes align=0x%lx\n",
__func__, PAGE_SIZE, PAGE_SIZE);
}
return pte;
}
|
