Commit | Line | Data |
---|---|---|
15651291 HY |
1 | /* |
2 | * atomicio.c - ACPI IO memory pre-mapping/post-unmapping, then | |
3 | * accessing in atomic context. | |
4 | * | |
5 | * This is used for NMI handler to access IO memory area, because | |
6 | * ioremap/iounmap can not be used in NMI handler. The IO memory area | |
7 | * is pre-mapped in process context and accessed in NMI handler. | |
8 | * | |
9 | * Copyright (C) 2009-2010, Intel Corp. | |
10 | * Author: Huang Ying <ying.huang@intel.com> | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or | |
13 | * modify it under the terms of the GNU General Public License version | |
14 | * 2 as published by the Free Software Foundation. | |
15 | * | |
16 | * This program is distributed in the hope that it will be useful, | |
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
19 | * GNU General Public License for more details. | |
20 | * | |
21 | * You should have received a copy of the GNU General Public License | |
22 | * along with this program; if not, write to the Free Software | |
23 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
24 | */ | |
25 | ||
26 | #include <linux/kernel.h> | |
27 | #include <linux/module.h> | |
28 | #include <linux/init.h> | |
29 | #include <linux/acpi.h> | |
30 | #include <linux/io.h> | |
31 | #include <linux/kref.h> | |
32 | #include <linux/rculist.h> | |
33 | #include <linux/interrupt.h> | |
34 | #include <acpi/atomicio.h> | |
35 | ||
36 | #define ACPI_PFX "ACPI: " | |
37 | ||
38 | static LIST_HEAD(acpi_iomaps); | |
39 | /* | |
40 | * Used for mutual exclusion between writers of acpi_iomaps list, for | |
41 | * synchronization between readers and writer, RCU is used. | |
42 | */ | |
43 | static DEFINE_SPINLOCK(acpi_iomaps_lock); | |
44 | ||
45 | struct acpi_iomap { | |
46 | struct list_head list; | |
47 | void __iomem *vaddr; | |
48 | unsigned long size; | |
49 | phys_addr_t paddr; | |
50 | struct kref ref; | |
51 | }; | |
52 | ||
53 | /* acpi_iomaps_lock or RCU read lock must be held before calling */ | |
54 | static struct acpi_iomap *__acpi_find_iomap(phys_addr_t paddr, | |
55 | unsigned long size) | |
56 | { | |
57 | struct acpi_iomap *map; | |
58 | ||
59 | list_for_each_entry_rcu(map, &acpi_iomaps, list) { | |
60 | if (map->paddr + map->size >= paddr + size && | |
61 | map->paddr <= paddr) | |
62 | return map; | |
63 | } | |
64 | return NULL; | |
65 | } | |
66 | ||
67 | /* | |
68 | * Atomic "ioremap" used by NMI handler, if the specified IO memory | |
69 | * area is not pre-mapped, NULL will be returned. | |
70 | * | |
71 | * acpi_iomaps_lock or RCU read lock must be held before calling | |
72 | */ | |
73 | static void __iomem *__acpi_ioremap_fast(phys_addr_t paddr, | |
74 | unsigned long size) | |
75 | { | |
76 | struct acpi_iomap *map; | |
77 | ||
78 | map = __acpi_find_iomap(paddr, size); | |
79 | if (map) | |
80 | return map->vaddr + (paddr - map->paddr); | |
81 | else | |
82 | return NULL; | |
83 | } | |
84 | ||
85 | /* acpi_iomaps_lock must be held before calling */ | |
86 | static void __iomem *__acpi_try_ioremap(phys_addr_t paddr, | |
87 | unsigned long size) | |
88 | { | |
89 | struct acpi_iomap *map; | |
90 | ||
91 | map = __acpi_find_iomap(paddr, size); | |
92 | if (map) { | |
93 | kref_get(&map->ref); | |
94 | return map->vaddr + (paddr - map->paddr); | |
95 | } else | |
96 | return NULL; | |
97 | } | |
98 | ||
99 | /* | |
100 | * Used to pre-map the specified IO memory area. First try to find | |
101 | * whether the area is already pre-mapped, if it is, increase the | |
102 | * reference count (in __acpi_try_ioremap) and return; otherwise, do | |
103 | * the real ioremap, and add the mapping into acpi_iomaps list. | |
104 | */ | |
105 | static void __iomem *acpi_pre_map(phys_addr_t paddr, | |
106 | unsigned long size) | |
107 | { | |
108 | void __iomem *vaddr; | |
109 | struct acpi_iomap *map; | |
110 | unsigned long pg_sz, flags; | |
111 | phys_addr_t pg_off; | |
112 | ||
113 | spin_lock_irqsave(&acpi_iomaps_lock, flags); | |
114 | vaddr = __acpi_try_ioremap(paddr, size); | |
115 | spin_unlock_irqrestore(&acpi_iomaps_lock, flags); | |
116 | if (vaddr) | |
117 | return vaddr; | |
118 | ||
119 | pg_off = paddr & PAGE_MASK; | |
120 | pg_sz = ((paddr + size + PAGE_SIZE - 1) & PAGE_MASK) - pg_off; | |
121 | vaddr = ioremap(pg_off, pg_sz); | |
122 | if (!vaddr) | |
123 | return NULL; | |
124 | map = kmalloc(sizeof(*map), GFP_KERNEL); | |
125 | if (!map) | |
126 | goto err_unmap; | |
127 | INIT_LIST_HEAD(&map->list); | |
128 | map->paddr = pg_off; | |
129 | map->size = pg_sz; | |
130 | map->vaddr = vaddr; | |
131 | kref_init(&map->ref); | |
132 | ||
133 | spin_lock_irqsave(&acpi_iomaps_lock, flags); | |
134 | vaddr = __acpi_try_ioremap(paddr, size); | |
135 | if (vaddr) { | |
136 | spin_unlock_irqrestore(&acpi_iomaps_lock, flags); | |
137 | iounmap(map->vaddr); | |
138 | kfree(map); | |
139 | return vaddr; | |
140 | } | |
141 | list_add_tail_rcu(&map->list, &acpi_iomaps); | |
142 | spin_unlock_irqrestore(&acpi_iomaps_lock, flags); | |
143 | ||
144 | return vaddr + (paddr - pg_off); | |
145 | err_unmap: | |
146 | iounmap(vaddr); | |
147 | return NULL; | |
148 | } | |
149 | ||
150 | /* acpi_iomaps_lock must be held before calling */ | |
151 | static void __acpi_kref_del_iomap(struct kref *ref) | |
152 | { | |
153 | struct acpi_iomap *map; | |
154 | ||
155 | map = container_of(ref, struct acpi_iomap, ref); | |
156 | list_del_rcu(&map->list); | |
157 | } | |
158 | ||
159 | /* | |
160 | * Used to post-unmap the specified IO memory area. The iounmap is | |
161 | * done only if the reference count goes zero. | |
162 | */ | |
163 | static void acpi_post_unmap(phys_addr_t paddr, unsigned long size) | |
164 | { | |
165 | struct acpi_iomap *map; | |
166 | unsigned long flags; | |
167 | int del; | |
168 | ||
169 | spin_lock_irqsave(&acpi_iomaps_lock, flags); | |
170 | map = __acpi_find_iomap(paddr, size); | |
171 | BUG_ON(!map); | |
172 | del = kref_put(&map->ref, __acpi_kref_del_iomap); | |
173 | spin_unlock_irqrestore(&acpi_iomaps_lock, flags); | |
174 | ||
175 | if (!del) | |
176 | return; | |
177 | ||
178 | synchronize_rcu(); | |
179 | iounmap(map->vaddr); | |
180 | kfree(map); | |
181 | } | |
182 | ||
183 | /* In NMI handler, should set silent = 1 */ | |
184 | static int acpi_check_gar(struct acpi_generic_address *reg, | |
185 | u64 *paddr, int silent) | |
186 | { | |
187 | u32 width, space_id; | |
188 | ||
189 | width = reg->bit_width; | |
190 | space_id = reg->space_id; | |
191 | /* Handle possible alignment issues */ | |
192 | memcpy(paddr, ®->address, sizeof(*paddr)); | |
193 | if (!*paddr) { | |
194 | if (!silent) | |
195 | pr_warning(FW_BUG ACPI_PFX | |
196 | "Invalid physical address in GAR [0x%llx/%u/%u]\n", | |
197 | *paddr, width, space_id); | |
198 | return -EINVAL; | |
199 | } | |
200 | ||
201 | if ((width != 8) && (width != 16) && (width != 32) && (width != 64)) { | |
202 | if (!silent) | |
203 | pr_warning(FW_BUG ACPI_PFX | |
204 | "Invalid bit width in GAR [0x%llx/%u/%u]\n", | |
205 | *paddr, width, space_id); | |
206 | return -EINVAL; | |
207 | } | |
208 | ||
209 | if (space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY && | |
210 | space_id != ACPI_ADR_SPACE_SYSTEM_IO) { | |
211 | if (!silent) | |
212 | pr_warning(FW_BUG ACPI_PFX | |
213 | "Invalid address space type in GAR [0x%llx/%u/%u]\n", | |
214 | *paddr, width, space_id); | |
215 | return -EINVAL; | |
216 | } | |
217 | ||
218 | return 0; | |
219 | } | |
220 | ||
221 | /* Pre-map, working on GAR */ | |
222 | int acpi_pre_map_gar(struct acpi_generic_address *reg) | |
223 | { | |
224 | u64 paddr; | |
225 | void __iomem *vaddr; | |
226 | int rc; | |
227 | ||
228 | if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) | |
229 | return 0; | |
230 | ||
231 | rc = acpi_check_gar(reg, &paddr, 0); | |
232 | if (rc) | |
233 | return rc; | |
234 | ||
235 | vaddr = acpi_pre_map(paddr, reg->bit_width / 8); | |
236 | if (!vaddr) | |
237 | return -EIO; | |
238 | ||
239 | return 0; | |
240 | } | |
241 | EXPORT_SYMBOL_GPL(acpi_pre_map_gar); | |
242 | ||
243 | /* Post-unmap, working on GAR */ | |
244 | int acpi_post_unmap_gar(struct acpi_generic_address *reg) | |
245 | { | |
246 | u64 paddr; | |
247 | int rc; | |
248 | ||
249 | if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) | |
250 | return 0; | |
251 | ||
252 | rc = acpi_check_gar(reg, &paddr, 0); | |
253 | if (rc) | |
254 | return rc; | |
255 | ||
256 | acpi_post_unmap(paddr, reg->bit_width / 8); | |
257 | ||
258 | return 0; | |
259 | } | |
260 | EXPORT_SYMBOL_GPL(acpi_post_unmap_gar); | |
261 | ||
262 | /* | |
263 | * Can be used in atomic (including NMI) or process context. RCU read | |
264 | * lock can only be released after the IO memory area accessing. | |
265 | */ | |
266 | static int acpi_atomic_read_mem(u64 paddr, u64 *val, u32 width) | |
267 | { | |
268 | void __iomem *addr; | |
269 | ||
270 | rcu_read_lock(); | |
271 | addr = __acpi_ioremap_fast(paddr, width); | |
272 | switch (width) { | |
273 | case 8: | |
274 | *val = readb(addr); | |
275 | break; | |
276 | case 16: | |
277 | *val = readw(addr); | |
278 | break; | |
279 | case 32: | |
280 | *val = readl(addr); | |
281 | break; | |
282 | case 64: | |
283 | *val = readq(addr); | |
284 | break; | |
285 | default: | |
286 | return -EINVAL; | |
287 | } | |
288 | rcu_read_unlock(); | |
289 | ||
290 | return 0; | |
291 | } | |
292 | ||
293 | static int acpi_atomic_write_mem(u64 paddr, u64 val, u32 width) | |
294 | { | |
295 | void __iomem *addr; | |
296 | ||
297 | rcu_read_lock(); | |
298 | addr = __acpi_ioremap_fast(paddr, width); | |
299 | switch (width) { | |
300 | case 8: | |
301 | writeb(val, addr); | |
302 | break; | |
303 | case 16: | |
304 | writew(val, addr); | |
305 | break; | |
306 | case 32: | |
307 | writel(val, addr); | |
308 | break; | |
309 | case 64: | |
310 | writeq(val, addr); | |
311 | break; | |
312 | default: | |
313 | return -EINVAL; | |
314 | } | |
315 | rcu_read_unlock(); | |
316 | ||
317 | return 0; | |
318 | } | |
319 | ||
320 | /* GAR accessing in atomic (including NMI) or process context */ | |
321 | int acpi_atomic_read(u64 *val, struct acpi_generic_address *reg) | |
322 | { | |
323 | u64 paddr; | |
324 | int rc; | |
325 | ||
326 | rc = acpi_check_gar(reg, &paddr, 1); | |
327 | if (rc) | |
328 | return rc; | |
329 | ||
330 | *val = 0; | |
331 | switch (reg->space_id) { | |
332 | case ACPI_ADR_SPACE_SYSTEM_MEMORY: | |
333 | return acpi_atomic_read_mem(paddr, val, reg->bit_width); | |
334 | case ACPI_ADR_SPACE_SYSTEM_IO: | |
335 | return acpi_os_read_port(paddr, (u32 *)val, reg->bit_width); | |
336 | default: | |
337 | return -EINVAL; | |
338 | } | |
339 | } | |
340 | EXPORT_SYMBOL_GPL(acpi_atomic_read); | |
341 | ||
342 | int acpi_atomic_write(u64 val, struct acpi_generic_address *reg) | |
343 | { | |
344 | u64 paddr; | |
345 | int rc; | |
346 | ||
347 | rc = acpi_check_gar(reg, &paddr, 1); | |
348 | if (rc) | |
349 | return rc; | |
350 | ||
351 | switch (reg->space_id) { | |
352 | case ACPI_ADR_SPACE_SYSTEM_MEMORY: | |
353 | return acpi_atomic_write_mem(paddr, val, reg->bit_width); | |
354 | case ACPI_ADR_SPACE_SYSTEM_IO: | |
355 | return acpi_os_write_port(paddr, val, reg->bit_width); | |
356 | default: | |
357 | return -EINVAL; | |
358 | } | |
359 | } | |
360 | EXPORT_SYMBOL_GPL(acpi_atomic_write); |