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

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