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