1
2
3
4
5
6
7#define pr_fmt(fmt) "fsl-pamu: %s: " fmt, __func__
8
9#include "fsl_pamu.h"
10
11#include <linux/fsl/guts.h>
12#include <linux/interrupt.h>
13#include <linux/genalloc.h>
14
15#include <asm/mpc85xx.h>
16
17
18#define OMI_QMAN 0x00
19#define OMI_FMAN 0x01
20#define OMI_QMAN_PRIV 0x02
21#define OMI_CAAM 0x03
22
23#define make64(high, low) (((u64)(high) << 32) | (low))
24
25struct pamu_isr_data {
26 void __iomem *pamu_reg_base;
27 unsigned int count;
28};
29
30static struct paace *ppaact;
31static struct paace *spaact;
32
33static bool probed;
34
35
36
37
38
39
40
41
42static const struct of_device_id guts_device_ids[] = {
43 { .compatible = "fsl,qoriq-device-config-1.0", },
44 { .compatible = "fsl,qoriq-device-config-2.0", },
45 {}
46};
47
48
49
50
51
52
53
54
55
56static const struct of_device_id l3_device_ids[] = {
57 { .compatible = "fsl,t4240-l3-cache-controller", },
58 { .compatible = "fsl,b4860-l3-cache-controller", },
59 { .compatible = "fsl,p4080-l3-cache-controller", },
60 {}
61};
62
63
64static u32 max_subwindow_count;
65
66
67
68
69
70
71
72
73static struct paace *pamu_get_ppaace(int liodn)
74{
75 if (!ppaact || liodn >= PAACE_NUMBER_ENTRIES) {
76 pr_debug("PPAACT doesn't exist\n");
77 return NULL;
78 }
79
80 return &ppaact[liodn];
81}
82
83
84
85
86
87
88
89int pamu_enable_liodn(int liodn)
90{
91 struct paace *ppaace;
92
93 ppaace = pamu_get_ppaace(liodn);
94 if (!ppaace) {
95 pr_debug("Invalid primary paace entry\n");
96 return -ENOENT;
97 }
98
99 if (!get_bf(ppaace->addr_bitfields, PPAACE_AF_WSE)) {
100 pr_debug("liodn %d not configured\n", liodn);
101 return -EINVAL;
102 }
103
104
105 mb();
106
107 set_bf(ppaace->addr_bitfields, PAACE_AF_V, PAACE_V_VALID);
108 mb();
109
110 return 0;
111}
112
113
114
115
116
117
118
119int pamu_disable_liodn(int liodn)
120{
121 struct paace *ppaace;
122
123 ppaace = pamu_get_ppaace(liodn);
124 if (!ppaace) {
125 pr_debug("Invalid primary paace entry\n");
126 return -ENOENT;
127 }
128
129 set_bf(ppaace->addr_bitfields, PAACE_AF_V, PAACE_V_INVALID);
130 mb();
131
132 return 0;
133}
134
135
136static unsigned int map_addrspace_size_to_wse(phys_addr_t addrspace_size)
137{
138
139 BUG_ON(addrspace_size & (addrspace_size - 1));
140
141
142 return fls64(addrspace_size) - 2;
143}
144
145
146
147
148
149static void pamu_init_ppaace(struct paace *ppaace)
150{
151 set_bf(ppaace->addr_bitfields, PAACE_AF_PT, PAACE_PT_PRIMARY);
152
153 set_bf(ppaace->domain_attr.to_host.coherency_required, PAACE_DA_HOST_CR,
154 PAACE_M_COHERENCE_REQ);
155}
156
157
158
159
160
161int pamu_update_paace_stash(int liodn, u32 value)
162{
163 struct paace *paace;
164
165 paace = pamu_get_ppaace(liodn);
166 if (!paace) {
167 pr_debug("Invalid liodn entry\n");
168 return -ENOENT;
169 }
170 set_bf(paace->impl_attr, PAACE_IA_CID, value);
171
172 mb();
173
174 return 0;
175}
176
177
178
179
180
181
182
183
184
185
186
187
188int pamu_config_ppaace(int liodn, u32 omi, u32 stashid, int prot)
189{
190 struct paace *ppaace;
191
192 ppaace = pamu_get_ppaace(liodn);
193 if (!ppaace)
194 return -ENOENT;
195
196
197 set_bf(ppaace->addr_bitfields, PPAACE_AF_WSE,
198 map_addrspace_size_to_wse(1ULL << 36));
199
200 pamu_init_ppaace(ppaace);
201
202 ppaace->wbah = 0;
203 set_bf(ppaace->addr_bitfields, PPAACE_AF_WBAL, 0);
204
205
206 if (omi < OME_NUMBER_ENTRIES) {
207 set_bf(ppaace->impl_attr, PAACE_IA_OTM, PAACE_OTM_INDEXED);
208 ppaace->op_encode.index_ot.omi = omi;
209 } else if (~omi != 0) {
210 pr_debug("bad operation mapping index: %d\n", omi);
211 return -EINVAL;
212 }
213
214
215 if (~stashid != 0)
216 set_bf(ppaace->impl_attr, PAACE_IA_CID, stashid);
217
218 set_bf(ppaace->impl_attr, PAACE_IA_ATM, PAACE_ATM_WINDOW_XLATE);
219 ppaace->twbah = 0;
220 set_bf(ppaace->win_bitfields, PAACE_WIN_TWBAL, 0);
221 set_bf(ppaace->addr_bitfields, PAACE_AF_AP, prot);
222 set_bf(ppaace->impl_attr, PAACE_IA_WCE, 0);
223 set_bf(ppaace->addr_bitfields, PPAACE_AF_MW, 0);
224 mb();
225
226 return 0;
227}
228
229
230
231
232
233
234
235void get_ome_index(u32 *omi_index, struct device *dev)
236{
237 if (of_device_is_compatible(dev->of_node, "fsl,qman-portal"))
238 *omi_index = OMI_QMAN;
239 if (of_device_is_compatible(dev->of_node, "fsl,qman"))
240 *omi_index = OMI_QMAN_PRIV;
241}
242
243
244
245
246
247
248
249
250
251
252u32 get_stash_id(u32 stash_dest_hint, u32 vcpu)
253{
254 const u32 *prop;
255 struct device_node *node;
256 u32 cache_level;
257 int len, found = 0;
258 int i;
259
260
261 if (stash_dest_hint == PAMU_ATTR_CACHE_L3) {
262 node = of_find_matching_node(NULL, l3_device_ids);
263 if (node) {
264 prop = of_get_property(node, "cache-stash-id", NULL);
265 if (!prop) {
266 pr_debug("missing cache-stash-id at %pOF\n",
267 node);
268 of_node_put(node);
269 return ~(u32)0;
270 }
271 of_node_put(node);
272 return be32_to_cpup(prop);
273 }
274 return ~(u32)0;
275 }
276
277 for_each_of_cpu_node(node) {
278 prop = of_get_property(node, "reg", &len);
279 for (i = 0; i < len / sizeof(u32); i++) {
280 if (be32_to_cpup(&prop[i]) == vcpu) {
281 found = 1;
282 goto found_cpu_node;
283 }
284 }
285 }
286found_cpu_node:
287
288
289 for (cache_level = PAMU_ATTR_CACHE_L1; (cache_level < PAMU_ATTR_CACHE_L3) && found; cache_level++) {
290 if (stash_dest_hint == cache_level) {
291 prop = of_get_property(node, "cache-stash-id", NULL);
292 if (!prop) {
293 pr_debug("missing cache-stash-id at %pOF\n",
294 node);
295 of_node_put(node);
296 return ~(u32)0;
297 }
298 of_node_put(node);
299 return be32_to_cpup(prop);
300 }
301
302 prop = of_get_property(node, "next-level-cache", NULL);
303 if (!prop) {
304 pr_debug("can't find next-level-cache at %pOF\n", node);
305 of_node_put(node);
306 return ~(u32)0;
307 }
308 of_node_put(node);
309
310
311 node = of_find_node_by_phandle(*prop);
312 if (!node) {
313 pr_debug("Invalid node for cache hierarchy\n");
314 return ~(u32)0;
315 }
316 }
317
318 pr_debug("stash dest not found for %d on vcpu %d\n",
319 stash_dest_hint, vcpu);
320 return ~(u32)0;
321}
322
323
324#define QMAN_PAACE 1
325#define QMAN_PORTAL_PAACE 2
326#define BMAN_PAACE 3
327
328
329
330
331
332
333static void setup_qbman_paace(struct paace *ppaace, int paace_type)
334{
335 switch (paace_type) {
336 case QMAN_PAACE:
337 set_bf(ppaace->impl_attr, PAACE_IA_OTM, PAACE_OTM_INDEXED);
338 ppaace->op_encode.index_ot.omi = OMI_QMAN_PRIV;
339
340 set_bf(ppaace->impl_attr, PAACE_IA_CID, get_stash_id(PAMU_ATTR_CACHE_L3, 0));
341 set_bf(ppaace->domain_attr.to_host.coherency_required, PAACE_DA_HOST_CR,
342 0);
343 break;
344 case QMAN_PORTAL_PAACE:
345 set_bf(ppaace->impl_attr, PAACE_IA_OTM, PAACE_OTM_INDEXED);
346 ppaace->op_encode.index_ot.omi = OMI_QMAN;
347
348 set_bf(ppaace->impl_attr, PAACE_IA_CID, get_stash_id(PAMU_ATTR_CACHE_L3, 0));
349 break;
350 case BMAN_PAACE:
351 set_bf(ppaace->domain_attr.to_host.coherency_required, PAACE_DA_HOST_CR,
352 0);
353 break;
354 }
355}
356
357
358
359
360
361
362
363static void setup_omt(struct ome *omt)
364{
365 struct ome *ome;
366
367
368 ome = &omt[OMI_QMAN];
369
370 ome->moe[IOE_READ_IDX] = EOE_VALID | EOE_READ;
371 ome->moe[IOE_EREAD0_IDX] = EOE_VALID | EOE_RSA;
372 ome->moe[IOE_WRITE_IDX] = EOE_VALID | EOE_WRITE;
373 ome->moe[IOE_EWRITE0_IDX] = EOE_VALID | EOE_WWSAO;
374
375 ome->moe[IOE_DIRECT0_IDX] = EOE_VALID | EOE_LDEC;
376 ome->moe[IOE_DIRECT1_IDX] = EOE_VALID | EOE_LDECPE;
377
378
379 ome = &omt[OMI_FMAN];
380 ome->moe[IOE_READ_IDX] = EOE_VALID | EOE_READI;
381 ome->moe[IOE_WRITE_IDX] = EOE_VALID | EOE_WRITE;
382
383
384 ome = &omt[OMI_QMAN_PRIV];
385 ome->moe[IOE_READ_IDX] = EOE_VALID | EOE_READ;
386 ome->moe[IOE_WRITE_IDX] = EOE_VALID | EOE_WRITE;
387 ome->moe[IOE_EREAD0_IDX] = EOE_VALID | EOE_RSA;
388 ome->moe[IOE_EWRITE0_IDX] = EOE_VALID | EOE_WWSA;
389
390
391 ome = &omt[OMI_CAAM];
392 ome->moe[IOE_READ_IDX] = EOE_VALID | EOE_READI;
393 ome->moe[IOE_WRITE_IDX] = EOE_VALID | EOE_WRITE;
394}
395
396
397
398
399
400static void get_pamu_cap_values(unsigned long pamu_reg_base)
401{
402 u32 pc_val;
403
404 pc_val = in_be32((u32 *)(pamu_reg_base + PAMU_PC3));
405
406 max_subwindow_count = 1 << (1 + PAMU_PC3_MWCE(pc_val));
407}
408
409
410static int setup_one_pamu(unsigned long pamu_reg_base, unsigned long pamu_reg_size,
411 phys_addr_t ppaact_phys, phys_addr_t spaact_phys,
412 phys_addr_t omt_phys)
413{
414 u32 *pc;
415 struct pamu_mmap_regs *pamu_regs;
416
417 pc = (u32 *) (pamu_reg_base + PAMU_PC);
418 pamu_regs = (struct pamu_mmap_regs *)
419 (pamu_reg_base + PAMU_MMAP_REGS_BASE);
420
421
422
423 out_be32(&pamu_regs->ppbah, upper_32_bits(ppaact_phys));
424 out_be32(&pamu_regs->ppbal, lower_32_bits(ppaact_phys));
425 ppaact_phys = ppaact_phys + PAACT_SIZE;
426 out_be32(&pamu_regs->pplah, upper_32_bits(ppaact_phys));
427 out_be32(&pamu_regs->pplal, lower_32_bits(ppaact_phys));
428
429 out_be32(&pamu_regs->spbah, upper_32_bits(spaact_phys));
430 out_be32(&pamu_regs->spbal, lower_32_bits(spaact_phys));
431 spaact_phys = spaact_phys + SPAACT_SIZE;
432 out_be32(&pamu_regs->splah, upper_32_bits(spaact_phys));
433 out_be32(&pamu_regs->splal, lower_32_bits(spaact_phys));
434
435 out_be32(&pamu_regs->obah, upper_32_bits(omt_phys));
436 out_be32(&pamu_regs->obal, lower_32_bits(omt_phys));
437 omt_phys = omt_phys + OMT_SIZE;
438 out_be32(&pamu_regs->olah, upper_32_bits(omt_phys));
439 out_be32(&pamu_regs->olal, lower_32_bits(omt_phys));
440
441
442
443
444
445
446
447 out_be32((u32 *)(pamu_reg_base + PAMU_PICS),
448 PAMU_ACCESS_VIOLATION_ENABLE);
449 out_be32(pc, PAMU_PC_PE | PAMU_PC_OCE | PAMU_PC_SPCC | PAMU_PC_PPCC);
450 return 0;
451}
452
453
454static void setup_liodns(void)
455{
456 int i, len;
457 struct paace *ppaace;
458 struct device_node *node = NULL;
459 const u32 *prop;
460
461 for_each_node_with_property(node, "fsl,liodn") {
462 prop = of_get_property(node, "fsl,liodn", &len);
463 for (i = 0; i < len / sizeof(u32); i++) {
464 int liodn;
465
466 liodn = be32_to_cpup(&prop[i]);
467 if (liodn >= PAACE_NUMBER_ENTRIES) {
468 pr_debug("Invalid LIODN value %d\n", liodn);
469 continue;
470 }
471 ppaace = pamu_get_ppaace(liodn);
472 pamu_init_ppaace(ppaace);
473
474 set_bf(ppaace->addr_bitfields, PPAACE_AF_WSE, 35);
475 ppaace->wbah = 0;
476 set_bf(ppaace->addr_bitfields, PPAACE_AF_WBAL, 0);
477 set_bf(ppaace->impl_attr, PAACE_IA_ATM,
478 PAACE_ATM_NO_XLATE);
479 set_bf(ppaace->addr_bitfields, PAACE_AF_AP,
480 PAACE_AP_PERMS_ALL);
481 if (of_device_is_compatible(node, "fsl,qman-portal"))
482 setup_qbman_paace(ppaace, QMAN_PORTAL_PAACE);
483 if (of_device_is_compatible(node, "fsl,qman"))
484 setup_qbman_paace(ppaace, QMAN_PAACE);
485 if (of_device_is_compatible(node, "fsl,bman"))
486 setup_qbman_paace(ppaace, BMAN_PAACE);
487 mb();
488 pamu_enable_liodn(liodn);
489 }
490 }
491}
492
493static irqreturn_t pamu_av_isr(int irq, void *arg)
494{
495 struct pamu_isr_data *data = arg;
496 phys_addr_t phys;
497 unsigned int i, j, ret;
498
499 pr_emerg("access violation interrupt\n");
500
501 for (i = 0; i < data->count; i++) {
502 void __iomem *p = data->pamu_reg_base + i * PAMU_OFFSET;
503 u32 pics = in_be32(p + PAMU_PICS);
504
505 if (pics & PAMU_ACCESS_VIOLATION_STAT) {
506 u32 avs1 = in_be32(p + PAMU_AVS1);
507 struct paace *paace;
508
509 pr_emerg("POES1=%08x\n", in_be32(p + PAMU_POES1));
510 pr_emerg("POES2=%08x\n", in_be32(p + PAMU_POES2));
511 pr_emerg("AVS1=%08x\n", avs1);
512 pr_emerg("AVS2=%08x\n", in_be32(p + PAMU_AVS2));
513 pr_emerg("AVA=%016llx\n",
514 make64(in_be32(p + PAMU_AVAH),
515 in_be32(p + PAMU_AVAL)));
516 pr_emerg("UDAD=%08x\n", in_be32(p + PAMU_UDAD));
517 pr_emerg("POEA=%016llx\n",
518 make64(in_be32(p + PAMU_POEAH),
519 in_be32(p + PAMU_POEAL)));
520
521 phys = make64(in_be32(p + PAMU_POEAH),
522 in_be32(p + PAMU_POEAL));
523
524
525 if (phys) {
526 u32 *paace = phys_to_virt(phys);
527
528
529 for (j = 0; j < 4; j++)
530 pr_emerg("PAACE[%u]=%08x\n",
531 j, in_be32(paace + j));
532 }
533
534
535 out_be32(p + PAMU_AVS1, avs1 & PAMU_AV_MASK);
536 paace = pamu_get_ppaace(avs1 >> PAMU_AVS1_LIODN_SHIFT);
537 BUG_ON(!paace);
538
539 if (!get_bf(paace->addr_bitfields, PAACE_AF_V)) {
540
541
542
543
544
545
546 pics &= ~PAMU_ACCESS_VIOLATION_ENABLE;
547 } else {
548
549 ret = pamu_disable_liodn(avs1 >> PAMU_AVS1_LIODN_SHIFT);
550 BUG_ON(ret);
551 pr_emerg("Disabling liodn %x\n",
552 avs1 >> PAMU_AVS1_LIODN_SHIFT);
553 }
554 out_be32((p + PAMU_PICS), pics);
555 }
556 }
557
558 return IRQ_HANDLED;
559}
560
561#define LAWAR_EN 0x80000000
562#define LAWAR_TARGET_MASK 0x0FF00000
563#define LAWAR_TARGET_SHIFT 20
564#define LAWAR_SIZE_MASK 0x0000003F
565#define LAWAR_CSDID_MASK 0x000FF000
566#define LAWAR_CSDID_SHIFT 12
567
568#define LAW_SIZE_4K 0xb
569
570struct ccsr_law {
571 u32 lawbarh;
572 u32 lawbarl;
573 u32 lawar;
574 u32 reserved;
575};
576
577
578
579
580static int create_csd(phys_addr_t phys, size_t size, u32 csd_port_id)
581{
582 struct device_node *np;
583 const __be32 *iprop;
584 void __iomem *lac = NULL;
585 struct ccsr_law __iomem *law;
586 void __iomem *ccm = NULL;
587 u32 __iomem *csdids;
588 unsigned int i, num_laws, num_csds;
589 u32 law_target = 0;
590 u32 csd_id = 0;
591 int ret = 0;
592
593 np = of_find_compatible_node(NULL, NULL, "fsl,corenet-law");
594 if (!np)
595 return -ENODEV;
596
597 iprop = of_get_property(np, "fsl,num-laws", NULL);
598 if (!iprop) {
599 ret = -ENODEV;
600 goto error;
601 }
602
603 num_laws = be32_to_cpup(iprop);
604 if (!num_laws) {
605 ret = -ENODEV;
606 goto error;
607 }
608
609 lac = of_iomap(np, 0);
610 if (!lac) {
611 ret = -ENODEV;
612 goto error;
613 }
614
615
616 law = lac + 0xC00;
617
618 of_node_put(np);
619
620 np = of_find_compatible_node(NULL, NULL, "fsl,corenet-cf");
621 if (!np) {
622 ret = -ENODEV;
623 goto error;
624 }
625
626 iprop = of_get_property(np, "fsl,ccf-num-csdids", NULL);
627 if (!iprop) {
628 ret = -ENODEV;
629 goto error;
630 }
631
632 num_csds = be32_to_cpup(iprop);
633 if (!num_csds) {
634 ret = -ENODEV;
635 goto error;
636 }
637
638 ccm = of_iomap(np, 0);
639 if (!ccm) {
640 ret = -ENOMEM;
641 goto error;
642 }
643
644
645 csdids = ccm + 0x600;
646
647 of_node_put(np);
648 np = NULL;
649
650
651 for (csd_id = 0; csd_id < num_csds; csd_id++) {
652 if (!csdids[csd_id])
653 break;
654 }
655
656
657 csdids[csd_id] = csd_port_id;
658
659
660 for (i = 0; i < num_laws; i++) {
661 if (law[i].lawar & LAWAR_EN) {
662 phys_addr_t law_start, law_end;
663
664 law_start = make64(law[i].lawbarh, law[i].lawbarl);
665 law_end = law_start +
666 (2ULL << (law[i].lawar & LAWAR_SIZE_MASK));
667
668 if (law_start <= phys && phys < law_end) {
669 law_target = law[i].lawar & LAWAR_TARGET_MASK;
670 break;
671 }
672 }
673 }
674
675 if (i == 0 || i == num_laws) {
676
677 ret = -ENOENT;
678 goto error;
679 }
680
681
682 while (law[--i].lawar & LAWAR_EN) {
683 if (i == 0) {
684
685 ret = -ENOENT;
686 goto error;
687 }
688 }
689
690 law[i].lawbarh = upper_32_bits(phys);
691 law[i].lawbarl = lower_32_bits(phys);
692 wmb();
693 law[i].lawar = LAWAR_EN | law_target | (csd_id << LAWAR_CSDID_SHIFT) |
694 (LAW_SIZE_4K + get_order(size));
695 wmb();
696
697error:
698 if (ccm)
699 iounmap(ccm);
700
701 if (lac)
702 iounmap(lac);
703
704 if (np)
705 of_node_put(np);
706
707 return ret;
708}
709
710
711
712
713
714
715
716
717
718
719static const struct {
720 u32 svr;
721 u32 port_id;
722} port_id_map[] = {
723 {(SVR_P2040 << 8) | 0x10, 0xFF000000},
724 {(SVR_P2040 << 8) | 0x11, 0xFF000000},
725 {(SVR_P2041 << 8) | 0x10, 0xFF000000},
726 {(SVR_P2041 << 8) | 0x11, 0xFF000000},
727 {(SVR_P3041 << 8) | 0x10, 0xFF000000},
728 {(SVR_P3041 << 8) | 0x11, 0xFF000000},
729 {(SVR_P4040 << 8) | 0x20, 0xFFF80000},
730 {(SVR_P4080 << 8) | 0x20, 0xFFF80000},
731 {(SVR_P5010 << 8) | 0x10, 0xFC000000},
732 {(SVR_P5010 << 8) | 0x20, 0xFC000000},
733 {(SVR_P5020 << 8) | 0x10, 0xFC000000},
734 {(SVR_P5021 << 8) | 0x10, 0xFF800000},
735 {(SVR_P5040 << 8) | 0x10, 0xFF800000},
736};
737
738#define SVR_SECURITY 0x80000
739
740static int fsl_pamu_probe(struct platform_device *pdev)
741{
742 struct device *dev = &pdev->dev;
743 void __iomem *pamu_regs = NULL;
744 struct ccsr_guts __iomem *guts_regs = NULL;
745 u32 pamubypenr, pamu_counter;
746 unsigned long pamu_reg_off;
747 unsigned long pamu_reg_base;
748 struct pamu_isr_data *data = NULL;
749 struct device_node *guts_node;
750 u64 size;
751 struct page *p;
752 int ret = 0;
753 int irq;
754 phys_addr_t ppaact_phys;
755 phys_addr_t spaact_phys;
756 struct ome *omt;
757 phys_addr_t omt_phys;
758 size_t mem_size = 0;
759 unsigned int order = 0;
760 u32 csd_port_id = 0;
761 unsigned i;
762
763
764
765
766
767
768 if (WARN_ON(probed))
769 return -EBUSY;
770
771 pamu_regs = of_iomap(dev->of_node, 0);
772 if (!pamu_regs) {
773 dev_err(dev, "ioremap of PAMU node failed\n");
774 return -ENOMEM;
775 }
776 of_get_address(dev->of_node, 0, &size, NULL);
777
778 irq = irq_of_parse_and_map(dev->of_node, 0);
779 if (irq == NO_IRQ) {
780 dev_warn(dev, "no interrupts listed in PAMU node\n");
781 goto error;
782 }
783
784 data = kzalloc(sizeof(*data), GFP_KERNEL);
785 if (!data) {
786 ret = -ENOMEM;
787 goto error;
788 }
789 data->pamu_reg_base = pamu_regs;
790 data->count = size / PAMU_OFFSET;
791
792
793 ret = request_irq(irq, pamu_av_isr, 0, "pamu", data);
794 if (ret < 0) {
795 dev_err(dev, "error %i installing ISR for irq %i\n", ret, irq);
796 goto error;
797 }
798
799 guts_node = of_find_matching_node(NULL, guts_device_ids);
800 if (!guts_node) {
801 dev_err(dev, "could not find GUTS node %pOF\n", dev->of_node);
802 ret = -ENODEV;
803 goto error;
804 }
805
806 guts_regs = of_iomap(guts_node, 0);
807 of_node_put(guts_node);
808 if (!guts_regs) {
809 dev_err(dev, "ioremap of GUTS node failed\n");
810 ret = -ENODEV;
811 goto error;
812 }
813
814
815 get_pamu_cap_values((unsigned long)pamu_regs);
816
817
818
819
820
821
822 mem_size = (PAGE_SIZE << get_order(PAACT_SIZE)) +
823 (PAGE_SIZE << get_order(SPAACT_SIZE)) +
824 (PAGE_SIZE << get_order(OMT_SIZE));
825 order = get_order(mem_size);
826
827 p = alloc_pages(GFP_KERNEL | __GFP_ZERO, order);
828 if (!p) {
829 dev_err(dev, "unable to allocate PAACT/SPAACT/OMT block\n");
830 ret = -ENOMEM;
831 goto error;
832 }
833
834 ppaact = page_address(p);
835 ppaact_phys = page_to_phys(p);
836
837
838 if (ppaact_phys & ((PAGE_SIZE << order) - 1)) {
839 dev_err(dev, "PAACT/OMT block is unaligned\n");
840 ret = -ENOMEM;
841 goto error;
842 }
843
844 spaact = (void *)ppaact + (PAGE_SIZE << get_order(PAACT_SIZE));
845 omt = (void *)spaact + (PAGE_SIZE << get_order(SPAACT_SIZE));
846
847 dev_dbg(dev, "ppaact virt=%p phys=%pa\n", ppaact, &ppaact_phys);
848
849
850
851
852 for (i = 0; i < ARRAY_SIZE(port_id_map); i++) {
853 if (port_id_map[i].svr == (mfspr(SPRN_SVR) & ~SVR_SECURITY)) {
854 csd_port_id = port_id_map[i].port_id;
855 dev_dbg(dev, "found matching SVR %08x\n",
856 port_id_map[i].svr);
857 break;
858 }
859 }
860
861 if (csd_port_id) {
862 dev_dbg(dev, "creating coherency subdomain at address %pa, size %zu, port id 0x%08x",
863 &ppaact_phys, mem_size, csd_port_id);
864
865 ret = create_csd(ppaact_phys, mem_size, csd_port_id);
866 if (ret) {
867 dev_err(dev, "could not create coherence subdomain\n");
868 return ret;
869 }
870 }
871
872 spaact_phys = virt_to_phys(spaact);
873 omt_phys = virt_to_phys(omt);
874
875 pamubypenr = in_be32(&guts_regs->pamubypenr);
876
877 for (pamu_reg_off = 0, pamu_counter = 0x80000000; pamu_reg_off < size;
878 pamu_reg_off += PAMU_OFFSET, pamu_counter >>= 1) {
879
880 pamu_reg_base = (unsigned long)pamu_regs + pamu_reg_off;
881 setup_one_pamu(pamu_reg_base, pamu_reg_off, ppaact_phys,
882 spaact_phys, omt_phys);
883
884 pamubypenr &= ~pamu_counter;
885 }
886
887 setup_omt(omt);
888
889
890 out_be32(&guts_regs->pamubypenr, pamubypenr);
891
892 iounmap(guts_regs);
893
894
895
896 setup_liodns();
897
898 probed = true;
899
900 return 0;
901
902error:
903 if (irq != NO_IRQ)
904 free_irq(irq, data);
905
906 kfree_sensitive(data);
907
908 if (pamu_regs)
909 iounmap(pamu_regs);
910
911 if (guts_regs)
912 iounmap(guts_regs);
913
914 if (ppaact)
915 free_pages((unsigned long)ppaact, order);
916
917 ppaact = NULL;
918
919 return ret;
920}
921
922static struct platform_driver fsl_of_pamu_driver = {
923 .driver = {
924 .name = "fsl-of-pamu",
925 },
926 .probe = fsl_pamu_probe,
927};
928
929static __init int fsl_pamu_init(void)
930{
931 struct platform_device *pdev = NULL;
932 struct device_node *np;
933 int ret;
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954 np = of_find_compatible_node(NULL, NULL, "fsl,pamu");
955 if (!np) {
956 pr_err("could not find a PAMU node\n");
957 return -ENODEV;
958 }
959
960 ret = platform_driver_register(&fsl_of_pamu_driver);
961 if (ret) {
962 pr_err("could not register driver (err=%i)\n", ret);
963 goto error_driver_register;
964 }
965
966 pdev = platform_device_alloc("fsl-of-pamu", 0);
967 if (!pdev) {
968 pr_err("could not allocate device %pOF\n", np);
969 ret = -ENOMEM;
970 goto error_device_alloc;
971 }
972 pdev->dev.of_node = of_node_get(np);
973
974 ret = pamu_domain_init();
975 if (ret)
976 goto error_device_add;
977
978 ret = platform_device_add(pdev);
979 if (ret) {
980 pr_err("could not add device %pOF (err=%i)\n", np, ret);
981 goto error_device_add;
982 }
983
984 return 0;
985
986error_device_add:
987 of_node_put(pdev->dev.of_node);
988 pdev->dev.of_node = NULL;
989
990 platform_device_put(pdev);
991
992error_device_alloc:
993 platform_driver_unregister(&fsl_of_pamu_driver);
994
995error_driver_register:
996 of_node_put(np);
997
998 return ret;
999}
1000arch_initcall(fsl_pamu_init);
1001