?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
add a simple fork test
[qemu/linux-user.git] / target-ppc / helper.c
bloba953e1fa7677b3fc85c7d326cda79da282f4d97f
1 /*
2 * PowerPC 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, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA
19 */
20 #include <stdarg.h>
21 #include <stdlib.h>
22 #include <stdio.h>
23 #include <string.h>
24 #include <inttypes.h>
25 #include <signal.h>
26 #include <assert.h>
27
28 #include "cpu.h"
29 #include "exec-all.h"
30 #include "helper_regs.h"
31 #include "qemu-common.h"
32 #include "kvm.h"
33
34 //#define DEBUG_MMU
35 //#define DEBUG_BATS
36 //#define DEBUG_SLB
37 //#define DEBUG_SOFTWARE_TLB
38 //#define DUMP_PAGE_TABLES
39 //#define DEBUG_EXCEPTIONS
40 //#define FLUSH_ALL_TLBS
41
42 /*****************************************************************************/
43 /* PowerPC MMU emulation */
44
45 #if defined(CONFIG_USER_ONLY)
46 int cpu_ppc_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
47 int mmu_idx, int is_softmmu)
48 {
49 int exception, error_code;
50
51 if (rw == 2) {
52 exception = POWERPC_EXCP_ISI;
53 error_code = 0x40000000;
54 } else {
55 exception = POWERPC_EXCP_DSI;
56 error_code = 0x40000000;
57 if (rw)
58 error_code |= 0x02000000;
59 env->spr[SPR_DAR] = address;
60 env->spr[SPR_DSISR] = error_code;
61 }
62 env->exception_index = exception;
63 env->error_code = error_code;
64
65 return 1;
66 }
67
68 target_phys_addr_t cpu_get_phys_page_debug (CPUState *env, target_ulong addr)
69 {
70 return addr;
71 }
72
73 #else
74 /* Common routines used by software and hardware TLBs emulation */
75 static always_inline int pte_is_valid (target_ulong pte0)
76 {
77 return pte0 & 0x80000000 ? 1 : 0;
78 }
79
80 static always_inline void pte_invalidate (target_ulong *pte0)
81 {
82 *pte0 &= ~0x80000000;
83 }
84
85 #if defined(TARGET_PPC64)
86 static always_inline int pte64_is_valid (target_ulong pte0)
87 {
88 return pte0 & 0x0000000000000001ULL ? 1 : 0;
89 }
90
91 static always_inline void pte64_invalidate (target_ulong *pte0)
92 {
93 *pte0 &= ~0x0000000000000001ULL;
94 }
95 #endif
96
97 #define PTE_PTEM_MASK 0x7FFFFFBF
98 #define PTE_CHECK_MASK (TARGET_PAGE_MASK | 0x7B)
99 #if defined(TARGET_PPC64)
100 #define PTE64_PTEM_MASK 0xFFFFFFFFFFFFFF80ULL
101 #define PTE64_CHECK_MASK (TARGET_PAGE_MASK | 0x7F)
102 #endif
103
104 static always_inline int pp_check (int key, int pp, int nx)
105 {
106 int access;
107
108 /* Compute access rights */
109 /* When pp is 3/7, the result is undefined. Set it to noaccess */
110 access = 0;
111 if (key == 0) {
112 switch (pp) {
113 case 0x0:
114 case 0x1:
115 case 0x2:
116 access |= PAGE_WRITE;
117 /* No break here */
118 case 0x3:
119 case 0x6:
120 access |= PAGE_READ;
121 break;
122 }
123 } else {
124 switch (pp) {
125 case 0x0:
126 case 0x6:
127 access = 0;
128 break;
129 case 0x1:
130 case 0x3:
131 access = PAGE_READ;
132 break;
133 case 0x2:
134 access = PAGE_READ | PAGE_WRITE;
135 break;
136 }
137 }
138 if (nx == 0)
139 access |= PAGE_EXEC;
140
141 return access;
142 }
143
144 static always_inline int check_prot (int prot, int rw, int access_type)
145 {
146 int ret;
147
148 if (access_type == ACCESS_CODE) {
149 if (prot & PAGE_EXEC)
150 ret = 0;
151 else
152 ret = -2;
153 } else if (rw) {
154 if (prot & PAGE_WRITE)
155 ret = 0;
156 else
157 ret = -2;
158 } else {
159 if (prot & PAGE_READ)
160 ret = 0;
161 else
162 ret = -2;
163 }
164
165 return ret;
166 }
167
168 static always_inline int _pte_check (mmu_ctx_t *ctx, int is_64b,
169 target_ulong pte0, target_ulong pte1,
170 int h, int rw, int type)
171 {
172 target_ulong ptem, mmask;
173 int access, ret, pteh, ptev, pp;
174
175 access = 0;
176 ret = -1;
177 /* Check validity and table match */
178 #if defined(TARGET_PPC64)
179 if (is_64b) {
180 ptev = pte64_is_valid(pte0);
181 pteh = (pte0 >> 1) & 1;
182 } else
183 #endif
184 {
185 ptev = pte_is_valid(pte0);
186 pteh = (pte0 >> 6) & 1;
187 }
188 if (ptev && h == pteh) {
189 /* Check vsid & api */
190 #if defined(TARGET_PPC64)
191 if (is_64b) {
192 ptem = pte0 & PTE64_PTEM_MASK;
193 mmask = PTE64_CHECK_MASK;
194 pp = (pte1 & 0x00000003) | ((pte1 >> 61) & 0x00000004);
195 ctx->nx |= (pte1 >> 2) & 1; /* No execute bit */
196 ctx->nx |= (pte1 >> 3) & 1; /* Guarded bit */
197 } else
198 #endif
199 {
200 ptem = pte0 & PTE_PTEM_MASK;
201 mmask = PTE_CHECK_MASK;
202 pp = pte1 & 0x00000003;
203 }
204 if (ptem == ctx->ptem) {
205 if (ctx->raddr != (target_phys_addr_t)-1ULL) {
206 /* all matches should have equal RPN, WIMG & PP */
207 if ((ctx->raddr & mmask) != (pte1 & mmask)) {
208 if (loglevel != 0)
209 fprintf(logfile, "Bad RPN/WIMG/PP\n");
210 return -3;
211 }
212 }
213 /* Compute access rights */
214 access = pp_check(ctx->key, pp, ctx->nx);
215 /* Keep the matching PTE informations */
216 ctx->raddr = pte1;
217 ctx->prot = access;
218 ret = check_prot(ctx->prot, rw, type);
219 if (ret == 0) {
220 /* Access granted */
221 #if defined (DEBUG_MMU)
222 if (loglevel != 0)
223 fprintf(logfile, "PTE access granted !\n");
224 #endif
225 } else {
226 /* Access right violation */
227 #if defined (DEBUG_MMU)
228 if (loglevel != 0)
229 fprintf(logfile, "PTE access rejected\n");
230 #endif
231 }
232 }
233 }
234
235 return ret;
236 }
237
238 static always_inline int pte32_check (mmu_ctx_t *ctx,
239 target_ulong pte0, target_ulong pte1,
240 int h, int rw, int type)
241 {
242 return _pte_check(ctx, 0, pte0, pte1, h, rw, type);
243 }
244
245 #if defined(TARGET_PPC64)
246 static always_inline int pte64_check (mmu_ctx_t *ctx,
247 target_ulong pte0, target_ulong pte1,
248 int h, int rw, int type)
249 {
250 return _pte_check(ctx, 1, pte0, pte1, h, rw, type);
251 }
252 #endif
253
254 static always_inline int pte_update_flags (mmu_ctx_t *ctx, target_ulong *pte1p,
255 int ret, int rw)
256 {
257 int store = 0;
258
259 /* Update page flags */
260 if (!(*pte1p & 0x00000100)) {
261 /* Update accessed flag */
262 *pte1p |= 0x00000100;
263 store = 1;
264 }
265 if (!(*pte1p & 0x00000080)) {
266 if (rw == 1 && ret == 0) {
267 /* Update changed flag */
268 *pte1p |= 0x00000080;
269 store = 1;
270 } else {
271 /* Force page fault for first write access */
272 ctx->prot &= ~PAGE_WRITE;
273 }
274 }
275
276 return store;
277 }
278
279 /* Software driven TLB helpers */
280 static always_inline int ppc6xx_tlb_getnum (CPUState *env, target_ulong eaddr,
281 int way, int is_code)
282 {
283 int nr;
284
285 /* Select TLB num in a way from address */
286 nr = (eaddr >> TARGET_PAGE_BITS) & (env->tlb_per_way - 1);
287 /* Select TLB way */
288 nr += env->tlb_per_way * way;
289 /* 6xx have separate TLBs for instructions and data */
290 if (is_code && env->id_tlbs == 1)
291 nr += env->nb_tlb;
292
293 return nr;
294 }
295
296 static always_inline void ppc6xx_tlb_invalidate_all (CPUState *env)
297 {
298 ppc6xx_tlb_t *tlb;
299 int nr, max;
300
301 #if defined (DEBUG_SOFTWARE_TLB) && 0
302 if (loglevel != 0) {
303 fprintf(logfile, "Invalidate all TLBs\n");
304 }
305 #endif
306 /* Invalidate all defined software TLB */
307 max = env->nb_tlb;
308 if (env->id_tlbs == 1)
309 max *= 2;
310 for (nr = 0; nr < max; nr++) {
311 tlb = &env->tlb[nr].tlb6;
312 pte_invalidate(&tlb->pte0);
313 }
314 tlb_flush(env, 1);
315 }
316
317 static always_inline void __ppc6xx_tlb_invalidate_virt (CPUState *env,
318 target_ulong eaddr,
319 int is_code,
320 int match_epn)
321 {
322 #if !defined(FLUSH_ALL_TLBS)
323 ppc6xx_tlb_t *tlb;
324 int way, nr;
325
326 /* Invalidate ITLB + DTLB, all ways */
327 for (way = 0; way < env->nb_ways; way++) {
328 nr = ppc6xx_tlb_getnum(env, eaddr, way, is_code);
329 tlb = &env->tlb[nr].tlb6;
330 if (pte_is_valid(tlb->pte0) && (match_epn == 0 || eaddr == tlb->EPN)) {
331 #if defined (DEBUG_SOFTWARE_TLB)
332 if (loglevel != 0) {
333 fprintf(logfile, "TLB invalidate %d/%d " ADDRX "\n",
334 nr, env->nb_tlb, eaddr);
335 }
336 #endif
337 pte_invalidate(&tlb->pte0);
338 tlb_flush_page(env, tlb->EPN);
339 }
340 }
341 #else
342 /* XXX: PowerPC specification say this is valid as well */
343 ppc6xx_tlb_invalidate_all(env);
344 #endif
345 }
346
347 static always_inline void ppc6xx_tlb_invalidate_virt (CPUState *env,
348 target_ulong eaddr,
349 int is_code)
350 {
351 __ppc6xx_tlb_invalidate_virt(env, eaddr, is_code, 0);
352 }
353
354 void ppc6xx_tlb_store (CPUState *env, target_ulong EPN, int way, int is_code,
355 target_ulong pte0, target_ulong pte1)
356 {
357 ppc6xx_tlb_t *tlb;
358 int nr;
359
360 nr = ppc6xx_tlb_getnum(env, EPN, way, is_code);
361 tlb = &env->tlb[nr].tlb6;
362 #if defined (DEBUG_SOFTWARE_TLB)
363 if (loglevel != 0) {
364 fprintf(logfile, "Set TLB %d/%d EPN " ADDRX " PTE0 " ADDRX
365 " PTE1 " ADDRX "\n", nr, env->nb_tlb, EPN, pte0, pte1);
366 }
367 #endif
368 /* Invalidate any pending reference in Qemu for this virtual address */
369 __ppc6xx_tlb_invalidate_virt(env, EPN, is_code, 1);
370 tlb->pte0 = pte0;
371 tlb->pte1 = pte1;
372 tlb->EPN = EPN;
373 /* Store last way for LRU mechanism */
374 env->last_way = way;
375 }
376
377 static always_inline int ppc6xx_tlb_check (CPUState *env, mmu_ctx_t *ctx,
378 target_ulong eaddr, int rw,
379 int access_type)
380 {
381 ppc6xx_tlb_t *tlb;
382 int nr, best, way;
383 int ret;
384
385 best = -1;
386 ret = -1; /* No TLB found */
387 for (way = 0; way < env->nb_ways; way++) {
388 nr = ppc6xx_tlb_getnum(env, eaddr, way,
389 access_type == ACCESS_CODE ? 1 : 0);
390 tlb = &env->tlb[nr].tlb6;
391 /* This test "emulates" the PTE index match for hardware TLBs */
392 if ((eaddr & TARGET_PAGE_MASK) != tlb->EPN) {
393 #if defined (DEBUG_SOFTWARE_TLB)
394 if (loglevel != 0) {
395 fprintf(logfile, "TLB %d/%d %s [" ADDRX " " ADDRX
396 "] <> " ADDRX "\n",
397 nr, env->nb_tlb,
398 pte_is_valid(tlb->pte0) ? "valid" : "inval",
399 tlb->EPN, tlb->EPN + TARGET_PAGE_SIZE, eaddr);
400 }
401 #endif
402 continue;
403 }
404 #if defined (DEBUG_SOFTWARE_TLB)
405 if (loglevel != 0) {
406 fprintf(logfile, "TLB %d/%d %s " ADDRX " <> " ADDRX " " ADDRX
407 " %c %c\n",
408 nr, env->nb_tlb,
409 pte_is_valid(tlb->pte0) ? "valid" : "inval",
410 tlb->EPN, eaddr, tlb->pte1,
411 rw ? 'S' : 'L', access_type == ACCESS_CODE ? 'I' : 'D');
412 }
413 #endif
414 switch (pte32_check(ctx, tlb->pte0, tlb->pte1, 0, rw, access_type)) {
415 case -3:
416 /* TLB inconsistency */
417 return -1;
418 case -2:
419 /* Access violation */
420 ret = -2;
421 best = nr;
422 break;
423 case -1:
424 default:
425 /* No match */
426 break;
427 case 0:
428 /* access granted */
429 /* XXX: we should go on looping to check all TLBs consistency
430 * but we can speed-up the whole thing as the
431 * result would be undefined if TLBs are not consistent.
432 */
433 ret = 0;
434 best = nr;
435 goto done;
436 }
437 }
438 if (best != -1) {
439 done:
440 #if defined (DEBUG_SOFTWARE_TLB)
441 if (loglevel != 0) {
442 fprintf(logfile, "found TLB at addr " PADDRX " prot=%01x ret=%d\n",
443 ctx->raddr & TARGET_PAGE_MASK, ctx->prot, ret);
444 }
445 #endif
446 /* Update page flags */
447 pte_update_flags(ctx, &env->tlb[best].tlb6.pte1, ret, rw);
448 }
449
450 return ret;
451 }
452
453 /* Perform BAT hit & translation */
454 static always_inline void bat_size_prot (CPUState *env, target_ulong *blp,
455 int *validp, int *protp,
456 target_ulong *BATu, target_ulong *BATl)
457 {
458 target_ulong bl;
459 int pp, valid, prot;
460
461 bl = (*BATu & 0x00001FFC) << 15;
462 valid = 0;
463 prot = 0;
464 if (((msr_pr == 0) && (*BATu & 0x00000002)) ||
465 ((msr_pr != 0) && (*BATu & 0x00000001))) {
466 valid = 1;
467 pp = *BATl & 0x00000003;
468 if (pp != 0) {
469 prot = PAGE_READ | PAGE_EXEC;
470 if (pp == 0x2)
471 prot |= PAGE_WRITE;
472 }
473 }
474 *blp = bl;
475 *validp = valid;
476 *protp = prot;
477 }
478
479 static always_inline void bat_601_size_prot (CPUState *env,target_ulong *blp,
480 int *validp, int *protp,
481 target_ulong *BATu,
482 target_ulong *BATl)
483 {
484 target_ulong bl;
485 int key, pp, valid, prot;
486
487 bl = (*BATl & 0x0000003F) << 17;
488 #if defined (DEBUG_BATS)
489 if (loglevel != 0) {
490 fprintf(logfile, "b %02x ==> bl " ADDRX " msk " ADDRX "\n",
491 (uint8_t)(*BATl & 0x0000003F), bl, ~bl);
492 }
493 #endif
494 prot = 0;
495 valid = (*BATl >> 6) & 1;
496 if (valid) {
497 pp = *BATu & 0x00000003;
498 if (msr_pr == 0)
499 key = (*BATu >> 3) & 1;
500 else
501 key = (*BATu >> 2) & 1;
502 prot = pp_check(key, pp, 0);
503 }
504 *blp = bl;
505 *validp = valid;
506 *protp = prot;
507 }
508
509 static always_inline int get_bat (CPUState *env, mmu_ctx_t *ctx,
510 target_ulong virtual, int rw, int type)
511 {
512 target_ulong *BATlt, *BATut, *BATu, *BATl;
513 target_ulong base, BEPIl, BEPIu, bl;
514 int i, valid, prot;
515 int ret = -1;
516
517 #if defined (DEBUG_BATS)
518 if (loglevel != 0) {
519 fprintf(logfile, "%s: %cBAT v " ADDRX "\n", __func__,
520 type == ACCESS_CODE ? 'I' : 'D', virtual);
521 }
522 #endif
523 switch (type) {
524 case ACCESS_CODE:
525 BATlt = env->IBAT[1];
526 BATut = env->IBAT[0];
527 break;
528 default:
529 BATlt = env->DBAT[1];
530 BATut = env->DBAT[0];
531 break;
532 }
533 base = virtual & 0xFFFC0000;
534 for (i = 0; i < env->nb_BATs; i++) {
535 BATu = &BATut[i];
536 BATl = &BATlt[i];
537 BEPIu = *BATu & 0xF0000000;
538 BEPIl = *BATu & 0x0FFE0000;
539 if (unlikely(env->mmu_model == POWERPC_MMU_601)) {
540 bat_601_size_prot(env, &bl, &valid, &prot, BATu, BATl);
541 } else {
542 bat_size_prot(env, &bl, &valid, &prot, BATu, BATl);
543 }
544 #if defined (DEBUG_BATS)
545 if (loglevel != 0) {
546 fprintf(logfile, "%s: %cBAT%d v " ADDRX " BATu " ADDRX
547 " BATl " ADDRX "\n", __func__,
548 type == ACCESS_CODE ? 'I' : 'D', i, virtual, *BATu, *BATl);
549 }
550 #endif
551 if ((virtual & 0xF0000000) == BEPIu &&
552 ((virtual & 0x0FFE0000) & ~bl) == BEPIl) {
553 /* BAT matches */
554 if (valid != 0) {
555 /* Get physical address */
556 ctx->raddr = (*BATl & 0xF0000000) |
557 ((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |
558 (virtual & 0x0001F000);
559 /* Compute access rights */
560 ctx->prot = prot;
561 ret = check_prot(ctx->prot, rw, type);
562 #if defined (DEBUG_BATS)
563 if (ret == 0 && loglevel != 0) {
564 fprintf(logfile, "BAT %d match: r " PADDRX " prot=%c%c\n",
565 i, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',
566 ctx->prot & PAGE_WRITE ? 'W' : '-');
567 }
568 #endif
569 break;
570 }
571 }
572 }
573 if (ret < 0) {
574 #if defined (DEBUG_BATS)
575 if (loglevel != 0) {
576 fprintf(logfile, "no BAT match for " ADDRX ":\n", virtual);
577 for (i = 0; i < 4; i++) {
578 BATu = &BATut[i];
579 BATl = &BATlt[i];
580 BEPIu = *BATu & 0xF0000000;
581 BEPIl = *BATu & 0x0FFE0000;
582 bl = (*BATu & 0x00001FFC) << 15;
583 fprintf(logfile, "%s: %cBAT%d v " ADDRX " BATu " ADDRX
584 " BATl " ADDRX " \n\t" ADDRX " " ADDRX " " ADDRX "\n",
585 __func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
586 *BATu, *BATl, BEPIu, BEPIl, bl);
587 }
588 }
589 #endif
590 }
591
592 /* No hit */
593 return ret;
594 }
595
596 /* PTE table lookup */
597 static always_inline int _find_pte (mmu_ctx_t *ctx, int is_64b, int h,
598 int rw, int type)
599 {
600 target_ulong base, pte0, pte1;
601 int i, good = -1;
602 int ret, r;
603
604 ret = -1; /* No entry found */
605 base = ctx->pg_addr[h];
606 for (i = 0; i < 8; i++) {
607 #if defined(TARGET_PPC64)
608 if (is_64b) {
609 pte0 = ldq_phys(base + (i * 16));
610 pte1 = ldq_phys(base + (i * 16) + 8);
611 r = pte64_check(ctx, pte0, pte1, h, rw, type);
612 #if defined (DEBUG_MMU)
613 if (loglevel != 0) {
614 fprintf(logfile, "Load pte from " ADDRX " => " ADDRX " " ADDRX
615 " %d %d %d " ADDRX "\n",
616 base + (i * 16), pte0, pte1,
617 (int)(pte0 & 1), h, (int)((pte0 >> 1) & 1),
618 ctx->ptem);
619 }
620 #endif
621 } else
622 #endif
623 {
624 pte0 = ldl_phys(base + (i * 8));
625 pte1 = ldl_phys(base + (i * 8) + 4);
626 r = pte32_check(ctx, pte0, pte1, h, rw, type);
627 #if defined (DEBUG_MMU)
628 if (loglevel != 0) {
629 fprintf(logfile, "Load pte from " ADDRX " => " ADDRX " " ADDRX
630 " %d %d %d " ADDRX "\n",
631 base + (i * 8), pte0, pte1,
632 (int)(pte0 >> 31), h, (int)((pte0 >> 6) & 1),
633 ctx->ptem);
634 }
635 #endif
636 }
637 switch (r) {
638 case -3:
639 /* PTE inconsistency */
640 return -1;
641 case -2:
642 /* Access violation */
643 ret = -2;
644 good = i;
645 break;
646 case -1:
647 default:
648 /* No PTE match */
649 break;
650 case 0:
651 /* access granted */
652 /* XXX: we should go on looping to check all PTEs consistency
653 * but if we can speed-up the whole thing as the
654 * result would be undefined if PTEs are not consistent.
655 */
656 ret = 0;
657 good = i;
658 goto done;
659 }
660 }
661 if (good != -1) {
662 done:
663 #if defined (DEBUG_MMU)
664 if (loglevel != 0) {
665 fprintf(logfile, "found PTE at addr " PADDRX " prot=%01x ret=%d\n",
666 ctx->raddr, ctx->prot, ret);
667 }
668 #endif
669 /* Update page flags */
670 pte1 = ctx->raddr;
671 if (pte_update_flags(ctx, &pte1, ret, rw) == 1) {
672 #if defined(TARGET_PPC64)
673 if (is_64b) {
674 stq_phys_notdirty(base + (good * 16) + 8, pte1);
675 } else
676 #endif
677 {
678 stl_phys_notdirty(base + (good * 8) + 4, pte1);
679 }
680 }
681 }
682
683 return ret;
684 }
685
686 static always_inline int find_pte32 (mmu_ctx_t *ctx, int h, int rw, int type)
687 {
688 return _find_pte(ctx, 0, h, rw, type);
689 }
690
691 #if defined(TARGET_PPC64)
692 static always_inline int find_pte64 (mmu_ctx_t *ctx, int h, int rw, int type)
693 {
694 return _find_pte(ctx, 1, h, rw, type);
695 }
696 #endif
697
698 static always_inline int find_pte (CPUState *env, mmu_ctx_t *ctx,
699 int h, int rw, int type)
700 {
701 #if defined(TARGET_PPC64)
702 if (env->mmu_model & POWERPC_MMU_64)
703 return find_pte64(ctx, h, rw, type);
704 #endif
705
706 return find_pte32(ctx, h, rw, type);
707 }
708
709 #if defined(TARGET_PPC64)
710 static always_inline int slb_is_valid (uint64_t slb64)
711 {
712 return slb64 & 0x0000000008000000ULL ? 1 : 0;
713 }
714
715 static always_inline void slb_invalidate (uint64_t *slb64)
716 {
717 *slb64 &= ~0x0000000008000000ULL;
718 }
719
720 static always_inline int slb_lookup (CPUPPCState *env, target_ulong eaddr,
721 target_ulong *vsid,
722 target_ulong *page_mask, int *attr)
723 {
724 target_phys_addr_t sr_base;
725 target_ulong mask;
726 uint64_t tmp64;
727 uint32_t tmp;
728 int n, ret;
729
730 ret = -5;
731 sr_base = env->spr[SPR_ASR];
732 #if defined(DEBUG_SLB)
733 if (loglevel != 0) {
734 fprintf(logfile, "%s: eaddr " ADDRX " base " PADDRX "\n",
735 __func__, eaddr, sr_base);
736 }
737 #endif
738 mask = 0x0000000000000000ULL; /* Avoid gcc warning */
739 for (n = 0; n < env->slb_nr; n++) {
740 tmp64 = ldq_phys(sr_base);
741 tmp = ldl_phys(sr_base + 8);
742 #if defined(DEBUG_SLB)
743 if (loglevel != 0) {
744 fprintf(logfile, "%s: seg %d " PADDRX " %016" PRIx64 " %08"
745 PRIx32 "\n", __func__, n, sr_base, tmp64, tmp);
746 }
747 #endif
748 if (slb_is_valid(tmp64)) {
749 /* SLB entry is valid */
750 switch (tmp64 & 0x0000000006000000ULL) {
751 case 0x0000000000000000ULL:
752 /* 256 MB segment */
753 mask = 0xFFFFFFFFF0000000ULL;
754 break;
755 case 0x0000000002000000ULL:
756 /* 1 TB segment */
757 mask = 0xFFFF000000000000ULL;
758 break;
759 case 0x0000000004000000ULL:
760 case 0x0000000006000000ULL:
761 /* Reserved => segment is invalid */
762 continue;
763 }
764 if ((eaddr & mask) == (tmp64 & mask)) {
765 /* SLB match */
766 *vsid = ((tmp64 << 24) | (tmp >> 8)) & 0x0003FFFFFFFFFFFFULL;
767 *page_mask = ~mask;
768 *attr = tmp & 0xFF;
769 ret = n;
770 break;
771 }
772 }
773 sr_base += 12;
774 }
775
776 return ret;
777 }
778
779 void ppc_slb_invalidate_all (CPUPPCState *env)
780 {
781 target_phys_addr_t sr_base;
782 uint64_t tmp64;
783 int n, do_invalidate;
784
785 do_invalidate = 0;
786 sr_base = env->spr[SPR_ASR];
787 /* XXX: Warning: slbia never invalidates the first segment */
788 for (n = 1; n < env->slb_nr; n++) {
789 tmp64 = ldq_phys(sr_base);
790 if (slb_is_valid(tmp64)) {
791 slb_invalidate(&tmp64);
792 stq_phys(sr_base, tmp64);
793 /* XXX: given the fact that segment size is 256 MB or 1TB,
794 * and we still don't have a tlb_flush_mask(env, n, mask)
795 * in Qemu, we just invalidate all TLBs
796 */
797 do_invalidate = 1;
798 }
799 sr_base += 12;
800 }
801 if (do_invalidate)
802 tlb_flush(env, 1);
803 }
804
805 void ppc_slb_invalidate_one (CPUPPCState *env, uint64_t T0)
806 {
807 target_phys_addr_t sr_base;
808 target_ulong vsid, page_mask;
809 uint64_t tmp64;
810 int attr;
811 int n;
812
813 n = slb_lookup(env, T0, &vsid, &page_mask, &attr);
814 if (n >= 0) {
815 sr_base = env->spr[SPR_ASR];
816 sr_base += 12 * n;
817 tmp64 = ldq_phys(sr_base);
818 if (slb_is_valid(tmp64)) {
819 slb_invalidate(&tmp64);
820 stq_phys(sr_base, tmp64);
821 /* XXX: given the fact that segment size is 256 MB or 1TB,
822 * and we still don't have a tlb_flush_mask(env, n, mask)
823 * in Qemu, we just invalidate all TLBs
824 */
825 tlb_flush(env, 1);
826 }
827 }
828 }
829
830 target_ulong ppc_load_slb (CPUPPCState *env, int slb_nr)
831 {
832 target_phys_addr_t sr_base;
833 target_ulong rt;
834 uint64_t tmp64;
835 uint32_t tmp;
836
837 sr_base = env->spr[SPR_ASR];
838 sr_base += 12 * slb_nr;
839 tmp64 = ldq_phys(sr_base);
840 tmp = ldl_phys(sr_base + 8);
841 if (tmp64 & 0x0000000008000000ULL) {
842 /* SLB entry is valid */
843 /* Copy SLB bits 62:88 to Rt 37:63 (VSID 23:49) */
844 rt = tmp >> 8; /* 65:88 => 40:63 */
845 rt |= (tmp64 & 0x7) << 24; /* 62:64 => 37:39 */
846 /* Copy SLB bits 89:92 to Rt 33:36 (KsKpNL) */
847 rt |= ((tmp >> 4) & 0xF) << 27;
848 } else {
849 rt = 0;
850 }
851 #if defined(DEBUG_SLB)
852 if (loglevel != 0) {
853 fprintf(logfile, "%s: " PADDRX " %016" PRIx64 " %08" PRIx32 " => %d "
854 ADDRX "\n", __func__, sr_base, tmp64, tmp, slb_nr, rt);
855 }
856 #endif
857
858 return rt;
859 }
860
861 void ppc_store_slb (CPUPPCState *env, int slb_nr, target_ulong rs)
862 {
863 target_phys_addr_t sr_base;
864 uint64_t tmp64;
865 uint32_t tmp;
866
867 sr_base = env->spr[SPR_ASR];
868 sr_base += 12 * slb_nr;
869 /* Copy Rs bits 37:63 to SLB 62:88 */
870 tmp = rs << 8;
871 tmp64 = (rs >> 24) & 0x7;
872 /* Copy Rs bits 33:36 to SLB 89:92 */
873 tmp |= ((rs >> 27) & 0xF) << 4;
874 /* Set the valid bit */
875 tmp64 |= 1 << 27;
876 /* Set ESID */
877 tmp64 |= (uint32_t)slb_nr << 28;
878 #if defined(DEBUG_SLB)
879 if (loglevel != 0) {
880 fprintf(logfile, "%s: %d " ADDRX " => " PADDRX " %016" PRIx64
881 " %08" PRIx32 "\n", __func__,
882 slb_nr, rs, sr_base, tmp64, tmp);
883 }
884 #endif
885 /* Write SLB entry to memory */
886 stq_phys(sr_base, tmp64);
887 stl_phys(sr_base + 8, tmp);
888 }
889 #endif /* defined(TARGET_PPC64) */
890
891 /* Perform segment based translation */
892 static always_inline target_phys_addr_t get_pgaddr (target_phys_addr_t sdr1,
893 int sdr_sh,
894 target_phys_addr_t hash,
895 target_phys_addr_t mask)
896 {
897 return (sdr1 & ((target_phys_addr_t)(-1ULL) << sdr_sh)) | (hash & mask);
898 }
899
900 static always_inline int get_segment (CPUState *env, mmu_ctx_t *ctx,
901 target_ulong eaddr, int rw, int type)
902 {
903 target_phys_addr_t sdr, hash, mask, sdr_mask, htab_mask;
904 target_ulong sr, vsid, vsid_mask, pgidx, page_mask;
905 #if defined(TARGET_PPC64)
906 int attr;
907 #endif
908 int ds, vsid_sh, sdr_sh, pr;
909 int ret, ret2;
910
911 pr = msr_pr;
912 #if defined(TARGET_PPC64)
913 if (env->mmu_model & POWERPC_MMU_64) {
914 #if defined (DEBUG_MMU)
915 if (loglevel != 0) {
916 fprintf(logfile, "Check SLBs\n");
917 }
918 #endif
919 ret = slb_lookup(env, eaddr, &vsid, &page_mask, &attr);
920 if (ret < 0)
921 return ret;
922 ctx->key = ((attr & 0x40) && (pr != 0)) ||
923 ((attr & 0x80) && (pr == 0)) ? 1 : 0;
924 ds = 0;
925 ctx->nx = attr & 0x20 ? 1 : 0;
926 vsid_mask = 0x00003FFFFFFFFF80ULL;
927 vsid_sh = 7;
928 sdr_sh = 18;
929 sdr_mask = 0x3FF80;
930 } else
931 #endif /* defined(TARGET_PPC64) */
932 {
933 sr = env->sr[eaddr >> 28];
934 page_mask = 0x0FFFFFFF;
935 ctx->key = (((sr & 0x20000000) && (pr != 0)) ||
936 ((sr & 0x40000000) && (pr == 0))) ? 1 : 0;
937 ds = sr & 0x80000000 ? 1 : 0;
938 ctx->nx = sr & 0x10000000 ? 1 : 0;
939 vsid = sr & 0x00FFFFFF;
940 vsid_mask = 0x01FFFFC0;
941 vsid_sh = 6;
942 sdr_sh = 16;
943 sdr_mask = 0xFFC0;
944 #if defined (DEBUG_MMU)
945 if (loglevel != 0) {
946 fprintf(logfile, "Check segment v=" ADDRX " %d " ADDRX
947 " nip=" ADDRX " lr=" ADDRX " ir=%d dr=%d pr=%d %d t=%d\n",
948 eaddr, (int)(eaddr >> 28), sr, env->nip,
949 env->lr, (int)msr_ir, (int)msr_dr, pr != 0 ? 1 : 0,
950 rw, type);
951 }
952 #endif
953 }
954 #if defined (DEBUG_MMU)
955 if (loglevel != 0) {
956 fprintf(logfile, "pte segment: key=%d ds %d nx %d vsid " ADDRX "\n",
957 ctx->key, ds, ctx->nx, vsid);
958 }
959 #endif
960 ret = -1;
961 if (!ds) {
962 /* Check if instruction fetch is allowed, if needed */
963 if (type != ACCESS_CODE || ctx->nx == 0) {
964 /* Page address translation */
965 /* Primary table address */
966 sdr = env->sdr1;
967 pgidx = (eaddr & page_mask) >> TARGET_PAGE_BITS;
968 #if defined(TARGET_PPC64)
969 if (env->mmu_model & POWERPC_MMU_64) {
970 htab_mask = 0x0FFFFFFF >> (28 - (sdr & 0x1F));
971 /* XXX: this is false for 1 TB segments */
972 hash = ((vsid ^ pgidx) << vsid_sh) & vsid_mask;
973 } else
974 #endif
975 {
976 htab_mask = sdr & 0x000001FF;
977 hash = ((vsid ^ pgidx) << vsid_sh) & vsid_mask;
978 }
979 mask = (htab_mask << sdr_sh) | sdr_mask;
980 #if defined (DEBUG_MMU)
981 if (loglevel != 0) {
982 fprintf(logfile, "sdr " PADDRX " sh %d hash " PADDRX
983 " mask " PADDRX " " ADDRX "\n",
984 sdr, sdr_sh, hash, mask, page_mask);
985 }
986 #endif
987 ctx->pg_addr[0] = get_pgaddr(sdr, sdr_sh, hash, mask);
988 /* Secondary table address */
989 hash = (~hash) & vsid_mask;
990 #if defined (DEBUG_MMU)
991 if (loglevel != 0) {
992 fprintf(logfile, "sdr " PADDRX " sh %d hash " PADDRX
993 " mask " PADDRX "\n",
994 sdr, sdr_sh, hash, mask);
995 }
996 #endif
997 ctx->pg_addr[1] = get_pgaddr(sdr, sdr_sh, hash, mask);
998 #if defined(TARGET_PPC64)
999 if (env->mmu_model & POWERPC_MMU_64) {
1000 /* Only 5 bits of the page index are used in the AVPN */
1001 ctx->ptem = (vsid << 12) | ((pgidx >> 4) & 0x0F80);
1002 } else
1003 #endif
1004 {
1005 ctx->ptem = (vsid << 7) | (pgidx >> 10);
1006 }
1007 /* Initialize real address with an invalid value */
1008 ctx->raddr = (target_phys_addr_t)-1ULL;
1009 if (unlikely(env->mmu_model == POWERPC_MMU_SOFT_6xx ||
1010 env->mmu_model == POWERPC_MMU_SOFT_74xx)) {
1011 /* Software TLB search */
1012 ret = ppc6xx_tlb_check(env, ctx, eaddr, rw, type);
1013 } else {
1014 #if defined (DEBUG_MMU)
1015 if (loglevel != 0) {
1016 fprintf(logfile, "0 sdr1=" PADDRX " vsid=" ADDRX " "
1017 "api=" ADDRX " hash=" PADDRX
1018 " pg_addr=" PADDRX "\n",
1019 sdr, vsid, pgidx, hash, ctx->pg_addr[0]);
1020 }
1021 #endif
1022 /* Primary table lookup */
1023 ret = find_pte(env, ctx, 0, rw, type);
1024 if (ret < 0) {
1025 /* Secondary table lookup */
1026 #if defined (DEBUG_MMU)
1027 if (eaddr != 0xEFFFFFFF && loglevel != 0) {
1028 fprintf(logfile, "1 sdr1=" PADDRX " vsid=" ADDRX " "
1029 "api=" ADDRX " hash=" PADDRX
1030 " pg_addr=" PADDRX "\n",
1031 sdr, vsid, pgidx, hash, ctx->pg_addr[1]);
1032 }
1033 #endif
1034 ret2 = find_pte(env, ctx, 1, rw, type);
1035 if (ret2 != -1)
1036 ret = ret2;
1037 }
1038 }
1039 #if defined (DUMP_PAGE_TABLES)
1040 if (loglevel != 0) {
1041 target_phys_addr_t curaddr;
1042 uint32_t a0, a1, a2, a3;
1043 fprintf(logfile, "Page table: " PADDRX " len " PADDRX "\n",
1044 sdr, mask + 0x80);
1045 for (curaddr = sdr; curaddr < (sdr + mask + 0x80);
1046 curaddr += 16) {
1047 a0 = ldl_phys(curaddr);
1048 a1 = ldl_phys(curaddr + 4);
1049 a2 = ldl_phys(curaddr + 8);
1050 a3 = ldl_phys(curaddr + 12);
1051 if (a0 != 0 || a1 != 0 || a2 != 0 || a3 != 0) {
1052 fprintf(logfile, PADDRX ": %08x %08x %08x %08x\n",
1053 curaddr, a0, a1, a2, a3);
1054 }
1055 }
1056 }
1057 #endif
1058 } else {
1059 #if defined (DEBUG_MMU)
1060 if (loglevel != 0)
1061 fprintf(logfile, "No access allowed\n");
1062 #endif
1063 ret = -3;
1064 }
1065 } else {
1066 #if defined (DEBUG_MMU)
1067 if (loglevel != 0)
1068 fprintf(logfile, "direct store...\n");
1069 #endif
1070 /* Direct-store segment : absolutely *BUGGY* for now */
1071 switch (type) {
1072 case ACCESS_INT:
1073 /* Integer load/store : only access allowed */
1074 break;
1075 case ACCESS_CODE:
1076 /* No code fetch is allowed in direct-store areas */
1077 return -4;
1078 case ACCESS_FLOAT:
1079 /* Floating point load/store */
1080 return -4;
1081 case ACCESS_RES:
1082 /* lwarx, ldarx or srwcx. */
1083 return -4;
1084 case ACCESS_CACHE:
1085 /* dcba, dcbt, dcbtst, dcbf, dcbi, dcbst, dcbz, or icbi */
1086 /* Should make the instruction do no-op.
1087 * As it already do no-op, it's quite easy :-)
1088 */
1089 ctx->raddr = eaddr;
1090 return 0;
1091 case ACCESS_EXT:
1092 /* eciwx or ecowx */
1093 return -4;
1094 default:
1095 if (logfile) {
1096 fprintf(logfile, "ERROR: instruction should not need "
1097 "address translation\n");
1098 }
1099 return -4;
1100 }
1101 if ((rw == 1 || ctx->key != 1) && (rw == 0 || ctx->key != 0)) {
1102 ctx->raddr = eaddr;
1103 ret = 2;
1104 } else {
1105 ret = -2;
1106 }
1107 }
1108
1109 return ret;
1110 }
1111
1112 /* Generic TLB check function for embedded PowerPC implementations */
1113 static always_inline int ppcemb_tlb_check (CPUState *env, ppcemb_tlb_t *tlb,
1114 target_phys_addr_t *raddrp,
1115 target_ulong address,
1116 uint32_t pid, int ext, int i)
1117 {
1118 target_ulong mask;
1119
1120 /* Check valid flag */
1121 if (!(tlb->prot & PAGE_VALID)) {
1122 if (loglevel != 0)
1123 fprintf(logfile, "%s: TLB %d not valid\n", __func__, i);
1124 return -1;
1125 }
1126 mask = ~(tlb->size - 1);
1127 #if defined (DEBUG_SOFTWARE_TLB)
1128 if (loglevel != 0) {
1129 fprintf(logfile, "%s: TLB %d address " ADDRX " PID %u <=> " ADDRX
1130 " " ADDRX " %u\n",
1131 __func__, i, address, pid, tlb->EPN, mask, (uint32_t)tlb->PID);
1132 }
1133 #endif
1134 /* Check PID */
1135 if (tlb->PID != 0 && tlb->PID != pid)
1136 return -1;
1137 /* Check effective address */
1138 if ((address & mask) != tlb->EPN)
1139 return -1;
1140 *raddrp = (tlb->RPN & mask) | (address & ~mask);
1141 #if (TARGET_PHYS_ADDR_BITS >= 36)
1142 if (ext) {
1143 /* Extend the physical address to 36 bits */
1144 *raddrp |= (target_phys_addr_t)(tlb->RPN & 0xF) << 32;
1145 }
1146 #endif
1147
1148 return 0;
1149 }
1150
1151 /* Generic TLB search function for PowerPC embedded implementations */
1152 int ppcemb_tlb_search (CPUPPCState *env, target_ulong address, uint32_t pid)
1153 {
1154 ppcemb_tlb_t *tlb;
1155 target_phys_addr_t raddr;
1156 int i, ret;
1157
1158 /* Default return value is no match */
1159 ret = -1;
1160 for (i = 0; i < env->nb_tlb; i++) {
1161 tlb = &env->tlb[i].tlbe;
1162 if (ppcemb_tlb_check(env, tlb, &raddr, address, pid, 0, i) == 0) {
1163 ret = i;
1164 break;
1165 }
1166 }
1167
1168 return ret;
1169 }
1170
1171 /* Helpers specific to PowerPC 40x implementations */
1172 static always_inline void ppc4xx_tlb_invalidate_all (CPUState *env)
1173 {
1174 ppcemb_tlb_t *tlb;
1175 int i;
1176
1177 for (i = 0; i < env->nb_tlb; i++) {
1178 tlb = &env->tlb[i].tlbe;
1179 tlb->prot &= ~PAGE_VALID;
1180 }
1181 tlb_flush(env, 1);
1182 }
1183
1184 static always_inline void ppc4xx_tlb_invalidate_virt (CPUState *env,
1185 target_ulong eaddr,
1186 uint32_t pid)
1187 {
1188 #if !defined(FLUSH_ALL_TLBS)
1189 ppcemb_tlb_t *tlb;
1190 target_phys_addr_t raddr;
1191 target_ulong page, end;
1192 int i;
1193
1194 for (i = 0; i < env->nb_tlb; i++) {
1195 tlb = &env->tlb[i].tlbe;
1196 if (ppcemb_tlb_check(env, tlb, &raddr, eaddr, pid, 0, i) == 0) {
1197 end = tlb->EPN + tlb->size;
1198 for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE)
1199 tlb_flush_page(env, page);
1200 tlb->prot &= ~PAGE_VALID;
1201 break;
1202 }
1203 }
1204 #else
1205 ppc4xx_tlb_invalidate_all(env);
1206 #endif
1207 }
1208
1209 static int mmu40x_get_physical_address (CPUState *env, mmu_ctx_t *ctx,
1210 target_ulong address, int rw, int access_type)
1211 {
1212 ppcemb_tlb_t *tlb;
1213 target_phys_addr_t raddr;
1214 int i, ret, zsel, zpr, pr;
1215
1216 ret = -1;
1217 raddr = (target_phys_addr_t)-1ULL;
1218 pr = msr_pr;
1219 for (i = 0; i < env->nb_tlb; i++) {
1220 tlb = &env->tlb[i].tlbe;
1221 if (ppcemb_tlb_check(env, tlb, &raddr, address,
1222 env->spr[SPR_40x_PID], 0, i) < 0)
1223 continue;
1224 zsel = (tlb->attr >> 4) & 0xF;
1225 zpr = (env->spr[SPR_40x_ZPR] >> (28 - (2 * zsel))) & 0x3;
1226 #if defined (DEBUG_SOFTWARE_TLB)
1227 if (loglevel != 0) {
1228 fprintf(logfile, "%s: TLB %d zsel %d zpr %d rw %d attr %08x\n",
1229 __func__, i, zsel, zpr, rw, tlb->attr);
1230 }
1231 #endif
1232 /* Check execute enable bit */
1233 switch (zpr) {
1234 case 0x2:
1235 if (pr != 0)
1236 goto check_perms;
1237 /* No break here */
1238 case 0x3:
1239 /* All accesses granted */
1240 ctx->prot = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
1241 ret = 0;
1242 break;
1243 case 0x0:
1244 if (pr != 0) {
1245 ctx->prot = 0;
1246 ret = -2;
1247 break;
1248 }
1249 /* No break here */
1250 case 0x1:
1251 check_perms:
1252 /* Check from TLB entry */
1253 /* XXX: there is a problem here or in the TLB fill code... */
1254 ctx->prot = tlb->prot;
1255 ctx->prot |= PAGE_EXEC;
1256 ret = check_prot(ctx->prot, rw, access_type);
1257 break;
1258 }
1259 if (ret >= 0) {
1260 ctx->raddr = raddr;
1261 #if defined (DEBUG_SOFTWARE_TLB)
1262 if (loglevel != 0) {
1263 fprintf(logfile, "%s: access granted " ADDRX " => " PADDRX
1264 " %d %d\n", __func__, address, ctx->raddr, ctx->prot,
1265 ret);
1266 }
1267 #endif
1268 return 0;
1269 }
1270 }
1271 #if defined (DEBUG_SOFTWARE_TLB)
1272 if (loglevel != 0) {
1273 fprintf(logfile, "%s: access refused " ADDRX " => " PADDRX
1274 " %d %d\n", __func__, address, raddr, ctx->prot,
1275 ret);
1276 }
1277 #endif
1278
1279 return ret;
1280 }
1281
1282 void store_40x_sler (CPUPPCState *env, uint32_t val)
1283 {
1284 /* XXX: TO BE FIXED */
1285 if (val != 0x00000000) {
1286 cpu_abort(env, "Little-endian regions are not supported by now\n");
1287 }
1288 env->spr[SPR_405_SLER] = val;
1289 }
1290
1291 static int mmubooke_get_physical_address (CPUState *env, mmu_ctx_t *ctx,
1292 target_ulong address, int rw,
1293 int access_type)
1294 {
1295 ppcemb_tlb_t *tlb;
1296 target_phys_addr_t raddr;
1297 int i, prot, ret;
1298
1299 ret = -1;
1300 raddr = (target_phys_addr_t)-1ULL;
1301 for (i = 0; i < env->nb_tlb; i++) {
1302 tlb = &env->tlb[i].tlbe;
1303 if (ppcemb_tlb_check(env, tlb, &raddr, address,
1304 env->spr[SPR_BOOKE_PID], 1, i) < 0)
1305 continue;
1306 if (msr_pr != 0)
1307 prot = tlb->prot & 0xF;
1308 else
1309 prot = (tlb->prot >> 4) & 0xF;
1310 /* Check the address space */
1311 if (access_type == ACCESS_CODE) {
1312 if (msr_ir != (tlb->attr & 1))
1313 continue;
1314 ctx->prot = prot;
1315 if (prot & PAGE_EXEC) {
1316 ret = 0;
1317 break;
1318 }
1319 ret = -3;
1320 } else {
1321 if (msr_dr != (tlb->attr & 1))
1322 continue;
1323 ctx->prot = prot;
1324 if ((!rw && prot & PAGE_READ) || (rw && (prot & PAGE_WRITE))) {
1325 ret = 0;
1326 break;
1327 }
1328 ret = -2;
1329 }
1330 }
1331 if (ret >= 0)
1332 ctx->raddr = raddr;
1333
1334 return ret;
1335 }
1336
1337 static always_inline int check_physical (CPUState *env, mmu_ctx_t *ctx,
1338 target_ulong eaddr, int rw)
1339 {
1340 int in_plb, ret;
1341
1342 ctx->raddr = eaddr;
1343 ctx->prot = PAGE_READ | PAGE_EXEC;
1344 ret = 0;
1345 switch (env->mmu_model) {
1346 case POWERPC_MMU_32B:
1347 case POWERPC_MMU_601:
1348 case POWERPC_MMU_SOFT_6xx:
1349 case POWERPC_MMU_SOFT_74xx:
1350 case POWERPC_MMU_SOFT_4xx:
1351 case POWERPC_MMU_REAL:
1352 case POWERPC_MMU_BOOKE:
1353 ctx->prot |= PAGE_WRITE;
1354 break;
1355 #if defined(TARGET_PPC64)
1356 case POWERPC_MMU_620:
1357 case POWERPC_MMU_64B:
1358 /* Real address are 60 bits long */
1359 ctx->raddr &= 0x0FFFFFFFFFFFFFFFULL;
1360 ctx->prot |= PAGE_WRITE;
1361 break;
1362 #endif
1363 case POWERPC_MMU_SOFT_4xx_Z:
1364 if (unlikely(msr_pe != 0)) {
1365 /* 403 family add some particular protections,
1366 * using PBL/PBU registers for accesses with no translation.
1367 */
1368 in_plb =
1369 /* Check PLB validity */
1370 (env->pb[0] < env->pb[1] &&
1371 /* and address in plb area */
1372 eaddr >= env->pb[0] && eaddr < env->pb[1]) ||
1373 (env->pb[2] < env->pb[3] &&
1374 eaddr >= env->pb[2] && eaddr < env->pb[3]) ? 1 : 0;
1375 if (in_plb ^ msr_px) {
1376 /* Access in protected area */
1377 if (rw == 1) {
1378 /* Access is not allowed */
1379 ret = -2;
1380 }
1381 } else {
1382 /* Read-write access is allowed */
1383 ctx->prot |= PAGE_WRITE;
1384 }
1385 }
1386 break;
1387 case POWERPC_MMU_MPC8xx:
1388 /* XXX: TODO */
1389 cpu_abort(env, "MPC8xx MMU model is not implemented\n");
1390 break;
1391 case POWERPC_MMU_BOOKE_FSL:
1392 /* XXX: TODO */
1393 cpu_abort(env, "BookE FSL MMU model not implemented\n");
1394 break;
1395 default:
1396 cpu_abort(env, "Unknown or invalid MMU model\n");
1397 return -1;
1398 }
1399
1400 return ret;
1401 }
1402
1403 int get_physical_address (CPUState *env, mmu_ctx_t *ctx, target_ulong eaddr,
1404 int rw, int access_type)
1405 {
1406 int ret;
1407
1408 #if 0
1409 if (loglevel != 0) {
1410 fprintf(logfile, "%s\n", __func__);
1411 }
1412 #endif
1413 if ((access_type == ACCESS_CODE && msr_ir == 0) ||
1414 (access_type != ACCESS_CODE && msr_dr == 0)) {
1415 /* No address translation */
1416 ret = check_physical(env, ctx, eaddr, rw);
1417 } else {
1418 ret = -1;
1419 switch (env->mmu_model) {
1420 case POWERPC_MMU_32B:
1421 case POWERPC_MMU_601:
1422 case POWERPC_MMU_SOFT_6xx:
1423 case POWERPC_MMU_SOFT_74xx:
1424 #if defined(TARGET_PPC64)
1425 case POWERPC_MMU_620:
1426 case POWERPC_MMU_64B:
1427 #endif
1428 /* Try to find a BAT */
1429 if (env->nb_BATs != 0)
1430 ret = get_bat(env, ctx, eaddr, rw, access_type);
1431 if (ret < 0) {
1432 /* We didn't match any BAT entry or don't have BATs */
1433 ret = get_segment(env, ctx, eaddr, rw, access_type);
1434 }
1435 break;
1436 case POWERPC_MMU_SOFT_4xx:
1437 case POWERPC_MMU_SOFT_4xx_Z:
1438 ret = mmu40x_get_physical_address(env, ctx, eaddr,
1439 rw, access_type);
1440 break;
1441 case POWERPC_MMU_BOOKE:
1442 ret = mmubooke_get_physical_address(env, ctx, eaddr,
1443 rw, access_type);
1444 break;
1445 case POWERPC_MMU_MPC8xx:
1446 /* XXX: TODO */
1447 cpu_abort(env, "MPC8xx MMU model is not implemented\n");
1448 break;
1449 case POWERPC_MMU_BOOKE_FSL:
1450 /* XXX: TODO */
1451 cpu_abort(env, "BookE FSL MMU model not implemented\n");
1452 return -1;
1453 case POWERPC_MMU_REAL:
1454 cpu_abort(env, "PowerPC in real mode do not do any translation\n");
1455 return -1;
1456 default:
1457 cpu_abort(env, "Unknown or invalid MMU model\n");
1458 return -1;
1459 }
1460 }
1461 #if 0
1462 if (loglevel != 0) {
1463 fprintf(logfile, "%s address " ADDRX " => %d " PADDRX "\n",
1464 __func__, eaddr, ret, ctx->raddr);
1465 }
1466 #endif
1467
1468 return ret;
1469 }
1470
1471 target_phys_addr_t cpu_get_phys_page_debug (CPUState *env, target_ulong addr)
1472 {
1473 mmu_ctx_t ctx;
1474
1475 if (unlikely(get_physical_address(env, &ctx, addr, 0, ACCESS_INT) != 0))
1476 return -1;
1477
1478 return ctx.raddr & TARGET_PAGE_MASK;
1479 }
1480
1481 /* Perform address translation */
1482 int cpu_ppc_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
1483 int mmu_idx, int is_softmmu)
1484 {
1485 mmu_ctx_t ctx;
1486 int access_type;
1487 int ret = 0;
1488
1489 if (rw == 2) {
1490 /* code access */
1491 rw = 0;
1492 access_type = ACCESS_CODE;
1493 } else {
1494 /* data access */
1495 access_type = env->access_type;
1496 }
1497 ret = get_physical_address(env, &ctx, address, rw, access_type);
1498 if (ret == 0) {
1499 ret = tlb_set_page_exec(env, address & TARGET_PAGE_MASK,
1500 ctx.raddr & TARGET_PAGE_MASK, ctx.prot,
1501 mmu_idx, is_softmmu);
1502 } else if (ret < 0) {
1503 #if defined (DEBUG_MMU)
1504 if (loglevel != 0)
1505 cpu_dump_state(env, logfile, fprintf, 0);
1506 #endif
1507 if (access_type == ACCESS_CODE) {
1508 switch (ret) {
1509 case -1:
1510 /* No matches in page tables or TLB */
1511 switch (env->mmu_model) {
1512 case POWERPC_MMU_SOFT_6xx:
1513 env->exception_index = POWERPC_EXCP_IFTLB;
1514 env->error_code = 1 << 18;
1515 env->spr[SPR_IMISS] = address;
1516 env->spr[SPR_ICMP] = 0x80000000 | ctx.ptem;
1517 goto tlb_miss;
1518 case POWERPC_MMU_SOFT_74xx:
1519 env->exception_index = POWERPC_EXCP_IFTLB;
1520 goto tlb_miss_74xx;
1521 case POWERPC_MMU_SOFT_4xx:
1522 case POWERPC_MMU_SOFT_4xx_Z:
1523 env->exception_index = POWERPC_EXCP_ITLB;
1524 env->error_code = 0;
1525 env->spr[SPR_40x_DEAR] = address;
1526 env->spr[SPR_40x_ESR] = 0x00000000;
1527 break;
1528 case POWERPC_MMU_32B:
1529 case POWERPC_MMU_601:
1530 #if defined(TARGET_PPC64)
1531 case POWERPC_MMU_620:
1532 case POWERPC_MMU_64B:
1533 #endif
1534 env->exception_index = POWERPC_EXCP_ISI;
1535 env->error_code = 0x40000000;
1536 break;
1537 case POWERPC_MMU_BOOKE:
1538 /* XXX: TODO */
1539 cpu_abort(env, "BookE MMU model is not implemented\n");
1540 return -1;
1541 case POWERPC_MMU_BOOKE_FSL:
1542 /* XXX: TODO */
1543 cpu_abort(env, "BookE FSL MMU model is not implemented\n");
1544 return -1;
1545 case POWERPC_MMU_MPC8xx:
1546 /* XXX: TODO */
1547 cpu_abort(env, "MPC8xx MMU model is not implemented\n");
1548 break;
1549 case POWERPC_MMU_REAL:
1550 cpu_abort(env, "PowerPC in real mode should never raise "
1551 "any MMU exceptions\n");
1552 return -1;
1553 default:
1554 cpu_abort(env, "Unknown or invalid MMU model\n");
1555 return -1;
1556 }
1557 break;
1558 case -2:
1559 /* Access rights violation */
1560 env->exception_index = POWERPC_EXCP_ISI;
1561 env->error_code = 0x08000000;
1562 break;
1563 case -3:
1564 /* No execute protection violation */
1565 env->exception_index = POWERPC_EXCP_ISI;
1566 env->error_code = 0x10000000;
1567 break;
1568 case -4:
1569 /* Direct store exception */
1570 /* No code fetch is allowed in direct-store areas */
1571 env->exception_index = POWERPC_EXCP_ISI;
1572 env->error_code = 0x10000000;
1573 break;
1574 #if defined(TARGET_PPC64)
1575 case -5:
1576 /* No match in segment table */
1577 if (env->mmu_model == POWERPC_MMU_620) {
1578 env->exception_index = POWERPC_EXCP_ISI;
1579 /* XXX: this might be incorrect */
1580 env->error_code = 0x40000000;
1581 } else {
1582 env->exception_index = POWERPC_EXCP_ISEG;
1583 env->error_code = 0;
1584 }
1585 break;
1586 #endif
1587 }
1588 } else {
1589 switch (ret) {
1590 case -1:
1591 /* No matches in page tables or TLB */
1592 switch (env->mmu_model) {
1593 case POWERPC_MMU_SOFT_6xx:
1594 if (rw == 1) {
1595 env->exception_index = POWERPC_EXCP_DSTLB;
1596 env->error_code = 1 << 16;
1597 } else {
1598 env->exception_index = POWERPC_EXCP_DLTLB;
1599 env->error_code = 0;
1600 }
1601 env->spr[SPR_DMISS] = address;
1602 env->spr[SPR_DCMP] = 0x80000000 | ctx.ptem;
1603 tlb_miss:
1604 env->error_code |= ctx.key << 19;
1605 env->spr[SPR_HASH1] = ctx.pg_addr[0];
1606 env->spr[SPR_HASH2] = ctx.pg_addr[1];
1607 break;
1608 case POWERPC_MMU_SOFT_74xx:
1609 if (rw == 1) {
1610 env->exception_index = POWERPC_EXCP_DSTLB;
1611 } else {
1612 env->exception_index = POWERPC_EXCP_DLTLB;
1613 }
1614 tlb_miss_74xx:
1615 /* Implement LRU algorithm */
1616 env->error_code = ctx.key << 19;
1617 env->spr[SPR_TLBMISS] = (address & ~((target_ulong)0x3)) |
1618 ((env->last_way + 1) & (env->nb_ways - 1));
1619 env->spr[SPR_PTEHI] = 0x80000000 | ctx.ptem;
1620 break;
1621 case POWERPC_MMU_SOFT_4xx:
1622 case POWERPC_MMU_SOFT_4xx_Z:
1623 env->exception_index = POWERPC_EXCP_DTLB;
1624 env->error_code = 0;
1625 env->spr[SPR_40x_DEAR] = address;
1626 if (rw)
1627 env->spr[SPR_40x_ESR] = 0x00800000;
1628 else
1629 env->spr[SPR_40x_ESR] = 0x00000000;
1630 break;
1631 case POWERPC_MMU_32B:
1632 case POWERPC_MMU_601:
1633 #if defined(TARGET_PPC64)
1634 case POWERPC_MMU_620:
1635 case POWERPC_MMU_64B:
1636 #endif
1637 env->exception_index = POWERPC_EXCP_DSI;
1638 env->error_code = 0;
1639 env->spr[SPR_DAR] = address;
1640 if (rw == 1)
1641 env->spr[SPR_DSISR] = 0x42000000;
1642 else
1643 env->spr[SPR_DSISR] = 0x40000000;
1644 break;
1645 case POWERPC_MMU_MPC8xx:
1646 /* XXX: TODO */
1647 cpu_abort(env, "MPC8xx MMU model is not implemented\n");
1648 break;
1649 case POWERPC_MMU_BOOKE:
1650 /* XXX: TODO */
1651 cpu_abort(env, "BookE MMU model is not implemented\n");
1652 return -1;
1653 case POWERPC_MMU_BOOKE_FSL:
1654 /* XXX: TODO */
1655 cpu_abort(env, "BookE FSL MMU model is not implemented\n");
1656 return -1;
1657 case POWERPC_MMU_REAL:
1658 cpu_abort(env, "PowerPC in real mode should never raise "
1659 "any MMU exceptions\n");
1660 return -1;
1661 default:
1662 cpu_abort(env, "Unknown or invalid MMU model\n");
1663 return -1;
1664 }
1665 break;
1666 case -2:
1667 /* Access rights violation */
1668 env->exception_index = POWERPC_EXCP_DSI;
1669 env->error_code = 0;
1670 env->spr[SPR_DAR] = address;
1671 if (rw == 1)
1672 env->spr[SPR_DSISR] = 0x0A000000;
1673 else
1674 env->spr[SPR_DSISR] = 0x08000000;
1675 break;
1676 case -4:
1677 /* Direct store exception */
1678 switch (access_type) {
1679 case ACCESS_FLOAT:
1680 /* Floating point load/store */
1681 env->exception_index = POWERPC_EXCP_ALIGN;
1682 env->error_code = POWERPC_EXCP_ALIGN_FP;
1683 env->spr[SPR_DAR] = address;
1684 break;
1685 case ACCESS_RES:
1686 /* lwarx, ldarx or stwcx. */
1687 env->exception_index = POWERPC_EXCP_DSI;
1688 env->error_code = 0;
1689 env->spr[SPR_DAR] = address;
1690 if (rw == 1)
1691 env->spr[SPR_DSISR] = 0x06000000;
1692 else
1693 env->spr[SPR_DSISR] = 0x04000000;
1694 break;
1695 case ACCESS_EXT:
1696 /* eciwx or ecowx */
1697 env->exception_index = POWERPC_EXCP_DSI;
1698 env->error_code = 0;
1699 env->spr[SPR_DAR] = address;
1700 if (rw == 1)
1701 env->spr[SPR_DSISR] = 0x06100000;
1702 else
1703 env->spr[SPR_DSISR] = 0x04100000;
1704 break;
1705 default:
1706 printf("DSI: invalid exception (%d)\n", ret);
1707 env->exception_index = POWERPC_EXCP_PROGRAM;
1708 env->error_code =
1709 POWERPC_EXCP_INVAL | POWERPC_EXCP_INVAL_INVAL;
1710 env->spr[SPR_DAR] = address;
1711 break;
1712 }
1713 break;
1714 #if defined(TARGET_PPC64)
1715 case -5:
1716 /* No match in segment table */
1717 if (env->mmu_model == POWERPC_MMU_620) {
1718 env->exception_index = POWERPC_EXCP_DSI;
1719 env->error_code = 0;
1720 env->spr[SPR_DAR] = address;
1721 /* XXX: this might be incorrect */
1722 if (rw == 1)
1723 env->spr[SPR_DSISR] = 0x42000000;
1724 else
1725 env->spr[SPR_DSISR] = 0x40000000;
1726 } else {
1727 env->exception_index = POWERPC_EXCP_DSEG;
1728 env->error_code = 0;
1729 env->spr[SPR_DAR] = address;
1730 }
1731 break;
1732 #endif
1733 }
1734 }
1735 #if 0
1736 printf("%s: set exception to %d %02x\n", __func__,
1737 env->exception, env->error_code);
1738 #endif
1739 ret = 1;
1740 }
1741
1742 return ret;
1743 }
1744
1745 /*****************************************************************************/
1746 /* BATs management */
1747 #if !defined(FLUSH_ALL_TLBS)
1748 static always_inline void do_invalidate_BAT (CPUPPCState *env,
1749 target_ulong BATu,
1750 target_ulong mask)
1751 {
1752 target_ulong base, end, page;
1753
1754 base = BATu & ~0x0001FFFF;
1755 end = base + mask + 0x00020000;
1756 #if defined (DEBUG_BATS)
1757 if (loglevel != 0) {
1758 fprintf(logfile, "Flush BAT from " ADDRX " to " ADDRX " (" ADDRX ")\n",
1759 base, end, mask);
1760 }
1761 #endif
1762 for (page = base; page != end; page += TARGET_PAGE_SIZE)
1763 tlb_flush_page(env, page);
1764 #if defined (DEBUG_BATS)
1765 if (loglevel != 0)
1766 fprintf(logfile, "Flush done\n");
1767 #endif
1768 }
1769 #endif
1770
1771 static always_inline void dump_store_bat (CPUPPCState *env, char ID,
1772 int ul, int nr, target_ulong value)
1773 {
1774 #if defined (DEBUG_BATS)
1775 if (loglevel != 0) {
1776 fprintf(logfile, "Set %cBAT%d%c to " ADDRX " (" ADDRX ")\n",
1777 ID, nr, ul == 0 ? 'u' : 'l', value, env->nip);
1778 }
1779 #endif
1780 }
1781
1782 void ppc_store_ibatu (CPUPPCState *env, int nr, target_ulong value)
1783 {
1784 target_ulong mask;
1785
1786 dump_store_bat(env, 'I', 0, nr, value);
1787 if (env->IBAT[0][nr] != value) {
1788 mask = (value << 15) & 0x0FFE0000UL;
1789 #if !defined(FLUSH_ALL_TLBS)
1790 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1791 #endif
1792 /* When storing valid upper BAT, mask BEPI and BRPN
1793 * and invalidate all TLBs covered by this BAT
1794 */
1795 mask = (value << 15) & 0x0FFE0000UL;
1796 env->IBAT[0][nr] = (value & 0x00001FFFUL) |
1797 (value & ~0x0001FFFFUL & ~mask);
1798 env->IBAT[1][nr] = (env->IBAT[1][nr] & 0x0000007B) |
1799 (env->IBAT[1][nr] & ~0x0001FFFF & ~mask);
1800 #if !defined(FLUSH_ALL_TLBS)
1801 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1802 #else
1803 tlb_flush(env, 1);
1804 #endif
1805 }
1806 }
1807
1808 void ppc_store_ibatl (CPUPPCState *env, int nr, target_ulong value)
1809 {
1810 dump_store_bat(env, 'I', 1, nr, value);
1811 env->IBAT[1][nr] = value;
1812 }
1813
1814 void ppc_store_dbatu (CPUPPCState *env, int nr, target_ulong value)
1815 {
1816 target_ulong mask;
1817
1818 dump_store_bat(env, 'D', 0, nr, value);
1819 if (env->DBAT[0][nr] != value) {
1820 /* When storing valid upper BAT, mask BEPI and BRPN
1821 * and invalidate all TLBs covered by this BAT
1822 */
1823 mask = (value << 15) & 0x0FFE0000UL;
1824 #if !defined(FLUSH_ALL_TLBS)
1825 do_invalidate_BAT(env, env->DBAT[0][nr], mask);
1826 #endif
1827 mask = (value << 15) & 0x0FFE0000UL;
1828 env->DBAT[0][nr] = (value & 0x00001FFFUL) |
1829 (value & ~0x0001FFFFUL & ~mask);
1830 env->DBAT[1][nr] = (env->DBAT[1][nr] & 0x0000007B) |
1831 (env->DBAT[1][nr] & ~0x0001FFFF & ~mask);
1832 #if !defined(FLUSH_ALL_TLBS)
1833 do_invalidate_BAT(env, env->DBAT[0][nr], mask);
1834 #else
1835 tlb_flush(env, 1);
1836 #endif
1837 }
1838 }
1839
1840 void ppc_store_dbatl (CPUPPCState *env, int nr, target_ulong value)
1841 {
1842 dump_store_bat(env, 'D', 1, nr, value);
1843 env->DBAT[1][nr] = value;
1844 }
1845
1846 void ppc_store_ibatu_601 (CPUPPCState *env, int nr, target_ulong value)
1847 {
1848 target_ulong mask;
1849 int do_inval;
1850
1851 dump_store_bat(env, 'I', 0, nr, value);
1852 if (env->IBAT[0][nr] != value) {
1853 do_inval = 0;
1854 mask = (env->IBAT[1][nr] << 17) & 0x0FFE0000UL;
1855 if (env->IBAT[1][nr] & 0x40) {
1856 /* Invalidate BAT only if it is valid */
1857 #if !defined(FLUSH_ALL_TLBS)
1858 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1859 #else
1860 do_inval = 1;
1861 #endif
1862 }
1863 /* When storing valid upper BAT, mask BEPI and BRPN
1864 * and invalidate all TLBs covered by this BAT
1865 */
1866 env->IBAT[0][nr] = (value & 0x00001FFFUL) |
1867 (value & ~0x0001FFFFUL & ~mask);
1868 env->DBAT[0][nr] = env->IBAT[0][nr];
1869 if (env->IBAT[1][nr] & 0x40) {
1870 #if !defined(FLUSH_ALL_TLBS)
1871 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1872 #else
1873 do_inval = 1;
1874 #endif
1875 }
1876 #if defined(FLUSH_ALL_TLBS)
1877 if (do_inval)
1878 tlb_flush(env, 1);
1879 #endif
1880 }
1881 }
1882
1883 void ppc_store_ibatl_601 (CPUPPCState *env, int nr, target_ulong value)
1884 {
1885 target_ulong mask;
1886 int do_inval;
1887
1888 dump_store_bat(env, 'I', 1, nr, value);
1889 if (env->IBAT[1][nr] != value) {
1890 do_inval = 0;
1891 if (env->IBAT[1][nr] & 0x40) {
1892 #if !defined(FLUSH_ALL_TLBS)
1893 mask = (env->IBAT[1][nr] << 17) & 0x0FFE0000UL;
1894 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1895 #else
1896 do_inval = 1;
1897 #endif
1898 }
1899 if (value & 0x40) {
1900 #if !defined(FLUSH_ALL_TLBS)
1901 mask = (value << 17) & 0x0FFE0000UL;
1902 do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1903 #else
1904 do_inval = 1;
1905 #endif
1906 }
1907 env->IBAT[1][nr] = value;
1908 env->DBAT[1][nr] = value;
1909 #if defined(FLUSH_ALL_TLBS)
1910 if (do_inval)
1911 tlb_flush(env, 1);
1912 #endif
1913 }
1914 }
1915
1916 /*****************************************************************************/
1917 /* TLB management */
1918 void ppc_tlb_invalidate_all (CPUPPCState *env)
1919 {
1920 switch (env->mmu_model) {
1921 case POWERPC_MMU_SOFT_6xx:
1922 case POWERPC_MMU_SOFT_74xx:
1923 ppc6xx_tlb_invalidate_all(env);
1924 break;
1925 case POWERPC_MMU_SOFT_4xx:
1926 case POWERPC_MMU_SOFT_4xx_Z:
1927 ppc4xx_tlb_invalidate_all(env);
1928 break;
1929 case POWERPC_MMU_REAL:
1930 cpu_abort(env, "No TLB for PowerPC 4xx in real mode\n");
1931 break;
1932 case POWERPC_MMU_MPC8xx:
1933 /* XXX: TODO */
1934 cpu_abort(env, "MPC8xx MMU model is not implemented\n");
1935 break;
1936 case POWERPC_MMU_BOOKE:
1937 /* XXX: TODO */
1938 cpu_abort(env, "BookE MMU model is not implemented\n");
1939 break;
1940 case POWERPC_MMU_BOOKE_FSL:
1941 /* XXX: TODO */
1942 cpu_abort(env, "BookE MMU model is not implemented\n");
1943 break;
1944 case POWERPC_MMU_32B:
1945 case POWERPC_MMU_601:
1946 #if defined(TARGET_PPC64)
1947 case POWERPC_MMU_620:
1948 case POWERPC_MMU_64B:
1949 #endif /* defined(TARGET_PPC64) */
1950 tlb_flush(env, 1);
1951 break;
1952 default:
1953 /* XXX: TODO */
1954 cpu_abort(env, "Unknown MMU model\n");
1955 break;
1956 }
1957 }
1958
1959 void ppc_tlb_invalidate_one (CPUPPCState *env, target_ulong addr)
1960 {
1961 #if !defined(FLUSH_ALL_TLBS)
1962 addr &= TARGET_PAGE_MASK;
1963 switch (env->mmu_model) {
1964 case POWERPC_MMU_SOFT_6xx:
1965 case POWERPC_MMU_SOFT_74xx:
1966 ppc6xx_tlb_invalidate_virt(env, addr, 0);
1967 if (env->id_tlbs == 1)
1968 ppc6xx_tlb_invalidate_virt(env, addr, 1);
1969 break;
1970 case POWERPC_MMU_SOFT_4xx:
1971 case POWERPC_MMU_SOFT_4xx_Z:
1972 ppc4xx_tlb_invalidate_virt(env, addr, env->spr[SPR_40x_PID]);
1973 break;
1974 case POWERPC_MMU_REAL:
1975 cpu_abort(env, "No TLB for PowerPC 4xx in real mode\n");
1976 break;
1977 case POWERPC_MMU_MPC8xx:
1978 /* XXX: TODO */
1979 cpu_abort(env, "MPC8xx MMU model is not implemented\n");
1980 break;
1981 case POWERPC_MMU_BOOKE:
1982 /* XXX: TODO */
1983 cpu_abort(env, "BookE MMU model is not implemented\n");
1984 break;
1985 case POWERPC_MMU_BOOKE_FSL:
1986 /* XXX: TODO */
1987 cpu_abort(env, "BookE FSL MMU model is not implemented\n");
1988 break;
1989 case POWERPC_MMU_32B:
1990 case POWERPC_MMU_601:
1991 /* tlbie invalidate TLBs for all segments */
1992 addr &= ~((target_ulong)-1ULL << 28);
1993 /* XXX: this case should be optimized,
1994 * giving a mask to tlb_flush_page
1995 */
1996 tlb_flush_page(env, addr | (0x0 << 28));
1997 tlb_flush_page(env, addr | (0x1 << 28));
1998 tlb_flush_page(env, addr | (0x2 << 28));
1999 tlb_flush_page(env, addr | (0x3 << 28));
2000 tlb_flush_page(env, addr | (0x4 << 28));
2001 tlb_flush_page(env, addr | (0x5 << 28));
2002 tlb_flush_page(env, addr | (0x6 << 28));
2003 tlb_flush_page(env, addr | (0x7 << 28));
2004 tlb_flush_page(env, addr | (0x8 << 28));
2005 tlb_flush_page(env, addr | (0x9 << 28));
2006 tlb_flush_page(env, addr | (0xA << 28));
2007 tlb_flush_page(env, addr | (0xB << 28));
2008 tlb_flush_page(env, addr | (0xC << 28));
2009 tlb_flush_page(env, addr | (0xD << 28));
2010 tlb_flush_page(env, addr | (0xE << 28));
2011 tlb_flush_page(env, addr | (0xF << 28));
2012 break;
2013 #if defined(TARGET_PPC64)
2014 case POWERPC_MMU_620:
2015 case POWERPC_MMU_64B:
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(env, 1);
2022 break;
2023 #endif /* defined(TARGET_PPC64) */
2024 default:
2025 /* XXX: TODO */
2026 cpu_abort(env, "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 #if defined(TARGET_PPC64)
2037 void ppc_store_asr (CPUPPCState *env, target_ulong value)
2038 {
2039 if (env->asr != value) {
2040 env->asr = value;
2041 tlb_flush(env, 1);
2042 }
2043 }
2044 #endif
2045
2046 void ppc_store_sdr1 (CPUPPCState *env, target_ulong value)
2047 {
2048 #if defined (DEBUG_MMU)
2049 if (loglevel != 0) {
2050 fprintf(logfile, "%s: " ADDRX "\n", __func__, value);
2051 }
2052 #endif
2053 if (env->sdr1 != value) {
2054 /* XXX: for PowerPC 64, should check that the HTABSIZE value
2055 * is <= 28
2056 */
2057 env->sdr1 = value;
2058 tlb_flush(env, 1);
2059 }
2060 }
2061
2062 void ppc_store_sr (CPUPPCState *env, int srnum, target_ulong value)
2063 {
2064 #if defined (DEBUG_MMU)
2065 if (loglevel != 0) {
2066 fprintf(logfile, "%s: reg=%d " ADDRX " " ADDRX "\n",
2067 __func__, srnum, value, env->sr[srnum]);
2068 }
2069 #endif
2070 if (env->sr[srnum] != value) {
2071 env->sr[srnum] = value;
2072 #if !defined(FLUSH_ALL_TLBS) && 0
2073 {
2074 target_ulong page, end;
2075 /* Invalidate 256 MB of virtual memory */
2076 page = (16 << 20) * srnum;
2077 end = page + (16 << 20);
2078 for (; page != end; page += TARGET_PAGE_SIZE)
2079 tlb_flush_page(env, page);
2080 }
2081 #else
2082 tlb_flush(env, 1);
2083 #endif
2084 }
2085 }
2086 #endif /* !defined (CONFIG_USER_ONLY) */
2087
2088 /* GDBstub can read and write MSR... */
2089 void ppc_store_msr (CPUPPCState *env, target_ulong value)
2090 {
2091 hreg_store_msr(env, value, 0);
2092 }
2093
2094 /*****************************************************************************/
2095 /* Exception processing */
2096 #if defined (CONFIG_USER_ONLY)
2097 void do_interrupt (CPUState *env)
2098 {
2099 env->exception_index = POWERPC_EXCP_NONE;
2100 env->error_code = 0;
2101 }
2102
2103 void ppc_hw_interrupt (CPUState *env)
2104 {
2105 env->exception_index = POWERPC_EXCP_NONE;
2106 env->error_code = 0;
2107 }
2108 #else /* defined (CONFIG_USER_ONLY) */
2109 static always_inline void dump_syscall (CPUState *env)
2110 {
2111 fprintf(logfile, "syscall r0=" REGX " r3=" REGX " r4=" REGX
2112 " r5=" REGX " r6=" REGX " nip=" ADDRX "\n",
2113 ppc_dump_gpr(env, 0), ppc_dump_gpr(env, 3), ppc_dump_gpr(env, 4),
2114 ppc_dump_gpr(env, 5), ppc_dump_gpr(env, 6), env->nip);
2115 }
2116
2117 /* Note that this function should be greatly optimized
2118 * when called with a constant excp, from ppc_hw_interrupt
2119 */
2120 static always_inline void powerpc_excp (CPUState *env,
2121 int excp_model, int excp)
2122 {
2123 target_ulong msr, new_msr, vector;
2124 int srr0, srr1, asrr0, asrr1;
2125 int lpes0, lpes1, lev;
2126
2127 if (0) {
2128 /* XXX: find a suitable condition to enable the hypervisor mode */
2129 lpes0 = (env->spr[SPR_LPCR] >> 1) & 1;
2130 lpes1 = (env->spr[SPR_LPCR] >> 2) & 1;
2131 } else {
2132 /* Those values ensure we won't enter the hypervisor mode */
2133 lpes0 = 0;
2134 lpes1 = 1;
2135 }
2136
2137 if (loglevel & CPU_LOG_INT) {
2138 fprintf(logfile, "Raise exception at " ADDRX " => %08x (%02x)\n",
2139 env->nip, excp, env->error_code);
2140 }
2141 msr = env->msr;
2142 new_msr = msr;
2143 srr0 = SPR_SRR0;
2144 srr1 = SPR_SRR1;
2145 asrr0 = -1;
2146 asrr1 = -1;
2147 msr &= ~((target_ulong)0x783F0000);
2148 switch (excp) {
2149 case POWERPC_EXCP_NONE:
2150 /* Should never happen */
2151 return;
2152 case POWERPC_EXCP_CRITICAL: /* Critical input */
2153 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2154 switch (excp_model) {
2155 case POWERPC_EXCP_40x:
2156 srr0 = SPR_40x_SRR2;
2157 srr1 = SPR_40x_SRR3;
2158 break;
2159 case POWERPC_EXCP_BOOKE:
2160 srr0 = SPR_BOOKE_CSRR0;
2161 srr1 = SPR_BOOKE_CSRR1;
2162 break;
2163 case POWERPC_EXCP_G2:
2164 break;
2165 default:
2166 goto excp_invalid;
2167 }
2168 goto store_next;
2169 case POWERPC_EXCP_MCHECK: /* Machine check exception */
2170 if (msr_me == 0) {
2171 /* Machine check exception is not enabled.
2172 * Enter checkstop state.
2173 */
2174 if (loglevel != 0) {
2175 fprintf(logfile, "Machine check while not allowed. "
2176 "Entering checkstop state\n");
2177 } else {
2178 fprintf(stderr, "Machine check while not allowed. "
2179 "Entering checkstop state\n");
2180 }
2181 env->halted = 1;
2182 env->interrupt_request |= CPU_INTERRUPT_EXITTB;
2183 }
2184 new_msr &= ~((target_ulong)1 << MSR_RI);
2185 new_msr &= ~((target_ulong)1 << MSR_ME);
2186 if (0) {
2187 /* XXX: find a suitable condition to enable the hypervisor mode */
2188 new_msr |= (target_ulong)MSR_HVB;
2189 }
2190 /* XXX: should also have something loaded in DAR / DSISR */
2191 switch (excp_model) {
2192 case POWERPC_EXCP_40x:
2193 srr0 = SPR_40x_SRR2;
2194 srr1 = SPR_40x_SRR3;
2195 break;
2196 case POWERPC_EXCP_BOOKE:
2197 srr0 = SPR_BOOKE_MCSRR0;
2198 srr1 = SPR_BOOKE_MCSRR1;
2199 asrr0 = SPR_BOOKE_CSRR0;
2200 asrr1 = SPR_BOOKE_CSRR1;
2201 break;
2202 default:
2203 break;
2204 }
2205 goto store_next;
2206 case POWERPC_EXCP_DSI: /* Data storage exception */
2207 #if defined (DEBUG_EXCEPTIONS)
2208 if (loglevel != 0) {
2209 fprintf(logfile, "DSI exception: DSISR=" ADDRX" DAR=" ADDRX "\n",
2210 env->spr[SPR_DSISR], env->spr[SPR_DAR]);
2211 }
2212 #endif
2213 new_msr &= ~((target_ulong)1 << MSR_RI);
2214 if (lpes1 == 0)
2215 new_msr |= (target_ulong)MSR_HVB;
2216 goto store_next;
2217 case POWERPC_EXCP_ISI: /* Instruction storage exception */
2218 #if defined (DEBUG_EXCEPTIONS)
2219 if (loglevel != 0) {
2220 fprintf(logfile, "ISI exception: msr=" ADDRX ", nip=" ADDRX "\n",
2221 msr, env->nip);
2222 }
2223 #endif
2224 new_msr &= ~((target_ulong)1 << MSR_RI);
2225 if (lpes1 == 0)
2226 new_msr |= (target_ulong)MSR_HVB;
2227 msr |= env->error_code;
2228 goto store_next;
2229 case POWERPC_EXCP_EXTERNAL: /* External input */
2230 new_msr &= ~((target_ulong)1 << MSR_RI);
2231 if (lpes0 == 1)
2232 new_msr |= (target_ulong)MSR_HVB;
2233 goto store_next;
2234 case POWERPC_EXCP_ALIGN: /* Alignment exception */
2235 new_msr &= ~((target_ulong)1 << MSR_RI);
2236 if (lpes1 == 0)
2237 new_msr |= (target_ulong)MSR_HVB;
2238 /* XXX: this is false */
2239 /* Get rS/rD and rA from faulting opcode */
2240 env->spr[SPR_DSISR] |= (ldl_code((env->nip - 4)) & 0x03FF0000) >> 16;
2241 goto store_current;
2242 case POWERPC_EXCP_PROGRAM: /* Program exception */
2243 switch (env->error_code & ~0xF) {
2244 case POWERPC_EXCP_FP:
2245 if ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {
2246 #if defined (DEBUG_EXCEPTIONS)
2247 if (loglevel != 0) {
2248 fprintf(logfile, "Ignore floating point exception\n");
2249 }
2250 #endif
2251 env->exception_index = POWERPC_EXCP_NONE;
2252 env->error_code = 0;
2253 return;
2254 }
2255 new_msr &= ~((target_ulong)1 << MSR_RI);
2256 if (lpes1 == 0)
2257 new_msr |= (target_ulong)MSR_HVB;
2258 msr |= 0x00100000;
2259 if (msr_fe0 == msr_fe1)
2260 goto store_next;
2261 msr |= 0x00010000;
2262 break;
2263 case POWERPC_EXCP_INVAL:
2264 #if defined (DEBUG_EXCEPTIONS)
2265 if (loglevel != 0) {
2266 fprintf(logfile, "Invalid instruction at " ADDRX "\n",
2267 env->nip);
2268 }
2269 #endif
2270 new_msr &= ~((target_ulong)1 << MSR_RI);
2271 if (lpes1 == 0)
2272 new_msr |= (target_ulong)MSR_HVB;
2273 msr |= 0x00080000;
2274 break;
2275 case POWERPC_EXCP_PRIV:
2276 new_msr &= ~((target_ulong)1 << MSR_RI);
2277 if (lpes1 == 0)
2278 new_msr |= (target_ulong)MSR_HVB;
2279 msr |= 0x00040000;
2280 break;
2281 case POWERPC_EXCP_TRAP:
2282 new_msr &= ~((target_ulong)1 << MSR_RI);
2283 if (lpes1 == 0)
2284 new_msr |= (target_ulong)MSR_HVB;
2285 msr |= 0x00020000;
2286 break;
2287 default:
2288 /* Should never occur */
2289 cpu_abort(env, "Invalid program exception %d. Aborting\n",
2290 env->error_code);
2291 break;
2292 }
2293 goto store_current;
2294 case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
2295 new_msr &= ~((target_ulong)1 << MSR_RI);
2296 if (lpes1 == 0)
2297 new_msr |= (target_ulong)MSR_HVB;
2298 goto store_current;
2299 case POWERPC_EXCP_SYSCALL: /* System call exception */
2300 /* NOTE: this is a temporary hack to support graphics OSI
2301 calls from the MOL driver */
2302 /* XXX: To be removed */
2303 if (env->gpr[3] == 0x113724fa && env->gpr[4] == 0x77810f9b &&
2304 env->osi_call) {
2305 if (env->osi_call(env) != 0) {
2306 env->exception_index = POWERPC_EXCP_NONE;
2307 env->error_code = 0;
2308 return;
2309 }
2310 }
2311 if (loglevel & CPU_LOG_INT) {
2312 dump_syscall(env);
2313 }
2314 new_msr &= ~((target_ulong)1 << MSR_RI);
2315 lev = env->error_code;
2316 if (lev == 1 || (lpes0 == 0 && lpes1 == 0))
2317 new_msr |= (target_ulong)MSR_HVB;
2318 goto store_next;
2319 case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
2320 new_msr &= ~((target_ulong)1 << MSR_RI);
2321 goto store_current;
2322 case POWERPC_EXCP_DECR: /* Decrementer exception */
2323 new_msr &= ~((target_ulong)1 << MSR_RI);
2324 if (lpes1 == 0)
2325 new_msr |= (target_ulong)MSR_HVB;
2326 goto store_next;
2327 case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
2328 /* FIT on 4xx */
2329 #if defined (DEBUG_EXCEPTIONS)
2330 if (loglevel != 0)
2331 fprintf(logfile, "FIT exception\n");
2332 #endif
2333 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2334 goto store_next;
2335 case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
2336 #if defined (DEBUG_EXCEPTIONS)
2337 if (loglevel != 0)
2338 fprintf(logfile, "WDT exception\n");
2339 #endif
2340 switch (excp_model) {
2341 case POWERPC_EXCP_BOOKE:
2342 srr0 = SPR_BOOKE_CSRR0;
2343 srr1 = SPR_BOOKE_CSRR1;
2344 break;
2345 default:
2346 break;
2347 }
2348 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2349 goto store_next;
2350 case POWERPC_EXCP_DTLB: /* Data TLB error */
2351 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2352 goto store_next;
2353 case POWERPC_EXCP_ITLB: /* Instruction TLB error */
2354 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2355 goto store_next;
2356 case POWERPC_EXCP_DEBUG: /* Debug interrupt */
2357 switch (excp_model) {
2358 case POWERPC_EXCP_BOOKE:
2359 srr0 = SPR_BOOKE_DSRR0;
2360 srr1 = SPR_BOOKE_DSRR1;
2361 asrr0 = SPR_BOOKE_CSRR0;
2362 asrr1 = SPR_BOOKE_CSRR1;
2363 break;
2364 default:
2365 break;
2366 }
2367 /* XXX: TODO */
2368 cpu_abort(env, "Debug exception is not implemented yet !\n");
2369 goto store_next;
2370 case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavailable */
2371 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2372 goto store_current;
2373 case POWERPC_EXCP_EFPDI: /* Embedded floating-point data interrupt */
2374 /* XXX: TODO */
2375 cpu_abort(env, "Embedded floating point data exception "
2376 "is not implemented yet !\n");
2377 goto store_next;
2378 case POWERPC_EXCP_EFPRI: /* Embedded floating-point round interrupt */
2379 /* XXX: TODO */
2380 cpu_abort(env, "Embedded floating point round exception "
2381 "is not implemented yet !\n");
2382 goto store_next;
2383 case POWERPC_EXCP_EPERFM: /* Embedded performance monitor interrupt */
2384 new_msr &= ~((target_ulong)1 << MSR_RI);
2385 /* XXX: TODO */
2386 cpu_abort(env,
2387 "Performance counter exception is not implemented yet !\n");
2388 goto store_next;
2389 case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
2390 /* XXX: TODO */
2391 cpu_abort(env,
2392 "Embedded doorbell interrupt is not implemented yet !\n");
2393 goto store_next;
2394 case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
2395 switch (excp_model) {
2396 case POWERPC_EXCP_BOOKE:
2397 srr0 = SPR_BOOKE_CSRR0;
2398 srr1 = SPR_BOOKE_CSRR1;
2399 break;
2400 default:
2401 break;
2402 }
2403 /* XXX: TODO */
2404 cpu_abort(env, "Embedded doorbell critical interrupt "
2405 "is not implemented yet !\n");
2406 goto store_next;
2407 case POWERPC_EXCP_RESET: /* System reset exception */
2408 new_msr &= ~((target_ulong)1 << MSR_RI);
2409 if (0) {
2410 /* XXX: find a suitable condition to enable the hypervisor mode */
2411 new_msr |= (target_ulong)MSR_HVB;
2412 }
2413 goto store_next;
2414 case POWERPC_EXCP_DSEG: /* Data segment exception */
2415 new_msr &= ~((target_ulong)1 << MSR_RI);
2416 if (lpes1 == 0)
2417 new_msr |= (target_ulong)MSR_HVB;
2418 goto store_next;
2419 case POWERPC_EXCP_ISEG: /* Instruction segment exception */
2420 new_msr &= ~((target_ulong)1 << MSR_RI);
2421 if (lpes1 == 0)
2422 new_msr |= (target_ulong)MSR_HVB;
2423 goto store_next;
2424 case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
2425 srr0 = SPR_HSRR0;
2426 srr1 = SPR_HSRR1;
2427 new_msr |= (target_ulong)MSR_HVB;
2428 goto store_next;
2429 case POWERPC_EXCP_TRACE: /* Trace exception */
2430 new_msr &= ~((target_ulong)1 << MSR_RI);
2431 if (lpes1 == 0)
2432 new_msr |= (target_ulong)MSR_HVB;
2433 goto store_next;
2434 case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
2435 srr0 = SPR_HSRR0;
2436 srr1 = SPR_HSRR1;
2437 new_msr |= (target_ulong)MSR_HVB;
2438 goto store_next;
2439 case POWERPC_EXCP_HISI: /* Hypervisor instruction storage exception */
2440 srr0 = SPR_HSRR0;
2441 srr1 = SPR_HSRR1;
2442 new_msr |= (target_ulong)MSR_HVB;
2443 goto store_next;
2444 case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
2445 srr0 = SPR_HSRR0;
2446 srr1 = SPR_HSRR1;
2447 new_msr |= (target_ulong)MSR_HVB;
2448 goto store_next;
2449 case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment exception */
2450 srr0 = SPR_HSRR0;
2451 srr1 = SPR_HSRR1;
2452 new_msr |= (target_ulong)MSR_HVB;
2453 goto store_next;
2454 case POWERPC_EXCP_VPU: /* Vector unavailable exception */
2455 new_msr &= ~((target_ulong)1 << MSR_RI);
2456 if (lpes1 == 0)
2457 new_msr |= (target_ulong)MSR_HVB;
2458 goto store_current;
2459 case POWERPC_EXCP_PIT: /* Programmable interval timer interrupt */
2460 #if defined (DEBUG_EXCEPTIONS)
2461 if (loglevel != 0)
2462 fprintf(logfile, "PIT exception\n");
2463 #endif
2464 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2465 goto store_next;
2466 case POWERPC_EXCP_IO: /* IO error exception */
2467 /* XXX: TODO */
2468 cpu_abort(env, "601 IO error exception is not implemented yet !\n");
2469 goto store_next;
2470 case POWERPC_EXCP_RUNM: /* Run mode exception */
2471 /* XXX: TODO */
2472 cpu_abort(env, "601 run mode exception is not implemented yet !\n");
2473 goto store_next;
2474 case POWERPC_EXCP_EMUL: /* Emulation trap exception */
2475 /* XXX: TODO */
2476 cpu_abort(env, "602 emulation trap exception "
2477 "is not implemented yet !\n");
2478 goto store_next;
2479 case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
2480 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2481 if (lpes1 == 0) /* XXX: check this */
2482 new_msr |= (target_ulong)MSR_HVB;
2483 switch (excp_model) {
2484 case POWERPC_EXCP_602:
2485 case POWERPC_EXCP_603:
2486 case POWERPC_EXCP_603E:
2487 case POWERPC_EXCP_G2:
2488 goto tlb_miss_tgpr;
2489 case POWERPC_EXCP_7x5:
2490 goto tlb_miss;
2491 case POWERPC_EXCP_74xx:
2492 goto tlb_miss_74xx;
2493 default:
2494 cpu_abort(env, "Invalid instruction TLB miss exception\n");
2495 break;
2496 }
2497 break;
2498 case POWERPC_EXCP_DLTLB: /* Data load TLB miss */
2499 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2500 if (lpes1 == 0) /* XXX: check this */
2501 new_msr |= (target_ulong)MSR_HVB;
2502 switch (excp_model) {
2503 case POWERPC_EXCP_602:
2504 case POWERPC_EXCP_603:
2505 case POWERPC_EXCP_603E:
2506 case POWERPC_EXCP_G2:
2507 goto tlb_miss_tgpr;
2508 case POWERPC_EXCP_7x5:
2509 goto tlb_miss;
2510 case POWERPC_EXCP_74xx:
2511 goto tlb_miss_74xx;
2512 default:
2513 cpu_abort(env, "Invalid data load TLB miss exception\n");
2514 break;
2515 }
2516 break;
2517 case POWERPC_EXCP_DSTLB: /* Data store TLB miss */
2518 new_msr &= ~((target_ulong)1 << MSR_RI); /* XXX: check this */
2519 if (lpes1 == 0) /* XXX: check this */
2520 new_msr |= (target_ulong)MSR_HVB;
2521 switch (excp_model) {
2522 case POWERPC_EXCP_602:
2523 case POWERPC_EXCP_603:
2524 case POWERPC_EXCP_603E:
2525 case POWERPC_EXCP_G2:
2526 tlb_miss_tgpr:
2527 /* Swap temporary saved registers with GPRs */
2528 if (!(new_msr & ((target_ulong)1 << MSR_TGPR))) {
2529 new_msr |= (target_ulong)1 << MSR_TGPR;
2530 hreg_swap_gpr_tgpr(env);
2531 }
2532 goto tlb_miss;
2533 case POWERPC_EXCP_7x5:
2534 tlb_miss:
2535 #if defined (DEBUG_SOFTWARE_TLB)
2536 if (loglevel != 0) {
2537 const unsigned char *es;
2538 target_ulong *miss, *cmp;
2539 int en;
2540 if (excp == POWERPC_EXCP_IFTLB) {
2541 es = "I";
2542 en = 'I';
2543 miss = &env->spr[SPR_IMISS];
2544 cmp = &env->spr[SPR_ICMP];
2545 } else {
2546 if (excp == POWERPC_EXCP_DLTLB)
2547 es = "DL";
2548 else
2549 es = "DS";
2550 en = 'D';
2551 miss = &env->spr[SPR_DMISS];
2552 cmp = &env->spr[SPR_DCMP];
2553 }
2554 fprintf(logfile, "6xx %sTLB miss: %cM " ADDRX " %cC " ADDRX
2555 " H1 " ADDRX " H2 " ADDRX " %08x\n",
2556 es, en, *miss, en, *cmp,
2557 env->spr[SPR_HASH1], env->spr[SPR_HASH2],
2558 env->error_code);
2559 }
2560 #endif
2561 msr |= env->crf[0] << 28;
2562 msr |= env->error_code; /* key, D/I, S/L bits */
2563 /* Set way using a LRU mechanism */
2564 msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
2565 break;
2566 case POWERPC_EXCP_74xx:
2567 tlb_miss_74xx:
2568 #if defined (DEBUG_SOFTWARE_TLB)
2569 if (loglevel != 0) {
2570 const unsigned char *es;
2571 target_ulong *miss, *cmp;
2572 int en;
2573 if (excp == POWERPC_EXCP_IFTLB) {
2574 es = "I";
2575 en = 'I';
2576 miss = &env->spr[SPR_TLBMISS];
2577 cmp = &env->spr[SPR_PTEHI];
2578 } else {
2579 if (excp == POWERPC_EXCP_DLTLB)
2580 es = "DL";
2581 else
2582 es = "DS";
2583 en = 'D';
2584 miss = &env->spr[SPR_TLBMISS];
2585 cmp = &env->spr[SPR_PTEHI];
2586 }
2587 fprintf(logfile, "74xx %sTLB miss: %cM " ADDRX " %cC " ADDRX
2588 " %08x\n",
2589 es, en, *miss, en, *cmp, env->error_code);
2590 }
2591 #endif
2592 msr |= env->error_code; /* key bit */
2593 break;
2594 default:
2595 cpu_abort(env, "Invalid data store TLB miss exception\n");
2596 break;
2597 }
2598 goto store_next;
2599 case POWERPC_EXCP_FPA: /* Floating-point assist exception */
2600 /* XXX: TODO */
2601 cpu_abort(env, "Floating point assist exception "
2602 "is not implemented yet !\n");
2603 goto store_next;
2604 case POWERPC_EXCP_DABR: /* Data address breakpoint */
2605 /* XXX: TODO */
2606 cpu_abort(env, "DABR exception is not implemented yet !\n");
2607 goto store_next;
2608 case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
2609 /* XXX: TODO */
2610 cpu_abort(env, "IABR exception is not implemented yet !\n");
2611 goto store_next;
2612 case POWERPC_EXCP_SMI: /* System management interrupt */
2613 /* XXX: TODO */
2614 cpu_abort(env, "SMI exception is not implemented yet !\n");
2615 goto store_next;
2616 case POWERPC_EXCP_THERM: /* Thermal interrupt */
2617 /* XXX: TODO */
2618 cpu_abort(env, "Thermal management exception "
2619 "is not implemented yet !\n");
2620 goto store_next;
2621 case POWERPC_EXCP_PERFM: /* Embedded performance monitor interrupt */
2622 new_msr &= ~((target_ulong)1 << MSR_RI);
2623 if (lpes1 == 0)
2624 new_msr |= (target_ulong)MSR_HVB;
2625 /* XXX: TODO */
2626 cpu_abort(env,
2627 "Performance counter exception is not implemented yet !\n");
2628 goto store_next;
2629 case POWERPC_EXCP_VPUA: /* Vector assist exception */
2630 /* XXX: TODO */
2631 cpu_abort(env, "VPU assist exception is not implemented yet !\n");
2632 goto store_next;
2633 case POWERPC_EXCP_SOFTP: /* Soft patch exception */
2634 /* XXX: TODO */
2635 cpu_abort(env,
2636 "970 soft-patch exception is not implemented yet !\n");
2637 goto store_next;
2638 case POWERPC_EXCP_MAINT: /* Maintenance exception */
2639 /* XXX: TODO */
2640 cpu_abort(env,
2641 "970 maintenance exception is not implemented yet !\n");
2642 goto store_next;
2643 case POWERPC_EXCP_MEXTBR: /* Maskable external breakpoint */
2644 /* XXX: TODO */
2645 cpu_abort(env, "Maskable external exception "
2646 "is not implemented yet !\n");
2647 goto store_next;
2648 case POWERPC_EXCP_NMEXTBR: /* Non maskable external breakpoint */
2649 /* XXX: TODO */
2650 cpu_abort(env, "Non maskable external exception "
2651 "is not implemented yet !\n");
2652 goto store_next;
2653 default:
2654 excp_invalid:
2655 cpu_abort(env, "Invalid PowerPC exception %d. Aborting\n", excp);
2656 break;
2657 store_current:
2658 /* save current instruction location */
2659 env->spr[srr0] = env->nip - 4;
2660 break;
2661 store_next:
2662 /* save next instruction location */
2663 env->spr[srr0] = env->nip;
2664 break;
2665 }
2666 /* Save MSR */
2667 env->spr[srr1] = msr;
2668 /* If any alternate SRR register are defined, duplicate saved values */
2669 if (asrr0 != -1)
2670 env->spr[asrr0] = env->spr[srr0];
2671 if (asrr1 != -1)
2672 env->spr[asrr1] = env->spr[srr1];
2673 /* If we disactivated any translation, flush TLBs */
2674 if (new_msr & ((1 << MSR_IR) | (1 << MSR_DR)))
2675 tlb_flush(env, 1);
2676 /* reload MSR with correct bits */
2677 new_msr &= ~((target_ulong)1 << MSR_EE);
2678 new_msr &= ~((target_ulong)1 << MSR_PR);
2679 new_msr &= ~((target_ulong)1 << MSR_FP);
2680 new_msr &= ~((target_ulong)1 << MSR_FE0);
2681 new_msr &= ~((target_ulong)1 << MSR_SE);
2682 new_msr &= ~((target_ulong)1 << MSR_BE);
2683 new_msr &= ~((target_ulong)1 << MSR_FE1);
2684 new_msr &= ~((target_ulong)1 << MSR_IR);
2685 new_msr &= ~((target_ulong)1 << MSR_DR);
2686 #if 0 /* Fix this: not on all targets */
2687 new_msr &= ~((target_ulong)1 << MSR_PMM);
2688 #endif
2689 new_msr &= ~((target_ulong)1 << MSR_LE);
2690 if (msr_ile)
2691 new_msr |= (target_ulong)1 << MSR_LE;
2692 else
2693 new_msr &= ~((target_ulong)1 << MSR_LE);
2694 /* Jump to handler */
2695 vector = env->excp_vectors[excp];
2696 if (vector == (target_ulong)-1ULL) {
2697 cpu_abort(env, "Raised an exception without defined vector %d\n",
2698 excp);
2699 }
2700 vector |= env->excp_prefix;
2701 #if defined(TARGET_PPC64)
2702 if (excp_model == POWERPC_EXCP_BOOKE) {
2703 if (!msr_icm) {
2704 new_msr &= ~((target_ulong)1 << MSR_CM);
2705 vector = (uint32_t)vector;
2706 } else {
2707 new_msr |= (target_ulong)1 << MSR_CM;
2708 }
2709 } else {
2710 if (!msr_isf) {
2711 new_msr &= ~((target_ulong)1 << MSR_SF);
2712 vector = (uint32_t)vector;
2713 } else {
2714 new_msr |= (target_ulong)1 << MSR_SF;
2715 }
2716 }
2717 #endif
2718 /* XXX: we don't use hreg_store_msr here as already have treated
2719 * any special case that could occur. Just store MSR and update hflags
2720 */
2721 env->msr = new_msr & env->msr_mask;
2722 hreg_compute_hflags(env);
2723 env->nip = vector;
2724 /* Reset exception state */
2725 env->exception_index = POWERPC_EXCP_NONE;
2726 env->error_code = 0;
2727 }
2728
2729 void do_interrupt (CPUState *env)
2730 {
2731 powerpc_excp(env, env->excp_model, env->exception_index);
2732 }
2733
2734 void ppc_hw_interrupt (CPUPPCState *env)
2735 {
2736 int hdice;
2737
2738 #if 0
2739 if (loglevel & CPU_LOG_INT) {
2740 fprintf(logfile, "%s: %p pending %08x req %08x me %d ee %d\n",
2741 __func__, env, env->pending_interrupts,
2742 env->interrupt_request, (int)msr_me, (int)msr_ee);
2743 }
2744 #endif
2745 /* External reset */
2746 if (env->pending_interrupts & (1 << PPC_INTERRUPT_RESET)) {
2747 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_RESET);
2748 powerpc_excp(env, env->excp_model, POWERPC_EXCP_RESET);
2749 return;
2750 }
2751 /* Machine check exception */
2752 if (env->pending_interrupts & (1 << PPC_INTERRUPT_MCK)) {
2753 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_MCK);
2754 powerpc_excp(env, env->excp_model, POWERPC_EXCP_MCHECK);
2755 return;
2756 }
2757 #if 0 /* TODO */
2758 /* External debug exception */
2759 if (env->pending_interrupts & (1 << PPC_INTERRUPT_DEBUG)) {
2760 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DEBUG);
2761 powerpc_excp(env, env->excp_model, POWERPC_EXCP_DEBUG);
2762 return;
2763 }
2764 #endif
2765 if (0) {
2766 /* XXX: find a suitable condition to enable the hypervisor mode */
2767 hdice = env->spr[SPR_LPCR] & 1;
2768 } else {
2769 hdice = 0;
2770 }
2771 if ((msr_ee != 0 || msr_hv == 0 || msr_pr != 0) && hdice != 0) {
2772 /* Hypervisor decrementer exception */
2773 if (env->pending_interrupts & (1 << PPC_INTERRUPT_HDECR)) {
2774 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_HDECR);
2775 powerpc_excp(env, env->excp_model, POWERPC_EXCP_HDECR);
2776 return;
2777 }
2778 }
2779 if (msr_ce != 0) {
2780 /* External critical interrupt */
2781 if (env->pending_interrupts & (1 << PPC_INTERRUPT_CEXT)) {
2782 /* Taking a critical external interrupt does not clear the external
2783 * critical interrupt status
2784 */
2785 #if 0
2786 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_CEXT);
2787 #endif
2788 powerpc_excp(env, env->excp_model, POWERPC_EXCP_CRITICAL);
2789 return;
2790 }
2791 }
2792 if (msr_ee != 0) {
2793 /* Watchdog timer on embedded PowerPC */
2794 if (env->pending_interrupts & (1 << PPC_INTERRUPT_WDT)) {
2795 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_WDT);
2796 powerpc_excp(env, env->excp_model, POWERPC_EXCP_WDT);
2797 return;
2798 }
2799 if (env->pending_interrupts & (1 << PPC_INTERRUPT_CDOORBELL)) {
2800 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_CDOORBELL);
2801 powerpc_excp(env, env->excp_model, POWERPC_EXCP_DOORCI);
2802 return;
2803 }
2804 /* Fixed interval timer on embedded PowerPC */
2805 if (env->pending_interrupts & (1 << PPC_INTERRUPT_FIT)) {
2806 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_FIT);
2807 powerpc_excp(env, env->excp_model, POWERPC_EXCP_FIT);
2808 return;
2809 }
2810 /* Programmable interval timer on embedded PowerPC */
2811 if (env->pending_interrupts & (1 << PPC_INTERRUPT_PIT)) {
2812 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PIT);
2813 powerpc_excp(env, env->excp_model, POWERPC_EXCP_PIT);
2814 return;
2815 }
2816 /* Decrementer exception */
2817 if (env->pending_interrupts & (1 << PPC_INTERRUPT_DECR)) {
2818 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DECR);
2819 powerpc_excp(env, env->excp_model, POWERPC_EXCP_DECR);
2820 return;
2821 }
2822 /* External interrupt */
2823 if (env->pending_interrupts & (1 << PPC_INTERRUPT_EXT)) {
2824 /* Taking an external interrupt does not clear the external
2825 * interrupt status
2826 */
2827 #if 0
2828 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_EXT);
2829 #endif
2830 powerpc_excp(env, env->excp_model, POWERPC_EXCP_EXTERNAL);
2831 return;
2832 }
2833 if (env->pending_interrupts & (1 << PPC_INTERRUPT_DOORBELL)) {
2834 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DOORBELL);
2835 powerpc_excp(env, env->excp_model, POWERPC_EXCP_DOORI);
2836 return;
2837 }
2838 if (env->pending_interrupts & (1 << PPC_INTERRUPT_PERFM)) {
2839 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PERFM);
2840 powerpc_excp(env, env->excp_model, POWERPC_EXCP_PERFM);
2841 return;
2842 }
2843 /* Thermal interrupt */
2844 if (env->pending_interrupts & (1 << PPC_INTERRUPT_THERM)) {
2845 env->pending_interrupts &= ~(1 << PPC_INTERRUPT_THERM);
2846 powerpc_excp(env, env->excp_model, POWERPC_EXCP_THERM);
2847 return;
2848 }
2849 }
2850 }
2851 #endif /* !CONFIG_USER_ONLY */
2852
2853 void cpu_dump_rfi (target_ulong RA, target_ulong msr)
2854 {
2855 FILE *f;
2856
2857 if (logfile) {
2858 f = logfile;
2859 } else {
2860 f = stdout;
2861 return;
2862 }
2863 fprintf(f, "Return from exception at " ADDRX " with flags " ADDRX "\n",
2864 RA, msr);
2865 }
2866
2867 void cpu_ppc_reset (void *opaque)
2868 {
2869 CPUPPCState *env;
2870 target_ulong msr;
2871
2872 env = opaque;
2873 msr = (target_ulong)0;
2874 if (0) {
2875 /* XXX: find a suitable condition to enable the hypervisor mode */
2876 msr |= (target_ulong)MSR_HVB;
2877 }
2878 msr |= (target_ulong)0 << MSR_AP; /* TO BE CHECKED */
2879 msr |= (target_ulong)0 << MSR_SA; /* TO BE CHECKED */
2880 msr |= (target_ulong)1 << MSR_EP;
2881 #if defined (DO_SINGLE_STEP) && 0
2882 /* Single step trace mode */
2883 msr |= (target_ulong)1 << MSR_SE;
2884 msr |= (target_ulong)1 << MSR_BE;
2885 #endif
2886 #if defined(CONFIG_USER_ONLY)
2887 msr |= (target_ulong)1 << MSR_FP; /* Allow floating point usage */
2888 msr |= (target_ulong)1 << MSR_VR; /* Allow altivec usage */
2889 msr |= (target_ulong)1 << MSR_SPE; /* Allow SPE usage */
2890 msr |= (target_ulong)1 << MSR_PR;
2891 env->msr = msr & env->msr_mask;
2892 #else
2893 env->nip = env->hreset_vector | env->excp_prefix;
2894 if (env->mmu_model != POWERPC_MMU_REAL)
2895 ppc_tlb_invalidate_all(env);
2896 #endif
2897 hreg_compute_hflags(env);
2898 env->reserve = (target_ulong)-1ULL;
2899 /* Be sure no exception or interrupt is pending */
2900 env->pending_interrupts = 0;
2901 env->exception_index = POWERPC_EXCP_NONE;
2902 env->error_code = 0;
2903 /* Flush all TLBs */
2904 tlb_flush(env, 1);
2905 }
2906
2907 CPUPPCState *cpu_ppc_init (const char *cpu_model)
2908 {
2909 CPUPPCState *env;
2910 const ppc_def_t *def;
2911
2912 def = cpu_ppc_find_by_name(cpu_model);
2913 if (!def)
2914 return NULL;
2915
2916 env = qemu_mallocz(sizeof(CPUPPCState));
2917 if (!env)
2918 return NULL;
2919 cpu_exec_init(env);
2920 ppc_translate_init();
2921 env->cpu_model_str = cpu_model;
2922 cpu_ppc_register_internal(env, def);
2923 cpu_ppc_reset(env);
2924
2925 if (kvm_enabled())
2926 kvm_init_vcpu(env);
2927
2928 return env;
2929 }
2930
2931 void cpu_ppc_close (CPUPPCState *env)
2932 {
2933 /* Should also remove all opcode tables... */
2934 qemu_free(env);
2935 }
qemu linux-user patches