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