4 * Copyright(c) 2013 Intel Corporation.
5 * Copyright(c) 2015 Bryan O'Donoghue <pure.logic@nexus-software.ie>
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
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.
18 * This code is based on the Linux MTRR code and reference code from
19 * Intel's Quark BSP EFI, Linux and grub code.
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
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27 #include <asm-generic/sections.h>
28 #include <asm/cpu_device_id.h>
30 #include <asm/iosf_mbi.h>
31 #include <linux/debugfs.h>
32 #include <linux/init.h>
34 #include <linux/module.h>
35 #include <linux/types.h>
45 static struct imr_device imr_dev
;
48 * IMR read/write mask control registers.
49 * See quark-x1000-datasheet.pdf sections 12.7.4.5 and 12.7.4.6 for
55 * 23:2 1 KiB aligned lo address
60 * 23:2 1 KiB aligned hi address
63 #define IMR_LOCK BIT(31)
72 #define IMR_NUM_REGS (sizeof(struct imr_regs)/sizeof(u32))
74 #define imr_to_phys(x) ((x) << IMR_SHIFT)
75 #define phys_to_imr(x) ((x) >> IMR_SHIFT)
78 * imr_is_enabled - true if an IMR is enabled false otherwise.
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
88 * @imr: pointer to IMR descriptor.
89 * @return: true if IMR enabled false if disabled.
91 static inline int imr_is_enabled(struct imr_regs
*imr
)
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);
100 * imr_read - read an IMR at a given index.
102 * Requires caller to hold imr mutex.
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.
109 static int imr_read(struct imr_device
*idev
, u32 imr_id
, struct imr_regs
*imr
)
111 u32 reg
= imr_id
* IMR_NUM_REGS
+ idev
->reg_base
;
114 ret
= iosf_mbi_read(QRK_MBI_UNIT_MM
, MBI_REG_READ
, reg
++, &imr
->addr_lo
);
118 ret
= iosf_mbi_read(QRK_MBI_UNIT_MM
, MBI_REG_READ
, reg
++, &imr
->addr_hi
);
122 ret
= iosf_mbi_read(QRK_MBI_UNIT_MM
, MBI_REG_READ
, reg
++, &imr
->rmask
);
126 return iosf_mbi_read(QRK_MBI_UNIT_MM
, MBI_REG_READ
, reg
++, &imr
->wmask
);
130 * imr_write - write an IMR at a given index.
132 * Requires caller to hold imr mutex.
133 * Note lock bits need to be written independently of address bits.
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.
141 static int imr_write(struct imr_device
*idev
, u32 imr_id
,
142 struct imr_regs
*imr
, bool lock
)
145 u32 reg
= imr_id
* IMR_NUM_REGS
+ idev
->reg_base
;
148 local_irq_save(flags
);
150 ret
= iosf_mbi_write(QRK_MBI_UNIT_MM
, MBI_REG_WRITE
, reg
++, imr
->addr_lo
);
154 ret
= iosf_mbi_write(QRK_MBI_UNIT_MM
, MBI_REG_WRITE
, reg
++, imr
->addr_hi
);
158 ret
= iosf_mbi_write(QRK_MBI_UNIT_MM
, MBI_REG_WRITE
, reg
++, imr
->rmask
);
162 ret
= iosf_mbi_write(QRK_MBI_UNIT_MM
, MBI_REG_WRITE
, reg
++, imr
->wmask
);
166 /* Lock bit must be set separately to addr_lo address bits. */
168 imr
->addr_lo
|= IMR_LOCK
;
169 ret
= iosf_mbi_write(QRK_MBI_UNIT_MM
, MBI_REG_WRITE
,
170 reg
- IMR_NUM_REGS
, imr
->addr_lo
);
175 local_irq_restore(flags
);
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.
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
);
191 * imr_dbgfs_state_show - print state of IMR registers.
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.
197 static int imr_dbgfs_state_show(struct seq_file
*s
, void *unused
)
202 struct imr_device
*idev
= s
->private;
207 mutex_lock(&idev
->lock
);
209 for (i
= 0; i
< idev
->max_imr
; i
++) {
211 ret
= imr_read(idev
, i
, &imr
);
216 * Remember to add IMR_ALIGN bytes to size to indicate the
217 * inherent IMR_ALIGN size bytes contained in the masked away
220 if (imr_is_enabled(&imr
)) {
221 base
= imr_to_phys(imr
.addr_lo
);
222 end
= imr_to_phys(imr
.addr_hi
) + IMR_MASK
;
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");
235 mutex_unlock(&idev
->lock
);
240 * imr_state_open - debugfs open callback.
242 * @inode: pointer to struct inode.
243 * @file: pointer to struct file.
244 * @return: result of single open.
246 static int imr_state_open(struct inode
*inode
, struct file
*file
)
248 return single_open(file
, imr_dbgfs_state_show
, inode
->i_private
);
251 static const struct file_operations imr_state_ops
= {
252 .open
= imr_state_open
,
255 .release
= single_release
,
259 * imr_debugfs_register - register debugfs hooks.
261 * @idev: pointer to imr_device structure.
262 * @return: 0 on success - errno on failure.
264 static int imr_debugfs_register(struct imr_device
*idev
)
266 idev
->file
= debugfs_create_file("imr_state", S_IFREG
| S_IRUGO
, NULL
,
267 idev
, &imr_state_ops
);
268 return PTR_ERR_OR_ZERO(idev
->file
);
272 * imr_debugfs_unregister - unregister debugfs hooks.
274 * @idev: pointer to imr_device structure.
277 static void imr_debugfs_unregister(struct imr_device
*idev
)
279 debugfs_remove(idev
->file
);
283 * imr_check_params - check passed address range IMR alignment and non-zero size
285 * @base: base address of intended IMR.
286 * @size: size of intended IMR.
287 * @return: zero on valid range -EINVAL on unaligned base/size.
289 static int imr_check_params(phys_addr_t base
, size_t size
)
291 if ((base
& IMR_MASK
) || (size
& IMR_MASK
)) {
292 pr_err("base %pa size 0x%08zx must align to 1KiB\n",
303 * imr_raw_size - account for the IMR_ALIGN bytes that addr_hi appends.
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
309 * @size: input size bytes.
310 * @return: reduced size.
312 static inline size_t imr_raw_size(size_t size
)
314 return size
- IMR_ALIGN
;
318 * imr_address_overlap - detects an address overlap.
320 * @addr: address to check against an existing IMR.
321 * @imr: imr being checked.
322 * @return: true for overlap false for no overlap.
324 static inline int imr_address_overlap(phys_addr_t addr
, struct imr_regs
*imr
)
326 return addr
>= imr_to_phys(imr
->addr_lo
) && addr
<= imr_to_phys(imr
->addr_hi
);
330 * imr_add_range - add an Isolated Memory Region.
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.
339 int imr_add_range(phys_addr_t base
, size_t size
,
340 unsigned int rmask
, unsigned int wmask
, bool lock
)
344 struct imr_device
*idev
= &imr_dev
;
350 if (WARN_ONCE(idev
->init
== false, "driver not initialized"))
353 ret
= imr_check_params(base
, size
);
357 /* Tweak the size value. */
358 raw_size
= imr_raw_size(size
);
359 end
= base
+ raw_size
;
362 * Check for reserved IMR value common to firmware, kernel and grub
363 * indicating a disabled IMR.
365 imr
.addr_lo
= phys_to_imr(base
);
366 imr
.addr_hi
= phys_to_imr(end
);
369 if (!imr_is_enabled(&imr
))
372 mutex_lock(&idev
->lock
);
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.
381 for (i
= 0; i
< idev
->max_imr
; i
++) {
382 ret
= imr_read(idev
, i
, &imr
);
386 /* Find overlap @ base or end of requested range. */
388 if (imr_is_enabled(&imr
)) {
389 if (imr_address_overlap(base
, &imr
))
391 if (imr_address_overlap(end
, &imr
))
398 /* Error out if we have no free IMR entries. */
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
);
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
);
413 ret
= imr_write(idev
, reg
, &imr
, lock
);
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.
422 imr
.rmask
= IMR_READ_ACCESS_ALL
;
423 imr
.wmask
= IMR_WRITE_ACCESS_ALL
;
424 imr_write(idev
, reg
, &imr
, false);
427 mutex_unlock(&idev
->lock
);
430 EXPORT_SYMBOL_GPL(imr_add_range
);
433 * __imr_remove_range - delete an Isolated Memory Region.
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.
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
448 static int __imr_remove_range(int reg
, phys_addr_t base
, size_t size
)
453 struct imr_device
*idev
= &imr_dev
;
458 if (WARN_ONCE(idev
->init
== false, "driver not initialized"))
462 * Validate address range if deleting by address, else we are
463 * deleting by index where base and size will be ignored.
466 ret
= imr_check_params(base
, size
);
471 /* Tweak the size value. */
472 raw_size
= imr_raw_size(size
);
473 end
= base
+ raw_size
;
475 mutex_lock(&idev
->lock
);
478 /* If a specific IMR is given try to use it. */
479 ret
= imr_read(idev
, reg
, &imr
);
483 if (!imr_is_enabled(&imr
) || imr
.addr_lo
& IMR_LOCK
) {
489 /* Search for match based on address range. */
490 for (i
= 0; i
< idev
->max_imr
; i
++) {
491 ret
= imr_read(idev
, i
, &imr
);
495 if (!imr_is_enabled(&imr
) || imr
.addr_lo
& IMR_LOCK
)
498 if ((imr_to_phys(imr
.addr_lo
) == base
) &&
499 (imr_to_phys(imr
.addr_hi
) == end
)) {
512 pr_debug("remove %d phys %pa-%pa size %zx\n", reg
, &base
, &end
, raw_size
);
514 /* Tear down the IMR. */
517 imr
.rmask
= IMR_READ_ACCESS_ALL
;
518 imr
.wmask
= IMR_WRITE_ACCESS_ALL
;
520 ret
= imr_write(idev
, reg
, &imr
, false);
523 mutex_unlock(&idev
->lock
);
528 * imr_remove_range - delete an Isolated Memory Region by address
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.
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
540 int imr_remove_range(phys_addr_t base
, size_t size
)
542 return __imr_remove_range(-1, base
, size
);
544 EXPORT_SYMBOL_GPL(imr_remove_range
);
547 * imr_clear - delete an Isolated Memory Region by index
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
552 * imr_ge(base, size); delete IMR from base to base+size.
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
559 static inline int imr_clear(int reg
)
561 return __imr_remove_range(reg
, 0, 0);
565 * imr_fixup_memmap - Tear down IMRs used during bootup.
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.
575 * @idev: pointer to imr_device structure.
578 static void __init
imr_fixup_memmap(struct imr_device
*idev
)
580 phys_addr_t base
= virt_to_phys(&_text
);
581 size_t size
= virt_to_phys(&__end_rodata
) - base
;
585 /* Tear down all existing unlocked IMRs. */
586 for (i
= 0; i
< idev
->max_imr
; i
++)
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.
594 ret
= imr_add_range(base
, size
, IMR_CPU
, IMR_CPU
, true);
596 pr_err("unable to setup IMR for kernel: (%p - %p)\n",
597 &_text
, &__end_rodata
);
599 pr_info("protecting kernel .text - .rodata: %zu KiB (%p - %p)\n",
600 size
/ 1024, &_text
, &__end_rodata
);
605 static const struct x86_cpu_id imr_ids
[] __initconst
= {
606 { X86_VENDOR_INTEL
, 5, 9 }, /* Intel Quark SoC X1000. */
609 MODULE_DEVICE_TABLE(x86cpu
, imr_ids
);
612 * imr_init - entry point for IMR driver.
614 * return: -ENODEV for no IMR support 0 if good to go.
616 static int __init
imr_init(void)
618 struct imr_device
*idev
= &imr_dev
;
621 if (!x86_match_cpu(imr_ids
) || !iosf_mbi_available())
624 idev
->max_imr
= QUARK_X1000_IMR_MAX
;
625 idev
->reg_base
= QUARK_X1000_IMR_REGBASE
;
628 mutex_init(&idev
->lock
);
629 ret
= imr_debugfs_register(idev
);
631 pr_warn("debugfs register failed!\n");
632 imr_fixup_memmap(idev
);
637 * imr_exit - exit point for IMR code.
639 * Deregisters debugfs, leave IMR state as-is.
643 static void __exit
imr_exit(void)
645 imr_debugfs_unregister(&imr_dev
);
648 module_init(imr_init
);
649 module_exit(imr_exit
);
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");