This source file includes following definitions.
- imr_is_enabled
- imr_read
- imr_write
- imr_dbgfs_state_show
- imr_debugfs_register
- imr_check_params
- imr_raw_size
- imr_address_overlap
- imr_add_range
- __imr_remove_range
- imr_remove_range
- imr_clear
- imr_fixup_memmap
- imr_init
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
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 <linux/debugfs.h>
33 #include <linux/init.h>
34 #include <linux/mm.h>
35 #include <linux/types.h>
36
37 struct imr_device {
38 bool init;
39 struct mutex lock;
40 int max_imr;
41 int reg_base;
42 };
43
44 static 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
64 struct 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
90 static 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
108 static 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
139 static 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;
165 failed:
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
185 static 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 DEFINE_SHOW_ATTRIBUTE(imr_dbgfs_state);
228
229
230
231
232
233
234 static void imr_debugfs_register(struct imr_device *idev)
235 {
236 debugfs_create_file("imr_state", 0444, NULL, idev,
237 &imr_dbgfs_state_fops);
238 }
239
240
241
242
243
244
245
246
247 static int imr_check_params(phys_addr_t base, size_t size)
248 {
249 if ((base & IMR_MASK) || (size & IMR_MASK)) {
250 pr_err("base %pa size 0x%08zx must align to 1KiB\n",
251 &base, size);
252 return -EINVAL;
253 }
254 if (size == 0)
255 return -EINVAL;
256
257 return 0;
258 }
259
260
261
262
263
264
265
266
267
268
269
270 static inline size_t imr_raw_size(size_t size)
271 {
272 return size - IMR_ALIGN;
273 }
274
275
276
277
278
279
280
281
282 static inline int imr_address_overlap(phys_addr_t addr, struct imr_regs *imr)
283 {
284 return addr >= imr_to_phys(imr->addr_lo) && addr <= imr_to_phys(imr->addr_hi);
285 }
286
287
288
289
290
291
292
293
294
295
296 int imr_add_range(phys_addr_t base, size_t size,
297 unsigned int rmask, unsigned int wmask)
298 {
299 phys_addr_t end;
300 unsigned int i;
301 struct imr_device *idev = &imr_dev;
302 struct imr_regs imr;
303 size_t raw_size;
304 int reg;
305 int ret;
306
307 if (WARN_ONCE(idev->init == false, "driver not initialized"))
308 return -ENODEV;
309
310 ret = imr_check_params(base, size);
311 if (ret)
312 return ret;
313
314
315 raw_size = imr_raw_size(size);
316 end = base + raw_size;
317
318
319
320
321
322 imr.addr_lo = phys_to_imr(base);
323 imr.addr_hi = phys_to_imr(end);
324 imr.rmask = rmask;
325 imr.wmask = wmask;
326 if (!imr_is_enabled(&imr))
327 return -ENOTSUPP;
328
329 mutex_lock(&idev->lock);
330
331
332
333
334
335
336
337 reg = -1;
338 for (i = 0; i < idev->max_imr; i++) {
339 ret = imr_read(idev, i, &imr);
340 if (ret)
341 goto failed;
342
343
344 ret = -EINVAL;
345 if (imr_is_enabled(&imr)) {
346 if (imr_address_overlap(base, &imr))
347 goto failed;
348 if (imr_address_overlap(end, &imr))
349 goto failed;
350 } else {
351 reg = i;
352 }
353 }
354
355
356 if (reg == -1) {
357 ret = -ENOMEM;
358 goto failed;
359 }
360
361 pr_debug("add %d phys %pa-%pa size %zx mask 0x%08x wmask 0x%08x\n",
362 reg, &base, &end, raw_size, rmask, wmask);
363
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
370 ret = imr_write(idev, reg, &imr);
371 if (ret < 0) {
372
373
374
375
376
377 imr.addr_lo = 0;
378 imr.addr_hi = 0;
379 imr.rmask = IMR_READ_ACCESS_ALL;
380 imr.wmask = IMR_WRITE_ACCESS_ALL;
381 imr_write(idev, reg, &imr);
382 }
383 failed:
384 mutex_unlock(&idev->lock);
385 return ret;
386 }
387 EXPORT_SYMBOL_GPL(imr_add_range);
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405 static int __imr_remove_range(int reg, phys_addr_t base, size_t size)
406 {
407 phys_addr_t end;
408 bool found = false;
409 unsigned int i;
410 struct imr_device *idev = &imr_dev;
411 struct imr_regs imr;
412 size_t raw_size;
413 int ret = 0;
414
415 if (WARN_ONCE(idev->init == false, "driver not initialized"))
416 return -ENODEV;
417
418
419
420
421
422 if (reg == -1) {
423 ret = imr_check_params(base, size);
424 if (ret)
425 return ret;
426 }
427
428
429 raw_size = imr_raw_size(size);
430 end = base + raw_size;
431
432 mutex_lock(&idev->lock);
433
434 if (reg >= 0) {
435
436 ret = imr_read(idev, reg, &imr);
437 if (ret)
438 goto failed;
439
440 if (!imr_is_enabled(&imr) || imr.addr_lo & IMR_LOCK) {
441 ret = -ENODEV;
442 goto failed;
443 }
444 found = true;
445 } else {
446
447 for (i = 0; i < idev->max_imr; i++) {
448 ret = imr_read(idev, i, &imr);
449 if (ret)
450 goto failed;
451
452 if (!imr_is_enabled(&imr) || imr.addr_lo & IMR_LOCK)
453 continue;
454
455 if ((imr_to_phys(imr.addr_lo) == base) &&
456 (imr_to_phys(imr.addr_hi) == end)) {
457 found = true;
458 reg = i;
459 break;
460 }
461 }
462 }
463
464 if (!found) {
465 ret = -ENODEV;
466 goto failed;
467 }
468
469 pr_debug("remove %d phys %pa-%pa size %zx\n", reg, &base, &end, raw_size);
470
471
472 imr.addr_lo = 0;
473 imr.addr_hi = 0;
474 imr.rmask = IMR_READ_ACCESS_ALL;
475 imr.wmask = IMR_WRITE_ACCESS_ALL;
476
477 ret = imr_write(idev, reg, &imr);
478
479 failed:
480 mutex_unlock(&idev->lock);
481 return ret;
482 }
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497 int imr_remove_range(phys_addr_t base, size_t size)
498 {
499 return __imr_remove_range(-1, base, size);
500 }
501 EXPORT_SYMBOL_GPL(imr_remove_range);
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516 static inline int imr_clear(int reg)
517 {
518 return __imr_remove_range(reg, 0, 0);
519 }
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535 static void __init imr_fixup_memmap(struct imr_device *idev)
536 {
537 phys_addr_t base = virt_to_phys(&_text);
538 size_t size = virt_to_phys(&__end_rodata) - base;
539 unsigned long start, end;
540 int i;
541 int ret;
542
543
544 for (i = 0; i < idev->max_imr; i++)
545 imr_clear(i);
546
547 start = (unsigned long)_text;
548 end = (unsigned long)__end_rodata - 1;
549
550
551
552
553
554
555
556
557
558 ret = imr_add_range(base, size, IMR_CPU, IMR_CPU);
559 if (ret < 0) {
560 pr_err("unable to setup IMR for kernel: %zu KiB (%lx - %lx)\n",
561 size / 1024, start, end);
562 } else {
563 pr_info("protecting kernel .text - .rodata: %zu KiB (%lx - %lx)\n",
564 size / 1024, start, end);
565 }
566
567 }
568
569 static const struct x86_cpu_id imr_ids[] __initconst = {
570 { X86_VENDOR_INTEL, 5, 9 },
571 {}
572 };
573
574
575
576
577
578
579 static int __init imr_init(void)
580 {
581 struct imr_device *idev = &imr_dev;
582
583 if (!x86_match_cpu(imr_ids) || !iosf_mbi_available())
584 return -ENODEV;
585
586 idev->max_imr = QUARK_X1000_IMR_MAX;
587 idev->reg_base = QUARK_X1000_IMR_REGBASE;
588 idev->init = true;
589
590 mutex_init(&idev->lock);
591 imr_debugfs_register(idev);
592 imr_fixup_memmap(idev);
593 return 0;
594 }
595 device_initcall(imr_init);