arch/arm/cpu/armv8/cache_v8.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2013
   4  * David Feng <fenghua@phytium.com.cn>
   5  *
   6  * (C) Copyright 2016
   7  * Alexander Graf <agraf@suse.de>
   8  */
   9
  10 #include <common.h>
  11 #include <cpu_func.h>
  12 #include <hang.h>
  13 #include <log.h>
  14 #include <asm/cache.h>
  15 #include <asm/global_data.h>
  16 #include <asm/system.h>
  17 #include <asm/armv8/mmu.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 #if !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
  22
  23 /*
  24  *  With 4k page granule, a virtual address is split into 4 lookup parts
  25  *  spanning 9 bits each:
  26  *
  27  *    _______________________________________________
  28  *   |       |       |       |       |       |       |
  29  *   |   0   |  Lv0  |  Lv1  |  Lv2  |  Lv3  |  off  |
  30  *   |_______|_______|_______|_______|_______|_______|
  31  *     63-48   47-39   38-30   29-21   20-12   11-00
  32  *
  33  *             mask        page size
  34  *
  35  *    Lv0: FF8000000000       --
  36  *    Lv1:   7FC0000000       1G
  37  *    Lv2:     3FE00000       2M
  38  *    Lv3:       1FF000       4K
  39  *    off:          FFF
  40  */
  41
  42 static int get_effective_el(void)
  43 {
  44         int el = current_el();
  45
  46         if (el == 2) {
  47                 u64 hcr_el2;
  48
  49                 /*
  50                  * If we are using the EL2&0 translation regime, the TCR_EL2
  51                  * looks like the EL1 version, even though we are in EL2.
  52                  */
  53                 __asm__ ("mrs %0, HCR_EL2\n" : "=r" (hcr_el2));
  54                 if (hcr_el2 & BIT(HCR_EL2_E2H_BIT))
  55                         return 1;
  56         }
  57
  58         return el;
  59 }
  60
  61 u64 get_tcr(u64 *pips, u64 *pva_bits)
  62 {
  63         int el = get_effective_el();
  64         u64 max_addr = 0;
  65         u64 ips, va_bits;
  66         u64 tcr;
  67         int i;
  68
  69         /* Find the largest address we need to support */
  70         for (i = 0; mem_map[i].size || mem_map[i].attrs; i++)
  71                 max_addr = max(max_addr, mem_map[i].virt + mem_map[i].size);
  72
  73         /* Calculate the maximum physical (and thus virtual) address */
  74         if (max_addr > (1ULL << 44)) {
  75                 ips = 5;
  76                 va_bits = 48;
  77         } else  if (max_addr > (1ULL << 42)) {
  78                 ips = 4;
  79                 va_bits = 44;
  80         } else  if (max_addr > (1ULL << 40)) {
  81                 ips = 3;
  82                 va_bits = 42;
  83         } else  if (max_addr > (1ULL << 36)) {
  84                 ips = 2;
  85                 va_bits = 40;
  86         } else  if (max_addr > (1ULL << 32)) {
  87                 ips = 1;
  88                 va_bits = 36;
  89         } else {
  90                 ips = 0;
  91                 va_bits = 32;
  92         }
  93
  94         if (el == 1) {
  95                 tcr = TCR_EL1_RSVD | (ips << 32) | TCR_EPD1_DISABLE;
  96                 if (gd->arch.has_hafdbs)
  97                         tcr |= TCR_EL1_HA | TCR_EL1_HD;
  98         } else if (el == 2) {
  99                 tcr = TCR_EL2_RSVD | (ips << 16);
 100                 if (gd->arch.has_hafdbs)
 101                         tcr |= TCR_EL2_HA | TCR_EL2_HD;
 102         } else {
 103                 tcr = TCR_EL3_RSVD | (ips << 16);
 104                 if (gd->arch.has_hafdbs)
 105                         tcr |= TCR_EL3_HA | TCR_EL3_HD;
 106         }
 107
 108         /* PTWs cacheable, inner/outer WBWA and inner shareable */
 109         tcr |= TCR_TG0_4K | TCR_SHARED_INNER | TCR_ORGN_WBWA | TCR_IRGN_WBWA;
 110         tcr |= TCR_T0SZ(va_bits);
 111
 112         if (pips)
 113                 *pips = ips;
 114         if (pva_bits)
 115                 *pva_bits = va_bits;
 116
 117         return tcr;
 118 }
 119
 120 #define MAX_PTE_ENTRIES 512
 121
 122 static int pte_type(u64 *pte)
 123 {
 124         return *pte & PTE_TYPE_MASK;
 125 }
 126
 127 /* Returns the LSB number for a PTE on level <level> */
 128 static int level2shift(int level)
 129 {
 130         /* Page is 12 bits wide, every level translates 9 bits */
 131         return (12 + 9 * (3 - level));
 132 }
 133
 134 static u64 *find_pte(u64 addr, int level)
 135 {
 136         int start_level = 0;
 137         u64 *pte;
 138         u64 idx;
 139         u64 va_bits;
 140         int i;
 141
 142         debug("addr=%llx level=%d\n", addr, level);
 143
 144         get_tcr(NULL, &va_bits);
 145         if (va_bits < 39)
 146                 start_level = 1;
 147
 148         if (level < start_level)
 149                 return NULL;
 150
 151         /* Walk through all page table levels to find our PTE */
 152         pte = (u64*)gd->arch.tlb_addr;
 153         for (i = start_level; i < 4; i++) {
 154                 idx = (addr >> level2shift(i)) & 0x1FF;
 155                 pte += idx;
 156                 debug("idx=%llx PTE %p at level %d: %llx\n", idx, pte, i, *pte);
 157
 158                 /* Found it */
 159                 if (i == level)
 160                         return pte;
 161                 /* PTE is no table (either invalid or block), can't traverse */
 162                 if (pte_type(pte) != PTE_TYPE_TABLE)
 163                         return NULL;
 164                 /* Off to the next level */
 165                 pte = (u64*)(*pte & 0x0000fffffffff000ULL);
 166         }
 167
 168         /* Should never reach here */
 169         return NULL;
 170 }
 171
 172 #ifdef CONFIG_CMO_BY_VA_ONLY
 173 static void __cmo_on_leaves(void (*cmo_fn)(unsigned long, unsigned long),
 174                             u64 pte, int level, u64 base)
 175 {
 176         u64 *ptep;
 177         int i;
 178
 179         ptep = (u64 *)(pte & GENMASK_ULL(47, PAGE_SHIFT));
 180         for (i = 0; i < PAGE_SIZE / sizeof(u64); i++) {
 181                 u64 end, va = base + i * BIT(level2shift(level));
 182                 u64 type, attrs;
 183
 184                 pte = ptep[i];
 185                 type = pte & PTE_TYPE_MASK;
 186                 attrs = pte & PMD_ATTRINDX_MASK;
 187                 debug("PTE %llx at level %d VA %llx\n", pte, level, va);
 188
 189                 /* Not valid? next! */
 190                 if (!(type & PTE_TYPE_VALID))
 191                         continue;
 192
 193                 /* Not a leaf? Recurse on the next level */
 194                 if (!(type == PTE_TYPE_BLOCK ||
 195                       (level == 3 && type == PTE_TYPE_PAGE))) {
 196                         __cmo_on_leaves(cmo_fn, pte, level + 1, va);
 197                         continue;
 198                 }
 199
 200                 /*
 201                  * From this point, this must be a leaf.
 202                  *
 203                  * Start excluding non memory mappings
 204                  */
 205                 if (attrs != PTE_BLOCK_MEMTYPE(MT_NORMAL) &&
 206                     attrs != PTE_BLOCK_MEMTYPE(MT_NORMAL_NC))
 207                         continue;
 208
 209                 if (gd->arch.has_hafdbs && (pte & (PTE_RDONLY | PTE_DBM)) != PTE_DBM)
 210                         continue;
 211
 212                 end = va + BIT(level2shift(level)) - 1;
 213
 214                 /* No intersection with RAM? */
 215                 if (end < gd->ram_base ||
 216                     va >= (gd->ram_base + gd->ram_size))
 217                         continue;
 218
 219                 /*
 220                  * OK, we have a partial RAM mapping. However, this
 221                  * can cover *more* than the RAM. Yes, u-boot is
 222                  * *that* braindead. Compute the intersection we care
 223                  * about, and not a byte more.
 224                  */
 225                 va = max(va, (u64)gd->ram_base);
 226                 end = min(end, gd->ram_base + gd->ram_size);
 227
 228                 debug("Flush PTE %llx at level %d: %llx-%llx\n",
 229                       pte, level, va, end);
 230                 cmo_fn(va, end);
 231         }
 232 }
 233
 234 static void apply_cmo_to_mappings(void (*cmo_fn)(unsigned long, unsigned long))
 235 {
 236         u64 va_bits;
 237         int sl = 0;
 238
 239         if (!gd->arch.tlb_addr)
 240                 return;
 241
 242         get_tcr(NULL, &va_bits);
 243         if (va_bits < 39)
 244                 sl = 1;
 245
 246         __cmo_on_leaves(cmo_fn, gd->arch.tlb_addr, sl, 0);
 247 }
 248 #else
 249 static inline void apply_cmo_to_mappings(void *dummy) {}
 250 #endif
 251
 252 /* Returns and creates a new full table (512 entries) */
 253 static u64 *create_table(void)
 254 {
 255         u64 *new_table = (u64*)gd->arch.tlb_fillptr;
 256         u64 pt_len = MAX_PTE_ENTRIES * sizeof(u64);
 257
 258         /* Allocate MAX_PTE_ENTRIES pte entries */
 259         gd->arch.tlb_fillptr += pt_len;
 260
 261         if (gd->arch.tlb_fillptr - gd->arch.tlb_addr > gd->arch.tlb_size)
 262                 panic("Insufficient RAM for page table: 0x%lx > 0x%lx. "
 263                       "Please increase the size in get_page_table_size()",
 264                         gd->arch.tlb_fillptr - gd->arch.tlb_addr,
 265                         gd->arch.tlb_size);
 266
 267         /* Mark all entries as invalid */
 268         memset(new_table, 0, pt_len);
 269
 270         return new_table;
 271 }
 272
 273 static void set_pte_table(u64 *pte, u64 *table)
 274 {
 275         /* Point *pte to the new table */
 276         debug("Setting %p to addr=%p\n", pte, table);
 277         *pte = PTE_TYPE_TABLE | (ulong)table;
 278 }
 279
 280 /* Splits a block PTE into table with subpages spanning the old block */
 281 static void split_block(u64 *pte, int level)
 282 {
 283         u64 old_pte = *pte;
 284         u64 *new_table;
 285         u64 i = 0;
 286         /* level describes the parent level, we need the child ones */
 287         int levelshift = level2shift(level + 1);
 288
 289         if (pte_type(pte) != PTE_TYPE_BLOCK)
 290                 panic("PTE %p (%llx) is not a block. Some driver code wants to "
 291                       "modify dcache settings for an range not covered in "
 292                       "mem_map.", pte, old_pte);
 293
 294         new_table = create_table();
 295         debug("Splitting pte %p (%llx) into %p\n", pte, old_pte, new_table);
 296
 297         for (i = 0; i < MAX_PTE_ENTRIES; i++) {
 298                 new_table[i] = old_pte | (i << levelshift);
 299
 300                 /* Level 3 block PTEs have the table type */
 301                 if ((level + 1) == 3)
 302                         new_table[i] |= PTE_TYPE_TABLE;
 303
 304                 debug("Setting new_table[%lld] = %llx\n", i, new_table[i]);
 305         }
 306
 307         /* Set the new table into effect */
 308         set_pte_table(pte, new_table);
 309 }
 310
 311 static void map_range(u64 virt, u64 phys, u64 size, int level,
 312                       u64 *table, u64 attrs)
 313 {
 314         u64 map_size = BIT_ULL(level2shift(level));
 315         int i, idx;
 316
 317         idx = (virt >> level2shift(level)) & (MAX_PTE_ENTRIES - 1);
 318         for (i = idx; size; i++) {
 319                 u64 next_size, *next_table;
 320
 321                 if (level >= gd->arch.first_block_level &&
 322                     size >= map_size && !(virt & (map_size - 1))) {
 323                         if (level == 3)
 324                                 table[i] = phys | attrs | PTE_TYPE_PAGE;
 325                         else
 326                                 table[i] = phys | attrs;
 327
 328                         virt += map_size;
 329                         phys += map_size;
 330                         size -= map_size;
 331
 332                         continue;
 333                 }
 334
 335                 /* Going one level down */
 336                 if (pte_type(&table[i]) == PTE_TYPE_FAULT)
 337                         set_pte_table(&table[i], create_table());
 338
 339                 next_table = (u64 *)(table[i] & GENMASK_ULL(47, PAGE_SHIFT));
 340                 next_size = min(map_size - (virt & (map_size - 1)), size);
 341
 342                 map_range(virt, phys, next_size, level + 1, next_table, attrs);
 343
 344                 virt += next_size;
 345                 phys += next_size;
 346                 size -= next_size;
 347         }
 348 }
 349
 350 static void add_map(struct mm_region *map)
 351 {
 352         u64 attrs = map->attrs | PTE_TYPE_BLOCK | PTE_BLOCK_AF;
 353         u64 va_bits;
 354         int level = 0;
 355
 356         get_tcr(NULL, &va_bits);
 357         if (va_bits < 39)
 358                 level = 1;
 359
 360         if (!gd->arch.first_block_level)
 361                 gd->arch.first_block_level = 1;
 362
 363         if (gd->arch.has_hafdbs)
 364                 attrs |= PTE_DBM | PTE_RDONLY;
 365
 366         map_range(map->virt, map->phys, map->size, level,
 367                   (u64 *)gd->arch.tlb_addr, attrs);
 368 }
 369
 370 static void count_range(u64 virt, u64 size, int level, int *cntp)
 371 {
 372         u64 map_size = BIT_ULL(level2shift(level));
 373         int i, idx;
 374
 375         idx = (virt >> level2shift(level)) & (MAX_PTE_ENTRIES - 1);
 376         for (i = idx; size; i++) {
 377                 u64 next_size;
 378
 379                 if (level >= gd->arch.first_block_level &&
 380                     size >= map_size && !(virt & (map_size - 1))) {
 381                         virt += map_size;
 382                         size -= map_size;
 383
 384                         continue;
 385                 }
 386
 387                 /* Going one level down */
 388                 (*cntp)++;
 389                 next_size = min(map_size - (virt & (map_size - 1)), size);
 390
 391                 count_range(virt, next_size, level + 1, cntp);
 392
 393                 virt += next_size;
 394                 size -= next_size;
 395         }
 396 }
 397
 398 static int count_ranges(void)
 399 {
 400         int i, count = 0, level = 0;
 401         u64 va_bits;
 402
 403         get_tcr(NULL, &va_bits);
 404         if (va_bits < 39)
 405                 level = 1;
 406
 407         for (i = 0; mem_map[i].size || mem_map[i].attrs; i++)
 408                 count_range(mem_map[i].virt, mem_map[i].size, level, &count);
 409
 410         return count;
 411 }
 412
 413 /* Returns the estimated required size of all page tables */
 414 __weak u64 get_page_table_size(void)
 415 {
 416         u64 one_pt = MAX_PTE_ENTRIES * sizeof(u64);
 417         u64 size, mmfr1;
 418
 419         asm volatile("mrs %0, id_aa64mmfr1_el1" : "=r" (mmfr1));
 420         if ((mmfr1 & 0xf) == 2) {
 421                 gd->arch.has_hafdbs = true;
 422                 gd->arch.first_block_level = 2;
 423         } else {
 424                 gd->arch.has_hafdbs = false;
 425                 gd->arch.first_block_level = 1;
 426         }
 427
 428         /* Account for all page tables we would need to cover our memory map */
 429         size = one_pt * count_ranges();
 430
 431         /*
 432          * We need to duplicate our page table once to have an emergency pt to
 433          * resort to when splitting page tables later on
 434          */
 435         size *= 2;
 436
 437         /*
 438          * We may need to split page tables later on if dcache settings change,
 439          * so reserve up to 4 (random pick) page tables for that.
 440          */
 441         size += one_pt * 4;
 442
 443         return size;
 444 }
 445
 446 void setup_pgtables(void)
 447 {
 448         int i;
 449
 450         if (!gd->arch.tlb_fillptr || !gd->arch.tlb_addr)
 451                 panic("Page table pointer not setup.");
 452
 453         /*
 454          * Allocate the first level we're on with invalidate entries.
 455          * If the starting level is 0 (va_bits >= 39), then this is our
 456          * Lv0 page table, otherwise it's the entry Lv1 page table.
 457          */
 458         create_table();
 459
 460         /* Now add all MMU table entries one after another to the table */
 461         for (i = 0; mem_map[i].size || mem_map[i].attrs; i++)
 462                 add_map(&mem_map[i]);
 463 }
 464
 465 static void setup_all_pgtables(void)
 466 {
 467         u64 tlb_addr = gd->arch.tlb_addr;
 468         u64 tlb_size = gd->arch.tlb_size;
 469
 470         /* Reset the fill ptr */
 471         gd->arch.tlb_fillptr = tlb_addr;
 472
 473         /* Create normal system page tables */
 474         setup_pgtables();
 475
 476         /* Create emergency page tables */
 477         gd->arch.tlb_size -= (uintptr_t)gd->arch.tlb_fillptr -
 478                              (uintptr_t)gd->arch.tlb_addr;
 479         gd->arch.tlb_addr = gd->arch.tlb_fillptr;
 480         setup_pgtables();
 481         gd->arch.tlb_emerg = gd->arch.tlb_addr;
 482         gd->arch.tlb_addr = tlb_addr;
 483         gd->arch.tlb_size = tlb_size;
 484 }
 485
 486 /* to activate the MMU we need to set up virtual memory */
 487 __weak void mmu_setup(void)
 488 {
 489         int el;
 490
 491         /* Set up page tables only once */
 492         if (!gd->arch.tlb_fillptr)
 493                 setup_all_pgtables();
 494
 495         el = current_el();
 496         set_ttbr_tcr_mair(el, gd->arch.tlb_addr, get_tcr(NULL, NULL),
 497                           MEMORY_ATTRIBUTES);
 498
 499         /* enable the mmu */
 500         set_sctlr(get_sctlr() | CR_M);
 501 }
 502
 503 /*
 504  * Performs a invalidation of the entire data cache at all levels
 505  */
 506 void invalidate_dcache_all(void)
 507 {
 508 #ifndef CONFIG_CMO_BY_VA_ONLY
 509         __asm_invalidate_dcache_all();
 510         __asm_invalidate_l3_dcache();
 511 #else
 512         apply_cmo_to_mappings(invalidate_dcache_range);
 513 #endif
 514 }
 515
 516 /*
 517  * Performs a clean & invalidation of the entire data cache at all levels.
 518  * This function needs to be inline to avoid using stack.
 519  * __asm_flush_l3_dcache return status of timeout
 520  */
 521 inline void flush_dcache_all(void)
 522 {
 523 #ifndef CONFIG_CMO_BY_VA_ONLY
 524         int ret;
 525
 526         __asm_flush_dcache_all();
 527         ret = __asm_flush_l3_dcache();
 528         if (ret)
 529                 debug("flushing dcache returns 0x%x\n", ret);
 530         else
 531                 debug("flushing dcache successfully.\n");
 532 #else
 533         apply_cmo_to_mappings(flush_dcache_range);
 534 #endif
 535 }
 536
 537 #ifndef CONFIG_SYS_DISABLE_DCACHE_OPS
 538 /*
 539  * Invalidates range in all levels of D-cache/unified cache
 540  */
 541 void invalidate_dcache_range(unsigned long start, unsigned long stop)
 542 {
 543         __asm_invalidate_dcache_range(start, stop);
 544 }
 545
 546 /*
 547  * Flush range(clean & invalidate) from all levels of D-cache/unified cache
 548  */
 549 void flush_dcache_range(unsigned long start, unsigned long stop)
 550 {
 551         __asm_flush_dcache_range(start, stop);
 552 }
 553 #else
 554 void invalidate_dcache_range(unsigned long start, unsigned long stop)
 555 {
 556 }
 557
 558 void flush_dcache_range(unsigned long start, unsigned long stop)
 559 {
 560 }
 561 #endif /* CONFIG_SYS_DISABLE_DCACHE_OPS */
 562
 563 void dcache_enable(void)
 564 {
 565         /* The data cache is not active unless the mmu is enabled */
 566         if (!(get_sctlr() & CR_M)) {
 567                 invalidate_dcache_all();
 568                 __asm_invalidate_tlb_all();
 569                 mmu_setup();
 570         }
 571
 572         /* Set up page tables only once (it is done also by mmu_setup()) */
 573         if (!gd->arch.tlb_fillptr)
 574                 setup_all_pgtables();
 575
 576         set_sctlr(get_sctlr() | CR_C);
 577 }
 578
 579 void dcache_disable(void)
 580 {
 581         uint32_t sctlr;
 582
 583         sctlr = get_sctlr();
 584
 585         /* if cache isn't enabled no need to disable */
 586         if (!(sctlr & CR_C))
 587                 return;
 588
 589         if (IS_ENABLED(CONFIG_CMO_BY_VA_ONLY)) {
 590                 /*
 591                  * When invalidating by VA, do it *before* turning the MMU
 592                  * off, so that at least our stack is coherent.
 593                  */
 594                 flush_dcache_all();
 595         }
 596
 597         set_sctlr(sctlr & ~(CR_C|CR_M));
 598
 599         if (!IS_ENABLED(CONFIG_CMO_BY_VA_ONLY))
 600                 flush_dcache_all();
 601
 602         __asm_invalidate_tlb_all();
 603 }
 604
 605 int dcache_status(void)
 606 {
 607         return (get_sctlr() & CR_C) != 0;
 608 }
 609
 610 u64 *__weak arch_get_page_table(void) {
 611         puts("No page table offset defined\n");
 612
 613         return NULL;
 614 }
 615
 616 static bool is_aligned(u64 addr, u64 size, u64 align)
 617 {
 618         return !(addr & (align - 1)) && !(size & (align - 1));
 619 }
 620
 621 /* Use flag to indicate if attrs has more than d-cache attributes */
 622 static u64 set_one_region(u64 start, u64 size, u64 attrs, bool flag, int level)
 623 {
 624         int levelshift = level2shift(level);
 625         u64 levelsize = 1ULL << levelshift;
 626         u64 *pte = find_pte(start, level);
 627
 628         /* Can we can just modify the current level block PTE? */
 629         if (is_aligned(start, size, levelsize)) {
 630                 if (flag) {
 631                         *pte &= ~PMD_ATTRMASK;
 632                         *pte |= attrs & PMD_ATTRMASK;
 633                 } else {
 634                         *pte &= ~PMD_ATTRINDX_MASK;
 635                         *pte |= attrs & PMD_ATTRINDX_MASK;
 636                 }
 637                 debug("Set attrs=%llx pte=%p level=%d\n", attrs, pte, level);
 638
 639                 return levelsize;
 640         }
 641
 642         /* Unaligned or doesn't fit, maybe split block into table */
 643         debug("addr=%llx level=%d pte=%p (%llx)\n", start, level, pte, *pte);
 644
 645         /* Maybe we need to split the block into a table */
 646         if (pte_type(pte) == PTE_TYPE_BLOCK)
 647                 split_block(pte, level);
 648
 649         /* And then double-check it became a table or already is one */
 650         if (pte_type(pte) != PTE_TYPE_TABLE)
 651                 panic("PTE %p (%llx) for addr=%llx should be a table",
 652                       pte, *pte, start);
 653
 654         /* Roll on to the next page table level */
 655         return 0;
 656 }
 657
 658 void mmu_set_region_dcache_behaviour(phys_addr_t start, size_t size,
 659                                      enum dcache_option option)
 660 {
 661         u64 attrs = PMD_ATTRINDX(option >> 2);
 662         u64 real_start = start;
 663         u64 real_size = size;
 664
 665         debug("start=%lx size=%lx\n", (ulong)start, (ulong)size);
 666
 667         if (!gd->arch.tlb_emerg)
 668                 panic("Emergency page table not setup.");
 669
 670         /*
 671          * We can not modify page tables that we're currently running on,
 672          * so we first need to switch to the "emergency" page tables where
 673          * we can safely modify our primary page tables and then switch back
 674          */
 675         __asm_switch_ttbr(gd->arch.tlb_emerg);
 676
 677         /*
 678          * Loop through the address range until we find a page granule that fits
 679          * our alignment constraints, then set it to the new cache attributes
 680          */
 681         while (size > 0) {
 682                 int level;
 683                 u64 r;
 684
 685                 for (level = 1; level < 4; level++) {
 686                         /* Set d-cache attributes only */
 687                         r = set_one_region(start, size, attrs, false, level);
 688                         if (r) {
 689                                 /* PTE successfully replaced */
 690                                 size -= r;
 691                                 start += r;
 692                                 break;
 693                         }
 694                 }
 695
 696         }
 697
 698         /* We're done modifying page tables, switch back to our primary ones */
 699         __asm_switch_ttbr(gd->arch.tlb_addr);
 700
 701         /*
 702          * Make sure there's nothing stale in dcache for a region that might
 703          * have caches off now
 704          */
 705         flush_dcache_range(real_start, real_start + real_size);
 706 }
 707
 708 /*
 709  * Modify MMU table for a region with updated PXN/UXN/Memory type/valid bits.
 710  * The procecess is break-before-make. The target region will be marked as
 711  * invalid during the process of changing.
 712  */
 713 void mmu_change_region_attr(phys_addr_t addr, size_t siz, u64 attrs)
 714 {
 715         int level;
 716         u64 r, size, start;
 717
 718         start = addr;
 719         size = siz;
 720         /*
 721          * Loop through the address range until we find a page granule that fits
 722          * our alignment constraints, then set it to "invalid".
 723          */
 724         while (size > 0) {
 725                 for (level = 1; level < 4; level++) {
 726                         /* Set PTE to fault */
 727                         r = set_one_region(start, size, PTE_TYPE_FAULT, true,
 728                                            level);
 729                         if (r) {
 730                                 /* PTE successfully invalidated */
 731                                 size -= r;
 732                                 start += r;
 733                                 break;
 734                         }
 735                 }
 736         }
 737
 738         flush_dcache_range(gd->arch.tlb_addr,
 739                            gd->arch.tlb_addr + gd->arch.tlb_size);
 740         __asm_invalidate_tlb_all();
 741
 742         /*
 743          * Loop through the address range until we find a page granule that fits
 744          * our alignment constraints, then set it to the new cache attributes
 745          */
 746         start = addr;
 747         size = siz;
 748         while (size > 0) {
 749                 for (level = 1; level < 4; level++) {
 750                         /* Set PTE to new attributes */
 751                         r = set_one_region(start, size, attrs, true, level);
 752                         if (r) {
 753                                 /* PTE successfully updated */
 754                                 size -= r;
 755                                 start += r;
 756                                 break;
 757                         }
 758                 }
 759         }
 760         flush_dcache_range(gd->arch.tlb_addr,
 761                            gd->arch.tlb_addr + gd->arch.tlb_size);
 762         __asm_invalidate_tlb_all();
 763 }
 764
 765 #else   /* !CONFIG_IS_ENABLED(SYS_DCACHE_OFF) */
 766
 767 /*
 768  * For SPL builds, we may want to not have dcache enabled. Any real U-Boot
 769  * running however really wants to have dcache and the MMU active. Check that
 770  * everything is sane and give the developer a hint if it isn't.
 771  */
 772 #ifndef CONFIG_SPL_BUILD
 773 #error Please describe your MMU layout in CONFIG_SYS_MEM_MAP and enable dcache.
 774 #endif
 775
 776 void invalidate_dcache_all(void)
 777 {
 778 }
 779
 780 void flush_dcache_all(void)
 781 {
 782 }
 783
 784 void dcache_enable(void)
 785 {
 786 }
 787
 788 void dcache_disable(void)
 789 {
 790 }
 791
 792 int dcache_status(void)
 793 {
 794         return 0;
 795 }
 796
 797 void mmu_set_region_dcache_behaviour(phys_addr_t start, size_t size,
 798                                      enum dcache_option option)
 799 {
 800 }
 801
 802 #endif  /* !CONFIG_IS_ENABLED(SYS_DCACHE_OFF) */
 803
 804 #if !CONFIG_IS_ENABLED(SYS_ICACHE_OFF)
 805
 806 void icache_enable(void)
 807 {
 808         invalidate_icache_all();
 809         set_sctlr(get_sctlr() | CR_I);
 810 }
 811
 812 void icache_disable(void)
 813 {
 814         set_sctlr(get_sctlr() & ~CR_I);
 815 }
 816
 817 int icache_status(void)
 818 {
 819         return (get_sctlr() & CR_I) != 0;
 820 }
 821
 822 int mmu_status(void)
 823 {
 824         return (get_sctlr() & CR_M) != 0;
 825 }
 826
 827 void invalidate_icache_all(void)
 828 {
 829         __asm_invalidate_icache_all();
 830         __asm_invalidate_l3_icache();
 831 }
 832
 833 #else   /* !CONFIG_IS_ENABLED(SYS_ICACHE_OFF) */
 834
 835 void icache_enable(void)
 836 {
 837 }
 838
 839 void icache_disable(void)
 840 {
 841 }
 842
 843 int icache_status(void)
 844 {
 845         return 0;
 846 }
 847
 848 int mmu_status(void)
 849 {
 850         return 0;
 851 }
 852
 853 void invalidate_icache_all(void)
 854 {
 855 }
 856
 857 #endif  /* !CONFIG_IS_ENABLED(SYS_ICACHE_OFF) */
 858
 859 /*
 860  * Enable dCache & iCache, whether cache is actually enabled
 861  * depend on CONFIG_SYS_DCACHE_OFF and CONFIG_SYS_ICACHE_OFF
 862  */
 863 void __weak enable_caches(void)
 864 {
 865         icache_enable();
 866         dcache_enable();
 867 }