?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target-arm/translate.c: Use arm_dc_feature() rather than arm_feature()
[qemu-kvm.git] / target-ppc / mmu_helper.c
blob4a34a73ad4e5eaf21a533bd612bfe1c7f2bf630c
1 /*
2 * PowerPC MMU, TLB, SLB and BAT emulation helpers for QEMU.
3 *
4 * Copyright (c) 2003-2007 Jocelyn Mayer
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include "cpu.h"
20 #include "exec/helper-proto.h"
21 #include "sysemu/kvm.h"
22 #include "kvm_ppc.h"
23 #include "mmu-hash64.h"
24 #include "mmu-hash32.h"
25 #include "exec/cpu_ldst.h"
26
27 //#define DEBUG_MMU
28 //#define DEBUG_BATS
29 //#define DEBUG_SOFTWARE_TLB
30 //#define DUMP_PAGE_TABLES
31 //#define DEBUG_SOFTWARE_TLB
32 //#define FLUSH_ALL_TLBS
33
34 #ifdef DEBUG_MMU
35 # define LOG_MMU(...) qemu_log(__VA_ARGS__)
36 # define LOG_MMU_STATE(cpu) log_cpu_state((cpu), 0)
37 #else
38 # define LOG_MMU(...) do { } while (0)
39 # define LOG_MMU_STATE(cpu) do { } while (0)
40 #endif
41
42 #ifdef DEBUG_SOFTWARE_TLB
43 # define LOG_SWTLB(...) qemu_log(__VA_ARGS__)
44 #else
45 # define LOG_SWTLB(...) do { } while (0)
46 #endif
47
48 #ifdef DEBUG_BATS
49 # define LOG_BATS(...) qemu_log(__VA_ARGS__)
50 #else
51 # define LOG_BATS(...) do { } while (0)
52 #endif
53
54 /*****************************************************************************/
55 /* PowerPC MMU emulation */
56
57 /* Context used internally during MMU translations */
58 typedef struct mmu_ctx_t mmu_ctx_t;
59 struct mmu_ctx_t {
60 hwaddr raddr; /* Real address */
61 hwaddr eaddr; /* Effective address */
62 int prot; /* Protection bits */
63 hwaddr hash[2]; /* Pagetable hash values */
64 target_ulong ptem; /* Virtual segment ID | API */
65 int key; /* Access key */
66 int nx; /* Non-execute area */
67 };
68
69 /* Common routines used by software and hardware TLBs emulation */
70 static inline int pte_is_valid(target_ulong pte0)
71 {
72 return pte0 & 0x80000000 ? 1 : 0;
73 }
74
75 static inline void pte_invalidate(target_ulong *pte0)
76 {
77 *pte0 &= ~0x80000000;
78 }
79
80 #define PTE_PTEM_MASK 0x7FFFFFBF
81 #define PTE_CHECK_MASK (TARGET_PAGE_MASK | 0x7B)
82
83 static int pp_check(int key, int pp, int nx)
84 {
85 int access;
86
87 /* Compute access rights */
88 access = 0;
89 if (key == 0) {
90 switch (pp) {
91 case 0x0:
92 case 0x1:
93 case 0x2:
94 access |= PAGE_WRITE;
95 /* No break here */
96 case 0x3:
97 access |= PAGE_READ;
98 break;
99 }
100 } else {
101 switch (pp) {
102 case 0x0:
103 access = 0;
104 break;
105 case 0x1:
106 case 0x3:
107 access = PAGE_READ;
108 break;
109 case 0x2:
110 access = PAGE_READ | PAGE_WRITE;
111 break;
112 }
113 }
114 if (nx == 0) {
115 access |= PAGE_EXEC;
116 }
117
118 return access;
119 }
120
121 static int check_prot(int prot, int rw, int access_type)
122 {
123 int ret;
124
125 if (access_type == ACCESS_CODE) {
126 if (prot & PAGE_EXEC) {
127 ret = 0;
128 } else {
129 ret = -2;
130 }
131 } else if (rw) {
132 if (prot & PAGE_WRITE) {
133 ret = 0;
134 } else {
135 ret = -2;
136 }
137 } else {
138 if (prot & PAGE_READ) {
139 ret = 0;
140 } else {
141 ret = -2;
142 }
143 }
144
145 return ret;
146 }
147
148 static inline int ppc6xx_tlb_pte_check(mmu_ctx_t *ctx, target_ulong pte0,
149 target_ulong pte1, int h, int rw, int type)
150 {
151 target_ulong ptem, mmask;
152 int access, ret, pteh, ptev, pp;
153
154 ret = -1;
155 /* Check validity and table match */
156 ptev = pte_is_valid(pte0);
157 pteh = (pte0 >> 6) & 1;
158 if (ptev && h == pteh) {
159 /* Check vsid & api */
160 ptem = pte0 & PTE_PTEM_MASK;
161 mmask = PTE_CHECK_MASK;
162 pp = pte1 & 0x00000003;
163 if (ptem == ctx->ptem) {
164 if (ctx->raddr != (hwaddr)-1ULL) {
165 /* all matches should have equal RPN, WIMG & PP */
166 if ((ctx->raddr & mmask) != (pte1 & mmask)) {
167 qemu_log("Bad RPN/WIMG/PP\n");
168 return -3;
169 }
170 }
171 /* Compute access rights */
172 access = pp_check(ctx->key, pp, ctx->nx);
173 /* Keep the matching PTE informations */
174 ctx->raddr = pte1;
175 ctx->prot = access;
176 ret = check_prot(ctx->prot, rw, type);
177 if (ret == 0) {
178 /* Access granted */
179 LOG_MMU("PTE access granted !\n");
180 } else {
181 /* Access right violation */
182 LOG_MMU("PTE access rejected\n");
183 }
184 }
185 }
186
187 return ret;
188 }
189
190 static int pte_update_flags(mmu_ctx_t *ctx, target_ulong *pte1p,
191 int ret, int rw)
192 {
193 int store = 0;
194
195 /* Update page flags */
196 if (!(*pte1p & 0x00000100)) {
197 /* Update accessed flag */
198 *pte1p |= 0x00000100;
199 store = 1;
200 }
201 if (!(*pte1p & 0x00000080)) {
202 if (rw == 1 && ret == 0) {
203 /* Update changed flag */
204 *pte1p |= 0x00000080;
205 store = 1;
206 } else {
207 /* Force page fault for first write access */
208 ctx->prot &= ~PAGE_WRITE;
209 }
210 }
211
212 return store;
213 }
214
215 /* Software driven TLB helpers */
216 static inline int ppc6xx_tlb_getnum(CPUPPCState *env, target_ulong eaddr,
217 int way, int is_code)
218 {
219 int nr;
220
221 /* Select TLB num in a way from address */
222 nr = (eaddr >> TARGET_PAGE_BITS) & (env->tlb_per_way - 1);
223 /* Select TLB way */
224 nr += env->tlb_per_way * way;
225 /* 6xx have separate TLBs for instructions and data */
226 if (is_code && env->id_tlbs == 1) {
227 nr += env->nb_tlb;
228 }
229
230 return nr;
231 }
232
233 static inline void ppc6xx_tlb_invalidate_all(CPUPPCState *env)
234 {
235 PowerPCCPU *cpu = ppc_env_get_cpu(env);
236 ppc6xx_tlb_t *tlb;
237 int nr, max;
238
239 /* LOG_SWTLB("Invalidate all TLBs\n"); */
240 /* Invalidate all defined software TLB */
241 max = env->nb_tlb;
242 if (env->id_tlbs == 1) {
243 max *= 2;
244 }
245 for (nr = 0; nr < max; nr++) {
246 tlb = &env->tlb.tlb6[nr];
247 pte_invalidate(&tlb->pte0);
248 }
249 tlb_flush(CPU(cpu), 1);
250 }
251
252 static inline void ppc6xx_tlb_invalidate_virt2(CPUPPCState *env,
253 target_ulong eaddr,
254 int is_code, int match_epn)
255 {
256 #if !defined(FLUSH_ALL_TLBS)
257 CPUState *cs = CPU(ppc_env_get_cpu(env));
258 ppc6xx_tlb_t *tlb;
259 int way, nr;
260
261 /* Invalidate ITLB + DTLB, all ways */
262 for (way = 0; way < env->nb_ways; way++) {
263 nr = ppc6xx_tlb_getnum(env, eaddr, way, is_code);
264 tlb = &env->tlb.tlb6[nr];
265 if (pte_is_valid(tlb->pte0) && (match_epn == 0 || eaddr == tlb->EPN)) {
266 LOG_SWTLB("TLB invalidate %d/%d " TARGET_FMT_lx "\n", nr,
267 env->nb_tlb, eaddr);
268 pte_invalidate(&tlb->pte0);
269 tlb_flush_page(cs, tlb->EPN);
270 }
271 }
272 #else
273 /* XXX: PowerPC specification say this is valid as well */
274 ppc6xx_tlb_invalidate_all(env);
275 #endif
276 }
277
278 static inline void ppc6xx_tlb_invalidate_virt(CPUPPCState *env,
279 target_ulong eaddr, int is_code)
280 {
281 ppc6xx_tlb_invalidate_virt2(env, eaddr, is_code, 0);
282 }
283
284 static void ppc6xx_tlb_store(CPUPPCState *env, target_ulong EPN, int way,
285 int is_code, target_ulong pte0, target_ulong pte1)
286 {
287 ppc6xx_tlb_t *tlb;
288 int nr;
289
290 nr = ppc6xx_tlb_getnum(env, EPN, way, is_code);
291 tlb = &env->tlb.tlb6[nr];
292 LOG_SWTLB("Set TLB %d/%d EPN " TARGET_FMT_lx " PTE0 " TARGET_FMT_lx
293 " PTE1 " TARGET_FMT_lx "\n", nr, env->nb_tlb, EPN, pte0, pte1);
294 /* Invalidate any pending reference in QEMU for this virtual address */
295 ppc6xx_tlb_invalidate_virt2(env, EPN, is_code, 1);
296 tlb->pte0 = pte0;
297 tlb->pte1 = pte1;
298 tlb->EPN = EPN;
299 /* Store last way for LRU mechanism */
300 env->last_way = way;
301 }
302
303 static inline int ppc6xx_tlb_check(CPUPPCState *env, mmu_ctx_t *ctx,
304 target_ulong eaddr, int rw, int access_type)
305 {
306 ppc6xx_tlb_t *tlb;
307 int nr, best, way;
308 int ret;
309
310 best = -1;
311 ret = -1; /* No TLB found */
312 for (way = 0; way < env->nb_ways; way++) {
313 nr = ppc6xx_tlb_getnum(env, eaddr, way,
314 access_type == ACCESS_CODE ? 1 : 0);
315 tlb = &env->tlb.tlb6[nr];
316 /* This test "emulates" the PTE index match for hardware TLBs */
317 if ((eaddr & TARGET_PAGE_MASK) != tlb->EPN) {
318 LOG_SWTLB("TLB %d/%d %s [" TARGET_FMT_lx " " TARGET_FMT_lx
319 "] <> " TARGET_FMT_lx "\n", nr, env->nb_tlb,
320 pte_is_valid(tlb->pte0) ? "valid" : "inval",
321 tlb->EPN, tlb->EPN + TARGET_PAGE_SIZE, eaddr);
322 continue;
323 }
324 LOG_SWTLB("TLB %d/%d %s " TARGET_FMT_lx " <> " TARGET_FMT_lx " "
325 TARGET_FMT_lx " %c %c\n", nr, env->nb_tlb,
326 pte_is_valid(tlb->pte0) ? "valid" : "inval",
327 tlb->EPN, eaddr, tlb->pte1,
328 rw ? 'S' : 'L', access_type == ACCESS_CODE ? 'I' : 'D');
329 switch (ppc6xx_tlb_pte_check(ctx, tlb->pte0, tlb->pte1, 0, rw, access_type)) {
330 case -3:
331 /* TLB inconsistency */
332 return -1;
333 case -2:
334 /* Access violation */
335 ret = -2;
336 best = nr;
337 break;
338 case -1:
339 default:
340 /* No match */
341 break;
342 case 0:
343 /* access granted */
344 /* XXX: we should go on looping to check all TLBs consistency
345 * but we can speed-up the whole thing as the
346 * result would be undefined if TLBs are not consistent.
347 */
348 ret = 0;
349 best = nr;
350 goto done;
351 }
352 }
353 if (best != -1) {
354 done:
355 LOG_SWTLB("found TLB at addr " TARGET_FMT_plx " prot=%01x ret=%d\n",
356 ctx->raddr & TARGET_PAGE_MASK, ctx->prot, ret);
357 /* Update page flags */
358 pte_update_flags(ctx, &env->tlb.tlb6[best].pte1, ret, rw);
359 }
360
361 return ret;
362 }
363
364 /* Perform BAT hit & translation */
365 static inline void bat_size_prot(CPUPPCState *env, target_ulong *blp,
366 int *validp, int *protp, target_ulong *BATu,
367 target_ulong *BATl)
368 {
369 target_ulong bl;
370 int pp, valid, prot;
371
372 bl = (*BATu & 0x00001FFC) << 15;
373 valid = 0;
374 prot = 0;
375 if (((msr_pr == 0) && (*BATu & 0x00000002)) ||
376 ((msr_pr != 0) && (*BATu & 0x00000001))) {
377 valid = 1;
378 pp = *BATl & 0x00000003;
379 if (pp != 0) {
380 prot = PAGE_READ | PAGE_EXEC;
381 if (pp == 0x2) {
382 prot |= PAGE_WRITE;
383 }
384 }
385 }
386 *blp = bl;
387 *validp = valid;
388 *protp = prot;
389 }
390
391 static int get_bat_6xx_tlb(CPUPPCState *env, mmu_ctx_t *ctx,
392 target_ulong virtual, int rw, int type)
393 {
394 target_ulong *BATlt, *BATut, *BATu, *BATl;
395 target_ulong BEPIl, BEPIu, bl;
396 int i, valid, prot;
397 int ret = -1;
398
399 LOG_BATS("%s: %cBAT v " TARGET_FMT_lx "\n", __func__,
400 type == ACCESS_CODE ? 'I' : 'D', virtual);
401 switch (type) {
402 case ACCESS_CODE:
403 BATlt = env->IBAT[1];
404 BATut = env->IBAT[0];
405 break;
406 default:
407 BATlt = env->DBAT[1];
408 BATut = env->DBAT[0];
409 break;
410 }
411 for (i = 0; i < env->nb_BATs; i++) {
412 BATu = &BATut[i];
413 BATl = &BATlt[i];
414 BEPIu = *BATu & 0xF0000000;
415 BEPIl = *BATu & 0x0FFE0000;
416 bat_size_prot(env, &bl, &valid, &prot, BATu, BATl);
417 LOG_BATS("%s: %cBAT%d v " TARGET_FMT_lx " BATu " TARGET_FMT_lx
418 " BATl " TARGET_FMT_lx "\n", __func__,
419 type == ACCESS_CODE ? 'I' : 'D', i, virtual, *BATu, *BATl);
420 if ((virtual & 0xF0000000) == BEPIu &&
421 ((virtual & 0x0FFE0000) & ~bl) == BEPIl) {
422 /* BAT matches */
423 if (valid != 0) {
424 /* Get physical address */
425 ctx->raddr = (*BATl & 0xF0000000) |
426 ((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |
427 (virtual & 0x0001F000);
428 /* Compute access rights */
429 ctx->prot = prot;
430 ret = check_prot(ctx->prot, rw, type);
431 if (ret == 0) {
432 LOG_BATS("BAT %d match: r " TARGET_FMT_plx " prot=%c%c\n",
433 i, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',
434 ctx->prot & PAGE_WRITE ? 'W' : '-');
435 }
436 break;
437 }
438 }
439 }
440 if (ret < 0) {
441 #if defined(DEBUG_BATS)
442 if (qemu_log_enabled()) {
443 LOG_BATS("no BAT match for " TARGET_FMT_lx ":\n", virtual);
444 for (i = 0; i < 4; i++) {
445 BATu = &BATut[i];
446 BATl = &BATlt[i];
447 BEPIu = *BATu & 0xF0000000;
448 BEPIl = *BATu & 0x0FFE0000;
449 bl = (*BATu & 0x00001FFC) << 15;
450 LOG_BATS("%s: %cBAT%d v " TARGET_FMT_lx " BATu " TARGET_FMT_lx
451 " BATl " TARGET_FMT_lx "\n\t" TARGET_FMT_lx " "
452 TARGET_FMT_lx " " TARGET_FMT_lx "\n",
453 __func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
454 *BATu, *BATl, BEPIu, BEPIl, bl);
455 }
456 }
457 #endif
458 }
459 /* No hit */
460 return ret;
461 }
462
463 /* Perform segment based translation */
464 static inline int get_segment_6xx_tlb(CPUPPCState *env, mmu_ctx_t *ctx,
465 target_ulong eaddr, int rw, int type)
466 {
467 hwaddr hash;
468 target_ulong vsid;
469 int ds, pr, target_page_bits;
470 int ret;
471 target_ulong sr, pgidx;
472
473 pr = msr_pr;
474 ctx->eaddr = eaddr;
475
476 sr = env->sr[eaddr >> 28];
477 ctx->key = (((sr & 0x20000000) && (pr != 0)) ||
478 ((sr & 0x40000000) && (pr == 0))) ? 1 : 0;
479 ds = sr & 0x80000000 ? 1 : 0;
480 ctx->nx = sr & 0x10000000 ? 1 : 0;
481 vsid = sr & 0x00FFFFFF;
482 target_page_bits = TARGET_PAGE_BITS;
483 LOG_MMU("Check segment v=" TARGET_FMT_lx " %d " TARGET_FMT_lx " nip="
484 TARGET_FMT_lx " lr=" TARGET_FMT_lx
485 " ir=%d dr=%d pr=%d %d t=%d\n",
486 eaddr, (int)(eaddr >> 28), sr, env->nip, env->lr, (int)msr_ir,
487 (int)msr_dr, pr != 0 ? 1 : 0, rw, type);
488 pgidx = (eaddr & ~SEGMENT_MASK_256M) >> target_page_bits;
489 hash = vsid ^ pgidx;
490 ctx->ptem = (vsid << 7) | (pgidx >> 10);
491
492 LOG_MMU("pte segment: key=%d ds %d nx %d vsid " TARGET_FMT_lx "\n",
493 ctx->key, ds, ctx->nx, vsid);
494 ret = -1;
495 if (!ds) {
496 /* Check if instruction fetch is allowed, if needed */
497 if (type != ACCESS_CODE || ctx->nx == 0) {
498 /* Page address translation */
499 LOG_MMU("htab_base " TARGET_FMT_plx " htab_mask " TARGET_FMT_plx
500 " hash " TARGET_FMT_plx "\n",
501 env->htab_base, env->htab_mask, hash);
502 ctx->hash[0] = hash;
503 ctx->hash[1] = ~hash;
504
505 /* Initialize real address with an invalid value */
506 ctx->raddr = (hwaddr)-1ULL;
507 /* Software TLB search */
508 ret = ppc6xx_tlb_check(env, ctx, eaddr, rw, type);
509 #if defined(DUMP_PAGE_TABLES)
510 if (qemu_log_enabled()) {
511 hwaddr curaddr;
512 uint32_t a0, a1, a2, a3;
513
514 qemu_log("Page table: " TARGET_FMT_plx " len " TARGET_FMT_plx
515 "\n", sdr, mask + 0x80);
516 for (curaddr = sdr; curaddr < (sdr + mask + 0x80);
517 curaddr += 16) {
518 a0 = ldl_phys(curaddr);
519 a1 = ldl_phys(curaddr + 4);
520 a2 = ldl_phys(curaddr + 8);
521 a3 = ldl_phys(curaddr + 12);
522 if (a0 != 0 || a1 != 0 || a2 != 0 || a3 != 0) {
523 qemu_log(TARGET_FMT_plx ": %08x %08x %08x %08x\n",
524 curaddr, a0, a1, a2, a3);
525 }
526 }
527 }
528 #endif
529 } else {
530 LOG_MMU("No access allowed\n");
531 ret = -3;
532 }
533 } else {
534 target_ulong sr;
535
536 LOG_MMU("direct store...\n");
537 /* Direct-store segment : absolutely *BUGGY* for now */
538
539 /* Direct-store implies a 32-bit MMU.
540 * Check the Segment Register's bus unit ID (BUID).
541 */
542 sr = env->sr[eaddr >> 28];
543 if ((sr & 0x1FF00000) >> 20 == 0x07f) {
544 /* Memory-forced I/O controller interface access */
545 /* If T=1 and BUID=x'07F', the 601 performs a memory access
546 * to SR[28-31] LA[4-31], bypassing all protection mechanisms.
547 */
548 ctx->raddr = ((sr & 0xF) << 28) | (eaddr & 0x0FFFFFFF);
549 ctx->prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
550 return 0;
551 }
552
553 switch (type) {
554 case ACCESS_INT:
555 /* Integer load/store : only access allowed */
556 break;
557 case ACCESS_CODE:
558 /* No code fetch is allowed in direct-store areas */
559 return -4;
560 case ACCESS_FLOAT:
561 /* Floating point load/store */
562 return -4;
563 case ACCESS_RES:
564 /* lwarx, ldarx or srwcx. */
565 return -4;
566 case ACCESS_CACHE:
567 /* dcba, dcbt, dcbtst, dcbf, dcbi, dcbst, dcbz, or icbi */
568 /* Should make the instruction do no-op.
569 * As it already do no-op, it's quite easy :-)
570 */
571 ctx->raddr = eaddr;
572 return 0;
573 case ACCESS_EXT:
574 /* eciwx or ecowx */
575 return -4;
576 default:
577 qemu_log("ERROR: instruction should not need "
578 "address translation\n");
579 return -4;
580 }
581 if ((rw == 1 || ctx->key != 1) && (rw == 0 || ctx->key != 0)) {
582 ctx->raddr = eaddr;
583 ret = 2;
584 } else {
585 ret = -2;
586 }
587 }
588
589 return ret;
590 }
591
592 /* Generic TLB check function for embedded PowerPC implementations */
593 static int ppcemb_tlb_check(CPUPPCState *env, ppcemb_tlb_t *tlb,
594 hwaddr *raddrp,
595 target_ulong address, uint32_t pid, int ext,
596 int i)
597 {
598 target_ulong mask;
599
600 /* Check valid flag */
601 if (!(tlb->prot & PAGE_VALID)) {
602 return -1;
603 }
604 mask = ~(tlb->size - 1);
605 LOG_SWTLB("%s: TLB %d address " TARGET_FMT_lx " PID %u <=> " TARGET_FMT_lx
606 " " TARGET_FMT_lx " %u %x\n", __func__, i, address, pid, tlb->EPN,
607 mask, (uint32_t)tlb->PID, tlb->prot);
608 /* Check PID */
609 if (tlb->PID != 0 && tlb->PID != pid) {
610 return -1;
611 }
612 /* Check effective address */
613 if ((address & mask) != tlb->EPN) {
614 return -1;
615 }
616 *raddrp = (tlb->RPN & mask) | (address & ~mask);
617 if (ext) {
618 /* Extend the physical address to 36 bits */
619 *raddrp |= (uint64_t)(tlb->RPN & 0xF) << 32;
620 }
621
622 return 0;
623 }
624
625 /* Generic TLB search function for PowerPC embedded implementations */
626 static int ppcemb_tlb_search(CPUPPCState *env, target_ulong address,
627 uint32_t pid)
628 {
629 ppcemb_tlb_t *tlb;
630 hwaddr raddr;
631 int i, ret;
632
633 /* Default return value is no match */
634 ret = -1;
635 for (i = 0; i < env->nb_tlb; i++) {
636 tlb = &env->tlb.tlbe[i];
637 if (ppcemb_tlb_check(env, tlb, &raddr, address, pid, 0, i) == 0) {
638 ret = i;
639 break;
640 }
641 }
642
643 return ret;
644 }
645
646 /* Helpers specific to PowerPC 40x implementations */
647 static inline void ppc4xx_tlb_invalidate_all(CPUPPCState *env)
648 {
649 PowerPCCPU *cpu = ppc_env_get_cpu(env);
650 ppcemb_tlb_t *tlb;
651 int i;
652
653 for (i = 0; i < env->nb_tlb; i++) {
654 tlb = &env->tlb.tlbe[i];
655 tlb->prot &= ~PAGE_VALID;
656 }
657 tlb_flush(CPU(cpu), 1);
658 }
659
660 static inline void ppc4xx_tlb_invalidate_virt(CPUPPCState *env,
661 target_ulong eaddr, uint32_t pid)
662 {
663 #if !defined(FLUSH_ALL_TLBS)
664 CPUState *cs = CPU(ppc_env_get_cpu(env));
665 ppcemb_tlb_t *tlb;
666 hwaddr raddr;
667 target_ulong page, end;
668 int i;
669
670 for (i = 0; i < env->nb_tlb; i++) {
671 tlb = &env->tlb.tlbe[i];
672 if (ppcemb_tlb_check(env, tlb, &raddr, eaddr, pid, 0, i) == 0) {
673 end = tlb->EPN + tlb->size;
674 for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE) {
675 tlb_flush_page(cs, page);
676 }
677 tlb->prot &= ~PAGE_VALID;
678 break;
679 }
680 }
681 #else
682 ppc4xx_tlb_invalidate_all(env);
683 #endif
684 }
685
686 static int mmu40x_get_physical_address(CPUPPCState *env, mmu_ctx_t *ctx,
687 target_ulong address, int rw,
688 int access_type)
689 {
690 ppcemb_tlb_t *tlb;
691 hwaddr raddr;
692 int i, ret, zsel, zpr, pr;
693
694 ret = -1;
695 raddr = (hwaddr)-1ULL;
696 pr = msr_pr;
697 for (i = 0; i < env->nb_tlb; i++) {
698 tlb = &env->tlb.tlbe[i];
699 if (ppcemb_tlb_check(env, tlb, &raddr, address,
700 env->spr[SPR_40x_PID], 0, i) < 0) {
701 continue;
702 }
703 zsel = (tlb->attr >> 4) & 0xF;
704 zpr = (env->spr[SPR_40x_ZPR] >> (30 - (2 * zsel))) & 0x3;
705 LOG_SWTLB("%s: TLB %d zsel %d zpr %d rw %d attr %08x\n",
706 __func__, i, zsel, zpr, rw, tlb->attr);
707 /* Check execute enable bit */
708 switch (zpr) {
709 case 0x2:
710 if (pr != 0) {
711 goto check_perms;
712 }
713 /* No break here */
714 case 0x3:
715 /* All accesses granted */
716 ctx->prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
717 ret = 0;
718 break;
719 case 0x0:
720 if (pr != 0) {
721 /* Raise Zone protection fault. */
722 env->spr[SPR_40x_ESR] = 1 << 22;
723 ctx->prot = 0;
724 ret = -2;
725 break;
726 }
727 /* No break here */
728 case 0x1:
729 check_perms:
730 /* Check from TLB entry */
731 ctx->prot = tlb->prot;
732 ret = check_prot(ctx->prot, rw, access_type);
733 if (ret == -2) {
734 env->spr[SPR_40x_ESR] = 0;
735 }
736 break;
737 }
738 if (ret >= 0) {
739 ctx->raddr = raddr;
740 LOG_SWTLB("%s: access granted " TARGET_FMT_lx " => " TARGET_FMT_plx
741 " %d %d\n", __func__, address, ctx->raddr, ctx->prot,
742 ret);
743 return 0;
744 }
745 }
746 LOG_SWTLB("%s: access refused " TARGET_FMT_lx " => " TARGET_FMT_plx
747 " %d %d\n", __func__, address, raddr, ctx->prot, ret);
748
749 return ret;
750 }
751
752 void store_40x_sler(CPUPPCState *env, uint32_t val)
753 {
754 PowerPCCPU *cpu = ppc_env_get_cpu(env);
755
756 /* XXX: TO BE FIXED */
757 if (val != 0x00000000) {
758 cpu_abort(CPU(cpu), "Little-endian regions are not supported by now\n");
759 }
760 env->spr[SPR_405_SLER] = val;
761 }
762
763 static inline int mmubooke_check_tlb(CPUPPCState *env, ppcemb_tlb_t *tlb,
764 hwaddr *raddr, int *prot,
765 target_ulong address, int rw,
766 int access_type, int i)
767 {
768 int ret, prot2;
769
770 if (ppcemb_tlb_check(env, tlb, raddr, address,
771 env->spr[SPR_BOOKE_PID],
772 !env->nb_pids, i) >= 0) {
773 goto found_tlb;
774 }
775
776 if (env->spr[SPR_BOOKE_PID1] &&
777 ppcemb_tlb_check(env, tlb, raddr, address,
778 env->spr[SPR_BOOKE_PID1], 0, i) >= 0) {
779 goto found_tlb;
780 }
781
782 if (env->spr[SPR_BOOKE_PID2] &&
783 ppcemb_tlb_check(env, tlb, raddr, address,
784 env->spr[SPR_BOOKE_PID2], 0, i) >= 0) {
785 goto found_tlb;
786 }
787
788 LOG_SWTLB("%s: TLB entry not found\n", __func__);
789 return -1;
790
791 found_tlb:
792
793 if (msr_pr != 0) {
794 prot2 = tlb->prot & 0xF;
795 } else {
796 prot2 = (tlb->prot >> 4) & 0xF;
797 }
798
799 /* Check the address space */
800 if (access_type == ACCESS_CODE) {
801 if (msr_ir != (tlb->attr & 1)) {
802 LOG_SWTLB("%s: AS doesn't match\n", __func__);
803 return -1;
804 }
805
806 *prot = prot2;
807 if (prot2 & PAGE_EXEC) {
808 LOG_SWTLB("%s: good TLB!\n", __func__);
809 return 0;
810 }
811
812 LOG_SWTLB("%s: no PAGE_EXEC: %x\n", __func__, prot2);
813 ret = -3;
814 } else {
815 if (msr_dr != (tlb->attr & 1)) {
816 LOG_SWTLB("%s: AS doesn't match\n", __func__);
817 return -1;
818 }
819
820 *prot = prot2;
821 if ((!rw && prot2 & PAGE_READ) || (rw && (prot2 & PAGE_WRITE))) {
822 LOG_SWTLB("%s: found TLB!\n", __func__);
823 return 0;
824 }
825
826 LOG_SWTLB("%s: PAGE_READ/WRITE doesn't match: %x\n", __func__, prot2);
827 ret = -2;
828 }
829
830 return ret;
831 }
832
833 static int mmubooke_get_physical_address(CPUPPCState *env, mmu_ctx_t *ctx,
834 target_ulong address, int rw,
835 int access_type)
836 {
837 ppcemb_tlb_t *tlb;
838 hwaddr raddr;
839 int i, ret;
840
841 ret = -1;
842 raddr = (hwaddr)-1ULL;
843 for (i = 0; i < env->nb_tlb; i++) {
844 tlb = &env->tlb.tlbe[i];
845 ret = mmubooke_check_tlb(env, tlb, &raddr, &ctx->prot, address, rw,
846 access_type, i);
847 if (!ret) {
848 break;
849 }
850 }
851
852 if (ret >= 0) {
853 ctx->raddr = raddr;
854 LOG_SWTLB("%s: access granted " TARGET_FMT_lx " => " TARGET_FMT_plx
855 " %d %d\n", __func__, address, ctx->raddr, ctx->prot,
856 ret);
857 } else {
858 LOG_SWTLB("%s: access refused " TARGET_FMT_lx " => " TARGET_FMT_plx
859 " %d %d\n", __func__, address, raddr, ctx->prot, ret);
860 }
861
862 return ret;
863 }
864
865 static void booke206_flush_tlb(CPUPPCState *env, int flags,
866 const int check_iprot)
867 {
868 PowerPCCPU *cpu = ppc_env_get_cpu(env);
869 int tlb_size;
870 int i, j;
871 ppcmas_tlb_t *tlb = env->tlb.tlbm;
872
873 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
874 if (flags & (1 << i)) {
875 tlb_size = booke206_tlb_size(env, i);
876 for (j = 0; j < tlb_size; j++) {
877 if (!check_iprot || !(tlb[j].mas1 & MAS1_IPROT)) {
878 tlb[j].mas1 &= ~MAS1_VALID;
879 }
880 }
881 }
882 tlb += booke206_tlb_size(env, i);
883 }
884
885 tlb_flush(CPU(cpu), 1);
886 }
887
888 static hwaddr booke206_tlb_to_page_size(CPUPPCState *env,
889 ppcmas_tlb_t *tlb)
890 {
891 int tlbm_size;
892
893 tlbm_size = (tlb->mas1 & MAS1_TSIZE_MASK) >> MAS1_TSIZE_SHIFT;
894
895 return 1024ULL << tlbm_size;
896 }
897
898 /* TLB check function for MAS based SoftTLBs */
899 static int ppcmas_tlb_check(CPUPPCState *env, ppcmas_tlb_t *tlb,
900 hwaddr *raddrp, target_ulong address,
901 uint32_t pid)
902 {
903 hwaddr mask;
904 uint32_t tlb_pid;
905
906 if (!msr_cm) {
907 /* In 32bit mode we can only address 32bit EAs */
908 address = (uint32_t)address;
909 }
910
911 /* Check valid flag */
912 if (!(tlb->mas1 & MAS1_VALID)) {
913 return -1;
914 }
915
916 mask = ~(booke206_tlb_to_page_size(env, tlb) - 1);
917 LOG_SWTLB("%s: TLB ADDR=0x" TARGET_FMT_lx " PID=0x%x MAS1=0x%x MAS2=0x%"
918 PRIx64 " mask=0x" TARGET_FMT_lx " MAS7_3=0x%" PRIx64 " MAS8=%x\n",
919 __func__, address, pid, tlb->mas1, tlb->mas2, mask, tlb->mas7_3,
920 tlb->mas8);
921
922 /* Check PID */
923 tlb_pid = (tlb->mas1 & MAS1_TID_MASK) >> MAS1_TID_SHIFT;
924 if (tlb_pid != 0 && tlb_pid != pid) {
925 return -1;
926 }
927
928 /* Check effective address */
929 if ((address & mask) != (tlb->mas2 & MAS2_EPN_MASK)) {
930 return -1;
931 }
932
933 if (raddrp) {
934 *raddrp = (tlb->mas7_3 & mask) | (address & ~mask);
935 }
936
937 return 0;
938 }
939
940 static int mmubooke206_check_tlb(CPUPPCState *env, ppcmas_tlb_t *tlb,
941 hwaddr *raddr, int *prot,
942 target_ulong address, int rw,
943 int access_type)
944 {
945 int ret;
946 int prot2 = 0;
947
948 if (ppcmas_tlb_check(env, tlb, raddr, address,
949 env->spr[SPR_BOOKE_PID]) >= 0) {
950 goto found_tlb;
951 }
952
953 if (env->spr[SPR_BOOKE_PID1] &&
954 ppcmas_tlb_check(env, tlb, raddr, address,
955 env->spr[SPR_BOOKE_PID1]) >= 0) {
956 goto found_tlb;
957 }
958
959 if (env->spr[SPR_BOOKE_PID2] &&
960 ppcmas_tlb_check(env, tlb, raddr, address,
961 env->spr[SPR_BOOKE_PID2]) >= 0) {
962 goto found_tlb;
963 }
964
965 LOG_SWTLB("%s: TLB entry not found\n", __func__);
966 return -1;
967
968 found_tlb:
969
970 if (msr_pr != 0) {
971 if (tlb->mas7_3 & MAS3_UR) {
972 prot2 |= PAGE_READ;
973 }
974 if (tlb->mas7_3 & MAS3_UW) {
975 prot2 |= PAGE_WRITE;
976 }
977 if (tlb->mas7_3 & MAS3_UX) {
978 prot2 |= PAGE_EXEC;
979 }
980 } else {
981 if (tlb->mas7_3 & MAS3_SR) {
982 prot2 |= PAGE_READ;
983 }
984 if (tlb->mas7_3 & MAS3_SW) {
985 prot2 |= PAGE_WRITE;
986 }
987 if (tlb->mas7_3 & MAS3_SX) {
988 prot2 |= PAGE_EXEC;
989 }
990 }
991
992 /* Check the address space and permissions */
993 if (access_type == ACCESS_CODE) {
994 if (msr_ir != ((tlb->mas1 & MAS1_TS) >> MAS1_TS_SHIFT)) {
995 LOG_SWTLB("%s: AS doesn't match\n", __func__);
996 return -1;
997 }
998
999 *prot = prot2;
1000 if (prot2 & PAGE_EXEC) {
1001 LOG_SWTLB("%s: good TLB!\n", __func__);
1002 return 0;
1003 }
1004
1005 LOG_SWTLB("%s: no PAGE_EXEC: %x\n", __func__, prot2);
1006 ret = -3;
1007 } else {
1008 if (msr_dr != ((tlb->mas1 & MAS1_TS) >> MAS1_TS_SHIFT)) {
1009 LOG_SWTLB("%s: AS doesn't match\n", __func__);
1010 return -1;
1011 }
1012
1013 *prot = prot2;
1014 if ((!rw && prot2 & PAGE_READ) || (rw && (prot2 & PAGE_WRITE))) {
1015 LOG_SWTLB("%s: found TLB!\n", __func__);
1016 return 0;
1017 }
1018
1019 LOG_SWTLB("%s: PAGE_READ/WRITE doesn't match: %x\n", __func__, prot2);
1020 ret = -2;
1021 }
1022
1023 return ret;
1024 }
1025
1026 static int mmubooke206_get_physical_address(CPUPPCState *env, mmu_ctx_t *ctx,
1027 target_ulong address, int rw,
1028 int access_type)
1029 {
1030 ppcmas_tlb_t *tlb;
1031 hwaddr raddr;
1032 int i, j, ret;
1033
1034 ret = -1;
1035 raddr = (hwaddr)-1ULL;
1036
1037 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
1038 int ways = booke206_tlb_ways(env, i);
1039
1040 for (j = 0; j < ways; j++) {
1041 tlb = booke206_get_tlbm(env, i, address, j);
1042 if (!tlb) {
1043 continue;
1044 }
1045 ret = mmubooke206_check_tlb(env, tlb, &raddr, &ctx->prot, address,
1046 rw, access_type);
1047 if (ret != -1) {
1048 goto found_tlb;
1049 }
1050 }
1051 }
1052
1053 found_tlb:
1054
1055 if (ret >= 0) {
1056 ctx->raddr = raddr;
1057 LOG_SWTLB("%s: access granted " TARGET_FMT_lx " => " TARGET_FMT_plx
1058 " %d %d\n", __func__, address, ctx->raddr, ctx->prot,
1059 ret);
1060 } else {
1061 LOG_SWTLB("%s: access refused " TARGET_FMT_lx " => " TARGET_FMT_plx
1062 " %d %d\n", __func__, address, raddr, ctx->prot, ret);
1063 }
1064
1065 return ret;
1066 }
1067
1068 static const char *book3e_tsize_to_str[32] = {
1069 "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K",
1070 "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M",
1071 "1G", "2G", "4G", "8G", "16G", "32G", "64G", "128G", "256G", "512G",
1072 "1T", "2T"
1073 };
1074
1075 static void mmubooke_dump_mmu(FILE *f, fprintf_function cpu_fprintf,
1076 CPUPPCState *env)
1077 {
1078 ppcemb_tlb_t *entry;
1079 int i;
1080
1081 if (kvm_enabled() && !env->kvm_sw_tlb) {
1082 cpu_fprintf(f, "Cannot access KVM TLB\n");
1083 return;
1084 }
1085
1086 cpu_fprintf(f, "\nTLB:\n");
1087 cpu_fprintf(f, "Effective Physical Size PID Prot "
1088 "Attr\n");
1089
1090 entry = &env->tlb.tlbe[0];
1091 for (i = 0; i < env->nb_tlb; i++, entry++) {
1092 hwaddr ea, pa;
1093 target_ulong mask;
1094 uint64_t size = (uint64_t)entry->size;
1095 char size_buf[20];
1096
1097 /* Check valid flag */
1098 if (!(entry->prot & PAGE_VALID)) {
1099 continue;
1100 }
1101
1102 mask = ~(entry->size - 1);
1103 ea = entry->EPN & mask;
1104 pa = entry->RPN & mask;
1105 /* Extend the physical address to 36 bits */
1106 pa |= (hwaddr)(entry->RPN & 0xF) << 32;
1107 size /= 1024;
1108 if (size >= 1024) {
1109 snprintf(size_buf, sizeof(size_buf), "%3" PRId64 "M", size / 1024);
1110 } else {
1111 snprintf(size_buf, sizeof(size_buf), "%3" PRId64 "k", size);
1112 }
1113 cpu_fprintf(f, "0x%016" PRIx64 " 0x%016" PRIx64 " %s %-5u %08x %08x\n",
1114 (uint64_t)ea, (uint64_t)pa, size_buf, (uint32_t)entry->PID,
1115 entry->prot, entry->attr);
1116 }
1117
1118 }
1119
1120 static void mmubooke206_dump_one_tlb(FILE *f, fprintf_function cpu_fprintf,
1121 CPUPPCState *env, int tlbn, int offset,
1122 int tlbsize)
1123 {
1124 ppcmas_tlb_t *entry;
1125 int i;
1126
1127 cpu_fprintf(f, "\nTLB%d:\n", tlbn);
1128 cpu_fprintf(f, "Effective Physical Size TID TS SRWX"
1129 " URWX WIMGE U0123\n");
1130
1131 entry = &env->tlb.tlbm[offset];
1132 for (i = 0; i < tlbsize; i++, entry++) {
1133 hwaddr ea, pa, size;
1134 int tsize;
1135
1136 if (!(entry->mas1 & MAS1_VALID)) {
1137 continue;
1138 }
1139
1140 tsize = (entry->mas1 & MAS1_TSIZE_MASK) >> MAS1_TSIZE_SHIFT;
1141 size = 1024ULL << tsize;
1142 ea = entry->mas2 & ~(size - 1);
1143 pa = entry->mas7_3 & ~(size - 1);
1144
1145 cpu_fprintf(f, "0x%016" PRIx64 " 0x%016" PRIx64 " %4s %-5u %1u S%c%c%c"
1146 "U%c%c%c %c%c%c%c%c U%c%c%c%c\n",
1147 (uint64_t)ea, (uint64_t)pa,
1148 book3e_tsize_to_str[tsize],
1149 (entry->mas1 & MAS1_TID_MASK) >> MAS1_TID_SHIFT,
1150 (entry->mas1 & MAS1_TS) >> MAS1_TS_SHIFT,
1151 entry->mas7_3 & MAS3_SR ? 'R' : '-',
1152 entry->mas7_3 & MAS3_SW ? 'W' : '-',
1153 entry->mas7_3 & MAS3_SX ? 'X' : '-',
1154 entry->mas7_3 & MAS3_UR ? 'R' : '-',
1155 entry->mas7_3 & MAS3_UW ? 'W' : '-',
1156 entry->mas7_3 & MAS3_UX ? 'X' : '-',
1157 entry->mas2 & MAS2_W ? 'W' : '-',
1158 entry->mas2 & MAS2_I ? 'I' : '-',
1159 entry->mas2 & MAS2_M ? 'M' : '-',
1160 entry->mas2 & MAS2_G ? 'G' : '-',
1161 entry->mas2 & MAS2_E ? 'E' : '-',
1162 entry->mas7_3 & MAS3_U0 ? '0' : '-',
1163 entry->mas7_3 & MAS3_U1 ? '1' : '-',
1164 entry->mas7_3 & MAS3_U2 ? '2' : '-',
1165 entry->mas7_3 & MAS3_U3 ? '3' : '-');
1166 }
1167 }
1168
1169 static void mmubooke206_dump_mmu(FILE *f, fprintf_function cpu_fprintf,
1170 CPUPPCState *env)
1171 {
1172 int offset = 0;
1173 int i;
1174
1175 if (kvm_enabled() && !env->kvm_sw_tlb) {
1176 cpu_fprintf(f, "Cannot access KVM TLB\n");
1177 return;
1178 }
1179
1180 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
1181 int size = booke206_tlb_size(env, i);
1182
1183 if (size == 0) {
1184 continue;
1185 }
1186
1187 mmubooke206_dump_one_tlb(f, cpu_fprintf, env, i, offset, size);
1188 offset += size;
1189 }
1190 }
1191
1192 static void mmu6xx_dump_BATs(FILE *f, fprintf_function cpu_fprintf,
1193 CPUPPCState *env, int type)
1194 {
1195 target_ulong *BATlt, *BATut, *BATu, *BATl;
1196 target_ulong BEPIl, BEPIu, bl;
1197 int i;
1198
1199 switch (type) {
1200 case ACCESS_CODE:
1201 BATlt = env->IBAT[1];
1202 BATut = env->IBAT[0];
1203 break;
1204 default:
1205 BATlt = env->DBAT[1];
1206 BATut = env->DBAT[0];
1207 break;
1208 }
1209
1210 for (i = 0; i < env->nb_BATs; i++) {
1211 BATu = &BATut[i];
1212 BATl = &BATlt[i];
1213 BEPIu = *BATu & 0xF0000000;
1214 BEPIl = *BATu & 0x0FFE0000;
1215 bl = (*BATu & 0x00001FFC) << 15;
1216 cpu_fprintf(f, "%s BAT%d BATu " TARGET_FMT_lx
1217 " BATl " TARGET_FMT_lx "\n\t" TARGET_FMT_lx " "
1218 TARGET_FMT_lx " " TARGET_FMT_lx "\n",
1219 type == ACCESS_CODE ? "code" : "data", i,
1220 *BATu, *BATl, BEPIu, BEPIl, bl);
1221 }
1222 }
1223
1224 static void mmu6xx_dump_mmu(FILE *f, fprintf_function cpu_fprintf,
1225 CPUPPCState *env)
1226 {
1227 ppc6xx_tlb_t *tlb;
1228 target_ulong sr;
1229 int type, way, entry, i;
1230
1231 cpu_fprintf(f, "HTAB base = 0x%"HWADDR_PRIx"\n", env->htab_base);
1232 cpu_fprintf(f, "HTAB mask = 0x%"HWADDR_PRIx"\n", env->htab_mask);
1233
1234 cpu_fprintf(f, "\nSegment registers:\n");
1235 for (i = 0; i < 32; i++) {
1236 sr = env->sr[i];
1237 if (sr & 0x80000000) {
1238 cpu_fprintf(f, "%02d T=%d Ks=%d Kp=%d BUID=0x%03x "
1239 "CNTLR_SPEC=0x%05x\n", i,
1240 sr & 0x80000000 ? 1 : 0, sr & 0x40000000 ? 1 : 0,
1241 sr & 0x20000000 ? 1 : 0, (uint32_t)((sr >> 20) & 0x1FF),
1242 (uint32_t)(sr & 0xFFFFF));
1243 } else {
1244 cpu_fprintf(f, "%02d T=%d Ks=%d Kp=%d N=%d VSID=0x%06x\n", i,
1245 sr & 0x80000000 ? 1 : 0, sr & 0x40000000 ? 1 : 0,
1246 sr & 0x20000000 ? 1 : 0, sr & 0x10000000 ? 1 : 0,
1247 (uint32_t)(sr & 0x00FFFFFF));
1248 }
1249 }
1250
1251 cpu_fprintf(f, "\nBATs:\n");
1252 mmu6xx_dump_BATs(f, cpu_fprintf, env, ACCESS_INT);
1253 mmu6xx_dump_BATs(f, cpu_fprintf, env, ACCESS_CODE);
1254
1255 if (env->id_tlbs != 1) {
1256 cpu_fprintf(f, "ERROR: 6xx MMU should have separated TLB"
1257 " for code and data\n");
1258 }
1259
1260 cpu_fprintf(f, "\nTLBs [EPN EPN + SIZE]\n");
1261
1262 for (type = 0; type < 2; type++) {
1263 for (way = 0; way < env->nb_ways; way++) {
1264 for (entry = env->nb_tlb * type + env->tlb_per_way * way;
1265 entry < (env->nb_tlb * type + env->tlb_per_way * (way + 1));
1266 entry++) {
1267
1268 tlb = &env->tlb.tlb6[entry];
1269 cpu_fprintf(f, "%s TLB %02d/%02d way:%d %s ["
1270 TARGET_FMT_lx " " TARGET_FMT_lx "]\n",
1271 type ? "code" : "data", entry % env->nb_tlb,
1272 env->nb_tlb, way,
1273 pte_is_valid(tlb->pte0) ? "valid" : "inval",
1274 tlb->EPN, tlb->EPN + TARGET_PAGE_SIZE);
1275 }
1276 }
1277 }
1278 }
1279
1280 void dump_mmu(FILE *f, fprintf_function cpu_fprintf, CPUPPCState *env)
1281 {
1282 switch (env->mmu_model) {
1283 case POWERPC_MMU_BOOKE:
1284 mmubooke_dump_mmu(f, cpu_fprintf, env);
1285 break;
1286 case POWERPC_MMU_BOOKE206:
1287 mmubooke206_dump_mmu(f, cpu_fprintf, env);
1288 break;
1289 case POWERPC_MMU_SOFT_6xx:
1290 case POWERPC_MMU_SOFT_74xx:
1291 mmu6xx_dump_mmu(f, cpu_fprintf, env);
1292 break;
1293 #if defined(TARGET_PPC64)
1294 case POWERPC_MMU_64B:
1295 case POWERPC_MMU_2_06:
1296 case POWERPC_MMU_2_06a:
1297 case POWERPC_MMU_2_06d:
1298 dump_slb(f, cpu_fprintf, env);
1299 break;
1300 #endif
1301 default:
1302 qemu_log_mask(LOG_UNIMP, "%s: unimplemented\n", __func__);
1303 }
1304 }
1305
1306 static inline int check_physical(CPUPPCState *env, mmu_ctx_t *ctx,
1307 target_ulong eaddr, int rw)
1308 {
1309 int in_plb, ret;
1310
1311 ctx->raddr = eaddr;
1312 ctx->prot = PAGE_READ | PAGE_EXEC;
1313 ret = 0;
1314 switch (env->mmu_model) {
1315 case POWERPC_MMU_SOFT_6xx:
1316 case POWERPC_MMU_SOFT_74xx:
1317 case POWERPC_MMU_SOFT_4xx:
1318 case POWERPC_MMU_REAL:
1319 case POWERPC_MMU_BOOKE:
1320 ctx->prot |= PAGE_WRITE;
1321 break;
1322
1323 case POWERPC_MMU_SOFT_4xx_Z:
1324 if (unlikely(msr_pe != 0)) {
1325 /* 403 family add some particular protections,
1326 * using PBL/PBU registers for accesses with no translation.
1327 */
1328 in_plb =
1329 /* Check PLB validity */
1330 (env->pb[0] < env->pb[1] &&
1331 /* and address in plb area */
1332 eaddr >= env->pb[0] && eaddr < env->pb[1]) ||
1333 (env->pb[2] < env->pb[3] &&
1334 eaddr >= env->pb[2] && eaddr < env->pb[3]) ? 1 : 0;
1335 if (in_plb ^ msr_px) {
1336 /* Access in protected area */
1337 if (rw == 1) {
1338 /* Access is not allowed */
1339 ret = -2;
1340 }
1341 } else {
1342 /* Read-write access is allowed */
1343 ctx->prot |= PAGE_WRITE;
1344 }
1345 }
1346 break;
1347
1348 default:
1349 /* Caller's checks mean we should never get here for other models */
1350 abort();
1351 return -1;
1352 }
1353
1354 return ret;
1355 }
1356
1357 static int get_physical_address(CPUPPCState *env, mmu_ctx_t *ctx,
1358 target_ulong eaddr, int rw, int access_type)
1359 {
1360 PowerPCCPU *cpu = ppc_env_get_cpu(env);
1361 int ret = -1;
1362 bool real_mode = (access_type == ACCESS_CODE && msr_ir == 0)
1363 || (access_type != ACCESS_CODE && msr_dr == 0);
1364
1365 #if 0
1366 qemu_log("%s\n", __func__);
1367 #endif
1368
1369 switch (env->mmu_model) {
1370 case POWERPC_MMU_SOFT_6xx:
1371 case POWERPC_MMU_SOFT_74xx:
1372 if (real_mode) {
1373 ret = check_physical(env, ctx, eaddr, rw);
1374 } else {
1375 /* Try to find a BAT */
1376 if (env->nb_BATs != 0) {
1377 ret = get_bat_6xx_tlb(env, ctx, eaddr, rw, access_type);
1378 }
1379 if (ret < 0) {
1380 /* We didn't match any BAT entry or don't have BATs */
1381 ret = get_segment_6xx_tlb(env, ctx, eaddr, rw, access_type);
1382 }
1383 }
1384 break;
1385
1386 case POWERPC_MMU_SOFT_4xx:
1387 case POWERPC_MMU_SOFT_4xx_Z:
1388 if (real_mode) {
1389 ret = check_physical(env, ctx, eaddr, rw);
1390 } else {
1391 ret = mmu40x_get_physical_address(env, ctx, eaddr,
1392 rw, access_type);
1393 }
1394 break;
1395 case POWERPC_MMU_BOOKE:
1396 ret = mmubooke_get_physical_address(env, ctx, eaddr,
1397 rw, access_type);
1398 break;
1399 case POWERPC_MMU_BOOKE206:
1400 ret = mmubooke206_get_physical_address(env, ctx, eaddr, rw,
1401 access_type);
1402 break;
1403 case POWERPC_MMU_MPC8xx:
1404 /* XXX: TODO */
1405 cpu_abort(CPU(cpu), "MPC8xx MMU model is not implemented\n");
1406 break;
1407 case POWERPC_MMU_REAL:
1408 if (real_mode) {
1409 ret = check_physical(env, ctx, eaddr, rw);
1410 } else {
1411 cpu_abort(CPU(cpu), "PowerPC in real mode do not do any translation\n");
1412 }
1413 return -1;
1414 default:
1415 cpu_abort(CPU(cpu), "Unknown or invalid MMU model\n");
1416 return -1;
1417 }
1418 #if 0
1419 qemu_log("%s address " TARGET_FMT_lx " => %d " TARGET_FMT_plx "\n",
1420 __func__, eaddr, ret, ctx->raddr);
1421 #endif
1422
1423 return ret;
1424 }
1425
1426 hwaddr ppc_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
1427 {
1428 PowerPCCPU *cpu = POWERPC_CPU(cs);
1429 CPUPPCState *env = &cpu->env;
1430 mmu_ctx_t ctx;
1431
1432 switch (env->mmu_model) {
1433 #if defined(TARGET_PPC64)
1434 case POWERPC_MMU_64B:
1435 case POWERPC_MMU_2_06:
1436 case POWERPC_MMU_2_06a:
1437 case POWERPC_MMU_2_06d:
1438 return ppc_hash64_get_phys_page_debug(env, addr);
1439 #endif
1440
1441 case POWERPC_MMU_32B:
1442 case POWERPC_MMU_601:
1443 return ppc_hash32_get_phys_page_debug(env, addr);
1444
1445 default:
1446 ;
1447 }
1448
1449 if (unlikely(get_physical_address(env, &ctx, addr, 0, ACCESS_INT) != 0)) {
1450
1451 /* Some MMUs have separate TLBs for code and data. If we only try an
1452 * ACCESS_INT, we may not be able to read instructions mapped by code
1453 * TLBs, so we also try a ACCESS_CODE.
1454 */
1455 if (unlikely(get_physical_address(env, &ctx, addr, 0,
1456 ACCESS_CODE) != 0)) {
1457 return -1;
1458 }
1459 }
1460
1461 return ctx.raddr & TARGET_PAGE_MASK;
1462 }
1463
1464 static void booke206_update_mas_tlb_miss(CPUPPCState *env, target_ulong address,
1465 int rw)
1466 {
1467 env->spr[SPR_BOOKE_MAS0] = env->spr[SPR_BOOKE_MAS4] & MAS4_TLBSELD_MASK;
1468 env->spr[SPR_BOOKE_MAS1] = env->spr[SPR_BOOKE_MAS4] & MAS4_TSIZED_MASK;
1469 env->spr[SPR_BOOKE_MAS2] = env->spr[SPR_BOOKE_MAS4] & MAS4_WIMGED_MASK;
1470 env->spr[SPR_BOOKE_MAS3] = 0;
1471 env->spr[SPR_BOOKE_MAS6] = 0;
1472 env->spr[SPR_BOOKE_MAS7] = 0;
1473
1474 /* AS */
1475 if (((rw == 2) && msr_ir) || ((rw != 2) && msr_dr)) {
1476 env->spr[SPR_BOOKE_MAS1] |= MAS1_TS;
1477 env->spr[SPR_BOOKE_MAS6] |= MAS6_SAS;
1478 }
1479
1480 env->spr[SPR_BOOKE_MAS1] |= MAS1_VALID;
1481 env->spr[SPR_BOOKE_MAS2] |= address & MAS2_EPN_MASK;
1482
1483 switch (env->spr[SPR_BOOKE_MAS4] & MAS4_TIDSELD_PIDZ) {
1484 case MAS4_TIDSELD_PID0:
1485 env->spr[SPR_BOOKE_MAS1] |= env->spr[SPR_BOOKE_PID] << MAS1_TID_SHIFT;
1486 break;
1487 case MAS4_TIDSELD_PID1:
1488 env->spr[SPR_BOOKE_MAS1] |= env->spr[SPR_BOOKE_PID1] << MAS1_TID_SHIFT;
1489 break;
1490 case MAS4_TIDSELD_PID2:
1491 env->spr[SPR_BOOKE_MAS1] |= env->spr[SPR_BOOKE_PID2] << MAS1_TID_SHIFT;
1492 break;
1493 }
1494
1495 env->spr[SPR_BOOKE_MAS6] |= env->spr[SPR_BOOKE_PID] << 16;
1496
1497 /* next victim logic */
1498 env->spr[SPR_BOOKE_MAS0] |= env->last_way << MAS0_ESEL_SHIFT;
1499 env->last_way++;
1500 env->last_way &= booke206_tlb_ways(env, 0) - 1;
1501 env->spr[SPR_BOOKE_MAS0] |= env->last_way << MAS0_NV_SHIFT;
1502 }
1503
1504 /* Perform address translation */
1505 static int cpu_ppc_handle_mmu_fault(CPUPPCState *env, target_ulong address,
1506 int rw, int mmu_idx)
1507 {
1508 CPUState *cs = CPU(ppc_env_get_cpu(env));
1509 mmu_ctx_t ctx;
1510 int access_type;
1511 int ret = 0;
1512
1513 if (rw == 2) {
1514 /* code access */
1515 rw = 0;
1516 access_type = ACCESS_CODE;
1517 } else {
1518 /* data access */
1519 access_type = env->access_type;
1520 }
1521 ret = get_physical_address(env, &ctx, address, rw, access_type);
1522 if (ret == 0) {
1523 tlb_set_page(cs, address & TARGET_PAGE_MASK,
1524 ctx.raddr & TARGET_PAGE_MASK, ctx.prot,
1525 mmu_idx, TARGET_PAGE_SIZE);
1526 ret = 0;
1527 } else if (ret < 0) {
1528 LOG_MMU_STATE(cs);
1529 if (access_type == ACCESS_CODE) {
1530 switch (ret) {
1531 case -1:
1532 /* No matches in page tables or TLB */
1533 switch (env->mmu_model) {
1534 case POWERPC_MMU_SOFT_6xx:
1535 cs->exception_index = POWERPC_EXCP_IFTLB;
1536 env->error_code = 1 << 18;
1537 env->spr[SPR_IMISS] = address;
1538 env->spr[SPR_ICMP] = 0x80000000 | ctx.ptem;
1539 goto tlb_miss;
1540 case POWERPC_MMU_SOFT_74xx:
1541 cs->exception_index = POWERPC_EXCP_IFTLB;
1542 goto tlb_miss_74xx;
1543 case POWERPC_MMU_SOFT_4xx:
1544 case POWERPC_MMU_SOFT_4xx_Z:
1545 cs->exception_index = POWERPC_EXCP_ITLB;
1546 env->error_code = 0;
1547 env->spr[SPR_40x_DEAR] = address;
1548 env->spr[SPR_40x_ESR] = 0x00000000;
1549 break;
1550 case POWERPC_MMU_BOOKE206:
1551 booke206_update_mas_tlb_miss(env, address, rw);
1552 /* fall through */
1553 case POWERPC_MMU_BOOKE:
1554 cs->exception_index = POWERPC_EXCP_ITLB;
1555 env->error_code = 0;
1556 env->spr[SPR_BOOKE_DEAR] = address;
1557 return -1;
1558 case POWERPC_MMU_MPC8xx:
1559 /* XXX: TODO */
1560 cpu_abort(cs, "MPC8xx MMU model is not implemented\n");
1561 break;
1562 case POWERPC_MMU_REAL:
1563 cpu_abort(cs, "PowerPC in real mode should never raise "
1564 "any MMU exceptions\n");
1565 return -1;
1566 default:
1567 cpu_abort(cs, "Unknown or invalid MMU model\n");
1568 return -1;
1569 }
1570 break;
1571 case -2:
1572 /* Access rights violation */
1573 cs->exception_index = POWERPC_EXCP_ISI;
1574 env->error_code = 0x08000000;
1575 break;
1576 case -3:
1577 /* No execute protection violation */
1578 if ((env->mmu_model == POWERPC_MMU_BOOKE) ||
1579 (env->mmu_model == POWERPC_MMU_BOOKE206)) {
1580 env->spr[SPR_BOOKE_ESR] = 0x00000000;
1581 }
1582 cs->exception_index = POWERPC_EXCP_ISI;
1583 env->error_code = 0x10000000;
1584 break;
1585 case -4:
1586 /* Direct store exception */
1587 /* No code fetch is allowed in direct-store areas */
1588 cs->exception_index = POWERPC_EXCP_ISI;
1589 env->error_code = 0x10000000;
1590 break;
1591 }
1592 } else {
1593 switch (ret) {
1594 case -1:
1595 /* No matches in page tables or TLB */
1596 switch (env->mmu_model) {
1597 case POWERPC_MMU_SOFT_6xx:
1598 if (rw == 1) {
1599 cs->exception_index = POWERPC_EXCP_DSTLB;
1600 env->error_code = 1 << 16;
1601 } else {
1602 cs->exception_index = POWERPC_EXCP_DLTLB;
1603 env->error_code = 0;
1604 }
1605 env->spr[SPR_DMISS] = address;
1606 env->spr[SPR_DCMP] = 0x80000000 | ctx.ptem;
1607 tlb_miss:
1608 env->error_code |= ctx.key << 19;
1609 env->spr[SPR_HASH1] = env->htab_base +
1610 get_pteg_offset32(env, ctx.hash[0]);
1611 env->spr[SPR_HASH2] = env->htab_base +
1612 get_pteg_offset32(env, ctx.hash[1]);
1613 break;
1614 case POWERPC_MMU_SOFT_74xx:
1615 if (rw == 1) {
1616 cs->exception_index = POWERPC_EXCP_DSTLB;
1617 } else {
1618 cs->exception_index = POWERPC_EXCP_DLTLB;
1619 }
1620 tlb_miss_74xx:
1621 /* Implement LRU algorithm */
1622 env->error_code = ctx.key << 19;
1623 env->spr[SPR_TLBMISS] = (address & ~((target_ulong)0x3)) |
1624 ((env->last_way + 1) & (env->nb_ways - 1));
1625 env->spr[SPR_PTEHI] = 0x80000000 | ctx.ptem;
1626 break;
1627 case POWERPC_MMU_SOFT_4xx:
1628 case POWERPC_MMU_SOFT_4xx_Z:
1629 cs->exception_index = POWERPC_EXCP_DTLB;
1630 env->error_code = 0;
1631 env->spr[SPR_40x_DEAR] = address;
1632 if (rw) {
1633 env->spr[SPR_40x_ESR] = 0x00800000;
1634 } else {
1635 env->spr[SPR_40x_ESR] = 0x00000000;
1636 }
1637 break;
1638 case POWERPC_MMU_MPC8xx:
1639 /* XXX: TODO */
1640 cpu_abort(cs, "MPC8xx MMU model is not implemented\n");
1641 break;
1642 case POWERPC_MMU_BOOKE206:
1643 booke206_update_mas_tlb_miss(env, address, rw);
1644 /* fall through */
1645 case POWERPC_MMU_BOOKE:
1646 cs->exception_index = POWERPC_EXCP_DTLB;
1647 env->error_code = 0;
1648 env->spr[SPR_BOOKE_DEAR] = address;
1649 env->spr[SPR_BOOKE_ESR] = rw ? ESR_ST : 0;
1650 return -1;
1651 case POWERPC_MMU_REAL:
1652 cpu_abort(cs, "PowerPC in real mode should never raise "
1653 "any MMU exceptions\n");
1654 return -1;
1655 default:
1656 cpu_abort(cs, "Unknown or invalid MMU model\n");
1657 return -1;
1658 }
1659 break;
1660 case -2:
1661 /* Access rights violation */
1662 cs->exception_index = POWERPC_EXCP_DSI;
1663 env->error_code = 0;
1664 if (env->mmu_model == POWERPC_MMU_SOFT_4xx
1665 || env->mmu_model == POWERPC_MMU_SOFT_4xx_Z) {
1666 env->spr[SPR_40x_DEAR] = address;
1667 if (rw) {
1668 env->spr[SPR_40x_ESR] |= 0x00800000;
1669 }
1670 } else if ((env->mmu_model == POWERPC_MMU_BOOKE) ||
1671 (env->mmu_model == POWERPC_MMU_BOOKE206)) {
1672 env->spr[SPR_BOOKE_DEAR] = address;
1673 env->spr[SPR_BOOKE_ESR] = rw ? ESR_ST : 0;
1674 } else {
1675 env->spr[SPR_DAR] = address;
1676 if (rw == 1) {
1677 env->spr[SPR_DSISR] = 0x0A000000;
1678 } else {
1679 env->spr[SPR_DSISR] = 0x08000000;
1680 }
1681 }
1682 break;
1683 case -4:
1684 /* Direct store exception */
1685 switch (access_type) {
1686 case ACCESS_FLOAT:
1687 /* Floating point load/store */
1688 cs->exception_index = POWERPC_EXCP_ALIGN;
1689 env->error_code = POWERPC_EXCP_ALIGN_FP;
1690 env->spr[SPR_DAR] = address;
1691 break;
1692 case ACCESS_RES:
1693 /* lwarx, ldarx or stwcx. */
1694 cs->exception_index = POWERPC_EXCP_DSI;
1695 env->error_code = 0;
1696 env->spr[SPR_DAR] = address;
1697 if (rw == 1) {
1698 env->spr[SPR_DSISR] = 0x06000000;
1699 } else {
1700 env->spr[SPR_DSISR] = 0x04000000;
1701 }
1702 break;
1703 case ACCESS_EXT:
1704 /* eciwx or ecowx */
1705 cs->exception_index = POWERPC_EXCP_DSI;
1706 env->error_code = 0;
1707 env->spr[SPR_DAR] = address;
1708 if (rw == 1) {
1709 env->spr[SPR_DSISR] = 0x06100000;
1710 } else {
1711 env->spr[SPR_DSISR] = 0x04100000;
1712 }
1713 break;
1714 default:
1715 printf("DSI: invalid exception (%d)\n", ret);
1716 cs->exception_index = POWERPC_EXCP_PROGRAM;
1717 env->error_code =
1718 POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL;
1719 env->spr[SPR_DAR] = address;
1720 break;
1721 }
1722 break;
1723 }
1724 }
1725 #if 0
1726 printf("%s: set exception to %d %02x\n", __func__,
1727 cs->exception, env->error_code);
1728 #endif
1729 ret = 1;
1730 }
1731
1732 return ret;
1733 }
1734
1735 /*****************************************************************************/
1736 /* BATs management */
1737 #if !defined(FLUSH_ALL_TLBS)
1738 static inline void do_invalidate_BAT(CPUPPCState *env, target_ulong BATu,
1739 target_ulong mask)
1740 {
1741 CPUState *cs = CPU(ppc_env_get_cpu(env));
1742 target_ulong base, end, page;
1743
1744 base = BATu & ~0x0001FFFF;
1745 end = base + mask + 0x00020000;
1746 LOG_BATS("Flush BAT from " TARGET_FMT_lx " to " TARGET_FMT_lx " ("
1747 TARGET_FMT_lx ")\n", base, end, mask);
1748 for (page = base; page != end; page += TARGET_PAGE_SIZE) {
1749 tlb_flush_page(cs, page);
1750 }
1751 LOG_BATS("Flush done\n");
1752 }
1753 #endif
1754
1755 static inline void dump_store_bat(CPUPPCState *env, char ID, int ul, int nr,
1756 target_ulong value)
1757 {
1758 LOG_BATS("Set %cBAT%d%c to " TARGET_FMT_lx " (" TARGET_FMT_lx ")\n", ID,
1759 nr, ul == 0 ? 'u' : 'l', value, env->nip);
1760 }
1761
1762 void helper_store_ibatu(CPUPPCState *env, uint32_t nr, target_ulong value)
1763 {
1764 target_ulong mask;
1765
1766 dump_store_bat(env, 'I', 0, nr, value);
1767 if (env->IBAT[0][nr] != value) {
1768 mask = (value << 15) & 0x0FFE0000UL;
1769 #if !defined(FLUSH_ALL_TLBS)
1770 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1771 #endif
1772 /* When storing valid upper BAT, mask BEPI and BRPN
1773 * and invalidate all TLBs covered by this BAT
1774 */
1775 mask = (value << 15) & 0x0FFE0000UL;
1776 env->IBAT[0][nr] = (value & 0x00001FFFUL) |
1777 (value & ~0x0001FFFFUL & ~mask);
1778 env->IBAT[1][nr] = (env->IBAT[1][nr] & 0x0000007B) |
1779 (env->IBAT[1][nr] & ~0x0001FFFF & ~mask);
1780 #if !defined(FLUSH_ALL_TLBS)
1781 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1782 #else
1783 tlb_flush(env, 1);
1784 #endif
1785 }
1786 }
1787
1788 void helper_store_ibatl(CPUPPCState *env, uint32_t nr, target_ulong value)
1789 {
1790 dump_store_bat(env, 'I', 1, nr, value);
1791 env->IBAT[1][nr] = value;
1792 }
1793
1794 void helper_store_dbatu(CPUPPCState *env, uint32_t nr, target_ulong value)
1795 {
1796 target_ulong mask;
1797
1798 dump_store_bat(env, 'D', 0, nr, value);
1799 if (env->DBAT[0][nr] != value) {
1800 /* When storing valid upper BAT, mask BEPI and BRPN
1801 * and invalidate all TLBs covered by this BAT
1802 */
1803 mask = (value << 15) & 0x0FFE0000UL;
1804 #if !defined(FLUSH_ALL_TLBS)
1805 do_invalidate_BAT(env, env->DBAT[0][nr], mask);
1806 #endif
1807 mask = (value << 15) & 0x0FFE0000UL;
1808 env->DBAT[0][nr] = (value & 0x00001FFFUL) |
1809 (value & ~0x0001FFFFUL & ~mask);
1810 env->DBAT[1][nr] = (env->DBAT[1][nr] & 0x0000007B) |
1811 (env->DBAT[1][nr] & ~0x0001FFFF & ~mask);
1812 #if !defined(FLUSH_ALL_TLBS)
1813 do_invalidate_BAT(env, env->DBAT[0][nr], mask);
1814 #else
1815 tlb_flush(env, 1);
1816 #endif
1817 }
1818 }
1819
1820 void helper_store_dbatl(CPUPPCState *env, uint32_t nr, target_ulong value)
1821 {
1822 dump_store_bat(env, 'D', 1, nr, value);
1823 env->DBAT[1][nr] = value;
1824 }
1825
1826 void helper_store_601_batu(CPUPPCState *env, uint32_t nr, target_ulong value)
1827 {
1828 target_ulong mask;
1829 #if defined(FLUSH_ALL_TLBS)
1830 int do_inval;
1831 #endif
1832
1833 dump_store_bat(env, 'I', 0, nr, value);
1834 if (env->IBAT[0][nr] != value) {
1835 #if defined(FLUSH_ALL_TLBS)
1836 do_inval = 0;
1837 #endif
1838 mask = (env->IBAT[1][nr] << 17) & 0x0FFE0000UL;
1839 if (env->IBAT[1][nr] & 0x40) {
1840 /* Invalidate BAT only if it is valid */
1841 #if !defined(FLUSH_ALL_TLBS)
1842 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1843 #else
1844 do_inval = 1;
1845 #endif
1846 }
1847 /* When storing valid upper BAT, mask BEPI and BRPN
1848 * and invalidate all TLBs covered by this BAT
1849 */
1850 env->IBAT[0][nr] = (value & 0x00001FFFUL) |
1851 (value & ~0x0001FFFFUL & ~mask);
1852 env->DBAT[0][nr] = env->IBAT[0][nr];
1853 if (env->IBAT[1][nr] & 0x40) {
1854 #if !defined(FLUSH_ALL_TLBS)
1855 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1856 #else
1857 do_inval = 1;
1858 #endif
1859 }
1860 #if defined(FLUSH_ALL_TLBS)
1861 if (do_inval) {
1862 tlb_flush(env, 1);
1863 }
1864 #endif
1865 }
1866 }
1867
1868 void helper_store_601_batl(CPUPPCState *env, uint32_t nr, target_ulong value)
1869 {
1870 #if !defined(FLUSH_ALL_TLBS)
1871 target_ulong mask;
1872 #else
1873 int do_inval;
1874 #endif
1875
1876 dump_store_bat(env, 'I', 1, nr, value);
1877 if (env->IBAT[1][nr] != value) {
1878 #if defined(FLUSH_ALL_TLBS)
1879 do_inval = 0;
1880 #endif
1881 if (env->IBAT[1][nr] & 0x40) {
1882 #if !defined(FLUSH_ALL_TLBS)
1883 mask = (env->IBAT[1][nr] << 17) & 0x0FFE0000UL;
1884 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1885 #else
1886 do_inval = 1;
1887 #endif
1888 }
1889 if (value & 0x40) {
1890 #if !defined(FLUSH_ALL_TLBS)
1891 mask = (value << 17) & 0x0FFE0000UL;
1892 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1893 #else
1894 do_inval = 1;
1895 #endif
1896 }
1897 env->IBAT[1][nr] = value;
1898 env->DBAT[1][nr] = value;
1899 #if defined(FLUSH_ALL_TLBS)
1900 if (do_inval) {
1901 tlb_flush(env, 1);
1902 }
1903 #endif
1904 }
1905 }
1906
1907 /*****************************************************************************/
1908 /* TLB management */
1909 void ppc_tlb_invalidate_all(CPUPPCState *env)
1910 {
1911 PowerPCCPU *cpu = ppc_env_get_cpu(env);
1912
1913 switch (env->mmu_model) {
1914 case POWERPC_MMU_SOFT_6xx:
1915 case POWERPC_MMU_SOFT_74xx:
1916 ppc6xx_tlb_invalidate_all(env);
1917 break;
1918 case POWERPC_MMU_SOFT_4xx:
1919 case POWERPC_MMU_SOFT_4xx_Z:
1920 ppc4xx_tlb_invalidate_all(env);
1921 break;
1922 case POWERPC_MMU_REAL:
1923 cpu_abort(CPU(cpu), "No TLB for PowerPC 4xx in real mode\n");
1924 break;
1925 case POWERPC_MMU_MPC8xx:
1926 /* XXX: TODO */
1927 cpu_abort(CPU(cpu), "MPC8xx MMU model is not implemented\n");
1928 break;
1929 case POWERPC_MMU_BOOKE:
1930 tlb_flush(CPU(cpu), 1);
1931 break;
1932 case POWERPC_MMU_BOOKE206:
1933 booke206_flush_tlb(env, -1, 0);
1934 break;
1935 case POWERPC_MMU_32B:
1936 case POWERPC_MMU_601:
1937 #if defined(TARGET_PPC64)
1938 case POWERPC_MMU_64B:
1939 case POWERPC_MMU_2_06:
1940 case POWERPC_MMU_2_06a:
1941 case POWERPC_MMU_2_06d:
1942 #endif /* defined(TARGET_PPC64) */
1943 tlb_flush(CPU(cpu), 1);
1944 break;
1945 default:
1946 /* XXX: TODO */
1947 cpu_abort(CPU(cpu), "Unknown MMU model\n");
1948 break;
1949 }
1950 }
1951
1952 void ppc_tlb_invalidate_one(CPUPPCState *env, target_ulong addr)
1953 {
1954 #if !defined(FLUSH_ALL_TLBS)
1955 PowerPCCPU *cpu = ppc_env_get_cpu(env);
1956 CPUState *cs;
1957
1958 addr &= TARGET_PAGE_MASK;
1959 switch (env->mmu_model) {
1960 case POWERPC_MMU_SOFT_6xx:
1961 case POWERPC_MMU_SOFT_74xx:
1962 ppc6xx_tlb_invalidate_virt(env, addr, 0);
1963 if (env->id_tlbs == 1) {
1964 ppc6xx_tlb_invalidate_virt(env, addr, 1);
1965 }
1966 break;
1967 case POWERPC_MMU_SOFT_4xx:
1968 case POWERPC_MMU_SOFT_4xx_Z:
1969 ppc4xx_tlb_invalidate_virt(env, addr, env->spr[SPR_40x_PID]);
1970 break;
1971 case POWERPC_MMU_REAL:
1972 cpu_abort(CPU(cpu), "No TLB for PowerPC 4xx in real mode\n");
1973 break;
1974 case POWERPC_MMU_MPC8xx:
1975 /* XXX: TODO */
1976 cpu_abort(CPU(cpu), "MPC8xx MMU model is not implemented\n");
1977 break;
1978 case POWERPC_MMU_BOOKE:
1979 /* XXX: TODO */
1980 cpu_abort(CPU(cpu), "BookE MMU model is not implemented\n");
1981 break;
1982 case POWERPC_MMU_BOOKE206:
1983 /* XXX: TODO */
1984 cpu_abort(CPU(cpu), "BookE 2.06 MMU model is not implemented\n");
1985 break;
1986 case POWERPC_MMU_32B:
1987 case POWERPC_MMU_601:
1988 /* tlbie invalidate TLBs for all segments */
1989 addr &= ~((target_ulong)-1ULL << 28);
1990 cs = CPU(cpu);
1991 /* XXX: this case should be optimized,
1992 * giving a mask to tlb_flush_page
1993 */
1994 tlb_flush_page(cs, addr | (0x0 << 28));
1995 tlb_flush_page(cs, addr | (0x1 << 28));
1996 tlb_flush_page(cs, addr | (0x2 << 28));
1997 tlb_flush_page(cs, addr | (0x3 << 28));
1998 tlb_flush_page(cs, addr | (0x4 << 28));
1999 tlb_flush_page(cs, addr | (0x5 << 28));
2000 tlb_flush_page(cs, addr | (0x6 << 28));
2001 tlb_flush_page(cs, addr | (0x7 << 28));
2002 tlb_flush_page(cs, addr | (0x8 << 28));
2003 tlb_flush_page(cs, addr | (0x9 << 28));
2004 tlb_flush_page(cs, addr | (0xA << 28));
2005 tlb_flush_page(cs, addr | (0xB << 28));
2006 tlb_flush_page(cs, addr | (0xC << 28));
2007 tlb_flush_page(cs, addr | (0xD << 28));
2008 tlb_flush_page(cs, addr | (0xE << 28));
2009 tlb_flush_page(cs, addr | (0xF << 28));
2010 break;
2011 #if defined(TARGET_PPC64)
2012 case POWERPC_MMU_64B:
2013 case POWERPC_MMU_2_06:
2014 case POWERPC_MMU_2_06a:
2015 case POWERPC_MMU_2_06d:
2016 /* tlbie invalidate TLBs for all segments */
2017 /* XXX: given the fact that there are too many segments to invalidate,
2018 * and we still don't have a tlb_flush_mask(env, n, mask) in QEMU,
2019 * we just invalidate all TLBs
2020 */
2021 tlb_flush(CPU(cpu), 1);
2022 break;
2023 #endif /* defined(TARGET_PPC64) */
2024 default:
2025 /* XXX: TODO */
2026 cpu_abort(CPU(cpu), "Unknown MMU model\n");
2027 break;
2028 }
2029 #else
2030 ppc_tlb_invalidate_all(env);
2031 #endif
2032 }
2033
2034 /*****************************************************************************/
2035 /* Special registers manipulation */
2036 void ppc_store_sdr1(CPUPPCState *env, target_ulong value)
2037 {
2038 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2039
2040 LOG_MMU("%s: " TARGET_FMT_lx "\n", __func__, value);
2041 assert(!env->external_htab);
2042 if (env->spr[SPR_SDR1] != value) {
2043 env->spr[SPR_SDR1] = value;
2044 #if defined(TARGET_PPC64)
2045 if (env->mmu_model & POWERPC_MMU_64) {
2046 target_ulong htabsize = value & SDR_64_HTABSIZE;
2047
2048 if (htabsize > 28) {
2049 fprintf(stderr, "Invalid HTABSIZE 0x" TARGET_FMT_lx
2050 " stored in SDR1\n", htabsize);
2051 htabsize = 28;
2052 }
2053 env->htab_mask = (1ULL << (htabsize + 18 - 7)) - 1;
2054 env->htab_base = value & SDR_64_HTABORG;
2055 } else
2056 #endif /* defined(TARGET_PPC64) */
2057 {
2058 /* FIXME: Should check for valid HTABMASK values */
2059 env->htab_mask = ((value & SDR_32_HTABMASK) << 16) | 0xFFFF;
2060 env->htab_base = value & SDR_32_HTABORG;
2061 }
2062 tlb_flush(CPU(cpu), 1);
2063 }
2064 }
2065
2066 /* Segment registers load and store */
2067 target_ulong helper_load_sr(CPUPPCState *env, target_ulong sr_num)
2068 {
2069 #if defined(TARGET_PPC64)
2070 if (env->mmu_model & POWERPC_MMU_64) {
2071 /* XXX */
2072 return 0;
2073 }
2074 #endif
2075 return env->sr[sr_num];
2076 }
2077
2078 void helper_store_sr(CPUPPCState *env, target_ulong srnum, target_ulong value)
2079 {
2080 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2081
2082 LOG_MMU("%s: reg=%d " TARGET_FMT_lx " " TARGET_FMT_lx "\n", __func__,
2083 (int)srnum, value, env->sr[srnum]);
2084 #if defined(TARGET_PPC64)
2085 if (env->mmu_model & POWERPC_MMU_64) {
2086 uint64_t rb = 0, rs = 0;
2087
2088 /* ESID = srnum */
2089 rb |= ((uint32_t)srnum & 0xf) << 28;
2090 /* Set the valid bit */
2091 rb |= SLB_ESID_V;
2092 /* Index = ESID */
2093 rb |= (uint32_t)srnum;
2094
2095 /* VSID = VSID */
2096 rs |= (value & 0xfffffff) << 12;
2097 /* flags = flags */
2098 rs |= ((value >> 27) & 0xf) << 8;
2099
2100 ppc_store_slb(env, rb, rs);
2101 } else
2102 #endif
2103 if (env->sr[srnum] != value) {
2104 env->sr[srnum] = value;
2105 /* Invalidating 256MB of virtual memory in 4kB pages is way longer than
2106 flusing the whole TLB. */
2107 #if !defined(FLUSH_ALL_TLBS) && 0
2108 {
2109 target_ulong page, end;
2110 /* Invalidate 256 MB of virtual memory */
2111 page = (16 << 20) * srnum;
2112 end = page + (16 << 20);
2113 for (; page != end; page += TARGET_PAGE_SIZE) {
2114 tlb_flush_page(CPU(cpu), page);
2115 }
2116 }
2117 #else
2118 tlb_flush(CPU(cpu), 1);
2119 #endif
2120 }
2121 }
2122
2123 /* TLB management */
2124 void helper_tlbia(CPUPPCState *env)
2125 {
2126 ppc_tlb_invalidate_all(env);
2127 }
2128
2129 void helper_tlbie(CPUPPCState *env, target_ulong addr)
2130 {
2131 ppc_tlb_invalidate_one(env, addr);
2132 }
2133
2134 /* Software driven TLBs management */
2135 /* PowerPC 602/603 software TLB load instructions helpers */
2136 static void do_6xx_tlb(CPUPPCState *env, target_ulong new_EPN, int is_code)
2137 {
2138 target_ulong RPN, CMP, EPN;
2139 int way;
2140
2141 RPN = env->spr[SPR_RPA];
2142 if (is_code) {
2143 CMP = env->spr[SPR_ICMP];
2144 EPN = env->spr[SPR_IMISS];
2145 } else {
2146 CMP = env->spr[SPR_DCMP];
2147 EPN = env->spr[SPR_DMISS];
2148 }
2149 way = (env->spr[SPR_SRR1] >> 17) & 1;
2150 (void)EPN; /* avoid a compiler warning */
2151 LOG_SWTLB("%s: EPN " TARGET_FMT_lx " " TARGET_FMT_lx " PTE0 " TARGET_FMT_lx
2152 " PTE1 " TARGET_FMT_lx " way %d\n", __func__, new_EPN, EPN, CMP,
2153 RPN, way);
2154 /* Store this TLB */
2155 ppc6xx_tlb_store(env, (uint32_t)(new_EPN & TARGET_PAGE_MASK),
2156 way, is_code, CMP, RPN);
2157 }
2158
2159 void helper_6xx_tlbd(CPUPPCState *env, target_ulong EPN)
2160 {
2161 do_6xx_tlb(env, EPN, 0);
2162 }
2163
2164 void helper_6xx_tlbi(CPUPPCState *env, target_ulong EPN)
2165 {
2166 do_6xx_tlb(env, EPN, 1);
2167 }
2168
2169 /* PowerPC 74xx software TLB load instructions helpers */
2170 static void do_74xx_tlb(CPUPPCState *env, target_ulong new_EPN, int is_code)
2171 {
2172 target_ulong RPN, CMP, EPN;
2173 int way;
2174
2175 RPN = env->spr[SPR_PTELO];
2176 CMP = env->spr[SPR_PTEHI];
2177 EPN = env->spr[SPR_TLBMISS] & ~0x3;
2178 way = env->spr[SPR_TLBMISS] & 0x3;
2179 (void)EPN; /* avoid a compiler warning */
2180 LOG_SWTLB("%s: EPN " TARGET_FMT_lx " " TARGET_FMT_lx " PTE0 " TARGET_FMT_lx
2181 " PTE1 " TARGET_FMT_lx " way %d\n", __func__, new_EPN, EPN, CMP,
2182 RPN, way);
2183 /* Store this TLB */
2184 ppc6xx_tlb_store(env, (uint32_t)(new_EPN & TARGET_PAGE_MASK),
2185 way, is_code, CMP, RPN);
2186 }
2187
2188 void helper_74xx_tlbd(CPUPPCState *env, target_ulong EPN)
2189 {
2190 do_74xx_tlb(env, EPN, 0);
2191 }
2192
2193 void helper_74xx_tlbi(CPUPPCState *env, target_ulong EPN)
2194 {
2195 do_74xx_tlb(env, EPN, 1);
2196 }
2197
2198 /*****************************************************************************/
2199 /* PowerPC 601 specific instructions (POWER bridge) */
2200
2201 target_ulong helper_rac(CPUPPCState *env, target_ulong addr)
2202 {
2203 mmu_ctx_t ctx;
2204 int nb_BATs;
2205 target_ulong ret = 0;
2206
2207 /* We don't have to generate many instances of this instruction,
2208 * as rac is supervisor only.
2209 */
2210 /* XXX: FIX THIS: Pretend we have no BAT */
2211 nb_BATs = env->nb_BATs;
2212 env->nb_BATs = 0;
2213 if (get_physical_address(env, &ctx, addr, 0, ACCESS_INT) == 0) {
2214 ret = ctx.raddr;
2215 }
2216 env->nb_BATs = nb_BATs;
2217 return ret;
2218 }
2219
2220 static inline target_ulong booke_tlb_to_page_size(int size)
2221 {
2222 return 1024 << (2 * size);
2223 }
2224
2225 static inline int booke_page_size_to_tlb(target_ulong page_size)
2226 {
2227 int size;
2228
2229 switch (page_size) {
2230 case 0x00000400UL:
2231 size = 0x0;
2232 break;
2233 case 0x00001000UL:
2234 size = 0x1;
2235 break;
2236 case 0x00004000UL:
2237 size = 0x2;
2238 break;
2239 case 0x00010000UL:
2240 size = 0x3;
2241 break;
2242 case 0x00040000UL:
2243 size = 0x4;
2244 break;
2245 case 0x00100000UL:
2246 size = 0x5;
2247 break;
2248 case 0x00400000UL:
2249 size = 0x6;
2250 break;
2251 case 0x01000000UL:
2252 size = 0x7;
2253 break;
2254 case 0x04000000UL:
2255 size = 0x8;
2256 break;
2257 case 0x10000000UL:
2258 size = 0x9;
2259 break;
2260 case 0x40000000UL:
2261 size = 0xA;
2262 break;
2263 #if defined(TARGET_PPC64)
2264 case 0x000100000000ULL:
2265 size = 0xB;
2266 break;
2267 case 0x000400000000ULL:
2268 size = 0xC;
2269 break;
2270 case 0x001000000000ULL:
2271 size = 0xD;
2272 break;
2273 case 0x004000000000ULL:
2274 size = 0xE;
2275 break;
2276 case 0x010000000000ULL:
2277 size = 0xF;
2278 break;
2279 #endif
2280 default:
2281 size = -1;
2282 break;
2283 }
2284
2285 return size;
2286 }
2287
2288 /* Helpers for 4xx TLB management */
2289 #define PPC4XX_TLB_ENTRY_MASK 0x0000003f /* Mask for 64 TLB entries */
2290
2291 #define PPC4XX_TLBHI_V 0x00000040
2292 #define PPC4XX_TLBHI_E 0x00000020
2293 #define PPC4XX_TLBHI_SIZE_MIN 0
2294 #define PPC4XX_TLBHI_SIZE_MAX 7
2295 #define PPC4XX_TLBHI_SIZE_DEFAULT 1
2296 #define PPC4XX_TLBHI_SIZE_SHIFT 7
2297 #define PPC4XX_TLBHI_SIZE_MASK 0x00000007
2298
2299 #define PPC4XX_TLBLO_EX 0x00000200
2300 #define PPC4XX_TLBLO_WR 0x00000100
2301 #define PPC4XX_TLBLO_ATTR_MASK 0x000000FF
2302 #define PPC4XX_TLBLO_RPN_MASK 0xFFFFFC00
2303
2304 target_ulong helper_4xx_tlbre_hi(CPUPPCState *env, target_ulong entry)
2305 {
2306 ppcemb_tlb_t *tlb;
2307 target_ulong ret;
2308 int size;
2309
2310 entry &= PPC4XX_TLB_ENTRY_MASK;
2311 tlb = &env->tlb.tlbe[entry];
2312 ret = tlb->EPN;
2313 if (tlb->prot & PAGE_VALID) {
2314 ret |= PPC4XX_TLBHI_V;
2315 }
2316 size = booke_page_size_to_tlb(tlb->size);
2317 if (size < PPC4XX_TLBHI_SIZE_MIN || size > PPC4XX_TLBHI_SIZE_MAX) {
2318 size = PPC4XX_TLBHI_SIZE_DEFAULT;
2319 }
2320 ret |= size << PPC4XX_TLBHI_SIZE_SHIFT;
2321 env->spr[SPR_40x_PID] = tlb->PID;
2322 return ret;
2323 }
2324
2325 target_ulong helper_4xx_tlbre_lo(CPUPPCState *env, target_ulong entry)
2326 {
2327 ppcemb_tlb_t *tlb;
2328 target_ulong ret;
2329
2330 entry &= PPC4XX_TLB_ENTRY_MASK;
2331 tlb = &env->tlb.tlbe[entry];
2332 ret = tlb->RPN;
2333 if (tlb->prot & PAGE_EXEC) {
2334 ret |= PPC4XX_TLBLO_EX;
2335 }
2336 if (tlb->prot & PAGE_WRITE) {
2337 ret |= PPC4XX_TLBLO_WR;
2338 }
2339 return ret;
2340 }
2341
2342 void helper_4xx_tlbwe_hi(CPUPPCState *env, target_ulong entry,
2343 target_ulong val)
2344 {
2345 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2346 CPUState *cs = CPU(cpu);
2347 ppcemb_tlb_t *tlb;
2348 target_ulong page, end;
2349
2350 LOG_SWTLB("%s entry %d val " TARGET_FMT_lx "\n", __func__, (int)entry,
2351 val);
2352 entry &= PPC4XX_TLB_ENTRY_MASK;
2353 tlb = &env->tlb.tlbe[entry];
2354 /* Invalidate previous TLB (if it's valid) */
2355 if (tlb->prot & PAGE_VALID) {
2356 end = tlb->EPN + tlb->size;
2357 LOG_SWTLB("%s: invalidate old TLB %d start " TARGET_FMT_lx " end "
2358 TARGET_FMT_lx "\n", __func__, (int)entry, tlb->EPN, end);
2359 for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE) {
2360 tlb_flush_page(cs, page);
2361 }
2362 }
2363 tlb->size = booke_tlb_to_page_size((val >> PPC4XX_TLBHI_SIZE_SHIFT)
2364 & PPC4XX_TLBHI_SIZE_MASK);
2365 /* We cannot handle TLB size < TARGET_PAGE_SIZE.
2366 * If this ever occurs, one should use the ppcemb target instead
2367 * of the ppc or ppc64 one
2368 */
2369 if ((val & PPC4XX_TLBHI_V) && tlb->size < TARGET_PAGE_SIZE) {
2370 cpu_abort(cs, "TLB size " TARGET_FMT_lu " < %u "
2371 "are not supported (%d)\n",
2372 tlb->size, TARGET_PAGE_SIZE, (int)((val >> 7) & 0x7));
2373 }
2374 tlb->EPN = val & ~(tlb->size - 1);
2375 if (val & PPC4XX_TLBHI_V) {
2376 tlb->prot |= PAGE_VALID;
2377 if (val & PPC4XX_TLBHI_E) {
2378 /* XXX: TO BE FIXED */
2379 cpu_abort(cs,
2380 "Little-endian TLB entries are not supported by now\n");
2381 }
2382 } else {
2383 tlb->prot &= ~PAGE_VALID;
2384 }
2385 tlb->PID = env->spr[SPR_40x_PID]; /* PID */
2386 LOG_SWTLB("%s: set up TLB %d RPN " TARGET_FMT_plx " EPN " TARGET_FMT_lx
2387 " size " TARGET_FMT_lx " prot %c%c%c%c PID %d\n", __func__,
2388 (int)entry, tlb->RPN, tlb->EPN, tlb->size,
2389 tlb->prot & PAGE_READ ? 'r' : '-',
2390 tlb->prot & PAGE_WRITE ? 'w' : '-',
2391 tlb->prot & PAGE_EXEC ? 'x' : '-',
2392 tlb->prot & PAGE_VALID ? 'v' : '-', (int)tlb->PID);
2393 /* Invalidate new TLB (if valid) */
2394 if (tlb->prot & PAGE_VALID) {
2395 end = tlb->EPN + tlb->size;
2396 LOG_SWTLB("%s: invalidate TLB %d start " TARGET_FMT_lx " end "
2397 TARGET_FMT_lx "\n", __func__, (int)entry, tlb->EPN, end);
2398 for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE) {
2399 tlb_flush_page(cs, page);
2400 }
2401 }
2402 }
2403
2404 void helper_4xx_tlbwe_lo(CPUPPCState *env, target_ulong entry,
2405 target_ulong val)
2406 {
2407 ppcemb_tlb_t *tlb;
2408
2409 LOG_SWTLB("%s entry %i val " TARGET_FMT_lx "\n", __func__, (int)entry,
2410 val);
2411 entry &= PPC4XX_TLB_ENTRY_MASK;
2412 tlb = &env->tlb.tlbe[entry];
2413 tlb->attr = val & PPC4XX_TLBLO_ATTR_MASK;
2414 tlb->RPN = val & PPC4XX_TLBLO_RPN_MASK;
2415 tlb->prot = PAGE_READ;
2416 if (val & PPC4XX_TLBLO_EX) {
2417 tlb->prot |= PAGE_EXEC;
2418 }
2419 if (val & PPC4XX_TLBLO_WR) {
2420 tlb->prot |= PAGE_WRITE;
2421 }
2422 LOG_SWTLB("%s: set up TLB %d RPN " TARGET_FMT_plx " EPN " TARGET_FMT_lx
2423 " size " TARGET_FMT_lx " prot %c%c%c%c PID %d\n", __func__,
2424 (int)entry, tlb->RPN, tlb->EPN, tlb->size,
2425 tlb->prot & PAGE_READ ? 'r' : '-',
2426 tlb->prot & PAGE_WRITE ? 'w' : '-',
2427 tlb->prot & PAGE_EXEC ? 'x' : '-',
2428 tlb->prot & PAGE_VALID ? 'v' : '-', (int)tlb->PID);
2429 }
2430
2431 target_ulong helper_4xx_tlbsx(CPUPPCState *env, target_ulong address)
2432 {
2433 return ppcemb_tlb_search(env, address, env->spr[SPR_40x_PID]);
2434 }
2435
2436 /* PowerPC 440 TLB management */
2437 void helper_440_tlbwe(CPUPPCState *env, uint32_t word, target_ulong entry,
2438 target_ulong value)
2439 {
2440 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2441 ppcemb_tlb_t *tlb;
2442 target_ulong EPN, RPN, size;
2443 int do_flush_tlbs;
2444
2445 LOG_SWTLB("%s word %d entry %d value " TARGET_FMT_lx "\n",
2446 __func__, word, (int)entry, value);
2447 do_flush_tlbs = 0;
2448 entry &= 0x3F;
2449 tlb = &env->tlb.tlbe[entry];
2450 switch (word) {
2451 default:
2452 /* Just here to please gcc */
2453 case 0:
2454 EPN = value & 0xFFFFFC00;
2455 if ((tlb->prot & PAGE_VALID) && EPN != tlb->EPN) {
2456 do_flush_tlbs = 1;
2457 }
2458 tlb->EPN = EPN;
2459 size = booke_tlb_to_page_size((value >> 4) & 0xF);
2460 if ((tlb->prot & PAGE_VALID) && tlb->size < size) {
2461 do_flush_tlbs = 1;
2462 }
2463 tlb->size = size;
2464 tlb->attr &= ~0x1;
2465 tlb->attr |= (value >> 8) & 1;
2466 if (value & 0x200) {
2467 tlb->prot |= PAGE_VALID;
2468 } else {
2469 if (tlb->prot & PAGE_VALID) {
2470 tlb->prot &= ~PAGE_VALID;
2471 do_flush_tlbs = 1;
2472 }
2473 }
2474 tlb->PID = env->spr[SPR_440_MMUCR] & 0x000000FF;
2475 if (do_flush_tlbs) {
2476 tlb_flush(CPU(cpu), 1);
2477 }
2478 break;
2479 case 1:
2480 RPN = value & 0xFFFFFC0F;
2481 if ((tlb->prot & PAGE_VALID) && tlb->RPN != RPN) {
2482 tlb_flush(CPU(cpu), 1);
2483 }
2484 tlb->RPN = RPN;
2485 break;
2486 case 2:
2487 tlb->attr = (tlb->attr & 0x1) | (value & 0x0000FF00);
2488 tlb->prot = tlb->prot & PAGE_VALID;
2489 if (value & 0x1) {
2490 tlb->prot |= PAGE_READ << 4;
2491 }
2492 if (value & 0x2) {
2493 tlb->prot |= PAGE_WRITE << 4;
2494 }
2495 if (value & 0x4) {
2496 tlb->prot |= PAGE_EXEC << 4;
2497 }
2498 if (value & 0x8) {
2499 tlb->prot |= PAGE_READ;
2500 }
2501 if (value & 0x10) {
2502 tlb->prot |= PAGE_WRITE;
2503 }
2504 if (value & 0x20) {
2505 tlb->prot |= PAGE_EXEC;
2506 }
2507 break;
2508 }
2509 }
2510
2511 target_ulong helper_440_tlbre(CPUPPCState *env, uint32_t word,
2512 target_ulong entry)
2513 {
2514 ppcemb_tlb_t *tlb;
2515 target_ulong ret;
2516 int size;
2517
2518 entry &= 0x3F;
2519 tlb = &env->tlb.tlbe[entry];
2520 switch (word) {
2521 default:
2522 /* Just here to please gcc */
2523 case 0:
2524 ret = tlb->EPN;
2525 size = booke_page_size_to_tlb(tlb->size);
2526 if (size < 0 || size > 0xF) {
2527 size = 1;
2528 }
2529 ret |= size << 4;
2530 if (tlb->attr & 0x1) {
2531 ret |= 0x100;
2532 }
2533 if (tlb->prot & PAGE_VALID) {
2534 ret |= 0x200;
2535 }
2536 env->spr[SPR_440_MMUCR] &= ~0x000000FF;
2537 env->spr[SPR_440_MMUCR] |= tlb->PID;
2538 break;
2539 case 1:
2540 ret = tlb->RPN;
2541 break;
2542 case 2:
2543 ret = tlb->attr & ~0x1;
2544 if (tlb->prot & (PAGE_READ << 4)) {
2545 ret |= 0x1;
2546 }
2547 if (tlb->prot & (PAGE_WRITE << 4)) {
2548 ret |= 0x2;
2549 }
2550 if (tlb->prot & (PAGE_EXEC << 4)) {
2551 ret |= 0x4;
2552 }
2553 if (tlb->prot & PAGE_READ) {
2554 ret |= 0x8;
2555 }
2556 if (tlb->prot & PAGE_WRITE) {
2557 ret |= 0x10;
2558 }
2559 if (tlb->prot & PAGE_EXEC) {
2560 ret |= 0x20;
2561 }
2562 break;
2563 }
2564 return ret;
2565 }
2566
2567 target_ulong helper_440_tlbsx(CPUPPCState *env, target_ulong address)
2568 {
2569 return ppcemb_tlb_search(env, address, env->spr[SPR_440_MMUCR] & 0xFF);
2570 }
2571
2572 /* PowerPC BookE 2.06 TLB management */
2573
2574 static ppcmas_tlb_t *booke206_cur_tlb(CPUPPCState *env)
2575 {
2576 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2577 uint32_t tlbncfg = 0;
2578 int esel = (env->spr[SPR_BOOKE_MAS0] & MAS0_ESEL_MASK) >> MAS0_ESEL_SHIFT;
2579 int ea = (env->spr[SPR_BOOKE_MAS2] & MAS2_EPN_MASK);
2580 int tlb;
2581
2582 tlb = (env->spr[SPR_BOOKE_MAS0] & MAS0_TLBSEL_MASK) >> MAS0_TLBSEL_SHIFT;
2583 tlbncfg = env->spr[SPR_BOOKE_TLB0CFG + tlb];
2584
2585 if ((tlbncfg & TLBnCFG_HES) && (env->spr[SPR_BOOKE_MAS0] & MAS0_HES)) {
2586 cpu_abort(CPU(cpu), "we don't support HES yet\n");
2587 }
2588
2589 return booke206_get_tlbm(env, tlb, ea, esel);
2590 }
2591
2592 void helper_booke_setpid(CPUPPCState *env, uint32_t pidn, target_ulong pid)
2593 {
2594 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2595
2596 env->spr[pidn] = pid;
2597 /* changing PIDs mean we're in a different address space now */
2598 tlb_flush(CPU(cpu), 1);
2599 }
2600
2601 void helper_booke206_tlbwe(CPUPPCState *env)
2602 {
2603 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2604 uint32_t tlbncfg, tlbn;
2605 ppcmas_tlb_t *tlb;
2606 uint32_t size_tlb, size_ps;
2607 target_ulong mask;
2608
2609
2610 switch (env->spr[SPR_BOOKE_MAS0] & MAS0_WQ_MASK) {
2611 case MAS0_WQ_ALWAYS:
2612 /* good to go, write that entry */
2613 break;
2614 case MAS0_WQ_COND:
2615 /* XXX check if reserved */
2616 if (0) {
2617 return;
2618 }
2619 break;
2620 case MAS0_WQ_CLR_RSRV:
2621 /* XXX clear entry */
2622 return;
2623 default:
2624 /* no idea what to do */
2625 return;
2626 }
2627
2628 if (((env->spr[SPR_BOOKE_MAS0] & MAS0_ATSEL) == MAS0_ATSEL_LRAT) &&
2629 !msr_gs) {
2630 /* XXX we don't support direct LRAT setting yet */
2631 fprintf(stderr, "cpu: don't support LRAT setting yet\n");
2632 return;
2633 }
2634
2635 tlbn = (env->spr[SPR_BOOKE_MAS0] & MAS0_TLBSEL_MASK) >> MAS0_TLBSEL_SHIFT;
2636 tlbncfg = env->spr[SPR_BOOKE_TLB0CFG + tlbn];
2637
2638 tlb = booke206_cur_tlb(env);
2639
2640 if (!tlb) {
2641 helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
2642 POWERPC_EXCP_INVAL |
2643 POWERPC_EXCP_INVAL_INVAL);
2644 }
2645
2646 /* check that we support the targeted size */
2647 size_tlb = (env->spr[SPR_BOOKE_MAS1] & MAS1_TSIZE_MASK) >> MAS1_TSIZE_SHIFT;
2648 size_ps = booke206_tlbnps(env, tlbn);
2649 if ((env->spr[SPR_BOOKE_MAS1] & MAS1_VALID) && (tlbncfg & TLBnCFG_AVAIL) &&
2650 !(size_ps & (1 << size_tlb))) {
2651 helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
2652 POWERPC_EXCP_INVAL |
2653 POWERPC_EXCP_INVAL_INVAL);
2654 }
2655
2656 if (msr_gs) {
2657 cpu_abort(CPU(cpu), "missing HV implementation\n");
2658 }
2659 tlb->mas7_3 = ((uint64_t)env->spr[SPR_BOOKE_MAS7] << 32) |
2660 env->spr[SPR_BOOKE_MAS3];
2661 tlb->mas1 = env->spr[SPR_BOOKE_MAS1];
2662
2663 /* MAV 1.0 only */
2664 if (!(tlbncfg & TLBnCFG_AVAIL)) {
2665 /* force !AVAIL TLB entries to correct page size */
2666 tlb->mas1 &= ~MAS1_TSIZE_MASK;
2667 /* XXX can be configured in MMUCSR0 */
2668 tlb->mas1 |= (tlbncfg & TLBnCFG_MINSIZE) >> 12;
2669 }
2670
2671 /* Make a mask from TLB size to discard invalid bits in EPN field */
2672 mask = ~(booke206_tlb_to_page_size(env, tlb) - 1);
2673 /* Add a mask for page attributes */
2674 mask |= MAS2_ACM | MAS2_VLE | MAS2_W | MAS2_I | MAS2_M | MAS2_G | MAS2_E;
2675
2676 if (!msr_cm) {
2677 /* Executing a tlbwe instruction in 32-bit mode will set
2678 * bits 0:31 of the TLB EPN field to zero.
2679 */
2680 mask &= 0xffffffff;
2681 }
2682
2683 tlb->mas2 = env->spr[SPR_BOOKE_MAS2] & mask;
2684
2685 if (!(tlbncfg & TLBnCFG_IPROT)) {
2686 /* no IPROT supported by TLB */
2687 tlb->mas1 &= ~MAS1_IPROT;
2688 }
2689
2690 if (booke206_tlb_to_page_size(env, tlb) == TARGET_PAGE_SIZE) {
2691 tlb_flush_page(CPU(cpu), tlb->mas2 & MAS2_EPN_MASK);
2692 } else {
2693 tlb_flush(CPU(cpu), 1);
2694 }
2695 }
2696
2697 static inline void booke206_tlb_to_mas(CPUPPCState *env, ppcmas_tlb_t *tlb)
2698 {
2699 int tlbn = booke206_tlbm_to_tlbn(env, tlb);
2700 int way = booke206_tlbm_to_way(env, tlb);
2701
2702 env->spr[SPR_BOOKE_MAS0] = tlbn << MAS0_TLBSEL_SHIFT;
2703 env->spr[SPR_BOOKE_MAS0] |= way << MAS0_ESEL_SHIFT;
2704 env->spr[SPR_BOOKE_MAS0] |= env->last_way << MAS0_NV_SHIFT;
2705
2706 env->spr[SPR_BOOKE_MAS1] = tlb->mas1;
2707 env->spr[SPR_BOOKE_MAS2] = tlb->mas2;
2708 env->spr[SPR_BOOKE_MAS3] = tlb->mas7_3;
2709 env->spr[SPR_BOOKE_MAS7] = tlb->mas7_3 >> 32;
2710 }
2711
2712 void helper_booke206_tlbre(CPUPPCState *env)
2713 {
2714 ppcmas_tlb_t *tlb = NULL;
2715
2716 tlb = booke206_cur_tlb(env);
2717 if (!tlb) {
2718 env->spr[SPR_BOOKE_MAS1] = 0;
2719 } else {
2720 booke206_tlb_to_mas(env, tlb);
2721 }
2722 }
2723
2724 void helper_booke206_tlbsx(CPUPPCState *env, target_ulong address)
2725 {
2726 ppcmas_tlb_t *tlb = NULL;
2727 int i, j;
2728 hwaddr raddr;
2729 uint32_t spid, sas;
2730
2731 spid = (env->spr[SPR_BOOKE_MAS6] & MAS6_SPID_MASK) >> MAS6_SPID_SHIFT;
2732 sas = env->spr[SPR_BOOKE_MAS6] & MAS6_SAS;
2733
2734 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
2735 int ways = booke206_tlb_ways(env, i);
2736
2737 for (j = 0; j < ways; j++) {
2738 tlb = booke206_get_tlbm(env, i, address, j);
2739
2740 if (!tlb) {
2741 continue;
2742 }
2743
2744 if (ppcmas_tlb_check(env, tlb, &raddr, address, spid)) {
2745 continue;
2746 }
2747
2748 if (sas != ((tlb->mas1 & MAS1_TS) >> MAS1_TS_SHIFT)) {
2749 continue;
2750 }
2751
2752 booke206_tlb_to_mas(env, tlb);
2753 return;
2754 }
2755 }
2756
2757 /* no entry found, fill with defaults */
2758 env->spr[SPR_BOOKE_MAS0] = env->spr[SPR_BOOKE_MAS4] & MAS4_TLBSELD_MASK;
2759 env->spr[SPR_BOOKE_MAS1] = env->spr[SPR_BOOKE_MAS4] & MAS4_TSIZED_MASK;
2760 env->spr[SPR_BOOKE_MAS2] = env->spr[SPR_BOOKE_MAS4] & MAS4_WIMGED_MASK;
2761 env->spr[SPR_BOOKE_MAS3] = 0;
2762 env->spr[SPR_BOOKE_MAS7] = 0;
2763
2764 if (env->spr[SPR_BOOKE_MAS6] & MAS6_SAS) {
2765 env->spr[SPR_BOOKE_MAS1] |= MAS1_TS;
2766 }
2767
2768 env->spr[SPR_BOOKE_MAS1] |= (env->spr[SPR_BOOKE_MAS6] >> 16)
2769 << MAS1_TID_SHIFT;
2770
2771 /* next victim logic */
2772 env->spr[SPR_BOOKE_MAS0] |= env->last_way << MAS0_ESEL_SHIFT;
2773 env->last_way++;
2774 env->last_way &= booke206_tlb_ways(env, 0) - 1;
2775 env->spr[SPR_BOOKE_MAS0] |= env->last_way << MAS0_NV_SHIFT;
2776 }
2777
2778 static inline void booke206_invalidate_ea_tlb(CPUPPCState *env, int tlbn,
2779 uint32_t ea)
2780 {
2781 int i;
2782 int ways = booke206_tlb_ways(env, tlbn);
2783 target_ulong mask;
2784
2785 for (i = 0; i < ways; i++) {
2786 ppcmas_tlb_t *tlb = booke206_get_tlbm(env, tlbn, ea, i);
2787 if (!tlb) {
2788 continue;
2789 }
2790 mask = ~(booke206_tlb_to_page_size(env, tlb) - 1);
2791 if (((tlb->mas2 & MAS2_EPN_MASK) == (ea & mask)) &&
2792 !(tlb->mas1 & MAS1_IPROT)) {
2793 tlb->mas1 &= ~MAS1_VALID;
2794 }
2795 }
2796 }
2797
2798 void helper_booke206_tlbivax(CPUPPCState *env, target_ulong address)
2799 {
2800 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2801
2802 if (address & 0x4) {
2803 /* flush all entries */
2804 if (address & 0x8) {
2805 /* flush all of TLB1 */
2806 booke206_flush_tlb(env, BOOKE206_FLUSH_TLB1, 1);
2807 } else {
2808 /* flush all of TLB0 */
2809 booke206_flush_tlb(env, BOOKE206_FLUSH_TLB0, 0);
2810 }
2811 return;
2812 }
2813
2814 if (address & 0x8) {
2815 /* flush TLB1 entries */
2816 booke206_invalidate_ea_tlb(env, 1, address);
2817 tlb_flush(CPU(cpu), 1);
2818 } else {
2819 /* flush TLB0 entries */
2820 booke206_invalidate_ea_tlb(env, 0, address);
2821 tlb_flush_page(CPU(cpu), address & MAS2_EPN_MASK);
2822 }
2823 }
2824
2825 void helper_booke206_tlbilx0(CPUPPCState *env, target_ulong address)
2826 {
2827 /* XXX missing LPID handling */
2828 booke206_flush_tlb(env, -1, 1);
2829 }
2830
2831 void helper_booke206_tlbilx1(CPUPPCState *env, target_ulong address)
2832 {
2833 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2834 int i, j;
2835 int tid = (env->spr[SPR_BOOKE_MAS6] & MAS6_SPID);
2836 ppcmas_tlb_t *tlb = env->tlb.tlbm;
2837 int tlb_size;
2838
2839 /* XXX missing LPID handling */
2840 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
2841 tlb_size = booke206_tlb_size(env, i);
2842 for (j = 0; j < tlb_size; j++) {
2843 if (!(tlb[j].mas1 & MAS1_IPROT) &&
2844 ((tlb[j].mas1 & MAS1_TID_MASK) == tid)) {
2845 tlb[j].mas1 &= ~MAS1_VALID;
2846 }
2847 }
2848 tlb += booke206_tlb_size(env, i);
2849 }
2850 tlb_flush(CPU(cpu), 1);
2851 }
2852
2853 void helper_booke206_tlbilx3(CPUPPCState *env, target_ulong address)
2854 {
2855 PowerPCCPU *cpu = ppc_env_get_cpu(env);
2856 int i, j;
2857 ppcmas_tlb_t *tlb;
2858 int tid = (env->spr[SPR_BOOKE_MAS6] & MAS6_SPID);
2859 int pid = tid >> MAS6_SPID_SHIFT;
2860 int sgs = env->spr[SPR_BOOKE_MAS5] & MAS5_SGS;
2861 int ind = (env->spr[SPR_BOOKE_MAS6] & MAS6_SIND) ? MAS1_IND : 0;
2862 /* XXX check for unsupported isize and raise an invalid opcode then */
2863 int size = env->spr[SPR_BOOKE_MAS6] & MAS6_ISIZE_MASK;
2864 /* XXX implement MAV2 handling */
2865 bool mav2 = false;
2866
2867 /* XXX missing LPID handling */
2868 /* flush by pid and ea */
2869 for (i = 0; i < BOOKE206_MAX_TLBN; i++) {
2870 int ways = booke206_tlb_ways(env, i);
2871
2872 for (j = 0; j < ways; j++) {
2873 tlb = booke206_get_tlbm(env, i, address, j);
2874 if (!tlb) {
2875 continue;
2876 }
2877 if ((ppcmas_tlb_check(env, tlb, NULL, address, pid) != 0) ||
2878 (tlb->mas1 & MAS1_IPROT) ||
2879 ((tlb->mas1 & MAS1_IND) != ind) ||
2880 ((tlb->mas8 & MAS8_TGS) != sgs)) {
2881 continue;
2882 }
2883 if (mav2 && ((tlb->mas1 & MAS1_TSIZE_MASK) != size)) {
2884 /* XXX only check when MMUCFG[TWC] || TLBnCFG[HES] */
2885 continue;
2886 }
2887 /* XXX e500mc doesn't match SAS, but other cores might */
2888 tlb->mas1 &= ~MAS1_VALID;
2889 }
2890 }
2891 tlb_flush(CPU(cpu), 1);
2892 }
2893
2894 void helper_booke206_tlbflush(CPUPPCState *env, target_ulong type)
2895 {
2896 int flags = 0;
2897
2898 if (type & 2) {
2899 flags |= BOOKE206_FLUSH_TLB1;
2900 }
2901
2902 if (type & 4) {
2903 flags |= BOOKE206_FLUSH_TLB0;
2904 }
2905
2906 booke206_flush_tlb(env, flags, 1);
2907 }
2908
2909
2910 /*****************************************************************************/
2911
2912 /* try to fill the TLB and return an exception if error. If retaddr is
2913 NULL, it means that the function was called in C code (i.e. not
2914 from generated code or from helper.c) */
2915 /* XXX: fix it to restore all registers */
2916 void tlb_fill(CPUState *cs, target_ulong addr, int is_write, int mmu_idx,
2917 uintptr_t retaddr)
2918 {
2919 PowerPCCPU *cpu = POWERPC_CPU(cs);
2920 PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
2921 CPUPPCState *env = &cpu->env;
2922 int ret;
2923
2924 if (pcc->handle_mmu_fault) {
2925 ret = pcc->handle_mmu_fault(cpu, addr, is_write, mmu_idx);
2926 } else {
2927 ret = cpu_ppc_handle_mmu_fault(env, addr, is_write, mmu_idx);
2928 }
2929 if (unlikely(ret != 0)) {
2930 if (likely(retaddr)) {
2931 /* now we have a real cpu fault */
2932 cpu_restore_state(cs, retaddr);
2933 }
2934 helper_raise_exception_err(env, cs->exception_index, env->error_code);
2935 }
2936 }
QEMU modified to work with kvm