blob: c1bdafaac3ca828cec43af9e43d12933e4de7ea9 [file] [log] [blame]
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +00001/**
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
37struct imr_device {
38 struct dentry *file;
39 bool init;
40 struct mutex lock;
41 int max_imr;
42 int reg_base;
43};
44
45static 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
65struct 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 */
91static 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 */
109static 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
Andy Shevchenko4077a382015-11-11 19:59:29 +0200114 ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->addr_lo);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000115 if (ret)
116 return ret;
117
Andy Shevchenko4077a382015-11-11 19:59:29 +0200118 ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->addr_hi);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000119 if (ret)
120 return ret;
121
Andy Shevchenko4077a382015-11-11 19:59:29 +0200122 ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->rmask);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000123 if (ret)
124 return ret;
125
Andy Shevchenko4077a382015-11-11 19:59:29 +0200126 return iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->wmask);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000127}
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 */
141static 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
Andy Shevchenko4077a382015-11-11 19:59:29 +0200150 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->addr_lo);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000151 if (ret)
152 goto failed;
153
Andy Shevchenko4077a382015-11-11 19:59:29 +0200154 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->addr_hi);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000155 if (ret)
156 goto failed;
157
Andy Shevchenko4077a382015-11-11 19:59:29 +0200158 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->rmask);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000159 if (ret)
160 goto failed;
161
Andy Shevchenko4077a382015-11-11 19:59:29 +0200162 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->wmask);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000163 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;
Andy Shevchenko4077a382015-11-11 19:59:29 +0200169 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE,
170 reg - IMR_NUM_REGS, imr->addr_lo);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000171 if (ret)
172 goto failed;
173 }
174
175 local_irq_restore(flags);
176 return 0;
177failed:
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 */
197static 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 */
246static 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
251static 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 */
264static 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);
Fengguang Wu32d39162015-02-19 16:14:32 +0800268 return PTR_ERR_OR_ZERO(idev->file);
Bryan O'Donoghue28a375d2015-01-30 16:29:38 +0000269}
270
271/**
272 * imr_debugfs_unregister - unregister debugfs hooks.
273 *
274 * @idev: pointer to imr_device structure.
275 * @return:
276 */
277static 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 */
289static 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 */
312static 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 */
324static 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 */
339int 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 }
426failed:
427 mutex_unlock(&idev->lock);
428 return ret;
429}
430EXPORT_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 */
448static 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
522failed:
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 */
540int imr_remove_range(phys_addr_t base, size_t size)
541{
542 return __imr_remove_range(-1, base, size);
543}
544EXPORT_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 */
559static 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 */
578static 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
605static const struct x86_cpu_id imr_ids[] __initconst = {
606 { X86_VENDOR_INTEL, 5, 9 }, /* Intel Quark SoC X1000. */
607 {}
608};
609MODULE_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 */
616static 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 */
643static void __exit imr_exit(void)
644{
645 imr_debugfs_unregister(&imr_dev);
646}
647
648module_init(imr_init);
649module_exit(imr_exit);
650
651MODULE_AUTHOR("Bryan O'Donoghue <pure.logic@nexus-software.ie>");
652MODULE_DESCRIPTION("Intel Isolated Memory Region driver");
653MODULE_LICENSE("Dual BSD/GPL");