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 void 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     if (enter_pm) {
1925         if (likely(!env->halted)) {
1926             /* power save: exit cpu loop */
1927             env->halted = 1;
1928             env->exception_index = EXCP_HLT;
1929             cpu_loop_exit();
1930         }
1931     }
1932 }
1933
1934 #if defined(TARGET_PPC64)
1935 void ppc_store_msr_32 (CPUPPCState *env, uint32_t value)
1936 {
1937     do_store_msr(env,
1938                  (do_load_msr(env) & ~0xFFFFFFFFULL) | (value & 0xFFFFFFFF));
1939 }
1940 #endif
1941
1942 void do_compute_hflags (CPUPPCState *env)
1943 {
1944     /* Compute current hflags */
1945     env->hflags = (msr_vr << MSR_VR) |
1946         (msr_ap << MSR_AP) | (msr_sa << MSR_SA) | (msr_pr << MSR_PR) |
1947         (msr_fp << MSR_FP) | (msr_fe0 << MSR_FE0) | (msr_se << MSR_SE) |
1948         (msr_be << MSR_BE) | (msr_fe1 << MSR_FE1) | (msr_le << MSR_LE);
1949 #if defined (TARGET_PPC64)
1950     env->hflags |= msr_cm << MSR_CM;
1951     env->hflags |= (uint64_t)msr_sf << MSR_SF;
1952     env->hflags |= (uint64_t)msr_hv << MSR_HV;
1953 #endif
1954 }
1955
1956 /*****************************************************************************/
1957 /* Exception processing */
1958 #if defined (CONFIG_USER_ONLY)
1959 void do_interrupt (CPUState *env)
1960 {
1961     env->exception_index = POWERPC_EXCP_NONE;
1962     env->error_code = 0;
1963 }
1964
1965 void ppc_hw_interrupt (CPUState *env)
1966 {
1967     env->exception_index = POWERPC_EXCP_NONE;
1968     env->error_code = 0;
1969 }
1970 #else /* defined (CONFIG_USER_ONLY) */
1971 static void dump_syscall (CPUState *env)
1972 {
1973     fprintf(logfile, "syscall r0=0x" REGX " r3=0x" REGX " r4=0x" REGX
1974             " r5=0x" REGX " r6=0x" REGX " nip=0x" ADDRX "\n",
1975             env->gpr[0], env->gpr[3], env->gpr[4],
1976             env->gpr[5], env->gpr[6], env->nip);
1977 }
1978
1979 /* Note that this function should be greatly optimized
1980  * when called with a constant excp, from ppc_hw_interrupt
1981  */
1982 static always_inline void powerpc_excp (CPUState *env,
1983                                         int excp_model, int excp)
1984 {
1985     target_ulong msr, vector;
1986     int srr0, srr1, asrr0, asrr1;
1987
1988     if (loglevel & CPU_LOG_INT) {
1989         fprintf(logfile, "Raise exception at 0x" ADDRX " => 0x%08x (%02x)\n",
1990                 env->nip, excp, env->error_code);
1991     }
1992     msr = do_load_msr(env);
1993     srr0 = SPR_SRR0;
1994     srr1 = SPR_SRR1;
1995     asrr0 = -1;
1996     asrr1 = -1;
1997     msr &= ~((target_ulong)0x783F0000);
1998     switch (excp) {
1999     case POWERPC_EXCP_NONE:
2000         /* Should never happen */
2001         return;
2002     case POWERPC_EXCP_CRITICAL:    /* Critical input                         */
2003         msr_ri = 0; /* XXX: check this */
2004         switch (excp_model) {
2005         case POWERPC_EXCP_40x:
2006             srr0 = SPR_40x_SRR2;
2007             srr1 = SPR_40x_SRR3;
2008             break;
2009         case POWERPC_EXCP_BOOKE:
2010             srr0 = SPR_BOOKE_CSRR0;
2011             srr1 = SPR_BOOKE_CSRR1;
2012             break;
2013         case POWERPC_EXCP_G2:
2014             break;
2015         default:
2016             goto excp_invalid;
2017         }
2018         goto store_next;
2019     case POWERPC_EXCP_MCHECK:    /* Machine check exception                  */
2020         if (msr_me == 0) {
2021             /* Machine check exception is not enabled */
2022             /* XXX: we may just stop the processor here, to allow debugging */
2023             excp = POWERPC_EXCP_RESET;
2024             goto excp_reset;
2025         }
2026         msr_ri = 0;
2027         msr_me = 0;
2028 #if defined(TARGET_PPC64H)
2029         msr_hv = 1;
2030 #endif
2031         /* XXX: should also have something loaded in DAR / DSISR */
2032         switch (excp_model) {
2033         case POWERPC_EXCP_40x:
2034             srr0 = SPR_40x_SRR2;
2035             srr1 = SPR_40x_SRR3;
2036             break;
2037         case POWERPC_EXCP_BOOKE:
2038             srr0 = SPR_BOOKE_MCSRR0;
2039             srr1 = SPR_BOOKE_MCSRR1;
2040             asrr0 = SPR_BOOKE_CSRR0;
2041             asrr1 = SPR_BOOKE_CSRR1;
2042             break;
2043         default:
2044             break;
2045         }
2046         goto store_next;
2047     case POWERPC_EXCP_DSI:       /* Data storage exception                   */
2048 #if defined (DEBUG_EXCEPTIONS)
2049         if (loglevel != 0) {
2050             fprintf(logfile, "DSI exception: DSISR=0x" ADDRX" DAR=0x" ADDRX
2051                     "\n", env->spr[SPR_DSISR], env->spr[SPR_DAR]);
2052         }
2053 #endif
2054         msr_ri = 0;
2055 #if defined(TARGET_PPC64H)
2056         if (lpes1 == 0)
2057             msr_hv = 1;
2058 #endif
2059         goto store_next;
2060     case POWERPC_EXCP_ISI:       /* Instruction storage exception            */
2061 #if defined (DEBUG_EXCEPTIONS)
2062         if (loglevel != 0) {
2063             fprintf(logfile, "ISI exception: msr=0x" ADDRX ", nip=0x" ADDRX
2064                     "\n", msr, env->nip);
2065         }
2066 #endif
2067         msr_ri = 0;
2068 #if defined(TARGET_PPC64H)
2069         if (lpes1 == 0)
2070             msr_hv = 1;
2071 #endif
2072         msr |= env->error_code;
2073         goto store_next;
2074     case POWERPC_EXCP_EXTERNAL:  /* External input                           */
2075         msr_ri = 0;
2076 #if defined(TARGET_PPC64H)
2077         if (lpes0 == 1)
2078             msr_hv = 1;
2079 #endif
2080         goto store_next;
2081     case POWERPC_EXCP_ALIGN:     /* Alignment exception                      */
2082         msr_ri = 0;
2083 #if defined(TARGET_PPC64H)
2084         if (lpes1 == 0)
2085             msr_hv = 1;
2086 #endif
2087         /* XXX: this is false */
2088         /* Get rS/rD and rA from faulting opcode */
2089         env->spr[SPR_DSISR] |= (ldl_code((env->nip - 4)) & 0x03FF0000) >> 16;
2090         goto store_current;
2091     case POWERPC_EXCP_PROGRAM:   /* Program exception                        */
2092         switch (env->error_code & ~0xF) {
2093         case POWERPC_EXCP_FP:
2094             if ((msr_fe0 == 0 && msr_fe1 == 0) || msr_fp == 0) {
2095 #if defined (DEBUG_EXCEPTIONS)
2096                 if (loglevel != 0) {
2097                     fprintf(logfile, "Ignore floating point exception\n");
2098                 }
2099 #endif
2100                 return;
2101             }
2102             msr_ri = 0;
2103 #if defined(TARGET_PPC64H)
2104             if (lpes1 == 0)
2105                 msr_hv = 1;
2106 #endif
2107             msr |= 0x00100000;
2108             /* Set FX */
2109             env->fpscr[7] |= 0x8;
2110             /* Finally, update FEX */
2111             if ((((env->fpscr[7] & 0x3) << 3) | (env->fpscr[6] >> 1)) &
2112                 ((env->fpscr[1] << 1) | (env->fpscr[0] >> 3)))
2113                 env->fpscr[7] |= 0x4;
2114             if (msr_fe0 != msr_fe1) {
2115                 msr |= 0x00010000;
2116                 goto store_current;
2117             }
2118             break;
2119         case POWERPC_EXCP_INVAL:
2120 #if defined (DEBUG_EXCEPTIONS)
2121             if (loglevel != 0) {
2122                 fprintf(logfile, "Invalid instruction at 0x" ADDRX "\n",
2123                         env->nip);
2124             }
2125 #endif
2126             msr_ri = 0;
2127 #if defined(TARGET_PPC64H)
2128             if (lpes1 == 0)
2129                 msr_hv = 1;
2130 #endif
2131             msr |= 0x00080000;
2132             break;
2133         case POWERPC_EXCP_PRIV:
2134             msr_ri = 0;
2135 #if defined(TARGET_PPC64H)
2136             if (lpes1 == 0)
2137                 msr_hv = 1;
2138 #endif
2139             msr |= 0x00040000;
2140             break;
2141         case POWERPC_EXCP_TRAP:
2142             msr_ri = 0;
2143 #if defined(TARGET_PPC64H)
2144             if (lpes1 == 0)
2145                 msr_hv = 1;
2146 #endif
2147             msr |= 0x00020000;
2148             break;
2149         default:
2150             /* Should never occur */
2151             cpu_abort(env, "Invalid program exception %d. Aborting\n",
2152                       env->error_code);
2153             break;
2154         }
2155         goto store_next;
2156     case POWERPC_EXCP_FPU:       /* Floating-point unavailable exception     */
2157         msr_ri = 0;
2158 #if defined(TARGET_PPC64H)
2159         if (lpes1 == 0)
2160             msr_hv = 1;
2161 #endif
2162         goto store_current;
2163     case POWERPC_EXCP_SYSCALL:   /* System call exception                    */
2164         /* NOTE: this is a temporary hack to support graphics OSI
2165            calls from the MOL driver */
2166         /* XXX: To be removed */
2167         if (env->gpr[3] == 0x113724fa && env->gpr[4] == 0x77810f9b &&
2168             env->osi_call) {
2169             if (env->osi_call(env) != 0)
2170                 return;
2171         }
2172         if (loglevel & CPU_LOG_INT) {
2173             dump_syscall(env);
2174         }
2175         msr_ri = 0;
2176 #if defined(TARGET_PPC64H)
2177         if (lev == 1 || (lpes0 == 0 && lpes1 == 0))
2178             msr_hv = 1;
2179 #endif
2180         goto store_next;
2181     case POWERPC_EXCP_APU:       /* Auxiliary processor unavailable          */
2182         msr_ri = 0;
2183         goto store_current;
2184     case POWERPC_EXCP_DECR:      /* Decrementer exception                    */
2185         msr_ri = 0;
2186 #if defined(TARGET_PPC64H)
2187         if (lpes1 == 0)
2188             msr_hv = 1;
2189 #endif
2190         goto store_next;
2191     case POWERPC_EXCP_FIT:       /* Fixed-interval timer interrupt           */
2192         /* FIT on 4xx */
2193 #if defined (DEBUG_EXCEPTIONS)
2194         if (loglevel != 0)
2195             fprintf(logfile, "FIT exception\n");
2196 #endif
2197         msr_ri = 0; /* XXX: check this */
2198         goto store_next;
2199     case POWERPC_EXCP_WDT:       /* Watchdog timer interrupt                 */
2200 #if defined (DEBUG_EXCEPTIONS)
2201         if (loglevel != 0)
2202             fprintf(logfile, "WDT exception\n");
2203 #endif
2204         switch (excp_model) {
2205         case POWERPC_EXCP_BOOKE:
2206             srr0 = SPR_BOOKE_CSRR0;
2207             srr1 = SPR_BOOKE_CSRR1;
2208             break;
2209         default:
2210             break;
2211         }
2212         msr_ri = 0; /* XXX: check this */
2213         goto store_next;
2214     case POWERPC_EXCP_DTLB:      /* Data TLB error                           */
2215         msr_ri = 0; /* XXX: check this */
2216         goto store_next;
2217     case POWERPC_EXCP_ITLB:      /* Instruction TLB error                    */
2218         msr_ri = 0; /* XXX: check this */
2219         goto store_next;
2220     case POWERPC_EXCP_DEBUG:     /* Debug interrupt                          */
2221         switch (excp_model) {
2222         case POWERPC_EXCP_BOOKE:
2223             srr0 = SPR_BOOKE_DSRR0;
2224             srr1 = SPR_BOOKE_DSRR1;
2225             asrr0 = SPR_BOOKE_CSRR0;
2226             asrr1 = SPR_BOOKE_CSRR1;
2227             break;
2228         default:
2229             break;
2230         }
2231         /* XXX: TODO */
2232         cpu_abort(env, "Debug exception is not implemented yet !\n");
2233         goto store_next;
2234 #if defined(TARGET_PPCEMB)
2235     case POWERPC_EXCP_SPEU:      /* SPE/embedded floating-point unavailable  */
2236         msr_ri = 0; /* XXX: check this */
2237         goto store_current;
2238     case POWERPC_EXCP_EFPDI:     /* Embedded floating-point data interrupt   */
2239         /* XXX: TODO */
2240         cpu_abort(env, "Embedded floating point data exception "
2241                   "is not implemented yet !\n");
2242         goto store_next;
2243     case POWERPC_EXCP_EFPRI:     /* Embedded floating-point round interrupt  */
2244         /* XXX: TODO */
2245         cpu_abort(env, "Embedded floating point round exception "
2246                   "is not implemented yet !\n");
2247         goto store_next;
2248     case POWERPC_EXCP_EPERFM:    /* Embedded performance monitor interrupt   */
2249         msr_ri = 0;
2250         /* XXX: TODO */
2251         cpu_abort(env,
2252                   "Performance counter exception is not implemented yet !\n");
2253         goto store_next;
2254     case POWERPC_EXCP_DOORI:     /* Embedded doorbell interrupt              */
2255         /* XXX: TODO */
2256         cpu_abort(env,
2257                   "Embedded doorbell interrupt is not implemented yet !\n");
2258         goto store_next;
2259     case POWERPC_EXCP_DOORCI:    /* Embedded doorbell critical interrupt     */
2260         switch (excp_model) {
2261         case POWERPC_EXCP_BOOKE:
2262             srr0 = SPR_BOOKE_CSRR0;
2263             srr1 = SPR_BOOKE_CSRR1;
2264             break;
2265         default:
2266             break;
2267         }
2268         /* XXX: TODO */
2269         cpu_abort(env, "Embedded doorbell critical interrupt "
2270                   "is not implemented yet !\n");
2271         goto store_next;
2272 #endif /* defined(TARGET_PPCEMB) */
2273     case POWERPC_EXCP_RESET:     /* System reset exception                   */
2274         msr_ri = 0;
2275 #if defined(TARGET_PPC64H)
2276         msr_hv = 1;
2277 #endif
2278     excp_reset:
2279         goto store_next;
2280 #if defined(TARGET_PPC64)
2281     case POWERPC_EXCP_DSEG:      /* Data segment exception                   */
2282         msr_ri = 0;
2283 #if defined(TARGET_PPC64H)
2284         if (lpes1 == 0)
2285             msr_hv = 1;
2286 #endif
2287         /* XXX: TODO */
2288         cpu_abort(env, "Data segment exception is not implemented yet !\n");
2289         goto store_next;
2290     case POWERPC_EXCP_ISEG:      /* Instruction segment exception            */
2291         msr_ri = 0;
2292 #if defined(TARGET_PPC64H)
2293         if (lpes1 == 0)
2294             msr_hv = 1;
2295 #endif
2296         /* XXX: TODO */
2297         cpu_abort(env,
2298                   "Instruction segment exception is not implemented yet !\n");
2299         goto store_next;
2300 #endif /* defined(TARGET_PPC64) */
2301 #if defined(TARGET_PPC64H)
2302     case POWERPC_EXCP_HDECR:     /* Hypervisor decrementer exception         */
2303         srr0 = SPR_HSRR0;
2304         srr1 = SPR_HSSR1;
2305         msr_hv = 1;
2306         goto store_next;
2307 #endif
2308     case POWERPC_EXCP_TRACE:     /* Trace exception                          */
2309         msr_ri = 0;
2310 #if defined(TARGET_PPC64H)
2311         if (lpes1 == 0)
2312             msr_hv = 1;
2313 #endif
2314         goto store_next;
2315 #if defined(TARGET_PPC64H)
2316     case POWERPC_EXCP_HDSI:      /* Hypervisor data storage exception        */
2317         srr0 = SPR_HSRR0;
2318         srr1 = SPR_HSSR1;
2319         msr_hv = 1;
2320         goto store_next;
2321     case POWERPC_EXCP_HISI:      /* Hypervisor instruction storage exception */
2322         srr0 = SPR_HSRR0;
2323         srr1 = SPR_HSSR1;
2324         msr_hv = 1;
2325         /* XXX: TODO */
2326         cpu_abort(env, "Hypervisor instruction storage exception "
2327                   "is not implemented yet !\n");
2328         goto store_next;
2329     case POWERPC_EXCP_HDSEG:     /* Hypervisor data segment exception        */
2330         srr0 = SPR_HSRR0;
2331         srr1 = SPR_HSSR1;
2332         msr_hv = 1;
2333         goto store_next;
2334     case POWERPC_EXCP_HISEG:     /* Hypervisor instruction segment exception */
2335         srr0 = SPR_HSRR0;
2336         srr1 = SPR_HSSR1;
2337         msr_hv = 1;
2338         goto store_next;
2339 #endif /* defined(TARGET_PPC64H) */
2340     case POWERPC_EXCP_VPU:       /* Vector unavailable exception             */
2341         msr_ri = 0;
2342 #if defined(TARGET_PPC64H)
2343         if (lpes1 == 0)
2344             msr_hv = 1;
2345 #endif
2346         goto store_current;
2347     case POWERPC_EXCP_PIT:       /* Programmable interval timer interrupt    */
2348 #if defined (DEBUG_EXCEPTIONS)
2349         if (loglevel != 0)
2350             fprintf(logfile, "PIT exception\n");
2351 #endif
2352         msr_ri = 0; /* XXX: check this */
2353         goto store_next;
2354     case POWERPC_EXCP_IO:        /* IO error exception                       */
2355         /* XXX: TODO */
2356         cpu_abort(env, "601 IO error exception is not implemented yet !\n");
2357         goto store_next;
2358     case POWERPC_EXCP_RUNM:      /* Run mode exception                       */
2359         /* XXX: TODO */
2360         cpu_abort(env, "601 run mode exception is not implemented yet !\n");
2361         goto store_next;
2362     case POWERPC_EXCP_EMUL:      /* Emulation trap exception                 */
2363         /* XXX: TODO */
2364         cpu_abort(env, "602 emulation trap exception "
2365                   "is not implemented yet !\n");
2366         goto store_next;
2367     case POWERPC_EXCP_IFTLB:     /* Instruction fetch TLB error              */
2368         msr_ri = 0; /* XXX: check this */
2369 #if defined(TARGET_PPC64H) /* XXX: check this */
2370         if (lpes1 == 0)
2371             msr_hv = 1;
2372 #endif
2373         switch (excp_model) {
2374         case POWERPC_EXCP_602:
2375         case POWERPC_EXCP_603:
2376         case POWERPC_EXCP_603E:
2377         case POWERPC_EXCP_G2:
2378             goto tlb_miss_tgpr;
2379         case POWERPC_EXCP_7x5:
2380             goto tlb_miss;
2381         case POWERPC_EXCP_74xx:
2382             goto tlb_miss_74xx;
2383         default:
2384             cpu_abort(env, "Invalid instruction TLB miss exception\n");
2385             break;
2386         }
2387         break;
2388     case POWERPC_EXCP_DLTLB:     /* Data load TLB miss                       */
2389         msr_ri = 0; /* XXX: check this */
2390 #if defined(TARGET_PPC64H) /* XXX: check this */
2391         if (lpes1 == 0)
2392             msr_hv = 1;
2393 #endif
2394         switch (excp_model) {
2395         case POWERPC_EXCP_602:
2396         case POWERPC_EXCP_603:
2397         case POWERPC_EXCP_603E:
2398         case POWERPC_EXCP_G2:
2399             goto tlb_miss_tgpr;
2400         case POWERPC_EXCP_7x5:
2401             goto tlb_miss;
2402         case POWERPC_EXCP_74xx:
2403             goto tlb_miss_74xx;
2404         default:
2405             cpu_abort(env, "Invalid data load TLB miss exception\n");
2406             break;
2407         }
2408         break;
2409     case POWERPC_EXCP_DSTLB:     /* Data store TLB miss                      */
2410         msr_ri = 0; /* XXX: check this */
2411 #if defined(TARGET_PPC64H) /* XXX: check this */
2412         if (lpes1 == 0)
2413             msr_hv = 1;
2414 #endif
2415         switch (excp_model) {
2416         case POWERPC_EXCP_602:
2417         case POWERPC_EXCP_603:
2418         case POWERPC_EXCP_603E:
2419         case POWERPC_EXCP_G2:
2420         tlb_miss_tgpr:
2421             /* Swap temporary saved registers with GPRs */
2422             swap_gpr_tgpr(env);
2423             msr_tgpr = 1;
2424             goto tlb_miss;
2425         case POWERPC_EXCP_7x5:
2426         tlb_miss:
2427 #if defined (DEBUG_SOFTWARE_TLB)
2428             if (loglevel != 0) {
2429                 const unsigned char *es;
2430                 target_ulong *miss, *cmp;
2431                 int en;
2432                 if (excp == POWERPC_EXCP_IFTLB) {
2433                     es = "I";
2434                     en = 'I';
2435                     miss = &env->spr[SPR_IMISS];
2436                     cmp = &env->spr[SPR_ICMP];
2437                 } else {
2438                     if (excp == POWERPC_EXCP_DLTLB)
2439                         es = "DL";
2440                     else
2441                         es = "DS";
2442                     en = 'D';
2443                     miss = &env->spr[SPR_DMISS];
2444                     cmp = &env->spr[SPR_DCMP];
2445                 }
2446                 fprintf(logfile, "6xx %sTLB miss: %cM " ADDRX " %cC " ADDRX
2447                         " H1 " ADDRX " H2 " ADDRX " %08x\n",
2448                         es, en, *miss, en, *cmp,
2449                         env->spr[SPR_HASH1], env->spr[SPR_HASH2],
2450                         env->error_code);
2451             }
2452 #endif
2453             msr |= env->crf[0] << 28;
2454             msr |= env->error_code; /* key, D/I, S/L bits */
2455             /* Set way using a LRU mechanism */
2456             msr |= ((env->last_way + 1) & (env->nb_ways - 1)) << 17;
2457             break;
2458         case POWERPC_EXCP_74xx:
2459         tlb_miss_74xx:
2460 #if defined (DEBUG_SOFTWARE_TLB)
2461             if (loglevel != 0) {
2462                 const unsigned char *es;
2463                 target_ulong *miss, *cmp;
2464                 int en;
2465                 if (excp == POWERPC_EXCP_IFTLB) {
2466                     es = "I";
2467                     en = 'I';
2468                     miss = &env->spr[SPR_IMISS];
2469                     cmp = &env->spr[SPR_ICMP];
2470                 } else {
2471                     if (excp == POWERPC_EXCP_DLTLB)
2472                         es = "DL";
2473                     else
2474                         es = "DS";
2475                     en = 'D';
2476                     miss = &env->spr[SPR_TLBMISS];
2477                     cmp = &env->spr[SPR_PTEHI];
2478                 }
2479                 fprintf(logfile, "74xx %sTLB miss: %cM " ADDRX " %cC " ADDRX
2480                         " %08x\n",
2481                         es, en, *miss, en, *cmp, env->error_code);
2482             }
2483 #endif
2484             msr |= env->error_code; /* key bit */
2485             break;
2486         default:
2487             cpu_abort(env, "Invalid data store TLB miss exception\n");
2488             break;
2489         }
2490         goto store_next;
2491     case POWERPC_EXCP_FPA:       /* Floating-point assist exception          */
2492         /* XXX: TODO */
2493         cpu_abort(env, "Floating point assist exception "
2494                   "is not implemented yet !\n");
2495         goto store_next;
2496     case POWERPC_EXCP_IABR:      /* Instruction address breakpoint           */
2497         /* XXX: TODO */
2498         cpu_abort(env, "IABR exception is not implemented yet !\n");
2499         goto store_next;
2500     case POWERPC_EXCP_SMI:       /* System management interrupt              */
2501         /* XXX: TODO */
2502         cpu_abort(env, "SMI exception is not implemented yet !\n");
2503         goto store_next;
2504     case POWERPC_EXCP_THERM:     /* Thermal interrupt                        */
2505         /* XXX: TODO */
2506         cpu_abort(env, "Thermal management exception "
2507                   "is not implemented yet !\n");
2508         goto store_next;
2509     case POWERPC_EXCP_PERFM:     /* Embedded performance monitor interrupt   */
2510         msr_ri = 0;
2511 #if defined(TARGET_PPC64H)
2512         if (lpes1 == 0)
2513             msr_hv = 1;
2514 #endif
2515         /* XXX: TODO */
2516         cpu_abort(env,
2517                   "Performance counter exception is not implemented yet !\n");
2518         goto store_next;
2519     case POWERPC_EXCP_VPUA:      /* Vector assist exception                  */
2520         /* XXX: TODO */
2521         cpu_abort(env, "VPU assist exception is not implemented yet !\n");
2522         goto store_next;
2523     case POWERPC_EXCP_SOFTP:     /* Soft patch exception                     */
2524         /* XXX: TODO */
2525         cpu_abort(env,
2526                   "970 soft-patch exception is not implemented yet !\n");
2527         goto store_next;
2528     case POWERPC_EXCP_MAINT:     /* Maintenance exception                    */
2529         /* XXX: TODO */
2530         cpu_abort(env,
2531                   "970 maintenance exception is not implemented yet !\n");
2532         goto store_next;
2533     default:
2534     excp_invalid:
2535         cpu_abort(env, "Invalid PowerPC exception %d. Aborting\n", excp);
2536         break;
2537     store_current:
2538         /* save current instruction location */
2539         env->spr[srr0] = env->nip - 4;
2540         break;
2541     store_next:
2542         /* save next instruction location */
2543         env->spr[srr0] = env->nip;
2544         break;
2545     }
2546     /* Save MSR */
2547     env->spr[srr1] = msr;
2548     /* If any alternate SRR register are defined, duplicate saved values */
2549     if (asrr0 != -1)
2550         env->spr[asrr0] = env->spr[srr0];
2551     if (asrr1 != -1)
2552         env->spr[asrr1] = env->spr[srr1];
2553     /* If we disactivated any translation, flush TLBs */
2554     if (msr_ir || msr_dr)
2555         tlb_flush(env, 1);
2556     /* reload MSR with correct bits */
2557     msr_ee = 0;
2558     msr_pr = 0;
2559     msr_fp = 0;
2560     msr_fe0 = 0;
2561     msr_se = 0;
2562     msr_be = 0;
2563     msr_fe1 = 0;
2564     msr_ir = 0;
2565     msr_dr = 0;
2566 #if 0 /* Fix this: not on all targets */
2567     msr_pmm = 0;
2568 #endif
2569     msr_le = msr_ile;
2570     do_compute_hflags(env);
2571     /* Jump to handler */
2572     vector = env->excp_vectors[excp];
2573     if (vector == (target_ulong)-1) {
2574         cpu_abort(env, "Raised an exception without defined vector %d\n",
2575                   excp);
2576     }
2577     vector |= env->excp_prefix;
2578 #if defined(TARGET_PPC64)
2579     if (excp_model == POWERPC_EXCP_BOOKE) {
2580         msr_cm = msr_icm;
2581         if (!msr_cm)
2582             vector = (uint32_t)vector;
2583     } else {
2584         msr_sf = msr_isf;
2585         if (!msr_sf)
2586             vector = (uint32_t)vector;
2587     }
2588 #endif
2589     env->nip = vector;
2590     /* Reset exception state */
2591     env->exception_index = POWERPC_EXCP_NONE;
2592     env->error_code = 0;
2593 }
2594
2595 void do_interrupt (CPUState *env)
2596 {
2597     powerpc_excp(env, env->excp_model, env->exception_index);
2598 }
2599
2600 void ppc_hw_interrupt (CPUPPCState *env)
2601 {
2602 #if 1
2603     if (loglevel & CPU_LOG_INT) {
2604         fprintf(logfile, "%s: %p pending %08x req %08x me %d ee %d\n",
2605                 __func__, env, env->pending_interrupts,
2606                 env->interrupt_request, msr_me, msr_ee);
2607     }
2608 #endif
2609     /* External reset */
2610     if (env->pending_interrupts & (1 << PPC_INTERRUPT_RESET)) {
2611         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_RESET);
2612         powerpc_excp(env, env->excp_model, POWERPC_EXCP_RESET);
2613         return;
2614     }
2615     /* Machine check exception */
2616     if (env->pending_interrupts & (1 << PPC_INTERRUPT_MCK)) {
2617         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_MCK);
2618         powerpc_excp(env, env->excp_model, POWERPC_EXCP_MCHECK);
2619         return;
2620     }
2621 #if 0 /* TODO */
2622     /* External debug exception */
2623     if (env->pending_interrupts & (1 << PPC_INTERRUPT_DEBUG)) {
2624         env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DEBUG);
2625         powerpc_excp(env, env->excp_model, POWERPC_EXCP_DEBUG);
2626         return;
2627     }
2628 #endif
2629 #if defined(TARGET_PPC64H)
2630     if ((msr_ee != 0 || msr_hv == 0 || msr_pr == 1) & hdice != 0) {
2631         /* Hypervisor decrementer exception */
2632         if (env->pending_interrupts & (1 << PPC_INTERRUPT_HDECR)) {
2633             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_HDECR);
2634             powerpc_excp(env, env->excp_model, POWERPC_EXCP_HDECR);
2635             return;
2636         }
2637     }
2638 #endif
2639     if (msr_ce != 0) {
2640         /* External critical interrupt */
2641         if (env->pending_interrupts & (1 << PPC_INTERRUPT_CEXT)) {
2642             /* Taking a critical external interrupt does not clear the external
2643              * critical interrupt status
2644              */
2645 #if 0
2646             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_CEXT);
2647 #endif
2648             powerpc_excp(env, env->excp_model, POWERPC_EXCP_CRITICAL);
2649             return;
2650         }
2651     }
2652     if (msr_ee != 0) {
2653         /* Watchdog timer on embedded PowerPC */
2654         if (env->pending_interrupts & (1 << PPC_INTERRUPT_WDT)) {
2655             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_WDT);
2656             powerpc_excp(env, env->excp_model, POWERPC_EXCP_WDT);
2657             return;
2658         }
2659 #if defined(TARGET_PPCEMB)
2660         if (env->pending_interrupts & (1 << PPC_INTERRUPT_CDOORBELL)) {
2661             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_CDOORBELL);
2662             powerpc_excp(env, env->excp_model, POWERPC_EXCP_DOORCI);
2663             return;
2664         }
2665 #endif
2666 #if defined(TARGET_PPCEMB)
2667         /* External interrupt */
2668         if (env->pending_interrupts & (1 << PPC_INTERRUPT_EXT)) {
2669             /* Taking an external interrupt does not clear the external
2670              * interrupt status
2671              */
2672 #if 0
2673             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_EXT);
2674 #endif
2675             powerpc_excp(env, env->excp_model, POWERPC_EXCP_EXTERNAL);
2676             return;
2677         }
2678 #endif
2679         /* Fixed interval timer on embedded PowerPC */
2680         if (env->pending_interrupts & (1 << PPC_INTERRUPT_FIT)) {
2681             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_FIT);
2682             powerpc_excp(env, env->excp_model, POWERPC_EXCP_FIT);
2683             return;
2684         }
2685         /* Programmable interval timer on embedded PowerPC */
2686         if (env->pending_interrupts & (1 << PPC_INTERRUPT_PIT)) {
2687             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PIT);
2688             powerpc_excp(env, env->excp_model, POWERPC_EXCP_PIT);
2689             return;
2690         }
2691         /* Decrementer exception */
2692         if (env->pending_interrupts & (1 << PPC_INTERRUPT_DECR)) {
2693             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DECR);
2694             powerpc_excp(env, env->excp_model, POWERPC_EXCP_DECR);
2695             return;
2696         }
2697 #if !defined(TARGET_PPCEMB)
2698         /* External interrupt */
2699         if (env->pending_interrupts & (1 << PPC_INTERRUPT_EXT)) {
2700             /* Taking an external interrupt does not clear the external
2701              * interrupt status
2702              */
2703 #if 0
2704             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_EXT);
2705 #endif
2706             powerpc_excp(env, env->excp_model, POWERPC_EXCP_EXTERNAL);
2707             return;
2708         }
2709 #endif
2710 #if defined(TARGET_PPCEMB)
2711         if (env->pending_interrupts & (1 << PPC_INTERRUPT_DOORBELL)) {
2712             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_DOORBELL);
2713             powerpc_excp(env, env->excp_model, POWERPC_EXCP_DOORI);
2714             return;
2715         }
2716 #endif
2717         if (env->pending_interrupts & (1 << PPC_INTERRUPT_PERFM)) {
2718             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_PERFM);
2719             powerpc_excp(env, env->excp_model, POWERPC_EXCP_PERFM);
2720             return;
2721         }
2722         /* Thermal interrupt */
2723         if (env->pending_interrupts & (1 << PPC_INTERRUPT_THERM)) {
2724             env->pending_interrupts &= ~(1 << PPC_INTERRUPT_THERM);
2725             powerpc_excp(env, env->excp_model, POWERPC_EXCP_THERM);
2726             return;
2727         }
2728     }
2729 }
2730 #endif /* !CONFIG_USER_ONLY */
2731
2732 void cpu_dump_EA (target_ulong EA)
2733 {
2734     FILE *f;
2735
2736     if (logfile) {
2737         f = logfile;
2738     } else {
2739         f = stdout;
2740         return;
2741     }
2742     fprintf(f, "Memory access at address " ADDRX "\n", EA);
2743 }
2744
2745 void cpu_dump_rfi (target_ulong RA, target_ulong msr)
2746 {
2747     FILE *f;
2748
2749     if (logfile) {
2750         f = logfile;
2751     } else {
2752         f = stdout;
2753         return;
2754     }
2755     fprintf(f, "Return from exception at " ADDRX " with flags " ADDRX "\n",
2756             RA, msr);
2757 }
2758
2759 void cpu_ppc_reset (void *opaque)
2760 {
2761     CPUPPCState *env;
2762     int i;
2763
2764     env = opaque;
2765     /* XXX: some of those flags initialisation values could depend
2766      *      on the actual PowerPC implementation
2767      */
2768     for (i = 0; i < 63; i++)
2769         env->msr[i] = 0;
2770 #if defined(TARGET_PPC64)
2771     msr_hv = 0; /* Should be 1... */
2772 #endif
2773     msr_ap = 0; /* TO BE CHECKED */
2774     msr_sa = 0; /* TO BE CHECKED */
2775     msr_ip = 0; /* TO BE CHECKED */
2776 #if defined (DO_SINGLE_STEP) && 0
2777     /* Single step trace mode */
2778     msr_se = 1;
2779     msr_be = 1;
2780 #endif
2781 #if defined(CONFIG_USER_ONLY)
2782     msr_fp = 1; /* Allow floating point exceptions */
2783     msr_pr = 1;
2784 #else
2785     env->nip = 0xFFFFFFFC;
2786     ppc_tlb_invalidate_all(env);
2787 #endif
2788     do_compute_hflags(env);
2789     env->reserve = -1;
2790     /* Be sure no exception or interrupt is pending */
2791     env->pending_interrupts = 0;
2792     env->exception_index = POWERPC_EXCP_NONE;
2793     env->error_code = 0;
2794     /* Flush all TLBs */
2795     tlb_flush(env, 1);
2796 }
2797
2798 CPUPPCState *cpu_ppc_init (void)
2799 {
2800     CPUPPCState *env;
2801
2802     env = qemu_mallocz(sizeof(CPUPPCState));
2803     if (!env)
2804         return NULL;
2805     cpu_exec_init(env);
2806     cpu_ppc_reset(env);
2807
2808     return env;
2809 }
2810
2811 void cpu_ppc_close (CPUPPCState *env)
2812 {
2813     /* Should also remove all opcode tables... */
2814     free(env);
2815 }