Loading...
1/*
2 * Trapped io support
3 *
4 * Copyright (C) 2008 Magnus Damm
5 *
6 * Intercept io operations by trapping.
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12#include <linux/kernel.h>
13#include <linux/mm.h>
14#include <linux/bitops.h>
15#include <linux/vmalloc.h>
16#include <linux/module.h>
17#include <linux/init.h>
18#include <asm/mmu_context.h>
19#include <asm/uaccess.h>
20#include <asm/io.h>
21#include <asm/io_trapped.h>
22
23#define TRAPPED_PAGES_MAX 16
24
25#ifdef CONFIG_HAS_IOPORT_MAP
26LIST_HEAD(trapped_io);
27EXPORT_SYMBOL_GPL(trapped_io);
28#endif
29#ifdef CONFIG_HAS_IOMEM
30LIST_HEAD(trapped_mem);
31EXPORT_SYMBOL_GPL(trapped_mem);
32#endif
33static DEFINE_SPINLOCK(trapped_lock);
34
35static int trapped_io_disable __read_mostly;
36
37static int __init trapped_io_setup(char *__unused)
38{
39 trapped_io_disable = 1;
40 return 1;
41}
42__setup("noiotrap", trapped_io_setup);
43
44int register_trapped_io(struct trapped_io *tiop)
45{
46 struct resource *res;
47 unsigned long len = 0, flags = 0;
48 struct page *pages[TRAPPED_PAGES_MAX];
49 int k, n;
50
51 if (unlikely(trapped_io_disable))
52 return 0;
53
54 /* structure must be page aligned */
55 if ((unsigned long)tiop & (PAGE_SIZE - 1))
56 goto bad;
57
58 for (k = 0; k < tiop->num_resources; k++) {
59 res = tiop->resource + k;
60 len += roundup(resource_size(res), PAGE_SIZE);
61 flags |= res->flags;
62 }
63
64 /* support IORESOURCE_IO _or_ MEM, not both */
65 if (hweight_long(flags) != 1)
66 goto bad;
67
68 n = len >> PAGE_SHIFT;
69
70 if (n >= TRAPPED_PAGES_MAX)
71 goto bad;
72
73 for (k = 0; k < n; k++)
74 pages[k] = virt_to_page(tiop);
75
76 tiop->virt_base = vmap(pages, n, VM_MAP, PAGE_NONE);
77 if (!tiop->virt_base)
78 goto bad;
79
80 len = 0;
81 for (k = 0; k < tiop->num_resources; k++) {
82 res = tiop->resource + k;
83 pr_info("trapped io 0x%08lx overrides %s 0x%08lx\n",
84 (unsigned long)(tiop->virt_base + len),
85 res->flags & IORESOURCE_IO ? "io" : "mmio",
86 (unsigned long)res->start);
87 len += roundup(resource_size(res), PAGE_SIZE);
88 }
89
90 tiop->magic = IO_TRAPPED_MAGIC;
91 INIT_LIST_HEAD(&tiop->list);
92 spin_lock_irq(&trapped_lock);
93#ifdef CONFIG_HAS_IOPORT_MAP
94 if (flags & IORESOURCE_IO)
95 list_add(&tiop->list, &trapped_io);
96#endif
97#ifdef CONFIG_HAS_IOMEM
98 if (flags & IORESOURCE_MEM)
99 list_add(&tiop->list, &trapped_mem);
100#endif
101 spin_unlock_irq(&trapped_lock);
102
103 return 0;
104 bad:
105 pr_warning("unable to install trapped io filter\n");
106 return -1;
107}
108EXPORT_SYMBOL_GPL(register_trapped_io);
109
110void __iomem *match_trapped_io_handler(struct list_head *list,
111 unsigned long offset,
112 unsigned long size)
113{
114 unsigned long voffs;
115 struct trapped_io *tiop;
116 struct resource *res;
117 int k, len;
118 unsigned long flags;
119
120 spin_lock_irqsave(&trapped_lock, flags);
121 list_for_each_entry(tiop, list, list) {
122 voffs = 0;
123 for (k = 0; k < tiop->num_resources; k++) {
124 res = tiop->resource + k;
125 if (res->start == offset) {
126 spin_unlock_irqrestore(&trapped_lock, flags);
127 return tiop->virt_base + voffs;
128 }
129
130 len = resource_size(res);
131 voffs += roundup(len, PAGE_SIZE);
132 }
133 }
134 spin_unlock_irqrestore(&trapped_lock, flags);
135 return NULL;
136}
137EXPORT_SYMBOL_GPL(match_trapped_io_handler);
138
139static struct trapped_io *lookup_tiop(unsigned long address)
140{
141 pgd_t *pgd_k;
142 pud_t *pud_k;
143 pmd_t *pmd_k;
144 pte_t *pte_k;
145 pte_t entry;
146
147 pgd_k = swapper_pg_dir + pgd_index(address);
148 if (!pgd_present(*pgd_k))
149 return NULL;
150
151 pud_k = pud_offset(pgd_k, address);
152 if (!pud_present(*pud_k))
153 return NULL;
154
155 pmd_k = pmd_offset(pud_k, address);
156 if (!pmd_present(*pmd_k))
157 return NULL;
158
159 pte_k = pte_offset_kernel(pmd_k, address);
160 entry = *pte_k;
161
162 return pfn_to_kaddr(pte_pfn(entry));
163}
164
165static unsigned long lookup_address(struct trapped_io *tiop,
166 unsigned long address)
167{
168 struct resource *res;
169 unsigned long vaddr = (unsigned long)tiop->virt_base;
170 unsigned long len;
171 int k;
172
173 for (k = 0; k < tiop->num_resources; k++) {
174 res = tiop->resource + k;
175 len = roundup(resource_size(res), PAGE_SIZE);
176 if (address < (vaddr + len))
177 return res->start + (address - vaddr);
178 vaddr += len;
179 }
180 return 0;
181}
182
183static unsigned long long copy_word(unsigned long src_addr, int src_len,
184 unsigned long dst_addr, int dst_len)
185{
186 unsigned long long tmp = 0;
187
188 switch (src_len) {
189 case 1:
190 tmp = __raw_readb(src_addr);
191 break;
192 case 2:
193 tmp = __raw_readw(src_addr);
194 break;
195 case 4:
196 tmp = __raw_readl(src_addr);
197 break;
198 case 8:
199 tmp = __raw_readq(src_addr);
200 break;
201 }
202
203 switch (dst_len) {
204 case 1:
205 __raw_writeb(tmp, dst_addr);
206 break;
207 case 2:
208 __raw_writew(tmp, dst_addr);
209 break;
210 case 4:
211 __raw_writel(tmp, dst_addr);
212 break;
213 case 8:
214 __raw_writeq(tmp, dst_addr);
215 break;
216 }
217
218 return tmp;
219}
220
221static unsigned long from_device(void *dst, const void *src, unsigned long cnt)
222{
223 struct trapped_io *tiop;
224 unsigned long src_addr = (unsigned long)src;
225 unsigned long long tmp;
226
227 pr_debug("trapped io read 0x%08lx (%ld)\n", src_addr, cnt);
228 tiop = lookup_tiop(src_addr);
229 WARN_ON(!tiop || (tiop->magic != IO_TRAPPED_MAGIC));
230
231 src_addr = lookup_address(tiop, src_addr);
232 if (!src_addr)
233 return cnt;
234
235 tmp = copy_word(src_addr,
236 max_t(unsigned long, cnt,
237 (tiop->minimum_bus_width / 8)),
238 (unsigned long)dst, cnt);
239
240 pr_debug("trapped io read 0x%08lx -> 0x%08llx\n", src_addr, tmp);
241 return 0;
242}
243
244static unsigned long to_device(void *dst, const void *src, unsigned long cnt)
245{
246 struct trapped_io *tiop;
247 unsigned long dst_addr = (unsigned long)dst;
248 unsigned long long tmp;
249
250 pr_debug("trapped io write 0x%08lx (%ld)\n", dst_addr, cnt);
251 tiop = lookup_tiop(dst_addr);
252 WARN_ON(!tiop || (tiop->magic != IO_TRAPPED_MAGIC));
253
254 dst_addr = lookup_address(tiop, dst_addr);
255 if (!dst_addr)
256 return cnt;
257
258 tmp = copy_word((unsigned long)src, cnt,
259 dst_addr, max_t(unsigned long, cnt,
260 (tiop->minimum_bus_width / 8)));
261
262 pr_debug("trapped io write 0x%08lx -> 0x%08llx\n", dst_addr, tmp);
263 return 0;
264}
265
266static struct mem_access trapped_io_access = {
267 from_device,
268 to_device,
269};
270
271int handle_trapped_io(struct pt_regs *regs, unsigned long address)
272{
273 mm_segment_t oldfs;
274 insn_size_t instruction;
275 int tmp;
276
277 if (trapped_io_disable)
278 return 0;
279 if (!lookup_tiop(address))
280 return 0;
281
282 WARN_ON(user_mode(regs));
283
284 oldfs = get_fs();
285 set_fs(KERNEL_DS);
286 if (copy_from_user(&instruction, (void *)(regs->pc),
287 sizeof(instruction))) {
288 set_fs(oldfs);
289 return 0;
290 }
291
292 tmp = handle_unaligned_access(instruction, regs,
293 &trapped_io_access, 1, address);
294 set_fs(oldfs);
295 return tmp == 0;
296}
1/*
2 * Trapped io support
3 *
4 * Copyright (C) 2008 Magnus Damm
5 *
6 * Intercept io operations by trapping.
7 *
8 * This file is subject to the terms and conditions of the GNU General Public
9 * License. See the file "COPYING" in the main directory of this archive
10 * for more details.
11 */
12#include <linux/kernel.h>
13#include <linux/mm.h>
14#include <linux/bitops.h>
15#include <linux/vmalloc.h>
16#include <linux/module.h>
17#include <linux/init.h>
18#include <asm/system.h>
19#include <asm/mmu_context.h>
20#include <asm/uaccess.h>
21#include <asm/io.h>
22#include <asm/io_trapped.h>
23
24#define TRAPPED_PAGES_MAX 16
25
26#ifdef CONFIG_HAS_IOPORT
27LIST_HEAD(trapped_io);
28EXPORT_SYMBOL_GPL(trapped_io);
29#endif
30#ifdef CONFIG_HAS_IOMEM
31LIST_HEAD(trapped_mem);
32EXPORT_SYMBOL_GPL(trapped_mem);
33#endif
34static DEFINE_SPINLOCK(trapped_lock);
35
36static int trapped_io_disable __read_mostly;
37
38static int __init trapped_io_setup(char *__unused)
39{
40 trapped_io_disable = 1;
41 return 1;
42}
43__setup("noiotrap", trapped_io_setup);
44
45int register_trapped_io(struct trapped_io *tiop)
46{
47 struct resource *res;
48 unsigned long len = 0, flags = 0;
49 struct page *pages[TRAPPED_PAGES_MAX];
50 int k, n;
51
52 if (unlikely(trapped_io_disable))
53 return 0;
54
55 /* structure must be page aligned */
56 if ((unsigned long)tiop & (PAGE_SIZE - 1))
57 goto bad;
58
59 for (k = 0; k < tiop->num_resources; k++) {
60 res = tiop->resource + k;
61 len += roundup(resource_size(res), PAGE_SIZE);
62 flags |= res->flags;
63 }
64
65 /* support IORESOURCE_IO _or_ MEM, not both */
66 if (hweight_long(flags) != 1)
67 goto bad;
68
69 n = len >> PAGE_SHIFT;
70
71 if (n >= TRAPPED_PAGES_MAX)
72 goto bad;
73
74 for (k = 0; k < n; k++)
75 pages[k] = virt_to_page(tiop);
76
77 tiop->virt_base = vmap(pages, n, VM_MAP, PAGE_NONE);
78 if (!tiop->virt_base)
79 goto bad;
80
81 len = 0;
82 for (k = 0; k < tiop->num_resources; k++) {
83 res = tiop->resource + k;
84 pr_info("trapped io 0x%08lx overrides %s 0x%08lx\n",
85 (unsigned long)(tiop->virt_base + len),
86 res->flags & IORESOURCE_IO ? "io" : "mmio",
87 (unsigned long)res->start);
88 len += roundup(resource_size(res), PAGE_SIZE);
89 }
90
91 tiop->magic = IO_TRAPPED_MAGIC;
92 INIT_LIST_HEAD(&tiop->list);
93 spin_lock_irq(&trapped_lock);
94#ifdef CONFIG_HAS_IOPORT
95 if (flags & IORESOURCE_IO)
96 list_add(&tiop->list, &trapped_io);
97#endif
98#ifdef CONFIG_HAS_IOMEM
99 if (flags & IORESOURCE_MEM)
100 list_add(&tiop->list, &trapped_mem);
101#endif
102 spin_unlock_irq(&trapped_lock);
103
104 return 0;
105 bad:
106 pr_warning("unable to install trapped io filter\n");
107 return -1;
108}
109EXPORT_SYMBOL_GPL(register_trapped_io);
110
111void __iomem *match_trapped_io_handler(struct list_head *list,
112 unsigned long offset,
113 unsigned long size)
114{
115 unsigned long voffs;
116 struct trapped_io *tiop;
117 struct resource *res;
118 int k, len;
119 unsigned long flags;
120
121 spin_lock_irqsave(&trapped_lock, flags);
122 list_for_each_entry(tiop, list, list) {
123 voffs = 0;
124 for (k = 0; k < tiop->num_resources; k++) {
125 res = tiop->resource + k;
126 if (res->start == offset) {
127 spin_unlock_irqrestore(&trapped_lock, flags);
128 return tiop->virt_base + voffs;
129 }
130
131 len = resource_size(res);
132 voffs += roundup(len, PAGE_SIZE);
133 }
134 }
135 spin_unlock_irqrestore(&trapped_lock, flags);
136 return NULL;
137}
138EXPORT_SYMBOL_GPL(match_trapped_io_handler);
139
140static struct trapped_io *lookup_tiop(unsigned long address)
141{
142 pgd_t *pgd_k;
143 pud_t *pud_k;
144 pmd_t *pmd_k;
145 pte_t *pte_k;
146 pte_t entry;
147
148 pgd_k = swapper_pg_dir + pgd_index(address);
149 if (!pgd_present(*pgd_k))
150 return NULL;
151
152 pud_k = pud_offset(pgd_k, address);
153 if (!pud_present(*pud_k))
154 return NULL;
155
156 pmd_k = pmd_offset(pud_k, address);
157 if (!pmd_present(*pmd_k))
158 return NULL;
159
160 pte_k = pte_offset_kernel(pmd_k, address);
161 entry = *pte_k;
162
163 return pfn_to_kaddr(pte_pfn(entry));
164}
165
166static unsigned long lookup_address(struct trapped_io *tiop,
167 unsigned long address)
168{
169 struct resource *res;
170 unsigned long vaddr = (unsigned long)tiop->virt_base;
171 unsigned long len;
172 int k;
173
174 for (k = 0; k < tiop->num_resources; k++) {
175 res = tiop->resource + k;
176 len = roundup(resource_size(res), PAGE_SIZE);
177 if (address < (vaddr + len))
178 return res->start + (address - vaddr);
179 vaddr += len;
180 }
181 return 0;
182}
183
184static unsigned long long copy_word(unsigned long src_addr, int src_len,
185 unsigned long dst_addr, int dst_len)
186{
187 unsigned long long tmp = 0;
188
189 switch (src_len) {
190 case 1:
191 tmp = __raw_readb(src_addr);
192 break;
193 case 2:
194 tmp = __raw_readw(src_addr);
195 break;
196 case 4:
197 tmp = __raw_readl(src_addr);
198 break;
199 case 8:
200 tmp = __raw_readq(src_addr);
201 break;
202 }
203
204 switch (dst_len) {
205 case 1:
206 __raw_writeb(tmp, dst_addr);
207 break;
208 case 2:
209 __raw_writew(tmp, dst_addr);
210 break;
211 case 4:
212 __raw_writel(tmp, dst_addr);
213 break;
214 case 8:
215 __raw_writeq(tmp, dst_addr);
216 break;
217 }
218
219 return tmp;
220}
221
222static unsigned long from_device(void *dst, const void *src, unsigned long cnt)
223{
224 struct trapped_io *tiop;
225 unsigned long src_addr = (unsigned long)src;
226 unsigned long long tmp;
227
228 pr_debug("trapped io read 0x%08lx (%ld)\n", src_addr, cnt);
229 tiop = lookup_tiop(src_addr);
230 WARN_ON(!tiop || (tiop->magic != IO_TRAPPED_MAGIC));
231
232 src_addr = lookup_address(tiop, src_addr);
233 if (!src_addr)
234 return cnt;
235
236 tmp = copy_word(src_addr,
237 max_t(unsigned long, cnt,
238 (tiop->minimum_bus_width / 8)),
239 (unsigned long)dst, cnt);
240
241 pr_debug("trapped io read 0x%08lx -> 0x%08llx\n", src_addr, tmp);
242 return 0;
243}
244
245static unsigned long to_device(void *dst, const void *src, unsigned long cnt)
246{
247 struct trapped_io *tiop;
248 unsigned long dst_addr = (unsigned long)dst;
249 unsigned long long tmp;
250
251 pr_debug("trapped io write 0x%08lx (%ld)\n", dst_addr, cnt);
252 tiop = lookup_tiop(dst_addr);
253 WARN_ON(!tiop || (tiop->magic != IO_TRAPPED_MAGIC));
254
255 dst_addr = lookup_address(tiop, dst_addr);
256 if (!dst_addr)
257 return cnt;
258
259 tmp = copy_word((unsigned long)src, cnt,
260 dst_addr, max_t(unsigned long, cnt,
261 (tiop->minimum_bus_width / 8)));
262
263 pr_debug("trapped io write 0x%08lx -> 0x%08llx\n", dst_addr, tmp);
264 return 0;
265}
266
267static struct mem_access trapped_io_access = {
268 from_device,
269 to_device,
270};
271
272int handle_trapped_io(struct pt_regs *regs, unsigned long address)
273{
274 mm_segment_t oldfs;
275 insn_size_t instruction;
276 int tmp;
277
278 if (trapped_io_disable)
279 return 0;
280 if (!lookup_tiop(address))
281 return 0;
282
283 WARN_ON(user_mode(regs));
284
285 oldfs = get_fs();
286 set_fs(KERNEL_DS);
287 if (copy_from_user(&instruction, (void *)(regs->pc),
288 sizeof(instruction))) {
289 set_fs(oldfs);
290 return 0;
291 }
292
293 tmp = handle_unaligned_access(instruction, regs,
294 &trapped_io_access, 1, address);
295 set_fs(oldfs);
296 return tmp == 0;
297}