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