1 /* 2 * PowerPC memory management structures 3 */ 4 5 #ifndef _PPC_MMU_H_ 6 #define _PPC_MMU_H_ 7 8 #ifndef __ASSEMBLY__ 9 /* Hardware Page Table Entry */ 10 #include <linux/bitops.h> 11 typedef struct _PTE { 12 #ifdef CONFIG_PPC64BRIDGE 13 unsigned long long vsid:52; 14 unsigned long api:5; 15 unsigned long :5; 16 unsigned long h:1; 17 unsigned long v:1; 18 unsigned long long rpn:52; 19 #else /* CONFIG_PPC64BRIDGE */ 20 unsigned long v:1; /* Entry is valid */ 21 unsigned long vsid:24; /* Virtual segment identifier */ 22 unsigned long h:1; /* Hash algorithm indicator */ 23 unsigned long api:6; /* Abbreviated page index */ 24 unsigned long rpn:20; /* Real (physical) page number */ 25 #endif /* CONFIG_PPC64BRIDGE */ 26 unsigned long :3; /* Unused */ 27 unsigned long r:1; /* Referenced */ 28 unsigned long c:1; /* Changed */ 29 unsigned long w:1; /* Write-thru cache mode */ 30 unsigned long i:1; /* Cache inhibited */ 31 unsigned long m:1; /* Memory coherence */ 32 unsigned long g:1; /* Guarded */ 33 unsigned long :1; /* Unused */ 34 unsigned long pp:2; /* Page protection */ 35 } PTE; 36 37 /* Values for PP (assumes Ks=0, Kp=1) */ 38 #define PP_RWXX 0 /* Supervisor read/write, User none */ 39 #define PP_RWRX 1 /* Supervisor read/write, User read */ 40 #define PP_RWRW 2 /* Supervisor read/write, User read/write */ 41 #define PP_RXRX 3 /* Supervisor read, User read */ 42 43 /* Segment Register */ 44 typedef struct _SEGREG { 45 unsigned long t:1; /* Normal or I/O type */ 46 unsigned long ks:1; /* Supervisor 'key' (normally 0) */ 47 unsigned long kp:1; /* User 'key' (normally 1) */ 48 unsigned long n:1; /* No-execute */ 49 unsigned long :4; /* Unused */ 50 unsigned long vsid:24; /* Virtual Segment Identifier */ 51 } SEGREG; 52 53 /* Block Address Translation (BAT) Registers */ 54 typedef struct _P601_BATU { /* Upper part of BAT for 601 processor */ 55 unsigned long bepi:15; /* Effective page index (virtual address) */ 56 unsigned long :8; /* unused */ 57 unsigned long w:1; 58 unsigned long i:1; /* Cache inhibit */ 59 unsigned long m:1; /* Memory coherence */ 60 unsigned long ks:1; /* Supervisor key (normally 0) */ 61 unsigned long kp:1; /* User key (normally 1) */ 62 unsigned long pp:2; /* Page access protections */ 63 } P601_BATU; 64 65 typedef struct _BATU { /* Upper part of BAT (all except 601) */ 66 #ifdef CONFIG_PPC64BRIDGE 67 unsigned long long bepi:47; 68 #else /* CONFIG_PPC64BRIDGE */ 69 unsigned long bepi:15; /* Effective page index (virtual address) */ 70 #endif /* CONFIG_PPC64BRIDGE */ 71 unsigned long :4; /* Unused */ 72 unsigned long bl:11; /* Block size mask */ 73 unsigned long vs:1; /* Supervisor valid */ 74 unsigned long vp:1; /* User valid */ 75 } BATU; 76 77 typedef struct _P601_BATL { /* Lower part of BAT for 601 processor */ 78 unsigned long brpn:15; /* Real page index (physical address) */ 79 unsigned long :10; /* Unused */ 80 unsigned long v:1; /* Valid bit */ 81 unsigned long bl:6; /* Block size mask */ 82 } P601_BATL; 83 84 typedef struct _BATL { /* Lower part of BAT (all except 601) */ 85 #ifdef CONFIG_PPC64BRIDGE 86 unsigned long long brpn:47; 87 #else /* CONFIG_PPC64BRIDGE */ 88 unsigned long brpn:15; /* Real page index (physical address) */ 89 #endif /* CONFIG_PPC64BRIDGE */ 90 unsigned long :10; /* Unused */ 91 unsigned long w:1; /* Write-thru cache */ 92 unsigned long i:1; /* Cache inhibit */ 93 unsigned long m:1; /* Memory coherence */ 94 unsigned long g:1; /* Guarded (MBZ in IBAT) */ 95 unsigned long :1; /* Unused */ 96 unsigned long pp:2; /* Page access protections */ 97 } BATL; 98 99 typedef struct _BAT { 100 BATU batu; /* Upper register */ 101 BATL batl; /* Lower register */ 102 } BAT; 103 104 typedef struct _P601_BAT { 105 P601_BATU batu; /* Upper register */ 106 P601_BATL batl; /* Lower register */ 107 } P601_BAT; 108 109 /* 110 * Simulated two-level MMU. This structure is used by the kernel 111 * to keep track of MMU mappings and is used to update/maintain 112 * the hardware HASH table which is really a cache of mappings. 113 * 114 * The simulated structures mimic the hardware available on other 115 * platforms, notably the 80x86 and 680x0. 116 */ 117 118 typedef struct _pte { 119 unsigned long page_num:20; 120 unsigned long flags:12; /* Page flags (some unused bits) */ 121 } pte; 122 123 #define PD_SHIFT (10+12) /* Page directory */ 124 #define PD_MASK 0x02FF 125 #define PT_SHIFT (12) /* Page Table */ 126 #define PT_MASK 0x02FF 127 #define PG_SHIFT (12) /* Page Entry */ 128 129 /* MMU context */ 130 131 typedef struct _MMU_context { 132 SEGREG segs[16]; /* Segment registers */ 133 pte **pmap; /* Two-level page-map structure */ 134 } MMU_context; 135 136 extern void _tlbie(unsigned long va); /* invalidate a TLB entry */ 137 extern void _tlbia(void); /* invalidate all TLB entries */ 138 139 typedef enum { 140 IBAT0 = 0, IBAT1, IBAT2, IBAT3, 141 DBAT0, DBAT1, DBAT2, DBAT3, 142 #ifdef CONFIG_HIGH_BATS 143 IBAT4, IBAT5, IBAT6, IBAT7, 144 DBAT4, DBAT5, DBAT6, DBAT7 145 #endif 146 } ppc_bat_t; 147 148 extern int read_bat(ppc_bat_t bat, unsigned long *upper, unsigned long *lower); 149 extern int write_bat(ppc_bat_t bat, unsigned long upper, unsigned long lower); 150 extern void print_bats(void); 151 152 #endif /* __ASSEMBLY__ */ 153 154 #define BATU_VS 0x00000002 155 #define BATU_VP 0x00000001 156 #define BATU_INVALID 0x00000000 157 158 #define BATL_WRITETHROUGH 0x00000040 159 #define BATL_CACHEINHIBIT 0x00000020 160 #define BATL_MEMCOHERENCE 0x00000010 161 #define BATL_GUARDEDSTORAGE 0x00000008 162 #define BATL_NO_ACCESS 0x00000000 163 164 #define BATL_PP_MSK 0x00000003 165 #define BATL_PP_00 0x00000000 /* No access */ 166 #define BATL_PP_01 0x00000001 /* Read-only */ 167 #define BATL_PP_10 0x00000002 /* Read-write */ 168 #define BATL_PP_11 0x00000003 169 170 #define BATL_PP_NO_ACCESS BATL_PP_00 171 #define BATL_PP_RO BATL_PP_01 172 #define BATL_PP_RW BATL_PP_10 173 174 /* BAT Block size values */ 175 #define BATU_BL_128K 0x00000000 176 #define BATU_BL_256K 0x00000004 177 #define BATU_BL_512K 0x0000000c 178 #define BATU_BL_1M 0x0000001c 179 #define BATU_BL_2M 0x0000003c 180 #define BATU_BL_4M 0x0000007c 181 #define BATU_BL_8M 0x000000fc 182 #define BATU_BL_16M 0x000001fc 183 #define BATU_BL_32M 0x000003fc 184 #define BATU_BL_64M 0x000007fc 185 #define BATU_BL_128M 0x00000ffc 186 #define BATU_BL_256M 0x00001ffc 187 188 /* Block lengths for processors that support extended block length */ 189 #ifdef HID0_XBSEN 190 #define BATU_BL_512M 0x00003ffc 191 #define BATU_BL_1G 0x00007ffc 192 #define BATU_BL_2G 0x0000fffc 193 #define BATU_BL_4G 0x0001fffc 194 #define BATU_BL_MAX BATU_BL_4G 195 #else 196 #define BATU_BL_MAX BATU_BL_256M 197 #endif 198 199 /* BAT Access Protection */ 200 #define BPP_XX 0x00 /* No access */ 201 #define BPP_RX 0x01 /* Read only */ 202 #define BPP_RW 0x02 /* Read/write */ 203 204 /* Macros to get values from BATs, once data is in the BAT register format */ 205 #define BATU_VALID(x) (x & 0x3) 206 #define BATU_VADDR(x) (x & 0xfffe0000) 207 #define BATL_PADDR(x) ((phys_addr_t)((x & 0xfffe0000) \ 208 | ((x & 0x0e00ULL) << 24) \ 209 | ((x & 0x04ULL) << 30))) 210 #define BATU_SIZE(x) (1ULL << (fls((x & BATU_BL_MAX) >> 2) + 17)) 211 212 /* bytes into BATU_BL */ 213 #define TO_BATU_BL(x) \ 214 (u32)((((1ull << __ilog2_u64((u64)x)) / (128 * 1024)) - 1) * 4) 215 216 /* Used to set up SDR1 register */ 217 #define HASH_TABLE_SIZE_64K 0x00010000 218 #define HASH_TABLE_SIZE_128K 0x00020000 219 #define HASH_TABLE_SIZE_256K 0x00040000 220 #define HASH_TABLE_SIZE_512K 0x00080000 221 #define HASH_TABLE_SIZE_1M 0x00100000 222 #define HASH_TABLE_SIZE_2M 0x00200000 223 #define HASH_TABLE_SIZE_4M 0x00400000 224 #define HASH_TABLE_MASK_64K 0x000 225 #define HASH_TABLE_MASK_128K 0x001 226 #define HASH_TABLE_MASK_256K 0x003 227 #define HASH_TABLE_MASK_512K 0x007 228 #define HASH_TABLE_MASK_1M 0x00F 229 #define HASH_TABLE_MASK_2M 0x01F 230 #define HASH_TABLE_MASK_4M 0x03F 231 232 /* Control/status registers for the MPC8xx. 233 * A write operation to these registers causes serialized access. 234 * During software tablewalk, the registers used perform mask/shift-add 235 * operations when written/read. A TLB entry is created when the Mx_RPN 236 * is written, and the contents of several registers are used to 237 * create the entry. 238 */ 239 #define MI_CTR 784 /* Instruction TLB control register */ 240 #define MI_GPM 0x80000000 /* Set domain manager mode */ 241 #define MI_PPM 0x40000000 /* Set subpage protection */ 242 #define MI_CIDEF 0x20000000 /* Set cache inhibit when MMU dis */ 243 #define MI_RSV4I 0x08000000 /* Reserve 4 TLB entries */ 244 #define MI_PPCS 0x02000000 /* Use MI_RPN prob/priv state */ 245 #define MI_IDXMASK 0x00001f00 /* TLB index to be loaded */ 246 #define MI_RESETVAL 0x00000000 /* Value of register at reset */ 247 248 /* These are the Ks and Kp from the PowerPC books. For proper operation, 249 * Ks = 0, Kp = 1. 250 */ 251 #define MI_AP 786 252 #define MI_Ks 0x80000000 /* Should not be set */ 253 #define MI_Kp 0x40000000 /* Should always be set */ 254 255 /* The effective page number register. When read, contains the information 256 * about the last instruction TLB miss. When MI_RPN is written, bits in 257 * this register are used to create the TLB entry. 258 */ 259 #define MI_EPN 787 260 #define MI_EPNMASK 0xfffff000 /* Effective page number for entry */ 261 #define MI_EVALID 0x00000200 /* Entry is valid */ 262 #define MI_ASIDMASK 0x0000000f /* ASID match value */ 263 /* Reset value is undefined */ 264 265 /* A "level 1" or "segment" or whatever you want to call it register. 266 * For the instruction TLB, it contains bits that get loaded into the 267 * TLB entry when the MI_RPN is written. 268 */ 269 #define MI_TWC 789 270 #define MI_APG 0x000001e0 /* Access protection group (0) */ 271 #define MI_GUARDED 0x00000010 /* Guarded storage */ 272 #define MI_PSMASK 0x0000000c /* Mask of page size bits */ 273 #define MI_PS8MEG 0x0000000c /* 8M page size */ 274 #define MI_PS512K 0x00000004 /* 512K page size */ 275 #define MI_PS4K_16K 0x00000000 /* 4K or 16K page size */ 276 #define MI_SVALID 0x00000001 /* Segment entry is valid */ 277 /* Reset value is undefined */ 278 279 /* Real page number. Defined by the pte. Writing this register 280 * causes a TLB entry to be created for the instruction TLB, using 281 * additional information from the MI_EPN, and MI_TWC registers. 282 */ 283 #define MI_RPN 790 284 285 /* Define an RPN value for mapping kernel memory to large virtual 286 * pages for boot initialization. This has real page number of 0, 287 * large page size, shared page, cache enabled, and valid. 288 * Also mark all subpages valid and write access. 289 */ 290 #define MI_BOOTINIT 0x000001fd 291 292 #define MD_CTR 792 /* Data TLB control register */ 293 #define MD_GPM 0x80000000 /* Set domain manager mode */ 294 #define MD_PPM 0x40000000 /* Set subpage protection */ 295 #define MD_CIDEF 0x20000000 /* Set cache inhibit when MMU dis */ 296 #define MD_WTDEF 0x10000000 /* Set writethrough when MMU dis */ 297 #define MD_RSV4I 0x08000000 /* Reserve 4 TLB entries */ 298 #define MD_TWAM 0x04000000 /* Use 4K page hardware assist */ 299 #define MD_PPCS 0x02000000 /* Use MI_RPN prob/priv state */ 300 #define MD_IDXMASK 0x00001f00 /* TLB index to be loaded */ 301 #define MD_RESETVAL 0x04000000 /* Value of register at reset */ 302 303 #define M_CASID 793 /* Address space ID (context) to match */ 304 #define MC_ASIDMASK 0x0000000f /* Bits used for ASID value */ 305 306 /* These are the Ks and Kp from the PowerPC books. For proper operation, 307 * Ks = 0, Kp = 1. 308 */ 309 #define MD_AP 794 310 #define MD_Ks 0x80000000 /* Should not be set */ 311 #define MD_Kp 0x40000000 /* Should always be set */ 312 313 /* The effective page number register. When read, contains the information 314 * about the last instruction TLB miss. When MD_RPN is written, bits in 315 * this register are used to create the TLB entry. 316 */ 317 #define MD_EPN 795 318 #define MD_EPNMASK 0xfffff000 /* Effective page number for entry */ 319 #define MD_EVALID 0x00000200 /* Entry is valid */ 320 #define MD_ASIDMASK 0x0000000f /* ASID match value */ 321 /* Reset value is undefined */ 322 323 /* The pointer to the base address of the first level page table. 324 * During a software tablewalk, reading this register provides the address 325 * of the entry associated with MD_EPN. 326 */ 327 #define M_TWB 796 328 #define M_L1TB 0xfffff000 /* Level 1 table base address */ 329 #define M_L1INDX 0x00000ffc /* Level 1 index, when read */ 330 /* Reset value is undefined */ 331 332 /* A "level 1" or "segment" or whatever you want to call it register. 333 * For the data TLB, it contains bits that get loaded into the TLB entry 334 * when the MD_RPN is written. It is also provides the hardware assist 335 * for finding the PTE address during software tablewalk. 336 */ 337 #define MD_TWC 797 338 #define MD_L2TB 0xfffff000 /* Level 2 table base address */ 339 #define MD_L2INDX 0xfffffe00 /* Level 2 index (*pte), when read */ 340 #define MD_APG 0x000001e0 /* Access protection group (0) */ 341 #define MD_GUARDED 0x00000010 /* Guarded storage */ 342 #define MD_PSMASK 0x0000000c /* Mask of page size bits */ 343 #define MD_PS8MEG 0x0000000c /* 8M page size */ 344 #define MD_PS512K 0x00000004 /* 512K page size */ 345 #define MD_PS4K_16K 0x00000000 /* 4K or 16K page size */ 346 #define MD_WT 0x00000002 /* Use writethrough page attribute */ 347 #define MD_SVALID 0x00000001 /* Segment entry is valid */ 348 /* Reset value is undefined */ 349 350 /* Real page number. Defined by the pte. Writing this register 351 * causes a TLB entry to be created for the data TLB, using 352 * additional information from the MD_EPN, and MD_TWC registers. 353 */ 354 #define MD_RPN 798 355 356 /* This is a temporary storage register that could be used to save 357 * a processor working register during a tablewalk. 358 */ 359 #define M_TW 799 360 361 /* 362 * At present, all PowerPC 400-class processors share a similar TLB 363 * architecture. The instruction and data sides share a unified, 364 * 64-entry, fully-associative TLB which is maintained totally under 365 * software control. In addition, the instruction side has a 366 * hardware-managed, 4-entry, fully- associative TLB which serves as a 367 * first level to the shared TLB. These two TLBs are known as the UTLB 368 * and ITLB, respectively. 369 */ 370 371 #define PPC4XX_TLB_SIZE 64 372 373 /* 374 * TLB entries are defined by a "high" tag portion and a "low" data 375 * portion. On all architectures, the data portion is 32-bits. 376 * 377 * TLB entries are managed entirely under software control by reading, 378 * writing, and searchoing using the 4xx-specific tlbre, tlbwr, and tlbsx 379 * instructions. 380 */ 381 382 /* 383 * FSL Book-E support 384 */ 385 386 #define MAS0_TLBSEL_MSK 0x30000000 387 #define MAS0_TLBSEL(x) (((x) << 28) & MAS0_TLBSEL_MSK) 388 #define MAS0_ESEL_MSK 0x0FFF0000 389 #define MAS0_ESEL(x) (((x) << 16) & MAS0_ESEL_MSK) 390 #define MAS0_NV(x) ((x) & 0x00000FFF) 391 392 #define MAS1_VALID 0x80000000 393 #define MAS1_IPROT 0x40000000 394 #define MAS1_TID(x) (((x) << 16) & 0x3FFF0000) 395 #define MAS1_TS 0x00001000 396 #define MAS1_TSIZE(x) (((x) << 7) & 0x00000F80) 397 #define TSIZE_TO_BYTES(x) (1ULL << ((x) + 10)) 398 399 #define MAS2_EPN 0xFFFFF000 400 #define MAS2_X0 0x00000040 401 #define MAS2_X1 0x00000020 402 #define MAS2_W 0x00000010 403 #define MAS2_I 0x00000008 404 #define MAS2_M 0x00000004 405 #define MAS2_G 0x00000002 406 #define MAS2_E 0x00000001 407 408 #define MAS3_RPN 0xFFFFF000 409 #define MAS3_U0 0x00000200 410 #define MAS3_U1 0x00000100 411 #define MAS3_U2 0x00000080 412 #define MAS3_U3 0x00000040 413 #define MAS3_UX 0x00000020 414 #define MAS3_SX 0x00000010 415 #define MAS3_UW 0x00000008 416 #define MAS3_SW 0x00000004 417 #define MAS3_UR 0x00000002 418 #define MAS3_SR 0x00000001 419 420 #define MAS4_TLBSELD(x) MAS0_TLBSEL(x) 421 #define MAS4_TIDDSEL 0x000F0000 422 #define MAS4_TSIZED(x) MAS1_TSIZE(x) 423 #define MAS4_X0D 0x00000040 424 #define MAS4_X1D 0x00000020 425 #define MAS4_WD 0x00000010 426 #define MAS4_ID 0x00000008 427 #define MAS4_MD 0x00000004 428 #define MAS4_GD 0x00000002 429 #define MAS4_ED 0x00000001 430 431 #define MAS6_SPID0 0x3FFF0000 432 #define MAS6_SPID1 0x00007FFE 433 #define MAS6_SAS 0x00000001 434 #define MAS6_SPID MAS6_SPID0 435 436 #define MAS7_RPN 0xFFFFFFFF 437 438 #define FSL_BOOKE_MAS0(tlbsel,esel,nv) \ 439 (MAS0_TLBSEL(tlbsel) | MAS0_ESEL(esel) | MAS0_NV(nv)) 440 #define FSL_BOOKE_MAS1(v,iprot,tid,ts,tsize) \ 441 ((((v) << 31) & MAS1_VALID) |\ 442 (((iprot) << 30) & MAS1_IPROT) |\ 443 (MAS1_TID(tid)) |\ 444 (((ts) << 12) & MAS1_TS) |\ 445 (MAS1_TSIZE(tsize))) 446 #define FSL_BOOKE_MAS2(epn, wimge) \ 447 (((epn) & MAS2_EPN) | (wimge)) 448 #define FSL_BOOKE_MAS3(rpn, user, perms) \ 449 (((rpn) & MAS3_RPN) | (user) | (perms)) 450 #define FSL_BOOKE_MAS7(rpn) \ 451 (((u64)(rpn)) >> 32) 452 453 #define BOOKE_PAGESZ_1K 0 454 #define BOOKE_PAGESZ_2K 1 455 #define BOOKE_PAGESZ_4K 2 456 #define BOOKE_PAGESZ_8K 3 457 #define BOOKE_PAGESZ_16K 4 458 #define BOOKE_PAGESZ_32K 5 459 #define BOOKE_PAGESZ_64K 6 460 #define BOOKE_PAGESZ_128K 7 461 #define BOOKE_PAGESZ_256K 8 462 #define BOOKE_PAGESZ_512K 9 463 #define BOOKE_PAGESZ_1M 10 464 #define BOOKE_PAGESZ_2M 11 465 #define BOOKE_PAGESZ_4M 12 466 #define BOOKE_PAGESZ_8M 13 467 #define BOOKE_PAGESZ_16M 14 468 #define BOOKE_PAGESZ_32M 15 469 #define BOOKE_PAGESZ_64M 16 470 #define BOOKE_PAGESZ_128M 17 471 #define BOOKE_PAGESZ_256M 18 472 #define BOOKE_PAGESZ_512M 19 473 #define BOOKE_PAGESZ_1G 20 474 #define BOOKE_PAGESZ_2G 21 475 #define BOOKE_PAGESZ_4G 22 476 #define BOOKE_PAGESZ_8G 23 477 #define BOOKE_PAGESZ_16GB 24 478 #define BOOKE_PAGESZ_32GB 25 479 #define BOOKE_PAGESZ_64GB 26 480 #define BOOKE_PAGESZ_128GB 27 481 #define BOOKE_PAGESZ_256GB 28 482 #define BOOKE_PAGESZ_512GB 29 483 #define BOOKE_PAGESZ_1TB 30 484 #define BOOKE_PAGESZ_2TB 31 485 486 #define TLBIVAX_ALL 4 487 #define TLBIVAX_TLB0 0 488 #define TLBIVAX_TLB1 8 489 490 #ifdef CONFIG_E500 491 #ifndef __ASSEMBLY__ 492 extern void set_tlb(u8 tlb, u32 epn, u64 rpn, 493 u8 perms, u8 wimge, 494 u8 ts, u8 esel, u8 tsize, u8 iprot); 495 extern void disable_tlb(u8 esel); 496 extern void invalidate_tlb(u8 tlb); 497 extern void init_tlbs(void); 498 extern int find_tlb_idx(void *addr, u8 tlbsel); 499 extern void init_used_tlb_cams(void); 500 extern int find_free_tlbcam(void); 501 extern void print_tlbcam(void); 502 503 extern unsigned int setup_ddr_tlbs(unsigned int memsize_in_meg); 504 extern void clear_ddr_tlbs(unsigned int memsize_in_meg); 505 506 enum tlb_map_type { 507 TLB_MAP_RAM, 508 TLB_MAP_IO, 509 }; 510 511 extern uint64_t tlb_map_range(ulong v_addr, phys_addr_t p_addr, uint64_t size, 512 enum tlb_map_type map_type); 513 514 extern void write_tlb(u32 _mas0, u32 _mas1, u32 _mas2, u32 _mas3, u32 _mas7); 515 516 #define SET_TLB_ENTRY(_tlb, _epn, _rpn, _perms, _wimge, _ts, _esel, _sz, _iprot) \ 517 { .mas0 = FSL_BOOKE_MAS0(_tlb, _esel, 0), \ 518 .mas1 = FSL_BOOKE_MAS1(1, _iprot, 0, _ts, _sz), \ 519 .mas2 = FSL_BOOKE_MAS2(_epn, _wimge), \ 520 .mas3 = FSL_BOOKE_MAS3(_rpn, 0, _perms), \ 521 .mas7 = FSL_BOOKE_MAS7(_rpn), } 522 523 struct fsl_e_tlb_entry { 524 u32 mas0; 525 u32 mas1; 526 u32 mas2; 527 u32 mas3; 528 u32 mas7; 529 }; 530 531 extern struct fsl_e_tlb_entry tlb_table[]; 532 extern int num_tlb_entries; 533 #endif 534 #endif 535 536 #ifdef CONFIG_E300 537 #define LAWAR_EN 0x80000000 538 #define LAWAR_SIZE 0x0000003F 539 540 #define LAWAR_TRGT_IF_PCI 0x00000000 541 #define LAWAR_TRGT_IF_PCI1 0x00000000 542 #define LAWAR_TRGT_IF_PCIX 0x00000000 543 #define LAWAR_TRGT_IF_PCI2 0x00100000 544 #define LAWAR_TRGT_IF_PCIE1 0x00200000 545 #define LAWAR_TRGT_IF_PCIE2 0x00100000 546 #define LAWAR_TRGT_IF_PCIE3 0x00300000 547 #define LAWAR_TRGT_IF_LBC 0x00400000 548 #define LAWAR_TRGT_IF_CCSR 0x00800000 549 #define LAWAR_TRGT_IF_DDR_INTERLEAVED 0x00B00000 550 #define LAWAR_TRGT_IF_RIO 0x00c00000 551 #define LAWAR_TRGT_IF_DDR 0x00f00000 552 #define LAWAR_TRGT_IF_DDR1 0x00f00000 553 #define LAWAR_TRGT_IF_DDR2 0x01600000 554 555 #define LAWAR_SIZE_BASE 0xa 556 #define LAWAR_SIZE_4K (LAWAR_SIZE_BASE+1) 557 #define LAWAR_SIZE_8K (LAWAR_SIZE_BASE+2) 558 #define LAWAR_SIZE_16K (LAWAR_SIZE_BASE+3) 559 #define LAWAR_SIZE_32K (LAWAR_SIZE_BASE+4) 560 #define LAWAR_SIZE_64K (LAWAR_SIZE_BASE+5) 561 #define LAWAR_SIZE_128K (LAWAR_SIZE_BASE+6) 562 #define LAWAR_SIZE_256K (LAWAR_SIZE_BASE+7) 563 #define LAWAR_SIZE_512K (LAWAR_SIZE_BASE+8) 564 #define LAWAR_SIZE_1M (LAWAR_SIZE_BASE+9) 565 #define LAWAR_SIZE_2M (LAWAR_SIZE_BASE+10) 566 #define LAWAR_SIZE_4M (LAWAR_SIZE_BASE+11) 567 #define LAWAR_SIZE_8M (LAWAR_SIZE_BASE+12) 568 #define LAWAR_SIZE_16M (LAWAR_SIZE_BASE+13) 569 #define LAWAR_SIZE_32M (LAWAR_SIZE_BASE+14) 570 #define LAWAR_SIZE_64M (LAWAR_SIZE_BASE+15) 571 #define LAWAR_SIZE_128M (LAWAR_SIZE_BASE+16) 572 #define LAWAR_SIZE_256M (LAWAR_SIZE_BASE+17) 573 #define LAWAR_SIZE_512M (LAWAR_SIZE_BASE+18) 574 #define LAWAR_SIZE_1G (LAWAR_SIZE_BASE+19) 575 #define LAWAR_SIZE_2G (LAWAR_SIZE_BASE+20) 576 #define LAWAR_SIZE_4G (LAWAR_SIZE_BASE+21) 577 #define LAWAR_SIZE_8G (LAWAR_SIZE_BASE+22) 578 #define LAWAR_SIZE_16G (LAWAR_SIZE_BASE+23) 579 #define LAWAR_SIZE_32G (LAWAR_SIZE_BASE+24) 580 #endif 581 582 #endif /* _PPC_MMU_H_ */ 583