1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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/types.h>
35
36struct imr_device {
37 struct dentry *file;
38 bool init;
39 struct mutex lock;
40 int max_imr;
41 int reg_base;
42};
43
44static struct imr_device imr_dev;
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62#define IMR_LOCK BIT(31)
63
64struct imr_regs {
65 u32 addr_lo;
66 u32 addr_hi;
67 u32 rmask;
68 u32 wmask;
69};
70
71#define IMR_NUM_REGS (sizeof(struct imr_regs)/sizeof(u32))
72#define IMR_SHIFT 8
73#define imr_to_phys(x) ((x) << IMR_SHIFT)
74#define phys_to_imr(x) ((x) >> IMR_SHIFT)
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90static inline int imr_is_enabled(struct imr_regs *imr)
91{
92 return !(imr->rmask == IMR_READ_ACCESS_ALL &&
93 imr->wmask == IMR_WRITE_ACCESS_ALL &&
94 imr_to_phys(imr->addr_lo) == 0 &&
95 imr_to_phys(imr->addr_hi) == 0);
96}
97
98
99
100
101
102
103
104
105
106
107
108static int imr_read(struct imr_device *idev, u32 imr_id, struct imr_regs *imr)
109{
110 u32 reg = imr_id * IMR_NUM_REGS + idev->reg_base;
111 int ret;
112
113 ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->addr_lo);
114 if (ret)
115 return ret;
116
117 ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->addr_hi);
118 if (ret)
119 return ret;
120
121 ret = iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->rmask);
122 if (ret)
123 return ret;
124
125 return iosf_mbi_read(QRK_MBI_UNIT_MM, MBI_REG_READ, reg++, &imr->wmask);
126}
127
128
129
130
131
132
133
134
135
136
137
138
139static int imr_write(struct imr_device *idev, u32 imr_id, struct imr_regs *imr)
140{
141 unsigned long flags;
142 u32 reg = imr_id * IMR_NUM_REGS + idev->reg_base;
143 int ret;
144
145 local_irq_save(flags);
146
147 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->addr_lo);
148 if (ret)
149 goto failed;
150
151 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->addr_hi);
152 if (ret)
153 goto failed;
154
155 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->rmask);
156 if (ret)
157 goto failed;
158
159 ret = iosf_mbi_write(QRK_MBI_UNIT_MM, MBI_REG_WRITE, reg++, imr->wmask);
160 if (ret)
161 goto failed;
162
163 local_irq_restore(flags);
164 return 0;
165failed:
166
167
168
169
170
171 local_irq_restore(flags);
172 WARN(ret, "IOSF-MBI write fail range 0x%08x-0x%08x unreliable\n",
173 imr_to_phys(imr->addr_lo), imr_to_phys(imr->addr_hi) + IMR_MASK);
174
175 return ret;
176}
177
178
179
180
181
182
183
184
185static int imr_dbgfs_state_show(struct seq_file *s, void *unused)
186{
187 phys_addr_t base;
188 phys_addr_t end;
189 int i;
190 struct imr_device *idev = s->private;
191 struct imr_regs imr;
192 size_t size;
193 int ret = -ENODEV;
194
195 mutex_lock(&idev->lock);
196
197 for (i = 0; i < idev->max_imr; i++) {
198
199 ret = imr_read(idev, i, &imr);
200 if (ret)
201 break;
202
203
204
205
206
207
208 if (imr_is_enabled(&imr)) {
209 base = imr_to_phys(imr.addr_lo);
210 end = imr_to_phys(imr.addr_hi) + IMR_MASK;
211 size = end - base + 1;
212 } else {
213 base = 0;
214 end = 0;
215 size = 0;
216 }
217 seq_printf(s, "imr%02i: base=%pa, end=%pa, size=0x%08zx "
218 "rmask=0x%08x, wmask=0x%08x, %s, %s\n", i,
219 &base, &end, size, imr.rmask, imr.wmask,
220 imr_is_enabled(&imr) ? "enabled " : "disabled",
221 imr.addr_lo & IMR_LOCK ? "locked" : "unlocked");
222 }
223
224 mutex_unlock(&idev->lock);
225 return ret;
226}
227
228
229
230
231
232
233
234
235static int imr_state_open(struct inode *inode, struct file *file)
236{
237 return single_open(file, imr_dbgfs_state_show, inode->i_private);
238}
239
240static const struct file_operations imr_state_ops = {
241 .open = imr_state_open,
242 .read = seq_read,
243 .llseek = seq_lseek,
244 .release = single_release,
245};
246
247
248
249
250
251
252
253static int imr_debugfs_register(struct imr_device *idev)
254{
255 idev->file = debugfs_create_file("imr_state", S_IFREG | S_IRUGO, NULL,
256 idev, &imr_state_ops);
257 return PTR_ERR_OR_ZERO(idev->file);
258}
259
260
261
262
263
264
265
266
267static int imr_check_params(phys_addr_t base, size_t size)
268{
269 if ((base & IMR_MASK) || (size & IMR_MASK)) {
270 pr_err("base %pa size 0x%08zx must align to 1KiB\n",
271 &base, size);
272 return -EINVAL;
273 }
274 if (size == 0)
275 return -EINVAL;
276
277 return 0;
278}
279
280
281
282
283
284
285
286
287
288
289
290static inline size_t imr_raw_size(size_t size)
291{
292 return size - IMR_ALIGN;
293}
294
295
296
297
298
299
300
301
302static inline int imr_address_overlap(phys_addr_t addr, struct imr_regs *imr)
303{
304 return addr >= imr_to_phys(imr->addr_lo) && addr <= imr_to_phys(imr->addr_hi);
305}
306
307
308
309
310
311
312
313
314
315
316int imr_add_range(phys_addr_t base, size_t size,
317 unsigned int rmask, unsigned int wmask)
318{
319 phys_addr_t end;
320 unsigned int i;
321 struct imr_device *idev = &imr_dev;
322 struct imr_regs imr;
323 size_t raw_size;
324 int reg;
325 int ret;
326
327 if (WARN_ONCE(idev->init == false, "driver not initialized"))
328 return -ENODEV;
329
330 ret = imr_check_params(base, size);
331 if (ret)
332 return ret;
333
334
335 raw_size = imr_raw_size(size);
336 end = base + raw_size;
337
338
339
340
341
342 imr.addr_lo = phys_to_imr(base);
343 imr.addr_hi = phys_to_imr(end);
344 imr.rmask = rmask;
345 imr.wmask = wmask;
346 if (!imr_is_enabled(&imr))
347 return -ENOTSUPP;
348
349 mutex_lock(&idev->lock);
350
351
352
353
354
355
356
357 reg = -1;
358 for (i = 0; i < idev->max_imr; i++) {
359 ret = imr_read(idev, i, &imr);
360 if (ret)
361 goto failed;
362
363
364 ret = -EINVAL;
365 if (imr_is_enabled(&imr)) {
366 if (imr_address_overlap(base, &imr))
367 goto failed;
368 if (imr_address_overlap(end, &imr))
369 goto failed;
370 } else {
371 reg = i;
372 }
373 }
374
375
376 if (reg == -1) {
377 ret = -ENOMEM;
378 goto failed;
379 }
380
381 pr_debug("add %d phys %pa-%pa size %zx mask 0x%08x wmask 0x%08x\n",
382 reg, &base, &end, raw_size, rmask, wmask);
383
384
385 imr.addr_lo = phys_to_imr(base);
386 imr.addr_hi = phys_to_imr(end);
387 imr.rmask = rmask;
388 imr.wmask = wmask;
389
390 ret = imr_write(idev, reg, &imr);
391 if (ret < 0) {
392
393
394
395
396
397 imr.addr_lo = 0;
398 imr.addr_hi = 0;
399 imr.rmask = IMR_READ_ACCESS_ALL;
400 imr.wmask = IMR_WRITE_ACCESS_ALL;
401 imr_write(idev, reg, &imr);
402 }
403failed:
404 mutex_unlock(&idev->lock);
405 return ret;
406}
407EXPORT_SYMBOL_GPL(imr_add_range);
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425static int __imr_remove_range(int reg, phys_addr_t base, size_t size)
426{
427 phys_addr_t end;
428 bool found = false;
429 unsigned int i;
430 struct imr_device *idev = &imr_dev;
431 struct imr_regs imr;
432 size_t raw_size;
433 int ret = 0;
434
435 if (WARN_ONCE(idev->init == false, "driver not initialized"))
436 return -ENODEV;
437
438
439
440
441
442 if (reg == -1) {
443 ret = imr_check_params(base, size);
444 if (ret)
445 return ret;
446 }
447
448
449 raw_size = imr_raw_size(size);
450 end = base + raw_size;
451
452 mutex_lock(&idev->lock);
453
454 if (reg >= 0) {
455
456 ret = imr_read(idev, reg, &imr);
457 if (ret)
458 goto failed;
459
460 if (!imr_is_enabled(&imr) || imr.addr_lo & IMR_LOCK) {
461 ret = -ENODEV;
462 goto failed;
463 }
464 found = true;
465 } else {
466
467 for (i = 0; i < idev->max_imr; i++) {
468 ret = imr_read(idev, i, &imr);
469 if (ret)
470 goto failed;
471
472 if (!imr_is_enabled(&imr) || imr.addr_lo & IMR_LOCK)
473 continue;
474
475 if ((imr_to_phys(imr.addr_lo) == base) &&
476 (imr_to_phys(imr.addr_hi) == end)) {
477 found = true;
478 reg = i;
479 break;
480 }
481 }
482 }
483
484 if (!found) {
485 ret = -ENODEV;
486 goto failed;
487 }
488
489 pr_debug("remove %d phys %pa-%pa size %zx\n", reg, &base, &end, raw_size);
490
491
492 imr.addr_lo = 0;
493 imr.addr_hi = 0;
494 imr.rmask = IMR_READ_ACCESS_ALL;
495 imr.wmask = IMR_WRITE_ACCESS_ALL;
496
497 ret = imr_write(idev, reg, &imr);
498
499failed:
500 mutex_unlock(&idev->lock);
501 return ret;
502}
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517int imr_remove_range(phys_addr_t base, size_t size)
518{
519 return __imr_remove_range(-1, base, size);
520}
521EXPORT_SYMBOL_GPL(imr_remove_range);
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536static inline int imr_clear(int reg)
537{
538 return __imr_remove_range(reg, 0, 0);
539}
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555static void __init imr_fixup_memmap(struct imr_device *idev)
556{
557 phys_addr_t base = virt_to_phys(&_text);
558 size_t size = virt_to_phys(&__end_rodata) - base;
559 unsigned long start, end;
560 int i;
561 int ret;
562
563
564 for (i = 0; i < idev->max_imr; i++)
565 imr_clear(i);
566
567 start = (unsigned long)_text;
568 end = (unsigned long)__end_rodata - 1;
569
570
571
572
573
574
575
576
577
578 ret = imr_add_range(base, size, IMR_CPU, IMR_CPU);
579 if (ret < 0) {
580 pr_err("unable to setup IMR for kernel: %zu KiB (%lx - %lx)\n",
581 size / 1024, start, end);
582 } else {
583 pr_info("protecting kernel .text - .rodata: %zu KiB (%lx - %lx)\n",
584 size / 1024, start, end);
585 }
586
587}
588
589static const struct x86_cpu_id imr_ids[] __initconst = {
590 { X86_VENDOR_INTEL, 5, 9 },
591 {}
592};
593
594
595
596
597
598
599static int __init imr_init(void)
600{
601 struct imr_device *idev = &imr_dev;
602 int ret;
603
604 if (!x86_match_cpu(imr_ids) || !iosf_mbi_available())
605 return -ENODEV;
606
607 idev->max_imr = QUARK_X1000_IMR_MAX;
608 idev->reg_base = QUARK_X1000_IMR_REGBASE;
609 idev->init = true;
610
611 mutex_init(&idev->lock);
612 ret = imr_debugfs_register(idev);
613 if (ret != 0)
614 pr_warn("debugfs register failed!\n");
615 imr_fixup_memmap(idev);
616 return 0;
617}
618device_initcall(imr_init);
619