Commit | Line | Data |
---|---|---|
28a375df BD |
1 | /** |
2 | * imr.c | |
3 | * | |
4 | * Copyright(c) 2013 Intel Corporation. | |
5 | * Copyright(c) 2015 Bryan O'Donoghue <pure.logic@nexus-software.ie> | |
6 | * | |
7 | * IMR registers define an isolated region of memory that can | |
8 | * be masked to prohibit certain system agents from accessing memory. | |
9 | * When a device behind a masked port performs an access - snooped or | |
10 | * not, an IMR may optionally prevent that transaction from changing | |
11 | * the state of memory or from getting correct data in response to the | |
12 | * operation. | |
13 | * | |
14 | * Write data will be dropped and reads will return 0xFFFFFFFF, the | |
15 | * system will reset and system BIOS will print out an error message to | |
16 | * inform the user that an IMR has been violated. | |
17 | * | |
18 | * This code is based on the Linux MTRR code and reference code from | |
19 | * Intel's Quark BSP EFI, Linux and grub code. | |
20 | * | |
21 | * See quark-x1000-datasheet.pdf for register definitions. | |
22 | * http://www.intel.com/content/dam/www/public/us/en/documents/datasheets/quark-x1000-datasheet.pdf | |
23 | */ | |
24 | ||
25 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
26 | ||
27 | #include <asm-generic/sections.h> | |
28 | #include <asm/cpu_device_id.h> | |
29 | #include <asm/imr.h> | |
30 | #include <asm/iosf_mbi.h> | |
31 | #include <linux/debugfs.h> | |
32 | #include <linux/init.h> | |
33 | #include <linux/mm.h> | |
34 | #include <linux/module.h> | |
35 | #include <linux/types.h> | |
36 | ||
37 | struct imr_device { | |
38 | struct dentry *file; | |
39 | bool init; | |
40 | struct mutex lock; | |
41 | int max_imr; | |
42 | int reg_base; | |
43 | }; | |
44 | ||
45 | static struct imr_device imr_dev; | |
46 | ||
47 | /* | |
48 | * IMR read/write mask control registers. | |
49 | * See quark-x1000-datasheet.pdf sections 12.7.4.5 and 12.7.4.6 for | |
50 | * bit definitions. | |
51 | * | |
52 | * addr_hi | |
53 | * 31 Lock bit | |
54 | * 30:24 Reserved | |
55 | * 23:2 1 KiB aligned lo address | |
56 | * 1:0 Reserved | |
57 | * | |
58 | * addr_hi | |
59 | * 31:24 Reserved | |
60 | * 23:2 1 KiB aligned hi address | |
61 | * 1:0 Reserved | |
62 | */ | |
63 | #define IMR_LOCK BIT(31) | |
64 | ||
65 | struct imr_regs { | |
66 | u32 addr_lo; | |
67 | u32 addr_hi; | |
68 | u32 rmask; | |
69 | u32 wmask; | |
70 | }; | |
71 | ||
72 | #define IMR_NUM_REGS (sizeof(struct imr_regs)/sizeof(u32)) | |
73 | #define IMR_SHIFT 8 | |
74 | #define imr_to_phys(x) ((x) << IMR_SHIFT) | |
75 | #define phys_to_imr(x) ((x) >> IMR_SHIFT) | |
76 | ||
77 | /** | |
78 | * imr_is_enabled - true if an IMR is enabled false otherwise. | |
79 | * | |
80 | * Determines if an IMR is enabled based on address range and read/write | |
81 | * mask. An IMR set with an address range set to zero and a read/write | |
82 | * access mask set to all is considered to be disabled. An IMR in any | |
83 | * other state - for example set to zero but without read/write access | |
84 | * all is considered to be enabled. This definition of disabled is how | |
85 | * firmware switches off an IMR and is maintained in kernel for | |
86 | * consistency. | |
87 | * | |
88 | * @imr: pointer to IMR descriptor. | |
89 | * @return: true if IMR enabled false if disabled. | |
90 | */ | |
91 | static inline int imr_is_enabled(struct imr_regs *imr) | |
92 | { | |
93 | return !(imr->rmask == IMR_READ_ACCESS_ALL && | |
94 | imr->wmask == IMR_WRITE_ACCESS_ALL && | |
95 | imr_to_phys(imr->addr_lo) == 0 && | |
96 | imr_to_phys(imr->addr_hi) == 0); | |
97 | } | |
98 | ||
99 | /** | |
100 | * imr_read - read an IMR at a given index. | |
101 | * | |
102 | * Requires caller to hold imr mutex. | |
103 | * | |
104 | * @idev: pointer to imr_device structure. | |
105 | * @imr_id: IMR entry to read. | |
106 | * @imr: IMR structure representing address and access masks. | |
107 | * @return: 0 on success or error code passed from mbi_iosf on failure. | |
108 | */ | |
109 | static int imr_read(struct imr_device *idev, u32 imr_id, struct imr_regs *imr) | |
110 | { | |
111 | u32 reg = imr_id * IMR_NUM_REGS + idev->reg_base; | |
112 | int ret; | |
113 | ||
4077a387 | 114 | ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->addr_lo); |
28a375df BD |
115 | if (ret) |
116 | return ret; | |
117 | ||
4077a387 | 118 | ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->addr_hi); |
28a375df BD |
119 | if (ret) |
120 | return ret; | |
121 | ||
4077a387 | 122 | ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->rmask); |
28a375df BD |
123 | if (ret) |
124 | return ret; | |
125 | ||
4077a387 | 126 | return iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->wmask); |
28a375df BD |
127 | } |
128 | ||
129 | /** | |
130 | * imr_write - write an IMR at a given index. | |
131 | * | |
132 | * Requires caller to hold imr mutex. | |
133 | * Note lock bits need to be written independently of address bits. | |
134 | * | |
135 | * @idev: pointer to imr_device structure. | |
136 | * @imr_id: IMR entry to write. | |
137 | * @imr: IMR structure representing address and access masks. | |
138 | * @lock: indicates if the IMR lock bit should be applied. | |
139 | * @return: 0 on success or error code passed from mbi_iosf on failure. | |
140 | */ | |
141 | static int imr_write(struct imr_device *idev, u32 imr_id, | |
142 | struct imr_regs *imr, bool lock) | |
143 | { | |
144 | unsigned long flags; | |
145 | u32 reg = imr_id * IMR_NUM_REGS + idev->reg_base; | |
146 | int ret; | |
147 | ||
148 | local_irq_save(flags); | |
149 | ||
4077a387 | 150 | ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->addr_lo); |
28a375df BD |
151 | if (ret) |
152 | goto failed; | |
153 | ||
4077a387 | 154 | ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->addr_hi); |
28a375df BD |
155 | if (ret) |
156 | goto failed; | |
157 | ||
4077a387 | 158 | ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->rmask); |
28a375df BD |
159 | if (ret) |
160 | goto failed; | |
161 | ||
4077a387 | 162 | ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->wmask); |
28a375df BD |
163 | if (ret) |
164 | goto failed; | |
165 | ||
166 | /* Lock bit must be set separately to addr_lo address bits. */ | |
167 | if (lock) { | |
168 | imr->addr_lo |= IMR_LOCK; | |
4077a387 AS |
169 | ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, |
170 | reg - IMR_NUM_REGS, imr->addr_lo); | |
28a375df BD |
171 | if (ret) |
172 | goto failed; | |
173 | } | |
174 | ||
175 | local_irq_restore(flags); | |
176 | return 0; | |
177 | failed: | |
178 | /* | |
179 | * If writing to the IOSF failed then we're in an unknown state, | |
180 | * likely a very bad state. An IMR in an invalid state will almost | |
181 | * certainly lead to a memory access violation. | |
182 | */ | |
183 | local_irq_restore(flags); | |
184 | WARN(ret, "IOSF-MBI write fail range 0x%08x-0x%08x unreliable\n", | |
185 | imr_to_phys(imr->addr_lo), imr_to_phys(imr->addr_hi) + IMR_MASK); | |
186 | ||
187 | return ret; | |
188 | } | |
189 | ||
190 | /** | |
191 | * imr_dbgfs_state_show - print state of IMR registers. | |
192 | * | |
193 | * @s: pointer to seq_file for output. | |
194 | * @unused: unused parameter. | |
195 | * @return: 0 on success or error code passed from mbi_iosf on failure. | |
196 | */ | |
197 | static int imr_dbgfs_state_show(struct seq_file *s, void *unused) | |
198 | { | |
199 | phys_addr_t base; | |
200 | phys_addr_t end; | |
201 | int i; | |
202 | struct imr_device *idev = s->private; | |
203 | struct imr_regs imr; | |
204 | size_t size; | |
205 | int ret = -ENODEV; | |
206 | ||
207 | mutex_lock(&idev->lock); | |
208 | ||
209 | for (i = 0; i < idev->max_imr; i++) { | |
210 | ||
211 | ret = imr_read(idev, i, &imr); | |
212 | if (ret) | |
213 | break; | |
214 | ||
215 | /* | |
216 | * Remember to add IMR_ALIGN bytes to size to indicate the | |
217 | * inherent IMR_ALIGN size bytes contained in the masked away | |
218 | * lower ten bits. | |
219 | */ | |
220 | if (imr_is_enabled(&imr)) { | |
221 | base = imr_to_phys(imr.addr_lo); | |
222 | end = imr_to_phys(imr.addr_hi) + IMR_MASK; | |
223 | } else { | |
224 | base = 0; | |
225 | end = 0; | |
226 | } | |
227 | size = end - base; | |
228 | seq_printf(s, "imr%02i: base=%pa, end=%pa, size=0x%08zx " | |
229 | "rmask=0x%08x, wmask=0x%08x, %s, %s\n", i, | |
230 | &base, &end, size, imr.rmask, imr.wmask, | |
231 | imr_is_enabled(&imr) ? "enabled " : "disabled", | |
232 | imr.addr_lo & IMR_LOCK ? "locked" : "unlocked"); | |
233 | } | |
234 | ||
235 | mutex_unlock(&idev->lock); | |
236 | return ret; | |
237 | } | |
238 | ||
239 | /** | |
240 | * imr_state_open - debugfs open callback. | |
241 | * | |
242 | * @inode: pointer to struct inode. | |
243 | * @file: pointer to struct file. | |
244 | * @return: result of single open. | |
245 | */ | |
246 | static int imr_state_open(struct inode *inode, struct file *file) | |
247 | { | |
248 | return single_open(file, imr_dbgfs_state_show, inode->i_private); | |
249 | } | |
250 | ||
251 | static const struct file_operations imr_state_ops = { | |
252 | .open = imr_state_open, | |
253 | .read = seq_read, | |
254 | .llseek = seq_lseek, | |
255 | .release = single_release, | |
256 | }; | |
257 | ||
258 | /** | |
259 | * imr_debugfs_register - register debugfs hooks. | |
260 | * | |
261 | * @idev: pointer to imr_device structure. | |
262 | * @return: 0 on success - errno on failure. | |
263 | */ | |
264 | static int imr_debugfs_register(struct imr_device *idev) | |
265 | { | |
266 | idev->file = debugfs_create_file("imr_state", S_IFREG | S_IRUGO, NULL, | |
267 | idev, &imr_state_ops); | |
32d39169 | 268 | return PTR_ERR_OR_ZERO(idev->file); |
28a375df BD |
269 | } |
270 | ||
271 | /** | |
272 | * imr_debugfs_unregister - unregister debugfs hooks. | |
273 | * | |
274 | * @idev: pointer to imr_device structure. | |
275 | * @return: | |
276 | */ | |
277 | static void imr_debugfs_unregister(struct imr_device *idev) | |
278 | { | |
279 | debugfs_remove(idev->file); | |
280 | } | |
281 | ||
282 | /** | |
283 | * imr_check_params - check passed address range IMR alignment and non-zero size | |
284 | * | |
285 | * @base: base address of intended IMR. | |
286 | * @size: size of intended IMR. | |
287 | * @return: zero on valid range -EINVAL on unaligned base/size. | |
288 | */ | |
289 | static int imr_check_params(phys_addr_t base, size_t size) | |
290 | { | |
291 | if ((base & IMR_MASK) || (size & IMR_MASK)) { | |
292 | pr_err("base %pa size 0x%08zx must align to 1KiB\n", | |
293 | &base, size); | |
294 | return -EINVAL; | |
295 | } | |
296 | if (size == 0) | |
297 | return -EINVAL; | |
298 | ||
299 | return 0; | |
300 | } | |
301 | ||
302 | /** | |
303 | * imr_raw_size - account for the IMR_ALIGN bytes that addr_hi appends. | |
304 | * | |
305 | * IMR addr_hi has a built in offset of plus IMR_ALIGN (0x400) bytes from the | |
306 | * value in the register. We need to subtract IMR_ALIGN bytes from input sizes | |
307 | * as a result. | |
308 | * | |
309 | * @size: input size bytes. | |
310 | * @return: reduced size. | |
311 | */ | |
312 | static inline size_t imr_raw_size(size_t size) | |
313 | { | |
314 | return size - IMR_ALIGN; | |
315 | } | |
316 | ||
317 | /** | |
318 | * imr_address_overlap - detects an address overlap. | |
319 | * | |
320 | * @addr: address to check against an existing IMR. | |
321 | * @imr: imr being checked. | |
322 | * @return: true for overlap false for no overlap. | |
323 | */ | |
324 | static inline int imr_address_overlap(phys_addr_t addr, struct imr_regs *imr) | |
325 | { | |
326 | return addr >= imr_to_phys(imr->addr_lo) && addr <= imr_to_phys(imr->addr_hi); | |
327 | } | |
328 | ||
329 | /** | |
330 | * imr_add_range - add an Isolated Memory Region. | |
331 | * | |
332 | * @base: physical base address of region aligned to 1KiB. | |
333 | * @size: physical size of region in bytes must be aligned to 1KiB. | |
334 | * @read_mask: read access mask. | |
335 | * @write_mask: write access mask. | |
336 | * @lock: indicates whether or not to permanently lock this region. | |
337 | * @return: zero on success or negative value indicating error. | |
338 | */ | |
339 | int imr_add_range(phys_addr_t base, size_t size, | |
340 | unsigned int rmask, unsigned int wmask, bool lock) | |
341 | { | |
342 | phys_addr_t end; | |
343 | unsigned int i; | |
344 | struct imr_device *idev = &imr_dev; | |
345 | struct imr_regs imr; | |
346 | size_t raw_size; | |
347 | int reg; | |
348 | int ret; | |
349 | ||
350 | if (WARN_ONCE(idev->init == false, "driver not initialized")) | |
351 | return -ENODEV; | |
352 | ||
353 | ret = imr_check_params(base, size); | |
354 | if (ret) | |
355 | return ret; | |
356 | ||
357 | /* Tweak the size value. */ | |
358 | raw_size = imr_raw_size(size); | |
359 | end = base + raw_size; | |
360 | ||
361 | /* | |
362 | * Check for reserved IMR value common to firmware, kernel and grub | |
363 | * indicating a disabled IMR. | |
364 | */ | |
365 | imr.addr_lo = phys_to_imr(base); | |
366 | imr.addr_hi = phys_to_imr(end); | |
367 | imr.rmask = rmask; | |
368 | imr.wmask = wmask; | |
369 | if (!imr_is_enabled(&imr)) | |
370 | return -ENOTSUPP; | |
371 | ||
372 | mutex_lock(&idev->lock); | |
373 | ||
374 | /* | |
375 | * Find a free IMR while checking for an existing overlapping range. | |
376 | * Note there's no restriction in silicon to prevent IMR overlaps. | |
377 | * For the sake of simplicity and ease in defining/debugging an IMR | |
378 | * memory map we exclude IMR overlaps. | |
379 | */ | |
380 | reg = -1; | |
381 | for (i = 0; i < idev->max_imr; i++) { | |
382 | ret = imr_read(idev, i, &imr); | |
383 | if (ret) | |
384 | goto failed; | |
385 | ||
386 | /* Find overlap @ base or end of requested range. */ | |
387 | ret = -EINVAL; | |
388 | if (imr_is_enabled(&imr)) { | |
389 | if (imr_address_overlap(base, &imr)) | |
390 | goto failed; | |
391 | if (imr_address_overlap(end, &imr)) | |
392 | goto failed; | |
393 | } else { | |
394 | reg = i; | |
395 | } | |
396 | } | |
397 | ||
398 | /* Error out if we have no free IMR entries. */ | |
399 | if (reg == -1) { | |
400 | ret = -ENOMEM; | |
401 | goto failed; | |
402 | } | |
403 | ||
404 | pr_debug("add %d phys %pa-%pa size %zx mask 0x%08x wmask 0x%08x\n", | |
405 | reg, &base, &end, raw_size, rmask, wmask); | |
406 | ||
407 | /* Enable IMR at specified range and access mask. */ | |
408 | imr.addr_lo = phys_to_imr(base); | |
409 | imr.addr_hi = phys_to_imr(end); | |
410 | imr.rmask = rmask; | |
411 | imr.wmask = wmask; | |
412 | ||
413 | ret = imr_write(idev, reg, &imr, lock); | |
414 | if (ret < 0) { | |
415 | /* | |
416 | * In the highly unlikely event iosf_mbi_write failed | |
417 | * attempt to rollback the IMR setup skipping the trapping | |
418 | * of further IOSF write failures. | |
419 | */ | |
420 | imr.addr_lo = 0; | |
421 | imr.addr_hi = 0; | |
422 | imr.rmask = IMR_READ_ACCESS_ALL; | |
423 | imr.wmask = IMR_WRITE_ACCESS_ALL; | |
424 | imr_write(idev, reg, &imr, false); | |
425 | } | |
426 | failed: | |
427 | mutex_unlock(&idev->lock); | |
428 | return ret; | |
429 | } | |
430 | EXPORT_SYMBOL_GPL(imr_add_range); | |
431 | ||
432 | /** | |
433 | * __imr_remove_range - delete an Isolated Memory Region. | |
434 | * | |
435 | * This function allows you to delete an IMR by its index specified by reg or | |
436 | * by address range specified by base and size respectively. If you specify an | |
437 | * index on its own the base and size parameters are ignored. | |
438 | * imr_remove_range(0, base, size); delete IMR at index 0 base/size ignored. | |
439 | * imr_remove_range(-1, base, size); delete IMR from base to base+size. | |
440 | * | |
441 | * @reg: imr index to remove. | |
442 | * @base: physical base address of region aligned to 1 KiB. | |
443 | * @size: physical size of region in bytes aligned to 1 KiB. | |
444 | * @return: -EINVAL on invalid range or out or range id | |
445 | * -ENODEV if reg is valid but no IMR exists or is locked | |
446 | * 0 on success. | |
447 | */ | |
448 | static int __imr_remove_range(int reg, phys_addr_t base, size_t size) | |
449 | { | |
450 | phys_addr_t end; | |
451 | bool found = false; | |
452 | unsigned int i; | |
453 | struct imr_device *idev = &imr_dev; | |
454 | struct imr_regs imr; | |
455 | size_t raw_size; | |
456 | int ret = 0; | |
457 | ||
458 | if (WARN_ONCE(idev->init == false, "driver not initialized")) | |
459 | return -ENODEV; | |
460 | ||
461 | /* | |
462 | * Validate address range if deleting by address, else we are | |
463 | * deleting by index where base and size will be ignored. | |
464 | */ | |
465 | if (reg == -1) { | |
466 | ret = imr_check_params(base, size); | |
467 | if (ret) | |
468 | return ret; | |
469 | } | |
470 | ||
471 | /* Tweak the size value. */ | |
472 | raw_size = imr_raw_size(size); | |
473 | end = base + raw_size; | |
474 | ||
475 | mutex_lock(&idev->lock); | |
476 | ||
477 | if (reg >= 0) { | |
478 | /* If a specific IMR is given try to use it. */ | |
479 | ret = imr_read(idev, reg, &imr); | |
480 | if (ret) | |
481 | goto failed; | |
482 | ||
483 | if (!imr_is_enabled(&imr) || imr.addr_lo & IMR_LOCK) { | |
484 | ret = -ENODEV; | |
485 | goto failed; | |
486 | } | |
487 | found = true; | |
488 | } else { | |
489 | /* Search for match based on address range. */ | |
490 | for (i = 0; i < idev->max_imr; i++) { | |
491 | ret = imr_read(idev, i, &imr); | |
492 | if (ret) | |
493 | goto failed; | |
494 | ||
495 | if (!imr_is_enabled(&imr) || imr.addr_lo & IMR_LOCK) | |
496 | continue; | |
497 | ||
498 | if ((imr_to_phys(imr.addr_lo) == base) && | |
499 | (imr_to_phys(imr.addr_hi) == end)) { | |
500 | found = true; | |
501 | reg = i; | |
502 | break; | |
503 | } | |
504 | } | |
505 | } | |
506 | ||
507 | if (!found) { | |
508 | ret = -ENODEV; | |
509 | goto failed; | |
510 | } | |
511 | ||
512 | pr_debug("remove %d phys %pa-%pa size %zx\n", reg, &base, &end, raw_size); | |
513 | ||
514 | /* Tear down the IMR. */ | |
515 | imr.addr_lo = 0; | |
516 | imr.addr_hi = 0; | |
517 | imr.rmask = IMR_READ_ACCESS_ALL; | |
518 | imr.wmask = IMR_WRITE_ACCESS_ALL; | |
519 | ||
520 | ret = imr_write(idev, reg, &imr, false); | |
521 | ||
522 | failed: | |
523 | mutex_unlock(&idev->lock); | |
524 | return ret; | |
525 | } | |
526 | ||
527 | /** | |
528 | * imr_remove_range - delete an Isolated Memory Region by address | |
529 | * | |
530 | * This function allows you to delete an IMR by an address range specified | |
531 | * by base and size respectively. | |
532 | * imr_remove_range(base, size); delete IMR from base to base+size. | |
533 | * | |
534 | * @base: physical base address of region aligned to 1 KiB. | |
535 | * @size: physical size of region in bytes aligned to 1 KiB. | |
536 | * @return: -EINVAL on invalid range or out or range id | |
537 | * -ENODEV if reg is valid but no IMR exists or is locked | |
538 | * 0 on success. | |
539 | */ | |
540 | int imr_remove_range(phys_addr_t base, size_t size) | |
541 | { | |
542 | return __imr_remove_range(-1, base, size); | |
543 | } | |
544 | EXPORT_SYMBOL_GPL(imr_remove_range); | |
545 | ||
546 | /** | |
547 | * imr_clear - delete an Isolated Memory Region by index | |
548 | * | |
549 | * This function allows you to delete an IMR by an address range specified | |
550 | * by the index of the IMR. Useful for initial sanitization of the IMR | |
551 | * address map. | |
552 | * imr_ge(base, size); delete IMR from base to base+size. | |
553 | * | |
554 | * @reg: imr index to remove. | |
555 | * @return: -EINVAL on invalid range or out or range id | |
556 | * -ENODEV if reg is valid but no IMR exists or is locked | |
557 | * 0 on success. | |
558 | */ | |
559 | static inline int imr_clear(int reg) | |
560 | { | |
561 | return __imr_remove_range(reg, 0, 0); | |
562 | } | |
563 | ||
564 | /** | |
565 | * imr_fixup_memmap - Tear down IMRs used during bootup. | |
566 | * | |
567 | * BIOS and Grub both setup IMRs around compressed kernel, initrd memory | |
568 | * that need to be removed before the kernel hands out one of the IMR | |
569 | * encased addresses to a downstream DMA agent such as the SD or Ethernet. | |
570 | * IMRs on Galileo are setup to immediately reset the system on violation. | |
571 | * As a result if you're running a root filesystem from SD - you'll need | |
572 | * the boot-time IMRs torn down or you'll find seemingly random resets when | |
573 | * using your filesystem. | |
574 | * | |
575 | * @idev: pointer to imr_device structure. | |
576 | * @return: | |
577 | */ | |
578 | static void __init imr_fixup_memmap(struct imr_device *idev) | |
579 | { | |
580 | phys_addr_t base = virt_to_phys(&_text); | |
581 | size_t size = virt_to_phys(&__end_rodata) - base; | |
582 | int i; | |
583 | int ret; | |
584 | ||
585 | /* Tear down all existing unlocked IMRs. */ | |
586 | for (i = 0; i < idev->max_imr; i++) | |
587 | imr_clear(i); | |
588 | ||
589 | /* | |
590 | * Setup a locked IMR around the physical extent of the kernel | |
591 | * from the beginning of the .text secton to the end of the | |
592 | * .rodata section as one physically contiguous block. | |
593 | */ | |
594 | ret = imr_add_range(base, size, IMR_CPU, IMR_CPU, true); | |
595 | if (ret < 0) { | |
596 | pr_err("unable to setup IMR for kernel: (%p - %p)\n", | |
597 | &_text, &__end_rodata); | |
598 | } else { | |
599 | pr_info("protecting kernel .text - .rodata: %zu KiB (%p - %p)\n", | |
600 | size / 1024, &_text, &__end_rodata); | |
601 | } | |
602 | ||
603 | } | |
604 | ||
605 | static const struct x86_cpu_id imr_ids[] __initconst = { | |
606 | { X86_VENDOR_INTEL, 5, 9 }, /* Intel Quark SoC X1000. */ | |
607 | {} | |
608 | }; | |
609 | MODULE_DEVICE_TABLE(x86cpu, imr_ids); | |
610 | ||
611 | /** | |
612 | * imr_init - entry point for IMR driver. | |
613 | * | |
614 | * return: -ENODEV for no IMR support 0 if good to go. | |
615 | */ | |
616 | static int __init imr_init(void) | |
617 | { | |
618 | struct imr_device *idev = &imr_dev; | |
619 | int ret; | |
620 | ||
621 | if (!x86_match_cpu(imr_ids) || !iosf_mbi_available()) | |
622 | return -ENODEV; | |
623 | ||
624 | idev->max_imr = QUARK_X1000_IMR_MAX; | |
625 | idev->reg_base = QUARK_X1000_IMR_REGBASE; | |
626 | idev->init = true; | |
627 | ||
628 | mutex_init(&idev->lock); | |
629 | ret = imr_debugfs_register(idev); | |
630 | if (ret != 0) | |
631 | pr_warn("debugfs register failed!\n"); | |
632 | imr_fixup_memmap(idev); | |
633 | return 0; | |
634 | } | |
635 | ||
636 | /** | |
637 | * imr_exit - exit point for IMR code. | |
638 | * | |
639 | * Deregisters debugfs, leave IMR state as-is. | |
640 | * | |
641 | * return: | |
642 | */ | |
643 | static void __exit imr_exit(void) | |
644 | { | |
645 | imr_debugfs_unregister(&imr_dev); | |
646 | } | |
647 | ||
648 | module_init(imr_init); | |
649 | module_exit(imr_exit); | |
650 | ||
651 | MODULE_AUTHOR("Bryan O'Donoghue <pure.logic@nexus-software.ie>"); | |
652 | MODULE_DESCRIPTION("Intel Isolated Memory Region driver"); | |
653 | MODULE_LICENSE("Dual BSD/GPL"); |