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