git.maemo.org Git - qemu/blob - target-ppc/helper.c

   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
  31 //#define DEBUG_MMU
  32 //#define DEBUG_BATS
  33 //#define DEBUG_SOFTWARE_TLB
  34 //#define DEBUG_EXCEPTIONS
  35 //#define FLUSH_ALL_TLBS
  36
  37 /*****************************************************************************/
  38 /* PowerPC MMU emulation */
  39
  40 #if defined(CONFIG_USER_ONLY)
  41 int cpu_ppc_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
  42                               int is_user, int is_softmmu)
  43 {
  44     int exception, error_code;
  45
  46     if (rw == 2) {
  47         exception = EXCP_ISI;
  48         error_code = 0;
  49     } else {
  50         exception = EXCP_DSI;
  51         error_code = 0;
  52         if (rw)
  53             error_code |= 0x02000000;
  54         env->spr[SPR_DAR] = address;
  55         env->spr[SPR_DSISR] = error_code;
  56     }
  57     env->exception_index = exception;
  58     env->error_code = error_code;
  59
  60     return 1;
  61 }
  62
  63 target_phys_addr_t cpu_get_phys_page_debug (CPUState *env, target_ulong addr)
  64 {
  65     return addr;
  66 }
  67
  68 #else
  69 /* Common routines used by software and hardware TLBs emulation */
  70 static inline int pte_is_valid (target_ulong pte0)
  71 {
  72     return pte0 & 0x80000000 ? 1 : 0;
  73 }
  74
  75 static inline void pte_invalidate (target_ulong *pte0)
  76 {
  77     *pte0 &= ~0x80000000;
  78 }
  79
  80 #if defined(TARGET_PPC64)
  81 static inline int pte64_is_valid (target_ulong pte0)
  82 {
  83     return pte0 & 0x0000000000000001ULL ? 1 : 0;
  84 }
  85
  86 static inline void pte64_invalidate (target_ulong *pte0)
  87 {
  88     *pte0 &= ~0x0000000000000001ULL;
  89 }
  90 #endif
  91
  92 #define PTE_PTEM_MASK 0x7FFFFFBF
  93 #define PTE_CHECK_MASK (TARGET_PAGE_MASK | 0x7B)
  94 #if defined(TARGET_PPC64)
  95 #define PTE64_PTEM_MASK 0xFFFFFFFFFFFFFF80ULL
  96 #define PTE64_CHECK_MASK (TARGET_PAGE_MASK | 0x7F)
  97 #endif
  98
  99 static inline int _pte_check (mmu_ctx_t *ctx, int is_64b,
 100                               target_ulong pte0, target_ulong pte1,
 101                               int h, int rw)
 102 {
 103     target_ulong ptem, mmask;
 104     int access, ret, pteh, ptev;
 105
 106     access = 0;
 107     ret = -1;
 108     /* Check validity and table match */
 109 #if defined(TARGET_PPC64)
 110     if (is_64b) {
 111         ptev = pte64_is_valid(pte0);
 112         pteh = (pte0 >> 1) & 1;
 113     } else
 114 #endif
 115     {
 116         ptev = pte_is_valid(pte0);
 117         pteh = (pte0 >> 6) & 1;
 118     }
 119     if (ptev && h == pteh) {
 120         /* Check vsid & api */
 121 #if defined(TARGET_PPC64)
 122         if (is_64b) {
 123             ptem = pte0 & PTE64_PTEM_MASK;
 124             mmask = PTE64_CHECK_MASK;
 125         } else
 126 #endif
 127         {
 128             ptem = pte0 & PTE_PTEM_MASK;
 129             mmask = PTE_CHECK_MASK;
 130         }
 131         if (ptem == ctx->ptem) {
 132             if (ctx->raddr != (target_ulong)-1) {
 133                 /* all matches should have equal RPN, WIMG & PP */
 134                 if ((ctx->raddr & mmask) != (pte1 & mmask)) {
 135                     if (loglevel != 0)
 136                         fprintf(logfile, "Bad RPN/WIMG/PP\n");
 137                     return -3;
 138                 }
 139             }
 140             /* Compute access rights */
 141             if (ctx->key == 0) {
 142                 access = PAGE_READ;
 143                 if ((pte1 & 0x00000003) != 0x3)
 144                     access |= PAGE_WRITE;
 145             } else {
 146                 switch (pte1 & 0x00000003) {
 147                 case 0x0:
 148                     access = 0;
 149                     break;
 150                 case 0x1:
 151                 case 0x3:
 152                     access = PAGE_READ;
 153                     break;
 154                 case 0x2:
 155                     access = PAGE_READ | PAGE_WRITE;
 156                     break;
 157                 }
 158             }
 159             /* Keep the matching PTE informations */
 160             ctx->raddr = pte1;
 161             ctx->prot = access;
 162             if ((rw == 0 && (access & PAGE_READ)) ||
 163                 (rw == 1 && (access & PAGE_WRITE))) {
 164                 /* Access granted */
 165 #if defined (DEBUG_MMU)
 166                 if (loglevel != 0)
 167                     fprintf(logfile, "PTE access granted !\n");
 168 #endif
 169                 ret = 0;
 170             } else {
 171                 /* Access right violation */
 172 #if defined (DEBUG_MMU)
 173                 if (loglevel != 0)
 174                     fprintf(logfile, "PTE access rejected\n");
 175 #endif
 176                 ret = -2;
 177             }
 178         }
 179     }
 180
 181     return ret;
 182 }
 183
 184 static int pte32_check (mmu_ctx_t *ctx,
 185                         target_ulong pte0, target_ulong pte1, int h, int rw)
 186 {
 187     return _pte_check(ctx, 0, pte0, pte1, h, rw);
 188 }
 189
 190 #if defined(TARGET_PPC64)
 191 static int pte64_check (mmu_ctx_t *ctx,
 192                         target_ulong pte0, target_ulong pte1, int h, int rw)
 193 {
 194     return _pte_check(ctx, 1, pte0, pte1, h, rw);
 195 }
 196 #endif
 197
 198 static int pte_update_flags (mmu_ctx_t *ctx, target_ulong *pte1p,
 199                              int ret, int rw)
 200 {
 201     int store = 0;
 202
 203     /* Update page flags */
 204     if (!(*pte1p & 0x00000100)) {
 205         /* Update accessed flag */
 206         *pte1p |= 0x00000100;
 207         store = 1;
 208     }
 209     if (!(*pte1p & 0x00000080)) {
 210         if (rw == 1 && ret == 0) {
 211             /* Update changed flag */
 212             *pte1p |= 0x00000080;
 213             store = 1;
 214         } else {
 215             /* Force page fault for first write access */
 216             ctx->prot &= ~PAGE_WRITE;
 217         }
 218     }
 219
 220     return store;
 221 }
 222
 223 /* Software driven TLB helpers */
 224 static int ppc6xx_tlb_getnum (CPUState *env, target_ulong eaddr,
 225                               int way, int is_code)
 226 {
 227     int nr;
 228
 229     /* Select TLB num in a way from address */
 230     nr = (eaddr >> TARGET_PAGE_BITS) & (env->tlb_per_way - 1);
 231     /* Select TLB way */
 232     nr += env->tlb_per_way * way;
 233     /* 6xx have separate TLBs for instructions and data */
 234     if (is_code && env->id_tlbs == 1)
 235         nr += env->nb_tlb;
 236
 237     return nr;
 238 }
 239
 240 void ppc6xx_tlb_invalidate_all (CPUState *env)
 241 {
 242     ppc6xx_tlb_t *tlb;
 243     int nr, max;
 244
 245 #if defined (DEBUG_SOFTWARE_TLB) && 0
 246     if (loglevel != 0) {
 247         fprintf(logfile, "Invalidate all TLBs\n");
 248     }
 249 #endif
 250     /* Invalidate all defined software TLB */
 251     max = env->nb_tlb;
 252     if (env->id_tlbs == 1)
 253         max *= 2;
 254     for (nr = 0; nr < max; nr++) {
 255         tlb = &env->tlb[nr].tlb6;
 256 #if !defined(FLUSH_ALL_TLBS)
 257         tlb_flush_page(env, tlb->EPN);
 258 #endif
 259         pte_invalidate(&tlb->pte0);
 260     }
 261 #if defined(FLUSH_ALL_TLBS)
 262     tlb_flush(env, 1);
 263 #endif
 264 }
 265
 266 static inline void __ppc6xx_tlb_invalidate_virt (CPUState *env,
 267                                                  target_ulong eaddr,
 268                                                  int is_code, int match_epn)
 269 {
 270 #if !defined(FLUSH_ALL_TLBS)
 271     ppc6xx_tlb_t *tlb;
 272     int way, nr;
 273
 274     /* Invalidate ITLB + DTLB, all ways */
 275     for (way = 0; way < env->nb_ways; way++) {
 276         nr = ppc6xx_tlb_getnum(env, eaddr, way, is_code);
 277         tlb = &env->tlb[nr].tlb6;
 278         if (pte_is_valid(tlb->pte0) && (match_epn == 0 || eaddr == tlb->EPN)) {
 279 #if defined (DEBUG_SOFTWARE_TLB)
 280             if (loglevel != 0) {
 281                 fprintf(logfile, "TLB invalidate %d/%d " ADDRX "\n",
 282                         nr, env->nb_tlb, eaddr);
 283             }
 284 #endif
 285             pte_invalidate(&tlb->pte0);
 286             tlb_flush_page(env, tlb->EPN);
 287         }
 288     }
 289 #else
 290     /* XXX: PowerPC specification say this is valid as well */
 291     ppc6xx_tlb_invalidate_all(env);
 292 #endif
 293 }
 294
 295 void ppc6xx_tlb_invalidate_virt (CPUState *env, target_ulong eaddr,
 296                                  int is_code)
 297 {
 298     __ppc6xx_tlb_invalidate_virt(env, eaddr, is_code, 0);
 299 }
 300
 301 void ppc6xx_tlb_store (CPUState *env, target_ulong EPN, int way, int is_code,
 302                        target_ulong pte0, target_ulong pte1)
 303 {
 304     ppc6xx_tlb_t *tlb;
 305     int nr;
 306
 307     nr = ppc6xx_tlb_getnum(env, EPN, way, is_code);
 308     tlb = &env->tlb[nr].tlb6;
 309 #if defined (DEBUG_SOFTWARE_TLB)
 310     if (loglevel != 0) {
 311         fprintf(logfile, "Set TLB %d/%d EPN " ADDRX " PTE0 " ADDRX
 312                 " PTE1 " ADDRX "\n", nr, env->nb_tlb, EPN, pte0, pte1);
 313     }
 314 #endif
 315     /* Invalidate any pending reference in Qemu for this virtual address */
 316     __ppc6xx_tlb_invalidate_virt(env, EPN, is_code, 1);
 317     tlb->pte0 = pte0;
 318     tlb->pte1 = pte1;
 319     tlb->EPN = EPN;
 320     /* Store last way for LRU mechanism */
 321     env->last_way = way;
 322 }
 323
 324 static int ppc6xx_tlb_check (CPUState *env, mmu_ctx_t *ctx,
 325                              target_ulong eaddr, int rw, int access_type)
 326 {
 327     ppc6xx_tlb_t *tlb;
 328     int nr, best, way;
 329     int ret;
 330
 331     best = -1;
 332     ret = -1; /* No TLB found */
 333     for (way = 0; way < env->nb_ways; way++) {
 334         nr = ppc6xx_tlb_getnum(env, eaddr, way,
 335                                access_type == ACCESS_CODE ? 1 : 0);
 336         tlb = &env->tlb[nr].tlb6;
 337         /* This test "emulates" the PTE index match for hardware TLBs */
 338         if ((eaddr & TARGET_PAGE_MASK) != tlb->EPN) {
 339 #if defined (DEBUG_SOFTWARE_TLB)
 340             if (loglevel != 0) {
 341                 fprintf(logfile, "TLB %d/%d %s [" ADDRX " " ADDRX
 342                         "] <> " ADDRX "\n",
 343                         nr, env->nb_tlb,
 344                         pte_is_valid(tlb->pte0) ? "valid" : "inval",
 345                         tlb->EPN, tlb->EPN + TARGET_PAGE_SIZE, eaddr);
 346             }
 347 #endif
 348             continue;
 349         }
 350 #if defined (DEBUG_SOFTWARE_TLB)
 351         if (loglevel != 0) {
 352             fprintf(logfile, "TLB %d/%d %s " ADDRX " <> " ADDRX " " ADDRX
 353                     " %c %c\n",
 354                     nr, env->nb_tlb,
 355                     pte_is_valid(tlb->pte0) ? "valid" : "inval",
 356                     tlb->EPN, eaddr, tlb->pte1,
 357                     rw ? 'S' : 'L', access_type == ACCESS_CODE ? 'I' : 'D');
 358         }
 359 #endif
 360         switch (pte32_check(ctx, tlb->pte0, tlb->pte1, 0, rw)) {
 361         case -3:
 362             /* TLB inconsistency */
 363             return -1;
 364         case -2:
 365             /* Access violation */
 366             ret = -2;
 367             best = nr;
 368             break;
 369         case -1:
 370         default:
 371             /* No match */
 372             break;
 373         case 0:
 374             /* access granted */
 375             /* XXX: we should go on looping to check all TLBs consistency
 376              *      but we can speed-up the whole thing as the
 377              *      result would be undefined if TLBs are not consistent.
 378              */
 379             ret = 0;
 380             best = nr;
 381             goto done;
 382         }
 383     }
 384     if (best != -1) {
 385     done:
 386 #if defined (DEBUG_SOFTWARE_TLB)
 387         if (loglevel != 0) {
 388             fprintf(logfile, "found TLB at addr 0x%08lx prot=0x%01x ret=%d\n",
 389                     ctx->raddr & TARGET_PAGE_MASK, ctx->prot, ret);
 390         }
 391 #endif
 392         /* Update page flags */
 393         pte_update_flags(ctx, &env->tlb[best].tlb6.pte1, ret, rw);
 394     }
 395
 396     return ret;
 397 }
 398
 399 /* Perform BAT hit & translation */
 400 static int get_bat (CPUState *env, mmu_ctx_t *ctx,
 401                     target_ulong virtual, int rw, int type)
 402 {
 403     target_ulong *BATlt, *BATut, *BATu, *BATl;
 404     target_ulong base, BEPIl, BEPIu, bl;
 405     int i;
 406     int ret = -1;
 407
 408 #if defined (DEBUG_BATS)
 409     if (loglevel != 0) {
 410         fprintf(logfile, "%s: %cBAT v 0x" ADDRX "\n", __func__,
 411                 type == ACCESS_CODE ? 'I' : 'D', virtual);
 412     }
 413 #endif
 414     switch (type) {
 415     case ACCESS_CODE:
 416         BATlt = env->IBAT[1];
 417         BATut = env->IBAT[0];
 418         break;
 419     default:
 420         BATlt = env->DBAT[1];
 421         BATut = env->DBAT[0];
 422         break;
 423     }
 424 #if defined (DEBUG_BATS)
 425     if (loglevel != 0) {
 426         fprintf(logfile, "%s...: %cBAT v 0x" ADDRX "\n", __func__,
 427                 type == ACCESS_CODE ? 'I' : 'D', virtual);
 428     }
 429 #endif
 430     base = virtual & 0xFFFC0000;
 431     for (i = 0; i < 4; i++) {
 432         BATu = &BATut[i];
 433         BATl = &BATlt[i];
 434         BEPIu = *BATu & 0xF0000000;
 435         BEPIl = *BATu & 0x0FFE0000;
 436         bl = (*BATu & 0x00001FFC) << 15;
 437 #if defined (DEBUG_BATS)
 438         if (loglevel != 0) {
 439             fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
 440                     " BATl 0x" ADDRX "\n",
 441                     __func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
 442                     *BATu, *BATl);
 443         }
 444 #endif
 445         if ((virtual & 0xF0000000) == BEPIu &&
 446             ((virtual & 0x0FFE0000) & ~bl) == BEPIl) {
 447             /* BAT matches */
 448             if ((msr_pr == 0 && (*BATu & 0x00000002)) ||
 449                 (msr_pr == 1 && (*BATu & 0x00000001))) {
 450                 /* Get physical address */
 451                 ctx->raddr = (*BATl & 0xF0000000) |
 452                     ((virtual & 0x0FFE0000 & bl) | (*BATl & 0x0FFE0000)) |
 453                     (virtual & 0x0001F000);
 454                 if (*BATl & 0x00000001)
 455                     ctx->prot = PAGE_READ;
 456                 if (*BATl & 0x00000002)
 457                     ctx->prot = PAGE_WRITE | PAGE_READ;
 458 #if defined (DEBUG_BATS)
 459                 if (loglevel != 0) {
 460                     fprintf(logfile, "BAT %d match: r 0x" PADDRX
 461                             " prot=%c%c\n",
 462                             i, ctx->raddr, ctx->prot & PAGE_READ ? 'R' : '-',
 463                             ctx->prot & PAGE_WRITE ? 'W' : '-');
 464                 }
 465 #endif
 466                 ret = 0;
 467                 break;
 468             }
 469         }
 470     }
 471     if (ret < 0) {
 472 #if defined (DEBUG_BATS)
 473         if (loglevel != 0) {
 474             fprintf(logfile, "no BAT match for 0x" ADDRX ":\n", virtual);
 475             for (i = 0; i < 4; i++) {
 476                 BATu = &BATut[i];
 477                 BATl = &BATlt[i];
 478                 BEPIu = *BATu & 0xF0000000;
 479                 BEPIl = *BATu & 0x0FFE0000;
 480                 bl = (*BATu & 0x00001FFC) << 15;
 481                 fprintf(logfile, "%s: %cBAT%d v 0x" ADDRX " BATu 0x" ADDRX
 482                         " BATl 0x" ADDRX " \n\t"
 483                         "0x" ADDRX " 0x" ADDRX " 0x" ADDRX "\n",
 484                         __func__, type == ACCESS_CODE ? 'I' : 'D', i, virtual,
 485                         *BATu, *BATl, BEPIu, BEPIl, bl);
 486             }
 487         }
 488 #endif
 489     }
 490     /* No hit */
 491     return ret;
 492 }
 493
 494 /* PTE table lookup */
 495 static inline int _find_pte (mmu_ctx_t *ctx, int is_64b, int h, int rw)
 496 {
 497     target_ulong base, pte0, pte1;
 498     int i, good = -1;
 499     int ret, r;
 500
 501     ret = -1; /* No entry found */
 502     base = ctx->pg_addr[h];
 503     for (i = 0; i < 8; i++) {
 504 #if defined(TARGET_PPC64)
 505         if (is_64b) {
 506             pte0 = ldq_phys(base + (i * 16));
 507             pte1 =  ldq_phys(base + (i * 16) + 8);
 508             r = pte64_check(ctx, pte0, pte1, h, rw);
 509         } else
 510 #endif
 511         {
 512             pte0 = ldl_phys(base + (i * 8));
 513             pte1 =  ldl_phys(base + (i * 8) + 4);
 514             r = pte32_check(ctx, pte0, pte1, h, rw);
 515         }
 516 #if defined (DEBUG_MMU)
 517         if (loglevel != 0) {
 518             fprintf(logfile, "Load pte from 0x" ADDRX " => 0x" ADDRX
 519                     " 0x" ADDRX " %d %d %d 0x" ADDRX "\n",
 520                     base + (i * 8), pte0, pte1,
 521                     (int)(pte0 >> 31), h, (int)((pte0 >> 6) & 1), ctx->ptem);
 522         }
 523 #endif
 524         switch (r) {
 525         case -3:
 526             /* PTE inconsistency */
 527             return -1;
 528         case -2:
 529             /* Access violation */
 530             ret = -2;
 531             good = i;
 532             break;
 533         case -1:
 534         default:
 535             /* No PTE match */
 536             break;
 537         case 0:
 538             /* access granted */
 539             /* XXX: we should go on looping to check all PTEs consistency
 540              *      but if we can speed-up the whole thing as the
 541              *      result would be undefined if PTEs are not consistent.
 542              */
 543             ret = 0;
 544             good = i;
 545             goto done;
 546         }
 547     }
 548     if (good != -1) {
 549     done:
 550 #if defined (DEBUG_MMU)
 551         if (loglevel != 0) {
 552             fprintf(logfile, "found PTE at addr 0x" PADDRX " prot=0x%01x "
 553                     "ret=%d\n",
 554                     ctx->raddr, ctx->prot, ret);
 555         }
 556 #endif
 557         /* Update page flags */
 558         pte1 = ctx->raddr;
 559         if (pte_update_flags(ctx, &pte1, ret, rw) == 1) {
 560 #if defined(TARGET_PPC64)
 561             if (is_64b) {
 562                 stq_phys_notdirty(base + (good * 16) + 8, pte1);
 563             } else
 564 #endif
 565             {
 566                 stl_phys_notdirty(base + (good * 8) + 4, pte1);
 567             }
 568         }
 569     }
 570
 571     return ret;
 572 }
 573
 574 static int find_pte32 (mmu_ctx_t *ctx, int h, int rw)
 575 {
 576     return _find_pte(ctx, 0, h, rw);
 577 }
 578
 579 #if defined(TARGET_PPC64)
 580 static int find_pte64 (mmu_ctx_t *ctx, int h, int rw)
 581 {
 582     return _find_pte(ctx, 1, h, rw);
 583 }
 584 #endif
 585
 586 static inline int find_pte (CPUState *env, mmu_ctx_t *ctx, int h, int rw)
 587 {
 588 #if defined(TARGET_PPC64)
 589     if (PPC_MMU(env) == PPC_FLAGS_MMU_64B ||
 590         PPC_MMU(env) == PPC_FLAGS_MMU_64BRIDGE)
 591         return find_pte64(ctx, h, rw);
 592 #endif
 593
 594     return find_pte32(ctx, h, rw);
 595 }
 596
 597 static inline target_phys_addr_t get_pgaddr (target_phys_addr_t sdr1,
 598                                              int sdr_sh,
 599                                              target_phys_addr_t hash,
 600                                              target_phys_addr_t mask)
 601 {
 602     return (sdr1 & ((target_ulong)(-1ULL) << sdr_sh)) | (hash & mask);
 603 }
 604
 605 #if defined(TARGET_PPC64)
 606 static int slb_lookup (CPUState *env, target_ulong eaddr,
 607                        target_ulong *vsid, target_ulong *page_mask, int *attr)
 608 {
 609     target_phys_addr_t sr_base;
 610     target_ulong mask;
 611     uint64_t tmp64;
 612     uint32_t tmp;
 613     int n, ret;
 614     int slb_nr;
 615
 616     ret = -5;
 617     sr_base = env->spr[SPR_ASR];
 618     mask = 0x0000000000000000ULL; /* Avoid gcc warning */
 619 #if 0 /* XXX: Fix this */
 620     slb_nr = env->slb_nr;
 621 #else
 622     slb_nr = 32;
 623 #endif
 624     for (n = 0; n < slb_nr; n++) {
 625         tmp64 = ldq_phys(sr_base);
 626         if (tmp64 & 0x0000000008000000ULL) {
 627             /* SLB entry is valid */
 628             switch (tmp64 & 0x0000000006000000ULL) {
 629             case 0x0000000000000000ULL:
 630                 /* 256 MB segment */
 631                 mask = 0xFFFFFFFFF0000000ULL;
 632                 break;
 633             case 0x0000000002000000ULL:
 634                 /* 1 TB segment */
 635                 mask = 0xFFFF000000000000ULL;
 636                 break;
 637             case 0x0000000004000000ULL:
 638             case 0x0000000006000000ULL:
 639                 /* Reserved => segment is invalid */
 640                 continue;
 641             }
 642             if ((eaddr & mask) == (tmp64 & mask)) {
 643                 /* SLB match */
 644                 tmp = ldl_phys(sr_base + 8);
 645                 *vsid = ((tmp64 << 24) | (tmp >> 8)) & 0x0003FFFFFFFFFFFFULL;
 646                 *page_mask = ~mask;
 647                 *attr = tmp & 0xFF;
 648                 ret = 0;
 649                 break;
 650             }
 651         }
 652         sr_base += 12;
 653     }
 654
 655     return ret;
 656 }
 657 #endif /* defined(TARGET_PPC64) */
 658
 659 /* Perform segment based translation */
 660 static int get_segment (CPUState *env, mmu_ctx_t *ctx,
 661                         target_ulong eaddr, int rw, int type)
 662 {
 663     target_phys_addr_t sdr, hash, mask, sdr_mask;
 664     target_ulong sr, vsid, vsid_mask, pgidx, page_mask;
 665 #if defined(TARGET_PPC64)
 666     int attr;
 667 #endif
 668     int ds, nx, vsid_sh, sdr_sh;
 669     int ret, ret2;
 670
 671 #if defined(TARGET_PPC64)
 672     if (PPC_MMU(env) == PPC_FLAGS_MMU_64B) {
 673         ret = slb_lookup(env, eaddr, &vsid, &page_mask, &attr);
 674         if (ret < 0)
 675             return ret;
 676         ctx->key = ((attr & 0x40) && msr_pr == 1) ||
 677             ((attr & 0x80) && msr_pr == 0) ? 1 : 0;
 678         ds = 0;
 679         nx = attr & 0x20 ? 1 : 0;
 680         vsid_mask = 0x00003FFFFFFFFF80ULL;
 681         vsid_sh = 7;
 682         sdr_sh = 18;
 683         sdr_mask = 0x3FF80;
 684     } else
 685 #endif /* defined(TARGET_PPC64) */
 686     {
 687         sr = env->sr[eaddr >> 28];
 688         page_mask = 0x0FFFFFFF;
 689         ctx->key = (((sr & 0x20000000) && msr_pr == 1) ||
 690                     ((sr & 0x40000000) && msr_pr == 0)) ? 1 : 0;
 691         ds = sr & 0x80000000 ? 1 : 0;
 692         nx = sr & 0x10000000 ? 1 : 0;
 693         vsid = sr & 0x00FFFFFF;
 694         vsid_mask = 0x01FFFFC0;
 695         vsid_sh = 6;
 696         sdr_sh = 16;
 697         sdr_mask = 0xFFC0;
 698 #if defined (DEBUG_MMU)
 699         if (loglevel != 0) {
 700             fprintf(logfile, "Check segment v=0x" ADDRX " %d 0x" ADDRX
 701                     " nip=0x" ADDRX " lr=0x" ADDRX
 702                     " ir=%d dr=%d pr=%d %d t=%d\n",
 703                     eaddr, (int)(eaddr >> 28), sr, env->nip,
 704                     env->lr, msr_ir, msr_dr, msr_pr, rw, type);
 705         }
 706         if (!ds && loglevel != 0) {
 707             fprintf(logfile, "pte segment: key=%d n=0x" ADDRX "\n",
 708                     ctx->key, sr & 0x10000000);
 709         }
 710 #endif
 711     }
 712     ret = -1;
 713     if (!ds) {
 714         /* Check if instruction fetch is allowed, if needed */
 715         if (type != ACCESS_CODE || nx == 0) {
 716             /* Page address translation */
 717             pgidx = (eaddr & page_mask) >> TARGET_PAGE_BITS;
 718             hash = ((vsid ^ pgidx) << vsid_sh) & vsid_mask;
 719             /* Primary table address */
 720             sdr = env->sdr1;
 721             mask = ((sdr & 0x000001FF) << sdr_sh) | sdr_mask;
 722             ctx->pg_addr[0] = get_pgaddr(sdr, sdr_sh, hash, mask);
 723             /* Secondary table address */
 724             hash = (~hash) & vsid_mask;
 725             ctx->pg_addr[1] = get_pgaddr(sdr, sdr_sh, hash, mask);
 726 #if defined(TARGET_PPC64)
 727             if (PPC_MMU(env) == PPC_FLAGS_MMU_64B ||
 728                 PPC_MMU(env) == PPC_FLAGS_MMU_64BRIDGE) {
 729                 /* Only 5 bits of the page index are used in the AVPN */
 730                 ctx->ptem = (vsid << 12) | ((pgidx >> 4) & 0x0F80);
 731             } else
 732 #endif
 733             {
 734                 ctx->ptem = (vsid << 7) | (pgidx >> 10);
 735             }
 736             /* Initialize real address with an invalid value */
 737             ctx->raddr = (target_ulong)-1;
 738             if (unlikely(PPC_MMU(env) == PPC_FLAGS_MMU_SOFT_6xx)) {
 739                 /* Software TLB search */
 740                 ret = ppc6xx_tlb_check(env, ctx, eaddr, rw, type);
 741             } else {
 742 #if defined (DEBUG_MMU)
 743                 if (loglevel != 0) {
 744                     fprintf(logfile, "0 sdr1=0x" PADDRX " vsid=0x%06x "
 745                             "api=0x%04x hash=0x%07x pg_addr=0x" PADDRX "\n",
 746                             sdr, (uint32_t)vsid, (uint32_t)pgidx,
 747                             (uint32_t)hash, ctx->pg_addr[0]);
 748                 }
 749 #endif
 750                 /* Primary table lookup */
 751                 ret = find_pte(env, ctx, 0, rw);
 752                 if (ret < 0) {
 753                     /* Secondary table lookup */
 754 #if defined (DEBUG_MMU)
 755                     if (eaddr != 0xEFFFFFFF && loglevel != 0) {
 756                         fprintf(logfile,
 757                                 "1 sdr1=0x" PADDRX " vsid=0x%06x api=0x%04x "
 758                                 "hash=0x%05x pg_addr=0x" PADDRX "\n",
 759                                 sdr, (uint32_t)vsid, (uint32_t)pgidx,
 760                                 (uint32_t)hash, ctx->pg_addr[1]);
 761                     }
 762 #endif
 763                     ret2 = find_pte(env, ctx, 1, rw);
 764                     if (ret2 != -1)
 765                         ret = ret2;
 766                 }
 767             }
 768         } else {
 769 #if defined (DEBUG_MMU)
 770             if (loglevel != 0)
 771                 fprintf(logfile, "No access allowed\n");
 772 #endif
 773             ret = -3;
 774         }
 775     } else {
 776 #if defined (DEBUG_MMU)
 777         if (loglevel != 0)
 778             fprintf(logfile, "direct store...\n");
 779 #endif
 780         /* Direct-store segment : absolutely *BUGGY* for now */
 781         switch (type) {
 782         case ACCESS_INT:
 783             /* Integer load/store : only access allowed */
 784             break;
 785         case ACCESS_CODE:
 786             /* No code fetch is allowed in direct-store areas */
 787             return -4;
 788         case ACCESS_FLOAT:
 789             /* Floating point load/store */
 790             return -4;
 791         case ACCESS_RES:
 792             /* lwarx, ldarx or srwcx. */
 793             return -4;
 794         case ACCESS_CACHE:
 795             /* dcba, dcbt, dcbtst, dcbf, dcbi, dcbst, dcbz, or icbi */
 796             /* Should make the instruction do no-op.
 797              * As it already do no-op, it's quite easy :-)
 798              */
 799             ctx->raddr = eaddr;
 800             return 0;
 801         case ACCESS_EXT:
 802             /* eciwx or ecowx */
 803             return -4;
 804         default:
 805             if (logfile) {
 806                 fprintf(logfile, "ERROR: instruction should not need "
 807                         "address translation\n");
 808             }
 809             return -4;
 810         }
 811         if ((rw == 1 || ctx->key != 1) && (rw == 0 || ctx->key != 0)) {
 812             ctx->raddr = eaddr;
 813             ret = 2;
 814         } else {
 815             ret = -2;
 816         }
 817     }
 818
 819     return ret;
 820 }
 821
 822 /* Generic TLB check function for embedded PowerPC implementations */
 823 static int ppcemb_tlb_check (CPUState *env, ppcemb_tlb_t *tlb,
 824                              target_phys_addr_t *raddrp,
 825                              target_ulong address,
 826                              uint32_t pid, int ext, int i)
 827 {
 828     target_ulong mask;
 829
 830     /* Check valid flag */
 831     if (!(tlb->prot & PAGE_VALID)) {
 832         if (loglevel != 0)
 833             fprintf(logfile, "%s: TLB %d not valid\n", __func__, i);
 834         return -1;
 835     }
 836     mask = ~(tlb->size - 1);
 837     if (loglevel != 0) {
 838         fprintf(logfile, "%s: TLB %d address " ADDRX " PID %d <=> "
 839                 ADDRX " " ADDRX " %d\n",
 840                 __func__, i, address, pid, tlb->EPN, mask, (int)tlb->PID);
 841     }
 842     /* Check PID */
 843     if (tlb->PID != 0 && tlb->PID != pid)
 844         return -1;
 845     /* Check effective address */
 846     if ((address & mask) != tlb->EPN)
 847         return -1;
 848     *raddrp = (tlb->RPN & mask) | (address & ~mask);
 849     if (ext) {
 850         /* Extend the physical address to 36 bits */
 851         *raddrp |= (target_phys_addr_t)(tlb->RPN & 0xF) << 32;
 852     }
 853
 854     return 0;
 855 }
 856
 857 /* Generic TLB search function for PowerPC embedded implementations */
 858 int ppcemb_tlb_search (CPUPPCState *env, target_ulong address, uint32_t pid)
 859 {
 860     ppcemb_tlb_t *tlb;
 861     target_phys_addr_t raddr;
 862     int i, ret;
 863
 864     /* Default return value is no match */
 865     ret = -1;
 866     for (i = 0; i < 64; i++) {
 867         tlb = &env->tlb[i].tlbe;
 868         if (ppcemb_tlb_check(env, tlb, &raddr, address, pid, 0, i) == 0) {
 869             ret = i;
 870             break;
 871         }
 872     }
 873
 874     return ret;
 875 }
 876
 877 /* Helpers specific to PowerPC 40x implementations */
 878 void ppc4xx_tlb_invalidate_all (CPUState *env)
 879 {
 880     ppcemb_tlb_t *tlb;
 881     int i;
 882
 883     for (i = 0; i < env->nb_tlb; i++) {
 884         tlb = &env->tlb[i].tlbe;
 885         if (tlb->prot & PAGE_VALID) {
 886 #if 0 // XXX: TLB have variable sizes then we flush all Qemu TLB.
 887             end = tlb->EPN + tlb->size;
 888             for (page = tlb->EPN; page < end; page += TARGET_PAGE_SIZE)
 889                 tlb_flush_page(env, page);
 890 #endif
 891             tlb->prot &= ~PAGE_VALID;
 892         }
 893     }
 894     tlb_flush(env, 1);
 895 }
 896
 897 int mmu40x_get_physical_address (CPUState *env, mmu_ctx_t *ctx,
 898                                  target_ulong address, int rw, int access_type)
 899 {
 900     ppcemb_tlb_t *tlb;
 901     target_phys_addr_t raddr;
 902     int i, ret, zsel, zpr;
 903
 904     ret = -1;
 905     raddr = -1;
 906     for (i = 0; i < env->nb_tlb; i++) {
 907         tlb = &env->tlb[i].tlbe;
 908         if (ppcemb_tlb_check(env, tlb, &raddr, address,
 909                              env->spr[SPR_40x_PID], 0, i) < 0)
 910             continue;
 911         zsel = (tlb->attr >> 4) & 0xF;
 912         zpr = (env->spr[SPR_40x_ZPR] >> (28 - (2 * zsel))) & 0x3;
 913         if (loglevel != 0) {
 914             fprintf(logfile, "%s: TLB %d zsel %d zpr %d rw %d attr %08x\n",
 915                     __func__, i, zsel, zpr, rw, tlb->attr);
 916         }
 917         if (access_type == ACCESS_CODE) {
 918             /* Check execute enable bit */
 919             switch (zpr) {
 920             case 0x2:
 921                 if (msr_pr)
 922                     goto check_exec_perm;
 923                 goto exec_granted;
 924             case 0x0:
 925                 if (msr_pr) {
 926                     ctx->prot = 0;
 927                     ret = -3;
 928                     break;
 929                 }
 930                 /* No break here */
 931             case 0x1:
 932             check_exec_perm:
 933                 /* Check from TLB entry */
 934                 if (!(tlb->prot & PAGE_EXEC)) {
 935                     ret = -3;
 936                 } else {
 937                     if (tlb->prot & PAGE_WRITE) {
 938                         ctx->prot = PAGE_READ | PAGE_WRITE;
 939                     } else {
 940                         ctx->prot = PAGE_READ;
 941                     }
 942                     ret = 0;
 943                 }
 944                 break;
 945             case 0x3:
 946             exec_granted:
 947                 /* All accesses granted */
 948                 ctx->prot = PAGE_READ | PAGE_WRITE;
 949                 ret = 0;
 950                 break;
 951             }
 952         } else {
 953             switch (zpr) {
 954             case 0x2:
 955                 if (msr_pr)
 956                     goto check_rw_perm;
 957                 goto rw_granted;
 958             case 0x0:
 959                 if (msr_pr) {
 960                     ctx->prot = 0;
 961                     ret = -2;
 962                     break;
 963                 }
 964                 /* No break here */
 965             case 0x1:
 966             check_rw_perm:
 967                 /* Check from TLB entry */
 968                 /* Check write protection bit */
 969                 if (tlb->prot & PAGE_WRITE) {
 970                     ctx->prot = PAGE_READ | PAGE_WRITE;
 971                     ret = 0;
 972                 } else {
 973                     ctx->prot = PAGE_READ;
 974                     if (rw)
 975                         ret = -2;
 976                     else
 977                         ret = 0;
 978                 }
 979                 break;
 980             case 0x3:
 981             rw_granted:
 982                 /* All accesses granted */
 983                 ctx->prot = PAGE_READ | PAGE_WRITE;
 984                 ret = 0;
 985                 break;
 986             }
 987         }
 988         if (ret >= 0) {
 989             ctx->raddr = raddr;
 990             if (loglevel != 0) {
 991                 fprintf(logfile, "%s: access granted " ADDRX " => " REGX
 992                         " %d %d\n", __func__, address, ctx->raddr, ctx->prot,
 993                         ret);
 994             }
 995             return 0;
 996         }
 997     }
 998     if (loglevel != 0) {
 999         fprintf(logfile, "%s: access refused " ADDRX " => " REGX
1000                 " %d %d\n", __func__, address, raddr, ctx->prot,
1001                 ret);
1002     }
1003
1004     return ret;
1005 }
1006
1007 void store_40x_sler (CPUPPCState *env, uint32_t val)
1008 {
1009     /* XXX: TO BE FIXED */
1010     if (val != 0x00000000) {
1011         cpu_abort(env, "Little-endian regions are not supported by now\n");
1012     }
1013     env->spr[SPR_405_SLER] = val;
1014 }
1015
1016 int mmubooke_get_physical_address (CPUState *env, mmu_ctx_t *ctx,
1017                                    target_ulong address, int rw,
1018                                    int access_type)
1019 {
1020     ppcemb_tlb_t *tlb;
1021     target_phys_addr_t raddr;
1022     int i, prot, ret;
1023
1024     ret = -1;
1025     raddr = -1;
1026     for (i = 0; i < env->nb_tlb; i++) {
1027         tlb = &env->tlb[i].tlbe;
1028         if (ppcemb_tlb_check(env, tlb, &raddr, address,
1029                              env->spr[SPR_BOOKE_PID], 1, i) < 0)
1030             continue;
1031         if (msr_pr)
1032             prot = tlb->prot & 0xF;
1033         else
1034             prot = (tlb->prot >> 4) & 0xF;
1035         /* Check the address space */
1036         if (access_type == ACCESS_CODE) {
1037             if (msr_is != (tlb->attr & 1))
1038                 continue;
1039             ctx->prot = prot;
1040             if (prot & PAGE_EXEC) {
1041                 ret = 0;
1042                 break;
1043             }
1044             ret = -3;
1045         } else {
1046             if (msr_ds != (tlb->attr & 1))
1047                 continue;
1048             ctx->prot = prot;
1049             if ((!rw && prot & PAGE_READ) || (rw && (prot & PAGE_WRITE))) {
1050                 ret = 0;
1051                 break;
1052             }
1053             ret = -2;
1054         }
1055     }
1056     if (ret >= 0)
1057         ctx->raddr = raddr;
1058
1059     return ret;
1060 }
1061
1062 static int check_physical (CPUState *env, mmu_ctx_t *ctx,
1063                            target_ulong eaddr, int rw)
1064 {
1065     int in_plb, ret;
1066
1067     ctx->raddr = eaddr;
1068     ctx->prot = PAGE_READ;
1069     ret = 0;
1070     switch (PPC_MMU(env)) {
1071     case PPC_FLAGS_MMU_32B:
1072     case PPC_FLAGS_MMU_SOFT_6xx:
1073     case PPC_FLAGS_MMU_601:
1074     case PPC_FLAGS_MMU_SOFT_4xx:
1075     case PPC_FLAGS_MMU_401:
1076         ctx->prot |= PAGE_WRITE;
1077         break;
1078 #if defined(TARGET_PPC64)
1079     case PPC_FLAGS_MMU_64B:
1080     case PPC_FLAGS_MMU_64BRIDGE:
1081 #endif
1082         /* Real address are 60 bits long */
1083         ctx->raddr &= 0x0FFFFFFFFFFFFFFFUL;
1084         ctx->prot |= PAGE_WRITE;
1085         break;
1086     case PPC_FLAGS_MMU_403:
1087         if (unlikely(msr_pe != 0)) {
1088             /* 403 family add some particular protections,
1089              * using PBL/PBU registers for accesses with no translation.
1090              */
1091             in_plb =
1092                 /* Check PLB validity */
1093                 (env->pb[0] < env->pb[1] &&
1094                  /* and address in plb area */
1095                  eaddr >= env->pb[0] && eaddr < env->pb[1]) ||
1096                 (env->pb[2] < env->pb[3] &&
1097                  eaddr >= env->pb[2] && eaddr < env->pb[3]) ? 1 : 0;
1098             if (in_plb ^ msr_px) {
1099                 /* Access in protected area */
1100                 if (rw == 1) {
1101                     /* Access is not allowed */
1102                     ret = -2;
1103                 }
1104             } else {
1105                 /* Read-write access is allowed */
1106                 ctx->prot |= PAGE_WRITE;
1107             }
1108         }
1109     case PPC_FLAGS_MMU_BOOKE:
1110         ctx->prot |= PAGE_WRITE;
1111         break;
1112     case PPC_FLAGS_MMU_BOOKE_FSL:
1113         /* XXX: TODO */
1114         cpu_abort(env, "BookE FSL MMU model not implemented\n");
1115         break;
1116     default:
1117         cpu_abort(env, "Unknown or invalid MMU model\n");
1118         return -1;
1119     }
1120
1121     return ret;
1122 }
1123
1124 int get_physical_address (CPUState *env, mmu_ctx_t *ctx, target_ulong eaddr,
1125                           int rw, int access_type, int check_BATs)
1126 {
1127     int ret;
1128 #if 0
1129     if (loglevel != 0) {
1130         fprintf(logfile, "%s\n", __func__);
1131     }
1132 #endif
1133     if ((access_type == ACCESS_CODE && msr_ir == 0) ||
1134         (access_type != ACCESS_CODE && msr_dr == 0)) {
1135         /* No address translation */
1136         ret = check_physical(env, ctx, eaddr, rw);
1137     } else {
1138         ret = -1;
1139         switch (PPC_MMU(env)) {
1140         case PPC_FLAGS_MMU_32B:
1141         case PPC_FLAGS_MMU_SOFT_6xx:
1142             /* Try to find a BAT */
1143             if (check_BATs)
1144                 ret = get_bat(env, ctx, eaddr, rw, access_type);
1145             /* No break here */
1146 #if defined(TARGET_PPC64)
1147         case PPC_FLAGS_MMU_64B:
1148         case PPC_FLAGS_MMU_64BRIDGE:
1149 #endif
1150             if (ret < 0) {
1151                 /* We didn't match any BAT entry or don't have BATs */
1152                 ret = get_segment(env, ctx, eaddr, rw, access_type);
1153             }
1154             break;
1155         case PPC_FLAGS_MMU_SOFT_4xx:
1156         case PPC_FLAGS_MMU_403:
1157             ret = mmu40x_get_physical_address(env, ctx, eaddr,
1158                                               rw, access_type);
1159             break;
1160         case PPC_FLAGS_MMU_601:
1161             /* XXX: TODO */
1162             cpu_abort(env, "601 MMU model not implemented\n");
1163             return -1;
1164         case PPC_FLAGS_MMU_BOOKE:
1165             ret = mmubooke_get_physical_address(env, ctx, eaddr,
1166                                                 rw, access_type);
1167             break;
1168         case PPC_FLAGS_MMU_BOOKE_FSL:
1169             /* XXX: TODO */
1170             cpu_abort(env, "BookE FSL MMU model not implemented\n");
1171             return -1;
1172         case PPC_FLAGS_MMU_401:
1173             cpu_abort(env, "PowerPC 401 does not do any translation\n");
1174             return -1;
1175         default:
1176             cpu_abort(env, "Unknown or invalid MMU model\n");
1177             return -1;
1178         }
1179     }
1180 #if 0
1181     if (loglevel != 0) {
1182         fprintf(logfile, "%s address " ADDRX " => %d " PADDRX "\n",
1183                 __func__, eaddr, ret, ctx->raddr);
1184     }
1185 #endif
1186
1187     return ret;
1188 }
1189
1190 target_phys_addr_t cpu_get_phys_page_debug (CPUState *env, target_ulong addr)
1191 {
1192     mmu_ctx_t ctx;
1193
1194     if (unlikely(get_physical_address(env, &ctx, addr, 0, ACCESS_INT, 1) != 0))
1195         return -1;
1196
1197     return ctx.raddr & TARGET_PAGE_MASK;
1198 }
1199
1200 /* Perform address translation */
1201 int cpu_ppc_handle_mmu_fault (CPUState *env, target_ulong address, int rw,
1202                               int is_user, int is_softmmu)
1203 {
1204     mmu_ctx_t ctx;
1205     int exception = 0, error_code = 0;
1206     int access_type;
1207     int ret = 0;
1208
1209     if (rw == 2) {
1210         /* code access */
1211         rw = 0;
1212         access_type = ACCESS_CODE;
1213     } else {
1214         /* data access */
1215         /* XXX: put correct access by using cpu_restore_state()
1216            correctly */
1217         access_type = ACCESS_INT;
1218         //        access_type = env->access_type;
1219     }
1220     ret = get_physical_address(env, &ctx, address, rw, access_type, 1);
1221     if (ret == 0) {
1222         ret = tlb_set_page(env, address & TARGET_PAGE_MASK,
1223                            ctx.raddr & TARGET_PAGE_MASK, ctx.prot,
1224                            is_user, is_softmmu);
1225     } else if (ret < 0) {
1226 #if defined (DEBUG_MMU)
1227         if (loglevel != 0)
1228             cpu_dump_state(env, logfile, fprintf, 0);
1229 #endif
1230         if (access_type == ACCESS_CODE) {
1231             exception = EXCP_ISI;
1232             switch (ret) {
1233             case -1:
1234                 /* No matches in page tables or TLB */
1235                 switch (PPC_MMU(env)) {
1236                 case PPC_FLAGS_MMU_SOFT_6xx:
1237                     exception = EXCP_I_TLBMISS;
1238                     env->spr[SPR_IMISS] = address;
1239                     env->spr[SPR_ICMP] = 0x80000000 | ctx.ptem;
1240                     error_code = 1 << 18;
1241                     goto tlb_miss;
1242                 case PPC_FLAGS_MMU_SOFT_4xx:
1243                 case PPC_FLAGS_MMU_403:
1244                     exception = EXCP_40x_ITLBMISS;
1245                     error_code = 0;
1246                     env->spr[SPR_40x_DEAR] = address;
1247                     env->spr[SPR_40x_ESR] = 0x00000000;
1248                     break;
1249                 case PPC_FLAGS_MMU_32B:
1250                     error_code = 0x40000000;
1251                     break;
1252 #if defined(TARGET_PPC64)
1253                 case PPC_FLAGS_MMU_64B:
1254                     /* XXX: TODO */
1255                     cpu_abort(env, "MMU model not implemented\n");
1256                     return -1;
1257                 case PPC_FLAGS_MMU_64BRIDGE:
1258                     /* XXX: TODO */
1259                     cpu_abort(env, "MMU model not implemented\n");
1260                     return -1;
1261 #endif
1262                 case PPC_FLAGS_MMU_601:
1263                     /* XXX: TODO */
1264                     cpu_abort(env, "MMU model not implemented\n");
1265                     return -1;
1266                 case PPC_FLAGS_MMU_BOOKE:
1267                     /* XXX: TODO */
1268                     cpu_abort(env, "MMU model not implemented\n");
1269                     return -1;
1270                 case PPC_FLAGS_MMU_BOOKE_FSL:
1271                     /* XXX: TODO */
1272                     cpu_abort(env, "MMU model not implemented\n");
1273                     return -1;
1274                 case PPC_FLAGS_MMU_401:
1275                     cpu_abort(env, "PowerPC 401 should never raise any MMU "
1276                               "exceptions\n");
1277                     return -1;
1278                 default:
1279                     cpu_abort(env, "Unknown or invalid MMU model\n");
1280                     return -1;
1281                 }
1282                 break;
1283             case -2:
1284                 /* Access rights violation */
1285                 error_code = 0x08000000;
1286                 break;
1287             case -3:
1288                 /* No execute protection violation */
1289                 error_code = 0x10000000;
1290                 break;
1291             case -4:
1292                 /* Direct store exception */
1293                 /* No code fetch is allowed in direct-store areas */
1294                 error_code = 0x10000000;
1295                 break;
1296             case -5:
1297                 /* No match in segment table */
1298                 exception = EXCP_ISEG;
1299                 error_code = 0;
1300                 break;
1301             }
1302         } else {
1303             exception = EXCP_DSI;
1304             switch (ret) {
1305             case -1:
1306                 /* No matches in page tables or TLB */
1307                 switch (PPC_MMU(env)) {
1308                 case PPC_FLAGS_MMU_SOFT_6xx:
1309                     if (rw == 1) {
1310                         exception = EXCP_DS_TLBMISS;
1311                         error_code = 1 << 16;
1312                     } else {
1313                         exception = EXCP_DL_TLBMISS;
1314                         error_code = 0;
1315                     }
1316                     env->spr[SPR_DMISS] = address;
1317                     env->spr[SPR_DCMP] = 0x80000000 | ctx.ptem;
1318                 tlb_miss:
1319                     error_code |= ctx.key << 19;
1320                     env->spr[SPR_HASH1] = ctx.pg_addr[0];
1321                     env->spr[SPR_HASH2] = ctx.pg_addr[1];
1322                     /* Do not alter DAR nor DSISR */
1323                     goto out;
1324                 case PPC_FLAGS_MMU_SOFT_4xx:
1325                 case PPC_FLAGS_MMU_403:
1326                     exception = EXCP_40x_DTLBMISS;
1327                     error_code = 0;
1328                     env->spr[SPR_40x_DEAR] = address;
1329                     if (rw)
1330                         env->spr[SPR_40x_ESR] = 0x00800000;
1331                     else
1332                         env->spr[SPR_40x_ESR] = 0x00000000;
1333                     break;
1334                 case PPC_FLAGS_MMU_32B:
1335                     error_code = 0x40000000;
1336                     break;
1337 #if defined(TARGET_PPC64)
1338                 case PPC_FLAGS_MMU_64B:
1339                     /* XXX: TODO */
1340                     cpu_abort(env, "MMU model not implemented\n");
1341                     return -1;
1342                 case PPC_FLAGS_MMU_64BRIDGE:
1343                     /* XXX: TODO */
1344                     cpu_abort(env, "MMU model not implemented\n");
1345                     return -1;
1346 #endif
1347                 case PPC_FLAGS_MMU_601:
1348                     /* XXX: TODO */
1349                     cpu_abort(env, "MMU model not implemented\n");
1350                     return -1;
1351                 case PPC_FLAGS_MMU_BOOKE:
1352                     /* XXX: TODO */
1353                     cpu_abort(env, "MMU model not implemented\n");
1354                     return -1;
1355                 case PPC_FLAGS_MMU_BOOKE_FSL:
1356                     /* XXX: TODO */
1357                     cpu_abort(env, "MMU model not implemented\n");
1358                     return -1;
1359                 case PPC_FLAGS_MMU_401:
1360                     cpu_abort(env, "PowerPC 401 should never raise any MMU "
1361                               "exceptions\n");
1362                     return -1;
1363                 default:
1364                     cpu_abort(env, "Unknown or invalid MMU model\n");
1365                     return -1;
1366                 }
1367                 break;
1368             case -2:
1369                 /* Access rights violation */
1370                 error_code = 0x08000000;
1371                 break;
1372             case -4:
1373                 /* Direct store exception */
1374                 switch (access_type) {
1375                 case ACCESS_FLOAT:
1376                     /* Floating point load/store */
1377                     exception = EXCP_ALIGN;
1378                     error_code = EXCP_ALIGN_FP;
1379                     break;
1380                 case ACCESS_RES:
1381                     /* lwarx, ldarx or srwcx. */
1382                     error_code = 0x04000000;
1383                     break;
1384                 case ACCESS_EXT:
1385                     /* eciwx or ecowx */
1386                     error_code = 0x04100000;
1387                     break;
1388                 default:
1389                     printf("DSI: invalid exception (%d)\n", ret);
1390                     exception = EXCP_PROGRAM;
1391                     error_code = EXCP_INVAL | EXCP_INVAL_INVAL;
1392                     break;
1393                 }
1394                 break;
1395             case -5:
1396                 /* No match in segment table */
1397                 exception = EXCP_DSEG;
1398                 error_code = 0;
1399                 break;
1400             }
1401             if (exception == EXCP_DSI && rw == 1)
1402                 error_code |= 0x02000000;
1403             /* Store fault address */
1404             env->spr[SPR_DAR] = address;
1405             env->spr[SPR_DSISR] = error_code;
1406         }
1407     out:
1408 #if 0
1409         printf("%s: set exception to %d %02x\n",
1410                __func__, exception, error_code);
1411 #endif
1412         env->exception_index = exception;
1413         env->error_code = error_code;
1414         ret = 1;
1415     }
1416
1417     return ret;
1418 }
1419
1420 /*****************************************************************************/
1421 /* BATs management */
1422 #if !defined(FLUSH_ALL_TLBS)
1423 static inline void do_invalidate_BAT (CPUPPCState *env,
1424                                       target_ulong BATu, target_ulong mask)
1425 {
1426     target_ulong base, end, page;
1427
1428     base = BATu & ~0x0001FFFF;
1429     end = base + mask + 0x00020000;
1430 #if defined (DEBUG_BATS)
1431     if (loglevel != 0) {
1432         fprintf(logfile, "Flush BAT from " ADDRX " to " ADDRX " (" ADDRX ")\n",
1433                 base, end, mask);
1434     }
1435 #endif
1436     for (page = base; page != end; page += TARGET_PAGE_SIZE)
1437         tlb_flush_page(env, page);
1438 #if defined (DEBUG_BATS)
1439     if (loglevel != 0)
1440         fprintf(logfile, "Flush done\n");
1441 #endif
1442 }
1443 #endif
1444
1445 static inline void dump_store_bat (CPUPPCState *env, char ID, int ul, int nr,
1446                                    target_ulong value)
1447 {
1448 #if defined (DEBUG_BATS)
1449     if (loglevel != 0) {
1450         fprintf(logfile, "Set %cBAT%d%c to 0x" ADDRX " (0x" ADDRX ")\n",
1451                 ID, nr, ul == 0 ? 'u' : 'l', value, env->nip);
1452     }
1453 #endif
1454 }
1455
1456 target_ulong do_load_ibatu (CPUPPCState *env, int nr)
1457 {
1458     return env->IBAT[0][nr];
1459 }
1460
1461 target_ulong do_load_ibatl (CPUPPCState *env, int nr)
1462 {
1463     return env->IBAT[1][nr];
1464 }
1465
1466 void do_store_ibatu (CPUPPCState *env, int nr, target_ulong value)
1467 {
1468     target_ulong mask;
1469
1470     dump_store_bat(env, 'I', 0, nr, value);
1471     if (env->IBAT[0][nr] != value) {
1472         mask = (value << 15) & 0x0FFE0000UL;
1473 #if !defined(FLUSH_ALL_TLBS)
1474         do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1475 #endif
1476         /* When storing valid upper BAT, mask BEPI and BRPN
1477          * and invalidate all TLBs covered by this BAT
1478          */
1479         mask = (value << 15) & 0x0FFE0000UL;
1480         env->IBAT[0][nr] = (value & 0x00001FFFUL) |
1481             (value & ~0x0001FFFFUL & ~mask);
1482         env->IBAT[1][nr] = (env->IBAT[1][nr] & 0x0000007B) |
1483             (env->IBAT[1][nr] & ~0x0001FFFF & ~mask);
1484 #if !defined(FLUSH_ALL_TLBS)
1485         do_invalidate_BAT(env, env->IBAT[0][nr], mask);
1486 #else
1487         tlb_flush(env, 1);
1488 #endif
1489     }
1490 }
1491
1492 void do_store_ibatl (CPUPPCState *env, int nr, target_ulong value)
1493 {
1494     dump_store_bat(env, 'I', 1, nr, value);
1495     env->IBAT[1][nr] = value;
1496 }
1497
1498 target_ulong do_load_dbatu (CPUPPCState *env, int nr)
1499 {
1500     return env->DBAT[0][nr];
1501 }
1502
1503 target_ulong do_load_dbatl (CPUPPCState *env, int nr)
1504 {
1505     return env->DBAT[1][nr];
1506 }
1507
1508 void do_store_dbatu (CPUPPCState *env, int nr, target_ulong value)
1509 {
1510     target_ulong mask;
1511
1512     dump_store_bat(env, 'D', 0, nr, value);
1513     if (env->DBAT[0][nr] != value) {
1514         /* When storing valid upper BAT, mask BEPI and BRPN
1515          * and invalidate all TLBs covered by this BAT
1516          */
1517         mask = (value << 15) & 0x0FFE0000UL;
1518 #if !defined(FLUSH_ALL_TLBS)
1519         do_invalidate_BAT(env, env->DBAT[0][nr], mask);
1520 #endif
1521         mask = (value << 15) & 0x0FFE0000UL;
1522         env->DBAT[0][nr] = (value & 0x00001FFFUL) |
1523             (value & ~0x0001FFFFUL & ~mask);
1524         env->DBAT[1][nr] = (env->DBAT[1][nr] & 0x0000007B) |
1525             (env->DBAT[1][nr] & ~0x0001FFFF & ~mask);
1526 #if !defined(FLUSH_ALL_TLBS)
1527         do_invalidate_BAT(env, env->DBAT[0][nr], mask);
1528 #else
1529         tlb_flush(env, 1);
1530 #endif
1531     }
1532 }
1533
1534 void do_store_dbatl (CPUPPCState *env, int nr, target_ulong value)
1535 {
1536     dump_store_bat(env, 'D', 1, nr, value);
1537     env->DBAT[1][nr] = value;
1538 }
1539
1540
1541 /*****************************************************************************/
1542 /* TLB management */
1543 void ppc_tlb_invalidate_all (CPUPPCState *env)
1544 {
1545     if (unlikely(PPC_MMU(env) == PPC_FLAGS_MMU_SOFT_6xx)) {
1546         ppc6xx_tlb_invalidate_all(env);
1547     } else if (unlikely(PPC_MMU(env) == PPC_FLAGS_MMU_SOFT_4xx)) {
1548         ppc4xx_tlb_invalidate_all(env);
1549     } else {
1550         tlb_flush(env, 1);
1551     }
1552 }
1553
1554 /*****************************************************************************/
1555 /* Special registers manipulation */
1556 #if defined(TARGET_PPC64)
1557 target_ulong ppc_load_asr (CPUPPCState *env)
1558 {
1559     return env->asr;
1560 }
1561
1562 void ppc_store_asr (CPUPPCState *env, target_ulong value)
1563 {
1564     if (env->asr != value) {
1565         env->asr = value;
1566         tlb_flush(env, 1);
1567     }
1568 }
1569 #endif
1570
1571 target_ulong do_load_sdr1 (CPUPPCState *env)
1572 {
1573     return env->sdr1;
1574 }
1575
1576 void do_store_sdr1 (CPUPPCState *env, target_ulong value)
1577 {
1578 #if defined (DEBUG_MMU)
1579     if (loglevel != 0) {
1580         fprintf(logfile, "%s: 0x" ADDRX "\n", __func__, value);
1581     }
1582 #endif
1583     if (env->sdr1 != value) {
1584         env->sdr1 = value;
1585         tlb_flush(env, 1);
1586     }
1587 }
1588
1589 target_ulong do_load_sr (CPUPPCState *env, int srnum)
1590 {
1591     return env->sr[srnum];
1592 }
1593
1594 void do_store_sr (CPUPPCState *env, int srnum, target_ulong value)
1595 {
1596 #if defined (DEBUG_MMU)
1597     if (loglevel != 0) {
1598         fprintf(logfile, "%s: reg=%d 0x" ADDRX " " ADDRX "\n",
1599                 __func__, srnum, value, env->sr[srnum]);
1600     }
1601 #endif
1602     if (env->sr[srnum] != value) {
1603         env->sr[srnum] = value;
1604 #if !defined(FLUSH_ALL_TLBS) && 0
1605         {
1606             target_ulong page, end;
1607             /* Invalidate 256 MB of virtual memory */
1608             page = (16 << 20) * srnum;
1609             end = page + (16 << 20);
1610             for (; page != end; page += TARGET_PAGE_SIZE)
1611                 tlb_flush_page(env, page);
1612         }
1613 #else
1614         tlb_flush(env, 1);
1615 #endif
1616     }
1617 }
1618 #endif /* !defined (CONFIG_USER_ONLY) */
1619
1620 uint32_t ppc_load_xer (CPUPPCState *env)
1621 {
1622     return (xer_so << XER_SO) |
1623         (xer_ov << XER_OV) |
1624         (xer_ca << XER_CA) |
1625         (xer_bc << XER_BC) |
1626         (xer_cmp << XER_CMP);
1627 }
1628
1629 void ppc_store_xer (CPUPPCState *env, uint32_t value)
1630 {
1631     xer_so = (value >> XER_SO) & 0x01;
1632     xer_ov = (value >> XER_OV) & 0x01;
1633     xer_ca = (value >> XER_CA) & 0x01;
1634     xer_cmp = (value >> XER_CMP) & 0xFF;
1635     xer_bc = (value >> XER_BC) & 0x7F;
1636 }
1637
1638 /* Swap temporary saved registers with GPRs */
1639 static inline void swap_gpr_tgpr (CPUPPCState *env)
1640 {
1641     ppc_gpr_t tmp;
1642
1643     tmp = env->gpr[0];
1644     env->gpr[0] = env->tgpr[0];
1645     env->tgpr[0] = tmp;
1646     tmp = env->gpr[1];
1647     env->gpr[1] = env->tgpr[1];
1648     env->tgpr[1] = tmp;
1649     tmp = env->gpr[2];
1650     env->gpr[2] = env->tgpr[2];
1651     env->tgpr[2] = tmp;
1652     tmp = env->gpr[3];
1653     env->gpr[3] = env->tgpr[3];
1654     env->tgpr[3] = tmp;
1655 }
1656
1657 /* GDBstub can read and write MSR... */
1658 target_ulong do_load_msr (CPUPPCState *env)
1659 {
1660     return
1661 #if defined (TARGET_PPC64)
1662         ((target_ulong)msr_sf   << MSR_SF)   |
1663         ((target_ulong)msr_isf  << MSR_ISF)  |
1664         ((target_ulong)msr_hv   << MSR_HV)   |
1665 #endif
1666         ((target_ulong)msr_ucle << MSR_UCLE) |
1667         ((target_ulong)msr_vr   << MSR_VR)   | /* VR / SPE */
1668         ((target_ulong)msr_ap   << MSR_AP)   |
1669         ((target_ulong)msr_sa   << MSR_SA)   |
1670         ((target_ulong)msr_key  << MSR_KEY)  |
1671         ((target_ulong)msr_pow  << MSR_POW)  | /* POW / WE */
1672         ((target_ulong)msr_tlb  << MSR_TLB)  | /* TLB / TGPE / CE */
1673         ((target_ulong)msr_ile  << MSR_ILE)  |
1674         ((target_ulong)msr_ee   << MSR_EE)   |
1675         ((target_ulong)msr_pr   << MSR_PR)   |
1676         ((target_ulong)msr_fp   << MSR_FP)   |
1677         ((target_ulong)msr_me   << MSR_ME)   |
1678         ((target_ulong)msr_fe0  << MSR_FE0)  |
1679         ((target_ulong)msr_se   << MSR_SE)   | /* SE / DWE / UBLE */
1680         ((target_ulong)msr_be   << MSR_BE)   | /* BE / DE */
1681         ((target_ulong)msr_fe1  << MSR_FE1)  |
1682         ((target_ulong)msr_al   << MSR_AL)   |
1683         ((target_ulong)msr_ip   << MSR_IP)   |
1684         ((target_ulong)msr_ir   << MSR_IR)   | /* IR / IS */
1685         ((target_ulong)msr_dr   << MSR_DR)   | /* DR / DS */
1686         ((target_ulong)msr_pe   << MSR_PE)   | /* PE / EP */
1687         ((target_ulong)msr_px   << MSR_PX)   | /* PX / PMM */
1688         ((target_ulong)msr_ri   << MSR_RI)   |
1689         ((target_ulong)msr_le   << MSR_LE);
1690 }
1691
1692 void do_store_msr (CPUPPCState *env, target_ulong value)
1693 {
1694     int enter_pm;
1695
1696     value &= env->msr_mask;
1697     if (((value >> MSR_IR) & 1) != msr_ir ||
1698         ((value >> MSR_DR) & 1) != msr_dr) {
1699         /* Flush all tlb when changing translation mode */
1700         tlb_flush(env, 1);
1701         env->interrupt_request |= CPU_INTERRUPT_EXITTB;
1702     }
1703 #if 0
1704     if (loglevel != 0) {
1705         fprintf(logfile, "%s: T0 %08lx\n", __func__, value);
1706     }
1707 #endif
1708     switch (PPC_EXCP(env)) {
1709     case PPC_FLAGS_EXCP_602:
1710     case PPC_FLAGS_EXCP_603:
1711         if (((value >> MSR_TGPR) & 1) != msr_tgpr) {
1712             /* Swap temporary saved registers with GPRs */
1713             swap_gpr_tgpr(env);
1714         }
1715         break;
1716     default:
1717         break;
1718     }
1719 #if defined (TARGET_PPC64)
1720     msr_sf   = (value >> MSR_SF)   & 1;
1721     msr_isf  = (value >> MSR_ISF)  & 1;
1722     msr_hv   = (value >> MSR_HV)   & 1;
1723 #endif
1724     msr_ucle = (value >> MSR_UCLE) & 1;
1725     msr_vr   = (value >> MSR_VR)   & 1; /* VR / SPE */
1726     msr_ap   = (value >> MSR_AP)   & 1;
1727     msr_sa   = (value >> MSR_SA)   & 1;
1728     msr_key  = (value >> MSR_KEY)  & 1;
1729     msr_pow  = (value >> MSR_POW)  & 1; /* POW / WE */
1730     msr_tlb  = (value >> MSR_TLB)  & 1; /* TLB / TGPR / CE */
1731     msr_ile  = (value >> MSR_ILE)  & 1;
1732     msr_ee   = (value >> MSR_EE)   & 1;
1733     msr_pr   = (value >> MSR_PR)   & 1;
1734     msr_fp   = (value >> MSR_FP)   & 1;
1735     msr_me   = (value >> MSR_ME)   & 1;
1736     msr_fe0  = (value >> MSR_FE0)  & 1;
1737     msr_se   = (value >> MSR_SE)   & 1; /* SE / DWE / UBLE */
1738     msr_be   = (value >> MSR_BE)   & 1; /* BE / DE */
1739     msr_fe1  = (value >> MSR_FE1)  & 1;
1740     msr_al   = (value >> MSR_AL)   & 1;
1741     msr_ip   = (value >> MSR_IP)   & 1;
1742     msr_ir   = (value >> MSR_IR)   & 1; /* IR / IS */
1743     msr_dr   = (value >> MSR_DR)   & 1; /* DR / DS */
1744     msr_pe   = (value >> MSR_PE)   & 1; /* PE / EP */
1745     msr_px   = (value >> MSR_PX)   & 1; /* PX / PMM */
1746     msr_ri   = (value >> MSR_RI)   & 1;
1747     msr_le   = (value >> MSR_LE)   & 1;
1748     do_compute_hflags(env);
1749
1750     enter_pm = 0;
1751     switch (PPC_EXCP(env)) {
1752     case PPC_FLAGS_EXCP_603:
1753         /* Don't handle SLEEP mode: we should disable all clocks...
1754          * No dynamic power-management.
1755          */
1756         if (msr_pow == 1 && (env->spr[SPR_HID0] & 0x00C00000) != 0)
1757             enter_pm = 1;
1758         break;
1759     case PPC_FLAGS_EXCP_604:
1760         if (msr_pow == 1)
1761             enter_pm = 1;
1762         break;
1763     case PPC_FLAGS_EXCP_7x0:
1764         if (msr_pow == 1 && (env->spr[SPR_HID0] & 0x00E00000) != 0)
1765             enter_pm = 1;
1766         break;
1767     default:
1768         break;
1769     }
1770     if (enter_pm) {
1771         if (likely(!env->halted)) {
1772             /* power save: exit cpu loop */
1773             env->halted = 1;
1774             env->exception_index = EXCP_HLT;
1775             cpu_loop_exit();
1776         }
1777     }
1778 }
1779
1780 #if defined(TARGET_PPC64)
1781 void ppc_store_msr_32 (CPUPPCState *env, uint32_t value)
1782 {
1783     do_store_msr(env,
1784                  (do_load_msr(env) & ~0xFFFFFFFFULL) | (value & 0xFFFFFFFF));
1785 }
1786 #endif
1787
1788 void do_compute_hflags (CPUPPCState *env)
1789 {
1790     /* Compute current hflags */
1791     env->hflags = (msr_vr << MSR_VR) |
1792         (msr_ap << MSR_AP) | (msr_sa << MSR_SA) | (msr_pr << MSR_PR) |
1793         (msr_fp << MSR_FP) | (msr_fe0 << MSR_FE0) | (msr_se << MSR_SE) |
1794         (msr_be << MSR_BE) | (msr_fe1 << MSR_FE1) | (msr_le << MSR_LE);
1795 #if defined (TARGET_PPC64)
1796     env->hflags |= msr_cm << MSR_CM;
1797     env->hflags |= (uint64_t)msr_sf << MSR_SF;
1798     env->hflags |= (uint64_t)msr_hv << MSR_HV;
1799 #endif
1800 }
1801
1802 /*****************************************************************************/
1803 /* Exception processing */
1804 #if defined (CONFIG_USER_ONLY)
1805 void do_interrupt (CPUState *env)
1806 {
1807     env->exception_index = -1;
1808 }
1809
1810 void ppc_hw_interrupt (CPUState *env)
1811 {
1812     env->exception_index = -1;
1813 }
1814 #else /* defined (CONFIG_USER_ONLY) */
1815 static void dump_syscall (CPUState *env)
1816 {
1817     fprintf(logfile, "syscall r0=0x" REGX " r3=0x" REGX " r4=0x" REGX
1818             " r5=0x" REGX " r6=0x" REGX " nip=0x" ADDRX "\n",
1819             env->gpr[0], env->gpr[3], env->gpr[4],
1820             env->gpr[5], env->gpr[6], env->nip);
1821 }
1822
1823 void do_interrupt (CPUState *env)
1824 {
1825     target_ulong msr, *srr_0, *srr_1, *asrr_0, *asrr_1;
1826     int excp, idx;
1827
1828     excp = env->exception_index;
1829     msr = do_load_msr(env);
1830     /* The default is to use SRR0 & SRR1 to save the exception context */
1831     srr_0 = &env->spr[SPR_SRR0];
1832     srr_1 = &env->spr[SPR_SRR1];
1833     asrr_0 = NULL;
1834     asrr_1 = NULL;
1835 #if defined (DEBUG_EXCEPTIONS)
1836     if ((excp == EXCP_PROGRAM || excp == EXCP_DSI) && msr_pr == 1) {
1837         if (loglevel != 0) {
1838             fprintf(logfile,
1839                     "Raise exception at 0x" ADDRX " => 0x%08x (%02x)\n",
1840                     env->nip, excp, env->error_code);
1841             cpu_dump_state(env, logfile, fprintf, 0);
1842         }
1843     }
1844 #endif
1845     if (loglevel & CPU_LOG_INT) {
1846         fprintf(logfile, "Raise exception at 0x" ADDRX " => 0x%08x (%02x)\n",
1847                 env->nip, excp, env->error_code);
1848     }
1849     msr_pow = 0;
1850     idx = -1;
1851     /* Generate informations in save/restore registers */
1852     switch (excp) {
1853     /* Generic PowerPC exceptions */
1854     case EXCP_RESET: /* 0x0100 */
1855         switch (PPC_EXCP(env)) {
1856         case PPC_FLAGS_EXCP_40x:
1857             srr_0 = &env->spr[SPR_40x_SRR2];
1858             srr_1 = &env->spr[SPR_40x_SRR3];
1859             break;
1860         case PPC_FLAGS_EXCP_BOOKE:
1861             idx = 0;
1862             srr_0 = &env->spr[SPR_BOOKE_CSRR0];
1863             srr_1 = &env->spr[SPR_BOOKE_CSRR1];
1864             break;
1865         default:
1866             if (msr_ip)
1867                 excp += 0xFFC00;
1868             excp |= 0xFFC00000;
1869             break;
1870         }
1871         goto store_next;
1872     case EXCP_MACHINE_CHECK: /* 0x0200 */
1873         switch (PPC_EXCP(env)) {
1874         case PPC_FLAGS_EXCP_40x:
1875             srr_0 = &env->spr[SPR_40x_SRR2];
1876             srr_1 = &env->spr[SPR_40x_SRR3];
1877             break;
1878         case PPC_FLAGS_EXCP_BOOKE:
1879             idx = 1;
1880             srr_0 = &env->spr[SPR_BOOKE_MCSRR0];
1881             srr_1 = &env->spr[SPR_BOOKE_MCSRR1];
1882             asrr_0 = &env->spr[SPR_BOOKE_CSRR0];
1883             asrr_1 = &env->spr[SPR_BOOKE_CSRR1];
1884             msr_ce = 0;
1885             break;
1886         default:
1887             break;
1888         }
1889         msr_me = 0;
1890         break;
1891     case EXCP_DSI: /* 0x0300 */
1892         /* Store exception cause */
1893         /* data location address has been stored
1894          * when the fault has been detected
1895          */
1896         idx = 2;
1897         msr &= ~0xFFFF0000;
1898 #if defined (DEBUG_EXCEPTIONS)
1899         if (loglevel != 0) {
1900             fprintf(logfile, "DSI exception: DSISR=0x" ADDRX" DAR=0x" ADDRX
1901                     "\n", env->spr[SPR_DSISR], env->spr[SPR_DAR]);
1902         }
1903 #endif
1904         goto store_next;
1905     case EXCP_ISI: /* 0x0400 */
1906         /* Store exception cause */
1907         idx = 3;
1908         msr &= ~0xFFFF0000;
1909         msr |= env->error_code;
1910 #if defined (DEBUG_EXCEPTIONS)
1911         if (loglevel != 0) {
1912             fprintf(logfile, "ISI exception: msr=0x" ADDRX ", nip=0x" ADDRX
1913                     "\n", msr, env->nip);
1914         }
1915 #endif
1916         goto store_next;
1917     case EXCP_EXTERNAL: /* 0x0500 */
1918         idx = 4;
1919         goto store_next;
1920     case EXCP_ALIGN: /* 0x0600 */
1921         if (likely(PPC_EXCP(env) != PPC_FLAGS_EXCP_601)) {
1922             /* Store exception cause */
1923             idx = 5;
1924             /* Get rS/rD and rA from faulting opcode */
1925             env->spr[SPR_DSISR] |=
1926                 (ldl_code((env->nip - 4)) & 0x03FF0000) >> 16;
1927             /* data location address has been stored
1928              * when the fault has been detected
1929              */
1930         } else {
1931             /* IO error exception on PowerPC 601 */
1932             /* XXX: TODO */
1933             cpu_abort(env,
1934                       "601 IO error exception is not implemented yet !\n");
1935         }
1936         goto store_current;
1937     case EXCP_PROGRAM: /* 0x0700 */
1938         idx = 6;
1939         msr &= ~0xFFFF0000;
1940         switch (env->error_code & ~0xF) {
1941         case EXCP_FP:
1942             if (msr_fe0 == 0 && msr_fe1 == 0) {
1943 #if defined (DEBUG_EXCEPTIONS)
1944                 if (loglevel != 0) {
1945                     fprintf(logfile, "Ignore floating point exception\n");
1946                 }
1947 #endif
1948                 return;
1949             }
1950             msr |= 0x00100000;
1951             /* Set FX */
1952             env->fpscr[7] |= 0x8;
1953             /* Finally, update FEX */
1954             if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
1955                 ((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
1956                 env->fpscr[7] |= 0x4;
1957             break;
1958         case EXCP_INVAL:
1959 #if defined (DEBUG_EXCEPTIONS)
1960             if (loglevel != 0) {
1961                 fprintf(logfile, "Invalid instruction at 0x" ADDRX "\n",
1962                         env->nip);
1963             }
1964 #endif
1965             msr |= 0x00080000;
1966             break;
1967         case EXCP_PRIV:
1968             msr |= 0x00040000;
1969             break;
1970         case EXCP_TRAP:
1971             idx = 15;
1972             msr |= 0x00020000;
1973             break;
1974         default:
1975             /* Should never occur */
1976             break;
1977         }
1978         msr |= 0x00010000;
1979         goto store_current;
1980     case EXCP_NO_FP: /* 0x0800 */
1981         idx = 7;
1982         msr &= ~0xFFFF0000;
1983         goto store_current;
1984     case EXCP_DECR:
1985         goto store_next;
1986     case EXCP_SYSCALL: /* 0x0C00 */
1987         idx = 8;
1988         /* NOTE: this is a temporary hack to support graphics OSI
1989            calls from the MOL driver */
1990         if (env->gpr[3] == 0x113724fa && env->gpr[4] == 0x77810f9b &&
1991             env->osi_call) {
1992             if (env->osi_call(env) != 0)
1993                 return;
1994         }
1995         if (loglevel & CPU_LOG_INT) {
1996             dump_syscall(env);
1997         }
1998         goto store_next;
1999     case EXCP_TRACE: /* 0x0D00 */
2000         goto store_next;
2001     case EXCP_PERF: /* 0x0F00 */
2002         /* XXX: TODO */
2003         cpu_abort(env,
2004                   "Performance counter exception is not implemented yet !\n");
2005         goto store_next;
2006     /* 32 bits PowerPC specific exceptions */
2007     case EXCP_FP_ASSIST: /* 0x0E00 */
2008         /* XXX: TODO */
2009         cpu_abort(env, "Floating point assist exception "
2010                   "is not implemented yet !\n");
2011         goto store_next;
2012     /* 64 bits PowerPC exceptions */
2013     case EXCP_DSEG: /* 0x0380 */
2014         /* XXX: TODO */
2015         cpu_abort(env, "Data segment exception is not implemented yet !\n");
2016         goto store_next;
2017     case EXCP_ISEG: /* 0x0480 */
2018         /* XXX: TODO */
2019         cpu_abort(env,
2020                   "Instruction segment exception is not implemented yet !\n");
2021         goto store_next;
2022     case EXCP_HDECR: /* 0x0980 */
2023         /* XXX: TODO */
2024         cpu_abort(env, "Hypervisor decrementer exception is not implemented "
2025                   "yet !\n");
2026         goto store_next;
2027     /* Implementation specific exceptions */
2028     case 0x0A00:
2029         if (likely(env->spr[SPR_PVR] == CPU_PPC_G2 ||
2030                    env->spr[SPR_PVR] == CPU_PPC_G2LE)) {
2031             /* Critical interrupt on G2 */
2032             /* XXX: TODO */
2033             cpu_abort(env, "G2 critical interrupt is not implemented yet !\n");
2034             goto store_next;
2035         } else {
2036             cpu_abort(env, "Invalid exception 0x0A00 !\n");
2037         }
2038         return;
2039     case 0x0F20:
2040         idx = 9;
2041         switch (PPC_EXCP(env)) {
2042         case PPC_FLAGS_EXCP_40x:
2043             /* APU unavailable on 405 */
2044             /* XXX: TODO */
2045             cpu_abort(env,
2046                       "APU unavailable exception is not implemented yet !\n");
2047             goto store_next;
2048         case PPC_FLAGS_EXCP_74xx:
2049             /* Altivec unavailable */
2050             /* XXX: TODO */
2051             cpu_abort(env, "Altivec unavailable exception "
2052                       "is not implemented yet !\n");
2053             goto store_next;
2054         default:
2055             cpu_abort(env, "Invalid exception 0x0F20 !\n");
2056             break;
2057         }
2058         return;
2059     case 0x1000:
2060         idx = 10;
2061         switch (PPC_EXCP(env)) {
2062         case PPC_FLAGS_EXCP_40x:
2063             /* PIT on 4xx */
2064             msr &= ~0xFFFF0000;
2065 #if defined (DEBUG_EXCEPTIONS)
2066             if (loglevel != 0)
2067                 fprintf(logfile, "PIT exception\n");
2068 #endif
2069             goto store_next;
2070         case PPC_FLAGS_EXCP_602:
2071         case PPC_FLAGS_EXCP_603:
2072             /* ITLBMISS on 602/603 */
2073             goto store_gprs;
2074         case PPC_FLAGS_EXCP_7x5:
2075             /* ITLBMISS on 745/755 */
2076             goto tlb_miss;
2077         default:
2078             cpu_abort(env, "Invalid exception 0x1000 !\n");
2079             break;
2080         }
2081         return;
2082     case 0x1010:
2083         idx = 11;
2084         switch (PPC_EXCP(env)) {
2085         case PPC_FLAGS_EXCP_40x:
2086             /* FIT on 4xx */
2087             msr &= ~0xFFFF0000;
2088 #if defined (DEBUG_EXCEPTIONS)
2089             if (loglevel != 0)
2090                 fprintf(logfile, "FIT exception\n");
2091 #endif
2092             goto store_next;
2093         default:
2094             cpu_abort(env, "Invalid exception 0x1010 !\n");
2095             break;
2096         }
2097         return;
2098     case 0x1020:
2099         idx = 12;
2100         switch (PPC_EXCP(env)) {
2101         case PPC_FLAGS_EXCP_40x:
2102             /* Watchdog on 4xx */
2103             msr &= ~0xFFFF0000;
2104 #if defined (DEBUG_EXCEPTIONS)
2105             if (loglevel != 0)
2106                 fprintf(logfile, "WDT exception\n");
2107 #endif
2108             goto store_next;
2109         case PPC_FLAGS_EXCP_BOOKE:
2110             srr_0 = &env->spr[SPR_BOOKE_CSRR0];
2111             srr_1 = &env->spr[SPR_BOOKE_CSRR1];
2112             break;
2113         default:
2114             cpu_abort(env, "Invalid exception 0x1020 !\n");
2115             break;
2116         }
2117         return;
2118     case 0x1100:
2119         idx = 13;
2120         switch (PPC_EXCP(env)) {
2121         case PPC_FLAGS_EXCP_40x:
2122             /* DTLBMISS on 4xx */
2123             msr &= ~0xFFFF0000;
2124             goto store_next;
2125         case PPC_FLAGS_EXCP_602:
2126         case PPC_FLAGS_EXCP_603:
2127             /* DLTLBMISS on 602/603 */
2128             goto store_gprs;
2129         case PPC_FLAGS_EXCP_7x5:
2130             /* DLTLBMISS on 745/755 */
2131             goto tlb_miss;
2132         default:
2133             cpu_abort(env, "Invalid exception 0x1100 !\n");
2134             break;
2135         }
2136         return;
2137     case 0x1200:
2138         idx = 14;
2139         switch (PPC_EXCP(env)) {
2140         case PPC_FLAGS_EXCP_40x:
2141             /* ITLBMISS on 4xx */
2142             msr &= ~0xFFFF0000;
2143             goto store_next;
2144         case PPC_FLAGS_EXCP_602:
2145         case PPC_FLAGS_EXCP_603:
2146             /* DSTLBMISS on 602/603 */
2147         store_gprs:
2148             /* Swap temporary saved registers with GPRs */
2149             swap_gpr_tgpr(env);
2150             msr_tgpr = 1;
2151 #if defined (DEBUG_SOFTWARE_TLB)
2152             if (loglevel != 0) {
2153                 const unsigned char *es;
2154                 target_ulong *miss, *cmp;
2155                 int en;
2156                 if (excp == 0x1000) {
2157                     es = "I";
2158                     en = 'I';
2159                     miss = &env->spr[SPR_IMISS];
2160                     cmp = &env->spr[SPR_ICMP];
2161                 } else {
2162                     if (excp == 0x1100)
2163                         es = "DL";
2164                     else
2165                         es = "DS";
2166                     en = 'D';
2167                     miss = &env->spr[SPR_DMISS];
2168                     cmp = &env->spr[SPR_DCMP];
2169                 }
2170                 fprintf(logfile, "6xx %sTLB miss: %cM " ADDRX " %cC " ADDRX
2171                         " H1 " ADDRX " H2 " ADDRX " %08x\n",
2172                         es, en, *miss, en, *cmp,
2173                         env->spr[SPR_HASH1], env->spr[SPR_HASH2],
2174                         env->error_code);
2175             }
2176 #endif
2177             goto tlb_miss;
2178         case PPC_FLAGS_EXCP_7x5:
2179             /* DSTLBMISS on 745/755 */
2180         tlb_miss:
2181             msr &= ~0xF83F0000;
2182             msr |= env->crf[0] << 28;
2183             msr |= env->error_code; /* key, D/I, S/L bits */
2184             /* Set way using a LRU mechanism */
2185             msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
2186             goto store_next;
2187         default:
2188             cpu_abort(env, "Invalid exception 0x1200 !\n");
2189             break;
2190         }
2191         return;
2192     case 0x1300:
2193         switch (PPC_EXCP(env)) {
2194         case PPC_FLAGS_EXCP_601:
2195         case PPC_FLAGS_EXCP_602:
2196         case PPC_FLAGS_EXCP_603:
2197         case PPC_FLAGS_EXCP_604:
2198         case PPC_FLAGS_EXCP_7x0:
2199         case PPC_FLAGS_EXCP_7x5:
2200             /* IABR on 6xx/7xx */
2201             /* XXX: TODO */
2202             cpu_abort(env, "IABR exception is not implemented yet !\n");
2203             goto store_next;
2204         default:
2205             cpu_abort(env, "Invalid exception 0x1300 !\n");
2206             break;
2207         }
2208         return;
2209     case 0x1400:
2210         switch (PPC_EXCP(env)) {
2211         case PPC_FLAGS_EXCP_601:
2212         case PPC_FLAGS_EXCP_602:
2213         case PPC_FLAGS_EXCP_603:
2214         case PPC_FLAGS_EXCP_604:
2215         case PPC_FLAGS_EXCP_7x0:
2216         case PPC_FLAGS_EXCP_7x5:
2217             /* SMI on 6xx/7xx */
2218             /* XXX: TODO */
2219             cpu_abort(env, "SMI exception is not implemented yet !\n");
2220             goto store_next;
2221         default:
2222             cpu_abort(env, "Invalid exception 0x1400 !\n");
2223             break;
2224         }
2225         return;
2226     case 0x1500:
2227         switch (PPC_EXCP(env)) {
2228         case PPC_FLAGS_EXCP_602:
2229             /* Watchdog on 602 */
2230             /* XXX: TODO */
2231             cpu_abort(env,
2232                       "602 watchdog exception is not implemented yet !\n");
2233             goto store_next;
2234         case PPC_FLAGS_EXCP_970:
2235             /* Soft patch exception on 970 */
2236             /* XXX: TODO */
2237             cpu_abort(env,
2238                       "970 soft-patch exception is not implemented yet !\n");
2239             goto store_next;
2240         case PPC_FLAGS_EXCP_74xx:
2241             /* VPU assist on 74xx */
2242             /* XXX: TODO */
2243             cpu_abort(env, "VPU assist exception is not implemented yet !\n");
2244             goto store_next;
2245         default:
2246             cpu_abort(env, "Invalid exception 0x1500 !\n");
2247             break;
2248         }
2249         return;
2250     case 0x1600:
2251         switch (PPC_EXCP(env)) {
2252         case PPC_FLAGS_EXCP_602:
2253             /* Emulation trap on 602 */
2254             /* XXX: TODO */
2255             cpu_abort(env, "602 emulation trap exception "
2256                       "is not implemented yet !\n");
2257             goto store_next;
2258         case PPC_FLAGS_EXCP_970:
2259             /* Maintenance exception on 970 */
2260             /* XXX: TODO */
2261             cpu_abort(env,
2262                       "970 maintenance exception is not implemented yet !\n");
2263             goto store_next;
2264         default:
2265             cpu_abort(env, "Invalid exception 0x1600 !\n");
2266             break;
2267         }
2268         return;
2269     case 0x1700:
2270         switch (PPC_EXCP(env)) {
2271         case PPC_FLAGS_EXCP_7x0:
2272         case PPC_FLAGS_EXCP_7x5:
2273             /* Thermal management interrupt on G3 */
2274             /* XXX: TODO */
2275             cpu_abort(env, "G3 thermal management exception "
2276                       "is not implemented yet !\n");
2277             goto store_next;
2278         case PPC_FLAGS_EXCP_970:
2279             /* VPU assist on 970 */
2280             /* XXX: TODO */
2281             cpu_abort(env,
2282                       "970 VPU assist exception is not implemented yet !\n");
2283             goto store_next;
2284         default:
2285             cpu_abort(env, "Invalid exception 0x1700 !\n");
2286             break;
2287         }
2288         return;
2289     case 0x1800:
2290         switch (PPC_EXCP(env)) {
2291         case PPC_FLAGS_EXCP_970:
2292             /* Thermal exception on 970 */
2293             /* XXX: TODO */
2294             cpu_abort(env, "970 thermal management exception "
2295                       "is not implemented yet !\n");
2296             goto store_next;
2297         default:
2298             cpu_abort(env, "Invalid exception 0x1800 !\n");
2299             break;
2300         }
2301         return;
2302     case 0x2000:
2303         switch (PPC_EXCP(env)) {
2304         case PPC_FLAGS_EXCP_40x:
2305             /* DEBUG on 4xx */
2306             /* XXX: TODO */
2307             cpu_abort(env, "40x debug exception is not implemented yet !\n");
2308             goto store_next;
2309         case PPC_FLAGS_EXCP_601:
2310             /* Run mode exception on 601 */
2311             /* XXX: TODO */
2312             cpu_abort(env,
2313                       "601 run mode exception is not implemented yet !\n");
2314             goto store_next;
2315         case PPC_FLAGS_EXCP_BOOKE:
2316             srr_0 = &env->spr[SPR_BOOKE_CSRR0];
2317             srr_1 = &env->spr[SPR_BOOKE_CSRR1];
2318             break;
2319         default:
2320             cpu_abort(env, "Invalid exception 0x1800 !\n");
2321             break;
2322         }
2323         return;
2324     /* Other exceptions */
2325     /* Qemu internal exceptions:
2326      * we should never come here with those values: abort execution
2327      */
2328     default:
2329         cpu_abort(env, "Invalid exception: code %d (%04x)\n", excp, excp);
2330         return;
2331     store_current:
2332         /* save current instruction location */
2333         *srr_0 = env->nip - 4;
2334         break;
2335     store_next:
2336         /* save next instruction location */
2337         *srr_0 = env->nip;
2338         break;
2339     }
2340     /* Save msr */
2341     *srr_1 = msr;
2342     if (asrr_0 != NULL)
2343         *asrr_0 = *srr_0;
2344     if (asrr_1 != NULL)
2345         *asrr_1 = *srr_1;
2346     /* If we disactivated any translation, flush TLBs */
2347     if (msr_ir || msr_dr) {
2348         tlb_flush(env, 1);
2349     }
2350     /* reload MSR with correct bits */
2351     msr_ee = 0;
2352     msr_pr = 0;
2353     msr_fp = 0;
2354     msr_fe0 = 0;
2355     msr_se = 0;
2356     msr_be = 0;
2357     msr_fe1 = 0;
2358     msr_ir = 0;
2359     msr_dr = 0;
2360     msr_ri = 0;
2361     msr_le = msr_ile;
2362     if (PPC_EXCP(env) == PPC_FLAGS_EXCP_BOOKE) {
2363         msr_cm = msr_icm;
2364         if (idx == -1 || (idx >= 16 && idx < 32)) {
2365             cpu_abort(env, "Invalid exception index for excp %d %08x idx %d\n",
2366                       excp, excp, idx);
2367         }
2368 #if defined(TARGET_PPC64)
2369         if (msr_cm)
2370             env->nip = (uint64_t)env->spr[SPR_BOOKE_IVPR];
2371         else
2372 #endif
2373             env->nip = (uint32_t)env->spr[SPR_BOOKE_IVPR];
2374         if (idx < 16)
2375             env->nip |= env->spr[SPR_BOOKE_IVOR0 + idx];
2376         else if (idx < 38)
2377             env->nip |= env->spr[SPR_BOOKE_IVOR32 + idx - 32];
2378     } else {
2379         msr_sf = msr_isf;
2380         env->nip = excp;
2381     }
2382     do_compute_hflags(env);
2383     /* Jump to handler */
2384     env->exception_index = EXCP_NONE;
2385 }
2386
2387 void ppc_hw_interrupt (CPUPPCState *env)
2388 {
2389     int raised = 0;
2390
2391 #if 1
2392     if (loglevel & CPU_LOG_INT) {
2393         fprintf(logfile, "%s: %p pending %08x req %08x me %d ee %d\n",
2394                 __func__, env, env->pending_interrupts,
2395                 env->interrupt_request, msr_me, msr_ee);
2396     }
2397 #endif
2398     /* Raise it */
2399     if (env->pending_interrupts & (1 << PPC_INTERRUPT_RESET)) {
2400         /* External reset / critical input */
2401         /* XXX: critical input should be handled another way.
2402          *      This code is not correct !
2403          */
2404         env->exception_index = EXCP_RESET;
2405         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_RESET);
2406         raised = 1;
2407     }
2408     if (raised == 0 && msr_me != 0) {
2409         /* Machine check exception */
2410         if (env->pending_interrupts & (1 << PPC_INTERRUPT_MCK)) {
2411             env->exception_index = EXCP_MACHINE_CHECK;
2412             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_MCK);
2413             raised = 1;
2414         }
2415     }
2416     if (raised == 0 && msr_ee != 0) {
2417 #if defined(TARGET_PPC64H) /* PowerPC 64 with hypervisor mode support */
2418         /* Hypervisor decrementer exception */
2419         if (env->pending_interrupts & (1 << PPC_INTERRUPT_HDECR)) {
2420             env->exception_index = EXCP_HDECR;
2421             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_HDECR);
2422             raised = 1;
2423         } else
2424 #endif
2425         /* Decrementer exception */
2426         if (env->pending_interrupts & (1 << PPC_INTERRUPT_DECR)) {
2427             env->exception_index = EXCP_DECR;
2428             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DECR);
2429             raised = 1;
2430         /* Programmable interval timer on embedded PowerPC */
2431         } else if (env->pending_interrupts & (1 << PPC_INTERRUPT_PIT)) {
2432             env->exception_index = EXCP_40x_PIT;
2433             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PIT);
2434             raised = 1;
2435         /* Fixed interval timer on embedded PowerPC */
2436         } else if (env->pending_interrupts & (1 << PPC_INTERRUPT_FIT)) {
2437             env->exception_index = EXCP_40x_FIT;
2438             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_FIT);
2439             raised = 1;
2440         /* Watchdog timer on embedded PowerPC */
2441         } else if (env->pending_interrupts & (1 << PPC_INTERRUPT_WDT)) {
2442             env->exception_index = EXCP_40x_WATCHDOG;
2443             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_WDT);
2444             raised = 1;
2445         /* External interrupt */
2446         } else if (env->pending_interrupts & (1 << PPC_INTERRUPT_EXT)) {
2447             env->exception_index = EXCP_EXTERNAL;
2448             /* Taking an external interrupt does not clear the external
2449              * interrupt status
2450              */
2451 #if 0
2452             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_EXT);
2453 #endif
2454             raised = 1;
2455 #if 0 // TODO
2456         /* Thermal interrupt */
2457         } else if (env->pending_interrupts & (1 << PPC_INTERRUPT_THERM)) {
2458             env->exception_index = EXCP_970_THRM;
2459             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_THERM);
2460             raised = 1;
2461 #endif
2462         }
2463 #if 0 // TODO
2464     /* External debug exception */
2465     } else if (env->pending_interrupts & (1 << PPC_INTERRUPT_DEBUG)) {
2466         env->exception_index = EXCP_xxx;
2467         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DEBUG);
2468         raised = 1;
2469 #endif
2470     }
2471     if (raised != 0) {
2472         env->error_code = 0;
2473         do_interrupt(env);
2474     }
2475 }
2476 #endif /* !CONFIG_USER_ONLY */
2477
2478 void cpu_dump_EA (target_ulong EA)
2479 {
2480     FILE *f;
2481
2482     if (logfile) {
2483         f = logfile;
2484     } else {
2485         f = stdout;
2486         return;
2487     }
2488     fprintf(f, "Memory access at address " ADDRX "\n", EA);
2489 }
2490
2491 void cpu_dump_rfi (target_ulong RA, target_ulong msr)
2492 {
2493     FILE *f;
2494
2495     if (logfile) {
2496         f = logfile;
2497     } else {
2498         f = stdout;
2499         return;
2500     }
2501     fprintf(f, "Return from exception at " ADDRX " with flags " ADDRX "\n",
2502             RA, msr);
2503 }
2504
2505 void cpu_ppc_reset (void *opaque)
2506 {
2507     CPUPPCState *env;
2508     int i;
2509
2510     env = opaque;
2511     /* XXX: some of those flags initialisation values could depend
2512      *      on the actual PowerPC implementation
2513      */
2514     for (i = 0; i < 63; i++)
2515         env->msr[i] = 0;
2516 #if defined(TARGET_PPC64)
2517     msr_hv = 0; /* Should be 1... */
2518 #endif
2519     msr_ap = 0; /* TO BE CHECKED */
2520     msr_sa = 0; /* TO BE CHECKED */
2521     msr_ip = 0; /* TO BE CHECKED */
2522 #if defined (DO_SINGLE_STEP) && 0
2523     /* Single step trace mode */
2524     msr_se = 1;
2525     msr_be = 1;
2526 #endif
2527 #if defined(CONFIG_USER_ONLY)
2528     msr_fp = 1; /* Allow floating point exceptions */
2529     msr_pr = 1;
2530 #else
2531     env->nip = 0xFFFFFFFC;
2532     ppc_tlb_invalidate_all(env);
2533 #endif
2534     do_compute_hflags(env);
2535     env->reserve = -1;
2536     /* Be sure no exception or interrupt is pending */
2537     env->pending_interrupts = 0;
2538     env->exception_index = EXCP_NONE;
2539     /* Flush all TLBs */
2540     tlb_flush(env, 1);
2541 }
2542
2543 CPUPPCState *cpu_ppc_init (void)
2544 {
2545     CPUPPCState *env;
2546
2547     env = qemu_mallocz(sizeof(CPUPPCState));
2548     if (!env)
2549         return NULL;
2550     cpu_exec_init(env);
2551     cpu_ppc_reset(env);
2552
2553     return env;
2554 }
2555
2556 void cpu_ppc_close (CPUPPCState *env)
2557 {
2558     /* Should also remove all opcode tables... */
2559     free(env);
2560 }