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